h&E t݂      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRS T U V W X YZ[\]^_`abcdefghi j k l m n o p q r s t u vwxyz{|}~            !"""""""#$$$$$$$$$$$$$$$$$$$%%%%%%%&&&&&&&&&&&&&&&&&&&&&&&&&&&&&''''''''''''''''''''''''''''((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((())))))))))))))********************++++++++++++++++,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,------...//////////////////000011111111112222222222222222222222222222222222233333333333334444444444444444444444444444444444444444444444445555566666666666666777777777777777777777777777888888888889999999999999999999999999999::;;;;;;;;;;;<<<<<<<<<<<<<<<<<<<<==========================                   >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>???????????                       @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A B B B B B B B B B B B B B B B B B B B B B B B C C C C C C C C C C C C C C C C C C C 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 E E E E E 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                                      G G G G G G G G 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 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 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 LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLMMMMMMMMMMMMMMMNNMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMOOOOOOOOOOOOOOOOOOOOPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRSSSSSSSSSSSSSSSSSSSSSSSSSSTTTTTTTTTTTTTTTTTTTTTTTTTTTTUUUUUVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUXXXXXXXXXXXXXXXXXYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYZ[[\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]^^^^^^^^^^^^^^_____________________ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ ` ` ` ` ` a a a a a a a a a a a a a a a a a a a a a a a b b b b b b b b b b b b b b b b b b b b b b b b b!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!e!e!e!e!e!e!e!e!e!e!e!e!e!e!e!e!e!e!e!e!e!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"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g#g#g#g#g#g#g#g#g#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#i#i#i#i#i#i#i#i#i#i#i#i#i#i#i#i#i#i#i#i#i#i#i#i#i#i#i#i#i#i#i#i#i#i#i#i#i#i#i#i#i#i#i#i#i#i#i#N#N#N#N#N#N#N#N#N#N#N#N#N#N#N#N#N#N#N#N#N#N#N#N#N#N#N#N#N#N#N#N#N#N#N#N#N#N#N#N#N#N#N#N#N#N#N#N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N$N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N%N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&N&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&j&j&j&j&j&j&j&j&j&j&j&j&j&j&j&j&j&k&k&k&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'm'm'm'm'm'm'm'm'm'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(o(o(o(o(o(o(o(o(o(o(o(o(o(o(o(o(o(o(o(o(o(o(o(o(o(o(o(o(o(o(o(o(o(o(o(o(o(o(o(o(o(o(o(o(o(o(o(o(o(o(o(o(o(p(p(p(p(p(p(p(p(p(p(p(p(p(p(p(p(p(p(p(p(p(p(p(p(p(p(p(p(p(p(p(p(p(p(p(p(p(p(p(p(p(p(p(p(p(p(p(p(p(p(p(p(p(p(q(q(q(q(q(q(q(q(q(q(q(q(q(q(q(q(q(q(q)q)q)q)q)q)q)q)q)q)q)q)q)q)q)q)q)q)q)q)q)q)q)q)q)q)q)q)q)q)r)r)r)r)r)r)r)r)r)r)r)r)r)r)r)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)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*u*u*u*u*u*u*u*u*u*u*u*u*u*u*u*u*u*u*u*u*u*u*u*u*u*u*u*u*u*u*u*u*u*u*u*u*u*u*u*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*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v+v+v+v+v+v+v+v+v+v+v+v+v+v+v+v+v+v+v+v+v+v+v+v+v+v+v+v+v+v+v+v+v+v+v+v+w+w+w+w+w+w+w+w+w+w+w+w+w+w+w+w+w+w+w+w+w+w+w+w+w+w+w+w+w+w+w+w+w+w+w+w+w+w+w+w+w+w+w+w+w+w+w+w+w+w+w+w+w+w+x+x+x+x+x+x+x+x+x+x+x+x+x+x+x+x+x+x+x+x+x+x+x+x+x+x+x+x+x+x+x+x+x+y+y+y+y+y+y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,z,z,z,z,z,z,z,z,z,z,z,z,z,z,z,z,z,z,z,z,z,z,z, , , , , , , , , , ,{,{,{,{,{,{,{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{-{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{.{/{/{/{/{/{/{/{/{/{/{/{/{/{/{/{/{/{/{/{/{/{/{/{/{/{/{/{/{/{/{/{/{/{/{/{/{/{/{/{/{/{/{/{/{/{/{/{/{/{/{/{/{/{/{/{/{/{/{/{/{/{/{/{/{/{/|/|/|/|/|/|/|/|/|/|/|/|/|/|/|/|/|/|/|/|/|/|/|/|/|/|/|/|/|/|/|/|/|/|/|/|/|/|/|/|/|/|/|/|/|/|/|/|/|/|/|/|/|/|/|/|/|/|/|/|/|/|/|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}0}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1}1~1~1~1~1~1~1~1~1~1~1~1~1~1~1~1~1~1~1~1~1~111111111111111111111112222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222233333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444445555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555566666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777778888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888899999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<================================================================================================================================>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ @ @@@@@@@@@@@@@@@@@@@@@@@@AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBjBjBjBjBjBjBjBjBjBjBjBjBjBjBjBjBjBjBjBjBjBjBjBjBjBjBjBjBjBjBjBjBjBjBjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjCjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjDjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjEjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjFjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjGjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjHjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjIjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjJjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjKjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjLjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjMjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjPjQjQjQjQjQjQjQjQjQjQjQjQjQjQjQjQjQjQjQjQjQjQjQjQjQjQjQjQjQjQjQjQjQjQjQjQjQjQjQjQjQjQjQjQjQjQjQjQjQjQjQjQjQjQjQjQjQjQjQjQjQjQjQjQjQjQjQjQjQjQjQjQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRkRkRkRkRkRkRkRkRkRkRkRkRkRkRkRkRkRkRkRkRkRkRkRkRkRkRkRkRkRkRkRkRkRkRkRkRkRkRkRkRkRkRkRkRkRkRkRkRkRkRkRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRSSSSSSSSSSSSSSSSSSSSSSSSSSkSkSkSkSkSkSkSkSSSSSSSkSkSkSkSkSkSkSkSkSSSkSSSSSSSSSSSSSSSSSSSSkSkSkSkSkSkSkSkSkSkSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUU~U~U~U~U~U~U~U~U~U~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~VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVkVkVkVkVkVkVkVkVkVkVVVVVVVkVkVkVkVkVkVkVkVkVkVkVkVkVkVkVkVkVkWkWkWkWkWkWkWkWkWkWkWkWkWkWkWkWkWkWkWkWkWkWkWkWkWkWkWkWkWkWkWkWkWkWkWkWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZkZkZkZkZkZkZkZkZkZkZkZkZkZkZkZkZkZkZkZkZkZkZkZkZkZkZkZkZk[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[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[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\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\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]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]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]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_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`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`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````````````````````````````````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffgggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggghhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiijjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||k||||||||||||||||||||||||||||||||||||||||||||||||||}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~k~~~~~~~~~~~~~~k~k~k~k~~~~~~~~~~~~~~~~~~~~~~k~k~k~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~kkkkkk€kÀkĀkŀkƀkǀkȀkɀkʀkˀk̀k̀k΀kπkЀkрkҀkӀkԀkՀր׀؀ـڀۀ܀݀ހ߀ÁāŁƁǁȁɁʁˁ́́΁ρЁсҁӁԁՁցׁ؁فځہ܁݁ށ߁‚ÂĂłƂǂȂɂʂ˂̂͂΂ςЂт҂ӂԂՂւׂ؂قڂۂ܂ Safe-Inferred!"%&'/2589:;<e:Agda1Agda42Agda71Agda113Agda154AgdaReturn the error corresponding to an exit code from the Agda process M M Safe-Inferred!"%&'/2589:;<fAgdaCut off structural order comparison at some depth in termination checker?Agdac >= 0( means: record decrease up to including c+1.AgdaThe default termination depth. Safe-Inferred!"%&'/2589:;<iAgda 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.   Safe-Inferred!"%&'/2589:;<j AgdaA constant term.Agda,A term with one hole and the (old) contents.Agda%A term with many holes (error value). Safe-Inferred!"%&'/2589:;<kAgdaBetter 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. Safe-Inferred!"%&'/2589:;<rAgdaType 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.! QRe dcba`_^fgh Safe-Inferred!"%&'/2589:;<sAgda%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. Safe-Inferred!"%&'/2589:;<uAgda3Tokenization for environment variable substitution.Agda~.Agda $VARIABLE or @${VARIABLE}$.AgdaOrdinary characters.AgdaTokenize a string. The ~ is recognized as $HOME% only at the beginning of the string.AgdaHome directory.Agda&Environment variable substitution map.AgdaInput.AgdaOutput with variables and ~ (home) substituted. Safe-Inferred!"%&'/2589:;<vN Safe-Inferred!"%&'/2589:;< AgdaRepeat 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  applyUnless Safe-Inferred!"%&'/2589:;<AgdaSemiring with idempotent  == dioidAgdaE.g. +Agdaneutral element of compose , e.g. zero  Safe-Inferred!"%&'/2589:;< 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. VW VW9 1 Safe-Inferred!"%&'/2589:;<Agda Hash tables.AgdaAn empty hash table.AgdaInserts the key and the corresponding value into the hash table.AgdaTries to find a value corresponding to the key in the hash table.Agda"Converts the hash table to a list.5The order of the elements in the list is unspecified. Safe-Inferred!"%&'/2589:;<AgdaShould not be used when  could be used.AgdaShould only be used in let or where.Agda7Unstructured pragma (Andreas, 2017-08-23, issue #2712). Safe-Inferred!"%&'/2589:;<Agda The function  makes every function argument, case and generator pattern, and  binding strict (except for those patterns that are marked as irrefutable, and anything in a  or :). Note that only the outermost patterns are made strict. Safe-Inferred!"%&'/2589:;<AgdaCatch s.Agda#Upon exception, the state is reset.Agda+Upon exception, the written output is lost.Agda Alias of  for the IO monad. Safe-Inferred!"%&'/2589:;<UAgdaReturns a close function for the file together with the contents.  Safe-Inferred!"%&'/2589:;<Agda=Action to be carried out for copying a directory recursively.AgdaCreate directory if missing.AgdaCopy file if changed.AgdacopyDirContent 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.)AgdaPerform scheduled .AgdacopyDirContentDryRun src dest; creates a to-do list for recursively copying directory src onto dest.AgdacopyIfChanged src dst makes sure that dst' exists and has the same content as dst.! Safe-Inferred!"%&'/2589:;<fAgdaCreates a temporary file, writes some stuff, and returns the filepath" Safe-Inferred!"%&'/2589:;<Agda*A kind of exception that can be thrown by  and .Agda#Decoding failed for the given file.AgdaConverts many character sequences which may be interpreted as line or paragraph separators into 'n'.AgdaReads a UTF8-encoded text file and converts many character sequences which may be interpreted as line or paragraph separators into 'n'.&If the file cannot be decoded, then a  is raised.AgdaReads a UTF8-encoded text file and converts many character sequences which may be interpreted as line or paragraph separators into 'n'.&If the file cannot be decoded, then a  is raised.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.# Safe-Inferred!"%&'/2589:;<AgdaRead +, modify it strictly, and return old value. $ Safe-Inferred!"%&'/2589:;< 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.  % Safe-Inferred!"%&'/2589:;<nAgdatoImpossible 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 .& Safe-Inferred!"%&'/2589:;<AgdaIsomorphic to Set ݂.Agdanot . member b.AgdatoSingleton s == Just b iff s == singleton b.AgdaThe empty set.Agda The full set.AgdaA singleton set.' Safe-Inferred!"%&'/2589:;<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.( Safe-Inferred!"%&'/2589:;<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) Safe-Inferred""%&'/2589:;<6 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.AgdaFrom a list of integers.Agda No integers.Agda All integers.Agda'If finite, return the list of elements.Agda Invariant.  * Safe-Inferred!"%&'/2589:;< 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+ Safe-Inferred%"%&')*/012589:;<R 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., Safe-Inferred!"%&'/2589:;<YAgdaTokenising the input (makes  cleaner)Agda*Options for Auto, default value and lenses$$- Safe-Inferred!"%&'/2589:;<Agda(View source:) This is how you implement a lens for a record field.. Safe-Inferred""%&'/2589:;<Agda;Update monadically the value at one position (must exist!).Agda Wrapper for  for convenience.AgdaFilter a map based on the keys./ Safe-Inferred!"%&'/2589:;<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.0 Safe-Inferred!"%&'/2589:;<Agda"Simple, non-reentrant memoisation.AgdaRecursive memoisation, second argument is the value you get on recursive calls.1 Safe-Inferred""%&'/2589:;<{Agda/Maximum of on-negative (small) natural numbers.2 Safe-Inferred!"%&'/2589:;<ZAgda Satisfying null empty == True.AgdaA  is ' when it corresponds to the empty list.  3 Safe-Inferred!"%&'/2589:;< 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 . 4 Safe-Inferred""%&'/2589:;<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.5 Safe-Inferred""%&'/2589:;<yAgda?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.6 Safe-Inferred!"%&'/2589:;<ҹ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).7 Safe-Inferred!"%&'/2589:;<Agda A set of sAgdaVarious things that can be measured when checking an Agda development. Turned on with the `--profile` flag, for instance `--profile=sharing` to turn on the  option. , , and  are mutually exclusive.NOTE: Changing this data type requires bumping the interface version number in .AgdaMeasure time taken by various parts of the system (type checking, serialization, etc)Agda/Measure time spent on individual (Agda) modulesAgda3Measure time spent on individual (Agda) definitionsAgda!Measure things related to sharingAgda/Collect detailed statistics about serializationAgda+Collect statistics about constraint solvingAgda%Count number of created metavariablesAgda$Measure time of interactive commandsAgda,Collect statistics about conversion checkingAgda#The empty set of profiling options.AgdaStrings accepted by AgdaParse and add a profiling option to a set of profiling options. Returns  with a helpful error message if the option doesn't parse or if it's incompatible with existing options. The special string "all" adds all options compatible with the given set and prefering the first of incompatible options. So `--profile=all` sets  over  and 0, but `--profile=modules --profile=all` sets  and not .AgdaCheck if a given profiling option is present in a set of profiling options.AgdaUse only for serialization.AgdaUse only for serialization.8 Safe-Inferred!"%&'/2589:;<ڼAgdaStar semirings ( 5https://en.wikipedia.org/wiki/Semiring#Star_semirings).Agda Semirings ( &https://en.wikipedia.org/wiki/Semiring). Safe-Inferred!"%&'/2589:;<09 Safe-Inferred!"%&'/2589:;<<Agda Overloaded  singleton constructor for collections.AgdaA create-only possibly empty collection is a monoid with the possibility to inject elements.: Safe-Inferred""%&'/2589:;<ޥAgdaGiven a function f :: a -> NonEmpty c9 which returns a non-empty list of characteristics 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 as paired with a non-empty list of characteristics into groups such that each element in a group shares at least one characteristic with at least one other element of the group. Safe-Inferred!"%&'/2589:;<iAgdaLet n be the size of type a.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).AgdaTime O(n). Assumes Bool-vector of length n.AgdaTime O(n). Produces Bool-vector of length n.AgdaTime O(n). Produces Bool-vector of length n.AgdaTime O(n). Bulk insert/delete.; Safe-Inferred!"%&'/2589:;< Agda&Classification of identifier variants.AgdaIdentifier ends in Integer many primes.AgdaIdentifier ends in number Integer (ordinary digits).AgdaIdentifier ends in number Integer (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.AgdaIncrease the suffix by one.Agda Parse suffix.Agda Print suffix.  < Safe-Inferred!"%&'/2589:;<$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.  = Safe-Inferred!"%&'/2589:;<AgdaFinite map from [k] to v.With the strict  type,  is also strict in v.Agda"Helper function used to implement  and .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.  Safe-Inferred!"%&'/2589:;<eAgdaBifunctoriality for pairs.Agda mapFst f = f -*- idAgda mapSnd g = id -*- gAgdaLifted pairing.AgdaMonadic version of .AgdaMonadic .AgdaMonadic .XX23> Safe-Inferred!"%&'/2589:;<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. 2.Agda5Case distinction for lists, with list first. O(1).Cf. 2.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).Agda*Lookup function (safe). O(min n index).Agda A variant of  that might provide more informative error messages if the index is out of bounds.4Precondition: The index should not be out of bounds.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).AgdaBreaks a list just after1 an element satisfying the predicate is found. breakAfter1 even 1 [3,5,2,4,7,8]([1,3,5,2],[4,7,8])AgdaBreaks a list just after1 an element satisfying the predicate is found.breakAfter even [1,3,5,2,4,7,8]([1,3,5,2],[4,7,8])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).AgdaReturns a list with one boolean for each non-empty suffix of the list, starting with the longest suffix (the entire list). Each boolean is  exactly when every element in the corresponding suffix satisfies the predicate. An example:    AbCde( = [False, False, False, True, True] For total predicates p and finite and total lists xs the following holds:   p xs =  ( p) ( ( xs)) Agda,Find the longest suffix of the first string xs* that is a prefix of the second string ys. So, basically, find the overlap where the strings can be glued together. Returns the index where the overlap starts and the length of the overlap. The length of the overlap plus the index is the length of the first string. Note that in the worst case, the empty overlap  (length xs,0) is returned.)Worst-case time complexity is quadratic:  O(min(n,m)) where  n = length xs and  m = length ys.There might be asymptotically better implementations following Knuth-Morris-Pratt (KMP), but for rather short lists this is good enough.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 .Agda2Chop up a list in chunks of a given length. O(n).AgdaChop a list at the positions when the predicate holds. Contrary to wordsBy, 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.Agda A variant of  that is parametrised by a function that is used to select which element from a group of equal elements that is returned. The returned elements keep the order that they had in the input list.. A variant of : which applies the predicate to consecutive pairs. O(n). AgdaSplit a list into sublists. Generalisation of the prelude function words . Same as  and , but with the non-emptyness guarantee on the chunks. O(n). words xs == wordsBy isSpace xs AgdaBreaks a list just after1 an element satisfying the predicate is found.breakAfter even [1,3,5,2,4,7,8]([1,3,5,2],[4,7,8]) 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 . AgdaList - but with a base case for the singleton list. Agda$Default value if convertee is empty.Agda&List to convert, supposedly non-empty.AgdaConverted list.   !"#$%&'()*+,-./0123456789:;<=>?@ABCDEF    !"#$%&'()*+,-./0123456789:;<=>?@ABCDEF  ? Safe-Inferred!"%&'/2589:;< 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.  @ Safe-Inferred!"%&'/2589:;<!f AgdaThing 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.  A Safe-Inferred!"%&'/2589:;<0e 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 nPrecondition for   (  _ is) xs: Every index in is must be non-negative and, if xs is finite, then every index must also be smaller than the length of xs.The implementation is supposed to be extensionally equal to the following one (if different exceptions are identified), but in some cases more efficient:  permute (  _ is) xs =  (xs >) is AgdaIdentity permutation. Agda"Restrict a permutation to work on n elements, discarding picks >=n. Agda9Pick the elements that are not picked by the permutation. AgdaliftP k takes a  Perm {m} n to a Perm {m+k} (n+k). Analogous to ?, but Permutations operate on de Bruijn LEVELS, not indices. Agda 2permute (compose p1 p2) == permute p1 . permute p2 Agda invertP err p is the inverse of p) where defined, otherwise defaults to err. composeP p (invertP err p) == p AgdaTurn 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.  B Safe-Inferred!"%&'/2589:;<2 AgdaLists of length D2. Agda Unsafe! O(1). Agda Safe. O(1). Agda Safe. O(1). Agda Safe. O(1). AgdaAny  is either a singleton or a  . O(1). Agda Inverse of  . O(1). AgdaO(1). AgdaO(length first list). AgdaO(length first list). Agda Safe. O(1). Agda Safe. O(1). Agda Safe. O(n). Agda is unsafe.  C Safe-Inferred""%&'/2589:;<9 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.AgdaThe smallest representable mantissa. Simultaneously, the smallest integer which can be represented as a Double without loss of precision.AgdaThe largest representable mantissa. Simultaneously, the largest integer which can be represented as a Double without loss of precision.Agda#The largest representable exponent.Agda$The smallest representable exponent. Agda.Encode a mantissa and an exponent as a Double.+ +  Safe-Inferred!"%&'/2589:;<?E 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 v 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  telescopesvwxyz{|}~ vwxyz{|}~ 6D Safe-Inferred!"%&'/2589:;<A 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.  E Safe-Inferred!"%&'/2589:;<KAgdaThe extended parser type computes one top-level document, plus one document per encountered memoisation key. is used to mark that a given memoisation key has been seen, but that no corresponding document has yet been stored. Agda(Documents paired with precedence levels. AgdaAn extended parser type, with some support for printing parsers.AgdaInvariant: If the boolean is , then the result must be  something, and if the boolean is , then the result must be ƒ something. 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.ăAgdaMemoised values.ŃAgdaContinuations.ƃAgdaState monad used by the parser.ǃAgda Positions. 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.ȃAgdaA smart constructor.ɃAgdaExtracts the parser.ʃAgdaExtracts the documents.˃AgdaA helper function.̃Agda Pretty-prints a memoisation key.̓AgdaA helper function.   Safe-Inferred!"%&'/2589:;<L& Safe-Inferred!"%&'/2589:;<L! QRe^_`abc dfgh! QRe^_`abc dfghF Safe-Inferred!"%&'/2589:;<P@ 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.΃Agda0displayInBuffer buffername append header content displays content (with header header%) in some suitable way in the buffer  buffername. If append is True, then the content is appended to previous content (if any), otherwise any previous content is deleted.σAgda$The name of the running info buffer. AgdaClear the running info buffer. AgdaClear the warning buffer AgdaDisplay running information about what the type-checker is up to.  Safe-Inferred!"%&'/2589:;<U 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 ƒ.ST  TS  Safe-Inferred!"%&'/2589:;<_& 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.-\NV[ZY] - ]N[ZYV\G Safe-Inferred#"%&'/2589:;<c 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  H Safe-Inferred""%&'/2589:;<i 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). False negatives may be returned. 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. AgdaA partial version of ؃& with flipped arguments, returning 6 if the given path cannot be relativized to the given root. Agda'The absolute path we see to relativize.AgdaThe root for relativization.AgdaThe relative path, if any. I Safe-Inferred!"%&'/2589:;<j AgdaHashes a piece of ك. Agda-Hashing a module name for unique identifiers.  J Safe-Inferred!"%&'/2589:;<p> 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.  K Safe-Inferred!"%&'/2589:;< 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  . Agda$Is the value a source key? O(log n). Agda$Is the value a target key? O(log n). 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).' ' T Safe-Inferred!"%&'/2589:;<QAgdaPicking 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.ۃAgda3Are we allowed to use unicode supscript characters?AgdaReturn the glyph set based on a given (unicode or ascii) glyph mode܃Agda/Choose the glyph set based on the unsafe IORef.W Safe-Inferred!"%&'/2589:;<XAgdaBuiltins 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.] Safe-Inferred!"%&'/2589:;<a AgdaThe  WarningName data enumeration is meant to have a one-to-one correspondance to existing warnings in the codebase.݃Agda9From user-given directives we compute WarningMode updatesAgda2Some 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 onesAgdawarningModeUpdate 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 errorAgdaCommon sets of warningsAgdaThe flag corresponding to a warning is precisely the name of the constructor minus the trailing underscore.Agda warningUsage generated using warningNameDescriptionރAgda WarningName descriptions used for generating usage information Leave String empty to skip that name.^ Safe-Inferred!"%&'/2589:;<߃AgdaList of Help Topics NOTA BENE: You need to add each new topic together with its name to  allHelpTopicsAgdaInterface to the help functionAgdaGeneral usage informationAgda)Specialised usage information about TOPICAgdaUsage information generationAgdaConversion functions to strings_ Safe-Inferred!"%&'/2589:;<-Agda5Cache locations of project configurations and parsed  .agda-lib files.AgdaThrows v exceptions, still collects  s.Agda Collects s and  s.AgdaCollection of s and  s.AgdaExceptions thrown by the  .agda-lib parser.Agda1An invalid library name, e.g., containing spaces.AgdaI/O error while reading file.AgdaMissing these mandatory fields.Agda'These fields occur each more than once.Agda=At the given line number, a field name is missing before the :.AgdaAt the given line number, an invalid field name is encountered before the :. (E.g., containing spaces.)Agda=At the given line number, the given field is not followed by :.AgdaAt the given line number, indented text (content) is not preceded by a field.Agda0Collected errors while processing library files.Agda/The user specified replacement for the default  libraries file does not exist.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.AgdaThe  .agda-lib file could not be parsed.Agda*An I/O Error occurred when reading a file.AgdaThe  executables! file contains duplicate entries. AgdaLibrary Warnings. AgdaInformation about which  .agda-lib. file we are reading and from where in the  libraries file it came from. 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 . Agda)Does a parse error contain a line number? Agda#Compute a position position prefix.-Depending on the error to be printed, it willeither give the name of the  libraries file and a line inside it,or give the name of the  .agda-lib file. Agda5Print library file parse error without position info. Agda 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.The time complexity is likely O(n + e log n) (but this depends on the, at the time of writing undocumented, time complexity of ).#AgdaThe graph's strongly connected components, in reverse topological order.The time complexity is likely O(n + e log n) (but this depends on the, at the time of writing undocumented, time complexity of ).#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).AgdaUsed to implement # and #.#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).#AgdaConstructs a graph g', with the same nodes as the original graph g. In g' there is an edge from n1 to n2> if and only if there is a (possibly empty) simple path from n1 to n2 in g. In that case the edge is labelled with all of the longest (in terms of numbers of edges) simple paths from n1 to n2 in g), as well as the lengths of these paths.Precondition: The graph must be acyclic. The number of nodes in the graph must not be larger than  :: ނ.>Worst-case time complexity (if the paths are not inspected):  O(e n log n)( (this has not been verified carefully).1The algorithm is based on one found on Wikipedia.#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.#AgdaThe transitive reduction of the graph: a graph with the same reachability relation as the graph, but with as few edges as possible.Precondition: The graph must be acyclic. The number of nodes in the graph must not be larger than  :: ނ.Worst-case time complexity:  O(e n log n)) (this has not been verified carefully).1The algorithm is based on one found on Wikipedia.#Agda*The graph's strongly connected components."""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""##################""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""###"""""###############h Safe-Inferred!"%&'/2589:;<#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.##i Safe-Inferred!"%&'/2589:;</#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.############################################## Safe-Inferred!"%&'/2589:;<I?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:  . AgdaFile information used in the  ,   and   types. AgdaThe file's path. Agda!The file's top-level module name.This field is optional, but some things may break if the field is not instantiated with an actual top-level module name. For instance, the  and ( instances only make use of this field.The field uses  rather than  because it should be possible to instantiate it with something that is not yet defined (see ).This  should not contain a range. 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. AgdaA smart constructor for  . 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*The range's top-level module name, if any.If there is no range, then ? is returned. If there is a range without a module name, then   is returned. Agda*The range's top-level module name, if any. 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. Agda Only the   component is compared. Agda Only the   component is compared. 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].   Safe-Inferred!"%&'/2589:;<Agda8Top-level module names (with constant-time comparisons).&Agda:Raw top-level module names (with linear-time comparisons).&Agda3A top-level module name has one or more name parts.&Agda0Turns a raw top-level module name into a string.&Agda#Hashes a raw top-level module name.&AgdaTurns a qualified name into a &. The qualified name is assumed to represent a top-level module name.&Agda Computes the & corresponding to the given module name, which is assumed to represent a top-level module name.2Precondition: The module name must be well-formed.&Agda#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 spanAllowedBeforeModule.&AgdaA lens focusing on the &.&AgdaConverts a top-level module name to a raw top-level module name.&AgdaConverts a raw top-level module name and a hash to a top-level module name.This function does not ensure that there are no hash collisions, that is taken care of by .&AgdaA corresponding . The range of each Name! part is the whole range of the .&AgdaTurns a top-level module name into a file name with the given suffix.&AgdaFinds the current project's "root" directory, given a project file and the corresponding top-level module name.8Example: If the module "A.B.C" is located in the file "fooABC.agda", then the root is "foo".2Precondition: The module name must be well-formed.&AgdaThe   is not forced.&AgdaThe   is not forced.&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&N Safe-Inferred#"%&'/23589:;<5#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.#AgdaApplies to the stated function#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.$Agda unquoteDecl xs = e$Agda unquoteDef xs = e$Agda %unquoteDecl data d constructor xs = e$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 field signatures$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%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%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 $.Agda)Generic expression to pattern conversion.%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.Agda&Default result for non-pattern things.AgdaThe expression to translate.AgdaThe translated pattern (maybe).######################################$#$$$$$$$$$#$########$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$%%%$%%%%%%%%%$%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%$$%%%$%%%%%%%%%$%%%%%%%%%%%%%%%%%%%%%%$$##%%%%%%%%%%%$$$$$%%$$$$%$$$$%%%%%%%%%%%%%%$$$$$$%%$$$%%%%%$$$$$%$#$#$$$$$$$$$#$########$$$$$$$$$$$###$$$$$$$$$$$$$###$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$%%%$$$$$$$$$$$$$$$$$$$$#############################%X Safe-Inferred!"%&'/2589:;<:AgdaRanges are not forced.  L Safe-Inferred""%&'/2589:;<O AgdaNotation parts. Agda&An identifier part. For instance, for _+_ the only identifier part is +. AgdaA hole: a place where argument expressions can be written. For instance, for _+_) the two underscores are holes, and for  syntax  A ( x C B) = B , A , x the variables A and B are holes. The number is the position of the hole, counting from zero. For instance, the number for A is 0, and the number for B is 1. AgdaA bound variable.The first range is the range of the variable in the right-hand side of the syntax declaration, and the second range is the range of the variable in the left-hand side. Agda/A wildcard (an underscore in binding position). Agda.Positions of variables in syntax declarations. AgdaThe position (in the left-hand side of the syntax declaration) of the hole in which the variable is bound, counting from zero (and excluding parts that are not holes). For instance, for  syntax  A ( x C B) = B , A , x the number for x is 1, corresponding to B (0 would correspond to A). AgdaThe position in the list of variables for this particular variable, counting from zero, and including wildcards. For instance, for "syntax F ( x _ y C A) = y ! A ! x the number for x is 0, the number for _ is 1, and the number for y is 2. 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 expressions Agda  rewrite e Agda with p <- e in eq Agda!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.Agda4Meta-variable identifiers use the same structure as s.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 N.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?AgdaAgda variants.Only some variants are tracked.AgdaVariants of Cubical Agda.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.Agda can be embedded into .Agda can be projected onto .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=The record selector is not included in the resulting strings.Agda?The record selectors are not included in the resulting strings.AgdaRanges are not forced.AgdaRanges are not forced.Agdanull for import directives holds when everything is imported unchanged (no names are hidden or renamed).    U Safe-Inferred!"%&'/2589:;<!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>M Safe-Inferred!"%&'/2589:;< 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?S Safe-Inferred""%&'(/2589:;<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.Agda7Annotates a tokenized string with position information.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.Agda6Replaces non-space characters in a string with spaces.Agda*Check if a character is a blank character.AgdaShort list of extensions for literate Agda files. For display purposes.AgdaReturns a tuple consisting of the first line of the input, and the rest of the input.Agda2Canonical decomposition of an empty literate file.AgdaCreate a regular expression that: - Must match the whole string - Works across line boundariesAgdaPreprocessor for literate TeX.AgdaPreprocessor for Markdown.Agda"Preprocessor for reStructuredText.Agda$Preprocessor for Org mode documents.O Safe-Inferred""%&'/2589:;< 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.P Safe-Inferred!"%&'/2589:;<AgdaArbitrary JS code.,,c Safe-Inferred!"%&'/2589:;<!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!d Safe-Inferred!"%&'/2589:;<=!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!6Q Safe-Inferred!"%&'/2589:;<Z(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.AgdaProjection 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 instancesR Safe-Inferred!"%&'/2589:;<Ӯ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.e Safe-Inferred""%&'/2589:;<S!Agda)Typechecker drives the solution of metas.-!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!-!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!f Safe-Inferred!"%&'/2589:;<&!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):5!!!!!!!!!!"""""""""""""""""""""""""""""""""""""""""""5""""""""""""""""""""""!""""""!!!!!""""!!""""""""!!"""a Safe-Inferred!"%&'/2589:;<۴ 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.   b Safe-Inferred!"%&'/2589:;< 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.AgdaConstructs a pair. 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 The number of ranges in the map.%This function should not be exported. 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 A variant of  . If a range in the middle was split into two pieces, then those two pieces are returned. 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.  Y Safe-Inferred!"%&'/2589:;<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 [] Z Safe-Inferred!"%&'/2589:;<RAgda,Split alts into TAGuard alts and other alts.[ Safe-Inferred!"%&'/2589:;< AgdaWe lose track of @-patterns in the internal syntax. This pass puts them back.\ Safe-Inferred!"%&'/2589:;<iAgdaArbitrary 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.m Safe-Inferred!"%&'/2589:;<@'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.'AgdaShow the attributes necessary to recover a modality, in long-form (e.g. using at-syntax rather than dots). For the default modality, the result is at- (rather than the empty document). Suitable for showing modalities outside of binders.,''''''''''''''''''''''''''''''''''''''''''''n Safe-Inferred!"%&'/2589:;<H '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).''''''''''''''''''''''''''''''''''''''''''''''''''o Safe-Inferred!"%&'/2589:;< (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.(Agda9Data type constructed in the Happy parser; converted to  ! before it leaves the Happy code.(Agda  xA @ xA C y.: The first argument contains the bound names.(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?(AgdaIs the part a binder?(AgdaBenchmark a pure computation and bill it to the given account./(((((((((((((((((((((((((((((((((((((((((((((((/(((((((((((((((((((((((((((((((((((((((((((((((q Safe-Inferred!"%&'/2589:;<(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.!((((((((((((((((((())))))))))))))!((((((((((((((()(((()))))))))))))r Safe-Inferred$"%&')*/12589:;<$0 )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."))))))))))))))))))))))))))))))))))"))))))))))))))))))))))))))))))))))s Safe-Inferred!"%&'/2589:;<%)Agda,Generic traversals for concrete expressions. Note: does not go into patterns!)AgdaThis corresponds to .)AgdaThis corresponds to .)AgdaThis corresponds to .))))))))t Safe-Inferred""%&'/2589:;<)iAgdaWhile ) and Polarities are not semigroups under disjoint union (which might fail), we get a semigroup instance for the monadic m (Fixities, Polarities)% which propagates the first error.AgdaAdd more fixities. Throw an exception for multiple fixity declarations. OR: Disjoint union of fixity maps. Throws exception if not disjoint.)AgdaGet the fixities and polarity pragmas from the current block. Doesn't go inside modules and where blocks. The reason for this is that these declarations have to appear at the same level (or possibly outside an abstract or mutual block) as their target declaration.AgdaCompute the names defined in a declaration. We stay in the current scope, i.e., do not go into modules. ))))))))))))) )))))))))))))u Safe-Inferred!"%&'/2589:;<7C)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.*AgdaNumbering declarations in an interleaved mutual block.*Agda&Internal number of the data signature.*AgdaThe data signature.*Agda.Constructors associated to the data signature.*Agda6Function clauses associated to the function signature.*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.)))))))***********************************************************************************************************************************)**))))))*******v Safe-Inferred!"%&'/2589:;<B#*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 Hidden identifier in a variable declaration. Hiding has no effect there as generalized variables are always hidden (or instance variables).*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.*AgdaDefinitions (e.g. constructors or functions) without a declaration.*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.=****************************************+++++++++++++++++++++=++++*+++++++++++++***************************************++++w Safe-Inferred!"%&'/2589:;<M+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+++++++++++++++++++++++++++++++++++++++++++++++++x Safe-Inferred!"%&'/2589:;<R+AgdaInformation about cohesion attributes (printed representations and positions).This information is returned by the parser. Code that calls the parser should, if appropriate, complain if support for cohesion attributes has not been enabled and the returned list is non-empty. This can be taken care of by , which should not be called until after pragma options have been set.+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.++++++++++++++++++++++++++++++++++++++++++++++++++++++++++y Safe-Inferred!"%&'/2589:;<d8+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.,Agda5Every encountered occurrence of a cohesion attribute.,AgdaThe parse monad.AgdaOld interface to parser.,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.++++++,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,+++,,,,,,,,,,,,,,,,,,,,,,,,,,,,,+++,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,, Safe-Inferred#"%&')*/2589:;<fsAgdaGraph structurez Safe-Inferred""%&'/2589:;<m ,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?,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,  Safe-Inferred!"%&'/2589:;<sp ,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 == (U 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.,AgdaMaps 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 -..Agda$The flat list of ambiguous names in -..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.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./Agda/Sets the binding site of all names in the path.-Agda The name x this explanation is about.Agda2The directory in which the current module resides.AgdaThe local variable that x could denote, if any.AgdaThe defined names that x could denote.AgdaThe modules that x could denote.-Agda- can be DefName, -, -.-Agda(- ==) . - for all names.-Agda isJust . . . - for all names.-Agda(- ==) . - for all names..Agda4Merged scope, clashing names, clashing module names.,,,,,,,--------------------------------------------------------------------------------------------------------------------------------........................................................................................-------------------------------------------------------..............--------------.------------------.......----....---------------------..------------.--.................................,--................,,,,........,,..| Safe-Inferred!"%&'/2589:;<$/Agda:Has the constructor pattern a dotted (forced) constructor?/AgdaDotted constructor./AgdaOrdinary constructor./AgdaConstructor pattern info./AgdaDoes this pattern come form the eta-expansion of an implicit pattern?/Agda;For a general pattern we remember the source code position./AgdaThe range of the "as" and "to" keywords, if any. Retained for highlighting purposes./AgdaThe "as" module name, if any. Retained for highlighting purposes./Agda Retained for abstractToConcrete of $./AgdaInformation about application/Agda6Do we prefer a lambda argument with or without parens?/Agda-Default is system inserted and prefer parens./Agda/ with no range information./AgdaSame as  mkDefInfo but where we can also give the  IsInstance/AgdaEmpty range for patterns.0AgdaDefault value for /.>//////////////////////////////////////////////////////////////>//////////////////////////////////////////////////////////////} Safe-Inferred!"%&'/2589:;<10Agda#Conversion between different types.0AgdaA type that is intended to be used when constructing highlighting information.>Note the invariant which values of this type should satisfy (1).This is a type synonym in order to make it easy to change to another representation."The type should be an instance of   0,  and &, and there should be an instance of 0 0 0.0AgdaHighlighting information.>Note the invariant which values of this type should satisfy (1).This is a type synonym in order to make it easy to change to another representation.0Agda'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 (1).0AgdaSyntax highlighting information, represented by maps from positions to 0.,The first position in the file has number 1.0AgdaA limited kind of syntax highlighting information: a pair consisting of   and 0.Note the invariant which 0s should satisfy (1).0AgdaIs the highlighting "token-based", i.e. based only on information from the lexer?0AgdaThe defining module.0AgdaThe file position in that module. File positions are counted from 1.0Agda Has this DefinitionSite/ been created at the defining site of the name?0Agda#A pretty name for the HTML linking.0AgdaMeta information which can be associated with a character/character range.0AgdaThis 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).0AgdaThe definition site of the annotated thing, if applicable and known.0AgdaIs this entry token-based?0AgdaOther aspects, generated by type checking. (These can overlap with each other and with 1s.)0Agda.A warning that is considered fatal in the end.0AgdaUnsolved constraint not connected to meta-variable. This could for instance be an emptyness constraint.0AgdaUsed for highlighting unreachable clauses, unreachable RHS (because of an absurd pattern), etc.0Agda8Used for shadowed repeated variable names in telescopes.0AgdaWhen this constructor is used it is probably a good idea to include a 0* explaining why the pattern is incomplete.0Agda!Code which is being type-checked.0AgdaFunction declaration without matching definition NB: We put CatchallClause last so that it is overwritten by other, more important, aspects in the emacs mode.1AgdaNameKind(s are figured out during scope checking.1AgdaBound variable.1AgdaGeneralizable variable. (This includes generalizable variables that have been generalized).1Agda%Inductive or coinductive constructor.1Agda Record field.1Agda Module name.1Agda Primitive.1Agda Record type.1Agda!Named argument, like x in {x = v}1AgdaMacro.1Agda6Syntactic aspects of the code. (These cannot overlap.)1Agda Symbols like forall, =, ->, etc.1AgdaThings like Set and Prop.1AgdaIs the name an operator part?1AgdaText occurring in pragmas that does not have a more specific aspect.1Agda"Non-code contents in literate Agda1AgdaDelimiters used to separate the Agda code blocks from the other contents in literate Agda1AgdaInvariant for 0.1AgdaInvariant for 0 hl%, parametrised by the invariant for hl.?Additionally the endofunction should be extensionally equal to (fs ) for some list fs.1AgdaThe invariant for 0.1AgdaThe invariant for 0.?Additionally the endofunction should be extensionally equal to (fs ) for some list fs.1Agda A variant of  with 0 set to 0.1Agda4Conversion from classification of the scope checker.AgdaMerges meta information.1AgdaSome 1#s are more informative than others.1AgdaNameKind in Name can get more precise. 0000000000000000000000000000000000000000000111111111111111111111111111111111111111111111111111111111000000000000000100000000000000000001000001010111 00  Safe-Inferred!"%&'/2589:;<͊#AgdaTransposable things.1Agda1 m extracts the diagonal of m.For non-square matrices, the length of the diagonal is the minimum of the dimensions of the matrix.1Agda6Type of matrices, parameterised on the type of values.Sparse matrices are implemented as an ordered association list, mapping coordinates to values.1AgdaDimensions of the matrix.1Agda!Association of indices to values.1Agda%Type of matrix indices (row, column).1Agda Row index, 1 <= row <= rows.1Agda Column index 1 <= col <= cols.1AgdaSize of a matrix.1AgdaNumber of rows, >= 0.1AgdaNumber of columns, >= 0.1Agda iff the matrix is square.1AgdaReturns  iff the matrix is empty.1Agda5Compute the matrix size of the union of two matrices.Agda (i,)  $ f a), and same for gs and g.Agda Instance of 2$ which keeps longer assoc lists.  O(n1 + n2).2Agda?General pointwise combination function for sparse matrices.  O(n1 + n2).2Agda2 (+) m1 m2 adds m1 and m2, using (+) to add values.  O(n1 + n2).Returns a matrix of size 1 m1 m2.2Agda2 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.2Agda"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.2Agda2 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.2Agda2 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.2Agda2 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.2AgdaPointwise comparison. Only matrices with the same dimension are comparable.2AgdaDiagonal of sparse matrix.O(n) where n2 is the number of non-zero elements in the matrix.2AgdaMatrix transposition. O(n log n) where n2 is the number of non-zero elements in the matrix.2AgdaTransposing coordinates.2AgdaSize of transposed matrix.2AgdaOnly 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.Agda!Element only present in left map.Agda"Element only present in right map.AgdaElement present in both maps.2Agda$Element only present in left matrix.Agda%Element only present in right matrix.Agda!Element present in both matrices.AgdaResult counts as zero?11111111111111111111111222222221111111111111111112222211111222 Safe-Inferred""%&'/2589:;<2AgdaA partial order, aimed at deciding whether a call graph gets worse during the completion.2Agda:In the paper referred to above, there is an order R with 2  Le  Lt.This is generalized to 2  '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.2Agda2Decrease 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.2AgdaNo relation, infinite increase, or increase beyond termination depth.2Agda&Matrix-shaped order, currently UNUSED.2Agda$Raw increase which does not cut off.2Agda$Raw decrease which does not cut off.2AgdaSmart constructor for Decr k :: Order which cuts off too big values.Possible values for k:  - ?cutoff  k  ?cutoff + 1.2AgdaSmart constructor for matrix shaped orders, avoiding empty and singleton matrices.2Agdale, lt,  decreasing, unknown4: for backwards compatibility, and for external use.2AgdaUsable decrease.2AgdaDecreasing and usable?2AgdaMatrix-shaped order is decreasing if any diagonal element is decreasing.2AgdaMultiplication of 2.s. (Corresponds to sequential composition.)Agda collapse mWe assume that m codes a permutation: each row has at most one column that is not Unknown.To collapse a matrix into a single value, we take the best value of each column and multiply them. That means if one column is all Unknown, i.e., no argument relates to that parameter, then the collapsed value is also Unknown.,This makes order multiplication associative.Agda'Can two matrices be multplied together?2Agda+The supremum of a (possibly empty) list of 2;s. More information (i.e., more decrease) is bigger. 2# is no information, thus, smallest.Agda(2, , 2) forms a semiring, with 2 as zero and Le as one.2Agda%The infimum of a (non empty) list of 2$s. Gets the worst information. 2& is the least element, thus, dominant.AgdaPick the worst information.2AgdaWe use a record for semiring instead of a type class since implicit arguments cannot occur in instance constraints, like +instance (?cutoff :: Int) => SemiRing Order.2AgdaInformation order: 2 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).2Agda/We assume the matrices have the same dimension.2AgdaIt does not get worse then ` increase'. If we are still decreasing, it can get worse: less decreasing.2222222222222222222222222222222222222222222222 Safe-Inferred#"%&'/2589:;<2AgdaSets of incomparable call matrices augmented with path information. Use overloaded , , , .2Agda,Call matrix augmented with path information.2Agda"The matrix of the (composed call).2AgdaMeta info, like call path.2Agda0Call matrix multiplication and call combination.2AgdaCall 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:2 (less than) if the j-th argument to the target; function is structurally strictly smaller than the i-th pattern.2 (less than or equal) if the j-th argument to the target+ function is structurally smaller than the i-th pattern.2 otherwise.2Agda0Call matrix indices = function argument indices.Machine integer ނ is sufficient, since we cannot index more arguments than we have addresses on our machine.2AgdaNon-augmented call matrix.2AgdaInsert into a call matrix set.2AgdaUnion two call matrix sets.2Agda/Convert into a list of augmented call matrices.2AgdaCall matrix multiplication.f --(m1)--> g --(m2)--> h is combined to f --(m2 2 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).2Agda%Augmented call matrix multiplication.2Agda1Call matrix set product is the Cartesian product.222222222222222222222222222222222222 Safe-Inferred#"%&'/2589:;<=2AgdaA 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.2AgdaCalls are edges in the call graph. It can be labelled with several call matrices if there are several pathes from one function to another.2AgdaCall graph nodes.Machine integer ނ is sufficient, since we cannot index more than we have addresses on our machine.2Agda!Make a call with a single matrix.2AgdaMake a call with empty cinfo.2AgdaReturns all the nodes with incoming edges. Somewhat expensive. O(e).2AgdaConverts a call graph to a list of calls with associated meta information.AgdaConverts a list of calls with associated meta information to a call graph.2Agda#Takes the union of two call graphs.2Agda!Inserts a call into a call graph.AgdaCall graph combination.Application of 2 to all pairs (c1,c2) for which " c1 = " c2.)2Agda"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.2 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.2Agda?Displays the recursion behaviour corresponding to a call graph.2Agda2 is a monoid under 2.2Agda: checks whether the call graph is completely disconnected.""2222222222222222222""22222222222 Safe-Inferred""%&'/2589:;<2Agda2TODO: This comment seems to be partly out of date.2 cs( checks if the functions represented by cs terminate. The call graph cs should have one entry (2&) 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).3AgdaA 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.22232223 Safe-Inferred!"%&'/2589:;<%3AgdaSometimes 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.3AgdaIn the lexer, regular expressions are associated with lex actions who's task it is to construct the tokens.3Agda#This is what the lexer manipulates.3AgdaFile.3AgdaCurrent position.3AgdaCurrent input.3AgdaPreviously read character.3Agda A lens for 3.3Agda,Get the previously lexed character. Same as 3. Alex needs this to be defined to handle "patterns with a left-context".3Agda,Returns the next character, and updates the 3 value.This function is not suitable for use by Alex 2, because it can return non-ASCII characters.3Agda'Returns the next byte, and updates the 3 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).3AgdaConjunction of 3s.3AgdaDisjunction of 3s.3Agda Negation of 3s.33333333333333333333333333333333333333333333 Safe-Inferred!"%&'/2589:;< 3AgdaThe LookAhead monad is basically a state monad keeping with an extra 3, wrapped around the , monad.3Agda8Throw an error message according to the supplied method.3Agda$Get the current look-ahead position.3AgdaSet the look-ahead position.3AgdaLift a computation in the , monad to the 3 monad.3AgdaLook at the next character. Fails if there are no more characters.Agda#Look at the next character. Return ! if there are no more characters.3AgdaConsume all the characters up to the current look-ahead position.3Agda-Undo look-ahead. Restores the input from the ,.3Agda!Consume the next character. Does 3 followed by 3.3AgdaDo 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.3AgdaSame as 3 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.3AgdaRun a 37 computation. The first argument is the error function. 333333333333 333333333333 Safe-Inferred!"%&'/2589:;< @ 3AgdaLex a string literal. Assumes that a double quote has been lexed.3AgdaLex 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.AgdaCustom error function.AgdaThe general function to lex a string or character literal token. The character argument is the delimiter (" for strings and ' for characters).AgdaThis is where the work happens. The string argument is an accumulating parameter for the string being lexed.AgdaA string gap consists of whitespace (possibly including line breaks) enclosed in backslashes. The gap is not part of the resulting string.AgdaLex a single character.Agda?Lex an escaped character. Assumes the backslash has been lexed.Agda$Read a number in the specified base.AgdaSame as $ but with an accumulating parameter.AgdaThe escape codes.3333 Safe-Inferred!"%&'/2589:;< 3Agda Should comment tokens be output?3Agda Should comment tokens be output?3Agda,Manually lexing a block comment. Assumes an  open comment< has been lexed. In the end the comment is discarded and 3" is called to lex a real token.3Agda Lex a hole ( {! ... !}#). Holes can be nested. Returns  .3AgdaSkip 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.3333333333 Safe-Inferred!"%&'/2589:;<3Agda 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 3 is executed, generating the closing brace. The open brace is generated when entering by 3.3AgdaThis 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 3.3AgdaThis 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.3AgdaReturn the next token. This is the function used by Happy in the parser.  lexer k = 3 >>= kAgda&Do not use this function; it sets the , to .3Agda3This is the main lexing function generated by Alex. 3333333333333 3333333333333 Safe-Inferred!"%&'/2589:;<$3AgdaAt a new line, we confirm either existing tentative layout columns, or, if the last token was a layout keyword, the expected new layout column.3Agda&This action is only executed from the 3/ state. It will exit this state, enter the 3 state, and return a virtual close brace (closing the empty layout block started by 3).3Agda ...)τAgda+Converts lambda bindings to typed bindings.ЄAgdaReturns the value of the first erasure attribute, if any, or else the default value of type .Raises warnings for all attributes except for erasure attributes, and for multiple erasure attributes.фAgdaConstructs extended lambdas.҄Agda&Constructs extended or absurd lambdas.ӄAgdaInterpret an expression as a list of names and (not parsed yet) as-patternsԄAgda0Match a pattern-matching "assignment" statement p <- eՄAgdaBuild a with-blockքAgdaBuild a with-statementׄAgdaBuild a do-statement؄AgdaExtract record directivesلAgda&Check for duplicate record directives.3AgdaBreaks 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"]ڄAgdaReturns = iff the name is a valid Haskell (hierarchical) module name.ۄAgda)Turn an expression into a left hand side.܄AgdaTurn an expression into a pattern. Fails if the expression is not a valid pattern.݄AgdaTurn an expression into a name. Fails if the expression is not a valid identifier.ބAgdaWhen given expression is e1 = e2, turn it into a named expression. Call this inside an implicit argument {e} or {{e}}, where an equality must be a named argument (rather than a cubical partial match).߄AgdaParse an attribute.Agda%Apply an attribute to thing (usually ). This will fail if one of the attributes is already set in the thing to something else than the default value.Agda#Apply attributes to thing (usually ). Expects a reversed list of attributes. This will fail if one of the attributes is already set in the thing to something else than the default value.Agda$Set the tactic attribute of a binderAgda$Get the tactic attribute if present.AgdaReport a parse error if two attributes in the list are of the same kind, thus, present conflicting information.AgdaReport an attribute as conflicting (e.g., with an already set value).AgdaReport attributes as conflicting (e.g., with each other). Precondition: List not emtpy.ЄAgda!The attributes, in reverse order.фAgda#The range of the lambda symbol and where or the braces.Agda The attributes in reverse order.AgdaThe clauses in reverse order.҄AgdaThe range of the lambda symbol.Agda!The attributes, in reverse order.Agda Catch-all?Agda Possibly empty list of patterns.333333333333339 9  Safe-Inferred!"%&'/2589:;<:u3AgdaWrapped Parser type.3Agda/A monad for handling parse errors and warnings.3AgdaRun a 3 computation, returning a list of warnings in first-to-last order and either a parse error or the parsed thing.AgdaAdd a +.AgdaEmbed a + as 3 computation.3Agda'Returns the contents of the given file.AgdaInitial state for lexing.Agda/Initial state for lexing with top-level layout.3AgdaParse without top-level layout.AgdaParse with top-level layout.AgdaParse with top-level layout.AgdaParse with top-level layout.3AgdaExtensions supported by 3.3AgdaParses a module.3AgdaParses a module name.3AgdaParses an expression.3Agda0Parses an expression followed by a where clause.3AgdaParses an expression or some other content of an interaction hole.3Agda3Gives the parsed token stream (including comments).Agda9Keep comments in the token stream generated by the lexer.AgdaDo not keep comments in the token stream generated by the lexer.AgdaName of source file.AgdaParser to use.AgdaContents of source file.Agda The file.Agda)The file contents. Note that the file is not read from disk.3Agda The file.Agda)The file contents. Note that the file is not read from disk.#+++,,,,,,,,,,,,,,,,3333333333333333#333333333333,,,,,,,,,,,,,,+++,,3333 Safe-Inferred!"%&'/2589:;<= 3Agda5Eliminations, subsuming applications and projections.3Agda Application.3Agda Projection.  is name of a record projection.3Agda'IApply x y r, x and y are the endpoints4AgdaDrop 3 constructor. (Safe)4AgdaOnly 3 variant.4AgdaDrop 3 constructors. (Safe)4AgdaSplit at first non-34Agda Discards Proj f entries.4AgdaDrop 3 constructors. (Safe)4AgdaThis instance cheats on 3, use with care. 3s are always assumed to be , since they have no . Same for IApply 3333334444444 3333444443344 Safe-Inferred!"%&'/2589:;<H4AgdaShould a constraint wake up or not? If not, we might refine the unblocker.4AgdaSomething 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).4AgdaWhat is causing the blocking? Or in other words which metas or problems need to be solved to unblock the blocked computation/constraint.4AgdaUnblock if meta is instantiated4Agda Unblock when function is defined4AgdaEven if we are not stuck on a meta during reduction we can fail to reduce a definition by pattern matching for another reason.4AgdaThe Elim' is neutral and blocks a pattern match.4AgdaA level is a maximum expression of a closed level and 0..n 54 expressions each of which is an atom plus a number.5AgdaSorts.5AgdaSet B.5AgdaProp B.5AgdaSet:.5AgdaSSet B.5AgdaSizeUniv, a sort inhabited by type Size.5AgdaLockUniv, a sort for locks.5Agda IntervalUniv+, a sort inhabited by the cubical interval.5AgdaSort of the pi type.5Agda(Sort of a (non-dependent) function type.5AgdaSort of another sort.5AgdaA postulated sort.5AgdaA (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.5AgdaSequence of types. An argument of the first type is bound in later types and so on.5Agda5 is never 5.5Agda'Types are terms with a sort annotation.5AgdaBinder.52: The bound variable might appear in the body. 5 is pseudo-binder, it does not introduce a fresh variable, similar to the const of Haskell.5Agda6The body has (at least) one free variable. Danger: 5! doesn't shift variables properly5Agda 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.5Agdax es neutral5Agda+Terms are beta normal. Relevance is ignored5Agdaf es, possibly a delta/iota-redex5Agdac es or record { fs = es } es allows only Apply and IApply eliminations, and IApply only for data constructors.5Agda)dependent or non-dependent function space6AgdaIrrelevant stuff in relevant position, but created in an irrelevant context. Basically, an internal version of the irrelevance axiom .irrAx : .A -> A.6AgdaA (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. Dummy terms should never be used in places where they can affect type checking, so syntactic checks are free to ignore the eliminators, which are only there to ease debugging when a dummy term incorrectly leaks into a relevant position.6AgdaStore the names of the record fields in the constructor. This allows reduction of projection redexes outside of TCM. For instance, during substitution and application.6AgdaThe name of the constructor.6AgdaData or record constructor?6Agda'Record constructors can be coinductive.6Agda"The name of the record fields.  is stored since the info in the constructor args might not be accurate because of subtyping (issue #2170).6AgdaType of argument lists.6Agda 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 5 of internal syntax, in Context and 5.  is used for actual arguments (5, 5, 5 etc.) and in Abstract syntax and other situations.  cubical When ,annFinite (argInfoAnnotation domInfo) = True for the domain of a 5 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.6Agdae.g. x in {x = y : A} -> B.6Agda3Is this a -type (False), or a partial type (True)?6Agda "@tactic e".6AgdaConstant level n6Agda6Make an absurd pattern with the given de Bruijn index.6AgdaBuild partial 5 from 56AgdaBuild 5 from 5.6Agda'Retrieve the PatternInfo from a pattern6Agda Retrieve the origin of a pattern6Agda1Does the pattern perform a match that could fail?6AgdaAbsurd lambdas are internally represented as identity with variable name "()".6AgdaAn unapplied variable.6AgdaAdd 6 is it is not already a DontCare.6AgdaConstruct a string representing the call-site that created the dummy thing.6Agda,Aux: A dummy term to constitute a dummy termlevel sort/type.6AgdaA dummy level to constitute a level/sort created at location. Note: use macro  DUMMY_LEVEL !6Agda5A dummy term created at location. Note: use macro  DUMMY_TERM !6Agda5A dummy sort created at location. Note: use macro  DUMMY_SORT !6Agda5A dummy type created at location. Note: use macro  DUMMY_TYPE !6AgdaContext entries without a type have this dummy type. Note: use macro  DUMMY_DOM !6AgdaGiven a constant m and level l , compute m + l6Agda)A traversal for the names in a telescope.6Agda(Convert a list telescope to a telescope.6Agda%Convert a telescope to its list form.6AgdaLens to edit a 5 as a list.6AgdaRemoving a topmost 6 constructor.6AgdaDoesn't do any reduction.6Agda>Convert top-level postfix projections into prefix projections.6AgdaConvert 3/ projection eliminations according to their  into 5 projection applications.6Agda#A view distinguishing the neutrals Var, Def, and MetaV which can be projected.6AgdaIgnores  and  and tactic.7Agda2The size of a telescope is its length (as a list).7AgdaA  clause is one with no patterns and no rhs. Should not exist in practice.5AgdaThe  PatVarName is a name suggestion.5Agda#eliminations ordered left-to-right.6Agda-Should absurd patterns count as proper match?Agda1Should projection patterns count as proper match?Agda The pattern.333333444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555566655555555666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666444444444444444444444444444444444444445555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555556665555555566666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666654 Safe-Inferred!"%&'/2589:;<8AgdaThings we can substitute for a variable. Needs to be able to represent variables, e.g. for substituting under binders.8Agda+Produce a variable without name suggestion.8Agda(Produce a variable with name suggestion.8Agda=Are we dealing with a variable? If yes, what is its index?8AgdaWe can substitute Terms for variables.88888888 Safe-Inferred!"%&'/2589:;<88888888 Safe-Inferred!"%&'/2589:;<.8Agda&Gather free variables in a collection.8AgdaThe current context.8AgdaAdditional context, e.g., whether to ignore free variables in sorts.8AgdaAre we flexible or rigid?8Agda+What is the current relevance and quantity?8Agda#Method to return a single variable.8Agda5Where should we skip sorts in free variable analysis?8Agda Do not skip.8AgdaSkip when annotation to a type.8AgdaSkip unconditionally.8AgdaKeep track of 87 for every variable, but forget the involved meta vars.8AgdaRepresentation of a variable set as map from de Bruijn indices to 8.8AgdaAny 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 8.8AgdaLaws * 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.8AgdaOccurrence of free variables is classified by several dimensions. Currently, we have 8 and .8AgdaDepending 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).8Agda7In 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.8Agda*In arguments to variables and definitions.8AgdaIn top position, or only under inductive record constructors (unit).8Agda3Under at least one and only inductive constructors.8Agda5A set of meta variables. Forms a monoid under union.8Agda8 aggregation (additive operation of the semiring). For combining occurrences of the same variable in subterms. This is a refinement of the  operation for 8 which would work if 8 did not have the 8* as an argument. Now, to aggregate two 8$ occurrences, we union the involved 8s.8Agda Unit for 8.8AgdaAbsorptive for 8.8Agda8 composition (multiplicative operation of the semiring). For accumulating the context of a variable.8 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.80 is next in strength. Destroys strong rigidity.8 is still dominant over 8.80 is the unit. It is the top (identity) context.8Agda Unit for 8.8AgdaThe absorptive element of variable occurrence under aggregation: strongly rigid, relevant.8AgdaFirst argument is the outer occurrence (context) and second is the inner. This multiplicative operation is to modify an occurrence under a context.8AgdaIgnore free variables in sorts.8AgdaThe initial context.8AgdaRun function for FreeM.8AgdaBase case: a variable.8Agda3Subtract, but return Nothing if result is negative.8AgdaGoing under a binder.8Agda Going under n binders.8Agda Changing the .8Agda Changing the .8Agda Changing the 8 context.8Agda v[args].9AgdaApply something to a bunch of arguments. Preserves blocking tags (application can never resolve blocking).9Agda Apply to some default arguments.9Agda#Apply to a single default argument.9Agda%Raise de Bruijn index, i.e. weakening9AgdaReplace de Bruijn index i by a 5 in something.9AgdaReplace what is now de Bruijn index 0, but go under n binders. %substUnder n u == subst n (raise n u).9AgdaTo replace index n by term u, do applySubst (singletonS n u).  ,  E u : A --------------------------------- ,  E singletonS || u : , A,  9AgdaSingle substitution without disturbing any deBruijn indices.  , A,  E u : A --------------------------------- , A,  E inplace || u : , A,  9Agda$Lift a substitution under k binders.9Agda   E  : ,  -------------------  E dropS ||  :  9Agda applySubst ( 9& ) v == applySubst  (applySubst  v)9Agda   E  :   E reverse vs :  ----------------------------- (treating Nothing as having any type)  E prependS vs  : ,  9Agda   E reverse vs :  -----------------------------  E parallelS vs  : ,   Note the  in , .9Agda E (strengthenS E ||) : ,9AgdaA "smart" variant of 5. If 91 is applied to a substitution with an outermost 5 constructor, then the "error message" of that constructor is discarded in favour of the  argument of this function.9AgdalookupS (listS [(x0,t0)..(xn,tn)]) xi = ti, assuming x0 < .. < xn.9Agda #, ,  E raiseFromS || || : , 9Agda/Instantiate an abstraction. Strict in the term.9AgdaInstantiate 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 9. Used in Apply.9Agda9Instantiate an abstraction that doesn't use its argument.9AgdaunderAbs 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.9AgdaunderLambdas n k a b drops n initial 5s from b, performs operation k on a and the body of b, and puts the 5 s back. a is raised correctly according to the number of abstractions.,99999999999999999999999999999999999999999999,9999999999999999999999999999999999999999999994 Safe-Inferred!"%&'/2589:;<./999:99:::::::::::::::::::::::::::::::::::::::::/::::::::::::::::::::::::::::::::::::::::999:99: Safe-Inferred!"%&'/2589:;<: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 3 patterns in a list of clauses.:AgdaGet the number of initial 3 patterns in a clause.:AgdaGet the number of initial 3 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.:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: Safe-Inferred""%&'/2589:;<: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.:::::::: Safe-Inferred!"%&'/2589:;<!;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:;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:;;;;;;;;; Safe-Inferred!"%&'/2589:;<;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.;;;;;;;;;;;;;;;; Safe-Inferred!"%&'/2589:;<;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. ;;;;;;;;;;; ;;;;;;;;;;; Safe-Inferred!"%&'/2589:;<4;AgdaSpines corresponding to < values.;AgdaRight-hand side spines.;AgdaClause spines.;AgdaDeclaration spines. Used in debugging to make it easy to see where constructors such as = and = are placed.<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<Agdais it an ordinary unnamed where?<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).<AgdaExtra information that is attached to a typed binding, that plays a role during type checking but strictly speaking is not part of the  name : type&" relation which a makes up a binding.<Agda+Does this binding have a tactic annotation?<AgdaDoes this binding correspond to a Partial binder, rather than to a Pi binder? Must be present here to be reflected into abstract syntax later (and to be printed to the user later).<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.=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 / of /. However, if you want to print an interaction meta as just ? instead of ?n, you should set the / 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.=AgdaRecord construction.=AgdaRecord update.=AgdaScope annotation.=AgdaQuote an identifier .=Agda Quote a term.=Agda#The splicing construct: unquote ...=Agda For printing DontCare from Syntax.Internal.=AgdaTypes are just expressions. Use this type synonym for hinting that an expression should be a type.=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 =.=AgdaSmart constructor for =.=Agda$The name defined by the given axiom.3Precondition: The declaration has to be a (scoped) =.=Agda5The declaration spine corresponding to a declaration.=Agda+The clause spine corresponding to a clause.=Agda=The right-hand side spine corresponding to a right-hand side.=AgdaThe spine corresponding to a < value.>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.;;;;;;;;;;<<<<<<<<<<<;;;;;;;;;<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<=========================================================================================================;;;;;;;;;;<<<<<<<<<<<;;;;;;;;;<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<========================================================================================================= Safe-Inferred!"%&'/2589:;< ?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.?AgdaCollect A.Pis.?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.!?????????????????????????????????!????????????????????????????????? Safe-Inferred!"%&'/2589:;<?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.?????? Safe-Inferred!"%&'/2589:;< ?Agda-Convert a focused lhs to spine view and back.?AgdaThe next patterns are ...(This view discards /.)?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.?AgdaCombine 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.%?????????????????????????????????????%????????????????????????????????????? Safe-Inferred&"%&')*/012589:;<#@Agda 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.@AgdaUsing IsBase we can define notions of Domains and  CoDomains. which *reduce* under positive information IsBase t ~ 'True even though the shape of t is not formally exposed@AgdaIsBase t is 'True whenever t is *not* a function space.@AgdaArrows [a1,..,an] r corresponds to a1 -> .. -> an -> r | Products [a1,..,an] corresponds to (a1, (..,( an, ())..))@Agda Version of Foldr taking a defunctionalised argument so that we can use partially applied functions.@AgdaOn Lists@Agda On Booleans@AgdaAll 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)@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ Safe-Inferred$"%&')*/12589:;<o@AgdaA known boolean is one we can obtain a singleton for. Concrete values are trivially known.@Agda"Singleton for type level booleans.@@@@@@@@@@@@@@ Safe-Inferred!"%&'/2589:;<O@AgdaLike  Bifunctor, but preserving sharing.@AgdaLike , but preserving sharing.@AgdaThe ChangeT monad transformer.@AgdaThe class of change monads.@AgdaRun a @0 computation, returning result plus change flag.AgdaRun a @% computation, but ignore change flag.@AgdaMap a @( computation (monad transformer action).@AgdaBlindly run an updater.@AgdaRun a @0 computation, returning result plus change flag.@AgdaBlindly run an updater.@AgdaMark a computation as dirty.@AgdaReplace result of updating with original input if nothing has changed.AgdaEval an updater (using @).@Agda8A mock change monad. Always assume change has happened.@Agda = sharing . updater1@Agda-Mark computation as having changed something.@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ Safe-Inferred#"%&')*/2589:;<AgdaMake a declaration private.*Andreas, 2012-11-17: Mark computation as @ if there was a declaration that could be privatized. If no privatization is taking place, we want to complain about *."Alternatively, we could only flag @6 if a non-private thing was privatized. Then, nested private+s would sometimes also be complained about.AgdaMake a declaration abstract.Mark computation as @ if there was a declaration that could be made abstract. If no abstraction is taking place, we want to complain about *."Alternatively, we could only flag @7 if a non-abstract thing was abstracted. Then, nested abstract+s would sometimes also be complained about.AgdaCheck that declarations in a mutual block are consistently equipped with MEASURE pragmas, or whether there is a NO_TERMINATION_CHECK pragma.Agda Replace (DataRecFun)Sigs with Axioms for postulated names The first argument is a list of axioms only.@AgdaMain. Fixities (or more precisely syntax declarations) are needed when grouping function clauses.@Agda(Approximately) convert a * back to a list of #s.@AgdaHas the * a field of type ?@AgdaContents of a where& clause are abstract if the parent is.Agda(Lone signatures to be turned into AxiomsAgdaDeclarations containing themAgda+In the output, everything should be defined*******************************************************************++++++++@@@***************************++++***************************************+++@@@*+  Safe-Inferred!"%&'/2589:;<mijklmnopqrstu@@@jiosumrklpnqt@ Safe-Inferred!"%&'/2589:;<%w@Agda e.g. x + 5@Agdaa number or infinity@AgdaA solution assigns to each flexible variable a size expression which is either a constant or a v + n for a rigid variable v.@Agda"A matrix with row descriptions in b and column descriptions in c.@Agda6The Graph Monad, for constructing a graph iteratively.@AgdaScope for each flexible var.@AgdaNode labels to node numbers.@AgdaNode numbers to node labels.@AgdaNumber of nodes n.@AgdaThe edges (restrict to [0..n[).@Agda%A constraint is an edge in the graph.@AgdaFor  Arc v1 k v2 at least one of v1 or v2 is a MetaV+ (Flex), the other a MetaV or a Var (Rigid). If k <= 0 this means suc^(-k) v1 <= v2 otherwise v1 <= suc^k v3.@Agda3Which rigid variables a flex may be instatiated to.AAgdaNodes 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.AAgda sizeRigid r n. returns the size expression corresponding to r + n5@@@@@@@@@@@@@@@@@@@@@@@@AAAAAAAAAAAAAAAAAAAAAAAAAAAAA5AAAAAAAAAAAAAAA@@@AA@@@@A@@@@@@@A@AAAAAA@@@@@@AA@@@AA Safe-Inferred""%&'/12589:;<&AAAAAAAAAA Safe-Inferred!"%&'/2589:;<' AAAAAAAAAA AAAAAAAAAA Safe-Inferred""%&'/2589:;<' Safe-Inferred!"%&'/2589:;<)JAAgdaThe version of Agda.AAgdaThis 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.AAgdaReturns a URL corresponding to the given section in the documentation for the current version.AAAAAA Safe-Inferred$"%&'/2589:;<)AAgda?Information about current git commit, generated at compile timeAAAA Safe-Inferred""#%&'/2589:;<@AAgdaLibrary names are structured into the base name and a suffix of version numbers, e.g.  mylib-1.2.3". The version suffix is optional.AAgdaActual library name.AAgdaMajor version, minor version, subminor version, etc., all non-negative. Note: a priori, there is no reason why the version numbers should be Ints.AAgdaRaise collected  LibErrors as exception.AgdaGet the path to ~/.agda1 (system-specific). Can be overwritten by the AGDA_DIR environment variable.(This is not to be confused with the directory for the data files that Agda needs (e.g. the primitive modules).)AAgdaReturns the absolute default lib dir. This directory is used to store the Primitive.agda file.AgdaThe ~.agda libraries file lists the libraries Agda should know about. The content of  libraries is a list of paths to  .agda-lib files."Agda honors also version-specific  libraries files, e.g. libraries-2.6.0.defaultLibraryFiles gives a list of all  libraries files Agda should process by default. The first file in this list that exists is actually used.AgdaThe  defaultsFile contains a list of library names relevant for each Agda project.AgdaThe ~.agda executables file lists the executables Agda should know about. The content of  executables# is a list of paths to executables."Agda honors also version-specific  executables files, e.g. executables-2.6.0.defaultExecutablesFiles gives a list of all  executables Agda should process by default. The first file in this list that exists is actually used.Agda!Find project root by looking for  .agda-lib files.If there are none, look in the parent directories until one is found.AAgdaGet project rootAAgdaGet the contents of  .agda-lib! files in the given project root.AAgda: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).Agda/Return list of libraries to be used by default. None if the defaults file does not exist.AgdaReturns the path of the  libraries1 file which lists the libraries Agda knows about.Note: file may not exist.%If the user specified an alternative  libraries file which does not exist, an exception is thrown containing the name of this file.AAgda9Parse the descriptions of the libraries Agda knows about.Returns none if there is no  libraries file.AgdaParse the given library files.Agda.Remove trailing white space and line comments.AgdaReturns the path of the  executables; file which lists the trusted executables Agda knows about.Note: file may not exist.AAgda0Return the trusted executables Agda knows about.Returns none if there is no  executables file.Agda Parse the  executables file.AAgda6Get all include pathes for a list of libraries to use.AgdafindLib x libs retrieves the matches for x from list libs. Case x is unversioned: If x is contained in libs, then that match is returned. Otherwise, the matches with the highest version number are returned.Case x is versioned: the matches with the highest version number are returned.Examples, see A.AAgdaGeneralized 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" ] == []Agdax  y if x and y have the same vvBase and either x5 has no version qualifier or the versions also match.AAgdaSplit 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.)AAgdaPrint a  VersionView , inverse of  versionView (modulo leading zeros).Agda2Candidate (init: the directory Agda was called in)AgdaActual root and  .agda-lib files for this projectAgda2Candidate (init: the directory Agda was called in)AgdaActual root and  .agda-lib files for this projectAAgda Project root.AgdaUse defaults if no  .agda-lib file exists for this project?Agda The returned LibNames are all non-empty strings.AgdaOverride the default  libraries file?AAgdaOverride the default  libraries file?Agda-Content of library files. (Might have empty LibNames.)AgdaName of  libraries file for error reporting.Agda/Library files paired with their line number in  libraries.Agda-Content of library files. (Might have empty LibNames.)AAgda Content of  executables files.AAgda 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.& AAAAAAAAAAAAAAA&AAAAAAA A AAAAAAA Safe-Inferred#"%&'/12589:;<[?AAgda2Descriptions of infective and coinfective options.AAgdaIs the option active?AAgdaA description of the option (typically a flag that activates the option).AAgda:Is the option (roughly speaking) infective or coinfective?AAgdaThis function returns  exactly when, from the perspective of the option in question, the options in the current module (the first argument) are compatible with the options in a given imported module (the second argument).AAgdaA warning message that should be used if this option is not used correctly. The given module name is the name of an imported module for which A failed.AAgdaInfective or coinfective?AAgdaf :: 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 recordAAgdaThe 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.AAgda%Options which can be set in a pragma.AAgdaCut 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?BAgda2Perform the forcing analysis on data constructors?BAgda6Perform the projection-likeness analysis on functions?BAgda,Mark parameters of record modules as erased?BAgda$Can rewrite rules be added and used?BAgdaShould we speculatively unify function applications as if they were injective?BAgda$Should system generated projections  ProjSystem0 be printed postfix (True) or prefix (False).BAgdaShould case splitting replace variables with dot patterns (False) or keep them as variables (True).BAgda?Should instance search consider instances with qualified names?BAgdaShould the conversion checker use the syntactic equality shortcut?  means that it should.  n, for a non-negative number n/, means that syntactic equality checking gets n units of fuel. If the fuel becomes zero, then syntactic equality checking is turned off. The fuel counter is decreased in the failure continuation of .BAgdaCount extended grapheme clusters rather than code points when generating LaTeX.BAgdaAutomatic compile-time inlining for simple definitions (unless marked NOINLINE).BAgda+Use the Agda abstract machine (fastReduce)?BAgda(Use call-by-name instead of call-by-needBAgda"Check confluence of rewrite rules?BAgda&Are the cohesion modalities available?BAgda)Can we split on a (@flat x : A) argument?BAgdaShould every top-level module start with an implicit statement ,open import Agda.Primitive using (Set; Prop)?BAgdaShould we load the primitive modules at all? This is a stronger form of B.BAgdaSave meta-variables.BAgdaShow identity substitutions when pretty-printing terms (i.e. always show all arguments of a metavariable)BAgdaDo not discard clauses constructed by the coverage checker (needed for some external backends)BAgda'The list should not contain duplicates.BAgda-Use this (if Just) instead of .agda/librariesBAgdaUse ~.agdadefaultsBAgdalook for .agda-lib filesBAgda2Map names of trusted executables to absolute pathsBAgdaAgda REPL (-I).BAgda%Exit if an interactive command fails.BAgda2In the absence of a path the project root is used.BAgdaShould the top-level module only be scope-checked, and not type-checked?BAgdaShould code points that are not supported by the locale be transliterated?BAgda is used if no verbosity options have been given, thus making it possible to handle the default case relatively quickly. Note that  corresponds to a trie with verbosity level 1 for the empty path.BAgdaMap a function over the long options. Also removes the short options. Will be used to add the plugin name to the plugin options.BAgda-Checks that the given options are consistent.BAgda x, (i=1) -> y]dAgdaA telescope split in two.dAgda;The permutation takes us from the original telescope to firstPart ++ secondPart.dAgda(Flatten telescope: ( : Tel) -> [Type ]dAgdaOrder a flattened telescope in the correct dependeny order:  -> Permutation ( -> ~)Since reorderTel tel( uses free variable analysis of type in tel, the telescope should be cd.dAgdaUnflatten: turns a flattened telescope into a proper telescope. Must be properly ordered.dAgda A variant of d; which takes the size of the last argument as an argument.dAgdaRename the variables in the telescope to the given names Precondition: size xs == size tel.dAgda(Get the suggested names from a telescopeeAgda A variant of e 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.eAgda.Split the telescope at the specified position.eAgdaPermute 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) eAgdaRecursively computes dependencies of a set of variables in a given telescope. Any dependencies outside of the telescope are ignored.eAgdaComputes 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.eAgdaSplit a telescope into the part that defines the given variables and the part that doesn't.See .eAgdaAs splitTelescope, but fails if any additional variables or reordering would be needed to make the first part well-typed.eAgdaTry 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.eAgdaTry to eta-expand one variable in the telescope (given by its de Bruijn level)eAgdatelViewUpTo n t takes off the first n function types of t. Takes off all if n < 0.eAgdatelViewUpTo' n p t takes off $t$ the first n (or arbitrary many if n < 0-) function domains as long as they satify p.eAgdatelViewUpToPath n t takes off $t$ the first n (or arbitrary many if n < 0!) function domains or Path types. telViewUpToPath n t = fst  $ telViewUpToPathBoundary'n teAgdaLike 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.eAgda8(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 ] : beAgda9(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 .eAgdateleElimsB 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 : AeAgdaReduces 5.eAgdaReduces 5.eAgdaReturns  Left (a,b) in case the type is Pi a b or  PathP b _ _. Assumes the 5 is in whnf.eAgdaAssumes 5 is in whnf.eAgdaDecomposing a function type.eAgdaIf 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.eAgdaIf 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.eAgda&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.eAgda&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.eAgdaCompute type arityeAgdaStrips all hidden and instance Pi's and return the argument telescope and head definition name, if possible.eAgda:Register the definition with the given type as an instanceeAgdaTry 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.eAgdaA set of de Bruijn indices.AgdaOriginal telescope.Agda firstPart mentions the given variables,  secondPart not.eAgdaA list of de Bruijn indicesAgdaThe telescope to splitAgda firstPart5 mentions the given variables in the given order,  secondPart contains all other variableseAgdaE Agda! E var k : A de Bruijn _level_Agda  E u : A[[[[dddddddddddddddddddddddeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeddddddddddeeeeeedddddeeee[eeeeddeeeeeeeeeeeeeeeeeeeee[[[eddddddeeee Safe-Inferred!"%&'/2589:;< TAgda8Assorted warnings and errors to be displayed to the userTAgdaClassifying warnings: some are benign, others are (non-fatal) errorsTAgda(warnings that will be turned into errorsTAgdaall warnings, including errors and benign ones Note: order of constructors is important for the derived Ord instanceTAgda2Store a warning and generate highlighting from it.TAgda Raise every WARNING_ON_USAGE connected to a name.Agda;Should we only emit a single warning with this constructor.TAgda;The only way to construct a empty WarningsAndNonFatalErrorsTAgdarunning the Parse monadTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT Safe-Inferred!"%&'/2589:;<mAgda/Report a number of names that are not in scope.mAgda.Suggest some corrections to a misspelled name.mAgdaIf there are several warnings, remove the unsolved-constraints warning in case there are no interesting constraints to list.mAgda$Turns warnings, if any, into errors.mAgdaDepending which flags are set, one may happily ignore some warnings.mAgda8Collect all warnings that have accumulated in the state.mAgda Print range?Agda Correction suggestion generator.AgdaNames that are not in scope.mAgdaNames in scope.Agda,Canonization function for similarity search.AgdaA name which is not in scope.Agda"did you mean" hint.SmmmmmmmmmmmmmmmSmmmmmmmmmmmmmmm Safe-Inferred!"%&'/2589:;<.jjooojjo Safe-Inferred#"%&'/2589:;<!YAgdaA sort can either be small (Set l, Prop l, Size, ...) or large (Set n).YAgdaPerforms void (noAbs) abstraction over telescope.YAgdaApply 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.YAgdaIf v# is a record or constructed value, canProject f v returns its field f.YAgdaEliminate a constructed term.YAgdadefApp 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.YAgda  (x:A)->B(x) Y [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.YAgdaIf permute  : [a] -> [a], then ,applySubst (renaming _ ) : Term  -> Term YAgdaIf permute  : [a] -> [a], then +applySubst (renamingR ) : Term  -> Term YAgdaThe permutation should permute the corresponding context. (right-to-left list)YAgda  projDropParsApply proj o args = K proj o `9` argsThis function is an optimization, saving us from construction lambdas we immediately remove through application.YAgdaTakes off all exposed function domains from the given type. This means that it does not reduce to expose Pi-types.YAgdatelView'UpTo n t takes off the first n exposed function types of t#. Takes off all (exposed ones) if n < 0.YAgda0Add given binding to the front of the telescope.YAgdaTurn a typed binding (x1 .. xn : A) into a telescope.YAgdaTurn a typed binding (x1 .. xn : A) into a telescope.YAgda )mkPi dom t = telePi (telFromList [dom]) tYAgda)Uses free variable analysis to introduce 5 bindings.YAgdaEverything will be an 5.YAgdaOnly abstract the visible components of the telescope, and all that bind variables. Everything will be an 5! Caution: quadratic time!YAgdaAbstract over a telescope in a term, producing lambdas. Dumb abstraction: Always produces 5, never 5.$The implementation is sound because 5 does not use 5.YAgdaGiven arguments vs : tel= (vector typing), extract their individual types. Returns Nothing is tel is not long enough.YAgdaIn compiled clauses, the variables in the clause body are relative to the pattern variables (including dot patterns) instead of the clause telescope.YAgdaunivSort' univInf s gets the next higher sort of s), if it is known (i.e. it is not just  UnivSort s).Precondition: s is reducedYAgdaReturns  Left blocker7 for unknown (blocked) sorts, and otherwise returns Right s where s! indicates the size and fibrancy.YAgdaCompute the sort of a function type from the sorts of its domain and codomain.YAgdaCompute the sort of a pi type from the sorts of its domain and codomain.YAgdaGiven two levels a and b , compute a E b" and return its canonical form.YAgdaEquality of binders relies on weakening which is a special case of renaming which is a special case of substitution.YAgda Syntactic 5 equality, ignores stuff below DontCare and sharing.YAgda Syntactic 5$ equality, ignores sort annotations.ZAgdatel 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'.ZAgda)Make sure we only drop variable patterns.555555558888999999999999999999999999999999999999999999999YYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYY55555555 Safe-Inferred!"%&'/2589:;< RAgdaGets the include directories.Precondition: B must be nonempty (i.e. Y must have run).YAgdaSets the pragma options.YAgdaSets 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 then the state is reset (partly, see Y)./An empty list of relative include directories ( []) is interpreted as ["."].YAgda+Returns the library files for a given file.YAgda-Returns the library options for a given file.YAgdaDisable display forms.YAgdaDisable display forms.YAgda#Check if display forms are enabled.YAgdaMakes 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 some other things). An empty list is interpreted as ["."].YAgdaSwitch on printing of implicit and irrelevant arguments. E.g. for reification in with-function generation. Restores all A> after completion. Thus, do not attempt to make persistent A changes in a Y bracket.YAgdaChange A* for a computation and restore afterwards.YAgda Returns the  currently in effect.YAgda%The base directory of relative paths.YAgdaThe file name.AgdaThe top-level module name.YAgdaThe file name.AgdaThe top-level module name.YAgda%The base directory of relative paths.YAgda%The base directory of relative paths.YAgdaNew include directories.Agda%The base directory of relative paths.RRYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYRYYYYYYYYYYRYYYYYYYYYYYYYYYY Safe-Inferred!"%&'/2589:;<$VAgda:Resets the non-persistent part of the type checking state.VAgda&Resets all of the type checking state. Keep only ( and backend information.VAgdaRestore &! after performing subcomputation.In contrast to , the (* info from the subcomputation is saved.VAgdaSame as V but also returns the state in which we were just before reverting it.VAgdaSame as V but keep all warnings.VAgda:Allow rolling back the state changes of a TCM computation.VAgdaA 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.)VAgda Lens for I.VAgdaGet the current scope.VAgdaSet the current scope.VAgda;Modify the current scope without updating the inverse maps.VAgdaModify the current scope.VAgda Get a part of the current scope.VAgda&Run a computation in a modified scope.VAgda#Run a computation in a local scope.VAgdaSame as V-, but discard the scope from the computation.VAgda2Discard any changes to the scope by a computation.VAgda Scope error.VAgdaDebug print the scope.VAgdaUpdate 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.VAgdaRun some computation in a different signature, restore original signature.VAgdaTries to convert a raw top-level module name to a top-level module name.VAgdaSet the top-level module. This affects the global module id of freshly generated names.VAgda1The name of the current top-level module, if any.VAgdaUse 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.VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV Safe-Inferred!"%&'/2589:;<RAgda?Debug print some lines if the verbosity level for the given B is at least B.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 B is at least B.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 v and print it.RAgda(Debug print the result of a computation.RAgdaConditionally render debug v, 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).RAgdaExpected a type to be an application of a particular datatype.CAgdaconstructor, datatypeCAgdaDatatype, constructors.CAgdaconstructor, typeCAgdaThe left hand side of a function definition has a hidden argument where a non-hidden was expected.CAgda9Expected a non-hidden function and found a hidden lambda.CAgdaA function is applied to a hidden argument where a non-hidden was expected.CAgdaA function is applied to a hidden named argument it does not have. The list contains names of possible hidden arguments at this point.CAgda0Wrong user-given relevance annotation in lambda.CAgda/Wrong user-given quantity annotation in lambda.CAgda/Wrong user-given cohesion annotation in lambda.CAgdaThe given quantity does not correspond to the expected quantity.CAgdaFailed to apply injectivity to constructor of indexed datatypeDAgda=Can't solve equation because variable occurs in (type of) lhsDAgda=Can't solve reflexive equation because --without-K is enabledDAgda?Can't solve equation because solution modality is less "usable"DAgdaError when splitting a pattern variable into possible constructor patterns.DAgdaNeither data type nor record.DAgda'Type could not be sufficiently reduced.DAgda8Data type, but in erased position. If the boolean is , then the reason for the error is that the K rule is turned off.DAgdaSplit on codata not allowed. UNUSED, but keep! -- | NoRecordConstructor Type -- ^ record type, but no constructorDAgdaCopattern split with a catchallDAgda-We do not know the target type of the clause.DAgda!Target type is not a record type.DAgdaBlocking metavariable (if any)DAgda Constructor.DAgdaContext for indices.DAgda,Inferred indices (from type of constructor).DAgda)Expected indices (from checking pattern).DAgda$Reason(s) why unification got stuck.DAgdaInformation about a mutual block which did not pass the termination checker.DAgdaThe functions which failed to check. (May not include automatically generated functions.)DAgdaThe problematic call sites.DAgdaInformation about a call.DAgda,Target function name. (Contains its range.)DAgda+To be formatted representation of the call.DAgdaLocation in the internal Agda source code location where the error raisedDAgda"Range where the warning was raisedDAgdaThe warning itselfDAgdaThe warning printed in the state and environment where it was raisedDAgda*Should the warning be affected by caching.DAgdaEach redundant field comes with a range of associated dead code.DAgdaRecord type, fields not supplied by user, non-fields but supplied. The redundant fields come with a range of associated dead code.DAgda4`UnreachableClauses f rs` means that the clauses in f' whose ranges are rs are unreachableDAgda!`CoverageIssue f pss` means that pss are not covered in fDAgdaDo not use directly with warningDAgdaDo not use directly with warningDAgdaDo not use directly with warningDAgdaIn `OldBuiltin old new`, the BUILTIN old has been replaced by newDAgdaIf the user wrote just {-# REWRITE #-}.DAgda An empty where block is dead code.DAgdaIf the user wrote something other than an unqualified name in the as clause of an import statement. The $ gives optionally extra explanation.DAgdaIf a renaming import directive introduces a name or module name clash in the exported names of a module. (See issue #4154.)DAgdaThe  'pattern'5 declaration is useless in the presence of either  coinductive or  eta-equality. Content of ! is "coinductive" or "eta", resp.DAgdaIf the user opens a module public before the module header. (See issue #2377.)DAgda Names in 5 directive that don't hide anything imported by a  directive.DAgdaAn instance was declared with an implicit argument, which means it will never actually be considered by instance search.DAgdaThe type of an instance argument doesn't end in a named or variable type, so it will never be considered by instance search.DAgdaAs InstanceWithExplicitArg, but for local bindings rather than top-level instances.DAgda&The --inversion-max-depth was reached.DAgdaA coinductive record was declared but neither --guardedness nor --sized-types is enabled.DAgda'Harmless generic warning (not an error)DAgda=Generic error which doesn't abort proceedings (not a warning)DAgda:Generic warning when code is useless and thus ignored.   is for dead code highlighting.DAgdaUnsafe OPTIONS.DAgdaETA pragma is unsafe.DAgda)`DeprecationWarning old new version`: old is deprecated, use new( instead. This will be an error in Agda version.DAgdaUser-defined warning (e.g. to mention that a name is deprecated)DAgda'Duplicate mentions of the same name in using directive(s).DAgdaFixity of modules cannot be changed via renaming (since modules have no fixity).DAgdaSome 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.DAgdaImporting a file using an infective option into one which doesn'tDAgdaImporting a file not using a coinfective option from one which doesDAgdaConfluence checker found critical pair and equality checking resulted in a type errorDAgdaConfluence checker got stuck on computing overlap between two rewrite rulesDAgda+The global confluence checker found a term u that reduces to both v1 and v22 and there is no rule to resolve the ambiguity.DAgda+The global confluence checker found a term u that reduces to v, but v does not reduce to rho(u).DAgda&COMPILE directive for an erased symbolDAgda&Out of scope error we can recover fromDAgda:Was not able to compute a full equivalence when splitting.DAgda;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.DAgdaRanges of checked arguments, where present. e.g. inserted implicits have no correponding abstract syntax.DAgda&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.EAgdaAdd implicit arguments in the end until type is no longer hidden 5.EAgda!Do not append implicit arguments.EAgdaMakes  doExpandLast have no effect. Used to avoid implicit insertion of arguments to metavariables.EAgda6Abstract things in the current module can be accessed.EAgda#No abstract things can be accessed.EAgda$All abstract things can be accessed.EAgdaThe Context is a stack of Es.EAgda=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).EAgda4anonymous modules and their number of free variablesEAgdaThe 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.EAgda!the current (if any) mutual blockEAgda/are we inside the scope of a termination pragmaEAgda,are we inside the scope of a coverage pragmaEAgdaare we inside a make-case (if so, ignore forcing analysis in unifier)EAgda>Are we currently in the process of solving active constraints?EAgdaHave we stepped into the where-declarations of a clause? Everything under a where# will be checked with this flag on.EAgda&Are we working on types? Turned on by  workOnTypes.EAgdaAre we allowed to assign metas?EAgdaWhen 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.EAgda7 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.EAgdaAre 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.EAgda+Sometimes we want to disable display forms.EAgda8Interactive highlighting uses this range rather than E.EAgdaWhat is the current clause we are type-checking? Will be recorded in interaction points in this clause.EAgdawhat we're doing at the momentEAgdaSet to E+ when imported modules are type-checked.EAgdaWhen type-checking an alias f=e, we do not want to insert hidden arguments in the end, because these will become unsolved metas.EAgdaWe are reducing an application of this function. (For tracking of incomplete matches.)EAgdaDid we encounter a simplification (proper match) during the current reduction process?EAgdaInjectivity can cause non-termination for unsolvable contraints (#431, #3067). Keep a limit on the nesting depth of injectivity uses.EAgdaWhen 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.EAgdaWhen True, types will be omitted from printed pi types if they can be inferred.EAgdaWhen 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.EAgdaUsed by the scope checker to make sure that certain forms of expressions are not used inside dot patterns: extended lambdas and let-expressions.EAgdaUntil we get a termination checker for instance search (#1743) we limit the search depth to ensure termination.EAgda#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.EAgda+Use call-by-need evaluation for reductions.EAgdaCheckpoints track the evolution of the context as we go under binders or refine it by pattern matching.EAgdaKeeps the substitution from each previous checkpoint to the current context.EAgda"Should new metas generalized over.EAgda(Values for used generalizable variables.EAgdaIs 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.EAgdaAre we currently computing the overlap between two rewrite rules for the purpose of confluence checking?EAgdaAre we currently in the process of executing an elaborate-and-give interactive command?EAgdaIf this counter is , then syntactic equality checking is unrestricted. If it is zero, then syntactic equality checking is not run at all. If it is a positive number, then syntactic equality checking is allowed to run, but the counter is decreased in the failure continuation of .EAgda Via stdout.EAgdaBoth via files and via stdout.EAgdaThis includes both non-interactive highlighting and interactive highlighting of the expression that is currently being type-checked.EAgdaBUILTIN REWRITE). We can have several rewrite relations.EAgda-Builtin of any kind. Type can be checked (Just t) or inferred (Nothing). The second argument is the hook for the verification function.EAgda2When 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.EAgdaThe instance table is a Map' associating to every name of record data typepostulate its list of instancesEAgda8Highlight (interactively) if and only if the boolean is .FAgdaChecking a clause for confluence with endpoint reductions. Always  E f vs = rhs/ for now, but we store the simplifications of f vs[] and rhs[].FAgda*Interaction command: show module contents.FAgdaused by setCurrentRangeFAgda PrimitivesFAgda Controlling reduce.FAgda:(Projection and) projection-like functions may be reduced.FAgda'Functions marked INLINE may be reduced.FAgda%Copattern definitions may be reduced.FAgda6Non-recursive functions and primitives may be reduced.FAgda(Even recursive functions may be reduced.FAgdaReduce 5 terms.FAgdaAllow  allReductions in types, even if not allowed at term level (used by confluence checker)FAgda9Functions whose termination has not (yet) been confirmed.FAgda0Functions that have failed termination checking.FAgdaThree cases: 1. not reduced, 2. reduced, but blocked, 3. reduced, not blocked.FAgdaDid 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?FAgda for primitive functions, not null for builtin functions.FAgdaBuiltin functions can have inverses. For instance, natural number addition.FAgda for primitive functions,  something for builtin functions.FAgdaNumber of parameters.FAgda+Number of arguments (excluding parameters).FAgdaName of (original) constructor and fields. (This might be in a module instance.)FAgda Name of datatype or record type.FAgdaInductive or coinductive?FAgdaCubical composition.FAgda Projections.  if not yet computed.FAgdaWhich 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.FAgdaWhich 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.FAgdaNumber of parameters.FAgdaWas this record type created by a module application? If yes, the clause is its definition (linking back to the original record type).FAgdaConstructor name and fields.FAgdaDoes this record have a  constructor?FAgdaThe record field names.FAgdaThe record field telescope. (Includes record parameters.) Note: $TelV recTel _ == telView' recConType . Thus, recTel is redundant.FAgdaMutually recursive functions, datas and record>s. Does include this record. Empty if not recursive. Nothing- if not yet computed (by positivity checker).FAgda#Eta-expand at this record type? False for unguarded recursive records and coinductive records unless the user specifies otherwise.FAgdaIn 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.FAgda or *? Matters only for recursive records.  means that the user did not specify it, which is an error for recursive records.FAgda'Just True' means that unfolding of the recursive record terminates, 'Just False' means that we have no evidence for termination, and 3 means we have not run the termination checker yet.FAgdaNumber of parameters.FAgdaNumber of indices.FAgda(This might be in an instantiated module.FAgdaConstructor names, ordered according to the order of their definition.FAgdaMutually recursive functions, datas and records. Does include this data type. Empty if not recursive. Nothing- if not yet computed (by positivity checker).FAgda"Path constructor names (subset of dataCons).FAgda