h$ * v                ! " # $ % & ' ( ) * +,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcd e f g hijklmnopqrstuvwxyz{|}~                       !!!!!!!!!!!!!!!!!!!!!!!!!!!!"###############################################################################################################################$$$$$$$$$$$$$$%%%%%%%%%%%%%%%%%%%%&&&&&&&&&&&&&&&&''''''''''''''((((((((((((((((((((((((((((((((((((())))))**+++++++++++++++++,,,,,,,,,,,,,,,,,,,,,,,,,,,,,-------------------------------------------------------------------------------------------------------..........////000000000011111111111111111111111111122222222222222222222222222222222222333333333333333333333333333333333333333333333333444445555555555555555666666666667777777777777788899999999999999999              : : : : : : : : : : : : : : : : : : : : : : : : : : : : : ; ; ; ; ; ; ; ; ; ; ; ; ; ; < < < < < < = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =                            > > > > > > > > > > > > ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ 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 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 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 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 G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G 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 HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIJJJJJJJJJJJJJJJJJJJJJJJJJJKKKKKKKKKKKKKKKKKKKKLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLMMMMMMMMMMMMMMMMMMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOOOOOOOOOOOOOOPPPPPPPPPPPPPPPPPPPPPQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTUUUUUUUUUUUUUUUUUUUUVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYZZZZZZZZZZZZZZZZZZZZ[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[\]]^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^___`aaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbcddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd d d d d d e e e e e e e e e e e e e e e e e e e e e e e e e e e e e e e e e e e e e e e e e e e e e e f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"f"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#h#h#h#h#h#h#h#h#h#h$h$h$h$h$h$h$h$h$h$h$h$h$h$h$h$h$h$h$h$h$h$h$h$h$h$h$h$h$h$h$i$i$i$i$i$i$i$i$i$i$i$i$i$i$i$i$i$i$i$i$i$i$i$i$i$i$i$i$i$i$i$i$i$i$i$i$i$i$i$i$i$i$i$i$i$i$i$i$i$i$i$i$j$j$j$j$j$j$j$j$j$j$j$j$j$j$j$j$j$j$j$j$j$j$j$j$j$j$j$j$j$j$j$j$j$j$j$j$j$j$j$j$j$j$j$j$j$j%k%k%k%k%k%k%k%k%k%k%k%k%k%k%k%k%k%k%k%k%k%k%k%k%k%k%k%k%k%k%k%k%k%k%k%k%k%k%k%l%l%l%l%l%l%l%l%l%l%l%l%l%l%l%l%l%l%l%l%l%l%l%l%l%l%l%l%l%l%l%l%m%m%m%m%m%m%m%m%m%m%m%m%m%m%m%m%m%m%m%n%n%n%n%n%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&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&q&q&q&q&q&q&q&q&q&q&q'q'q'q'q'q'q'q'q'q'q'q'q'''''''''''r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r'r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r(r)r)r)r)r)r)r)r)r)r)r)r)r)r)r)r)r)r)r)r)r)r)r)r)r)r)r)r)r)r)r)s)s)s)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t)t*t*t*t*t*t*t*t*t*t*t*t*t*t*t*t*t*t*t*t*t*t*t*t*t*t*t*t*t*t*t*t*t*t*t*t*t*t*t*t*t*t*t*u*u*u*u*u*u*u*u*u*u*u*u*u*u*u*u*u*u*u*u*u*u*u*u*u*u*u*u*u*u*u*u*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*w*w*w*w*w+w+w+w+w+w+w+w+w+w+w+w+w+w+w+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+y+y+y+y+z+z+z+z+z+z+z+z+z+z+z+z+z+z+z+z+z+z+z+z+{+{+{+{+{+{+{+{+{+{+{+{+{+{+{+|+|+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+}+~+~+~++++,,,,,,,,,,,,,,,,,,,,,,,,,,,},},~,~,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,--------------------------------------------------------------------------------------------------------------------------------................................................................................................................................////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111122222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333334444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444455555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666667777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777788888888888888888888888888888888888888888888888888888888888888888888888888 8 8888888888888888888888888888888888888888888888888888899999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::M:M:M:M:M:M:M:M:M:M:M:M:M:M:M:M:M:M:M:M:M:M:M:M:M:M:M:M:M:M:M:M:M:M:M:M:M:M:M:M:M:M:M:M:M:M:M:M:M:M:M:M:M:M:M:M:M:M:M:M:M:M:M:M:M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M;M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M<M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M=M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M>M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M?M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@M@MAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMAMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMBMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMCMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMDMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMEMFMFMFMFMFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJpJpJpJpJpJpJpJpJpJpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^________________________________________________________________________________________________________________________________````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffgggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggghhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiijjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkklllllllllllllllllllllllllllllllllllllllllllllllllllllll_l_l_l_l_l_l_l_l_l_l_l_l_l_l_l_l_l_l_l_l_l_llllllllllllllllllllllllllllllllllllllllllllllllllllmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmnnnnnnnnnnnnnnnnn`n`n`n`n`n`n`n`n`n` None #$%-25679>?-dAgdaIn f and  we want to know whether we are allowed to insert unicode characters or not.defgdefg Safe-Inferred #$%-25679>?/wAgdaBuiltins 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.hijklmnopqrstuvwxyz{|}~hijklmnopqsturvwxyz{|}~ Safe-Inferred #$%-25679>?2AgdaCut off structural order comparison at some depth in termination checker?Agdac >= 0( means: record decrease up to including c+1. Safe-Inferred #$%-25679>?5kAgda 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 ns.AgdaThe standard semiring on ns.AgdaThe standard semiring on ns.   Safe-Inferred #$%-25679>?6_AgdaA constant term.Agda,A term with one hole and the (old) contents.Agda%A term with many holes (error value). Safe-Inferred #$%-25679>?7OAgdaGuard: return the action f only if the boolean is TrueAgdaGuard: return the value a only if the boolean is True Safe-Inferred #$%-25679>?9 AgdaFinite bijective map from a to b. There, and back again.AgdaLookup. O(log n).AgdaInverse lookup. O(log n).AgdaEmpty bimap. O(1).AgdaSingleton bimap. O(1).Agda=Insert. Overwrites existing value if present. O(Map.insert).Agda Left-biased Union. O(Map.union).AgdaConstruct from a list of pairs.Does not check for actual bijectivity of constructed finite map. O(n log n)AgdaTurn into list, sorted ascendingly by first value. O(Map.toList)   Safe-Inferred #$%-25679>?:)  Safe-Inferred #$%-25679>?;AgdaError class for backward compatibility (from Control.Monad.Trans.Error in transformers 0.3.0.0).AgdaWe cannot define data constructors synonymous, so we define the  mkExceptT6 function to be used instead of the data constructor ExceptT.Agda#A string can be thrown as an error. %(&')* %*(&')None #$%-25679>?< Safe-Inferred #$%-25679>?EAgdaRepeat a state transition f :: a -> (b, a) with output b while condition cond on the output is true. Return all intermediate results and the final result where cond is False.(Postconditions (when it terminates): (fst (last (iterWhile cond f a)) == False. $all fst (init (interWhile cond f a)).AgdaRepeat something while a condition on some state is true. Return the last state (including the changes of the last transition, even if the condition became false then).AgdaMonadic version of .Agda%A version of the trampoline function.The usual function iterates f :: a -> Maybe a as long as Just{}, is returned, and returns the last value of a upon Nothing.usualTrampoline f = trampolineWhile $ a -> maybe (False,a) (True,) (f a).trampolineWhile is very similar to  repeatWhile, only that it discards the state on which the condition went False;, and returns the last state on which the condition was True.AgdaMonadic version of .AgdaMore general trampoline, which allows some final computation from iteration state a into result type b.AgdaMonadic version of .AgdaIteration to fixed-point.iterateUntil r f a0 iterates endofunction f, starting with a0 , until r( relates its result to its input, i.e., f a r a.9This is the generic pattern behind saturation algorithms.If f is monotone with regard to r , meaning a r b implies f a r f b , and f-chains starting with a09 are finite then iteration is guaranteed to terminate.*A typical instance will work on sets, and r could be set inclusion, and a0 the empty set, and f- the step function of a saturation algorithm.AgdaMonadic version of .Agda n f x applies f to x n times and returns the result.)The applications are calculated strictly.AgdaapplyWhen b f a applies f to a when b.AgdaapplyUnless b f a applies f to a unless b.AgdaMonadic version of  applyWhenAgdaMonadic version of  applyUnlessNone #$%-25679>?FAgdaSemiring with idempotent n == dioidAgdaE.g. +Agdaneutral element of compose , e.g. zero  Safe-Inferred #$%-25679>?KH Agda?A decoration is a functor that is traversable into any functor.The n 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 n6 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.  9 1 Safe-Inferred #$%-25679>?LAgda7Unstructured pragma (Andreas, 2017-08-23, issue #2712). Safe-Inferred #$%-25679>?N3AgdaCatch ns.Agda+Upon exception, the written output is lost.Agda Alias of n for the IO monad. Safe-Inferred #$%-25679>?NAgdaReturns a close function for the file together with the contents. Safe-Inferred #$%-25679>?PlAgdacopyDirContent 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.) Safe-Inferred #$%-25679>?R AgdaReads a UTF8-encoded text file and converts many character sequences which may be interpreted as line or paragraph separators into 'n'.AgdaWrites a UTF8-encoded text file. The native convention for line endings is used.AgdaWrites a UTF8-encoded text file. The native convention for line endings is used. Safe-Inferred #$%-25679>?RAgdaCreates a temporary file, writes some stuff, and returns the filepath Safe-Inferred #$%-25679>?S=AgdaRead n+, modify it strictly, and return old value. nnnnnnnnnn Safe-Inferred #$%-25679>?XAgdaMonads 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  IMPOSSIBLEAgda8Create something with a callstack's file and line numberAgda:Create something with the call site's file and line numberAgda Throw an  Impossible* error reporting the *caller's* call site.Agda Throw an  Unreachable error reporting the *caller's* call site. Note that this call to "withFileAndLine" will be filtered out due its filter on the srcLocModule.  Safe-Inferred #$%-235679>?ZAgdatoImpossible e extracts the  Impossible value raised via  IMPOSSIBLE to create the element e of type Empty. It proceeds by evaluating e to weak head normal form and catching the exception. We are forced to wrap things in a Maybe because of catchImpossible's type.! Safe-Inferred #$%-25679>?^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 #$%-25679>?_P#None #$%-25679>?cLAgdaAgsy'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.$ Safe-Inferred #$%-25679>?g AgdaRepresents a set of integers. Invariants: - All cannot be the argument to n or n - at most one  IntsBelow - at most one  IntsAbove - if `Below lo` and `Below hi`, then `lo < hi` - if `Below lo .. (Some xs)` then `all (> lo) xs` - if `Above hi .. (Some xs)` then `all (< hi - 1) xs`Agda MembershipAgdaAll integers `< n`AgdaAll integers `>= n`AgdaA single integer.Agda No integers.Agda All integers.Agda'If finite, return the list of elements.Agda Invariant.  % Safe-Inferred #$%-25679>?kH 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 #$%'(-./25679>?n 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 #$%-25679>?pAgda Content of a  .agda-lib file.Agda!The symbolic name of the library.Agda Path to this  .agda-lib file (not content of the file).Agda3Roots where to look for the modules of the library.Agda Dependencies.AgdaA symbolic library name.AgdaThe special name "." is used to indicated that the current directory should count as a project root.AgdaLenses for AgdaLibFile  ( Safe-Inferred #$%-25679>?qAgdaTokenising the input (makes  cleaner)Agda*Options for Auto, default value and lenses$$) Safe-Inferred #$%-25679>?rAgda(View source:) This is how you implement a lens for a record field.* Safe-Inferred #$%-25679>?sAgdaFilter a map based on the keys.Agda>O(n log n). Rebuilds the map from scratch. Not worse than n.+ Safe-Inferred #$%-25679>?ymAgdaRetain object when tag is n.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 = n (n p [a])Agda Version of n" with different argument ordering.Agda Version of n with different argument ordering. Often, we want to case on a n%, do something interesting in the n( case, but only a default action in the n* case. Then, the argument ordering of  caseMaybe is preferable. $caseMaybe m d f = flip (maybe d) m fAgda with flipped branches.AgdaMonadic version of n.AgdaMonadic version of n.AgdaMonadic version of . That is, $ with a different argument ordering.Agda with flipped branches.AgdaA more telling name for  for the n collection type. Or:  without the n case.Agda without the n case.Agda without the n case.Agda without the n case.AgdaLazy version of allJust  . sequence. (allJust = mapM for the Maybe/ monad.) Only executes monadic effect while isJust.nnnnnnnnnnnn, Safe-Inferred #$%-25679>?}Agda.Lazy monadic computation of a list of results.AgdaBoilerplate function to lift n through the  transformer.AgdaThe empty lazy list.AgdaConsing a value to a lazy list.AgdaSingleton lazy list.Agda Case distinction over lazy list.Agda+Folding a lazy list, effects left-to-right.Agda8Force all values in the lazy list, effects left-to-rightAgdaThe 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- Safe-Inferred #$%-25679>? AgdaThe  WarningName data enumeration is meant to have a one-to-one correspondance to existing warnings in the codebase.AgdaA  WarningMode has two components: a set of warnings to be displayed and a flag stating whether warnings should be turned into fatal errors.AgdaThe 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. Safe-Inferred #$%-25679>?AgdaInterface to the help functionAgdaGeneral usage informationAgda)Specialised usage information about TOPICAgdaUsage information generationAgdaConversion functions to strings/None #$%-25679>?Agda"Simple, non-reentrant memoisation.AgdaRecursive memoisation, second argument is the value you get on recursive calls.0None #$%-25679>?Agda/Maximum of on-negative (small) natural numbers.1 Safe-Inferred #$%-25679>?Agda Satisfying null empty == True.AgdaA n is ' when it corresponds to the empty list.  2 Safe-Inferred #$%-2356789>?2Agda Analogous to  in  Data.Maybe.Agda Analogous to  in  Data.Maybe.Agda Analogous to  in  Data.Maybe.Agda Analogous to  in  Data.Maybe.Agda unionWith for collections of size <= 1.Agda Unzipping a list of length <= 1.AgdaFiltering a singleton list. filterMaybe p a =  (n 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 n only modulo strictness. The laws only hold in the strict semantics. Eg. pure f  * pure _|_ = _|_#, but according to the laws for n it should be  pure (f _|_)3. We ignore this issue here, it applies also to n and n.3 Safe-Inferred #$%-25679>?KAgdaInclusion 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 n.Agda%Represent a non-empty disjunction of ns as .AgdaA ! information is a disjunction of n informations.AgdaAny n 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.Agdan and n _ 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.4 Safe-Inferred #$%-25679>?Agda?Completing POMonoids with inverses to form a Galois connection.Law: composition and inverse composition form a Galois connection. & related (inverseCompose p x) POLE y  == related x POLE (p <> y) AgdaPartially ordered monoid."Law: composition must be monotone.  related x POLE x' && related y POLE y' ==> related (x <> y) POLE (x' <> y') AgdaPartially ordered semigroup."Law: composition must be monotone.  related x POLE x' && related y POLE y' ==> related (x <> y) POLE (x' <> y') AgdahasLeftAdjoint x checks whether  x^-1 := x  mempty is such that x  y == x^-1 <> y for any y.5None #$%-235679>?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).6 Safe-Inferred #$%-25679>?AgdaStar semirings ( 5https://en.wikipedia.org/wiki/Semiring#Star_semirings).Agda Semirings ( &https://en.wikipedia.org/wiki/Semiring).7 Safe-Inferred #$%-25679>?98None #$%-25679>?AgdaCharacteristic identifiers.AgdaGiven a function f :: a -> NonEmpty C6 which returns a non-empty list of characteristics C of a, partition a list of as into groups such that each element in a group shares at least one characteristic with at least one other element of the group.AgdaPartition a list of a5s paired with a non-empty list of characteristics C into groups such that each element in a group shares at least one characteristic with at least one other element of the group.9 Safe-Inferred #$%-25679>?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. Safe-Inferred #$%-25679>? AgdaWhile n- 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 n when printing to world.Agda+Comma separated list, without the brackets.AgdaApply = to V if boolean is true.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 bAgda pshow = text . pretty AgdaUsed for with-like  telescopes+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWYX^]Z\[c_`ba  +,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWYX^]Z\[c_`ba6: Safe-Inferred #$%-25679>?E Agda(Documents paired with precedence levels. AgdaAn extended parser type, with some support for printing parsers. AgdaRuns the parser. Agda&Tries to print the parser, or returns n, depending on the implementation. This function might not terminate. AgdaParses a token satisfying the given predicate. The computed value is returned. AgdaUses the given function to modify the printed representation (if any) of the given parser. AgdaMemoises the given parser./Every memoised parser must be annotated with a unique key. (Parametrised parsers must use distinct keys for distinct inputs.) AgdaMemoises the given parser, but only if printing, not if parsing./Every memoised parser must be annotated with a unique key. (Parametrised parsers must use distinct keys for distinct inputs.) AgdaThe parser type.The parameters of the type Parser k r tok a have the following meanings: kType used for memoisation keys.rThe type of memoised values. (Yes, all memoised values have to have the same type.)tokThe token type.aThe result type. AgdaUses the given document as the printed representation of the given parser. The document's precedence is taken to be  . Agda.Parses a token satisfying the given predicate. AgdaParses a single token. AgdaParses a given token. AgdaPrecedence of >>=. AgdaPrecedence of  |. AgdaPrecedence of  *. AgdaPrecedence of E and +. AgdaPrecedence of atoms.  ;None #$%-235679>?$ Agda%Paths which are known to be absolute.Note that the n and n instances do not check if different paths point to the same files or directories. Agda Extract the   to be used as n. Agda Constructs  s.2Precondition: The path must be absolute and valid. AgdaMakes the path absolute.This function may raise an __IMPOSSIBLE__ error if n" does not return an absolute path. AgdaTries to establish if the two file paths point to the same file (or directory). AgdaCase-sensitive n for Windows.This is case-sensitive only on the file name part, not on the directory part. (Ideally, path components coming from module name components should be checked case-sensitively and the other path components should be checked case insensitively.)   4<None #$%-25679>? AgdaHashes a piece of n. Agda-Hashing a module name for unique identifiers.  =None #$%-25679>? Agda4The flexibe variables contained in a pice of syntax. Agda2The rigid variables contained in a pice of syntax. Agda)Make offsets non-negative by rounding up. AgdaOffsets + n must be non-negative AgdaExecuting a substitution. AgdaPartial substitution from flexible variables to size expression. Agda*Type of solution wanted for each flexible. Agda,Assigning a polarity to a flexible variable. Agda)What type of solution are we looking for? Agda= 0. AgdaDefault polarity is  . Agda?Returns an error message if we have a contradictory constraint. Agda  acts as n,   as n. Agda Interpret   as relation on  . AgdaAdd offset to size expression. AgdaComparison operator is ordered   <  .5 5 None #$%-235679>? 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).   >None #$%-25679>? Agda&Classification of identifier variants. AgdaIdentifier ends in Int many primes. AgdaIdentifier ends in number Int (ordinary digits). AgdaIdentifier ends in number Int (subscript digits). Agda3Are we allowed to use unicode supscript characters? Agda'Is the character one of the subscripts 'A'-'A'? Agda Converts '0'-'9' to 'A'-'A'-Precondition: The digit needs to be in range. Agda Converts 'A'-'A' to '0'-'9'.-Precondition: The digit needs to be in range. Agda?Increase the suffix by one. If no suffix yet, put a subscript 13 unless users do not want us to use any unicode. Agda Parse suffix. Agda Print suffix. ? Safe-Inferred #$%-25679>? 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 #$%-25679>?w AgdaFinite map from [k] to v.With the strict n type,   is also strict in v. AgdaSingleton trie. AgdaeveryPrefix k v! is a trie where every prefix of k (including k itself) is mapped to v. AgdaLeft biased union.#union = unionWith ( new old -> new). Agda/Pointwise union with merge function for values. Agda.Insert. Overwrites existing value if present. %insert = insertWith ( new old -> new) Agda6Insert with function merging new value with old value. Agda.Delete value at key, but leave subtree intact. Agda*Adjust value at key, leave subtree intact. AgdaConvert to ascending list. AgdaConvert to ascending list. AgdaConvert to list where nodes at the same level are ordered according to the given ordering. AgdaCreate new values based on the entire subtrie. Almost, but not quite comonad extend. Agda8Returns the value associated with the given key, if any. Agda%Is the given key present in the trie? Agda&Collect all values along a given path. Agda(Get the subtrie rooted at the given key. AgdaFilter a trie. Agda Key lens. Agda Empty trie.   None #$%-25679>? AgdaBifunctoriality for pairs. Agda mapFst f = f -*- id Agda mapSnd g = id -*- g AgdaLifted pairing. AgdaMonadic version of  . AgdaMonadic  . AgdaMonadic  .    2 3ANone #$%-25679>?; 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. 1. Agda5Case distinction for lists, with list first. O(1).Cf. 1. 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] = 1 AgdaTail function (safe). O(1). AgdaTail function (safe). Returns a default list on empty lists. O(1). AgdaLast element (safe). O(n). Agda"Last two elements (safe). O(n). AgdaOpposite of cons (:), safe. O(1). AgdaMaybe cons. O(1). "mcons ma as = maybeToList ma ++ as Agdan and n in one go, safe. O(n). Agdainit, safe. O(n). Agda4Lookup function (partially safe). O(min n index). AgdaLookup function with default value for index out of range. O(min n index).The name is chosen akin to . AgdaFind an element satisfying a predicate and return it with its index. O(n) in the worst case, e.g. findWithIndex f xs = Nothing.%TODO: more efficient implementation!? AgdaA generalised variant of  elemIndex. O(n). AgdadownFrom n = [n-1,..1,0] . O(n). Agda:Update the first element of a list, if it exists. O(1). Agda9Update the last element of a list, if it exists. O(n). Agda/Update nth element of a list, if it exists. O(min index n). Precondition: the index is >= 0. Agda#splitExactlyAt n xs = Just (ys, zs) iff  xs = ys ++ zs and genericLength ys = n. Agda*Drop from the end of a list. O(length). &dropEnd n = reverse . drop n . reverseForces the whole list even for n==0. AgdaSplit off the largest suffix whose elements satisfy a predicate. O(n).spanEnd p xs = (ys, zs) where  xs = ys ++ zs and all p zs and #maybe True (not . p) (lastMaybe yz). AgdaA generalized version of  takeWhile . (Cf. mapMaybe vs. filter#). @O(length . takeWhileJust f)."takeWhileJust f = fst . spanJust f. AgdaA generalized version of span. O(length . fst . spanJust f). AgdaPartition a list into ns and n s. O(n). partitionMaybe f = partitionEithers . map ( a -> maybe (Left a) Right (f a))Note: n f = snd . partitionMaybe f. AgdaLike n, but additionally return the last partition of the list where the predicate is False everywhere. O(n). AgdaLike n, but additionally return the last partition of the list where the function always returns Nothing . O(n). AgdaSublist relation. Agda7All ways of removing one element from a list. O(n). Agda6Compute the common prefix of two lists. O(min n m). AgdaDrops from both lists simultaneously until one list is empty. O(min n m). AgdaCheck if a list has a given prefix. If so, return the list minus the prefix. O(length prefix). Agda4Compute the common suffix of two lists. O(n + m). AgdastripSuffix suf xs = Just pre iff xs = pre ++ suf. O(n). Agda&stripReversedSuffix rsuf xs = Just pre iff xs = pre ++ reverse suf . O(n). Agda  f = groupBy ((n ) `on` f) n n (n `on` f). O(n log n). Agda A variant of n: which applies the predicate to consecutive pairs. O(n). AgdaSplit a list into sublists. Generalisation of the prelude function words . O(n). words xs == wordsBy isSpace xs Agda2Chop up a list in chunks of a given length. O(n). AgdaChop a list at the positions when the predicate holds. Contrary to  , consecutive separator elements will result in an empty segment in the result. O(n). *intercalate [x] (chopWhen (== x) xs) == xs AgdaCheck 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 == (n xs). Agda&Check whether a list is sorted. O(n).Assumes that the n% instance implements a partial order. AgdaCheck whether all elements in a list are distinct from each other. Assumes that the n- 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 n. 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. AgdaEfficient variant of nubBy for lists, using a set to store already seen elements. O(n log n)Specification: )nubOn f xs == 'nubBy' ((==) `'on'` f) xs. AgdaEfficient variant of nubBy for finite lists. O(n log n).Specification: For each list xs there is a list ys which is a permutation of xs such that *uniqOn f xs == 'nubBy' ((==) `'on'` f) ys. Furthermore: List.sortBy (compare `on` f) (uniqOn f xs) == uniqOn f xs uniqOn id == Set.toAscList . Set.fromList AgdaChecks if all the elements in the list are equal. Assumes that the n6 instance stands for an equivalence relation. O(n). Agda5Requires both lists to have the same length. O(n). Otherwise, Nothing is returned. AgdaLike n but keep the rest of the second list as-is (in case the second list is longer). O(n).  zipWithKeepRest f as bs == zipWith f as bs ++ drop (length as) bs AgdaImplemented using tree recursion, don't run me at home! O(3^(min n m)). Agda*Implemented using dynamic programming and  Data.Array . O(n*m). AgdaThe list after the split point. Agda The list before the split point.? ? BNone #$%-25679>? 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 n: > n $ n "\x2200" "\8704" > n $   "\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 @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ AgdaShows a non-negative integer using the characters A-A instead of 0-9 unless the user explicitly asked us to not use any unicode characters. Agda1Adds a final newline if there is not already one. Agda-Indents every line the given number of steps. Agda6Show a number using comma to separate powers of 1,000. AgdaRemove leading whitespace. AgdaRemove trailing whitespace. Agda'Remove leading and trailing whitesapce. CNone #$%-25679>?$ 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.  DNone #$%-25679>? AgdaSimple Emacs Lisp expressions. AgdaAtom. AgdaList. AgdaFormats a response command. Replaces 'n'= with spaces to ensure that each command is a single line. Agda-Writes a response command to standard output. AgdaClear the running info buffer. AgdaClear the warning buffer AgdaDisplay running information about what the type-checker is up to. ENone #$%-25679>? AgdaRemove suffix .0$ from printed floating point number.  None #$%-25679>?y Agda Loop while we have an exception. AgdaMonadic version of n$ with a different argument ordering. Agda'Either _ b' is a functor. Agda'Either a' is a functor. Agdan 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 n. 8maybeLeft (Left a) = Just a maybeLeft Right{} = Nothing AgdaSafe projection from n.  x) xs) else Nothing Agda)Groups a list into alternating chunks of n and n values AgdaConvert n to n ().    None #$%-25679>?] 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 n :: (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 n :: (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 n to . AgdaGeneralises the n& function from lists to an arbitrary . AgdaFinally for the  class. Errors in the finally part take precedence over prior errors. AgdaTry a computation, return n if an  occurs. Agda1Run a command, catch the exception and return it. 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.+  +  FNone #$%-25679>?N 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.  GNone #$%-2356789>?7 Agda=Killing the range of an object sets all range information to  . Agda;If it is also possible to set the range, this is the class.Instances should satisfy   (  r x) == r. Agda5Things that have a range are instances of this class. Agda1Wrapper to indicate that range should be printed. AgdaA range is a file name, plus a sequence of intervals, assumed to point to the given file. The intervals should be consecutive and separated.1Note the invariant which ranges have to satisfy:  . AgdaAn interval. The iEnd* position is not included in the interval.4Note the invariant which intervals have to satisfy:  . Agda Represents a point in the input.If two positions have the same   and   components, then the final two components should be the same as well, but since this can be hard to enforce the program should not rely too much on the last two components; they are mainly there to improve error messages for the user.4Note the invariant which positions have to satisfy:  . AgdaFile. AgdaPosition, counting from 1. AgdaLine number, counting from 1. AgdaColumn number, counting from 1. Agda Sets the   components of the interval. Agda Gets the   component of the interval. Because of the invariant, they are both the same. Agda6Converts a file name and two positions to an interval. AgdaThe length of an interval. AgdaThe intervals that make up the range. The intervals are consecutive and separated ( ). Agda8Turns a file name plus a list of intervals into a range.Precondition:  . AgdaAre the intervals consecutive and separated, do they all point to the same file, and do they satisfy the interval invariant? AgdaRange invariant. Agda"The file the range is pointing to. Agda%Conflate a range to its right margin. Agda*Remove ranges in keys and values of a map. Agda;The first position in a file: position 1, line 1, column 1. Agda;The first position in a file: position 1, line 1, column 1. Agda$Ranges between two unknown positions Agda?Advance the position by one character. A newline character ('n') moves the position to the first character in the next line. Any other character moves the position to the next column. Agda!Advance the position by a string.  movePosByString = foldl' movePos Agda%Backup the position by one character.(Precondition: The character must not be 'n'. Agda2Converts a file name and two positions to a range. Agda"Converts two positions to a range.;Precondition: The positions have to point to the same file. Agda0Converts a file name and an interval to a range. Agda-Converts a range to an interval, if possible. AgdaConverts a range to an interval, if possible. Note that the information about the source file is lost. Agda?Returns the shortest continuous range containing the given one. Agda0Removes gaps between intervals on the same line. Agda*The initial position in the range, if any. Agda*The initial position in the range, if any. Agda;The position after the final position in the range, if any. Agda;The position after the final position in the range, if any. Agda4Finds the least interval which covers the arguments.8Precondition: The intervals must point to the same file. AgdafuseRanges r r' unions the ranges r and r'.!Meaning it finds the least range r0 that covers r and r'.Precondition: The ranges must point to the same file (or be empty). AgdaPrecondition: The ranges must point to the same file (or be empty). Agda beginningOf r is an empty range (a single, empty interval) positioned at the beginning of r. If r" does not have a beginning, then   is returned. AgdabeginningOfFile r is an empty range (a single, empty interval) at the beginning of r's starting position's file. If there is no such position, then an empty range is returned. Agdax `withRangeOf` y sets the range of x to the range of y. Agda*Interleaves two streams of ranged elementsIt will report the conflicts as a list of conflicting pairs. In case of conflict, the element with the earliest start position is placed first. In case of a tie, the element with the earliest ending position is placed first. If both tie, the element from the first list is placed first. 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]. HNone #$%-235679>?  Agda%Things that support delayed dropping. Agda)Delayed dropping which allows undropping. Agda&Non-negative number of things to drop.AgdaWhere to drop from.Agda3Invert a Permutation on a partial finite int map. inversePermute perm f = f' such that permute perm f' = f!Example, with map represented as  [Maybe a]:  f = [Nothing, Just a, Just b ] perm = Perm 4 [3,0,2] f' = [ Just a , Nothing , Just b , Nothing ]  Zipping perm with f gives  [(0,a),(2,b)], after compression with  catMaybes. This is an IntMap9 which can easily written out into a substitution again.AgdaPartial permutations. Examples:)permute [1,2,0] [x0,x1,x2] = [x1,x2,x0] (proper permutation).&permute [1,0] [x0,x1,x2] = [x1,x0] (partial permuation).,permute [1,0,1,2] [x0,x1,x2] = [x1,x0,x1,x2]- (not a permutation because not invertible).Agda typing would be: 9Perm : {m : Nat}(n : Nat) -> Vec (Fin n) m -> Permutation m is the  of the permutation.Agda'permute [1,2,0] [x0,x1,x2] = [x1,x2,x0] More precisely, permute indices list = sublist , generates sublist from list1 by picking the elements of list as indicated by indices. *permute [1,3,0] [x0,x1,x2,x3] = [x1,x3,x0]Agda typing: ,permute (Perm {m} n is) : Vec A m -> Vec A nAgdaIdentity permutation.Agda"Restrict a permutation to work on n elements, discarding picks >=n.Agda9Pick the elements that are not picked by the permutation.AgdaliftP k takes a  Perm {m} n to a Perm {m+k} (n+k). Analogous to ?, but Permutations operate on de Bruijn LEVELS, not indices.Agda 2permute (compose p1 p2) == permute p1 . permute p2Agda invertP err p is the inverse of p) where defined, otherwise defaults to err. composeP p (invertP err p) == pAgdaTurn a possible non-surjective permutation into a surjective permutation.Agda ?permute (reverseP p) xs == reverse $ permute p $ reverse xs Example:  permute (reverseP (Perm 4 [1,3,0])) [x0,x1,x2,x3] == permute (Perm 4 $ map (3-) [0,3,1]) [x0,x1,x2,x3] == permute (Perm 4 [3,0,2]) [x0,x1,x2,x3] == [x3,x0,x2] == reverse [x2,x0,x3] == reverse $ permute (Perm 4 [1,3,0]) [x3,x2,x1,x0] == reverse $ permute (Perm 4 [1,3,0]) $ reverse [x0,x1,x2,x3] With reverseP, you can convert a permutation on de Bruijn indices to one on de Bruijn levels, and vice versa.Agda8permPicks (flipP p) = permute p (downFrom (permRange p)) or permute (flipP (Perm n xs)) [0..n-1] = permute (Perm n xs) (downFrom n)Can be use to turn a permutation from (de Bruijn) levels to levels to one from levels to indices.See .Agda expandP i n  in the domain of  replace the ith element by n elements.AgdaStable topologic sort. The first argument decides whether its first argument is an immediate parent to its second argument. AgdaPerform the dropping. Agda Drop more. AgdaPick up dropped stuff.   INone  #$%-2356789>?]tAgdaPart of a NotationAgdaArgument is the position of the hole (with binding) where the binding should occur. First range is the rhs range and second is the binder.Agda+Argument is where the expression should go.Agda"An underscore in binding position.AgdaNotation as provided by the syntax declaration.AgdaRewriteEqn' qn p e represents the rewrite and irrefutable with clauses of the LHS. qn stands for the QName of the auxiliary function generated to implement the feature p is the type of patterns e is the type of expressionsAgda  rewrite eAgda  with p <- eAgda!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_.Agda4A meta variable identifier is just a natural number.AgdaThe unique identifier of a name. Second argument is the top-level module identifier.AgdaIs this a macro definition?Agda0Is this definition eligible for instance search?Agda Range of the instance keyword.Agda"Is any element of a collection an .AgdaAbstract or concrete.AgdaAccess modifier.Agda Store the  of the private block that lead to this qualifier. This is needed for more faithful printing of declarations.AgdaFunctions can be defined in both infix and prefix style. See f.Agda"Where does a projection come from?AgdaUser wrote a prefix projection.Agda User wrote a postfix projection.Agda'Projection was generated by the system.AgdaWhere does the ConP or Con come from?Agda8Inserted by system or expanded from an implicit pattern.Agda#User wrote a constructor (pattern).AgdaUser wrote a record (pattern).Agda(Generated by interactive case splitting.AgdaString with range info.AgdaA RawName is some sort of string.AgdaThing with range info.AgdaNames in binders and arguments.AgdaOnly  arguments can have names.AgdaAccessor/editor for the  component.AgdaStandard argument names.AgdaStandard naming.Agda&Something potentially carrying a name.Agda4A function argument can be hidden and/or irrelevant.AgdaA lens to access the : attribute in data structures. Minimal implementation: getFreeVariables and mapFreeVariables or  LensArgInfo.AgdaA lens to access the : attribute in data structures. Minimal implementation:  getOrigin and  mapOrigin or  LensArgInfo.AgdaDecorating something with  information.AgdaOrigin of arguments.Agda/From the source file / user input. (Preserve!)AgdaE.g. inserted hidden arguments.Agda%Produced by the reflection machinery.Agda&Produced by an interactive case split.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.AgdaA lens to access the : attribute in data structures. Minimal implementation:  getRelevance and  mapRelevance or  LensModality.Agda:A function argument can be relevant or irrelevant. See Agda.TypeChecking.Irrelevance.Agda4The argument is (possibly) relevant at compile-time.AgdaThe argument may never flow into evaluation position. Therefore, it is irrelevant at run-time. It is treated relevantly during equality checking.Agda3The argument is irrelevant at compile- and runtime.AgdaQuantity for linearity.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.AgdaA lens to access the : attribute in data structures. Minimal implementation:  getHiding and  mapHiding or  LensArgInfo.AgdaDecorating something with  information.Agda4Used to specify whether something should be delayed.AgdaMonoidal composition of  information in some data.Agda arguments are visible.Agda and  arguments are  notVisible.Agda arguments are hidden.AgdaIgnores .Agdam  m' means that an m can be used where ever an m' is required.Agda(Multiplicative monoid (standard monoid).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.Agda# forms a pointwise additive monoid.Agda"Absorptive element under addition.AgdaEquality ignoring origin.AgdaEquality ignoring origin.Agda. forms an additive monoid with zero Quantity0.AgdaAbsorptive element is .Agdam moreUsableQuantity m' means that an m can be used where ever an m' is required.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.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 n.AgdaCompose with relevance flag from the left. This function is e.g. used to update the relevance information on pattern variables a! after a match against something rel.AgdainverseComposeRelevance r x returns the most irrelevant y such that forall x, y we have )x `moreRelevant` (r `composeRelevance` y) iff 0(r `inverseComposeRelevance` x) `moreRelevant` y (Galois connection).AgdaLeft division by a 3. Used e.g. to modify context when going into a rel argument.AgdaCombine inferred . The unit is .Agda4 forms a monoid under addition, and even a semiring.Agda"Absorptive element under addition.AgdaIrrelevant 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.Agda"Absorptive element under addition.Agdaxs `withArgsFrom` args translates xs into a list of s, using the elements in args to fill in the non- fields.5Precondition: The two lists should have equal length.Agda,Equality of argument names of things modulo   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.n 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.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.Agda% forms a semigroup under composition.AgdaMore relevant is smaller.AgdaMore relevant is smaller.Agda Continous is the unit.Agda% forms a semigroup under composition.AgdaFlatter is smaller.Agda2Order is given by implication: flatter is smaller.AgdaDominance ordering.AgdaPointwise unit.AgdaPointwise composition.AgdaRanges are not forced.Agda Default is .Agda+Semigroup computes if any of several is an .Agda(Show non-record version of this newtype.AgdaRanges are not forced.AgdaRanges are not forced.Agdanull for import directives holds when everything is imported unchanged (no names are hidden or renamed).JNone #$%&-25679>?h# Agda/Type of a literate preprocessor: Invariants:  f : Processor f pos s /= []f pos s >>= layerContent == sAgdaA list of contiguous layers.Agda9A sequence of characters in a file playing the same role.Agda Role of a character in the file.AgdaList of valid extensions for literate Agda files, and their corresponding preprocessors.If you add new extensions, remember to update test/Utils.hs so that test cases ending in the new extensions are found.AgdaReturns True& if the role corresponds to Agda code.AgdaReturns True! if the layer contains Agda code.AgdaBlanks the non-code parts of a given file, preserving positions of characters corresponding to code. This way, there is a direct correspondence between source positions and positions in the processed result.AgdaShort list of extensions for literate Agda files. For display purposes.AgdaPreprocessor for literate TeX.AgdaPreprocessor for Markdown.Agda"Preprocessor for reStructuredText.Agda$Preprocessor for Org mode documents.KNone #$%-256789>?l> 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 n, depending on the implementation. This function might not terminate.LNone #$%-2356789>?xAgda+Check whether a name is the empty name "_".AgdaNumber of holes in a $ (i.e., arity of a mixfix-operator).AgdaTop-level module names. Used in connection with the file system.&Invariant: The list must not be empty.AgdaQName is a list of namespaces and the name of the constant. For the moment assumes namespaces are just Names and not explicitly applied modules. Also assumes namespaces are generative by just using derived equality. We will have to define an equality instance to non-generative namespaces (as well as having some sort of lookup table for namespace names).AgdaA.rest.Agdax.Agda?zAgdaArbitrary JS code.%%ONone #$%-25679>?zPNone #$%-25679>?|5AgdaCheck 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.  QNone #$%-25679>?'Agda"Entry of an explicit substitution.&An explicit substitution is a list of CAction"Maybe expression": Expression or reference to meta variable.AgdaAgsy's internal syntax.AgdaLambda with hiding information.AgdaTrue8 if possibly dependent (var not known to not occur). False if non-dependent.Agda&Absurd lambda with hiding information.AgdaUnique identifier of the head.Agda'This application has been type-checked.AgdaHead.Agda Arguments.Agda"Head of application (elimination).Agda Dot pattern.AgdaConstant definitions.AgdaConstant signatures.AgdaFor debug printing.AgdaReference to the Agda constant.AgdaType of constant.AgdaConstant definition.Agda7Free vars of the module where the constant is defined..AgdaAbstraction with maybe a name.Different from Agda, where there is also info whether function is constant.AgdaThe concrete instance of the blk parameter in 8. I.e., the information passed to the search control.AgdaNat - deffreevars (to make cost of using module parameters correspond to that of hints).Agda1Size of typing context in which meta was created.Agda!Head normal form of type of meta.AgdaTrue if iota steps performed when normalising target type (used to put cost when traversing a definition by construction instantiation).Agda;Unique identifiers for variable occurrences in unification.AgdaSubstituting for a variable.AgdaFreeVars class and instancesAgda Renaming Typeclass and instancesRNone #$%-25679>?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.SNone #$%-25679>?WAgda)Typechecker drives the solution of metas.--TNone #$%-25679>?AgdaSpeculation: Type class computing the size (?) of a pattern and collecting the vars it introducesAgdaTake a list of patterns and returns (is, size, vars) where (speculation):22UNone #$%-25679>?U 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:  n .AgdaThe  invariant.AgdaThe  invariant.Agdan iff the ranges overlap.)The ranges are assumed to be well-formed.Agdan iff the range is empty.Agda(Converts a range to a list of positions.Agda/Converts several ranges to a list of positions.Agda Converts a   to a .Agda minus xs ys! computes the difference between xs and ys<: the result contains those positions which are present in xs but not in ys.*Linear in the lengths of the input ranges.VNone #$%-235679>?,Agda The result of parsing something.AgdaWarnings for parsing.Agda,Parse errors that concern a range in a file.Agda)The range of the bigger overlapping tokenAgda,Parse errors: what you get if parsing fails.Agda4Errors that arise at a specific position in the fileAgda,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 tokenAgda"The file which the error concerns.Agda Parser flags.Agda/Should comment tokens be returned by the lexer?AgdaWe need to keep track of the context to do layout. The context specifies the indentation (if any) of a layout block. See Agda.Syntax.Parser.Layout for more informaton.Agda no layoutAgdalayout at specified columnAgda: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 locationAgdaposition of last tokenAgdathe current inputAgdathe character before the inputAgdathe previous tokenAgdathe stack of layout contextsAgdathe state of the lexer (states can be nested so we need a stack)Agdaparametrization of the parserAgdaThe parse monad.Agda,Throw a parse error at the current position.AgdaConstructs the initial state of the parser. The string argument is the input string, the file path is only there because it's part of a position.AgdaThe default flags.Agda.The most general way of parsing a string. The Agda.Syntax.Parser; will define more specialised functions that supply the  and the .Agda.The even more general way of parsing a string.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 context.AgdaShould only be used at the beginning of a file. When we start parsing we should be in layout mode. Instead of forcing zero indentation we use the indentation of the first token.>>WNone #$%-235679>?"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>XNone #$%-235679>? Agda-Sections, as well as non-sectioned operators.Agda>For non-sectioned operators this should match the notation's .AgdaEffective precedence level. n for closed notations.Agdan for non-sectioned operators.Agda/All the notation information related to a name.Agda-The names the syntax and/or fixity belong to.Invariant: The set is non-empty. Every name in the list matches .Agda3Associativity and precedence (fixity) of the names.Agda!Syntax associated with the names.AgdaTrue if the notation comes from an operator (rather than a syntax declaration).AgdaClassification of notations.AgdaEx:  _bla_blub_.AgdaEx:  _bla_blub.AgdaEx:  bla_blub_.AgdaEx: bla_blub.Agda8Data type constructed in the Happy parser; converted to $ before it leaves the Happy code.Agda x -> y2; 1st argument is the bound name (unused for now).AgdaSimple named hole with hiding.AgdaIs the hole a binder?Agda2Get a flat list of identifier parts of a notation.AgdaTarget argument position of a part (Nothing if it is not a hole).AgdaIs the part a hole? WildHoles don't count since they don't correspond to anything the user writes.AgdaIs the part a normal hole?AgdaIs the part a binder?Agda?Ż 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?ZNone #$%-235679>?ƔAgdaRanges are not forced.  [None #$%-235679>?Κ 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.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.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 binding\None #$%-25679>?]None #$%-25679>?iAgdaWe lose track of @-patterns in the internal syntax. This pass puts them back.^None #$%-25679>?AgdaA misplaced end-comment "-}".aNone #$%-235679>?'AgdaLibrary Warnings.AgdaParse  .agda-lib file.Sets  name and turn mentioned include directories into absolute pathes (provided the given n is absolute).Agda+Remove leading whitespace and line comment.Agda4Break a comma-separated string. Result strings are trimmed.bNone #$%-25679>?Agda SCC DAGs.0The maps map SCC indices to and from SCCs/nodes.AgdaVarious kinds of nodes.AgdaNodes with outgoing edges.AgdaNodes with incoming edges.Agda!All nodes, with or without edges.AgdaEdges.AgdaOutgoing node.AgdaIncoming node.AgdaEdge label (weight).Agda Graph n e, is a type of directed graphs with nodes in n and edges in e.At most one edge is allowed between any two nodes. Multigraphs can be simulated by letting the edge type e be a collection type.The graphs are represented as adjacency maps (adjacency lists, but using finite maps instead of arrays and lists). This makes it possible to compute a node's outgoing edges in logarithmic time (O(log n)). However, computing the incoming edges may be more expensive.Note that neither the number of nodes nor the number of edges may exceed n :: n.AgdaForward edges.AgdaInternal invariant.AgdaIf there is an edge from s to t, then  lookup s t g is n e, where e is the edge's label. O(log n).AgdaThe graph's edges. O(n + e).Agdaneighbours u g consists of all nodes v" for which there is an edge from u to v in g-, along with the corresponding edge labels.  O(log n + |neighbours u g|).AgdaneighboursMap u g consists of all nodes v" for which there is an edge from u to v in g-, along with the corresponding edge labels. O(log n).AgdaedgesFrom g ns is a list containing all edges originating in the given nodes (i.e., all outgoing edges for the given nodes). If ns does not contain duplicates, then the resulting list does not contain duplicates. O(|ns| log |n| + |edgesFrom g ns|).Agda edgesTo g ns is a list containing all edges ending in the given nodes (i.e., all incoming edges for the given nodes). If ns does not contain duplicates, then the resulting list does not contain duplicates. O(|ns | n log n).AgdaAll self-loops.  O(n log n).Agda All nodes. O(n).AgdaNodes with outgoing edges. O(n).AgdaNodes with incoming edges. O(n + e log n).Agda Constructs a  structure. O(n + e log n).Agda*Nodes without incoming or outgoing edges. O(n + e log n).AgdaChecks whether the graph is discrete (containing no edges other than  edges). O(n + e).AgdaReturns True iff the graph is acyclic.AgdaConstructs a completely disconnected graph containing the given nodes.  O(n log n).AgdaConstructs a completely disconnected graph containing the given nodes. O(n).Agda fromEdges es$ is a graph containing the edges in es=, with the caveat that later edges overwrite earlier edges. O(|es| log n).AgdafromEdgesWith f es$ is a graph containing the edges in es. Later edges are combined with earlier edges using the supplied function. O(|es| log n).Agda"Empty graph (no nodes, no edges). O(1).Agda5A graph with two nodes and a single connecting edge. O(1).Agda Inserts an edge into the graph. O(log n).Agda Inserts an edge into the graph. O(log n).AgdainsertWith f s t new inserts an edge from s to t3 into the graph. If there is already an edge from s to t with label old6, then this edge gets replaced by an edge with label  f new old%, and otherwise the edge's label is new. O(log n).Agda A variant of . O(log n).AgdaLeft-biased union.Time complexity: See .AgdaUnion. The function is used to combine edge labels for edges that occur in both graphs (labels from the first graph are given as the first argument to the function).Time complexity:  O(nA log (nAnA + 1) + eA log eA, where nA/ is the number of nodes in the graph with the smallest number of nodes and nA0 is the number of nodes in the other graph, and eA is the number of edges in the graph with the smallest number of edges and eA+ is the number of edges in the other graph."Less complicated time complexity: O((n + e) log n (where n and e refer to the resulting graph).AgdaUnion. O((n + e) log n (where n and e refer to the resulting graph).AgdaUnion. The function is used to combine edge labels for edges that occur in several graphs. O((n + e) log n (where n and e refer to the resulting graph).Agda A variant of n< that provides extra information to the function argument. O(n + e).AgdaReverses an edge. O(1).Agda.The opposite graph (with all edges reversed). O((n + e) log n).AgdaRemoves  edges. O(n + e).AgdaremoveNodes ns g removes the nodes in ns% (and all corresponding edges) from g. O((n + e) log |ns|).AgdaremoveNode n g removes the node n% (and all corresponding edges) from g. O(n + e).AgdaremoveEdge s t g removes the edge going from s to t , if any. O(log n).Agda0Keep only the edges that satisfy the predicate. O(n + e).AgdaUnzips the graph. O(n + e).AgdacomposeWith times plus g g' finds all edges s --c_i--> t_i --d_i--> u) and constructs the result graph from !edge(s,u) = sum_i (c_i times d_i).Complexity: For each edge s --> t in g' we look up all edges starting with t in g'.>Precondition: The two graphs must have exactly the same nodes.AgdaThe graph's strongly connected components, in reverse topological order.AgdaThe graph's strongly connected components, in reverse topological order.Agda invariant.AgdaThe opposite DAG.Agda'The nodes reachable from the given SCC.AgdaConstructs a DAG containing the graph's strongly connected components.AgdaConstructs a DAG containing the graph's strongly connected components.AgdareachableFrom g n/ is a map containing all nodes reachable from n in g. For each node a simple path to the node is given, along with its length (the number of edges). The paths are as short as possible (in terms of the number of edges).Precondition: n must be a node in g<. The number of nodes in the graph must not be larger than n :: n.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 n :: n.Amortised time complexity (assuming that comparisons take constant time): O((|ns | + e) log n).Agda#walkSatisfying every some g from to% determines if there is a walk from from to to in g/, in which every edge satisfies the predicate every(, and some edge satisfies the predicate some. If there are several such walks, then a shortest one (in terms of the number of edges) is returned.Precondition: from and to must be nodes in g<. The number of nodes in the graph must not be larger than n :: n.Amortised time complexity (assuming that comparisons and the predicates take constant time to compute): O(n + e log n).AgdaTransitive closure ported from Agda.Termination.CallGraph.%Relatively efficient, see Issue 1560.Agda Version of  that produces a list of intermediate results paired to the left with a difference that lead to the new intermediat result.The last element in the list is the transitive closure, paired with the empty graph. (complete g = snd $ last $ completeIter gAgda-Computes the transitive closure of the graph.Uses the Gauss-Jordan-Floyd-Warshall-McNaughton-Yamada algorithm (as described by Russell O'Connor in "A Very General Method of Computing Shortest Paths"  'http://r6.ca/blog/20110808T035622Z.html), implemented using matrices.4The resulting graph does not contain any zero edges.This algorithm should be seen as a reference implementation. In practice ! is likely to be more efficient.Agda-Computes the transitive closure of the graph.Uses the Gauss-Jordan-Floyd-Warshall-McNaughton-Yamada algorithm (as described by Russell O'Connor in "A Very General Method of Computing Shortest Paths"  'http://r6.ca/blog/20110808T035622Z.html), implemented using , and with some shortcuts:Zero edge differences are not added to the graph, thus avoiding some zero edges.Strongly connected components are used to avoid computing some zero edges.The graph's strongly connected components (in reverse topological order) are returned along with the transitive closure.AgdaThe transitive closure. Using . NOTE: DO NOT USE () AS EDGE LABEL SINCE THIS MEANS EVERY EDGE IS CONSIDERED A ZERO EDGE AND NO NEW EDGES WILL BE ADDED! Use 'Maybe ()' instead.Agda*The graph's strongly connected components.cNone #$%&-25679>?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.dNone #$%-25679>?%AgdaThese metas are < D.Agda,Lower or upper bound for a flexible variableAgdaA graph forest.Agda Going from Lt to Le is pred , going from Le to Lt is succ.X --(R,n)--> Y means  X (R) Y + n#. [ ... if n positive and X + (-n) (R) Y if n negative. ]AgdaNodes not connected.Agda4Test for negativity, used to detect negative cycles.Agda1Compute list of edges that start in a given node.Agda/Compute list of edges that target a given node.9Note: expensive for unidirectional graph representations.Agda Set.foldl* does not exist in legacy versions of the  containers package.AgdaFloyd-Warshall algorithm.Agda5Convert a label to a weight, decrementing in case of  .AgdaSplit a list of graphs gs into those that mention node n and those that do not. If n6 is zero or infinity, we regard it as "not mentioned".AgdaAdd an edge to a graph forest. Graphs that share a node with the edge are joined.AgdaReflexive closure. Add edges 0 -> n -> n -> oo for all nodes n.Agdah  g if any edge in g between rigids and constants is implied by a corresponding edge in h", which means that the edge in g/ carries at most the information of the one in h.Application: Constraint implication: Constraints are compatible with hypotheses.Agda2Build a graph from list of simplified constraints.Agda2Build a graph from list of simplified constraints.AgdaIf we have an edge  X + n <= X (with n >= 0), we must set X = oo.Agda2Compute a lower bound for a flexible from an edge.Agda3Compute an upper bound for a flexible from an edge.Agda6Compute the lower bounds for all flexibles in a graph.Agda6Compute the upper bounds for all flexibles in a graph.Agda0Compute the bounds for all flexibles in a graph.AgdaCompute the relative minima in a set of nodes (those that do not have a predecessor in the set).AgdaCompute the relative maxima in a set of nodes (those that do not have a successor in the set).AgdaGiven source nodes n1,n2,... find all target nodes m1,m2, such that for all j, there are edges n_i --l_ij--> m_j for all i. Return these edges as a map from target notes to a list of edges. We assume the graph is reflexive-transitive.AgdaGiven target nodes m1,m2,... find all source nodes n1,n2, such that for all j, there are edges n_i --l_ij--> m_j for all i. Return these edges as a map from target notes to a list of edges. We assume the graph is reflexive-transitive.AgdaCompute the sup of two different rigids or a rigid and a constant.AgdaCompute the inf of two different rigids or a rigid and a constant.Agda$Compute the least upper bound (sup).AgdaCompute the greatest lower bound (inf) of size expressions relative to a hypotheses graph.AgdaSolve a forest of constraint graphs relative to a hypotheses graph. Concatenate individual solutions.AgdaCheck that after substitution of the solution, constraints are implied by hypotheses.Agda1Iterate solver until no more metas can be solved.This might trigger a (wanted) error on the second iteration (see Issue 2096) which would otherwise go unnoticed.AgdaPartial implementation of Num.Agda$An edge is negative if its label is.Agda A graph is  if it contains a negative loop (diagonal edge). Makes sense on transitive graphs.Agda;Meta variable polarities (prefer lower or upper solution?).AgdaHypotheses (assumed to have no metas, so, fixed during iteration).AgdaConstraints to solve.Agda7Previous substitution (already applied to constraints).AgdaAccumulated substition.eNone #$%-235679>?H 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, n  w n bound iff n [ n every w n n some w | (every, some) <- ess ]. Agda+productOfEdgesInBoundedWalk occ g u v bound returns a value distinct from n iff there is a walk c (a list of edges) in g, from u to v, for which the product n  (n occ c) n bound&. In this case the returned value is n (n  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.  fNone #$%-235679>?