h$ g      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHI JK L MNO P Q RS TUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~             !!!!!!!!!!!!!!!!!!!""""""""############################$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$%%%%%%%%%%%%%%&&&&&&&&&&&&&&&&&&&&''''''''''''''''((((((((((((((((((((((((((((((((((((())))))****++++++++++++++++++,,,,----------.............................////////////////////////////////////////////////0000011111111111111112222222222233333333333333333333333333444555555555556666666666666666666677777777777777777777777777                   8888888888888888888888888888888888888888888888888888888888888888888888899999999999::::::::::::::::::;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;                    < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < <                                             = = = = = = = = = = = = = = = = > > > > > > > > > > > > > > > > > > > > > > > > > > > > > ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? @ @ @ @ @ @ @ @ @ @ @ @ @                                     A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A B B B B B B B B B B B B B B B B C C C C C C D D D D D D D D D D D D D D D D D D D D D D D D D D D D D D D D D D D D D D D D D E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F G G G G GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHIIIIIIIIIIIIIIIIIIIIJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOOOOOOOOOOOOOOOOOOOOOOOOPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPQQQQQQQQQQQQQQQQRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSTTTTTTTTTTTTTTTTTTUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUVWWXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXYYYZ[[[[[[[[[[[[[[[[[[[[[[[[[[ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \!\!\!\!\!\!\!\!\!\!\!\!\!\!\!\!\!\!\!\!\!\!\!\!\!\!\!\!\!\!\!\!\!\!\!\!\!\!\!\!\!\!\!\!\!\!\!\!\!\!\!\!\!\!\!\!\!\!\!\!\!\!\!\!\!\!\!\!\!\!\!]!]!]!]!]!]!]!]!]!]!]!]!]!]!^!^!^!^!^!^!^!^!^!^!^!^!^!^!^!^!^!^!^!^!^!^!^!^!^!^!^!^!^!^!^!^!^!^!^!^!^!^!^!^!^!^!^!^"^"^"^"^"^"^"^"^"^"^"^"^"^"^"^"^"^"^"^"^"^"^"^"^"^"^"^"^"^"^"^"^"^"^"^"^"^"^"^"^"^"^"_"_"_"_"_"`"`"`"`"`"`"`"`"`"`"`"`"`"`"`"`"`"`"`"`"`"`"`"a"a"a"a"a"a"a"a"a"a"a"a"a"a"a"a"a"a"a"a"a"a"a"a"a"b"b"b"b"b"b"b"b"b"b"b"b"b"b"b"b"b"b"c"c"c"c"c"c"c"c"c"c"c"c"c"c"c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#c#d#d#d#d#d#d#d#d#d#d#d#d#d#d#d#d#d#d#d#d#d#d#d#d#d#d#d#d#d#d#d#d#d#d#d#d#d#d#d#d#d#d#d#d#d#d#d#d#d#d#d#d#d#d#d#d#d#d#d#d#d#d#d#d#d#d#d#d#d#d#d#d#e#e#e#e#e#e#e#e#e#e#e#e#e#e#e#e$e$e$e$e$e$e$e$e$e$e$e$e$e$e$e$e$e$e$e$e$e$e$e$e$e$e$e$e$e$e$e$e$e$e$e$e$e$e$e$e$e$e$e$e$e$e$e$e$e$e$e$e$e$e$e$e$e$e$e$e$e$e$e$e$e$f$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%h%h%h%h%h%h%h%h%h%h%h%h%h%h%h%h%h%h%h%h%h%h%h%h%h%h%h%h%h%h%h%h%h%h%h%h%h%h%h%h%h%h%h%h%h%h%h%h%h%h%i%i%i%i%i%i%i%i%i%i%i%i%i%i%i%i%i%i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(j(j(j(j(j(j(j(j(j(j(j(j(j(j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)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*m*m*m*m*m*m*m*m*m*m*m*m*m*m*m*m*m*m*m*m*m*m*m*m*m*m*m*m*m*m*m*m*m*m*m*m*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*n*n*n*n*n*n*n*n*n*n*n*n*n*n*n*n*n*n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+q+q+q+q+q+q+q+q+q+q+q+q+q+q+q+q+q+q+q+r+r+r+r+r+r+r+r+r+r+r+r+r+r+r+r+r+r+r+r,r,r,r,r,r,r,r,r,r,r,r,r,r,r,r,r,r,r,r,r,r,r,r,r,r,r,r,r,r,r,r,r,r,r,r,r,r,r,r,r,r,r,r,r,r,r,r,r,r,r,r,r,r,r,r,r,r,r,r,r,r,r,r,r,r,r,r,r,r,r,r,r,r,r,r,r,r,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-t-t-t-t-t-t-t-t-t-t-t-t-t-t-t-t-t-t-t-t-t-t-t-t-t-t-t-t-t-t-t-t-t-t-t-t-t-t-t-t-t-t-t-t-t-t-t-t-t-t-t-t-t-t-u-u-u-u-u-u-u-u-u-u-u-u-u-u-u-u-u-u-u-u-u-u-u-u-u-u-u-u-u-u-u-u-v-v-v-v-v-v-v-v-v-v-v-v-v-v-v-v-v-v.v.v.v.v.v. . . . . . . . . . .w.w.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.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/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/w/w/w/w/w/w/w/w/w/w/w/w/w/w/w/w/w/w/w/w/w/w/w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1y1y1y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2z2z2z2z3z3z3z3z3z3z3z3z3z3z3z3z3z3z3z3z3z3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3|3|3|3|3|3|3|3|3|3|3|3|3|3|3|3|3|3|3|3|3|3|3|3|3|3|3|3|3|3|3|3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}4}4}4}4}4}4}4}4}4}4}4}4}4}4~4~4~4~4~4~4~4~4~4~4~4~4~4~4~4~4~4~4~4~4~4~4~4~44444444444444444444444444444444444444444444444444444444444444444444444444444444444444444445555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555566666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777778888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888899999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<================================================================================================================================>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQNQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQOQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTUUUUUUUUUUUUUUUUUUUUUUUUUUUzUzUzUzUzUzUzUzUzUzUzUzUzUzUzUzUzUzUzUzUzUzUzUzUzUzUzUzUzUzUzUzUzUzUzUzUzUzUzUzUzUzUzUzUzUzUzUzUzUzUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^________________________________________________________________________________________________________________________________````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffgggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggghhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiijjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqrrrrrrrrrrrrrrrrrrrrrrrrrr r r r r r r r r r r r r r r r r rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyzzzzzzzYzYzYzYzYzYzYzYzYzYzYzYzYzYzYzYzYzYzYzYzYzYzYzYzYzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{||||||||||||||||||||||||||||||||||||||||||||||||| None! #$%-02356789>?SAgda1Agda42Agda71Agda154AgdaReturn the error corresponding to an exit code from the Agda process I INone# #$%'(-02356789>?T|AgdaNames connected to an entity|Agda'Rendering that entity's name to a label|AgdaGraph structure |||||||||||None! #$%-02356789>?UAgdaCut off structural order comparison at some depth in termination checker?Agdac >= 0( means: record decrease up to including c+1.AgdaThe default termination depth.None! #$%-02356789>?XHAgda Semirings.Agda Addition.AgdaMultiplication.AgdaZero. 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 |s.AgdaThe standard semiring on |s.AgdaThe standard semiring on |s.  None! #$%-02356789>?YAAgdaA constant term.Agda,A term with one hole and the (old) contents.Agda%A term with many holes (error value).None! #$%-02356789>?ZAgdaBetter name for |.AgdaGuard: return the action f only if the boolean is TrueAgdaGuard: return the value a only if the boolean is TrueAgdaBranch over a | collection of values.AgdaBranch over a |3 collection of values using the supplied action.None! #$%-02356789>?a,AgdaType of a filter for CallSiteAgdaType of an entry in a  CallStackAgdaType of a column of a SrcLocAgdaType of a line number of a SrcLocAgdaType of a filename of a SrcLoc | e.g. `srcfullAgdaUtilsFoo.hs`Agda$Type of the name of a function in a CallSite | e.g. proveEverythingAgdaType of the module name of a SrcLoc | e.g. AgdaType of the package name of a SrcLoc | e.g. `Agda-2.@`Agda1The same as the un-exported internal function in %GHC.Exceptions (prettyCallStackLines) Prints like: +doFoo, called at foo.hs:190:24 in main:MainAgdaPretty-print a  CallStack". This has a few differences from GHC.Stack.prettyCallStackLines. We omit the "CallStack (from GetCallStack)" header line for brevity. If there is only one entry (which is common, due to the manual nature of the  HasCallStack constraint), shows the entry on one line. If there are multiple, then the following lines are indented.AgdaGet the most recent CallSite in a  CallStack, if there is one.Agda CallStack! comprising only the most recent CallSiteAgda Transform a  CallStack by transforming its list of CallSiteAgda Transform a  CallStack by filtering each CallSiteAgdaPops n entries off a  CallStack using  popCallStack.. Note that frozen callstacks are unaffected.!MNWXYa`_^]\[ZNone! #$%-02356789>?bAgda%The unicode replacement character  .Agda&Is a character a surrogate code point.Agda?Map surrogate code points to the unicode replacement character.AgdaTotal function to convert an integer to a character. Maps surrogate code points to the replacement character U+FFFD.None! #$%-02356789>?cCNone! #$%-02356789>?cNone! #$%-02356789>?mCAgdaRepeat a state transition f :: a -> (b, a) with output b while condition cond 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)).AgdaRepeat 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).AgdaMonadic version of .Agda%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.usualTrampoline f = trampolineWhile $ a -> maybe (False,a) (True,) (f a).trampolineWhile is very similar to  repeatWhile, only that it discards the state on which the condition went False;, and returns the last state on which the condition was True.AgdaMonadic version of .AgdaMore general trampoline, which allows some final computation from iteration state a into result type b.AgdaMonadic version of .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.AgdaMonadic version of  applyWhenAgdaMonadic version of  applyUnlessNone! #$%-02356789>?nKAgdaSemiring with idempotent | == dioidAgdaE.g. +Agdaneutral element of compose , e.g. zeroNone! #$%-02356789>?r Agda?A decoration is a functor that is traversable into any functor.The | superclass is given because of the limitations of the Haskell class system.  traverseF actually implies functoriality.Minimal complete definition:  traverseF or  distributeF.Agda traverseF is the defining property.Agda%Decorations commute into any functor.Agda?Composition: pure function after functorial (monadic) function.AgdaThe true pure for loop.  is a misnomer, it should be forA.AgdaInfix version of .Agda#Any decoration is traversable with traverse = traverseF. Just like any |6 is a functor, so is any decoration, given by just  traverseF , a functor.AgdaAny decoration is a lens. set is a special case of dmap.Agda0A typical decoration is pairing with some stuff.Agda3Decorations compose. (Thus, they form a category.)Agda%The identity functor is a decoration. R R9 1None! #$%-02356789>?sAgda7Unstructured pragma (Andreas, 2017-08-23, issue #2712).None! #$%-02356789>?v AgdaCatch |s.Agda#Upon exception, the state is reset.Agda+Upon exception, the written output is lost.Agda Alias of | for the IO monad.None! #$%-02356789>?vAgdaReturns a close function for the file together with the contents.None! #$%-02356789>?xNAgdacopyDirContent src dest recursively copies directory src onto dest.First, a to-do list of copy actions is created. Then, the to-do list is carried out.This avoids copying files we have just created again, which can happen if src and dest( are not disjoint. (See issue #2705.)None! #$%-02356789>?xAgdaCreates a temporary file, writes some stuff, and returns the filepathNone! #$%-02356789>?zAgdaReads a UTF8-encoded text file and converts many character sequences which may be interpreted as line or paragraph separators into 'n'.AgdaWrites a UTF8-encoded text file. The native convention for line endings is used.AgdaWrites a UTF8-encoded text file. The native convention for line endings is used. None! #$%-02356789>?{.AgdaRead |+, modify it strictly, and return old value. ||||||||||!None! #$%-02356789>?e AgdaMonads 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.Agda"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.AgdaWe reached a program point without all the required primitives or BUILTIN to proceed forward. (ImpMissingDefinitions neededDefs forThisAgdaAbort by throwing an "impossible" error. You should not use this function directly. Instead use  IMPOSSIBLEAgda 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.  "None! #$%-02356789>?AgdatoImpossible 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.AgdaValues of type  are not forced, because ' is used as a constructor argument in .#None! #$%-02356789>?AgdaA set with duplicates. Faithfully stores elements which are equal with regard to (==).Agda%The list contains all occurrences of a (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).AgdaReturn 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.$None! #$%-02356789>?/AgdaAgsy's meta variables.a the type of the metavariable (what it can be instantiated with). blk= the search control information (e.g. the scope of the meta).AgdaMaybe an instantiation (refinement). It is usually shallow, i.e., just one construct(or) with arguments again being metas.AgdaDoes this meta block a principal constraint (i.e., a type-checking constraint).Agda:List of observers, i.e., constraints blocked by this meta.Agda4Used for experiments with independence of subproofs.Agda Experimental.AgdaResult of type-checking.AgdaSuccess.AgdaDefinite failure.Agda Experimental.Agda$Parallel conjunction of constraints.AgdaExperimental, related to . First arg is sidecondition.AgdaForking proof on something that is not part of the term language. E.g. whether a term will reduce or not.Agda Obsolete.AgdaTrav instance a with block type blk%None" #$%-02356789>? AgdaRepresents a set of integers. Invariants: - All cannot be the argument to | or | - 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.Agda No integers.Agda All integers.Agda'If finite, return the list of elements.Agda Invariant.  &None! #$%-02356789>?< AgdaVan 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.84444'None& #$%'(-./02356789>? Agda An index into a type-level list.Agda4Lists indexed by a type-level list. A value of type All p [xA..xA]% is a sequence of values of types p xA, .., p xA.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.(None! #$%-02356789>?AgdaTokenising the input (makes  cleaner)Agda*Options for Auto, default value and lenses$$)None! #$%-02356789>?Agda(View source:) This is how you implement a lens for a record field.*None" #$%-02356789>?Agda;Update monadically the value at one position (must exist!).Agda Wrapper for  for convenience.AgdaFilter a map based on the keys.Agda>O(n log n). Rebuilds the map from scratch. Not worse than |.+None! #$%-02356789>?AgdaRetain object when tag is |.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 = | (| p [a])Agda Version of |" with different argument ordering.Agda Version of | 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 d f = flip (maybe d) m fAgda with flipped branches.AgdaMonadic version of |.AgdaMonadic version of |.AgdaMonadic version of . That is, $ with a different argument ordering.Agda with flipped branches.AgdaA more telling name for  for the | collection type. Or:  without the | case.Agda without the | case.Agda without the | case.Agda without the | case.AgdaLazy version of allJust  . sequence. (allJust = mapM for the Maybe/ monad.) Only executes monadic effect while isJust.AgdaLift a maybe to an Alternative.||||||||||||,None! #$%-02356789>?!Agda"Simple, non-reentrant memoisation.AgdaRecursive memoisation, second argument is the value you get on recursive calls.-None" #$%-02356789>?Agda/Maximum of on-negative (small) natural numbers..None! #$%-02356789>?Agda Satisfying null empty == True.AgdaA | is ' when it corresponds to the empty list.  None" #$%-02356789>?Agda Analogous to  in  Data.Maybe.Agda Analogous to  in  Data.Maybe.Agda Analogous to  in  Data.Maybe.Agda Analogous to  in  Data.Maybe.Agda unionWith for collections of size <= 1.Agda Unzipping a list of length <= 1.AgdaFiltering a singleton list. filterMaybe p a =  (| p [a])Agda Version of " with different argument ordering.Agda Version of  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  for the  collection type. Or:  without the  case.Agda without the  case.AgdaNote that strict Maybe is an | only modulo strictness. The laws only hold in the strict semantics. Eg. pure f  * pure _|_ = _|_#, but according to the laws for | it should be  pure (f _|_)3. We ignore this issue here, it applies also to | and |./None" #$%-02356789>?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.AgdaCombining 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 |.Agda%Represent a non-empty disjunction of |s as .AgdaA ! information is a disjunction of | informations.AgdaAny | 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.Agda| and | _ are unrelated.Partial ordering for Maybe a is the same as for  Either () a.Agda4The pointwise ordering for lists of the same length.There 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.0None" #$%-02356789>?`Agda?Completing POMonoids with inverses to form a Galois connection.Law: composition and inverse composition form a Galois connection. & related (inverseCompose p x) POLE y  == related x POLE (p <> y) AgdaPartially ordered monoid."Law: composition must be monotone.  related x POLE x' && related y POLE y' ==> related (x <> y) POLE (x' <> y') AgdaPartially ordered semigroup."Law: composition must be monotone.  related x POLE x' && related y POLE y' ==> related (x <> y) POLE (x' <> y') AgdahasLeftAdjoint x checks whether  x^-1 := x  mempty is such that x  y == x^-1 <> y for any y.1None! #$%-02356789>?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).2None! #$%-02356789>?AgdaStar semirings ( 5https://en.wikipedia.org/wiki/Semiring#Star_semirings).Agda Semirings ( &https://en.wikipedia.org/wiki/Semiring).None! #$%-02356789>?3None! #$%-02356789>?Agda Overloaded  singleton constructor for collections.AgdaA create-only possibly empty collection is a monoid with the possibility to inject elements.4None" #$%-02356789>?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.AgdaPartition 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.None! #$%-02356789>?Agda Time O(n)!Agda Time O(1).Agdanot . member a . Time O(1).Agda Time O(n).AgdaThe empty set. Time O(n).AgdaThe full set. Time O(n).AgdaA singleton set. 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).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).Agda Time O(n).5None! #$%-02356789>? Agda&Classification of identifier variants.AgdaIdentifier ends in Int many primes.AgdaIdentifier ends in number Int (ordinary digits).AgdaIdentifier ends in number Int (subscript digits).Agda'Is the character one of the subscripts 'A'-'A'?Agda Converts '0'-'9' to 'A'-'A'-Precondition: The digit needs to be in range.Agda Converts 'A'-'A' to '0'-'9'.-Precondition: The digit needs to be in range.Agda?Increase the suffix by one. If no suffix yet, put a subscript 13 unless users do not want us to use any unicode.Agda Parse suffix.Agda Print suffix.  6None! #$%-02356789>?AgdaDisjoint sum of three.AgdaEnum 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.  7None! #$%-02356789>?qAgdaFinite map from [k] to v.With the strict | type,  is also strict in v.AgdaSingleton trie.AgdaeveryPrefix k v! is a trie where every prefix of k (including k itself) is mapped to v.AgdaLeft biased union.#union = unionWith ( new old -> new).Agda/Pointwise union with merge function for values.Agda.Insert. Overwrites existing value if present. %insert = insertWith ( new old -> new)Agda6Insert with function merging new value with old value.Agda.Delete value at key, but leave subtree intact.Agda*Adjust value at key, leave subtree intact.AgdaConvert to ascending list.AgdaConvert to ascending list.AgdaConvert to list where nodes at the same level are ordered according to the given ordering.AgdaCreate new values based on the entire subtrie. Almost, but not quite comonad extend.Agda8Returns the value associated with the given key, if any.Agda%Is the given key present in the trie?Agda&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. None! #$%-02356789>?AgdaBifunctoriality for pairs.Agda mapFst f = f -*- idAgda mapSnd g = id -*- gAgdaLifted pairing.AgdaMonadic version of .AgdaMonadic .AgdaMonadic .SS238None! #$%-02356789>?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.AgdaAppend a single element at the end. Time: O(length); use only on small lists.Agda5Case distinction for lists, with list first. O(1).Cf. ..Agda5Case distinction for lists, with list first. O(1).Cf. ..Agda4Case distinction for lists, with list last. O(1).AgdaHead function (safe). Returns a default value on empty lists. O(1). >headWithDefault 42 [] = 42 headWithDefault 42 [1,2,3] = 1AgdaTail function (safe). O(1).AgdaTail function (safe). Returns a default list on empty lists. O(1).AgdaLast element (safe). O(n).AgdaLast element (safe). Returns a default list on empty lists. O(n).Agda3Last element of non-empty list (safe). O(n). last1 a as = last (a : as)Agda"Last two elements (safe). O(n).AgdaOpposite of cons (:), safe. O(1).AgdaMaybe cons. O(1). "mcons ma as = maybeToList ma ++ asAgda| and | in one go, safe. O(n).Agda| and |& of non-empty list, safe. O(n). *initLast1 a as = (init (a:as), last (a:as)Agda|& of non-empty list, safe. O(n). init1 a as = init (a:as)Agdainit, safe. O(n).Agdainit, safe. O(n).Agda4Lookup function (partially safe). O(min n index).AgdaLookup function with default value for index out of range. O(min n index).The name is chosen akin to .AgdaFind 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.AgdaSplit 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 |s and | s. O(n). partitionMaybe f = partitionEithers . map ( a -> maybe (Left a) Right (f a))Note: | f = snd . partitionMaybe f.AgdaLike |, but additionally return the last partition of the list where the predicate is False everywhere. O(n).AgdaLike |, 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).AgdaDrops from both lists simultaneously until one list is empty. O(min n m).AgdaCheck 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 ((| ) `on` f) | | (| `on` f). O(n log n).Agda A variant of | which applies the predicate to consecutive pairs. O(n). DEPRECATED in favor of .AgdaSplit 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).AgdaChop 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) == xsAgdaCheck 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 == (| xs).Agda&Check whether a list is sorted. O(n).Assumes that the |% instance implements a partial order.AgdaCheck whether all elements in a list are distinct from each other. Assumes that the |- 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 |.AgdaReturns an (arbitrary) representative for each list element that occurs more than once. O(n log n).AgdaRemove the first representative for each list element. Thus, returns all duplicate copies. O(n log n).&allDuplicates xs == sort $ xs \ nub xs.AgdaPartition a list into first and later occurrences of elements (modulo some quotient given by a representation function).Time: O(n log n).Specification: nubAndDuplicatesOn f xs = (ys, xs List.\\ ys) where ys = nubOn f xsAgdaEfficient variant of nubBy 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: List.sortBy (compare `on` f) (uniqOn f xs) == uniqOn f xs uniqOn id == Set.toAscList . Set.fromListAgdaChecks if all the elements in the list are equal. Assumes that the |6 instance stands for an equivalence relation. O(n).AgdaNon-efficient, monadic nub . O(n).Agda5Requires both lists to have the same length. O(n). Otherwise, Nothing is returned.AgdaLike | but keep the rest of the second list as-is (in case the second list is longer). O(n).  zipWithKeepRest f as bs == zipWith f as bs ++ drop (length as) bs AgdaImplemented 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.9None! #$%-02356789>?Q Agda adds double quotes around the string, replaces newline characters with n, and escapes double quotes and backslashes within the string. This is different from the behaviour of |: > | $ | "\x2200" "\8704" > | $  "\x2200" "D" (The code examples above have been tested using version 4.2.0.0 of the base library.)AgdaTurns the string into a Haskell string literal, avoiding escape codes.Agda$Adds hyphens around the given stringputStrLn $ delimiter "Title"<@@@@ Title @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@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.  None" #$%-02356789>?9Agda%Return the last element and the rest.AgdaBuild a list with one element.Agda"Append a list to a non-empty list.Agda#Prepend a list to a non-empty list.AgdaMore precise type for snoc.AgdaMore precise type for 8. A variant of |: which applies the predicate to consecutive pairs. O(n).Agda(Concatenate one or more non-empty lists.AgdaLike 8. Duplicates in the first list are not removed. O(nm).AgdaChecks if all the elements in the list are equal. Assumes that the |6 instance stands for an equivalence relation. O(n).AgdaLike |.AgdaLike .AgdaLike .AgdaLike .AgdaLike .AgdaNon-efficient, monadic  . O(n).AgdaLike .AgdaLike .  !"#$%&'()*+,-./0123456789:;<=>?@ABV  !"#$%&'()*+,-./0123456789:;<=>?@ABV:None! #$%-02356789>?FAgdaThing decorated with its size. The thing should fit into main memory, thus, the size is an Int.Agda,The size of a collection (i.e., its length).AgdaCache the size of an object.AgdaReturn the cached size.;None! #$%-02356789>?Agda%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]:  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  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 nAgdaIdentity 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) == pAgdaTurn a possible non-surjective permutation into a surjective permutation.Agda ?permute (reverseP p) xs == reverse $ permute p $ reverse xs Example:  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 reverseP, 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 permute (flipP (Perm n xs)) [0..n-1] = permute (Perm n xs) (downFrom n)Can 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.AgdaStable 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.None! #$%-02356789>? AgdaLists of length D2. Agda Safe. O(1). Agda Safe. O(1). Agda Safe. O(n). Agda Safe. O(1). Agda Safe. O(1). Agda Safe. O(1). AgdaUnsafe! <None" #$%-02356789>?d AgdaDenotational equality for floating point numbers, checks bitwise equality.NOTE: Denotational equality distinguishes NaNs, so its results may vary depending on the architecture and compilation flags. Unfortunately, this is a problem with floating-point numbers in general. AgdaI guess "denotational orderings" are now a thing? The point is that we need an Ord instance which provides a total ordering, and is consistent with the denotational equality.NOTE: The ordering induced via  * is total, and is consistent with  . However, it is *deeply* unintuitive. For one, it considers all negative numbers to be larger than positive numbers. AgdaReturn Just x if it's a finite number, otherwise return Nothing. AgdaRemove suffix .0$ from printed floating point number. Agda$Decode a Double to an integer ratio. Agda$Encode an integer ratio as a double. AgdaDecode a Double to its mantissa and its exponent, normalised such that the mantissa is the smallest possible number without loss of accuracy. AgdaChecks whether or not the Double is within a safe range of operation. Agda.Encode a mantissa and an exponent as a Double.+ + None! #$%-02356789>?  AgdaWhile |- is for rendering data in Haskell syntax,   is for displaying data to the world, i.e., the user and the environment.Atomic data has no inner document structure, so just implement   as pretty a = text $ ... a .... AgdaUse instead of | when printing to world. Agda1Separate, but only if both separees are not null. Agda+Comma separated list, without the brackets. AgdaPretty print a set. Agda!Pretty print an association list. Agda"Pretty print a single association. AgdaApply { to  if boolean is true. AgdaOnly wrap in parens if not  Agdaalign max rows lays out the elements of rows 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 b Agda pshow = text . show AgdaUsed for with-like  telescopesopqrstuvwxyz{|}~ opqrstuvwxyz{|}~ 6=None! #$%-02356789>?$ Agda"CPU time in pico (10^-12) seconds. Agda Timestamps. AgdaThe current time. AgdaMeasure the time of a computation. Of course, does not work with exceptions. Agda(Print CPU time in milli (10^-3) seconds.  >None! #$%-02356789>? Agda(Documents paired with precedence levels. AgdaAn extended parser type, with some support for printing parsers. AgdaRuns the parser. Agda&Tries to print the parser, or returns |, depending on the implementation. This function might not terminate. AgdaParses a token satisfying the given predicate. The computed value is returned. AgdaUses 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 unique key. (Parametrised parsers must use distinct keys for distinct inputs.) AgdaMemoises the given parser, but only if printing, not if parsing./Every memoised parser must be annotated with a unique 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.rThe type of memoised values. (Yes, all memoised values have to have the same type.)tokThe token type.aThe result type. AgdaUses 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 E and +. AgdaPrecedence of atoms.  None! #$%-02356789>?wNone! #$%-02356789>?!MNWXYaZ[\]^`_!MNWXYaZ[\]^`_?None! #$%-02356789>? 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-negative AgdaExecuting a substitution. AgdaPartial 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= 0. AgdaDefault polarity is  . Agda?Returns an error message if we have a contradictory constraint. Agda  acts as |,   as |. Agda Interpret   as relation on  . AgdaAdd offset to size expression. AgdaComparison operator is ordered   <  .7 7 @None! #$%-02356789>? 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. AgdaClear the running info buffer. AgdaClear the warning buffer AgdaDisplay running information about what the type-checker is up to. None! #$%-02356789>?# Agda Loop while we have an exception. AgdaMonadic version of |$ with a different argument ordering. Agda'Either _ b' is a functor. Agda'Either a' is a functor. Agda| is bitraversable. Note: From base >= 4.10.0.0 already present in . Agda Analogue of . Agda Analogue of . Agda Analogue of +. Agda Analogue of +. AgdaSafe projection from |. 8maybeLeft (Left a) = Just a maybeLeft Right{} = Nothing AgdaSafe projection from |.  x) xs) else Nothing Agda)Groups a list into alternating chunks of | and | values AgdaConvert | to | e, given an error e for the | case. Agda Swap tags | and |.OP  PO None! #$%-02356789>?-c 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. AgdaLazy 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 () 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 | :: (a -> Maybe b) -> [a] -> [b]. Agda A version of  ' with a computation for the input list. AgdaThe for version of  . AgdaThe for version of  . AgdaA monadic version of | :: (a -> Bool) -> [a] -> [a]. AgdaA monadic version of  dropWhileEnd :: (a -> Bool) -> [a] -> m [a]:. Effects happen starting at the end of the list until p becomes false. AgdaA `monadic' version of @ partition# :: (a -> Bool) -> [a] -> ([a],[a]) Agda Translates | to  . AgdaGeneralises the |& function from lists to an arbitrary  . Agda"Branch over elements of a monadic | data structure. AgdaFinally for the Error class. Errors in the finally part take precedence over prior errors. AgdaTry a computation, return | if an Error occurs. Agda1Run a command, catch the exception and return it. AgdaLike |-, but raise given error when condition fails. Agda;Bracket without failure. Typically used to preserve state. Agda Restore state after computation. AgdaAcquires resource. Run first.AgdaReleases resource. Run last.Agda Computes result. Run in-between.,U JT , TJ UANone# #$%-02356789>?2 Agda.Lazy monadic computation of a list of results. AgdaBoilerplate function to lift | through the   transformer. Agda Inverse to  . 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. AgdaLazy monadic disjunction of lazy monadic list, effects left-to-right AgdaLazy monadic conjunction of lazy monadic list, effects left-to-right Agda8Force all values in the lazy list, effects left-to-right AgdaThe join operation of the ListT m monad. AgdaWe can `run' a computation of a   as it is monadic itself. Agda Monadic cons. AgdaMonadic singleton. Agda Extending a monadic function to  . Agda!Alternative implementation using  . Agda Change from one monad to another  BNone" #$%-02356789>?6 Agda%Paths which are known to be absolute.Note that the | and | instances do not check if different paths point to the same files or directories. Agda Extract the   to be used as |. Agda Constructs  s.2Precondition: The path must be absolute and valid. AgdaMakes the path absolute.This function may raise an __IMPOSSIBLE__ error if |" does not return an absolute path. Agda!Resolve symlinks etc. Preserves  . AgdaTries to establish if the two file paths point to the same file (or directory). AgdaCase-sensitive | 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.) AgdaTrue if the first file is newer than the second file. If a file doesn't exist it is considered to be infinitely old. CNone! #$%-02356789>?7 AgdaHashes a piece of |. Agda-Hashing a module name for unique identifiers.  DNone! #$%-02356789>?< Agda'Monad with access to benchmarking data. AgdaWe need to be able to terminate benchmarking in case of an exception. AgdaBenchmark structure is a trie, mapping accounts (phases and subphases) to CPU time spent on their performance. AgdaAre we benchmarking at all? Agda!What are we billing to currently? Agda/The accounts and their accumulated timing bill. Agda3Record when we started billing the current account. Agda(Account we can bill computation time to. AgdaSemantic editor combinator. AgdaSemantic editor combinator. AgdaSemantic editor combinator. Agda"Add to specified CPU time account. AgdaTurn benchmarking on/off. AgdaBill current account with time up to now. Switch to new account. Return old account (if any). Agda.Resets the account and the timing information. AgdaBill a computation to a specific account. Works even if the computation is aborted by an exception. Agda;Bill a CPS function to an account. Can't handle exceptions. Agda.Bill a pure computation to a specific account. Agda2Print benchmark as three-column table with totals. Agda$Initial benchmark structure (empty). AgdaMaybe new account.AgdaMaybe old account.  ENone! #$%-02356789>?O AgdaFinite maps from k to v!, with a way to quickly get from v to k for certain values of type v (those for which   is defined).&Every value of this type must satisfy  . Agda0Partial injections from a type to some tag type.The idea is that  ( should be injective on its domain: if   x =   y = | i, then x = y. However, this property does not need to hold globally. The preconditions of the  3 operations below specify for which sets of values   must be injective. AgdaChecks if the function   is injective for the values in the given list for which the function is defined. AgdaThe invariant for  . AgdaLookup. O(log n). AgdaInverse lookup. O(log n). AgdaSingleton map. O(1). Agda0Insertion. Overwrites existing values. O(log n).Precondition: See  . AgdaThe precondition for   k v m: If v has a   (  v D |), then m must not contain any mapping k' C v' for which k D k' and   v =   v'. AgdaModifies the value at the given position, if any. If the function returns |&, then the value is removed. O(log n).The precondition for   f k m is that, if the value v is inserted into m, and   v% is defined, then no key other than k may map to a value v' for which   v' =   v. AgdaModifies the value at the given position, if any. If the function returns |&, then the value is removed. O(log n).Precondition: See  . AgdaThe precondition for   f k m is that, if the value v is inserted into m, and   v% is defined, then no key other than k may map to a value v' for which   v' =   v. AgdaModifies the value at the given position, if any. If the function returns |&, then the value is removed. O(log n).Precondition: See  . AgdaThe precondition for   f k m is that, if the value v is inserted into m, and   v% is defined, then no key other than k may map to a value v' for which   v' =   v. Agda;Modifies the value at the given position, if any. O(log n).Precondition: See  . AgdaThe precondition for   f k m is that, if the value v is inserted into m, and   v% is defined, then no key other than k may map to a value v' for which   v' =   v. AgdaInserts a binding into the map. If a binding for the key already exists, then the value obtained by applying the function to the key, the new value and the old value is inserted, and the old value is returned.Precondition: See  . AgdaThe precondition for   f k v m is that, if the value v' is inserted into m, and   v'% is defined, then no key other than k may map to a value v'' for which   v'' =   v'. AgdaChanges all the values using the given function, which is also given access to keys. O(n log n).Precondition: See  . AgdaThe precondition for   f m!: For any two distinct mappings kA C vA, kA C vA in m for which the tags of f kA vA and f kA vA are defined the values of f must be distinct (f kA vA D f kA vA). Furthermore   must be injective for { f k v | (k, v) D m }. AgdaChanges all the values using the given function, which is also given access to keys. O(n).Precondition: See  ". Note that tags must not change. AgdaThe precondition for   f m is that, if m maps k to v, then   (f k v) ==   v. Agda0Left-biased union. For the time complexity, see |.Precondition: See  . AgdaConversion from lists of pairs. Later entries take precedence over earlier ones. O(n log n).Precondition: See  . AgdaConversion to lists of pairs, with the keys in ascending order. O(n). Agda#The keys, in ascending order. O(n). Agda>The values, ordered according to the corresponding keys. O(n). AgdaConversion from two lists that contain distinct keys/tags, with the keys/tags in ascending order. O(n).Precondition: See  . AgdaGenerates input suitable for  . O(n).% % FNone! #$%-02356789>?f8 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   (  r x) == r. Agda5Things that have a range are instances of this class. Agda1Wrapper to indicate that range should be printed. AgdaA 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:  . AgdaAn interval. The iEnd* position is not included in the interval.4Note the invariant which intervals have to satisfy:  . Agda Represents a point in the input.If two positions have the same   and   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:  . AgdaFile. AgdaPosition, counting from 1. AgdaLine number, counting from 1. AgdaColumn number, counting from 1. Agda Sets the   components of the interval. Agda Gets the   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. AgdaThe 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:  . AgdaAre 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 positions Agda?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' movePos Agda%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. AgdaConverts 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'.Precondition: The ranges must point to the same file (or be empty). AgdaPrecondition: The ranges must point to the same file (or be empty). Agda beginningOf r 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 r 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 elementsIt 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. AgdaTo get   #, we need a semigroup instance for  . AgdaPrecondition: The ranges of the tuple elements must point to the same file (or be empty). AgdaPrecondition: The ranges of the tuple elements must point to the same file (or be empty). AgdaPrecondition: The ranges of the tuple elements must point to the same file (or be empty). AgdaPrecondition: The ranges of the tuple elements must point to the same file (or be empty). AgdaPrecondition: The ranges of the tuple elements must point to the same file (or be empty). AgdaPrecondition: The ranges of the tuple elements must point to the same file (or be empty). AgdaPrecondition: The ranges of the list elements must point to the same file (or be empty). AgdaPrecondition: The ranges of the list elements must point to the same file (or be empty). AgdaOverlaps with  KillRange [a]. GNone" #$%-02356789>? 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.AgdaRewriteEqn' qn p e represents the rewrite and irrefutable with clauses of the LHS. qn stands for the QName of the auxiliary function generated to implement the feature nm/ is the type of names for pattern variables p is the type of patterns e is the type of expressionsAgda  rewrite eAgda with p <- e in eqAgda!Coverage check? (Default is yes).Agda!Universe check? (Default is yes).Agda#Positivity check? (Default = True).Agda0Termination check? (Default = TerminationCheck).AgdaRun the termination checker.Agda#Skip termination checking (unsafe).AgdaTreat as non-terminating.Agda/Treat as terminating (unsafe). Same effect as .Agda2Skip termination checking but use measure instead.AgdaRename from this name.Agda#To this one. Must be same kind as .AgdaNew fixity of  (optional).AgdaThe range of the "to" keyword. Retained for highlighting purposes.Agda3An imported name can be a module or a defined name.AgdaImported module name of type m.AgdaImported name of type n.AgdaThe using clause of import directive.AgdaNo using clause given.Agdausing the specified names.AgdaThe things you are allowed to say when you shuffle names between name spaces (i.e. in import,  namespace, or open declarations).Agda Only for open3. Exports the opened names from the current module.AgdaThe notation is handled as the fixity in the renamer. Hence, they are grouped together in this type.AgdaRange of the name in the fixity declaration (used for correct highlighting, see issue #2140).AgdaFixity of operators.Agda&Range of the whole fixity declaration.AgdaAssociativity.AgdaNo fixity declared.Agda$Fixity level declared as the number.Agda Precedence levels for operators.AgdaPlaceholders are used to represent the underscores in a section.AgdaThe second argument is used only (but not always) for name parts other than underscores.Agda4The position of a name part or underscore in a name.Agda;The following underscore is at the beginning of the name: _foo.Agda8The following underscore is in the middle of the name: foo_bar.Agda4The following underscore is at the end of the name: foo_.AgdaA "problem" consists of a set of constraints and the same constraint can be part of multiple problems.Agda4A meta variable identifier is just a natural number.AgdaThe 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  of the private block that lead to this qualifier. This is needed for more faithful printing of declarations.AgdaFunctions can be defined in both infix and prefix style. See i.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.AgdaThe type of the nameAgdaStandard argument names.AgdaStandard naming.Agda&Something potentially carrying a name.Agda4A function argument can be hidden and/or irrelevant.AgdaSometimes we want a different kind of binder/pi-type, without it supporting any of the Modality interface.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.AgdaNamed 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.Agdaidentity modality. | Sharp -- ^ same points, codiscrete topology, idempotent monad, diamond-like.Agdasingle point space, artificially added for Flat left-composition.AgdaIn the future there might be different kinds of them. For now we assume lock weakening.AgdaWe have a tuple of annotations, which might not be fully orthogonal.AgdaFitch-style dependent right adjoints. See Modal Dependent Type Theory and Dependent Right Adjoints, arXiv:1804.05236.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.AgdaA special case of : erased or not.AgdaQuantity for linearity.A 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} (could be updated destructively). Mostly TODO (needs postponable constraints between quantities to compute uses).AgdaUnrestricted use B.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.AgdaType wrapper to indicate composition or multiplicative monoid/semigroup context.Agda;Type wrapper to indicate additive monoid/semigroup context.AgdaA lens to access the : attribute in data structures. Minimal implementation:  getHiding and  mapHiding or  LensArgInfo.AgdaDecorating something with  information.Agda Inductive < CoinductiveAgda0Can we construct a record by copattern matching?Agda/Can we pattern match on the record constructor?Agda=For a record without eta, which type of matching do we allow?Agda$Can match on the record constructor.Agda5Can copattern match using the projections. (Default.)AgdaPattern and copattern matching is allowed in the presence of eta.In the absence of eta, we have to choose whether we want to allow matching on the constructor or copattern matching with the projections. Having both leads to breakage of subject reduction (issue #4560).Agda%Does a record come with eta-equality?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).AgdaCompose 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.AgdainverseComposeModality 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).AgdaLeft division by a 3. Used e.g. to modify context when going into a m argument.3Note that this function does not change quantities.Agda# forms a pointwise additive monoid.AgdaIdentity under additionAgdaIdentity under compositionAgda"Absorptive element under addition.AgdaThe default Modality Beware that this is neither the additive unit nor the unit under composition, because the default quantity is .AgdaEquality ignoring origin.AgdaEquality ignoring origin.Agda. forms an additive monoid with zero Quantity0.AgdaIdentity element under additionAgdaAbsorptive element! This differs from Relevance and Cohesion whose default is the multiplicative unit.Agda"Identity element under compositionAgdaAbsorptive element is .Agdam moreUsableQuantity m' means that an m can be used where ever an m' is required.Agda+Composition of quantities (multiplication). is dominant.  is neutral.Right-biased for origin.AgdaCompose 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.AgdainverseComposeQuantity 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).AgdaLeft division by a 3. Used e.g. to modify context when going into a q argument.Agda Check for .Agda Check for .Agda Check for .Agda*Did the user supply a quantity annotation?Agda9A thing of quantity 0 is unusable, all others are usable.AgdaThe default value of type  : not erased.AgdaEquality ignoring origin.AgdaIs the value "erased"?AgdaComposition of values of type . is dominant.  is neutral.Right-biased for the origin.AgdaInformation ordering. Relevant `moreRelevant` NonStrict `moreRelevant` IrrelevantAgdaEquality ignoring origin.AgdausableRelevance rel == False! iff we cannot use a variable of rel.Agda composition.  is dominant, + is neutral. Composition coincides with |.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"Identity element under compositionAgda"Absorptive element under addition.Agda;Default Relevance is the identity element under compositionAgdaIrrelevant function arguments may appear non-strictly in the codomain type.AgdaApplied when working on types (unless --experimental-irrelevance).AgdaInformation ordering. Flat `moreCohesion` Continuous `moreCohesion` Sharp `moreCohesion` SquashAgdaEquality ignoring origin.AgdausableCohesion rel == False! iff we cannot use a variable of rel.Agda composition.  is dominant,  is neutral.AgdaCompose 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.AgdainverseComposeCohesion 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.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.AgdaIdentity under compositionAgda"Absorptive element under addition.Agda:Default Cohesion is the identity element under compositionAgdaxs `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   and .Agda,Equality of argument names of things modulo   and .AgdaDoes an argument arg fit the shape dom of the next expected argument?The hiding has to match, and if the argument has a name, it should match the name of the domain.| 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 =  .AgdaDefault is directive is private% (use everything, but do not export).AgdaisDefaultImportDir implies null, but not the other way round.AgdaLike partitionEithers.Agda Just for the 9 instance. Should never combine different overlapping.Agda, is an idempotent partial monoid, with unit .  and  are incompatible.AgdaRight-biased composition, because the left quantity acts as context, and the right one as occurrence.AgdaRight-biased composition, because the left quantity acts as context, and the right one as occurrence.AgdaRight-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.AgdaIn 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 under composition.Agda% forms a semigroup under composition.AgdaMore relevant is smaller.AgdaMore relevant is smaller.Agda is the additive unit.Agda" forms a semigroup under addition.Agda Continous is the multiplicative unit.Agda% forms a semigroup under composition.AgdaFlatter is smaller.Agda2Order is given by implication: flatter is smaller.AgdaPointwise additive unit.AgdaPointwise addition.AgdaPointwise composition unit.AgdaPointwise composition.AgdaDominance ordering.AgdaRanges are not forced.AgdaIgnores range.AgdaIgnores range.AgdaIgnores range.Agda Default is .Agda+Semigroup computes if any of several is an .Agda(Show non-record version of this newtype.AgdaRanges are not forced.AgdaRanges are not forced.Agdanull for import directives holds when everything is imported unchanged (no names are hidden or renamed).  HNone! #$%-02356789>? 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 C x or not? See .AgdaDecorating something with Fixity'.Agda#Argument context preferring parens.AgdaDo we need to bracket an operator application of the given fixity in a context with the given precedence.AgdaDo 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: mA >>= ( x C x) >>= mA (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?INone" #$%-02356789>?4 AgdaThe parser monad.AgdaMemoisation keys.AgdaRuns the parser.AgdaParses a token satisfying the given predicate. The computed value is returned.Agda.Parses a token satisfying the given predicate.AgdaUses 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 unique key. (Parametrised parsers must use distinct keys for distinct inputs.)AgdaMemoises the given parser, but only if printing, not if parsing./Every memoised parser must be annotated with a unique key. (Parametrised parsers must use distinct keys for distinct inputs.)Agda&Tries to print the parser, or returns |, depending on the implementation. This function might not terminate.JNone! #$%-02356789>?AgdaArbitrary JS code.,,KNone! #$%-02356789>?'Agda"Entry of an explicit substitution.&An explicit substitution is a list of CAction"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.Different 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.AgdaNat - 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 instancesAgda Renaming Typeclass and instancesLNone! #$%-02356789>?Agda!Moves A move is composed of a Cost: together with an action computing the refined problem.Agda univar sub v figures out what the name of v" "outside" of the substitution sub ought to be, if anything.Agda6List of the variables instantiated by the substitutionAgdaNew 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 placeholdersAgdaNew App?lication node using a new spine of arguments respecting the Hiding annotationAgdaEquality reasoning steps The begin token is accompanied by two steps because it does not make sense to have a derivation any shorter than that.AgdaPick the first unused UId amongst the ones you have seen (GA: ??) Defaults to the head of the seen ones.MNone! #$%-02356789>?ԥAgda)Typechecker drives the solution of metas.--NNone" #$%&-02356789>? Agda/Type of a literate preprocessor: Invariants:  f : Processor f pos s /= []f pos s >>= layerContent == sAgdaA list of contiguous layers.Agda9A sequence of characters in a file playing the same role.Agda Role of a character in the file.AgdaList of valid extensions for literate Agda files, and their corresponding preprocessors.If 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.AgdaShort list of extensions for literate Agda files. For display purposes.AgdaPreprocessor for literate TeX.AgdaPreprocessor for Markdown.Agda"Preprocessor for reStructuredText.Agda$Preprocessor for Org mode documents.ONone! #$%-02356789>?AgdaPicking the appropriate set of special characters depending on whether we are allowed to use unicode or have to limit ourselves to ascii.AgdaWe want to know whether we are allowed to insert unicode characters or not.AgdaReturn the glyph set based on a given (unicode or ascii) glyph modePNone! #$%-02356789>?(Agda+Check whether a name is the empty name "_".Agda3Method by which to generate fresh unshadowed names.Agda1Append an integer Unicode subscript: x, xA, xA, @Agda-Append an integer ASCII counter: x, x1, x2, @AgdaNumber of holes in a $ (i.e., arity of a mixfix-operator).AgdaTop-level module names. Used in connection with the file system.&Invariant: The list must not be empty.AgdaQName 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?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 C Set which is not valid Agda.SNone! #$%-02356789>?1"AgdaMake a  from some kind of string.AgdaThe   sets the definition site of the name, not the use site.Agda*Check whether we are a projection pattern.Agda A name suffixAgda?AgdaRanges are not forced.  UNone! #$%-02356789>? ~Agda5Checks if the given expression is unreachable or not.AgdaCode 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.AgdaCode which could not be obtained because of a hole in the program. This should throw a runtime error. The string gives some information about the meta variable that got compiled.AgdaMatches 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)AgdaBinds no variablesAgdaCompiler-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 | StringAgdaintroduces 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.AgdaCase 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.AgdaUsed by the GHC backendAgda,A runtime error, something bad has happened.AgdaThe treeless compiler can behave differently depending on the target language evaluation strategy. For instance, more aggressive erasure for lazy targets.Agda4Usage status of function arguments in treeless code.Agda|, if treeless usage analysis has not run yet.Agda=Strip leading coercions and indicate whether there were some.AgdaExpose the format  coerce f args.We 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 bindingAgdafilterUsed used args drops those args which are labelled  ArgUnused in list used.Specification:  filterUsed used args = [ a | (a, ArgUsed) <- zip args $ used ++ repeat ArgUsed ]  Examples:  filterUsed [] == id filterUsed (repeat ArgUsed) == id filterUsed (repeat ArgUnused) == const [] VNone! #$%-02356789>?WNone! #$%-02356789>?AgdaWe lose track of @-patterns in the internal syntax. This pass puts them back.XNone! #$%-02356789>?AgdaArbitrary string (not enclosed in double quotes), used in pragmas.AgdaA misplaced end-comment "-}".AgdaUnconditional layout keywords.Some keywords introduce layout only in certain circumstances, these are not included here.[None! #$%-02356789>?AgdaThe  WarningName data enumeration is meant to have a one-to-one correspondance to existing warnings in the codebase. Agda2Some warnings are errors and cannot be turned off. 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 defaultWarningMode is a curated set of warnings covering non-fatal errors and disabling style-related ones AgdawarningModeUpdate str computes the action of str over the current  WarningMode: it may reset the set of warnings, add or remove a specific flag or demand that any warning be turned into an error AgdaCommon sets of warnings AgdaThe flag corresponding to a warning is precisely the name of the constructor minus the trailing underscore. Agda warningUsage generated using warningNameDescription        \None! #$%-02356789>?)6 Agda The result of parsing something. AgdaWarnings for parsing. Agda,Parse errors that concern a range in a file. AgdaUnsupported attribute. AgdaMultiple attributes. 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?!Agda=Status of a layout column (see #1145). A layout column is ! until we encounter a new line. This allows stacking of layout keywords. Inside a  LayoutContext the sequence of ! columns needs to be strictly increasing. 'Tentative columns between !3 columns need to be strictly increasing as well.!AgdaThe token defining the layout column was on the same line as the layout keyword and we have not seen a new line yet.!AgdaWe have seen a new line since the layout keyword and the layout column has not been superseded by a smaller column.!AgdaA (layout) column.!AgdaWe need to keep track of the context to do layout. The context specifies the indentation columns of the open layout blocks. See Agda.Syntax.Parser.Layout for more informaton.!AgdaLayout at specified !, introduced by .!AgdaThe stack of layout blocks..When we encounter a layout keyword, we push a ! block with noColumn. This is replaced by aproper column once we reach the next token.!Agda:For context sensitive lexing alex provides what is called  start codes in the Alex documentation. It is really an integer representing the state of the lexer, so we call it LexState instead.!AgdaThe 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 blocks!Agda%the status of the coming layout block!Agda'the keyword for the coming layout block!Agdathe state of the lexer (states can be nested so we need a stack)!Agdaparametrization of the parser!AgdaIn reverse order.!AgdaThe parse monad.!Agda,Throw a parse error at the current position.!AgdaRecords a warning.!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.!AgdaParses a string as if it were the contents of the given file Useful for integrating preprocessors.!AgdaThe parse interval is between the last position and the current position.!AgdaFake 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.!AgdaUse ! or ! as appropriate.!Agda3Report a parse error at the beginning of the given  .!AgdaFor 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 ! the current position.!Agda Return the current layout block.!Agda5When we see a layout keyword, by default we expect a ! block. !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! !!!!!!!!!!!!!! !!!!!!!! !!!!!!!!!!!!!!!!!!!!!!!!!!!!]None! #$%-02356789>?+!AgdaInterface to the help function!AgdaGeneral usage information!Agda)Specialised usage information about TOPIC!AgdaUsage information generation!AgdaConversion functions to strings!!!!!!!!!!!!^None! #$%-02356789>?3O!AgdaThrows  exceptions, still collects !s.!Agda Collects !s and !s.!AgdaCache locations of project configurations and parsed .agda-lib files!Agda0Collected errors while processing library files.!AgdaRaised when a library name could not successfully be resolved to an  .agda-lib file.!Agda1Raised when a library name is defined in several .agda-lib files.!AgdaGeneric error.!AgdaLibrary Warnings.!Agda2Raised when a trusted executable can not be found.!AgdaRaised when a trusted executable does not have the executable permission.!AgdaName of  libraries file!AgdaLine number in  libraries file.!Agda Library file!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.!Agda4Default pragma options for all files in the library.!AgdaA file can either belong to a project located at a given root containing one or more .agda-lib files, or be part of the default project.!AgdaE.g. ~.agda executables.!AgdaThe executables file might not exist, but we may print its assumed location in error messages.!AgdaA symbolic executable name.!AgdaE.g. ~.agda libraries.!AgdaThe libraries file might not exist, but we may print its assumed location in error messages.!AgdaA symbolic library name.!AgdaThe special name "." is used to indicated that the current directory should count as a project root."AgdaLenses for AgdaLibFile"Agda Pretty-print !.=!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"""""""""""""""""=!!!!!!!!!!!!!!!!!!!!!!!""""""!!!!!!!!!!!!!!"!!!!!!!""""""""""_None! #$%-02356789>?5"AgdaParse  .agda-lib file.Sets " name and turn mentioned include directories into absolute pathes (provided the given | is absolute)."Agda+Remove leading whitespace and line comment."Agda4Break a comma-separated string. Result strings are trimmed.""""""""`None! #$%-02356789>?9x "Agda.Zero or more consecutive and separated ranges."AgdaCharacter ranges. The first character in the file has position 1. Note that the "4 position is considered to be outside of the range. Invariant: " } "."AgdaThe " invariant."AgdaThe " invariant."Agda| iff the ranges overlap.)The ranges are assumed to be well-formed."Agda(Converts a range to a list of positions."Agda/Converts several ranges to a list of positions."Agda Converts a   to a "."Agda Converts a  #, seen as a continuous range, 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.""""""""""""""""""""""""""""""aNone! #$%-02356789>?C"Agda*Maps containing non-overlapping intervals.The implementation does not use IntMap, because IntMap does not come with a constant-time size function.Note the invariant which "s should satisfy (")."AgdaThe keys are starting points of ranges, and the pairs contain endpoints and values."Agda7A strict pair type where the first argument must be an |.*This type is included because there is no } instance for } in the package strict before version 4."AgdaA class that is intended to make it easy to swap between different range map implementations.Note that some ", operations are not included in this class."AgdaThe map " rs x contains the ranges from rs9, and every position in those ranges is associated with x."AgdaConverts range maps to }s from positions to values."AgdaConverts the map to a list. The ranges are non-overlapping and non-empty, and earlier ranges precede later ones in the list."Agda?Returns the smallest range covering everything in the map (or |, if the range would be empty).Note that the default implementation of this operation might be inefficient."AgdaLike ", but with several " instead of only one."AgdaInvariant for ".8The ranges must not be empty, and they must not overlap."Agda3Converts a list of pairs of ranges and values to a ". The ranges have to be non-overlapping and non-empty, and earlier ranges have to precede later ones."Agda,Inserts a value, along with a corresponding " , into a ". No attempt is made to merge adjacent ranges with equal values.The function argument is used to combine values. The inserted value is given as the first argument to the function."Agda The value of " p f is a pair (f1, f2)! which contains everything from f. All the positions in f1 are less than p, and all the positions in f2 are greater than or equal to p."Agda Returns a "> overlapping the given range, as well as the rest of the map."AgdaRestricts the " to the given range."AgdaMerges "s by inserting every "piece" of the smaller one into the larger one."AgdaMerges "s by inserting every "piece" of the smaller one into the larger one.""""""""""""""""""""""""""""""""""bNone! #$%-02356789>?D""""""""""""""""""""""""""""""""""""cNone! #$%-02356789>?F|#AgdaSeparate by blank line.#Agda1Separate by space that will be removed by minify.For non-removable space, use d <> " " <> d'.#Agda1Concatenate vertically, separated by blank lines.#AgdaApply # to " if boolean is true.#AgdaCheck 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.("""""""""""""""#########################("""""""""""###################""#""######5#5#6dNone! #$%-02356789>?HD#AgdaSpeculation: Type class computing the size (?) of a pattern and collecting the vars it introduces#AgdaTake a list of patterns and returns (is, size, vars) where (speculation):4####################################################4####################################################eNone! #$%-02356789>?o#Agda SCC DAGs.0The maps map SCC indices to and from SCCs/nodes.#AgdaVarious kinds of nodes.#AgdaNodes with outgoing edges.#AgdaNodes with incoming edges.#Agda!All nodes, with or without edges.#AgdaEdges.#AgdaOutgoing node.#AgdaIncoming node.#AgdaEdge label (weight).#Agda Graph n e, is a type of directed graphs with nodes in n and edges in e.At 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)). However, computing the incoming edges may be more expensive.Note that neither the number of nodes nor the number of edges may exceed } :: |.$AgdaForward edges.$AgdaInternal invariant.$AgdaIf there is an edge from s to t, then  lookup s t g is | e, where e is the edge's label. O(log n).$AgdaThe graph's edges. O(n + e).$Agdaneighbours 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|).$AgdaneighboursMap 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).$AgdaedgesFrom g ns is a list containing all edges originating in the given nodes (i.e., all outgoing edges for the given nodes). If ns does not contain duplicates, then the resulting list does not contain duplicates. O(|ns| log |n| + |edgesFrom g ns|).$Agda edgesTo g ns is a list containing all edges ending in the given nodes (i.e., all incoming edges for the given nodes). If ns does not contain duplicates, then the resulting list does not contain duplicates. O(|ns | n log n).$AgdaAll self-loops.  O(n log n).$Agda All nodes. O(n).$AgdaNodes with outgoing edges. O(n).$AgdaNodes with incoming edges. O(n + e log n).$Agda Constructs a # structure. O(n + e log n).$Agda*Nodes without incoming or outgoing edges. O(n + e log n).$AgdaChecks whether the graph is discrete (containing no edges other than  edges). O(n + e).$AgdaReturns True iff the graph is acyclic.$AgdaConstructs a completely disconnected graph containing the given nodes.  O(n log n).$AgdaConstructs 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 es. 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).$Agda Inserts an edge into the graph. O(log n).$AgdainsertWith 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).$Agda A variant of $. O(log n).$AgdaLeft-biased union.Time complexity: See $.$AgdaUnion. 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(nA log (nAnA + 1) + eA log eA, where nA/ is the number of nodes in the graph with the smallest number of nodes and nA0 is the number of nodes in the other graph, and eA is the number of edges in the graph with the smallest number of edges and eA+ 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).$AgdaUnion. O((n + e) log n (where n and e refer to the resulting graph).$AgdaUnion. 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).$Agda A variant of }< that provides extra information to the function argument. O(n + e).$AgdaReverses an edge. O(1).$Agda.The opposite graph (with all edges reversed). O((n + e) log n).$AgdaRemoves  edges. O(n + e).$AgdaremoveNodes ns g removes the nodes in ns% (and all corresponding edges) from g. O((n + e) log |ns|).$AgdaremoveNode n g removes the node n% (and all corresponding edges) from g. O(n + e).$AgdaremoveEdge s t g removes the edge going from s to t , if any. O(log n).$Agda0Keep only the edges that satisfy the predicate. O(n + e).$AgdaUnzips the graph. O(n + e).$AgdacomposeWith 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.$AgdaThe graph's strongly connected components, in reverse topological order.$AgdaThe graph's strongly connected components, in reverse topological order.$Agda# invariant.$AgdaThe opposite DAG.$Agda'The nodes reachable from the given SCC.$AgdaConstructs a DAG containing the graph's strongly connected components.$AgdaConstructs a DAG containing the graph's strongly connected components.$AgdareachableFrom 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 } :: |.Amortised time complexity (assuming that comparisons take constant time):  O(e log n), if the lists are not inspected. Inspection of a prefix of a list is linear in the length of the prefix.$AgdareachableFromSet 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 } :: |.Amortised time complexity (assuming that comparisons take constant time): O((|ns | + e) log n).$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 some. 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 } :: |.Amortised 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.The 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.This 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 #, and with some shortcuts:Zero edge differences are not added to the graph, thus avoiding some zero edges.Strongly connected components are used to avoid computing some zero edges.The 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.$Agda*The graph's strongly connected components.################$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$#$$$#####$$$$$$$$$$$#####$$$$$$$$$$$$$$$$$$$$$$$$$$$$$#####$$$$$$$$$$$$$fNone! #$%-02356789>?r$Agdatopoligical 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.$$gNone! #$%-02356789>?%$AgdaThese metas are < D.$Agda,Lower or upper bound for a flexible variable$AgdaA 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".$AgdaAdd 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 g 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.Application: 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.%AgdaCompute the relative minima in a set of nodes (those that do not have a predecessor in the set).%AgdaCompute 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.%AgdaCompute the sup of two different rigids or a rigid and a constant.%AgdaCompute the inf of two different rigids or a rigid and a constant.%Agda$Compute the least upper bound (sup).%AgdaCompute the greatest lower bound (inf) of size expressions relative to a hypotheses graph.%AgdaSolve a forest of constraint graphs relative to a hypotheses graph. Concatenate individual solutions.%AgdaCheck that after substitution of the solution, constraints are implied by hypotheses.%Agda1Iterate solver until no more metas can be solved.This 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 $ if it contains a negative loop (diagonal edge). Makes sense on transitive graphs.%Agda;Meta variable polarities (prefer lower or upper solution?).AgdaHypotheses (assumed to have no metas, so, fixed during iteration).AgdaConstraints to solve.Agda7Previous substitution (already applied to constraints).AgdaAccumulated substition.$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$%%%%%%%%%%%%%%%%%%%%%%%$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$%%$$$%$$$$$%%%%%%%%%%%%%%%%%%%%hNone! #$%-02356789>?N%AgdaSubterm 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.%AgdaGuarded strictly positive occurrence (i.e., under D). For checking recursive records.%Agda-One part of the description of an occurrence.%Agda(in the nth argument of a define constant%Agda'in the principal argument of built-in D%Agda"as an argument to a bound variable%Agda as an argument of a metavariable%Agdain the type of a constructor%Agda$in a datatype index of a constructor%Agda'in the nth clause of a defined function%Agda1matched against in a clause of a defined function%Agda"is an index of an inductive family%Agdain the definition of a constant%AgdaDescription 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, }  w } bound iff } [ } every w } } some w | (every, some) <- ess ].%Agda+productOfEdgesInBoundedWalk occ g u v bound returns a value distinct from | iff there is a walk c (a list of edges) in g, from u to v, for which the product }  (} occ c) } bound&. In this case the returned value is | (}  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  is meet (glb) and 0 is composition. Both operations are idempotent.For , % is neutral (zero) and % is dominant. For , % is neutral (one) and % is dominant.%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%iNone# #$%-012356789>?%AgdaThe ' is not an application.%Agda(Extended content of an interaction hole.%Agda e%Agda  (rewrite | invert) e0 | ... | en%Agda=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 name%AgdaINLINE or NOINLINE&Agda6Throws an internal error in the scope checker. The }+s are words to be displayed with the error.&Agda:For coinductive records, use pragma instead of regular  eta-equality, definition (as it is might make Agda loop).&AgdaApplies to the named function&AgdaApplies to the current module&AgdaMark a definition as injective for the pattern matching unifier.&Agda*Display lhs as rhs (modifies the printer).&Agda)Applies to the following function clause.&AgdaApplies to the following function (and all that are mutually recursive with it) or to the functions in the following mutual block.&AgdaApplies to the following function (and all that are mutually recursive with it) or to the functions in the following mutual block.&Agda:Applies to the following data/record type or mutual block.&Agda*Applies to the following data/record type.&Agda  tel. M args&Agda  M {{...}}&AgdaThe representation type of a declaration. The comments indicate which type in the intended family the constructor targets.&AgdaAxioms and functions can be irrelevant. (Hiding should be NotHidden)&Agda=Variables to be generalized, can be hidden and/or irrelevant.&Agda#lone data signature in mutual block&Agda%lone record signature in mutual block&Agda$Should not survive beyond the parser&Agdanotation declaration for a name&AgdaIn  Agda.Syntax.Concrete.Definitions we generate private blocks temporarily, which should be treated different that user-declared private blocks. Thus the .&AgdaThe  9 here (exceptionally) only refers to the range of the instance( keyword. The range of the whole block InstanceB r ds is fuseRange r ds.&Agda1Isolated record directives parsed as Declarations&AgdaRange of keyword  [co]inductive.&Agda Range of [no-]eta-equality keyword.&AgdaIf declaration pattern is present, give its range.&Agda(Just type signatures or instance blocks.&AgdaJust type signatures.&Agda.From the parser, we get an expression for the as-#, which we have to parse into a .&AgdaThe content of the as -clause of the import statement.&AgdaThe "as" name.&AgdaThe range of the "as" keyword. Retained for highlighting purposes.&Agda3An imported name can be a module or a defined name.&AgdaThe things you are allowed to say when you shuffle names between name spaces (i.e. in import,  namespace, or open declarations).&AgdaAn expression followed by a where clause. Currently only used to give better a better error message in interaction.&AgdaPossibly empty sequence.&AgdaNo where clauses.&Agda Ordinary where.   of the where/ keyword. List of declarations can be empty.&Agda Named where: module M where ds.   of the keywords module and where . The  flag applies to the  (not the module contents!) and is propagated from the parent function. List of declarations can be empty.&Agdawhere block following a clause.&Agda+No right hand side because of absurd match.&Agda:Processed (operator-parsed) intermediate form of the core f ps of &. Corresponds to &.&Agda f&Agda ps&AgdaRecord projection.&Agda-Patterns for record indices (currently none).&AgdaMain argument.&AgdaNon-empty; at least one (| p).&Agda+Pattern that was expanded from an ellipsis ....&Agda;Left hand sides can be written in infix style. For example: +n + suc m = suc (n + m) (f D g) x = f (g x)We use fixity information to see which name is actually defined.&AgdaOriginal pattern (including with-patterns), rewrite equations and with-expressions.&Agdae.g.  f ps | wps&Agda(rewrite e | with p <- e in eq) (many)&Agdawith e1 in eq | {e2} | ... (many)&AgdaA 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 optional'Agda p C e where cs'Agda9Concrete patterns. No literals in patterns at the moment.'Agdac or x'Agda quote'Agdap p' or  p {x = p'}'Agdap1..pn before parsing operators'Agdaeg: p => p' for operator _=>_ The  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 unused'Agda .e'Agda0, 1, etc.'Agda record {x = p; y = q}'Agdai = i1$ i.e. cubical face lattice generator'Agda...., only as left-most pattern. Second arg is Nothing before expansion, and Just p after expanding ellipsis to p.'Agda| p, for with-patterns.'AgdaConcrete expressions. Should represent exactly what the user wrote.'Agdaex: x'Agdaex: 1 or "foo"'Agdaex: ? or  {! ... !}'Agdaex: _ or _A_5'Agdabefore parsing operators'Agdaex: e e, e {e}, or  e {x = e}'Agdaex: e + e The  is possibly ambiguous, but it must correspond to one of the names in the set.'Agdaex: e | e1 | .. | en'Agdaex: {e} or {x=e}'Agdaex: {{e}} or {{x=e}}'Agdaex:  \x {y} -> e or \(x:A){y:B} -> e'Agdaex: \ ()'Agdaex: .\ { p11 .. p1a -> e1 ; .. ; pn1 .. pnz -> en }'Agdaex: e -> e or .e -> e (NYI: {e} -> e)'Agdaex:  (xs:e) -> e or  {xs:e} -> e'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 let'Agdaex: (e)'Agdaex: (| e1 | e2 | .. | en |) or (|)'Agdaex: do x <- m1; m2'Agdaex: () or {}, only in patterns'Agdaex: x@p, only in patterns'Agdaex: .p, only in patterns'Agdaex: ..A, used for parsing ..A -> B'Agda!only used for printing telescopes'Agdaex: quote, should be applied to a name'Agdaex:  quoteTerm, should be applied to a term'Agdaex:  @(tactic t)", used to declare tactic arguments'Agdaex: unquote&, should be applied to a term of type Term'Agdato print irrelevant things'Agdaex: a = b, used internally in the parser'Agda...$, used internally to parse patterns.'AgdaAn abstraction inside a special syntax declaration (see Issue 358 why we introduce this).'Agda-Drop type annotations and lets from bindings.'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'AgdaSmart constructor for Lam: check for non-zero bindings.'AgdaSmart constructor for Let": check for non-zero let bindings.'AgdaSmart constructor for TLet": check for non-zero let bindings.'AgdaExtract a record directive'Agda#Computes the top-level module name.Precondition: The % has to be well-formed. This means that there are only allowed declarations before the first module declaration, typically import declarations. See '.'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 expression'Agda-Observe the relevance status of an expression'Agda2Observe various modifiers applied to an expression'AgdaTurn an expression into a pattern. Fails if the expression is not a valid pattern.'AgdaTurn an expression into a pattern, turning non-pattern subexpressions into '.'AgdaA & is  when the where 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.%%%%%%%%%%%%%%%%%%&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''%%'''''''''''&&&&&''&&&&'&&&&''''''''''''''&&&&&''&&&'''''&&&&&'&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&''''''''''''''''''&&&&&&&&&&&&&&'''&&&&&&&&&&&&&&&&&'''%%%%%%%%&&&&&&&&&&&&%%%%%%%%''jNone! #$%-02356789>?:(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.*(((((((((((((())))))(((((((((((((())))))kNone! #$%-02356789>?- )Agda| for root of split tree)AgdaTag 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.)AgdaNo more splits coming. We are at a single, all-variable clause.)AgdaA split is necessary.)Agda+The number of variables bound in the clause)AgdaArg. no to split at.)AgdaSub split trees.)AgdaConvert a split tree into a  (for printing).))))))))))))))))))))))))))))))))))))))))))))))))))lNone! #$%-02356789>?} )Agda-Sections, as well as non-sectioned operators.)Agda>For non-sectioned operators this should match the notation's *.)AgdaEffective precedence level. | for closed notations.)Agda| for non-sectioned operators.)Agda/All the notation information related to a name.)Agda-The names the syntax and/or fixity belong to.Invariant: The set is non-empty. Every name in the list matches ).)Agda3Associativity and precedence (fixity) of the names.*Agda!Syntax associated with the names.*AgdaTrue 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.*AgdaTarget argument position of a part (Nothing if it is not a hole).*AgdaIs 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?ӊ(*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 *.*Agda Subphase for *.*Agda Subphase for *.*Agda Subphase for *.*Agda Subphase for *.*Agda Subphase for *.*Agda Subphase for *: compacting interfaces.*Agda Subphase for *.*Agda Subphase for *.*Agda Subphase for *.*Agda 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 signature*Agda Subphase for *: generalizing over variables*Agda Subphase for *: solving instance goals*Agda Subphase for *: unification of the indices*AgdaPretty printing names.*Agda.Global variable to store benchmark statistics.*Agda=Benchmark an IO computation and bill it to the given account.*Agda>Benchmark a pure computation and bill it to the given account./***********************************************/***********************************************nNone! #$%-02356789>?ބ*AgdaGeneric pattern traversal.See .*Agda Fold pattern.*AgdaCombine a pattern and the value computed from its subpatterns.*Agda;Combine a pattern and the its recursively computed version.*Agdapre : Modification before recursion.Agdapost: Modification after recursion.*Agdapre : Modification before recursion.*Agdapost: Modification after recursion.!********************************+!********************************+oNone$ #$%'(-/02356789>? +AgdaA singleton type for * (except for the constructor *).+Agda"Used to define the return type of +.+AgdaShould sections be parsed?+AgdaThe  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 record the tokens' original positions within their respective identifiers.+Agda)Parse a specific identifier as a NamePart+AgdaParses 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 binder+Agda0Parse the "operator part" of the given notation.Normal holes (but not binders) at the beginning and end are ignored.If the notation does not contain any binders, then a section notation is allowed."++++++++++++++++++++++++++++++++++"++++++++++++++++++++++++++++++++++pNone! #$%-02356789>?U+Agda,Generic traversals for concrete expressions. Note: does not go into patterns!+AgdaThis corresponds to }.+AgdaThis corresponds to }.+AgdaThis corresponds to }.++++++++qNone" #$%-02356789>?+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. +++++++++++++ +++++++++++++rNone! #$%-02356789>?+Agda$The kind of the forward declaration.+AgdaName of a data type+AgdaName of a record type+AgdaName of a function.+Agdawe are nicifying a mutual block+Agda,we are nicifying decls not in a mutual block+AgdaSeveral declarations expect only type signatures as sub-declarations. These are:+Agda  postulate+Agda primitive. Ensured by parser.+Agdainstance. Actually, here all kinds of sub-declarations are allowed a priori.+Agdafield. Ensured by parser.+Agdadata ... where=. Here we got a bad error message for Agda-2.5 (Issue 1698).+Agda constructor, in interleaved mutual.,AgdaIn an `interleaved mutual' block we collect the data signatures, function signatures, as well as their associated constructors and function clauses respectively. Each signature is given a position in the block (from 0 onwards) and each set of constructor / clauses is given a *distinct* one. This allows for interleaved forward declarations similar to what one gets in a new-style mutual block.,AgdaIn an inferred mutual block we keep accumulating nice declarations until all of the lone signatures have an attached definition. The type is therefore a bit span-like: we return an initial segment (the inferred mutual block) together with leftovers.,AgdaWhen processing a mutual block we collect the various checks present in the block before combining them.,AgdaOne 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 instance modifiers have been distributed to the individual declarations. Observe the order of components:Range 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 & is the actual &.,AgdaBlock of function clauses (we have seen the type signature before). The &s 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 (Maybe Range) gives range of the  'pattern' declaration.+++++++++++++++++++,,,+,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,+++,,,+,,,+++++++,+++++++++,,,,,,,sNone! #$%-02356789>?!,Agda-Non-fatal errors encountered in the Nicifier.,AgdaEmpty abstract block.,AgdaEmpty  constructor block.,AgdaEmpty field block.,AgdaEmpty variable block.,AgdaEmpty instance block,AgdaEmpty macro block.,AgdaEmpty mutual block.,AgdaEmpty  postulate block.,AgdaEmpty private block.,AgdaEmpty  primitive block.,AgdaA {-# CATCHALL #-} pragma that does not precede a function clause.,Agda)Invalid definition in a constructor block,AgdaInvalid constructor block (not inside an interleaved mutual block),AgdaA {-# NON_COVERING #-} pragma that does not apply to any function.,AgdaA {-# NO_POSITIVITY_CHECK #-} pragma that does not apply to any data or record type.,AgdaA {-# NO_UNIVERSE_CHECK #-} pragma that does not apply to a data or record type.,Agda?A record directive outside of a record / below existing fields.,AgdaA {-# 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 mode,Agdaabstract6 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.,AgdaIn a mutual block, a clause could belong to any of the D2 type signatures ().,AgdaIn an interleaved mutual block, a constructor could belong to any of the data signatures (),AgdaIn a mutual block, all or none need a MEASURE pragma. Range is of mutual block.-Agda-Exception with internal source code callstack-Agda(Nicifier warnings turned into errors in --safe mode.;,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,--------;----,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,----tNone! #$%-02356789>?5-AgdaIf !, this name can have a different  than the key of - pointing to it.-AgdaNicifier state.-Agda4Lone type signatures that wait for their definition.-Agda5Termination checking pragma waiting for a definition.-Agda4Positivity checking pragma waiting for a definition.-AgdaUniverse checking pragma waiting for a data/rec signature or definition.-Agda.Catchall pragma waiting for a function clause.-Agda)Coverage pragma waiting for a definition.-Agda(Stack of warnings. Head is last warning.-AgdaWe distinguish different &s (anonymous definitions) by a unique .-AgdaNicifier monad. Preserve the state when throwing an exception.-AgdaRun a Nicifier computation, return result and warnings (in chronological order).-AgdaInitial nicifier state.-AgdaLens for field -.-AgdaAdding a lone signature to the state. Return the name (which is made unique if ).-Agda'Remove a lone signature from the state.-Agda"Search for forward type signature.-Agda4Check that no lone signatures are left in the state.-AgdaEnsure that all forward declarations have been given a definition.-Agda?Get names of lone function signatures, plus their unique names.-Agda Create a - map from an association list.-AgdaLens for field -.-AgdaLens for field -.-AgdaLens for field -.-AgdaGet universe check pragma from a data/rec signature. Defaults to .-AgdaLens for field -.-Agda>Get current catchall pragma, and reset it for the next clause.-AgdaAdd a new warning.-Agda(Stack of warnings. Head is last warning.-AgdaWe 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  replaceSigs, which might replace the wrong signature.Another reason is that we want to distinguish different occurrences of ) in a mutual block (issue #4157). The $ in the codomain will have a unique .1-------------------------------------------------1-------------------------------------------------uNone! #$%-02356789>? U-Agda(Conjunctive constraint.)-AgdaAn attribute is a modifier for .-AgdaModifiers 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.-AgdaSetting some attributes in left-to-right order. Blindly overwrites previous settings.-AgdaSetting  if unset.-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.--------------------------------------------------------vNone" #$%-02356789>? -Agda;Result of comparing a candidate with the current favorites.-AgdaGreat, 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.-Agda.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.We 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 } under  and 'union..AgdaEquality checking is a bit expensive, since we need to sort! Maybe use a Set! of favorites in the first place?-------------------------------- None! #$%-02356789>? .Agda,A finite map, represented as a set of pairs.%Invariant: at most one value per key..AgdaLookup 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 == (Q m)..Agda9O(n). Get the domain (list of keys) of the finite map..AgdaO(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..AgdaO(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?@9.AgdaSet the  in an abstract name..AgdaUsed for instance arguments to check whether a name is in scope, but we do not care whether is is ambiguous.Agda9Ambiguous 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..AgdaRecord 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 S..AgdaThe resolved qualified name..Agda6The kind (definition, constructor, record field etc.)..Agda&Explanation where this name came from..AgdaAdditional 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 ..AgdaDefined in this module..AgdaImported from another module..Agda!Imported by a module application..AgdaDecorate something with ..Agda A set of ., for the sake of /..AgdaOnly these kinds..AgdaAll but these Kinds..AgdaFor the sake of parsing left-hand sides, we distinguish constructor and record field names from defined names..AgdaConstructor name ( or don't know)..AgdaConstructor name (definitely )..AgdaRecord field name..AgdaName of a pattern synonym..AgdaName to be generalized.Agda&Generalizable variable from a let open.AgdaName of a macro.Agda3A name that can only be quoted. Previous category DefName: (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..AgdaAll abstract names targeted by a concrete name in scope. Computed by /..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, ...)..AgdaIf this list is not empty, the local variable is shadowed by one or more imports..AgdaFor 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 ... in.Agda  | ... in q.AgdaLocal variables..Agda"For the sake of highlighting, the . map also stores the . of an A.QName..AgdaThe ...Agda)Possible renderings of the abstract name..AgdaThe complete information about the scope at a particular program point includes the scope stack, the local variables, and the context precedence..AgdaThe variables that will be bound at the end of the current block of variables (i.e. clause). We collect them here instead of binding them immediately so we can avoid shadowing between variables in the same variable block..Agda&Maps concrete names C.Name to fixities.Agda(Maps concrete names C.Name to polarities.AgdaSee ..Agda#Things not exported by this module..Agda+Things defined and exported by this module..Agda1Things from open public, exported by this module..AgdaA 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 parameter/Agda*Project name of unshadowed local variable./Agda%Get all locals that are not shadowed  by imports./AgdaLenses for ScopeInfo components/Agda Lens for /./Agda Lens for /./Agda inNameSpace> selects either the name map or the module name map from a .. What is selected is determined by result type (using the dependent-type trickery)./Agda?For ambiguous constructors, we might have both alternatives of !. In this case, we default to ../Agda?For ambiguous constructors, we might have both alternatives of !. In this case, we default to ./Agda Only return  [Co]ConName if no ambiguity./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 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.)/Agda Version of / 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./Agda%Rename the abstract names in a scope./Agda%Remove private name space of a scope.Should be a right identity for /. >exportedNamesInScope . restrictPrivate == exportedNamesInScope./Agda9Remove private things from the given module from a scope./AgdaFilter privates out of a ./Agda3Disallow using generalized variables from the scope/Agda.Add an explanation to why things are in scope./Agda5Get the public parts of the public modules of a scope/AgdaCompute a flattened scope. Only include unqualified names or names qualified by modules in the first argument./Agda:Get all concrete names in scope. Includes bound variables./AgdaLook up a name in the scope/AgdaFind the concrete names that map (uniquely) to a given abstract qualified name. Sort by number of modules in the qualified name, unqualified names first./Agda A version of / that also delivers the .. Used in highlighting./AgdaFind the concrete names that map (uniquely) to a given abstract module name. Sort by length, shortest first./Agda+Add first string only if list is non-empty./AgdaInvariant: the . components should be equal whenever we have to concrete renderings of an abstract name./AgdaWe show shadowed variables as prefixed by a ".", as not in scope.0Agda/Sets the binding site of all names in the path./Agda4Merged scope, clashing names, clashing module names..................................................................................................................///////////////////////////////////////////////////////////////////////////////////////////////////////.//////......././////.............................///////////////////............../..................///////....////.....................//.........///////////////////////////////.../////////////////....////////..//xNone! #$%-02356789>?G0Agda:Has the constructor pattern a dotted (forced) constructor?0AgdaDotted constructor.0AgdaOrdinary constructor.0AgdaConstructor pattern info.0AgdaDoes this pattern come form the eta-expansion of an implicit pattern?0Agda;For a general pattern we remember the source code position.1AgdaThe range of the "as" and "to" keywords, if any. Retained for highlighting purposes.1AgdaThe "as" module name, if any. Retained for highlighting purposes.1Agda Retained for abstractToConcrete of &.1AgdaInformation about application1Agda6Do we prefer a lambda argument with or without parens?1Agda-Default is system inserted and prefer parens.1Agda1 with no range information.1AgdaSame as  mkDefInfo but where we can also give the  IsInstance1AgdaEmpty range for patterns.1AgdaDefault value for 0.>00000000000000000000000000000000000111111111111111111111111111>11111111111111111111111100000000000110000000000000000100000000yNone! #$%-02356789>?Y01Agda#Conversion between different types.1AgdaA type that is intended to be used when constructing highlighting information.>Note the invariant which values of this type should satisfy (2).This is a type synonym in order to make it easy to change to another representation."The type should be an instance of " 2,  and }&, and there should be an instance of 1 1 2.2AgdaHighlighting information.>Note the invariant which values of this type should satisfy (2).This is a type synonym in order to make it easy to change to another representation.2Agda'Highlighting info with delayed merging.Merging large sets of highlighting info repeatedly might be costly. The idea of this type is to accumulate small pieces of highlighting information, and then to merge them all at the end.>Note the invariant which values of this type should satisfy (2).2AgdaSyntax highlighting information, represented by maps from positions to 2.,The first position in the file has number 1.2AgdaA limited kind of syntax highlighting information: a pair consisting of " and 2.Note the invariant which 2s should satisfy (2).2AgdaIs the highlighting "token-based", i.e. based only on information from the lexer?2AgdaThe defining module.2AgdaThe file position in that module. File positions are counted from 1.2Agda Has this DefinitionSite/ been created at the defining site of the name?2Agda#A pretty name for the HTML linking.2AgdaMeta information which can be associated with a character/character range.2AgdaThis note, if not null, 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).2AgdaThe definition site of the annotated thing, if applicable and known.2AgdaIs this entry token-based?2AgdaOther aspects, generated by type checking. (These can overlap with each other and with 2s.)2Agda.A warning that is considered fatal in the end.2AgdaUnsolved constraint not connected to meta-variable. This could for instance be an emptyness constraint.2AgdaUsed for highlighting unreachable clauses, unreachable RHS (because of an absurd pattern), etc.2Agda8Used for shadowed repeated variable names in telescopes.2AgdaWhen this constructor is used it is probably a good idea to include a 2* explaining why the pattern is incomplete.2Agda!Code which is being type-checked.2AgdaFunction declaration without matching definition NB: We put CatchallClause last so that it is overwritten by other, more important, aspects in the emacs mode.2AgdaNameKind(s are figured out during scope checking.2AgdaBound variable.2AgdaGeneralizable variable. (This includes generalizable variables that have been generalized).2Agda%Inductive or coinductive constructor.2Agda Record field.2Agda Module name.2Agda Primitive.2Agda Record type.2Agda!Named argument, like x in {x = v}2AgdaMacro.2Agda6Syntactic aspects of the code. (These cannot overlap.)2Agda Symbols like forall, =, ->, etc.2AgdaThings like Set and Prop.2AgdaIs the name an operator part?2AgdaText occurring in pragmas that does not have a more specific aspect.2Agda"Non-code contents in literate Agda2AgdaDelimiters used to separate the Agda code blocks from the other contents in literate Agda2AgdaInvariant for 2.2AgdaInvariant for 2 hl%, parametrised by the invariant for hl.?Additionally the endofunction should be extensionally equal to (fs }) for some list fs.2AgdaThe invariant for 2.2AgdaThe invariant for 1.?Additionally the endofunction should be extensionally equal to (fs }) for some list fs.2Agda A variant of } with 2 set to 2.2Agda4Conversion from classification of the scope checker.2AgdaSome 2#s are more informative than others.2AgdaNameKind in Name can get more precise.""""""""1112222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222221222""""""11""{None! #$%-02356789>?m3Agda3 m extracts the diagonal of m.For non-square matrices, the length of the diagonal is the minimum of the dimensions of the matrix.3Agda6Type of matrices, parameterised on the type of values.Sparse matrices are implemented as an ordered association list, mapping coordinates to values.3AgdaDimensions of the matrix.3Agda!Association of indices to values.3Agda%Type of matrix indices (row, column).3Agda Row index, 1 <= row <= rows.3Agda Column index 1 <= col <= cols.3AgdaSize of a matrix.3AgdaNumber of rows, >= 0.3AgdaNumber of columns, >= 0.3Agda| iff the matrix is square.3AgdaReturns | iff the matrix is empty.3Agda5Compute the matrix size of the union of two matrices.3Agda#Constructs a matrix from a list of (index, value) -pairs. O(n) where n is size of the list.!Precondition: indices are unique.3Agda3 sz rs constructs a matrix from a list of lists of values (a list of rows). O(size) where size = rows  cols.Precondition: } rs | 3 sz and } ((3 sz |) . }) rs.3Agda6Converts 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.3Agda-Converts a matrix to a list of row lists. O(size) where size = rows  cols.3Agda (i,)  $ f a), and same for gs and g.3Agda?General pointwise combination function for sparse matrices.  O(n1 + n2).3Agda3 (+) m1 m2 adds m1 and m2, using (+) to add values.  O(n1 + n2).Returns a matrix of size 3 m1 m2.3Agda3 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.3Agda"Association list intersection.  O(n1 + n2). interAssocWith f l l' = { (i, f a b) | (i,a) D l and (i,b) D l' }Used to combine sparse matrices, it might introduce zero elements if f( can return zero for non-zero arguments.3Agda3 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) 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.3Agda3 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.3Agda3 x m adds a new row to m, after the rows already existing in the matrix. All elements in the new row get set to x.3AgdaPointwise comparison. Only matrices with the same dimension are comparable.3AgdaDiagonal of sparse matrix.O(n) where n2 is the number of non-zero elements in the matrix.3AgdaMatrix transposition. O(n log n) where n2 is the number of non-zero elements in the matrix.3AgdaTransposing coordinates.3AgdaSize of transposed matrix.3AgdaOnly 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.3Agda$Element only present in left matrix.Agda%Element only present in right matrix.Agda!Element present in both matrices.AgdaResult counts as zero?33333333333333333333333333333333333333333333333333333333333333|None" #$%-02356789>?{3AgdaA partial order, aimed at deciding whether a call graph gets worse during the completion.3Agda:In the paper referred to above, there is an order R with 3 } Le } Lt.This is generalized to 3 } '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.3Agda2Decrease 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.3AgdaNo relation, infinite increase, or increase beyond termination depth.3Agda&Matrix-shaped order, currently UNUSED.3Agda$Raw increase which does not cut off.3Agda$Raw decrease which does not cut off.3AgdaSmart constructor for Decr k :: Order which cuts off too big values.Possible values for k:  - ?cutoff } k } ?cutoff + 1.3AgdaSmart constructor for matrix shaped orders, avoiding empty and singleton matrices.3Agdale, lt,  decreasing, unknown4: for backwards compatibility, and for external use.3AgdaUsable decrease.3AgdaDecreasing and usable?3AgdaMatrix-shaped order is decreasing if any diagonal element is decreasing.3AgdaMultiplication of 3.s. (Corresponds to sequential composition.)3Agda+The supremum of a (possibly empty) list of 3;s. More information (i.e., more decrease) is bigger. 3# is no information, thus, smallest.3Agda%The infimum of a (non empty) list of 3$s. Gets the worst information. 3& is the least element, thus, dominant.3AgdaWe use a record for semiring instead of a type class since implicit arguments cannot occur in instance constraints, like +instance (?cutoff :: Int) => SemiRing Order.3AgdaInformation order: 3 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).3Agda/We assume the matrices have the same dimension.3AgdaIt does not get worse then ` increase'. If we are still decreasing, it can get worse: less decreasing.3333333333333333333333333333333333333333333333}None# #$%-02356789>?3AgdaSets of incomparable call matrices augmented with path information. Use overloaded , , , }.3Agda,Call matrix augmented with path information.3Agda"The matrix of the (composed call).3AgdaMeta info, like call path.3Agda0Call matrix multiplication and call combination.3AgdaCall 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.In 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 source 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:3 (less than) if the j-th argument to the target; function is structurally strictly smaller than the i-th pattern.3 (less than or equal) if the j-th argument to the target+ function is structurally smaller than the i-th pattern.3 otherwise.3Agda0Call matrix indices = function argument indices.Machine integer | is sufficient, since we cannot index more arguments than we have addresses on our machine.3AgdaNon-augmented call matrix.3AgdaInsert into a call matrix set.3AgdaUnion two call matrix sets.3Agda/Convert into a list of augmented call matrices.3AgdaCall matrix multiplication.f --(m1)--> g --(m2)--> h is combined to f --(m2 3 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).3Agda%Augmented call matrix multiplication.3Agda1Call matrix set product is the Cartesian product.333333333333333333333333333333333333~None# #$%-02356789>? 4AgdaA call graph is a set of calls. Every call also has some associated meta information, which should be }al so that the meta information for different calls can be combined when the calls are combined.4AgdaCalls are edges in the call graph. It can be labelled with several call matrices if there are several pathes from one function to another.4AgdaCall graph nodes.Machine integer | is sufficient, since we cannot index more than we have addresses on our machine.4Agda!Make a call with a single matrix.4AgdaMake a call with empty cinfo.4AgdaReturns all the nodes with incoming edges. Somewhat expensive. O(e).4AgdaConverts a call graph to a list of calls with associated meta information.4Agda#Takes the union of two call graphs.4Agda!Inserts a call into a call graph.4Agda"Call graph comparison. A graph cs' is `worse' than cs 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.4 cs completes the call graph cs. 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.4Agda?Displays the recursion behaviour corresponding to a call graph.4Agda4 is a monoid under 4.4Agda: checks whether the call graph is completely disconnected.##3444444444444444444##43444444444None" #$%-02356789>?\4Agda2TODO: This comment seems to be partly out of date.4 cs( checks if the functions represented by cs terminate. The call graph cs should have one entry (4&) per recursive function application.| perms: is returned if the functions are size-change terminating.,If termination can not be established, then | problems is returned instead. Here problems contains an indication of why termination cannot be established. See lexOrder for further details.Note 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).4AgdaA call c! is idempotent if it is an endo (# == #) of order 1. (Endo-calls of higher orders are e.g. argument permutations). We can test idempotency by self-composition. Self-composition c >*< c: should not make any parameter-argument relation worse.44444444None! #$%-02356789>?4AgdaSometimes 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.4AgdaIn the lexer, regular expressions are associated with lex actions who's task it is to construct the tokens.4Agda#This is what the lexer manipulates.4AgdaFile.4AgdaCurrent position.4AgdaCurrent input.4AgdaPreviously read character.4Agda A lens for 4.4Agda,Get the previously lexed character. Same as 4. Alex needs this to be defined to handle "patterns with a left-context".4Agda,Returns the next character, and updates the 4 value.This function is not suitable for use by Alex 2, because it can return non-ASCII characters.4Agda'Returns the next byte, and updates the 4 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:Whitespace 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'.Note that it is important that there are no keywords containing 'z', '+', ' ' or '\1'.*This function is used by Alex (version 3).4AgdaConjunction of 4s.4AgdaDisjunction of 4s.4Agda Negation of 4s.44444444444444444444444444444444444444444444None! #$%-02356789>? 4AgdaThe LookAhead monad is basically a state monad keeping with an extra 4, wrapped around the ! monad.4Agda8Throw an error message according to the supplied method.4Agda$Get the current look-ahead position.4AgdaSet the look-ahead position.4AgdaLift a computation in the ! monad to the 4 monad.4AgdaLook at the next character. Fails if there are no more characters.4AgdaConsume all the characters up to the current look-ahead position.4Agda-Undo look-ahead. Restores the input from the !.4Agda!Consume the next character. Does 4 followed by 4.4AgdaDo 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.4AgdaSame as 4 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.4AgdaRun a 47 computation. The first argument is the error function. 444444444444 444444444444None! #$%-02356789>?Z4AgdaLex a string literal. Assumes that a double quote has been lexed.4AgdaLex 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.4444None! #$%-02356789>?4Agda Should comment tokens be output?4Agda Should comment tokens be output?4Agda,Manually lexing a block comment. Assumes an  open comment< has been lexed. In the end the comment is discarded and 4" is called to lex a real token.4Agda Lex a hole ( {! ... !}#). Holes can be nested. Returns  .4AgdaSkip 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.4444444444None# #$%-02356789>?4AgdaThis is the initial state for parsing a regular, non-literate file.4Agda8The layout state. Entered when we see a layout keyword (4$) and exited at the next token (4).4AgdaWe enter this state from 4 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 data 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 4 is executed, generating the closing brace. The open brace is generated when entering by 4.4AgdaThis 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 4.4AgdaThis 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.4AgdaReturn the next token. This is the function used by Happy in the parser.  lexer k = 4 >>= k4Agda3This is the main lexing function generated by Alex. 4444444444444 4444444444444None$ #$%-02356789>?4Agda1Parse the token stream. Used by the TeX compiler.5Agda3Parse an expression. Could be used in interactions.5AgdaParse an expression followed by a where clause. Could be used in interactions.5AgdaParse a module.5AgdaBreaks up a string into substrings. Returns every maximal subsequence of zero or more characters distinct from |. splitOnDots "" == [""] splitOnDots "foo.bar" == ["foo", "bar"] splitOnDots ".foo.bar" == ["", "foo", "bar"] splitOnDots "foo.bar." == ["foo", "bar", ""] splitOnDots "foo..bar" == ["foo", "", "bar"]45555555555455}9 }9 None! #$%-02356789>?4Agda?4AgdaAt a new line, we confirm either existing tentative layout columns, or, if the last token was a layout keyword, the expected new layout column.4Agda&This action is only executed from the 4/ state. It will exit this state, enter the 4 state, and return a virtual close brace (closing the empty layout block started by 4).4Agda? 5AgdaWrapped Parser type.5Agda/A monad for handling parse errors and warnings.5AgdaRun a 5 computation, returning a list of warnings in first-to-last order and either a parse error or the parsed thing.5Agda'Returns the contents of the given file.5AgdaParse without top-level layout.5AgdaExtensions supported by 5.5AgdaParses a module.5AgdaParses a module name.5AgdaParses an expression.5Agda0Parses an expression followed by a where clause.5AgdaParses an expression or some other content of an interaction hole.5Agda3Gives the parsed token stream (including comments).5AgdaThe path to the file.Agda)The file contents. Note that the file is not read from disk.# 5555555555555555#555555555555 5555None! #$%-02356789>?1 5Agda5Eliminations, subsuming applications and projections.5Agda Application.5Agda Projection.  is name of a record projection.5Agda'IApply x y r, x and y are the endpoints5AgdaDrop 5 constructor. (Safe)5AgdaDrop 5 constructors. (Safe)5AgdaSplit at first non-55Agda Discards Proj f entries.5AgdaDrop 5 constructors. (Safe)5AgdaThis instance cheats on 5, use with care. 5s are always assumed to be , since they have no . Same for IApply 555555555555 555555555555None! #$%-02356789>?ͬ 5AgdaShould a constraint wake up or not? If not, we might refine the unblocker.5AgdaSomething where a meta variable may block reduction. Notably a top-level meta is considered blocking. This did not use to be the case (pre Aug 2020).5AgdaWhat is causing the blocking? Or in other words which metas or problems need to be solved to unblock the blocked computation/constraint.5AgdaUnblock if meta is instantiated5AgdaEven if we are not stuck on a meta during reduction we can fail to reduce a definition by pattern matching for another reason.5AgdaThe Elim' is neutral and blocks a pattern match.5Agda?6AgdaThe 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.6Agda2Suggest a name if available (i.e. name is not "_")6Agda#Constructing a singleton telescope.6Agda Drop the types from a telescope.6AgdaTelescope as list.6AgdaView type as path type.6Agdareduced6AgdaSort of this type.6Agda Builtin PATH.6AgdaHidden6AgdaHidden6Agda NotHidden6Agda NotHidden6AgdaView type as equality type.6Agdareduced6Agdareduced6AgdaSort of this type.6AgdaBuiltin EQUALITY.6AgdaHidden. Empty or Level.6AgdaHidden6Agda NotHidden6Agda NotHidden6AgdaSubstitutions.6AgdaIdentity substitution.   E IdS : 6AgdaEmpty substitution, lifts from the empty context. First argument is  IMPOSSIBLE. Apply this to closed terms you want to use in a non-empty context.  E EmptyS : ()6AgdaSubstitution extension, `cons'.   E u : A  E  :  ----------------------  E u :#  : , A 6Agda/Strengthening substitution. First argument is  IMPOSSIBLE. Apply this to a term which does not contain variable 0 to lower all de Bruijn indices by one.   E  :  ---------------------------  E Strengthen  : , A 6Agda9Weakening substitution, lifts to an extended context.   E  :  ------------------- ,  E Wk ||  :  6Agda9Lifting substitution. Use this to go under a binder. Lift 1  == var 0 :# Wk 1 .   E  :  ------------------------- ,  E Lift ||  : ,  6Agda7Extract pattern variables in left-to-right order. A 6+ is also treated as variable (see docu for 6).6AgdaThe ConPatternInfo= states whether the constructor belongs to a record type (True) or data type (False). In the former case, the  PatOrigin of the conPInfo 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 (6).6Agda)Information on the origin of the pattern.6AgdaFalse if data constructor. True if record constructor.6AgdaShould the match block on non-canonical terms or can it proceed to the catch-all clause?6AgdaThe 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.6AgdaLazy patterns are generated by the forcing translation in the unifier () and are dropped by the clause compiler (TODO: not yet) () when the variables they bind are unused. The GHC backend compiles lazy matches to lazy patterns in Haskell (TODO: not yet).6Agda+Type used when numbering pattern variables.6Agda7Patterns 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.6Agda x6Agda .t6Agdac ps= The subpatterns do not contain any projection copatterns.6AgdaE.g. 5, "hello".6Agda1Projection copattern. Can only appear by itself.6AgdaPath elimination pattern, like VarP but keeps track of endpoints.6Agda:Used for HITs, the QName should be the one from primHComp.6AgdaOrigin of the pattern: what did the user write in this position?6AgdaPattern inserted by the system6AgdaPattern generated by case split6AgdaUser wrote a variable pattern6AgdaUser wrote a dot pattern6AgdaUser wrote a wildcard pattern6Agda User wrote a constructor pattern6AgdaUser wrote a record pattern6AgdaUser wrote a literal pattern6AgdaUser wrote an absurd pattern6AgdaPattern variables.6Agda3A 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. A level is a maximum expression of a closed level and 0..n 64 expressions each of which is an atom plus a number.6AgdaSorts.6AgdaSet B.6AgdaProp B.6AgdaSet:.6AgdaSSet B.6AgdaSizeUniv, a sort inhabited by type Size.6AgdaLockUniv, a sort for locks.6AgdaSort of the pi type.6Agda(Sort of a (non-dependent) function type.6AgdaSort of another sort.6AgdaA postulated sort.7AgdaA (part of a) term or type which is only used for internal purposes. Replaces the abuse of Prop for a dummy sort. The String typically describes the location where we create this dummy, but can contain other information as well.7AgdaSequence of types. An argument of the first type is bound in later types and so on.7Agda7 is never 7.7Agda'Types are terms with a sort annotation.7AgdaBinder.72: The bound variable might appear in the body. 7 is pseudo-binder, it does not introduce a fresh variable, similar to the const of Haskell.7Agda6The body has (at least) one free variable. Danger: 7! doesn't shift variables properly7Agda 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.7Agdax es neutral7Agda+Terms are beta normal. Relevance is ignored7Agdaf es, possibly a delta/iota-redex7Agdac es or record { fs = es } es allows only Apply and IApply eliminations, and IApply only for data constructors.7Agda)dependent or non-dependent function space7AgdaIrrelevant stuff in relevant position, but created in an irrelevant context. Basically, an internal version of the irrelevance axiom .irrAx : .A -> A.7AgdaA (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.7AgdaStore the names of the record fields in the constructor. This allows reduction of projection redexes outside of TCM. For instance, during substitution and application.7AgdaThe name of the constructor.7AgdaData or record constructor?7Agda'Record constructors can be coinductive.7Agda"The name of the record fields.  is stored since the info in the constructor args might not be accurate because of subtyping (issue #2170).7AgdaType of argument lists.7Agda 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 7 of internal syntax, in Context and 7.  is used for actual arguments (7, 7, 7 etc.) and in Abstract syntax and other situations.  cubical When domFinite = True for the domain of a 7 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.7Agdae.g. x in {x = y : A} -> B.7Agda "@tactic e".7AgdaConstant level n7Agda6Make an absurd pattern with the given de Bruijn index.7AgdaBuild partial 6 from 77AgdaBuild 7 from 6.7Agda'Retrieve the PatternInfo from a pattern7Agda Retrieve the origin of a pattern7Agda1Does the pattern perform a match that could fail?7AgdaAbsurd lambdas are internally represented as identity with variable name "()".7AgdaAn unapplied variable.7AgdaAdd 7 is it is not already a DontCare.7AgdaConstruct a string representing the call-site that created the dummy thing.7Agda,Aux: A dummy term to constitute a dummy termlevel sort/type.7AgdaA dummy level to constitute a level/sort created at location. Note: use macro  DUMMY_LEVEL !7Agda5A dummy term created at location. Note: use macro  DUMMY_TERM !7Agda5A dummy sort created at location. Note: use macro  DUMMY_SORT !7Agda5A dummy type created at location. Note: use macro  DUMMY_TYPE !7AgdaContext entries without a type have this dummy type. Note: use macro  DUMMY_DOM !7AgdaGiven a constant m and level l , compute m + l7Agda)A traversal for the names in a telescope.7Agda(Convert a list telescope to a telescope.7Agda%Convert a telescope to its list form.7AgdaLens to edit a 7 as a list.7AgdaRemoving a topmost 7 constructor.7AgdaDoesn't do any reduction.7Agda>Convert top-level postfix projections into prefix projections.8AgdaConvert 5/ projection eliminations according to their  into 7 projection applications.8Agda#A view distinguishing the neutrals Var, Def, and MetaV which can be projected.8AgdaIgnores  and  and tactic.8Agda2The size of a telescope is its length (as a list).8AgdaA  clause is one with no patterns and no rhs. Should not exist in practice.6AgdaThe  PatVarName is a name suggestion.7Agda#eliminations ordered left-to-right.7Agda-Should absurd patterns count as proper match?Agda1Should projection patterns count as proper match?Agda The pattern.555555555555555555555555555555555555555555555555555555556666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666766666666666777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777788886666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666667666666666667777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777888864None! #$%-02356789>?|9AgdaThings we can substitute for a variable. Needs to be able to represent variables, e.g. for substituting under binders.9Agda+Produce a variable without name suggestion.9Agda(Produce a variable with name suggestion.9Agda=Are we dealing with a variable? If yes, what is its index?9AgdaWe can substitute Terms for variables.99999999None! #$%-02356789>?99999999None! #$%-02356789>?.9Agda&Gather free variables in a collection.9AgdaThe current context.9AgdaAdditional context, e.g., whether to ignore free variables in sorts.9AgdaAre we flexible or rigid?9Agda+What is the current relevance and quantity?9Agda#Method to return a single variable.9Agda5Where should we skip sorts in free variable analysis?9Agda Do not skip.9AgdaSkip when annotation to a type.9AgdaSkip unconditionally.9AgdaKeep track of 97 for every variable, but forget the involved meta vars.9AgdaRepresentation of a variable set as map from de Bruijn indices to 9.9AgdaAny 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 9.9AgdaLaws * 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.9AgdaOccurrence of free variables is classified by several dimensions. Currently, we have 9 and .9AgdaDepending on the surrounding context of a variable, it's occurrence can be classified as flexible or rigid, with finer distinctions.The constructors are listed in increasing order (wrt. information content).9Agda7In arguments of metas. The set of metas is used by ' 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.9Agda*In arguments to variables and definitions.9AgdaIn top position, or only under inductive record constructors (unit).9Agda3Under at least one and only inductive constructors.9Agda5A set of meta variables. Forms a monoid under union.:Agda9 aggregation (additive operation of the semiring). For combining occurrences of the same variable in subterms. This is a refinement of the | operation for 9 which would work if 9 did not have the 9* as an argument. Now, to aggregate two 9$ occurrences, we union the involved 9s.:Agda Unit for :.:AgdaAbsorptive for :.:Agda9 composition (multiplicative operation of the semiring). For accumulating the context of a variable.9 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.90 is next in strength. Destroys strong rigidity.9 is still dominant over 9.90 is the unit. It is the top (identity) context.:Agda Unit for :.:AgdaThe absorptive element of variable occurrence under aggregation: strongly rigid, relevant.:AgdaFirst argument is the outer occurrence (context) and second is the inner. This multiplicative operation is to modify an occurrence under a context.:AgdaIgnore free variables in sorts.:AgdaThe initial context.:AgdaRun function for FreeM.:AgdaBase case: a variable.:Agda3Subtract, but return Nothing if result is negative.:AgdaGoing under a binder.:Agda Going under n binders.:Agda Changing the .:Agda Changing the .:Agda Changing the 9 context.:Agda?&:AgdaCollect 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.: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.:AgdaCollect 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.:AgdaRigid 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) = (}= m) $ case VarOcc (Flexible ms) _ -> Just ms _ -> Nothing:Agda"Hereditary Semigroup instance for |. (The default instance for | may not be the hereditary one.):Agda"Hereditary Semigroup instance for |. (The default instance for | may not be the hereditary one.)3999999999999999999999999999::::::::::::::::::::::::3:::9999999:9::::::::::::::::9999999999:999999:::999None! #$%-02356789>?2l:Agda:! instance whose argument type is 7:Agda:& instance whose agument type is itself:AgdaSimple constraint alias for a : instance a with arg type t.:AgdaApply a substitution.:Agda(abstract args v) ; args --> v[args].:AgdaApply 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. weakening;AgdaReplace de Bruijn index i by a 7 in something.;AgdaReplace 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).  ,  E u : A --------------------------------- ,  E singletonS || u : , A,  ;AgdaSingle substitution without disturbing any deBruijn indices.  , A,  E u : A --------------------------------- , A,  E inplace || u : , A,  ;Agda$Lift a substitution under k binders.;Agda   E  : ,  -------------------  E dropS ||  :  ;Agda applySubst ( ;& ) v == applySubst  (applySubst  v);Agda   E  :   E reverse vs :  ----------------------------- (treating Nothing as having any type)  E prependS vs  : ,  ;Agda E (strengthenS E ||) : ,;AgdalookupS (listS [(x0,t0)..(xn,tn)]) xi = ti, assuming x0 < .. < xn.;Agda #, ,  E raiseFromS || || : , ;Agda/Instantiate an abstraction. Strict in the term.;AgdaInstantiate an abstraction. Lazy in the term, which allow it to be  IMPOSSIBLE 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. a 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 7s from b, performs operation k on a and the body of b, and puts the 7 s back. a is raised correctly according to the number of abstractions.,:::::::::;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;,:;;;;::::::::;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4None! #$%-02356789>?3p/;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;/;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;None! #$%-02356789>?>;Agda State [i] (f (Pattern' (i,x)));Agda+Arity of a function, computed from clauses.;AgdaTranslate the clause patterns to terms with free variables bound by the clause telescope.%Precondition: no projection patterns.;AgdaTranslate the clause patterns to an elimination spine with free variables bound by the clause telescope.;Agda5Augment pattern variables with their de Bruijn index.;AgdaComputes the permutation from the clause telescope to the pattern variables.Use as  fromMaybe  IMPOSSIBLE . dbPatPerm to crash in a controlled way if a de Bruijn index is out of scope here.The first argument controls whether dot patterns counts as variables or not.;AgdaComputes the permutation from the clause telescope to the pattern variables.Use as  fromMaybe  IMPOSSIBLE . clausePerm 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.;AgdaCompute from each subpattern a value and collect them all in a monoid.;AgdaTraverse pattern(s) with a modification before the recursive descent.;AgdaTraverse pattern(s) with a modification after the recursive descent.;Agda!Get the number of common initial 5 patterns in a list of clauses.;AgdaGet the number of initial 5 patterns in a clause.;AgdaGet the number of initial 5 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" #$%-02356789>?@<AgdaGeneric term traversal.Note: 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! #$%-02356789>?G;<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 < 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.<AgdaAbsurd case. Add the free variables here as well so we can build correct number of lambdas for strict backends. (#4280)<AgdaBranches in a case tree.<Agda3We are constructing a record here (copatterns). < lists projections.<AgdaMap from constructor (or projection) names to their arity and the case subtree. (Projections have arity 0.)<AgdaEta-expand with the given (eta record) constructor. If this is present, there should not be any conBranches or litBranches.<Agda!Map from literal to case subtree.<Agda'(Possibly additional) catch-all clause.<Agda?(if True) In case of non-canonical argument use catchAllBranch.<AgdaLazy pattern match. Requires single (non-copattern) branch with no lit branches and no catch-all.<AgdaCheck that the requirements on lazy matching (single inductive case) are met, and set lazy to False otherwise.<Agda1Check whether a case tree has a catch-all clause.<Agda5Check whether a case tree has any projection patterns<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<None! #$%-02356789>?J<AgdaReturns every meta-variable occurrence in the given type, except for those in sort annotations on types.<AgdaReturns < 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 < with a suitable monoid.<Agda| if thing contains no metas. noMetas = null . allMetasList.<Agda8Returns the first meta it find in the thing, if any. 'firstMeta == listToMaybe . allMetasList.<AgdaA blocker that unblocks if any of the metas in a term are solved.<AgdaA blocker that unblocks if any of the metas in a term are solved.<<<<<<<<<<<<<<<<None! #$%-02356789>?N<AgdaGetting the used definitions.Note: in contrast to  getDefs also collects from sorts in terms. Thus, this is not an instance of foldTerm.<Agda*What it takes to get the used definitions.=AgdaInputs to and outputs of getDefs' are organized as a monad.=AgdagetDefs' lookup emb a 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 emb can also choose to discard a used definition by mapping to the unit of the monoid. <<<<<====== ======<<<<<None! #$%-02356789>?q:=AgdaTurn a name into an expression.=AgdaAre we in an abstract block?)In that case some definition is abstract.=Agda,Parameterised over the type of dot patterns.=AgdaDestructor pattern d.=Agda%Defined pattern: function definition f ps. It is also abused to convert destructor patterns into concrete syntax thus, we put AmbiguousQName here as well.=AgdaUnderscore pattern entered by user. Or generated at type checking for implicit arguments.=Agda Dot pattern .e=Agda| p, for with-patterns.=AgdaPattern with type annotation=AgdaThe 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!=AgdaThe lhs of a clause in focused (projection-application) view (outside-in). Projection patters are represented as =s.=AgdaRange.=Agda Copatterns.=AgdaThe 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.=AgdaWe store the original concrete expression in case we have to reproduce it during interactive case splitting. | for internally generated rhss.=AgdaThe s are the names of the generated with functions, one for each >.=AgdaThe 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 by=AgdaThe declaration is a >.=AgdaWe 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. * User pattern is an annotated wildcard: type annotation will be checked after splitting is complete.=AgdaWe don't yet know the position of generalized parameters from the data sig, so we keep these in a set on the side.=AgdaMaps 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) before type-checking. However, this would be slightly problematic: $We would have to typecheck the type A several times.If A contains a meta variable or hole, it would be duplicated by such a translation.While 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 defn>AgdaIrrefutable pattern binding.>Agda*LetApply mi newM (oldM args) renamings dir. The ImportDirective is for highlighting purposes.>Agda,only for highlighting and abstractToConcrete>Agda?Only used for highlighting. Refers to the first occurrence of x in let x : A; x = e(. | LetGeneralize DefInfo ArgInfo Expr>Agda. is not .:. Name can be ambiguous e.g. for built-in constructors.>AgdaBuiltins 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).The fourth argument contains an optional assignment of polarities to arguments.>AgdaFirst argument is set of generalizable variables used in the type.>Agda record field>Agdaprimitive function>Agda)a bunch of mutually recursive definitions>AgdaThe ImportDirective is for highlighting purposes.>AgdaThe ImportDirective is for highlighting purposes.>Agda'only retained for highlighting purposes>Agdasequence of function clauses>Agdalone data signature>Agdalone record signature>AgdaThe >' gives the constructor type telescope, (x1 : A1)..(xn : An) -> Prop, and the optional name is the constructor's name. The optional   is for the pattern attribute.>AgdaOnly for highlighting purposes>Agdascope annotation>AgdaRenaming (generic).>AgdaRecord field assignment f = e.>AgdaExpressions after scope checking (operators parsed, names resolved).>AgdaBound variable.>AgdaConstant: axiom, function, data or record type, with a possible suffix.>AgdaProjection (overloaded).>AgdaConstructor (overloaded).>AgdaPattern synonym.>AgdaMacro.>AgdaLiteral.>Agda&Meta variable for interaction. The " is usually identical with the 1 of 1. However, if you want to print an interaction meta as just ? instead of ?n, you should set the 1 to | while keeping the .>Agda=Meta variable for hidden argument (must be inferred locally).>Agda.e, for postfix projection.>AgdaOrdinary (binary) application.>AgdaWith application.>Agda bs C e.>Agda() or {}.>AgdaDependent function space  C A.>Agda(Like a Pi, but the ordering is not known>AgdaNon-dependent function space.>Agda let bs in e.>Agda#Only used when printing telescopes.>AgdaRecord construction.>AgdaRecord update.>AgdaScope annotation.>AgdaQuote an identifier .>Agda Quote a term.>Agda#The splicing construct: unquote ...>Agda tactic e x1 .. xn>Agda For printing DontCare from Syntax.Internal.>AgdaA 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} -> ...>AgdaPattern synonym for regular Def>Agda!Smart constructor for Generalized>Agda$The name defined by the given axiom.3Precondition: The declaration has to be a (scoped) >.?AgdaDoes not compare . fields.?AgdaDoes not compare . fields. Does not distinguish between prefix and postfix projections.?AgdaIgnore   when comparing =s.?AgdaIgnore = when comparing =s.?AgdaTurn a . into an expression.Assumes name is not ..?AgdaTurn an . into an expression.==========================================================================================================>>>=>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>==========================================================================================================>>>=>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>None! #$%-02356789>?x@Agda-Extracts "all" names which are declared in a >.Includes: local modules and where clauses. Excludes:  open public, let, with" function names, extended lambdas.@AgdaApply an expression rewriting to every subexpression, inside-out. See Agda.Syntax.Internal.Generic.@AgdaThe first expression is pre-traversal, the second one post-traversal.@AgdaCollects plain lambdas.@Agda-Gather applications to expose head and spine.Note: everything is an application, possibly of itself to 0 arguments@AgdaGather top-level = atterns and =%atterns to expose underlying pattern.@Agda Remove top > wrappers.@AgdaRemove > wrappers everywhere.!NB: Unless the implementation of @ for clauses has been finished, this does not work for clauses yet.@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@None! #$%-02356789>?z@AgdaMerge 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.@@@@@@None! #$%-02356789>?@Agda-Convert a focused lhs to spine view and back.@AgdaThe next patterns are ...(This view discards 0.)@Agda&Application patterns (non-empty list).@Agda6A projection pattern. Is also stored unmodified here.@AgdaWith patterns (non-empty list). These patterns are not prefixed with =.@AgdaGeneric pattern traversal.@Agda Fold pattern.@AgdaTraverse pattern.@AgdaCompute from each subpattern a value and collect them all in a monoid.@AgdaTraverse pattern(s) with a modification before the recursive descent.@AgdaTraverse pattern(s) with a modification after the recursive descent.@Agda?Map pattern(s) with a modification after the recursive descent.@Agda9Collect pattern variables in left-to-right textual order.@Agda4Check if a pattern contains a specific (sub)pattern.@AgdaCheck if a pattern contains an absurd pattern. For instance, suc () , does so.+Precondition: contains no pattern synonyms.@Agda)Check if a pattern contains an @-pattern.@AgdaCheck if any user-written pattern variables occur more than once, and throw the given error if they do.@AgdaPattern substitution.For the embedded expression, the given pattern substitution is turned into an expression substitution.@AgdaPattern substitution, parametrized by substitution function for embedded expressions.@Agda7Split patterns into (patterns, trailing with-patterns).@Agda1Get the tail of with-patterns of a pattern spine.@AgdaConstruct the @" of the given list (if not empty).+Return the view and the remaining patterns.@AgdaAdd applicative patterns (non-projection / non-with patterns) to the right.@AgdaAdd with-patterns to the right.AAgdaCombine 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.@Agda&Substitution function for expressions.Agda(Parallel) substitution.AgdaInput pattern.%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@AAAAA%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@AAAAANone' #$%'(-./02356789>?'AAgda Currying as b# witnesses the isomorphism between  Arrows as b and Products as -> b. It is defined as a type class rather than by recursion on a singleton for as so all of that these conversions are inlined at compile time for concrete arguments.AAgdaUsing 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 exposedAAgdaIsBase t is 'True whenever t is *not* a function space.AAgdaArrows [a1,..,an] r corresponds to a1 -> .. -> an -> r | Products [a1,..,an] corresponds to (a1, (..,( an, ())..))AAgda Version of Foldr taking a defunctionalised argument so that we can use partially applied functions.AAgdaOn ListsAAgda On BooleansAAgdaAll p as ensures that the constraint p is satisfied by all the types in as. (Types is between scare-quotes here because the code is actually kind polymorphic)AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANone$ #$%'(-/02356789>?gAAgdaA known boolean is one we can obtain a singleton for. Concrete values are trivially known.AAgda"Singleton for type level booleans.AAAAAAAAAAAAAANone! #$%-02356789>? AAgdaLike  Bifunctor, but preserving sharing.AAgdaLike |, but preserving sharing.AAgdaThe ChangeT monad transformer.AAgdaThe class of change monads.AAgdaRun a A0 computation, returning result plus change flag.AAgdaMap a A( computation (monad transformer action).AAgdaBlindly run an updater.AAgdaRun a A0 computation, returning result plus change flag.AAgdaBlindly run an updater.AAgdaMark a computation as dirty.AAgdaReplace result of updating with original input if nothing has changed.AAgda8A mock change monad. Always assume change has happened.AAgda = sharing . updater1AAgda-Mark computation as having changed something.AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANone# #$%'(-02356789>?AAgdaMain. Fixities (or more precisely syntax declarations) are needed when grouping function clauses.AAgda(Approximately) convert a , back to a list of &s.AAgdaHas the , a field of type ?AAgdaContents of a where& clause are abstract if the parent is.,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,--------AAA,,,,,,,,,,,,,,,,,,,,,,,,,,----,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,---AAA,-None! #$%-02356789>?0bcdefghijklmnAAAhimljkbdcenfgANone! #$%-02356789>?.AAgda e.g. x + 5AAgdaa number or infinityAAgdaA solution assigns to each flexible variable a size expression which is either a constant or a v + n for a rigid variable v.AAgda"A matrix with row descriptions in b and column descriptions in c.AAgda6The Graph Monad, for constructing a graph iteratively.AAgdaScope for each flexible var.AAgdaNode labels to node numbers.AAgdaNode numbers to node labels.AAgdaNumber of nodes n.AAgdaThe edges (restrict to [0..n[).AAgda%A constraint is an edge in the graph.BAgdaFor  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.BAgda3Which rigid variables a flex may be instatiated to.BAgdaNodes of the graph are either - flexible variables (with identifiers drawn from Int*), - rigid variables (also identified by Intn2 to be at most k(. Also adds nodes if not yet present.BAgda sizeRigid r n. returns the size expression corresponding to r + n5AAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB5BBBBBBBBBBBBBBBBBBBBABBABAAAAAAABABBBBBBAAAAAABBAAABBNone" #$%-/02356789>?PBBBBBBBBBBNone! #$%-02356789>? BBBBBBBBBB BBBBBBBBBBNone" #$%-02356789>?'}}}}}}}}None! #$%-02356789>?]BAgdaThe version of Agda.BAgdaThis package name. This is mainly intended for use in the test suites to filter ephemeral hash-fingerprinted package names like !Agda-2.6.2-5ceeWeguf1QFMaHLput4zw.BBBBNone$ #$%-02356789>?BAgda?Information about current git commit, generated at compile timeBBBBNone! #$%-02356789>?BAgdaLibrary names are structured into the base name and a suffix of version numbers, e.g.  mylib-1.2.3". The version suffix is optional.BAgdaActual library name.BAgdaMajor version, minor version, subminor version, etc., all non-negative. Note: a priori, there is no reason why the version numbers should be Ints.BAgdaRaise collected  LibErrors as exception.BAgdaReturns the absolute default lib dir. This directory is used to store the Primitive.agda file.BAgdaGet project rootBAgdaGet the contents of  .agda-lib! files in the given project root.BAgda:Get dependencies and include paths for given project root: Look for  .agda-lib files according to findAgdaLibFiles?. If none are found, use default dependencies (according to defaults/ file) and current directory (project root).BAgda9Parse the descriptions of the libraries Agda knows about.Returns none if there is no  libraries file.BAgda0Return the trusted executables Agda knows about.Returns none if there is no  executables file.BAgda6Get all include pathes for a list of libraries to use.BAgdaGeneralized version of } for testing. findLib' 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" ] == []BAgdaSplit a library name into basename and a list of version numbers. versionView "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.)BAgdaPrint a  VersionView , inverse of  versionView (modulo leading zeros).BAgda Project root.AgdaUse defaults if no  .agda-lib file exists for this project?Agda The returned LibNames are all non-empty strings.BAgdaOverride the default  libraries file?Agda-Content of library files. (Might have empty LibNames.)BAgda Content of  executables files.BAgda 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.&!!!!!!!!!!!!!!!!!!!!!!"BBBBBBBBBBBBBBB&BBBBBBB!!!!!!!!!!B!!!!!!!"!!!!!BBBBBBBNone# #$%-/02356789>?+BAgdaf :: Flag opts is an action on the option record that results from parsing an option. f opts produces either an error message or an updated options recordBAgdaThe 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.BAgda%Options which can be set in a pragma.BAgdaCut off structural order comparison at some depth in termination checker?BAgda+irrelevant levels, irrelevant data matchingBAgda(Allow definitions by copattern matching?BAgda0Is pattern matching allowed in the current file?CAgda2Perform the forcing analysis on data constructors?CAgda6Perform the projection-likeness analysis on functions?CAgda$Can rewrite rules be added and used?CAgdaShould we speculatively unify function applications as if they were injective?CAgda$Should system generated projections  ProjSystem0 be printed postfix (True) or prefix (False).CAgdaShould case splitting replace variables with dot patterns (False) or keep them as variables (True).CAgda?Should instance search consider instances with qualified names?CAgda:Should conversion checker use syntactic equality shortcut?CAgdaCount extended grapheme clusters rather than code points when generating LaTeX.CAgdaAutomatic compile-time inlining for simple definitions (unless marked NOINLINE).CAgda+Use the Agda abstract machine (fastReduce)?CAgda(Use call-by-name instead of call-by-needCAgda"Check confluence of rewrite rules?CAgda)Can we split on a (@flat x : A) argument?CAgdaShould every top-level module start with an implicit statement ,open import Agda.Primitive using (Set; Prop)?CAgdaShow identity substitutions when pretty-printing terms (i.e. always show all arguments of a metavariable)CAgda-Use this (if Just) instead of .agda/librariesCAgdaUse ~.agdadefaultsCAgdalook for .agda-lib filesCAgda2Map names of trusted executables to absolute pathsCAgdaAgda REPL (-I).CAgda2In the absence of a path the project root is used.CAgdaShould the top-level module only be scope-checked, and not type-checked?CAgdaMap a function over the long options. Also removes the short options. Will be used to add the plugin name to the plugin options.CAgda-Checks that the given options are consistent.CAgda?CAgda9Returns the pragma options which are currently in effect.CAgda?Returns the command line options which are currently in effect.CCCNone! #$%-02356789>? DCHEGF BBBBBBBBCCCCCCCCCCCCCCCCCCCCCCCBBBBBBBBBBBBBBBBBBBBBCCCBBCCCCBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCBBBBCCCCBBCCCBBBBBBBBBBBBBBBBBBBBBCCCCCCCCCCCCCCCCCCCCCCCBBBCDCHGFECCC BBBCCCCCCCCCCCCCCCCCCCCCCCQNone" #$%-02356789>?rmAgda+Polarity for equality and subtype checking.AgdaMaps 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.AgdaA non-fatal error is an error which does not prevent us from checking the document further and interacting with the user.CAgdaThe constraints needed for L and similar.CAgdaEmbedding a TCM computation.CAgda3`patternViolation b` aborts the current computationCAgda`catchPatternErr handle m` runs m, handling pattern violations with handle (doesn't roll back the state)CAgda MonadTCState made into its own dedicated service class. This allows us to use } for } extensions of TCM.CAgda MonadTCEnv made into its own dedicated service class. This allows us to use | for } extensions of TCM.CAgda Environment of the reduce monad.CAgda Read only access to environment.CAgda0Read only access to state (signature, metas...).CAgda?The first argument is the state in which the error was raised.CAgdaThe exception which is usually caught. Raised for pattern violations during unification (assignV) but also in other situations where we want to backtrack. Contains an unblocker to control when the computation should be retried.CAgdaLocation in the internal Agda source code where the error was raisedCAgda(The state in which the error was raised.CAgdaExpected a type to be an application of a particular datatype.CAgdaconstructor, datatypeDAgdaDatatype, constructors.DAgdaconstructor, typeDAgdaThe left hand side of a function definition has a hidden argument where a non-hidden was expected.DAgda9Expected a non-hidden function and found a hidden lambda.DAgdaA function is applied to a hidden argument where a non-hidden was expected.DAgdaA function is applied to a hidden named argument it does not have. The list contains names of possible hidden arguments at this point.DAgda0Wrong user-given relevance annotation in lambda.DAgda/Wrong user-given quantity annotation in lambda.DAgda/Wrong user-given cohesion annotation in lambda.DAgdaThe given quantity does not correspond to the expected quantity.DAgdaFailed to apply injectivity to constructor of indexed datatypeEAgda=Can't solve equation because variable occurs in (type of) lhsEAgda=Can't solve reflexive equation because --without-K is enabledEAgda?Can't solve equation because solution modality is less "usable"EAgdaError when splitting a pattern variable into possible constructor patterns.EAgdaNeither data type nor record.EAgda'Type could not be sufficiently reduced.EAgda8Data type, but in erased position. If the boolean is |, then the reason for the error is that the K rule is turned off.EAgdaSplit on codata not allowed. UNUSED, but keep! -- | NoRecordConstructor Type -- ^ record type, but no constructorEAgdaCopattern split with a catchallEAgda-We do not know the target type of the clause.EAgda!Target type is not a record type.EAgdaBlocking metavariable (if any)EAgda Constructor.EAgdaContext for indices.EAgda,Inferred indices (from type of constructor).EAgda)Expected indices (from checking pattern).EAgda$Reason(s) why unification got stuck.EAgdaInformation about a mutual block which did not pass the termination checker.EAgdaThe functions which failed to check. (May not include automatically generated functions.)EAgdaThe problematic call sites.EAgdaInformation about a call.EAgdaTarget function name.EAgdaRange of the target function.EAgda+To be formatted representation of the call.EAgdaLocation in the internal Agda source code location where the error raisedEAgda"Range where the warning was raisedEAgdaThe warning itselfEAgdaThe warning printed in the state and environment where it was raisedEAgda*Should the warning be affected by caching.EAgdaEach redundant field comes with a range of associated dead code.EAgdaRecord type, fields not supplied by user, non-fields but supplied. The redundant fields come with a range of associated dead code.EAgda4`UnreachableClauses f rs` means that the clauses in f' whose ranges are rs are unreachableEAgda!`CoverageIssue f pss` means that pss are not covered in fEAgdaDo not use directly with warningEAgdaDo not use directly with warningEAgdaDo not use directly with warningEAgdaIn `OldBuiltin old new`, the BUILTIN old has been replaced by newEAgdaIf the user wrote just {-# REWRITE #-}.EAgda An empty where block is dead code.EAgdaIf the user wrote something other than an unqualified name in the as clause of an import statement. The }$ gives optionally extra explanation.EAgdaIf a renaming import directive introduces a name or module name clash in the exported names of a module. (See issue #4154.)EAgdaThe  'pattern'5 declaration is useless in the presence of either  coinductive or  eta-equality. Content of }! is "coinductive" or "eta", resp.EAgdaIf the user opens a module public before the module header. (See issue #2377.)EAgda Names in 5 directive that don't hide anything imported by a  directive.EAgdaAn instance was declared with an implicit argument, which means it will never actually be considered by instance search.EAgdaThe type of an instance argument doesn't end in a named or variable type, so it will never be considered by instance search.EAgdaAs InstanceWithExplicitArg, but for local bindings rather than top-level instances.EAgda&The --inversion-max-depth was reached.EAgdaA coinductive record was declared but neither --guardedness nor --sized-types is enabled.EAgda'Harmless generic warning (not an error)EAgda=Generic error which doesn't abort proceedings (not a warning)EAgda:Generic warning when code is useless and thus ignored.   is for dead code highlighting.EAgdaUnsafe OPTIONS.EAgdaETA pragma is unsafe.EAgda)`DeprecationWarning old new version`: old is deprecated, use new( instead. This will be an error in Agda version.EAgdaUser-defined warning (e.g. to mention that a name is deprecated)EAgda'Duplicate mentions of the same name in using directive(s).EAgdaFixity of modules cannot be changed via renaming (since modules have no fixity).EAgdaSome imported names are not actually exported by the source module. The second argument is the names that could be exported. The third argument is the module names that could be exported.EAgdaImporting a file using an infective option into one which doesn'tEAgdaImporting a file not using a coinfective option from one which doesEAgdaConfluence checker found critical pair and equality checking resulted in a type errorEAgdaConfluence checker got stuck on computing overlap between two rewrite rulesEAgda+The global confluence checker found a term u that reduces to both v1 and v22 and there is no rule to resolve the ambiguity.EAgda+The global confluence checker found a term u that reduces to v, but v does not reduce to rho(u).EAgda&COMPILE directive for an erased symbolEAgda&Out of scope error we can recover fromEAgda;The as-name in an as-pattern may not shadow a constructor (False) or pattern synonym name (True,), because this can be confusing to read.EAgdaRanges of checked arguments, where present. e.g. inserted implicits have no correponding abstract syntax.EAgda&Checked and inserted arguments so far.EAgdaConstraints for the head so far, i.e. before applying the correponding elim.EAgda%Type for the rest of the application.EAgdaA 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.FAgdaAdd implicit arguments in the end until type is no longer hidden 7.FAgda!Do not append implicit arguments.FAgdaMakes  doExpandLast have no effect. Used to avoid implicit insertion of arguments to metavariables.FAgda6Abstract things in the current module can be accessed.FAgda#No abstract things can be accessed.FAgda$All abstract things can be accessed.FAgdaThe Context is a stack of Fs.FAgda=The path to the file that is currently being type-checked. |9 if we do not have a file (like in interactive mode see  CommandLine).FAgda4anonymous modules and their number of free variablesFAgdaThe module stack with the entry being the top-level module as Agda chases modules. It will be empty if there is no main module, will have a single entry for the top level module, or more when descending past the main module. This is used to detect import cycles and in some cases highlighting behavior. 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.FAgda!the current (if any) mutual blockFAgda/are we inside the scope of a termination pragmaFAgda,are we inside the scope of a coverage pragmaFAgdaare we inside a make-case (if so, ignore forcing analysis in unifier)FAgda>Are we currently in the process of solving active constraints?FAgdaHave we stepped into the where-declarations of a clause? Everything under a where# will be checked with this flag on.FAgda&Are we working on types? Turned on by  workOnTypes.FAgdaAre we allowed to assign metas?FAgdaWhen 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.FAgda7 component: Are we checking an irrelevant argument? (= Irrelevant) 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.FAgdaAre we currently case-splitting on a strict datatype (i.e. in SSet)? If yes, the pattern-matching unifier will solve reflexive equations even --without-K.FAgda+Sometimes we want to disable display forms.FAgda8Interactive highlighting uses this range rather than F.FAgdaWhat is the current clause we are type-checking? Will be recorded in interaction points in this clause.FAgdawhat we're doing at the momentFAgdaSet to F+ when imported modules are type-checked.FAgdaWhen type-checking an alias f=e, we do not want to insert hidden arguments in the end, because these will become unsolved metas.FAgdaWe are reducing an application of this function. (For debugging of incomplete matches only.)FAgdaDid we encounter a simplification (proper match) during the current reduction process?FAgdaInjectivity can cause non-termination for unsolvable contraints (431, 3067). Keep a limit on the nesting depth of injectivity uses.FAgdaWhen 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.FAgdaWhen True, types will be omitted from printed pi types if they can be inferred.FAgdaWhen 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.FAgdaUsed by the scope checker to make sure that certain forms of expressions are not used inside dot patterns: extended lambdas and let-expressions.FAgdaUntil we get a termination checker for instance search (#1743) we limit the search depth to ensure termination.FAgda#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.FAgda+Use call-by-need evaluation for reductions.FAgdaCheckpoints track the evolution of the context as we go under binders or refine it by pattern matching.FAgdaKeeps the substitution from each previous checkpoint to the current context.FAgda"Should new metas generalized over.FAgda(Values for used generalizable variables.FAgdaIs some backend active at the moment, and if yes, which? NB: we only store the  here, otherwise instance Data TCEnv is not derivable. The actual backend can be obtained from the name via K.FAgdaAre we currently computing the overlap between two rewrite rules for the purpose of confluence checking?FAgda Via stdout.FAgdaBoth via files and via stdout.FAgdaThis includes both non-interactive highlighting and interactive highlighting of the expression that is currently being type-checked.FAgda-Builtin of any kind. Type can be checked (Just t) or inferred (Nothing). The second argument is the hook for the verification function.FAgda2When typechecking something of the following form:"instance x : _ x = y it's not yet known where to add x, so we add it to a list of unresolved instances and we'll deal with it later.FAgdaThe instance table is a Map' associating to every name of record data typepostulate its list of instancesFAgda8Highlight (interactively) if and only if the boolean is |.FAgda*Interaction command: show module contents.FAgdaused by setCurrentRangeGAgda PrimitivesGAgda Controlling reduce.GAgda:(Projection and) projection-like functions may be reduced.GAgda'Functions marked INLINE may be reduced.GAgda%Copattern definitions may be reduced.GAgda6Non-recursive functions and primitives may be reduced.GAgda(Even recursive functions may be reduced.GAgdaReduce 6 terms.GAgdaAllow  allReductions in types, even if not allowed at term level (used by confluence checker)GAgda9Functions whose termination has not (yet) been confirmed.GAgda0Functions that have failed termination checking.GAgdaThree cases: 1. not reduced, 2. reduced, but blocked, 3. reduced, not blocked.GAgdaDid 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?GAgda PostulateGAgdaData or record type signature that doesn't yet have a definitionGAgda&Generalizable variable (introduced in  generalize block)GAgda Returned by  getConstInfo if definition is abstract.GAgdaPrimitive or builtin functions.GAgda5Can transp for this postulate be constant? Set to True for bultins like String.GAgda|* while function is still type-checked. Just cc after type and coverage checking and translation to case trees.GAgdaThe split tree constructed by the coverage checker. Needed to re-compile the clauses after forcing translation.GAgda2Intermediate representation for compiler backends.GAgdaCovering clauses computed by coverage checking. Erased by (IApply) confluence checking(?)GAgdaMutually recursive functions, datas and records. Does include this function. Empty list if not recursive. Nothing- if not yet computed (by positivity checker).GAgda+Are the clauses of this definition delayed?GAgdaIs 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.GAgda9Has this function been termination checked? Did it pass?GAgdaIs this function generated from an extended lambda? If yes, then return the number of hidden and non-hidden lambda-lifted argumentsGAgdaIs this a generated with-function? If yes, then what's the name of the parent function.GAgdaNumber of parameters.GAgdaNumber of indices.GAgda(This might be in an instantiated module.GAgdaConstructor names , ordered according to the order of their definition.GAgdaMutually recursive functions, datas and records. Does include this data type. Empty if not recursive. Nothing- if not yet computed (by positivity checker).GAgda+Path constructor names (subset of dataCons)GAgdaNumber of parameters.GAgdaWas this record type created by a module application? If yes, the clause is its definition (linking back to the original record type).GAgdaConstructor name and fields.GAgdaDoes this record have a  constructor?GAgdaThe record field names.GAgdaThe record field telescope. (Includes record parameters.) Note: $TelV recTel _ == telView' recConType . Thus, recTel is redundant.GAgdaMutually recursive functions, datas and record>s. Does include this record. Empty if not recursive. Nothing- if not yet computed (by positivity checker).GAgda#Eta-expand at this record type? False for unguarded recursive records and coinductive records unless the user specifies otherwise.GAgdaIn case eta-equality is off, do we allow pattern matching on the constructor or construction by copattern matching? Having both loses subject reduction, see issue #4560. After positivity checking, this field is obsolete, part of G.GAgda or *? Matters only for recursive records. | means that the user did not specify it, which is an error for recursive records.GAgdaNumber of parameters.GAgda+Number of arguments (excluding parameters).GAgdaName of (original) constructor and fields. (This might be in a module instance.)GAgda Name of datatype or record type.GAgdaInductive or coinductive?GAgdaCubical composition.GAgda Projections. | if not yet computed.GAgdaWhich 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.GAgdaWhich arguments are erased at runtime (computed during compilation to treeless)? | means erased, | means retained. | if no erasure analysis has been performed yet. The length of the list is conArity.GAgda for primitive functions, not null for builtin functions.GAgdaBuiltin functions can have inverses. For instance, natural number addition.GAgda| for primitive functions, | something for builtin functions.GAgda r .p2 (Invariant: the number of abstractions equals H.) In case of a projection-like function, just the function symbol is returned as 7: t = pars -> f.HAgda,Additional information for extended lambdas.HAgdaFor 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.HAgda2Was this definition created from an absurd lambda  ()?HAgdaAn alternative representation of partial elements in a telescope:  E  . [A uA, ... , A uA] :  C PartialP (D_: :) T see cubicaltt paper (however we do not store the type T).HAgda4the telescope , binding vars for the clauses,  E HAgda?a system [A uA, ... , A uA] where ,  E : and , , : E u:HAgda;The backends are responsible for parsing their own pragmas.HAgdaInformation about whether an argument is forced by the type of a function.HAgdamonotoneHAgdaantitoneHAgdano information (mixed variance)HAgdaconstantHAgda5When lambda-lifting new args are generalizable if H, also when the number is zero.HAgdaHiding should not be used.HAgda-The canonical name, used e.g. in compilation.HAgdaType of the lifted definition.HAgdaVariance information on arguments of the definition. Does not include info for dropped parameters to projection(-like) functions and constructors.HAgdaPositivity information on arguments of the definition. Does not include info for dropped parameters to projection(-like) functions and constructors.HAgda)How many arguments should be generalised.HAgdaGives 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.HAgdaJust q/ when this definition is an instance of class qHAgda:Has this function been created by a module instantiation?HAgdaThe set of symbols with rewrite rules that match against this symbolHAgda8should compilers skip this? Used for e.g. cubical's compHAgdaShould the def be treated as injective by the pattern matching unifier?HAgda)Is this a function defined by copatterns?HAgdaWhat blocking tag to use when we cannot reduce this def? Used when checking a function definition is blocked on a meta in the type.HAgda?Rewrite rules can be added independently from function clauses.HAgdaName of rewrite rule q :  C f ps D rhs where D is the rewrite relation.HAgda.HAgdaf.HAgda  E f ps : t.HAgda  E rhs : t.HAgda E t.HAgdaWas this rewrite rule created from a clause in the definition of the function?HAgda1Non-linear (non-constructor) first-order pattern.HAgdaMatches anything (modulo non-linearity) that only contains bound variables that occur in the given arguments.HAgdaMatches f esHAgdaMatches  x C tHAgdaMatches  (x : A) C BHAgda"Matches a sort of the given shape.HAgdaMatches x es# where x is a lambda-bound variableHAgda'Matches the term modulo  (ideally ).HAgdaA structured presentation of a 7 for reification into .HAgda(f vs | ws) es. The first H is the parent function f with its args vs. The list of Hs are the with expressions ws . The 7 are additional arguments es (possible in case the with-application is of function type) or projections (if it is of record type).HAgdac vs.HAgdad vs.HAgda.v.HAgdav.HAgdaA  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 H which is used to reify to a more readable . The patterns ts are just terms, but the first  dfPatternVars: variables are pattern variables that matches any term.HAgdaNumber n of pattern variables in H.HAgdaLeft hand side patterns, the n first free variables are pattern variables, any variables above n are fixed and only match that particular variable. This happens when you have display forms inside parameterised modules that match on the module parameters. The  is ignored in these patterns.HAgdaRight hand side.HAgda'The rewrite rules defined in this file.HAgda0Which clause is an interaction point located in?HAgda4The interaction point is not in the rhs of a clause.HAgdaThe name of the function.HAgda*The number of the clause of this function.HAgdaThe type of the functionHAgdaModule parameter substitutionHAgdaThe original AST clause.HAgda&Environment for rechecking the clause.HAgda The boundary imposed by the LHS.HAgdaDatatype representing a single boundary condition: x_0 = u_0, ... ,x_n = u_n E t = ?n esHAgda x_0 = u_0, ... ,x_n = u_nHAgda tHAgda ?n esHAgdaIs ?n overapplied in ?n es ?HAgdaFlag 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).HAgda/Data structure managing the interaction points.We never remove interaction points from this map, only set their H to True. (Issue #2368)HAgdaInteraction 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.HAgda&The position of the interaction point.HAgda0The meta variable, if any, holding the type etc.HAgda/Has this interaction point already been solved?HAgdaThe clause of the interaction point (if any). Used for case splitting.IAgdaName suggestion for meta variable. Empty string means no suggestion.IAgdaMetaInfo4 is cloned from one meta to the next during pruning.IAgda-Instantiable with irrelevant/erased solution?IAgda7Run the extended occurs check that goes in definitions?IAgdaUsed for printing. Just x8 if meta-variable comes from omitted argument with name x.IAgdaShould this meta be generalized if unsolved? If so, at what ArgInfo?IAgdaMeta variable priority: When we have an equation between meta-variables, which one should be instantiated?6Higher value means higher priority to be instantiated.IAgda( (xs : tA) C e) : t This is not an instance of I as the domain type has already been checked. For example, when checking '( (x y : Fin _) C e) : (x : Fin n) C ? we want to postpone ( (y : Fin n) C e) : ? where Fin n is a 7 rather than an >.IAgda,Quote the given term and check type against 7IAgdametas created for hidden and instance arguments in the principal argument's typeIAgdaprincipal argument's type, stripped of hidden and instance argumentsIAgda Solving a I constraint may or may not check the target type. If it did, it returns a handle to any unsolved constraints.IAgda4solved by term (abstracted over some free variables)IAgdaunsolvedIAgda+open, to be instantiated by instance searchIAgda(solution blocked by unsolved constraintsIAgdaFrozen 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).IAgdaDo not instantiate.IAgda4some metavariables are more eager to be instantiatedIAgdaa metavariable doesn't have to depend on all variables in the context, this "permutation" will throw away the ones it does not depend onIAgdameta variables scheduled for eta-expansion but blocked by this oneIAgdaare we past the point where we can instantiate this meta variable?IAgdaJust m$ means this meta will be equated to m# when the latter is unblocked. See blockedTermOnProblem.IAgdaThe value of a generalizable variable. This is created to be a generalizable meta before checking the type to be generalized.IAgda2Generalize because it is a generalizable variable.IAgdaGeneralize because it is a metavariable and we're currently checking the type of a generalizable variable (this should get the default modality).IAgdaDon't generalize.IAgdaParametrized since it is used without MetaId when creating a new meta.IAgdaare we checking (CmpLeq) or inferring (CmpEq ) the type?IAgdaA thing tagged with the context it came from. Also keeps the substitution from previous checkpoints. This lets us handle the case when an open thing was created in a context that we have since exited. Remember which module it's from to make sure we don't get confused by checkpoints from other files.IAgdaWe can either compare two terms at a given type, or compare two types without knowing (or caring about) their sorts.IAgdaType should not be Size5. But currently, we do not rely on this invariant.IAgda Replaces AsTermsOf Size.IAgdaAn extension of  to >=.IAgdaMeta created for a term blocked by a postponed type checking problem or unsolved constraints. The I( for the meta (when unsolved) is either I or I.IAgda+The range is the one of the absurd pattern.IAgdaCheck that the 7. is either not a SIZELT or a non-empty SIZELT.IAgdathe first argument is the instance argument and the second one is the list of candidates (or Nothing if we haven@t determined the list of candidates yet)IAgda2Last argument is the error causing us to postpone.IAgdaFirst argument is computation and the others are hole and goal typeIAgdaCheckLockedVars t ty lk lk_ty with t : ty,  lk : lk_ty and t lk well-typed.IAgda)is the term usable at the given modality?IAgdaHash of the source code.IAgdaThe 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.IAgda4Source file type, determined from the file extensionIAgda"Imported modules and their hashes.IAgdaModule name of this interface.IAgdaScope defined by this module.Andreas, AIM XX: Too avoid duplicate serialization, this field is not serialized, so if you deserialize an interface, iScope will be empty. But constructIScope constructs I from I.IAgda1Scope after we loaded this interface. Used in  and .IAgda-Display forms added for imported identifiers.IAgda&User warnings for imported identifiersIAgda8Whether this module should raise a warning when importedJAgda$Pragma options set in library files.JAgdaPragma options set in the file.JAgdaOptions/features used when checking the file (can be different from options set directly in the file).JAgdaWarnings were encountered when the module was type checked. These might include warnings not stored in the interface itself, specifically unsolved interaction metas. See Agda.Interaction.ImportsJAgda| if the module is a primitive module, which should always be importable.JAgdaThe J used to create the IJAgdaDistinguishes between type-checked and scope-checked interfaces when stored in the map of J.JAgdaA 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).JAgdaMaps source file names to the corresponding top-level module names.JAgdaCreate a fresh name from a.JAgda0A complete log for a module will look like this:JJ, entering the main module.JJJ*, for declarations and nested modulesJ, leaving the main module.JAgdaNever a Section or ScopeDeclJAgdaLike J, but storing the log for an ongoing type checking of a module. Stored in reverse order (last performed action first).JAgdaA log of what the type checker does and states after the action is completed. The cached version is stored first executed action first.JAgdaA part of the state which is not reverted when an error is thrown or the state is reset.JAgdaCallback function to call when there is a response to give to the interactive frontend. See the documentation of 2.JAgdaStructure to track how much CPU time was spent on which Agda phase. Needs to be a strict field to avoid space leaks!JAgdaShould be strict field.JAgdaCached typechecking state from the last loaded file. Should be Nothing when checking imports.JAgda#Current backends with their optionsJAgda)A mutual block of names in the signature.JAgda&The original info of the mutual block.JAgdaHighlighting info.JAgdaDisambiguation carried out by the type checker. Maps position of first name character to disambiguated  for each $ already passed by the type checker.JAgdaDirty when a constraint is added, used to prevent pointer update. Currently unused.JAgdaDefinitions 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.JAgdaDeclared identifiers of the current file. These will be serialized after successful type checking.JAgdaFor each module remember the checkpoint corresponding to the orignal context of the module parameters.JAgda-Display forms we add for imported identifiersJAgdaThe current module is available after it has been type checked.JAgdaMap keeping track of concrete names assigned to each abstract name (can be more than one name in case the first one is shadowed)JAgdaMap 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.JAgdaMap keeping track for each (abstract) name the list of all (raw) names that it could maybe be shadowed by.JAgdaCounters to collect various statistics about meta variables etc. Only for current file.JAgdaShould 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.JAgda/Local partial definitions, to be stored in the  InterfaceJAgda1Name disambiguation for the sake of highlighting.JAgdaHighlighting info for tokens and Happy parser warnings (but not for those tokens/warnings for which highlighting exists in J).JAgda?Imported declared identifiers. Those most not be serialized!JAgda2Pattern synonyms of the current file. Serialized.JAgda3Imported pattern synonyms. Must not be serialized!JAgdaCollected generalizable variables; used during scope checking of termsJAgda&Options applying to the current file. OPTIONS! pragmas only affect this field.JAgda;Display forms added by someone else to imported identifiersJAgda{-# FOREIGN #-} code that should be included in the compiled output. Does not include code for imported modules.JAgda Imported  UserWarnings, not to be stored in the  InterfaceJAgdaLocally defined  UserWarnings, to be stored in the  InterfaceJAgda=Whether the current module should raise a warning when openedJAgda6Imported partial definitions, not to be stored in the  InterfaceJAgdaMap from directories to paths of closest enclosing .agda-lib files (or Nothing if there are none).JAgda:Contents of .agda-lib files that have already been parsed.JAgda/The state which is frozen after scope checking.JAgda1The state which is modified after scope checking.JAgda'State which is forever, like a diamond.JAgdaEmpty persistent state.JAgdaEmpty state of type checker.KAgda Creates a J map based on K. O(n log n).For a single reverse lookup in K, rather use lookupModuleFromSourse.KAgda Lookup an   in K.O(n).KAgdaCombines the source hash and the (full) hashes of the imported modules.KAgdaEmbed  into I.KAgda!Flip the direction of comparison.KAgdaTurn a  function into a I function. Property:  dirToCmp f (fromCmp cmp) = f cmpKAgda$By default, we have no display form.KAgda+Create a definition with sensible defaults.KAgda>Building the projection function (which drops the parameters).KAgda,The info of the principal (record) argument.KAgda3Make sure we do not overwrite a user specification.KAgdaIs the record type recursive?KAgdaA template for creating G% definitions, with sensible defaults.KAgdaChecking whether we are dealing with a function yet to be defined.KAgdaConceptually: 2redBind m f k = either (return . Left . f) k =<< mKAgda:Not quite all reductions (skip non-terminating reductions)LAgda+Are the clauses of this definition delayed?LAgda2Has the definition failed the termination checker?LAgdaHas the definition not termination checked or did the check fail?LAgda&ifTopLevelAndHighlightingLevelIs l b m runs m when we're type-checking the top-level module (or before we've started doing this) and either the highlighting level is at least l or b is |.LAgda$ifTopLevelAndHighlightingLevelIs l m runs m when we're type-checking the top-level module (or before we've started doing this) and the highlighting level is at least l.LAgda&Modify the lens-indicated part of the TCEnv in a subcomputation.LAgda A variant of C6 in which the computation is strict in the new state.LAgdaOverwrite the part of the  focused on by the lens.LAgdaModify the part of the  focused on by the lens.LAgda'Modify a part of the state monadically.LAgdaModify the part of the 0 focused on by the lens, and return some result.LAgda?Modify a part of the state monadically, and return some result.LAgda.Preserve the state of the failing computation.LAgdaExecute 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.LAgdaUtility function for 1-arg constructed type errors. Note that the  HasCallStack+ constraint is on the *resulting* function.LAgda4Running the type checking monad (most general form).LAgdaRunning the type checking monad on toplevel (with initial state).LAgdaL runs a safe  action (a 9 action which cannot fail, except that it might raise C!s) in the initial environment.LAgda6Runs the given computation in a separate thread, with a copy' of the current state and environment.Note 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.LAgda$Base name for patterns in telescopesLAgda&Base name for extended lambda patternsLAgda?v)QAgdaicodeArgs proxy (a1, ..., an) maps icode over a1, ..., an* and returns the corresponding list of Int32.QAgdaMonad used by the decoder.TCM is not used because the associated overheads would make decoding slower.QAgdaMonad used by the encoder.QAgdaState of the decoder.QAgdaObtained from interface file.QAgdaObtained from interface file.QAgdaObtained from interface file.QAgdaObtained from interface file.QAgdaObtained from interface file.QAgdaObtained from interface file.QAgdaCreated and modified by decoder. Used to introduce sharing while deserializing objects.QAgda?IRAgdaAssumes that the first module in the import path is the module we are worried about.RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRNone! #$%-02356789>?RAgda+Get the name of the current module, if any.RAgda#Set the name of the current module.RAgda*Get the path of the currently checked fileRAgda7Get the number of variables bound by anonymous modules.RAgda+Add variables bound by an anonymous module.RAgda(Set the current environment to the givenRAgdaGet the current environmentRAgdaSet highlighting levelRAgdaRestore setting for F to default.RAgdaIf the reduced did a proper match (constructor or literal pattern), then record this as simplification step.RAgda Lens for G.RAgdaReduce Def f vs only if f is a projection.RAgdaAllow all reductions except for non-terminating functions (default).RAgda9Allow all reductions including non-terminating functions.RAgdaAllow all reductions when reducing types. Otherwise only allow inlined functions to be unfolded.RAgda/Update allowed reductions when working on typesRAgda?RAgda?Debug print some lines if the verbosity level for the given C is at least C.Note: In the presence of OverloadedStrings , just @( traceS key level "Literate string"  gives an Ambiguous type variable error in  GHC@. Use the legacy functions R and R instead then.RAgda?Debug print some lines if the verbosity level for the given C is at least C.Note: In the presence of OverloadedStrings , just @) reportS key level "Literate string"  gives an Ambiguous type variable error in  GHC@. Use the legacy functions R and R instead then.RAgda=Print brackets around debug messages issued by a computation.RAgda.Check whether we are currently debug printing.RAgda;Flag in a computation that we are currently debug printing.RAgda%Print a debug message if switched on.RAgda/During printing, catch internal errors of kind  and print them.RAgda#Conditionally println debug string.RAgdaConditionally render debug  and print it.RAgda(Debug print the result of a computation.RAgdaConditionally render debug , print it, and then continue.RAgda5Check whether a certain verbosity level is activated.-Precondition: The level must be non-negative.RAgdaCheck whether a certain verbosity level is activated (exact match).RAgdaRun a computation if a certain verbosity level is activated (exact match).RAgda?RAgdaGet the statistics.RAgda)Modify the statistics via given function.RAgdaIncrease specified counter by 1.RAgdaIncrease specified counter by n.RAgdaSet the specified counter to the maximum of its current value and n.RAgdaPrint the given statistics if verbosity "profile.ticks" is given.RRRRRRRRRRRRRRRRNone! #$%-02356789>?jSAgda/To be called before any write or restore calls.SAgda Writes a J( to the current log, using the current JSAgdaRuns the action and restores the current cache at the end of it.SAgdaRuns the action without cache and restores the current cache at the end of it.SAgda>Reads the next entry in the cached type check log, if present.SAgdaEmpties the "to read" CachedState. To be used when it gets invalid.SAgdaMakes sure that the K is |(, with a clean current log. Crashes is K is already active with a dirty log. Should be called when we start typechecking the current file.SAgdaCaches the current type check log. Discardes the old cache. Does nothing if caching is inactive. SSSSSSSSSS SSSSSSSSSSNone! #$%-02356789>?SAgdaWhen verbosity is set or changes, we need to turn benchmarking on or off.SAgdaPrints the accumulated benchmark results. Does nothing if profiling is not activated at level 2.8 ***********************************************SS S SNone! #$%-02356789>?rSSSSSSSSSSNone! #$%-02356789>? SAgda8Assorted warnings and errors to be displayed to the userSAgdaClassifying warnings: some are benign, others are (non-fatal) errorsSAgda(warnings that will be turned into errorsSAgdaall warnings, including errors and benign ones Note: order of constructors is important for the derived Ord instanceSAgda2Store a warning and generate highlighting from it.SAgda Raise every WARNING_ON_USAGE connected to a name.SAgda;The only way to construct a empty WarningsAndNonFatalErrorsSAgdarunning the Parse monadSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSNone! #$%-02356789>? SAgdaMark a definition to be inlined if it satisfies the inlining criterion.SSNone! #$%-02356789>?Ž8SAgda A subset of T.TAgda8Ignore additional checks, like termination/positivity...TAgdaDon't ignore any checks.TAgda/Ordered ascendingly by degree of normalization.TAgdaAvailable backends.TAgdaThe T monad. }! state holds the remaining input.TAgda?w2AgdaCallback 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 2 functions:Convert the response into a } representation and print it on standard output (suitable for inter-process communication).Put the response into a mutable variable stored in the closure of the 2< function. (suitable for intra-process communication).2AgdaStatus information.2AgdaGive action result"Comment derived from agda2-mode.elIf 22 is 'Give_String s', then the goal is replaced by s, and otherwise the text inside the goal is retained (parenthesised if 2 is U).2AgdaShould token-based highlighting be removed in conjunction with the application of new highlighting (in order to reduce the risk of flicker)?3Agda4Info to display at the end of an interactive command3Agda,There are two kinds of "make case" commands.3Agda'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.3Agda$Response is list of printed clauses.3Agda(Solution for one or more meta-variables.3Agda)The integer is the message's debug level.3Agda%Clear highlighting of the given kind.3AgdaA command sent when an abort command has completed successfully.3Agda>A command sent when an exit command is about to be completed.3Agda The default 2 function prints certain things to stdout (other things generate internal errors).UAgda!Are implicit arguments displayed?UAgda#Are irrelevant arguments displayed?UAgda.Has the module been successfully type checked?UAgdaEntry in context.UAgdaThe original concrete name.UAgda&The name reified from abstract syntax.UAgda The type.UAgda)The value (if it is a let-bound variable)UAgda Whether the U is in scope.UAgda/Auxiliary information that comes with Goal TypeUAgda Errors that goes into Info_ErrorWhen an error message is displayed this constructor should be used, if appropriate.UAgdaGoals & WarningsUAgdaWhen an error message is displayed this constructor should be used, if appropriate.UAgdaU, denotes either an error or a success (when 3< is present) TODO: split these into separate constructorsUAgda7Yes, remove all token-based highlighting from the file.UAgdaNo.22UUUU2UUU2UU3UUUUUUUUUUUUUUUU3UU333333333333333SUUUUUUUUUUUUUUUUUUUUUUU333333333333332UU3UU3UUUUUUUUUUUUUUUUUUUUUUUSUUUUUUUUUUUUUUUU2UUUU2UUU23None! #$%-02356789>?-"UAgda:Resets the non-persistent part of the type checking state.UAgda&Resets all of the type checking state. Keep only * and backend information.UAgdaRestore ! after performing subcomputation.In contrast to , the ** info from the subcomputation is saved.UAgdaSame as U but also returns the state in which we were just before reverting it.UAgdaSame as U but keep all warnings.UAgda:Allow rolling back the state changes of a TCM computation.UAgdaA fresh TCM instance.The 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.)UAgda Lens for J.UAgdaGet the current scope.UAgdaSet the current scope.UAgda;Modify the current scope without updating the inverse maps.UAgdaModify the current scope.UAgda Get a part of the current scope.UAgda&Run a computation in a modified scope.UAgda#Run a computation in a local scope.UAgdaSame as U-, but discard the scope from the computation.UAgda2Discard any changes to the scope by a computation.UAgda Scope error.UAgdaDebug print the scope.UAgdaUpdate 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.UAgdaRun some computation in a different signature, restore original signature.UAgdaSet the top-level module. This affects the global module id of freshly generated names.UAgdaUse a different top-level module for a computation. Used when generating names for imported modules.VAgda Lens for K.VAgda,Get both local and imported pattern synonymsVAgdaLens getter for * from .VAgda Lens map for *.VAgdaLens getter for * from .VAgdaLens modify for *.VAgda>Look through the signature and reconstruct the instance table.VAgda Lens for K.VAgda4Remove all instances whose type is still unresolved.VAgda/Add an instance whose type is still unresolved.VAgdaAdd instance to some `class'.VAgdaName of the instance.AgdaName of the class.UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUVVVVVVVVVVVVVVVVVVVVVVVVUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUVVVVVVVVVVVVVVVVVVVVVVVVNone! #$%-02356789>?VAgda$Record a function call in the trace.VAgdaReset F' to previous value in the continuation.Caveat: if the last V did not set an V, for example, only set the   with  /, we will revert to the last interesting call.VAgda5Lispify and print the given highlighting information.VAgdaSets 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  ).VAgdahighlightAsTypeChecked rPre r m runs m 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.VAgda rPreAgda r VVVVVVVVVV VVVVVVVVVVNone! #$%-02356789>?@VAgdaPass the current mutual block id or create a new mutual block if we are not already inside on.VAgdaSet the mutual block info for a block, possibly overwriting the existing one.VAgda6Set the mutual block info for a block if non-existing.VAgda&Set the mutual block for a definition.VAgdaGet the current mutual block, if any, otherwise a fresh mutual block is returned.VAgda0Reverse lookup of a mutual block id for a names.VVVVVVVVVVVVVVVVNone! #$%-02356789>?VVVVVVNone! #$%-02356789>?W VAgdaMonad service class containing methods for adding and solving constraintsVAgda#Unconditionally add the constraint.VAgda#Add constraint as awake constraint.VAgdaSolve awake constraints matching the predicate. If the second argument is True solve constraints even if already V.VAgdaGet the awake constraintsVAgdaTakes out all constraints matching given filter. Danger! The taken constraints need to be solved or put back at some point.VAgdaSuspend 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.VAgdaAdd new a constraintVAgdaStart solving constraintsVAgda7Add constraint if the action raises a pattern violation'VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV'VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVNone! #$%-02356789>? WAgdaThese builtins may use postulates, and are still considered --safeWAgdaThese builtins may not use postulates under --safe. They are not automatically unsafe, but will be if they use an unsafe feature.1VVVVVVVVVVVVVVVVVVVVVVVVVVVVVWWWWWWWWWWWWWWWWWWWW1VVVVWWVVVVWWVVVVWVVVVVWWWWWWWWWVVVVVVVWWWWVVVVVWWNone! #$%-02356789>?I WAgdaSets the pragma options.WAgdaSets the command line options (both persistent and pragma options are updated).Relative include directories are made absolute with respect to the current working directory. If the include directories have changed (thus, they are | now, and were previously | something>), then the state is reset (completely, see setIncludeDirs) ./An empty list of relative include directories (| []) is interpreted as ["."].WAgdaDisable display forms.WAgdaDisable display forms.WAgda#Check if display forms are enabled.WAgdaGets the include directories.Precondition: C must be nonempty (i.e. W must have run).WAgdaMakes the given directories absolute and stores them as include directories.If the include directories change, then the state is reset (completely, except for the include directories and J). An empty list is interpreted as ["."].WAgdaSwitch on printing of implicit and irrelevant arguments. E.g. for reification in with-function generation. Restores all B> after completion. Thus, do not attempt to make persistent B changes in a W bracket.WAgdaChange B* for a computation and restore afterwards.WAgda%The base directory of relative paths.WAgda%The base directory of relative paths.WAgda%The base directory of relative paths.WAgdaNew include directories.Agda%The base directory of relative paths.WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWNone# #$%-02356789>?WAgdaPerforms void (noAbs) abstraction over telescope.WAgdaApply Elims 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.WAgdaIf $v$ is a record value, canProject f v returns its field f.WAgdaEliminate a constructed term.WAgdadefApp 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.WAgda  (x:A)->B(x) W [u] = B(u)Precondition: The type must contain the right number of pis without having to perform any reduction.piApply$ is potentially unsafe, the monadic piApplyM is preferable.WAgdaIf permute  : [a] -> [a], then ,applySubst (renaming _ ) : Term  -> Term WAgdaIf permute  : [a] -> [a], then +applySubst (renamingR ) : Term  -> Term WAgdaThe permutation should permute the corresponding context. (right-to-left list)WAgda  projDropParsApply proj o args = K proj o `;` argsThis function is an optimization, saving us from construction lambdas we immediately remove through application.WAgdaTakes off all exposed function domains from the given type. This means that it does not reduce to expose Pi-types.WAgdatelView'UpTo n t takes off the first n exposed function types of t#. Takes off all (exposed ones) if n < 0.WAgdaTurn a typed binding (x1 .. xn : A) into a telescope.WAgdaTurn a typed binding (x1 .. xn : A) into a telescope.WAgda )mkPi dom t = telePi (telFromList [dom]) tWAgda)Uses free variable analysis to introduce 7 bindings.WAgdaEverything will be an 7.WAgdaOnly abstract the visible components of the telescope, and all that bind variables. Everything will be an 7! Caution: quadratic time!WAgdaAbstract over a telescope in a term, producing lambdas. Dumb abstraction: Always produces 7, never 7.$The implementation is sound because 7 does not use 7.WAgdaGiven arguments vs : tel= (vector typing), extract their individual types. Returns Nothing is tel is not long enough.WAgdaIn compiled clauses, the variables in the clause body are relative to the pattern variables (including dot patterns) instead of the clause telescope.WAgdaunivSort' univInf s gets the next higher sort of s), if it is known (i.e. it is not just  UnivSort s).Precondition: s is reducedWAgdaReturns Nothing4 for unknown (meta) sorts, and otherwise returns  Just (b,f) where b indicates smallness and f fibrancy. I.e., b is True# for (relatively) small sorts like Set l and Prop l, and instead b is False for large sorts such as Set.WAgdaCompute the sort of a function type from the sorts of its domain and codomain.WAgdaCompute the sort of a pi type from the sorts of its domain and codomain.WAgdaGiven two levels a and b , compute a E b" and return its canonical form.XAgdaEquality of binders relies on weakening which is a special case of renaming which is a special case of substitution.XAgda Syntactic 7 equality, ignores stuff below DontCare and sharing.XAgda Syntactic 7$ equality, ignores sort annotations.XAgdatel E ( E lhs C rhs : t) becomes tel,  E lhs C rhs : t) we do not need to change lhs, rhs, and t since they live in . See 'Abstract Clause'.XAgda)Make sure we only drop variable patterns.666666669999::::::::::;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWXWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWX66666666None! #$%-02356789>?WYAgda+Create an open term in the current context.YAgdaExtract the value from an open term. The checkpoint at which it was created must be in scope.YAgdaExtract the value from an open term. If the checkpoint is no longer in scope use the provided function to pull the object to the most recent common checkpoint. The function is given the substitution from the common ancestor to the checkpoint of the thing.YAgdaAn I" is closed if it has checkpoint 0.YYYYYYYYNone! #$%-02356789>?RAgdaaddCtx x arg cont add a variable to the context.Chooses an unused .7Warning: Does not update module parameter substitution!RAgda'Add a let bound variable to the contextRAgdaUpdate the context. Requires a substitution that transports things living in the old context to the new.RAgdaGet the substitution from the context at a given checkpoint to the current context.YAgdaWrapper to tell Y not to mark names as D. Used when adding a user-provided, but already type checked, telescope to the context.YAgdaVarious specializations of addCtx.YAgda Modify a F in a computation. Warning: does not update the checkpoints. Use  updateContext instead.YAgda Modify the 7 part of context entries.YAgda7Change to top (=empty) context. Resets the checkpoints.YAgdaChange to top (=empty) context, but don't update the checkpoints. Totally not safe!YAgdaDelete the last n bindings from the context. Doesn't update checkpoints! Use Y or `updateContext rho (drop n)` instead, for an appropriate substitution rho.YAgdaDelete the last n bindings from the context. Any occurrences of these variables are replaced with the given err.YAgda*Add a new checkpoint. Do not use directly!YAgdaGet the substitution from the context at a given checkpoint to the current context.YAgdaGet substitution   E  : 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.YAgda:Default implementation of addCtx in terms of updateContextYAgdaRun 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.YAgda;Go under an abstraction. Do not extend context in case of 7.YAgda"Go under an abstraction, treating 7 as 7.YAgdaGo under an abstract without worrying about the type to add to the context.YAgdaMap a monadic function on the thing under the abstraction, adding the abstracted variable to the context.YAgdaAdd a let bound variableYAgdaAdd a let bound variableYAgdaGet the current context.YAgda$Get the size of the current context.YAgda Generate [var (n - 1), ..., var 0]% for all declarations in the context.YAgda Generate [var (n - 1), ..., var 0]% for all declarations in the context.YAgdaGet the current context as a 7.YAgda1Get the names of all declarations in the context.YAgda0get type of bound variable (i.e. deBruijn index)YAgdaGet 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..RRRRRRYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYY.YYYYYYYRYYRRRRRYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYNone! #$%-02356789>?$ YAgdaSort primitives.YAgdaThe coinductive primitives.YAgdagetTerm use name looks up name as a primitive or builtin, and throws an error otherwise. The use argument describes how the name is used for the sake of the error message.YAgda2Rewrite a literal to constructor form if possible.[AgdaTries to build a Y.[AgdaCheck whether the type is actually an path (lhs D rhs) and extract lhs, rhs, and their type.Precondition: type is reduced.[AgdaNon dependent Path[Agda Revert the 6.Postcondition: type is reduced.[Agda"Get the name of the equality type.[AgdaCheck whether the type is actually an equality (lhs D rhs) and extract lhs, rhs, and their type.Precondition: type is reduced.[Agda Revert the 6.Postcondition: type is reduced.[Agda(Primitives with typechecking constrants.RRYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[RRYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[None! #$%-02356789>?$[AgdaA deep view on sizes.[Agda)A de Bruijn index under some projections.[AgdaA useful view on sizes.[AgdaCheck if a type is the Z type. The argument should be reduced.[Agda)Result of querying whether size variable i is bounded by another size.[Agdayes  i : Size< t[AgdaTest 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.\AgdaIgnore  in equality test.8[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[\\\\\8[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[\\\\\None" #$%-02356789>?9+\AgdaA 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.\AgdaCreate a new module with an empty scope. If the module is not new (e.g. duplicate import$), don't erase its contents. (Just' if it is a datatype or record module.)\Agda"Apply a function to the scope map.\Agda$Apply a function to the given scope.\Agda*Apply a monadic function to the top scope.\Agda&Apply a function to the current scope.\Agda5Apply a function to the public or private name space.\Agda7Run a computation without changing the local variables.\AgdaRun 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).\Agda6Check that the newly added variable have unique names.\AgdaAfter collecting some variable names in the scopeVarsToBind, bind them all simultaneously.\Agda2Create a fresh abstract name from a concrete name.This function is used when we translate a concrete name in a binder. The  ) of the concrete name is saved as the  of the abstract name.\Agda 0freshAbstractName_ = freshAbstractName noFixity'\Agda'Create a fresh abstract qualified name.\Agda>Create a concrete name that is not yet in scope. | NOTE: See  chooseName in *Agda.Syntax.Translation.AbstractToConcrete! for similar logic. | NOTE: See withName in +Agda.Syntax.Translation.ReflectedToAbstract for similar logic.\Agda?Look up the abstract name referred to by a given concrete name.\AgdaLook 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.)\AgdaTest if a given abstract name can appear with a suffix. Currently only true for the names of builtin sorts Set and Prop.\AgdaLook up a module in the scope.\Agda'Get the fixity of a not yet bound name.\Agda+Get the polarities of a not yet bound name.\AgdaCollect the fixity/syntax declarations and polarity pragmas from the list of declarations and store them in the scope.\Agda?Get the notation of a name. The name is assumed to be in scope.\AgdaBind a variable.\Agda;Temporarily unbind a variable. Used for non-recursive lets.\Agda.Bind a defined name. Must not shadow anything.\AgdaBind a name. Returns the C" if exists, but does not throw it.\AgdaRebind 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.\AgdaBind a module name.\AgdaBind a qualified module name. Adds it to the imports field of the scope.\Agda Clear the scope of any no names.\AgdaCreate 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.\Agda*Warn about useless fixity declarations in renaming8 directives. Monadic for the sake of error reporting.\Agda>Check that an import directive doesn't contain repeated names.\AgdaApply an import directive and check that all the names mentioned actually exist.(Monadic for the sake of error reporting.\AgdaTranslation of ImportDirective.\Agda Create a \.\AgdaApply a \.\AgdaTranslation of Renaming.\AgdaOpen a module.\Agda>Open a module, possibly given an already resolved module name.\AgdaOld local scopeAgdaNew local scope\Agda(Restrict search to these kinds of names.AgdaUnless |., restrict search to match any of these names.AgdaName to be resolvedAgda?<\AgdaWe 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 messages\Agda9Translate something in a context of the given precedence.]AgdaAssumes name is not ..\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\None! #$%-02356789>?>*]Agda Variant of ]- which does not insert outermost parentheses.]Agda Variant of ]- which does not insert outermost parentheses.]]]]]]]]]]None# #$%'(-02356789>??]AgdaParses a left-hand side, and makes sure that it defined the expected name.]AgdaParses a pattern.]Agda.Parse a list of expressions (typically from a ') into an application.]AgdaParse an expression into a module application (an identifier plus a list of arguments).]]]]]]]]]]None! #$%-02356789>?B]Agda:When making a function projection-like, we drop the first n arguments.]AgdaTo drop the first n 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.]AgdaUse for dropping initial lambdas in clause bodies. NOTE: does not reduce term, need lambdas to be present.]Agda,NOTE: does not work for recursive functions.]Agda=NOTE: This creates telescopes with unbound de Bruijn indices.]]]]None" #$%-02356789>?]A>SAgdaLookup the definition of a name. The result is a closed thing, all free variables have been abstracted over.SAgda Version that reports exceptions:SAgda4Lookup the rewrite rules with the given head symbol.SAgdaSignature lookup errors.SAgda8The name is not in the signature; default error message.SAgda0The name is not available, since it is abstract.SAgdaLookup a section telescope.If it doesn't exist, like in hierarchical top-level modules, the section telescope is empty.SAgdaUnless 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.]AgdaAdd 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.]AgdaLifts clauses to the top-level and adds them to definition. Also adjusts the funCopatternLHS field if necessary.]Agda#Add a compiler pragma `{-# COMPILE  backend  name  text #-}`]AgdaAdd a section to the signature.The current context will be stored as the cumulative module parameters for this section.]AgdaSets the checkpoint for the given module to the current checkpoint.]AgdaGet 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.]AgdaAdd display forms for a name f0 copied by a module application. Essentially if f can reduce to  xs C A.B.C.f vs (by unfolding module application copies (H), then we add a display form A.B.C.f vs ==> f xs ]Agda>Module application (followed by module parameter abstraction).]AgdaAdd a display form to a definition (could be in this or imported signature).]AgdaFind all names used (recursively) by display forms of a given name.]Agda#Check if a display form is looping.]AgdaCan be called on either a (co)datatype, a record type or a (co)constructor.]Agda?Does the given constructor come from a single-constructor type?5Precondition: The name has to refer to a constructor.]AgdaStandard eliminator for S.]AgdaGet the original name of the projection (the current one could be from a module application).]Agda%Look up the polarity of a definition.]AgdaLook 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 H for the given identifier (which should already exist in the signature).]AgdaReturns a list of length G. If no erasure analysis has been performed yet, this will be a list of |s.]Agda#add data constructors to a datatype]AgdaGet the mutually recursive identifiers of a symbol from the signature.]Agda.Get the mutually recursive identifiers from a H.]Agda'Set the mutually recursive identifiers.]Agda5Check whether two definitions are mutually recursive.]Agda A functiondatarecord 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 MA  where module MA  where f = ... module MA  where ... MA.MA.f [insert  raised by ] ^AgdaInstantiate a closed definition with the correct part of the current context.^Agda'Give the abstract view of a definition.^AgdaEnter 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.^AgdaEnter concrete or abstract mode depending on whether the given identifier is concrete or abstract.^AgdaCheck whether a name might have to be treated abstractly (either if we're ^ 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).?^SSNone" #$%-02356789>?q3^AgdaUnfreeze meta and its type if this is a meta again. Does not unfreeze deep occurrences of metas.^AgdaCheck whether all metas are instantiated. Precondition: argument is a meta (in some form) or a list of metas.^AgdaMonad service class for creating, solving and eta-expanding of metavariables.^AgdaGenerate a new meta variable with some instantiation given. For instance, the instantiation could be a I.^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.^AgdaEta 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.^AgdaInsert a new meta variable with associated information into the meta store.^AgdaCompute 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. This is used for the purpose of deciding if a metavariable is constrained or if it can be generalized over (see Agda.TypeChecking.Generalize).^AgdaCreate I in the current environment.^AgdaChange the ArgInfo that will be used when generalizing over this meta.^AgdaRegister an interaction point during scope checking. If there is no interaction id yet, create one.^AgdaFind an interaction point by   by searching the whole map. Issue 3000: Don't consider solved interaction points.?sT_AgdaStrenghtening.____________________________________None! #$%-02356789>?sNone! #$%-02356789>?t6__None! #$%-02356789>?t__None! #$%-02356789>?tHHHHIIJJJJFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFHHIEEEEEECCCCCCCEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEECCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCEEEDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDCCCCCCCCCCDDDDDEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFGGFFFGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGHHGGGHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIJJJJJJIIIIIIIIIIIIIIJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRSSSSSSSSSSSSSSSSSSSSUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[\\\\\]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^__None! #$%-02356789>?_AgdaGet 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! #$%-02356789>?hLRS____SLRNone! #$%-02356789>?Q_AgdaIf the given list of words is non-empty, print them as debug message (using R$) before raising the internal error.____None! #$%-02356789>?8`AgdaExpand literal integer pattern into suc/zero constructor patterns.`Agda7Expand away (deeply) all pattern synonyms in a pattern.````````None! #$%-02356789>?````````````````````````````````````None! #$%-02356789>?*``````None! #$%-02356789>?`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 7.AgdaName x of the abstraction.AgdaBody (7) b of the 7.AgdaLam i (Abs x b), eta-contracted if possible.````````````````None" #$%-02356789>?kRAgda(Specialized version to put in boot file.`AgdainstantiateFull' `5s metas everywhere (and recursively) but does not `.`AgdaOnly unfold definitions if this leads to simplification which means that a constructor/literal pattern is matched. We include reduction of IApply patterns, as `p i0` is akin to matcing on the i0 constructor of interval.`AgdaIs something (an elimination of) a meta variable? Does not perform any reductions.`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).`AgdaNormalise the given term but also preserve blocking tags TODO: implement a more efficient version of this.`Agda+Meaning no metas left in the instantiation.`AgdaBlocking on all blockers.`AgdaBlocking on any blockers.`AgdaCase 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.`Agda-Throw pattern violation if blocked or a meta.`AgdaIf the first argument is |0, then a single delayed clause may be unfolded.`AgdaReduce 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.`AgdaApply a definition using the compiled clauses, or fall back to ordinary clauses if no compiled clauses exist.`AgdaApply a defined function to it's arguments, using the compiled clauses. The original term is the first argument applied to the third.`AgdaApply a defined function to it's arguments, using the original clauses.3R````````````````````````````````````````````````aa3`````````````````````````````````R```````````a``a``None! #$%-02356789>?$YAgdaA safe variant of W.YAgda+Gather leading s of a type in a telescope.bAgda  [ (i,(x,y)) ] = [(i=0) -> x, (i=1) -> y]bAgdaA telescope split in two.bAgda;The permutation takes us from the original telescope to firstPart ++ secondPart.bAgda(Flatten telescope: ( : Tel) -> [Type ]bAgdaOrder 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.bAgdaUnflatten: turns a flattened telescope into a proper telescope. Must be properly ordered.bAgdaRename the variables in the telescope to the given names Precondition: size xs == size tel.bAgda(Get the suggested names from a telescopebAgda A variant of b 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.bAgda.Split the telescope at the specified position.bAgdaPermute 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):  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) bAgdaRecursively computes dependencies of a set of variables in a given telescope. Any dependencies outside of the telescope are ignored.bAgdaComputes 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.bAgdaSplit a telescope into the part that defines the given variables and the part that doesn't.See .bAgdaAs splitTelescope, but fails if any additional variables or reordering would be needed to make the first part well-typed.bAgdaTry 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.bAgdaTry to eta-expand one variable in the telescope (given by its de Bruijn level)bAgdatelViewUpTo n t takes off the first n function types of t. Takes off all if n < 0.bAgdatelViewUpTo' n p t takes off $t$ the first n (or arbitrary many if n < 0-) function domains as long as they satify p.bAgdatelViewUpToPath n t takes off $t$ the first n (or arbitrary many if n < 0!) function domains or Path types.bAgdaLike telViewUpToPath but also returns the Boundary expected by the Path types encountered. The boundary terms live in the telescope given by the TelView. Each point of the boundary has the type of the codomain of the Path type it got taken from, see  fullBoundary.bAgda8(TelV  b, [(i,t_i,u_i)]) <- telViewUpToPathBoundary n a Input:  E a Output:  E b  E i : I  E [ (i=0) -> t_i; (i=1) -> u_i ] : bbAgda9(TelV  b, [(i,t_i,u_i)]) <- telViewUpToPathBoundaryP n a Input:  E a Output: . E b . E T is the codomain of the PathP at variable i . E i : I . E [ (i=0) -> t_i; (i=1) -> u_i ] : T Useful to reconstruct IApplyP patterns after teleNamedArgs .bAgdateleElimsB args bs = es Input: . E args :  . E T is the codomain of the PathP at variable i . E i : I . E bs = [ (i=0) -> t_i; (i=1) -> u_i ] : T Output: . | PiPath  bs A E es : AbAgda'returns Left (a,b) in case the type is Pi a b or  PathP b _ _ assumes the type is in whnf.bAgdaDecomposing a function type.bAgdaIf the given type is a Pi, pass its parts to the first continuation. If not (or blocked), pass the reduced type to the second continuation.bAgdaIf the given type is a Pi, pass its parts to the first continuation. If not (or blocked), pass the reduced type to the second continuation.bAgda&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.bAgda&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.bAgdaCompute type aritybAgdaStrips all hidden and instance Pi's and return the argument telescope and head definition name, if possible.bAgda:Register the definition with the given type as an instancebAgdaTry 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.bAgdaA set of de Bruijn indices.AgdaOriginal telescope.Agda firstPart mentions the given variables,  secondPart not.bAgdaA list of de Bruijn indicesAgdaThe telescope to splitAgda firstPart5 mentions the given variables in the given order,  secondPart contains all other variablesbAgdaE Agda! E var k : A de Bruijn _level_Agda  E u : AYYYYbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbYbbbbbbbbbbbbbbbbbbbbbbbbbbbYYYbbbbbbbbbbbNone! #$%-02356789>?TbAgda,Instantiate full as long as things are equalbAgda'Syntactic equality check for terms.  checkSyntacticEquality v v' = do (v, v') <- instantiateFull (v, v') return ((v, v'), v==v')  only that v, v' 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.bAgda!Syntactic equality ignores sorts.bAgda Syntactic term equality ignores 7 stuff.bbbbNone# #$%'(-02356789>?bAgda:Convert a term (from a dot pattern) to a DeBruijn pattern.bbbbbbNone! #$%-02356789>? cAgdaA  SingleLevel is a Level3 that cannot be further decomposed as a maximum a E b.cAgdaGet the Z as a 7.cAgda-Raises an error if no level kit is available.cAgda,Checks whether level kit is fully available.cAgdaGiven a level l, find the maximum constant n such that  l = n + l'cAgdaGiven a level l, find the biggest constant n such that n <= lcAgdaGiven a constant n and a level l, find the level l' such that  l = n + l' (or Nothing if there is no such level). Operates on levels in canonical form.cAgdaGiven two levels a and b%, try to decompose the first one as  a = a' E b (for the minimal value of a').cAgda Return the maximum of the given  SingleLevels%\cccccccccccccccccccccccccccccccccccc%ccccccccccccccccc\cccccccccccccccccccNone! #$%-02356789>?cAgdasimplifyLevelConstraint c cs turns an c 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.cAgda Constraint c to simplify.Agda)Other constraints, enable simplification.AgdaJust,: list of constraints equal to the original c. Nothing: no simplification possible.ccNone! #$%-02356789>?cAgdaRun 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.ccccNone! #$%-02356789>?cAgda!A variable can either not occur (c) or it does occur (c). In the latter case, the occurrence may disappear depending on the instantiation of some set of metas.cAgdaTry 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.ccccccccccNone! #$%-02356789>?zcAgdaGiven the type of a constructor (excluding the parameters), decide which arguments are forced. Precondition: the type is of the form  C D vs and the vs are in normal form.cAgda(Assumes that the term is in normal form.ccccccNone" #$%-02356789>?cAgda!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.ccNone! #$%-02356789>?cAgdaRun before serialisation to remove any definitions that are not reachable from the public interface to the module.ccNone! #$%-02356789>?SAgdamatchCompiledE c es% takes a function given by case tree c and and a spine es$ and tries to apply the function to es.cAgdaA 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.cAgdamatch'- 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 nth 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.SScccSScccNone! #$%-02356789>?cAgdaGiven 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 6: field in the clauses belonging to the given functions.cAgdaanysDef names a returns all definitions from names that are used in a.ccccNone! #$%-02356789>?dAgda?dAgdaAlso tracks whether module parameters should be dropped from the patterns.dAgdaLike reify7 but instantiates blocking metas, useful for reporting.dAgdareifyDisplayFormP; tries to recursively rewrite a lhs with a display form.=Note: we are not necessarily in the empty context upon entry!dAgdablankNotInScope e" replaces variables in expression e with _% if they are currently not in scope.dAgdaAssumes that pattern variables have been added to the context already. Picks pattern variable names from context.dAgdaSkip reification of implicit and irrelevant args if option is off.dAgdaLHS head symbolAgda7Patterns to be taken into account to find display form.Agda.Remaining trailing patterns ("with patterns").Agda!New head symbol and new patterns. ddddddddddd dddddddddddNone! #$%-02356789>?GSAgdad without the brackets.dAgdaPretty-print something paired with a (printable) node. | This intermediate typeclass exists to avoid UndecidableInstances.dAgda2Pairing something with a node (for printing only).dAgda!Comma-separated list in brackets.dAgda,Pretty print with a given context precedencedAgda#Proper pretty printing of patterns:eAgda8This instance is more specific than a generic instance  Semigroup a => Semigroup (TCM a).1SSSSSSSSSSSSSSSSS\ddddddddddddddddddddddddddddd1SSSSSSSSSSSSSSSSSddddddddddddddddddddddddddddd\S5S6S6d5None" #$%-02356789>?zeAgdaIn an ambient context , telePiPath f lams  t bs builds a type that can be telViewPathBoundaryP'ed into (TelV  t, bs'). . E t bs = [(i,u_i)]  = 0,(i : I),1 D b D {0,1}. .0 | lams 1 (u_i .b) : (telePiPath f 1 t bs)(i = b) -- kinda: see lams  E telePiPath f  t bseAgdatelePiPath_  t [(i,u)]1  E t i D   E u_b : t for b D {0,1}eAgdaarity of the type, including both Pi and Path. Does not reduce the type.eeeeeeeeeeNone! #$%-02356789>?eeNone" #$%-012356789>?դeAgdaAbbreviation: argN =  .eAgdaAbbreviation: argH =   .-eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee-eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee4e4e4e9 e9 None! #$%-02356789>?fAgdaParse quote.efffffffffffffffffffefffffffffffffffffNone" #$%-02356789>?1fAgda;Define a "ghcomp" version of gcomp. Normal comp looks like:comp^i A [ phi -> u ] u0 = hcomp^i A(1/i) [ phi -> forward A i u ] (forward A 0 u0)So for "gcomp" we compute:gcomp^i A [ phi -> u ] u0 = hcomp^i A(1/i) [ phi -> forward A i u, ~ phi -> forward A 0 u0 ] (forward A 0 u0)The point of this is that gcomp does not produce any empty systems (if phi = 0 it will reduce to "forward A 0 u".fAgda Tries to  primTransp 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.fAgdaLike  transpTel but performing a transpFill./fffffffffffffffffffffffffffffffffffffffffffffff/fffffffffffffffffffffffffffffffffffffffffffffffNone! #$%-02356789>?^fAgdabuildList A ts builds a list of type List A. Assumes that the terms ts all have type A.fAgdamkPrimInjective 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.fAgda primEraseEquality : {a : Level} {A : Set a} {x y : A} -> x D y -> x D yfAgdaGet the + of the principal argument of BUILTIN REFL.Returns Nothing for e.g.  data Eq {a} {A : Set a} (x : A) : A C Set a where refl : Eq x x Returns Just ... for e.g.  data Eq {a} {A : Set a} : (x y : A) C Set a where refl : D x C Eq x x fAgdaUsed for both  primForce and primForceLemma.Reeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0RfffffffffffffffffffffffffffffffffffffffffffffffNone! #$%-02356789>?$SggSNone" #$%-02356789>?&^Agda,Is a type a proposition? (Needs reduction.)^AgdaModify the context whenever going from the l.h.s. (term side) of the typing judgement to the r.h.s. (type side).gAgdaCheck whether something can be used in a position of the given modality.This 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.gAgdaCheck whether something can be used in a position of the given relevance.This 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.gAgdaPrepare parts of a parameter telescope for abstraction in constructors and projections.gAgdaInternal workhorse, expects value of --experimental-irrelevance flag as argument.gAgda(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.gAgda(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 /= RelevantgAgdaApply relevance rel the the relevance annotation of the (typing/equality) judgement. This is part of the work done when going into a rel -context.Precondition: Relevance /= RelevantgAgdaLike g , but only act on context if --irrelevant-projections. See issue #2170.gAgda;Sets the current quantity (unless the given quantity is 1).gAgdaApply quantity q the the quantity annotation of the (typing/equality) judgement. This is part of the work done when going into a q -context.Precondition: Quantity /= Quantity1gAgdaApply inverse composition with the given cohesion to the typing context.gAgda0Can we split on arguments of the given cohesion?gAgda(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.;This function might also do something for other modalities.gAgda(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.This function might also do something for other modalities, but not for quantities.Precondition: Modality /= RelevantgAgdaApply modality m the the modality annotation of the (typing/equality) judgement. This is part of the work done when going into a m -context.Precondition: Modality /= RelevantgAgdaLike g0, but only act on context (for Relevance) if --irrelevant-projections. See issue #2170.gAgdaWake 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 g> 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).#Also set the current quantity to 0.gAgda$Is a type fibrant (i.e. Type, Prop)?gAgdaCofibrant types are those that could be the domain of a fibrant pi type. (Notion by C. Sattler).^^gggggggggggggggggggggggggg^ggggggggggggggggggggg^gggNone" #$%-02356789>?=1_AgdaCheck if a name refers to a record constructor. If yes, return record definition._AgdaCheck 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._AgdaCheck if a name refers to a record. If yes, return record definition.gAgda8Replace projection patterns by the original projections.gAgdaTyping of an elimination.gAgdaType of the argument.gAgda+The type of the record which is eliminated.hAgdaThe type of the field.hAgda*Order the fields of a record construction.hAgdaRaise generated Es as warnings.hAgdaRaise generated E s as errors.hAgda>Order the fields of a record construction. Raise generated Es as warnings.hAgda>Order the fields of a record construction. Raise generated E s as errors.hAgdaA 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.hAgdaA 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.hAgdaA 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.hAgdaGet the definition for a record. Throws an exception if the name does not refer to a record or the record is abstract.hAgda.Get the record name belonging to a field name.hAgda Get the field names of a record.hAgda0Find all records with at least the given fields.hAgda Get the field types of a record.hAgda/Get the field names belonging to a record type.hAgdaReturns the given record type's constructor name (with an empty range).hAgdaReduce 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.hAgdaReduce 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).hAgda*Get the original projection info for name.hAgdagetDefType 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: hAgdaThe analogue of W. 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.hAgdaGiven a head and its type, compute the types of the eliminations.hAgdaGoing under one of these does not count as a decrease in size for the termination checker.hAgdaCheck if a name refers to a record which is not coinductive. (Projections are then size-preserving)hAgdaCheck if a type is an eta expandable record and return the record identifier and the parameters.hAgdaTurn off eta for unguarded recursive records. Projections do not preserve guardedness.hAgdaTurn on eta for inductive guarded recursive records. Projections do not preserve guardedness.hAgdaTurn on eta for non-recursive record, unless user declared otherwise.hAgda1Check whether record type is marked as recursive.9Precondition: record type identifier exists in signature.hAgda etaExpandBoundVar i = (, , )%Precondition: The current context is  = A, x:R pars, A where |A| = i and R4 is a eta-expandable record type with constructor c and fields '.Postcondition:  = A, ', A[c '] and   E  :  and   E  : .hAgda #expandRecordVar i  = (, , , ')Precondition:  = A, x:R pars, A where |A| = i and R7 is a eta-expandable record type with constructor c and fields '.Postcondition:  = A, ', A[c '] and   E  :  and   E  : .hAgdaPrecondition: variable list is ordered descendingly. Can be empty.hAgda curryAt v ( (y : R pars) -> B) n = ( v ->   ys C v  (c ys) {- curry -} , v ->   y C v  (p1 y) ... (pm y) {- uncurry -} ,  (ys : As) C B[c ys / y] )where  n = size .hAgdaetaExpand 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.hAgdaEta expand a record regardless of whether it's an eta-record or not.hAgdaIs the type a hereditarily singleton record type? May return a blocking metavariable.Precondition: The name should refer to a record type, and the arguments should be the parameters to the type.hAgdaReturn the unique (closed) inhabitant if exists. In case of counting irrelevance in, the returned inhabitant contains dummy terms.hAgdaCheck whether a type has a unique inhabitant and return it. Can be blocked by a metavar.hAgdaCheck whether a type has a unique inhabitant (irrelevant parts ignored). Can be blocked by a metavar.hAgdaChecks 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.hAgda(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.hAgda(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.hAgda(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.hAgda*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 .AgdaGiven fields enriched by placeholders for missing explicit fields.hAgda*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 .AgdaGiven fields enriched by placeholders for missing explicit fields.hAgda*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 .AgdaGiven fields enriched by placeholders for missing explicit fields.hAgda"Record type. Need not be reduced.hAgdaHead (record value).Agda Its type.Agda Projection.=______ggggghghhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh=hhhhhhhhhhhh_hhhhh_hhhhhggghgh_hhhh__hhhhhhhhhhhhhh_hhhhhhhggNone! #$%-02356789>?hAgdaState worked on during the main loop of checking a lhs. [Ulf Norell's PhD, page. 35]hAgda#The types of the pattern variables.hAgdaPatterns 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).hAgdaUser patterns of supposed type delta.hAgdaType eliminated by h in the problem. Can be  to indicate that we came by an irrelevant projection and, hence, the rhs must be type-checked in irrelevant mode.hAgda%have we splitted with a PartialFocus?hAgda,The user patterns we still have to split on.hAgdaUser patterns which are typed (including the ones generated from implicit arguments).hAgdaList 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  In this sitation, for clause 2, we construct an initial problem  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.hAgdaThe code that checks the RHS.hAgdaFlexible variables are equipped with information where they come from, in order to make a choice which one to assign when two flexibles are unified.hAgdaWhen 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...hAgdaFrom a record pattern (6). Saves the h of its subpatterns.hAgda-From a hidden formal argument or underscore (WildP).hAgdaFrom a dot pattern (6).hAgda*From a non-record constructor or literal (6 or 6).hAgdaClassify remaining patterns after splitting is complete into pattern variables, as patterns, dot patterns, and absurd patterns. Precondition: there are no more constructor patterns.hAgdaBuild 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.hAgda"The telescope of pattern variablesAgda0The list of user names for each pattern variable=====hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh=====hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhNone" #$%-02356789>?%_AgdaIf matching is inconclusive (DontKnow) we want to know whether it is due to a particular meta variable.`AgdamatchCopatterns ps es matches spine es against copattern spine ps.Returns _ 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 _ if an argument could not be evaluated to constructor form because of a blocking meta variable. In any case, also returns spine es in reduced form (with all the weak head reductions performed that were necessary to come to a decision).`AgdaBuilds a proper substitution from an IntMap produced by match(Co)patternsiAgda Instead of }, we need to use this lazy version of combining pattern matching computations.iAgdaMatch a single copattern.iAgdaMatch a single pattern.iAgdaMatch a single pattern._____```iiiiiiiiii____ii`iii_`i`iiiiNone! #$%-02356789>?1 iAgdaPossible results of i.iAgdaSuccess: this many implicits have to be inserted (list can be empty).iAgdaError: hidden argument where there should have been a non-hidden argument.iAgdaError: bad named argument.iAgdaInsert implicit binders in a list of binders, but not at the end.iAgdaInsert implicit binders in a list of binders, but not at the end.iAgdaimplicitArgs 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.iAgdaimplicitNamedArgs 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.iAgda'Create a metavariable according to the  info.iAgda'Create a questionmark according to the  info.iAgdaIf 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 i exception is thrown.iAgdaIf 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 i exception is thrown.iAgda/Should be non-empty, otherwise nothing happens.Agda7Function type eliminated by arguments given by binders.AgdaPadded binders.iAgda Non-empty.Agda7Function type eliminated by arguments given by binders.AgdaPadded binders.iAgdan0, 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.iAgdan0, 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.iAgdaKind/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.iAgdaKind/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.iAgdaNext given argument a.AgdaExpected arguments ts.iAgdaNext given argument a.AgdaExpected arguments ts. iiiiiiiiiiiii iiiiiiiiiiiiiNone! #$%-02356789>?2iAgda;Insert implicit patterns in a list of patterns. Even if F(, trailing SIZELT patterns are inserted.iAgda(Insert trailing SizeLt patterns, if any.iAgda;Insert implicit patterns in a list of patterns. Even if F(, trailing SIZELT patterns are inserted.iiiiiiiiNone! #$%-02356789>?9iAgdaRename 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.iAgda)Are there any untyped user patterns left?iAgdaConstruct an initial h% from user patterns. Example: @Case : {A : Set} C Maybe A C Set C Set C Set Case nothing B C = B Case (just _) B C = Csample : {A : Set} (m : Maybe A) C Case m Bool (Maybe A C 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:  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)" @iAgdaTry to move patterns from the problem rest into the problem. Possible if type of problem rest has been updated to a function type.iAgdaThe initial telescope delta of parameters.AgdaThe 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.iiiiiiiiiiiiNone! #$%-02356789>?;iAgdaExpand a clause to the maximal arity, by inserting variable patterns and applying the body to variables.iAgdaGet the name of defined symbol of the head normal form of a term. Returns | if no such head exists.iiiiNone! #$%-02356789>?F+_AgdaGet 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.iAgdaArity.iAgdaList of field names.iAgdaGet true constructor with fields, expanding literals to constructors if possible.iAgdaAugment constructor with record fields (preserve constructor name). The true constructor might only surface via reduce.iAgdaIs the datatype of this constructor a Higher Inductive Type? Precondition: The argument must refer to a constructor of a datatype or record.iAgdagetConType c t/ computes the constructor parameters from type t? and returns them plus the instantiated type of constructor c. This works also if t 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.iAgdagetFullyAppliedConType 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.iAgdaReturn 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.iAgdaCheck if a name refers to a datatype or a record with a named constructor.iAgda1Check if a name refers to a datatype or a record.iAgda Precodition: 7 is reduced.iAgda,Precondition: Name is a data or record type.iAgda|! if not data or record type name.iAgda|" if not data or record definition.iAgda 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, ct is the type of the constructor instantiated to the parameters.iAgda 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, ct is the type of the constructor instantiated to the parameters.__iiiiiiiiiiiiiiiii_ii_iiiiiiiiiiiiiiiNone" #$%-02356789>?IoiAgda9Get all symbols that a non-linear pattern matches againstiAgda;Gather the set of pattern variables of a non-linear patterniAgda,Convert from a non-linear pattern to a term.iAgdaTurn 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.iAgda5Only computes free variables that are not bound (see i), i.e., those in a H. iiiiiiiii iiiiiiiiiNone! #$%-02356789>?LjAgdaTake 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 D is raised.jAgdaSplit tree annotated for record pattern translation. type RecordSplitTree = SplitTree' RecordSplitNode type RecordSplitTrees = SplitTrees' RecordSplitNode;Bottom-up procedure to record-pattern-translate split tree.jAgdaReplaces 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.jjjjjjjjNone! #$%-02356789>?XjAgda%Edge labels for the positivity graph.jAgda Monad for computing occurrences.jAgda"Context for computing occurrences.jAgda*Items corresponding to the free variables.=Potential invariant: It seems as if the list has the form genericReplicate n | ++ } (| . j) is, for some n and is, where is! is decreasing (non-strictly).jAgdaName for D builtin.jAgdaUsed to build j and occurrence graphs.jAgdaUsed to build j and occurrence graphs.jAgdaOnlyVarsUpTo n occs* discards occurrences of de Bruijn index >= n.jAgdaCheck that the datatypes in the mutual block containing the given declarations are strictly positive.Also add information about positivity and recursivity of records to the signature.jAgdaRemoves j entries.jAgdaAn interpreter for j.=WARNING: There can be lots of sharing between the generated % entries. Traversing all of these entries could be expensive. (See j for an example.)jAgdaRunning the monadjAgda0Computes the number of occurrences of different js in the given definition.2WARNING: There can be lots of sharing between the % entries. Traversing all of these entries could be expensive. (See j for an example.)jAgda1Computes the occurrences in the given definition.jAgda4Merges two edges between the same source and target.jAgda2WARNING: There can be lots of sharing between the % entries in the edges. Traversing all of these entries could be expensive. (See j for an example.)jAgdaComputes all non-2 occurrence graph edges represented by the given j.2WARNING: There can be lots of sharing between the % 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:% _ } (} [% F, % 0]),% _ } (} [% F, % 0, %]),% _ } (} [% F, % 0, %, %]),% _ } (} [% F, % 0, %, %, %]), and so on.jAgda.The monoid laws only hold up to flattening of j.jAgda1The semigroup laws only hold up to flattening of j.jAgdaThese operations form a semiring if we quotient by the relation "the % components are equal".jAgdaExtension of the j#, usually a local variable context.jAgda&The names in the current mutual block.AgdaThe current name.&jjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjj&jjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjNone! #$%-02356789>?d SAgdaWhich Deftypes are eligible for the principle argument of a projection-like function?SAgdaTurn 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   C D  C C for D a name (Def ) which is S: data  record   postulate.The application of f should only get stuck if the principal argument is inferable (neutral). Thus:a. f cannot have absurd clauses (which are stuck even if the principal argument is a constructor).b. f 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 f waiting for a projection can be stuck even when the principal argument is a constructor.For internal reasons: f cannot be constructor headedf 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.agdajAgda View for a Def f (Apply a : es) where isProjection f. Used for projection-like fs.jAgdaA projection or projection-like function, applied to its principal argumentjAgdaJust a lone projection-like function, missing its principal argument (from which we could infer the parameters).jAgda*Not a projection or projection-like thing.jAgda Semantics of j.jAgda Top-level j (no reduction).jAgdaReduce 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.)jAgdaTurn prefix projection-like function application into postfix ones. This does just one layer, such that the top spine contains the projection-like functions as projections. Used in  compareElims in TypeChecking.Conversion and in Agda.TypeChecking.CheckInternal.If the | is |, a lone projection like function will be turned into a lambda-abstraction, expecting the principal argument. If the | is | , it will be returned unaltered.No precondition. Preserves constructorForm, since it really does only something on (applications of) projection-like functions.SSjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjSSNone! #$%-02356789>?hjAgdaInfer the sort of another sort. If we can compute the bigger sort straight away, return that. Otherwise, return  UnivSort s and add a constraint to ensure we can compute the sort eventually.jAgdaInfer the sort of a pi type. If we can compute the sort straight away, return that. Otherwise, return  PiSort a s2 and add a constraint to ensure we can compute the sort eventually.jAgdaAs  inferPiSort', but for a nondependent function type.jAgda Non-dependent version of ptsRulejAgdaRecursively check that an iterated function type constructed by telePi is well-sorted.jAgdaResult is in reduced form.jAgdaReconstruct the sort of a term./Precondition: given term is a well-sorted type.jAgdaReconstruct the minimal sort of a type (ignoring the sort annotation).jjjjjjjjjjjjjjjjjjjjjjjjjjjjNone! #$%-02356789>?ljAgda/Report a number of names that are not in scope.kAgda.Suggest some corrections to a misspelled name.kAgdaIf there are several warnings, remove the unsolved-constraints warning in case there are no interesting constraints to list.kAgda$Turns warnings, if any, into errors.kAgdaDepending which flags are set, one may happily ignore some warnings.kAgda8Collect all warnings that have accumulated in the state.jAgda Print range?Agda Correction suggestion generator.AgdaNames that are not in scope.kAgdaNames in scope.Agda,Canonization function for similarity search.AgdaA name which is not in scope.Agda"did you mean" hint.SjjjjkkkkkkkkkkkSjjjjkkkkkkkkkkkNone! #$%-02356789>?skAgdaFor each variable in the patterns of a split clause, we remember the de Bruijn-index and the literals excluded by previous matches.kAgdaVariable blocking a match.kAgda/De Bruijn index of variable blocking the match.kAgdaConstructors in this position.kAgdaLiterals in this position.kAgdaTrue if at least one clause has a variable pattern in this position.kAgdaTrue if at least one clause has a lazy pattern in this position.kAgda%Missing elimination blocking a match.kAgdaBlocked on unsplit projection.kAgda!Blocked on unintroduced argument.kAgdaTrue if there are also matching clauses without an unsplit copattern.kAgda Is the unintroduced argument an 5 pattern?kAgdaIf matching is inconclusive (Block) we want to know which variables or projections are blocking the match.kAgdaMatches unconditionally.kAgdaDefinitely does not match.kAgdaBlockedOnProj o" if the clause has a result split.kAgdaBlockingVar i cs ls o means variable i is blocked on constructors cs and literals ls.kAgda3Match the given patterns against a list of clauses.7If successful, return the index of the covering clause.kAgda-A pattern that matches anything (modulo eta).kAgdamatchClause qs i c checks whether clause c( covers a split clause with patterns qs.kAgda+Search for clause that covers the patterns.AgdaPatterns of the current  SplitClause.kAgdaSplit clause patterns qs.AgdaClause c to cover split clause.AgdaResult. If k the instantiation rs such that (namedClausePats c)[rs] == qs.%kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk%kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkNone! #$%-02356789>?tc kkkkkkkkkkkk kkkkkkkkkkkkNone" #$%-02356789>?y kAgdaMatch a non-linear pattern against a neutral term, returning a substitution.kAgdaMatching against a term produces a constraint which we have to verify after applying the substitution computed by matching.kAgda+Telescope of free variables in the equationkAgda8Type of the equation, living in same context as the rhs.kAgda-Term from pattern, living in pattern context.kAgdaTerm from scrutinee, living in context where matching was invoked.kAgdaMonad for non-linear matching.kAgdaAdd substitution  i |-> v : a to result of matching.kAgda?Typed -equality, also handles empty record types. Returns | if the terms are equal, or `Just b` if the terms are not (where b contains information about possible metas blocking the comparison)kAgdaUtility function for getting the name and type of a head term (i.e. a 7 or 7 with no arguments)kAgda3Are 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 patternkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkNone! #$%-02356789>?,lAgda6The call information is stored as free monoid over E. As long as we never look at it, only accumulate it, it does not matter whether we use Set, (nub) list, or Tree. Internally, due to lazyness, it is anyway a binary tree of }; nodes and singleton leafs. Since we define no order on E! (expensive), we cannot use a Set or nub list. Performance-wise, I could not see a difference between Set and list.lAgda2True if thing not eligible for structural descent.lAgdaThing.lAgdaExtract variables from 6;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).lAgdaTermination monad.lAgda Termination monad service class.lAgdaThe termination environment.lAgdaAre we mining dot patterns to find evindence of structal descent?lAgda#The name of size successor, if any.lAgda2The name of the delay constructor (sharp), if any.lAgda/Depth at which to cut off the structural order.lAgda3The name of the function we are currently checking.lAgdaThe names of the functions in the mutual block we are checking. This includes the internally generated functions (with, extendedlambda, coinduction).lAgdaThe list of name actually appearing in the file (abstract syntax). Excludes the internally generated functions.lAgdaDoes the actual clause result from with-inlining? (If yes, it may be ill-typed.)lAgdaTarget type of the function we are currently termination checking. Only the constructors of l are considered guarding.lAgda%Are we checking a delayed definition?lAgdaOnly consider the l |< arguments for establishing termination. See issue #1023.lAgdaOnly consider guardedness if | (not masked).lAgda How many SIZELT relations do we have in the context (= clause telescope). Used to approximate termination for metas in call args.lAgda+The patterns of the clause we are checking.lAgdaNumber 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.lAgdaThe current guardedness status. Changes as we go deeper into the term. Updated during call graph extraction, hence strict.lAgdaWhen 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).lAgdaPattern variables that can be compared to argument variables using SIZELT.lAgdaThe current guardedness level.lAgda+The target of the function we are checking.lAgda!The mutual block we are checking.The functions are numbered according to their order of appearance in this list.lAgda!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.lAgda)Generic run method for termination monad.lAgdaRun TerM computation in default environment (created from options).lAgda Lens for l.lAgda Lens for l.lAgda Lens for l.lAgda9Compute usable vars from patterns and run subcomputation.lAgdaSet l when going under constructor c.lAgdaSet l$ for arguments following projection q. We disregard j j > k: in context. Returns 3 in this case. Overapproximates.lAgda*Print masked things in double parentheses.lAgda*Only show intermediate nodes. (Drop last E).llllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllNone" #$%-02356789>?RAgdaProduces a function which drops the filename component of the qualified name.mAgda3Drops the filename component of the qualified name.RRkkkkkkkkkmmmRmkkkkkkkkkmRmNone! #$%-02356789>?ggmmggNone" #$%-02356789>?smAgdaSize constraints we can solve.mAgda Leq a +n b represents  a =< b + n.  Leq a -n b represents  a + n =< b.mAgdaAtomic size expressions.mAgda)A size meta applied to de Bruijn indices.mAgdaA de Bruijn index.mAgdaCheck whether a type is either not a SIZELT or a SIZELT that is non-empty.mAgda;Precondition: Term is reduced and not blocked. Throws a C if undecidedmAgda-Checks that a size variable is ensured to be > 0. E.g. variable i cannot be zero in context 9(i : Size) (j : Size< C C i) (k : Size< j) (k' : Size< k). Throws a C if undecided.mAgdaCheck whether a variable in the context is bounded by a size expression. If  x : Size< a, then a is returned.mAgdaWhenever we create a bounded size meta, add a constraint expressing the bound. First argument is the new meta and must be a MetaV{}. In boundedSizeMetaHook v tel a, tel includes the current context.mAgda#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.mAgdaCompute the deep size view of a term. Precondition: sized types are enabled.mAgdaCompare two sizes.mAgdaCompare two sizes in max view.mAgdacompareBelowMax u vs checks  u <= max vs. Precondition:  size vs >= 2mAgdaIf F then postpone as constraint, otherwise, fail hard. Failing is required if we speculatively test several alternatives.mAgda3Checked whether a size constraint is trivial (like X <= X+1).mAgda9Test whether a problem consists only of size constraints.mAgda-Test whether a constraint speaks about sizes.mAgda?Take out all size constraints of the given direction (DANGER!).mAgda4Find the size constraints of the matching direction.mAgda.Return a list of size metas and their context.mAgdaCompute 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. mAgdaTurn a constraint over de Bruijn indices into a size constraint.mAgdaTurn a term with de Bruijn indices into a size expression with offset. Throws a C, if the term isn't a proper size expression.mAgdaCompute list of size metavariables with their arguments appearing in a constraint.mAgdaConvert 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.mAgdaMain 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 compatiblemAgda&Old solver for size constraints using Agda.Utils.Warshall6. This solver does not smartly use size hypotheses  j : Size< i.mAgdaTest for being a sized typeAgda Restriction to these directions.mAgdaSize metas and their arity.Agda(Size constraints (in preprocessed form).AgdaReturns False if solver fails.#mmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmm#mmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmNone! #$%-02356789>?}[Agda/What is the polarity of a function composition?[AgdaMain function of this module.mAgda#Get the next polarity from a list, H if empty.mAgdaReplace H by H&. (Arbitrary bias, but better than H, see issue 1596).mAgdaDoes not look into sort.[[mmm[[mmmNone! #$%-02356789>? mAgdaDo a full whnf and treat neutral terms as rigid. Used on the arguments to an injective functions and to the right-hand side.mAgdaDoes deBruijn variable i correspond to a top-level argument, and if so which one (index from the left).mAgdaJoin a list of inversion maps.mAgda%Update the heads of an inversion map.mAgdaPrecondition: all the given clauses are non-absurd and contain a proper match.mAgdaIf 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 `_,_`.mAgdaTurn variable heads, referring to top-level argument positions, into proper heads. These might still be G, but in that case they refer to deBruijn variables. Checks that the instantiated heads are still rigid and distinct.mAgda,Argument should be in weak head normal form.mAgdaPrecondition: The first term must be blocked on the given meta and the second must be neutral.mAgdaThe second argument should be a blocked application and the third argument the inverse of the applied function.mmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmNone" #$%-02356789>?5mAgdafindInstance 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 Nothing when the type of the meta wasn't known when the constraint was generated. In that case, try to find its type again.mmmmmmmmNone" #$%-02356789>? VAgdaguardConstraint c blocker tries to solve blocker first. If successful without constraints, it moves on to solve c, otherwise it adds a c= to the constraint pool, blocked by the problem generated by blocker.VAgda=Don't allow the argument to produce any blocking constraints.WARNING: this does not mean that the given computation cannot constrain the solution space further. It can well do so, by solving metas.mAgdaAdd all constraints belonging to the given problem to the current problem(s).mAgdaRun a computation that should succeeds without constraining the solution space, i.e., not add any information about meta-variables.mAgda,Create a fresh problem for the given action.mAgdaWake constraints matching the given predicate (and aren't instance constraints if m).mAgda4Wake up the constraints depending on the given meta.mAgda1Wake up all constraints not blocked on a problem.mAgdaSolve awake constraints matching the predicate. If the second argument is True solve constraints even if already V.VVVVVVmmmmmmmmmmmmnnnmmmVmmmVVVmmmmmVmnnnVNone" #$%-02356789>?BnAgdaUnification succeeded.nAgdaTerms are not unifiable.nAgda)Unification got blocked on a metavariablenAgda1Some other error happened, unification got stuck.nAgda Result of n.nAgdaUnify 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.nAgdaDon't ever reduce the whole }, 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 }.nAgda gammaAgda flexAgda aAgda usAgda vsnnnnnnnnnnnnnnNone" #$%-02356789>?nAgdathe kill list is empty or only FalsesnAgda0there is no possible kill (because of type dep.)nAgda%managed to kill some args in the listnAgda$all prescribed kills where performednAgdaCollect the *definitely* rigid variables in a monoid. We need to successively reduce the expression to do this.nAgdaExtended occurs check.nAgdaUnfold definitions during occurs check? This effectively runs the occurs check on the normal form.nAgda6The passed modality is the one of the current context.nAgda6Extra environment for the occurs check. (Complements 9.)nAgda*The allowed variables with their variance.nAgdaThe meta we want to solve.nAgda/The size of the typing context upon invocation.nAgdaSet the names of definitions to be looked at to the defs in the current mutual block.nAgda,Is a def in the list of stuff to be checked?nAgda3Remove a def from the list of defs to be looked at.nAgdaCheck whether a free variable is allowed in the context as specified by the modality.nAgdaOccurs check fails if a defined name is not available since it was declared in irrelevant or erased context.nAgdaConstruct a test whether a de Bruijn index is allowed or needs to be pruned.nAgda"Leave the strongly rigid position.nAgdaWhen assigning  m xs := v , check that m does not occur in v# and that the free variables of v are contained in xs.nAgdaprune 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.nAgdahasBadRigid 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.)nAgdaCheck whether a term Def f es is finally stuck. Currently, we give only a crude approximation.nAgdaCheck 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.nAgdakillArgs [k1,...,kn] X prunes argument i from metavar X if ki==True. Pruning is carried out whenever > 0 arguments can be pruned.nAgda;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.nAgdaInstantiate a meta variable with a new one that only takes the arguments which are not pruneable.nAgdaMeta to prune.AgdaArguments to meta variable.Agda,Test for allowed variable (de Bruijn index).nAgda,Test for allowed variable (de Bruijn index).AgdaArgument of meta variable.Agda#Exception if argument is matchable.nAgda,Test for allowed variable (de Bruijn index).nAgda9Arguments 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.0nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn0nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnNone" #$%-02356789>?rRAgda term to checkAgdaits typeAgdathe lockAgdatype of the lockRnnnnRnnNone$ #$%'(-02356789>? *_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 6 (Set)._AgdaCreate a new value meta with specific dependencies without -expanding._AgdaCreate 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 cands 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.For 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 I and the  should point to something I or a I+. Further, the meta variable may not be I.nAgda7Exceptions raised when substitution cannot be inverted.nAgdaCannot recover.nAgda=A potentially neutral arg: can't invert, but can try pruning.nAgda&Try to eta-expand var to remove projs.nAgda?Normalize just far enough to be able to eta-contract maximally.nAgda6Check whether one of the meta args is a projected var.nAgdaFind 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.nAgdaCheck whether a meta variable is a place holder for a blocked term.nAgda8Skip frozen check. Used for eta expanding frozen metas.nAgda4Create a sort meta that cannot be instantiated with 6 (Set).nAgda1Create a sort meta that may be instantiated with 6 (Set).oAgda,Create a new value meta without -expanding.oAgdaCreate a metavariable of record type. This is actually one metavariable for each field.oAgda6Construct a blocked constant if there are constraints.oAgdaunblockedTester t returns a 5 for t.Auxiliary function used when creating a postponed type checking problem.oAgda)Create a postponed type checking problem e : t that waits for type t to unblock (become instantiated or its constraints resolved).oAgda)Create a postponed type checking problem e : t that waits for conditon unblock. A new meta is created in the current context that has as instantiation the postponed type checking problem. An I constraint is added for this meta, which links to this meta.oAgda1Type of the term that is produced by solving the I.oAgda7Eta expand metavariables listening on the current meta.oAgda/Wake up a meta listener and let it do its thingoAgdaEta expand a metavariable, if it is of the specified kind. Don't do anything if the metavariable is a blocked term.oAgdaEta expand blocking metavariables of record type, and reduce the blocked thing.oAgdaassignMeta 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.oAgdaassignMeta' 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.oAgdaCheck that the instantiation of the metavariable with the given term is well-typed.oAgdaGiven two types a and b with a <: b , check that a == b.oAgdaTurn the assignment problem _X args <= SizeLt u into _X args = SizeLt (_Y args) and constraint  _Y args <= u.oAgda Eta-expand bound variables like z in  X (fst z).oAgdaEta-expand a de Bruijn index of record type in context and passed term(s).oAgdaTurn non-det substitution into proper substitution, if possible. Otherwise, raise the error.oAgdaCheck 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 Vars 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.oAgda Turn open metas into postulates.Preconditions: We are Y.F is set to the top-level module.oAgdaSort metas in dependency order.nAgda)a possibly non-deterministic substitutionoAgda"Should the meta be created frozen?AgdaName of record typeAgdaParameters of record type.oAgda 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.oAgdaMeta variable arguments.AgdaRight hand side._____________nnnnnnnnnnnnnnnnnnnnoooooooooooooooooooooooooooooooooooonnnn_nn_nnnoo_o___ooo__o__ooooooooooooooo_ooo_oo_ooooonnnnnnonnnnnoooNone" #$%-02356789>?4oAgda'Size constraint with de Bruijn indices.oAgdaDeBruijn indicesoAgda Living in Context.oAgda Living in Context.oAgda'Size expression with de Bruijn indices.oAgdaSize metas in size expressions.oAgdaDe Bruijn indices.oAgda Identifiers for rigid variables.oAgda$Name for printing in debug messages.oAgdaDe Bruijn index.oAgda,Flag to control the behavior of size solver.oAgda2Instantiate all unconstrained size variables to D.oAgda,Leave unconstrained size variables unsolved.oAgda,Solve size constraints involving hypotheses.oAgda"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 A of N! extended by some local bindings A.  is the current context. The module parameter substitution from current M to N be   E  : A.If M == N=, we do not need the parameter substitution. We try raising.We first strengthen  E c to live in A and obtain cA = strengthen A c. We then transport cA to  and obtain cA = applySubst  cA.)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 A and then raise by A - A0. This "raising" might be a strengthening if A is shorter than A.:(TODO: If the module substitution does not exist, because N is not a parent of M, we cannot use the constraint, as it has been created in an unrelated context.)oAgda0A hazardous hack, may the Gods have mercy on us.To 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.oAgdaReturn the size metas occurring in the simplified constraints. A constraint like C _j =< D : Size simplifies to nothing, so _j would not be in this set.oAgda2Solve a cluster of constraints sharing some metas.oAgdaCollect constraints from a typing context, looking for SIZELT hypotheses.oAgdaConvert 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.oAgdaTurn a constraint over de Bruijn indices into a size constraint.oAgda#Turn a term into a size expression.Returns |, if the term isn't a proper size expression.oAgda&Turn a de size expression into a term.oAgda Only for ;.oAgda*An order which ignores the meta arguments.oAgda-An equality which ignores the meta arguments.oAgda$Assumes we are in the right context.ooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooNone" #$%-02356789>?icAgda9Check 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.cAgda.Check that the first sort equal to the second.cAgda+equalTermOnFace  A u v = _ ,  E u = v : AcAgdaEquality on TypescAgdacompareElims pols a v els1 els2: performs type-directed equality on eliminator spines. t is the type of the head v.cAgda(Type-directed equality on argument listscAgda)Syntax directed equality on atomic valuescAgda)Type directed equality on terms or types.cAgda!Type directed equality on values.oAgdaTry whether a computation runs without errors or new constraints (may create new metas, though). Restores state upon failure.oAgdaTry whether a computation runs without errors or new constraints (may create new metas, though). Return |$ the result upon success. Return | and restore state upon failure.oAgdaCheck if to lists of arguments are the same (and all variables). Precondition: the lists have the same length.oAgdaintersectVars 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.oAgdaRun the given computation but turn any errors into blocked computations with the given blockeroAgda$Ignore errors in irrelevant context.oAgdaTry to assign meta. If meta is projected, try to eta-expand and run conversion check again.oAgdaCompute the head type of an elimination. For projection-like functions this requires inferring the type of the principal argument.oAgdaCheck whether a1 cmp a2% and continue in context extended by a1.oAgdaWhen 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.oAgdaCompare 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...)oAgda 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.oAgdaAccount for situations like k : (Size< j) <= (Size< k + 1)Actually, the semantics is (Size<= k) D (Size< j) E rhs which gives a disjunctive constraint. Mmmh, looks like stuff TODO."For now, we do a cheap heuristics.oAgdaleqInterval r q = r D q in the I lattice. (D r_i) D (D q_j) iff D i. D j. r_i D q_joAgdaleqConj r q = r D q in the I lattice, when r and q are conjuctions. ' (D r_i) D (D q_j) iff ' (D r_i) D (D q_j) = (D r_i) iff ' {r_i | i} D {q_j | j} = {r_i | i} iff ' {q_j | j} E {r_i | i}o 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.4ccccccccccccccccccoooooooooooooooooooooooooooooooooo4cooooocococcoooooocoooooooocooocccooccccccooooooccooNone" #$%-02356789>?noAgdaCheck confluence of the given rewrite rules wrt all other rewrite rules (also amongst themselves).Check confluence of the clauses of the given function wrt rewrite rules of the constructors they match againstoopoopNone$ #$%'(-02356789>?  QAgdarewrite b v rules es tries to rewrite v applied to es with the rewrite rules rules. b is the default blocking tag.RAgdaCheck that the name given to the BUILTIN REWRITE is actually a relation symbol. I.e., its type should be of the form  C (lhs : A) (rhs : B) C Set B. Note: we do not care about hiding/non-hiding of lhs and rhs.pAgdaDeconstructing a type into  C t C t' C core.pAgdaThe whole telescope , t, t'.pAgda.pAgdat.pAgdat'.pAgdacore.pAgdaDeconstructing a type into  C t C t' C core . Returns Nothing if not enough argument types.pAgda? uRAgda)The entry point to the reduction machine.RRRR}2}2None" #$%-02356789>? pAgda+addClause f (Clause {namedClausePats = ps}) checks that f ps$ reduces in a way that agrees with IApply reductions.pAgda"current context is of the form .pAgdaLike  unifyElims but  is from the the meta's MetaInfo and the context extension  is taken from the Closure.pAgda&variables to keep  E x_n .. x_0 : Agda variables to solve . E ts : ppppppppNone! #$%-02356789>? pAgda=Generalize a telescope over a set of generalizable variables.pAgda?Generalize a type over a set of (used) generalizable variables.pAgdaAllow returning additional information from the type checking action.ppppppNone" #$%-02356789>? ^ pAgdaReturn the parameters that share variables with the indices nonLinearParameters :: Int -> Type -> TCM [Int] nonLinearParameters nPars t =pAgdaA 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.pAgdaA Type with sort Type l/ Such a type supports both hcomp and transp.pAgdaType check a datatype definition. Assumes that the type has already been checked.pAgdaEnsure that the type is a sort. If it is not directly a sort, compare it to a n.pAgdaType check a constructor declaration. Checks that the constructor targets the datatype and that it fits inside the declared sort. Returns the non-linear parameters.pAgdaDefine projections for non-indexed data types (families don't work yet). Of course, these projections are partial functions in general.Precondition: we are in the context  of the data type parameters.pAgda&Bind the named generalized parameters.pAgda"Bind the parameters of a datatype.We allow omission of hidden parameters at the definition site. Example:  data D {a} (A : Set a) : Set a data D A where c : A -> D A pAgdaCheck that the arguments to a constructor fits inside the sort of the datatype. The third argument is the type of the constructor.When  --without-K is active and the type is fibrant the procedure also checks that the type is usable at the current modality. See  4784 and 5434.6As a side effect, return the arity of the constructor.pAgdaWhen --without-K is enabled, we should check that the sorts of the index types fit into the sort of the datatype.pAgdaCheck 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).pAgda!Is the type coinductive? Returns |% if the answer cannot be determined.pAgdaName 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).pAgdaPathCons, . E u : R Agda%how to apply a "projection" to a termAgdasome name, e.g. record nameAgda param types Agdafields' types  E Agda fields' namesAgdarecord type  E TpAgdaPathCons, . E u : R Agda%how to apply a "projection" to a termAgdasome name, e.g. record nameAgda param types Agdafields' types  E Agda fields' namesAgdarecord type  E TpAgda%how to apply a "projection" to a termAgdasome name, e.g. record nameAgda param types Agdafields' types  E Agda fields' namesAgdarecord type ( : ) E R[]pAgdaNumber 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.ppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppNone! #$%-02356789>?  cAgdac traverses the whole 76, and we can use this traversal to modify the term.cAgdaInfer type of a neutral term.cAgdaEntry point for term checking.cAgdaCheck if sort is well-formed.cAgda 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 TheorycAgda/Entry point for e.g. checking WithFunctionType.cAgda(The default action is to not change the 7 at all.pAgda/Called on each subterm before the checker runs.pAgda/Called on each subterm after the type checking.pAgdaCalled for each ArgInfo. The first / is from the type, the second from the term.pAgda9Called for bringing projection-like funs in post-fix formpAgdaReturns 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.cpppppcccccccccjppccccccpcpppppcccpjNone! #$%-02356789>? $ppppppppppppppNone! #$%-02356789>? qAgdaWe do a little bit of work here to make it possible to generate nice layout for multi-line error messages. Specifically we split the parts into lines (indicated by n in a string part) and vcat all the lines.qAgda"Argument should be a term of type  Term C 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).qAgdaRaise an error if the  --allow-exec option was not specified.qAgda Convert an ExitCode to an Agda natural number.qAgda=Call a trusted executable with the given arguments and input.*Returns the exit code, stdout, and stderr.qAgda9Raise an error if the trusted executable cannot be found.*ppppqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq*qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqppppqqqqNone! #$%-02356789>? cqAgdaEta-expand a term if its type is a function type or an eta-record type.qAgdaEta-expand functions and expressions of eta-record type wherever possible.qqqqqqNone! #$%-02356789>? #, qAgda subst u . absTerm u == idqAgdaisPrefixOf u v = Just es if v == u ; es.qAgdaabstractType a v b[v] = b where a : v.qAgda3piAbstractTerm NotHidden v a b[v] = (w : a) -> b[w] 3piAbstractTerm Hidden v a b[v] = {w : a} -> b[w]qAgda (piAbstract (v, a) b[v] = (w : a) -> b[w]For the inspect idiom, it does something special: @piAbstract (v, a) b[v] = (w : a) {w' : Eq a w v} -> b[w]For rewrite , it does something special: piAbstract (prf, Eq a v v') b[v,prf] = (w : a) (w' : Eq a w v') -> b[w,w']qAgda This swaps var 0 and var 1.qAgdaIgnores irrelevant arguments and modality. (And, of course, origin and free variables).qAgdaIgnore the tactic.qAgda!Ignore origin and free variables.qAgdaIgnores 7.qAgdaIgnores sorts. qqqqqqqqqqq qqqqqqqqqqqNone" #$%-02356789>? 6qAgda6Split pattern variables according to with-expressions.qAgdaAbstract with-expressions vs+ to generate type for with-helper function.Each  EqualityType, coming from a rewrite , will turn into 2 abstractions.qAgdaFrom a list of with and rewrite; expressions and their types, compute the list of final with" expressions (after expanding the rewrites).qAgdaCompute the clauses for the with-function given the original patterns.qAgda >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 D b  SEq as bs test : (s : Nat  Stream Nat) (t : Stream Nat) C SEq (delay s) t C 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) C (fst w D a)  SEq (snd w) as  = t a as p -- reorder to bring with-relevant (= needed) vars first  = a as t p C  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 [..] is to be understood as substitution. The projection patterns have vanished from ps' (as they are already in qs).qAgdaConstruct 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 qAgda1 context of types and with-arguments.Agda E t type of rhs.Agda  E vs : as+ with arguments and their types. Output:Agda(A,A,,t',vtys') where A:part of context needed for with arguments and their types.A>part of context not needed for with arguments and their types.*permutation from  to AA as returned by b. AA E t'type of rhs under  A E vtys'%with-arguments and their types under .qAgdaA8 context for types of with types.AgdaA,A E vs : raise A as. with and rewrite-expressions and their type.AgdaA E A> context extension to type with-expressions.Agda A,A E b type of rhs.Agda%@A,A E [(i,(u0,u1))] : b boundary.AgdaA C wtel C A@ C b@ such that [vs/wtel]wtel = as and [vs/wtel]A@ = A and [vs/wtel]b@ = b+. Plus the final number of with-arguments.q 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.q 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 ).qAgdaThe name of parent function.AgdaThe name of the with -function.AgdaA The arguments of the with function before the with expressions.AgdaA 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.qqqqqqqqqqqqqqqqNone% #$%'(-02356789>? :#qAgda:The result of termination checking a module. Must be a } and have .qAgda4Entry point: Termination check a single declaration.Precondition: F must be set correctly.qAgda8Entry point: Termination check the current mutual block.qAgda/Extract recursive calls from level expressions.qAgda$Extract recursive calls from a term.qAgda$Extract recursive calls from a type.qAgda*Sorts can contain arbitrary terms of type Level<, so look for recursive calls also in sorts. Ideally, 6; would not be its own datatype but just a subgrammar of 7*, then we would not need this boilerplate.qAgdaThe function names defined in this block on top-level. (For error-reporting only.)qqqqqqNone! #$%-02356789>? :rAgda Check that   E  : .rrrrNone! #$%-02356789>? :rrNone! #$%-02356789>? ;NrrNone" #$%-02356789>? <rAgdaInteraction monad.rAgdaLine reader. The line reader history is not stored between sessions.rrrrrr None" #$%-02356789>? =rAgdaThe JSON version of PrettyTCM , for encoding JSON value in TCMrAgdaTCM monadic version of objectrAgda'Pairs a key with a value wrapped in TCMrAgda"Abbreviation of `_ #= encodeTCM _`rAgdaA handy alternative of r with kind specifiedrAgdaA handy alternative of } with kind specified KLrrrrrrr rrrrrrrLKNone! #$%-02356789>? >-rrrrrrrrrrrrrrrrNone! #$%-02356789>? NrAgda? OrAgda Converts the 2 and 21 fields to strings that are friendly to editors.rAgdaChoose which method to use based on HighlightingInfo and HighlightingMethodrrrrNone! #$%-02356789>? OrrrrNone! #$%-02356789>? P6rrNone! #$%-02356789>? PrrNone! #$%-02356789>? PrrNone! #$%-02356789>? Q\rAgda'Takes the name of the data/record type.SrrrrSNone! #$%-02356789>? QrrrrrrrrrrrrNone! #$%-02356789>? RrrNone! #$%-02356789>? RkrrNone! #$%-02356789>? SsrAgda$Insert unsafeCoerce (in the form of ) everywhere it's needed in the right-hand side of a definition.rAgda/The number of retained arguments after erasure.rrrrNone! #$%-02356789>? VrAgdaCalls 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).Uses the debug printout machinery to relay any progress information the compiler prints to stdout.rAgdaGeneralisation of  callCompiler) where the raised exception is returned.rAgda$Should we actually call the compilerAgdaThe path to the compilerAgdaCommand-line arguments.rAgdaThe path to the compilerAgdaCommand-line arguments.rrrrNone! #$%-02356789>? VrAgda7Turns syntax highlighting information into a JSON valuerAgda:Must contain a mapping for every definition site's module.rrNone! #$%-02356789>? _& SAgdaHighlight a warning. We do not generate highlighting for unsolved metas and constraints, as that gets handled in bulk after typechecking.sAgdaHighlighting levels.sAgdaFull highlighting. Should only be used after typechecking has completed successfully.sAgdaHighlighting without disambiguation of overloaded constructors.sAgdaGenerate syntax highlighting information for the given declaration, and (if appropriate) print it. If the boolean is |, then the state is additionally updated with the new highlighting info (in case of a conflict new info takes precedence over old info).The procedure makes use of some of the highlighting info corresponding to K (that corresponding to the interval covered by the declaration). If the boolean is |, then this highlighting info is additionally removed from the data structure that K refers to.sAgdaGenerate and return the syntax highlighting information for the tokens in the given file.sAgdaGenerate and return the syntax highlighting information for the tokens in the given file.sAgdaGenerate and return the syntax highlighting information for the tokens in the given string, which is assumed to correspond to the given range.sAgda-Prints syntax highlighting info for an error.sAgda Generate highlighting for error.sAgda*Generate syntax highlighting for warnings.sAgdaGenerates and prints syntax highlighting information for unsolved meta-variables and certain unsolved constraints.sAgdaStore a disambiguation of record field tags for the purpose of highlighting.sAgdaDeclaration to highlight.AgdaAmount of highlighting.AgdaUpdate the state?sAgdaThe module to highlight.Agda)The file contents. Note that the file is not read from disk.sAgda*Record field names in a record expression.Agda>Record field names in the corresponding record type definitionSVVsssssssssssssssssssssssssssVVSsssssNone" #$%-02356789>? f sAgda'Result of checking the LHS of a clause.sAgdaThe number of original module parameters. These are present in the the patterns.sAgda : The types of the pattern variables, in internal dependency order. Corresponds to 6.sAgda The patterns in internal syntax.sAgda0Whether the LHS has at least one absurd pattern.sAgdaThe type of the body. Is b if  is defined. 8 to indicate the rhs must be checked in irrelevant mode.sAgdaSubstitution version of  lhsPatterns,, only up to the first projection pattern.  |- lhsPatSubst : . Where  is the argument telescope of the function. This is used to update inherited dot patterns in with-function clauses.sAgdaAs-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).sAgdahave we done a partial split?sAgdaA pattern is flexible if it is dotted or implicit, or a record pattern with only flexible subpatterns.sAgdaBind as patternssAgdaCheck 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.sAgdaLists of flexible patterns are h.sAgda Trace, e.g. F or F.Agda+The name of the definition we are checking.Agda The patterns.AgdaThe expected type  a =  C b.Agda4Module parameter substitution from with-abstraction.AgdaPatterns that have been stripped away by with-desugaring. ^ These should not contain any proper matches.Agda Continuation.ssssssssssssssssssssssssssssssssssssssssssNone" #$%-02356789>? ,QAgdaRun a tactic `tac : Term C TC E` in a hole (second argument) of the type given by the third argument. Runs the continuation if successful.QAgda=Checking a lambda whose domain type has already been checked.QAgdaInfer the type of an expression. Implemented by checking against a meta variable. Except for neutrals, for them a polymorphic type is inferred.QAgdaType check an expression.QAgdaCheck that an expression is a type and infer its (minimal) sort.sAgda(Flag to control resurrection on domains.sAgdaWe are checking a module telescope. We pass into the type world to check the domain type. This resurrects the whole context.sAgdaWe 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.sAgda#Check that an expression is a type.sAgda,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.sAgda?Ensure that a (freshly created) function type does not inhabit 6. 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 t should not matter, as we are only checking whether its sort reduces to 6.;Currently UNUSED since SizeUniv is turned off (as of 2016).Check that an expression is a type which is equal to a given type.sAgdaType check a (module) telescope. Binds the variables defined by the telescope.sAgdaType check the telescope of a dependent function type. Binds the resurrected variables defined by the telescope. The returned telescope is unmodified (not resurrected).sAgdaType check a telescope. Binds the variables defined by the telescope.sAgda0Check the domain of a function type. Used in checkTypedBindings and to typecheck A.Fun cases.sAgdaCheck a typed binding and extends the context with the bound variables. The telescope passed to the continuation is valid in the original context.Parametrized by a flag wether we check a typed lambda or a Pi. This flag is needed for irrelevance.sAgdaAfter a typed binding has been checked, add the patterns it bindssAgda7Check a tactic attribute. Should have type Term C TC E.sAgdaType check a lambda expression. "checkLambda bs e ty" means ( bs -> e) : tysAgdaCheck 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.sAgdaCheck 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.sAgdaCheck 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.sAgdaCheck 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.sAgdaInsert hidden lambda until the hiding info of the domain type matches the expected hiding info. Throws DsAgdacheckAbsurdLambda i h e t# checks absurd lambda against type t. Precondition: e = AbsurdLam i hsAgda,checkExtendedLambda i di erased qname cs e t/ check pattern matching lambda. Precondition: $e = ExtendedLam i di erased qname cssAgdaRun a computation.&If successful, that's it, we are done.If 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.Note that the returned meta might only exists in the state where the error was thrown, thus, be an invalid  in the current state.sAgdaPicks up record field assignments from modules that export a definition that has the same name as the missing field.sAgdacheckRecordExpression fs e t) checks record construction against type t. Precondition  e = Rec _ fs.sAgda 'checkRecordUpdate cmp ei recexpr fs e tPreconditions: e = RecUpdate ei recexpr fs and t is reduced.sAgdaRemove top layers of scope info of expression and set the scope accordingly in the .sAgda*Unquote a TCM computation in a given hole.sAgda-Check an interaction point without arguments.sAgda&Check an underscore without arguments.sAgdaType check a meta variable.sAgdaInfer the type of a meta variable. If it is a new one, we create a new meta for its type.sAgdaType 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.sAgdaTurn a domain-free binding (e.g. lambda) into a domain-full one, by inserting an underscore for the missing type.sAgda,Check arguments whose value we already know.This 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.sAgda.Check an argument whose value we already know.sAgdaCheck a single argument.sAgdaUsed to check aliases f = e. Switches off F+ for the checking of top-level application.sAgda?Check whether a de Bruijn index is bound by a module telescope.sAgda=Infer the type of an expression, and if it is of the form  {tel} -> D vs for some datatype D then insert the hidden arguments. Otherwise, leave the type polymorphic. QAgda Unreduced!sAgda cmpAgda TBind _ _ xps typAgda xpsAgda typAgda bodyAgda targetsAgdaExpected hiding.AgdaExpected to be a function type.AgdaContinuation on blocked type.AgdaContinuation when expected hiding found. The continuation may assume that the Type is of the form (El _ (Pi _ _)).Agda!Term with hidden lambda inserted.sAgdaModules and field assignments.Agda#Names of fields of the record type.Agda)Completed field assignments from modules.sAgdaHow 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.sAgda cmpAgda eiAgda recexprAgda fsAgda e = RecUpdate ei recexpr fsAgdaNeed not be reduced.sAgda Not reduced!sAgda5User-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.sAgdaUser-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.=QQQQQQQssssssssssssssssssssssssssssssssssssssssssssssssssssss=ssQsssssssssssssssssssssssssQssssssssssQQQsQsssssssssQsssssssNone" #$%-02356789>? sAgdabindPostulatedName 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 H of q.sAgda&Bind a builtin thing to an expression.sAgda#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.ssssssssssssNone! #$%-02356789>? d_Agda3Binds the FLAT builtin, and changes its definition._AgdaBinds the SHARP builtin, and changes the definitions of INFINITY and SHARP._AgdaBinds the INFINITY builtin, but does not change the type's definition._Agda The type of L._Agda The type of L_._Agda The type of D.____________None" #$%-02356789>? sAgdaA Covering is the result of splitting a s.sAgdaDe Bruijn level (counting dot patterns) of argument we split on.sAgdaCovering clauses, indexed by constructor/literal these clauses share.sAgdaType of variables in scPats.sAgdaThe patterns leading to the currently considered branch of the split tree.sAgdaSubstitution from s to old context. Only needed directly after split on variable: * To update s * To rename other split variables when splitting on multiple variables. scSubst is not ` transitive', i.e., does not record the substitution from the original context to s over a series of splits. It is freshly computed after each split by computeNeighborhood ; also t, which does not split on a variable, should reset it to the identity ;, lest it be applied to s again, leading to Issue 1294.sAgdaWe need to keep track of the module parameter checkpoints for the clause for the purpose of inferring missing instance clauses.sAgda'The type of the rhs, living in context s. } computes the new s by applying substitution s.sAgda,Project the split clauses out of a covering.sAgdaCreate a split clause from a clause in internal syntax. Used by make-case.sAgda1Top-level function for checking pattern coverage.Effects:3Marks unreachable clauses as such in the signature.0Adds missing instances clauses to the signature.sAgdaTop-level function for eliminating redundant clauses in the interactive case splittersAgdaAdd more patterns to split clause if the target type is a function type. Returns the domains of the function type (if any).tAgdaEntry point from Interaction.MakeCase.tAgdaEntry point from TypeChecking.Empty and Interaction.BasicOps. splitLast CoInductive is used in the refine tactics.tAgdasplitResult for MakeCase, tries to introduce IApply or ProjP copatternstAgdaFor debugging only.sAgdaName f of definition.Agda7Absolute type (including the full parameter telescope).Agda Clauses of f!. These are the very clauses of f in the signature.gsssssssssssssssstttsssssssssssssssstttgNone! #$%-02356789>? ccAgdaCheck whether one of the types in the given telescope is constructor-less and if yes, return its index in the telescope (0 = leftmost).cAgdaEnsure that a type is empty. This check may be postponed as emptiness constraint.cAgda0Check whether some type in a telescope is empty.cAgdaCheck whether a type is empty.cAgdaRange of the absurd pattern.AgdaType that should be empty (empty data type or iterated product of such).ccccccccNone! #$%-02356789>? SAgdaProcess 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.tAgdaStripped-down version of 6 used in clause compiler.tAgda8Pattern variables are considered in left-to-right order.tAgdaStrip down a clause. Don't forget to apply the substitution to the dot patterns!tAgdaGet 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.tAgdaIs is not a variable pattern? And if yes, is it a record pattern and/or a fallThrough one?tAgdaIs this a variable pattern?Maintain invariant: isVar = isNothing . properSplit!tAgdasplitOn single n cs* will force expansion of catch-alls if single.tAgda4Expand 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:  f x false = a f false = _ -> b f x true = c  case tree:  f x y = case y of true -> case x of true -> c false -> b false -> a Example from issue #3628:  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 tAgda? tAgda '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.tAgda(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 checkedtAgdaPosition and other info.AgdaRecord type identifier.AgdaCheck universes?Agda1(Co)Inductive, (No)Eta, (Co)Pattern, Constructor?AgdaRecord parameters.Agda!Approximate type of constructor (fields0 -> Set). Does not include record parameters.AgdaField signatures.tAgdaDatatype name.Agda parameters.AgdaProjection names.Agda E  field types.Agda E T target type.tAgdasome name, e.g. record nameAgda param types Agdafields' types  E Agda fields' namesAgdarecord type  E TtAgdasome name, e.g. record nameAgda param types Agdafields' types  E Agda fields' namesAgdarecord type  E TttttttttttNone" #$%-02356789>? A"_AgdaSet G" 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.tAgda,Which argument indexes have a partial split.tAgdaParameters for creating a with -function.tAgdaParent function name.tAgdaWith function name.tAgdaType of the parent function.tAgdaContext of the parent patterns.tAgdaTypes of arguments to the with function before the with expressions (needed vars).tAgdaTypes of arguments to the with function after the with expressions (unneeded vars).tAgda-With and rewrite expressions and their types.tAgdaType of the right hand side.tAgdaParent patterns.tAgda.Number of module parameters in parent patternstAgdaPermutation resulting from splitting the telescope into needed and unneeded vars.tAgda;Permutation reordering the variables in the parent pattern.tAgdaFinal permutation (including permutation for the parent clause).tAgda'The given clauses for the with functiontAgda-Subtsitution to generate call for the parent.tAgdaA single clause without arguments and without type signature is an alias.tAgda'Check a trivial definition of the form f = etAgda,Type check a definition by pattern matching.tAgdaModify all the LHSCore of the given RHS. (Used to insert patterns for rewrite or the inspect idiom)tAgdaInsert some names into the with-clauses LHS of the given RHS. (Used for the inspect idiom)tAgdaInsert some with-patterns into the with-clauses LHS of the given RHS. (Used for rewrite)tAgdaInsert with-patterns before the trailing with patterns. If there are none, append the with-patterns.tAgdaThe LHS part of checkClause.tAgdaType check a function clause.tAgda3Generate the abstract pattern corresponding to RefltAgdaType check the with and rewrite lhss and/or the rhs.tAgdaInvoked in empty context.tAgdaType check a where clause.tAgdaSet 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)Agdadoes the definition come from an extended lambda (if so, we need to know some stuff about lambda-lifted args)Agdais it a with function (if so, what's the name of the parent function)Agda range infoAgdathe name of the functionAgdathe clauses to checkt Agda'the type we expect the function to haveAgdais it irrelevant (for instance)Agda2are the clauses delayed (not unfolded willy-nilly)Agdadoes the definition come from an extended lambda (if so, we need to know some stuff about lambda-lifted args)Agdais it a with function (if so, what's the name of the parent function)Agda range infoAgdathe name of the functionAgdasubstitution (from with abstraction) that needs to be applied to module parametersAgdathe clauses to checktAgda(Type of function defined by this clause.Agda? 3tAgda-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.ttttNone" #$%-02356789>? QAgdaChecking the type of an overloaded projection application. See }.QAgdaPrecondition: Application hd args = appView e.QAgdacheckApplication hd args e t) checks an application. Precondition: Application hs args = appView echeckApplication1 disambiguates constructors (and continues to }#) and resolves pattern synonyms.QAgdaCheck that a list of arguments fits a telescope. Inserts hidden arguments as necessary. Returns the type-checked arguments and the remaining telescope.QAgda%checkArguments cmp 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.QAgdaComparison for targetAgda)Eagerly insert trailing hidden arguments?AgdaRange of application.AgdaArguments to check.Agda%Telescope to check arguments against.Agda8Checked arguments and remaining telescope if successful.QQQQQQQQQQNone" #$%-02356789>? GQAgda"Check an application of a section.QAgda Type check a single declaration.QAgda&Type check a sequence of declarations.tAgdaCached checkDecltAgdaCheck 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).tAgdaRun a reflected TCM computatation expected to define a given list of names.tAgdaInstantiate all metas in H 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.tAgdaHighlight 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.tAgda Termination check a declaration.tAgda+Check a set of mutual names for positivity.tAgdaCheck that all coinductive records are actually recursive. (Otherwise, one can implement invalid recursion schemes just like for the old coinduction.)tAgda7Check a set of mutual names for constructor-headedness.tAgda4Check 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.tAgda>Freeze metas created by given computation if in abstract mode.tAgdaType check an axiom.tAgdaData 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.tAgda,Type check a primitive function declaration.tAgdaCheck a pragma.tAgda=Type check a bunch of mutual inductive recursive definitions.All definitions which have so far been assigned to the given mutual block are returned.tAgdaType check the type signature of an inductive or recursive definition.tAgdaType check a module.tAgda Helper for Q.Matches the arguments of the module application with the module parameters.Returns the remaining module parameters as an open telescope. Warning: the returned telescope is not the final result, an actual instantiation of the parameters does not occur.tAgdaCheck an application of a section. (Do not invoke this procedure directly, use Q.)tAgdaType check an import declaration. Actually doesn't do anything, since all the work is done when scope checking.QAgdaName m1' of module defined by the module macro.AgdaThe module macro  tel C m2 args.AgdaImported names and modulestAgdaName of applied module.AgdaThe module parameters.Agda(The arguments this module is applied to.Agda>The remaining module parameters (has free de Bruijn indices!).tAgdaName m1' of module defined by the module macro.AgdaThe module macro  tel C m2 args.AgdaImported names and modules$QQQttttttttttttttttttttttttttttttttt$tQQtttttttttttttttttttttttttttQtttttNone! #$%-02356789>? $QQQQtQQtQQNone! #$%-02356789>? otAgda Formats the 21 tag for the Emacs backend. No quotes are added.tAgdaTurns syntax highlighting information into a list of S-expressions.tAgda:Must contain a mapping for every definition site's module.ttttNone! #$%-02356789>? tAgda9Errors which can arise when trying to find a source file."Invariant: All paths are absolute.tAgdaThe file was not found. It should have had one of the given file names.tAgda"Several matching files were found.Invariant: The list of matching files has at least two elements.tAgdaType 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.tAgdaMakes an interface file from an AbsolutePath candidate. If the file does not exist, then fail by returning Nothing.uAgdaConverts an Agda file name to the corresponding interface file name. Note that we do not guarantee that the file exists.uAgdaGiven the module name which the error applies to this function converts a t to a C.uAgdaFinds 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.uAgdaTries to find the source file corresponding to a given top-level module name. The returned paths are absolute.SIDE EFFECT: Updates K.uAgda A variant of u which does not require .uAgdaFinds the interface file corresponding to a given top-level module file. The returned paths are absolute.Raises |+ if the the interface file cannot be found.uAgdaFinds the interface file corresponding to a given top-level module file. The returned paths are absolute.Raises an error if the source file cannot be found, and returns |= if the source file can be found but not the interface file.uAgdaEnsures 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.uAgdaComputes the module name of the top-level module in the given file.If no top-level module name is given, then an attempt is made to use the file name as a module name.tAgda$Path to the candidate interface fileAgdaInterface file iff it existsuAgdaInclude paths.AgdaCached invocations of u. An updated copy is returned.uAgdaPath to the source fileAgda Maybe path to the interface fileuAgdaThe name of the module.Agda"The file from which it was loaded.Agda3The expected name, coming from an import statement.uAgdaThe path to the file.AgdaThe parsed module.tttttttttuuuuuuuuuuutttttuttttuuuuuuuuuuNone" #$%-02356789>? uAgda*Ranges that should be serialised properly.uAgda"Ranges are always deserialised as  .uuuuuuNone! #$%-02356789>? =None! #$%-02356789>? ڊNone! #$%-02356789>? None! #$%-02356789>? $vvvvvvvvNone! #$%-02356789>? ہNone! #$%-02356789>? None" #$%-02356789>? vAgdaEncodes something. To ensure relocatability file paths in positions are replaced with module names.vAgdaDecodes an uncompressed bytestring (without extra hashes or magic numbers). The result depends on the include path.Returns |$ if a decoding error is encountered.vAgdaEncodes an interface. To ensure relocatability file paths in positions are replaced with module names.An uncompressed bytestring corresponding to the encoded interface is returned.vAgda=Decodes an interface. The result depends on the include path.Returns | if the file does not start with the right magic number or some other decoding error is encountered.QvvvvvvvvvvvvvvQNone! #$%-02356789>? vAgdaas seen from inside the modulevAgda*Temporary data type to scope check a file.vAgda/The file path from which we loaded this module.vAgdaThe expected module name (coming from the import statement that triggered scope checking this file).vAgdaThe file content.vAgdaThings that can be translated to abstract syntax are instances of this class.vAgdaThis operation does not affect the scope, i.e. the original scope is restored upon completion.vAgdaThe top-level module name.vAgda Declaration ,open import Agda.Primitive using (Set; Prop) when C.vAgdaContent of interaction hole.wAgda%Top-level declarations are always  (import|open)* -- a bunch of possibly opened imports module ThisModule ... -- the top-level module of this file wAgdaScope check an expression.vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvNone" #$%-02356789>? /wAgdaParses an expression.wAgdaAfter a give, redo termination etc. checks for function which was complemented.wAgdaTry to fill hole by expression.Returns the given expression unchanged (for convenient generalization to w).wAgda!Try to refine hole by expression e.)This amounts to successively try to give e, e ?, e ? ?3, ... Returns the successfully given expression.wAgda9Evaluate the given expression in the current environment wAgdaModifier for interactive commands, specifying the amount of normalization in the output.wAgdaModifier for the interactive computation command, specifying the mode of computation and result display.wAgdaModifier for interactive commands, specifying whether safety checks should be ignored.wAgdaGoals and WarningswAgdaPrint open metas nicely.wAgda2Collecting the context of the given meta-variable.wAgdagetSolvedInteractionPoints True returns all solutions, even if just solved by another, non-interaction meta. getSolvedInteractionPoints False5 only returns metas that are solved by a non-meta.wAgdaCreate type of application of new helper function that would solve the goal.wAgdaGives a list of names and corresponding types. This list includes not only the local variables in scope, but also the let-bindings.wAgdaReturns 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.wAgdaThe 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.wAgdaRuns the given computation as if in an anonymous goal at the end of the top-level module.+Sets up current module, scope, and context.wAgda Parse a name.wAgda8Check whether an expression is a (qualified) identifier.wAgda3Returns the contents of the given module or record.wAgda4Returns the contents of the given record identifier.wAgda)Returns the contents of the given module.wAgdaSkip safety checks?AgdaHole.AgdaThe expression to give.Agda9If successful, the very expression is returned unchanged.wAgdaSkip safety checks when giving?AgdaHole.Agda'The expression to refine the hole with.Agda"The successfully given expression.wAgda!Degree of normalization of goals.Agda(Degree of normalization of hidden goals.wAgda Normalise?wAgda"How should the types be presented?AgdaThe range of the next argument.AgdaThe module name.AgdaModule names, context extension needed to print types, names paired up with corresponding types.wAgda!Amount of normalization in types.Agda%Expression presumably of record type.AgdaModule names, context extension, names paired up with corresponding types.wAgda!Amount of normalization in types.Agda Module name, Nothing if top-level module.AgdaModule names, context extension, names paired up with corresponding types./wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww/wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwNone! #$%-02356789>? 8wwNone" #$%-02356789>? wAgdaLookup 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.wAgdaParse variables (visible or hidden), returning their de Bruijn indices. Used in w.wAgda&Entry point for case splitting tactic.wAgdaMake the given pattern variables visible by marking their origin as  and pattern origin as 6 in the s.wAgdaIf a copattern split yields no clauses, we must be at an empty record type. In this case, replace the rhs by record{}wAgda2Make clause with no rhs (because of absurd match).wAgda*Make a clause with a question mark as rhs.wAgdaThe function name.Agda6The context of the RHS of the clause we are splitting.Agda.The as-bindings of the clause we are splittingAgda,The hole of this function we are working on.AgdaThe range of this hole.Agda9The words the user entered in this hole (variable names).AgdaThe computed de Bruijn indices of the variables to split on, with information about whether each variable is in scope. wwwwwwwwwww wwwwwwwwwwwNone! #$%-02356789>? .wwwwwwxxwwwxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.xxxxxxxxxxwwxxwwwwwxxxxxxxxwwxxxxxxxxxxxxxxxxxNone! #$%-02356789>? uxAgda6Result 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.xAgda#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. xxxxxxxxx xxxxxxxxxNone" #$%-02356789>? ASAgdaScope checks the given module. A proper version of the module name (with correct definition sites) is returned.xAgdaThe result and associated parameters of a type-checked file, when invoked directly via interaction or a backend. Note that the constructor is not exported.xAgdaIs the aim to type-check the top-level module, or only to scope-check it?xAgdaThe decorated source code.xAgda Source code.xAgdaSource file typexAgda*Source location at the time of its parsingxAgdaThe parsed module.xAgdaThe top-level module name.xAgda:The .agda-lib file(s) of the project this file belongs to.xAgda%Flattened unidirectional pattern for x! for destructuring inside the J field.xAgda&Parses a source file and prepares the x record.xAgdaType 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 x is x, 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 (J). Note, however, that if the file has already been type-checked, then a complete interface is returned.xAgda.Read interface file corresponding to a module.xAgda7Should the file be type-checked, or only scope-checked?AgdaThe decorated source code.SxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxSxxxNone! #$%-02356789>? xxNone" #$%-02356789>? xAgda$Sets up the compilation environment.xAgdaConjunctive semigroup (x is absorbing).xxxxxxxxxxxxxxxxxxxxxxxxxxxxNone! #$%-02356789>?  xAgda Classify FOREIGN Haskell code.xAgda3A pragma that must appear before the module header.xAgdaAn import statement. Must appear right after the module header.xAgda1The rest. To appear after the import statements.xAgda GHC backend translation pragmas.xAgda'@COMPILE GHC X = data D (cA | ... | cA)xAgda COMPILE GHC x as fyAgdaGet content of  FOREIGN GHC pragmas, sorted by x2: file header pragmas, import statements, rest.yAgda Classify a  FOREIGN GHC declaration.yAgdaClassify a Haskell pragma into whether it is a file header pragma or not.yAgdaPartition a list by x attribute.xxxxxxxxxxxxxxyyyyyyxxxxxxxxxxyyyxxxxyyyNone" #$%-02356789>? yAgdaThe default compilation monad is the entire TCM (L) enriched with our state and module infoyAgdaTransformer adding read-only module info and a writable set of imported modulesyAgdaMonads that can produce an  HsModuleEnvyAgdaThe name of the Agda moduleyAgdaWhether this is the compilation root and therefore should have the main& function. This corresponds to the IsMain flag provided to the backend, not necessarily whether the GHC module has a main function defined.yAgda3Whether the current module is expected to have the main& function. This corresponds to the IsMain flag provided to the backend, not necessarily whether the GHC module actually has a main function defined.yAgdaThis is the same value as curMName,, but does not rely on the TCM's state. (curMName, and co. should be removed, but the current Backend2 interface is not sufficient yet to allow that)yAgdaGet the Haskell module name of the currently-focused Agda moduleyAgda0Name for definition stripped of unused argumentsyAgda:Can the character be used in a Haskell module name part (conid)? This function is more restrictive than what the Haskell report allows.yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyNone! #$%-02356789>? yAgdaHaskell module names have to satisfy the Haskell (including the hierarchical module namespace extension) lexical syntax: 4modid -> [modid.] large {small | large | digit | ' }y is an injective function into the set of module names defined by modid. The function preserves .s, and it also preserves module names whose first name part is not y.3Precondition: The input must not start or end with ., and no two .s may be adjacent.yyNone! #$%-02356789>? (yyyyyyyyyyyyNone! #$%-02356789>? =yAgda7Check that the main function has type IO a, for some a.yAgda,Haskell modules to be imported for BUILT-INsyAgda)Definition bodies for primitive functionsyyyyyyyyyyyyyyyzyyyyyyyyyyyyyyyzNone! #$%-02356789>? zzzzzzzzYNone$ #$%'(-.02356789>? Agda%Look for a backend of the given name.AgdaAsk the active backend whether a type may be erased. See issue #3732.zAgda0Optional version information to be printed with  --version.zAgdaDefault optionszAgdaBackend-specific command-line flags. Should at minimum contain a flag to enable the backend.zAgda%Unless the backend has been enabled, runAgda- will fall back to vanilla Agda behaviour.zAgdaCalled after type checking completes, but before compilation starts.zAgda3Called after module compilation has completed. The IsMain argument is NotMain if the  --no-main flag is present.zAgdaCalled 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. Will be Nothing if only scope checking.zAgda? Lw zAgda Restore both  and T.zAgdaRestore , do not touch T.zAgdaBuild an opposite action to } for state monads.zAgda Opposite of } for T.This function should only be applied to computations that are guaranteed not to raise any errors (except for Cs).zAgda?Lift a TCM action transformer to a CommandM action transformer.zAgdaDitto, but restore state.zAgda1Put a response by the callback function given by J.zAgda A Lens for T.zAgda A Lens for T.zAgda*Do setup and error handling for a command.zAgdaRun an T) value, catch the exceptions, emit output!If an error happens the state of T does not change, but stPersistent may change (which contains successfully loaded interfaces for example).zAgdaIf the next command from the command queue is anything but an actual command, then the command is returned.If the command is an T 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.zAgdaCreates a command queue, and forks a thread that writes commands to the queue. The queue is returned.zAgdaCan the command run even if the relevant file has not been loaded into the state?zAgdaShould 3& be issued after the command has run?zAgdaInterpret an interactionzAgdaSolved goals already instantiated internally The second argument potentially limits it to one specific goal.zAgda"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 x.zAgdaSet F to T , if any.zAgda)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 ii by the newly created interaction points in the state if safety checks pass (unless force is applied).zAgda/Sorts interaction points based on their ranges.zAgdaDisplays the current goal, the given document, and the current context.Should not modify the state.zAgdaShows all the top-level names in the given module, along with their types.zAgdaShows all the top-level names in scope which mention all the given identifiers in their type.zAgda"Explain why something is in scope.zAgdaSets the command line options and updates the status information.zAgda!Computes some status information.Does not change the state.zAgda'Displays or updates status information.Does not change the state.zAgda display_info does what  display_info' False does, but additionally displays some status information (see z and z).zAgdaParses 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.zAgdaTell to highlight the code using the given highlighting info (unless it is Nothing).zAgdaTells the Emacs mode to go to the first error position (if any).zAgdarunAgdaliftAgda(reverse lift in double negative positionzAgdarunAgdaliftAgda(reverse lift in double negative positionzAgdaReturns the next command.zAgdaFile to load into interaction.Agda'Arguments to Agda for loading this fileAgdaAllow unsolved meta-variables?Agda+Full type-checking, or only scope-checking?Agda&Continuation after successful loading.zAgda Should safety checks be skipped?zAgdaThe command to perform.AgdaThe expression to parse.-zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz-zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzNone! #$%-02356789>? MzAgdaz is a fake ghci interpreter for both the Emacs the JSON frontendzzNone! #$%-02356789>? ODzAgdaz is a fake ghci interpreter for the Emacs frontend and for interaction tests.z reads the Emacs frontend commands from stdin, interprets them and print the result into stdout.zAgdaSerializing Info_ErrorzAgda,Pretty-prints the type of the meta-variable.wwzzzzzwwzzzNone! #$%-02356789>? PzAgdaz is a interpreter like z#, but outputs JSON-encoded strings.z( reads Haskell values (that starts from IOTCM ...) from stdin, interprets them, and outputs JSON-encoded strings. into stdout.zzNone! #$%-02356789>? PzNone! #$%-02356789>? Q/zzNone# #$%&-02356789>? Ur}AgdaThe parser uses a Position which includes a source filename for error reporting and such. We don't actually get the source filename with an  Interface, and it isn't necessary to look it up. This is a "nice-to-have" parameter.}AgdaCount extended grapheme clusters rather than code points when generating LaTeX.}Agda Output items.}Agda+Log LaTeX messages using a provided action.This could be accomplished by putting logs into the RWST output and splitting it into a WriterT, but that becomes slightly more complicated to reason about in the presence of IO exceptions.We want the logging to be reasonbly polymorphic, avoid space leaks that can occur with WriterT, and also be usable during outer phases such as directory preparation.? UzNone! #$%-02356789>? V*zzNone! #$%-02356789>? W}AgdaOptions for HTML generation}Agda#Determine how to highlight the file}Agda1Bundle up the highlighting info for a source file}}}}}}}}}}}}}}}}}None! #$%-02356789>? W~zNone! #$%-02356789>? WzzNone! #$%-02356789>? ^azAgdaConstructor coverage monadzAgda&Constructor coverage monad transformer{Agda9Environment for naming of local variables. Invariant: reverse ccCxt ++ ccNameSupply{AgdaSupply of fresh names{AgdaNames currently in scope{AgdaThe main6 function definition(s), if both the module is the IsMain& module (root/focused) and a suitable main function was defined.{AgdaModule compilation environment, bundling the overall backend session options along with the module's basic readable properties.{AgdaMonads that can read  GHCOptions{AgdaThe options derived from GHCFlags and other shared options.{Agda)Use the compiler at PATH instead of "ghc"{Agda)Use the compiler at PATH instead of "ghc"{Agda"We do not erase types that have a x pragma. This is to ensure a stable interface to third-party code.{Agda.Initial environment for expression generation.{Agda%Term variables are de Bruijn indices.{Agda'Introduce n variables into the context.{AgdaExtract Agda term to Haskell expression. Erased arguments are extracted as (). Types are extracted as ().{AgdaTranslate a non-application, non-coercion, non-constructor, non-definition term.{Agda"Are we looking at the main module?Agda Path to the .agdai file.Agda2Could we confirm the existence of a main function?{Agda"Are we looking at the main module?AgdaCompiled module content.{Agda%Is the type inductive or coinductive?zzz{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{zz{{{{{{{{{{{{{{{{{{{{{{{z{{{{{{None! #$%-02356789>? cy{AgdaRemove spaces etc. See  8https://en.wikipedia.org/wiki/Minification_(programming).{Agda'Run generated code through interpreter.{AgdaAfter all modules have been compiled, copy RTE modules and verify compiled modules.|Agda3Ensure that there is at most one pragma for a name.|Agda5Cubical primitives that are (currently) not compiled.;TODO: Primitives that are neither part of this set nor of |, and for which |5 does not return anything, are silently compiled to <. Thus, if a cubical primitive is by accident omitted from |, then programs that should be rejected are compiled to something which might not work as intended. A better approach might be to list exactly those primitives which should be compiled to .|Agda*Primitives implemented in the JS Agda RTS.0{{{{{{{{{{{{{{{{{{{{{{{{{{||||||||||||||||||||||0{{{{{{{{{{{{{{{{{{{{{{{{{|||{|||||||||||||||||||ZNone! #$%-02356789>? dNone! #$%-02356789>? g |AgdaMain execution mode|AgdaThe main function|Agda5The main function without importing built-in backends|AgdaDetermine the main execution mode to run, based on the configured backends and command line options. | This is pure.|Agda)Run Agda with parsed command line options|AgdaPrint usage information.|AgdaPrint version information.|AgdaWhat to do for bad options.|Agda6Run a TCM action in IO; catch and pretty print errors.|AgdaBackend interactionAgda program nameAgdaparsed command line options||||||||||||||||||||||||||||||||||||||||||||||||||             !!!!!!!!!!!!!!!!!!!""""""""############################$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$%%%%%%%%%%%%%%&&&&&&&&&&&&&&&&&&&&''''''''''''''''((((((((((((((((((((((((((((((((((((())))))****++++++++++++++++++,,,,----------.............................///////////////////////////// / / / / / / / / / / / / / / / / / / / 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 2   3 33 33 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 44 4              5 5 55 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 7 7 77 77 77 77 777 7 777 7 77 7 7 7 7 7 7   8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 88 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 88 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 9 9 9 9 9 9 9 9 9 9 9          : : : : : :: : : : : : : : : : : : ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ;                < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < <                                             = = = = = = = = = = = = = = = = > > > > > > > > > > > > > > > > > > > > > > > > > > > > > ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? @ @ @@@ @ @ @ @ @ @ @ @                                    A A A A A A A A A A A A A A A A A A A A A AAAAAAAAAAABBBBBBBBBBBBBBBBCCCCCCDDDDDD DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDEEEEEEEEEEEEEEEEEEEE EEEEEEEEEEEEEEEEEEEEEEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHI IIIIIIIII I I I I I I IIIIJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJ JJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOOOOOOOOOOOOOOOOOOOOOOOOPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPQ QQQQQQQQQQQQQQQRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRSSSSSS SS SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSTTTTTTTTTTTTTTTTTTUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUVWWXXXX X X X X X X X X XX X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X 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 XXX X X X Y Y Y Z [ [ [ [ [ [ [ [ [ [ [ [ [![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![!\!\!\!\!\!\!\!\!\!\!\!\!\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\ \"\"\"\"\"\ \"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\ \ \ \"\"\"\"\"\"\"\"\"\"]"]"]"]"]"]"]"]"]"]"]"]"]"]"^"^"^"^"^"^"^"^"^"^"^"^"^"^"^"^"^"^"^"^"^"^"^"^"^"^"^"^"^"^"^"^"^"^"^"^"^"^"^"^"^"^"^"^"^"^#^#^#^#^#^#^#^#^#^#^#^#^#^#^#^#^#^#^#^#^#^#^#^#^#^#^#^#^#^#^#^#^#^#^#^#^#^#^#^#^#_#_#_#_#_#`#`#```#`#``#`#`#`#`#`#`#`#`#`#`#`#`#`#`#`#a#a#a#a#a#a#aa#aa#a#a#a#aaa#a#a#a#a#a#a#a#a#a#bb#b#b#b b#b#b#b#bb#b#b#b#b#bb#b#c#c#c c ccc#c#c#c#c#c#cc#ccc#cccc#c#cc c c c#c cccc c#c#c c#c#cc#c#c#c#c#c#c#c#c#c#c#c c c#c#c$c$d$d$d$d$d$d$d$d$d$d$d$d$d$d$d$d$d$d$d$d$d$d$d$d$d$d$d$d$d$d$d$d$d$d$d$d$d$d$d$d$d$d$d$d$d$d$d$d$d$d$d$d$d$d$d$d$d$d$d$d$d$d$d$d$d$d$d$d$d$d$d$d$e$e$e$e$e$e$e$e$e$e$e$e$e$e$e$e$e$e$eee$e$e$e$e$e$e$e$e$e$e$e$e$e$e$e$e$eeee$e e$ee ee$e$e$ee$e$e$e$e$ee$e$e$e$e$e$e$e$e$e$e$e$e$e$e%e%e%e%e%e%e%e%e%e%e%f%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g g%g%g$g%g%g$g%g%g%g%g%g$g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%h&h&h&h&h&h&h&h&h&h&h&h&h&h&h&h&h&h&h&h&h&h&h&h&h&h&h&h&h&h&h&h&h&h&h&h&h&h&h&h&h&h&h&h&h&h&h&h&h&h&i&i&i&i&i&i&ii&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&i&ii&i&i&i&i&ii&i&i&ii&i&ii&i&i&ii&i&i&i&ii&i&i&i&ii&i&i&ii&iii&ii&i&i&i&i&i&i&ii&i&iiii&i&i&i&i&i&i&i&i&i&i&i&i&i&i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'iii'i'i'i'i'i'i'ii'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'iii'ii'ii'i'i'i'ii'i'i'ii'i'ii'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'i'ii'i'i'i'i'i'i'i'i'i'i'i'i'i'i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i)i)i)i)i)i)i)i)i)i)i)i)i)i)i)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j#j)j)j)j)j)jj)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)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k*k*k*k*k*k*k*k*k*k*k*k*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*mmm*m*m&m*m*m*m*m*m*m*m*m*m*m*m$m*m*m*m*m*mm*m*mm*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*m*n*n*n*n*n*n*n*n*n*n*n*n*n*n*n*n*n*n*n*n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o o+o+o+o+o+o+o o+o+o+o+o+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+q+q+q+q+q+q+q+q+q+q+q q+q+q+q+q+q+q+q+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,rrr,r,r,r,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,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,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-u-u-u-u-u'u-u-u-u-u-u-u-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-vv-v-v-v-vvvv-v-v-v-v-v-v- - #      - w-w-w-w.w.w.w.w.w.w.w.w.w.w.w.w.w.w.w.w.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.ww.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.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/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/w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0w0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x,x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1y1y1y1y1y1y1y1y1y1y1y1y1y1y1y1y1y1y1y1y1y1y1y1y1y1y1y1y1y1yy1y1y1y1y1y1y1y,y1y1y1y1y1y1y1y%y1yyy&y1yyy&yy1y&y2yy yy2yyy2yy&y2yy2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2y2z2z2z2z2z2z2z2z2z2z2z2z2z2z2z2z2z2z2z2z2z2{{2{${2{2{{2{2{2{2{2{2{2{2{2{2{{2{2{2{2{2{2{2{2{{2{2{{2{2{2{2{2{2{2{2{2{2{2{2{2{2{2{2{2{2{2{2{2|2|2|2|2|!|3|3|3|3|3|3|3|3|3|3|3|3|3|3|3|3|3|3|3|3|3|3|3|3|3|3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}}}}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3}3~3~3~3~3~%~3~3~3~$~~~~$~3~3~3~3~3~3~3~3~3~3~33333333333333333333333333333333333 333333333333333344444444444444 444444444444444444444444444444444444 44444 "44444444444444444444444444444444444444444444444444444444444444444444444444444444455555555555555555555555555555555555555555555555555555555555555555555555$555555555555555'55'5'55555555555555555555555555555554555555*5555555666666666'66666666666666666*6'6666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666677777777777777777777777777777777777777777777777777777777777777,77777777777777777777777777777777,,,7777777777777777777777777777777777888888888888888888888888888888888888888888888888888888888888*888888888888888888888888888888888888888888888888888888888888888888888888899999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999#99999 99999999999999999999999:::::*,&&:,&:56:'5'5''5:::::::!664::,)7:74:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::6::::::::::::::::::::::::;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;&;';555555''''';''';';''''''''';;;;;;;''&;;;;;;;;';';;;;;;;;:;5;;;;;;;;;;;;;'''''''''''';&&;;;;;;&&&;&&&&&&&&&&0&,&&&&;&&&,&&;;;&&<<<<<<<<<<'<4&&''''''''''<'''''<<<<<<''<<<'<<<<<<<<<<<<<<77<<7<<<(<<<<<<<<(<((((<<<<<((((<<<<(<<<<(((<<(<<<((<(<<<<<<<<<<<<<<<<<<<<<<<<<()<()<<<<<<<<<<<<<<<()<<<<<<<<<<<<<()((((<<<<<()(<<<==()(===========77777=7=============+=+++========&=='=='=======+=+=+=====+==++=+++++++=+===+======================**=*===::=====5========*==**=*======================1====>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >> >>>>>>$$>>>>$> >>.  > >>%  %>>>2>>>>>>>>>%>>> >>>>%%%>>>%%  %%>>>>>>>>>>>>??????????????????????????????????????&????????????????????????????????????????????????????????????????????????????????????????????@@@@@@@@@@@@@@@@@@@@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@Q@QAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQBQBQBQBQBQBQBQBQBQBQBQBQBQBQBQBQBQBQBQBQBQBQBQ!QBQBQBQBQBQBQBQBQBQBQBQBQBQBQBQAQBQBQBQBQBQBQBQBQBQBQBQBQBQBQBQBQBQBQBQBQBQBQBQBQBQBQBQBQBQBQBQBQQBQBQBQBQBQBQBQBQBQBQBQBQBQBQBQBQBQBQBQBQBQBQBQBQBQBQBQBQBQBQBQBQBQBQBQBQBQBQBQBQBQBQBQBQBQBQBQBQBQBQBQBQBQBQBQBQBQBQBQBQBQBQBQCQCQCQCQCQCQ3QCQ*QCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQ,QCQCQCQ1QQQQ&QCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQCQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQ*QCQDQDQDQDQDQDQDQDQDQDQ0QDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQ;Q;QDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQDQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQQEQEQEQ0Q0QEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQ&QEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQ&QEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQ QEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQ>QEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQEQFQFQFQFQFQFQFQFQFQFQFQFQFQFQ0Q0QFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQFQ"QFQFQFQFQFQFQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQGQ0QGQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQHQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQ QIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQIQJQJQJQJQJQJQJQ0QJQ0QJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQ0QJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQJQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQ1QKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQ1QKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQ:QKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQKQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQ QLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQLQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMQMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM%MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN       NNNNNOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO#OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO<OOOOOOOOOOOOOOOOOOOOOOOOOOOOPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP:PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPzPzPzPz2zPzPzPzPzPzPzPzPzPzPzPzPzPzPzPzPzPzPzPzPzPzPzPzQzQzQzQzQzQzQzPzQzQzQzQzQzQzQzQzQzQzQz1zQzQzQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ>QQQQQRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRNRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS<'=SSSSSSSSSSSSSSSSSSSSSSSSS=SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT"TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVWWWWWWWWWWWWWWWWW WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWNWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXQXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXYYYYYYYYYYYYYYYYYYYYYYYYYYYYY YYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYY;YYYYYYYYZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ''ZZZZZZZZZZ9ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ[[[[[[[[[[[[[[[[[[UQ[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[*[[[[[[[[[\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^_____________3_____________________________________________________________________________________________________________________XX        ````J`````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc'c'ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddeeeeeeeeeeeee$$%eeeeeeeeeeeeeeeeeeeeee$eeeeeeeeeeeeeeeee9eeeeeeeeeeeeee%ee%%%%%%eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeffffffff[[ff3fffffffffffSfdffffffffffffffffffffffffffffffffffffffffff3fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggg ggghhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhZhhhhhhhhhhhhhhhhiiiiiiiiiiiiPiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii;iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiggiijjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk_kkkkkkkkkkkkkkkkkkkk'kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkllllllllllllllllllllllllllllllllllllllllllllllllllll^^^^lllllllllllllllllllllllllllllllll l l l l l l l l l l l l l l l l llll43lllll9llllllllllllllllllmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmm*mmmmmmmmmmmmmmmmmmm666mmmmmmmmmmmmmmmmmmmmmmmm8mmmmmmmmmmmmmmmmmmmmmmmmmmmmmnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn,nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnoooooo,ooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppqqqqqqqqqqqqqqqqqqqqq_q_qqq'qqqq__qqqqq__q_qqqqqqqqqqq_qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqrrrrrrrrrrrrrrrrrrr1rrrrrrrrrr rrrrrrrrrrrrrrrrrrrrrrrrrr9rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr'rrrrsssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssss#sssssssssssss#sssssssssssstttttttttYtYtYYtYtYtYtYtYtYtYtYtYtYtYtYtYtY YtYtYtYtYtYtYttttttttttttt ttttttttttttttttqttttttttttttttttrtttttttttttttttttttttttttttttttttttttttttttttttjtttttttttuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu4u3uuuuuuuuuuuuuuuusuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu4uuuuuuuuuuvvvvvvvvvvvvvvvvvvvvvvvvvvXXvvvvvvvvvvvvvvvvvvv@vvvvvvvvvvvvvvvvvvvvvv%v%#vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv vvvvvvvvvvvvvvvvvvvvvvvvvvv?vvvvvvvvvvvvvwvwwvwwwwwwwwwwwwwwwwwwwww#wwwYwvw$wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww!Agda-2.6.2-I0Qlyix7vKjGEzjSnBhBdjAgda.Utils.List2Agda.Utils.SemigroupAgda.Utils.MonadAgda.Utils.SmallSetAgda.Utils.CallStackAgda.Utils.FunctorAgda.Utils.List1Agda.Interaction.OptionsAgda.Interaction.ExitCodeAgda.Interaction.JSONAgda.Utils.EitherAgda.Utils.AssocListAgda.Utils.TupleAgda.Utils.VarSetAgda.Utils.PrettyAgda.Utils.Maybe.StrictAgda.Termination.CutOffAgda.Termination.SemiringAgda.Utils.AffineHoleAgda.Utils.ApplicativeAgda.Utils.CharAgda.Utils.EnvironmentAgda.Utils.FailAgda.Utils.Function"Agda.TypeChecking.SizedTypes.UtilsAgda.Utils.Haskell.Syntax Agda.Utils.IOAgda.Utils.IO.BinaryAgda.Utils.IO.DirectoryAgda.Utils.IO.TempFileAgda.Utils.IO.UTF8Agda.Utils.IORefAgda.Utils.ImpossibleAgda.Utils.EmptyAgda.Utils.BagAgda.Auto.NarrowingSearchAgda.Utils.IntSet.InfiniteAgda.Utils.LensAgda.Utils.IndexedListAgda.Auto.OptionsAgda.Utils.Lens.ExamplesAgda.Utils.MapAgda.Utils.MaybeAgda.Utils.MemoAgda.Utils.MonoidAgda.Utils.NullAgda.Utils.PartialOrdAgda.Utils.POMonoidAgda.Utils.PointerAgda.Utils.SemiRingAgda.Utils.SingletonAgda.Utils.ClusterAgda.Utils.SuffixAgda.Utils.ThreeAgda.Utils.TrieAgda.Utils.ListAgda.Utils.StringAgda.Utils.SizeAgda.Utils.PermutationAgda.Utils.FloatAgda.Utils.TimeAgda.Utils.Parser.MemoisedCPS#Agda.TypeChecking.SizedTypes.SyntaxAgda.Interaction.EmacsCommandAgda.Utils.ListTAgda.Utils.FileNameAgda.Utils.HashAgda.Utils.BenchmarkAgda.Utils.BiMapAgda.Syntax.PositionAgda.Syntax.CommonAgda.Syntax.Fixity+Agda.Syntax.Concrete.Operators.Parser.MonadAgda.Compiler.JS.SyntaxAgda.Auto.SyntaxAgda.Auto.SearchControlAgda.Auto.TypecheckAgda.Syntax.Parser.LiterateAgda.Syntax.Concrete.GlyphAgda.Syntax.Concrete.NameAgda.TypeChecking.Monad.BaseAgda.Syntax.BuiltinAgda.Syntax.Abstract.NameAgda.Syntax.LiteralAgda.Syntax.Treeless$Agda.Compiler.Treeless.GuardsToPrims!Agda.Compiler.Treeless.AsPatternsAgda.Syntax.Parser.TokensAgda.Compiler.BackendAgda.Compiler.Builtin!Agda.Interaction.Options.WarningsAgda.Syntax.Parser.MonadAgda.Interaction.Options.HelpAgda.Interaction.Library.BaseAgda.Interaction.Library.Parse#Agda.Interaction.Highlighting.RangeAgda.Utils.RangeMapAgda.Compiler.JS.SubstitutionAgda.Compiler.JS.PrettyAgda.Auto.CaseSplit,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.Syntax.NotationAgda.BenchmarkingAgda.Syntax.Concrete.Pattern%Agda.Syntax.Concrete.Operators.ParserAgda.Syntax.Concrete.GenericAgda.Syntax.Concrete.Fixity&Agda.Syntax.Concrete.Definitions.Types'Agda.Syntax.Concrete.Definitions.Errors&Agda.Syntax.Concrete.Definitions.MonadAgda.Syntax.Concrete.AttributeAgda.Utils.FavoritesAgda.Syntax.Scope.BaseAgda.Syntax.Info%Agda.Interaction.Highlighting.PreciseAgda.Interaction.ResponseAgda.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.ElimAgda.Syntax.Internal.BlockersAgda.Syntax.Internal%Agda.TypeChecking.Substitute.DeBruijn!Agda.TypeChecking.Free.PrecomputeAgda.TypeChecking.Free.LazyAgda.TypeChecking.Free"Agda.TypeChecking.Substitute.ClassAgda.Syntax.ReflectedAgda.Syntax.Internal.PatternAgda.Syntax.Internal.Generic Agda.TypeChecking.CompiledClauseAgda.Syntax.Internal.MetaVarsAgda.Syntax.Internal.DefsAgda.Syntax.AbstractAgda.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.ReduceAgda.TypeChecking.Primitive Agda.TypeChecking.Monad.MetaVarsAgda.TypeChecking.Monad.ImportsAgda.TypeChecking.Monad.EnvAgda.TypeChecking.Monad.ContextAgda.TypeChecking.Monad.BuiltinAgda.TypeChecking.LockAgda.TypeChecking.ErrorsAgda.TypeChecking.Monad.Debug"Agda.TypeChecking.Monad.Statistics!Agda.TypeChecking.Monad.Signature Agda.TypeChecking.ProjectionLikeAgda.TypeChecking.Monad.PureAgda.TypeChecking.Pretty Agda.TypeChecking.Pretty.WarningAgda.TypeChecking.Pretty.CallAgda.TypeChecking.Monad.Caching!Agda.TypeChecking.Monad.Benchmark&Agda.TypeChecking.CompiledClause.Match(Agda.TypeChecking.CompiledClause.CompileAgda.Syntax.Internal.NamesAgda.Interaction.Imports&Agda.Interaction.Highlighting.GenerateAgda.TypeChecking.WarningsAgda.Compiler.Treeless.EraseAgda.TypeChecking.InliningAgda.Interaction.BaseAgda.TypeChecking.Monad.StateAgda.TypeChecking.Monad.TraceAgda.TypeChecking.Monad.MutualAgda.TypeChecking.Monad.Closure#Agda.TypeChecking.Monad.ConstraintsAgda.TypeChecking.ConstraintsAgda.Interaction.Options.LensesAgda.TypeChecking.Monad.OptionsAgda.TypeChecking.SubstituteAgda.TypeChecking.Monad.OpenAgda.TypeChecking.TelescopeAgda.TypeChecking.Polarity"Agda.TypeChecking.Monad.SizedTypesAgda.TypeChecking.LevelAgda.Syntax.Scope.Monad*Agda.Syntax.Translation.AbstractToConcreteAgda.Syntax.Abstract.PrettyAgda.Syntax.Concrete.OperatorsAgda.TypeChecking.DropArgsAgda.TypeChecking.IrrelevanceAgda.TypeChecking.MetaVarsAgda.TypeChecking.DatatypesAgda.Compiler.Treeless.SubstAgda.Compiler.Treeless.PrettyAgda.Compiler.Treeless.CompareAgda.Compiler.Treeless.UncaseAgda.TypeChecking.Rules.Def+Agda.TypeChecking.Rules.Builtin.Coinduction"Agda.TypeChecking.Rewriting.ClauseAgda.TypeChecking.Reduce.MonadAgda.ImpossibleTestAgda.TypeChecking.Records Agda.TypeChecking.Patterns.Match#Agda.TypeChecking.Patterns.AbstractAgda.TypeChecking.Names"Agda.TypeChecking.MetaVars.MentionAgda.TypeChecking.EtaContract#Agda.TypeChecking.SyntacticEquality#Agda.TypeChecking.Patterns.Internal"Agda.TypeChecking.LevelConstraintsAgda.TypeChecking.Level.SolveAgda.TypeChecking.Free.ReduceAgda.TypeChecking.ForcingAgda.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.Rules.Display Agda.TypeChecking.Primitive.BaseAgda.TypeChecking.Quote#Agda.TypeChecking.Primitive.Cubical#Agda.TypeChecking.Pretty.Constraint#Agda.TypeChecking.Rules.LHS.ProblemAgda.TypeChecking.Implicit$Agda.TypeChecking.Rules.LHS.Implicit'Agda.TypeChecking.Rules.LHS.ProblemRestAgda.TypeChecking.Functions)Agda.TypeChecking.Rewriting.NonLinPattern Agda.TypeChecking.RecordPatternsAgda.TypeChecking.PositivityAgda.TypeChecking.Sort Agda.TypeChecking.Coverage.Match!Agda.TypeChecking.Conversion.Pure'Agda.TypeChecking.Rewriting.NonLinMatchAgda.Termination.MonadAgda.TypeChecking.SizedTypesAgda.TypeChecking.Injectivity#Agda.TypeChecking.InstanceArguments!Agda.TypeChecking.Rules.LHS.Unify!Agda.TypeChecking.MetaVars.Occurs"Agda.TypeChecking.SizedTypes.Solve&Agda.TypeChecking.Rewriting.Confluence"Agda.TypeChecking.IApplyConfluenceAgda.TypeChecking.GeneralizeAgda.TypeChecking.Rules.Data'Agda.TypeChecking.ReconstructParametersAgda.TypeChecking.UnquoteAgda.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.FromAbstract$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.CoerceAgda.Compiler.CallCompiler"Agda.Interaction.Highlighting.JSONAgda.TypeChecking.Rules.LHSAgda.TypeChecking.Rules.BuiltinAgda.TypeChecking.CoverageAgda.TypeChecking.Rules.RecordAgda.Compiler.ToTreeless#Agda.Interaction.Highlighting.EmacsAgda.Interaction.FindFile,Agda.TypeChecking.Serialise.Instances.Common2Agda.TypeChecking.Serialise.Instances.Highlighting/Agda.TypeChecking.Serialise.Instances.Compilers.Agda.TypeChecking.Serialise.Instances.Internal.Agda.TypeChecking.Serialise.Instances.Abstract,Agda.TypeChecking.Serialise.Instances.Errors%Agda.TypeChecking.Serialise.InstancesAgda.TypeChecking.Serialise*Agda.Syntax.Translation.ConcreteToAbstractAgda.Interaction.BasicOpsAgda.Interaction.SearchAboutAgda.Interaction.MakeCaseAgda.Auto.ConvertAgda.Auto.AutoAgda.Interaction.CommandLineAgda.Compiler.CommonAgda.Compiler.MAlonzo.PragmasAgda.Compiler.MAlonzo.MiscAgda.Compiler.MAlonzo.EncodeAgda.Compiler.MAlonzo.Pretty Agda.Compiler.MAlonzo.Primitives"Agda.Compiler.MAlonzo.HaskellTypesAgda.Interaction.InteractionTopAgda.Interaction.AgdaTopAgda.Interaction.EmacsTopAgda.Interaction.JSONTop!Agda.Interaction.Highlighting.Dot#Agda.Interaction.Highlighting.LaTeX"Agda.Interaction.Highlighting.HTMLAgda.Compiler.MAlonzo.CompilerAgda.Compiler.JS.Compiler Agda.Main&Agda.Interaction.Highlighting.Dot.BaseAgda.Utils.CallStack.Base Agda.UtilsFooData.Traversablefor Substitution' TraversableforM_Lazy listToMaybe maybeToList catMaybesmapMaybeforMifNull Data.List genericIndexgroupBy'union Data.EitherpartitionEithersleftsrights Control.MonadzipWithMAgda.TypeChecking.SubstitutionliftSAgda.Syntax.Internal.Patterns numberPatVarsAgda.Utils.CallStack.PrettyData Bitraversable Data.Maybe fromMaybe fromMaybeMLHSTree APatternLikeData.MapmapKeysMonotonicQName whyInScope unifyStepcompileClauses NonLinMatch'foldTermAgda.Syntax.TranslationAbstractToConcrete' Paths_AgdaAgda.Interaction.Options.Base#Agda.Interaction.Options.HasOptionsAbstractSyntax AtTopLevelinteractionLoop localStateAgda.TypeChecking.MonadAgda.TypeChecking.Testsprop_splitTelescope getConTypesimplifyLevelConstraintAgda.TheTypeChecker)Agda.Interaction.Highlighting.Dot.Backend(Agda.Interaction.Highlighting.LaTeX.Base+Agda.Interaction.Highlighting.LaTeX.Backend'Agda.Interaction.Highlighting.HTML.Base*Agda.Interaction.Highlighting.HTML.BackendbaseGHC.ExtstoListGHC.Base<><*>GHC.IxIx SemigroupGHC.Stack.Types CallStackSrcLoc Data.Functor<$>mplusmzero MonadPlusData.List.NonEmptysortWithsortBy transposenubBynubunzipzipWithzip!! isPrefixOf groupAllWith1 groupWith1groupBy1group1 groupAllWith groupWithgroupBygroup partitionfilterbreakspan dropWhile takeWhilesplitAtdroptakerepeatreversecycleiterate interspersescanr1scanl1scanrscanlsome1inserttailsinitsmapfromListsortcons<|initlasttailheadunfoldrunconsnonEmptyunfoldxorlengthSystem.Console.GetOptOptionOptDescrOptArgReqArgNoArgArgDescr System.Exit exitSuccessunless<=<>=> GHC.Stack callStack GHC.Exception prettySrcLocisRightisLeftGHC.Listlookup$> Data.Tupleswapwhen<$:|fromCallSiteList getCallStack HasCallStack srcLocEndCol srcLocEndLinesrcLocStartColsrcLocStartLine srcLocFile srcLocModule srcLocPackagecontainers-0.6.2.1Data.IntSet.Internal toDescList isSubsetOf intersection differenceunionsdelete singletonemptymembernullpretty-1.1.3.6Text.PrettyPrint.HughesPJ fullRender renderStylerenderfcatcat<+>$+$$$hangnestbracesbracketsparens doubleQuotesquotesrationaldoublefloatintegerintrbracelbracerbracklbrackrparenlparenequalsspacecoloncommasemiisEmpty zeroWidthText sizedTextptexttextcharDoc#Text.PrettyPrint.Annotated.HughesPJstylePStrChrribbonsPerLine lineLengthmodeStyle OneLineModeLeftMode ZigZagModePageModeMode%strict-0.4.0.1-DiXMdJzk69J4nN7qjlnNOVData.Strict.MaybemaybefromJust isNothingisJustJustNothingMaybe AgdaError UnknownErrorTCMError OptionErrorImpossibleErroragdaErrorToIntagdaErrorFromInt exitAgdaWith$fShowAgdaError $fEqAgdaError$fEnumAgdaError$fBoundedAgdaErrorCutOff DontCutOff defaultCutOff$fNFDataCutOff $fShowCutOff $fEqCutOff $fOrdCutOffSemiringaddmulzeroHasZero zeroElementintegerSemiring intSemiring boolSemiring $fHasZeroInt$fHasZeroInteger AffineHole ZeroHolesOneHole ManyHoles$fApplicativeAffineHole$fFunctorAffineHoleforA?*>?$>foldAfoldMapACallSiteFilterCallSite SrcLocCol SrcLocLine SrcLocFileSrcFun SrcLocModule SrcLocPackageprettyCallSiteprettyCallStack headCallSitetruncatedCallStack overCallSitesfilterCallStack popnCallStackwithNBackCallStackwithCurrentCallStackwithCallerCallStackreplacementCharisSurrogateCodePointreplaceSurrogateCodePoint integerToCharexpandEnvironmentVariables $fEqToken $fShowTokenFailrunFailrunFail_$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 ModuleNameLiteralIntFracCharStringAltExpVarConLitInfixAppAnnAppLambdaLetIfCase ExpTypeSigNegAppFakeExpStmt Qualifier GeneratorPatPVarPLitPAsPat PWildCardPBangPatPApp PatTypeSigPIrrPatTypeTyForallTyFunTyConTyVarTyAppFakeTypeMatch GuardedRhsRhs UnGuardedRhs GuardedRhssBindsBDeclsDeriving StrictnessStrictConDecl DataOrNewDataTypeNewTypeDeclTypeDeclDataDeclTypeSigFunBindPatSynFakeDecl ImportSpecIVar ImportDecl importModuleimportQualified importSpecs ModulePragmaLanguagePragma OtherPragmaModuleunit_con$fEqDecl $fEqMatch$fEqRhs$fEqExp$fEqAlt $fEqBinds$fEqGuardedRhs$fEqStmt $fEqConDecl$fEqPat$fEqType $fEqTyVarBind$fEqQOp $fEqQName$fEqName$fEqModuleName$fOrdModuleName $fEqLiteral$fEqStrictness $fEqDataOrNewCatchIOcatchIO$fCatchIOStateT$fCatchIOWriterT $fCatchIOIOreadBinaryFile'copyDirContentwriteToTempFile readTextFile writeFilewriteTextToFilereadModifyIORef'CatchImpossiblecatchImpossiblecatchImpossibleJusthandleImpossiblehandleImpossibleJust Impossible UnreachableImpMissingDefinitionsthrowImpossible__IMPOSSIBLE__ impossible__UNREACHABLE__$fExceptionImpossible$fShowImpossible$fNFDataImpossible$fOrdImpossible$fEqImpossible$fCatchImpossibleIOEmptyabsurd toImpossible $fShowEmpty $fOrdEmpty $fEqEmpty $fNFDataEmpty $fDataEmptyBagbagsize! notMembercountgroupskeyselems toAscList traverse' $fFoldableBag $fMonoidBag$fSemigroupBag $fShowBag$fEqBag$fOrdBagChoice LeftDisjunct RightDisjunctSRes HandleSolQPB QPBlockedQPDoubleBlockedPBNotPBPBlockedPDoubleBlockedMBNotBBlockedFailedMetaEnvMMNotMMetaBlkInfo Refinable refinementsMove'MovemoveCostmoveNextCostgetCost RefCreateEnvrunRefCreateEnvUndoRestorePrioMetaNoPrioSubConstraintsscflip sccomcountscsub1scsub2CTree ctpriometactsubctparent cthandlesMetavarmbindmprincipalpresentmobs mcompoint mextrarefsOKMetaOKHandleOKValPropOKError AddExtraRefAnd SideconditionOr ConnectHandleTermTravWithTravBlocktravPriogetPrio hequalMetavarnewMetainitMetanewCTreenewSubConstraints ureadIORef uwriteIORef umodifyIORefureadmodifyIORefrunUndonewPlaceholder newOKHandledryInstantiatermmmcasemmmcasemmpcase doubleblockmbcasembpcasemmbpcasewaitokmbretmbfailedmpret expandbind topSearchextractblkinfosrecalcsseqcrecalcreccalccalcchoosePrioMeta propagatePriochoose$fRefinableOKValblk$fMonadRefCreateEnv$fApplicativeRefCreateEnv$fFunctorRefCreateEnv $fEqPrioMeta $fEqMetavar$fTravMM$fRefinableChoiceblk $fNumCost$fEqCost $fOrdCost$fEqPrio $fOrdPrio $fNumPrioIntSetbelowabovefull toFiniteList invariant$fMonoidIntSet$fSemigroupIntSet $fEqIntSet $fShowIntSetLensMapLensSetLensGetLens'lFstlSnd^.setoverfocususe.=%=%==%%= locallyStateviewlocallylocally'keyIndexZeroSucAllNilConsSomewithSomemakeAll forgetAll forgetIndex mapWithIndexlIndex lookupIndex allIndices AutoTokenMCRDLTSH AutoOptions autoHints autoTimeOutautoPickautoMode autoHintModeTimeOut getTimeOutHints AutoHintModeAHMNone AHMModuleMNormal MCaseSplitMRefineinitAutoOptionsaoHints aoTimeOutaoPickaoMode aoHintMode autoTokens parseTime parseArgs $fShowTimeOutRecordfield1field2 lensField1 lensField2adjustMadjustM' filterKeys mapMaybeKeys boolToMaybeunionMaybeWithunionsMaybeWith unzipMaybe filterMaybeforMaybe caseMaybeifJustmaybeM caseMaybeMifJustMwhenJust whenNothing whenJustM whenNothingMallJustM liftMaybememomemoRec 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(,,) $fNull(,)$fNull()toStricttoLazy$fApplicativeMaybe Inclusion inclusion Pointwise pointwise PartialOrd comparable ComparablePartialOrderingPOLTPOLEPOEQPOGEPOGTPOAnyleqPOoppPOorPOseqPO fromOrdering fromOrderings toOrderings comparableOrdrelated$fMonoidPartialOrdering$fSemigroupPartialOrdering$fPartialOrdPartialOrdering$fPartialOrd(,)$fPartialOrdEither$fPartialOrdMaybe$fPartialOrd()$fPartialOrdInteger$fPartialOrdInt$fPartialOrdPointwise$fPartialOrdInclusion$fPartialOrdInclusion0 $fEqInclusion$fOrdInclusion$fShowInclusion$fFunctorInclusion $fEqPointwise$fShowPointwise$fFunctorPointwise$fEqPartialOrdering$fShowPartialOrdering$fEnumPartialOrdering$fBoundedPartialOrderingLeftClosedPOMonoidinverseComposePOMonoid POSemigrouphasLeftAdjointPtrnewPtrderefPtr updatePtrsetPtr updatePtrM $fDataIORef $fNFDataPtr $fHashablePtr$fOrdPtr$fEqPtr$fTraversablePtr $fFoldablePtr $fFunctorPtr $fShowPtr $fDataPtr StarSemiRingostarSemiRingozeroooneoplusotimes$fSemiRingMaybe $fSemiRing()$fStarSemiRingMaybe$fStarSemiRing()$fSemigroupStateT$fSemigroupReaderT Singleton Collection$fSingleton(,)HashMap$fSingletonaHashSet$fSingleton(,)IntMap$fSingleton(,)Map$fSingletonIntIntSet$fSingletonaSet$fSingletonaSeq$fSingletonaNonEmpty$fSingletonaEndo$fSingletona->$fSingletona[]$fSingletonaMaybe$fCollection(,)HashMap$fCollectionaHashSet$fCollection(,)Map$fCollectionaSet$fCollection(,)IntMap$fCollectionIntIntSet$fCollectionaSeq$fCollectionaEndo$fCollectiona->$fCollectiona[]clustercluster'SmallSettotal complement\\ mapMemberShipzipMemberShipWith fromAscListfromDistinctAscList $fEqSmallSet $fOrdSmallSet$fShowSmallSet$fDataSmallSet$fNFDataSmallSetSuffixPrime SubscriptisSubscriptDigittoSubscriptDigitfromSubscriptDigit nextSuffix suffixView renderSuffix addSuffixEither3In1In2In3ThreeOneTwo partition3partitionEithers3 mapEither3M forEither3M $fEqEither3 $fOrdEither3 $fShowEither3 $fEqThree $fOrdThree $fShowThree$fBoundedThree $fEnumThreeTrie everyPrefix unionWith insertWithadjusttoListOrderedBy mapSubTries lookupPath lookupTrievalueAt $fNullTrie $fNFDataTrie $fShowTrie$fEqTrie $fFunctorTrie$fFoldableTriePair-*-mapFstmapSnd/\fst3snd3thd3uncurry3uncurry4mapPairMmapFstMmapSndM$fApplicativePair$fEqPair $fFunctorPair$fFoldablePair$fTraversablePairStrSufSt SSSMismatchSSSStrip SSSResultReversedSuffixPrefixsnoccaseList caseListMlistCaseheadWithDefault tailMaybetailWithDefault lastMaybelastWithDefaultlast1last2mconsinitLast initLast1init1 initMaybeinitWithDefault!!!indexWithDefault findWithIndexgenericElemIndexdownFrom updateHead updateLastupdateAtsplitExactlyAtdropEndspanEnd takeWhileJustspanJustpartitionMaybe filterAndRestmapMaybeAndRest isSublistOfholes commonPrefix dropCommon stripPrefixBy commonSuffix stripSuffixstripReversedSuffixgroupOnwordsBychopchopWhenhasElemsorteddistinct fastDistinct duplicates allDuplicatesnubAndDuplicatesOnnubOnuniqOnallEqualnubMzipWith'zipWithKeepRest unzipWitheditDistanceSpec editDistancemergeStrictlyOrderedByquotehaskellStringLiteral delimiteraddFinalNewLineindentshowThousandSepltrimrtrimtrim$fIsStringStateT$fIsStringReaderTList1appendprependconcat zipWithM_ SizedThingtheSize sizedThingSized sizeThing $fSizedIntSet $fSizedSeq $fSizedMap$fSizedNonEmpty $fSizedIntMap$fSizedHashSet$fSizedHashMap $fSizedSet $fSized[]$fNullSizedThing$fSizedSizedThingDoDropdoDropdropMoreunDropDropdropNdropFromInversePermuteinversePermute PermutationPerm permRange permPickspermute safePermuteidPtakePdroppedPliftPcomposePinvertPcompactPreversePflipPexpandPtopoSort topoSortM$fNFDataPermutation$fNullPermutation$fSizedPermutation$fShowPermutation$fInversePermute->[]$fInversePermute[][]$fInversePermute[]IntMap$fInversePermute[][]0$fDoDropPermutation $fDoDrop[]$fEqDrop $fOrdDrop $fShowDrop $fDataDrop $fFunctorDrop$fFoldableDrop$fTraversableDrop$fEqPermutation$fDataPermutation$fGenericPermutationList2 fromListMaybefromList1MaybetoList1 fromList1 $fNFDataList2 $fIsListList2 $fEqList2 $fOrdList2 $fShowList2 $fDataList2$fFunctorList2$fFoldableList2$fTraversableList2doubleEqdoubleLedoubleLt intToDouble doublePlus doubleMinus doubleTimes doubleNegate doubleDiv doublePow doubleSqrt doubleExp doubleLog doubleSin doubleCos doubleTan doubleASin doubleACos doubleATan doubleATan2 doubleSinh doubleCosh doubleTanh doubleASinh doubleACosh doubleATanhisPosInfisNegInf isPosZero isNegZero doubleRound doubleFloor doubleCeilingdoubleToWord64 doubleDenotEqdoubleDenotOrdasFinitetoStringWithoutDotZero doubleToRatio ratioToDouble doubleDecode isSafeInteger doubleEncodePrettypretty prettyPrec prettyList prettyShowsepfsephsephcatvcat punctuatepwordsfwordshsepWith prettyList_ prettySet prettyMap prettyAssignmparensparensNonEmptyalign multiLineTextpshow singPluralprefixedThings $fDataDoc $fPrettyMap$fPrettyIntMap $fPrettySet$fPrettyIntSet$fPrettyNonEmpty $fPretty[] $fPrettyMaybe $fPretty() $fPrettyDoc $fPrettyChar $fPrettyText$fPrettyDouble$fPrettyWord64$fPrettyInteger $fPrettyInt32 $fPrettyInt $fPrettyBoolCPUTime ClockTime getClockTimefromMilliseconds getCPUTime measureTime$fPrettyCPUTime $fEqCPUTime $fShowCPUTime $fOrdCPUTime $fNumCPUTime $fRealCPUTime $fEnumCPUTime$fIntegralCPUTime$fNFDataCPUTimeDocPParserWithGrammar ParserClassparsegrammarsat'annotatememoisememoiseIfPrintingParserdocsattokentokbindPchoicePseqPstarPatomP$fAlternativeParser$fApplicativeParser$fFunctorParser $fMonadParser$fParserClassParserkrtok#$fParserClassParserWithGrammarkrtok$fAlternativeParserWithGrammar$fApplicativeParserWithGrammar$fFunctorParserWithGrammar$fMonadParserWithGrammarFlexsFlexOfflexsRigidsRigidOfrigidsTruncateOffsettruncateOffset 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$fRigidsConstraint'$fRigidsSizeExpr' $fRigids[]$fFlexsConstraint'$fFlexsSizeExpr' $fFlexs[]$fShowSolution$fNullSolution $fEqPolarity $fOrdPolarity$fShowConstraint'$fFunctorConstraint'$fFoldableConstraint'$fTraversableConstraint' $fShowCmp$fEqCmp $fBoundedCmp $fEnumCmp$fShowSizeExpr' $fEqSizeExpr'$fOrdSizeExpr'$fFunctorSizeExpr'$fFoldableSizeExpr'$fTraversableSizeExpr'$fEqFlex $fOrdFlex $fEqRigid $fOrdRigid $fEqOffset $fOrdOffset $fNumOffset $fEnumOffsetLispAQresponse putResponse display_info'clearRunningInfo clearWarningdisplayRunningInfo $fPrettyLisp$fEqLisp whileLeft caseEitherMmapLeftmapRighttraverseEitherfromLeft fromRight fromLeftM fromRightM maybeLeft maybeRightallLeftallRight groupByEither maybeToEither swapEither==<<whenMunlessMguardMifMifNotMand2MandMallMor2MorManyMaltM1 orEitherMmapM'forM'mapMMforMMmapMM_forMM_ mapMaybeM mapMaybeMM forMaybeM forMaybeMM dropWhileM dropWhileEndM partitionM fromMaybeMP catMaybesMP scatterMPfinallytryMaybetryCatchguardWithErrorbracket_ListTrunListTmapListT unmapListTnilListT consListTsgListT caseListT foldListTanyListTallListT sequenceListT concatListT runMListT consMListTsgMListT mapMListT mapMListT_alt liftListT$fMonadFailListT$fMonadStatesListT$fMonadReaderrListT$fMonadIOListT$fMonadTransListT $fMonadListT$fApplicativeListT$fMonadPlusListT$fAlternativeListT $fMonoidListT$fSemigroupListT$fFunctorListT AbsolutePathfilePath mkAbsoluteabsolutecanonicalizeAbsolutePathsameFiledoesFileExistCaseSensitive isNewerThan$fPrettyAbsolutePath$fShowAbsolutePath$fEqAbsolutePath$fOrdAbsolutePath$fDataAbsolutePath$fHashableAbsolutePath$fNFDataAbsolutePathHashhashByteString hashTextFilehashText combineHashes hashString MonadBench BenchPhase getBenchmark putBenchmarkmodifyBenchmark Benchmark benchmarkOncurrentAccounttimings BenchmarkOn BenchmarkOff BenchmarkSomeTimingsCurrentAccountAccount isBenchmarkOnmapBenchmarkOnmapCurrentAccount mapTimings addCPUTime getsBenchmarksetBenchmarkingswitchBenchmarkingresetbillTo billToCPS billPureTo$fNFDataBenchmarkOn$fNFDataBenchmark$fPrettyBenchmark$fNullBenchmark$fMonadBenchListT$fMonadBenchExceptT$fMonadBenchStateT$fMonadBenchWriterT$fMonadBenchReaderT$fGenericBenchmark$fGenericBenchmarkOnBiMap biMapThere biMapBackHasTagTagtagtagInjectiveForbiMapInvariant invLookupinsertPreconditionalterMalteralterPreconditionupdateupdatePreconditionadjustPreconditioninsertLookupWithKeyinsertLookupWithKeyPrecondition mapWithKeymapWithKeyPreconditionmapWithKeyFixedTagsmapWithKeyFixedTagsPreconditionunionPreconditionfromListPreconditionfromDistinctAscendingLists&fromDistinctAscendingListsPreconditiontoDistinctAscendingLists $fShowBiMap $fOrdBiMap $fEqBiMap $fNullBiMap$fGenericBiMap 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$fSemigroupAbsolutePath$fPrettyPosition'$fOrdPosition' $fEqPosition'$fNFDataPosition'$fPrettyPosition'0$fNFDataPosition'0$fPrettyInterval'$fNFDataInterval'$fPrettyInterval'0$fNFDataInterval'0$fPrettyRange'$fMonoidRange'$fSemigroupRange' $fNullRange'$fNFDataRange'$fHasRangeEither$fHasRange(,,,,,,)$fHasRange(,,,,,)$fHasRange(,,,,)$fHasRange(,,,)$fHasRange(,,) $fHasRange(,)$fHasRangeMaybe$fHasRangeList2$fHasRangeNonEmpty $fHasRange[]$fHasRangeBool $fHasRange()$fHasRangeRange'$fHasRangeInterval'$fSetRangeMaybe $fSetRange[]$fSetRangeRange'$fKillRangeEither$fKillRange(,,,)$fKillRange(,,)$fKillRange(,)$fKillRangeSet$fKillRangeMaybe$fKillRangeMaybe0$fKillRangeList2$fKillRangeNonEmpty$fKillRangeDrop$fKillRangeMap $fKillRange[]$fKillRange[]0$fKillRangePermutation$fKillRangeInteger$fKillRangeInt$fKillRangeBool $fKillRange()$fKillRangeVoid$fKillRangeRange'$fPrettyPrintRange$fEqPrintRange$fOrdPrintRange$fHasRangePrintRange$fSetRangePrintRange$fKillRangePrintRange $fShowRange' $fDataRange' $fEqRange' $fOrdRange'$fFunctorRange'$fFoldableRange'$fTraversableRange'$fGenericRange'$fShowInterval'$fDataInterval' $fEqInterval'$fOrdInterval'$fFunctorInterval'$fFoldableInterval'$fTraversableInterval'$fGenericInterval'$fShowPosition'$fDataPosition'$fFunctorPosition'$fFoldablePosition'$fTraversablePosition'$fGenericPosition'GenPartBindHole NormalHoleWildHoleIdPartNotationExpandedEllipsis NoEllipsis ellipsisRangeellipsisWithArgs RewriteEqn'RewriteInvert CoverageCheckYesCoverageCheckNoCoverageCheck UniverseCheckYesUniverseCheckNoUniverseCheckPositivityCheckYesPositivityCheckNoPositivityCheckTerminationCheckNoTerminationCheckNonTerminating TerminatingTerminationMeasure Renaming'RenamingrenFromrenTo renFixity renToRange ImportedName'ImportedModule ImportedNameUsing' UseEverythingUsingRenamingDirective'HidingDirective'ImportDirective'ImportDirectiveimportDirRangeusinghiding impRenaming publicOpen LensFixity' lensFixity' LensFixity lensFixityFixity' theFixity theNotation theNameRangeFixity fixityRange fixityLevel fixityAssoc AssociativityNonAssoc LeftAssoc RightAssoc FixityLevel UnrelatedRelatedPrecedenceLevel InteractionId interactionIdMaybePlaceholder Placeholder NoPlaceholderPositionInName BeginningMiddleEnd ProblemIdConstrMetaIdmetaIdNameIdModuleNameHashIsMacroMacroDef NotMacroDef IsInstance InstanceDefNotInstanceDef AnyIsAbstract anyIsAbstractLensIsAbstractlensIsAbstract IsAbstract AbstractDef ConcreteDefAccess PrivateAccess PublicAccessIsInfixInfixDef PrefixDef ProjOrigin ProjPrefix ProjPostfix ProjSystem ConOrigin ConOSystemConOConConORec ConOSplitRStringRawNameRangedrangeOf rangedThingArgNameNamedArg LensNamedNameOf lensNamed NamedNameNamed_NamednameOf namedThing Underscore underscore isUnderscoreArgargInfounArg LensArgInfo getArgInfo setArgInfo mapArgInfoArgInfo argInfoHidingargInfoModality argInfoOriginargInfoFreeVariablesargInfoAnnotationLensFreeVariablesgetFreeVariablessetFreeVariablesmapFreeVariables FreeVariables UnknownFVsKnownFVs LensOrigin getOrigin setOrigin mapOrigin WithOriginwoOriginwoThingOrigin UserWrittenInserted Reflected CaseSplit Substitution LensCohesion getCohesion setCohesion mapCohesionCohesionFlat ContinuousSquashLensLockgetLocksetLockmapLockLock IsNotLockIsLockLensAnnotation getAnnotation setAnnotation mapAnnotation AnnotationannLock LensRelevance getRelevance setRelevance mapRelevance RelevanceRelevant NonStrict IrrelevantErased NotErased LensQuantity getQuantity setQuantity mapQuantityQuantity Quantity0 Quantity1 Quantityω QωOrigin QωInferredQω QωPlentyQ1Origin Q1InferredQ1Q1LinearQ0Origin Q0InferredQ0Q0Erased LensModality getModality setModality mapModalityModality modRelevance modQuantity modCohesionUnderComposition UnderAddition LensHiding getHiding setHiding mapHiding WithHidingwhHidingwhThingHidingHiddenInstance NotHidden Overlappable YesOverlap NoOverlap Induction Inductive CoInductiveCopatternMatchingAllowedcopatternMatchingAllowedPatternMatchingAllowedpatternMatchingAllowedPatternOrCopatternPatternMatchingCopatternMatchingHasEta0HasEtaHasEta'YesEtaNoEtaRecordDirectives'RecordDirectives recInductive recHasEta recPatternrecConstructorFileType AgdaFileType MdFileType RstFileType TexFileType OrgFileTypeDelayed NotDelayedArityNatemptyRecordDirectives mergeHidingvisible notVisiblehiddenhidehideOrKeepInstance makeInstance makeInstance'isOverlappable isInstance sameHidingmoreUsableModalityusableModalitycomposeModality applyModalityinverseComposeModality"inverseApplyModalityButNotQuantity addModality zeroModality unitModality topModalitydefaultModality sameModality lModRelevance lModQuantity lModCohesiongetRelevanceModsetRelevanceModmapRelevanceModgetQuantityModsetQuantityModmapQuantityModgetCohesionModsetCohesionModmapCohesionMod sameQuantity addQuantity zeroQuantitydefaultQuantity unitQuantity topQuantity moreQuantitycomposeQuantity applyQuantityinverseComposeQuantityinverseApplyQuantity hasQuantity0 hasQuantity1 hasQuantityωnoUserQuantityusableQuantity defaultErased asQuantity sameErasedisErased composeErased allRelevances isRelevant isIrrelevant isNonStrict moreRelevant sameRelevanceusableRelevancecomposeRelevanceapplyRelevanceinverseComposeRelevanceinverseApplyRelevance addRelevance zeroRelevance unitRelevance topRelevancedefaultRelevanceirrToNonStrictnonStrictToRelnonStrictToIrrdefaultAnnotation defaultLock allCohesions moreCohesion sameCohesionusableCohesioncomposeCohesion applyCohesioninverseComposeCohesioninverseApplyCohesion addCohesion zeroCohesion unitCohesion topCohesiondefaultCohesionunknownFreeVariablesnoFreeVariablesoneFreeVariablefreeVariablesFromListhasNoFreeVariablesdefaultArgInfogetHidingArgInfosetHidingArgInfomapHidingArgInfogetModalityArgInfosetModalityArgInfomapModalityArgInfogetOriginArgInfosetOriginArgInfomapOriginArgInfogetFreeVariablesArgInfosetFreeVariablesArgInfomapFreeVariablesArgInfoisInsertedHidden defaultArg withArgsFromwithNamedArgsFromsameNameunnamed isUnnamednamed userNamed getNameOf setNameOf mapNameOf bareNameOfbareNameWithDefault namedSamefittingNamedArgnamedArgdefaultNamedArg unnamedArgupdateNamedArgupdateNamedArgA setNamedArgargNameToStringstringToArgNameappendArgNamesunrangedrawNameToStringstringToRawName bestConInfonoModuleNameHash noPlaceholdernoFixity defaultFixity noFixity' _fixityAssoc _fixityLeveldefaultImportDirisDefaultImportDirmapUsingfromImportedNamesetImportedNamepartitionImportedNames noNotation$fNFDataDelayed$fKillRangeDelayed$fNFDataFileType$fPrettyFileType$fNFDataHasEta'$fKillRangeHasEta'$fHasRangeHasEta'$fKillRangePatternOrCopattern$fHasRangePatternOrCopattern$fNFDataPatternOrCopattern$fPatternMatchingAllowedHasEta'*$fPatternMatchingAllowedPatternOrCopattern!$fCopatternMatchingAllowedHasEta',$fCopatternMatchingAllowedPatternOrCopattern!$fPatternMatchingAllowedInduction$fNFDataInduction$fKillRangeInduction$fHasRangeInduction$fPrettyInduction$fNFDataOverlappable$fMonoidOverlappable$fSemigroupOverlappable$fNFDataHiding$fKillRangeHiding$fHasRangeHiding$fMonoidHiding$fSemigroupHiding$fPrettyHiding$fNFDataWithHiding$fKillRangeWithHiding$fSetRangeWithHiding$fHasRangeWithHiding$fApplicativeWithHiding$fDecorationWithHiding$fApplicativeUnderAddition$fApplicativeUnderComposition$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$fPartialOrdQuantity$fPOMonoidUnderAddition$fPOSemigroupUnderAddition$fMonoidUnderAddition$fSemigroupUnderAddition$$fLeftClosedPOMonoidUnderComposition$fPOMonoidUnderComposition$fPOSemigroupUnderComposition$fMonoidUnderComposition$fSemigroupUnderComposition$fSemigroupUnderComposition0$fKillRangeErased$fHasRangeErased$fNFDataErased$fPOMonoidUnderAddition0$fPOSemigroupUnderAddition0$fMonoidUnderAddition0$fSemigroupUnderAddition0%$fLeftClosedPOMonoidUnderComposition0$fPOMonoidUnderComposition0$fPOSemigroupUnderComposition0$fMonoidUnderComposition0$fSemigroupUnderComposition1$fPartialOrdRelevance$fOrdRelevance$fNFDataRelevance$fKillRangeRelevance$fSetRangeRelevance$fHasRangeRelevance $fNFDataLock$fNFDataAnnotation$fKillRangeAnnotation$fHasRangeAnnotation$fLensLockLock$fPOMonoidUnderAddition1$fPOSemigroupUnderAddition1$fMonoidUnderAddition1$fSemigroupUnderAddition1%$fLeftClosedPOMonoidUnderComposition1$fPOMonoidUnderComposition1$fPOSemigroupUnderComposition1$fMonoidUnderComposition1$fSemigroupUnderComposition2$fPartialOrdCohesion $fOrdCohesion$fNFDataCohesion$fKillRangeCohesion$fSetRangeCohesion$fHasRangeCohesion$fNFDataModality$fKillRangeModality$fHasRangeModality$fPOMonoidUnderAddition2$fPOSemigroupUnderAddition2$fMonoidUnderAddition2$fSemigroupUnderAddition2%$fLeftClosedPOMonoidUnderComposition2$fPOMonoidUnderComposition2$fPOSemigroupUnderComposition2$fMonoidUnderComposition2$fSemigroupUnderComposition3$fPartialOrdModality$fNFDataOrigin$fKillRangeOrigin$fHasRangeOrigin$fNFDataWithOrigin$fKillRangeWithOrigin$fSetRangeWithOrigin$fHasRangeWithOrigin$fPrettyWithOrigin$fDecorationWithOrigin$fNFDataFreeVariables$fKillRangeFreeVariables$fMonoidFreeVariables$fSemigroupFreeVariables$fNFDataArgInfo$fKillRangeArgInfo$fHasRangeArgInfo$fLensLockArgInfo$fLensArgInfoArgInfo$fLensFreeVariablesArgInfo $fLensFreeVariablesFreeVariables$fLensOriginArgInfo$fLensOriginWithOrigin$fLensOriginOrigin$fLensAnnotationArgInfo$fLensAnnotationAnnotation$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 $fLensLockArg$fLensAnnotationArg$fUnderscoreDoc$fUnderscoreByteString$fUnderscore[] $fNFDataNamed$fKillRangeNamed$fSetRangeNamed$fHasRangeNamed$fDecorationNamed$fLensHidingNamed$fLensNamedNamed$fLensNamedMaybe$fLensNamedArg$fNFDataRanged$fDecorationRanged$fKillRangeRanged$fHasRangeRanged $fOrdRanged $fEqRanged$fPrettyRanged$fNFDataRecordDirectives'$fKillRangeRecordDirectives'$fHasRangeRecordDirectives'$fKillRangeConOrigin$fNFDataConOrigin$fKillRangeProjOrigin$fNFDataProjOrigin$fKillRangeAccess$fHasRangeAccess$fNFDataAccess$fPrettyAccess$fNFDataIsAbstract$fKillRangeIsAbstract$fMonoidIsAbstract$fSemigroupIsAbstract$fLensIsAbstractIsAbstract$fAnyIsAbstractMaybe$fAnyIsAbstract[]$fAnyIsAbstractIsAbstract$fNFDataIsInstance$fHasRangeIsInstance$fKillRangeIsInstance$fNFDataIsMacro$fHasRangeIsMacro$fKillRangeIsMacro$fNFDataModuleNameHash$fHashableNameId$fNFDataNameId $fEnumNameId$fPrettyNameId$fKillRangeNameId$fHashableMetaId$fNFDataMetaId $fShowMetaId$fPrettyMetaId$fPrettyProblemId$fShowProblemId$fNFDataMaybePlaceholder$fKillRangeMaybePlaceholder$fHasRangeMaybePlaceholder$fKillRangeInteractionId$fPrettyInteractionId$fNFDataFixityLevel$fNullFixityLevel$fNFDataFixity$fKillRangeFixity$fHasRangeFixity $fNullFixity $fOrdFixity $fEqFixity$fLensFixityFixity$fNFDataImportedName'$fKillRangeImportedName'$fHasRangeImportedName'$fNFDataUsing'$fKillRangeUsing'$fHasRangeUsing' $fNullUsing'$fMonoidUsing'$fSemigroupUsing'$fNFDataRenaming'$fKillRangeRenaming'$fHasRangeRenaming'$fNFDataImportDirective'$fKillRangeImportDirective'$fHasRangeImportDirective'$fMonoidImportDirective'$fSemigroupImportDirective'$fNullImportDirective'$fNFDataTerminationCheck$fKillRangeTerminationCheck$fNFDataPositivityCheck$fMonoidPositivityCheck$fSemigroupPositivityCheck$fKillRangePositivityCheck$fNFDataUniverseCheck$fKillRangeUniverseCheck$fNFDataCoverageCheck$fMonoidCoverageCheck$fSemigroupCoverageCheck$fKillRangeCoverageCheck$fKillRangeRewriteEqn'$fHasRangeRewriteEqn'$fPrettyRewriteEqn'$fNFDataRewriteEqn'$fNFDataExpandedEllipsis$fKillRangeExpandedEllipsis$fNullExpandedEllipsis$fNFDataGenPart$fKillRangeGenPart$fSetRangeGenPart$fHasRangeGenPart $fOrdGenPart $fEqGenPart$fLensFixityFixity'$fKillRangeFixity'$fNFDataFixity' $fNullFixity' $fEqFixity'$fLensFixity'Fixity' $fDataFixity' $fShowFixity' $fDataGenPart $fShowGenPart$fDataExpandedEllipsis$fShowExpandedEllipsis$fEqExpandedEllipsis$fDataRewriteEqn'$fEqRewriteEqn'$fShowRewriteEqn'$fFunctorRewriteEqn'$fFoldableRewriteEqn'$fTraversableRewriteEqn'$fEqCoverageCheck$fOrdCoverageCheck$fShowCoverageCheck$fBoundedCoverageCheck$fEnumCoverageCheck$fDataCoverageCheck$fGenericCoverageCheck$fEqUniverseCheck$fOrdUniverseCheck$fShowUniverseCheck$fBoundedUniverseCheck$fEnumUniverseCheck$fDataUniverseCheck$fGenericUniverseCheck$fEqPositivityCheck$fOrdPositivityCheck$fShowPositivityCheck$fBoundedPositivityCheck$fEnumPositivityCheck$fDataPositivityCheck$fGenericPositivityCheck$fDataTerminationCheck$fShowTerminationCheck$fEqTerminationCheck$fFunctorTerminationCheck$fDataImportDirective'$fEqImportDirective'$fDataRenaming' $fEqRenaming' $fDataUsing' $fEqUsing'$fDataImportedName'$fEqImportedName'$fOrdImportedName'$fShowImportedName' $fDataFixity $fShowFixity$fEqAssociativity$fOrdAssociativity$fShowAssociativity$fDataAssociativity$fEqFixityLevel$fOrdFixityLevel$fShowFixityLevel$fDataFixityLevel$fEqInteractionId$fOrdInteractionId$fShowInteractionId$fNumInteractionId$fIntegralInteractionId$fRealInteractionId$fEnumInteractionId$fDataInteractionId$fNFDataInteractionId$fDataMaybePlaceholder$fEqMaybePlaceholder$fOrdMaybePlaceholder$fFunctorMaybePlaceholder$fFoldableMaybePlaceholder$fTraversableMaybePlaceholder$fShowMaybePlaceholder$fShowPositionInName$fEqPositionInName$fOrdPositionInName$fDataPositionInName$fDataProblemId $fEqProblemId$fOrdProblemId$fEnumProblemId$fRealProblemId$fIntegralProblemId$fNumProblemId$fNFDataProblemId $fEqMetaId $fOrdMetaId $fNumMetaId $fRealMetaId $fEnumMetaId$fIntegralMetaId $fDataMetaId$fGenericMetaId $fEqNameId $fOrdNameId $fDataNameId$fGenericNameId $fShowNameId$fEqModuleNameHash$fOrdModuleNameHash$fShowModuleNameHash$fDataModuleNameHash $fDataIsMacro $fShowIsMacro $fEqIsMacro $fOrdIsMacro$fGenericIsMacro$fDataIsInstance$fShowIsInstance$fEqIsInstance$fOrdIsInstance$fDataIsAbstract$fShowIsAbstract$fEqIsAbstract$fOrdIsAbstract$fGenericIsAbstract $fDataAccess $fShowAccess $fEqAccess $fOrdAccess $fDataIsInfix $fShowIsInfix $fEqIsInfix $fOrdIsInfix$fDataProjOrigin$fShowProjOrigin$fEqProjOrigin$fOrdProjOrigin$fEnumProjOrigin$fBoundedProjOrigin$fGenericProjOrigin$fDataConOrigin$fShowConOrigin $fEqConOrigin$fOrdConOrigin$fEnumConOrigin$fBoundedConOrigin$fGenericConOrigin$fFunctorRecordDirectives'$fDataRecordDirectives'$fShowRecordDirectives'$fEqRecordDirectives' $fDataRanged $fShowRanged$fFunctorRanged$fFoldableRanged$fTraversableRanged $fEqNamed $fOrdNamed $fShowNamed $fDataNamed$fFunctorNamed$fFoldableNamed$fTraversableNamed $fDataArg$fEqArg$fOrdArg $fShowArg $fFunctorArg $fFoldableArg$fTraversableArg $fDataArgInfo $fEqArgInfo $fOrdArgInfo $fShowArgInfo$fDataFreeVariables$fEqFreeVariables$fOrdFreeVariables$fShowFreeVariables$fDataWithOrigin$fEqWithOrigin$fOrdWithOrigin$fShowWithOrigin$fFunctorWithOrigin$fFoldableWithOrigin$fTraversableWithOrigin $fDataOrigin $fShowOrigin $fEqOrigin $fOrdOrigin$fDataModality $fEqModality $fOrdModality$fShowModality$fGenericModality$fDataCohesion$fShowCohesion $fEqCohesion$fEnumCohesion$fBoundedCohesion$fGenericCohesion$fDataAnnotation$fEqAnnotation$fOrdAnnotation$fShowAnnotation$fGenericAnnotation $fDataLock $fShowLock $fGenericLock$fEqLock $fEnumLock $fBoundedLock $fOrdLock$fDataRelevance$fShowRelevance $fEqRelevance$fEnumRelevance$fBoundedRelevance$fGenericRelevance $fDataErased $fShowErased $fEqErased$fGenericErased$fDataQuantity$fShowQuantity$fGenericQuantity $fEqQuantity $fOrdQuantity$fDataQωOrigin$fShowQωOrigin$fGenericQωOrigin $fEqQωOrigin$fOrdQωOrigin$fDataQ1Origin$fShowQ1Origin$fGenericQ1Origin $fEqQ1Origin $fOrdQ1Origin$fDataQ0Origin$fShowQ0Origin$fGenericQ0Origin $fEqQ0Origin $fOrdQ0Origin$fShowUnderComposition$fFunctorUnderComposition$fEqUnderComposition$fOrdUnderComposition$fPartialOrdUnderComposition$fShowUnderAddition$fFunctorUnderAddition$fEqUnderAddition$fOrdUnderAddition$fPartialOrdUnderAddition$fDataWithHiding$fEqWithHiding$fOrdWithHiding$fShowWithHiding$fFunctorWithHiding$fFoldableWithHiding$fTraversableWithHiding $fDataHiding $fShowHiding $fEqHiding $fOrdHiding$fDataOverlappable$fShowOverlappable$fEqOverlappable$fOrdOverlappable$fDataInduction $fEqInduction$fOrdInduction$fShowInduction$fDataPatternOrCopattern$fShowPatternOrCopattern$fEqPatternOrCopattern$fOrdPatternOrCopattern$fEnumPatternOrCopattern$fBoundedPatternOrCopattern $fDataHasEta' $fShowHasEta' $fEqHasEta' $fOrdHasEta'$fFunctorHasEta'$fFoldableHasEta'$fTraversableHasEta'$fDataFileType $fEqFileType $fOrdFileType$fShowFileType$fGenericFileType $fDataDelayed $fShowDelayed $fEqDelayed $fOrdDelayed$fGenericDelayedPrecedenceStack PrecedenceTopCtxFunctionSpaceDomainCtxLeftOperandCtxRightOperandCtx FunctionCtx ArgumentCtxInsideOperandCtx WithFunCtx WithArgCtx DotPatternCtxParenPreference PreferParenPreferParenlessThingWithFixity preferParenpreferParenlesspushPrecedenceheadPrecedence argumentCtx_ opBrackets opBrackets' lamBrackets appBrackets appBrackets'withAppBrackets piBracketsroundFixBrackets$fKillRangeThingWithFixity$fLensFixityThingWithFixity$fLensFixity'ThingWithFixity$fNFDataParenPreference$fPrettyPrecedence$fNFDataPrecedence$fShowPrecedence$fDataPrecedence$fEqPrecedence$fGenericPrecedence$fEqParenPreference$fOrdParenPreference$fShowParenPreference$fDataParenPreference$fGenericParenPreference$fFunctorThingWithFixity$fFoldableThingWithFixity$fTraversableThingWithFixity$fDataThingWithFixity$fShowThingWithFixity PrecedenceKeyMemoKeyNodeK PostLeftsK PreRightsKTopKAppKNonfixK$fHashableMemoKey $fEqMemoKey $fShowMemoKey$fGenericMemoKeyGlobalsglobalsUsesusesmodNameimportsexportscallMainJSQNameExportexpNamedefnCommentMemberId MemberIndexGlobalIdLocalIdSelfLocalGlobal UndefinedIntegerDoubleObjectArrayApplyLookupBinOpPreOpPlainJS $fOrdComment $fEqComment $fUsesExport $fUsesExp $fUsesComment $fUses(,,) $fUses(,) $fUsesMap$fUses[]$fGlobalsModule$fGlobalsExport $fGlobalsExp$fGlobalsComment $fGlobals(,,) $fGlobals(,) $fGlobalsMap$fGlobalsMaybe $fGlobals[] $fShowModule $fShowExport $fShowExp $fEqMemberId $fOrdMemberId$fShowMemberId $fShowComment$fSemigroupComment$fMonoidComment $fEqGlobalId $fOrdGlobalId$fShowGlobalId $fEqLocalId $fOrdLocalId $fShowLocalId renameOffsetFreeVarsfreeVarsOffset Weakeningweak' ExpandMetas expandMetas MetaliseOKH metaliseOKHEECtxCActionSubSkipWeakTrBrCExpClosICExp ICArgListCALNil CALConcat HNArgListHNALNilHNALCons HNALConParHNExp'HNAppHNLamHNPiHNSortHNExp WithSeenUIdsseenUIdsrawValueMArgListArgListALNilALConsALProjALConParMExpLamPiSort AbsurdLambdaappUIdappOKappHeadappElimsSet UnknownSortElrConstRef PatConAppPatVarPatExpClauseDeclContDefDatatype Constructor PostulateConstDefcdnamecdorigincdtypecdcont cddeffreevarsAbsMIdIdNoIdMyMBMyPBRefInfoRIEnv 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(,)$fEqElr$fEqEqReasoningState$fShowEqReasoningState ExpRefInfoeriMaineriUnifseriInfTypeUnknowneriIsEliminand eriUsedVars eriIotaSteperiPickSubsVar eriEqRStateinitExpRefInfogetinfounivarsubsvarsnewAbsnewLamnewPifoldArgsnewArgs'newArgsnewApp'newAppeqStepeqEndeqCongeqSym eqBeginStep2pickUidextrarefcostUnificationIf costIncreasecostUnificationOccurscostUnification costAppVarcostAppVarUsed costAppHintcostAppHintUsedcostAppRecCallcostAppRecCallUsedcostAppConstructorcostAppConstructorSinglecostAppExtraRefcostLam costLamUnfoldcostPicostSort costIotaStepcostInferredTypeUnkown costAbsurdLam costEqStep costEqEnd costEqSym costEqCongprioNoprioTypeUnknownprioTypecheckArgListprioInferredTypeUnknown prioCompBetaprioCompBetaStructured prioCompIotaprioCompChoice prioCompUnif prioCompCopyprioCompareArgList prioNoIotaprioAbsurdLambda prioProjIndex prioTypecheck $fTravArgList $fTravExp $fTravTrBr $fTrav(,)$fTrav[]$fRefinableIORefRefInfo$fRefinableClosRefInfo$fRefinableArgListRefInfo$fRefinableExpRefInfoCMFlexCMFFlexCMFSemi CMFBlockedCModeCMRigidPEvalPENoPEConAppHNResHNDoneHNMetaHNNBlkstcExp getDatatypeconstructorImpossibleunequalsunequal traversePitcargsaddendcopyargnoblksaddblkhnnhnn_blks hnn_checkstephnn'hnbhnc hnarglistgetNArgs getAllArgsiotastep noiotastepnoiotastep_termcomp'checkeliminandmaybeor iotapossmetameta_not_constructor calcEqRStatepickidtcSearch ProcessorLayersLayer layerRoleinterval layerContent LayerRoleMarkupCode atomizeLayersliterateSrcFileliterateProcessorsisCode isCodeLayer illiterateliterateExtsShortList literateTeX literateMd literateRsT literateOrg$fHasRangeLayer $fShowLayer$fShowLayerRole $fEqLayerRoleSpecialCharacters_dbraces_lambda_arrow_forallQ_leftIdiomBrkt_rightIdiomBrkt_emptyIdiomBrktUnicodeOrAscii UnicodeOk AsciiOnlyunsafeSetUnicodeOrAsciispecialCharactersForGlyphsbraces'dbracesforallQ leftIdiomBrktrightIdiomBrktemptyIdiomBrktarrowlambda$fNFDataUnicodeOrAscii$fShowUnicodeOrAscii$fEqUnicodeOrAscii$fEnumUnicodeOrAscii$fBoundedUnicodeOrAscii$fGenericUnicodeOrAsciiIsNoNameisNoName FreshNameModeUnicodeSubscript AsciiCounter LensInScope lensInScope isInScope mapInScope setInScope setNotInScope NameInScopeInScope NotInScopeNumHolesnumHolesTopLevelModuleNamemoduleNameRangemoduleNamePartsNamePartHole NamePartsNoName nameRange nameInScope nameNamePartsnameId isOpenMixfix simpleNamesimpleBinaryOperator simpleHole lensNameParts nameToRawName namePartsnameStringPartsstringNameParts isOperatorisHoleisPrefix isPostfixisInfixisNonfix nextRawNamenextName lastIdPartfirstNonTakenName nameSuffixnameSuffixView setNameSuffixnameRootsameRoot lensQNameNamequalify unqualify qnameParts isQualified isUnqualifiedtoTopLevelModuleNamemoduleNameToFileName projectRootnoName_noName$fNFDataNamePart$fPrettyNamePart $fOrdNamePart $fEqNamePart$fNFDataTopLevelModuleName$fKillRangeTopLevelModuleName$fSetRangeTopLevelModuleName$fHasRangeTopLevelModuleName$fPrettyTopLevelModuleName$fSizedTopLevelModuleName$fOrdTopLevelModuleName$fEqTopLevelModuleName$fNumHolesNonEmpty$fNFDataNameInScope $fNFDataName$fKillRangeName$fSetRangeName$fHasRangeName $fPrettyName$fNumHolesName $fOrdName$fUnderscoreName $fNFDataQName$fKillRangeQName$fSetRangeQName$fHasRangeQName $fPrettyQName$fNumHolesQName$fUnderscoreQName$fLensInScopeQName$fLensInScopeName$fLensInScopeNameInScope$fIsNoNameWithOrigin$fIsNoNameRanged$fIsNoNameQName$fIsNoNameName$fIsNoNameByteString $fIsNoName[] $fDataQName $fOrdQName $fDataName$fEqNameInScope$fShowNameInScope$fDataNameInScope$fShowTopLevelModuleName$fDataTopLevelModuleName$fGenericTopLevelModuleName$fDataNamePart$fGenericNamePart $fShowQName$fShowNamePart $fShowName Comparison BackendNameModuleToSourceTCMTCMTunTCMTCStateTCEnvHighlightingLevelHighlightingMethod NamedMeta TCWarningTCErrWarning builtinNat builtinSuc builtinZerobuiltinNatPlusbuiltinNatMinusbuiltinNatTimesbuiltinNatDivSucAuxbuiltinNatModSucAuxbuiltinNatEqualsbuiltinNatLess builtinWord64builtinIntegerbuiltinIntegerPosbuiltinIntegerNegSuc builtinFloat builtinChar builtinString builtinUnitbuiltinUnitUnit builtinSigma builtinBool builtinTrue builtinFalse builtinList builtinNil builtinCons builtinMaybebuiltinNothing builtinJust 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 builtinLevelbuiltinLevelZerobuiltinLevelSuc builtinSet builtinPropbuiltinSetOmegabuiltinLockUnivbuiltinSSetOmegabuiltinStrictSetbuiltinFromNatbuiltinFromNegbuiltinFromString builtinQNamebuiltinAgdaSortbuiltinAgdaSortSetbuiltinAgdaSortLitbuiltinAgdaSortPropbuiltinAgdaSortPropLitbuiltinAgdaSortInfbuiltinAgdaSortUnsupported builtinHiding builtinHiddenbuiltinInstancebuiltinVisiblebuiltinRelevancebuiltinRelevantbuiltinIrrelevantbuiltinQuantitybuiltinQuantity0builtinQuantityωbuiltinModalitybuiltinModalityConstructor builtinAssocbuiltinAssocLeftbuiltinAssocRightbuiltinAssocNonbuiltinPrecedencebuiltinPrecRelatedbuiltinPrecUnrelated builtinFixitybuiltinFixityFixity builtinArgbuiltinArgInfobuiltinArgArgInfo builtinArgArg builtinAbs builtinAbsAbsbuiltinAgdaTermbuiltinAgdaTermVarbuiltinAgdaTermLambuiltinAgdaTermExtLambuiltinAgdaTermDefbuiltinAgdaTermConbuiltinAgdaTermPibuiltinAgdaTermSortbuiltinAgdaTermLitbuiltinAgdaTermUnsupportedbuiltinAgdaTermMetabuiltinAgdaErrorPartbuiltinAgdaErrorPartStringbuiltinAgdaErrorPartTermbuiltinAgdaErrorPartNamebuiltinAgdaLiteralbuiltinAgdaLitNatbuiltinAgdaLitWord64builtinAgdaLitFloatbuiltinAgdaLitCharbuiltinAgdaLitStringbuiltinAgdaLitQNamebuiltinAgdaLitMetabuiltinAgdaClausebuiltinAgdaClauseClausebuiltinAgdaClauseAbsurdbuiltinAgdaPatternbuiltinAgdaPatVarbuiltinAgdaPatConbuiltinAgdaPatDotbuiltinAgdaPatLitbuiltinAgdaPatProjbuiltinAgdaPatAbsurdbuiltinAgdaDefinitionFunDefbuiltinAgdaDefinitionDataDefbuiltinAgdaDefinitionRecordDef$builtinAgdaDefinitionDataConstructorbuiltinAgdaDefinitionPostulatebuiltinAgdaDefinitionPrimitivebuiltinAgdaDefinitionbuiltinAgdaMetabuiltinAgdaTCMbuiltinAgdaTCMReturnbuiltinAgdaTCMBindbuiltinAgdaTCMUnifybuiltinAgdaTCMTypeErrorbuiltinAgdaTCMInferTypebuiltinAgdaTCMCheckTypebuiltinAgdaTCMNormalisebuiltinAgdaTCMReducebuiltinAgdaTCMCatchErrorbuiltinAgdaTCMGetContextbuiltinAgdaTCMExtendContextbuiltinAgdaTCMInContextbuiltinAgdaTCMFreshNamebuiltinAgdaTCMDeclareDefbuiltinAgdaTCMDeclarePostulatebuiltinAgdaTCMDefineFunbuiltinAgdaTCMGetTypebuiltinAgdaTCMGetDefinitionbuiltinAgdaTCMBlockOnMetabuiltinAgdaTCMCommitbuiltinAgdaTCMQuoteTermbuiltinAgdaTCMUnquoteTermbuiltinAgdaTCMQuoteOmegaTermbuiltinAgdaTCMIsMacrobuiltinAgdaTCMWithNormalisationbuiltinAgdaTCMWithReconsParamsbuiltinAgdaTCMDebugPrintbuiltinAgdaTCMOnlyReduceDefsbuiltinAgdaTCMDontReduceDefsbuiltinAgdaTCMNoConstraintsbuiltinAgdaTCMRunSpeculativebuiltinAgdaTCMExecisBuiltinNoDef builtinsNoDef sizeBuiltinsMkNamemkNamemkName_IsProjPisProjPNoSuffixAmbiguousQNameAmbQunAmbQMName mnameToListQNamedqnameqnamed qnameModule qnameName nameConcrete nameCanonicalnameBindingSite nameFixitynameIsRecordName uglyShowName unambiguousheadAmbQ isAmbiguousgetUnambiguousisAnonymousModuleName withRangesOf withRangesOfQ mnameFromListmnameFromList1 mnameToList1 noModuleNamecommonParentModulemakeName qnameToList0 qnameToList qnameFromList qnameToMName mnameToQName showQNameIdqnameToConcretemnameToConcretequalifyMqualifyQqualify_isLeParentModuleOfisLtParentModuleOfisLeChildModuleOfisLtChildModuleOf isInModule nameToArgName namedArgName$fLensFixityName$fLensFixity'Name$fHashableName$fNFDataModuleName$fSizedModuleName$fKillRangeModuleName$fSetRangeModuleName$fHasRangeModuleName$fPrettyModuleName $fSizedQName$fLensFixityQName$fLensFixity'QName$fHashableQName$fPrettyQNamed$fKillRangeAmbiguousQName$fHasRangeAmbiguousQName$fPrettyAmbiguousQName$fNumHolesAmbiguousQName$fNFDataSuffix $fIsProjPVoid$fIsProjPNamed $fIsProjPArg $fMkName[] $fDataSuffix $fShowSuffix $fEqSuffix $fOrdSuffix$fEqAmbiguousQName$fOrdAmbiguousQName$fDataAmbiguousQName$fNFDataAmbiguousQName$fFunctorQNamed$fFoldableQNamed$fTraversableQNamed$fDataModuleName$fShowAmbiguousQName $fShowQNamed$fShowModuleNameLitNat LitWord64LitFloat LitStringLitCharLitQNameLitMetaRLiteralshowText showChar'$fNFDataLiteral$fKillRangeLiteral $fOrdLiteral$fPrettyLiteral $fDataLiteral $fShowLiteral isUnreachableTError TUnreachableTMetaTAltTAConTAGuardTALitaConaArityaBodyaGuardaLitCaseInfocaseLazycaseTypeCaseTypeCTDataCTNatCTIntCTCharCTStringCTFloatCTQNameTPrimPAddPAdd64PSubPSub64PMulPMul64PQuotPQuot64PRemPRem64PGeqPLtPLt64PEqIPEq64PEqFPEqSPEqCPEqQPIfPSeqPITo64P64ToITTermTVarTDefTAppTLamTLitTConTLetTCaseTUnitTSortTErasedTCoerceArgsEvaluationStrategyLazyEvaluationEagerEvaluationArgUsageArgUsed ArgUnusedCompiled cTreeless cArgUsageTPFnTPOpisPrimEq coerceViewmkTApptAppView coerceAppViewtLetViewtLamViewmkTLammkLettIntintView word64ViewtPlusK tNegPlusK plusKView negPlusKViewtOp tUnreachable tIfThenElse filterUsed$fNFDataArgUsage $fNFDataTPrim$fNFDataCaseType$fNFDataCaseInfo$fNFDataTError $fNFDataTAlt $fNFDataTTerm$fNFDataCompiled$fKillRangeCompiled$fUnreachableTTerm$fUnreachableTAlt$fDataCompiled$fShowCompiled $fEqCompiled $fOrdCompiled$fGenericCompiled $fDataTTerm $fShowTTerm $fEqTTerm $fOrdTTerm$fGenericTTerm $fDataTAlt $fShowTAlt$fEqTAlt $fOrdTAlt $fGenericTAlt $fDataTError $fShowTError $fEqTError $fOrdTError$fGenericTError$fDataCaseInfo$fShowCaseInfo $fEqCaseInfo $fOrdCaseInfo$fGenericCaseInfo$fDataCaseType$fShowCaseType $fEqCaseType $fOrdCaseType$fGenericCaseType $fDataTPrim $fShowTPrim $fEqTPrim $fOrdTPrim$fGenericTPrim$fEqEvaluationStrategy$fShowEvaluationStrategy$fDataArgUsage$fShowArgUsage $fEqArgUsage $fOrdArgUsage$fGenericArgUsage convertGuardsrecoverAsPatterns $fShowAsPatToken TokKeywordTokIdTokQId TokLiteral TokSymbol TokStringTokTeX TokMarkup TokCommentTokDummyTokEOFSymDotSymSemiSymVirtualSemiSymBarSymColonSymArrowSymEqual SymLambda SymUnderscoreSymQuestionMarkSymAs SymOpenParen SymCloseParenSymOpenIdiomBracketSymCloseIdiomBracketSymEmptyIdiomBracketSymDoubleOpenBraceSymDoubleCloseBrace SymOpenBrace SymCloseBraceSymOpenVirtualBraceSymCloseVirtualBrace SymOpenPragmaSymClosePragma SymEllipsis SymDotDot SymEndCommentKeywordKwLetKwInKwWhereKwDataKwCoDataKwDo KwPostulate KwAbstract KwPrivate KwInstance KwInterleavedKwMutual KwOverlapKwOpenKwImportKwModule KwPrimitiveKwMacroKwInfixKwInfixLKwInfixRKwWith KwRewriteKwForallKwRecord 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 $fEqSymbol $fShowSymbol $fEqKeyword $fShowKeywordBackend lookupBackendactiveBackendMayEraseTypebuiltinBackends WarningNameOverlappingTokensWarning_UnsupportedAttribute_MultipleAttributes_LibUnknownField_EmptyAbstract_EmptyConstructor_ EmptyField_EmptyGeneralize_EmptyInstance_ EmptyMacro_ EmptyMutual_EmptyPostulate_EmptyPrimitive_ EmptyPrivate_EmptyRewritePragma_ EmptyWhere_InvalidCatchallPragma_InvalidConstructor_InvalidConstructorBlock_InvalidCoverageCheckPragma_InvalidNoPositivityCheckPragma_InvalidNoUniverseCheckPragma_InvalidRecordDirective_InvalidTerminationCheckPragma_MissingDefinitions_NotAllowedInMutual_OpenPublicAbstract_OpenPublicPrivate_ PolarityPragmasButNotPostulates_PragmaCompiled_PragmaNoTerminationCheck_ShadowingInTelescope_UnknownFixityInMixfixDecl_UnknownNamesInFixityDecl_UnknownNamesInPolarityPragmas_UselessAbstract_UselessInstance_UselessPrivate_AbsurdPatternRequiresNoRHS_,AsPatternShadowsConstructorOrPatternSynonym_CantGeneralizeOverSorts_ClashesViaRenaming_CoverageIssue_CoverageNoExactSplit_DeprecationWarning_DuplicateUsing_FixityInRenamingModule_GenericNonFatalError_GenericUseless_GenericWarning_IllformedAsClause_InstanceArgWithExplicitArg_InstanceWithExplicitArg_InstanceNoOutputTypeName_InversionDepthReached_ModuleDoesntExport_NoGuardednessFlag_ NotInScope_NotStrictlyPositive_ OldBuiltin_PragmaCompileErased_RewriteMaybeNonConfluent_RewriteNonConfluent_RewriteAmbiguousRules_RewriteMissingRule_ SafeFlagEta_SafeFlagInjective_SafeFlagNoCoverageCheck_SafeFlagNonTerminating_SafeFlagNoPositivityCheck_SafeFlagNoUniverseCheck_SafeFlagPolarity_SafeFlagPostulate_SafeFlagPragma_SafeFlagTerminating_&SafeFlagWithoutKFlagPrimEraseEquality_TerminationIssue_UnreachableClauses_UnsolvedConstraints_UnsolvedInteractionMetas_UnsolvedMetaVariables_UselessHiding_UselessInline_#UselessPatternDeclarationForRecord_UselessPublic_ UserWarning_WithoutKFlagPrimEraseEquality_WrongInstanceDeclaration_CoInfectiveImport_InfectiveImport_DuplicateFieldsWarning_TooManyFieldsWarning_ExeNotFoundWarning_ExeNotExecutableWarning_WarningModeErrorUnknown NoNoError WarningMode _warningSet _warn2Error warningSet warn2ErrordefaultWarningSetdefaultWarningModeprettyWarningModeErrorwarningModeUpdate warningSets noWarningsunsolvedWarningsincompleteMatchWarnings errorWarnings allWarnings usualWarningsstring2WarningNamewarningName2String usageWarning$fNFDataWarningName$fNFDataWarningMode$fEqWarningMode$fShowWarningMode$fGenericWarningMode$fEqWarningName$fOrdWarningName$fShowWarningName$fReadWarningName$fEnumWarningName$fBoundedWarningName$fGenericWarningName ParseResultParseOk ParseFailed ParseWarningOverlappingTokensWarningUnsupportedAttributeMultipleAttributes warnRange ParseErrorOverlappingTokensErrorInvalidExtensionError ReadFileError errSrcFileerrPoserrInput errPrevTokenerrMsgerrRangeerrPath errValidExts errIOError ParseFlagsparseKeepComments LayoutStatus Tentative ConfirmedColumn LayoutBlockLayout LayoutContextLexState ParseStatePState parseSrcFileparsePos parseLastPosparseInp parsePrevCharparsePrevToken parseLayoutparseLayStatus parseLayKw parseLexState parseFlags parseWarningsparseWarningName parseError parseWarning initStatedefaultParseFlagsparsePosString parseFromSrc setParsePos setLastPos setPrevTokengetParseInterval getLexState pushLexState popLexState getParseFlags parseErrorAt parseError'parseErrorRangelexError getContext setContext modifyContexttopBlockpopBlock pushBlockresetLayoutStatus$fHasRangeParseError$fPrettyParseError$fHasRangeParseWarning$fPrettyParseWarning$fNFDataParseWarning$fShowParseResult$fMonadStateParseStateParser$fMonadErrorParseErrorParser$fShowParseState$fDataParseWarning$fShowParseWarning$fShowParseError$fShowParseFlags$fShowLayoutBlock$fEqLayoutStatus$fShowLayoutStatusHelp GeneralHelpHelpFor allHelpTopicshelpTopicUsagestring2HelpTopic$fNFDataHelpTopic $fNFDataHelp$fEqHelp $fShowHelp $fGenericHelp $fEqHelpTopic$fShowHelpTopic$fGenericHelpTopicLibM LibErrorIOLibState LibError' LibNotFound AmbiguousLib OtherErrorLibError LibWarning' UnknownField ExeNotFoundExeNotExecutable LibWarningLibPositionInfo libFilePos lineNumPosfilePos LineNumber AgdaLibFile_libName_libFile _libIncludes _libDepends _libPragmas ProjectConfigDefaultProjectConfig configRootconfigAgdaLibFilesExecutablesFileefPathefExistsExeName LibrariesFilelfPathlfExistsLibNamelibNameForCurrentDir emptyLibFilelibNamelibFile libIncludes libDepends libPragmaslibraryWarningNamewarnings warnings' raiseErrors' raiseErrorsgetCachedProjectConfigstoreCachedProjectConfiggetCachedAgdaLibFilestoreCachedAgdaLibFileformatLibPositionInfoformatLibError$fNFDataExecutablesFile$fNFDataProjectConfig$fNFDataAgdaLibFile$fNFDataLibPositionInfo$fNFDataLibWarning'$fPrettyLibWarning'$fNFDataLibWarning$fPrettyLibWarning$fShowLibError'$fShowLibWarning$fDataLibWarning$fGenericLibWarning$fShowLibWarning'$fDataLibWarning'$fGenericLibWarning'$fShowLibPositionInfo$fDataLibPositionInfo$fGenericLibPositionInfo$fShowAgdaLibFile$fGenericAgdaLibFile$fGenericProjectConfig$fShowExecutablesFile$fDataExecutablesFile$fGenericExecutablesFile$fShowLibrariesFilerunP parseLibFiletrimLineComment splitCommas$fShowGenericLineRangesfromtorangesInvariant overlapping overlappingsrangeToPositionsrangesToPositionsrToR rangeToRangeminus $fNFDataRange $fNullRange $fEqRanges $fShowRanges$fNFDataRanges $fEqRange $fOrdRange $fShowRangeRangeMaprangeMapPairIntIsBasicRangeMaptoMap coveringRangeseveralrangeMapInvariant'fromNonOverlappingNonEmptyAscendingListinsideAndOutside restrictTo$fNFDataPairInt$fMonoidRangeMap$fSemigroupRangeMap$fIsBasicRangeMapaRangeMap$fNullRangeMap$fShowRangeMap$fNFDataRangeMap $fShowPairIntshift shiftFromshifter substitutermap'subst'applyselffix curriedApply curriedLambdaempvineobjectPrettiesprettiesIndentGroupBesideAboveEncloseSpaceminifiedCodeLinesLength$++$indentByenclosevsepunescape unescapesblockmodname variableNameisValidJSIdent $fMonoidDoc$fSemigroupDoc $fIsStringDoc$fPrettyModule$fPrettyComment$fPrettyMemberId$fPrettyGlobalId$fPrettyLocalId $fPretty(,) $fPrettyExp $fPrettiesMap$fPrettiesNonEmpty $fPretties[]LocalTerminationEnvsizeAndBoundVarsLiftlift'Unify UnifiesTounify' notequal' AssignmentsReplace ReplaceWithreplace'SolCSPatI CSPatConAppCSPatVarCSPatExpCSWithCSAbsurd CSOmittedArgCSCtxCSPatHI abspatvarnamecostCaseSplitVeryHighcostCaseSplitHighcostCaseSplitLowcostAddVarDepthdrophidcaseSplitSearchcaseSplitSearch' infertypevarreplace betareduce concatargsreplacepunifynotequalunifyVarunifyexplift removevarfindpermfreevars applypermrenseqctx depthofvarlocalTerminationEnvlocalTerminationSidecondgetblks $fRenamingHI$fRenamingCSPatI$fReplaceArgListArgList $fReplaceMMu$fReplaceExpMM$fReplaceAbsAbs$fUnifyArgList $fUnifyExp $fUnifyAbs $fUnifyMM $fLiftArgList $fLiftExp$fLiftMM $fLiftAbs$fLocalTerminationEnvMM$fLocalTerminationEnv(,)$fLocalTerminationEnvMM0$fLocalTerminationEnv[]$fLocalTerminationEnvCSPatI$fLocalTerminationEnvHIDAGdagGraphdagComponentMap dagNodeMapNodessrcNodestgtNodesallNodesEdgesourcetargetlabelGraphgraphedges neighbours neighboursMap edgesFromedgesTodiagonalnodes sourceNodes targetNodes computeNodes isolatedNodesdiscreteacyclic fromNodes fromNodeSet fromEdges fromEdgesWith insertEdgeinsertEdgeWith unionsWith mapWithEdge transposeEdgeclean removeNodes removeNode removeEdge filterEdges composeWithsccs'sccs dagInvariant oppositeDAG reachablesccDAG'sccDAG reachableFromreachableFromSetwalkSatisfyingcomplete completeIter1gaussJordanFloydWarshallMcNaughtonYamadaReference(gaussJordanFloydWarshallMcNaughtonYamadatransitiveClosure $fShowGraph $fPrettyGraph$fFunctorGraph $fPrettyEdge$fEqEdge $fOrdEdge $fFunctorEdge $fShowEdge $fEqGraphtopSortBounds 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 $fShowNode$fEqNode $fOrdNode $fShowLabel $fEqWeight $fShowWeight OccurrenceMixedJustNegJustPos StrictPosGuardPosUnusedWhere LeftOfArrowDefArgUnderInfVarArgMetaArg ConArgType IndArgTypeInClauseMatchedIsIndexInDefOf OccursWhereboundToEverySomeproductOfEdgesInBoundedWalk $fPrettyWhere $fNFDataWhere$fSizedOccursWhere$fPrettyOccursWhere$fNFDataOccursWhere$fNullOccurrence$fStarSemiRingOccurrence$fSemiRingOccurrence$fKillRangeOccurrence$fNFDataOccurrence$fPrettyOccurrence$fDataOccurrence$fShowOccurrence$fEqOccurrence$fOrdOccurrence$fEnumOccurrence$fBoundedOccurrence$fShowOccursWhere$fEqOccursWhere$fOrdOccursWhere$fDataOccursWhere$fGenericOccursWhere $fShowWhere $fEqWhere $fOrdWhere $fDataWhere$fGenericWhereAppView HoleContent HoleContent'HoleContentExprHoleContentRewriteMod modPragmasmodDeclsPragma OptionsPragma BuiltinPragma RewritePragma ForeignPragma CompilePragma StaticPragma InlinePragmaImpossiblePragma EtaPragmaWarningOnUsageWarningOnImportInjectivePragma DisplayPragmaCatchallPragmaTerminationCheckPragmaNoCoverageCheckPragmaNoPositivityCheckPragmaPolarityPragmaNoUniverseCheckPragma OpenShortHandDoOpenDontOpenModuleApplication SectionAppRecordModuleInstance DeclarationFieldSig GeneralizeField FunClauseDataSigDataDef RecordSig RecordDefRecordDirectiveInfix PatternSynMutualInterleavedMutualPrivate InstanceBLoneConstructorMacro PrimitiveOpenImport ModuleMacro UnquoteDecl UnquoteDefEtaTypeSignatureOrInstanceBlock TypeSignatureAsNameAsName'asNameasRangeHidingDirectiveRenamingDirective ExprWhere LamClauselamLHSlamRHS lamCatchAll WhereClause'NoWhereAnyWhere SomeWhere WhereClauseRHS' AbsurdRHSRHSLHSCoreLHSHeadLHSProjLHSWith LHSEllipsis lhsDefNamelhsPats lhsDestructor lhsPatsLeftlhsFocuslhsHeadlhsWithPatternslhsEllipsisRangelhsEllipsisPatWithExpr RewriteEqnlhsOriginalPattern lhsRewriteEqn lhsWithExpr Telescope Telescope1 TypedBinding'TBind TypedBindingTacticAttribute BoundNameBName boundName bnameFixity bnameTactic LamBinding' DomainFree DomainFull LamBindingBinderBinder' binderPattern binderNameDoStmtDoBindDoThenDoLetPatternIdentPQuotePAppPRawAppPOpAppPHiddenP InstancePParenPWildPAbsurdPAsPDotPLitPRecPEqualP EllipsisPWithP OpAppArgs' OpAppArgsExpr QuestionMarkRawAppOpAppWithApp HiddenArg InstanceArg AbsurdLam ExtendedLamFunRec RecUpdateParen IdiomBracketsDoBlockAbsurdAsDot DoubleDotETelQuote QuoteTermTacticUnquoteDontCareEqualEllipsis GeneralizedRecordAssignmentsRecordAssignmentModuleAssignment _qnameModA _exprModA_importDirModAFieldAssignmentFieldAssignment' _nameFieldA _exprFieldASyntaxBindingLambdaOrdinary fromOrdinary nameFieldA exprFieldA mkBinder_mkBinderdropTypeAndModality mkBoundName_ mkBoundNamelamBindingsToTelescopemakePimkLammkTLetisRecordDirectivetopLevelModuleNamespanAllowedBeforeModulerawApprawAppPappView unAppViewisSingleIdentifierP removeParenP observeHidingobserveRelevanceobserveModifiers returnExpr isPatternexprToPatternWithHoles isAbsurdP isBinderP$fNFDataFieldAssignment'$fKillRangeFieldAssignment'$fHasRangeFieldAssignment' $fNFDataRHS'$fNFDataWhereClause'$fNullWhereClause'$fNFDataRecordDirective$fKillRangeRecordDirective$fHasRangeRecordDirective$fNFDataOpenShortHand$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$fFunctorHoleContent'$fFoldableHoleContent'$fTraversableHoleContent' $fDataLHSCore $fEqLHSCore $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 $fDataOpApp$fFunctorOpApp$fFoldableOpApp$fTraversableOpApp $fEqOpApp$fDataModuleAssignment$fEqModuleAssignment$fDataOpenShortHand$fEqOpenShortHand$fShowOpenShortHand$fGenericOpenShortHand$fDataRecordDirective$fEqRecordDirective$fShowRecordDirective $fDataAsName' $fShowAsName'$fFunctorAsName'$fFoldableAsName'$fTraversableAsName' $fEqAsName'$fDataWhereClause'$fEqWhereClause'$fFunctorWhereClause'$fFoldableWhereClause'$fTraversableWhereClause' $fDataRHS' $fFunctorRHS'$fFoldableRHS'$fTraversableRHS'$fEqRHS'$fDataFieldAssignment'$fFunctorFieldAssignment'$fFoldableFieldAssignment'$fTraversableFieldAssignment'$fShowFieldAssignment'$fEqFieldAssignment'Tel NamedBinding withHiding namedBindingbracesAndSemicolons prettyHidingprettyRelevanceprettyQuantity prettyErasedprettyCohesion prettyTactic prettyTactic' isLabeledsmashTelpHasEta0pRecordDirectivepRecord prettyOpApp$fPrettyImportedName'$fPrettyRenaming'$fPrettyUsing'$fPrettyImportDirective'$fPrettyPattern $fPrettyNamed $fPrettyArg$fPrettyFixity'$fPrettyGenPart$fPrettyFixity$fPrettyFixityLevel$fPrettyAssociativity$fPrettyPragma$fPrettyOpenShortHand$fPrettyDeclaration$fPrettyDoStmt$fPrettyModuleApplication$fPrettyLHSCore $fPrettyLHS$fPrettyWhereClause' $fPrettyRHS'$fPrettyBinder'$fPrettyBoundName$fPrettyLamClause$fPrettyModuleAssignment$fPrettyFieldAssignment'$fPrettyEither$fPrettyMaybePlaceholder $fPrettyOpApp$fPrettyModality$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$fNFDataLazySplit$fNFDataSplitTree'$fKillRangeSplitTree'$fPrettySplitTree'$fNFDataSplitTag$fKillRangeSplitTag$fPrettySplitTag$fPrettySplitTreeLabel$fShowSplitTag $fEqSplitTag $fOrdSplitTag$fDataSplitTag$fGenericSplitTag$fDataSplitTree'$fShowSplitTree'$fGenericSplitTree'$fDataLazySplit$fShowLazySplit $fEqLazySplit$fOrdLazySplit$fGenericLazySplitNotationSection sectNotationsectKind sectLevel sectIsSection NewNotationnotaName notaNames notaFixitynotationnotaIsOperator NotationKind InfixNotationPrefixNotationPostfixNotationNonfixNotation NoNotationHoleName LambdaHoleExprHole _bindHoleNameholeName isLambdaHole stringParts holeTargetisAHole isNormalHole isBindingHole notationKind mkNotationnamesToNotationuseDefaultFixity notationNamessyntaxOfmergeNotations _notaFixity noSection$fNFDataNotationKind$fPrettyNotationKind$fNFDataNewNotation$fPrettyNewNotation$fLensFixityNewNotation$fNFDataNotationSection$fPrettyNotationSection$fShowNotationSection$fGenericNotationSection$fShowNewNotation$fGenericNewNotation$fEqNotationKind$fShowNotationKind$fGenericNotationKindPhaseParsingDeserializationScopingTyping Termination Positivity InjectivityProjectionLikenessCoverage Highlighting SerializationDeadCodeRecCheckReduceLevelCompareWith CompactionBuildInterface BinaryEncodeCompress OperatorsExprOperatorsPatternFree OccursCheckCheckLHSCheckRHSInstanceSearch UnifyIndicesInverseScopeLookup TopModule DefinitionisModuleAccount isDefAccountisInternalAccount benchmarksbillToIO billToPure$fMonadBenchIO $fNFDataPhase $fPrettyPhase $fEqPhase $fOrdPhase $fShowPhase$fGenericPhase 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$fCPatternLikeList2$fCPatternLikeNonEmpty$fCPatternLike[]$fCPatternLikeNamed$fCPatternLikeArg$fCPatternLike(,)$fCPatternLikePatternNKInPrePostNon OperatorType ParseSectionsDoNotParseSectionsIsExprexprView unExprView patternViewExprViewLocalVWildVOtherVAppVOpAppV HiddenArgV InstanceArgVLamVParenV placeholdermaybePlaceholdersatNoPlaceholderpartPatLeastTwoParts patternBinderopPargsPappP$fIsExprPattern $fIsExprExpr$fHasRangeExprView$fEqParseSections$fShowParseSectionsExprLikemapExprfoldExpr traverseExpr$fExprLikeDeclaration$fExprLikeModuleApplication$fExprLikeDoStmt$fExprLikeLamClause$fExprLikeRewriteEqn' $fExprLikeLHS$fExprLikeLamBinding'$fExprLikeOpApp$fExprLikeModuleAssignment$fExprLikeFieldAssignment'$fExprLikeExpr$fExprLike(,,,)$fExprLike(,,) $fExprLike(,)$fExprLikeEither$fExprLikeWhereClause'$fExprLikeTypedBinding'$fExprLikeRHS'$fExprLikeMaybePlaceholder$fExprLikeWithHiding$fExprLikeNamed $fExprLikeArg$fExprLikeMaybe$fExprLikeList2$fExprLikeNonEmpty $fExprLike[]$fExprLikeBool$fExprLikeQName$fExprLikeName $fExprLike()DoWarnNoWarnMonadFixityErrorthrowMultipleFixityDeclsthrowMultiplePolarityPragmaswarnUnknownNamesInFixityDecl!warnUnknownNamesInPolarityPragmaswarnUnknownFixityInMixfixDecl#warnPolarityPragmasButNotPostulatesFixitiesfixitiesAndPolarities$fMonoidMonadicFixPol$fSemigroupMonadicFixPol$fMonoidDeclaredNames$fSemigroupDeclaredNames $fEqDoWarn $fShowDoWarn DataRecOrFunDataNameRecNameFunName _kindPosCheck _kindUniCheckInMutual NotInMutual KindOfBlockPostulateBlockPrimitiveBlock InstanceBlock FieldBlock DataBlockConstructorBlockInterleavedDeclInterleavedDataInterleavedFun infixDataSig infixDataCons infixFunSiginfixFunClausesInferredMutualinferredChecks inferredBlockinferredLeftovers MutualChecksmutualTerminationmutualCoveragemutualPositivityNiceTypeSignatureNiceConstructorCatchallMeasureNiceDeclarationAxiom NiceFieldPrimitiveFunction NiceMutual NiceModuleNiceModuleMacroNiceOpen NiceImport NicePragma NiceRecSig NiceDataSig NiceFunClauseFunSigFunDef NiceDataDefNiceLoneConstructor NiceRecDefNicePatternSynNiceGeneralizeNiceUnquoteDeclNiceUnquoteDefextendInferredBlockisInterleavedFunisInterleavedDatainterleavedDecldeclName isFunNamesameKindterminationCheck coverageCheckpositivityCheck mutualChecks universeCheck$fNFDataClause$fPrettyNiceDeclaration$fHasRangeNiceDeclaration$fNFDataNiceDeclaration$fMonoidMutualChecks$fSemigroupMutualChecks$fPrettyDataRecOrFun$fEqDataRecOrFun$fDataDataRecOrFun$fShowDataRecOrFun $fEqInMutual$fShowInMutual$fDataKindOfBlock$fEqKindOfBlock$fOrdKindOfBlock$fShowKindOfBlock$fDataNiceDeclaration$fShowNiceDeclaration$fGenericNiceDeclaration $fDataClause $fShowClause$fGenericClauseDeclarationWarning' EmptyAbstractEmptyConstructor EmptyFieldEmptyGeneralize EmptyInstance EmptyMacro EmptyMutualEmptyPostulate EmptyPrivateEmptyPrimitiveInvalidCatchallPragmaInvalidConstructorInvalidConstructorBlockInvalidCoverageCheckPragmaInvalidNoPositivityCheckPragmaInvalidNoUniverseCheckPragmaInvalidRecordDirectiveInvalidTerminationCheckPragmaMissingDefinitionsNotAllowedInMutualOpenPublicPrivateOpenPublicAbstractPolarityPragmasButNotPostulatesPragmaNoTerminationCheckPragmaCompiledShadowingInTelescopeUnknownFixityInMixfixDeclUnknownNamesInFixityDeclUnknownNamesInPolarityPragmasUselessAbstractUselessInstanceUselessPrivateDeclarationWarning dwLocation dwWarningDeclarationException'MultipleEllipses InvalidNameDuplicateDefinitionDuplicateAnonDeclarationMissingWithClausesWrongDefinitionDeclarationPanicWrongContentBlockAmbiguousFunClausesAmbiguousConstructorInvalidMeasureMutualUnquoteDefRequiresSignature BadMacroDefDeclarationException deLocation deExceptiondeclarationWarningNamedeclarationWarningName'unsafeDeclarationWarningunsafeDeclarationWarning'$fPrettyDeclarationException'$fHasRangeDeclarationException'$fHasRangeDeclarationException$fNFDataDeclarationWarning'$fPrettyDeclarationWarning'$fHasRangeDeclarationWarning'$fNFDataDeclarationWarning$fPrettyDeclarationWarning$fHasRangeDeclarationWarning$fShowDeclarationWarning$fGenericDeclarationWarning$fDataDeclarationWarning'$fShowDeclarationWarning'$fGenericDeclarationWarning'$fDataDeclarationException'$fShowDeclarationException' NiceWarningsLoneSigsLoneSig loneSigRange loneSigName loneSigKindNiceEnv _loneSigs_termChk_posChk_uniChk _catchall_covChkniceWarn_nameIdNiceunNicerunNice initNiceEnv lensNameId nextNameIdloneSigs addLoneSig removeLoneSiggetSig noLoneSigsforgetLoneSigs checkLoneSigsloneFunsloneSigsFromLoneNamesterminationCheckPragmawithTerminationCheckPragmacoverageCheckPragmawithCoverageCheckPragmapositivityCheckPragmawithPositivityCheckPragmauniverseCheckPragmawithUniverseCheckPragmagetUniverseCheckFromSigcatchallPragmapopCatchallPragmawithCatchallPragma niceWarningdeclarationExceptiondeclarationWarning'declarationWarning $fFunctorNice$fApplicativeNice $fMonadNice$fMonadStateNiceEnvNice$$fMonadErrorDeclarationExceptionNice LensAttribute AttributeRelevanceAttributeQuantityAttributeCohesionAttribute LockAttributerelevanceAttributeTablequantityAttributeTablecohesionAttributeTablelockAttributeTable attributesMapstringToAttributeexprToAttribute setAttribute setAttributessetPristineRelevancesetPristineQuantitysetPristineCohesionsetPristineLocksetPristineAttributesetPristineAttributesisRelevanceAttributeisQuantityAttributeisTacticAttributerelevanceAttributesquantityAttributestacticAttributes$fKillRangeAttribute$fSetRangeAttribute$fHasRangeAttribute$fShowAttribute CompareResult Dominates IsDominated dominated notDominated dominator FavoritescompareWithFavoritescompareFavorites unionComparedinsertCompared$fMonoidFavorites$fSemigroupFavorites $fEqFavorites$fFoldableFavorites$fShowFavorites$fNullFavorites$fSingletonaFavorites AssocList mapWithKeyMSetBindingSitesetBindingSiteAllowAmbiguousNamesAmbiguousAnythingAmbiguousConProjsAmbiguousNothing UsingOrHiding UsingOnly HidingOnly ResolvedNameVarName DefinedName FieldNameConstructorNamePatternSynResName UnknownName resolvedVarresolvedBindingSourceAbstractModule AbsModuleamodName amodLineage NameMetadata NoMetadataGeneralizedVarsMetadata AbstractNameAbsName anameName anameKind anameLineage anameMetadata WhyInScopeDefinedOpenedAppliedWithKindtheKind kindedThing KindsOfNamesAllKindsOfNamesSomeKindsOfNamesExceptKindsOfNames KindOfNameConName CoConNameFldNamePatternSynNameGeneralizeNameDisallowedGeneralizeName MacroName QuotableName AxiomNamePrimName OtherDefName NameOrModule NameNotModule ModuleNotName inScopeTag InScopeTagNameTag ModuleTag InScopeSetModulesInScope NamesInScope ThingsInScope NameSpacensNames nsModules nsInScopeLocalVarlocalVarlocalBindingSourcelocalShadowedBy BindingSource LambdaBound PatternBoundLetBound WithBound LocalVars ModuleMapNameMap NameMapEntry qnameKind qnameConcrete ScopeInfo _scopeCurrent _scopeModules_scopeVarsToBind _scopeLocals_scopePrecedence_scopeInverseName_scopeInverseModule _scopeInScope_scopeFixities_scopePolaritiesScopeNameSpaces NameSpaceId PrivateNSPublicNS ImportedNSDataOrRecordModule IsDataModuleIsRecordModuleScope scopeName scopeParentsscopeNameSpaces scopeImportsscopeDatatypeModule allNameSpaceslocalNameSpacenameSpaceAccessscopeNameSpaceupdateScopeNameSpacesupdateScopeNameSpacesM shadowLocalpatternToModuleBoundnotShadowedLocalnotShadowedLocals scopeCurrent scopeModulesscopeVarsToBind scopeLocalsscopePrecedencescopeInverseNamescopeInverseModule scopeInScope scopeFixitiesscopePolaritiesscopeFixitiesAndPolaritiesupdateVarsToBind setVarsToBindupdateScopeLocalssetScopeLocals inNameSpace isDefName isConName conKindOfNameconKindOfName'approxConInductionexactConInduction exactConNameelemKindsOfNamesallKindsOfNamessomeKindsOfNamesexceptKindsOfNames lensAnameName lensAmodName mergeNamesmergeNamesManyemptyNameSpace mapNameSpace zipNameSpace mapNameSpaceM emptyScopeemptyScopeInfomapScope mapScope_ mapScopeNS mapScopeM mapScopeM_zipScope zipScope_recomputeInScopeSets filterScopeallNamesInScopeallNamesInScope'exportedNamesInScope namesInScopeallThingsInScope thingsInScope mergeScope mergeScopessetScopeAccess setNameSpacemodifyNameSpaceaddNameToScoperemoveNameFromScopeaddModuleToScope usingOrHidingapplyImportDirectiveapplyImportDirective_renameCanonicalNamesrestrictPrivaterestrictLocalPrivatewithoutPrivatesdisallowGeneralizedVarsinScopeBecause publicModules publicNameseverythingInScopeeverythingInScopeQualified flattenScopeconcreteNamesInScope scopeLookup scopeLookup' isNameInScopeisNameInScopeUnqualifiedinverseScopeLookupNameinverseScopeLookupName'inverseScopeLookupName''inverseScopeLookupModuleinverseScopeLookupModule'recomputeInverseScopeMapsprettyNameSpace blockOfLines$fPrettySuffix$fNFDataDataOrRecordModule$fNFDataNameSpaceId$fPrettyNameSpaceId$fNFDataBindingSource$fPrettyBindingSource$fNFDataNameOrModule$fNFDataKindOfName$fNFDataNameMapEntry$fSemigroupNameMapEntry$fNFDataWhyInScope$fNFDataNameMetadata$fNFDataAbstractName$fSetRangeAbstractName$fHasRangeAbstractName$fPrettyAbstractName$fLensFixityAbstractName$fOrdAbstractName$fEqAbstractName$fNFDataLocalVar$fPrettyLocalVar $fOrdLocalVar $fEqLocalVar$fNFDataAbstractModule$fPrettyAbstractModule$fOrdAbstractModule$fEqAbstractModule$fInScopeAbstractModule$fInScopeAbstractName$fNFDataNameSpace$fPrettyNameSpace $fNFDataScope $fPrettyScope $fNullScope$fNFDataScopeInfo$fKillRangeScopeInfo$fPrettyScopeInfo$fNullScopeInfo $fEqScopeInfo$fNFDataResolvedName$fPrettyResolvedName$fSetBindingSiteAbstractModule$fSetBindingSiteAbstractName$fSetBindingSiteModuleName$fSetBindingSiteQName$fSetBindingSiteName$fSetBindingSite[]$fEqAllowAmbiguousNames$fDataResolvedName$fShowResolvedName$fEqResolvedName$fGenericResolvedName$fDataScopeInfo$fShowScopeInfo$fGenericScopeInfo $fDataScope $fEqScope $fShowScope$fGenericScope$fDataNameSpace $fEqNameSpace$fShowNameSpace$fGenericNameSpace$fDataAbstractModule$fShowAbstractModule$fGenericAbstractModule$fDataLocalVar$fShowLocalVar$fGenericLocalVar$fDataAbstractName$fShowAbstractName$fGenericAbstractName$fDataNameMetadata$fShowNameMetadata$fGenericNameMetadata$fDataWhyInScope$fShowWhyInScope$fGenericWhyInScope$fDataWithKind$fShowWithKind $fEqWithKind $fOrdWithKind$fFunctorWithKind$fFoldableWithKind$fTraversableWithKind$fDataNameMapEntry$fShowNameMapEntry$fGenericNameMapEntry$fEqKindOfName$fOrdKindOfName$fShowKindOfName$fDataKindOfName$fEnumKindOfName$fBoundedKindOfName$fGenericKindOfName$fDataNameOrModule$fEqNameOrModule$fOrdNameOrModule$fShowNameOrModule$fEnumNameOrModule$fBoundedNameOrModule$fGenericNameOrModule$fDataBindingSource$fShowBindingSource$fEqBindingSource$fGenericBindingSource$fDataNameSpaceId$fEqNameSpaceId$fBoundedNameSpaceId$fEnumNameSpaceId$fShowNameSpaceId$fGenericNameSpaceId$fDataDataOrRecordModule$fShowDataOrRecordModule$fEqDataOrRecordModule$fEnumDataOrRecordModule$fBoundedDataOrRecordModule$fGenericDataOrRecordModule ConPatLazy ConPatEager ConPatInfo conPatOrigin conPatInfo conPatLazyPatInfoPatRangeLHSInfolhsRange lhsEllipsis MutualInfomutualTerminationCheckmutualCoverageCheckmutualPositivityCheck mutualRangeDeclInfo declRangeDefInfo'DefInfo defFixity defAccess defAbstract defInstancedefMacrodefInfo defTacticLetInfoLetRange ModuleInfo minfoRange minfoAsTo minfoAsNameminfoOpenShortminfoDirectiveAppInfoappRange appOrigin appParensExprInfo ExprRangeMetaInfo metaRange metaScope metaNumbermetaNameSuggestion emptyMetaInfo exprNoRangedefaultAppInfodefaultAppInfo_ mkDefInfomkDefInfoInstance patNoRange$fNFDataMetaInfo$fKillRangeMetaInfo$fHasRangeMetaInfo$fKillRangeExprInfo$fHasRangeExprInfo$fNFDataAppInfo$fLensOriginAppInfo$fKillRangeAppInfo$fHasRangeAppInfo$fNFDataModuleInfo$fKillRangeModuleInfo$fSetRangeModuleInfo$fHasRangeModuleInfo$fKillRangeLetInfo$fHasRangeLetInfo$fNFDataDeclInfo$fKillRangeDeclInfo$fSetRangeDeclInfo$fHasRangeDeclInfo$fNFDataDefInfo'$fAnyIsAbstractDefInfo'$fLensIsAbstractDefInfo'$fKillRangeDefInfo'$fSetRangeDefInfo'$fHasRangeDefInfo'$fNFDataMutualInfo$fKillRangeMutualInfo$fHasRangeMutualInfo$fNullMutualInfo$fNFDataLHSInfo $fNullLHSInfo$fKillRangeLHSInfo$fHasRangeLHSInfo$fNFDataConPatLazy$fNFDataConPatInfo$fSetRangeConPatInfo$fKillRangeConPatInfo$fHasRangeConPatInfo$fDataConPatInfo$fEqConPatInfo$fShowConPatInfo$fGenericConPatInfo$fDataConPatLazy$fEqConPatLazy$fOrdConPatLazy$fShowConPatLazy$fBoundedConPatLazy$fEnumConPatLazy$fGenericConPatLazy $fDataPatInfo $fEqPatInfo $fNullPatInfo$fSemigroupPatInfo$fMonoidPatInfo $fShowPatInfo$fSetRangePatInfo$fHasRangePatInfo$fKillRangePatInfo$fNFDataPatInfo $fDataLHSInfo $fShowLHSInfo $fEqLHSInfo$fGenericLHSInfo$fDataMutualInfo$fShowMutualInfo$fEqMutualInfo$fGenericMutualInfo$fDataDefInfo'$fShowDefInfo' $fEqDefInfo'$fGenericDefInfo'$fDataDeclInfo$fShowDeclInfo $fEqDeclInfo$fGenericDeclInfo $fDataLetInfo $fShowLetInfo $fEqLetInfo $fNullLetInfo$fNFDataLetInfo$fDataModuleInfo$fEqModuleInfo$fShowModuleInfo$fGenericModuleInfo $fDataAppInfo $fShowAppInfo $fEqAppInfo $fOrdAppInfo$fGenericAppInfo$fDataExprInfo$fShowExprInfo $fEqExprInfo$fNullExprInfo$fNFDataExprInfo$fDataMetaInfo$fShowMetaInfo $fEqMetaInfo$fGenericMetaInfoConvertconvertHighlightingInfoBuilderHighlightingInfo DelayedMerge PositionMap positionMap RangePair rangePair TokenBasedNotOnlyTokenBasedDefinitionSite defSiteModule defSitePos defSiteHere defSiteAnchorAspectsaspect otherAspectsnotedefinitionSite tokenBased OtherAspect ErrorWarning DottedPattern UnsolvedMetaUnsolvedConstraintTerminationProblemPositivityProblemDeadcodeCoverageProblemIncompletePattern TypeChecksMissingDefinitionCatchallClauseConfluenceProblemNameKind GeneralizableFunctionArgumentAspectNumber PrimitiveType BackgroundrangePairInvariantdelayedMergeInvarianthighlightingInfoInvariant highlightingInfoBuilderInvariant parserBasedkindOfNameToNameKind$fNFDataNameKind$fSemigroupNameKind$fNFDataAspect$fSemigroupAspect$fNFDataOtherAspect$fNFDataDefinitionSite$fSemigroupDefinitionSite$fEqDefinitionSite$fMonoidTokenBased$fSemigroupTokenBased$fNFDataAspects$fMonoidAspects$fSemigroupAspects $fEqAspects$fMonoidPositionMap$fSemigroupPositionMap#$fIsBasicRangeMapAspectsPositionMap$fShowDelayedMerge$fConvertDelayedMergeRangeMap $fConvertDelayedMergePositionMap$fConvertDelayedMergeRangeMap0$fConvertPositionMapRangeMap$fConvertRangeMapRangeMap$fConvertDelayedMergehl$$fIsBasicRangeMapAspectsDelayedMerge%$fIsBasicRangeMapAspectsDelayedMerge0$fIsBasicRangeMapaDelayedMerge!$fIsBasicRangeMapAspectsRangePair$fSemigroupDelayedMerge$fMonoidDelayedMerge$fShowPositionMap$fNFDataPositionMap$fShowRangePair$fNFDataRangePair $fShowAspects$fGenericAspects$fEqTokenBased$fShowTokenBased$fShowDefinitionSite$fGenericDefinitionSite$fEqOtherAspect$fOrdOtherAspect$fShowOtherAspect$fEnumOtherAspect$fBoundedOtherAspect$fGenericOtherAspect $fEqAspect $fShowAspect$fGenericAspect $fEqNameKind$fShowNameKind$fGenericNameKindInteractionOutputCallbackStatus GiveResultRemoveTokenBasedHighlighting DisplayInfoMakeCaseVariantResponseResp_HighlightingInfo Resp_StatusResp_JumpToErrorResp_InteractionPointsResp_GiveAction Resp_MakeCase Resp_SolveAllResp_DisplayInfoResp_RunningInfoResp_ClearRunningInfoResp_ClearHighlightingResp_DoneAbortingResp_DoneExiting defaultInteractionOutputCallbackDiagonalMatrixunMMIxrowcolSizerowscolssquaresupSize fromIndexList fromLists toSparseRowstoLists isSingleton zipAssocWith zipMatrices intersectWithinterAssocWith addColumnaddRow $fShowMatrix$fPartialOrdMatrix$fDiagonalMatrixb$fPrettyMatrix$fTransposeMatrix$fTransposeMIx$fTransposeSize $fEqMatrix $fOrdMatrix$fFunctorMatrix$fFoldableMatrix$fTraversableMatrix$fEqMIx$fOrdMIx $fShowMIx$fIxMIx$fEqSize $fOrdSize $fShowSizeNotWorsenotWorseOrderDecrMatincreasedecrease 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 $fShowCMSet$fSemigroupCMSet $fMonoidCMSet $fNullCMSet$fSingletonCallMatrixAugCMSet$fEqCallMatrixAug$fShowCallMatrixAug$fEqCallMatrix'$fOrdCallMatrix'$fShowCallMatrix'$fFunctorCallMatrix'$fFoldableCallMatrix'$fTraversableCallMatrix'$fPartialOrdCallMatrix'$fNotWorseCallMatrix' CallGraph theCallGraphCall callMatrixSetmkCallmkCall'completionStep$fPrettyCallGraph$fCollectionEdgeCallGraph$fSingletonEdgeCallGraph$fMonoidCallGraph$fSemigroupCallGraph$fNullCallGraph$fCombineNewOldGraph$fCombineNewOldFavorites$fShowCallGraph$fCombineNewOldCMSet terminatesterminatesFilterendos idempotent LexPredicate LexAction runLexAction TokenLength CurrentInput PreviousInput AlexInput lexSrcFilelexPoslexInput lexPrevChar lensLexInputalexInputPrevChar alexGetChar alexGetByte getLexInput setLexInput.&&..||.not'$fMonadStateParseStateLexAction$fMonadLexAction$fApplicativeLexAction$fFunctorLexAction LookAheadlookAheadErrorgetInputsetInputnextCharsyncrollback eatNextCharmatchmatch' runLookAhead$fFunctorLookAhead$fApplicativeLookAhead$fMonadLookAhead litStringlitCharinStateeof followedByliteral'literal identifiersymbolkeywordend_begin_endWith beginWithbeginskipandThen withLayout withInterval' withIntervallexToken confirmLayout emptyLayoutnewLayoutBlock offsideRule keepComments keepCommentsM nestedCommenthole skipBlock AlexReturnAlexEOF AlexErrorAlexSkip AlexTokennormallayout empty_layoutbolimp_dirlexercode alexScanUser tokensParser exprParserexprWhereParser moduleParsermoduleNameParserholeContentParser splitOnDots$fSetRangeAttr$fHasRangeAttr$fShowRHSOrTypeSigs$fFunctorLamBinds' withInterval_endPMunPMrunPMIO readFilePMacceptableFileExts parseFile $fFunctorPM$fApplicativePM $fMonadPM $fMonadIOPM$fMonadErrorParseErrorPM$fMonadState[]PM IsProjElim isProjElimElim'ProjIApply isApplyElim isApplyElim' allApplyElimssplitApplyElims argsFromElims allProjElims $fNFDataElim' $fPrettyElim'$fKillRangeElim'$fLensOriginElim'$fIsProjElimElim' $fDataElim' $fShowElim'$fFunctorElim'$fFoldableElim'$fTraversableElim'WakeUp DontWakeUpBlocked' NotBlocked theBlockerignoreBlockingblockingStatusBlocker UnblockOnAll UnblockOnAny UnblockOnMetaUnblockOnProblem NotBlocked'StuckOn Underapplied AbsurdMatchMissingClausesReallyNotBlocked alwaysUnblock neverUnblock unblockOnAll unblockOnAnyunblockOnEither unblockOnMetaunblockOnProblemunblockOnAllMetasunblockOnAnyMetaonBlockingMetasMallBlockingMetasallBlockingProblemsstuckOn blockedOnblocked notBlockedblocked_ notBlocked_ wakeUpWhen wakeUpWhen_wakeIfBlockedOnProblemwakeIfBlockedOnMeta unblockMetaunblockProblem$fNFDataNotBlocked'$fMonoidNotBlocked'$fSemigroupNotBlocked'$fPrettyBlocker$fMonoidBlocker$fSemigroupBlocker$fNFDataBlocker$fNFDataBlocked'$fMonoidBlocked'$fSemigroupBlocked'$fApplicativeBlocked'$fDecorationBlocked' $fShowWakeUp $fEqWakeUp$fDataBlocked'$fShowBlocked'$fFunctorBlocked'$fFoldableBlocked'$fTraversableBlocked'$fGenericBlocked' $fDataBlocker $fShowBlocker $fEqBlocker $fOrdBlocker$fGenericBlocker$fShowNotBlocked'$fDataNotBlocked'$fGenericNotBlocked'TermSizetermSizetsize SuggestionSuggest suggestNameSgTelsgTel TelToArgs telToArgsListTelListTel' DummyTermKind IntervalViewIZeroIOneIMinIMaxINegOTermPathViewPathTypeOTypepathSortpathName pathLevelpathTypepathLhspathRhs EqualityView EqualityType OtherType IdiomTypeeqtSorteqtName eqtParamseqtTypeeqtLhseqtRhsPatternSubstitutionIdSEmptyS:# StrengthenWk PatternVars PatternVarOut patternVarsConPatternInfoconPInfo conPRecordconPFallThroughconPTypeconPLazyDeBruijnPatternDBPatVar dbPatVarName dbPatVarIndexPattern'VarPConPProjPIApplyPDefP PatOrigin PatOSystem PatOSplitPatOVarPatODotPatOWildPatOConPatORecPatOLit PatOAbsurd PatternInfo patOrigin patAsNames PatVarNameclauseLHSRangeclauseFullRange clauseTelnamedClausePats clauseBody clauseTypeclauseCatchall clauseExactclauseRecursiveclauseUnreachableclauseEllipsisNAPsBlocked_ BraveTermunBrave LevelAtom PlusLevel PlusLevel'Level'MaxSort'InfSSetSizeUnivLockUnivPiSortFunSortUnivSortMetaSDefSDummyS IsFibrantIsStrictTeleEmptyTel ExtendTelLensSortlensSortgetSortType'Type''El_getSortunElNoAbsabsNameunAbsElimsElimConInfoMetaVDummy LensConName getConName setConName mapConNameConHeadconName conDataRecord conInductive conFields DataOrRecordIsDataIsRecord NamedArgsDomDom'domInfo domFinitedomName domTacticunDom ClosedLevel argFromDomnamedArgFromDom domFromArgdomFromNamedArg defaultDom defaultArgDomdefaultNamedArgDom clausePatspatVarNameToStringnameToPatVarNamedefaultPatternInfovarPdotPlitP namedVarP namedDBVarPabsurdPnoConPatternInfotoConPatternInfofromConPatternInfo patternInfo patternOriginproperlyMatchingproperlyMatching'isEqualityType isPathTypeisIOne absurdBody isAbsurdBodyabsurdPatternNameisAbsurdPatternNamevar dummyLocName dummyTermWith dummyLevel dummyTerm__DUMMY_TERM____DUMMY_LEVEL__ dummySort__DUMMY_SORT__ dummyType__DUMMY_TYPE__dummyDom __DUMMY_DOM__ atomicLevelvarSorttmSorttmSSort levelPluslevelSucmkTypemkPropmkSSetisSortimpossibleTerm mapAbsNamesM mapAbsNamesreplaceEmptyName telFromList' telFromList telToListlistTel stripDontCarearitysuggestsunSpineunSpine'hasElimspDomprettyPrecLevelSucs $fPrettyDom'$fLensCohesionDom'$fLensQuantityDom'$fLensRelevanceDom'$fLensAnnotationDom'$fLensFreeVariablesDom'$fLensOriginDom'$fLensModalityDom'$fLensHidingDom'$fLensArgInfoDom'$fLensNamedDom'$fEqDom'$fKillRangeDom'$fHasRangeDom'$fDecorationDom'$fNFDataDataOrRecord$fKillRangeDataOrRecord$fNFDataConHead$fKillRangeConHead$fHasRangeConHead$fPrettyConHead $fOrdConHead $fEqConHead$fLensConNameConHead$fSetRangeConHead $fNFDataAbs $fPrettyAbs$fKillRangeAbs $fSizedAbs $fShowAbs$fDecorationAbs $fNFDataTele$fKillRangeTele $fSizedTele $fNullTele$fNFDataIsFibrant$fDecorationType'' $fNFDataDom'$fNFDataLevel' $fNFDataSort'$fNFDataType'' $fNFDataTerm$fPrettyType'' $fPrettySort'$fPrettyLevel' $fPrettyTele $fPrettyTerm$fKillRangeSort'$fKillRangeType''$fKillRangeLevel'$fKillRangeTerm $fLensSortArg$fLensSortDom'$fLensSortType''$fLensSortSort'$fNFDataPlusLevel'$fPrettyPlusLevel'$fKillRangePlusLevel'$fKillRangeBlocked'$fNFDataPatOrigin$fKillRangePatOrigin$fNFDataPatternInfo$fKillRangePatternInfo$fNFDataDBPatVar$fPrettyDBPatVar$fKillRangeDBPatVar$fNFDataConPatternInfo$fKillRangeConPatternInfo$fNFDataPattern'$fPrettyPattern'$fKillRangePattern'$fIsProjPPattern'$fPrettyClause$fKillRangeClause $fNullClause$fHasRangeClause$fPatternVars[]$fPatternVarsArg$fPatternVarsArg0$fNFDataSubstitution'$fPrettySubstitution'$fNullSubstitution'$fKillRangeSubstitution'$fTelToArgsTele $fTelToArgs[] $fSgTelDom' $fSgTelDom'0 $fSgTel(,) $fSuggestTerm $fSuggestName $fSuggestAbs $fSuggest[]$fTermSizeSubstitution'$fTermSizePlusLevel'$fTermSizeLevel'$fTermSizeSort'$fTermSizeTerm $fTermSizet$fShowIntervalView$fShowSubstitution'$fFunctorSubstitution'$fFoldableSubstitution'$fTraversableSubstitution'$fGenericSubstitution'$fDataPattern'$fShowPattern'$fFunctorPattern'$fFoldablePattern'$fTraversablePattern'$fGenericPattern'$fDataConPatternInfo$fShowConPatternInfo$fGenericConPatternInfo$fDataDBPatVar$fShowDBPatVar $fEqDBPatVar$fGenericDBPatVar$fDataPatternInfo$fShowPatternInfo$fEqPatternInfo$fGenericPatternInfo$fDataPatOrigin$fShowPatOrigin $fEqPatOrigin$fGenericPatOrigin$fDataBraveTerm$fShowBraveTerm $fDataTerm $fShowTerm $fDataType'' $fShowType''$fFunctorType''$fFoldableType''$fTraversableType'' $fDataSort' $fShowSort' $fShowLevel' $fDataLevel'$fFunctorLevel'$fFoldableLevel'$fTraversableLevel'$fShowPlusLevel'$fDataPlusLevel'$fFunctorPlusLevel'$fFoldablePlusLevel'$fTraversablePlusLevel'$fDataIsFibrant$fShowIsFibrant $fEqIsFibrant$fOrdIsFibrant$fGenericIsFibrant $fDataTele $fShowTele $fFunctorTele$fFoldableTele$fTraversableTele $fGenericTele $fDataAbs $fFunctorAbs $fFoldableAbs$fTraversableAbs $fGenericAbs $fDataConHead $fShowConHead$fGenericConHead$fDataDataOrRecord$fShowDataOrRecord$fEqDataOrRecord$fGenericDataOrRecord $fDataDom' $fShowDom' $fFunctorDom'$fFoldableDom'$fTraversableDom'DeBruijn deBruijnVardebruijnNamedVar deBruijnView$fDeBruijnDBPatVar$fDeBruijnLevel'$fDeBruijnPlusLevel'$fDeBruijnTermPrecomputeFreeVarsprecomputeFreeVarsprecomputeFreeVars_precomputedFreeVars$fPrecomputeFreeVars(,)$fPrecomputeFreeVarsMaybe$fPrecomputeFreeVars[]$fPrecomputeFreeVarsElim'$fPrecomputeFreeVarsType''$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$fFreeEqualityView $fFreeClause $fFreeTele $fFreeAbs $fFreeDom' $fFreeArg $fFreeElim' $fFree(,,) $fFree(,) $fFreeNamed$fFreeWithHiding $fFreeMaybe$fFree[]$fFreePlusLevel' $fFreeLevel' $fFreeSort' $fFreeType'' $fFreeTerm$fShowFlexRigMap$fSingleton(,)FlexRigMap$fEqIgnoreSorts$fShowIgnoreSorts $fEqVarMap' $fShowVarMap' $fShowVarOcc' $fEqFlexRig'$fShowFlexRig'$fFunctorFlexRig'$fFoldableFlexRig' $fEqMetaSet $fShowMetaSet $fNullMetaSet$fSemigroupMetaSet$fMonoidMetaSet VarCounts varCountsfreeVarsIgnorerunFreevarOccurrenceInflexRigOccurrenceInfreeInfreeInIgnoringSorts 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$fMonoidRelevantIn TermSubst EndoSubst SubstWithSubstSubstArg applySubstabstractapplyEapplysapply1raise raiseFrom strengthen substUnderidSwkSraiseSconsS singletonSinplaceSdropScomposeSsplitS++#prependS parallelScompactS strengthenSlookupSlistS raiseFromSabsApp lazyAbsAppnoabsAppabsBodymkAbsreAbsunderAbs underLambdas $fSubstQNameDataConstructor AbsurdClause clauseRHSSetSLitSPropSPropLitSInfSUnknownSExtLam argsToElims$fShowDefinition $fShowSortPatternVarModalitiespatternVarModalitiesCountPatternVarscountPatternVars PatternLike foldrPatterntraversePatternMMapNamedArgPatternmapNamedArgPattern LabelPatVars PatVarLabel labelPatVarsunlabelPatVarsFunArityfunArity clauseArgs clauseElimsunnumberPatVars dbPatPerm dbPatPerm' clausePerm patternToElimpatternsToElims patternToTerm foldPatternpreTraversePatternMpostTraversePatternM $fFunArity[]$fFunArityClause $fFunArity[]0$fLabelPatVarsPattern'Pattern'$fLabelPatVars[][]$fLabelPatVarsNamedNamed$fLabelPatVarsArgArg$fMapNamedArgPatterna[]$fMapNamedArgPatternaArg$fPatternLikeaNamed$fPatternLikeaArg$fPatternLikea[]$fPatternLikeaPattern'$fCountPatternVarsPattern'$fCountPatternVarsNamed$fCountPatternVarsArg$fCountPatternVars[]$fPatternVarModalitiesPattern'$fPatternVarModalitiesArg$fPatternVarModalitiesNamed$fPatternVarModalities[]TermLike traverseTermMcopyTerm$fTermLikeEqualityView$fTermLikeSort'$fTermLikeType''$fTermLikePlusLevel'$fTermLikeLevel'$fTermLikeTerm$fTermLike(,,,)$fTermLike(,,) $fTermLike(,)$fTermLikeWithHiding$fTermLikeTele $fTermLikeAbs$fTermLikeBlocked'$fTermLikeMaybe $fTermLike[]$fTermLikeDom' $fTermLikeArg$fTermLikeElim'$fTermLikeQName$fTermLikeChar$fTermLikeInteger $fTermLikeInt$fTermLikeBoolCompiledClausesCompiledClauses'DoneBranches projPatterns conBranches etaBranch litBranchescatchAllBranch fallThrough lazyMatch WithAritycontentlitCaseconCaseetaCaseprojCasecatchAllcheckLazyMatch hasCatchAllhasProjectionPatterns prettyMap_$fNFDataWithArity$fTermLikeWithArity$fKillRangeWithArity$fPrettyWithArity$fMonoidWithArity$fSemigroupWithArity $fNFDataCase$fTermLikeCase$fKillRangeCase $fPrettyCase $fNullCase $fMonoidCase$fSemigroupCase$fNFDataCompiledClauses'$fTermLikeCompiledClauses'$fKillRangeCompiledClauses'$fPrettyCompiledClauses'$fDataCompiledClauses'$fFunctorCompiledClauses'$fTraversableCompiledClauses'$fFoldableCompiledClauses'$fShowCompiledClauses'$fGenericCompiledClauses' $fDataCase $fFunctorCase$fFoldableCase$fTraversableCase $fShowCase $fGenericCase$fDataWithArity$fFunctorWithArity$fFoldableWithArity$fTraversableWithArity$fShowWithArity$fGenericWithArityAllMetasallMetas allMetas' allMetasListnoMetas firstMetaunblockOnAnyMetaInunblockOnAllMetasIn $fAllMetasArg$fAllMetasMaybe $fAllMetas[]$fAllMetas(,,,)$fAllMetas(,,) $fAllMetas(,)$fAllMetasPlusLevel'$fAllMetasLevel'$fAllMetasSort'$fAllMetasDom'$fAllMetasTele$fAllMetasElim'$fAllMetasType''$fAllMetasTermGetDefsgetDefs MonadGetDefsdoDefdoMeta GetDefsEnv lookupMetaembDefGetDefsMgetDefs' $fGetDefs(,) $fGetDefsAbs $fGetDefsDom' $fGetDefsArg$fGetDefsElim' $fGetDefs[]$fGetDefsMaybe$fGetDefsPlusLevel'$fGetDefsLevel'$fGetDefsSort'$fGetDefsType''$fGetDefsMetaId $fGetDefsTerm$fGetDefsClause$fMonadGetDefsReaderT SubstExpr substExprPatternSynDefnsPatternSynDefn NameToExpr nameToExpr AnyAbstract anyAbstractPatternsNAPs1 PatternSynPAnnPLHSCore'lhsInfolhsCoreSpineLHS spLhsInfo spLhsDefName spLhsPatsWithRHS RewriteRHSrhsExpr rhsConcrete rewriteExprsrewriteStrippedPats rewriteRHSrewriteWhereDecls WithExpr' SpineClauseWhereDeclarations WhereDecls whereModule whereDeclsClause' clauseLHSclauseStrippedPatsclauseWhereDecls ProblemEq problemInPat problemInst problemType DataDefParamsdataDefGeneralizedParams dataDefParamsGeneralizeTelescope GeneralizeTelgeneralizeTelVars generalizeTel TacticAttr LetBindingLetBind LetPatBindLetApplyLetOpenLetDeclaredVariableBuiltinNoDefPragmaSectionRecSigRecDef PatternSynDef ScopedDecl ScopeCopyInfo renModulesrenNamesRen RecordAssigns RecordAssignAssignsAssignDef' ScopedExprBindNameunBind mkBindName generalized initCopyInfoextractPattern mkDomainFreemkTBindmkPinoDataDefParams noWhereDecls axiomNameapp patternToExprlambdaLiftExprinsertImplicitPatSynArgs$fKillRangeSuffix $fOrdBindName $fEqBindName$fNFDataScopeCopyInfo$fKillRangeScopeCopyInfo$fPrettyScopeCopyInfo$fSetRangePattern'$fHasRangePattern'$fNFDataLHSCore'$fKillRangeLHSCore'$fHasRangeLHSCore' $fNFDataRHS$fNFDataWhereDeclarations$fNFDataClause'$fNFDataProblemEq$fNFDataDataDefParams$fNFDataGeneralizeTelescope$fNFDataTypedBinding$fNFDataLamBinding$fNFDataLetBinding$fKillRangeLetBinding$fKillRangeWhereDeclarations$fKillRangeRHS$fKillRangeProblemEq$fKillRangeClause'$fKillRangeTypedBinding$fKillRangeDataDefParams$fKillRangeGeneralizeTelescope$fKillRangeLamBinding$fHasRangeLetBinding$fHasRangeWhereDeclarations $fHasRangeRHS$fHasRangeClause'$fHasRangeTypedBinding$fHasRangeLamBinding$fLensHidingTypedBinding$fLensHidingLamBinding$fUnderscoreExpr $fIsProjPExpr$fEqRHS$fNullWhereDeclarations $fEqProblemEq$fNFDataSpineLHS$fKillRangeSpineLHS$fHasRangeSpineLHS$fAnyAbstractDeclaration$fAnyAbstract[]$fNameToExprResolvedName$fNameToExprAbstractName$fSubstExprExpr$fSubstExprModuleName$fSubstExprName$fSubstExprEither$fSubstExpr(,)$fSubstExprFieldAssignment'$fSubstExprNamed$fSubstExprArg$fSubstExprNonEmpty $fSubstExpr[]$fSubstExprMaybe$fDataSpineLHS$fShowSpineLHS $fEqSpineLHS$fGenericSpineLHS $fGenericExpr $fGenericLHS $fDataClause' $fShowClause'$fFunctorClause'$fFoldableClause'$fTraversableClause' $fEqClause'$fGenericClause' $fDataRHS $fShowRHS $fGenericRHS$fDataWhereDeclarations$fShowWhereDeclarations$fEqWhereDeclarations$fGenericWhereDeclarations$fGenericDeclaration$fDataDataDefParams$fShowDataDefParams$fEqDataDefParams$fGenericDataDefParams$fDataLamBinding$fShowLamBinding$fEqLamBinding$fGenericLamBinding$fDataTypedBinding$fShowTypedBinding$fEqTypedBinding$fGenericTypedBinding$fGenericBinder'$fDataLetBinding$fShowLetBinding$fEqLetBinding$fGenericLetBinding$fGenericModuleApplication$fDataGeneralizeTelescope$fShowGeneralizeTelescope$fEqGeneralizeTelescope$fGenericGeneralizeTelescope$fGenericPragma$fDataProblemEq$fShowProblemEq$fGenericProblemEq$fDataLHSCore'$fShowLHSCore'$fFunctorLHSCore'$fFoldableLHSCore'$fTraversableLHSCore' $fEqLHSCore'$fGenericLHSCore' $fEqPattern'$fEqScopeCopyInfo$fShowScopeCopyInfo$fDataScopeCopyInfo$fGenericScopeCopyInfo$fShowBindName$fDataBindName$fHasRangeBindName$fKillRangeBindName$fSetRangeBindName$fNFDataBindName DeclaredNames declaredNamesKName recurseExprTraverseExprRecFnTraverseExprFn FoldExprRecFn FoldExprFnRecurseExprRecFn RecurseExprFnLamViewAppView' ApplicationappView'maybeProjTurnPostfixlamViewasViewunScope deepUnscopedeepUnscopeDeclsdeepUnscopeDecl$fExprLikeSpineLHS$fExprLikeLHSCore'$fExprLikeWhereDeclarations$fExprLikePattern'$fExprLikeTypedBinding$fExprLikeDataDefParams$fExprLikeGeneralizeTelescope$fExprLikeLamBinding$fExprLikeModuleName$fExprLikeBindName$fExprLikeVoid$fExprLikePragma $fExprLikeRHS$fExprLikeClause'$fExprLikeLetBinding$fDeclaredNamesRHS $fDeclaredNamesWhereDeclarations$fDeclaredNamesClause'$fDeclaredNamesPragma$fDeclaredNamesDeclaration $fDeclaredNamesRecordDirectives'$fDeclaredNamesWithKind$fDeclaredNames(,)$fDeclaredNamesEither$fDeclaredNamesFieldAssignment'$fDeclaredNamesNamed$fDeclaredNamesArg$fDeclaredNamesMaybe$fDeclaredNamesNonEmpty$fDeclaredNames[]$fFunctorAppView'mergePatternSynDefsmatchPatternSynmatchPatternSynP LHSToSpine lhsToSpine spineToLhsLHSProjPADotT foldrAPatterntraverseAPatternMNAP foldAPatternpreTraverseAPatternMpostTraverseAPatternM mapAPatterncontainsAPatterncontainsAbsurdPatterncontainsAsPatterncheckPatternLinearity substPattern substPattern'splitOffTrailingWithPatternstrailingWithPatternslhsCoreToSpinespineToLhsCorelhsCoreAddChunklhsCoreAllPatternslhsCoreToPattern mapLHSHead$fIsWithPPattern'$fMapNamedArgPattern(,)$fMapNamedArgPatternMaybe$$fMapNamedArgPatternFieldAssignment'$fMapNamedArgPattern[]$fMapNamedArgPatternArg$fAPatternLike(,)$fAPatternLikeFieldAssignment'$fAPatternLikeMaybe$fAPatternLike[]$fAPatternLikeNamed$fAPatternLikeArg$fAPatternLikePattern'$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$fMonadTransControlChangeT $fUpdater1[]$fUpdater1Maybe$fUpdater2Either $fUpdater2(,)$fFunctorChangeT$fApplicativeChangeT$fMonadChangeT$fMonadTransChangeT$fMonadFailChangeT$fMonadIOChangeTniceDeclarationsnotSoNiceDeclarationsniceHasAbstract$fMakeAbstractWhereClause'$fMakeAbstractClause$fMakeAbstractNiceDeclaration$fMakeAbstractIsAbstract$fMakeAbstract[]$fMakePrivateWhereClause'$fMakePrivateClause$fMakePrivateNiceDeclaration$fMakePrivateAccess$fMakePrivate[] $fEqDeclKind$fShowDeclKindVarSetsubtractSizeVar SizeConst LegendMatrixmatrixrowdescrcoldescrGM flexScopenodeMapintMapnextNode ConstraintsNewFlexArcNodeIdRConstRVarFiniteInfiniteAdjListwarshall warshallGincinfiniteisBelowemptyConstraints initGraphaddFlexaddNode addConstraint buildGraphmkMatrixextendSolution sizeRigidsolve$fSemiRingWeight$fPrettyConstraint$fPrettyLegendMatrix$fPrettySizeExpr WithDefaultDefaultValue setDefaultcollapseDefault$fNFDataWithDefault$fEqWithDefault$fShowWithDefault ComposeZipper ComposeZip ListZipperListZipZipperCarrierElement firstHoleplugHolenextHole$fZipperListZipper$fZipperComposeZipper$fEqListZipper$fOrdListZipper$fShowListZipper$fFunctorListZipper$fFoldableListZipper$fTraversableListZipperversionpackage'$fGenericAnArbitrarySymbolInThisPackageversionWithCommitInfo commitInfo VersionViewvvBase vvNumbersmkLibMgetPrimitiveLibDirfindProjectRootgetAgdaLibFiles'getDefaultLibrariesgetInstalledLibrariesgetTrustedExecutableslibraryIncludePathsfindLib' versionView unVersionView$fEqVersionView$fShowVersionViewFlagOptMConfluenceCheckLocalConfluenceCheckGlobalConfluenceCheck PragmaOptionsoptShowImplicitoptShowIrrelevant optUseUnicode optVerboseoptProp optTwoLeveloptAllowUnsolvedoptAllowIncompleteMatchoptDisablePositivityoptTerminationCheckoptTerminationDepthoptCompletenessCheckoptUniverseCheckoptOmegaInOmega optSubtypingoptCumulativity optSizedTypesoptGuardednessoptInjectiveTypeConstructorsoptUniversePolymorphismoptIrrelevantProjectionsoptExperimentalIrrelevance optWithoutK optCopatternsoptPatternMatching optExactSplitoptEta optForcingoptProjectionLike optRewriting optCubical optGuarded optFirstOrderoptPostfixProjectionsoptKeepPatternVariablesoptInstanceSearchDepthoptOverlappingInstancesoptQualifiedInstancesoptInversionMaxDepthoptSafeoptDoubleCheckoptSyntacticEqualityoptWarningModeoptCompileNoMain optCachingoptCountClusters optAutoInlineoptPrintPatternSynonyms optFastReduce optCallByNameoptConfluenceCheck optFlatSplitoptImportSorts optAllowExecoptShowIdentitySubstitutionsCommandLineOptionsOptionsoptProgramName optInputFileoptIncludePathsoptAbsoluteIncludePaths optLibrariesoptOverrideLibrariesFileoptDefaultLibs optUseLibsoptTrustedExecutablesoptPrintAgdaDiroptPrintVersion optPrintHelpoptInteractiveoptGHCiInteractionoptJSONInteractionoptOptimSmashing optCompileDiroptGenerateVimFileoptIgnoreInterfacesoptIgnoreAllInterfacesoptLocalInterfacesoptPragmaOptionsoptOnlyScopeChecking Verbosity VerboseLevel VerboseKeymapFlagdefaultVerbositydefaultInteractionOptionsdefaultOptionsdefaultPragmaOptionsrunOptM checkOptsunsafePragmaOptionsrestartOptionsinfectiveOptionscoinfectiveOptions inputFlagsafeFlagstandardOptionsdeadStandardOptionsstandardOptions_ getOptSimpleparsePragmaOptionsparsePluginOptionsusagestripRTS HasOptions pragmaOptionscommandLineOptions MonadTCErrorMonadTCMliftTCMBlockTunBlockT MonadBlockpatternViolationcatchPatternErr MonadTCStategetTCputTCmodifyTC MonadTCEnvaskTClocalTC MonadReduce liftReduceReduceM unReduceM ReduceEnvredEnvredSt TypeError Exception IOException PatternErr tcErrLocation tcErrState tcErrClosErr LHSOrPatSynIsLHSIsPatSyn InternalErrorNotImplemented NotSupportedCompilationErrorPropMustBeSingletonDataMustEndInSort#ShouldEndInApplicationOfTheDatatype&ShouldBeAppliedToTheDatatypeParametersShouldBeApplicationOf!ConstructorPatternInWrongDatatype6CantResolveOverloadedConstructorsTargetingSameDatatypeDoesNotConstructAnElementOfWrongHidingInLHSWrongHidingInLambdaWrongHidingInApplicationWrongNamedArgumentWrongIrrelevanceInLambdaWrongQuantityInLambdaWrongCohesionInLambdaQuantityMismatchHidingMismatchRelevanceMismatchUninstantiatedDotPattern ForcedConstructorNotInstantiatedIllformedProjectionPatternCannotEliminateWithPattern!WrongNumberOfConstructorArguments ShouldBeEmpty ShouldBeASort ShouldBePi ShouldBePathShouldBeRecordTypeShouldBeRecordPatternNotAProjectionPatternNotAProperTermInvalidTypeSort InvalidTypeFunctionTypeInSizeUnivSplitOnIrrelevantSplitOnUnusableCohesionSplitOnNonVariableSplitOnNonEtaRecordDefinitionIsIrrelevantDefinitionIsErasedVariableIsIrrelevantVariableIsErasedVariableIsOfUnusableCohesion UnequalLevel UnequalTerms UnequalTypesUnequalRelevanceUnequalQuantityUnequalCohesion UnequalHiding UnequalSorts UnequalBecauseOfUniverseConflict NotLeqSortMetaCannotDependOnMetaOccursInItselfMetaIrrelevantSolutionMetaErasedSolution GenericErrorGenericDocErrorSortOfSplitVarErrorBuiltinMustBeConstructorNoSuchBuiltinNameDuplicateBuiltinBindingNoBindingForBuiltinNoSuchPrimitiveFunctionDuplicatePrimitiveBindingWrongModalityForPrimitiveShadowedModuleBuiltinInParameterisedModuleIllegalLetInTelescopeIllegalPatternInTelescopeNoRHSRequiresAbsurdPattern TooManyFieldsDuplicateFieldsDuplicateConstructorsWithOnFreeVariableUnexpectedWithPatternsWithClausePatternMismatchFieldOutsideRecordModuleArityMismatchGeneralizeCyclicDependencyGeneralizeUnsolvedMeta SplitErrorImpossibleConstructorTooManyPolaritiesLocalVsImportedModuleClashSolvedButOpenHolesCyclicModuleDependency FileNotFoundOverlappingProjectsAmbiguousTopLevelModuleNameModuleNameUnexpectedModuleNameDoesntMatchFileNameClashingFileNamesForModuleDefinedInOtherFileBothWithAndRHSAbstractConstructorNotInScope NoSuchModule AmbiguousNameAmbiguousModuleClashingDefinitionClashingModuleClashingImportClashingModuleImportPatternShadowsConstructorDuplicateImportsInvalidPatternRepeatedVariablesInPatternGeneralizeNotSupportedHereMultipleFixityDeclsMultiplePolarityPragmasNotAModuleExprNotAnExpressionNotAValidLetBindingNotValidBeforeFieldNothingAppliedToHiddenArgNothingAppliedToInstanceArgBadArgumentsToPatternSynonymTooFewArgumentsToPatternSynonym$CannotResolveAmbiguousPatternSynonymUnusedVariableInPatternSynonymNoParseForApplicationAmbiguousParseForApplication NoParseForLHSAmbiguousParseForLHSOperatorInformationInstanceNoCandidate UnquoteFailedDeBruijnIndexOutOfScopeNeedOptionCopatternsNeedOptionRewritingNeedOptionPropNeedOptionTwoLevelNonFatalErrorsInstanceSearchDepthExhaustedTriedToCopyConstrainedPrim UnquoteError BadVisibilityConInsteadOfDefDefInsteadOfCon NonCanonical BlockedOnMeta UnquotePanicUnificationFailureUnifyIndicesNotVarsUnifyRecursiveEqUnifyReflexiveEqUnifyUnusableModalityNegativeUnification UnifyConflict UnifyCycle NotADatatype BlockedTypeErasedDatatypeCoinductiveDatatypeUnificationStuckCosplitCatchallCosplitNoTargetCosplitNoRecordTypeCannotCreateMissingClauseGenericSplitErrorcantSplitBlockercantSplitConName cantSplitTelcantSplitConIdxcantSplitGivenIdxcantSplitFailuresTerminationErrortermErrFunctions termErrCallsCallInfocallInfoTarget callInfoRange callInfoCalltcWarningLocationtcWarningRange tcWarningtcWarningPrintedWarningtcWarningCachedRecordFieldWarningDuplicateFieldsWarningTooManyFieldsWarning NicifierIssueTerminationIssueUnreachableClauses CoverageIssueCoverageNoExactSplitNotStrictlyPositiveUnsolvedMetaVariablesUnsolvedInteractionMetasUnsolvedConstraintsCantGeneralizeOverSortsAbsurdPatternRequiresNoRHS OldBuiltinEmptyRewritePragma EmptyWhereIllformedAsClauseClashesViaRenaming"UselessPatternDeclarationForRecord UselessPublic UselessHiding UselessInlineWrongInstanceDeclarationInstanceWithExplicitArgInstanceNoOutputTypeNameInstanceArgWithExplicitArgInversionDepthReachedNoGuardednessFlagGenericWarningGenericNonFatalErrorGenericUselessSafeFlagPostulateSafeFlagPragmaSafeFlagNonTerminatingSafeFlagTerminating%SafeFlagWithoutKFlagPrimEraseEqualityWithoutKFlagPrimEraseEqualitySafeFlagNoPositivityCheckSafeFlagPolaritySafeFlagNoUniverseCheckSafeFlagNoCoverageCheckSafeFlagInjective SafeFlagEtaLibraryWarningDeprecationWarning UserWarningDuplicateUsingFixityInRenamingModuleModuleDoesntExportInfectiveImportCoInfectiveImportRewriteNonConfluentRewriteMaybeNonConfluentRewriteAmbiguousRulesRewriteMissingRulePragmaCompileErased NotInScopeW+AsPatternShadowsConstructorOrPatternSynonymArgsCheckStateACStateacRangesacElims acConstraintsacTypeacData Candidate candidateKind candidateTerm candidateTypecandidateOverlappable CandidateKindLocalCandidateGlobalCandidate ExpandHidden ExpandLastDontExpandLastReallyDontExpandLast AbstractMode ConcreteModeIgnoreAbstractMode LetBindings ContextEntryContext UnquoteFlags_unquoteNormalise LensTCEnv lensTCEnv envContextenvLetBindingsenvCurrentModuleenvCurrentPathenvAnonymousModules envImportPathenvMutualBlockenvTerminationCheckenvCoverageCheck envMakeCaseenvSolvingConstraintsenvCheckingWhereenvWorkingOnTypesenvAssignMetasenvActiveProblemsenvAbstractMode envModalityenvSplitOnStrictenvDisplayFormsEnabledenvRangeenvHighlightingRange envClauseenvCallenvHighlightingLevelenvHighlightingMethod envExpandLast envAppDefenvSimplificationenvAllowedReductions envReduceDefsenvReconstructedenvInjectivityDepthenvCompareBlockedenvPrintDomainFreePienvPrintMetasBareenvInsideDotPatternenvUnquoteFlagsenvInstanceDepthenvIsDebugPrintingenvPrintingPatternLambdas envCallByNeedenvCurrentCheckpointenvCheckpointsenvGeneralizeMetasenvGeneralizedVarsenvActiveBackendNameenvConflComputingOverlapDirectIndirectNoneNonInteractive InteractiveBuiltinPrim BuiltinThings BuiltinInfo builtinName builtinDescBuiltinDescriptor BuiltinDataBuiltinDataCons BuiltinPrim BuiltinSortBuiltinPostulateBuiltinUnknownTempInstanceTable InstanceTable CheckClause CheckPatternCheckPatternLinearityTypeCheckPatternLinearityValueCheckLetBinding InferExpr CheckExprCallCheckDotPatternCheckProjection IsTypeCallIsType_InferVarInferDefCheckArgumentsCheckMetaSolutionCheckTargetType CheckDataDef CheckRecDefCheckConstructorCheckConstructorFitsInCheckFunDefCall CheckPragmaCheckPrimitive CheckIsEmptyCheckConfluenceCheckWithFunctionTypeCheckSectionApplicationCheckNamedWhereScopeCheckExprScopeCheckDeclaration ScopeCheckLHSNoHighlightingModuleContents StatisticsMutualIdMutIdTermHeadSortHeadPiHeadConsHeadVarHead UnknownHeadFunctionInverse' NotInjectiveInverse InversionMapFunctionInversePrimFun primFunName primFunArityprimFunImplementation PrimitiveImplPrimImpl ReduceDefsOnlyReduceDefsDontReduceDefsAllowedReductionsAllowedReductionProjectionReductionsInlineReductionsCopatternReductionsFunctionReductionsRecursiveReductionsLevelReductionsTypeLevelReductionsUnconfirmedReductionsNonTerminatingReductionsMaybeReducedElimsMaybeReducedArgs MaybeReducedMaybeRed isReduced ignoreReduced IsReduced NotReducedReduced NoReduction YesReductionSimplificationYesSimplificationNoSimplificationFieldsDefn DataOrRecSigGeneralizableVar AbstractDefn PrimitiveSortaxiomConstTransp datarecPars funClauses funCompiled funSplitTree funTreeless funCoveringfunInv funMutualfunAbstr funDelayed funProjectionfunFlags funTerminates funExtLamfunWithdataParsdataIxs dataClausedataConsdataSort dataMutual dataAbstr dataPathConsrecPars recClause recConHead recNamedCon recFieldsrecTel recMutualrecEtaEquality'recPatternMatching recInductionrecAbstrrecCompconParsconArity conSrcConconDataconAbstrconIndconCompconProj conForced conErased primAbstrprimName primClausesprimInv primCompiledprimSortCompKit nameOfHComp nameOfTransp FunctionFlag FunStatic FunInlineFunMacro EtaEquality SpecifiedInferredtheEtaEqualityProjLams getProjLams Projection projProperprojOrig projFromType projIndexprojLams ExtLamInfo extLamModule extLamAbsurd extLamSysSystem systemTel systemClausesFaceCompiledRepresentationCompilerPragmaIsForcedForced NotForced Covariant Contravariant Invariant NonvariantNumGeneralizableArgsNoGeneralizableArgsSomeGeneralizableArgs defArgInfodefNamedefType defPolaritydefArgOccurrencesdefArgGeneralizabledefGeneralizedParams defDisplay defMutualdefCompiledRepdefCopy defMatchabledefNoCompilation defInjectivedefCopatternLHS defBlockedtheDef RewriteRulerewName rewContextrewHeadrewPatsrewRHSrewType rewFromClause RewriteRulesNLPSortPTypePPropPInf PSizeUniv PLockUnivNLPType nlpTypeSort nlpTypeUnElPElimsNLPatPDefPLamPPiPSort PBoundVarPTerm DisplayTermDWithAppDConDDefDDotDTermLocalDisplayForm DisplayFormDisplay dfPatternVarsdfPatsdfRHS _secTelescope DisplayFormsRewriteRuleMap DefinitionsSections SignatureSig _sigSections_sigDefinitions_sigRewriteRulesIPClause IPNoClauseipcQName ipcClauseNoipcType ipcWithSub ipcClause ipcClosure ipcBoundary IPBoundary IPBoundary' ipbEquationsipbValue ipbMetaAppipbOverapplied OverappliedNotOverappliedInteractionPointsInteractionPointipRangeipMetaipSolvedipClause MetaStore nmSuggestionnmidMetaNameSuggestion miClosRange miModalitymiMetaOccursCheckmiNameSuggestionmiGeneralizableRunMetaOccursCheckDontRunMetaOccursCheck MetaPriorityTypeCheckingProblem CheckExpr CheckArgsCheckProjAppToKnownPrincipalArg CheckLambda DoQuoteTermPrincipalArgTypeMetas patmMetas patmRemainder CheckedTargetNotCheckedTargetMetaInstantiationInstV OpenInstance BlockedConstPostponedTypeCheckingProblemFrozen InstantiableListener EtaExpandCheckConstraint MetaVariableMetaVarmvInfo mvPriority mvPermutation mvJudgementmvInstantiation mvListenersmvFrozenmvTwinGeneralizedValuegenvalCheckpoint genvalTerm genvalType DoGeneralizeYesGeneralizeVarYesGeneralizeMeta NoGeneralize JudgementHasTypeIsSortjMetaId jComparison jMetaType OpenThingopenThingCheckpointopenThingCheckpointMapopenThingModule openThing CompareAs AsTermsOfAsSizesAsTypesCompareDirectionDirEqDirLeqDirGeqCmpEqCmpLeqValueCmpValueCmpOnFaceElimCmpSortCmpLevelCmp HasBiggerSort HasPTSRule CheckMetaInstUnBlockIsEmptyCheckSizeLtSat FindInstance CheckFunDef UnquoteTacticCheckLockedVarsUsableAtModalityProblemConstraintPConstrconstraintProblemsconstraintUnblocker theConstraint LensClosure lensClosureClosure clSignatureclEnvclScopeclModuleCheckpointsclValue Interface iSourceHashiSource iFileTypeiImportedModules iModuleNameiScope iInsideScope iSignature iDisplayForms iUserWarningsiImportWarningiBuiltin iForeignCode iHighlightingiDefaultPragmaOptionsiFilePragmaOptions iOptionsUsed iPatternSyns iWarnings iPartialDefs ForeignCodeDecodedModulesVisitedModules miInterface miWarnings miPrimitivemiModeModuleCheckModeModuleScopeCheckedModuleTypeCheckedMonadStConcreteNamesrunStConcreteNamesuseConcreteNamesmodifyConcreteNamesSourceToModule FreshName freshName_ CheckpointId MonadFreshfreshHasFresh freshLens nextFresh'TypeCheckAction EnterSection LeaveSectionPragmasCurrentTypeCheckLogCachedTypeCheckLogLoadedFileCache lfcCached lfcCurrentPersistentTCStatePersistentTCStstDecodedModulesstPersistentOptionsstInteractionOutputCallback stBenchmarkstAccumStatisticsstPersistLoadedFileCachestPersistBackends MutualBlock mutualInfo mutualNamesPostScopeStatestPostSyntaxInfostPostDisambiguatedNamesstPostMetaStorestPostInteractionPointsstPostAwakeConstraintsstPostSleepingConstraints stPostDirtystPostOccursCheckDefsstPostSignaturestPostModuleCheckpointsstPostImportsDisplayFormsstPostCurrentModulestPostInstanceDefsstPostConcreteNamesstPostUsedNamesstPostShadowingNamesstPostStatisticsstPostTCWarningsstPostMutualBlocksstPostLocalBuiltinsstPostFreshMetaIdstPostFreshMutualIdstPostFreshProblemIdstPostFreshCheckpointIdstPostFreshIntstPostFreshNameIdstPostAreWeCachingstPostPostponeInstanceSearchstPostConsideringInstancestPostInstantiateBlockingstPostLocalPartialDefs ConcreteNamesDisambiguatedNamesDisambiguatedName PreScopeState stPreTokens stPreImportsstPreImportedModulesstPreModuleToSourcestPreVisitedModules stPreScopestPrePatternSynsstPrePatternSynImportsstPreGeneralizedVarsstPrePragmaOptionsstPreImportedBuiltinsstPreImportedDisplayFormsstPreImportedInstanceDefsstPreForeignCodestPreFreshInteractionIdstPreImportedUserWarningsstPreLocalUserWarningsstPreWarningOnImportstPreImportedPartialDefsstPreProjectConfigsstPreAgdaLibFiles ReadTCState getTCStatelocallyTCState withTCStateTCStstPreScopeStatestPostScopeStatestPersistentStateinitPersistentStateinitPreScopeStateinitPostScopeStatestTokens stImportsstImportedModulesstModuleToSourcestVisitedModulesstScope stPatternSynsstPatternSynImportsstGeneralizedVarsstPragmaOptionsstImportedBuiltins stForeignCodestFreshInteractionIdstImportedUserWarningsstLocalUserWarningsgetUserWarningsstWarningOnImportstImportedPartialDefsstLocalPartialDefsgetPartialDefsstLoadedFileCache stBackendsstProjectConfigsstAgdaLibFiles 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 defaultAxiomconstTranspAxiom recRecursiverecEtaEquality emptyFunctionfunFlag funStatic funInlinefunMacroisMacroisEmptyFunctionisCopatternLHSrecCon defIsRecorddefIsDataOrRecorddefConstructors redReturnredBind notReducedreduced allReductionsreallyAllReductions reduceAllDefslocallyReduceDefslocallyReduceAllDefsshouldReduceDeflocallyReconstructedisReconstructedprimFun defClauses defCompiled defParameters defInversedefCompilerPragmas defDelayeddefNonterminatingdefTerminationUnconfirmed defForced"ifTopLevelAndHighlightingLevelIsOr ifTopLevelAndHighlightingLevelIsinitEnvdefaultUnquoteFlagsunquoteNormaliseeUnquoteNormaliseeContext eLetBindingseCurrentModule eCurrentPatheAnonymousModules eImportPath eMutualBlockeTerminationCheckeCoverageCheck eMakeCaseeSolvingConstraintseCheckingWhereeWorkingOnTypes eAssignMetaseActiveProblems eAbstractMode eModality eRelevance eQuantityeSplitOnStricteDisplayFormsEnabledeRangeeHighlightingRangeeCalleHighlightingLeveleHighlightingMethod eExpandLasteAppDefeSimplificationeAllowedReductions eReduceDefseReconstructedeInjectivityDeptheCompareBlockedePrintDomainFreePieInsideDotPattern eUnquoteFlagseInstanceDeptheIsDebugPrintingePrintingPatternLambdas eCallByNeedeCurrentCheckpoint eCheckpointseGeneralizeMetaseGeneralizedVarseActiveBackendNameeConflComputingOverlap aDefToMode aModeToDefisDontExpandLastrecordFieldWarningToError warningNametcWarningOriginsizedTypesOptionguardednessOptionwithoutKOption enableCaching mapRedEnvmapRedSt mapRedEnvSt reduceEnvreduceSt onReduceEnv fmapReduceapReduce thenReduce beforeReduce bindReduce runReduceM runReduceFuseRaskRlocalRasksTCviewTC locallyTCgetsTC modifyTC'useTC setTCLens modifyTCLens modifyTCLensM stateTCLens stateTCLensM runBlockedmapTCMTpureTCM returnTCMTbindTCMTthenTCMTfmapTCMTapTCMT catchError_finally_ internalErrorlocatedTypeError genericErrorgenericDocError typeError' typeError typeError'_ typeError_runTCM runTCMTop runTCMTop' runSafeTCMforkTCMpatternInTeleNameextendedLambdaNameisExtendedLambdaNameabsurdLambdaNameisAbsurdLambdaNamegeneralizedFieldNamegetGeneralizedFieldName$fNFDataDisambiguatedName$fNFDataMutualBlock$fNullMutualBlock$fNFDataTypeCheckAction$fMonadFreshiIdentityT$fMonadFreshiListT$fMonadFreshiStateT$fMonadFreshiReaderT$fPrettyCheckpointId$fShowCheckpointId $fFreshName()$fFreshNameRange' $fFreshName[]$fFreshName(,)$fMonadStConcreteNamesStateT$fMonadStConcreteNamesReaderT$fMonadStConcreteNamesIdentityT$fNFDataModuleCheckMode$fNFDataForeignCode$fNFDataComparison$fPrettyComparison$fPrettyCompareDirection$fNFDataCompareAs$fAllMetasCompareAs$fTermLikeCompareAs$fFreeCompareAs $fNFDataOpen$fKillRangeOpen $fPrettyOpen$fDecorationOpen$fNFDataJudgement$fPrettyJudgement$fNFDataDoGeneralize$fKillRangeDoGeneralize$fNFDataGeneralizedValue$fNFDataFrozen$fNFDataPrincipalArgTypeMetas$fNFDataRunMetaOccursCheck$fPrettyNamedMeta$fNFDataOverapplied$fNFDataIPBoundary'$fKillRangeSection$fPrettySection$fNFDataDisplayTerm$fKillRangeDisplayTerm$fPrettyDisplayTerm$fFreeDisplayTerm$fNFDataDisplayForm$fKillRangeDisplayForm$fPrettyDisplayForm$fFreeDisplayForm$fNFDataNLPSort$fNFDataNLPType $fNFDataNLPat$fKillRangeNLPSort$fKillRangeNLPType$fKillRangeNLPat$fNFDataRewriteRule$fKillRangeRewriteRule$fKillRangeHashMap$fNFDataNumGeneralizableArgs$fKillRangeNumGeneralizableArgs$fNFDataPolarity$fKillRangePolarity$fNFDataIsForced$fKillRangeIsForced$fNFDataCompilerPragma$fHasRangeCompilerPragma$fKillRangeMap0$fNFDataSystem$fKillRangeSystem$fNFDataExtLamInfo$fKillRangeExtLamInfo$fNFDataProjLams$fKillRangeProjLams$fPrettyProjLams$fNFDataProjection$fKillRangeProjection$fPrettyProjection$fNFDataEtaEquality$fKillRangeEtaEquality%$fCopatternMatchingAllowedEtaEquality#$fPatternMatchingAllowedEtaEquality$fNFDataFunctionFlag$fKillRangeFunctionFlag$fNFDataCompKit$fKillRangeCompKit$fNFDataSimplification$fMonoidSimplification$fSemigroupSimplification$fNullSimplification$fIsProjElimMaybeReduced$fNFDataAllowedReduction$fNFDataReduceDefs$fMonoidReduceDefs$fSemigroupReduceDefs$fNFDataTermHead$fKillRangeTermHead$fPrettyTermHead$fNFDataFunctionInverse'$fKillRangeFunctionInverse'$fPrettyFunctionInverse' $fNFDataDefn$fKillRangeDefn $fPrettyDefn$fKillRangeMutualId$fNFDataDefinition$fKillRangeDefinition$fPrettyDefinition$fLensRelevanceDefinition$fLensQuantityDefinition$fLensModalityDefinition$fLensArgInfoDefinition$fKillRangeHashMap0$fNFDataSignature$fKillRangeSignature $fNFDataCall$fHasRangeCall $fPrettyCall$fNFDataBuiltin$fNFDataHighlightingLevel$fNFDataHighlightingMethod$fNFDataUnquoteFlags$fNFDataAbstractMode$fNFDataExpandHidden $fNFDataTCEnv$fNFDataIPClause$fNFDataClosure$fKillRangeClosure$fLensQuantityTCEnv$fLensRelevanceTCEnv$fLensModalityTCEnv $fEqIPClause$fLensIsAbstractTCEnv$fHasRangeClosure $fShowClosure$fLensTCEnvTCEnv$fLensIsAbstractClosure$fLensTCEnvClosure$fNFDataInteractionPoint$fHasTagInteractionPoint$fEqInteractionPoint $fNFDataBiMap$fSetRangeMetaInfo$fLensQuantityMetaInfo$fLensModalityMetaInfo$fLensIsAbstractMetaInfo$fLensClosureRange'MetaInfo$fLensClosureaClosure$fNFDataCandidateKind$fNFDataCandidate$fFreeCandidate$fNFDataRecordFieldWarning$fNFDataCallInfo$fPrettyCallInfo$fNFDataTerminationError$fNFDataNegativeUnification$fNFDataUnificationFailure$fNFDataSplitError$fNFDataLHSOrPatSyn$fMonadTCEnvListT$fMonadTCEnvWriterT$fMonadTCEnvStateT$fMonadTCEnvReaderT$fMonadTCEnvMaybeT$fMonadTCEnvIdentityT$fMonadTCEnvExceptT$fMonadTCEnvChangeT$fMonadBlockReaderT$fMonadBlockMaybeT$fNFDataTypeError$fNFDataUnquoteError$fNFDataTCWarning$fNFDataWarning$fNFDataPrimFun$fNFDataTypeCheckingProblem$fNFDataMetaInstantiation$fNFDataListener$fNFDataMetaVariable$fNFDataConstraint$fNFDataProblemConstraint$fNFDataInterface$fNFDataLoadedFileCache$fNFDataPersistentTCState$fNFDataTCState$fNFDataPostScopeState$fNFDataPreScopeState $fNFDataTCErr $fNullTCMT$fMonadBenchTCMT $fNullTCMT0 $fMonoidTCMT$fSemigroupTCMT$fIsStringTCMT$fCatchImpossibleTCMT$fMonadErrorTCErrTCMT$fMonadBlockTCMT$fMonadTCEnvTCMT $fMonadIOTCMT$fMonadFailTCMT $fMonadTCMT$fMonadTransTCMT$fApplicativeTCMT $fFunctorTCMT$fMonadBlockExceptT$fMonadTCEnvReduceM$fMonadFailReduceM$fMonadReduceM$fApplicativeReduceM$fFunctorReduceM$fExceptionTCErr$fHasRangeTCErr $fShowTCErr $fEqTCWarning$fHasRangeTCWarning$fLensClosureRange'MetaVariable$fLensQuantityMetaVariable$fLensModalityMetaVariable$fSetRangeMetaVariable$fHasRangeMetaVariable$fShowMetaInstantiation $fOrdListener $fEqListener$fAllMetasConstraint$fTermLikeConstraint$fFreeConstraint$fHasRangeConstraint$fHasRangeProblemConstraint$fPrettyInterface$fMonadStConcreteNamesTCMT $fShowTCState$fMonadTCStateTCMT$fMonadTCStateWriterT$fMonadTCStateIdentityT$fMonadTCStateChangeT$fMonadTCStateStateT$fMonadTCStateReaderT$fMonadTCStateExceptT$fMonadTCStateListT$fMonadTCStateMaybeT$fHasOptionsTCMT$fHasFreshCheckpointId$fHasFreshProblemId $fHasFreshInt$fHasFreshNameId$fHasFreshInteractionId$fHasFreshMutualId$fHasFreshMetaId$fMonadFreshiTCMT$fReadTCStateTCMT$fHasOptionsReduceM$fReadTCStateReduceM$fReadTCStateWriterT$fReadTCStateStateT$fReadTCStateReaderT$fReadTCStateMaybeT$fReadTCStateIdentityT$fReadTCStateExceptT$fReadTCStateChangeT$fReadTCStateListT$fMonadReduceWriterT$fMonadReduceStateT$fMonadReduceReaderT$fMonadReduceMaybeT$fMonadReduceListT$fMonadReduceIdentityT$fMonadReduceExceptT$fMonadReduceChangeT$fMonadReduceReduceM$fMonadTCMWriterT$fMonadTCMStateT$fMonadTCMReaderT$fMonadTCMMaybeT$fMonadTCMListT$fMonadTCMIdentityT$fMonadTCMExceptT$fMonadTCMChangeT$fMonadTCMTCMT$fMonadReduceTCMT$fMonadBlockBlockT$fMonadReduceBlockT$fFunctorBlockT$fApplicativeBlockT $fMonadBlockT$fMonadTransBlockT$fMonadIOBlockT$fMonadFailBlockT$fReadTCStateBlockT$fHasOptionsBlockT$fMonadTCEnvBlockT$fMonadTCStateBlockT$fMonadTCMBlockT$fGenericTCState$fGenericPersistentTCState$fShowTCWarning$fGenericTCWarning $fShowWarning$fGenericWarning$fShowProblemConstraint$fGenericProblemConstraint$fShowConstraint$fGenericConstraint$fShowTypeError$fGenericTypeError$fShowUnquoteError$fGenericUnquoteError$fShowInterface$fGenericInterface$fGenericLoadedFileCache$fGenericPostScopeState$fGenericPrimFun$fGenericMetaVariable$fGenericMetaInstantiation$fGenericTypeCheckingProblem$fShowArgsCheckState$fGenericListener$fGenericPreScopeState$fEqLHSOrPatSyn$fShowLHSOrPatSyn$fGenericLHSOrPatSyn$fShowSplitError$fGenericSplitError$fShowUnificationFailure$fGenericUnificationFailure$fShowNegativeUnification$fGenericNegativeUnification$fShowTerminationError$fGenericTerminationError$fShowCallInfo$fGenericCallInfo$fShowRecordFieldWarning$fDataRecordFieldWarning$fGenericRecordFieldWarning$fShowCandidate$fDataCandidate$fGenericCandidate$fShowCandidateKind$fDataCandidateKind$fGenericCandidateKind$fGenericInteractionPoint$fGenericTCEnv$fGenericIPClause$fFunctorClosure$fFoldableClosure$fGenericClosure$fEqExpandHidden$fDataExpandHidden$fGenericExpandHidden$fDataAbstractMode$fShowAbstractMode$fEqAbstractMode$fGenericAbstractMode$fDataUnquoteFlags$fGenericUnquoteFlags$fEqHighlightingMethod$fShowHighlightingMethod$fReadHighlightingMethod$fDataHighlightingMethod$fGenericHighlightingMethod$fEqHighlightingLevel$fOrdHighlightingLevel$fShowHighlightingLevel$fReadHighlightingLevel$fDataHighlightingLevel$fGenericHighlightingLevel $fShowBuiltin$fFunctorBuiltin$fFoldableBuiltin$fTraversableBuiltin$fGenericBuiltin $fDataCall $fGenericCall$fShowSignature$fGenericSignature$fGenericDefinition$fDataMutualId $fEqMutualId $fOrdMutualId$fShowMutualId $fNumMutualId$fEnumMutualId$fNFDataMutualId $fDataDefn $fShowDefn $fGenericDefn$fDataFunctionInverse'$fShowFunctionInverse'$fFunctorFunctionInverse'$fGenericFunctionInverse'$fDataTermHead $fEqTermHead $fOrdTermHead$fShowTermHead$fGenericTermHead$fDataReduceDefs$fGenericReduceDefs$fShowAllowedReduction$fEqAllowedReduction$fOrdAllowedReduction$fEnumAllowedReduction$fBoundedAllowedReduction$fIxAllowedReduction$fDataAllowedReduction$fGenericAllowedReduction$fFunctorMaybeReduced$fFunctorReduced$fDataSimplification$fEqSimplification$fShowSimplification$fGenericSimplification $fNullFields $fDataCompKit $fEqCompKit $fOrdCompKit $fShowCompKit$fGenericCompKit$fDataFunctionFlag$fEqFunctionFlag$fOrdFunctionFlag$fEnumFunctionFlag$fShowFunctionFlag$fGenericFunctionFlag$fDataEtaEquality$fShowEtaEquality$fEqEtaEquality$fGenericEtaEquality$fDataProjection$fShowProjection$fGenericProjection$fDataProjLams$fShowProjLams$fNullProjLams$fGenericProjLams$fDataExtLamInfo$fShowExtLamInfo$fGenericExtLamInfo $fDataSystem $fShowSystem$fGenericSystem$fDataCompilerPragma$fShowCompilerPragma$fEqCompilerPragma$fGenericCompilerPragma$fDataIsForced$fShowIsForced $fEqIsForced$fGenericIsForced$fDataPolarity$fShowPolarity$fGenericPolarity$fDataNumGeneralizableArgs$fShowNumGeneralizableArgs$fDataRewriteRule$fShowRewriteRule$fGenericRewriteRule $fDataNLPSort $fShowNLPSort$fGenericNLPSort $fDataNLPat $fShowNLPat$fGenericNLPat $fDataNLPType $fShowNLPType$fGenericNLPType$fDataDisplayForm$fShowDisplayForm$fGenericDisplayForm$fDataDisplayTerm$fShowDisplayTerm$fGenericDisplayTerm $fDataSection $fShowSection$fNFDataSection$fShowIPBoundary'$fDataIPBoundary'$fFunctorIPBoundary'$fFoldableIPBoundary'$fTraversableIPBoundary'$fGenericIPBoundary'$fEqOverapplied$fShowOverapplied$fDataOverapplied$fGenericOverapplied$fEqRunMetaOccursCheck$fOrdRunMetaOccursCheck$fShowRunMetaOccursCheck$fGenericRunMetaOccursCheck$fEqMetaPriority$fOrdMetaPriority$fShowMetaPriority$fNFDataMetaPriority$fGenericPrincipalArgTypeMetas $fEqFrozen $fShowFrozen$fGenericFrozen$fShowGeneralizedValue$fDataGeneralizedValue$fGenericGeneralizedValue$fEqDoGeneralize$fOrdDoGeneralize$fShowDoGeneralize$fDataDoGeneralize$fGenericDoGeneralize$fGenericJudgement $fShowOpen $fFunctorOpen$fFoldableOpen$fTraversableOpen $fGenericOpen$fDataCompareAs$fShowCompareAs$fGenericCompareAs$fEqCompareDirection$fShowCompareDirection$fEqComparison$fDataComparison$fShowComparison$fGenericComparison$fShowForeignCode$fGenericForeignCode$fEqModuleCheckMode$fOrdModuleCheckMode$fBoundedModuleCheckMode$fEnumModuleCheckMode$fShowModuleCheckMode$fGenericModuleCheckMode$fDataCheckpointId$fEqCheckpointId$fOrdCheckpointId$fEnumCheckpointId$fRealCheckpointId$fIntegralCheckpointId$fNumCheckpointId$fNFDataCheckpointId$fGenericTypeCheckAction$fShowMutualBlock$fEqMutualBlock$fGenericMutualBlock$fGenericDisambiguatedNameVALUvaluN' valueArgsICODE icodeArgsEmbPrjicodeicod_valueStnodeEstringElTextEsTextEintegerEdoubleEnodeMemomodFileincludesMemoUDictnodeDstringDlTextDsTextDintegerDdoubleDtermDnameDqnameDnodeCstringClTextCsTextCintegerCdoubleCtermCnameCqnameCstats 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 fastReducereduceDefCopyTCMprimitiveFunctionsMonadInteractionPointsfreshInteractionIdmodifyInteractionPoints addImportaddImportCycleCheck getImports isImported getImportPath visitModulesetVisitedModulesgetVisitedModulesgetPrettyVisitedModulesgetVisitedModulegetDecodedModulessetDecodedModulesgetDecodedModulestoreDecodedModuledropDecodedModulewithImportPathcheckForImportCycle currentModulewithCurrentModulegetCurrentPathgetAnonymousVariableswithAnonymousModulewithEnvgetEnvwithHighlightingLevel doExpandLastdontExpandLastreallyDontExpandLastperformedSimplificationperformedSimplification'getSimplificationupdateAllowedReductionsmodifyAllowedReductionsputAllowedReductionsonlyReduceProjectionsallowAllReductionsallowNonTerminatingReductionsonlyReduceTypestypeLevelReductionsinsideDotPatternisInsideDotPattern callByNameMonadAddContextaddCtxaddLetBinding' updateContext withFreshNamecheckpointSubstitution HasBuiltinsgetBuiltinThingcheckLockedVarstopLevelModuleDropper prettyErrorTraceStraceSReportSreportS MonadDebugformatDebugMessagetraceDebugMessageverboseBracket getVerbosityisDebugPrintingnowDebugPrintingdefaultGetVerbositydefaultIsDebugPrintingdefaultNowDebugPrintingdisplayDebugMessagecatchAndPrintImpossible reportSLn__IMPOSSIBLE_VERBOSE__ reportSDoc reportResultunlessDebugPrintingtraceSLn traceSDocopenVerboseBracketcloseVerboseBracketcloseVerboseBracketExceptionparseVerboseKey hasVerbosityhasExactVerbositywhenExactVerbosity__CRASH_WHEN__verboseSapplyWhenVerboseS verbosity$fMonadDebugListT$fMonadDebugIdentityT$fMonadDebugWriterT$fMonadDebugStateT$fMonadDebugReaderT$fMonadDebugMaybeT$fMonadDebugExceptT$fMonadDebugChangeT$fMonadDebugTCMT $fReportSDoc $fReportS[] $fReportS[]0 $fReportS[]1 $fReportS[]2 $fReportSTCMT $fTraceSDoc $fTraceS[] $fTraceS[]0 $fTraceS[]1 $fTraceS[]2 $fTraceSTCMT$fMonadDebugBlockTMonadStatistics modifyCounter getStatisticsmodifyStatisticsticktickNtickMaxprintStatistics$fMonadStatisticsTCMT$fMonadStatisticsWriterT$fMonadStatisticsStateT$fMonadStatisticsReaderT$fMonadStatisticsMaybeT$fMonadStatisticsExceptT HasConstInfo getConstInfo getConstInfo'getRewriteRulesForSigError SigUnknown SigAbstract lookupSectioninFreshModuleIfFreeParamseligibleForProjectionLikemakeProjectionPureTCM PrettyContext PrettyTCM prettyTCM MonadPretty prettyWarningsayWhen cachingStarts areWeCachingwriteToCurrentLogrestorePostScopeState localCache withoutCachereadFromCachedLogcleanCachedLogactivateLoadedFileCachecacheCurrentLogupdateBenchmarkingStatusprintmatchCompiledE matchCompiledPSynNamesInnamesIn'namesIn$fNamesInAmbiguousQName$fNamesInPattern'$fNamesInDisplayTerm$fNamesInDisplayForm$fNamesInElim'$fNamesInLiteral$fNamesInPlusLevel'$fNamesInLevel' $fNamesInTerm$fNamesInSort'$fNamesInType''$fNamesInPattern'0 $fNamesInCase$fNamesInCompiledClauses'$fNamesInClause $fNamesInDefn$fNamesInDefinition$fNamesInConHead$fNamesInQName$fNamesInCompKit$fNamesIn(,,,) $fNamesIn(,,) $fNamesIn(,) $fNamesInTele$fNamesInFieldAssignment' $fNamesInOpen$fNamesInWithArity $fNamesInAbs$fNamesInNamed $fNamesInDom' $fNamesInArg $fNamesInMap $fNamesInSet$fNamesInNonEmpty $fNamesIn[]$fNamesInMaybe $fNamesInPSynscopeCheckImporthighlightWarningWarningsAndNonFatalErrors tcWarningsnonFatalErrors WhichWarnings ErrorWarnings AllWarnings MonadWarning addWarninggenericWarninggenericNonFatalError warning'_warning_warning'warningraiseWarningsOnUsageisUnsolvedWarning isMetaWarningisMetaTCWarningonlyShowIfUnsolvedclassifyWarningemptyWarningsAndNonFatalErrorsclassifyWarningsrunPM$fMonadWarningTCMT$fMonadWarningStateT$fMonadWarningReaderT$fEqWhichWarnings$fOrdWhichWarnings isErasable autoInlineOutputContextEntry ContextVar ContextLetOutputConstraint'OfType'ofNameofExprOutputConstraintOfType CmpInTypeCmpElimJustTypeCmpTypes CmpLevelsCmpTelesJustSortCmpSorts TypedAssignPostponedCheckArgs IsEmptyType SizeLtSatFindInstanceOF PTSInstancePostponedCheckFunDef CheckLock UsableAtMod OutputFormUseForce WithForce WithoutForce ComputeModeDefaultCompute HeadComputeIgnoreAbstractUseShowInstanceAsIs 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_highlightShowImplicitArgsToggleImplicitArgsShowIrrelevantArgsToggleIrrelevantArgsCmd_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' CurrentFilecurrentFilePathcurrentFileArgscurrentFileStampCommandMOldInteractionScopes CommandStatetheInteractionPointstheCurrentFileoptionsOnReloadoldInteractionScopes commandQueueinitCommandState readsToParseparseToReadsPrecexact readParseparens'$fReadPosition'$fReadAbsolutePath$fReadInterval' $fReadRange'$fReadInteractionId$fReadCompilerBackend$fShowCompilerBackend$fFunctorOutputForm$fFunctorOutputConstraint $fShowIOTCM' $fReadIOTCM'$fFunctorIOTCM'$fFoldableIOTCM'$fTraversableIOTCM'$fShowInteraction'$fReadInteraction'$fFunctorInteraction'$fFoldableInteraction'$fTraversableInteraction' $fEqUseForce$fReadUseForce$fShowUseForce$fShowComputeMode$fReadComputeMode$fEqComputeMode $fShowRewrite $fReadRewrite $fEqRewrite $fOrdRewrite$fEqCompilerBackend $fShowRemove $fReadRemove$fShowCommand'$fShowCurrentFile Give_String Give_Paren Give_NoParensShowImplicitArgumentssShowIrrelevantArgumentssCheckedResponseContextEntry 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 updateDefTypeupdateDefArgOccurrencesupdateDefPolarityupdateDefCompiledRepaddCompilerPragmaupdateFunClausesupdateCoveringupdateCompiledClausesupdateDefCopatternLHSupdateDefBlockedsetTopLevelModulewithTopLevelModulecurrentModuleNameHashaddForeignCodegetInteractionOutputCallbackappInteractionOutputCallbacksetInteractionOutputCallbackgetPatternSynssetPatternSynsmodifyPatternSynsgetPatternSynImportsgetAllPatternSynslookupPatternSynlookupSinglePatternSyn theBenchmarkupdateBenchmarkaddImportedInstancesupdateInstanceDefsmodifyInstanceDefsgetAllInstanceDefsgetAnonInstanceDefsclearAnonInstanceDefsaddUnknownInstanceaddNamedInstance MonadTrace traceCall traceCallM traceCallCPStraceClosureCallprintHighlightingInfointerestingCallgetCurrentRangesetCurrentRangehighlightAsTypeChecked$fMonadTraceTCMT$fMonadTraceExceptT$fMonadTraceWriterT$fMonadTraceStateT$fMonadTraceReaderT$fMonadTraceIdentityT noMutualBlock inMutualBlocksetMutualBlockInfoinsertMutualBlockInfosetMutualBlockcurrentOrFreshMutualBlocklookupMutualBlock mutualBlockOf enterClosure withClosure mapClosureMonadConstraintaddAwakeConstraintsolveConstraintsolveSomeAwakeConstraintswakeConstraintsstealConstraintsmodifyAwakeConstraintsmodifySleepingConstraintsConstraintStatusAwakeConstraintSleepingConstraintsolvingProblemsolvingProblemsisProblemSolvedgetConstraintsForProblemgetAwakeConstraintsdropConstraintstakeConstraintsputConstraintsToSleepputAllConstraintsToSleepholdConstraintstakeAwakeConstrainttakeAwakeConstraint'getAllConstraintswithConstraintbuildProblemConstraintbuildProblemConstraint_buildConstraintaddAndUnblockeraddOrUnblockeraddConstraint'addAwakeConstraint'addConstraintTonowSolvingConstraintsisSolvingConstraintscatchConstraintmapAwakeConstraintsmapSleepingConstraints$fMonadConstraintReaderT$fEqConstraintStatus$fShowConstraintStatusdebugConstraintsguardConstraintifNoConstraintsifNoConstraints_ noConstraintssolveAwakeConstraints'LensPersistentVerbositygetPersistentVerbositysetPersistentVerbositymapPersistentVerbosityPersistentVerbosityLensIncludePathsgetIncludePathssetIncludePathsmapIncludePathsgetAbsoluteIncludePathssetAbsoluteIncludePathsmapAbsoluteIncludePaths LensSafeMode getSafeMode setSafeMode mapSafeModeSafeModeLensCommandLineOptionsgetCommandLineOptionssetCommandLineOptionsmapCommandLineOptions LensVerbosity setVerbosity mapVerbosityLensPragmaOptionsgetPragmaOptionssetPragmaOptionsmapPragmaOptionslensPragmaOptionsmodifyPragmaOptionsmodifyVerbosity putVerbositymodifyCommandLineOptionsmodifySafeMode putSafeMode builtinModulesWithSafePostulates"builtinModulesWithUnsafePostulatesprimitiveModulesbuiltinModulesisPrimitiveModuleisBuiltinModule!isBuiltinModuleWithSafePostulatesmodifyIncludePathsputIncludePathsmodifyAbsoluteIncludePathsputAbsoluteIncludePathsmodifyPersistentVerbosityputPersistentVerbosity$fLensPragmaOptionsTCState%$fLensPragmaOptionsCommandLineOptions$fLensVerbosityTCState$fLensVerbosityPragmaOptions$fLensCommandLineOptionsTCState)$fLensCommandLineOptionsPersistentTCState$fLensSafeModeTCState$fLensSafeModePersistentTCState $fLensSafeModeCommandLineOptions$fLensSafeModePragmaOptions$fLensIncludePathsTCState#$fLensIncludePathsPersistentTCState$$fLensIncludePathsCommandLineOptions $fLensPersistentVerbosityTCState*$fLensPersistentVerbosityPersistentTCState+$fLensPersistentVerbosityCommandLineOptions&$fLensPersistentVerbosityPragmaOptionssetCommandLineOptions'libToTCMgetAgdaLibFilesgetLibraryOptionssetLibraryPathssetLibraryIncludesaddDefaultLibrariesaddTrustedExecutablessetOptionsFromPragmaenableDisplayFormsdisableDisplayFormsdisplayFormsEnabledgetIncludeDirssetIncludeDirs isPropEnabledisTwoLevelEnabledhasUniversePolymorphismshowImplicitArgumentsshowIrrelevantArgumentsshowIdentitySubstitutionswithShowAllArgumentswithShowAllArguments'withPragmaOptionspositivityCheckEnabled typeInType etaEnabledmaxInstanceSearchDepthmaxInversionDepth TeleNoAbs teleNoAbsTelVtheTeltheCoreTelView applyTermE canProjectconAppdefApp argToDontCare relToDontCarepiApplytelVars namedTelVars abstractArgsrenaming renamingRrenamePapplySubstTermapplyNLPatSubstapplyNLSubstToDomfromPatternSubstitution applyPatSubst usePatOriginusePatternInfoprojDropParsApplytelView' telView'UpTo bindsToTel' bindsToTel bindsToTel'1 bindsToTel1namedBindsToTelnamedBindsToTel1domFromNamedArgNamemkPiSort unlamViewtelePi'telePitelePi_ telePiVisibleteleLamtypeArgsWithTelcompiledClauseBody univSort'univSortssort isSmallSort fibrantLubfunSort'funSortpiSort'piSortlevelMaxlevelLublevelTm $fOrdElim' $fEqElim'$fOrdAbs$fEqAbs $fOrdTerm$fEqTerm $fOrdType'' $fEqType''$fOrdPlusLevel' $fSubstRange'$fSubstPattern'$fDeBruijnPattern'$fSubstEqualityView$fSubstCandidate $fSubst(,,,) $fSubst(,,) $fSubst(,) $fSubst()$fSubstWithHiding $fSubstMap $fSubst[] $fSubstMaybe $fSubstDom' $fSubstNamed $fSubstArg $fSubstAbs $fSubstElim'$fSubstCompareAs$fSubstConstraint $fSubstTele$fSubstDisplayTerm$fSubstDisplayForm$fSubstBlocked'$fSubstRewriteRule$fSubstNLPSort$fSubstNLPType $fSubstNLPat$fDeBruijnNLPat$fDeBruijnBraveTerm$fSubstProblemEq$fSubstPattern'0$fSubstConPatternInfo $fSubstName$fSubstPlusLevel' $fSubstLevel' $fSubstSort' $fSubstType''$fSubstBraveTerm $fSubstTerm$fSubstSubstitution'$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 $fOrdTele$fEqTele $fEqCandidate$fEqCandidateKind $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' addLetBindinggetContextSizegetContextArgsgetContextTermsgetContextTelescopegetContextNames lookupBV'lookupBVdomOfBVtypeOfBV nameOfBV'nameOfBV getVarInfo$fMonadAddContextTCMT$fMonadAddContextListT$fMonadAddContextWriterT$fMonadAddContextStateT$fMonadAddContextReaderT$fMonadAddContextMaybeT$fMonadAddContextIdentityT$fMonadAddContextExceptT$fAddContextTele$fAddContext[]$fAddContextName$fAddContextDom'$fAddContext(,)$fAddContext(,)0$fAddContext(,)1$fAddContext(,)2$fAddContext(,)3$fAddContext(,)4$fAddContext(,)5$fAddContext(,)6$fAddContext(,)7$fAddContextDom'0$fAddContextDom'1$fAddContext(,)8$fAddContext[]0$fAddContextKeepNames$fAddContext(,)9$fMonadAddContextBlockTPiApplyM piApplyM'piApplyMtelViewSortKit nameOfSet nameOfProp nameOfSSetnameOfSetOmegaCoinductionKit nameOfInf nameOfSharp nameOfFlatlitTypesetBuiltinThingsbindBuiltinName bindPrimitive getBuiltin getBuiltin' getPrimitive' getPrimitivegetPrimitiveTermgetPrimitiveTerm'getTerm'getName'getTermconstructorFormconstructorForm' primIntegerprimIntegerPosprimIntegerNegSuc primFloatprimChar primStringprimBool primSigmaprimUnit primUnitUnitprimTrue primFalseprimListprimNilprimCons primMaybe primNothingprimJustprimIOprimId 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 primLevelMaxprimSetprimProp primSetOmega primLockUniv primSSetOmega primStrictSet primFromNat primFromNegprimFromString primQNameprimArg primArgArgprimAbs primAbsAbs primAgdaSort primHiding primHidden primInstance primVisible primRelevance primRelevantprimIrrelevant primQuantity primQuantity0primQuantityω primModalityprimModalityConstructor primAssoc primAssocLeftprimAssocRight primAssocNonprimPrecedenceprimPrecRelatedprimPrecUnrelated primFixityprimFixityFixity primArgInfoprimArgArgInfoprimAgdaSortSetprimAgdaSortLitprimAgdaSortPropprimAgdaSortPropLitprimAgdaSortInfprimAgdaSortUnsupported primAgdaTermprimAgdaTermVarprimAgdaTermLamprimAgdaTermExtLamprimAgdaTermDefprimAgdaTermConprimAgdaTermPiprimAgdaTermSortprimAgdaTermLitprimAgdaTermUnsupportedprimAgdaTermMetaprimAgdaErrorPartprimAgdaErrorPartStringprimAgdaErrorPartTermprimAgdaErrorPartNameprimAgdaLiteralprimAgdaLitNatprimAgdaLitWord64primAgdaLitFloatprimAgdaLitCharprimAgdaLitStringprimAgdaLitQNameprimAgdaLitMetaprimAgdaPatternprimAgdaPatConprimAgdaPatVarprimAgdaPatDotprimAgdaPatLitprimAgdaPatProjprimAgdaPatAbsurdprimAgdaClauseprimAgdaClauseClauseprimAgdaClauseAbsurdprimAgdaDefinitionFunDefprimAgdaDefinitionDataDefprimAgdaDefinitionRecordDef!primAgdaDefinitionDataConstructorprimAgdaDefinitionPostulateprimAgdaDefinitionPrimitiveprimAgdaDefinition primAgdaMeta primAgdaTCMprimAgdaTCMReturnprimAgdaTCMBindprimAgdaTCMUnifyprimAgdaTCMTypeErrorprimAgdaTCMInferTypeprimAgdaTCMCheckTypeprimAgdaTCMNormaliseprimAgdaTCMReduceprimAgdaTCMCatchErrorprimAgdaTCMGetContextprimAgdaTCMExtendContextprimAgdaTCMInContextprimAgdaTCMFreshNameprimAgdaTCMDeclareDefprimAgdaTCMDeclarePostulateprimAgdaTCMDefineFunprimAgdaTCMGetTypeprimAgdaTCMGetDefinitionprimAgdaTCMQuoteTermprimAgdaTCMQuoteOmegaTermprimAgdaTCMUnquoteTermprimAgdaTCMBlockOnMetaprimAgdaTCMCommitprimAgdaTCMIsMacroprimAgdaTCMWithNormalisationprimAgdaTCMWithReconsParamsprimAgdaTCMDebugPrintprimAgdaTCMOnlyReduceDefsprimAgdaTCMDontReduceDefsprimAgdaTCMNoConstraintsprimAgdaTCMRunSpeculativeprimAgdaTCMExeccoinductionKit'coinductionKitsortKit getPrimNamegetBuiltinName'getPrimitiveName' isPrimitive intervalView' intervalViewintervalUnviewintervalUnview'pathView pathView' idViewAsPath boldPathView pathUnviewprimEqualityName equalityViewequalityUnviewconstrainedPrimsgetNameOfConstrained$fHasBuiltinsTCMT$fHasBuiltinsWriterT$fHasBuiltinsStateT$fHasBuiltinsReaderT$fHasBuiltinsMaybeT$fHasBuiltinsListT$fHasBuiltinsIdentityT$fHasBuiltinsExceptT$fHasBuiltinsBlockT composePolcomputePolarity SizeMaxView' SizeMaxViewSizeViewComparable NotComparableYesAboveYesBelow DeepSizeViewDSizeInfDSizeVar DSizeMeta DOtherSize ProjectedVarpvIndexprProjsSizeViewSizeInfSizeSuc OtherSize IsSizeType isSizeType BoundedSize BoundedLt BoundedNoisSizeTypeTestgetBuiltinDefNamegetBuiltinSizeisSizeNameTestisSizeNameTestRawhaveSizedTypes haveSizeLtbuiltinSizeHooksizeSortsizeUniv sizeType_sizeType sizeSucNamesizeSucsizeSuc_sizeMaxsizeViewviewProjectedVarunviewProjectedVarsizeViewComparable sizeViewSuc_ sizeViewPredsizeViewOffset removeSucs unSizeViewunDeepSizeView maxViewMax maxViewConssizeViewComparableWithMax maxViewSuc_ unMaxView$fIsSizeTypeCompareAs$fIsSizeTypeTerm$fIsSizeTypeType''$fIsSizeType(,)$fIsSizeTypeDom'$fEqProjectedVar$fPrettyDeepSizeView$fFunctorSizeViewComparable$fShowDeepSizeView$fShowProjectedVar$fEqBoundedSize$fShowBoundedSizereallyUnLevelViewOpenKind LetOpenModule TopOpenModuleImportedNameMapinameMap imoduleMap ScopeMemo memoNames memoModulesWSMScopeM printLocals scopeWarning' scopeWarningisDatatypeModulegetCurrentModulesetCurrentModulewithCurrentModule' getNamedScopegetCurrentScope createModule modifyScopesmodifyNamedScope setNamedScopemodifyNamedScopeMmodifyCurrentScopemodifyCurrentScopeMmodifyCurrentNameSpacesetContextPrecedencewithContextPrecedence getLocalVarsmodifyLocalVars setLocalVars withLocalVarsoutsideLocalVarswithCheckNoShadowingcheckNoShadowing getVarsToBind addVarToBindbindVarsToBindfreshAbstractNamefreshAbstractName_freshAbstractQNamefreshAbstractQName'freshConcreteName resolveName resolveName'tryResolveNamecanHaveSuffixTest resolveModulegetConcreteFixitygetConcretePolaritycomputeFixitiesAndPolarities getNotation bindVariableunbindVariablebindName bindName' bindName'' rebindName bindModule bindQModule stripNoNamesmemoToScopeInfo copyScopecheckNoFixityInRenamingModuleverifyImportDirectiveapplyImportDirectiveM mapImportDirimportedNameMapFromListlookupImportedName mapRenamingnoGeneralizedVarsIfLetOpen openModule_ openModule$fMonadFixityErrorTCMTRangeAndPragma ToConcreteConOfAbs toConcretebindToConcreteAbsToCon MonadAbsToConEnvpreserveInteractionIds noTakenNames runAbsToConabstractToConcreteScopeabstractToConcreteCtxabstractToConcrete_abstractToConcreteHiding lookupQName toConcreteCtx$fMonadDebugAbsToCon$fHasOptionsAbsToCon$fHasBuiltinsAbsToCon$fMonadStConcreteNamesAbsToCon$fReadTCStateAbsToCon$fMonadTCEnvAbsToCon$fMonadReaderEnvAbsToCon$fMonadFailAbsToCon$fMonadAbsToCon$fApplicativeAbsToCon$fFunctorAbsToCon$fToConcreteNamedMeta$fToConcreteInteractionId$fToConcreteMaybe$fToConcreteLHSCore'$fToConcreteLHS$fToConcreteSpineLHS$fToConcreteModuleApplication$fToConcreteClause'$fToConcreteConstr$fToConcreteMaybe0$fToConcreteMaybe1$fToConcreteRewriteEqn'$fToConcreteRHS$fToConcreteWhereDeclarations$fToConcreteLetBinding$fToConcreteTypedBinding$fToConcreteLamBinding$fToConcreteBinder'$fToConcreteFieldAssignment'$fToConcreteResolvedName$fToConcreteAbstractName$fToConcreteModuleName$fToConcreteQName$fToConcreteBindName$fToConcreteName$fToConcreteNamed$fToConcreteWithHiding$fToConcreteArg$fToConcrete(,,)$fToConcrete(,)$fToConcreteEither$fToConcreteNonEmpty$fToConcrete[]$fToConcreteBool$fToConcrete()$fToConcreteRangeAndPragma$fToConcreteDeclaration$fToConcreteUserPattern$fToConcreteUserPattern0$fToConcretePattern'$fToConcreteSplitPattern$fToConcreteSplitPattern0$fToConcreteBindingPattern$fToConcreteFreshenName$fToConcreteExpr$fHasRangeMaybeSection$fEqMaybeSection$fShowMaybeSection$fFunctorMaybeSection$fFoldableMaybeSection$fTraversableMaybeSectionshowAprettyAprettyAsshowATop prettyATopparseLHS parsePatternparsePatternSynparseApplicationparseModuleApplication$fPrettyParseLHS $fEqExprKind$fShowExprKindDropArgsdropArgs$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$fHasConstInfoBlockT$fHasConstInfoWriterT$fHasConstInfoStateT$fHasConstInfoReaderT$fHasConstInfoMaybeT$fHasConstInfoListT$fHasConstInfoIdentityT$fHasConstInfoExceptT$fHasConstInfoChangeT$fHasConstInfoTCMT$fPureTCMStateT$fPureTCMWriterT$fPureTCMReaderT$fPureTCMMaybeT$fPureTCMListT$fPureTCMIdentityT$fPureTCMExceptT$fPureTCMBlockT $fPureTCMTCMTisPropM workOnTypes UnFreezeMeta unfreezeMetaIsInstantiatedMetaisInstantiatedMetaMonadMetaSolvernewMeta'assignV assignTerm' etaExpandMeta updateMetaVarspeculateMetas KeepMetas RollBackMetasMetaKindRecordsSingletonRecordsLevels allMetaKindsdontAssignMetas getMetaStoremodifyMetaStoremetasCreatedBy lookupMeta'metaTypeupdateMetaVarTCM insertMetaVargetMetaPriority isSortMeta isSortMeta_ getMetaTypegetMetaContextArgsgetMetaTypeInContextisGeneralizableMetaisInstantiatedMeta'constraintMetascreateMetaInfocreateMetaInfo'setValueMetaNamegetMetaNameSuggestionsetMetaNameSuggestionsetMetaGeneralizableArgInfoupdateMetaVarRangesetMetaOccursCheckregisterInteractionPointfindInteractionPoint_connectInteractionPointremoveInteractionPointgetInteractionPointsgetInteractionMetasgetUniqueMetasRangesgetUnsolvedMetasgetUnsolvedInteractionMetasgetInteractionIdsAndMetasisInteractionMetalookupInteractionPointlookupInteractionIdlookupInteractionMetalookupInteractionMeta_ newMetaTCM'getInteractionRange getMetaRangegetInteractionScope withMetaInfo' withMetaInfogetMetaVariableSetgetMetaVariablesgetInstantiatedMetas getOpenMetas isOpenMeta listenToMetaunlistenToMetagetMetaListenersclearMetaListenerswithFreezeMetas freezeMetas freezeMetas' unfreezeMetasunfreezeMetas'isFrozen$fIsInstantiatedMetaAbs$fIsInstantiatedMetaArg$fIsInstantiatedMetaMaybe$fIsInstantiatedMeta[]$fIsInstantiatedMetaPlusLevel'$fIsInstantiatedMetaLevel'$fIsInstantiatedMetaTerm$fIsInstantiatedMetaMetaId$fMonadInteractionPointsTCMT$fMonadInteractionPointsStateT$fMonadInteractionPointsReaderT!$fMonadInteractionPointsIdentityT$fUnFreezeMetaAbs$fUnFreezeMeta[]$fUnFreezeMetaPlusLevel'$fUnFreezeMetaLevel'$fUnFreezeMetaSort'$fUnFreezeMetaTerm$fUnFreezeMetaType''$fUnFreezeMetaMetaId $fEqMetaKind$fEnumMetaKind$fBoundedMetaKind$fShowMetaKind Condition checkMetaInst newSortMeta newTelMetanewNamedValueMeta'newNamedValueMeta newValueMetanewInstanceMetaassignetaExpandMetaSafe assignTerm newArgsMeta newArgsMeta'getConstructorData getConHeadInSeqHasFreeOccursSeqArg UnderLambdaonceinSeq underLambdaoccursIn tryStrengthen $fSubstTAlt $fSubstTTerm$fDeBruijnTTerm$fMonoidOccurs$fSemigroupOccurs $fHasFree(,) $fHasFree[] $fHasFreeInt $fHasFreeTAlt$fHasFreeBinder$fHasFreeTTerm$fHasFreeInSeq $fEqOccurs $fOrdOccurs $fShowOccurs $fEqSeqArg $fOrdSeqArg $fShowSeqArg$fSemigroupSeqArg$fMonoidSeqArg$fEqUnderLambda$fOrdUnderLambda$fShowUnderLambda$fSemigroupUnderLambda$fMonoidUnderLambda $fPrettyTTerm equalTerms caseToSeq useTerPragma newSection checkFunDef' checkFunDefbindBuiltinFlatbindBuiltinSharpbindBuiltinInf typeOfFlat typeOfSharp typeOfInfToNLPattoNLPatgetClausesAsRewriteRules clauseQNameclauseToRewriteRule$fToNLPatArgElim'$fToNLPatArgElim'0$fToNLPatAbsAbs$fToNLPatElim'Elim'$fToNLPatDom'Dom' $fToNLPat[][]$fPureTCMReduceM$fHasConstInfoReduceM$fMonadDebugReduceM$fMonadAddContextReduceM$fHasBuiltinsReduceMimpossibleTestimpossibleTestReduceMisRecordConstructorisGeneratedRecordConstructoretaContractRecordgetRecordFieldNames_ isEtaRecordisRecord MonadMatchYesNoDontKnowmatchCopatterns matchPatternsbuildSubstitutionExpandPatternSynonymsexpandPatternSynonymsexpandLitPatternexpandPatternSynonyms'$fExpandPatternSynonymsPattern''$fExpandPatternSynonymsFieldAssignment'$fExpandPatternSynonymsNamed$fExpandPatternSynonymsArg$fExpandPatternSynonyms[]$fExpandPatternSynonymsMaybeNamesNamesTunName runNamesTrunNames currentCxtcxtSubstinCxtcl'clopenbind'bindglamglamNlamilam$fHasBuiltinsNamesT$fFunctorNamesT$fApplicativeNamesT $fMonadNamesT$fMonadFailNamesT$fMonadTransNamesT$fMonadStatesNamesT$fMonadIONamesT$fHasOptionsNamesT$fMonadDebugNamesT$fMonadTCEnvNamesT$fMonadTCStateNamesT$fMonadTCMNamesT$fReadTCStateNamesT$fMonadReduceNamesT$fMonadErroreNamesT$fMonadAddContextNamesT$fHasConstInfoNamesT$fPureTCMNamesT MentionsMeta mentionsMetas mentionsMeta$fMentionsMetaCompareAs$fMentionsMetaConstraint$fMentionsMetaProblemConstraint$fMentionsMetaTele$fMentionsMetaElim'$fMentionsMetaClosure$fMentionsMeta(,,)$fMentionsMeta(,)$fMentionsMetaMaybe$fMentionsMeta[]$fMentionsMetaDom'$fMentionsMetaArg$fMentionsMetaAbs$fMentionsMetaSort'$fMentionsMetaType''$fMentionsMetaBlocker$fMentionsMetaPlusLevel'$fMentionsMetaLevel'$fMentionsMetaTerm BinAppViewNoApp binAppView etaContractetaOnceetaConetaLamInstantiateFullinstantiateFull' Normalise normalise'Simplify simplify'reduce'reduceB'IsMetaisMeta Instantiate instantiate' instantiateinstantiateFullreducereduceBreduceWithBlocker withReduced normalise normaliseBsimplifyisFullyInstantiatedMetablockAllblockAny ifBlockedabortIfBlocked isBlocked reduceIApply reduceIApply'shouldTryFastReducemaybeFastReduceTermslowReduceTermunfoldCorecursionEunfoldCorecursionunfoldDefinitionunfoldDefinitionEunfoldDefinition'unfoldDefinitionStep reduceDefCopy reduceHead unfoldInlinedappDef_appDefE_appDefappDefEappDef'appDefE'simplifyBlocked'slowNormaliseArgs$fInstantiateEqualityView$fInstantiateCandidate$fInstantiateCompareAs$fInstantiateConstraint$fInstantiateClosure$fInstantiateDom'$fInstantiateSort'$fInstantiateBlocker$fInstantiateBlocked'$fInstantiatePlusLevel'$fInstantiateLevel'$fInstantiateType''$fInstantiateTerm$fInstantiate(,,)$fInstantiate(,)$fInstantiateIPBoundary'$fInstantiateTele$fInstantiateElim'$fInstantiateArg$fInstantiateAbs$fInstantiateMaybe$fInstantiateMaybe0$fInstantiateMap$fInstantiate[]$fIsMetaCompareAs$fIsMetaPlusLevel'$fIsMetaLevel' $fIsMetaArg $fIsMetaElim'$fIsMetaType'' $fIsMetaSort' $fIsMetaTerm$fReduceIPBoundary'$fReduceEqualityView$fReduceCandidate $fReduceMap$fReduceCompareAs$fReduceConstraint $fReduceTele$fReduceClosure $fReduceTerm$fReducePattern' $fReduce(,,) $fReduce(,) $fReduceDom' $fReduceArg $fReduce[] $fReduceAbs$fReducePlusLevel'$fReduceLevel' $fReduceElim' $fReduceSort'$fReduceType''$fSimplifyEqualityView$fSimplifyCandidate$fSimplifyDisplayForm$fSimplifyCompareAs$fSimplifyConstraint$fSimplifyProblemConstraint$fSimplifyTele$fSimplifyClosure$fSimplifyDom' $fSimplifyAbs$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$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'$fInstantiateFullPlusLevel'$fInstantiateFullLevel'$fInstantiateFullTerm$fInstantiateFullType''$fInstantiateFullSort'$fInstantiateFullDBPatVar$fInstantiateFullConHead$fInstantiateFullScope$fInstantiateFullQName$fInstantiateFullName$fInstantiateFullModuleName$fInstantiateFullInt$fInstantiateFullChar$fInstantiateFullBool$fInstantiateFull(,,,)$fInstantiateFull(,,)$fInstantiateFull(,)$fInstantiateFullIPBoundary'$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(,) $fSynEq[] $fSynEqType'' $fSynEqSort'$fSynEqPlusLevel' $fSynEqLevel' $fSynEqTerm $fSynEqBool TermToPattern termToPatterndotPatternsToPatterns$fTermToPatternTermPattern'$fTermToPatternNamedNamed$fTermToPatternArgArg$fTermToPattern[][] SingleLevel SingleLevel' SingleClosed SinglePlusLevelKitlvlTypelvlSuclvlMaxlvlZerotypeNamesucNamemaxNamezeroName levelType isLevelTypelevelSucFunctionbuiltinLevelKit requireLevels haveLevelsunLevelunlevelWithKitunConstVunPlusV maybePrimCon maybePrimDef levelView levelView' levelPlusViewlevelLowerBoundsubLevel levelMaxDiff unSingleLevelunSingleLevels levelMaxViewsingleLevelView$fFreeSingleLevel'$fSubstSingleLevel'$fShowSingleLevel'$fFunctorSingleLevel'$fFoldableSingleLevel'$fTraversableSingleLevel'$fEqSingleLevel' $fShowLeq$fEqLeqdefaultOpenLevelsToZerodefaultLevelsToZero ForceNotFreeIsFree MaybeFreeNotFree forceNotFree$fForceNotFreeSort'$fForceNotFreePlusLevel'$fForceNotFreeLevel'$fForceNotFreeTerm$fForceNotFreeType''$fForceNotFreeElim'$fForceNotFree[]$fForceNotFreeAbs$fForceNotFreeDom'$fForceNotFreeArg $fEqIsFree $fShowIsFreecomputeForcingAnnotationsisForced nextIsForced$fForcedVariablesTerm$fForcedVariablesArg$fForcedVariablesElim'$fForcedVariables[] checkEmptyTelensureEmptyType isEmptyTel isEmptyType displayForm $fMatchLevel' $fMatchSort' $fMatchTerm $fMatchElim' $fMatchArg $fMatch[]$fSubstWithOriginArg$fSubstWithOriginDisplayTerm$fSubstWithOriginTerm$fSubstWithOriginArg0$fSubstWithOriginElim'$fSubstWithOrigin[]eliminateDeadCodeMonadConversionleqSortleqLevelleqType equalLevel equalSort equalTypeequalTermOnFace equalTerm compareLevel compareSort compareType compareElims compareArgs compareAtomcompareTermOnFace compareAs compareTermStackFrameActionMonadCheckInternalinfercheckInternal' checkInternal checkSort checkType' checkTypeeraseUnusedAction defaultAction recursiveanyDefs ToAbstractAbsOfRef toAbstractMonadReflectedToAbstractVarswithNamewithVar withNameswithVarsaskVaraskName toAbstract_toAbstractWithoutImplicitmkDefmkAppmkVar mkVarNameannotatePatterncheckClauseTelescopeBindings$fToAbstractNonEmpty$fToAbstract[]$fToAbstractQNamed$fToAbstractPattern$fToAbstractSort$fToAbstractTerm$fToAbstractLiteral$fToAbstractAbs$fToAbstract(,)$fToAbstract(,)0$fToAbstract(,)1$fToAbstract[]0$fToAbstractArg$fToAbstractNamed NamedClauseReify ReifiesToreify reifyWhen MonadReifyreifyUnblockedreifyDisplayFormPblankNotInScope reifyPatterns $fReify(,,,) $fReify(,,) $fReify(,) $fReify[] $fReifyElim' $fReifyDom' $fReifyTele $fReifyAbs $fReifyLevel' $fReifySort' $fReifyType'' $fReifyQNamed $fReifyArg $fReifyNamed $fReifyTerm$fReifyLiteral$fReifyDisplayTerm $fReifyMetaId $fReifyExpr $fReifyName $fReifyBool$fReifyNamedClause$fReifyQNamed0$fMonoidMonoidMap$fSemigroupMonoidMap$fBlankVarsTypedBinding$fBlankVarsLamBinding$fBlankVarsRHS$fBlankVarsModuleName$fBlankVarsPattern'$fBlankVarsLHSCore'$fBlankVarsLHS$fBlankVarsProblemEq$fBlankVarsEither$fBlankVars(,)$fBlankVarsFieldAssignment'$fBlankVarsNonEmpty $fBlankVars[]$fBlankVarsNamed$fBlankVarsArg $fBinder(,) $fBinderMaybe$fBinderNonEmpty $fBinder[] $fBinderNamed $fBinderArg$fBinderFieldAssignment'$fBinderLetBinding$fBinderBindName$fBinderTypedBinding$fBinderLamBinding$fBinderBinder'$fBinderPattern'$fBinderLHSCore' $fBinderLHS$fBlankVarsExpr$fBlankVarsClause'PrettyTCMWithNodeprettyTCMWithNodeWithNode prettyTCMCtxprettyRprettyTCMPatternsprettyTCMPatternList$fPrettyTCMCandidate$fPrettyTCMSplitTag$fPrettyTCMOccurrence$fPrettyTCMRewriteRule$fPrettyTCMType''$fPrettyTCMElim'$fPrettyTCMNLPSort$fPrettyTCMNLPType$fPrettyTCMNLPat$fPrettyTCMElim'0$fPrettyTCMPattern'$fPrettyTCMDBPatVar$fPrettyTCMTele$fPrettyTCMConHead$fPrettyTCMAbstractName$fPrettyTCMModuleName$fPrettyTCMQName$fPrettyTCMName$fPrettyTCMWithHiding$fPrettyTCMTypeCheckingProblem$fPrettyTCMCompareAs$fPrettyTCMBlocker$fPrettyTCMModality$fPrettyTCMQuantity$fPrettyTCMRelevance$fPrettyTCMTypedBinding$fPrettyTCMExpr$fPrettyTCMEqualityView$fPrettyTCMMaybeReduced$fPrettyTCMElim'1$fPrettyTCMMap$fPrettyTCMBlocked'$fPrettyTCMMetaId$fPrettyTCMJudgement$fPrettyTCMClause$fPrettyTCMSubstitution'$fPrettyTCMIsForced$fPrettyTCMPolarity$fPrettyTCMPermutation$fPrettyTCMDom'$fPrettyTCMDom'0$fPrettyTCMArg$fPrettyTCMArg0$fPrettyTCMArg1$fPrettyTCMArg2$fPrettyTCMArg3$fPrettyTCMArg4$fPrettyTCMNamed$fPrettyTCMLevel'$fPrettyTCMQNamed$fPrettyTCMNamedClause$fPrettyTCMDisplayTerm$fPrettyTCMSort'$fPrettyTCMType''0$fPrettyTCMTerm$fPrettyTCM(,,)$fPrettyTCM(,)$fPrettyTCMMaybe $fPrettyTCM[]$fPrettyTCMClosure$fPrettyTCMCheckpointId$fPrettyTCMRange'$fPrettyTCMProblemId$fPrettyTCMInt$fPrettyTCMLiteral$fPrettyTCMComparison$fPrettyTCMQName0$fPrettyTCMName0$fPrettyTCMBool$fPrettyTCM[]0$fPrettyTCMPrettyContext$fPrettyTCMGraph$fPrettyTCMWithNodeOccurrence telePiPath telePiPath_ arityPiPath iApplyVars isIntervalcheckDisplayPragmaSigmaKit sigmaNamesigmaConsigmaFstsigmaSnd-->.-->..-->garrgpihPinPihPi'nPi'pPi'el'el'selInfelSSetnolamvarMgApplygApply'<@><#><..><@@>listtMaybeiopatheltset sSizeUniv tSizeUnivargNdomNargHdomHlookupPrimitiveFunctionlookupPrimitiveFunctionQgetBuiltinName isBuiltin getSigmaKit $fEqSigmaKit$fShowSigmaKit QuotingKitquoteTermWithKitquoteTypeWithKitquoteDomWithKitquoteDefnWithKitquoteListWithKit quotedName quotingKit quoteString quoteNamequoteNat quoteConName quoteMeta quoteTerm quoteTypequoteDom quoteDefn quoteList TermPositionHead Eliminated FamilyOrNotIsFamIsNotfamThing TranspOrHCompDoTranspDoHComprequireCubicalprimIntervalType 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$fEqTermPosition$fShowTermPosition$fEqFamilyOrNot$fShowFamilyOrNot$fFunctorFamilyOrNot$fFoldableFamilyOrNot$fTraversableFamilyOrNot$fEqTranspOrHComp$fShowTranspOrHCompPredRelOpFromTermfromTermFromTermFunctionToTermtoTermtoTermRPrimTermprimTermPrimTypeprimTypeLvlunLvlunNat buildListfromReducedTerm fromLiteralmkPrimInjectiveprimMetaToNatInjectiveprimCharToNatInjectiveprimStringToListInjectiveprimStringFromListInjectiveprimWord64ToNatInjectiveprimFloatToWord64InjectiveprimQNameToWord64sInjectivegetReflprimEraseEqualitygetReflArgInfo genPrimForce primForceprimForceLemmamkPrimLevelZeromkPrimLevelSucmkPrimLevelMaxmkPrimSetOmega primLockUniv' mkPrimFun1TCM mkPrimFun1 mkPrimFun2 mkPrimFun3 mkPrimFun4 $fPrettyNat $fTermLikeNat $fIntegralNat $fPrettyLvl $fPrimTermIO $fPrimTypeIO$fPrimTermMaybe$fPrimTypeMaybe $fPrimTerm[] $fPrimType[]$fPrimTermFixity'$fPrimTypeFixity'$fPrimTermType''$fPrimTypeType''$fPrimTermMetaId$fPrimTypeMetaId$fPrimTermQName$fPrimTypeQName $fPrimTermLvl $fPrimTypeLvl $fPrimTermNat $fPrimTypeNat$fPrimTermText$fPrimTypeText$fPrimTermDouble$fPrimTypeDouble$fPrimTermChar$fPrimTypeChar$fPrimTermBool$fPrimTypeBool$fPrimTermWord64$fPrimTypeWord64$fPrimTermInteger$fPrimTypeInteger $fPrimTerm(,) $fPrimType(,) $fPrimTerm-> $fPrimType-> $fToTermMaybe $fToTerm[] $fToTerm(,)$fToTermFixityLevel$fToTermAssociativity$fToTermFixity$fToTermFixity'$fToTermArgInfo$fToTermType'' $fToTermTerm $fToTermBool$fToTermInteger$fToTermMetaId $fToTermQName $fToTermText $fToTermChar$fToTermDouble $fToTermLvl$fToTermWord64 $fToTermNat$fFromTermMaybe $fFromTerm[]$fFromTermBool$fFromTermMetaId$fFromTermQName$fFromTermText$fFromTermChar$fFromTermDouble $fFromTermLvl$fFromTermWord64 $fFromTermNat$fFromTermInteger$fEqLvl$fOrdLvl$fEqNat$fOrdNat$fNumNat $fEnumNat $fRealNatinterestingConstraintprettyInterestingConstraintssayWhere$fPrettyTCMCall$fPrettyTCMCallInfoUsableModality usableModUsableRelevance usableRelhideAndRelParams workOnTypes'applyRelevanceToContextapplyRelevanceToContextOnlyapplyRelevanceToJudgementOnlyapplyRelevanceToContextFunBodyapplyQuantityToContextapplyQuantityToJudgementOnlyapplyCohesionToContextapplyCohesionToContextOnlysplittableCohesionapplyModalityToContextapplyModalityToContextOnlyapplyModalityToJudgementOnlyapplyModalityToContextFunBodywakeIrrelevantVars usableModAbsusableAtModalityisIrrelevantOrPropM isFibrantisCoFibrantSort$fUsableRelevanceAbs$fUsableRelevanceDom'$fUsableRelevanceArg$fUsableRelevanceElim'$fUsableRelevance(,,)$fUsableRelevance(,)$fUsableRelevance[]$fUsableRelevancePlusLevel'$fUsableRelevanceLevel'$fUsableRelevanceSort'$fUsableRelevanceType''$fUsableRelevanceTerm$fUsableModalityDom'$fUsableModalityArg$fUsableModalityElim'$fUsableModality(,)$fUsableModality[]$fUsableModalityLevel'$fUsableModalitySort'$fUsableModalityType''$fUsableModalityTermNormaliseProjPnormaliseProjPElimTypeArgTProjTprojTRec projTFieldmkCon orderFieldswarnOnRecordFieldWarningsfailOnRecordFieldWarningsorderFieldsWarnorderFieldsFailinsertMissingFieldsinsertMissingFieldsWarninsertMissingFieldsFail getRecordDefgetRecordOfFieldgetRecordFieldNamesrecordFieldNamesfindPossibleRecordsgetRecordFieldTypesgetRecordTypeFieldsgetRecordConstructor isRecordType tryRecordTypeorigProjection getDefType projectTyped typeElimsisEtaCon#isEtaOrCoinductiveRecordConstructorisInductiveRecordisEtaRecordTypeunguardedRecordrecursiveRecordnonRecursiveRecordisRecursiveRecordetaExpandBoundVarexpandRecordVarexpandRecordVarsRecursivelycurryAtetaExpandRecordforceEtaExpandRecordetaExpandRecord'etaExpandRecord_etaExpandRecord'_etaExpandAtRecordTypeisSingletonRecord isSingletonRecordModuloRelevanceisSingletonRecord'isSingletonTypeisSingletonTypeModuloRelevanceisSingletonType'isEtaVar$fPrettyTCMElimType$fNormaliseProjPPattern'$fNormaliseProjPNamed$fNormaliseProjPArg$fNormaliseProjP[]$fNormaliseProjPClauseLeftoverPatternspatternVariables asPatterns dotPatternsabsurdPatternstypeAnnotations otherPatternsLHSState_lhsTel _lhsOutPat _lhsProblem _lhsTarget_lhsPartialSplitAnnotationPattern 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$fSubstAsBinding$fPrettyTCMDotPattern$fSubstDotPattern$fPrettyTCMAbsurdPattern$fSubstAbsurdPattern$fPrettyTCMAnnotationPattern$fPrettyTCMLHSState$fSubstProblem$fPrettyPatVarPosition$fPrettyTCMLeftoverPatterns$fMonoidLeftoverPatterns$fNullLeftoverPatterns$fSemigroupLeftoverPatterns$fShowPatVarPosition$fEqPatVarPosition $fShowProblem$fEqFlexChoice$fShowFlexChoice$fEqFlexibleVar$fShowFlexibleVar$fFunctorFlexibleVar$fFoldableFlexibleVar$fTraversableFlexibleVar$fEqFlexibleVarKind$fShowFlexibleVarKind matchedArgs matchedArgs' foldMatch mergeElim mergeElimsmatchCopattern matchPatternyesSimplification matchPatternPmatchPatternsP $fMonoidMatch$fSemigroupMatch $fNullMatch$fFunctorMatchImplicitInsertion ImpInsert BadImplicits NoSuchNameNoInsertNeededinsertImplicitBindersTinsertImplicitBindersT1 implicitArgsimplicitNamedArgs newMetaArgnewInteractionMetaArginsertImplicitinsertImplicit'$fShowImplicitInsertion implicitPinsertImplicitPatternsinsertImplicitSizeLtPatternsinsertImplicitPatternsTuseNamesFromPatternuseNamesFromProblemEqs useOriginFrom noProblemRest initLHSStateupdateProblemRestetaExpandClausegetDefConstructorInfoDataCon RecordCon getConFormgetOrigConHead consOfHITgetFullyAppliedConTypegetConstructorInfo isDatatypeisDataOrRecordTypeisDataOrRecordgetNumberOfParametersgetNotErasedConstructorsgetConstructorsgetConstructors'getConstructors_ 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$fEqKind$fFunctorRecPatM$fApplicativeRecPatM$fMonadRecPatM$fMonadIORecPatM$fMonadTCMRecPatM$fHasOptionsRecPatM$fMonadTCEnvRecPatM$fMonadTCStateRecPatMDefNodeArgNodeComputeOccurrences occurrencesOccMOccEnvvarsinfOccurrencesBuilder'Concat' OccursAs' OccursHere'OccurrencesBuilderConcatOccursAs OccursHere OnlyVarsUpTo OccurrencesItemAnArgADefcheckStrictlyPositive getDefArity preprocessflattenwithExtendedOccEnvwithExtendedOccEnv'getOccurrencescomputeOccurrencescomputeOccurrences' mergeEdgesbuildOccurrenceGraph computeEdges$fPrettyTCMSeq $fPrettyItem$fHasRangeItem$fMonoidOccurrencesBuilder$fSemigroupOccurrencesBuilder$fComputeOccurrences(,)$fComputeOccurrencesMaybe$fComputeOccurrences[]$fComputeOccurrencesDom'$fComputeOccurrencesArg$fComputeOccurrencesElim'$fComputeOccurrencesAbs$fComputeOccurrencesTele$fComputeOccurrencesType''$fComputeOccurrencesPlusLevel'$fComputeOccurrencesLevel'$fComputeOccurrencesTerm$fComputeOccurrencesClause$fPrettyTCMNode$fPrettyTCMWithNodeEdge$fSemiRingEdge$fEqItem $fOrdItem $fShowItemProjEliminatorEvenLoneButLone NoPostfixProjectionViewLoneProjectionLike NoProjection projViewProj projViewSelf projViewSpine unProjViewprojViewreduceProjectionLikeelimView$fEqProjEliminator inferUnivSort sortFitsIn hasBiggerSort inferPiSort inferFunSortptsRuleptsRule' hasPTSRulecheckTelePiSortifIsSort ifNotSort shouldBeSortsortOf sortOfTypeprettyRecordFieldWarningprettyDuplicateFieldsprettyTooManyFieldsprettyNotInScopeNames didYouMeanprettyTCWarningsprettyTCWarnings'filterTCWarningstcWarningsToError applyFlagsToTCWarningsPreservingapplyFlagsToTCWarningsgetAllUnsolvedWarningsgetAllWarningsgetAllWarningsPreservinggetAllWarningsOfTCErr$fPrettyTCMTCWarning SplitPattern SplitPatVarsplitPatVarNamesplitPatVarIndexsplitExcludedLits BlockingVars BlockingVar blockingVarNoblockingVarConsblockingVarLitsblockingVarOverlapblockingVarLazy ApplyOrIApplyIsApplyIsIApplyBlockedOnResult BlockedOnProjBlockedOnApplyNotBlockedOnResultblockedOnResultOverlapblockedOnResultIApplyblockedOnResult blockedOnVarstoSplitPatternsfromSplitPatterns toSplitPSubstapplySplitPSubstisTrivialPatternsetBlockingVarOverlap matchClause$fPrettyBlockingVar$fDeBruijnSplitPatVar$fPrettyTCMSplitPatVar$fPrettySplitPatVar$fShowSplitPatVar$fShowBlockingVarPureConversionTunPureConversionT FreshThingsfreshIntfreshProblemId freshNameId pureEqualTerm pureEqualType pureCompareAsrunPureConversion$fMonadFreshIntPureConversionT!$fMonadFreshNameIdPureConversionT$$fMonadFreshProblemIdPureConversionT $fMonadStatisticsPureConversionT$fMonadWarningPureConversionT%$fMonadStConcreteNamesPureConversionT'$fMonadInteractionPointsPureConversionT $fMonadMetaSolverPureConversionT $fMonadConstraintPureConversionT$fMonadBlockPureConversionT$fNullPureConversionT$fIsStringPureConversionT$fSemigroupPureConversionT$fMonadTransPureConversionT$fFunctorPureConversionT$fApplicativePureConversionT$fMonadPureConversionT $fMonadErrorTCErrPureConversionT&$fMonadStateFreshThingsPureConversionT$fPureTCMPureConversionT$fMonadDebugPureConversionT $fMonadAddContextPureConversionT$fMonadReducePureConversionT$fReadTCStatePureConversionT$fMonadTCEnvPureConversionT$fHasOptionsPureConversionT$fHasConstInfoPureConversionT$fHasBuiltinsPureConversionT$fMonadFailPureConversionTPostponedEquationsPostponedEquation eqFreeVarseqTypeeqLhseqRhsNLMState_nlmSub_nlmEqsNLMunNLMnlmSubnlmEqsrunNLMmatchingBlockedtellSubtellEq reallyFreemakeSubstitutioncheckPostponedEquations nonLinMatchequal getTypedHead$fNullNLMState$fMonadBlockNLM$fMatchType''NLPatTerm$fMatch()NLPatLevel'$fMatch()NLPSortSort'$fMatch()NLPTypeType''$fMatchtDom'Dom'$fMatch(,)[][]$fMatchDom'ArgArg $fFunctorNLM$fApplicativeNLM $fMonadNLM$fMonadFailNLM$fAlternativeNLM$fMonadPlusNLM$fMonadErrorBlocked'NLM$fMonadStateNLMStateNLM$fHasBuiltinsNLM$fHasConstInfoNLM$fHasOptionsNLM$fReadTCStateNLM$fMonadTCEnvNLM$fMonadReduceNLM$fMonadAddContextNLM$fMonadDebugNLM $fPureTCMNLMCallPath callInfosMaskedgetMask getMaskedMaskedDeBruijnPatternsUsableSizeVarsusableSizeVarsTerMterMMonadTerterAskterLocalterAsksTerEnvterUseDotPatterns terSizeSucterSharp terCutOff terCurrent terMutual terUserNamesterHaveInlinedWith terTarget terDelayed terMaskArgs terMaskResult _terSizeDepth terPatternsterPatternsRaise terGuarded terUseSizeLt terUsableVarsGuardedTarget 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$fMonadBenchTerM$fUsableSizeVars[]$fUsableSizeVarsMasked$fUsableSizeVars[]0$fUsableSizeVarsPattern'$fMonadTerTerM$fPrettyCallPath$fShowCallPath$fSemigroupCallPath$fMonoidCallPath $fFunctorTerM$fApplicativeTerM $fMonadTerM$fMonadFailTerM$fMonadErrorTCErrTerM$fMonadStatisticsTerM$fHasOptionsTerM$fHasBuiltinsTerM$fMonadDebugTerM$fHasConstInfoTerM $fMonadIOTerM$fMonadTCEnvTerM$fMonadTCStateTerM$fMonadTCMTerM$fReadTCStateTerM$fMonadReduceTerM$fMonadAddContextTerM $fPureTCMTerM $fEqMasked $fOrdMasked $fShowMasked$fFunctorMasked$fFoldableMasked$fTraversableMasked tcErrString stringTCErrdropTopLevelModule$fPrettyTCMNegativeUnification$fPrettyTCMSplitError$fPrettyTCMTCErr$fPrettyUnequalType''$fPrettyUnequalTerm$fVerbalizeCohesion$fVerbalizeQuantity$fVerbalizeRelevance$fVerbalizeHiding$fPrettyTCMUnificationFailure$fVerbalizeIndefinite$fPrettyTCMTypeErrorprettyConstraint$fPrettyTCMConstraint$fPrettyTCMProblemConstraintOldSizeConstraintLeq OldSizeExprSizeMetacheckSizeLtSatcheckSizeNeverZerocheckSizeVarNeverZero isBoundedisBoundedProjVarisBoundedSizeTypeboundedSizeMetaHook trySizeUniv deepSizeView sizeMaxView compareSizescompareMaxViewscompareBelowMaxcompareSizeViewsgiveUptrivial isSizeProblemisSizeConstraintmkIsSizeConstraintisSizeConstraint_takeSizeConstraintsgetSizeConstraints getSizeMetasoldComputeSizeConstraintsoldComputeSizeConstraint oldSizeExprflexibleVariablesoldCanonicalizeSizeConstraintoldSolveSizeConstraints oldSolver$fPrettyOldSizeExpr$fPrettyOldSizeConstraint$fShowOldSizeConstraint$fEqOldSizeExpr$fShowOldSizeExpr polFromOcc nextPolaritypurgeNonvariant$fMonoidLeastPolarity$fSemigroupLeastPolarity $fSingletonPolarityLeastPolarity$fHasPolarityTerm$fHasPolarityAbs$fHasPolarity(,)$fHasPolarityType''$fHasPolarityPlusLevel'$fHasPolarityLevel'$fHasPolarityElim'$fHasPolarityDom'$fHasPolarityArg$fHasPolarity[]InvViewInvNoInv headSymbol headSymbol' topLevelArg joinHeadMaps updateHeadscheckInjectivitycheckInjectivity'checkOverapplicationinstantiateVarHeadsfunctionInverseuseInjectivityinvertFunctionforcePiUsingInjectivity findInstanceisInstanceConstraintshouldPostponeInstanceSearchpostponeInstanceConstraints$fShowYesNoMaybeaddConstraintTCMwakeConstraintsTCMstealConstraintsTCMnonConstraining newProblem newProblem_whenConstraintswakeConstraints'wakeupConstraintswakeupConstraints_solveAwakeConstraintssolveSomeAwakeConstraintsTCMsolveConstraintTCMsolveConstraint_checkTypeCheckingProblem$fMonadConstraintTCMTUnificationResult'UnifiesNoUnify UnifyBlocked UnifyStuckUnificationResult unifyIndices$fReduceEquality$fPrettyTCMUnifyState$fReduceUnifyState$fPrettyTCMUnifyStep$fMonoidUnifyOutput$fSemigroupUnifyOutput$fEqRetryNormalised$fShowRetryNormalised$fShowUnifyStep$fShowUnifyState$fShowUnificationResult'$fFunctorUnificationResult'$fFoldableUnificationResult'$fTraversableUnificationResult' PruneResultNothingToPrune PrunedNothingPrunedSomethingPrunedEverythingAnyRigidanyRigidoccurs metaOccursUnfoldStrategy YesUnfoldNoUnfold AllowedVarOccursM OccursCtx OccursExtra occUnfoldoccVarsoccMeta occCxtSizemodifyOccursCheckDefsinitOccursCheckdefNeedsCheckingtallyDef variableCheckdefinitionCheck metaCheck allowedVarsdefArgsunfoldBweaklystronglyflexiblypatternViolation' occursCheckmetaOccursQNameprune hasBadRigid isNeutralrigidVarsNotContainedInkillArgs killedTypereallyNotFreeIn performKill$fIsVarSet()-> $fOccurs(,,) $fOccurs(,) $fOccursMaybe $fOccurs[] $fOccursDom' $fOccursArg $fOccursAbs $fOccursElim' $fOccursSort'$fOccursType''$fOccursPlusLevel'$fOccursLevel'$fOccursClause $fOccursDefn $fOccursQName $fAnyRigid(,) $fAnyRigid[]$fAnyRigidElim'$fAnyRigidDom' $fAnyRigidArg $fAnyRigidAbs$fAnyRigidPlusLevel'$fAnyRigidLevel'$fAnyRigidSort'$fAnyRigidType''$fAnyRigidTerm $fOccursTerm$fEqPruneResult$fShowPruneResult$fEqUnfoldStrategy$fShowUnfoldStrategyrequireGuarded isTimelesscheckEarlierThan InvertExcept CantInvert NeutralArgProjVarRes SubstCandFVsReduceAndEtaContractreduceAndEtaContractNoProjectedVarnoProjectedVarfindIdx hasTwinMeta isBlockedTermisEtaExpandableassignTermTCM'newSortMetaBelowInfnewSortMetaCtx newTypeMeta' newTypeMeta newTypeMeta_ newLevelMetanewInstanceMetaCtxnewValueMetaCtx newValueMeta'newValueMetaCtx' trueConditionnewArgsMetaCtxnewArgsMetaCtx' newRecordMetanewRecordMetaCtxnewQuestionMarknewQuestionMark' blockTermblockTermOnProblemblockTypeOnProblemunblockedTesterpostponeTypeCheckingProblem_postponeTypeCheckingProblemetaExpandListenerswakeupListeneretaExpandMetaTCMetaExpandBlocked assignWrapper assignMeta assignMeta'checkSolutionForMetacheckSubtypeIsEqualsubtypingForSizeLtexpandProjectedVarsetaExpandProjectedVarcheckLinearity inverseSubstopenMetasToPostulatesdependencySortMetas$fMonadMetaSolverTCMT$fNoProjectedVarTerm$fNoProjectedVar[]$fNoProjectedVarArg$fReduceAndEtaContractTerm$fReduceAndEtaContractArg$fReduceAndEtaContract[]HypSizeConstraint sizeContext sizeHypIdssizeHypothesessizeConstraintSizeConstraint DBSizeExpr sizeMetaId sizeMetaArgs NamedRigid rigidName rigidIndexDefaultToInftyDontDefaultToInftyCCsolveSizeConstraintscastConstraintToCurrentContext'castConstraintToCurrentContextsolveSizeConstraints_ solveClustergetSizeHypothesescanonicalizeSizeConstraintcomputeSizeConstraintsizeExpr unSizeExpr$fPlusNamedRigidIntNamedRigid$fPrettyNamedRigid$fOrdNamedRigid$fEqNamedRigid$fSubstSizeExpr'$fSubstSizeMeta$fPrettyTCMSizeMeta$fPrettySizeMeta $fOrdSizeMeta $fEqSizeMeta$fPrettyTCMConstraint'$fSubstConstraint'$fPrettyTCMHypSizeConstraint$fFlexsHypSizeConstraint$fShowSizeMeta$fShowNamedRigid$fEqDefaultToInfty$fOrdDefaultToInfty$fShowDefaultToInftyConj tryConversiontryConversion'sameVars intersectVars blockOnError equalAtom convErrorassignE compareAsDir compareAs' compareTerm'compareAtomDircomputeElimHeadType compareDomcompareRelevancecompareQuantitycompareCohesion antiUnify antiUnifyArgs antiUnifyTypeantiUnifyElimscompareIrrelevantcompareWithPol polFromCmpcoerce coerceSizeforallFaceMapscompareInterval isCanonical leqIntervalleqConjcompareTermOnFace' bothAbsurdcheckConfluenceOfClausescheckConfluenceOfRulessortRulesOfSymbol$fParallelReduceAbs$fParallelReduceElim'$fParallelReduce[]$fParallelReduceType''$fParallelReduceDom'$fParallelReduceArg$fParallelReduceSort'$fParallelReduceTerm$fAllHolesPlusLevel' $fAllHoles[]$fAllHolesLevel'$fAllHolesSort'$fAllHolesTerm$fAllHolesType'' $fAllHoles[]0 $fAllHolesAbs$fAllHolesAbs0$fAllHolesDom' $fAllHolesArg$fMetasToVars(,,,)$fMetasToVars(,,)$fMetasToVars(,)$fMetasToVarsTele$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$fEqElimZipper$fOrdElimZipper$fShowElimZipper$fFunctorElimZipper$fFoldableElimZipper$fTraversableElimZipper$fFunctorThunk$fEqNormalisationcheckIApplyConfluence_checkIApplyConfluence unifyElimsunifyElimsMetageneralizeTelescopegeneralizeTypegeneralizeType' IsPathConsPathCons PointConsCType ClosedTypeLTypeLEl checkDataDef forceSortcheckConstructordefineCompDatadefineProjectionsfreshAbstractQName'_ fromLType lTypeLeveltoLType fromCTypetoCTypedefineTranspOrHCompForFieldsdefineTranspForFieldsdefineHCompForFieldsgetGeneralizedParametersbindGeneralizedParametersbindParameters bindParameterfitsIncheckIndexSorts constructs isCoinductive $fSubstLType $fSubstCType$fEqIsPathCons$fShowIsPathCons $fEqCType $fShowCType $fEqLType $fShowLType preAction postActionmodalityActionelimViewActioncheckInternalType' inferSpine'reconstructParametersInTypereconstructParametersInType'reconstructParametersInTelreconstructParametersInEqViewreconstructParametersreconstructParameters'dropParametersStdErrStdOutStdInExeArg ErrorPartStrPartTermPartunquote UnquoteResUnquoteM UnquoteStateDirtyClean agdaTermType agdaTypeType qNameTypeunpackUnquoteM packUnquoteM runUnquoteMliftU1liftU2inOriginalContextisConisDefreduceQuotedTermunquoteNchoice ensureDef ensureConpickName unquoteStringunquoteNStringprettyErrorParts unquoteTCMevalTCMrequireAllowExec exitCodeToNattcExecraiseExeNotFound$fUnquoteClause$fUnquotePattern $fUnquoteTerm$fUnquoteLiteral $fUnquoteSort $fUnquoteDom'$fUnquoteMetaId $fUnquoteAbs$fUnquoteQName$fUnquoteQuantity$fUnquoteRelevance$fUnquoteHiding $fUnquote(,) $fUnquote[] $fUnquoteText $fUnquoteChar$fUnquoteDouble$fUnquoteWord64$fUnquoteInteger $fUnquoteBool$fUnquoteElim' $fUnquoteArg$fUnquoteArgInfo$fUnquoteModality$fUnquoteErrorPart$fPrettyTCMErrorPart $fEqDirty etaExpandOnce deepEtaExpandetaExpandActionEqualSyequalSyAbsTermabsTerm IsPrefixOf abstractTypepiAbstractTerm piAbstract abstractTermswap01 $fAbsTerm(,) $fAbsTermAbs$fAbsTermMaybe $fAbsTerm[] $fAbsTermDom' $fAbsTermArg$fAbsTermElim'$fAbsTermPlusLevel'$fAbsTermLevel'$fAbsTermSort'$fAbsTermType'' $fAbsTermTerm $fEqualSyArg $fEqualSyDom'$fEqualSyArgInfo $fEqualSyAbs$fEqualSyElim'$fEqualSyType''$fEqualSySort'$fEqualSyPlusLevel'$fEqualSyLevel' $fEqualSyTerm $fEqualSy[]$fIsPrefixOfTerm$fIsPrefixOf[]$fIsPrefixOf[]0splitTelForWithwithFunctionType countWithArgs withArgumentsbuildWithFunctionstripWithClausePatternswithDisplayForm patsToElimsResulttermDecl termMutual$fExtractCallsPlusLevel'$fExtractCallsLevel'$fExtractCallsTerm$fExtractCallsType''$fExtractCallsSort'$fExtractCalls(,,)$fExtractCalls(,)$fExtractCalls[]$fExtractCallsElim'$fExtractCallsDom'$fExtractCallsArg$fExtractCallsAbs$fStripAllProjectionsTerm$fStripAllProjections[]$fStripAllProjections[]0$fStripAllProjectionsArgsanityCheckVarssanityCheckSubstparseIdiomBracketsSeqdesugarDoNotationIMrunIMreadline$fMonadErrorTCErrIM $fFunctorIM$fApplicativeIM $fMonadIM $fMonadIOIM$fHasOptionsIM$fMonadTCEnvIM$fReadTCStateIM$fMonadTCStateIM $fMonadTCMIM EncodeTCM encodeTCMobj#=@=kindkind'$fToJSONAbsolutePath $fToJSONDoc$fEncodeTCMMaybe$fEncodeTCMDoc$fEncodeTCMValue$fEncodeTCMInt32$fEncodeTCMInt$fEncodeTCMBool $fEncodeTCM[]$fEncodeTCM[]0vimFileescape wordBoundedmatchestoVimgenerateVimFile NameKindsrunHighlighter$fHiliteModuleName$fHiliteAmbiguousQName $fHiliteQName$fHiliteResolvedName$fHiliteDisambiguatedName$fHiliteImportedName'$fHiliteUsing'$fHiliteModuleInfo$fHiliteQuantity$fHiliteModality$fHiliteArgInfo $fHiliteArg $fHiliteNamed$fHiliteFieldAssignment'$fHiliteBindName$fHiliteBinder'$fHiliteLamBinding$fHiliteTypedBinding$fHiliteLetBinding$fHiliteModuleApplication$fHiliteDataDefParams$fHiliteGeneralizeTelescope$fHiliteWhereDeclarations$fHiliteProblemEq$fHiliteClause'$fHiliteRewriteEqn' $fHiliteRHS$fHiliteLHSCore' $fHiliteLHS$fHiliteLiteral$fHilitePattern' $fHiliteExpr$fHilitePragma$fHiliteDeclaration$fHiliteRecordDirectives' $fHilite(,)$fHiliteEither $fHiliteVoid$fHiliteWithHiding $fHiliteMaybe$fHiliteNonEmpty $fHilite[]$fHiliteRenamingTo$fHiliteRenamingTo0$fHiliteRenamingTo1$fHiliteRenaming'$fHiliteImportDirective'toAtomschooseHighlightingMethod usedArgumentsstripUnusedArguments simplifyTTerm $fShowAtom$fEqAtom $fOrdAtomnormalizeNamesdetectIdentityFunctions$fSemigroupIdentityIncomputeErasedConstructorArgs eraseTerms $fEqTypeInfo$fShowTypeInfo BuiltinKitnateliminateLiteralPatterns transformeliminateCaseDefaultstranslateBuiltins addCoercions erasedArity callCompiler callCompiler'jsonifyHighlightingInfo$fToJSONTokenBased$fEncodeTCMTokenBasedFullPartialgenerateAndPrintSyntaxInfogenerateTokenInfogenerateTokenInfoFromSourcegenerateTokenInfoFromStringprintSyntaxInfoprintErrorInfoerrorHighlightingwarningHighlightingprintUnsolvedInfocomputeUnsolvedInfostoreDisambiguatedProjectionstoreDisambiguatedConstructordisambiguateRecordFields#$fCollectionWithKindNameKindBuilder"$fSingletonWithKindNameKindBuilder$fMonoidNameKindBuilder$fSemigroupNameKindBuilderrecordInductionrecordEtaEquality LHSResult lhsParameters lhsVarTele lhsPatterns lhsHasAbsurd lhsBodyType lhsPatSubst lhsAsBindingslhsPartialSplitIsFlexiblePatternmaybeFlexiblePatternisFlexiblePatternbindAsPatternscheckLeftHandSidecheckSortOfSplitVar$fIsFlexiblePatternNamed$fIsFlexiblePatternArg$fIsFlexiblePattern[]$fIsFlexiblePatternPattern'$fIsFlexiblePatternPattern'0$fInstantiateFullLHSResultLamOrPiLamNotPiPiNotLamisTypeisType' checkLevel isTypeEqualToleqType_checkGeneralizeTelescopecheckTelescopecheckPiTelescopecheckTelescope' checkDomain checkPiDomaincheckTypedBindingsaddTypedPatternscheckTacticAttributeifPath checkPath checkLambda checkLambda'lambdaModalityChecklambdaIrrelevanceChecklambdaQuantityChecklambdaAnnotationChecklambdaCohesionChecklambdaAddContextcheckPostponedLambda0insertHiddenLambdascheckAbsurdLambdacheckExtendedLambda!catchIlltypedPatternBlockedOnMetaexpandModuleAssignscheckRecordExpressioncheckRecordUpdate checkLiteral scopedExprunquoteMcheckQuestionMarkcheckUnderscore checkMeta inferMetacheckOrInferMeta domainFreecheckKnownArgumentscheckKnownArgument checkNamedArg inferExpr'defOrVarcheckDontExpandLastisModuleFreeVarinferExprForWithcheckLetBindingscheckLetBinding $fEqLamOrPi $fShowLamOrPibindPostulatedName bindBuiltinisUntypedBuiltinbindUntypedBuiltinbindBuiltinNoDefbuiltinKindOfNameCovering covSplitArgcovSplitClauses SplitClauseSClausescTelscPatsscSubst scCheckpointsscTarget splitClausesclauseToSplitClause isCoveredinsertTrailingArgssplitClauseWithAbsurd splitLast splitResult$fPrettyTCMSplitClause$fEqAllowPartialCover$fShowAllowPartialCover$fEqInsertTrailing$fShowInsertTrailing$fMonoidErrorNonEmpty$fSemigroupErrorNonEmptyClsClclPatsclBodyRunRecordPatternTranslationDontRunRecordPatternTranslationcompileClauses'unBruijncompileWithSplitTreecompile nextSplit properSplitisVarsplitOnsplitCexpandCatchAllsensureNPatterns substBody$$fPrecomputeFreeVarsCompiledClauses' $fPrettyCl$fShowCl$fEqRunRecordPatternTranslation checkRecDefaddCompositionForRecorddefineCompKitRdefineTranspOrHCompRcheckRecordProjectionsClausesPostChecksCPCcpcPartialSplitsWithFunctionProblemNoWithFunction WithFunction wfParentNamewfName wfParentType wfParentTel wfBeforeTel wfAfterTelwfExprs wfRHSType wfParentPatswfParentParams wfPermSplit wfPermParent wfPermFinal wfClauses wfCallSubstcheckMacroTypeisAlias checkAlias checkFunDefS mapLHSCores insertNamesinsertInspectsinsertPatternsinsertPatternsLHSCorecheckSystemCoveragecheckClauseLHS checkClausegetReflPatterncheckRHS checkWithRHScheckWithFunction checkWhereatClause$fMonoidClausesPostChecks$fSemigroupClausesPostChecks toTreelessclosedTermToTreelessShowHeadshowHeadHighlightModuleContentsDontHightlightModuleContentsDoHighlightModuleContents FinalCheckscheckDeclCachedrevisitRecordPatternTranslationcheckUnquoteDeclcheckUnquoteDef unquoteTopinstantiateDefinitionType highlight_checkTermination_checkPositivity_checkCoinductiveRecordscheckInjectivity_checkProjectionLikeness_whenAbstractFreezeMetasAftercheckGeneralize checkAxiom checkAxiom'checkPrimitive checkPragma checkMutualcheckTypeSignaturecheckTypeSignature' checkSectioncheckModuleAritycheckSectionApplication' checkImportdebugPrintDecl$fShowHeadDeclaration$fEqHighlightModuleContentslispifyTokenBasedlispifyHighlightingInfo FindErrorNotFound Ambiguous InterfaceFile intFilePath SourceFile srcFilePathmkInterfaceFiletoIFilereplaceModuleExtensionfindErrorToTypeErrorfindFile findFile' findFile''findInterfaceFile'findInterfaceFilecheckModuleName moduleNamerootNameModule$fEqSourceFile$fOrdSourceFileSerialisedRangeunderlyingRange$fEmbPrjExpandedEllipsis$fEmbPrjImpossible$fEmbPrjCallStack$fEmbPrjSrcLoc$fEmbPrjDelayed$fEmbPrjIsAbstract$fEmbPrjLiteral$fEmbPrjProjOrigin$fEmbPrjConOrigin$fEmbPrjFreeVariables$fEmbPrjWithOrigin$fEmbPrjOrigin $fEmbPrjLock$fEmbPrjAnnotation$fEmbPrjRelevance$fEmbPrjModality$fEmbPrjCohesion$fEmbPrjQuantity$fEmbPrjQωOrigin$fEmbPrjQ1Origin$fEmbPrjQ0Origin$fEmbPrjHiding$fEmbPrjInduction$fEmbPrjPatternOrCopattern$fEmbPrjHasEta' $fEmbPrjArg$fEmbPrjWithHiding$fEmbPrjHashMap$fEmbPrjNameId$fEmbPrjModuleNameHash$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 $fEmbPrjList2$fEmbPrjNonEmpty $fEmbPrj[]$fEmbPrjTopLevelModuleName$fEmbPrjWithDefault$fEmbPrjPosition'$fEmbPrjAbsolutePath$fEmbPrjFileType $fEmbPrjBool $fEmbPrjMaybe$fEmbPrjMaybe0$fEmbPrjEither $fEmbPrj(,,) $fEmbPrjPair $fEmbPrj(,) $fEmbPrj() $fEmbPrjVoid$fEmbPrjDouble $fEmbPrjChar $fEmbPrjInt $fEmbPrjInt32$fEmbPrjWord64$fEmbPrjInteger $fEmbPrjText $fEmbPrjText0 $fEmbPrj[]0 $fEmbPrjName0$fEmbPrjSerialisedRange$fEmbPrjTokenBased$fEmbPrjRangeMap$fEmbPrjPairInt$fEmbPrjDefinitionSite$fEmbPrjAspects$fEmbPrjOtherAspect$fEmbPrjAspect$fEmbPrjNameKind $fEmbPrjRange$fEmbPrjForeignCode$fEmbPrjCompilerPragma$fEmbPrjSubstitution'$fEmbPrjBuiltin$fEmbPrjPattern'$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'$fEmbPrjIsFibrant$fEmbPrjPlusLevel'$fEmbPrjLevel' $fEmbPrjTerm $fEmbPrjAbs$fEmbPrjType''$fEmbPrjConHead$fEmbPrjDataOrRecord $fEmbPrjElim' $fEmbPrjDrop$fEmbPrjPermutation $fEmbPrjTele$fEmbPrjSection$fEmbPrjSignature $fEmbPrjDom'AbsNameWithFixity toAbsName fromAbsName$fEmbPrjNameOrModule$fEmbPrjScopeInfo$fEmbPrjPrecedence$fEmbPrjParenPreference$fEmbPrjConPatLazy$fEmbPrjConPatInfo$fEmbPrjLocalVar$fEmbPrjBindingSource$fEmbPrjKindOfName$fEmbPrjAbstractModule$fEmbPrjSuffix$fEmbPrjNameMetadata$fEmbPrjAbstractName$fEmbPrjWhyInScope$fEmbPrjNameSpace$fEmbPrjAccess$fEmbPrjNameSpaceId$fEmbPrjDataOrRecordModule $fEmbPrjScope$fEmbPrjBindName$fEmbPrjAbsNameWithFixity$fEmbPrjCutOff$fEmbPrjWarningName$fEmbPrjWarningMode$fEmbPrjConfluenceCheck$fEmbPrjUnicodeOrAscii$fEmbPrjPragmaOptions $fEmbPrjDoc$fEmbPrjLibPositionInfo$fEmbPrjExecutablesFile$fEmbPrjLibWarning'$fEmbPrjLibWarning$fEmbPrjDeclarationWarning'$fEmbPrjDeclarationWarning$fEmbPrjRecordFieldWarning$fEmbPrjParseWarning$fEmbPrjWarning$fEmbPrjTCWarning$fEmbPrjInterfaceencodedecodeencodeInterface encodeFiledecodeInterface decodeHashes decodeFile AbstractRHS TopLevelInfo topLevelDecls topLevelScopeTopLevel topLevelPathtopLevelExpectedNametopLevelTheThing OldModuleNameNewModuleQName NewModuleNameAPatNamePatNameOldQNameNewNameAbsOfConconcreteToAbstract_concreteToAbstractlocalToAbstractimportPrimitives$fToAbstractHoleContent'$fToAbstractPattern'$fToAbstractLHSCore'$fToAbstractWithHiding$fToAbstractRewriteEqn'$fToAbstractFieldAssignment'$fToAbstractMaybe$fToAbstractEither$fToAbstract(,,)$fToAbstract()!$fToAbstractRecordConstructorType$fToAbstractRewriteEqn'0$fToAbstractLamBinding'$fToAbstractBinder'$fToAbstractNewName$fToAbstractNewName0$fToAbstractMaybeOldQName$fToAbstractOldQName$fToAbstractLHSCore$fToAbstractResolveQName$fToAbstractPatName$fToAbstractOldName$fToQNameQName $fToQNameName$fToAbstractNewModuleName$fToAbstractNewModuleQName$fToAbstractModuleAssignment$fToAbstractOldModuleName$fEnsureNoLetStms[]$fEnsureNoLetStmsArg$fEnsureNoLetStmsNamed$fEnsureNoLetStmsLamBinding'$fEnsureNoLetStmsTypedBinding'$fEnsureNoLetStmsBinder'$fToAbstractDeclarations$fToAbstractTopLevel$fToAbstractTypedBinding'$fToAbstractExpr$fToAbstractLetDef$fToAbstractLetDefs$fToAbstractGenTel$fToAbstractGenTelAndType$fLivesInCurrentModuleQName"$fLivesInCurrentModuleAbstractName$fToAbstractDataConstrDecl$fToAbstractNiceDeclaration$fToAbstractRHS'$fToAbstractRightHandSide$fToAbstractAbstractRHS$fToAbstractLeftHandSide$fToAbstractClause$fToAbstractPragma$fShowTerminationOrPositivity$fFunctorNewName parseExpr parseExprIngiveExpr redoChecksgiverefine evalInCurrent evalInMeta normalFormcomputeIgnoreAbstractcomputeWrapInput showComputed outputFormIdreifyElimToExprprettyConstraintsgetConstraints namedMetaOfgetConstraintsMentioningstripConstraintPidsgetConstraints' getIPBoundarygetGoals getGoals' showGoalsgetWarningsAndNonFatalErrorsgetResponseContextgetSolvedInteractionPoints typeOfMetaMI typeOfMeta typeOfMeta'typesOfVisibleMetastypesOfHiddenMetasmetaHelperType contextOfMeta typeInCurrent typeInMetawithInteractionId withMetaId introTactic atTopLevel parseNameisQNameisNamemoduleContentsgetRecordContentsgetModuleContents$fPrettyIPBoundary'$fToConcreteIPBoundary'$fReifyIPBoundary'$fToConcreteOutputConstraint'$fPrettyOutputConstraint'$fToConcreteOutputConstraint$fToConcreteOutputForm$fPrettyOutputConstraint$fPrettyOutputForm$fReifyConstraint$fReifyProblemConstraint findMentions ClauseZipper CaseContextparseVariablesgetClauseZipperForIPrecheckAbstractClausemakeCasemakePatternVarsVisiblemakeRHSEmptyRecordmakeAbsurdClausemakeAbstractClauseanyEllipsisVar ConversionMOTTOMsConstssMetassEqssCurMeta sMainMetaMapSTModeTMAllHinthintIsConstructor hintQNameinitMapSpopMapStomygetdfvgetMetagetEqscopatternsNotImplementedliteralsNotImplementedhitsNotImplementedtomyIneqfmTypefmExpfmExpsfmLevelicnvh frommyExps abslamvarnamemodifyAbstractExprmodifyAbstractClause constructPats frommyClausecontains_constructornegtypefindClauseDeep matchType$fConversionExceptTExpTerm$fConversionExceptTExpType''$fConversionExceptTAbsAbs$fConversionExceptTMMb$fConversionStateT[]MM$fConversionStateTArg(,)$fConversionStateTTermMM$fConversionStateTType''MM$fConversionStateTArgPat$fConversionStateTClauseMaybe$fConversionStateT[][] $fEqTMode AutoResult autoProgress autoMessage AutoProgress Solutions FunClauses Refinementauto CheckResult crModuleInfo ScopeCheck TypeCheckSourcesrcText srcFileType srcOrigin srcModule srcModuleNamesrcProjectLibs crInterface crWarningscrModecrSource parseSource typeCheckMain readInterface$fEqMainInterface$fShowMainInterface$fEqMode $fShowModerunInteractionLoop$fFunctorReplM$fApplicativeReplM $fMonadReplM$fMonadIOReplM$fHasOptionsReplM$fMonadTCEnvReplM$fReadTCStateReplM$fMonadTCStateReplM$fMonadTCMReplM$fMonadErrorTCErrReplM$fMonadReaderReplEnvReplM$fMonadStateReplStateReplMIsMainNotMain doCompile doCompile' setInterfacecurIFcurMNamecurDefssortDefs compileDirrepl inCompilerEnv$fMonoidIsMain$fSemigroupIsMain $fEqIsMain $fShowIsMainKindOfForeignCodeForeignFileHeaderPragma ForeignImport ForeignOther HaskellPragmaHsDefnHsTypeHsDataHsExport HaskellType HaskellCode parsePragmaparseHaskellPragmagetHaskellPragmasanityCheckPragmagetHaskellConstructorforeignHaskellclassifyForeignclassifyPragmapartitionByKindOfForeignCode$fPrettyHaskellPragma$fHasRangeHaskellPragma$fShowHaskellPragma$fEqHaskellPragma HsCompileM HsCompileTHsCompileStatemazAccumlatedImportsReadHsModuleEnvaskHsModuleEnv HsModuleEnv mazModuleNamemazIsMainModulerunHsCompileT' runHsCompileTcurIsMainModule curAgdaModcurHsModihnameunqhnametlmodOfxqualxhqnhsNameconhqnbltQualdnamedunamehsPrimOp hsPrimOpApphsInt hsTypedInt hsTypedDoublehsLethsVarUQ hsAppView hsOpToExphsLambdahsMapAlthsMapRHSmazstrmazNamemazMod'mazMod mazCoerceName mazErasedNamemazAnyTypeName mazCoercemazIncompleteMatchrtmIncompleteMatchmazUnreachableErrorrtmUnreachableErrormazHolertmHole mazAnyTypemazRTE mazRTEFloatrtmQualrtmVarrtmErrorunsafeCoerceModfakeDfakeDSfakeDQfakeTypefakeExpfakeDecl emptyBinds isModChar$fReadHsModuleEnvStateT$fReadHsModuleEnvMaybeT$fReadHsModuleEnvIdentityT$fReadHsModuleEnvExceptT$fReadHsModuleEnvReaderT$fEqHsCompileState$fSemigroupHsCompileState$fMonoidHsCompileStateencodeModuleName prettyPrint prettyWhere prettyRhsprettyGuardedRhs prettyQName $fPrettyQOp $fPrettyAlt $fPrettyStmt $fPrettyType$fPrettyTyVarBind$fPrettyDataOrNew $fPrettyBinds $fPrettyPat $fPrettyMatch$fPrettyStrictness$fPrettyConDecl $fPrettyDecl$fPrettyImportSpec$fPrettyImportDecl$fPrettyModulePragmaCheckedMainFunctionDefcheckedMainDefcheckedMainDeclMainFunctionDefasMainFunctionDefmainFunctionDefscheckTypeOfMaincheckTypeOfMain'treelessPrimNameimportsForPrimxForPrimprimBody noCheckCoverbltQual' haskellTypecheckConstructorCounthsTelApproximationhsTelApproximation'$fEqPolyApprox RecompileBackend' backendNamebackendVersionoptionscommandLineFlags isEnabled preCompile postCompile preModule postModule compileDefscopeCheckingSuffices mayEraseType callBackend activeBackendparseBackendOptionsbackendInteraction$fNFDataBackend'$fNFDataBackend$fGenericBackend' GiveRefineGiveRefineIntro ElaborateGivelocalStateCommandMliftLocalStaterevLift revLiftTC commandMToIO liftCommandMTliftCommandMTLocalStatemodifyTheInteractionPointsmodifyOldInteractionScopesinsertOldInteractionScoperemoveOldInteractionScopegetOldInteractionScopehandleCommand_ handleCommandrunInteraction maybeAbortinitialiseCommandQueue independentupdateInteractionPointsAfter interpretsolveInstantiatedGoals cmd_load'withCurrentFilegive_gen highlightExprsortInteractionPointscmd_goal_type_context_andshowModuleContents searchAboutsetCommandLineOptsstatus displayStatus display_infoparseAndDoAtToplevel maybeTimedtellToUpdateHighlightingtellEmacsToJumpToError$fEqGiveRefine$fShowGiveRefine mimicGHCi showInfoErrorexplainWhyInScopeprettyTypeOfMetajsonREPL$fEncodeTCMResponse$fEncodeTCMTCWarning$fEncodeTCMTCErr$fEncodeTCMInfo_Error$fEncodeTCMGoalTypeAux$fEncodeTCMDisplayInfo$fEncodeTCMBlocker$fEncodeTCMOutputForm$fToJSONComputeMode$fEncodeTCMComputeMode$fToJSONCPUTime$fEncodeTCMCPUTime$fToJSONRewrite$fEncodeTCMRewrite$fToJSONMakeCaseVariant$fEncodeTCMMakeCaseVariant$fToJSONGiveResult$fEncodeTCMGiveResult$fEncodeTCMNamedMeta$fToJSONInteractionId$fEncodeTCMInteractionId$fToJSONMetaId$fToJSONProblemId$fEncodeTCMMetaId$fEncodeTCMProblemId$fToJSONRange'$fEncodeTCMRange'$fToJSONPosition'$fEncodeTCMPosition'$fEncodeTCMResponseContextEntry$fToJSONCurrentFile$fEncodeTCMCurrentFile$fToJSONCommandState$fEncodeTCMCommandState$fToJSONStatus$fEncodeTCMStatus$fToJSONNameInScope$fEncodeTCMNameInScope dotBackend latexBackend htmlBackend MonadGHCIOCCT CCContext NameSupplyCCEnv _ccNameSupply _ccContext UsesFloat GHCDefinitionghcDefUsesFloat ghcDefDeclsghcDefDefinition ghcDefMainDef ghcDefImports GHCModule ghcModEnvghcModMainFuncs GHCModuleEnvghcModCompileEnvghcModHsModuleEnv GHCCompileEnvghcCompileEnvOpts ReadGHCOpts askGhcOpts GHCOptions optGhcCallGhc optGhcBin optGhcFlagsoptGhcCompileDirGHCFlagsflagGhcCompileflagGhcCallGhc flagGhcBin flagGhcFlagsNoFloatYesFloat ghcBackend ghcBackend'defaultGHCFlagsghcCommandLineFlagswithCompilerFlag ghcPreCompileghcPostCompile ghcPreModule ghcPostModule ghcCompileDefghcMayEraseTypemazRTEFloatImport definitionconstructorCoverageCode ccNameSupply ccContext initCCEnvliftCC freshNamesintroscheckConstructorType checkCover closedTerm_ closedTermmkIfterm noApplicationhsCoerce compilePrimalthslitlitqname litqnamepatcondeclcompiledcondeclcompiledTypeSynonymtvaldeclinfodeclcopyRTEModules writeModule outFileAndDircurOutFileAndDir curOutFilecallGHC$fNFDataGHCFlags$fReadGHCOptsReaderT$fReadGHCOptsReaderT0$fReadGHCOptsReaderT1$fReadHsModuleEnvReaderT0$fReadGHCOptsReaderT2$fMonoidUsesFloat$fSemigroupUsesFloat $fEqUsesFloat$fShowUsesFloat$fGenericGHCFlags EnvWithOpts JSModuleEnv JSOptions optJSCompile optJSOptimize optJSMinify optJSVerify jsBackend jsBackend'defaultJSOptionsjsCommandLineFlags jsPreCompile jsPostCompile mergeModules jsPreModule jsPostModule jsCompileDefprefixjsMod jsFileNamejsMemberglobal'globalreorderreorder'isTopLevelValue isEmptyObject insertAftercheckCompilerPragmasdefJSDef definition' compileTerm compileAlteraseLocalVars visitorNameflatNamelocaloutFileoutFile_cubicalPrimitives primitives$fNFDataJSOptions$fGenericJSOptions FrontendType FrontEndEmacs FrontEndJson FrontEndRepl InteractorMainMode MainModeRunMainModePrintHelpMainModePrintVersionMainModePrintAgdaDirrunAgdarunAgda' getMainModeemacsModeInteractorjsonModeInteractorreplInteractordefaultInteractor getInteractorrunAgdaWithOptions printUsage backendUsage printVersion printAgdaDir optionErrorrunTCMPrettyErrors deConnectionsdeLabelDotGraph dgNodeLabelsdgEdgesdottify renderDotrenderDotToFileghc-prim GHC.TypesBoolinteger-wired-inGHC.Integer.Type Data.FoldableFoldableGHC.Num+FunctorGHC.IO.ExceptionGHC.IOcatch GHC.IORefIORef Data.IORefatomicWriteIORefatomicModifyIORef modifyIORef' modifyIORef mkWeakIORefatomicModifyIORef' writeIORef readIORefnewIORefBelowData.Map.InternalmapKeysTrue GHC.Maybe ApplicativeOrdering GHC.ClassesOrd==. Data.OldListcompareelemEqGHC.Showshow System.IOputStrLnShowFalseeitherEitherLeftRightguard mtl-2.2.2Control.Monad.Reader.Class MonadReaderFilePathdirectory-1.3.6.0System.DirectorycanonicalizePath doesFileExist text-1.2.3.2Data.Text.Internal.LazyTextmax<=deepseq-1.4.4.0Control.DeepSeqNFDataData.Strict.TupleData.IntMap.InternalIntMapGHC.EnummaxBoundfmapfoldr1orall&&anyfoldMapmapMMonoid++memptymappendHappyStk getBinDir getLibDir getDynLibDir getDataDir getLibexecDir getSysconfDirgetDataFileNamefindLibControl.Monad.State.Class MonadStatetransformers-0.5.6.2Control.Monad.Trans.State.LazyStateTControl.Monad.Trans.ReaderReaderTControl.Monad.Error.Class catchError)hashtables-1.2.4.1-CG1jegI0W125qroFjLdugDData.HashTable.IOCuckooHashTableBasicHashTableLinearHashTable Text.ReadreadsData.Sequence.InternalvarTel UnifyState:>>:$aeson-1.5.6.0-4Fai2YBAOjp98HRNOvB9PwData.Aeson.Types.Internal fixTargetType&inferOrCheckProjAppToKnownPrincipalArgcheckConstructorApplication compilerMainControl.Monad.Trans.ClassControl.Monad.IO.ClassliftIOlatexOptSourceFileNamelatexOptCountClusters LogMessage LogLaTeXTprepareCommonAssetsgenerateLaTeXIO LaTeXOptionslatexOptOutDir MonadLogLaTeXrunLogLaTeXTWith logMsgToText HtmlOptions HtmlHighlightsrcFileOfInterfaceLogHtmlT MonadLogHtmllogHtml htmlOptDirhtmlOptHighlighthtmlOptHighlightOccurrenceshtmlOptCssFile HighlightAll HighlightCode HighlightAutorunLogHtmlWithdefaultPageGenprepareCommonDestinationAssets