h*       !"#$%&'()*+, - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K LMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~        !"""""""""""""""""""#######$$$$$$$$$$$$$$$$$$$$$$$$$$$$$%%%%%%%%%%%%%%%%%%%%%%%%%%%%&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&''''''''''''''((((((((((((((((((((())))))))))))))))*************************************++++++,,,-------------------....//////////00000000000000000000000000000000000011111111111112222222222222222222222222222222222222222222222223333344444444444444555555555556666666666666666666666666666666666778888888888899999999999999999999::::::::::::::::::::::::::;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; ; ; ;                                    < < < < < < < < < < < < = = = = = = = = = = = = = = = = = = = = = = > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A                                        B B B B B B B B B B B B B B B B B B B B B B B B B B B B B B B B C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C 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 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 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 H I J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J JJJJJJJKKKKKKKKKKKKKKKKLLLLLLMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQRRRRRRRRRRRRRRRRRSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIUUUUUUUUUUUUUUUUVVVVVVVVVVVVVVVVVVVVVVVVVVVVVWXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ[[ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ ] ] ] ] ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_"_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_$_%_%_%_%_%_%_%_%_%_%_%_%_%_%_%_%_%_%_%_%_%_%_%_%_%_%_%_%_%_%_%_%_%_%_%_%_%_%_%_%_%`%`%`%`%`%`%`%`%`%`%`%`%`%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%b%b%b%b%b%b%b%b%b%b%b%b%b%b%b%b%b%b%b%b%b%b%b%b%b%b&b&b&b&b&b&b&b&b&b&b&b&b&b&b&b&b&b&b&b&b&b&b&b&b&b&b&b&b&b&b&b&b&b&b&b&b&b&b&b&b&b&b&b&b&b&b&b&b&b&b&b&b&b&b&b&b&b&b&b&b&b&b&b&b&b&b&b&b&b&b&b&b&b&b&b&b&b&b&b&b&b&b&b&b&b&b&b&b&b&b&b&b&b&b&b&c&d&d&e&e&e&e&e&e&e&e&e&e&e&e&e&e&e&e&e&e&e&e&e&e&e&e&e&e&e&e&e&e'e'e'e'e'e'e'e'e'e'e'e'e'e'e'e'e'e'e'e'e'e'e'e'e'e'e'e'e'e'e'e'e'e'e'e'e'e'e'e'e'e'e'e'e'e'e'e'e'e'e'e'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'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(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(i(j(j(j(j(j(j(j(j(j(j(j(j(j(j(j(j(j(j(j(j(j(j(j(j(j(j(j(j(j(j(j(j(j(j(j(j(j(j(j(j(j(j(j(j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)j)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k)k*k*k*k*k*k*k*k*k*k*k*k*k*k*k*k*k*k*k*k*k*k*k*k*k*k*k*k*k*k*k*k*k*k*k*k*k*k*k*k*k*k*k*k*k*k*k*k*k*k*k*k*k*k*k*k*k*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l*l+l+l+l+l+l+l+m+m+m+m+m+m+m+m+m+m+m+m+m+m+m+m+m+m+m+m+m+m+m+m+m+m+m+m+m+m+m+m+m+m+m+m+m+m+m+m+m+m+m+m+m+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+o+o+o+o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p-q-q-q-q-q-q-q-q-q-q-q-q-q-q-q-q-q-q-q-q-q-q-q-q-q-q-q-q-q-q-q-q-q-q-q-q-q-q-q-q-q-q-q-q-q-q-q-q-q-q-q-q-q-r-r-r-r-r-r-r-r-r-r-r-r-r-r-r-r-r-r-r-r-r-r-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-s.s.s.s.s.s.s.s.s.s.s.s.s.s.s.s.s.s.s.s.s.s.s.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t.t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t/t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t0t1t1t1t1t1t1t1t1t1t1t1t1t1t1t1t1t1t1t1t1t1t1t1t1t1t1t1t1t1t1t1t1t1t1t1t1t1t1t1t1t1t1t1t1t1t1t1t1t1t1t1t1t1t1t1t1t1t1t1t1t1t1t1t1t1t1t1t1t1t1t1t1t1t1t1t1t1u1u1u1u1u1u1u1u1u1v1v1v1v1v1v1v1v1v1v1v1v1v1v1v1v1w1w1w1w1w1w1w1w1w1w1w1w1w1w1w1w1w1w1w1w1w1w1w1w1w1w1w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2w2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x2x3x3x3x3x3x3x3x3x3x3x3x3x3x3x3x3x3x3x3x3x3x3x3x3x3x3x3x3x3x3y3y3y3y3y3y3y3y3y3y3y3y3y3y3y3y3y3y3y3y3y3y3y3y3y3y3y3y3y3y3y3y3y3y3y3y3y3y3y3y3y3y3y3y3y3y3y3y3y3y3y3z3z3z3z3z3z3z3z3z3z3z3z3z3z3z3z3z3z3z3z3z3z3z3z3z3z3z3{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~5555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555566666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777778888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888899999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<================================================================================================================================>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^________________________________________________________________________________________________________________________________````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffgggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggghhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiijjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~€ÀĀŀƀǀȀɀʀˀ̀̀΀πЀрҀӀԀՀր׀؀ـڀۀ܀݀ހ߀ÁāŁƁǁȁɁʁˁ́́΁ρЁсҁӁԁՁցׁ؁فځہ܁݁ށ߁‚ÂĂłƂǂȂɂʂ˂̂͂΂ςЂт҂ӂԂՂւׂ؂قڂۂ܂݂ނ߂ƒÃăŃƃǃȃɃʃ˃̃̓΃σЃу҃ӃԃՃփ׃؃كڃۃ܃݃ރ߃„ÄĄńƄDŽȄɄʄ˄̄̈́΄τЄф҄ӄԄՄքׄ؄لڄۄ܄݄ބ߄…ÅąŅƅDžȅɅʅ˅̅ͅ΅υЅх҅ӅԅՅօׅ؅مڅۅ܅݅ޅ߅†ÆĆņƆdžȆɆʆˆ̆͆ΆφІц҆ӆԆՆֆ׆؆نچۆ܆݆ކ߆‡ÇćŇƇLJȇɇʇˇ͇̇·χЇч҇ӇԇՇևׇ؇هڇۇ܇݇އ߇ˆÈĈňƈLjȈɈʈˈ͈̈ΈψЈш҈ӈԈՈֈ׈؈وڈۈ܈݈ވ߈‰ÉĉʼnƉljȉɉʉˉ͉̉ΉωЉщ҉ӉԉՉ։׉؉ىډۉ܉݉މ߉2.6.3.20230930 Safe-Inferred#"%&'-/369:;<=Agda1Agda42Agda71Agda113Agda154AgdaReturn the error corresponding to an exit code from the Agda process    Safe-Inferred#"%&'-/369:;<=,AgdaCut off structural order comparison at some depth in termination checker?-Agdac >= 0( means: record decrease up to including c+1./AgdaThe default termination depth.,-./,-./  Safe-Inferred#"%&'-/369:;<=z4Agda Semirings.6Agda Addition.7AgdaMultiplication.8AgdaZero. The one is never used in matrix multiplication , one :: a -- ^ One.9AgdaHasZero is needed for sparse matrices, to tell which is the element that does not have to be stored. It is a cut-down version of SemiRing, which is definable without the implicit ?cutoff.=AgdaThe standard semiring on s.>AgdaThe standard semiring on s.?AgdaThe standard semiring on s. 9:45678;<= 9:45678;<=  Safe-Inferred#"%&'-/369:;<=kAAgdaA constant term.BAgda,A term with one hole and the (old) contents.CAgda%A term with many holes (error value).@CBA@CBA  Safe-Inferred#"%&'-/369:;<=FAgdaBetter name for .GAgdaGuard: return the action f only if the boolean is TrueHAgdaGuard: return the value a only if the boolean is TrueIAgdaBranch over a  collection of values.JAgdaBranch over a 3 collection of values using the supplied action.GHIJFGHIJF Safe-Inferred#"%&'-/369:;<=LAgdaTypes isomorphic to .QAgdaBoolean algebras.YAgdaSet difference, dual to X.LNMPOQYXTSRWVUQYXTSRWVULNMPOV3W2 Safe-Inferred$"%&'-/369:;<=>U ]AgdaWe have IsFibrant < IsStrict.^AgdaFibrant universe._AgdaNon-fibrant universe.`AgdaFlavor of standard universe (Prop < Type < SSet,).aAgda!Fibrant universe of propositions.bAgdaFibrant universe.cAgdaNon-fibrant universe.dAgda*The successor universe type of a universe.eAgdaCompute the universe type of a function space from the universe types of domain and codomain.fAgda Conclude u1 from  funUniv u1 u2 and u2.gAgda Conclude u2 from  funUniv u1 u2 and u1.hAgdaFibrancy of standard universes.iAgdaHacky showing of standard universes, does not take actual names into account.fAgdaHave a?Agda` kind of the funSort.Agda` kind of the codomain.Agda` kind of the domain, if unique.gAgda` kind of the funSort.Agda` kind of the domain.Agda`* kind of the codomain, if uniquely exists. ]_^`cbadefghi `cba]_^defghi Safe-Inferred#"%&'-/369:;<={AgdaType of a filter for CallSite|AgdaType of an entry in a  CallStack}AgdaType of a column of a SrcLoc~AgdaType of a line number of a SrcLocAgdaType of a filename of a SrcLoc | e.g. `srcfullAgdaUtilsFoo.hs`Agda$Type of the name of a function in a CallSite | e.g. proveEverythingAgdaType of the module name of a SrcLoc | e.g. AgdaType of the package name of a SrcLoc | e.g. `Agda-2.@`Agda1The same as the un-exported internal function in %GHC.Exceptions (prettyCallStackLines) Prints like: +doFoo, called at foo.hs:190:24 in main:MainAgdaPretty-print a  CallStack". This has a few differences from GHC.Stack.prettyCallStackLines. We omit the "CallStack (from GetCallStack)" header line for brevity. If there is only one entry (which is common, due to the manual nature of the  HasCallStack constraint), shows the entry on one line. If there are multiple, then the following lines are indented.AgdaGet the most recent CallSite in a  CallStack, if there is one.Agda CallStack! comprising only the most recent CallSiteAgda Transform a  CallStack by transforming its list of CallSiteAgda Transform a  CallStack by filtering each CallSiteAgdaPops n entries off a  CallStack using  popCallStack.. Note that frozen callstacks are unaffected.!~}|{y z$ %&'()*+ Safe-Inferred#"%&'-/369:;<=nAgda%The unicode replacement character  .Agda&Is a character a surrogate code point.Agda?Map surrogate code points to the unicode replacement character.AgdaTotal function to convert an integer to a character. Maps surrogate code points to the replacement character U+FFFD. Safe-Inferred#"%&'-/369:;<=2Agda3Tokenization for environment variable substitution.Agda~.Agda $VARIABLE or @${VARIABLE}$.AgdaOrdinary characters.Agda&List of environment variable bindings.AgdaExpand a telescope of environment variables (each value may refer to variables earlier in the list).AgdaTokenize a string. The ~ is recognized as $HOME% only at the beginning of the string.AgdaHome directory.Agda&Environment variable substitution map.AgdaInput.AgdaOutput with variables and ~ (home) substituted. Safe-Inferred#"%&'-/369:;<= Safe-Inferred$"%&'-./369:;<=AgdaRepeat a state transition f :: a -> (b, a) with output b while condition cond on the output is true. Return all intermediate results and the final result where cond is False.(Postconditions (when it terminates): (fst (last (iterWhile cond f a)) == False. $all fst (init (interWhile cond f a)).AgdaRepeat something while a condition on some state is true. Return the last state (including the changes of the last transition, even if the condition became false then).AgdaMonadic version of .Agda%A version of the trampoline function.The usual function iterates f :: a -> Maybe a as long as Just{}, is returned, and returns the last value of a upon Nothing.usualTrampoline f = trampolineWhile $ a -> maybe (False,a) (True,) (f a).trampolineWhile is very similar to  repeatWhile, only that it discards the state on which the condition went False;, and returns the last state on which the condition was True.AgdaMonadic version of .AgdaMore general trampoline, which allows some final computation from iteration state a into result type b.AgdaMonadic version of .AgdaIteration to fixed-point.iterateUntil r f a0 iterates endofunction f, starting with a0 , until r( relates its result to its input, i.e., f a r a.9This is the generic pattern behind saturation algorithms.If f is monotone with regard to r , meaning a r b implies f a r f b , and f-chains starting with a09 are finite then iteration is guaranteed to terminate.*A typical instance will work on sets, and r could be set inclusion, and a0 the empty set, and f- the step function of a saturation algorithm.AgdaMonadic version of .Agda n f x applies f to x n times and returns the result.)The applications are calculated strictly.AgdaapplyWhen b f a applies f to a when b.AgdaapplyUnless b f a applies f to a unless b.AgdaMonadic version of  applyWhenAgdaMonadic version of  applyUnlessAgda version of .Agda version of . Safe-Inferred#"%&'-/369:;<=AgdaSemiring with idempotent  == dioidAgdaE.g. +Agdaneutral element of compose , e.g. zero Safe-Inferred#"%&'-/369:;<=p Agda?A decoration is a functor that is traversable into any functor.The  superclass is given because of the limitations of the Haskell class system.  traverseF actually implies functoriality.Minimal complete definition:  traverseF or  distributeF.Agda traverseF is the defining property.Agda%Decorations commute into any functor.Agda?Composition: pure function after functorial (monadic) function.AgdaThe true pure for loop.  is a misnomer, it should be forA.AgdaInfix version of .Agda#Any decoration is traversable with traverse = traverseF. Just like any 6 is a functor, so is any decoration, given by just  traverseF , a functor.AgdaAny decoration is a lens. set is a special case of dmap.Agda0A typical decoration is pairing with some stuff.Agda3Decorations compose. (Thus, they form a category.)Agda%The identity functor is a decoration.    9 1 Safe-Inferred#"%&'-/369:;<=9Agda Hash tables.AgdaAn empty hash table.AgdaInserts the key and the corresponding value into the hash table.AgdaTries to find a value corresponding to the key in the hash table.Agda"Converts the hash table to a list.5The order of the elements in the list is unspecified. Safe-Inferred#"%&'-/369:;<=dAgdaShould not be used when  could be used.AgdaShould only be used in let or where.Agda7Unstructured pragma (Andreas, 2017-08-23, issue #2712). Safe-Inferred#"%&'-/369:;<=JAgda The function  makes every function argument, case and generator pattern, and  binding strict (except for those patterns that are marked as irrefutable, and anything in a  or :). Note that only the outermost patterns are made strict. Safe-Inferred#"%&'-/369:;<=`AgdaCatch s.Agda#Upon exception, the state is reset.Agda+Upon exception, the written output is lost.Agda Alias of  for the IO monad. Safe-Inferred#"%&'-/369:;<=AgdaReturns a close function for the file together with the contents. Safe-Inferred#"%&'-/369:;<=vAgda=Action to be carried out for copying a directory recursively.AgdaCreate directory if missing.AgdaCopy file if changed.AgdacopyDirContent src dest recursively copies directory src onto dest.First, a to-do list of copy actions is created. Then, the to-do list is carried out.This avoids copying files we have just created again, which can happen if src and dest( are not disjoint. (See issue #2705.)AgdaPerform scheduled .AgdacopyDirContentDryRun src dest; creates a to-do list for recursively copying directory src onto dest.AgdacopyIfChanged src dst makes sure that dst' exists and has the same content as dst. Safe-Inferred#"%&'-/369:;<=+AgdaCreates a temporary file, writes some stuff, and returns the filepath  Safe-Inferred#"%&'-/369:;<=Agda*A kind of exception that can be thrown by  and .Agda#Decoding failed for the given file.AgdaConverts many character sequences which may be interpreted as line or paragraph separators into 'n'.Agda,Strip the byte order mark (BOM) from a Text. (https://github.com/agda/agda/issues/6524 https://github.com/haskell-hvr/cassava/issues/106#issuecomment-373986176AgdaReads a UTF8-encoded text file and converts many character sequences which may be interpreted as line or paragraph separators into 'n'.&If the file cannot be decoded, then a  is raised.AgdaReads a UTF8-encoded text file and converts many character sequences which may be interpreted as line or paragraph separators into 'n'.&If the file cannot be decoded, then a  is raised.AgdaWrites a UTF8-encoded text file. The native convention for line endings is used.AgdaWrites a UTF8-encoded text file. The native convention for line endings is used.! Safe-Inferred#"%&'-/369:;<=EAgdaRead +, modify it strictly, and return old value. " Safe-Inferred#"%&'-/369:;<=ė AgdaMonads in which we can catch an "impossible" error, if possible.Agda Catch any  exception.Agda Catch only # exceptions selected by the filter.Agda Version of , with argument order suiting short handlers.Agda Version of , with argument order suiting short handlers.Agda"Impossible" errors, annotated with a file name and a line number corresponding to the source code location of the error.Agda7We reached a program point which should be unreachable.Agda Impossible with a different error message. Used when we reach a program point which can in principle be reached, but not for a certain run.AgdaWe reached a program point without all the required primitives or BUILTIN to proceed forward. (ImpMissingDefinitions neededDefs forThisAgdaAbort by throwing an "impossible" error. You should not use this function directly. Instead use  IMPOSSIBLEAgda Throw an  Impossible* error reporting the *caller's* call site.Agda Throw an  Unreachable error reporting the *caller's* call site. Note that this call to "withFileAndLine" will be filtered out due its filter on the srcLocModule.  # Safe-Inferred#"%&'-/369:;<=AgdatoImpossible e extracts the  Impossible value raised via  IMPOSSIBLE to create the element e of type Empty. It proceeds by evaluating e to weak head normal form and catching the exception. We are forced to wrap things in a Maybe because of catchImpossible's type.AgdaValues of type  are not forced, because ' is used as a constructor argument in t.$ Safe-Inferred#"%&'-/369:;<=<AgdaIsomorphic to Set .Agdanot . member b.AgdatoSingleton s == Just b iff s == singleton b.AgdaThe empty set.Agda The full set.AgdaA singleton set.% Safe-Inferred#"%&'-/369:;<=̅AgdaA set with duplicates. Faithfully stores elements which are equal with regard to (==).Agda%The list contains all occurrences of a (not just the duplicates!). Hence, the invariant: the list is never empty.AgdaIs the bag empty?Agda7Number of elements in the bag. Duplicates count. O(n).Agda (bag ! a) finds all elements equal to a(. O(log n). Total function, returns [] if none are.Agda O(log n).Agda O(log n).AgdaReturn the multiplicity of the given element. O(log n + count _ _).AgdaO(1)AgdaO(1)Agda "insert a b = union b (singleton a)Agda !fromList = unions . map singletonAgda:Returns the elements of the bag, grouped by equality (==).Agda!Returns the bag, with duplicates.Agda#Returns the bag without duplicates.Agda!Returns the bag, with duplicates.& Safe-Inferred#"%&'-/369:;<=*AgdaAgsy's meta variables.a the type of the metavariable (what it can be instantiated with). blk= the search control information (e.g. the scope of the meta).AgdaMaybe an instantiation (refinement). It is usually shallow, i.e., just one construct(or) with arguments again being metas.AgdaDoes this meta block a principal constraint (i.e., a type-checking constraint).Agda:List of observers, i.e., constraints blocked by this meta.Agda4Used for experiments with independence of subproofs.Agda Experimental.AgdaResult of type-checking.AgdaSuccess.AgdaDefinite failure.Agda Experimental.Agda$Parallel conjunction of constraints.AgdaExperimental, related to . First arg is sidecondition.AgdaForking proof on something that is not part of the term language. E.g. whether a term will reduce or not.Agda Obsolete.AgdaTrav instance a with block type blk' Safe-Inferred$"%&'-/369:;<= AgdaRepresents a set of integers. Invariants: - All cannot be the argument to  or  - at most one  IntsBelow - at most one  IntsAbove - if `Below lo` and `Below hi`, then `lo < hi` - if `Below lo .. (Some xs)` then `all (> lo) xs` - if `Above hi .. (Some xs)` then `all (< hi - 1) xs`Agda MembershipAgdaAll integers `< n`AgdaAll integers `>= n`AgdaA single integer.AgdaFrom a list of integers.Agda No integers.Agda All integers.Agda'If finite, return the list of elements.Agda Invariant.  ( Safe-Inferred#"%&'-/369:;<=AgdaVan Laarhoven style homogeneous lenses. Mnemoic: "Lens outer inner", same type argument order as 'get :: o -> 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'"%&')*-/01369:;<=t Agda An index into a type-level list.Agda4Lists indexed by a type-level list. A value of type All p [xA..xA]% is a sequence of values of types p xA, .., p xA.Agda&Existential wrapper for indexed types.AgdaUnpacking a wrapped value.Agda/Constructing an indexed list from a plain list.Agda/Turning an indexed list back into a plain list.Agda!Indices are just natural numbers.AgdaMapping over an indexed list.Agda>If you have an index you can get a lens for the given element.Agda)Looking up an element in an indexed list.Agda!All indices into an indexed list.* Safe-Inferred#"%&'-/369:;<=~AgdaTokenising the input (makes  cleaner)Agda*Options for Auto, default value and lenses$$+ Safe-Inferred#"%&'-/369:;<=߹Agda(View source:) This is how you implement a lens for a record field., Safe-Inferred$"%&'-/369:;<=Agda;Update monadically the value at one position (must exist!).Agda Wrapper for  for convenience.AgdaFilter a map based on the keys.- Safe-Inferred#"%&'-/369:;<=XAgdaRetain object when tag is .Agda unionWith for collections of size <= 1.Agda unionsWith for collections of size <= 1.Agda Unzipping a list of length <= 1.AgdaFiltering a singleton list. filterMaybe p a =  ( p [a])Agda Version of " with different argument ordering.Agda Version of  with different argument ordering. Often, we want to case on a %, do something interesting in the ( case, but only a default action in the * case. Then, the argument ordering of  caseMaybe is preferable. $caseMaybe m d f = flip (maybe d) m fAgda with flipped branches.AgdaMonadic version of .AgdaMonadic version of .AgdaMonadic version of . That is, $ with a different argument ordering.Agda with flipped branches.AgdaA more telling name for  for the  collection type. Or:  without the  case.Agda without the  case.Agda without the  case.Agda without the  case.AgdaLazy version of allJust  . sequence. (allJust = mapM for the Maybe/ monad.) Only executes monadic effect while isJust.AgdaLift a maybe to an Alternative.AgdaLike , takes the prefix of a list satisfying a predicate. Returns the run of s until the first , and the tail of the list.J Safe-Inferred#"%&'-/369:;<=# AgdaIs the highlighting "token-based", i.e. based only on information from the lexer? AgdaThe defining module. AgdaThe file position in that module. File positions are counted from 1. Agda Has this DefinitionSite/ been created at the defining site of the name? Agda#A pretty name for the HTML linking. Agda6Syntactic aspects of the code. (These cannot overlap.)Meta information which can be associated with a character/character range. AgdaThis note, if not null, can be displayed as a tool-tip or something like that. It should contain useful information about the range (like the module containing a certain identifier, or the fixity of an operator). AgdaThe definition site of the annotated thing, if applicable and known. AgdaIs this entry token-based? AgdaOther aspects, generated by type checking. (These can overlap with each other and with  s.) Agda.A warning that is considered fatal in the end. AgdaUnsolved constraint not connected to meta-variable. This could for instance be an emptyness constraint. AgdaUsed for highlighting unreachable clauses, unreachable RHS (because of an absurd pattern), etc. Agda8Used for shadowed repeated variable names in telescopes. AgdaWhen this constructor is used it is probably a good idea to include a  * explaining why the pattern is incomplete. Agda!Code which is being type-checked. AgdaFunction declaration without matching definition NB: We put CatchallClause last so that it is overwritten by other, more important, aspects in the emacs mode. AgdaNameKind(s are figured out during scope checking. AgdaBound variable. AgdaGeneralizable variable. (This includes generalizable variables that have been generalized). Agda%Inductive or coinductive constructor. Agda Record field. Agda Module name. Agda Primitive. Agda Record type. Agda!Named argument, like x in {x = v} AgdaMacro. Agda Symbols like forall, =, ->, 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 Agda AgdaDelimiters used to separate the Agda code blocks from the other contents in literate Agda AgdaSome  #s are more informative than others. AgdaNameKind in Name can get more precise.< < . Safe-Inferred#"%&'-/369:;<=Agda"Simple, non-reentrant memoisation.AgdaRecursive memoisation, second argument is the value you get on recursive calls./ Safe-Inferred$"%&'-/369:;<=Agda/Maximum of on-negative (small) natural numbers.0 Safe-Inferred#"%&'-/369:;<=Agda Satisfying null empty == True.AgdaViewing  as  (), a boolean is  when it is false.AgdaA  is ' when it corresponds to the empty list.  1 Safe-Inferred#"%&'-/369:;<=\ Agda unionWith for collections of size <= 1.Agda Unzipping a list of length <= 1.AgdaFiltering a singleton list. filterMaybe p a =  ( p [a])Agda Version of " with different argument ordering.Agda Version of  with different argument ordering. Often, we want to case on a %, do something interesting in the ( case, but only a default action in the * case. Then, the argument ordering of  caseMaybe is preferable. (caseMaybe m err f = flip (maybe err) m fAgdaMonadic version of .AgdaMonadic version of .AgdaMonadic version of . That is, $ with a different argument ordering.Agda with flipped branches.AgdaA more telling name for  for the  collection type. Or:  without the  case.Agda without the  case.AgdaNote that strict Maybe is an  only modulo strictness. The laws only hold in the strict semantics. Eg. pure f  * pure _|_ = _|_#, but according to the laws for  it should be  pure (f _|_)3. We ignore this issue here, it applies also to  and . 2 Safe-Inferred$"%&'-/369:;<=AgdaInclusion comparison wrapper.AgdaPointwise comparison wrapper.AgdaDecidable partial orderings.Agda6The result of comparing two things (of the same type).Agda Less than.AgdaLess or equal than.AgdaEqualAgdaGreater or equal.Agda Greater than.AgdaNo information (incomparable).Agda8Comparing the information content of two elements of '. More precise information is smaller.Includes equality: x  x == True.Agda Opposites.related a po b iff related b (oppPO po) a.AgdaCombining two pieces of information (picking the least information). Used for the dominance ordering on tuples.orPO1 is associative, commutative, and idempotent. orPO has dominant element POAny, but no neutral element.AgdaChains (transitivity)  x R y S z.seqPO1 is associative, commutative, and idempotent. seqPO has dominant element POAny and neutral element (unit) POEQ.AgdaEmbed .Agda%Represent a non-empty disjunction of s as .AgdaA ! information is a disjunction of  informations.AgdaAny  is a .Agda+Are two elements related in a specific way? related a o b holds iff comparable a b is contained in o.Agda1Partial ordering forms a monoid under sequencing.Agda.Less is ``less general'' (i.e., more precise).Agda&Pointwise partial ordering for tuples.related (x1,x2) o (y1,y2) iff related x1 o x2 and related y1 o y2.Agda$Partial ordering for disjoint sums: Left _ and Right _ are unrelated.Agda and  _ are unrelated.Partial ordering for Maybe a is the same as for  Either () a.Agda4The pointwise ordering for lists of the same length.There are other partial orderings for lists, e.g., prefix, sublist, subset, lexicographic, simultaneous order.Agda(Sets are partially ordered by inclusion.AgdaSublist for ordered lists.3 Safe-Inferred$"%&'-/369:;<=Agda?Completing POMonoids with inverses to form a Galois connection.Law: composition and inverse composition form a Galois connection. & related (inverseCompose p x) POLE y  == related x POLE (p <> y) AgdaPartially ordered monoid."Law: composition must be monotone.  related x POLE x' && related y POLE y' ==> related (x <> y) POLE (x' <> y') AgdaPartially ordered semigroup."Law: composition must be monotone.  related x POLE x' && related y POLE y' ==> related (x <> y) POLE (x' <> y') AgdahasLeftAdjoint x checks whether  x^-1 := x  mempty is such that x  y == x^-1 <> y for any y.4 Safe-Inferred#"%&'-/369:;<= >AgdaIf f a contains many copies of a they will all be the same pointer in the result. If the function is well-behaved (i.e. preserves the implicit equivalence, this shouldn't matter).5 Safe-Inferred#"%&'-/369:;<= RAgdaStar semirings ( 5https://en.wikipedia.org/wiki/Semiring#Star_semirings).Agda Semirings ( &https://en.wikipedia.org/wiki/Semiring). Safe-Inferred#"%&'-/369:;<=  Safe-Inferred#"%&'-/369:;<= AgdaAn element in a small set.This must implement  and  , and contain at most 64 values.Agda Time O(1).Agda Time O(1).Agdanot . member a . Time O(1).AgdaThe empty set. Time O(1).AgdaThe full set. Time O(1).AgdaA singleton set. Time O(1).Agda Time O(1).Agda Time O(1).Agda Time O(n).Agda Time O(1).Agda Time O(1).Agda Time O(1).Agda Time O(n).Agda Time O(n).Agda Time O(n).Agda Time O(n).Agda Time O(n).Agda Time O(n).Agda Time O(n).6 Safe-Inferred#"%&'-/369:;<= Agda Overloaded  singleton constructor for collections.Agda0Create-only collection with at most one element.AgdaA create-only possibly empty collection is a monoid with the possibility to inject elements.7 Safe-Inferred$"%&'-/369:;<=AgdaGiven a function f :: a -> NonEmpty c9 which returns a non-empty list of characteristics of a, partition a list of as into groups such that each element in a group shares at least one characteristic with at least one other element of the group.AgdaPartition a list of as paired with a non-empty list of characteristics into groups such that each element in a group shares at least one characteristic with at least one other element of the group.8 Safe-Inferred#"%&'-/369:;<= Agda&Classification of identifier variants.AgdaIdentifier ends in Integer many primes.AgdaIdentifier ends in number Integer (ordinary digits).AgdaIdentifier ends in number Integer (subscript digits).Agda'Is the character one of the subscripts 'A'-'A'?Agda Converts '0'-'9' to 'A'-'A'-Precondition: The digit needs to be in range.Agda Converts 'A'-'A' to '0'-'9'.-Precondition: The digit needs to be in range.AgdaIncrease the suffix by one.Agda Parse suffix.Agda Print suffix.  9 Safe-Inferred#"%&'-/369:;<=AgdaDisjoint sum of three.AgdaEnum type with 3 elements.AgdaPartition a list into 3 groups.)Preserves the relative order or elements.AgdaPartition a list into 3 groups.)Preserves the relative order or elements.  : Safe-Inferred#"%&'-/369:;<=AgdaFinite map from [k] to v.With the strict  type,  is also strict in v.Agda"Helper function used to implement  and .AgdaSingleton trie.AgdaeveryPrefix k v! is a trie where every prefix of k (including k itself) is mapped to v.AgdaLeft biased union.#union = unionWith ( new old -> new).Agda/Pointwise union with merge function for values.Agda.Insert. Overwrites existing value if present. %insert = insertWith ( new old -> new)Agda6Insert with function merging new value with old value.Agda.Delete value at key, but leave subtree intact.Agda*Adjust value at key, leave subtree intact.AgdaConvert to ascending list.AgdaConvert to ascending list.AgdaConvert to list where nodes at the same level are ordered according to the given ordering.AgdaCreate new values based on the entire subtrie. Almost, but not quite comonad extend.Agda8Returns the value associated with the given key, if any.Agda%Is the given key present in the trie?Agda&Collect all values along a given path.Agda(Get the subtrie rooted at the given key.AgdaFilter a trie.Agda Key lens.Agda Empty trie. Safe-Inferred#"%&'-/369:;<=FAgdaBifunctoriality for pairs.Agda mapFst f = f -*- idAgda mapSnd g = id -*- gAgdaLifted pairing.AgdaMonadic version of .AgdaMonadic .AgdaMonadic .jj23; Safe-Inferred#"%&'-/369:;<=BAgda$Internal state for stripping suffix.AgdaError.Agda8"Negative string" to remove from end. List may be empty.Agda+"Positive string" (result). Non-empty list.AgdaAppend a single element at the end. Time: O(length); use only on small lists.Agda5Case distinction for lists, with list first. O(1).Cf. 0.Agda5Case distinction for lists, with list first. O(1).Cf. 0.Agda4Case distinction for lists, with list last. O(1).AgdaHead function (safe). Returns a default value on empty lists. O(1). >headWithDefault 42 [] = 42 headWithDefault 42 [1,2,3] = 1AgdaTail function (safe). O(1).AgdaTail function (safe). Returns a default list on empty lists. O(1).AgdaLast element (safe). O(n).AgdaLast element (safe). Returns a default list on empty lists. O(n).Agda3Last element of non-empty list (safe). O(n). last1 a as = last (a : as)Agda"Last two elements (safe). O(n).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 ++ asAgda and  in one go, safe. O(n).Agda and & of non-empty list, safe. O(n). *initLast1 a as = (init (a:as), last (a:as)Agda& of non-empty list, safe. O(n). init1 a as = init (a:as)Agdainit, safe. O(n).Agdainit, safe. O(n).Agda*Lookup function (safe). O(min n index).Agda A variant of  that might provide more informative error messages if the index is out of bounds.4Precondition: The index should not be out of bounds.AgdaLookup function with default value for index out of range. O(min n index).The name is chosen akin to .AgdaFind an element satisfying a predicate and return it with its index. O(n) in the worst case, e.g. findWithIndex f xs = Nothing.%TODO: more efficient implementation!?AgdaA generalised variant of  elemIndex. O(n).AgdadownFrom n = [n-1,..1,0] . O(n).Agda:Update the first element of a list, if it exists. O(1).Agda9Update the last element of a list, if it exists. O(n).Agda/Update nth element of a list, if it exists. O(min index n). Precondition: the index is >= 0.Agda#splitExactlyAt n xs = Just (ys, zs) iff  xs = ys ++ zs and genericLength ys = n.Agda*Drop from the end of a list. O(length). &dropEnd n = reverse . drop n . reverseForces the whole list even for n==0.AgdaSplit off the largest suffix whose elements satisfy a predicate. O(n).spanEnd p xs = (ys, zs) where  xs = ys ++ zs and all p zs and #maybe True (not . p) (lastMaybe yz).AgdaBreaks a list just after1 an element satisfying the predicate is found. breakAfter1 even 1 [3,5,2,4,7,8](1 :| [3,5,2],[4,7,8])AgdaBreaks a list just after1 an element satisfying the predicate is found.breakAfter even [1,3,5,2,4,7,8]([1,3,5,2],[4,7,8])AgdaA generalized version of  takeWhile . (Cf. mapMaybe vs. filter#). @O(length . takeWhileJust f)."takeWhileJust f = fst . spanJust f.AgdaA generalized version of span. O(length . fst . spanJust f).AgdaPartition a list into s and  s. O(n). partitionMaybe f = partitionEithers . map ( a -> maybe (Left a) Right (f a))Note:  f = snd . partitionMaybe f.AgdaLike , but additionally return the last partition of the list where the predicate is False everywhere. O(n).AgdaLike , but additionally return the last partition of the list where the function always returns Nothing . O(n).AgdaSublist relation.Agda7All ways of removing one element from a list. O(n).Agda6Compute the common prefix of two lists. O(min n m).AgdaDrops from both lists simultaneously until one list is empty. O(min n m).AgdaCheck if a list has a given prefix. If so, return the list minus the prefix. O(length prefix).Agda4Compute the common suffix of two lists. O(n + m).AgdastripSuffix suf xs = Just pre iff xs = pre ++ suf. O(n).Agda&stripReversedSuffix rsuf xs = Just pre iff xs = pre ++ reverse suf . O(n).AgdaReturns a list with one boolean for each non-empty suffix of the list, starting with the longest suffix (the entire list). Each boolean is  exactly when every element in the corresponding suffix satisfies the predicate. An example:    AbCde( = [False, False, False, True, True] For total predicates p and finite and total lists xs the following holds:   p xs =  ( p) ( ( xs)) Agda,Find the longest suffix of the first string xs* that is a prefix of the second string ys. So, basically, find the overlap where the strings can be glued together. Returns the index where the overlap starts and the length of the overlap. The length of the overlap plus the index is the length of the first string. Note that in the worst case, the empty overlap  (length xs,0) is returned.)Worst-case time complexity is quadratic:  O(min(n,m)) where  n = length xs and  m = length ys.There might be asymptotically better implementations following Knuth-Morris-Pratt (KMP), but for rather short lists this is good enough.Agda2Chop up a list in chunks of a given length. O(n).AgdaChop a list at the positions when the predicate holds. Contrary to wordsBy, consecutive separator elements will result in an empty segment in the result. O(n). *intercalate [x] (chopWhen (== x) xs) == xsAgdaCheck membership for the same list often. Use partially applied to create membership predicate hasElem xs :: a -> Bool. First time:  O(n log n) in the worst case.Subsequently: O(log n).Specification: hasElem xs == ( xs).Agda&Check whether a list is sorted. O(n).Assumes that the % instance implements a partial order.AgdaCheck whether all 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 xsAgdaEfficient variant of nubBy for lists, using a set to store already seen elements. O(n log n)Specification: )nubOn f xs == 'nubBy' ((==) `'on'` f) xs.Agda A variant of  that is parametrised by a function that is used to select which element from a group of equal elements that is returned. The returned elements keep the order that they had in the input list. Ŋ $ Ċ "\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$"%&'-/369:;<=P Agda Lossless , opposite of . AgdaSafe version of . Agda%Return the last element and the rest. Agda"Last two elements (safe). O(n). AgdaBuild a list with one element.More precise type for snoc. Agda  f =  ((NJ ) `on` f) Ȋ Ɋ (ʊ `on` f). O(n log n). AgdaMore precise type for ;. A variant of ˊ: which applies the predicate to consecutive pairs. O(n). Agda= 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#"%&'-/369:;<=d Agda%Things that support delayed dropping. Agda)Delayed dropping which allows undropping. Agda&Non-negative number of things to drop. AgdaWhere to drop from. Agda3Invert a Permutation on a partial finite int map. inversePermute perm f = f' such that permute perm f' = f!Example, with map represented as  [Maybe a]:  f = [Nothing, Just a, Just b ] perm = Perm 4 [3,0,2] f' = [ Just a , Nothing , Just b , Nothing ]  Zipping perm with f gives  [(0,a),(2,b)], after compression with  catMaybes. This is an IntMap9 which can easily written out into a substitution again. AgdaPartial permutations. Examples:)permute [1,2,0] [x0,x1,x2] = [x1,x2,x0] (proper permutation).&permute [1,0] [x0,x1,x2] = [x1,x0] (partial permuation).,permute [1,0,1,2] [x0,x1,x2] = [x1,x0,x1,x2]- (not a permutation because not invertible).Agda typing would be: 9Perm : {m : Nat}(n : Nat) -> Vec (Fin n) m -> Permutation m is the   of the permutation. Agda'permute [1,2,0] [x0,x1,x2] = [x1,x2,x0] More precisely, permute indices list = sublist , generates sublist from list1 by picking the elements of list as indicated by indices. *permute [1,3,0] [x0,x1,x2,x3] = [x1,x3,x0]Agda typing: ,permute (Perm {m} n is) : Vec A m -> Vec A nPrecondition for   (  _ is) xs: Every index in is must be non-negative and, if xs is finite, then every index must also be smaller than the length of xs.The implementation is supposed to be extensionally equal to the following one (if different exceptions are identified), but in some cases more efficient:  permute (  _ is) xs =  (xs ;) is AgdaIdentity permutation. Agda"Restrict a permutation to work on n elements, discarding picks >=n. Agda9Pick the elements that are not picked by the permutation. AgdaliftP k takes a  Perm {m} n to a Perm {m+k} (n+k). Analogous to ?, but Permutations operate on de Bruijn LEVELS, not indices. Agda 2permute (compose p1 p2) == permute p1 . permute p2 Agda invertP err p is the inverse of p) where defined, otherwise defaults to err. composeP p (invertP err p) == p AgdaTurn a possible non-surjective permutation into a surjective permutation. Agda ?permute (reverseP p) xs == reverse $ permute p $ reverse xs Example:  permute (reverseP (Perm 4 [1,3,0])) [x0,x1,x2,x3] == permute (Perm 4 $ map (3-) [0,3,1]) [x0,x1,x2,x3] == permute (Perm 4 [3,0,2]) [x0,x1,x2,x3] == [x3,x0,x2] == reverse [x2,x0,x3] == reverse $ permute (Perm 4 [1,3,0]) [x3,x2,x1,x0] == reverse $ permute (Perm 4 [1,3,0]) $ reverse [x0,x1,x2,x3] With reverseP, you can convert a permutation on de Bruijn indices to one on de Bruijn levels, and vice versa. Agda8permPicks (flipP p) = permute p (downFrom (permRange p)) or permute (flipP (Perm n xs)) [0..n-1] = permute (Perm n xs) (downFrom n)Can be use to turn a permutation from (de Bruijn) levels to levels to one from levels to indices.See . Agda expandP i n  in the domain of  replace the ith element by n elements. AgdaStable topologic sort. The first argument decides whether its first argument is an immediate parent to its second argument. AgdaPerform the dropping. Agda Drop more. AgdaPick up dropped stuff.  ? Safe-Inferred#"%&'-/369:;<=k Agda A set of  s AgdaVarious things that can be measured when checking an Agda development. Turned on with the `--profile` flag, for instance `--profile=sharing` to turn on the   option.  ,  , and   are mutually exclusive.NOTE: Changing this data type requires bumping the interface version number in . AgdaMeasure time taken by various parts of the system (type checking, serialization, etc) Agda/Measure time spent on individual (Agda) modules Agda3Measure time spent on individual (Agda) definitions Agda!Measure things related to sharing Agda/Collect detailed statistics about serialization Agda+Collect statistics about constraint solving Agda%Count number of created metavariables Agda$Measure time of interactive commands Agda,Collect statistics about conversion checking Agda#The empty set of profiling options. AgdaStrings accepted by  AgdaParse and add a profiling option to a set of profiling options. Returns ͊ with a helpful error message if the option doesn't parse or if it's incompatible with existing options. The special string "all" adds all options compatible with the given set and prefering the first of incompatible options. So `--profile=all` sets   over   and  0, but `--profile=modules --profile=all` sets   and not  . AgdaCheck if a given profiling option is present in a set of profiling options. AgdaUse only for serialization. AgdaUse only for serialization.  @ Safe-Inferred#"%&'-/369:;<=m AgdaLists of length D2. Agda Unsafe! O(1). Agda Safe. O(1). Agda Safe. O(1). Agda Safe. O(1). AgdaAny  is either a singleton or a  . O(1). Agda Inverse of  . O(1). AgdaO(1). AgdaO(length first list). AgdaO(length first list). Agda Safe. O(1). Agda Safe. O(1). Agda Safe. O(n). Agda is unsafe.  A Safe-Inferred$"%&'-/369:;<=t AgdaDenotational equality for floating point numbers, checks bitwise equality.NOTE: Denotational equality distinguishes NaNs, so its results may vary depending on the architecture and compilation flags. Unfortunately, this is a problem with floating-point numbers in general. AgdaI guess "denotational orderings" are now a thing? The point is that we need an Ord instance which provides a total ordering, and is consistent with the denotational equality.NOTE: The ordering induced via  * is total, and is consistent with  . However, it is *deeply* unintuitive. For one, it considers all negative numbers to be larger than positive numbers. AgdaReturn Just x if it's a finite number, otherwise return Nothing. AgdaRemove suffix .0$ from printed floating point number. Agda$Decode a Double to an integer ratio. Agda$Encode an integer ratio as a double. AgdaDecode a Double to its mantissa and its exponent, normalised such that the mantissa is the smallest possible number without loss of accuracy. AgdaChecks whether or not the Double is within a safe range of operation.ΊAgdaThe smallest representable mantissa. Simultaneously, the smallest integer which can be represented as a Double without loss of precision.ϊAgdaThe largest representable mantissa. Simultaneously, the largest integer which can be represented as a Double without loss of precision.ЊAgda#The largest representable exponent.ъAgda$The smallest representable exponent. Agda.Encode a mantissa and an exponent as a Double.+ +  Safe-Inferred#"%&'-/369:;<=|0AgdaWhile Ҋ- is for rendering data in Haskell syntax,  is for displaying data to the world, i.e., the user and the environment.Atomic data has no inner document structure, so just implement  as pretty a = text $ ... a ....Agda5The type of documents. We use documents annotated by   to record syntactic highlighting information that is generated during pretty-printing.AgdaUse instead of Ċ when printing to world.Agda1Separate, but only if both separees are not null.Agda+Comma separated list, without the brackets.AgdaPretty print a set.Agda!Pretty print an association list.Agda"Pretty print a single association.AgdaApply  to  if boolean is true.AgdaOnly wrap in parens if not Agdaalign max rows lays out the elements of rows in two columns, with the second components aligned. The alignment column of the second components is at most max2 characters to the right of the left-most column.Precondition: max > 0.Agda?Handles strings with newlines properly (preserving indentation)Agda a  ? b = hang a 2 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 {...}6U Safe-Inferred#"%&'-/369:;<=Agda"CPU time in pico (10^-12) seconds.Agda Timestamps.AgdaThe current time.AgdaMeasure the time of a computation. Of course, does not work with exceptions.Agda(Print CPU time in milli (10^-3) seconds.V Safe-Inferred#"%&'-/369:;<=ӊAgdaThe extended parser type computes one top-level document, plus one document per encountered memoisation key. is used to mark that a given memoisation key has been seen, but that no corresponding document has yet been stored.Agda(Documents paired with precedence levels.AgdaAn extended parser type, with some support for printing parsers.ԊAgdaInvariant: If the boolean is , then the result must be ͊ something, and if the boolean is Պ, then the result must be ֊ something.AgdaRuns the parser.Agda&Tries to print the parser, or returns , depending on the implementation. This function might not terminate.AgdaParses a token satisfying the given predicate. The computed value is returned.AgdaUses the given function to modify the printed representation (if any) of the given parser.AgdaMemoises the given parser./Every memoised parser must be annotated with a unique key. (Parametrised parsers must use distinct keys for distinct inputs.)AgdaMemoises the given parser, but only if printing, not if parsing./Every memoised parser must be annotated with a unique key. (Parametrised parsers must use distinct keys for distinct inputs.)AgdaThe parser type.The parameters of the type Parser k r tok a have the following meanings: kType used for memoisation keys.rThe type of memoised values. (Yes, all memoised values have to have the same type.)tokThe token type.aThe result type.׊AgdaMemoised values.؊AgdaContinuations.يAgdaState monad used by the parser.ڊAgda Positions.AgdaUses the given document as the printed representation of the given parser. The document's precedence is taken to be .Agda.Parses a token satisfying the given predicate.AgdaParses a single token.AgdaParses a given token.AgdaPrecedence of >>=.AgdaPrecedence of  |.AgdaPrecedence of  *.AgdaPrecedence of E and +.AgdaPrecedence of atoms.ۊAgdaA smart constructor.܊AgdaExtracts the parser.݊AgdaExtracts the documents.ފAgdaA helper function.ߊAgda Pretty-prints a memoisation key.AgdaA helper function. Safe-Inferred#"%&'-/369:;<=t Safe-Inferred#"%&'-/369:;<=! ~}|{ %&'()*+yz$! ~}|{ %&'()*+yz$` Safe-Inferred#"%&'-/369:;<= %AgdaSimple Emacs Lisp expressions.%AgdaAtom.%AgdaList.%AgdaFormats a response command. Replaces 'n'= with spaces to ensure that each command is a single line.%Agda-Writes a response command to standard output.Agda0displayInBuffer buffername append header content displays content (with header header%) in some suitable way in the buffer  buffername. If append is True, then the content is appended to previous content (if any), otherwise any previous content is deleted.Agda$The name of the running info buffer.%AgdaClear the running info buffer.%AgdaClear the warning buffer%AgdaDisplay running information about what the type-checker is up to. %%%%%%%%%%% %%%%%%%%%%%  Safe-Inferred#"%&'-/369:;<= Agda Loop while we have an exception. AgdaMonadic version of $ with a different argument ordering. Agda'Either _ b' is a functor. Agda'Either a' is a functor. Agda is bitraversable. Note: From base >= 4.10.0.0 already present in . Agda Analogue of . Agda Analogue of . Agda Analogue of -. Agda Analogue of -. AgdaSafe projection from ͊. 8maybeLeft (Left a) = Just a maybeLeft Right{} = Nothing AgdaSafe projection from ֊.  x) xs) else Nothing Agda)Groups a list into alternating chunks of ͊ and ֊ values AgdaConvert  to  e, given an error e for the  case. Agda Swap tags ͊ and ֊. K  K  Safe-Inferred#"%&'-/369:;<= Agda Binary bind. AgdaMonadic guard. AgdaMonadic if-then-else. Agda ifNotM mc = ifM (not  $ mc) AgdaLazy monadic conjunction. AgdaLazy monadic disjunction. AgdaLazy monadic disjunction with Either> truth values. Returns the last error message if all fail. AgdaLazy monadic disjunction with accumulation of errors in a monoid. Errors are discarded if we succeed. AgdaGeneralized version of 8traverse_ :: Applicative m => (a -> m ()) -> [a] -> m () Executes effects and collects results in left-to-right order. Works best with left-associative monoids.!Note that there is an alternative !mapM' f t = foldr mappend mempty  $ mapM f tthat collects results in right-to-left order (effects still left-to-right). It might be preferable for right associative monoids. AgdaGeneralized version of 3for_ :: Applicative m => [a] -> (a -> m ()) -> m () AgdaA monadic version of  :: (a -> Maybe b) -> [a] -> [b]. Agda A version of  ' with a computation for the input list. AgdaThe for version of  . AgdaThe for version of  . AgdaA monadic version of  :: (a -> Bool) -> [a] -> [a]. AgdaA monadic version of  dropWhileEnd :: (a -> Bool) -> [a] -> m [a]:. Effects happen starting at the end of the list until p becomes false. AgdaA `monadic' version of @ partition# :: (a -> Bool) -> [a] -> ([a],[a]) Agda Translates  to . AgdaGeneralises the & function from lists to an arbitrary . Agda"Branch over elements of a monadic  data structure. AgdaFinally for the Error class. Errors in the finally part take precedence over prior errors. AgdaTry a computation, return  if an Error occurs. Agda1Run a command, catch the exception and return it. AgdaLike -, but raise given error when condition fails. Agda;Bracket without failure. Typically used to preserve state. Agda Restore state after computation. AgdaOutput a single value. AgdaAcquires resource. Run first.AgdaReleases resource. Run last.Agda Computes result. Run in-between./   /   B Safe-Inferred%"%&'-/369:;<=d Agda.Lazy monadic computation of a list of results. AgdaBoilerplate function to lift  through the   transformer. Agda Inverse to  . AgdaThe empty lazy list. AgdaConsing a value to a lazy list. AgdaSingleton lazy list. Agda Case distinction over lazy list. Agda+Folding a lazy list, effects left-to-right. AgdaLazy monadic disjunction of lazy monadic list, effects left-to-right AgdaLazy monadic conjunction of lazy monadic list, effects left-to-right Agda8Force all values in the lazy list, effects left-to-right AgdaThe join operation of the ListT m monad. AgdaWe can `run' a computation of a   as it is monadic itself. Agda Monadic cons. AgdaMonadic singleton. Agda Extending a monadic function to  . Agda!Alternative implementation using  . Agda Change from one monad to another  K Safe-Inferred$"%&'-/369:;<=[ Agda%Paths which are known to be absolute.Note that the  and  instances do not check if different paths point to the same files or directories.Agda Extract the  to be used as .Agda Constructs s.2Precondition: The path must be absolute and valid.AgdaMakes the path absolute.This function may raise an __IMPOSSIBLE__ error if " does not return an absolute path.Agda!Resolve symlinks etc. Preserves .AgdaTries to establish if the two file paths point to the same file (or directory). False negatives may be returned.AgdaCase-sensitive  for Windows.This is case-sensitive only on the file name part, not on the directory part. (Ideally, path components coming from module name components should be checked case-sensitively and the other path components should be checked case insensitively.)AgdaTrue if the first file is newer than the second file. If a file doesn't exist it is considered to be infinitely old.AgdaA partial version of & with flipped arguments, returning 6 if the given path cannot be relativized to the given root.Agda'The absolute path we see to relativize.AgdaThe root for relativization.AgdaThe relative path, if any.  L Safe-Inferred#"%&'-/369:;<=?AgdaHashes a piece of .Agda-Hashing a module name for unique identifiers.X Safe-Inferred#"%&'-/369:;<=Agda'Monad with access to benchmarking data.AgdaWe need to be able to terminate benchmarking in case of an exception.AgdaBenchmark structure is a trie, mapping accounts (phases and subphases) to CPU time spent on their performance.AgdaAre we benchmarking at all?Agda!What are we billing to currently?Agda/The accounts and their accumulated timing bill.Agda3Record when we started billing the current account.Agda(Account we can bill computation time to.AgdaSemantic editor combinator.AgdaSemantic editor combinator.AgdaSemantic editor combinator.Agda"Add to specified CPU time account.AgdaTurn benchmarking on/off.AgdaBill current account with time up to now. Switch to new account. Return old account (if any).Agda.Resets the account and the timing information.AgdaBill a computation to a specific account. Works even if the computation is aborted by an exception.Agda;Bill a CPS function to an account. Can't handle exceptions.Agda.Bill a pure computation to a specific account.Agda2Print benchmark as three-column table with totals.Agda$Initial benchmark structure (empty).AgdaMaybe new account.AgdaMaybe old account.C Safe-Inferred#"%&'-/369:;<=. AgdaFinite maps from k to v!, with a way to quickly get from v to k for certain values of type v (those for which   is defined).&Every value of this type must satisfy  . Agda0Partial injections from a type to some tag type.The idea is that  ( should be injective on its domain: if   x =   y =  i, then x = y. However, this property does not need to hold globally. The preconditions of the  3 operations below specify for which sets of values   must be injective. AgdaChecks if the function   is injective for the values in the given list for which the function is defined. AgdaThe invariant for  . Agda$Is the value a source key? O(log n). Agda$Is the value a target key? O(log n). AgdaLookup. O(log n). AgdaInverse lookup. O(log n). AgdaSingleton map. O(1). Agda0Insertion. Overwrites existing values. O(log n).Precondition: See  . AgdaThe precondition for   k v m: If v has a   (  v D ), then m must not contain any mapping k' C v' for which k D k' and   v =   v'. AgdaModifies the value at the given position, if any. If the function returns &, then the value is removed. O(log n).The precondition for   f k m is that, if the value v is inserted into m, and   v% is defined, then no key other than k may map to a value v' for which   v' =   v. AgdaModifies the value at the given position, if any. If the function returns &, then the value is removed. O(log n).Precondition: See  . AgdaThe precondition for   f k m is that, if the value v is inserted into m, and   v% is defined, then no key other than k may map to a value v' for which   v' =   v. AgdaModifies the value at the given position, if any. If the function returns &, then the value is removed. O(log n).Precondition: See  . AgdaThe precondition for   f k m is that, if the value v is inserted into m, and   v% is defined, then no key other than k may map to a value v' for which   v' =   v. Agda;Modifies the value at the given position, if any. O(log n).Precondition: See  . AgdaThe precondition for   f k m is that, if the value v is inserted into m, and   v% is defined, then no key other than k may map to a value v' for which   v' =   v. AgdaInserts a binding into the map. If a binding for the key already exists, then the value obtained by applying the function to the key, the new value and the old value is inserted, and the old value is returned.Precondition: See  . AgdaThe precondition for   f k v m is that, if the value v' is inserted into m, and   v'% is defined, then no key other than k may map to a value v'' for which   v'' =   v'. AgdaChanges all the values using the given function, which is also given access to keys. O(n log n).Precondition: See  . AgdaThe precondition for   f m!: For any two distinct mappings kA C vA, kA C vA in m for which the tags of f kA vA and f kA vA are defined the values of f must be distinct (f kA vA D f kA vA). Furthermore   must be injective for { f k v | (k, v) D m }. AgdaChanges all the values using the given function, which is also given access to keys. O(n).Precondition: See  ". Note that tags must not change. AgdaThe precondition for   f m is that, if m maps k to v, then   (f k v) ==   v. Agda0Left-biased union. For the time complexity, see .Precondition: See  . AgdaConversion from lists of pairs. Later entries take precedence over earlier ones. O(n log n).Precondition: See  . AgdaConversion to lists of pairs, with the keys in ascending order. O(n). Agda#The keys, in ascending order. O(n). Agda>The values, ordered according to the corresponding keys. O(n). AgdaConversion from two lists that contain distinct keys/tags, with the keys/tags in ascending order. O(n).Precondition: See  . AgdaGenerates input suitable for  . O(n).' ' ^ Safe-Inferred#"%&'-/369:;<=5 AgdaPicking the appropriate set of special characters depending on whether we are allowed to use unicode or have to limit ourselves to ascii. AgdaWe want to know whether we are allowed to insert unicode characters or not. AgdaS!: Unicode characters are allowed. Agda'false: Stick to ASCII.Agda3Are we allowed to use unicode supscript characters? AgdaReturn the glyph set based on a given (unicode or ascii) glyph modeAgda/Choose the glyph set based on the unsafe IORef.  D Safe-Inferred#"%&'-/369:;<= AgdaThe  WarningName data enumeration is meant to have a one-to-one correspondance to existing warnings in the codebase.Agda9From user-given directives we compute WarningMode updates Agda2Some warnings are errors and cannot be turned off. AgdaA  WarningMode has two components: a set of warnings to be displayed and a flag stating whether warnings should be turned into fatal errors. AgdaThe defaultWarningMode is a curated set of warnings covering non-fatal errors and disabling style-related ones AgdawarningModeUpdate str computes the action of str over the current  WarningMode: it may reset the set of warnings, add or remove a specific flag or demand that any warning be turned into an error AgdaCommon sets of warnings AgdaWarnings enabled by  --exact-split. AgdaThe flag corresponding to a warning is precisely the name of the constructor minus the trailing underscore. Agda warningUsage generated using warningNameDescriptionAgda WarningName descriptions used for generating usage information Leave String empty to skip that name.The description should be a completion of the sentence "This warning is about ...". So, typically the subject is in plural.  E Safe-Inferred#"%&'-/369:;<=AgdaList of Help Topics NOTA BENE: You need to add each new topic together with its name to  allHelpTopics AgdaInterface to the help function AgdaGeneral usage information Agda)Specialised usage information about TOPIC AgdaUsage information generation AgdaConversion functions to strings  M Safe-Inferred#"%&'-/369:;<=Agda SCC DAGs.0The maps map SCC indices to and from SCCs/nodes.AgdaWithUniqueInt n consists of pairs of (unique) s and values of type n.2Values of this type are compared by comparing the s.AgdaVarious kinds of nodes.AgdaNodes with outgoing edges.AgdaNodes with incoming edges.Agda!All nodes, with or without edges.AgdaEdges.AgdaOutgoing node.AgdaIncoming node.AgdaEdge label (weight).Agda Graph n e, is a type of directed graphs with nodes in n and edges in e.At most one edge is allowed between any two nodes. Multigraphs can be simulated by letting the edge type e be a collection type.The graphs are represented as adjacency maps (adjacency lists, but using finite maps instead of arrays and lists). This makes it possible to compute a node's outgoing edges in logarithmic time (O(log n)). However, computing the incoming edges may be more expensive.Note that neither the number of nodes nor the number of edges may exceed Š :: .AgdaForward edges.AgdaInternal invariant.AgdaIf there is an edge from s to t, then  lookup s t g is  e, where e is the edge's label. O(log n).AgdaThe graph's edges. O(n + e).Agdaneighbours u g consists of all nodes v" for which there is an edge from u to v in g-, along with the corresponding edge labels.  O(log n + |neighbours u g|).AgdaneighboursMap u g consists of all nodes v" for which there is an edge from u to v in g-, along with the corresponding edge labels. O(log n).AgdaedgesFrom g ns is a list containing all edges originating in the given nodes (i.e., all outgoing edges for the given nodes). If ns does not contain duplicates, then the resulting list does not contain duplicates. O(|ns| log |n| + |edgesFrom g ns|).Agda edgesTo g ns is a list containing all edges ending in the given nodes (i.e., all incoming edges for the given nodes). If ns does not contain duplicates, then the resulting list does not contain duplicates. O(|ns | n log n).AgdaAll self-loops.  O(n log n).Agda All nodes. O(n).AgdaNodes with outgoing edges. O(n).AgdaNodes with incoming edges. O(n + e log n).Agda Constructs a  structure. O(n + e log n).Agda*Nodes without incoming or outgoing edges. O(n + e log n).AgdaChecks whether the graph is discrete (containing no edges other than  edges). O(n + e).AgdaReturns True iff the graph is acyclic.AgdaConstructs a completely disconnected graph containing the given nodes.  O(n log n).AgdaConstructs a completely disconnected graph containing the given nodes. O(n).Agda fromEdges es$ is a graph containing the edges in es=, with the caveat that later edges overwrite earlier edges. O(|es| log n).AgdafromEdgesWith f es$ is a graph containing the edges in es. Later edges are combined with earlier edges using the supplied function. O(|es| log n).Agda"Empty graph (no nodes, no edges). O(1).Agda5A graph with two nodes and a single connecting edge. O(1).Agda Inserts an edge into the graph. O(log n).Agda Inserts an edge into the graph. O(log n).AgdainsertWith f s t new inserts an edge from s to t3 into the graph. If there is already an edge from s to t with label old6, then this edge gets replaced by an edge with label  f new old%, and otherwise the edge's label is new. O(log n).Agda A variant of . O(log n).AgdaLeft-biased union.Time complexity: See .AgdaUnion. The function is used to combine edge labels for edges that occur in both graphs (labels from the first graph are given as the first argument to the function).Time complexity:  O(nA log (nAnA + 1) + eA log eA), where nA/ is the number of nodes in the graph with the smallest number of nodes and nA0 is the number of nodes in the other graph, and eA is the number of edges in the graph with the smallest number of edges and eA+ is the number of edges in the other graph."Less complicated time complexity: O((n + e) log n (where n and e refer to the resulting graph).AgdaUnion. O((n + e) log n (where n and e refer to the resulting graph).AgdaUnion. The function is used to combine edge labels for edges that occur in several graphs. O((n + e) log n (where n and e refer to the resulting graph).Agda A variant of < that provides extra information to the function argument. O(n + e).AgdaReverses an edge. O(1).Agda.The opposite graph (with all edges reversed). O((n + e) log n).AgdaRemoves  edges. O(n + e).Agda The graph filterNodes p g# contains exactly those nodes from g that satisfy the predicate p=. Edges to or from nodes that are removed are also removed. O(n + e).AgdaremoveNodes ns g removes the nodes in ns% (and all corresponding edges) from g. O((n + e) log |ns|).AgdaremoveNode n g removes the node n% (and all corresponding edges) from g. O(n + e).AgdaremoveEdge s t g removes the edge going from s to t , if any. O(log n).Agda0Keep only the edges that satisfy the predicate. O(n + e).AgdaRemoves the nodes that do not satisfy the predicate from the graph, but keeps the edges: if there is a path in the original graph between two nodes that are retained, then there is a path between these two nodes also in the resulting graph.(Precondition: The graph must be acyclic.Worst-case time complexity:  O(e n log n)) (this has not been verified carefully).AgdaRenames the nodes.6Precondition: The renaming function must be injective.Time complexity: O((n + e) log n).AgdaRenames the nodes.$Precondition: The renaming function ren" must be strictly increasing (if x  y then ren x  ren y).Time complexity: O(n + e).Agda'Combines each node label with a unique .Precondition: The number of nodes in the graph must not be larger than Š :: .Time complexity: O(n + e log n).AgdaUnzips the graph. O(n + e).AgdacomposeWith times plus g g' finds all edges s --c_i--> t_i --d_i--> u) and constructs the result graph from !edge(s,u) = sum_i (c_i times d_i).Complexity: For each edge s --> t in g' we look up all edges starting with t in g'.>Precondition: The two graphs must have exactly the same nodes.AgdaThe graph's strongly connected components, in reverse topological order.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.W Safe-Inferred#"%&'-/369:;<=Agdatopoligical sort with smallest-numbered available vertex first | input: nodes, edges | output is Nothing if the graph is not a DAG Note: should be stable to preserve order of generalizable variables. Algorithm due to Richard Eisenberg, and works by walking over the list left-to-right and moving each node the minimum distance left to guarantee topological ordering. Safe-Inferred%"%&')*-/369:;<=oAgdaGraph structureF Safe-Inferred$"%&'-/369:;<= Agda;Result of comparing a candidate with the current favorites. AgdaGreat, you are dominating a possibly (empty list of favorites) but there is also a rest that is not dominated. If null dominated, then  notDominated2 is necessarily the complete list of favorites. Agda.Sorry, but you are dominated by that favorite. Agda!A list of incomparable favorites. AgdaGosh, got some pretty a here, compare with my current favorites! Discard it if there is already one that is better or equal. (Skewed conservatively: faithful to the old favorites.) If there is no match for it, add it, and dispose of all that are worse than a.We require a partial ordering. Less is better! (Maybe paradoxically.) AgdaCompare a new set of favorites to an old one and discard the new favorites that are dominated by the old ones and vice verse. (Skewed conservatively: faithful to the old favorites.) 'compareFavorites new old = (new', old') Agda)After comparing, do the actual insertion. Agda%Compare, then insert accordingly. :insert a l = insertCompared a l (compareWithFavorites a l) Agda=Insert all the favorites from the first list into the second. AgdaConstruct favorites from elements of a partial order. The result depends on the order of the list if it contains equal elements, since earlier seen elements are favored over later seen equals. The first element of the list is seen first. Agda  forms a  under  and 'union. AgdaEquality checking is a bit expensive, since we need to sort! Maybe use a Set! of favorites in the first place?   Safe-Inferred#"%&'-/369:;<=r Agda,A finite map, represented as a set of pairs.%Invariant: at most one value per key. AgdaLookup keys in the same association list often. Use partially applied to create partial function apply m :: k -> Maybe v. First time:  O(n log n) in the worst case.Subsequently: O(log n).Specification:  apply m == (  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= 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?Z Safe-Inferred$"%&'-/369:;<=5AgdaA partial order, aimed at deciding whether a call graph gets worse during the completion.Agda:In the paper referred to above, there is an order R with   Le  Lt.This is generalized to   'Decr k' where Decr 1 replaces Lt and Decr 0 replaces Le. A negative decrease means an increase. The generalization allows the termination checker to record an increase by 1 which can be compensated by a following decrease by 2 which results in an overall decrease.However, the termination checker of the paper itself terminates because there are only finitely many different call-matrices. To maintain termination of the terminator we set a cutoff point which determines how high the termination checker can count. This value should be set by a global or file-wise option.See Call for more information.9TODO: document orders which are call-matrices themselves.Agda2Decrease of callee argument wrt. caller parameter.The Bool indicates whether the decrease (if any) is usable. In any chain, there needs to be one usable decrease. Unusable decreases come from SIZELT constraints which are not in inductive pattern match or a coinductive copattern match. See issue #2331.UPDATE: Andreas, 2017-07-26: Feature #2331 is unsound due to size quantification in terms. While the infrastructure for usable/unusable decrease remains in place, no unusable decreases are generated by TermCheck.AgdaNo relation, infinite increase, or increase beyond termination depth.Agda&Matrix-shaped order, currently UNUSED.Agda$Raw increase which does not cut off.Agda$Raw decrease which does not cut off.AgdaSmart constructor for Decr k :: Order which cuts off too big values.Possible values for k:  - ?cutoff  k  ?cutoff + 1.AgdaSmart constructor for matrix shaped orders, avoiding empty and singleton matrices.Agdale, lt,  decreasing, unknown4: for backwards compatibility, and for external use.AgdaUsable decrease.AgdaDecreasing and usable?AgdaMatrix-shaped order is decreasing if any diagonal element is decreasing.AgdaMultiplication of .s. (Corresponds to sequential composition.)Agda collapse mWe assume that m codes a permutation: each row has at most one column that is not Unknown.To collapse a matrix into a single value, we take the best value of each column and multiply them. That means if one column is all Unknown, i.e., no argument relates to that parameter, then the collapsed value is also Unknown.,This makes order multiplication associative.Agda'Can two matrices be multplied together?Agda+The supremum of a (possibly empty) list of ;s. More information (i.e., more decrease) is bigger. # is no information, thus, smallest.Agda(, , ) forms a semiring, with  as zero and Le as one.Agda%The infimum of a (non empty) list of $s. Gets the worst information. & is the least element, thus, dominant.AgdaPick the worst information.AgdaWe use a record for semiring instead of a type class since implicit arguments cannot occur in instance constraints, like +instance (?cutoff :: Int) => 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.[ Safe-Inferred%"%&'-/369:;<=BAgdaSets of incomparable call matrices augmented with path information. Use overloaded , , , . Agda,Call matrix augmented with path information. Agda"The matrix of the (composed call). AgdaMeta info, like call path. Agda0Call matrix multiplication and call combination. AgdaCall matrices.A call matrix for a call f --> g has dimensions  ar(g)  ar(f).9Each column corresponds to one formal argument of caller f9. Each row corresponds to one argument in the call to g.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.     \ Safe-Inferred%"%&'-/369:;<=J AgdaA call graph is a set of calls. Every call also has some associated meta information, which should be al so that the meta information for different calls can be combined when the calls are combined. AgdaCalls are edges in the call graph. It can be labelled with several call matrices if there are several pathes from one function to another. AgdaCall graph nodes.Machine integer  is sufficient, since we cannot index more than we have addresses on our machine. Agda!Make a call with a single matrix. AgdaMake a call with empty cinfo. AgdaReturns all the nodes with incoming edges. Somewhat expensive. O(e). AgdaConverts a call graph to a list of calls with associated meta information.AgdaConverts a list of calls with associated meta information to a call graph. Agda#Takes the union of two call graphs. Agda!Inserts a call into a call graph.AgdaCall graph combination.Application of   to all pairs (c1,c2) for which  c1 =  c2.) Agda"Call graph comparison. A graph cs' is `worse' than cs if it has a new edge (call) or a call got worse, which means that one of its elements that was better or equal to Le moved a step towards Un.A call graph is complete if combining it with itself does not make it any worse. This is sound because of monotonicity: By combining a graph with itself, it can only get worse, but if it does not get worse after one such step, it gets never any worse.  cs completes the call graph cs. A call graph is complete if it contains all indirect calls; if f -> g and g -> h are present in the graph, then f -> h should also be present. Agda?Displays the recursion behaviour corresponding to a call graph. Agda  is a monoid under  . Agda: checks whether the call graph is completely disconnected.      ] Safe-Inferred$"%&'-/369:;<=Pa Agda2TODO: This comment seems to be partly out of date.  cs( checks if the functions represented by cs terminate. The call graph cs should have one entry ( &) per recursive function application.֊ perms: is returned if the functions are size-change terminating.,If termination can not be established, then ͊ problems is returned instead. Here problems contains an indication of why termination cannot be established. See lexOrder for further details.Note that this function assumes that all data types are strictly positive.The termination criterion is taken from Jones et al. In the completed call graph, each idempotent call-matrix from a function to itself must have a decreasing argument. Idempotency is wrt. matrix multiplication.This criterion is strictly more liberal than searching for a lexicographic order (and easier to implement, but harder to justify). AgdaA call c! is idempotent if it is an endo ( == ) of order 1. (Endo-calls of higher orders are e.g. argument permutations). We can test idempotency by self-composition. Self-composition c >*< c: should not make any parameter-argument relation worse.  G Safe-Inferred("%&')*-/01369:;<=U. Agda Currying as b# witnesses the isomorphism between  Arrows as b and Products as -> b. It is defined as a type class rather than by recursion on a singleton for as so all of that these conversions are inlined at compile time for concrete arguments. AgdaUsing IsBase we can define notions of Domains and  CoDomains. which *reduce* under positive information IsBase t ~ 'True even though the shape of t is not formally exposed AgdaIsBase t is 'True whenever t is *not* a function space. AgdaArrows [a1,..,an] r corresponds to a1 -> .. -> an -> r | Products [a1,..,an] corresponds to (a1, (..,( an, ())..)) Agda Version of Foldr taking a defunctionalised argument so that we can use partially applied functions. AgdaOn Lists Agda On Booleans AgdaAll p as ensures that the constraint p is satisfied by all the types in as. (Types is between scare-quotes here because the code is actually kind polymorphic)  H Safe-Inferred%"%&'-/1369:;<=oY? Agda=Killing the range of an object sets all range information to .Agda;If it is also possible to set the range, this is the class.Instances should satisfy  ( r x) == r.Agda5Things that have a range are instances of this class.Agda1Wrapper to indicate that range should be printed.AgdaA range is a file name, plus a sequence of intervals, assumed to point to the given file. The intervals should be consecutive and separated.1Note the invariant which ranges have to satisfy: .AgdaAn interval. The iEnd* position is not included in the interval.4Note the invariant which intervals have to satisfy: .AgdaFile information used in the ,  and  types.AgdaThe file's path.Agda1The file's top-level module name (if applicable).This field is optional, but some things may break if the field is not instantiated with an actual top-level module name. For instance, the  and ( instances only make use of this field.The field uses  rather than  because it should be possible to instantiate it with something that is not yet defined (see ).This   should not contain a range.Agda Represents a point in the input.If two positions have the same  and  components, then the final two components should be the same as well, but since this can be hard to enforce the program should not rely too much on the last two components; they are mainly there to improve error messages for the user.4Note the invariant which positions have to satisfy: .AgdaFile.AgdaPosition, counting from 1.AgdaLine number, counting from 1.AgdaColumn number, counting from 1.AgdaA smart constructor for .Agda Sets the  components of the interval.Agda Gets the  component of the interval. Because of the invariant, they are both the same.Agda6Converts a file name and two positions to an interval.AgdaThe length of an interval.AgdaThe intervals that make up the range. The intervals are consecutive and separated ().Agda8Turns a file name plus a list of intervals into a range.Precondition: .AgdaAre the intervals consecutive and separated, do they all point to the same file, and do they satisfy the interval invariant?AgdaRange invariant.Agda"The file the range is pointing to.Agda*The range's top-level module name, if any.If there is no range, then ? is returned. If there is a range without a module name, then   is returned.Agda*The range's top-level module name, if any.Agda%Conflate a range to its right margin.Agda*Remove ranges in keys and values of a map.Agda;The first position in a file: position 1, line 1, column 1.Agda;The first position in a file: position 1, line 1, column 1.Agda$Ranges between two unknown 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$"%&'-/369:;<=óAgdaNotation parts.Agda&An identifier part. For instance, for _+_ the only identifier part is +.AgdaA hole: a place where argument expressions can be written. For instance, for _+_) the two underscores are holes, and for  syntax  A ( x C B) = B , A , x the variables A and B are holes. The number is the position of the hole, counting from zero. For instance, the number for A is 0, and the number for B is 1.AgdaA bound variable.The first range is the range of the variable in the right-hand side of the syntax declaration, and the second range is the range of the variable in the left-hand side.Agda/A wildcard (an underscore in binding position).Agda.Positions of variables in syntax declarations.AgdaThe position (in the left-hand side of the syntax declaration) of the hole in which the variable is bound, counting from zero (and excluding parts that are not holes). For instance, for  syntax  A ( x C B) = B , A , x the number for x is 1, corresponding to B (0 would correspond to A).AgdaThe position in the list of variables for this particular variable, counting from zero, and including wildcards. For instance, for "syntax F ( x _ y C A) = y ! A ! x the number for x is 0, the number for _ is 1, and the number for y is 2.AgdaNotation as provided by the syntax declaration.AgdaRewriteEqn' qn p e represents the rewrite and irrefutable with clauses of the LHS. qn stands for the QName of the auxiliary function generated to implement the feature nm/ is the type of names for pattern variables p is the type of patterns e is the type of expressionsAgda  rewrite eAgda with p <- e in eqAgda!Coverage check? (Default is yes).Agda!Universe check? (Default is yes).Agda#Positivity check? (Default = True).Agda0Termination check? (Default = TerminationCheck).AgdaRun the termination checker.Agda#Skip termination checking (unsafe).AgdaTreat as non-terminating.Agda/Treat as terminating (unsafe). Same effect as .Agda2Skip termination checking but use measure instead.AgdaRename from this name.Agda#To this one. Must be same kind as .AgdaNew fixity of  (optional).AgdaThe range of the "to" keyword. Retained for highlighting purposes.Agda3An imported name can be a module or a defined name.AgdaImported module name of type m.AgdaImported name of type n.AgdaThe using clause of import directive.AgdaNo using clause given.Agdausing the specified names.AgdaThe things you are allowed to say when you shuffle names between name spaces (i.e. in import,  namespace, or open declarations).Agda Only for open3. Exports the opened names from the current module.AgdaThe notation is handled as the fixity in the renamer. Hence, they are grouped together in this type.AgdaRange of the name in the fixity declaration (used for correct highlighting, see issue #2140).AgdaFixity of operators.Agda&Range of the whole fixity declaration.AgdaAssociativity.AgdaNo fixity declared.Agda$Fixity level declared as the number.Agda Precedence levels for operators.AgdaPlaceholders are used to represent the underscores in a section.AgdaThe second argument is used only (but not always) for name parts other than underscores.Agda4The position of a name part or underscore in a name.Agda;The following underscore is at the beginning of the name: _foo.Agda8The following underscore is in the middle of the name: foo_bar.Agda4The following underscore is at the end of the name: foo_.AgdaThe unique identifier of an opaque block. Second argument is the top-level module identifier.AgdaA "problem" consists of a set of constraints and the same constraint can be part of multiple problems.Agda4Meta-variable identifiers use the same structure as s.AgdaThe unique identifier of a name. Second argument is the top-level module identifier.Agda4Monoid representing the combined opaque blocks of a * containing possibly-opaque declarations.Agda