h&zL Ί      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                !!"#######$%%%%%%%%%%%%%%%%%%%&&&&&&&'''''''''''''''''''''''''''''(((((((((((((((((((((((((((()))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))**************+++++++++++++++++++++,,,,,,,,,,,,,,,,-------------------------------------......///000000000000000000011112222222222333333333333333333333333333333333333444444444444455555555555555555555555555555555555555555555555566666777777777777778888888888899999999999999999 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 : : : : ; ; ; ; ; ; ; ; ; ; ; < < < < < < < < < < < < < < < < < < < < = = = = = = = = = = = = = = = = = = = = = = = = = = > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > ? ? ? ? ? ? ? ? ? ? ? ?                                                        @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ A A A A A A A A A A A A A A A A A A A A A A A A A A A A B B B B B B B B B B B B B B B B B B B B B B B C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C                                        D D D D D D D D D D D D D D D D D D D D D D D D D D D D D D D D E E E E E E E E E E E E E E E 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 H H H H H H H H H H H H H H H H H H H H H H H I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I I IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIJJJJJJJJJJJJJJKKKKKKKKKKKKKKKKKKKKKKK          LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOOOOOOOOOOOOPPPPPPPPPPPPPPPPPPPPPPPPPPPPPQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQRSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVWWWWWWWWWWWWWWWWWWWWWWWWXXXXYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYZZZZZZZZZZZZZ[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[\\\\\\\\\\\\\\\\\\\\\\\\\\]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]^^^^^^^^^^^^^^^^^^^^_____________________________________________________________________________________________________``````````````````````````````````````````````````````````````````````````````aaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d!d!d!d!d!d!d!d!d!d!d!d!d!d!d!d!d!d!d!e!e!e!e!e!e!e!e!e!e!e!e!e!e!e!e!e!e!e!e!e!e!e!e!e!e!e!e!e!e!e!e!e!e!e!e!e!e!e!e!e!e!e!e!e!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f"f"f"f"f"f"f"f"f"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g"g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g#g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g$g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g%g&g&g&g&g&g&g&g&g&g&g&g&g&g&g&g&g&g&g&g&g&g&g&g&g&g&g&g&g&g&g&g&g&g&g&g&g&g&g&g&g&g&g&g&g&g&g&g&g&g&g&g&g&g&g&g&g&g&g&g&g&g&g&g&g&g&g&g&g&g&g&g&g&g&g&g&g&g&h&h&h&h&h&h&h&h&h&h&h&h&h&h&h&h&h&h&h&h&h&h&h&h&h&h&h&h&h&h&h&h&h&h&h&h&h&h&h&h&h&h&h&h&h&h&h&h&h&h&h'h'h'h'h'h'h'h'h'h'h'h'h'h'h'h'h'h'h'h'h'h'h'h'h'h'h'h'h'h'h'h'h'h'h'h'h'h'h'h'h'h'h'h'h'h'h'h'h'h'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'j'j'j'j'j'k(k(k(k(k(k(k(k(k(k(k(k(k(k(k(k(k(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l(l)l)l)l)l)l)l)l)l)l)l)l)l)l)l)l)l)l)l)l)l)l)l)l)l)l)l)l)l)l)l)l)l)m)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*o*o*o*o*o*o*o*o*o*o*o*o*o*o*o*o*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p*p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p-p-p-p-p-p-p-p-p-p-p-p-p-p-p-p-p-p-q-q-q-q-q-q-q-q-q-q-q-q-q-q-q-q-q-q-q-q-q-q-q-q-q-q-q-q-q-r-r-r-r-r-r-r-r-r-r-r-r-r-r-r-r-r-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s.s.s.s.s.s.s.s.s.s.s.s.s.s.s.s.s.s.s.s.s.s.s.s.s.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.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/w/w/w/w/w/w/w/w/w/w/w/w/w/w/w/w/w/w/w/w/w/w/w/w/w/w/w/w/w/w/w/w/w/w/w/w/w/w/w/w/w/w/w/w/w/w/w/w/w/w/w/w/w/w/w/w/w/w/w/w/w/w/w/w/w/w/w/w/w/w/w/w/w/w/w/x/x/x/x/x/x/x/x/x/x/x/x/x/x/x/x/x/x/x/x/x/x/x/x/x/x/x/x/x/x/x/x/x/x/x/x/x/x/x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x0x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x1x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x3x3x3x3x3x3x3x3x3x3x3x3x3x3x3x3x3y3y3y3y3y3y3y3y3y3z3z3z3z3z3z3z3z3z3z3z3z3z3z3z3z3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{3{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4{4|4|4|4|4|4|4|4|4|4|4|4|4|4|4|4|4|4|4|4|4|4|4|4|4|4|4|4|4|4|4|4|4|4|4|4|4|4|4|4|4|4|4|4|4|4|4|4|4|4|4|4|4|4|4}4}4}4}4}4}4}4}4}4}4}4}4}4}4}4}4}4}4}4}4}4}4}4}4}4}4}4}4}4}4}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5}5~5~5~5~5~5~5~5~5~5~5~5~5~5~5~5~5~5~5~5~5~5~5~5~5~5~5~55555555555555555555555555555555555555555555555555555555555555555555555555555555566666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777778888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888899999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<================================================================================================================================>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF F FFFFFFGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIJJJJJJJJJJJJJJJJJJJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrKrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrLrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrMrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrNrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrOrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrPrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrQrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrRrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrTrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrUrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrVrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrWrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrXrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrYrZrZrZrZrZrZrZrZrZrZrZrZrZrZrZrZrZrZrZrZrZrZrZrZrZrZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^________________________________________________________________________________________________________________________________````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffgggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggghhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiijjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~€ÀĀŀƀǀȀɀʀˀ̀̀΀πЀрҀӀԀՀր׀؀ـڀۀ܀݀ހ߀ÁāŁƁǁȁɁʁˁ́́΁ρЁсҁӁԁՁցׁ؁فځہ܁݁ށ߁‚ÂĂłƂǂȂɂʂ˂̂͂΂ςЂт҂ӂԂՂւׂ؂قڂۂ܂݂ނ߂ƒÃăŃƃǃȃɃʃ˃̃̓΃σЃу҃ӃԃՃփ׃؃كڃۃ܃݃ރ߃„ÄĄńƄDŽȄɄʄ˄̄̈́΄τЄф҄ӄԄՄքׄ؄لڄۄ܄݄ބ߄…ÅąŅƅDžȅɅʅ˅̅ͅ΅υЅх҅ӅԅՅօׅ؅مڅۅ܅݅ޅ߅†ÆĆņƆdžȆɆʆˆ̆͆ΆφІц҆ӆԆՆֆ׆؆نچۆ܆݆ކ߆‡ÇćŇƇLJȇɇʇˇ͇̇·χЇч҇ӇԇՇևׇ؇هڇۇ܇݇އ߇ˆÈĈňƈLjȈɈʈˈ͈̈ΈψЈш҈ӈԈՈֈ׈؈وڈۈ܈݈ވ߈‰ÉĉʼnƉljȉɉʉˉ͉̉ΉωЉщ҉ӉԉՉ։׉؉ىډۉ܉݉މ߉ŠÊĊŊƊNJȊɊʊˊ̊͊  Safe-Inferred#"%&'-/2589:;= 0( means: record decrease up to including c+1.AgdaThe default termination depth. Safe-Inferred#"%&'-/2589:; (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  applyUnlessAgdaي version of .Agdaي version of . Safe-Inferred#"%&'-/2589:; lo) xs` - if `Above hi .. (Some xs)` then `all (< hi - 1) xs`Agda MembershipAgdaAll integers `< n`AgdaAll integers `>= n`AgdaA single integer.AgdaFrom a list of integers.Agda No integers.Agda All integers.Agda'If finite, return the list of elements.Agda Invariant.  + Safe-Inferred#"%&'-/2589:; i'.AgdaGet inner part i of structure o as designated by  Lens' o i.AgdaSet inner part i of structure o as designated by  Lens' o i.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.Agda"Access a map value at a given key.Agda Focus on given element in a set.84444, Safe-Inferred'"%&')*-/012589:;If you have an index you can get a lens for the given element.Agda)Looking up an element in an indexed list.Agda!All indices into an indexed list.- Safe-Inferred#"%&'-/2589:; 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.7 Safe-Inferred#"%&'-/2589:; NonEmpty c9 which returns a non-empty list of characteristics of a, partition a list of as into groups such that each element in a group shares at least one characteristic with at least one other element of the group. AgdaPartition a list of as paired with a non-empty list of characteristics into groups such that each element in a group shares at least one characteristic with at least one other element of the group.Agda:Lift a function on non-empty lists to a function on lists. Duplicate of . AgdaGiven a function f :: a -> NonEmpty c9 which returns a non-empty list of characteristics of a , partition a non-empty 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 non-empty list of as paired with a non-empty list of characteristics into groups such that each element in a group shares at least one characteristic with at least one other element of the group.  ; Safe-Inferred#"%&'-/2589:; new). Agda/Pointwise union with merge function for values. Agda.Insert. Overwrites existing value if present. %insert = insertWith ( new old -> new) Agda6Insert with function merging new value with old value. Agda.Delete value at key, but leave subtree intact. Agda*Adjust value at key, leave subtree intact. AgdaConvert to ascending list. AgdaConvert to ascending list. AgdaConvert to list where nodes at the same level are ordered according to the given ordering. AgdaCreate new values based on the entire subtrie. Almost, but not quite comonad extend. Agda8Returns the value associated with the given key, if any. Agda%Is the given key present in the trie? Agda&Collect all values along a given path. Agda(Get the subtrie rooted at the given key. AgdaFilter a trie. Agda Key lens. Agda Empty trie.    Safe-Inferred#"%&'-/2589:; Safe-Inferred#"%&'-/2589:;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). AgdaLast element (safe). Returns a default list on empty lists. O(n). Agda3Last element of non-empty list (safe). O(n). last1 a as = last (a : as) Agda"Last two elements (safe). O(n). Agda last2' x y zs# computes the last two elements of x:y:zs . O(n). AgdaOpposite of cons (:), safe. O(1). AgdaMaybe cons. O(1). "mcons ma as = maybeToList ma ++ as Agda and  in one go, safe. O(n). Agda and & of non-empty list, safe. O(n). *initLast1 a as = (init (a:as), last (a:as) Agda& of non-empty list, safe. O(n). init1 a as = init (a:as) Agdainit, safe. O(n). Agdainit, safe. O(n). Agda*Lookup function (safe). O(min n index). Agda A variant of  that might provide more informative error messages if the index is out of bounds.4Precondition: The index should not be out of bounds. AgdaLookup function with default value for index out of range. O(min n index).The name is chosen akin to . AgdaFind an element satisfying a predicate and return it with its index. O(n) in the worst case, e.g. findWithIndex f xs = Nothing.%TODO: more efficient implementation!? AgdaA generalised variant of  elemIndex. O(n). AgdadownFrom n = [n-1,..1,0] . O(n). Agda:Update the first element of a list, if it exists. O(1). Agda9Update the last element of a list, if it exists. O(n). Agda/Update nth element of a list, if it exists. O(min index n). Precondition: the index is >= 0. Agda#splitExactlyAt n xs = Just (ys, zs) iff  xs = ys ++ zs and genericLength ys = n. Agda*Drop from the end of a list. O(length). &dropEnd n = reverse . drop n . reverseForces the whole list even for n==0. AgdaSplit off the largest suffix whose elements satisfy a predicate. O(n).spanEnd p xs = (ys, zs) where  xs = ys ++ zs and all p zs and #maybe True (not . p) (lastMaybe yz). AgdaBreaks a list just after1 an element satisfying the predicate is found. breakAfter1 even 1 [3,5,2,4,7,8](1 :| [3,5,2],[4,7,8]) AgdaBreaks a list just after1 an element satisfying the predicate is found.breakAfter even [1,3,5,2,4,7,8]([1,3,5,2],[4,7,8]) AgdaA generalized version of  takeWhile . (Cf. mapMaybe vs. filter#). @O(length . takeWhileJust f)."takeWhileJust f = fst . spanJust f. AgdaA generalized version of span. O(length . fst . spanJust f). AgdaPartition a list into s and  s. O(n). partitionMaybe f = partitionEithers . map ( a -> maybe (Left a) Right (f a))Note:  f = snd . partitionMaybe f. AgdaLike , but additionally return the last partition of the list where the predicate is False everywhere. O(n). AgdaLike , but additionally return the last partition of the list where the function always returns Nothing . O(n). AgdaSublist relation. Agda7All ways of removing one element from a list. O(n). Agda6Compute the common prefix of two lists. O(min n m). AgdaDrops from both lists simultaneously until one list is empty. O(min n m). AgdaCheck if a list has a given prefix. If so, return the list minus the prefix. O(length prefix). Agda4Compute the common suffix of two lists. O(n + m). AgdastripSuffix suf xs = Just pre iff xs = pre ++ suf. O(n). Agda&stripReversedSuffix rsuf xs = Just pre iff xs = pre ++ reverse suf . O(n). AgdaReturns a list with one boolean for each non-empty suffix of the list, starting with the longest suffix (the entire list). Each boolean is  exactly when every element in the corresponding suffix satisfies the predicate. An example:     AbCde( = [False, False, False, True, True] For total predicates p and finite and total lists xs the following holds:    p xs =  ( p) ( ( xs)) Agda,Find the longest suffix of the first string xs* that is a prefix of the second string ys. So, basically, find the overlap where the strings can be glued together. Returns the index where the overlap starts and the length of the overlap. The length of the overlap plus the index is the length of the first string. Note that in the worst case, the empty overlap  (length xs,0) is returned.)Worst-case time complexity is quadratic:  O(min(n,m)) where  n = length xs and  m = length ys.There might be asymptotically better implementations following Knuth-Morris-Pratt (KMP), but for rather short lists this is good enough. Agda2Chop up a list in chunks of a given length. O(n). AgdaChop a list at the positions when the predicate holds. Contrary to wordsBy, consecutive separator elements will result in an empty segment in the result. O(n). *intercalate [x] (chopWhen (== x) xs) == 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 == ( xs). Agda&Check whether a list is sorted. O(n).Assumes that the % instance implements a partial order. AgdaCheck whether all consecutive elements of a list satisfy the given relation. O(n). AgdaCheck whether all elements in a list are distinct from each other. Assumes that the - instance stands for an equivalence relation.O(n) in the worst case distinct xs == True. AgdaAn optimised version of  . O(n log n)./Precondition: The list's length must fit in an ϊ. AgdaReturns an (arbitrary) representative for each list element that occurs more than once. O(n log n). AgdaRemove the first representative for each list element. Thus, returns all duplicate copies. O(n log n).&allDuplicates xs == sort $ xs \ nub xs. AgdaPartition a list into first and later occurrences of elements (modulo some quotient given by a representation function).Time: O(n log n).Specification: nubAndDuplicatesOn f xs = (ys, xs List.\\ ys) where ys = nubOn f 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. Agda A variant of   that is parametrised by a function that is used to select which element from a group of equal elements that is returned. The returned elements keep the order that they had in the input list.. A variant of : which applies the predicate to consecutive pairs. O(n). Agda  $  "\x2200" "\8704" >  $   "\x2200" "D" (The code examples above have been tested using version 4.2.0.0 of the base library.) AgdaTurns the string into a Haskell string literal, avoiding escape codes. Agda$Adds hyphens around the given stringputStrLn $ delimiter "Title"<@@@@ Title @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ Agda1Adds a final newline if there is not already one. Agda-Indents every line the given number of steps. Agda, but remove empty words first. Agda6Show a number using comma to separate powers of 1,000. AgdaRemove leading whitespace. AgdaRemove trailing whitespace. Agda'Remove leading and trailing whitesapce.  Safe-Inferred#"%&'-/2589:;= 1 etc. Use   instead.See  https://wiki.haskell.org/Haskell_programming_tips#Don.27t_ask_for_the_length_of_a_list_when_you_don.27t_need_it . Agda*Lazily compute a (possibly infinite) size.1Use when comparing a size against a fixed number. AgdaCache the size of an object. AgdaReturn the cached size.  @ Safe-Inferred#"%&'-/2589:; Vec (Fin n) m -> Permutation m is the   of the permutation. Agda'permute [1,2,0] [x0,x1,x2] = [x1,x2,x0] More precisely, permute indices list = sublist , generates sublist from list1 by picking the elements of list as indicated by indices. *permute [1,3,0] [x0,x1,x2,x3] = [x1,x3,x0]Agda typing: ,permute (Perm {m} n is) : Vec A m -> Vec A nPrecondition for   (  _ is) xs: Every index in is must be non-negative and, if xs is finite, then every index must also be smaller than the length of xs.The implementation is supposed to be extensionally equal to the following one (if different exceptions are identified), but in some cases more efficient:  permute (  _ is) xs =  (xs >) is AgdaIdentity permutation. Agda"Restrict a permutation to work on n elements, discarding picks >=n. Agda9Pick the elements that are not picked by the permutation. AgdaliftP k takes a  Perm {m} n to a Perm {m+k} (n+k). Analogous to ?, but Permutations operate on de Bruijn LEVELS, not indices. Agda 2permute (compose p1 p2) == permute p1 . permute p2 Agda invertP err p is the inverse of p) where defined, otherwise defaults to err. composeP p (invertP err p) == p AgdaTurn a possible non-surjective permutation into a surjective permutation. Agda ?permute (reverseP p) xs == reverse $ permute p $ reverse xs Example:  permute (reverseP (Perm 4 [1,3,0])) [x0,x1,x2,x3] == permute (Perm 4 $ map (3-) [0,3,1]) [x0,x1,x2,x3] == permute (Perm 4 [3,0,2]) [x0,x1,x2,x3] == [x3,x0,x2] == reverse [x2,x0,x3] == reverse $ permute (Perm 4 [1,3,0]) [x3,x2,x1,x0] == reverse $ permute (Perm 4 [1,3,0]) $ reverse [x0,x1,x2,x3] With reverseP, you can convert a permutation on de Bruijn indices to one on de Bruijn levels, and vice versa. Agda8permPicks (flipP p) = permute p (downFrom (permRange p)) or permute (flipP (Perm n xs)) [0..n-1] = permute (Perm n xs) (downFrom n)Can be use to turn a permutation from (de Bruijn) levels to levels to one from levels to indices.See . Agda expandP i n  in the domain of  replace the ith element by n elements. AgdaStable topologic sort. The first argument decides whether its first argument is an immediate parent to its second argument. AgdaPerform the dropping. Agda Drop more. AgdaPick up dropped stuff.  A Safe-Inferred#"%&'-/2589:;= 4.10.0.0 already present in . Agda Analogue of . Agda Analogue of . Agda Analogue of 0. Agda Analogue of 0. AgdaSafe projection from . 8maybeLeft (Left a) = Just a maybeLeft Right{} = Nothing AgdaSafe projection from .  x) xs) else Nothing Agda)Groups a list into alternating chunks of  and  values AgdaConvert ي to  e, given an error e for the  case. Agda Swap tags  and .    Safe-Inferred#"%&'-/2589:; truth values. Returns the last error message if all fail. AgdaLazy monadic disjunction with accumulation of errors in a monoid. Errors are discarded if we succeed. AgdaGeneralized version of 8traverse_ :: Applicative m => (a -> m ()) -> [a] -> m () Executes effects and collects results in left-to-right order. Works best with left-associative monoids.!Note that there is an alternative !mapM' f t = foldr mappend mempty  $ mapM f tthat collects results in right-to-left order (effects still left-to-right). It might be preferable for right associative monoids. AgdaGeneralized version of 3for_ :: Applicative m => [a] -> (a -> m ()) -> m () AgdaA monadic version of  :: (a -> Maybe b) -> [a] -> [b]. Agda A version of  ' with a computation for the input list. AgdaThe for version of  . AgdaThe for version of  . AgdaA monadic version of  :: (a -> Bool) -> [a] -> [a]. AgdaA monadic version of  dropWhileEnd :: (a -> Bool) -> [a] -> m [a]:. Effects happen starting at the end of the list until p becomes false. AgdaA `monadic' version of @ partition# :: (a -> Bool) -> [a] -> ([a],[a]) Agda Translates ي to . AgdaGeneralises the & function from lists to an arbitrary . Agda"Branch over elements of a monadic Ҋ data structure. AgdaFinally for the Error class. Errors in the finally part take precedence over prior errors. AgdaTry a computation, return  if an Error occurs. Agda1Run a command, catch the exception and return it. AgdaLike -, but raise given error when condition fails. Agda;Bracket without failure. Typically used to preserve state. Agda Restore state after computation. AgdaOutput a single value. AgdaAcquires resource. Run first.AgdaReleases resource. Run last.Agda Computes result. Run in-between./  /  D Safe-Inferred$"%&'-/2589:;The values, ordered according to the corresponding keys. O(n). AgdaConversion from two lists that contain distinct keys/tags, with the keys/tags in ascending order. O(n).Precondition: See  . AgdaGenerates input suitable for  . O(n).' ' H Safe-Inferred#"%&'-/2589:; Maybe v. First time:  O(n log n) in the worst case.Subsequently: O(log n).Specification:  apply m == ( m).Agda9O(n). Get the domain (list of keys) of the finite map.AgdaO(1). Add a new binding. Assumes the binding is not yet in the list.AgdaO(n). Update the value at a key. The key must be in the domain of the finite map. Otherwise, an internal error is raised.AgdaO(n). Delete a binding. The key must be in the domain of the finite map. Otherwise, an internal error is raised.AgdaO(n). Update the value at a key with a certain function. The key must be in the domain of the finite map. Otherwise, an internal error is raised.Agda b. It is defined as a type class rather than by recursion on a singleton for as so all of that these conversions are inlined at compile time for concrete arguments.AgdaUsing IsBase we can define notions of Domains and  CoDomains. which *reduce* under positive information IsBase t ~ 'True even though the shape of t is not formally exposedAgdaIsBase t is 'True whenever t is *not* a function space.AgdaArrows [a1,..,an] r corresponds to a1 -> .. -> an -> r | Products [a1,..,an] corresponds to (a1, (..,( an, ())..))Agda Version of Foldr taking a defunctionalised argument so that we can use partially applied functions.AgdaOn ListsAgda On BooleansAgdaAll p as ensures that the constraint p is satisfied by all the types in as. (Types is between scare-quotes here because the code is actually kind polymorphic)M Safe-Inferred%"%&'-/12589:;This '(TopLevelModuleName' Range)' should not contain a range.Agda Represents a point in the input.If two positions have the same  and  components, then the final two components should be the same as well, but since this can be hard to enforce the program should not rely too much on the last two components; they are mainly there to improve error messages for the user.4Note the invariant which positions have to satisfy: .AgdaFile.AgdaPosition, counting from 1.AgdaLine number, counting from 1.AgdaColumn number, counting from 1.AgdaA smart constructor for .Agda Sets the  components of the interval.Agda Gets the  component of the interval. Because of the invariant, they are both the same.Agda6Converts a file name and two positions to an interval.AgdaThe length of an interval.AgdaThe intervals that make up the range. The intervals are consecutive and separated ().Agda8Turns a file name plus a list of intervals into a range.Precondition: .AgdaAre the intervals consecutive and separated, do they all point to the same file, and do they satisfy the interval invariant?AgdaRange invariant.Agda"The file the range is pointing to.Agda*The range's top-level module name, if any.If there is no range, then ? is returned. If there is a range without a module name, then   is returned.Agda*The range's top-level module name, if any.Agda%Conflate a range to its right margin.Agda*Remove ranges in keys and values of a map.Agda;The first position in a file: position 1, line 1, column 1.Agda;The first position in a file: position 1, line 1, column 1.Agda$Ranges between two unknown positionsAgda?Advance the position by one character. A newline character ('n') moves the position to the first character in the next line. Any other character moves the position to the next column.Agda!Advance the position by a string.  movePosByString = foldl' movePosAgda%Backup the position by one character.(Precondition: The character must not be 'n'.Agda2Converts a file name and two positions to a range.Agda"Converts two positions to a range.;Precondition: The positions have to point to the same file.Agda0Converts a file name and an interval to a range.Agda-Converts a range to an interval, if possible.AgdaConverts a range to an interval, if possible. Note that the information about the source file is lost.Agda?Returns the shortest continuous range containing the given one.Agda0Removes gaps between intervals on the same line.Agda*The initial position in the range, if any.Agda*The initial position in the range, if any.Agda;The position after the final position in the range, if any.Agda;The position after the final position in the range, if any.Agda4Finds the least interval which covers the arguments.8Precondition: The intervals must point to the same file.AgdafuseRanges r r' unions the ranges r and r'.!Meaning it finds the least range r0 that covers r and r'.Precondition: The ranges must point to the same file (or be empty).AgdaPrecondition: The ranges must point to the same file (or be empty).Agda beginningOf r is an empty range (a single, empty interval) positioned at the beginning of r. If r" does not have a beginning, then  is returned.AgdabeginningOfFile r is an empty range (a single, empty interval) at the beginning of r's starting position's file. If there is no such position, then an empty range is returned.Agdax `withRangeOf` y sets the range of x to the range of y.Agda*Interleaves two streams of ranged elementsIt will report the conflicts as a list of conflicting pairs. In case of conflict, the element with the earliest start position is placed first. In case of a tie, the element with the earliest ending position is placed first. If both tie, the element from the first list is placed first.Agda Only the  component is compared.Agda Only the  component is compared.AgdaPrecondition: The ranges of the tuple elements must point to the same file (or be empty).AgdaPrecondition: The ranges of the tuple elements must point to the same file (or be empty).AgdaPrecondition: The ranges of the tuple elements must point to the same file (or be empty).AgdaPrecondition: The ranges of the tuple elements must point to the same file (or be empty).AgdaPrecondition: The ranges of the tuple elements must point to the same file (or be empty).AgdaPrecondition: The ranges of the tuple elements must point to the same file (or be empty).AgdaPrecondition: The ranges of the list elements must point to the same file (or be empty).AgdaPrecondition: The ranges of the list elements must point to the same file (or be empty).AgdaOverlaps with  KillRange [a].N Safe-Inferred#"%&'-/2589:;, etc.AgdaThings like Set and Prop.AgdaIs the name an operator part?AgdaText occurring in pragmas that does not have a more specific aspect.Agda"Non-code contents in literate AgdaAgdaDelimiters used to separate the Agda code blocks from the other contents in literate AgdaAgdaSome #s are more informative than others.AgdaNameKind in Name can get more precise.<< Safe-Inferred#"%&'-/2589:; 0.Agda?Handles strings with newlines properly (preserving indentation)Agda a  ? b = hang a 2 bAgda pshow = text . showAgdaUsed for with-like  telescopesAgdaAttach a simple , rather than a full set of , to a document.AgdaWrap document in '...'AgdaWrap document in "..."AgdaWrap document in (...)AgdaWrap document in [...]AgdaWrap document in {...}6O Safe-Inferred#"%&'-/2589:;>=.AgdaPrecedence of  |.AgdaPrecedence of  *.AgdaPrecedence of E and +.AgdaPrecedence of atoms.ȋAgdaA smart constructor.ɋAgdaExtracts the parser.ʋAgdaExtracts the documents.ˋAgdaA helper function.̋Agda Pretty-prints a memoisation key.͋AgdaA helper function.Q Safe-Inferred#"%&'-/2589:; t_i --d_i--> u) and constructs the result graph from !edge(s,u) = sum_i (c_i times d_i).Complexity: For each edge s --> t in g' we look up all edges starting with t in g'.>Precondition: The two graphs must have exactly the same nodes.AgdaThe graph's strongly connected components, in reverse topological order.The time complexity is likely O(n + e log n) (but this depends on the, at the time of writing undocumented, time complexity of ϋ).AgdaThe graph's strongly connected components, in reverse topological order.The time complexity is likely O(n + e log n) (but this depends on the, at the time of writing undocumented, time complexity of ϋ).Agda invariant.AgdaThe opposite DAG.Agda'The nodes reachable from the given SCC.AgdaConstructs a DAG containing the graph's strongly connected components.AgdaConstructs a DAG containing the graph's strongly connected components.AgdareachableFrom g n/ is a map containing all nodes reachable from n in g. For each node a simple path to the node is given, along with its length (the number of edges). The paths are as short as possible (in terms of the number of edges).Precondition: n must be a node in g<. The number of nodes in the graph must not be larger than  :: ϊ.Amortised time complexity (assuming that comparisons take constant time):  O(e log n), if the lists are not inspected. Inspection of a prefix of a list is linear in the length of the prefix.AgdareachableFromSet g ns/ is a set containing all nodes reachable from ns in g.Precondition: Every node in ns must be a node in g<. The number of nodes in the graph must not be larger than  :: ϊ.Amortised time complexity (assuming that comparisons take constant time): O((|ns | + e) log n).ЋAgdaUsed to implement  and .Agda#walkSatisfying every some g from to% determines if there is a walk from from to to in g/, in which every edge satisfies the predicate every(, and some edge satisfies the predicate some. If there are several such walks, then a shortest one (in terms of the number of edges) is returned.Precondition: from and to must be nodes in g<. The number of nodes in the graph must not be larger than  :: ϊ.Amortised time complexity (assuming that comparisons and the predicates take constant time to compute): O(n + e log n).AgdaConstructs a graph g', with the same nodes as the original graph g. In g' there is an edge from n1 to n2> if and only if there is a (possibly empty) simple path from n1 to n2 in g. In that case the edge is labelled with all of the longest (in terms of numbers of edges) simple paths from n1 to n2 in g), as well as the lengths of these paths.Precondition: The graph must be acyclic. The number of nodes in the graph must not be larger than  :: ϊ.>Worst-case time complexity (if the paths are not inspected):  O(e n log n)( (this has not been verified carefully).1The algorithm is based on one found on Wikipedia.AgdaTransitive closure ported from Agda.Termination.CallGraph.%Relatively efficient, see Issue 1560.Agda Version of  that produces a list of intermediate results paired to the left with a difference that lead to the new intermediat result.The last element in the list is the transitive closure, paired with the empty graph. (complete g = snd $ last $ completeIter 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.AgdaThe transitive reduction of the graph: a graph with the same reachability relation as the graph, but with as few edges as possible.Precondition: The graph must be acyclic. The number of nodes in the graph must not be larger than  :: ϊ.Worst-case time complexity:  O(e n log n)) (this has not been verified carefully).1The algorithm is based on one found on Wikipedia.Agda*The graph's strongly connected components.R Safe-Inferred#"%&'-/2589:;= 0.AgdaNumber of columns, >= 0.Agda iff the matrix is square.AgdaReturns  iff the matrix is empty.Agda5Compute the matrix size of the union of two matrices.ՋAgda (i,)  $ f a), and same for gs and g.؋Agda Instance of $ which keeps longer assoc lists.  O(n1 + n2).Agda?General pointwise combination function for sparse matrices.  O(n1 + n2).Agda (+) m1 m2 adds m1 and m2, using (+) to add values.  O(n1 + n2).Returns a matrix of size  m1 m2.Agda f m1 m2! build the pointwise conjunction m1 and m2 . Uses f to combine non-zero values.  O(n1 + n2).Returns a matrix of size  infSize m1 m2.Agda"Association list intersection.  O(n1 + n2). interAssocWith f l l' = { (i, f a b) | (i,a) D l and (i,b) D l' }Used to combine sparse matrices, it might introduce zero elements if f( can return zero for non-zero arguments.Agda semiring m1 m2 multiplies matrices m1 and m2). Uses the operations of the semiring semiring" to perform the multiplication.0O(n1 + n2 log n2 + (i <= r1) (j <= c2) d(i,j)) where r1$ is the number of non-empty rows in m1 and c2' is the number of non-empty columns in m2 and d(i,j) is the bigger one of the following two quantifies: the length of sparse row i in m1$ and the length of sparse column j in m2.Given dimensions  m1 : r1  c1 and  m2 : r2  c2, a matrix of size r1  c2* is returned. It is not necessary that c1 == r2, the matrices are implicitly patched with zeros to match up for multiplication. For sparse matrices, this patching is a no-op.Agda x m adds a new column to m, after the columns already existing in the matrix. All elements in the new column get set to x.Agda x m adds a new row to m, after the rows already existing in the matrix. All elements in the new row get set to x.AgdaPointwise comparison. Only matrices with the same dimension are comparable.AgdaDiagonal of sparse matrix.O(n) where n2 is the number of non-zero elements in the matrix.AgdaMatrix transposition. O(n log n) where n2 is the number of non-zero elements in the matrix.AgdaTransposing coordinates.AgdaSize of transposed matrix.AgdaOnly left map remaining.AgdaOnly right map remaining.Agda!Element only present in left map.Agda"Element only present in right map.AgdaElement present in both maps.؋Agda!Element only present in left map.Agda"Element only present in right map.AgdaElement present in both maps.Agda$Element only present in left matrix.Agda%Element only present in right matrix.Agda!Element present in both matrices.AgdaResult counts as zero?U Safe-Inferred$"%&'-/2589:; SemiRing Order.AgdaInformation order:  is least information. The more we decrease, the more information we have.When having comparable call-matrices, we keep the lesser one. Call graph completion works toward losing the good calls, tending towards Unknown (the least information).Agda/We assume the matrices have the same dimension.AgdaIt does not get worse then ` increase'. If we are still decreasing, it can get worse: less decreasing.V Safe-Inferred$"%&'-/2589:; g has dimensions  ar(g)  ar(f).9Each column corresponds to one formal argument of caller f9. Each row corresponds to one argument in the call to g.In the presence of dot patterns, a call argument can be related to several different formal arguments of f. See e.g. testsucceedDotPatternTermination.agda:  data D : Nat -> Set where cz : D zero c1 : forall n -> D n -> D (suc n) c2 : forall n -> D n -> D n f : forall n -> D n -> Nat f .zero cz = zero f .(suc n) (c1 n d) = f n (c2 n d) f n (c2 .n d) = f n d 'Call matrices (without guardedness) are  -1 -1 n < suc n and n < c1 n d ? = c2 n d <= c1 n d = -1 n <= n and n < c2 n d ? -1 d < c2 n d Here is a part of the original documentation for call matrices (kept for historical reasons):This datatype encodes information about a single recursive function application. The columns of the call matrix stand for source function arguments (patterns). The rows of the matrix stand for target function arguments. Element (i, j)0 in the matrix should be computed as follows: (less than) if the j-th argument to the target; function is structurally strictly smaller than the i-th pattern. (less than or equal) if the j-th argument to the target+ function is structurally smaller than the i-th pattern. otherwise.Agda0Call matrix indices = function argument indices.Machine integer ϊ is sufficient, since we cannot index more arguments than we have addresses on our machine.AgdaNon-augmented call matrix.AgdaInsert into a call matrix set.AgdaUnion two call matrix sets.Agda/Convert into a list of augmented call matrices.AgdaCall matrix multiplication.f --(m1)--> g --(m2)--> h is combined to f --(m2  m1)--> h9Note the reversed order of multiplication: The matrix c1 of the second call g-->h in the sequence  f-->g-->h is multiplied with the matrix c2 of the first call.Preconditions: m1 has dimensions  ar(g)  ar(f). m2 has dimensions  ar(h)  ar(g).Postcondition:  m1 >*< m2 has dimensions  ar(h)  ar(f).Agda%Augmented call matrix multiplication.Agda1Call matrix set product is the Cartesian product.W Safe-Inferred$"%&'-/2589:; g and g -> h are present in the graph, then f -> h should also be present.Agda?Displays the recursion behaviour corresponding to a call graph.Agda is a monoid under .Agda: checks whether the call graph is completely disconnected.X Safe-Inferred$"%&'-/2589:;*< c: should not make any parameter-argument relation worse.Y Safe-Inferred#"%&'-/2589:; f pos s /= []*proposition> f pos s >>= layerContent == sAgdaA list of contiguous layers.Agda9A sequence of characters in a file playing the same role.Agda Role of a character in the file.Agda7Annotates a tokenized string with position information.AgdaList of valid extensions for literate Agda files, and their corresponding preprocessors.If you add new extensions, remember to update test/Utils.hs so that test cases ending in the new extensions are found.AgdaReturns True& if the role corresponds to Agda code.AgdaReturns True! if the layer contains Agda code.AgdaBlanks the non-code parts of a given file, preserving positions of characters corresponding to code. This way, there is a direct correspondence between source positions and positions in the processed result.Agda6Replaces non-space characters in a string with spaces.Agda*Check if a character is a blank character.AgdaShort list of extensions for literate Agda files. For display purposes.AgdaReturns a tuple consisting of the first line of the input, and the rest of the input.Agda2Canonical decomposition of an empty literate file.AgdaCreate a regular expression that: - Must match the whole string - Works across line boundariesAgdaPreprocessor for literate TeX.AgdaPreprocessor for Markdown.Agda"Preprocessor for reStructuredText.Agda$Preprocessor for Org mode documents.] Safe-Inferred#"%&'-/2589:;>= ( 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?^ Safe-Inferred$"%&'-/2589:;>` Safe-Inferred#"%&'-/2589:; " " <> d'.Agda1Concatenate vertically, separated by blank lines.AgdaApply  to  if boolean is true.AgdaCheck if a string is a valid JS identifier. The check ignores keywords as we prepend z_ to our identifiers. The check is conservative and may not admit all valid JS identifiers.++556c Safe-Inferred#"%&'-/2589:;"Maybe expression": Expression or reference to meta variable.AgdaAgsy's internal syntax.AgdaLambda with hiding information.AgdaTrue8 if possibly dependent (var not known to not occur). False if non-dependent.Agda&Absurd lambda with hiding information.AgdaUnique identifier of the head.Agda'This application has been type-checked.AgdaHead.Agda Arguments.Agda"Head of application (elimination).Agda Dot pattern.AgdaProjection pattern.AgdaConstant definitions.AgdaConstant signatures.AgdaFor debug printing.AgdaReference to the Agda constant.AgdaType of constant.AgdaConstant definition.Agda7Free vars of the module where the constant is defined..AgdaAbstraction with maybe a name.Different from Agda, where there is also info whether function is constant.AgdaThe concrete instance of the blk parameter in 8. I.e., the information passed to the search control. AgdaNat - deffreevars (to make cost of using module parameters correspond to that of hints). Agda1Size of typing context in which meta was created. Agda!Head normal form of type of meta. AgdaTrue if iota steps performed when normalising target type (used to put cost when traversing a definition by construction instantiation). Agda;Unique identifiers for variable occurrences in unification. AgdaSubstituting for a variable. AgdaFreeVars class and instances Agda Renaming Typeclass and instances           d Safe-Inferred$"%&'-/2589:; ess?, satisfying the following property: for every non-empty list w,   w ً bound iff  [  every w   some w | (every, some) <- ess ].'Agda+productOfEdgesInBoundedWalk occ g u v bound returns a value distinct from  iff there is a walk c (a list of edges) in g, from u to v, for which the product   ( occ c) ً bound&. In this case the returned value is  (  c) for one such walk c.Preconditions: u and v must belong to g, and bound must belong to the domain of boundToEverySome.'Agda'* is a complete lattice with least element ' and greatest element '.&It forms a commutative semiring where  is meet (glb) and 0 is composition. Both operations are idempotent.For , ' is neutral (zero) and ' is dominant. For , ' is neutral (one) and ' is dominant.''''''''''''''''''''''''''''''''''''''''''''''''j Safe-Inferred#"%&'-/2589:; p' for operator _=>_ The  is possibly ambiguous, but it must correspond to one of the names in the set.+Agda{p} or {x = p}+Agda{{p}} or  {{x = p}}+Agda (p)+Agda _+Agda ()+Agdax@p unused+Agda .e+Agda0, 1, etc.+Agda record {x = p; y = q}+Agdai = i1$ i.e. cubical face lattice generator+Agda...., only as left-most pattern. Second arg is Nothing before expansion, and Just p after expanding ellipsis to p.+Agda| p, for with-patterns.+AgdaConcrete expressions. Should represent exactly what the user wrote.+Agdaex: x+Agdaex: 1 or "foo"+Agdaex: ? or  {! ... !}+Agdaex: _ or _A_5+Agdabefore parsing operators+Agdaex: e e, e {e}, or  e {x = e}+Agdaex: e + e The  is possibly ambiguous, but it must correspond to one of the names in the set.+Agdaex: e | e1 | .. | en+Agdaex: {e} or {x=e}+Agdaex: {{e}} or {{x=e}}+Agdaex:  \x {y} -> e or \(x:A){y:B} -> e+Agdaex: \ ()+Agdaex: .\ { p11 .. p1a -> e1 ; .. ; pn1 .. pnz -> en }+Agdaex: e -> e or .e -> e (NYI: {e} -> e)+Agdaex:  (xs:e) -> e or  {xs:e} -> e+Agdaex: record {x = a; y = b}, or record { x = a; M1; M2 }+Agdaex: record e {x = a; y = b}+Agdaex:  let Ds in e+, missing body when parsing do-notation let+Agdaex: (e)+Agdaex: (| e1 | e2 | .. | en |) or (|)+Agdaex: do x <- m1; m2+Agdaex: () or {}, only in patterns+Agdaex: x@p, only in patterns+Agdaex: .p, only in patterns+Agdaex: ..A, used for parsing ..A -> B+Agdaex: quote, should be applied to a name+Agdaex:  quoteTerm, should be applied to a term+Agdaex:  @(tactic t)", used to declare tactic arguments+Agdaex: unquote&, should be applied to a term of type Term+Agdato print irrelevant things+Agdaex: a = b, used internally in the parser+Agda...$, used internally to parse patterns.+AgdaAn identifier coming from abstract syntax, for which we know a precise syntactic highlighting class (used in printing).+AgdaAn operator application coming from abstract syntax, for which we know a precise syntactic highlighting class (used in printing).+AgdaAn abstraction inside a special syntax declaration (see Issue 358 why we introduce this).,Agda-Drop type annotations and lets from bindings.,AgdaWe can try to get a  Telescope from a  [LamBinding]. If we have a type annotation already, we're happy. Otherwise we manufacture a binder with an underscore for the type.,AgdaSmart constructor for Pi: check whether the  Telescope is empty,AgdaSmart constructor for Lam: check for non-zero bindings.,AgdaSmart constructor for Let": check for non-zero let bindings.,AgdaSmart constructor for TLet": check for non-zero let bindings.,AgdaExtract a record directive,AgdaReturn * if * is *.,AgdaSplits off allowed (= import) declarations before the first non-allowed declaration. After successful parsing, the first non-allowed declaration should be a module declaration.,Agda*Observe the hiding status of an expression,Agda-Observe the relevance status of an expression,Agda2Observe various modifiers applied to an expression,AgdaTurn an expression into a pattern. Fails if the expression is not a valid pattern.,AgdaTurn an expression into a pattern, turning non-pattern subexpressions into +.Agda)Generic expression to pattern conversion.,AgdaA + is  when the where keyword is absent. An empty list of declarations does not count as  here.,AgdaRanges are not forced.,AgdaRanges are not forced.,AgdaRanges are not forced.,AgdaRanges are not forced.,AgdaRanges are not forced.,AgdaRanges are not forced.,AgdaRanges are not forced.,AgdaRanges are not forced.,AgdaRanges are not forced.Agda&Default result for non-pattern things.AgdaThe expression to translate.AgdaThe translated pattern (maybe).****************************************************************************************************++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++,,,,,,,,,,,,,,,,,,,,,,,,,,,++++++++++++++++++++++++++++++++++++++++++**,,,,,,,,,,,,,,+++++,,++++,++++++++++++++++++++++++,,+++,,,,,***********************************,,*************************+++++++++++++++++++++++++++++++++++++++*****+++++**++**++++*****************************,q Safe-Inferred#"%&'-/2589:;For non-sectioned operators this should match the notation's ...AgdaEffective precedence level.  for closed notations..AgdaË for non-sectioned operators..Agda/All the notation information related to a name..Agda-The names the syntax and/or fixity belong to.Invariant: The set is non-empty. Every name in the list matches ...Agda3Associativity and precedence (fixity) of the names..Agda!Syntax associated with the names..AgdaTrue if the notation comes from an operator (rather than a syntax declaration)..AgdaClassification of notations..AgdaEx:  _bla_blub_..AgdaEx:  _bla_blub..AgdaEx:  bla_blub_..AgdaEx: bla_blub..Agda9Data type constructed in the Happy parser; converted to ! before it leaves the Happy code..Agda  xA @ xA C y.: The first argument contains the bound names..AgdaSimple named hole with hiding..AgdaIs the hole a binder?.Agda2Get a flat list of identifier parts of a notation..AgdaTarget argument position of a part (Nothing if it is not a hole)..AgdaIs the part a hole?.AgdaIs the part a binder?.AgdaA level is a maximum expression of a closed level and 0..n 04 expressions each of which is an atom plus a number.0AgdaSorts.0AgdaProp B, Set B, SSet B.0AgdaProp:, (S)Set:.0AgdaSizeUniv, a sort inhabited by type Size.0AgdaLockUniv, a sort for locks.0Agda LevelUniv, a sort inhabited by type Level;. When --level-universe isn't on, this universe reduces to Set 00Agda IntervalUniv+, a sort inhabited by the cubical interval.0AgdaSort of the pi type.0Agda(Sort of a (non-dependent) function type.0AgdaSort of another sort.0AgdaA postulated sort.0AgdaA (part of a) term or type which is only used for internal purposes. Replaces the abuse of Prop for a dummy sort. The String typically describes the location where we create this dummy, but can contain other information as well.0AgdaPropSetSSet B.0Agda(PropSetSSet):.0AgdaSequence of types. An argument of the first type is bound in later types and so on.0Agda0 is never 0.0Agda'Types are terms with a sort annotation.0AgdaBinder.02: The bound variable might appear in the body. 0 is pseudo-binder, it does not introduce a fresh variable, similar to the const of Haskell.0Agda6The body has (at least) one free variable. Danger: 0! doesn't shift variables properly0Agda Raw values.Def is used for both defined and undefined constants. Assume there is a type declaration and a definition for every constant, even if the definition is an empty list of clauses.0Agdax es neutral0Agda+Terms are beta normal. Relevance is ignored0Agdaf es, possibly a delta/iota-redex0Agdac es or record { fs = es } es allows only Apply and IApply eliminations, and IApply only for data constructors.0Agda)dependent or non-dependent function space1AgdaIrrelevant stuff in relevant position, but created in an irrelevant context. Basically, an internal version of the irrelevance axiom .irrAx : .A -> A.1AgdaA (part of a) term or type which is only used for internal purposes. Replaces the  Sort Prop hack. The String typically describes the location where we create this dummy, but can contain other information as well. The second field accumulates eliminations in case we apply a dummy term to more of them. Dummy terms should never be used in places where they can affect type checking, so syntactic checks are free to ignore the eliminators, which are only there to ease debugging when a dummy term incorrectly leaks into a relevant position.1AgdaStore the names of the record fields in the constructor. This allows reduction of projection redexes outside of TCM. For instance, during substitution and application.1AgdaThe name of the constructor.1AgdaData or record constructor?1Agda'Record constructors can be coinductive.1Agda"The name of the record fields.  is stored since the info in the constructor args might not be accurate because of subtyping (issue #2170).1AgdaType of argument lists.1Agda Similar to , but we need to distinguish an irrelevance annotation in a function domain (the domain itself is not irrelevant!) from an irrelevant argument.Dom is used in 0 of internal syntax, in Context and 0.  is used for actual arguments (0, 0, 0 etc.) and in Abstract syntax and other situations.  cubical When ,annFinite (argInfoAnnotation domInfo) = True for the domain of a 0 type, the elements should be compared by tabulating the domain type. Only supported in case the domain type is primIsOne, to obtain the correct equality for partial elements.1Agdae.g. x in {x = y : A} -> B.1Agda3Is this a -type (False), or a partial type (True)?1Agda "@tactic e".1AgdaConstant level n1Agda4Is this a strict universe inhabitable by data types?1Agda6Make an absurd pattern with the given de Bruijn index.1AgdaBuild partial 0 from 01AgdaBuild 0 from 0.1Agda'Retrieve the PatternInfo from a pattern1Agda Retrieve the origin of a pattern1Agda1Does the pattern perform a match that could fail?1AgdaAbsurd lambdas are internally represented as identity with variable name "()".1AgdaAn unapplied variable.1AgdaAdd 1 is it is not already a DontCare.1AgdaConstruct a string representing the call-site that created the dummy thing.1Agda,Aux: A dummy term to constitute a dummy termlevel sort/type.1AgdaA dummy level to constitute a level/sort created at location. Note: use macro  DUMMY_LEVEL !1Agda5A dummy term created at location. Note: use macro  DUMMY_TERM !1Agda5A dummy sort created at location. Note: use macro  DUMMY_SORT !1Agda5A dummy type created at location. Note: use macro  DUMMY_TYPE !1AgdaContext entries without a type have this dummy type. Note: use macro  DUMMY_DOM !1AgdaGiven a constant m and level l , compute m + l1Agda)A traversal for the names in a telescope.1Agda(Convert a list telescope to a telescope.1Agda%Convert a telescope to its list form.1AgdaLens to edit a 0 as a list.1AgdaRemoving a topmost 1 constructor.1AgdaDoesn't do any reduction.1Agda>Convert top-level postfix projections into prefix projections.1AgdaConvert ./ projection eliminations according to their  into 0 projection applications.1Agda#A view distinguishing the neutrals Var, Def, and MetaV which can be projected.1AgdaIgnores  and  and tactic.2Agda2The size of a telescope is its length (as a list).2AgdaA  clause is one with no patterns and no rhs. Should not exist in practice.0AgdaThe  PatVarName is a name suggestion.0Agda#eliminations ordered left-to-right.1Agda-Should absurd patterns count as proper match?Agda1Should projection patterns count as proper match?Agda The pattern.&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&''''''''''''''''........///////////////////////////////////////////////////////////////////////////////////////////////0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001010000000011111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111///////////////////////////////////////00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000101000000001111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111104y Safe-Inferred#"%&'-/2589:; y) == withVarOcc o x <> withVarOcc o y ``` * Respects VarOcc composition: ``` withVarOcc oneVarOcc = id withVarOcc (composeVarOcc o1 o2) = withVarOcc o1 . withVarOcc o2 ``` * Respects VarOcc aggregation: ``` withVarOcc (o1 <> o2) x = withVarOcc o1 x <> withVarOcc o2 x ``` Since the corresponding unit law may fail, ``` withVarOcc mempty x = mempty ``` it is not quite a semimodule.3AgdaOccurrence of free variables is classified by several dimensions. Currently, we have 3 and .3AgdaDepending on the surrounding context of a variable, it's occurrence can be classified as flexible or rigid, with finer distinctions.The constructors are listed in increasing order (wrt. information content).3Agda7In arguments of metas. The set of metas is used by ' to generate the right blocking information. The semantics is that the status of a variable occurrence may change if one of the metas in the set gets solved. We may say the occurrence is tainted by the meta variables in the set.3Agda*In arguments to variables and definitions.3AgdaIn top position, or only under inductive record constructors (unit).3Agda3Under at least one and only inductive constructors.3Agda5A set of meta variables. Forms a monoid under union.3Agda3 aggregation (additive operation of the semiring). For combining occurrences of the same variable in subterms. This is a refinement of the  operation for 3 which would work if 3 did not have the 3* as an argument. Now, to aggregate two 3$ occurrences, we union the involved 3s.3Agda Unit for 3.3AgdaAbsorptive for 3.3Agda3 composition (multiplicative operation of the semiring). For accumulating the context of a variable.3 is dominant. Once we are under a meta, we are flexible regardless what else comes. We taint all variable occurrences under a meta by this meta.30 is next in strength. Destroys strong rigidity.3 is still dominant over 3.30 is the unit. It is the top (identity) context.3Agda Unit for 3.3AgdaThe absorptive element of variable occurrence under aggregation: strongly rigid, relevant.3AgdaFirst argument is the outer occurrence (context) and second is the inner. This multiplicative operation is to modify an occurrence under a context.3AgdaIgnore free variables in sorts.3AgdaThe initial context.3AgdaRun function for FreeM.3AgdaBase case: a variable.3Agda3Subtract, but return Nothing if result is negative.3AgdaGoing under a binder.3Agda Going under n binders.3Agda Changing the .3Agda Changing the .3Agda Changing the 3 context.3Agda State [i] (f (Pattern' (i,x)))4Agda+Arity of a function, computed from clauses.4AgdaTranslate the clause patterns to terms with free variables bound by the clause telescope.%Precondition: no projection patterns.4AgdaTranslate the clause patterns to an elimination spine with free variables bound by the clause telescope.4Agda5Augment pattern variables with their de Bruijn index.4AgdaComputes the permutation from the clause telescope to the pattern variables.Use as  fromMaybe  IMPOSSIBLE . dbPatPerm to crash in a controlled way if a de Bruijn index is out of scope here.The first argument controls whether dot patterns counts as variables or not.4AgdaComputes the permutation from the clause telescope to the pattern variables.Use as  fromMaybe  IMPOSSIBLE . clausePerm to crash in a controlled way if a de Bruijn index is out of scope here.4AgdaTurn a pattern into a term. Projection patterns are turned into projection eliminations, other patterns into apply elimination.4AgdaCompute from each subpattern a value and collect them all in a monoid.4AgdaTraverse pattern(s) with a modification before the recursive descent.4AgdaTraverse pattern(s) with a modification after the recursive descent.4Agda!Get the number of common initial . patterns in a list of clauses.5AgdaGet the number of initial . patterns in a clause.5AgdaGet the number of initial . patterns.5AgdaModify the content of VarP, and the closest surrounding NamedArg. Note: the  mapNamedArg for Pattern'! is not expressible simply by fmap or traverse etc., since ConP has NamedArg1 subpatterns, which are taken into account by  mapNamedArg.4Agda>Combine a pattern and the value computed from its subpatterns.4Agdapre : Modification before recursion.Agdapost: Modification after recursion.4Agdapre : Modification before recursion.4Agdapost: Modification after recursion.444444444444444444444444444444444444444444444444444444444444~ Safe-Inferred#"%&'-/2589:;Combine a pattern and the value computed from its subpatterns.6Agda;Combine a pattern and the its recursively computed version.6Agdapre : Modification before recursion.Agdapost: Modification after recursion.6Agdapre : Modification before recursion.6Agdapost: Modification after recursion.!666666666666666666666666666666666!666666666666666666666666666666666 Safe-Inferred&"%&')*-/12589:;Get current catchall pragma, and reset it for the next clause.9AgdaAdd a new warning.8Agda(Stack of warnings. Head is last warning.8AgdaWe retain the  also in the codomain since  as a key is up to Eq Name which ignores the range. However, without range names are not unique in case the user gives a second definition of the same name. This causes then problems in  replaceSigs, which might replace the wrong signature.Another reason is that we want to distinguish different occurrences of ) in a mutual block (issue #4157). The $ in the codomain will have a unique .588888888888888888999999999999999999999999999999999999599999998888888888888888899999999999999999999999999999 Safe-Inferred#"%&'-/2589:; Nat(Here the second line is not part of the where8 clause since it is has the same indentation as the data definition. What we have to do is insert an empty layout block {} after the where;. The only thing that can happen in this state is that : is executed, generating the closing brace. The open brace is generated when entering by :.:AgdaThis state is entered at the beginning of each line. You can't lex anything in this state, and to exit you have to check the layout rule. Done with :.:AgdaThis state can only be entered by the parser. In this state you can only lex the keywords using, hiding, renaming and to. Moreover they are only keywords in this particular state. The lexer will never enter this state by itself, that has to be done in the parser.:AgdaReturn the next token. This is the function used by Happy in the parser.  lexer k = : >>= kAgda&Do not use this function; it sets the 9 to .;Agda3This is the main lexing function generated by Alex. ::::::::::::; ::::::::::::; Safe-Inferred#"%&'-/2589:; ...)Agda+Converts lambda bindings to typed bindings.AgdaReturns the value of the first erasure attribute, if any, or else the default value of type .Raises warnings for all attributes except for erasure attributes, and for multiple erasure attributes.AgdaConstructs extended lambdas.Agda&Constructs extended or absurd lambdas.AgdaInterpret an expression as a list of names and (not parsed yet) as-patternsAgda0Match a pattern-matching "assignment" statement p <- eAgdaBuild a with-blockAgdaBuild a with-statementAgdaBuild a do-statementAgdaExtract record directivesAgda&Check for duplicate record directives.;AgdaBreaks up a string into substrings. Returns every maximal subsequence of zero or more characters distinct from . splitOnDots "" == [""] splitOnDots "foo.bar" == ["foo", "bar"] splitOnDots ".foo.bar" == ["", "foo", "bar"] splitOnDots "foo.bar." == ["foo", "bar", ""] splitOnDots "foo..bar" == ["foo", "", "bar"]AgdaReturns = iff the name is a valid Haskell (hierarchical) module name.Agda)Turn an expression into a left hand side.AgdaTurn an expression into a pattern. Fails if the expression is not a valid pattern.AgdaTurn an expression into a name. Fails if the expression is not a valid identifier.AgdaWhen given expression is e1 = e2, turn it into a named expression. Call this inside an implicit argument {e} or {{e}}, where an equality must be a named argument (rather than a cubical partial match).AgdaParse an attribute.Agda%Apply an attribute to thing (usually ). This will fail if one of the attributes is already set in the thing to something else than the default value.Agda#Apply attributes to thing (usually ). Expects a reversed list of attributes. This will fail if one of the attributes is already set in the thing to something else than the default value.Agda$Set the tactic attribute of a binderAgda$Get the tactic attribute if present.AgdaReport a parse error if two attributes in the list are of the same kind, thus, present conflicting information.AgdaReport an attribute as conflicting (e.g., with an already set value).AgdaReport attributes as conflicting (e.g., with each other). Precondition: List not emtpy.Agda!The attributes, in reverse order.Agda#The range of the lambda symbol and where or the braces.Agda The attributes in reverse order.AgdaThe clauses in reverse order.AgdaThe range of the lambda symbol.Agda!The attributes, in reverse order.Agda Catch-all?Agda Possibly empty list of patterns.;;;;;;;;;;;;;;9 9  Safe-Inferred#"%&'-/2589:;Benchmark a pure computation and bill it to the given account.1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Safe-Inferred$"%&'-/2589:; v[args].<AgdaApply something to a bunch of arguments. Preserves blocking tags (application can never resolve blocking).<Agda Apply to some default arguments.<Agda#Apply to a single default argument.<Agda%Raise de Bruijn index, i.e. weakening<AgdaReplace de Bruijn index i by a 0 in something.<AgdaReplace what is now de Bruijn index 0, but go under n binders. %substUnder n u == subst n (raise n u).<AgdaTo replace index n by term u, do applySubst (singletonS n u).  ,  E u : A --------------------------------- ,  E singletonS || u : , A,  <AgdaSingle substitution without disturbing any deBruijn indices.  , A,  E u : A --------------------------------- , A,  E inplace || u : , A,  <Agda$Lift a substitution under k binders.<Agda   E  : ,  -------------------  E dropS ||  :  <Agda applySubst ( <& ) v == applySubst  (applySubst  v)<Agda   E  :   E reverse vs :  ----------------------------- (treating Nothing as having any type)  E prependS vs  : ,  <Agda   E reverse vs :  -----------------------------  E parallelS vs  : ,   Note the  in , .<Agda E (strengthenS E ||) : ,<AgdaA "smart" variant of 0. If <1 is applied to a substitution with an outermost 0 constructor, then the "error message" of that constructor is discarded in favour of the  argument of this function.<AgdalookupS (listS [(x0,t0)..(xn,tn)]) xi = ti, assuming x0 < .. < xn.<Agda #, ,  E raiseFromS || || : , <Agda/Instantiate an abstraction. Strict in the term.<AgdaInstantiate an abstraction. Lazy in the term, which allow it to be  IMPOSSIBLE in the case where the variable shouldn't be used but we cannot use <. Used in Apply.<Agda9Instantiate an abstraction that doesn't use its argument.<AgdaunderAbs k a b applies k to a# and the content of abstraction b# and puts the abstraction back. a is raised if abstraction was proper such that at point of application of k and the content of b. are at the same context. Precondition: a and b& are at the same context at call time.<AgdaunderLambdas n k a b drops n initial 0s from b, performs operation k on a and the body of b, and puts the 0 s back. a is raised correctly according to the number of abstractions.,<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<,<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<4 Safe-Inferred%"%&')*-/2589:;Maps concrete module names to a list of abstract module names.=AgdaAll abstract names targeted by a concrete name in scope. Computed by =.=AgdaA local variable can be shadowed by an import. In case of reference to a shadowed variable, we want to report a scope error.=AgdaUnique ID of local variable.=Agda/Kind of binder used to introduce the variable (, let, ...).=AgdaIf this list is not empty, the local variable is shadowed by one or more imports.=AgdaFor each bound variable, we want to know whether it was bound by a , , module telescope, pattern, or let.=Agda (currently also used for  and module parameters)=Agda f ... ==Agda  let ... in=Agda  | ... in q=AgdaLocal variables.=Agda"For the sake of highlighting, the = map also stores the < of an A.QName.=AgdaThe <.=Agda)Possible renderings of the abstract name.=AgdaThe complete information about the scope at a particular program point includes the scope stack, the local variables, and the context precedence.=AgdaThe variables that will be bound at the end of the current block of variables (i.e. clause). We collect them here instead of binding them immediately so we can avoid shadowing between variables in the same variable block.=Agda&Maps concrete names C.Name to fixities=Agda(Maps concrete names C.Name to polarities=AgdaSee .=Agda#Things not exported by this module.=Agda+Things defined and exported by this module.=Agda1Things from open public, exported by this module.=AgdaA scope is a named collection of names partitioned into public and private names.=AgdaGet a = from =.=Agda A lens for ==Agda`Monadic' lens (Functor sufficient).=Agda3Shadow a local name by a non-empty list of imports.=Agda1Treat patternBound variable as a module parameter=Agda*Project name of unshadowed local variable.=Agda%Get all locals that are not shadowed  by imports.=AgdaLenses for ScopeInfo components=Agda Lens for =.=Agda Lens for =.=Agda inNameSpace> selects either the name map or the module name map from a =. What is selected is determined by result type (using the dependent-type trickery).=Agda?For ambiguous constructors, we might have both alternatives of !. In this case, we default to <.=Agda?For ambiguous constructors, we might have both alternatives of !. In this case, we default to .=Agda Only return  [Co]ConName if no ambiguity.=AgdaVan Laarhoven lens on <.=AgdaVan Laarhoven lens on <.=Agda$The flat list of ambiguous names in <.=AgdaThe empty name space.=Agda9Map functions over the names and modules in a name space.=AgdaZip together two name spaces.=Agda&Map monadic function over a namespace.=AgdaThe empty scope.=AgdaThe empty scope info.=Agda4Map functions over the names and modules in a scope.=AgdaSame as =2 but applies the same function to all name spaces.=AgdaSame as =7 but applies the function only on the given name space.=Agda Maybe C.Name for defined names and module names. However, the penalty of doing it in two passes should not be too high. (Doubling the run time.)=Agda Version of = that also returns sets of name and module name clashes introduced by renaming0 to identifiers that are already imported by using or lack of hiding.=Agda%Rename the abstract names in a scope.=Agda%Remove private name space of a scope.Should be a right identity for =. >exportedNamesInScope . restrictPrivate == exportedNamesInScope.>Agda9Remove private things from the given module from a scope.>AgdaFilter privates out of a =>Agda3Disallow using generalized variables from the scope>Agda.Add an explanation to why things are in scope.>Agda5Get the public parts of the public modules of a scope>Agda:Get all concrete names in scope. Includes bound variables.>AgdaLook up a name in the scope>AgdaFind the concrete names that map (uniquely) to a given abstract qualified name. Sort by number of modules in the qualified name, unqualified names first.>Agda A version of > that also delivers the <. Used in highlighting.>AgdaFind the concrete names that map (uniquely) to a given abstract module name. Sort by length, shortest first.>Agda+Add first string only if list is non-empty.>AgdaInvariant: the < components should be equal whenever we have to concrete renderings of an abstract name.>AgdaWe show shadowed variables as prefixed by a ".", as not in scope.>Agda/Sets the binding site of all names in the path.<Agda The name x this explanation is about.Agda2The directory in which the current module resides.AgdaThe local variable that x could denote, if any.AgdaThe defined names that x could denote.AgdaThe modules that x could denote.<Agda< can be DefName, <, <.<Agda(< ==) . < for all names.<Agda isJust . = . < for all names.<Agda(< ==) . < for all names.=Agda4Merged scope, clashing names, clashing module names.<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<================================================================================================================================>>>>>>>>>>>>>>>>>>>>>===========================================================================<<<<<<<<=<<<<<<<<<<<<<<<<<<=======<<<<====<<<<<<<<<<<<<<<<<<<<<==<<<<<<<<<<<<=<<=================================<<<=====>>>>>>>>>>><<<<>>>>>>>><<>> Safe-Inferred#"%&'-/2589:;Agda:Has the constructor pattern a dotted (forced) constructor??AgdaDotted constructor.?AgdaOrdinary constructor.?AgdaConstructor pattern info.?AgdaDoes this pattern come form the eta-expansion of an implicit pattern??Agda;For a general pattern we remember the source code position.?AgdaThe range of the "as" and "to" keywords, if any. Retained for highlighting purposes.?AgdaThe "as" module name, if any. Retained for highlighting purposes.?Agda Retained for abstractToConcrete of *.?AgdaInformation about application?Agda6Do we prefer a lambda argument with or without parens??Agda-Default is system inserted and prefer parens.?Agda? with no range information.?AgdaSame as  mkDefInfo but where we can also give the  IsInstance?AgdaEmpty range for patterns.?AgdaDefault value for ?.?>???????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????>?? Safe-Inferred#"%&'-/2589:; B.AAgdaE.g.  (let x = e) or  (let open M).AAgdaExtra information that is attached to a typed binding, that plays a role during type checking but strictly speaking is not part of the  name : type&" relation which a makes up a binding.AAgda+Does this binding have a tactic annotation?AAgdaDoes this binding correspond to a Partial binder, rather than to a Pi binder? Must be present here to be reflected into abstract syntax later (and to be printed to the user later).AAgda0A lambda binding is either domain free or typed.AAgda. x or {x} or .x or {x = y} or x@p or (p)AAgda. (xs:e) or {xs:e} or (let Ds)AAgdaOnly As.AAgdaBindings that are valid in a let.AAgda LetBind info rel name type defnAAgdaIrrefutable pattern binding.AAgda*LetApply mi newM (oldM args) renamings dir. The ImportDirective is for highlighting purposes.AAgda,only for highlighting and abstractToConcreteAAgda?Only used for highlighting. Refers to the first occurrence of x in let x : A; x = e.AAgda< is not <:. Name can be ambiguous e.g. for built-in constructors.AAgdaBuiltins that do not come with a definition, but declare a name for an Agda concept.AAgda"Range is range of REWRITE keyword.AAgda:For coinductive records, use pragma instead of regular  eta-equality, definition (as it is might make Agda loop).AAgda tel. M args : applies M to args and abstracts tel.AAgda  M {{...}}AAgda3Type signature (can be irrelevant, but not hidden).The fourth argument contains an optional assignment of polarities to arguments.AAgdaFirst argument is set of generalizable variables used in the type.AAgda record fieldAAgdaprimitive functionAAgda)a bunch of mutually recursive definitionsAAgdaThe ImportDirective is for highlighting purposes.AAgdaThe ImportDirective is for highlighting purposes.AAgdasequence of function clausesAAgdalone data signatureAAgdalone record signatureAAgdaThe A' gives the constructor type telescope, (x1 : A1)..(xn : An) -> Dummy, and the optional name is the constructor's name. The optional  is for the pattern attribute.AAgdaOnly for highlighting purposesAAgdascope annotationAAgda(Only for highlighting the unfolded namesAAgdaRenaming (generic).AAgdaRecord field assignment f = e.AAgdaExpressions after scope checking (operators parsed, names resolved).AAgdaBound variable.AAgdaConstant: axiom, function, data or record type, with a possible suffix.AAgdaProjection (overloaded).AAgdaConstructor (overloaded).AAgdaPattern synonym.AAgdaMacro.AAgdaLiteral.AAgda&Meta variable for interaction. The " is usually identical with the ? of ?. However, if you want to print an interaction meta as just ? instead of ?n, you should set the ? to  while keeping the .AAgda=Meta variable for hidden argument (must be inferred locally).AAgda.e, for postfix projection.AAgdaOrdinary (binary) application.AAgdaWith application.AAgda bs C e.AAgda() or {}.AAgdaDependent function space  C A.AAgda(Like a Pi, but the ordering is not knownAAgdaNon-dependent function space.AAgda let bs in e.AAgdaRecord construction.AAgdaRecord update.AAgdaScope annotation.AAgdaQuote an identifier &.AAgda Quote a term.AAgda#The splicing construct: unquote ...AAgda For printing DontCare from Syntax.Internal.AAgdaTypes are just expressions. Use this type synonym for hinting that an expression should be a type.AAgdaA name in a binding position: we also compare the nameConcrete when comparing the binders for equality.With  --caching on we compare abstract syntax to determine if we can reuse previous typechecking results: during that comparison two names can have the same nameId but be semantically different, e.g. in  {_ : A} -> .. vs.  {r : A} -> ...AAgdaPattern synonym for regular A.AAgdaSmart constructor for A.BAgda$The name defined by the given axiom.3Precondition: The declaration has to be a (scoped) A.BAgda5The declaration spine corresponding to a declaration.BAgda+The clause spine corresponding to a clause.BAgda=The right-hand side spine corresponding to a right-hand side.BAgdaThe spine corresponding to a @ value.BAgdaDoes not compare = fields.BAgdaDoes not compare = fields. Does not distinguish between prefix and postfix projections.BAgdaIgnore  when comparing @s.BAgdaIgnore @ when comparing @s.BAgdaTurn a < into an expression.Assumes name is not <.BAgdaTurn an < into an expression.&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&''''''''''''''''@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBB@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBB Safe-Inferred#"%&'-/2589:;Combine a pattern and the value computed from its subpatterns.DAgdapre : Modification before recursion.Agdapost: Modification after recursion.DAgdapre : Modification before recursion.DAgdapost: Modification after recursion.DAgda&Substitution function for expressions.Agda(Parallel) substitution.AgdaInput pattern.%DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD%DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD Safe-Inferred#"%&'-/2589:; overlapping the given range, as well as the rest of the map.EAgdaRestricts the E to the given range.EAgdaMerges Es by inserting every "piece" of the smaller one into the larger one.EAgdaMerges Es by inserting every "piece" of the smaller one into the larger one.EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE Safe-Inferred#"%&'-/2589:;Note the invariant which values of this type should satisfy (F).This is a type synonym in order to make it easy to change to another representation."The type should be an instance of E ,  and &, and there should be an instance of E E E.EAgdaHighlighting information.>Note the invariant which values of this type should satisfy (F).This is a type synonym in order to make it easy to change to another representation.EAgda'Highlighting info with delayed merging.Merging large sets of highlighting info repeatedly might be costly. The idea of this type is to accumulate small pieces of highlighting information, and then to merge them all at the end.>Note the invariant which values of this type should satisfy (F).EAgdaSyntax highlighting information, represented by maps from positions to .,The first position in the file has number 1.FAgdaA limited kind of syntax highlighting information: a pair consisting of E and .Note the invariant which Fs should satisfy (F).FAgdaInvariant for F.FAgdaInvariant for E hl%, parametrised by the invariant for hl.?Additionally the endofunction should be extensionally equal to (fs ) for some list fs.FAgdaThe invariant for E.FAgdaThe invariant for E.?Additionally the endofunction should be extensionally equal to (fs ) for some list fs.FAgda A variant of  with  set to .FAgda4Conversion from classification of the scope checker.AgdaMerges meta information.EEEEEEEEEEEEEEEEEFFFFFFFFFFFFFEEEEEFEFEFFFEEEEEEEEEE Safe-Inferred&"%&')*-/12589:;n2 to be at most k(. Also adds nodes if not yet present.GAgda sizeRigid r n. returns the size expression corresponding to r + n5FFFFFGGGFGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG5GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGFGGGFFGGFFFGG Safe-Inferred$"%&'-/12589:;(Non-empty) library names to be resolved to (lists of) pathes.Agda2Resolved pathes (no duplicates). Contains "." if  [LibName] does.-DDDDDDDDDDDDDDDDDEEEEEEEEEEEEGGGGGGGGGGGGGGGG-GGGGGGGGEDEEEDDDDDDDDEDGDDDDDDDEEEEEEEGGGGGGG Safe-Inferred&"%&'-/12589:; x, (i=1) -> y]nAgdaA telescope split in two.nAgda;The permutation takes us from the original telescope to firstPart ++ secondPart.nAgda(Flatten telescope: ( : Tel) -> [Type ]nAgdaOrder a flattened telescope in the correct dependeny order:  -> Permutation ( -> ~)Since reorderTel tel( uses free variable analysis of type in tel, the telescope should be ld.nAgdaUnflatten: turns a flattened telescope into a proper telescope. Must be properly ordered.nAgda A variant of n; which takes the size of the last argument as an argument.nAgdaRename the variables in the telescope to the given names Precondition: size xs == size tel.nAgda(Get the suggested names from a telescopenAgda A variant of n which takes the argument names (and the argument info) from the first telescope and the variable names from the second telescope.6Precondition: the two telescopes have the same length.nAgda.Split the telescope at the specified position.nAgdaPermute telescope: permutes or drops the types in the telescope according to the given permutation. Assumes that the permutation preserves the dependencies in the telescope.3For example (Andreas, 2016-12-18, issue #2344):  tel = (A : Set) (X : _18 A) (i : Fin (_m_23 A X)) tel (de Bruijn) = 2:Set, 1:_18 0, 0:Fin(_m_23 1 /0) flattenTel tel = 2:Set, 1:_18 0, 0:Fin(_m_23 1 0) |- [ Set, _18 2, Fin (_m_23 2 1) ] perm = 0,1,2 -> 0,1 (picks the first two) renaming _ perm = [var 0, var 1, error] -- THE WRONG RENAMING! renaming _ (flipP perm) = [error, var 1, var 0] -- The correct renaming! apply to flattened tel = ... |- [ Set, _18 1, Fin (_m_23 1 60) ] permute perm it = ... |- [ Set, _18 11 ] unflatten (de Bruijn) = 1:Set, 0: _18 90 unflatten = (A : Set) (X : _18 A) nAgdaRecursively computes dependencies of a set of variables in a given telescope. Any dependencies outside of the telescope are ignored.nAgdaComputes the set of variables in a telescope whose type depend on one of the variables in the given set (including recursive dependencies). Any dependencies outside of the telescope are ignored.nAgdaSplit a telescope into the part that defines the given variables and the part that doesn't.See .nAgdaAs splitTelescope, but fails if any additional variables or reordering would be needed to make the first part well-typed.nAgdaTry to instantiate one variable in the telescope (given by its de Bruijn level) with the given value, returning the new telescope and a substitution to the old one. Returns Nothing if the given value depends (directly or indirectly) on the variable.nAgdaTry to eta-expand one variable in the telescope (given by its de Bruijn level)nAgdatelViewUpTo n t takes off the first n function types of t. Takes off all if n < 0.nAgdatelViewUpTo' n p t takes off $t$ the first n (or arbitrary many if n < 0-) function domains as long as they satify p.nAgdatelViewUpToPath n t takes off $t$ the first n (or arbitrary many if n < 0!) function domains or Path types. telViewUpToPath n t = fst  $ telViewUpToPathBoundary'n tnAgdaLike telViewUpToPath but also returns the Boundary expected by the Path types encountered. The boundary terms live in the telescope given by the TelView. Each point of the boundary has the type of the codomain of the Path type it got taken from, see  fullBoundary.nAgda8(TelV  b, [(i,t_i,u_i)]) <- telViewUpToPathBoundary n a Input:  E a Output:  E b  E i : I  E [ (i=0) -> t_i; (i=1) -> u_i ] : bnAgda9(TelV  b, [(i,t_i,u_i)]) <- telViewUpToPathBoundaryP n a Input:  E a Output: . E b . E T is the codomain of the PathP at variable i . E i : I . E [ (i=0) -> t_i; (i=1) -> u_i ] : T Useful to reconstruct IApplyP patterns after teleNamedArgs .nAgdateleElimsB args bs = es Input: . E args :  . E T is the codomain of the PathP at variable i . E i : I . E bs = [ (i=0) -> t_i; (i=1) -> u_i ] : T Output: . | PiPath  bs A E es : AnAgdaReduces 0.nAgdaReduces 0.nAgdaReturns  Left (a,b) in case the type is Pi a b or  PathP b _ _. Assumes the 0 is in whnf.nAgdaAssumes 0 is in whnf.nAgdaDecomposing a function type.nAgdaIf the given type is a Pi, pass its parts to the first continuation. If not (or blocked), pass the reduced type to the second continuation.nAgdaIf the given type is a Pi, pass its parts to the first continuation. If not (or blocked), pass the reduced type to the second continuation.nAgda&If the given type is blocked or not a Pi;, pass it reduced to the first continuation. If it is a Pi,, pass its parts to the second continuation.nAgda&If the given type is blocked or not a Pi;, pass it reduced to the first continuation. If it is a Pi,, pass its parts to the second continuation.nAgdaCompute type aritynAgdaStrips all hidden and instance Pi's and return the argument telescope and head definition name, if possible.nAgdaRegister the definition with the given type as an instance. Issue warnings if instance is unusable.nAgda;Register the definition with the given type as an instance.nAgdaTry to solve the instance definitions whose type is not yet known, report an error if it doesn't work and return the instance table otherwise.nAgdaA set of de Bruijn indices.AgdaOriginal telescope.Agda firstPart mentions the given variables,  secondPart not.nAgdaA list of de Bruijn indicesAgdaThe telescope to splitAgda firstPart5 mentions the given variables in the given order,  secondPart contains all other variablesnAgdaE Agda! E var k : A de Bruijn _level_Agda  E u : AnAgdaName of instance.AgdaType of instance.nAgdaB(x) Z [u] = B(u)Precondition: The type must contain the right number of pis without having to perform any reduction.piApply$ is potentially unsafe, the monadic piApplyM is preferable.ZAgdaIf permute  : [a] -> [a], then ,applySubst (renaming _ ) : Term  -> Term ZAgdaIf permute  : [a] -> [a], then +applySubst (renamingR ) : Term  -> Term ZAgdaThe permutation should permute the corresponding context. (right-to-left list)ZAgda  projDropParsApply proj o args = T proj o `<` argsThis function is an optimization, saving us from construction lambdas we immediately remove through application.ZAgdaTakes off all exposed function domains from the given type. This means that it does not reduce to expose Pi-types.ZAgdatelView'UpTo n t takes off the first n exposed function types of t#. Takes off all (exposed ones) if n < 0.ZAgda0Add given binding to the front of the telescope.ZAgdaTurn a typed binding (x1 .. xn : A) into a telescope.ZAgdaTurn a typed binding (x1 .. xn : A) into a telescope.ZAgda )mkPi dom t = telePi (telFromList [dom]) tZAgda)Uses free variable analysis to introduce 0 bindings.ZAgdaEverything will be an 0.ZAgdaOnly abstract the visible components of the telescope, and all that bind variables. Everything will be an 0! Caution: quadratic time!ZAgdaAbstract over a telescope in a term, producing lambdas. Dumb abstraction: Always produces 0, never 0.$The implementation is sound because 0 does not use 0.ZAgdaGiven arguments vs : tel= (vector typing), extract their individual types. Returns Nothing is tel is not long enough.ZAgdaIn compiled clauses, the variables in the clause body are relative to the pattern variables (including dot patterns) instead of the clause telescope.ZAgdaunivSort' univInf s gets the next higher sort of s), if it is known (i.e. it is not just  UnivSort s).Precondition: s is reducedZAgdaReturns  Left blocker7 for unknown (blocked) sorts, and otherwise returns Right s where s! indicates the size and fibrancy.ZAgdaCompute the sort of a function type from the sorts of its domain and codomain.This function should only be called on reduced sorts, since the  LevelUniv: rules should only apply when the sort does not reduce to Set.ZAgdaCompute the sort of a pi type from the sorts of its domain and codomain. This function should only be called on reduced sorts, since the  LevelUniv9 rules should only apply when the sort doesn't reduce to SetZAgdaGiven two levels a and b , compute a E b" and return its canonical form.ZAgdaEquality of binders relies on weakening which is a special case of renaming which is a special case of substitution.ZAgda Syntactic 0 equality, ignores stuff below DontCare and sharing.ZAgda Syntactic 0$ equality, ignores sort annotations.[Agdatel E ( E lhs C rhs : t) becomes tel,  E lhs C rhs : t) we do not need to change lhs, rhs, and t since they live in . See 'Abstract Clause'.[Agda)Make sure we only drop variable patterns.000000003333<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<Expected a type to be an application of a particular datatype.JAgdaconstructor, datatypeJAgdaDatatype, constructors.JAgdaconstructor, typeJAgdaThe left hand side of a function definition has a hidden argument where a non-hidden was expected.JAgda9Expected a non-hidden function and found a hidden lambda.JAgdaA function is applied to a hidden argument where a non-hidden was expected.JAgdaA function is applied to a hidden named argument it does not have. The list contains names of possible hidden arguments at this point.JAgda0Wrong user-given relevance annotation in lambda.JAgda/Wrong user-given quantity annotation in lambda.JAgda/Wrong user-given cohesion annotation in lambda.JAgdaThe given quantity does not correspond to the expected quantity.JAgdaFailed to apply injectivity to constructor of indexed datatypeLAgda=Can't solve equation because variable occurs in (type of) lhsLAgda=Can't solve reflexive equation because --without-K is enabledLAgda?Can't solve equation because solution modality is less "usable"LAgdaError when splitting a pattern variable into possible constructor patterns.LAgdaNeither data type nor record.LAgda'Type could not be sufficiently reduced.LAgda"Data type, but in erased position.LAgdaSplit on codata not allowed. UNUSED, but keep! -- | NoRecordConstructor Type -- ^ record type, but no constructorLAgdaCopattern split with a catchallLAgda-We do not know the target type of the clause.LAgda!Target type is not a record type.LAgdaBlocking metavariable (if any)LAgda Constructor.LAgdaContext for indices.LAgda,Inferred indices (from type of constructor).LAgda)Expected indices (from checking pattern).LAgda$Reason(s) why unification got stuck.LAgdaThe reason for an L error.LAgdaThere are several constructors.LAgda The flag --erased-matches is not used.LAgdaThe K rule is not activated.LAgdaInformation about a mutual block which did not pass the termination checker.LAgdaThe functions which failed to check. (May not include automatically generated functions.)LAgdaThe problematic call sites.LAgdaInformation about a call.LAgda,Target function name. (Contains its range.)LAgda+To be formatted representation of the call.LAgdaLocation in the internal Agda source code location where the error raisedLAgda"Range where the warning was raisedLAgdaThe warning itselfLAgdaThe warning printed in the state and environment where it was raisedLAgda*Should the warning be affected by caching.LAgda4`UnreachableClauses f rs` means that the clauses in f' whose ranges are rs are unreachableLAgda!`CoverageIssue f pss` means that pss are not covered in fLAgda04 was turned into copattern matching clause(s) by an {-# INLINE constructor #-}5 and thus is not a definitional equality any more.LAgdaDo not use directly with warningLAgdaDo not use directly with warningLAgdaDo not use directly with warningLAgdaDo not use directly with warningLAgdaIn `OldBuiltin old new`, the BUILTIN old has been replaced by newLAgdaIf the user wrote just {-# REWRITE #-}.LAgda An empty where block is dead code.LAgdaIf the user wrote something other than an unqualified name in the as clause of an import statement. The $ gives optionally extra explanation.LAgdaA character literal Agda does not support, e.g. surrogate code points.LAgdaIf a renaming import directive introduces a name or module name clash in the exported names of a module. (See issue #4154.)LAgdaThe  'pattern'5 declaration is useless in the presence of either  coinductive or  eta-equality. Content of ! is "coinductive" or "eta", resp.LAgda4Warning when pragma is useless and thus ignored.  is for dead code highlighting.LAgdaIf the user opens a module public before the module header. (See issue #2377.)LAgda Names in 5 directive that don't hide anything imported by a  directive.LAgdaAn instance was declared with an implicit argument, which means it will never actually be considered by instance search.LAgdaThe type of an instance argument doesn't end in a named or variable type, so it will never be considered by instance search.LAgdaAs InstanceWithExplicitArg, but for local bindings rather than top-level instances.LAgda&The --inversion-max-depth was reached.LAgdaA coinductive record was declared but neither --guardedness nor --sized-types is enabled.LAgda'Harmless generic warning (not an error)LAgdaUnsafe OPTIONS.LAgda)`DeprecationWarning old new version`: old is deprecated, use new( instead. This will be an error in Agda version.LAgdaUser-defined warning (e.g. to mention that a name is deprecated)LAgda'Duplicate mentions of the same name in using directive(s).LAgdaFixity of modules cannot be changed via renaming (since modules have no fixity).LAgdaSome imported names are not actually exported by the source module. The second argument is the names that could be exported. The third argument is the module names that could be exported.LAgdaImporting a file using an infective option into one which doesn'tLAgdaImporting a file not using a coinfective option from one which doesLAgdaConfluence checker found critical pair and equality checking resulted in a type errorLAgdaConfluence checker got stuck on computing overlap between two rewrite rulesLAgda+The global confluence checker found a term u that reduces to both v1 and v22 and there is no rule to resolve the ambiguity.LAgda+The global confluence checker found a term u that reduces to v, but v does not reduce to rho(u).LAgda&COMPILE directive for an erased symbolLAgda&Out of scope error we can recover fromLAgda:Was not able to compute a full equivalence when splitting.LAgda;The as-name in an as-pattern may not shadow a constructor (False) or pattern synonym name (True,), because this can be confusing to read.LAgdaA pattern variable has the name of a constructor (data constructor or matchable record constructor).LAgdaExplicit use of @ or @plenty in hard compile-time mode.LAgdaFace constraint patterns (i = 0) must be visible arguments.LAgdaFace constraint patterns (i = 0) must be unnamed arguments.LAgdaRanges of checked arguments, where present. e.g. inserted implicits have no correponding abstract syntax.LAgda&Checked and inserted arguments so far.LAgdaConstraints for the head so far, i.e. before applying the correponding elim.LAgda%Type for the rest of the application.LAgdaA candidate solution for an instance meta is a term with its type. It may be the case that the candidate is not fully applied yet or of the wrong type, hence the need for the type.MAgdaAdd implicit arguments in the end until type is no longer hidden 0.MAgda!Do not append implicit arguments.MAgdaMakes  doExpandLast have no effect. Used to avoid implicit insertion of arguments to metavariables.MAgdaA block of opaque definitions.MAgda!Unique identifier for this block.MAgdaSet of names we are allowed to unfold. After scope-checking, this set should be transitively closed.MAgda.Declarations contained in this abstract block.MAgda4Pointer to an enclosing opaque block, if one exists.MAgdaWhere is this opaque block?MAgda6Abstract things in the current module can be accessed.MAgda#No abstract things can be accessed.MAgda$All abstract things can be accessed.MAgdaThe Context is a stack of Ms.MAgda=The path to the file that is currently being type-checked. 9 if we do not have a file (like in interactive mode see  CommandLine).MAgda4anonymous modules and their number of free variablesMAgdaThe module stack with the entry being the top-level module as Agda chases modules. It will be empty if there is no main module, will have a single entry for the top level module, or more when descending past the main module. This is used to detect import cycles and in some cases highlighting behavior. The level of a given module is not necessarily the same as the length, in the module dependency graph, of the shortest path from the top-level module; it depends on in which order Agda chooses to chase dependencies.MAgda!the current (if any) mutual blockMAgda/are we inside the scope of a termination pragmaMAgda,are we inside the scope of a coverage pragmaMAgdaare we inside a make-case (if so, ignore forcing analysis in unifier)MAgda>Are we currently in the process of solving active constraints?MAgdaHave we stepped into the where-declarations of a clause? Everything under a where# will be checked with this flag on.MAgda&Are we working on types? Turned on by  workOnTypes.MAgdaAre we allowed to assign metas?MAgdaWhen checking the typesignature of a public definition or the body of a non-abstract definition this is true. To prevent information about abstract things leaking outside the module.MAgda*Are we checking an irrelevant argument? (= Irrelevant) Then top-level irrelevant declarations are enabled. Other value: Relevant*, then only relevant decls. are available.MAgda.Are we checking a runtime-irrelevant thing? (=-) Then runtime-irrelevant things are usable.MAgdaIs the "hard" compile-time mode enabled? In this mode the quantity component of the environment is always zero, and every new definition is treated as erased.MAgdaAre we currently case-splitting on a strict datatype (i.e. in SSet)? If yes, the pattern-matching unifier will solve reflexive equations even --without-K.MAgda+Sometimes we want to disable display forms.MAgda5Fold let-bindings when printing terms (default: True)MAgda8Interactive highlighting uses this range rather than M.MAgdaWhat is the current clause we are type-checking? Will be recorded in interaction points in this clause.MAgdawhat we're doing at the momentMAgdaSet to M+ when imported modules are type-checked.MAgdaWhen type-checking an alias f=e, we do not want to insert hidden arguments in the end, because these will become unsolved metas.MAgdaWe are reducing an application of this function. (For tracking of incomplete matches.)MAgdaDid we encounter a simplification (proper match) during the current reduction process?MAgdaInjectivity can cause non-termination for unsolvable contraints (#431, #3067). Keep a limit on the nesting depth of injectivity uses.MAgdaWhen True, the conversion checker will consider all term constructors as injective, including blocked function applications and metas. Warning: this should only be used when not assigning any metas (e.g. when envAssignMetas is False or when running pureEqualTerms.) or else we get non-unique meta solutions.MAgdaWhen True, types will be omitted from printed pi types if they can be inferred.MAgdaWhen True, throw away meta numbers and meta elims. This is used for reifying terms for feeding into the user's source code, e.g., for the interaction tactics solveAll.MAgdaUsed by the scope checker to make sure that certain forms of expressions are not used inside dot patterns: extended lambdas and let-expressions.MAgdaUntil we get a termination checker for instance search (#1743) we limit the search depth to ensure termination.MAgda#3004: pattern lambdas with copatterns may refer to themselves. We don't have a good story for what to do in this case, but at least printing shouldn't loop. Here we keep track of which pattern lambdas we are currently in the process of printing.MAgda+Use call-by-need evaluation for reductions.MAgdaCheckpoints track the evolution of the context as we go under binders or refine it by pattern matching.MAgdaKeeps the substitution from each previous checkpoint to the current context.MAgda"Should new metas generalized over.MAgda(Values for used generalizable variables.MAgdaIs some backend active at the moment, and if yes, which? NB: we only store the - here, otherwise instance Data TCEnv is not derivable. The actual backend can be obtained from the name via S.MAgdaAre we currently computing the overlap between two rewrite rules for the purpose of confluence checking?MAgdaAre we currently in the process of executing an elaborate-and-give interactive command?MAgdaIf this counter is , then syntactic equality checking is unrestricted. If it is zero, then syntactic equality checking is not run at all. If it is a positive number, then syntactic equality checking is allowed to run, but the counter is decreased in the failure continuation of .MAgdaUnique identifier of the opaque block we are currently under, if any. Used by the scope checker (to associate definitions to blocks), and by the type checker (for unfolding control).MAgda Via stdout.MAgdaBoth via files and via stdout.MAgdaThis includes both non-interactive highlighting and interactive highlighting of the expression that is currently being type-checked.MAgdaBUILTIN REWRITE). We can have several rewrite relations.MAgda-Builtin of any kind. Type can be checked (Just t) or inferred (Nothing). The second argument is the hook for the verification function.MAgda2When typechecking something of the following form:"instance x : _ x = y it's not yet known where to add x, so we add it to a list of unresolved instances and we'll deal with it later.MAgdaThe instance table is a Map' associating to every name of record data typepostulate its list of instancesNAgda8Highlight (interactively) if and only if the boolean is .NAgdaChecking a clause for confluence with endpoint reductions. Always  E f vs = rhs/ for now, but we store the simplifications of f vs[] and rhs[].NAgda*Interaction command: show module contents.NAgdaused by setCurrentRangeNAgdaSee O.NAgda PrimitivesNAgda Controlling reduce.NAgda:(Projection and) projection-like functions may be reduced.NAgda'Functions marked INLINE may be reduced.NAgda%Copattern definitions may be reduced.NAgda6Non-recursive functions and primitives may be reduced.NAgda(Even recursive functions may be reduced.NAgdaReduce 0 terms.NAgdaAllow  allReductions in types, even if not allowed at term level (used by confluence checker)NAgda9Functions whose termination has not (yet) been confirmed.NAgda0Functions that have failed termination checking.NAgdaThree cases: 1. not reduced, 2. reduced, but blocked, 3. reduced, not blocked.NAgdaDid we encounter a simplifying reduction? In terms of CIC, that would be a iota-reduction. In terms of Agda, this is a constructor or literal pattern that matched. Just beta-reduction (substitution) or delta-reduction (unfolding of definitions) does not count as simplifying?NAgda for primitive functions, not null for builtin functions.NAgdaBuiltin functions can have inverses. For instance, natural number addition.NAgda for primitive functions,  something for builtin functions.NAgda*Primitives can also live in opaque blocks.NAgdaNumber of parameters.NAgda+Number of arguments (excluding parameters).NAgdaName of (original) constructor and fields. (This might be in a module instance.)NAgda Name of datatype or record type.NAgdaCubical composition.NAgda Projections.  if not yet computed.NAgdaWhich arguments are forced (i.e. determined by the type of the constructor)? Either this list is empty (if the forcing analysis isn't run), or its length is conArity.NAgdaWhich arguments are erased at runtime (computed during compilation to treeless)?  means erased, Ë means retained.  if no erasure analysis has been performed yet. The length of the list is conArity.NAgdaWas  --erasure in effect when the constructor was defined? (This can affect the constructor's type.)NAgdaShall we translate the constructor on the root of the rhs into copattern matching on the lhs? Activated by INLINE pragma.NAgdaNumber of parameters.NAgdaWas this record type created by a module application? If yes, the clause is its definition (linking back to the original record type).NAgdaConstructor name and fields.NAgdaDoes this record have a  constructor?NAgdaThe record field names.NAgdaThe record field telescope. (Includes record parameters.) Note: $TelV recTel _ == telView' recConType . Thus, recTel is redundant.NAgdaMutually recursive functions, datas and record>s. Does include this record. Empty if not recursive. Nothing- if not yet computed (by positivity checker).NAgda#Eta-expand at this record type? False for unguarded recursive records and coinductive records unless the user specifies otherwise.NAgdaIn case eta-equality is off, do we allow pattern matching on the constructor or construction by copattern matching? Having both loses subject reduction, see issue #4560. After positivity checking, this field is obsolete, part of O.NAgda or *? Matters only for recursive records.  means that the user did not specify it, which is an error for recursive records.NAgda'Just True' means that unfolding of the recursive record terminates, 'Just False' means that we have no evidence for termination, and 3 means we have not run the termination checker yet.NAgdaNumber of parameters.NAgdaNumber of indices.NAgda(This might be in an instantiated module.NAgdaConstructor names, ordered according to the order of their definition.NAgdaMutually recursive functions, datas and records. Does include this data type. Empty if not recursive. Nothing- if not yet computed (by positivity checker).NAgda"Path constructor names (subset of dataCons).NAgda