H {            ! " # $ % & ' ( ) * + ,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ !!!!!!!!!!!!!!!!!!!!!!!!!!!!! ! ! ! ! !!!!!!!!!!!!!!!!!!! !!!"!#!$!%!&!'!(!)!*!+!,!-!.!/!0!1!2!3!4!5!6!7!8!9!:!;!<!=!>!?!@!A!B!C!D!E!F!G!H!I!J!K!L!M!N!O!P!Q!R!S"T"U"V"W"X"Y"Z"["\"]"^"_"`"a"b"c"d"e"f"g"h"i"j"k"l"m"n"o"p"q"r"s"t"u"v"w"x"y"z"{"|"}"~""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""####################################################$$$$$$$ $ $ $ $ $$$$$$$$$$$$$$$$$$$ $!$"$#$$$%$&$'$($)$*$+$,$-$.$/%0%1%2%3%4%5%6%7%8%9%:%;%<%=%>%?%@%A%B%C%D%E%F%G%H%I%J%K%L%M%N%O%P%Q%R%S%T%U%V%W%X%Y%Z&['\']'^'_'`'a'b(c(d(e(f(g(h(i(j(k(l)m)n)o)p)q)r)s)t)u)v)w)x)y)z){)|)})~)))))))))))***********************************+++++++++++,,,-------........./////////////////////////////00000000000 0 0 0 0 0000000000000000000 0!0"0#0$0%0&0'0(0)0*0+0,0-0.0/000102030405060708090:0;0<0=1>1?1@1A1B1C1D1E1F1G1H1I1J1K1L1M1N1O1P1Q1R1S1T1U1V1W1X1Y1Z1[1\1]1^1_1`1a1b1c1d1e1f1g1h1i1j1k1l1m1n1o2p2q2r2s2t2u2v2w2x2y2z2{2|2}2~2222222222222222222222222222222222222222222222222333333333333333333333333333333333334444444444455555555555555555566666666666666666667777777 7 7 7 7 7777777777777777777 7!7"7#7$8%8&8'8(8)8*8+8,8-8.8/808182838485868788898:8;8<8=8>8?8@8A8B8C8D8E8F8G8H8I8J8K8L8M8N8O8P8Q8R8S8T8U8V8W8X8Y8Z8[8\8]8^8_8`8a8b8c8d8e8f8g9h9i9j9k9l9m9n9o9p9q9r9s9t9u9v9w9x9y9z9{9|9}9~999999:;;;;;;;;;;;;;;;<<<<<<<<<<<<<<<<<===================================>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>??????@@@@@@@@@@@@@ @ @ @ @ @@@@@@@@@@@@@@@@@@@ @!@"@#@$@%@&@'@(@)@*@+@,@-@.@/@0@1@2@3@4@5@6@7@8@9@:@;@<@=@>@?@@@A@B@C@D@E@F@G@H@I@J@K@L@M@N@O@P@Q@R@S@T@U@V@W@X@Y@Z@[@\@]@^@_@`@a@b@c@d@e@f@g@h@i@j@k@l@m@n@o@p@q@r@s@t@u@v@w@x@y@z@{@|@}@~@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC C C C C CCCCCCCCCCCCCCCCCCC C!C"C#C$C%C&C'C(C)C*C+C,C-C.C/C0D1D2D3D4D5D6D7D8D9D:D;D<D=D>D?D@DADBDCEDEEEFEGEHEIEJEKELEMENEOEPEQERESETEUEVEWEXEYEZE[E\E]E^E_E`EaEbEcEdEeEfEgEhEiEjEkElEmEnEoEpEqErEsEtEuEvEwExEyEzE{E|E}E~EEEEEEEEEEEEEEEEEEEEEEEEEEEEEFFFGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGHHHHHHHHHHHH H H H H HHHHHHHHHHIIIIIIIII I!I"I#I$I%I&I'I(I)I*I+I,I-I.I/I0I1I2I3I4J5J6J7J8J9J:J;J<J=J>J?J@JAJBJCJDJEJFJGJHJIJJJKJLJMJNJOJPJQJRJSJTJUJVJWJXJYJZJ[J\J]J^J_J`JaJbJcKdKeKfKgKhKiKjKkKlKmKnKoKpKqKrKsKtKuLvLwLxLyLzM{M|M}M~MMMMNNNNNNNNNNNNNNNNNNNNNNNOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP P P P P PPPPPPPPPPPPPPPPPPP P!P"P#P$P%P&P'P(P)P*P+P,P-P.P/P0P1P2P3P4P5P6P7P8P9P:P;P<P=P>P?P@PAPBPCPDPEPFPGPHPIPJPKPLQMQNQOQPQQRRRSRTRURVRWRXRYRZR[R\R]R^R_R`RaRbRcRdReRfRgRhRiRjRkRlRmRnRoRpRqRrRsRtRuRvRwRxRyRzR{S|S}S~SSSSSSSSSSSSSSSSSSSSSSSSSSSSSTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTUUUUUUUUUUUUUUUUUUVVVWWWWWWWWWWWXXXXXXXXXXXXXXXXYYYYYZ Z [ [ [ [ [ [ [ [ [ [ [ [ [ [ X X V V \ \ \ \ ] ] ] ] ] ] ] ] ^ ^ ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                                                                                                                                                                   ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                                                                                                                                                                   ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B_ C` Da Ea Fa Ga Ha Ia Ja Ka La Ma Nb Ob Pb Qb Rb Sb Tb Ub Vb Wb Xb Yb Zb [b \b ]b ^b _b `b ab bb cb db eb fb gb hb ib jb kb lb mb nb ob pb qb rb sb tb ub vb wb xb yb zb {b |b }b ~b b b b b b c c c 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 e e e e e e e e e e e e e e e e e e e e e e e e e e e e e e e e !e "f #g $g %g &g 'g (h )h *i +i ,i -i .i /i 0i 1i 2i 3i 4i 5i 6i 7i 8i 9i :i ;i <i =i >j ?j @j Aj Bj Cj Dj Ej Fj Gj Hj Ij Jj Kj Lj Mj Nk Ok Pk Qk Rl Sm Tn Uo Vp Wq Xq Yr Zr [r \r ]r ^r _s `s as bs cs ds es ft gt ht it jh kh lh mh nh oh ph qh rh sh th uh vh wh xh yh zh {h |h }h ~h h h h h h h u u u u u u u u u u u u u u u u u v v v v v v v w : : : : : : : : : : : : : :                                  f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x !x "y #z $z %z &z 'z ({ ){ *{ +{ ,{ -{ .{ /{ 0{ 1{ 2{ 3{ 4{ 5{ 6{ 7{ 8{ 9| :| ;| <| =| >| ?| @| A| B| C| D| E| F| G| H| I| J| K| L| M| N| O| P| Q| R| S| T| U| V| W| X| Y| Z| [| \| ]| ^| _| `| a| b| c} d} e} f} g} h} i} j} k~ l~ m~ n o p q r s t u v w x y z { | } ~                                            !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~llllllll  ` ` ` ```` !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ooooooooggggggggggaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaddddddddd      !"#$%&'()*+,-./01234q5q6q7q8q9q:q;q<q=q>q?q@qAqBqCqDqEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~nnnn      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~mmmmmmmmm~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~____________      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ Safe-Inferred      Safe-Inferred     Safe-Inferred Safe-InferredPointed class. >We could have used Data.Pointed by Edward Kmett, but it has a  lot of package dependencies.  Safe-Inferred Safe-Inferred Safe-Inferred  Safe-Inferred>Converts many character sequences which may be interpreted as # line or paragraph separators into '\n'.  None If f a contains many copies of a& they will all be the same pointer in L the result. If the function is well-behaved (i.e. preserves the implicit  equivalence, this shouldn' t matter).      None$Left biased union. !"#$%&!"#$%&!"#%&$!"#$%&  Safe-Inferred'BReturns a close function for the file together with the contents. ''''  Safe-Inferred()*+()*+()*+()*+ Safe-InferredNone Safe-Inferred Safe-InferredNone,-.      !"#$%&'()*+,-./0123456789:;<=,-.,-.,-.None/Is the operator associative? 0Is the operator commutative? 1(Is the element a zero for the operator? 2(Is the element a unit for the operator? 3<Does the first operator distribute (from the left) over the  second one? 4=Does the first operator distribute (from the right) over the  second one? 5Generates natural numbers. 6Generates positive numbers. 77Generates a list of elements picked from a given list. 8AIf the given list is non-empty, then an element from the list is = generated, and otherwise an arbitrary element is generated. 9Generates values of $ type, using the given generator to  generate the contents of the  constructor. : Coarbitrary " generator" for . ;Generates two elements. <Generates three elements. =Runs the tests, and returns > if all tests were successful. /0123456789:;<= A label for the tests. Used for  informational purposes. /0123456789:;<=/01234569:78;<=/0123456789:;<=None > Semirings. @ Addition. AMultiplication. BZero. 0 The one is never used in matrix multiplication . , one :: a -- ^ One. CHasZero= 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. EESemiRing type class. Additive monoid with multiplication operation. (Inherit addition and zero from Monoid. GSemiring invariant. IThe standard semiring on ?s. @The standard semiring on As. >?@ABCDEFGHBICJDE@ >?@ABCDEFGHIJ CDEF>?@ABGHIJ >?@ABCDEFGHBICJDE@NoneK7Type of matrices, parameterised on the type of values. L&Type of matrix indices (row, column). PSize of a matrix. F$This matrix type is used for tests. G9Converts a size to a set of bounds suitable for use with  the matrices in this module. U$No nonpositive indices are allowed. W@Generates a matrix of the given size, using the given generator  to generate the rows. X&Generates a matrix of the given size. Y9Constructs a matrix from a list of (index, value)-pairs. ZZ sz rs- constructs a matrix from a list of lists of  values (a list of rows). Precondition: H rs I R sz J K ((I S sz) . H) rs. [*Converts a matrix to a list of row lists. \The size of a matrix. ]> iff the matrix is square. ^Returns > iff the matrix is empty. __ (+) m1 m2 adds m1 and m2. Uses (+) to add values. Precondition: \ m1 == \ m2. `` m1 m2 multiplies m1 and m2. Uses the operations of - the semiring to perform the multiplication. Precondition: S (\ m1) == rows (\ m2). aa m extracts the diagonal of m. Precondition: ] m. bb x m adds a new column to m, after the columns D already existing in the matrix. All elements in the new column get  set to x. cc 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. 3KLMLMNOPQRSFTNGUOVPW7The generator is parameterised on the size of the row. XQYRZ[S\TU]^_V`WaXbYcZde[\]^_`aKLMNOPQRSTUVWXYZ[\]^_`abcdeKVPQRSTLMNOUZY[dXW\]^_`acbe+KLMLMNOPQRSFTNGUOVPWXQYRZ[S\TU]^_V`WaXbYcZde[\]^_`aNone!gHRun a parser on a list of tokens. Returns the list of complete matches. h)Consumes and returns the next character. $ Fails if there is no input left. i@Look-ahead: returns the part of the input that is left, without  consuming it. jAlways fails. kSymmetric choice. l5Local, exclusive, left-biased choice: If left parser < locally produces any result at all, then right parser is  not used. m5Transforms a parser into one that does the same, but 2 in addition returns the exact characters read.  IMPORTANT NOTE: m- gives a runtime error if its first argument 1 is built using any occurrences of readS_to_P. n=Consumes and returns the next character, if it satisfies the  specified predicate. o,Parses and returns the specified character. p)Parses and returns the specified string. qCParses the first zero or more characters satisfying the predicate. rBParses the first one or more characters satisfying the predicate. s,Combines all parsers in the specified list. tSkips all whitespace. u count n p parses n occurrences of p in sequence. A list of  results is returned. vbetween open close p parses open, followed by p and finally  close. Only the value of p is returned. w option x p will either parse p or return x without consuming  any input. x optional p optionally parses p and always returns (). y5Parses zero or more occurrences of the given parser. z4Parses one or more occurrences of the given parser. {Like y, but discards the result. |Like z, but discards the result. } sepBy p sep$ parses zero or more occurrences of p, separated by sep. ( Returns a list of values returned by p. ~ sepBy1 p sep# parses one or more occurrences of p, separated by sep. ( Returns a list of values returned by p.  endBy p sep$ parses zero or more occurrences of p, separated and ended  by sep.  endBy p sep# parses one or more occurrences of p, separated and ended  by sep.  chainr p op x$ parses zero or more occurrences of p, separated by op. ! Returns a value produced by a right associative application of all  functions returned by op!. If there are no occurrences of p, x is  returned.  chainl p op x$ parses zero or more occurrences of p, separated by op. ! Returns a value produced by a left associative application of all  functions returned by op!. If there are no occurrences of p, x is  returned. Like (, but parses one or more occurrences of p. Like (, but parses one or more occurrences of p. manyTill p end$ parses zero or more occurrences of p, until end 2 succeeds. Returns a list of values returned by p. b7Converts a parser into a Haskell ReadS-style function. ) This is the main way in which you can "run" a f parser:  the expanded type is  / readP_to_S :: ReadP a -> String -> [(a,String)]  c7Converts a Haskell ReadS-style function into a parser. @ Warning: This introduces local backtracking in the resulting 2 parser, and therefore a possible inefficiency. 4fdefghijklghijklmnopmnqrstuvwxyz{|}~bcopqrst!fghijklmnopqrstuvwxyz{|}~!fhiklmgjnopqrtsuvwxyz{|}~.fdejihgfklghijklmnopmnqrstuvwxyz{|}~bcopqrst Safe-Inferred n f x applies f to x n times and returns the  result. *The applications are calculated strictly.  Safe-Inferred uvwxyz{|}~v{|}~ uvwxyz{|}~None Timestamps. The current time.  Safe-Inferred  Safe-Inferred=Reads a UTF8-encoded text file and converts all Unicode line  endings into '\n'. ?Writes UTF8-encoded text to the handle, which should be opened > for writing and in text mode. The native convention for line  endings is used.  The handle'4s text encoding is not necessarily preserved, it is  changed to UTF8. @Writes a UTF8-encoded text file. The native convention for line  endings is used. NoneBifunctoriality for pairs. mapFst f = f -*- id mapSnd g = id -*- gLifted pairing. Monadic version of . Monadic . Monadic .   Safe-Inferred8 adds double quotes around the string, replaces newline  characters with n,, and escapes double quotes and backslashes < within the string. This is different from the behaviour of :    >  $  "\x2200"  "\8704"  >  $  "\x2200"  """ C(The code examples above have been tested using version 4.2.0.0 of  the base library.) ?Shows a non-negative integer using the characters - instead o 0-9. 2Adds a final newline if there is not already one. .Indents every line the given number of steps.  Safe-Inferred Safe-Inferred" Impossible"/ errors, annotated with a file name and a line @ number corresponding to the source code location of the error. Abort by throwing an " impossible" error. You should not use 2 this function directly. Instead use the macro in  undefined.h.  Catch an " impossible" error, if possible.  Safe-InferredNoneHead function (safe). Opposite of cons (:), safe. downFrom n = [n-1,..1,0] 0Update the last element of a list, if it exists A generalized version of  partition.  (Cf. mapMaybe vs. filter). Sublist relation. ;Check if a list has a given prefix. If so, return the list  minus the prefix. CSplit a list into sublists. Generalisation of the prelude function  words.  words xs == wordsBy isSpace xs ,Chop up a list in chunks of a given length. .All ways of removing one element from a list.  Check whether a list is sorted. Assumes that the & instance implements a partial order. <Check whether all elements in a list are distinct from each  other. Assumes that the $ instance stands for an equivalence  relation. An optimised version of . Precondition: The list's length must fit in an . ?Checks if all the elements in the list are equal. Assumes that  the . instance stands for an equivalence relation.  A variant of , which applies the predicate to consecutive  pairs.  f =  ((I) `on` f)   ( `on` f).  n xs gives the n-th element in xs D (counting from 0), plus the remaining elements (preserving order). -Requires both lists to have the same length. DLike zipWith, but returns the leftover elements of the input lists. HEfficient version of nub that sorts the list first. The tag function is ! assumed to be cheap. If it isn'+t pair up the elements with their tags and  call uniqBy fst (or snd).  Safe-Inferred permute [1,2,0] [x0,x1,x2] = [x1,x2,x0]Agda typing would be:  9Perm : {m : Nat}(n : Nat) -> Vec (Fin n) m -> Permutation  m is the  of the permutation. 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 n liftP k takes a  Perm {m} n to a Perm {m+k} (n+k).  Analogous to , > but Permutations operate on de Bruijn LEVELS, not indices. 2permute (compose p1 p2) == permute p1 . permute p2JTurn a possible non-surjective permutation into a surjective permutation.  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]    expandP i n  in the domain of  replace the ith element by n elements. DStable topologic sort. The first argument decides whether its first ; argument is an immediate parent to its second argument.   Safe-Inferred'Is the character one of the subscripts '@-@'?  Converts  '0'@-@'9' to '@-@'. .Precondition: The digit needs to be in range.  Converts '@-@' to  '0'@-@'9'. .Precondition: The digit needs to be in range.  None is a bifunctor. ' Either _ b' is a functor. 'Either a' is a functor. Returns > iff the argument is  x for some x. Returns > iff the argument is  x for some x. Returns  inputwith tags stripped if all elements are  to the right, and otherwise Left input:   allRight xs ==  if all isRight xs then  Right (map ((Right x) -> x) xs)  else  Left xs ! Safe-Inferredl      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRg      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRg/-.+,#*)('&%$!" 012  34   56789:;<=>?@ABCDEFGHIJKLMNOPQRA      !"#*)('&%$+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQR" Safe-Inferred{STUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~{STUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~{|~}x{zyrwvutsqlponmkfjihgbedca`]_^[\YZUXWVTS/STUXWVYZ[\]_^`abedcfjihgklponmqrwvutsx{zy|~}# Safe-Inferred=444 $ Safe-Inferred-      !"#$%&'()*+,-.-      !"#$%&'()*+,-.-   !"#   $%&'()*+,-.$      !"#$%&'()*+,-.% Safe-Inferred+/0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXY+/0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXY+;<=>?9:@870654321/ABCDEFGHIJKLMNOPQRSTUVWXY$/0654321789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXY& Safe-InferredZThe version of Agda. ZZZZ' Safe-Inferredaalign max rows lays out the elements of rows in two columns, A with the second components aligned. The alignment column of the  second components is at most max characters to the right of the  left-most column. Precondition: max > 0. [\]^_`aD[\]^_`a[\]^_`a[\]^_`a( Safe-Inferred bSimple Emacs Lisp expressions. dList. fAtom. gFormats a response command.  Replaces '\n'. with spaces to ensure that each command is a  single line. h.Writes a response command to standard output. i display_info' append header content displays content (with  header header) in some suitable way. If append is True, then E the content is appended to previous content (if any), otherwise any  previous content is deleted. %The name of the running info buffer. jClear the running info buffer. kBDisplay running information about what the type-checker is up to. bcdefghijk bcdefghijk bfedcghijk bfedcghijk)Nonel7Type of matrices, parameterised on the type of values. n&Type of matrix indices (row, column). rSize of a matrix. $This matrix type is used for tests. 9Converts a size to a set of bounds suitable for use with  the matrices in this module. w$No nonpositive indices are allowed. y@Generates a matrix of the given size, using the given generator  to generate the rows. z&Generates a matrix of the given size. {9Constructs a matrix from a list of (index, value)-pairs. || sz rs- constructs a matrix from a list of lists of  values (a list of rows). Precondition: H rs I t sz J K ((I u sz) . H) rs. 2Converts a sparse matrix to a sparse list of rows }*Converts a matrix to a list of row lists. The size of a matrix. ~> iff the matrix is square. Returns > iff the matrix is empty. Returns 'Just b', iff it is a 1x1 matrix with just one entry b.  Transposition  (+) m1 m2 adds m1 and m2. Uses (+) to add values. Precondition: m m1 == m m2.  assoc list union  f m1 m2! build the pointwise conjunction m1 and m2.  Uses f to combine non-zero values. Precondition: m m1 == m m2.  assoc list intersection  semiring m1 m2 multiplies m1 and m2 . Uses the  operations of the semiring semiring to perform the  multiplication. Precondition: u (m m1) == rows (m m2).  m extracts the diagonal of m. Precondition: ~ m.  x m adds a new column to m, after the columns D already existing in the matrix. All elements in the new column get  set to x.  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. <l m nopqrstuvwxy7The generator is parameterised on the size of the row. z{|}~    !"#lmnopqrstuvwxyz{|}~lmxrstuvnopqw|{}zym~3l m nopqrstuvwxyz{|}~    !"#*None%9A call graph is a set of calls. Every call also has some . associated meta information, which should be $al so that the E meta information for different calls can be combined when the calls  are combined. ;This datatype encodes information about a single recursive @ function application. The columns of the call matrix stand for  7 function arguments (patterns); the first argument has D index 0, the second 1, and so on. The rows of the matrix stand for   function arguments. Element (i, j) in the matrix should  be computed as follows:  Lt (less than) if the j-th argument to the  8 function is structurally strictly smaller than the i-th  pattern.  Le (less than or equal) if the j-th argument to the  + function is structurally smaller than the i-th  pattern.  % otherwise. AThe structural ordering used is defined in the paper referred to  above. The function making the call. The function being called. %The call matrix describing the call. .Call matrices. Note the call matrix invariant  (). Call matrix indices. 9In 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 A allows the termination checker to record an increase by 1 which B can be compensated by a following decrease by 2 which results in  an overall decrease. HHowever, the termination checker of the paper itself terminates because D there are only finitely many different call-matrices. To maintain ( termination of the terminator we set a cutoff point which determines C how high the termination checker can count. This value should be & set by a global or file-wise option. See  for more information. :TODO: document orders which are call-matrices themselves. %Raw increase which does not cut off. %Raw decrease which does not cut off. Smart constructor for Decr k :: Order which cuts off too big values. Possible values for k:  - ?cutoff & k & ?cutoff + 1. SSmart constructor for matrix shaped orders, avoiding empty and singleton matrices. le, lt,  decreasing, unknown5: for backwards compatibility, and for external use. Multiplication of s. (Corresponds to sequential  composition.) +The supremum of a (possibly empty) list of s. 5 More information (i.e., more decrease) is bigger.  %$ is no information, thus, smallest. '(, ', ) forms a semiring, with % as  zero and Le as one. %The infimum of a (non empty) list of s.  %' is the least element, thus, dominant. (+Generates a call matrix of the given size. >In a call matrix at most one element per row may be different  from %. )Call matrix multiplication. Precondition: see .  invariant.  combination. Precondition: see ); furthermore the  of the first ! argument should be equal to the  of the second one.  invariant. >Converts a call graph to a list of calls with associated meta  information. ?Converts a list of calls with associated meta information to a  call graph. Creates an empty call graph. $Takes the union of two call graphs. "Inserts a call into a call graph. *Generates a call graph. +(Call graph combination. (Application of  to all pairs (c1,  c2) for which  c1 =  c2.) Precondition: see ).  cs completes the call graph cs. A call graph is 0 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. ,Returns >! iff the call graph is complete. -Checks whether every $ used in the call graph corresponds * to a fixed number of arguments (i.e. rows/ columns). .!Returns a call graph padded with %s in such a way that  - is satisfied. @Displays the recursion behaviour corresponding to a call graph. /@Displays the recursion behaviour corresponding to a call graph. 0 is a monoid under . H12%34567'89:;(<)=>*?+@,-.A/0BCDEFGHIJ##=123%4567'89:;(<)=>*?+@,-.A/0BCDEFGHIJ+None AA column expresses how the size of a certain argument changes in 8 the various recursive calls a function makes to itself  (transitively). =A recursion behaviour expresses how a certain function calls E itself (transitively). For every argument position there is a value  (4) describing how the function calls itself for that  particular argument. See also . The indices to the columns. :A lexicographic ordering for the recursion behaviour of a C given function is a permutation of the argument indices which can = be used to show that the function terminates. See the paper % referred to above for more details. 1 invariant: the size must match the real size of = the recursion behaviour, and all columns must have the same  indices. K9Checks whether there are any calls left in the recursion  behaviour. AConstructs a recursion behaviour from a list of matrix diagonals  ("rows"). Note that the call indices do not need to be 0 distinct, since they are paired up with unique As. 6Precondition: all arrays should have the same bounds. LChecks if this "column"( is well-behaved (all calls decreasing, $ at least one strictly decreasing). MM n rb) computes a new recursion behaviour from  rb by removing all "rows" (calls) for which the n -th element  is #, and also completely removing the n -th column. !Precondition: there has to be an n -th column. NN rs ps checks that the permutation ps really @ induces a lexicographic ordering which shows that the function ( represented by the recursion behaviour rs terminates. BTries to compute a lexicographic ordering for the given recursion / behaviour. This algorithm should be complete. =If no lexicographic ordering can be found, then two sets are  returned: D A set of argument positions which are not properly decreasing, and ) the calls where these problems show up. OKPLMQNRSTU  OKPLMQNRSTU,None V9The call graph instantiation used by the examples below. 3TODO: 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   for further details. ANote that this function assumes that all data types are strictly  positive. 5The 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 G lexicographic order (and easier to implement, but harder to justify). W<Matrix is decreasing if any diagonal element is decreasing. X2Constructs a call graph suitable for use with the R monoid. YThe example from the JFP' 02 paper. Z<An example which is now handled by this algorithm: argument  swapping addition.  S x + y = S (y + x)  Z + y = y[FA related example which is anyway handled: argument swapping addition " using two alternating functions.  S x + y = S (y +' x)  Z + y = y S x +' y = S (y + x) Z +' y = y\A contrived example.  f (S x) y = f (S x) y + g x y  f Z y = y  g x y = f x yITODO: This example checks that the meta information is reported properly  when an error is encountered. ]This should terminate.  )f (S x) (S y) = g x (S y) + f (S (S x)) y )g (S x) (S y) = f (S x) (S y) + g x (S y)^#Another example which should fail.  f (S x) = f x + f (S x)  f x = f xITODO: This example checks that the meta information is reported properly  when an error is encountered. V_`WXYaZb[c\d]e^fV_`WXYaZb[c\d]e^f-None&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. g=The paths have to be absolute, valid and normalised, without  trailing path separators.  Constructs s. 3Precondition: The path must be absolute and valid. Makes the path absolute. This function may raise an __ IMPOSSIBLE__ error if  h# does not return an absolute path. @Tries to establish if the two file paths point to the same file  (or directory). *Case-sensitive doesFileExist for Windows. O This is case-sensitive only on the file name part, not on the directory part. H (Ideally, path components coming from module name components should be K checked case-sensitively and the other path components should be checked  case insenstively.) igjklm igjklmNonewhen_ is just Control.Monad.when with a more general type. unless_ is just Control.Monad.unless with a more general type. Lazy monadic conjunction. Lazy monadic disjunction. Lazy monadic disjunction with Either truth values. Generalized version of %mapM_ :: Monad m => (a -> m ()) -> [a] -> m () A 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 tLthat collects results in right-to-left order (effects still right-to-left). 9 It might be preferable for right associative monoids. Generalized version of forM_ :: Monad m => [a] -> (a -> m ()) -> m () n. for the continuation monad. Terribly useful. .Requires both lists to have the same lengths. A monadic version of  mapMaybe :: (a -> Maybe b) -> [a] -> [b]. Finally for the o( class. Errors in the finally part take  precedence over prior errors. Bracket for the o class. <Bracket without failure. Typically used to preserve state. !Restore state after computation. Acquires resource. Run first. Releases resource. Run last. !Computes result. Run in-between. Acquires resource. Run first. Releases resource. Run last. !Computes result. Run in-between. .None,Not very efficient (goes via a list), but it'll do.  Filter a map based on the keys.  Unzip a map.   /Nonep Used to test  and . q Used to test  and . 'A structural invariant for the graphs. *All edges originating in the given nodes. $Returns all the nodes in the graph. @Constructs a completely disconnected graph containing the given  nodes. >Removes the given node, and all corresponding edges, from the  graph. removeEdge n1 n2 g removes the edge going from n1 to n2, if  any.  The graph'8s strongly connected components, in reverse topological  order.  The graph'8s strongly connected components, in reverse topological  order. Returns True iff the graph is acyclic. .Computes the transitive closure of the graph. =Note that this algorithm is not guaranteed to be correct (or % terminate) for arbitrary semirings. 4This function operates on the entire graph at once. .Computes the transitive closure of the graph. =Note that this algorithm is not guaranteed to be correct (or % terminate) for arbitrary semirings. @This function operates on one strongly connected component at a  time. allPaths classify a b g5 returns a list of pathes (accumulated edge weights)  from node a to node b in g. ? Alternative intermediate pathes are only considered if they  are distinguished by the classify function. >Generates a node from the graph. (Unless the graph is empty.) @Generates an edge from the graph. (Unless the graph contains no  edges.)  All tests. %prsqtuvw!prsqtuvw0Nonef :: Flag opts6 is an action on the option record that results from  parsing an option. f opts( produces either an error message or an  updated options record The options from an OPTIONS pragma. >In the future it might be nice to switch to a more structured A representation. Note that, currently, there is not a one-to-one 3 correspondence between list elements and options. &Options which can be set in a pragma. ,irrelevant levels, irrelevant data matching "definitions by copattern matching , is used temporarily, before the paths have  been made absolute. An empty  list is  interpreted as [.] (see  f). !3In the absence of a path the project root is used. 0(This should probably go somewhere else. 1FMap a function over the long options. Also removes the short options. > Will be used to add the plugin name to the plugin options. 2For batch usage. x7For interactive usage, do not print any debug messages  by default. y(The default output directory for LaTeX. z'The default output directory for HTML. 5.Checks that the given options are consistent. 7Used for printing usage info. {Don' t export 8Parse the standard options. 9&Parse options from an options pragma. :Parse options for a plugin. ;CThe usage info message. The argument is the program name (probably  agda). s      !"#$%&'()*+,-./012x34|yz}56~7{89Pragma options. .Command-line options which should be updated. :;<?      !"#$%&'()*+,-./0123456789:;?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmn2=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmn2KLMNOPQR\^_`FGHIJSabCDET]cghdefAB?@=>UVWXYZ[mjiklnS=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmn2NoneqIThe unique identifier of a name. Second argument is the top-level module  identifier. uAbstract or concrete xAccess modifier. y?Visible from outside, but not exported when opening the module $ Used for qualified constructors. |=Functions can be defined in both infix and prefix style. See  @. Only  arguments can have names. %A function argument can be hidden and/or irrelevant.  Similar to , but we need to distinguish 2 an irrelevance annotation in a function domain * (the domain itself is not irrelevant!)  from an irrelevant argument. Dom is used in Pi of internal syntax, in Context and  Telescope.   is used for actual arguments (Var, Con, Def etc.)  and in Abstract syntax and other situations. 3A function argument can be relevant or irrelevant.  See . 7The polarity checker has determined that this argument : is unused in the definition. It can be skipped during 7 equality checking but should be mined for solutions $ of meta-variables with relevance  5The argument can be skipped during equality checking 8 because its value is already determined by the type. 4The argument is irrelevant at compile- and runtime. 6The argument may never flow into evaluation position. , Therefore, it is irrelevant at run-time. 6 It is treated relevantly during equality checking. 5The argument is (possibly) relevant at compile-time. 5Used to specify whether something should be delayed. Information ordering.   Relevant ` moreRelevant`  UnusedArg ` moreRelevant`  Forced ` moreRelevant`  NonStrict ` moreRelevant`  Irrelevant xs ` withArgsFrom` args translates xs into a list of s,  using the elements in args to fill in the non- fields. 6Precondition: The two lists should have equal length. Get the content of a . The functor instance for  would be ambiguous, $ so we give it another name here. Xopqrstuvwxyz{|}~@opqrstuvwxyz{|}~@|~}x{zyuwvtsqrop8opqrstuwvx{zy|~}3None,##4None  5None6None7None"      !"#"      !"#"      !"#"      !"#8None_8Check that no edges get longer when completing a graph. b+Check that all transitive edges are added. d2Check that no edges are added between components. K$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdef    C$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefCIJHKEGFLBDC?A@>=<;MN8:97O0123456P/QRSTUV*+,-.)WX&('YZ[$%\]^_`abcdef6$%&(')*+,-./012345678:9;<=>?A@BDCEGFHIJKLMNOPQRSTUVWXYZ[\]^_`abcdef    9None gTop-level module names. 'Invariant: The list must not be empty. jQName7 is a list of namespaces and the name of the constant. . For the moment assumes namespaces are just Name s and not ! explicitly applied modules. @ Also assumes namespaces are generative by just using derived > equality. We will have to define an equality instance to ? non-generative namespaces (as well as having some sort of ( lookup table for namespace names). p*A name is a non-empty list of alternating ns and os. A normal name P is represented by a singleton list, and operators are represented by a list  with o/s where the arguments should go. For instance:  [Hole,Id +,Hole]  is infix addition. Equality and ordering on Name,s are defined to ignore range so same names & in different locations are equal. s  noName_ = t ]t  noName r = p r [o]vIs the name an operator? y qualify A.B x == A.B.xz unqualify A.B.x == xThe range is preserved. { qnameParts A.B.x = [A, B, x]|Turns a qualified name into a g. The qualified 7 name is assumed to represent a top-level module name. }>Turns a top-level module name into a file name with the given  suffix. ~Finds the current project's "root" directory, given a project 3 file and the corresponding top-level module name. Example: If the module "A.B.C" is located in the file  "fooABC.agda", then the root is "foo". 3Precondition: The module name must be well-formed. -ghijklmnopqrstuvwxyz{|}~ ghijklmnopqrstuvwxyz{|}~prqmonstuvwxyz{jlkghi|}~%ghijlkmonprqstuvwxyz{|}~ ;None /Zero or more consecutive and separated ranges. BCharacter ranges. The first character in the file has position 1.  Note that the - position is considered to be outside of the  range.  Invariant:  & . The  invariant. The  invariant. > iff the ranges overlap. *The ranges are assumed to be well-formed. > iff the range is empty. )Converts a range to a list of positions. 0Converts several ranges to a list of positions.  Converts a C to a .  minus xs ys! computes the difference between xs and ys: the 6 result contains those positions which are present in xs but not  in ys. +Linear in the lengths of the input ranges. All the properties.  ! !<None Part of a Notation +Argument is where the expression should go TArgument is the position of the hole (with binding) where the binding should occur. *A name is a non-empty list of alternating Ids and Holes. A normal name P is represented by a singleton list, and operators are represented by a list  with Hole/s where the arguments should go. For instance:  [Hole,Id +,Hole]  is infix addition. Equality and ordering on Name,s are defined to ignore range so same names & in different locations are equal. 8Data type constructed in the Happy parser; converted to  " before it leaves the Happy code. simple named hole (x9 -> y) ; 1st argument is the bound name (unused for now) Target of a hole 3Get a flat list of identifier parts of a notation. ATarget argument position of a part (Nothing if it is not a hole) Is the part a hole? 3From notation with names to notation with indices. No notation by default  =None )Precedence is associated with a context. Fixity of operators. 0All the notation information related to a name. AThe notation is handled as the fixity in the renamer. Hence they $ are grouped together in this type. CIf an operator has no specific notation, recover it from its name. ,The default fixity. Currently defined to be  20. <The precedence corresponding to a possibly hidden argument. BDo we need to bracket an operator application of the given fixity + in a context with the given precedence. BDoes a lambda-like thing (lambda, let or pi) need brackets in the > given context? A peculiar thing with lambdas is that they don't E need brackets in certain right operand contexts. However, we insert - brackets anyway, for the following reasons:  Clarity. ) Sometimes brackets are needed. Example: m >>= ( x ! x) >>  (here _>>=_ is left associative). +Does a function application need brackets? 'Does a with application need brackets? %Does a function space need brackets? '"#$%## "#$%>None =Ambiguous qualified names. Used for overloaded constructors. BInvariant: All the names in the list must have the same concrete,  unqualified name. (A module name is just a qualified name. The ?6 instance for module names sets all individual ranges  to the given one. )Something preceeded by a qualified name. JQualified names are non-empty lists of names. Equality on qualified names D are just equality on the last name, i.e. the module part is just  for show. The ?2 instance for qualified names sets all individual A ranges (including those of the module prefix) to the given one. HA name is a unique identifier and a suggestion for a concrete name. The H concrete name contains the source location (if any) of the name. The 9 source location of the binding site is also recorded. GA module is anonymous if the qualification path ends in an underscore. >Sets the ranges of the individual names in the module name to B match those of the corresponding concrete names. If the concrete E names are fewer than the number of module name name parts, then the " initial name parts get the range ]. C.D.E ` withRangesOf` [A, B] returns C.D.E but with ranges set  as follows:  C: ].  D: the range of A.  E: the range of B. @Precondition: The number of module name name parts has to be at + least as large as the length of the list. Like -, but uses the name parts (qualifier + name) 6 of the qualified name as the list of concrete names. The C sets the definition site of the name, not the use  site. JTurn a qualified name into a concrete name. This should only be used as a H fallback when looking up the right concrete name in the scope fails.  Computes the TopLevelModuleName corresponding to the given E module name, which is assumed to represent a top-level module name. 3Precondition: The module name must be well-formed. Is the name an operator? 9Get the next version of the concrete name. For instance,  nextName x = x.  The name must not be a NoName. D&'()*+,-./0123456789:;..5&'()*+,-./0123456789:;?None <=>?@A<=>?@A@None[The r is not an application. >Modules: Top-level pragmas plus other top-level declarations. .Invariant: The string must be a valid Haskell  module name. @The representation type of a declaration. The comments indicate ? which type in the intended family the constructor targets.  notation declaration for a name  8The optional name is a name for the record constructor. !&lone record signature in mutual block #$lone data signature in mutual block %Record field, can be hidden and/or irrelevant. &(Axioms and functions can be irrelevant. '9A data constructor declaration is just a type signature. (Just type signatures. +The "as" name. ,The range of the "as" keyword. Retained  for highlighting purposes. /Rename from this name. 0 To this one. 1The range of the "to" keyword. Retained  for highlighting purposes. 23An imported name can be a module or a defined name 9FThe things you are allowed to say when you shuffle names between name  spaces (i.e. in import,  namespace, or open declarations). > Only for open4. Exports the opened names from the current module. F8Processed (scope-checked) intermediate form of the core f ps of Q.  Corresponds to T. Hrecord projection identifier Iside patterns J main branch Kside patterns M fN psQ<Left hand sides can be written in infix style. For example:   n + suc m = suc (n + m)  (f " g) x = f (g x) AWe use fixity information to see which name is actually defined. R:new with-patterns, rewrite equations and with-expressions SHoriginal pattern, with-patterns, rewrite equations and with-expressions T f psU| p (many) V rewrite e (many) Wwith e (many) XJA telescope is a sequence of typed bindings. Bound variables are in scope  in later types. YA typed binding. `KA sequence of typed bindings with hiding information. Appears in dependent 3 function spaces, typed lambdas, and telescopes. a. (xs : e) or {xs : e} b1A lambda binding is either domain free or typed. c. (xs : e) or {xs : e} d. x or {x} or .x or .{x} or {.x} e:Concrete patterns. No literals in patterns at the moment. f0, 1, etc. g .ehx@p unused i ()j _k (p)l{{p}} or  {{x = p}} m{p} or {x = p} neg: p => p' for operator _=>_ op1..pn before parsing operators pp p' or p {x = p'} qc or x rDConcrete expressions. Should represent exactly what the user wrote. sto print irrelevant things tex: unquote&, should be applied to a term of type Term uex:  quoteTerm, should be applied to a term vex: quote, should be applied to a name wex: quoteGoal x in e x"only used for printing telescopes yex: .p, only in patterns zex: x@p, only in patterns {ex: () or {}, only in patterns |ex: (e) }ex:  let Ds in e ~ex: record e {x = a; y = b} ex: record {x = a; y = b} ex: Set0, Set1, .. ex: Prop ex: Set ex:  (xs:e) -> e or  {xs:e} -> e ex: e -> e or .e -> e (NYI: {e} -> e) ex: \- { p11 .. p1a -> e1 ; .. ; pn1 .. pnz -> en } ex: \ () ex: \ x {y} -> e or \(x:A){y:B} -> e ex: {{e}} or {{x=e}} ex: {e} or {x=e} ex: e | e1 | .. | en ex: e + e ex: e e, e {e}, or  e {x = e} before parsing operators ex: _ or _A_5 ex: ? or  {! ... !} ex: 1 or "foo" ex: x Zan abstraction inside a special syntax declaration (see Issue 358 why we introduce this). Default is directive is private& (use everything, but do not export). $Computes the top-level module name. Precondition: The  has to be well-formed. &Get the leftmost symbol in a pattern. =Get all the identifiers in a pattern in left-to-right order.       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~BCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefgghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~r~}|{zyxwvutsbdc`aY[Z\]^_X&%$#"! ('9:;<=>68724355-./01)*+,  POQSRTUVWeqponmlkjihgfFLGMNHIJKCED?BA@   H      &%$#"! '()*+,-./01243556879:;<=>?BA@CEDFLGMNHIJKOPQSRTUVWXY[Z\]^_`abdce qponmlkjihgfr~}|{zyxwvutsBCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefgANone# A compressed /, in which consecutive positions with the same   are stored together. !Syntax highlighting information. A 7 is a mapping from file positions to meta information. -The first position in the file has number 1. 0Meta information which can be associated with a  character/character range. 9This note, if present, can be displayed as a tool-tip or A something like that. It should contain useful information about @ the range (like the module containing a certain identifier, or  the fixity of an operator). >The definition site of the annotated thing, if applicable and - known. File positions are counted from 1. ;Other aspects. (These can overlap with each other and with  s.) "Code which is being type-checked. <When this constructor is used it is probably a good idea to  include a + explaining why the pattern is incomplete. 9Unsolved constraint not connected to meta-variable. This 0 could for instance be an emptyness constraint.  Record type.  Primitive.  Module name. Record field. &Inductive or coinductive constructor. Bound variable. BVarious more or less syntactic aspects of the code. (These cannot  overlap.) Is the name an operator part? Things like Set and Prop. !Symbols like forall, =, ->, etc.  rs m( is a file whose positions are those in rs, 0 and in which every position is associated with m. Like , but with several  instead of only one. hMerges meta information. iMerges files. .Returns the smallest position, if any, in the .  Convert the 0 to a map from file positions (counting from 1)  to meta information.  Invariant for compressed files. -Note that these files are not required to be  maximally = compressed, because ranges are allowed to be empty, and the  .s in adjacent ranges are allowed to be equal. >Compresses a file by merging consecutive positions with equal & meta information into longer ranges.  Decompresses a compressed file.  rs m( is a file whose positions are those in rs, 0 and in which every position is associated with m. Like  singletonR, but with a list of  instead of a  single one. jMerges compressed files.  splitAtC p f splits the compressed file f into (f1, f2),  where all the positions in f1 are < p, and all the positions  in f2 are >= p. .Returns the smallest position, if any, in the . All the properties. Jklhimnojpqrstuvwxyz{|}~11*kl himnojpqrstuvwxyz{|}~BNone4  4CNoneY      !"#$%&'()*+,-./X      !"#$%&'()*+,-./X.-,+*)('&%$#"!      / 2.-,+*)('&%$#"!      /DNone 4 for root of split tree 7ISplit tree branching. A finite map from constructor names to splittrees G A list representation seems appropriate, since we are expecting not @ so many constructors per data type, and there is no need for  random access. 8Abstract case tree shape. 9A split is necessary. :Arg. no to split at. ;Sub split trees. <8No more splits coming. We are at a single, all-variable  clause. =,The number of variables bound in the clause @Convert a split tree into a  (for printing). 0123456789:;<=>?@AB0123456789:;<=>?@AB?>8<9=:;723456@A01B012345678<9=:;>?@ABENone&C"For modules we record the arity. I'm not sure that it's every used anywhere. F.Apart from the name, we also record whether it's a constructor or not and  what the fixity is. J3We distinguish constructor names from other names. WA  NameSpace= contains the mappings from concrete names that the user can N write to the abstract fully qualified names that the type checker wants to  read. [Local variables \GThe complete information about the scope at a particular program point N includes the scope stack, the local variables, and the context precedence. gKA scope is a named collection of names partitioned into public and private  names. uThe empty name space. v:Map functions over the names and modules in a name space. wZip together two name spaces. x'Map monadic function over a namespace. yThe empty scope. zThe empty scope info. {5Map functions over the names and modules in a scope. |Same as {3 but applies the same function to all name spaces. }=Map monadic functions over the names and modules in a scope. ~Same as }6 but applies the same function to both the public and  private name spaces. FZip together two scopes. The resulting scope has the same name as the  first scope. Same as 6 but applies the same function to both the public and  private name spaces. DFilter a scope keeping only concrete names matching the predicates. N The first predicate is applied to the names and the second to the modules. Return all names in a scope. Returns the scope's non-private names. >Merge two scopes. The result has the name of the first scope. GMerge a non-empty list of scopes. The result has the name of the first  scope in the list. JMove all names in a scope to the given name space (except never move from  Imported to Public). Add names to a scope. Add a name to a scope. Add a module to a scope.  Apply an 9 to a scope. &Rename the abstract names in a scope. +Restrict the private name space of a scope DRemove names that can only be used qualified (when opening a scope) 6Get the public parts of the public modules of a scope CCompute a flattened scope. Only include unqualified names or names - qualified by modules in the first argument. Look up a name in the scope IFind the shortest concrete name that maps (uniquely) to a given abstract  name. Takes the first component of . Takes the second component of . gCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~XCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~Xghijklmbfedcnop\]^_`a[WXYZVUTQSROPqJNMLKrFGHICDEstuvwxyz{|}~ICDEFGHIJNMLKOPQSRTUVWXYZ[\]^_`abfedcghijklmnopqrstuvwxyz{|}~FNone/Types which Geniplate should not descend into. A localised instance of . The generated  - functions neither descend into the types in  +, nor into the types in the list argument. A localised instance of . The generated  - functions neither descend into the types in  +, nor into the types in the list argument. GNone#4Patterns are variables, constructors, or wildcards.  QName is used in ConP rather than Name since ; a constructor might come from a particular namespace. ; This also meshes well with the fact that values (i.e. - the arguments we are matching with) use QName.  The type is  t' iff the pattern is a 6 record pattern. The scope used for the type is given # by any outer scope plus the clause' s telescope  (). for absurd clauses. :A clause is a list of patterns and the clause body should Bind. BThe telescope contains the types of the pattern variables and the B permutation is how to get from the order the variables occur in B the patterns to the order they occur in the telescope. The body @ binds the variables in the order they appear in the patterns.  6clauseTel ~ permute clausePerm (patternVars clausPats)CFor the purpose of the permutation and the body dot patterns count # as variables. TODO: Change this! 5Something where a meta variable may block reduction. 5A meta variable identifier is just a natural number. 9A level is a maximum expression of 0..n plus expressions 7 each of which is a number or an atom plus a number. Sorts. /if the free variable occurs in the second sort 3 the whole thing should reduce to Inf, otherwise  it's the normal Lub ISequence of types. An argument of the first type is bound in later types  and so on.  is never . (Types are terms with a sort annotation. Binder.  /: The bound variable might appear in the body.  ; is pseudo-binder, it does not introduce a fresh variable,  similar to the const of Haskell. +The body has (at least) one free variable.  Danger:  doesn't shift variables properly 6Eliminations, subsuming applications and projections. = Used for a view which exposes the head of a neutral term. name of a record projection Type of argument lists.  Raw values. Def3 is used for both defined and undefined constants. ; Assume there is a type declaration and a definition for 8 every constant, even if the definition is an empty  list of clauses. Explicit sharing 3Irrelevant stuff in relevant position, but created 5 in an irrelevant context. Basically, an internal $ version of the irrelevance axiom .irrAx : .A -> A. *dependent or non-dependent function space  c vsf vs, possibly a redex terms are beta normal x vs neutral 2Extract pattern variables in left-to-right order.  A + is also treated as variable (see docu for ). 2Does the pattern perform a match that could fail? 1Typically m would be TCM and f would be Blocked. An unapplied variable. A dummy type.  Top sort (Setomega). Get the next higher sort. Removing a topmost  constructor. Doesn't do any reduction. GSuggest a name for the first argument of a function of the given type. y aH HNone Ignore free variables in sorts. 6Where should we skip sorts in free variable analysis? Skip unconditionally.  Skip when annotation to a type.  Do not skip. IThe distinction between rigid and strongly rigid occurrences comes from: L Jason C. Reed, PhD thesis, 2009, page 96 (see also his LFMTP 2009 paper) JThe main idea is that x = t(x) is unsolvable if x occurs strongly rigidly O in t. It might have a solution if the occurrence is not strongly rigid, e.g. x = f -> suc (f (x ( y -> k))) has x = f -> suc (f (suc k)) #Jason C. Reed, PhD thesis, page 106 EFree variables of a term, (disjointly) partitioned into strongly and L and weakly rigid variables, flexible variables and irrelevant variables. (variables at top and under constructors 6ord. rigid variables, e.g., in arguments of variables  wvariables occuring in arguments of metas. These are potentially free, depending how the meta variable is instantiated.  .variables in irrelevant arguments and under a DontCare , i.e., in irrelevant positions   variables in uments   allVars fv includes irrelevant variables. "All but the irrelevant variables. HMark variables as flexible. Useful when traversing arguments of metas. VMark rigid variables as non-strongly. Useful when traversion arguments of variables. 'Mark all free variables as irrelevant. ?Mark all free variables as unused, except for irrelevant vars. Pointwise union.  delete x fv deletes variable x from variable set fv. subtractFV n fv* subtracts $n$ from each free variable in fv. $A single (strongly) rigid variable. Doesn'<t go inside solved metas, but collects the variables from a  metavariable application X ts as  flexibleVars. 8Is the variable bound by the abstraction actually used? :               (     INone1=Filter a list using a list of Bools specifying what to keep.  !"#$%&'()*+,-./0123 !"#$%&'()*+,-./01230-/.*,+123')(&%!"#$   !"#$%&')(*,+-/.0123JNone[ASmart constructor for let expressions to avoid unneceessary lets \'Some things are pointless to make lazy ]MIf casing on the same expression in a sub-expression, we know what branch to  pick ^?Smart constructor for applications to avoid empty applications _ Substitution b(Get the free variables in an expression /456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_Substitute this ... with this ...  in this. `ab/456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`ab4YXNQORSTUVWSTUPIMLKJ=HGFEDCBA@?>48659:;<7<<Z[\]^_`ab4 8659:;<7<<= HGFEDCBA@?>IMLKJN QORSTUVWSTUPXYZ[\]^_`abKNoned Absurd case. e Done xs b stands for the body b where the xs contains hiding H and name suggestions for the free variables. This is needed to build E lambdas on the right hand side for partial applications which can  still reduce. f Case n bs stands for a match on the n -th argument  (counting from zero) with bs as the case branches. i?Map from constructor names to their arity and the case subtree j!Map from literal to case subtree k'(Possibly additional) catch-all clause cdefghijklmnopqrstcdefghijklmnopqrstplmnoghijkcfedqrstcfedghijklmnopqrstLNoney6Put it in a monad to make it possible to do strictly. uvwxy     uvwxyuvwxyuvwxy     MNone{*The type serves the same role as the type  argument to . )TODO: If a hole is plugged this type may ! have to be updated in some way. z{|}~z{|}~}~z|{z|{}~NNoneNothing8 means there is an overlapping match for this variable.   Just cons/ means that it is an non-overlapping match and  cons# are the encountered constructors. If matching is inconclusive (Block) we want to know which % variables are blocking the match. 4Could match if non-empty list of blocking variables  is instantiated properly. Definitely does not match. Matches unconditionally. 2We use a special representation of the patterns we're trying to match L against a clause. In particular we want to keep track of which variables  are blocking a match. Given   the function clauses cs  2. the patterns ps and permutation perm of a split clause Jwe want to compute a variable index of the split clause to split on next. First, we find the set cs' of all the clauses that are instances (via substitutions rhos) of the split clause. QIn these substitutions, we look for a column that has only constructor patterns. &We try to split on this column first. 3Match the given patterns against a list of clauses &Left dominant merge of blocking vars.  choice m m' combines the match results m of a function clause / with the (already combined) match results $m'$ of the later clauses. < It is for skipping clauses that definitely do not match (). & It is left-strict, to be used with foldr. * If one clause unconditionally matches () we do not look further. ?Check if a clause could match given generously chosen literals matchClause mlist qs i c checks whther clause c number i ' covers a split clause with patterns qs. matchPats mlist ps qs0 checks whether a function clause with patterns  ps% covers a split clause with patterns qs matchPat mlit p q* checks whether a function clause pattern p ! covers a split clause pattern q. There are three results:  Yes () means it covers, because p is a variable  pattern or q is a wildcard.  No means it does not cover.  Block [x] means p is a proper instance of q and could become  a cover if q was split on variable x. =Combine results of checking whether function clause patterns ! covers split clause patterns. < is dominant: if one function clause pattern is disjoint to 0 the corresponding split clause pattern, then # the whole clauses are disjoint. 6 is neutral: for a match, all patterns have to match. + accumulates variables of the split clause  that have to be instantiated @ to make the split clause an instance of the function clause. ONone!termination check (default=True) EFor a general expression we can either remember just the source code < position or the entire concrete expression it came from. 9Even if we store the original expression we have to know ( whether to put parenthesis around it. ? !"#$%&'))" !"#$%&'PNoneB-Parameterised over the type of dot patterns. 3Generated at type checking for implicit arguments. %Defined pattern: function definition f ps or destructor pattern d p ps. The lhs minus with*-patterns in projection-application view.  Parameterised over the type e of dot patterns.  Projection Record projection identifier. Indices of the projection.  Currently none [](, since we do not have indexed records.  Main branch. Further applied to patterns. 'The head applied to ordinary patterns. Head f. Applied to patterns ps. AThe lhs of a clause in projection-application view (outside-in). ) Projection patters are represented as s. Range.  Copatterns. with patterns (after |). 0The lhs of a clause in spine view (inside-out). ( Projection patterns are contained in  spLhsPats,  represented as DefP d []. Range. "Name of function we are defining.  Function parameters (patterns). with patterns (after |). The 1s are the names of the generated with functions.  One for each .  The RHS shouldn't be another RewriteRHS The # is the name of the with function. We could throw away where- clauses at this point and translate them to  let. It''s not obvious how to remember that the let was really a  where7 clause though, so for the time being we keep it here. JA typed binding. Appears in dependent function spaces, typed lambdas, and J telescopes. I might be tempting to simplify this to only bind a single L name at a time. This would mean that we would have to typecheck the type  several times (x,y:A vs. x:A; y:A). In most cases this wouldn't  really be a problem, but it'-s good principle to not do extra work unless  you have to. (Typed bindings with hiding information. . (xs : e) or {xs : e} 1A lambda binding is either domain free or typed. . (xs:e) or {xs:e} . x or {x} or .x or .{x} Only s. -only for highlighting and abstractToConcrete irrefutable pattern binding  LetBind info rel name type defn scope annotation The ' gives the constructor type telescope, (x1 : A1)..(xn : An) -> Prop, + and the optional name is the constructor's name. lone record signature the s are + and binds the parameters of the datatype. lone data signature  ^ the s are + and binds the parameters of the datatype. sequence of function clauses (only retained for highlighting purposes *a bunch of mutually recursive definitions primitive function  record field  postulate  +for printing DontCare from Syntax.Internal !$The splicing construct: unquote ... $binds Name to current type in Expr %scope annotation &record update 'record construction (#only used when printing telescopes +Set, Set1, Set2, ... ,independent function space 1with application 3=meta variable for hidden argument (must be inferred locally) 4meta variable for interaction 5 Literals 6 Constructors 7?Constants (i.e. axioms, functions, projections, and datatypes) 8Bound variables ;%Used for checking pattern linearity. <Used in AbstractToConcrete. @Are we in an abstract block? *In that case some definition is abstract. B/Extracts all the names which are declared in a . C This does not include open public or let expressions, but it does @ include local modules, where clauses and the names of extended  lambdas. C%The name defined by the given axiom. +Precondition: The declaration has to be an .       !"#$%&'()*+,-./0123456789:;<=()*+,-./0123456789:;<=>?@ABCDEFGHIJK>?@ABCDEFGHIJKLMN      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJK876543210/.-,+*)('&%$#"!      9:;<=BC@ADE?>FGHIJKO       876543210/.-,+*)('&%$#"! 9:;<=()*+,-./0123456789:;<=>?@ABCDEFGHIJK>?@ABCDEFGHIJKLMNQNoneP.Check whether we are dealing with a universe. LMNOPLMNOPLMNOPLMNOPRNoneO4lone type signatures that wait for their definition PAThe kind of the forward declaration, remembering the parameters. Qname of a function R!name of a record with parameters Sname of a data with parameters T-we are nicifying decls not in a mutual block U we are nicifying a mutual block RThe exception type. T7in a mutual block, a clause could belong to any of the [Name] type signatures bDOne clause in a function definition. There is no guarantee that the Q  actually declares the p$. We will have to check that later. dOnly ws. eOnly ws. V%Termination check? (Default = True). fKThe nice declarations. No fixity declarations and function definitions are I contained in a single constructor instead of spread out between type  signatures and clauses. The private,  postulate, and abstract D modifiers have been distributed to the individual declarations. jCblock of function clauses (we have seen the type signature before) l<a uncategorized function clause, could be a function clause G without type signature or a pattern lhs (e.g. for irrefutable let)x w1Axioms and functions can be declared irrelevant. W'Search for forward type signature that XCEnsure that all forward declarations have been given a definition. YHCompute visible parameters of a data or record signature or definition. ZHAdd more fixities. Throw an exception for multiple fixity declarations. [.Get the fixities from the current block. Doesn' t go inside any blocks. N The reason for this is that fixity declarations have to appear at the same I level (or possibly outside an abstract or mutual block) as its target  declaration. O\]^_Q`aObcdPQRSeTURSTUVWXYZ[\]^_`abcdeVfghijklmnopqrstuvwfghijkWlXmxnYyZ[zopqrs*QRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz*fwvutsrqponmlkjihgedbcRa`_^]\[ZYXWVUTSQxyz#\_^]Q`aObcdPSRQeUTRa`_^]\[ZYXWVUTSbcdeVfwvutsrqponmlkjihgfghijkWlXmxnYyZ[zopqrsSNone "Combining a hierarchy of parsers. Variant of chainr1 Variant of chainl1 *Parse a specific identifier as a NamePart  Parse the  operator part of the given syntax. ) holes at beginning and end are IGNORED. BGiven a name with a syntax spec, and a list of parsed expressions % fitting it, rebuild the expression. N Note that this function must not parse any input (as guaranteed by the type) ?Parse using the appropriate fixity, given a parser parsing the : operator part, the name of the operator, and a parser of  subexpressions. ?Parse using the appropriate fixity, given a parser parsing the : operator part, the name of the operator, and a parser of  subexpressions. ?Parse using the appropriate fixity, given a parser parsing the : operator part, the name of the operator, and a parser of  subexpressions. ?Parse using the appropriate fixity, given a parser parsing the : operator part, the name of the operator, and a parser of  subexpressions. ?Parse using the appropriate fixity, given a parser parsing the : operator part, the name of the operator, and a parser of  subexpressions. ?Parse using the appropriate fixity, given a parser parsing the : operator part, the name of the operator, and a parser of  subexpressions. {|}~ {|}~ ~{|}{|}~ TNone!!The result of parsing something. What you get if parsing fails. where the error occured the remaining input the previous token hopefully an explanation  of what happened  There aren'"t any parser flags at the moment. 0Should comment tokens be returned by the lexer? ?We need to keep track of the context to do layout. The context = specifies the indentation (if any) of a layout block. See  Agda.Syntax.Parser.Layout for more informaton. layout at specified column  no layout <To do context sensitive lexing alex provides what is called  start codes N in the Alex documentation. It is really an integer representing the state  of the lexer, so we call it LexState instead. JThe parser state. Contains everything the parser and the lexer could ever  need. #position at current input location position of last token the current input the character before the input the previous token the stack of layout contexts the state of the lexer - (states can be nested so we need a stack) currently there are no flags The parse monad. Equivalent to StateT  (Either )  except for the definition of fail, which builds a suitable   object. @Constructs the initial state of the parser. The string argument > is the input string, the file path is only there because it's part  of a position. The default flags. .The most general way of parsing a string. The Agda.Syntax.Parser will define . more specialised functions that supply the  and the  . /The even more general way of parsing a string. ,The most general way of parsing a file. The Agda.Syntax.Parser will define . more specialised functions that supply the  and the  . ;Note that Agda source files always use the UTF-8 character  encoding. JThe parse interval is between the last position and the current position.  parseError = failGFake a parse error at the specified position. Used, for instance, when J lexing nested comments, which when failing will always fail at the end L of the file. A more informative position is the beginning of the failing  comment. IFor lexical errors we want to report the current position as the site of H the error, whereas for parse errors the previous position is the one  we'Gre interested in (since this will be the position of the token we just  lexed). This function does  the current position. #Return the current layout context. FShould only be used at the beginning of a file. When we start parsing K we should be in layout mode. Instead of forcing zero indentation we use ' the indentation of the first token. >tuvwxyz{|}~//( tuvwxyz{|}~UNone "Sometimes regular expressions aren'$t enough. Alex provides a way to do K arbitrary computations to see if the input matches. This is done with a  lex predicate. EIn the lexer, regular expressions are associated with lex actions who's ' task it is to construct the tokens. $This is what the lexer manipulates. current position current input previously read character ,Get the previously lexed character. Same as . Alex needs this  to be defined to handle "patterns with a left-context". Lex a character. No surprises. !This function is used by Alex 2.  A variant of . !This function is used by Alex 3. Conjunction of s. Disjunction of s.  Negation of s. WNone EThe LookAhead monad is basically a state monad keeping with an extra  , wrapped around the  monad. %Get the current look-ahead position. Set the look-ahead position. Lift a computation in the  monad to the  monad. CLook at the next character. Fails if there are no more characters. BConsume all the characters up to the current look-ahead position. -Undo look-ahead. Restores the input from the . !Consume the next character. Does  followed by . LDo a case on the current input string. If any of the given strings match we P move past it and execute the corresponding action. If no string matches, we O execute a default action, advancing the input one character. This function * only affects the look-ahead position. Same as 9 but takes the initial character from the first argument M instead of reading it from the input. Consequently, in the default case  the input is not advanced. Run a 8 computation. The first argument is the error function.    YNone!Should comment tokens be output? !Should comment tokens be output? ,Manually lexing a block comment. Assumes an  open comment has been lexed. + In the end the comment is discarded and  is called to lex a real  token.  Lex a hole ( {! ... !}). Holes can be nested.  Returns  . KSkip a block of text enclosed by the given open and close strings. Assumes L the first open string has been consumed. Open-close pairs may be nested. ZNone BLex a string literal. Assumes that a double quote has been lexed. HLex a character literal. Assumes that a single quote has been lexed. A L character literal is lexed in exactly the same way as a string literal. L Only before returning the token do we check that the lexed string is of O length 1. This is maybe not the most efficient way of doing things, but on L the other hand it will only be inefficient if there is a lexical error. Custom error function. EThe general function to lex a string or character literal token. The ( character argument is the delimiter (" for strings and ' for  characters). GThis is where the work happens. The string argument is an accumulating ) parameter for the string being lexed. EA string gap consists of whitespace (possibly including line breaks) I enclosed in backslashes. The gap is not part of the resulting string. Lex a single character. @Lex an escaped character. Assumes the backslash has been lexed. %Read a number in the specified base. Same as % but with an accumulating parameter. The escape codes.     [None CThis is the initial state for parsing a literate file. Code blocks  should be enclosed in \ begin{code} \ end{code} pairs. DThis is the initial state for parsing a regular, non-literate file. 8The layout state. Entered when we see a layout keyword () and - exited either when seeing an open brace ( openBrace) or at the next token  (). Update: we don'!t use braces for layout anymore. The state inside a pragma. We enter this state from  when the token following a L layout keyword is to the left of (or at the same column as) the current  layout context. Example:   data Empty : Set where  foo : Empty -> Nat (Here the second line is not part of the where clause since it is has the  same indentation as the data- definition. What we have to do is insert an  empty layout block {} after the where!. The only thing that can happen  in this state is that % is executed, generating the closing 8 brace. The open brace is generated when entering by . <This state is entered at the beginning of each line. You can't lex J anything in this state, and to exit you have to check the layout rule.  Done with . IThis state can only be entered by the parser. In this state you can only  lex the keywords using, hiding, renaming and to. Moreover they are K only keywords in this particular state. The lexer will never enter this 7 state by itself, that has to be done in the parser. IReturn the next token. This is the function used by Happy in the parser.  lexer k =  >>= k&Do not use this function; it sets the  to  . 4This is the main lexing function generated by Alex.                                   ~                XNone=True if the given state appears somewhere on the state stack 'True if we are at the end of the file. ITrue when the given character is the next character of the input string. Parse a literal. 7Parse an identifier. Identifiers can be qualified (see p).  Example:  Foo.Bar.f Parse a  token. Parse a  token, triggers layout for /. 9Exit the current state throwing away the current lexeme. 4Enter a new state throwing away the current lexeme. 5Exit the current state and perform the given action. /Enter a new state without consuming any input. )Executed for layout keywords. Enters the   ( state and performs the given action. Like (, but applies a function to the string. Parse a token from an F and the lexed string. )The most general way of parsing a token. -Scan the input to find the next token. Calls  #. This is the main lexing function )where all the work happens. The function  , Aused by the parser is the continuation version of this function. %Called at the end of a file. Returns . 1Set the current input and lex a new token (calls ). CUse the input string from the previous input (with the appropriate G number of characters dropped) instead of the fake input string that 8 was given to Alex (with unicode characters removed).  Alex 2 can'.t handle unicode characters. To solve this we 4 translate all Unicode (non-ASCII) identifiers to z, all Unicode  operator characters to +(, and all whitespace characters (except  for t and n) to ' '!. It is important that there aren't any  keywords containing z, + or  . 4Return a token without looking at the lexed string. 3Exit the current state without consuming any input !Parse a possibly qualified name.         VNone&This action is only executed from the   . state. It will exit this state, enter the   state, M and return a virtual close brace (closing the empty layout block started  by ). FStart a new layout context. This is one of two ways to get out of the    state (the other is   ). There are  two possibilities: G The current token is to the right of the current layout context (or we're  in a no layout context). J The current token is to the left of or in the same column as the current  context. JIn the first case everything is fine and we enter a new layout context at P the column of the current token. In the second case we have an empty layout  block so we enter the   state. In both F cases we return a virtual open brace without consuming any input. @Entering a new state when we know we want to generate a virtual {} may O seem a bit roundabout. The thing is that we can only generate one token at O a time, so the way to generate two tokens is to generate the first one and J then enter a state in which the only thing you can do is generate the  second one. /Executed for the first token in each line (see  ). M Checks the position of the token relative to the current layout context.  If the token is   to the left : H Exit the current context and a return virtual close brace (stay in the    state).   same column :  Exit the  ! state and return a virtual semi  colon.   to the right :  Exit the   state and continue lexing. If the current block doesn'%t use layout (i.e. it was started by   %) all positions are considered to be  to the right. $Executed upon lexing an open brace ('{'). Enters the   context. $Executed upon lexing a close brace ('}'). Exits the current layout M context. This might look a bit funny--the lexer will happily use a close L brace to close a context open by a virtual brace. This is not a problem J since the parser will make sure the braces are appropriately matched. 3Compute the relative position of a location to the  current layout context.         \None 2Parse the token stream. Used by the TeX compiler. 4Parse an expression. Could be used in interactions. Parse a module. Required by Happy. Create a name from a string. /Create a qualified name from a list of strings Match a particular name. (Build a forall pi (forall x y z -> ...) ,Converts lambda bindings to typed bindings. $Check that an import directive doesn't contain repeated names :Breaks up a string into substrings. Returns every maximal 6 subsequence of zero or more characters distinct from .  splitOnDots "" == [""] * splitOnDots "foo.bar" == ["foo", "bar"] . splitOnDots ".foo.bar" == ["", "foo", "bar"] . splitOnDots "foo.bar." == ["foo", "bar", ""] . splitOnDots "foo..bar" == ["foo", "", "bar"] Returns >0 iff the name is a valid Haskell (hierarchical)  module name. *Turn an expression into a left hand side.  DTurn an expression into a pattern. Fails if the expression is not a  valid pattern. !ATurn an expression into a name. Fails if the expression is not a  valid identifier.  Test suite. C"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:   ;< =!>?@ ABCDEFGHIJKLMNOPQRST        ="#$%&'(*)+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:   ;< =!>?@ ABCDEFGHIJKLMNOPQRST]None Wrapped Parser type. Parses a module. Parses an expression. 4Gives the parsed token stream (including comments). U:Keep comments in the token stream generated by the lexer. VADo not keep comments in the token stream generated by the lexer.  WXYZ[ \ ]     UV                 WXYZ[ \ ]     UV^None  Note that   only catches s.         None %Type-checking errors. &for pattern violations *EDistinguish error message when parsing lhs or pattern synonym, resp. >?The expr was used in the right hand side of an implicit module  definition, but it wasn't of the form m Delta. N7Module name, file from which it was loaded, file which , the include path says contains the module.  Scope errors s;The arguments are the meta variable, the parameters it can < depend on and the paratemeter that it wants to depend on. u8We ended up with an equality constraint where the terms 1 have different types. This is not supported. x.The two function types have different hiding. y1The two function types have different relevance. &The given type should have been a pi. (The given type should have been a sort. 8The term does not correspond to an inductive data type. =Expected a relevant function and found an irrelevant lambda. LA function is applied to a hidden argument where a non-hidden was expected. :Expected a non-hidden function and found a hidden lambda. BThe left hand side of a function definition has a hidden argument # where a non-hidden was expected. ,Varying number of arguments for a function. constructor, type -Indices (variables), index expressions (with 4 constructors applied to reconstructed parameters),  parameters. Variables, indices.  Indices. constructor, datatype ?Expected a type to be an application of a particular datatype. The target of a constructor isn't its datatype applied to  something that isn',t the parameters. First term is the correct 3 target and the second term is the actual target. The target of a constructor isn't an application of its  datatype. The  records what it does target. 8Information about a mutual block which did not pass the  termination checker. 6The functions which failed to check. (May not include % automatically generated functions.) The problematic call sites. Information about a call. Range of the head identifier. &Formatted representation of the call. (# would perhaps be better here, but  doesn't come  with an  instance.) "Do not append implicit arguments. AAdd implicit arguments in the end until type is no longer hidden . $all abstract things can be accessed #no abstract things can be accessed 6abstract things in the current module can be accessed The Context is a stack of  s. -The path to the file that is currently being  type-checked. 5anonymous modules and their number of free variables to detect import cycles "the current (if any) mutual block ?Are we currently in the process of solving active constraints?  Are we allowed to assign metas? 7When checking the typesignature of a public definition : or the body of a non-abstract definition this is true. 8 To prevent information about abstract things leaking  outside the module. *Are we checking an irrelevant argument? (= Irrelevant) 5 Then top-level irrelevant declarations are enabled.  Other value: Relevant', then only relevant decls. are avail. ,Sometimes we want to disable display forms. ;should we try to recover interaction points when reifying? 5 disabled when generating types for with functions it'5s safe to eta contract implicit lambdas as long as we're < not going to reify and retypecheck (like when doing with  abstraction) 0Interactive highlighting uses this range rather  than  . what we're doing at the moment &True when called from the Emacs mode. Set to   when imported modules are  type-checked. ,This number indicates how far away from the / top-level module Agda has come when chasing / modules. The level of a given module is not 5 necessarily the same as the length, in the module 3 dependency graph, of the shortest path from the 2 top-level module; it depends on in which order ' Agda chooses to chase dependencies. 6When True, allows destructively shared updating terms ; during evaluation or unification. This is disabled when = doing speculative checking, like solve instance metas, or > when updating might break abstraction, as is the case when " checking abstract definitions. 7How should highlighting be sent to the user interface? Both via files and via stdout.  Via stdout. <How much highlighting should be sent to the user interface? 4This includes both non-interactive highlighting and > interactive highlighting of the expression that is currently  being type-checked. used by setCurrentRange - Primitive or builtin functions. 0 for primitive functions,   something for builtin functions. 1 for primitive functions,   something for builtin functions. 7Inductive or coinductive? 9Number of parameters. ;Constructor name. =The record constructor's type. ?The record field telescope @Mutually recursive functions, datas and records. A!Eta-expand at this record type. False" for unguarded recursive records. B or  Coinductive'? Matters only for recursive records. CRecursive record. Implies recEtaEquality = False(. Projections are not size-preserving. LMutually recursive functions, datas and records. RMutually recursive functions, datas and records. T,Are the clauses of this definition delayed? UIs it a record projection? @ If yes, then return the name of the record type and index of E the record argument. Start counting with 1, because 0 means that > it is already applied to the record. (Can happen in module ? instantiation.) This information is used in the termination  checker. V=Should calls to this function be normalised at compile-time? W+Has this function been created by a module  instantiation? X:Has this function been termination checked? Did it pass? Z-Subterm occurrences for positivity checking. G The constructors are listed in increasing information they provide:  Mixed < = JustPos < = StrictPos < = GuardPos <= Unused  Mixed < = JustNeg <= Unused. \WGuarded strictly positive occurrence (i.e., under "). For checking recursive records. ]Strictly positive occurrence. ^0Positive occurrence, but not strictly positive. _Negative occurrence. `.Arbitrary occurrence (positive and negative). f,Polarity for equality and subtype checking. g constant h no information (mixed variance) i antitone j monotone t.Some defs can be irrelevant (but not hidden). vType of the lifted definition. The three arguments are:  n: number of free variables; 2 Patterns for arguments, one extra free var which + represents pattern vars. There should n of them.  Display form. n free variables. &This is the number of parameters when  we're inside the section and 0  outside. It's used to know how much of ) the context to apply function from the # section to when translating from  abstract to internal syntax. 9For printing, we couple a meta with its name suggestion. FName suggestion for meta variable. Empty string means no suggestion. MetaInfo5 is cloned from one meta to the next during pruning. 8Run the extended occurs check that goes in definitions? Used for printing.  Just x8 if meta-variable comes from omitted argument with name x. )solution blocked by unsolved constraints open, to be instantiated as implicit from scope  unsolved  solved by  Lam .. Sort s solved by term <Frozen meta variable cannot be instantiated by unification. D This serves to prevent the completion of a definition by its use ! outside of the current block.  (See issues 118, 288, 399). Do not instantiate. 5some metavariables are more eager to be instantiated a metavariable doesn'"t have to depend on all variables  in the context, this  permutation will throw away the  ones it does not depend on Cmeta variables scheduled for eta-expansion but blocked by this one Care we past the point where we can instantiate this meta variable? .A thing tagged with the context it came from. +the range is the one of the absurd pattern -the two types are for the error message only Haskell imports listed in % (transitively) imported modules are  not included here.  Pragma options set in the file. >7 if warnings were encountered when the module was type  checked. ;The modification time stamp of the interface file when the @ interface was read or written. Alternatively, if warnings were < encountered (in which case there may not be any up-to-date ? interface file), the time at which the interface was produced  (approximately).  Can be used for various things. BA part of the state which is not reverted when an error is thrown  or the state is reset. 5Options which apply to all files, unless overridden. Highlighting info. 7Highlighting info for tokens (but not those tokens for  which highlighting exists in  ). 2Definitions to be considered during occurs check. = Initialized to the current mutual block before the check. 7The current module is available after it has been type  checked. &Options applying to the current file. OPTIONS ! pragmas only affect this field. 7Imports that should be generated by the compiler (this * includes imports from imported modules). 2Callback fuction to call when there is a response ( to give to the interactive frontend.  See the documentation of . .,Are the clauses of this definition delayed? /AIs the definition just a copy created by a module instantiation? 1$ifTopLevelAndHighlightingLevelIs l m runs m when we're B type-checking the top-level module and the highlighting level is  at least l. 3/Preserve the state of the failing computation. > Running the type checking monad @6Runs the given computation in a separate thread, with a copy of $ the current state and environment. <Note that Agda sometimes uses actual, mutable state. If the  computation given to forkTCM tries to modify this state, then E bad things can happen, because accesses are not mutually exclusive.  The forkTCM7 function has been added mainly to allow the thread to  read8 (a snapshot of) the current state in a convenient way. ANote also that exceptions which are raised in the thread are not @ propagated to the parent, so the thread should not do anything  important. A'Base name for extended lambda patterns H ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                            ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                            ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A^_`abcdefghijklmnopqrstuvwxyz{|}~# ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                            ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                            ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A&                           ! " # }  ~ $ r s t u v w x y z { | q p o n k m l f j i h g a b c d e % Z ` _ ^ ] \ [ , Y N E 8 2 - O P Q R S T U V W X F G H I J K L M 9 : ; < = > ? @ A B C D 3 4 5 6 7 . / 0 1 & ' * + ' ) ( $ & % ! " #  ( )      * + , - . / 0                     1 2 -  ~ } | { z y x w v u t s r q p o n m l k j i h g f e d c b a ` _ ^ ] \ [ Z Y X W V U T S R Q P O N M L K J I H G F E D C B A @ ? > = < ; : 9 8 7 6 5 4 3 2 1 0 / . * , + % ) ( ' & # $ ! " 3 4 5 6 7 8 9 : ; < = > ? @ A # $ ! " % ) ( ' & * , + -s  ~ } | { z y x w v u t s r q p o n m l k j i h g f e d c b a ` _ ^ ] \ [ Z Y X W V U T S R Q P O N M L K J I H G F E D C B A @ ? > = < ; : 9 8 7 6 5 4 3 2 1 0 / .                                            ! " # $ & % ' ) ( * + ,- Y N E 8 2 - O P Q R S T U V W X F G H I J K L M 9 : ; < = > ? @ A B C D 3 4 5 6 7 . / 0 1 Z ` _ ^ ] \ [ a b c d e f j i h g k m l n o p q r s t u v w x y z { | }  ~                                                 ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A^_`abcdefghijklmnopqrstuvwxyz{|}~bNone QApply a substitution. SSubstitutions. Y!(abstract args v) args --> v[args]. [)Apply something to a bunch of arguments. E Preserves blocking tags (application can never resolve blocking). ]JThe type must contain the right number of pis without have to perform any  reduction. f applySubst (  f& ) v == applySubst  (applySubst  v) r %mkPi dom t = telePi (telFromList [dom]) t tEverything will be a pi. v>Dependent least upper bound, to assign a level to expressions  like forall i -> Set i. dLub s1 i.s2 = omega if i# appears in the rigid variables of s2. wInstantiate an abstraction {underAbs k a b applies k to a and the content of  abstraction b and puts the abstraction back.  a/ is raised if abstraction was proper such that  at point of application of k and the content of b  are at the same context.  Precondition: a and b' are at the same context at call time. |underLambdas n k a b drops n initial s from b,  performs operation k on a and the body of b,  and puts the  s back. a is raised correctly , according to the number of abstractions. (Syntactic equality, ignores stuff below DontCare. N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~  6 N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~  6 [ \ ] Y Z ^ _ S X W V U T ` a b c d e f g h i j Q R k l m n O P N o p q r s t u v w x y z { | } ~  w N O P Q R S X W V U T Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~  cNone subst u . abstractTerm u == id     eNone The coinductive primitives. !Tries to build a  .                           !                           !                           !                            !iNone *;Resets the non-persistent part of the type checking state. +'Resets all of the type checking state. ,Set the current scope. -Get the current scope. 3Sets stExtLambdaTele . 4Get stExtLambdaTele. 6Modify the current scope. 7$Run a computation in a local scope. 8Same as  7., but discard the scope from the computation. 93Discard any changes to the scope by a computation. :GSet the top-level module. This affects the global module id of freshly  generated names. ;IUse a different top-level module for a computation. Used when generating  names for imported modules. <6Tell the compiler to import the given Haskell module. =Get the Haskell imports.  * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < =jNone D9We make the translation monadic for modularity purposes. FNames in abstract syntax are fully qualified, but the concrete syntax H requires non-qualified names in places. In theory (if all scopes are K correct), we should get a non-qualified name when translating back to a - concrete name, but I suspect the scope isn't always perfect. In these 2 cases we just throw away the qualified part. It's just for pretty printing  anyway... General bracketing function. Expression bracketing Pattern bracketing Pattern bracketing JIf a name is defined with a fixity that differs from the default, we have 3 to generate a fixity declaration for that name. M:Translate something in a context of the given precedence. :Translate something in a context of the given precedence. !Helper function used in instance ToConcrete Definition. P > ? @ A B C D E F G H I J K Lthe bracketing function Should we bracket things  which have the given  precedence?  M      > ? @ A B C D E F G H I J K L M A B C M L I > ? K G F J D @ E HE > ? @ A B C D E F G H I J K L M     kNone N O P Q N O P Q N O P Q N O P QpNone VsimplifyLevelConstraint n c cs turns an c into an equality @ constraint if it is an inequality constraint and the reverse  inequality is contained in cs . Number n is the length  of the context c is defined in.  V V V VrNone Y Z [ \ ] ^ !"#$%&'() Y Z [ \ ] ^ \ ] ^ Y Z [ Y Z [ \ ] ^ !"#$%&'()sNone _,Get the name of the current module, if any. `$Set the name of the current module. a8Get the number of variables bound by anonymous modules. b,Add variables bound by an anonymous module. c)Set the current environment to the given dGet the current environment e7Increases the module nesting level by one in the given  computation.  _ ` a b c d e _ ` a b c d e _ ` a b c d e _ ` a b c d etNone f,Create an open term in the current context. g%Create an open term which is closed. hIExtract the value from an open term. Must be done in an extension of the * context in which the term was created.  f g h i f g h i f g h i f g h ihNone (QCheck if we are in a compatible context, i.e. an extension of the given context. )Get the current context. j Modify the   field of a  . k Modify all  s. l Modify a   in a computation. nChange the context. o Change to top (=empty) context. pDelete the last n bindings from the context. q Deprecated. raddCtx x arg cont add a variable to the context. Chooses an unused . sN-ary variant of addCtx. t;add a bunch of variables with the same type to the context u9Turns the string into a name and adds it to the context. vJTurns the string into a name and adds it to the context, with dummy type. w5Context entries without a type have this dummy type. xGo under an abstraction. yLGo under an abstract without worrying about the type to add to the context. z Add a telescope to the context. {Add a let bound variable |%Get the size of the current context. }Generate [Var n - 1, .., Var 0]& for all declarations in the context. Get the current context as a  with the specified . 1get type of bound variable (i.e. deBruijn index) TODO: move(?) HGet the term corresponding to a named variable. If it is a lambda bound M variable the deBruijn index is returned and if it is a let bound variable  its definition is returned.  ( ) j k l m n o p q r s t u v w x y z { | } ~   ( ) j k l m n o p q r s t u v w x y z { | } ~   j k l m n o p q r s t u v w x y z { ) | } ~  (  ( ) j k l m n o p q r s t u v w x y z { | } ~  uNone FAssumes that the first module in the import path is the module we are  worried about.     vNone &Set the mutual block for a definition Get all mutual blocks ?Get the current mutual block, if any, otherwise a fresh mutual  block is returned.     :None=Maps top-level module names to the corresponding source file  names. =Maps source file names to the corresponding top-level module  names. :Errors which can arise when trying to find a source file. #Invariant: All paths are absolute. #Several matching files were found. 7Invariant: The list of matching files has at least two  elements. <The file was not found. It should have had one of the given  file names. ?Converts an Agda file name to the corresponding interface file  name. ?Given the module name which the error applies to this function  converts a   to a  -. @Finds the source file corresponding to a given top-level module ( name. The returned paths are absolute. -Raises an error if the file cannot be found. ATries to find the source file corresponding to a given top-level / module name. The returned paths are absolute.  A variant of   which does not require . <Finds the interface file corresponding to a given top-level / module name. The returned paths are absolute. @Raises an error if the source file cannot be found, and returns  7 if the source file can be found but not the interface  file. =Ensures that the module name matches the file name. The file B corresponding to the module name (according to the include path) , has to be the same as the given file name. >Computes the module name of the top-level module in the given  file.  A variant of  ( which raises an error if the file name ! does not match the module name. =The file name is interpreted relative to the current working $ directory (unless it is absolute).  Creates a   map based on  .  Include paths. Cached invocations of  . An updated copy is returned. The name of the module. #The file from which it was loaded.       None 2Callback fuction to call when there is a response ( to give to the interactive frontend. =Note that the response is given in pieces and incrementally, G so the user can have timely response even during long computations. Typical  functions:  Convert the response into a * representation and " print it on standard output 2 (suitable for inter-process communication). 8 Put the response into a mutable variable stored in the  closure of the  function. 2 (suitable for intra-process communication). (Responses for any interactive interface =Note that the response is given in pieces and incrementally, G so the user can have timely response even during long computations.  The default  function  is set to __ IMPOSSIBLE__% because in this way it is easier to @ recognize that some response is lost due to an uninitialized   function. Give action result #Comment derived from agda2-mode.el If   is ' Give_String s', then the goal is replaced by s, E and otherwise the text inside the goal is retained (parenthesised  if   is  ). Status information. "Are implicit arguments displayed? /Has the module been successfully type checked? 5Info to display at the end of an interactive command  , denotes either an error or a success (when   is present) 0 TODO: split these into separate constructors  ' denotes two different types of errors 0 TODO: split these into separate constructors >When an error message is displayed this constructor should be  used, if appropriate. $ $ $    fNone "Gets the include directories. Precondition:  must be  something. @Which directory should form the base of relative include paths? The current working directory. The root directory of the "project" containing the given A file. The file needs to be syntactically correct, with a module  name matching the file name. Sets the pragma options. BSets the command line options (both persistent and pragma options  are updated). CRelative include directories are made absolute with respect to the D current working directory. If the include directories have changed  (and were previously  something), then the state is reset  (completely) . /An empty list of relative include directories ( []) is  interpreted as [.]. :Returns the pragma options which are currently in effect. @Returns the command line options which are currently in effect. Disable display forms. Disable display forms. $Check if display forms are enabled. Don't eta contract implicit Do eta contract implicit Don't reify interaction points @Makes the given directories absolute and stores them as include  directories. <If the include directories change (and they were previously   something/), then the state is reset (completely, except ! for the include directories and  ).  An empty list is interpreted as [.]. Should only be run if  . 9Switch on printing of implicit and irrelevant arguments. 5 E.g. for reification in with-function generation. AIf this command is run under the Emacs mode, then it formats the D debug message in such a way that the Emacs mode can understand it. ,Displays a debug message in a suitable way. .Precondition: The level must be non-negative. ' " New include directories. *How should relative paths be interpreted? The debug message. ' " ' " % "  xNone Arecord fields names need to be distinguished to parse copatterns ETo simplify interaction between scope checking and type checking (in < particular when chasing imports), we use the same monad. RCreate a new module with an empty scope (Bool is True if it is a datatype module) $Apply a function to the scope info. #Apply a function to the scope map. %Apply a function to the given scope. 'Apply a function to the current scope. +Apply a monadic function to the top scope. 6Apply a function to the public or private name space. 8Run a computation without changing the local variables. 3Create a fresh abstract name from a concrete name.  4freshAbstractName_ = freshAbstractName defaultFixity (Create a fresh abstract qualified name. @Look up the abstract name referred to by a given concrete name. Look up a module in the scope. >Get the fixity of a name. The name is assumed to be in scope. GBind a variable. The abstract name is supplied as the second argument. /Bind a defined name. Must not shadow anything. Bind a module name. IBind a qualified module name. Adds it to the imports field of the scope. !Clear the scope of any no names. BCreate a new scope with the given name from an old scope. Renames G public names in the old scope to match the new name and returns the  renamings. IApply an importdirective and check that all the names mentioned actually  exist. !Open a module. /                           !/                           !/                           !)                            !yNone+5Alpha-Equivalence of patterns, ignoring dot patterns ,,currently we only support variable patterns -A sequence of decisions b leading to a head a. .the list of choices /@This is a n^2 grouping algorithm which uses only alpha-equality 0Expects a sorted list. 1 Similar to /. 24Literal equality of patterns, ignoring dot patterns 2+3456789:;<,-=.> "?/@A01BCDE2FGHIJKLMNOPQRSTUVWXYZ[ " "(+3456789:;<,-=.> "?/@A01BCDE2FGHIJKLMNOPQRSTUVWXYZ[zNone # $ % & ' # $ % & ' # $ % & ' # $ % & '{None\%Name sets for classifying a pattern. ]name of defined symbol ^valid constructor names _valid field names `LBuilds parser for operator applications from all the operators and function 4 symbols in scope. When parsing a pattern we use  ). CThe effect is that operator parts (that are not constructor parts) ? can be used as atomic names in the pattern (so they can be  rebound). See testsucceedOpBind.agda for an example. FTo avoid problems with operators of the same precedence but different M associativity we decide (completely arbitrary) to fix the precedences of J operators with the same given precedence in the following order (from  loosest to hardest):  non-associative  left associative  right associative  prefix  postfix KThis has the effect that if you mix operators with the same precedence but * different associativity the parser won'!t complain. One could argue that % this is a Bad Thing, but since it'(s not trivial to implement the check it @ will stay this way until people start complaining about it. +CCompute all unqualified defined names in scope and their fixities. aHCompute all names (first component) and operators (second component) in  scope. blhsArgs' p splits a lhs f ps, given as a pattern p,  into (f, ps). -View a pattern p as a list p0 .. pn where p0 is the identifier " (in most cases a constructor). 9Pattern needs to be parsed already (operators resolved). .%Returns the list of possible parses. c)Returns zero or one classified patterns. /KParses a left-hand side, and makes sure that it defined the expected name. O TODO: check the arities of constructors. There is a possible ambiguity with  postfix constructors: ( Assume _ * is a constructor. Then 'true *' can be parsed as either the M intended _* applied to true, or as true applied to a variable *. If we $ check arities this problem won' t appear. 0Parses a pattern. O TODO: check the arities of constructors. There is a possible ambiguity with  postfix constructors: ( Assume _ * is a constructor. Then 'true *' can be parsed as either the M intended _* applied to true, or as true applied to a variable *. If we $ check arities this problem won' t appear. 2Helper function for  / and  0. dHelper function for  / and  0. 3?Collect all names in a pattern into a list of qualified names. 4,Return all qualifiers occuring in a list of js. 7 Each qualifier is returned as a list of names, e.g.  for  Data.Nat._+_ we return the list  [Data,Nat]. 51Parse a list of expressions into an application. +\e]^_f`ghijk ( ) *lm +ano ,pb - .qc / 0 1r 2d 3 4 5 6s 7 8tu ( ) * + , - . / 0 1 2 3 4 5 6 7 8 5 / 0 1 7 8 2 - 6 , . + ( * ) 4 3 \e]^_f`kjihg ( * )lm +ano ,pb - .qc / 0 1r 2d 3 4 5 6s 7 8tu|None >A deep view on sizes. DA useful view on sizes. H)Result of querying whether size variable i is bounded by another  size. Jyes i : Size< t KCheck if a type is the   type. The argument should be reduced. U?Transform list of terms into a term build from binary maximum. WsizeViewComparable v w checks whether v >= w (then Left)  or v <= w (then Right ). If uncomparable, it returns  NotComparable. YsizeViewPred k v decrements v by k (must be possible!). ZsizeViewOffset v9 returns the number of successors or Nothing when infty. [(Remove successors common to both sides. \Turn a size view into a term. _maxViewCons v ws = max v ws. It only adds v to ws if it is not  subsumed by an element of ws. `sizeViewComparableWithMax v ws tries to find w in ws that compares with v  and singles this out.  Precondition: v / = DSizeInv. * 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b* 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b* H J I K L M N O P Q R S T U D G F E V C > B A @ ? : = < ; W X Y Z [ \ ] 9 ^ _ ` a b 9 : = < ; > B A @ ? C D G F E H J I K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b}None e%Record a function call in the trace.  c d e f g h i j c d e f g h i j c d e f g h i j c d e f g h i jNone {DAdd a constant to the signature. Lifts the definition to top level. |3Set termination info of a defined function symbol.  Add a section to the signature. Lookup a section. If it doesn'(t exist that just means that the module  wasn't parameterised. ;Can be called on either a (co)datatype, a record type or a  (co)constructor. @Does the given constructor come from a single-constructor type? 6Precondition: The name has to refer to a constructor. HLookup the definition of a name. The result is a closed thing, all free ( variables have been abstracted over. &Look up the polarity of a definition. ;Look up polarity of a definition and compose with polarity  represented by  . "Set the polarity of a definition. .Return a finite list of argument occurrences. (Get the mutually recursive identifiers. (Set the mutually recursive identifiers. 6Check whether two definitions are mutually recursive. HLook up the number of free variables of a section. This is equal to the  number of parameters if we'1re currently inside the section and 0 otherwise. ECompute the number of free variables of a module. This is the sum of ' the free variables of its sections. KCompute the number of free variables of a defined name. This is the sum of ( the free variables of the sections it's contained in. 8Compute the context variables to apply a definition to. EInstantiate a closed definition with the correct part of the current  context. (Give the abstract view of a definition. PEnter abstract mode. Abstract definition in the current module are transparent. ;Not in abstract mode. All abstract definitions are opaque. @Ignore abstract mode. All abstract definitions are transparent. FCheck whether a name might have to be treated abstractly (either if we're    or it'1s not a local name). Returns true for things not , declared abstract as well, but for those   will have no effect. get type of a constant get relevance of a constant The name must be a datatype. 'Is it the name of a record projection? 6 n o p q r s t u v w x y z { | } ~  6 n o p q r s t u v w x y z { | } ~  6 n o p q r s t u v w x y z { | } ~  6 n o p q r s t u v w x y z { | } ~  None    None Get the current problem ZSteal all constraints belonging to the given problem and add them to the current problem. Get the awake constraints Add new a constraint Add already awake constraints Start solving constraints     None  Switch off assignment of metas. Get the meta store. Lookup a meta variable Create   in the current environment. ;Does the meta variable correspond to an interaction point? Generate new meta variable. <Generate a new meta variable with some instantiation given. . For instance, the instantiation could be a  . listenToMeta l m : register l as a listener to m. This is done $ when the type of l is blocked by m. Unregister a listener. Get the listeners to a meta. Freeze all meta variables. & & & & NoneI ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                            ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                            ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A " ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = N O P Q _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~  # $ % & ' 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j n o p q r s t u v w x y z { | } ~  None  Variant of  . which does not insert outermost parentheses.  Variant of  . which does not insert outermost parentheses.     NonevThe with clauses haven't been translated yet w rewrite e (many) xwith e (many) yqthe subclauses spawned by a with (monadic because we need to reset the local vars before checking these clauses) GThings that can be translated to abstract syntax are instances of this  class. z/Make sure that each variable occurs only once. {DCompute the type of the record constructor (with bogus target type) |The public) keyword must only be used together with open. }Computes the range of all the "to" keywords used in a renaming  directive. ~(This function should be used instead of   for things that need 8 to keep track of precedences to make sure that we don't forget about it. BThis operation does not affect the scope, i.e. the original scope  is restored upon completion. Like  3 but returns the scope after the completion of the  second argument.  Peel off  and represent it as an .  Peel off  and represent it as an , throwing away any name. By default, arguments are Relevant. BParse a possibly dotted C.Expr as A.Expr. Bool = True if dotted. -Returns the scope inside the checked module. The top-level module name. Aruns Syntax.Concrete.Definitions.niceDeclarations on main module KTurn an operator application into abstract syntax. Make sure to record the . right precedences for the various arguments. ~  v wxy         z{|} ~    ^  v wxy              z{|} ~  None Interaction monad. ;Line reader. The line reader history is not stored between  sessions.     None         None ! ! ! !None"data   see  #unusableRelevance rel == True! iff we cannot use a variable of rel. $ composition.   is dominant,  is neutral. %inverseComposeRelevance r x returns the most irrelevant y  such that forall x, y we have  x ` moreRelevant` (r `composeRelevance` y)  iff  (r `inverseComposeRelevance` x) ` moreRelevant` y (Galois connection). &For comparing  Relevance ignoring Forced and  UnusedArg. 'LIrrelevant function arguments may appear non-strictly in the codomain type. )GPrepare parts of a parameter telescope for abstraction in constructors  and projections. *)Used to modify context when going into a rel argument. +Compose two relevance flags. = This function is used to update the relevance information  on pattern variables a! after a match against something rel. ,>Modify the context whenever going from the l.h.s. (term side) 6 of the typing judgement to the r.h.s. (type side). -.Call me if --experimental-irrelevance is set. .EInternal workhorse, expects value of --experimental-irrelevance flag  as argument. /E(Conditionally) wake up irrelevant variables and make them relevant.  For instance, E in an irrelevant function argument otherwise irrelevant variables F may be used, so they are awoken before type checking the argument. 0DWake up irrelevant variables and make them relevant. For instance, E in an irrelevant function argument otherwise irrelevant variables F may be used, so they are awoken before type checking the argument. "#$%&'()*+,-./012"#$%&'()*+,-./012"#$%&'()*+,-./012"#$%&'()*+,-./012None=Calls a compiler: A Checks the exit code to see if the compiler exits successfully. @ If not, then an exception is raised, containing the text the ( compiler printed to stderr (if any). 9 Uses the debug printout machinery to relay any progress . information the compiler prints to stdout. >Generalisation of  callCompiler where the raised exception is  returned. =The path to the compiler Command-line arguments. >The path to the compiler Command-line arguments. =>=>=>None !Is not used currently, but could * potentially be used for hyperlinks as in  the HTML output? -Column number, used for polytable alignment. 'Indentation level, also for alignment. (Keeps track of whether we are in a code  block or not. The LaTeX monad is a combination of ErrorT and RWS . The error A part is just used to keep track whether we finished or not, the  reader part isn'4t used, the writer is where the output goes and the F state is for keeping track of the tokens and some other useful info. Run function for the LaTeX monad. 3Yields the next token, taking special care to begin/ end code E blocks. Junk occuring before and after the code blocks is separated E into separate tokens, this makes it easier to keep track of whether  we are in a code block or not. The start state, nonCode%, prints non-code (the LaTeX part of  literate Agda) until it sees a  beginBlock. >Deals with code blocks. Every token, except spaces, is pretty  printed as a LaTeX command. @Fixity declarations need a special treatment. The operations in  declarations like: infix num op1 op2 op3 Dare treated as comments and thus grouped together with the newlines D that follow, which results incorrect LaTeX output -- the following 5 state remedies the problem by breaking on newlines. BSpaces are grouped before processed, because multiple consecutive D spaces determine the alignment of the code and consecutive newline , characters need special treatment as well. ?The only exported function. It's (only) called in Main.hs. 'Transforms the source code into LaTeX. 4  ? ??*  ? NoneABCDEFGABCDEFGABCDEFGABCDEFGNoneH:When making a function projection-like, we drop the first n  arguments.  To drop the first n! arguments in a compiled clause, + we reduce the split argument indices by n and  drop n arguments from the bodies. 9 NOTE: this only works for non-recursive functions, we < are not dropping arguments to recursive calls in bodies.  -NOTE: does not work for recursive functions. KNOTE: does not go into the body, so does not work for recursive functions. >NOTE: This creates telescopes with unbound de Bruijn indices. HI  HIHIHI  None`Instantiate something. 3 Results in an open meta variable or a non meta.  Doesn'Dt do any reduction, and preserves blocking tags (when blocking meta  is uninstantiated). fIf the first argument is >#, then a single delayed clause may  be unfolded. gJReduce a non-primitive definition if it is a copy linking to another def. h=Reduce a non-primitive definition once unless it is delayed. uYZ[\]^_`abcdefghijk !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrsYZ[\]^_`abcdefghijkbc`ade]^_fghijk[\YZpYZ[\]^_`abcdefghijk !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrsNone lA telescope split in two. qQThe permutation should permute the corresponding telescope. (left-to-right list) rIf permute  : [a] -> [], then (applySubst (renaming ) : Term  -> Term sIf permute  : [a] -> [], then %substs (renamingR ) : Term  -> Term t%Flatten telescope: ( : Tel) -> [Type] u@Order a flattened telescope in the correct dependeny order:  -> Permutation ( -> ~wHUnflatten: turns a flattened telescope into a proper telescope. Must be  properly ordered. x)Get the suggested names from a telescope {ISplit a telescope into the part that defines the given variables and the  part that doesn't. }telViewUpTo n t takes off the first n function types of t.  Takes off all if n < 0. ~ telViewUpTo' n p t takes off $t$  the first n (or arbitrary many if n < 0) function domains  as long as they satify p. A safe variant of piApply. lmnopqrstuvwxyz{|}~lmnopqrstuvwxyz{|}~qrstuvwxyzlmnop{|}~lmnopqrstuvwxyz{|}~None Compiler monad Stuff we need in our compiler The initial (empty) state "When normal errors are not enough &Modify the state of the current module's Epic Interface #Get the state of the current module's Epic Interface 0Returns the type of a definition given its name ;Create a name which can be used in Epic code from a QName. "Copy pasted from MAlonzo, HAHA!!!  Move somewhere else! ,Bind an expression to a fresh variable name & replace at  to replace  replace with result? && None#Run the case-opts on an expression None?Get a list of all the datatypes that look like nats. The [QName] is on the  form [zeroConstr, sucConstr] 'Count the number of relevant arguments !Check if argument n is recursive None FChange constructors and cases on builtins and natish datatypes to use  primitive data -Map primitive constructors to primitive tags -Build transforms using the names of builtins +Translation to primitive integer functions *Corresponds to a case for natural numbers 5Corresponds to a case with a zero and default branch (Translation to primitive bool functions BChange all the primitives in the function using the PrimTransform ?Change all the primitives in an expression using PrimTransform Expression that is cased on Expression for the zero branch %Variable that is bound in suc branch Expression used for suc branch Result? Expression that is cased on  Zero branch Default branch Result? None.Raises an error if no level kit is available. @@@ @ None tuvwxtuvwxlNone RAGet the name of the datatype constructed by a given constructor. : Precondition: The argument must refer to a constructor DReturn the number of non-parameter arguments to a data constructor, / or the field names of a record constructor. *For getting just the arity of constructor c,  use either id size  $ getConstructorArity c. KCheck if a name refers to a datatype or a record with a named constructor. 2Check if a name refers to a datatype or a record. R R R RNoney dotVars ps3 gives all the variables inside of dot patterns of ps ; It is only invoked for patternish things. (Ulf O-tone!) B Use it for printing l.h.sides: which of the implicit arguments  have to be made explicit.  ReifyWhen$ is a auxiliary type class to reify . reifyWhen False should produce an z. ' This function serves to reify hidden/irrelevant things. { ?nameFirstIfHidden n (a1->...an->{x:a}->b) ({e} es) = {x = e} es|+Getting all(!) variables of an expression. C It should only get free ones, but it does not matter to include  the bound ones. }CSkip reification of implicit and irrelevant args if option is off. 2y~z{|}/y~z{|}NoneNonebad named argument >hidden argument where there should have been a non-hidden arg (this many implicits have to be inserted implicitArgs n expand t generates up to n implicit arguments  metas (unbounded if n<0), as long as t is a function type  and expand) holds on the hiding info of its domain. The list should be non-empty. NoneNone;3456789:;< 3456789:;< <89:;567 3493456789:;< `None  Warnings. 8Invariant: The fields are never empty at the same time.  2Termination checking problems are not reported if  optTerminationCheck is .  :Meta-variable problems are reported as type errors unless  optAllowUnsolved is >. Same as  . BTurns warnings into an error. Even if several errors are possible  only one is raised.  C     C34     C34     C    None Converts the  and  fields to atoms readable  by the Emacs interface. @Shows meta information in such a way that it can easily be read  by Emacs. 5Turns syntax highlighting information into a list of  S-expressions. All the properties. .Must contain a mapping for the definition site's  module, if any. 0Must contain a mapping for every definition site' s module. None Monad used by the decoder. 9 is not used because the associated overheads would make  decoding slower. Monad used by the encoder. <Maps module names to file names. This is the only component / of the state which is updated by the decoder. The include directories. ,The type of hashtables used in this module. 0A very limited amount of testing indicates that   is somewhat slower than  , and that   and the hashtables from Data.Hashtable are  much slower. 6Constructor tag (maybe omitted) and argument indices. :Throws an error which is suitable when the data stream is  malformed. :Encodes something. To ensure relocatability file paths in + positions are replaced with module names. ;Decodes something. The result depends on the include path. Returns 2 if the input does not start with the right magic 5 number or some other decoding error is encountered. :Encodes something. To ensure relocatability file paths in + positions are replaced with module names. ;Decodes something. The result depends on the include path. Returns 1 if the file does not start with the right magic 5 number or some other decoding error is encountered. Creates an empty dictionary. *The encoded data is written to this file.  Something.       !"#$%&'()*+,-./0123453Maps file names to the corresponding module names. 4 Must contain a mapping for every file name that is  later encountered. 6789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~NoneSize constraints we can solve.  Leq a +n b represents a =< b + n.   Leq a -n b represents a + n =< b. Atomic size expressions. A de Bruijn level. )A size meta applied to de Bruijn levels. &Compute the deep size view of a term. * Precondition: sized types are enabled.  Account for subtyping Size< i =< Size  Preconditions:   m = x els1,  n = y els2, m and n are not equal. !,Compare two sizes. Only with --sized-types. #compareBelowMax u vs checks u  = max vs@. Precondition: @size vs= 2 '9Whenever we create a bounded size meta, add a constraint  expressing the bound.  In boundedSizeMetaHook v tel a, tel includes the current context. (:Test whether a problem consists only of size constraints. ))Test is a constraint speaks about sizes. *Find the size constraints. ,DCompute a set of size constraints that all live in the same context G from constraints over terms of type size that may live in different  contexts. cf. p -@Turn a constraint over de Bruijn levels into a size constraint. .FTurn a term with de Bruijn levels into a size expression with offset.  Throws a  ; if the term isn't a proper size expression. /8Compute list of size metavariables with their arguments  appearing in a constraint. 1=Convert size constraint into form where each meta is applied  to levels  0,1,..,n-1 where n is the arity of that meta. X[] <= t beomes X[id] <= t[^-1] X[] "d Y[] becomes X[id] "d Y[[^-1]] or X[[^1]] "d Y[id] : whichever is defined. If none is defined, we give up.  !"#$%&'()*+,-./012 !"#$%&'()*+,-./012 !"#$%&'()*+,-./012 !"#$%&'()*+,-./012NoneLCheck if a constructor name is the internally generated record constructor. -The fields should be eta contracted already. #We can eta constract if all fields f = ... are irrelevant # or the corresponding projection f = f v of the same value v, = but we need at least one relevant field to find the value v. !Get the field names of a record. 4Check if a name refers to an eta expandable record. $Check if a name refers to a record. % If yes, return record definition. 3+Order the fields of a record construction. / Use the second argument for missing fields. 42The name of the module corresponding to a record. 5AGet the definition for a record. Throws an exception if the name  does not refer to a record. 61Find all records with at least the given fields. 7!Get the field types of a record. 80Get the field names belonging to a record type. 9(Get the type of the record constructor. :Returns the given record type'"s constructor name (with an empty  range). ;eCheck if a name refers to a record which is not coinductive. (Projections are then size-preserving) <aCheck if a type is an eta expandable record and return the record identifier and the parameters. =0Check if a name refers to a record constructor. % If yes, return record definition. >Mark record type as unguarded. ? No eta-expansion. Projections do not preserve guardedness. ?Mark record type as recursive. , Projections do not preserve guardedness. @DCompute the eta expansion of a record. The first argument should be % the name of a record type. Given  )record R : Set where x : A; y : B; .z : Cand r : R,  etaExpand R [] r is [R.x r, R.y r, DontCare] A?Is the type a hereditarily singleton record type? May return a  blocking metavariable. >Precondition: The name should refer to a record type, and the 1 arguments should be the parameters to the type. C1Return the unique (closed) inhabitant if exists. ? In case of counting irrelevance in, the returned inhabitant  contains garbage. D<Check whether a type has a unique inhabitant and return it.  Can be blocked by a metavar. EICheck whether a type has a unique inhabitant (irrelevant parts ignored).  Can be blocked by a metavar. GAuxiliary function. 3456789:;<=>?@ABCDEFG3456789:;<=>?@ABCDEFG3456789:;<=>?@ABCDEFG3456789:;<=>?@ABCDEFGNoneV Note that Inf a b, where Inf is the INFINITY builtin, is  translated to  translationof b (assuming that all coinductive  builtins are defined).  Note that if  haskellType* supported universe polymorphism then the 4 special treatment of INFINITY might not be needed. HIJKLMNOPQRSTUVHIJKLMNOPQRSTUVHIJKLMNOPQRSTUVHIJKLMNOPQRSTUVNoneW!Check which arguments are forced X7Remove forced arguments from constructors and branches WXYWXYWXYWXYNoneZ#Print a function to an Epic string [$Print expression to Epic expression Z[Z[Z[ Z[Nonec Relevance or d Relevance and e1Try to find as many unused variables as possible gInitiate a function's relevancies j5Calculate if a variable is relevant in an expression k8Try to find a fixpoint for all the functions relevance. \]^_`abcdefghijkl\]^_`abcdefghijklabcd]^_`\efghijkl\]^_`abcdefghijklNonemnopmnopmnopmnopNoneqConvert from Agda'0s internal representation to our auxiliary AST. rBTranslate an Agda definition to an Epic function where applicable tTranslate from Agda'>s desugared pattern matching (CompiledClauses) to our AuxAST. & This is all done by magic. It uses u to translate the actual 0 terms when the cases have been gone through. L The case expressions that we get use de Bruijn indices that change after # each case in the following way.  Say we have this pattern:   f (X x y) (Y z) = term -Initially, the variables have these indexes:   f 0@(X x y) 1@(Y z) = term The first case will be on 0%, and the variables bound inside the X H pattern will replace the outer index, so we get something like this:  ' f 0 2@(Y z) = case 0 of X 0 1 -> term  Notice how (Y z) now has index 2. 9 Then the second pattern is desugared in the same way:  2 f 0 2 = case 0 of X 0 1 -> case 2 of Y 2 -> term ?This replacement is what is done using the replaceAt function. LCompiledClauses also have default branches for when all branches fail (even G inner branches), the catchAllBranch. Epic does not support this, so M we have to add the catchAllBranch to each inner case (here we are calling I it omniDefault). To avoid code duplication it is first bound by a let  expression. uPTranslate the actual Agda terms, with an environment of all the bound variables N from patternmatching. Agda terms are in de Bruijn so we just check the new  names in the position. v.Translate Agda literals to our AUX definition qrst&Number of arguments in the definition uvqrstuvqrstuvqrstuvNone~FIf the pairs of constructor names have the same tags, the function is 9 injective. If Nothing, the function is not injective. PFind potentially injective functions, solve constraints to fix some constructor F tags and make functions whose constraints are fulfilled injections Are two terms injectible? 1 Precondition: t1 is normalised, t2 is in WHNF W When reducing t2, it may become a literal, which makes this not work in some cases... wxyz{|}~"Name of the function being tested  The function' s clauses "Name of the function being tested The current argument wxyz{|}~~{}|wxyzwxyz{}|~None Record pattern trees.  RecCon t args. stands for a record constructor application:  t9 is the type of the application, and the list contains a 4 projection function and a tree for every argument. 7Corresponds to variable and dot patterns; contains the  original pattern.  p5 means that a variable (corresponding to the pattern  p7, a variable or dot pattern) should be kept unchanged.   (n, x, t) means that n  variables, and n  dot @ patterns, should be removed, and a new variable, with the name x, 3 inserted instead. The type of the new variable is t. VarPat# stands for variable patterns, and DotPat for dot  patterns. +A monad used to translate record patterns. ?The state records the number of variables produced so far, the E reader records the total number of variables produced by the entire A computation. Functions using this monad need to be sufficiently  lazy in the reader component.  dropFrom i n drops arguments j with j  i + n@ and @j= i.  NOTE: n8 can be negative, in which case arguments are inserted. 5Split tree annotated for record pattern translation. Split tree annotation. "Constructor name for this branch. Arity of the constructor. %Should we translate this split away? Take a record pattern p! and yield a list of projections ? corresponding to the pattern variables, from left to right.  E.g. for  (x , (y , z)) we return [ fst, fst . snd, snd . snd ]. %If it is not a record pattern, error   is raised. HTake a matrix of booleans (at least one row!) and summarize the columns  using conjunction. insertColumn i a m inserts a column before the i th column in  matrix m and fills it with value a. cutSublist i n xs = (xs', ys, xs'') cuts out a sublist ys  of width n from xs, starting at column i. replaceByProjections i projs cc replaces variables i..i+n-1 & (counted from left) by projections projs_1 i .. projs_n i. If n==06, we matched on a zero-field record, which means that > we are actually introduce a new variable, increasing split ! positions greater or equal to i by one.  Otherwise, we have to lower HCheck if a split is on a record constructor, and return the projections  if yes. ,Bottom-up procedure to annotate split tree. <Bottom-up procedure to record-pattern-translate split tree. >Replaces pattern matching on record constructors with uses of C projection functions. Does not remove record constructor patterns > which have sub-patterns containing non-record constructor or  literal patterns. BIf the input clause contains dot patterns inside record patterns, D then the translation may yield clauses which are not type-correct. C However, we believe that it is safe to use the output as input to  m . Perhaps A it would be better to perform record pattern translation on the ? compiled clauses instead, but the code below has already been  implemented and seems to work. Runs a computation in the  monad. ?Returns the next pattern variable, and the corresponding term.  projections t- returns a projection for every non-dot leaf  pattern in t0. The term is the composition of the projection & functions from the leaf to the root. BEvery term is tagged with its origin: a variable pattern or a dot  pattern. BConverts a record tree to a single pattern along with information & about the deleted pattern variables. +Removes record constructors from patterns. Returns the following things:  The new pattern.  A substitution which maps the old pattern variables (in the C order they occurred in the pattern; not including dot patterns) B to terms (either the new name of the variable, or a projection ' applied to a new pattern variable). = A list explaining the changes to the variables bound in the  pattern. CRecord patterns containing non-record constructor patterns are not 0 translated (though their sub-patterns may be). Example: The pattern !rec1 (con1 a) (rec2 b c) (rec3 d) should  yield the pattern rec1 (con1 x) y z, along with a substitution  similar to #[x, proj2-1 y, proj2-2 y, proj3-1 z]. >This function assumes that literals are never of record type.  lifted to lists of arguments. 3Traverses a pattern and returns one of two things: < If there is no non-record constructor in the pattern, then   ps is returned, where ps contains one projection for > every variable in the input pattern (in the order they are  encountered). B Otherwise the output is a computation returning the same kind of  result as that coming from . (Computations are C returned rather than values to ensure that variable numbers are " allocated in the right order.) 0Assumes that literals are never of record type. Translates the telescope. @Translates the clause body. The substitution should take things - in the context of the old RHS to the new RHS' s context. )Turns a permutation into a substitution.  dropBinds n b drops the initial n occurrences of  from b. Precondition: b has to start with n occurrences of . *:Explanation of how the telescope should be changed. Types 0 should be in the context of the old telescope. 3Old telescope, flattened, in textual left-to-right  order. :New telescope, flattened, in textual left-to-right order.  4 is used to indicate the locations of dot patterns.  oNone UinitializeIFSMeta s t$ generates an instance meta of type t  with suggested name s. findInScope m (v,a)s& tries to instantiate on of the types as  of the candidate terms vs to the type t of the metavariable m.  If successful, meta m% is solved with the instantiation of v. I If unsuccessful, the constraint is regenerated, with possibly reduced  candidate set. CTo preserve the invariant that a constructor is not applied to its B parameter arguments, we explicitly check whether function term < we are applying to arguments is a unapplied constructor. " In this case we drop the first  3 arguments.  See Issue670a. 6Attempt to solve irrelevant metas by instance search. U U  U UgNone $Don'1t allow the argument to produce any constraints. 8Catches pattern violation errors and adds a constraint. -Create a fresh problem for the given action. guardConstraint c blocker tries to solve blocker first. ; If successful without constraints, it moves on to solve c, otherwise it  adds a  Guarded c cs constraint  to the blocker-generated constraints cs. 5Wake up the constraints depending on the given meta. Wake up all constraints.  # $ % & ' # $ % & ' ' $ # % & # $ % & 'None%all prescribed kills where performed &managed to kill some args in the list 1there is no possible kill (because of type dep.) the kill list is empty or only Falses Extended occurs check. ?Distinguish relevant and irrelevant variables in occurs check. !we are in an irrelevant argument )we are at the term root (this turns into  StronglyRigid) 9we are at the start or in the arguments of a constructor 2we are not in arguments of a meta but a bound var we are in arguments of a meta -Set the names of definitions to be looked at , to the defs in the current mutual block. -Is a def in the list of stuff to be checked? 4Remove a def from the list of defs to be looked at. Leave the top position. #Leave the strongly rigid position. When assigning  m xs := v , check that m does not occur in v " and that the free variables of v are contained in xs. prune m' vs xs' attempts to remove all arguments from vs whose ' free variables are not contained in xs.  If successful, m'3 is solved by the new, pruned meta variable and we  return True else False. hasBadRigid xs v = True# iff one of the rigid variables in v is not in xs. O Actually we can only prune if a bad variable is in the head. See issue 458. 2 Or in a non-eliminateable position (see succeed/PruningNonMillerPattern). killArgs [k1,...,kn] X prunes argument i from metavar X if ki==True. @ Pruning is carried out whenever > 0 arguments can be pruned.  True4 is only returned if all arguments could be pruned. &killedType [((x1,a1),k1)..((xn,an),kn)] b = ([k'1..k'n],t')  (ignoring Dom). Let t' = (xs:as) -> b.  Invariant: k' i == True iff  ki == True and pruning the ith argument from  type b1 is possible without creating unbound variables.  t' is type t after pruning all k'i==True. 5''(aNone F?Create a new metavariable, possibly -expanding in the process. GnewIFSMeta s t cands creates a new implicit from scope metavariable  of type t with name suggestion s! and initial solution candidates cands. H assign sort? x vs v I3Assign to an open metavar which may not be frozen. : First check that metavar args are in pattern fragment. 3 Then do extended occurs check on given thing. $Assignment is aborted by throwing a  PatternErr via a call to  patternViolation. This error is caught by catchConstraint  during equality checking ( compareAtom) and leads to , restoration of the original constraints. J!Do safe eta-expansions for meta (SingletonRecords,Levels). K)Performing the meta variable assignment. #The instantiation should not be an   or   and the   should point to something   or a  . ) Further, the meta variable may not be  .  Various kinds of metavariables. <Meta variables of level type, if type-in-type is activated. Meta variables of "hereditarily singleton" record type. Meta variables of record type. $Find position of a value in a list. > Used to change metavar argument indices during assignment. reverseA is necessary because we are directly abstracting over the list. DCheck whether a meta variable is a place holder for a blocked term. 9Skip frozen check. Used for eta expanding frozen metas. 4Create a new value meta with specific dependencies. ,Create a new value meta without -expanding.4Create a new value meta with specific dependencies. HCreate a metavariable of record type. This is actually one metavariable  for each field. 7Construct a blocked constant if there are constraints. unblockedTester t returns False if t is a meta or a blocked term. @Auxiliary function to create a postponed type checking problem. )Create a postponed type checking problem e : t that waits for type t A to unblock (become instantiated or its constraints resolved). )Create a postponed type checking problem e : t that waits for conditon  unblock<. A new meta is created in the current context that has as : instantiation the postponed type checking problem. An   constraint 5 is added for this meta, which links to this meta. 8Eta expand metavariables listening on the current meta. 0Wake up a meta listener and let it do its thing !All possible metavariable kinds. ;Eta expand a metavariable, if it is of the specified kind.  Don'5t do anything if the metavariable is a blocked term. AEta expand blocking metavariables of record type, and reduce the  blocked thing. ATurn non-det substitution into proper substitution, if possible. ) The substitution can be restricted to elemFVs Check that arguments args' to a metavar are in pattern fragment. : Assumes all arguments already in whnf and eta-reduced. ! Parameters are represented as Vars so  checkArgs really  checks that all args are Vars and returns the  substitution 6 to be applied to the rhs of the equation to solve.  (If args9 is considered a substitution, its inverse is returned.) (The returned list might not be ordered. ? Linearity, i.e., whether the substitution is deterministic, ! has to be checked separately. AReturns every meta-variable occurrence in the given type, except  for those in s. 4 D E F G H I J K L M*a possibly non-deterministic substitution 2 D E F G H I J K L M2 K G E F D L M J I H1 D E F G H I J K L MdNone highlightAsTypeChecked rPre r m runs m and returns its 4 result. Some code may additionally be highlighted:  If r% is non-empty and not a sub-range of rPre (after  f has been applied to both): r is + highlighted as being type-checked while m is running (this  highlighting is removed if m completes  successfully). ( Otherwise: Highlighting is removed for rPre - r before m  runs, and if m completes successfully, then rPre - r is & highlighted as being type-checked. =A function mapping names to the kind of name they stand for. Highlighting levels. 2Highlighting without disambiguation of overloaded  constructors. >Full highlighting. Should only be used after typechecking has  completed successfully. 6The list of termination problems is also highlighted. >Precondition: The termination problems must be located in the  module that is highlighted. 6Lispify and print the given highlighting information. 7Generate syntax highlighting information for the given 4 declaration, and (if appropriate) print it. If the    is  something, then the state is C additionally updated with the new highlighting info (in case of a 4 conflict new info takes precedence over old info). BThe procedure makes use of some of the token highlighting info in   4 (that corresponding to the interval covered by the  declaration). If the   is  something, @ then this token highlighting info is additionally removed from   . @Generate and return the syntax highlighting information for the  tokens in the given file.  Builds a  function. ?Generates syntax highlighting information for all constructors A occurring in patterns and expressions in the given declaration. 9This function should only be called after type checking. D Constructors can be overloaded, and the overloading is resolved by  the type checker. .Prints syntax highlighting info for an error. BGenerates and prints syntax highlighting information for unsolved 2 meta-variables and certain unsolved constraints. <Generates syntax highlighting information for unsolved meta  variables. CGenerates syntax highlighting information for unsolved constraints , that are not connected to a meta variable. 9Generates a suitable file for a possibly ambiguous name. Converts names to suitable s.  A variant of  for qualified abstract names. All the properties.  The module to highlight. This should only be  something if 3 type-checking completed successfully (without any  errors). (Maps source file paths to module names. The module to highlight. (Maps source file paths to module names. The module to highlight. (Maps source file paths to module names. .The file name of the current module. Used for  consistency checking. #The name qualifier (may be empty). The base name. 1Meta information to be associated with the name.  The argument is > iff the name is an operator. 0The definition site of the name. The calculated 5 meta information is extended with this information,  if possible. (Maps source file paths to module names. .The file name of the current module. Used for  consistency checking.  The name. 1Should the binding site be included in the file? 1Meta information to be associated with the name.  ^ The argument is > iff the name is an operator.     None"The name of the default CSS file. AGenerates HTML files from all the sources which the given module + depends on (including the module itself). <This function should only be called after type checking has  completed successfully. <Converts module names to the corresponding HTML file names. BGenerates an HTML file with a highlighted, hyperlinked version of  the given module. ,Constructs the web page, including headers. )Constructs the HTML displaying the code. $Directory in which to create files. Module to be highlighted. )Syntax highlighting info for the module. URL to the CSS file. Module to be highlighted. The contents of the module. Highlighting information. The contents of the module. Highlighting information. NoneNoneChange s to NoBind* if the variable is not used in the body. > Also normalises the body in the process. Or not. Disabled. None!Monad for computing occurrences. #Context for computing occurrences. +Items corresponding to the free variables. Name for " builtin. Description of an occurrence. *an unknown position (treated as negative)  in the definition of a constant 2matched against in a clause of a defined function (in the nth clause of a defined function %in a datatype index of a constructor  in the type of a constructor !!as an argument of a metavariable "#as an argument to a bound variable #(in the principal argument of built-in " $)in the nth argument of a define constant &BCheck that the datatypes in the mutual block containing the given % declarations are strictly positive. -onlyVarsUpTo n occs) discards occurrences of de Bruijn index >= n. /Running the monad 0/Compute the occurrences in a given definition. 1;Eta expand a clause to have the given number of variables.  Warning: doesn'#t update telescope or permutation! 8 This is used instead of special treatment of lambdas " (which was unsound: issue 121) 3 Given an ! computes the target node and an   . The first = argument is the set of names in the current mutual block. @These operations form a semiring if we quotient by the relation  "the  Z components are equal".  Z* is a complete lattice with least element  `  and greatest element  [. &It forms a commutative semiring where   is meet (glb)  and  1 is composition. Both operations are idempotent. For  ,  [ is neutral (zero) and  ` is dominant.  For  ,  ] is neutral (one) and  [ is dominant. @      !"#$%&'()*+,-./0123 +      !"#$%&'()*+,-./0123+&'%$#"! ()*+,-./01     23+      %$#"! &'()*+,-./0123 qNone W0What is the polarity of a function composition? XMain function of this module. 4polarities i a4 computes the list of polarities of de Bruijn index i  in syntactic entity a. 6$Infimum on the information lattice.   h is bottom (dominant for inf),   g is top (neutral for inf). 7 f+ negation, swapping monotone and antitone. 9#Get the next polarity from a list,  h if empty. :Replace  g by  h. ;BData and record parameters are used as phantom arguments all over 7 the test suite (and possibly in user developments).  enablePhantomTypes turns  g parameters to  h  to enable phantoms. <Make arguments  h if the type of a not- g ! later argument depends on it. =;Check whether a variable is relevant in a type expression, . ignoring domains of non-variant arguments. >1Record information that an argument is unused in . ?Improve 0 information in a type by polarity information.   g becomes . @ Propagate  g  f to  information in  s of a defined symbol. B#Hack for polarity of size indices. D polarity i a* computes the polarity of de Bruijn index i  in syntactic entity a by taking the infimum of all 5.  W X456789:;<=>?@ABCD         W X456789:;<=>?@ABCD67 W89: X;<=>?@ABC45D W X456789:;<=>?@ABCD        wNone CTurn a definition into a projection if it looks like a projection.     NoneEFGHIJKLMNOPQR         EFGHIJKLMNOPQRGHIJKLMNOEFPQREFGHIJKLMNOPQR         Nonek3Rewrite a literal to constructor form if possible. lbuildList A ts builds a list of type List A. Assumes that the terms  ts all have type A. mConceptually: .redBind m f k = either (return . Left . f) k =<< m Abbreviation: argN =   . Abbreviation: argH =   . _STUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~          ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8=STUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~=kijfghcde`ab^_\]Z[lYWXmnopqrstuvwxyz{|}~VUTSTSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~          ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8nNone T T T TNone+Reduce simple (single clause) definitions. -Argument should be on weak head normal form. None  /Check that the first sort equal to the second. compareTel t1 t2 cmp tel1 tel1 checks whether pointwise  tel1 `cmp` tel2 and complains that t2 `cmp` t1 failed if  not. Equality on Types ,Type-directed equality on eliminator spines )Type-directed equality on argument lists *Syntax directed equality on atomic values "Type directed equality on values. ACheck if to lists of arguments are the same (and all variables). 1 Precondition: the lists have the same length. intersectVars us vs) checks whether all relevant elements in us and vs > are variables, and if yes, returns a prune list which says True for 4 arguments which are different and can be pruned. %Ignore errors in irrelevant context. Compare: two terms in irrelevant position. This always succeeds. @ However, we can dig for solutions of irrelevant metas in the  terms we compare. / (Certainly not the systematic solution, that'd be proof search...)  coerce v a b coerces v : a to type b, returning a v' : b @ with maybe extra hidden applications or hidden abstractions. =In principle, this function can host coercive subtyping, but G currently it only tries to fix problems with hidden function types. :Check that the first sort is less or equal to the second.         NoneIType check a datatype definition. Assumes that the type has already been  checked. JType check a constructor declaration. Checks that the constructor targets ; the datatype and that it fits inside the declared sort. #Bind the parameters of a datatype. PCheck that the arguments to a constructor fits inside the sort of the datatype. 6 The first argument is the type of the constructor. HCheck that a type constructs something of the given datatype. The first 9 argument is the number of parameters to the datatype.  TODO: what if there's a meta here? !Is the type coinductive? Returns  if the answer cannot  be determined. NoneSSSSNoneTIf matching is inconclusive (DontKnow) we want to know whether , it is due to a particular meta variable. TUVWX 9TUVWXTWVUXTWVUX 9None 8State worked on during the main loop of checking a lhs. The permutation should permute allHoles" of the patterns to correspond to ) the abstract patterns in the problem.  the [Name]%s give the as-bindings for the focus /Index of focused variable in the out patterns. =Type of variable we are splitting, kept for record patterns. 2User patterns that could not be given a type yet.  Example:   6 f : (b : Bool) -> if b then Nat else Nat -> Nat  f true = zero  f false zero = zero  f false (suc n) = n   C In this sitation, for clause 2, we construct an initial problem    problemInPat = [false]  problemTel = (b : Bool) " problemRest.restPats = [zero] ; problemRest.restType = if b then Nat else Nat -> Nat    As we instantiate b to false, the  reduces to   Nat -> Nat and we can move pattern zero over to  problemInPat. =non-empty list of user patterns which could not yet be typed type eliminated by  &State of typechecking a LHS; input to split.  [Ulf Norell's PhD, page. 35] In Problem ps p delta,  ps( are the user patterns of supposed type delta.  p. is the pattern resulting from the splitting. : is a right dominant monoid.  pr1 `mappend` pr2 = pr2 unless  pr2 = mempty , then it is pr1. ' Basically, this means that the left  is discarded, so  use it wisely! 2 ; : < = > ? @ A B))  ; : < = > ? @ A BNoneDViews an expression (pair) as type shape. Fails if not same shape. (not a type or not definitely same shape  some meta built-in type  neutral type data/record  substHH u t substitutes u for the 0th variable in t. KAre we in a homogeneous (one type) or heterogeneous (two types) situation? heterogeneous  homogeneous NApply the current substitution on a term and reduce to weak head normal form. ]Were two terms unifiable or did we have to postpone some equation such that we are not sure? 9Unification did not fail, but we had to postpone a part. Unification succeeded. 5Output the result of unification (success or maybe). 4Tell that something could not be unified right now, $ so the unification succeeds only . :Check whether unification proceeded without postponement. 2Force equality now instead of postponing it using . DTry equality. If constraints remain, postpone (enter unsafe mode). < Heterogeneous equalities cannot be tried nor reawakened, & so we can throw them away and flag dirty. =Check whether heterogeneous situation is really homogeneous.  If not, give up. EIncludes flexible occurrences, metas need to be solved. TODO: relax? 8 TODO: later solutions may remove flexible occurences (Assignment with preceding occurs check. !JTake a substitution  and ensure that no variables from the domain appear > in the targets. The context of the targets is not changed. F TODO: can this be expressed using makeSubstitution and applySubst? (Unify indices. *>Given the type of a constructor application the corresponding D data or record type, applied to its parameters (extracted from the  given type), is returned. BPrecondition: The type has to correspond to an application of the  given constructor. ,Heterogeneous situation.  a1 and a2 need to end in same datatype/record. -<Return record type identifier if argument is a record type. .BReturn the type and its shape. Expects input in (u)reduced form. /1Return the reduced type(s) and the common shape. 0telViewUpToHH n t takes off the first n function types of t.  Takes off all if $n < 0$. CConjunctive monoid. l      !"#$%&'()*Constructor name. 1Type of constructor application (must end in data/ record). &Type of constructor, applied to pars. +Constructor name. 1Type of constructor application (must end in data/ record).  Name of data/ record type, * type of constructor to be applied, and  data/record parameters ,Constructor name. 9Type(s) of constructor application (must end in same data/ record). JType of constructor, instantiated possibly heterogeneously to parameters. -./0 D E F G H I J K L M N O P Q R S T U V W C XV      !"#$%&'()*+,-./0V      !"#$%&'()*+,-./0N      !"#$%&'()*+,-./0 D E F G H I J K L M N O P Q R S T U V W C XNone2)Main function, smash as much as possible 4CCan a datatype be inferred? If so, return the only possible value. 6KFind the only possible value for a certain type. If we fail return Nothing 1234567123456712345671234567None8'Insert implicit patterns in a problem. 90Insert implicit patterns in a list of patterns. 89898989None:IRename the variables in a telescope using the names from a given pattern ;*Are there any untyped user patterns left? <'Get the type of clause. Only valid if ;. =Construct an initial split  from user patterns. >=Try to move patterns from the problem rest into the problem. I Possible if type of problem rest has been updated to a function type. :;<=The user patterns. &The type the user patterns eliminate. 8The initial problem constructed from the user patterns. >?:;<=>?:;<=>?:;<=>?None@(TODO: move to Agda.Syntax.Abstract.View ATODO: move somewhere else BDSplit a problem at the first constructor of datatype type. Implicit ' patterns should have been inserted. C?Takes a type, which must be a data or record type application, D and checks that the indices are constructors (or literals) applied B to distinct variables which do not occur free in the parameters. @ For the purposes of this check parameters count as constructor > arguments; parameters are reconstructed from the given type. BPrecondition: The type must be a data or record type application. Dargs ` withTypesFrom` t returns the arguments args paired up  with their types, taken from t, which is assumed to be a length  args -ary pi. Precondition: t has to start with  length args pis. @ABCD@ABCD@ABCD@ABCDNoneEJInstantiate a telescope with a substitution. Might reorder the telescope.  'instantiateTel ( : Tel)( :  --> ) = ( Monadic only for debugging purposes. F3Produce a nice error message when splitting failed EFEFEFEFNoneG+Returns how many parameters a datatype has H+Returns how many parameters a datatype has KinsertTele i xs t tele  tpos % tele := Gamma ; (i : T as) ; Delta  n := parameters T  xs' := xs  \ (take n as) becomes  tpos  ( Gamma ; xs' ; Delta[i := t]3 --note that Delta still reference Gamma correctly  , T as ^ (size xs')  ) (we raise the type since we have added xs'' new bindings before Gamma, and as can only bind to Gamma. O@Main function for removing pattern matching on forced variables PNFor a given expression, in a certain telescope (the list of Var) is a mapping $ of variable name to the telescope. Q>replace the forcedVar with pattern matching from the outside. RHGiven a term containg the forced var, dig out the variable by inserting  the proper case-expressions. SRFind the location where a certain Variable index is by searching the constructors T aswell. i.e find a term that can be transformed into a pattern that contains the @ same value the index. This fails if no such term is present. GHIJKABS pos in tele 0If Just, it is the type to insert patterns from 3 is nothing if we only want to delete a binding. Term to replace at pos The telescope tele where everything is at LMNOPQRS GHIJKLMNOPQRS GHIJKLMNOPQRS GHIJKLMNOPQRSNoneTJCompute the set of flexible patterns in a list of patterns. The result is N the deBruijn indices of the flexible patterns. A pattern is flexible if it  is dotted or implicit. U(Compute the dot pattern instantiations. WJCheck if a problem is solved. That is, if the patterns are all variables. X.For each user-defined pattern variable in the , check > that the corresponding data type (if any) does not contain a < constructor of the same name (which is not in scope); this  " shadowing". could indicate an error, and is not allowed. ,Precondition: The problem has to be solved. Y#Check that a dot pattern matches it's instantiation. ZJBind the variables in a left hand side. Precondition: the patterns should  all be , , or  and the telescope should have & the same size as the pattern list.  There could also be .s resulting from eta expanded implicit record  patterns. [Bind as patterns \Check a LHS. Main function. TUVWX Trace, e.g., CheckPatternShadowing clause YZ[\ Trace, e.g. CheckPatternShadowing clause The patterns. The expected type a =  !. Continuation. ] TUVWXYZ[\] TUVWXYZ[\] TUVWXYZ[\]Nonebcoinductive data type c&data type, but in irrelevant position dneither data type nor record eA Covering is the result of splitting a i. g)De Bruijn level of argument we split on. h>Covering clauses, indexed by constructor these clauses share. kType of variables in scPats. l@How to get from the variables in the patterns to the telescope. mKThe patterns leading to the currently considered branch of the split tree. nSubstitution from scTel to old context. oThe type of the rhs. p-Project the split clauses out of a covering. q8Create a split clause from a clause in internal syntax. r6Old top-level function for checking pattern coverage.  DEPRECATED s2Top-level function for checking pattern coverage. t;cover cs (SClause _ _ ps _) = return (splitTree, used, pss). # checks that the list of clauses cs covers the given split clause.  Returns the  splitTree, the used clauses, and missing cases pss. v@Check that a type is a non-irrelevant datatype or a record with  named constructor. Unless the  argument is  " the data type must be inductive. w >computeNeighbourhood delta1 delta2 perm d pars ixs hix hps con , delta1 Telescope before split point 7 n Name of pattern variable at split point + delta2 Telescope after split point , d Name of datatype to split at $ pars Data type parameters ! ixs Data type indices ' hix Index of split variable 1 hps Patterns with hole at split point , con Constructor to fit into hole    dtype == d pars ixs xEntry point from Interaction.MakeCase.  Abs is for absurd clause. yEntry point from TypeChecking.Empty and Interaction.BasicOps. zsplit _   ps %. FIXME:  " ps, x "  (deBruijn inde}GConvert a de Bruijn index relative to a telescope to a de Buijn level. J The result should be the argument (counted from left, starting with 0) ) to split at (dot patterns included!). #^_`abcdefghijklmnopqrstuvwxyz9Coinductive constructors are allowed if this argument is  . {|}~9Coinductive constructors are allowed if this argument is  . Y Z!^_`abcdefghijklmnopqrstuvwxyz{|}~!ijklmnoefghpq_dcba`^rstuvwxyz{|}~^_dcba`efghijklmnopqrstuvwxyz{|}~ Y ZmNone S)Process function clauses into case tree.  This involves: 2 1. Coverage checking, generating a split tree. F 2. Translation of lhs record patterns into rhs uses of projection.  Update the split tree. 2 3. Generating a case tree from the split tree. # Phases 1. and 2. are skipped if Nothing. 8Get the index of the next argument we need to split on. O This the number of the first pattern that does a match in the first clause. S>Translate record patterns and coverage check with given type?  S S SNoneRICheck whether a type is empty. Maybe postponed as emptyness constraint. RRRR~None kCheck a list of arguments: checkArgs args t0 t1 checks that  t0 = Delta -> t0' and  args : Delta. Inserts hidden arguments to 6 make this happen. Returns the evaluated arguments vs, the remaining  type t0' (which should be a subtype of t1) and any constraints cs < that have to be solved for everything to be well-formed.  TODO: doesn't do proper blocking of terms lType check an expression. m=Check that an expression is a type without knowing the sort. $Check that an expression is a type. CCheck that an expression is a type which is equal to a given type. FType check a telescope. Binds the variables defined by the telescope. HCheck a typed binding and extends the context with the bound variables. N The telescope passed to the continuation is valid in the original context. HCheck a typed binding and extends the context with the bound variables. N The telescope passed to the continuation is valid in the original context. IParametrized by a flag wether we check a typed lambda or a Pi. This flag  is needed for irrelevance.  Type check a lambda expression. checkArguments' exph r args t0 t e k tries checkArguments exph args t0 t.  If it succeeds, it continues k* with the returned results. If it fails, M it registers a postponed typechecking problem and returns the resulting new  meta variable. Checks e := ((_ : t0) args) : t. KInfer the type of a head thing (variable, function symbol, or constructor) ACheck the type of a constructor application. This is easier than F a general application since the implicit arguments can be inserted 8 without looking at the arguments to the constructor.  checkHeadApplication e t hd args checks that e has type t,  assuming that e has the form hd args. The corresponding  type-checked term is returned. If the head term hd& is a coinductive constructor, then a  top-level definition fresh tel = hd args (where the clause is  delayed) is added, where tel corresponds to the current ! telescope. The returned term is  fresh tel. Precondition: The head hd) has to be unambiguous, and there should + not be any need to insert hidden lambdas. 1Check that a list of arguments fits a telescope. HInfer the type of an expression. Implemented by checking against a meta L variable. Except for neutrals, for them a polymorphic type is inferred. :Infer the type of an expression, and if it is of the form   {tel} -> D vs for some datatype D then insert the hidden 6 arguments. Otherwise, leave the type polymorphic. # k l m [" k l m" m l k! k l m [NonebindPostulatedName builtin e m checks that e is a postulated  name q, and binds the builtin builtin to the term m q def,  where def is the current  r of q. 'Bind a builtin thing to an expression.  \ ] ^ _ \ ] ^ _NoneJ4Binds the FLAT builtin, and changes its definition. KABinds the SHARP builtin, and changes the definitions of INFINITY  and SHARP. L8Binds the INFINITY builtin, but does not change the type's  definition.  The type of ".  The type of &o_.  The type of &m. JKLJKLLKJJKLNone `IRemove all projections from an algebraic term (not going under binders). a1Configuration parameters to termination checker. bJDo we assume that record and data type constructors preserve guardedness? c+The name of the sharp constructor, if any. dCTarget type of the function we are currently termination checking.  Only the constructors of  e are considered guarding. Termination check clauses f&The name refers to either an ordinary 2 constructor or the successor function on sized  types. -The result of termination checking a module.  Must be  and a $. g.Termination check a sequence of declarations. (Termination check a single declaration. hGTermination check a bunch of mutually inductive recursive definitions. i termMutual' conf names allNames checks allNames for termination. names is taken from the  Y syntax, so it contains only B the names the user has declared. This is for error reporting. allNames is taken from Internal syntax, it contains also G the definitions created by the type checker (e.g., with-functions). j%termFunction conf names allNames name checks name for termination. names is taken from the  Y syntax, so it contains only B the names the user has declared. This is for error reporting. allNames is taken from Internal syntax, it contains also G the definitions created by the type checker (e.g., with-functions). kTermination check a module. l4Termination check a definition by pattern matching. mliftDeBruijnPat p n *increases each de Bruijn index in p by n. A Needed when going under a binder during analysis of a term. n;Convert a term (from a dot pattern) to a DeBruijn pattern. o0Removes coconstructors from a deBruijn pattern. pcf.  q)Extract recursive calls from one clause. r%Extract recursive calls from a term. s Rewrite type  tel -> Size u@ to @tel - Size. tcompareArgs suc pats ts 3compare a list of de Bruijn patterns (=parameters) pats  with a list of arguments ts and create a call maxtrix ( with |ts| rows and |pats| columns. If sized types are enabled, suc$ is the name of the size successor. u u turns the result of  t into a proper call matrix v v7 adds guardedness flag in the upper left corner (0,0). wBStripping off a record constructor is not counted as decrease, in # contrast to a data constructor. ! A record constructor increases/)decreases by 0, a data constructor by 1. xCompute the sub patterns of a . yBFor termination checking purposes flat should not be considered a % projection. That is, it flat doesn'#t preserve either structural order - or guardedness like other projections do. N Andreas, 2012-06-09: the same applies to projections of recursive records. z;Remove projections until a term is no longer a projection.  Also, remove s. {compareTerm t dbpat , Precondition: top meta variable resolved |Compare two variables 5 ` } e a ~  b c d f  g h i j k l m n o p q r s t u v w x y z { | + ` } e a ~  b c d f  g h i j k l m n o p q r s t u v w x y z { | None 'checkRecDef i name con ps contel fields name Record type identifier. con& Maybe constructor name and info. ps Record parameters. contel# Approximate type of constructor (fields -> Set). fields List of field signatures. (checkRecordProjections m r q tel ftel fs. m  name of the generated module r  name of the record type q ! name of the record constructor tel $ parameters and record variable r (self) ftel  telescope of fields fs  the fields to be checked NoneGCompute the clauses for the with-function given the original patterns.  %stripWithClausePatterns  qs  ps = p'? - context bound by lhs of original function (not an argument) * - type of arguments to original function qs+ - internal patterns for original function  - permutation taking vars(qs) to  support( ps/ - patterns in with clause (presumably of type ) ps'2 - patterns for with function (presumably of type ) @Construct the display form for a with function. It will display O applications of the with function as applications to the original function.  For instance,  aux a b c as f (suc a) (suc b) | c n" is the number of with arguments. None P@Type check a definition by pattern matching. The third argument 3 specifies whether the clauses are delayed or not. 'Check a trivial definition of the form f = e DEnsure that all clauses have the same number of trailing implicits.  Example:    test : Bool ! {A B : Set} ! Se test true {A} = A  test false {B = B} = B trailingImplicits patches these clauses to    test : Bool ! {A B : Set} ! Se test true {A} {_} = A  test false {_} {B = B} = B &such that the arity of the clauses of test is uniform. dropNonHidden n tel drops n non-hidden domains from tel, 5 including all hidden domains that come before the nth non-hidden one. splitTrailingImplicits c returns the patterns of clause c  as pair  (ps, ips) where ips$ are the trailing implicit patterns  and ps is the rest. *patchUpTrailingImplicits should (ps, is) c takes a clause c whose  patterns are split into (ps, is) where is are the trailing  implicit patterns and ps the rest. is has already been patched N with omitted implicit patterns (which can occur if named implicit patterns  are there originally). should is an extension of is. 0 The returned clause contains an extension of is by new wildcards  to match should. AInsert some patterns in the in with-clauses LHS of the given RHS Type check a function clause. IType check a where clause. The first argument is the number of variables  bound in the left hand side. =Check if a pattern contains an absurd pattern. For instance, suc () PQPQQPPQNone M#Check an application of a section. N!Type check a single declaration. O'Type check a sequence of declarations. Type check an axiom. -Type check a primitive function declaration. Check a pragma. >Type check a bunch of mutual inductive recursive definitions. DAll definitions which have so far been assigned to the given mutual  block are returned. GType check the type signature of an inductive or recursive definition. Type check a module. 0Type check an import declaration. Actually doesn't do anything, since all ) the work is done when scope checking. MNO MNO ONM MNONone lNOON l_None B>Scope checks the given module. A proper version of the module 3 name (with correct definition sites) is returned. 1Merge an interface into the current proof state. @If the module has already been visited (without warnings), then B its interface is returned directly. Otherwise the computation is E used to find the interface and the computed interface is stored for  potential later use. -Type checks the given module (if necessary). BTries to return the interface associated to the given module. The A time stamp of the relevant interface file is also returned. May ; type check the module. An error is raised if a warning is  encountered. A more precise variant of . If warnings are A encountered then they are returned instead of being turned into  errors. :Print the highlighting information contained in the given  interface. >Writes the given interface to the given file. Returns the file's ! new modification time stamp, or  if the write failed. >Tries to type check a module and write out its interface. The E function only writes out an interface file if it does not encounter  any warnings. <If appropriate this function writes out syntax highlighting  information. ABuilds an interface for the current module, which should already & have been successfully type checked. ETrue if the first file is newer than the second file. If a file doesn't . exist it is considered to be infinitely old. B*If type checking is necessary, should all  state changes inflicted by   be preserved? The corresponding file. The file to type check. The expected module name.   for the current module. )Syntax highlighting info for the module. -Haskell modules imported in imported modules  (transitively). Options set in OPTIONS pragmas.  B  B BNone%%%%None  Agda module names. Used to test . 8Can the character be used in a Haskell module name part  (conid;)? This function is more restrictive than what the Haskell  report allows. @Haskell module names have to satisfy the Haskell (including the : hierarchical module namespace extension) lexical syntax:  modid -> [modid.] large {small | large | digit | ' }1 is an injective function into the set of module  names defined by modid. The function preserves .s, and it also 5 preserves module names whose first name part is not . 3Precondition: The input must not start or end with . , and no two  .s may be adjacent. All the properties.       None/A wrapper type used to avoid orphan instances. 2Encodes module names just before pretty-printing.   None8Check that the main function has type IO a, for some a.                     None )Extract Agda term to Haskell expression. ) Irrelevant arguments are extracted as ().  Types are extracted as ().  DontCare1 outside of irrelevant arguments is extracted as error. BNote that the INFINITY, SHARP and FLAT builtins are translated as  follows (if a   is given):   type Infinity a b = b  sharp :: a -> a  sharp x = x  flat :: a -> a  flat x = x  Move somewhere else! $-Irrelevant arguments are replaced by Haskells' ().   !"#$%&'()*&Is the type inductive or coinductive? +,-./0123456  !"#$%&'()*+,-./0123456 !"# $%&'()*+,-./0123456  !"#$%&'()*+,-./0123456None73Compile an interface into an executable using Epic HBefore running the compiler, we need to store some things in the state, L namely constructor tags, constructor irrelevancies and the delayed field # in functions (for coinduction). GPerform the chain of compilation stages, from definitions to epic code BChange the current directory to Epic folder, create it if it doesn' t already  exist. )Make a program from the given Epic code. #The program is written to the file ../m, where m is the last % component of the given module name. >Create the Epic main file, which calls the Agda main function ICall epic, with a given set of flags, if the |Bool| is True then include # the command line flags at the end TCall epic with a given set of flags, the argument function receives the flags given  at the command line 7 77 7 None#89:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ#89:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ#89:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ#89:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZNone[ A subset of _. uParses an expression. {:Evaluate the given expression in the current environment >Returns the type of the expression in the current environment A We wake up irrelevant variables just in case the user want to 1 invoke that command in an irrelevant context. ARuns the given computation as if in an anonymous goal at the end  of the top-level module. *Returns the contents of the given module. >[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ The range of the next argument. The module name. #Module names, names paired up with  corresponding types. 4[\]^_`abcdefghijklmnopqrstuvwxyz{|}~4uvwxyz{|ptsrq}no_mlkjihgfedcba`[\]^~([\]^_mlkjihgfedcba`noptsrquvwxyz{|}~ NoneThe interaction loop. ?The logo that prints when Agda is started in interactive mode. The help message None8Find the clause whose right hand side is the given meta + BY SEARCHING THE WHOLE SIGNATURE. Returns B the original clause, before record patterns have been translated 7 away. Raises an error if there is no matching clause. FAndreas, 2010-09-21: This looks like a SUPER UGLY HACK to me. You are E walking through the WHOLE signature to find an information you have / thrown away earlier. (shutter with disgust). E This code fails for record rhs because they have been eta-expanded,  so the MVar is gone. +Make a clause with a question mark as rhs. None,Maximum size of the generated element. When Nothing this value  is initialized from the  parameter. <When this is true no lambdas, literals, or constructors are  generated HOnly generates default configurations. Names and free variables varies. "Check that the generated terms don'#t have any out of scope variables.  UUN None telFromList . telToList == idAll elements of t/ are well-scoped under the original telescope.  unflattenTel . flattenTel == id u is stable.  4The result of splitting a telescope is well-scoped.  HThe permutation generated when splitting a telescope preserves scoping.                 None    None3 !"#$%&'()*+,-./0123456789:;<=>?@3 !"#$%&'()*+,-./0123456789:;<=>?@3 !"#$%&'()*+,-./0123456789:;<=>?@, !"#$%&'()*+,-./0123456789:;<=>?@None A AA   A None/DAvailable backends. IThe I monad.   " state holds the remaining input. LAn interactive computation. O>Shows all the top-level names in the given module, along with 0 their types. Uses the scope of the given goal. P&Displays the current goal and context and infers the type of an  expression. Q'Displays the current goal and context. YGoal commands If the range is ]!, then the string comes from the " minibuffer rather than the goal. Z&Toggle display of implicit arguments. [6Tells Agda whether or not to show implicit arguments. \!cmd_load_highlighting_info source loads syntax highlighting  information for the module in source, and asks Emacs to apply # highlighting info from this file. AIf the module does not exist, or its module name is malformed or C cannot be determined, or the module has not already been visited, E or the cached info is out of date, then no highlighting information  is printed. DThis command is used to load syntax highlighting information when a E new file is opened, and it would probably be annoying if jumping to @ the definition of an identifier reset the proof state, so this > command tries not to do that. One result of this is that the D command uses the current include directories, whatever they happen  to be. ]AParse and type check the given expression (as if it were defined ; at the top-level of the current module) and normalise it. ^9Parse the given expression (as if it were defined at the 6 top-level of the current module) and infer its type. `>Shows all the top-level names in the given module, along with ( their types. Uses the top-level scope. aMShow unsolved metas. If there are no unsolved metas but unsolved constraints  show those instead. ccmd_compile b m includes compiles the module in file m using  the backend b, using includes as the include directories. dcmd_load m includes loads the module in file m, using  includes as the include directories. e5Monad for computing answers to interactive commands. e is  extended with state h.  : is in a newtype wrapper because we would like to prevent  the accidental use of  .  Instead of   one can use o , see below. h/Auxiliary state of an interactive computation. j<The interaction points of the buffer, in the order in which 9 they appear in the buffer. The interaction points are  recorded in  theTCState&, but when new interaction points are @ added by give or refine Agda does not ensure that the ranges , of later interaction points are updated. k8The file which the state applies to. Only stored if the 8 module was successfully type checked (potentially with  warnings). The # is the modification time stamp of # the file when it was last loaded. l+Reset the options on each reload to these. m$Initial auxiliary interaction state nWrapped   for e. olift a TCM action to CommandM. o is a customized form of   for  . # At the end of the lifted action   is set H to its original value because the value is lost during the execution  of some TCM actions. pBuild an opposite action to   for state monads. q Opposite of   for e. 0 Use only if main errors are already catched. rr runs a safe TMC action (a  action which cannot fail) s@Lift a TCM action transformer to a CommandM action transformer. t1Put a response by the callback function given by  . uRun an J* value, catch the exceptions, emit output !If an error happens the state of e does not change, < but stPersistent may change (which contains successfully # loaded interfaces for example). vConverter from the type of   to I 3 The first paramter is part of the error message  in case the parse fails. xDemand an exact string. {BCan the command run even if the relevant file has not been loaded  into the state? |Interpret an interaction }cmd_load' m includes cmd cmd2 loads the module in file m,  using includes as the include directories. >If type checking completes without any exceptions having been  encountered then the command cmd r is executed, where r is the  result of . 0Sorts interaction points based on their ranges. -Pretty-prints the type of the meta-variable. 6Pretty-prints the context of the given meta-variable. ?Displays the current goal, the given document, and the current  context. >Shows all the top-level names in the given module, along with  their types. BSets the command line options and updates the status information. "Computes some status information. Displays/updates status information.  display_info does what  display_info' False does, but 4 additionally displays some status information (see  and  ). 1Parses and scope checks an expression (using the " inside scope" B as the scope), performs the given command with the expression as ! input, and displays the result. 8Tell to highlight the code using the given highlighting  info (unless it is Nothing). ATells the Emacs mode to go to the first error position (if any). aBCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnoprun lift )reverse lift in double negative position qrstuvwxyz{|}Allow unsolved meta-variables? ~ Normalise? %Print the elements in reverse order? The command to perform. 6The name to use for the buffer displaying the output. The expression to parse.  !!!!OBCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~OhijklmefgnopqrstuLdcba`_^]\[ZYXWVUTSRQPONMJKIvwxyz{|H}DGFE~BC>BCDGFEHIJKLdcba`_^]\[ZYXWVUTSRQPONMefghijklmnopqrstuvwxyz{|}~ !!!!None3 is a fake ghci interpreter for the Emacs frontend  and for interaction tests. / reads the Emacs frontend commands from stdin, 5 interprets them and print the result into stdout. !GConvert Response to an elisp value for the interactive emacs frontend. !Adds a "last" tag to a response. !<Show an iteraction point identifier as an elisp expression. !!!!!!NoneThe main function Print usage information. Print version information. What to do for bad options. Main !                   !"#$%&'()*+,-../0123456789::;<==>?@ABCDEFGHI/0JKLM8NOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwwxyz{|}~8       8!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ! ! ! ! !!!!!!!!!!!!!!!!!!! !!!"!#!$!%!&!'!(!)!*!+","-"."/"0"1"2"2"3"3"4"5"6"7"8"9":";"<"=">"?"@"A"B"C"D"E"F"G"H"I"J"K"L"M"N"K"O"P"Q"R"S"T"U"V"W"X"Y"Z"["\"]"^"_"`"`"a"b"c"d"e"f"f"g"h"i"j"k"l"m"n"o"p"q"r"s"t"u"v"w"x"y"z"{"|"}"~"""""""""""""""""""""""""""""""""""####################################################$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$%%%%%%%%%% % % % % % %%%%%%%%%%%%%%%%%%% %!%"%#%$%%%&%'%(%)&*'+','-'.'/'0'1(2(3(4(5(6(7(8(9(:(;)9)):):);)<)=)=)>)?)@)A)B)C)D)E)F)G)H)I)<)=)/)>)0)J)K)L)8*?*@*@*A*B*C*D*D*E**F*G*H*I*J*K*L*M*N*O*P*Q*R*S*T*U*V******W*X*8+Y+Z+[+\+]++^+_+`+a+8,b,c,8-d-e-f-g-h-i-8jklmnopqrstuvwxyz{|}~....4...../////////////////////////////800000000000000000000000000000000000000000000000000000000000000081111111111111111111111111111111111111111111111111 182 2 2 2 2 2n2 2222222222222222222222 2!2"2#2$2%2&2'2(2)2k2l2m2*2+2,2-2.2-2/202122232425262728292:2;2<2=2>2?3@3A3B3C3D3D3E3F3G3G3H3I3J3J3K3K3L3L3I3S3M3N3O3P3Q3R3S3T3U3V3W3X3Y3Z3[4\4]4+4,4^4_4`4a4b4c4F5d5e5f5g5h5i5j5k5l55m5n5o5p5q55r5s6t6t6u6v6w6x6x6y6z6{6|6}6~666666777777777777777777777s7777777777777O888888888D88888888888888888888888888888988888888888888888888888888888899999999i999999999999999999999:;;;;;;;;;;;;;;;8<<<<<<< < < < < <<<<<<============= =!="=#=$=$=%=%=&='=(=)=*=+=,=-=.=/=0=1=2=3=4>5>6>7>8>9>:>;>;><>=>>>>>?>>>@>A>B>C>D>E>F>G>H>I>J>K>L>M>N>O>P>Q>>R>S>>>T>U>V>W>X>Y>Z?[?\?]?^?_?`@a@a@D@b@c@d@e@f@g@h@i@j@k@l@m@@n@o@p@q@r@s@t@b@D@u@v@w@x@\@y@z@{@|@}@~@@@@@@@@]@@@@@@@@@@@@@@@@@)@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@Q@L@@@@M@@@@@N@@@@@@@@@@@@@@@AAAAAAAAAAAAAAAAAAAAAAxA\ADAAA^A]AAAAAAAWAAAAAAAAAA A A A A8B BBB}BBBBBBBCCCCCCCCCC C!C"CC#C$C%C&C'C(C)C*C+C,C-C.C/C0C1C2C3C4C5C6C7C8C9CC:C;C<C=C>C?C@CACBCCCDCECFCGCHCICJCKCLCMCNCOCPCQCRCSCTCUCVCWCXCYCZC[C\C]C^C_C`CaCbCcCdCeCfCgChCiCjCkClDmDmDnDnDoDpDqDrDsDtDuDvDwDxDyDzD{D|D}E~EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEFFFGGGGGGGGGGZGZGGGGGGGGGGGGGGGGGGGGGKGGGGOGGGGGOGGGGfGGfGGGGGQGGGGGGGKGLGG_GGMGTGGGGGGGGGGGGG G G G G GGGGGGGGGGGGGHHHHHH H!H"H#H$H%H&H'H(H)H*H+H,H-H.H/H0H1H2H3H4I5I5I6I7I8I9I:I;I<I=I>I>I?I@IAIBI#ICIDI%I%IEItIFItITIGIHIIJJJKJLJMJJJNJOJPJQJJRJSJTJJOJxJNJJMJJTJJUJVJWJXJJYJZJJ[J\J]J^J_J`JaJJbJcJdJeJfJhJgJhJiKjKkKlKxKxKmKnKoKpKqKqKKrKsKtKuKvKwLxLyLzL{L|M}M~MMMMMMNNNNNNNNNNNNNNNNN[NNNNNNOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPZPZPPPPPPPPPPPPPP]PPPPPPPbPdPgPhPiPlPkPjPmPPqPrPsPPPtPPPPPPPwPbPvPQPP{PxPPPP|PPPPPPPPPPPPQPPLPPPMPPNPPPPP_PTPPPPPPPPPPPPPPPPPPPQaQQQQRRRRRRRRRRRRRRRRRRZRZRRRRRRRRRR R R R R RRRRRRRRRSSSSSSSSSSS S!S"S#S$S%S&SSS'S(S)S*S+S,S-S.S/S0S1S2S3T4T5T6T7T7T8T9T:T;T<T<T=T>T?T@TATBTCTDTETFTGTHTITJTKTTLTMTOTNTOTPTQTRTSTTTUTVTWTXTYTZT[T\T]T^U_U`UaUbUcUdUdUeUfUgUhUiUjUkUlUmUnUoVpVqVrWsWtWuWWvWwWxWyWWzW{X|X}X~XXXXXXXXXXXXXYYYYYZZ[[[[[[[[[[[[[[XXVV\\\\8]]O]]N]]]]^^p                                  ! " # $ % & ' ( ( ) * + + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A ? B C C D- E F G H H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h g i j j k l m n o p q r@ s t u v w x y z { | } ~                                           x    ]                 ^                                                                                        w                    ! " #w $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 6 7 8 9 : ; ; < = > ? @ A B C D E F G H I J K K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u vL w x y z { | } ~             8                  _ ` a a a a a a a a a a b b b b b b b b b b b bzb bQblb b b b b b b bb b b b b b b b bhb b b b b b b b b b b b b b b b b b b b b b c c c 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 0e 1e 2e 3e 4e 5e 6e 7e 8e 9e :e ;e <e =e >e ?e @e Ae Be Ce De Ee Fe Ge He Ie Je Ke Le Me Ne Oe Pe Qe Re Se Te Ue Ve We Xe Ye Ze [e \e ]e ^e _e `e ae be ce de ee fe ge he ie je ke le me ne oe pe qe re se te ue vf wg xg yg zg {gh |h }i ~i i i i i i i i i i i i i i i i i i i j j j j j j j j j j j j j j j j k k k k l mn o pq q r r r r r r s s s s s s s t t t t 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 u u u u u u u u u u u u u u u u u v v v v v v v w : : : : : : : : : : : : : :                                  f f f f f f f !f "f #f $f %f &f 'f (f )f *f +f ,f -f .f /f 0f 1f 2f 3f 4f 5f 6f 7f 8f 9f :f ;f <f =f >f ?f @x Ax Bx Cx Dx Ex Fx Gx Hx Ix Jx Kx Lx Mx Nx Ox x Px Qx Rx Sx Tx Ux Vx Wx Xx Yx Zx [x \x ]x ^x _x `x ax bx cx dx ex fx gx hx ix jx kx lx mx ny oz pz qz rz sz t{ u{ v{ u{ w{ x{ y{ z{ {{ |{ }{ ~{ { { { { { | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | } } } } } } } } ~ ~ ~                                                                                 ! " # $ % & ' ( ) * + , - . / 0 1 1 2 3 4 5 5 6 7 7 8 9 : ; ; < = > ? @ A B C D E F G G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a bN c d e f g h i j k l m n o p q r s t u8 v w x y z { | } ~                         llllllll !"#$%&'()*+,-../012, )./3456789`:`:`;`<`=`>`?@8ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ j oooooooogggggggggg aaaaaaaaaaaaaaaaaaaaa a a a a aaaaaaaaaaaaaaaddddd d!d"d#d8$%&'())*+,-.//0123456789:;<=>?@ABCDUEFGHIJKLMNOqPqQq|qRqSqTqUqVqWqXqYqZq[q\q]q^q_`abcdefghijk[lCmnopqrstuvwwxnnyzz{|}~nnnzn  1      !"#$%&'()*+,-./0123456789:;S<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijkllmnopqrstuvwxyz{|}~mmmmmmmmm~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~____________8     7 !"#$%&'()*+,-./0123456789:;<=>?@A IB"CDEFz P<GH<I/245JKLMNOPQRSTUVWXYZ[\]]^_`abcdefghijklmnopqrstuvwxyz{|}~c J J8     / !"#$%&&'()*+,-./0123456789:;<=>?@@ABBCDEFGHIJKL8MNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrsrtrurvrwrxryrzr{r|r}r~                            nmz+z    U  !"#$%&'()*+,-./012k3456}W789:;<=*>?@ABCDEFGHIGHGHJGHdGHKGHLGHMGHGHGNGNOGNPGNQGNRGNSGNTGNUGNVGNWGNXGNYGNGNGNGNZGN[GNGNGNGN\GNGN]^_`abcdefghijklmnkopqrstsusv w!x!y!z!{!|#}#~#######' ~ { y z3 x94 | }567210I W/z(((())))!))))))))))))) )")#)$)%)&)')())))*)+),)-).*7***********?*************************+++++++++++,,,,,,,,,,,,,,,,,--d----//// / / / / 0000000000000000000 0!0"0#0$0%0&0'0(0)0*0+0,0-0.0/000102030405060708090:0;0<0=0>0?0@0 !1A1B1C1D1E1F1G1H1I1J1K1L1M1N1O1P1Q1R1S1T1U1V1W1X1Y1Z1[1\1]1^1_1`1a1b1c1d1e1f1g1h1i1j1k1l1m2n2o2p2q2r2s2t2u2v2w2x2y2z2{2|2}2~222222233333333344444444666888888889999999999999999;;;;;====>>>>>>>>>>>>>>>>>>>>>>??????@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@AAAAACAAAAAAAAAAAAAAAAAAAA B B B B BBBBBBBBBBBBBBBBBBBB B!B"B#B$B%B&B'B(B)B*B+B,B-B.B/B0B1C2D3D4D5D6D7E8E9E:E;E<E=E>E?E@EAEBECEDEEEFGHIGHJGHKGHLGMGNGOGPGQGRGSGTGUGVGWGXGYGZG[G\G]G^G_G`GaGbGcGdGeGfHgHhHiHjHkHlHHmHnHHHoHHpHpHqHHHrHsHtHuHvHwHxHyHzH{H|H}H~HIKKKKKKKLLLLLLLLLLLLNOOOOOOOOOOOOOOOOOOOOOOPPPPPPPPPPPPPPPPPP`PPPPPPPPPPPPPPPPPPPPPRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR fRRRRRRT1TTTTT }TTTTTTTTTWWWWsWWZZZZZZZZZ[[[[[[[[[[[[[ [ [ [ [ [[[[[[[[[[[[[[[[[[[ [!["[#[$[%[&['[([)[*[+[,[-[.[/[0[1[2[3[4[5[6[7[8[9[:[;[<[=[>[?[@[A[B[C[D[E[F[G[H[I[J[K[L[M[N[O[P[Q[R[S[T[U[V[W[X[Y[Z[[[\[][^[_[`[a[b[c[d[e[f[g[h[i[j[k[l[m[n[o[p[q[r[s[t[u[v[w[xXyXzX{X|X}X~V\\I\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\ \ \ \ \ \\\\\\\\\\\\\\\\\\\ \!\"\#\$\%\&\'\(\)\*\+\,\-\.\/\0\1\2\3\4\5\6\7\8\9\:\;\<\=\>\?\@\A\B\C\D\E\F\G\H\I\J\K\L\M\N\O\P\Q\R\S\T\U\V\W\X\Y\Z\[\\\]\^\_\`\a\b\c\d\e\f\g\h\i\j\k\l\m\n\o\p\q\r\s\t\u\v\w\x\y\z\{\|\}\~\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\ \ \ \ \ \\\\\\\\\\\\\\\\\\\ \!\"\#\$\%\&\'\(\)\*\+\,\-\.\/\0\1\2\3\4\5\6\7\8\9\:\;\<\=\>\?\@\A\B\C\D\E\F\G\H\I\J\K\L\M\N\O\P\Q\R\S\T\U\V\W\X\Y\Z\[\\\]\^\_\`\a\b\c\d\e\f\g\h\i\j\k\l\m\n\o\p\q\r\s\t\u\v\w\x\y\z\{\|\}\~\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\ \ \ \ \ \\\\\\\\\\\\\\\\\\\ \!\"\#\$\%\&\'\(\)\*\+\,\-\.\/\0\1\2\3\4\5\6\7\8\9\:\;\<\=\>\?\@\A\B\C\D\E\F\G\H\I\J\K\L\M\N\O\P\Q\R\S\T\U\V\W\X\Y\Z\[\\\]\^\_\`\a\b\c\d\e\f\g\h\i\j\k\l\m\n\o\p\q\r\s\t\u\v\w\x\y\z\{\|\}\~\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\ \ \ \ \ \\\\\\\\\\\\\\\\\\\ \!\"\#\$\%\&\'\(\)\*\+\,\-\.\/\0\1\2\3\4\5\6\7\8\9\:\;\<\=\>\?\@\A\B\C\D\E\F\G\H\I\J\K\L\M\N\O\P\Q\R\S\T\U\V\W\X\Y\Z\[\\\]\^\_\`\a\b\c\d\e\f\g\h\i\j\k\l\m\n\o\p\q\r\s\t\u\v\w\x\y\z\{\|\}\~\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\]]]]]K]]]O]bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb b b b b bbbbbbbbbbbbbbbbbbb b!b"b#b$b%b&b'b(b)b*b+b,b-b.b/b0c1c2c3c4c5c6c7c8c9c:c;c<c=j>j?j}j@jAjBjCjDjEjFjGjHjIjIj j jJjKjLjMjNjOjPjQj hjRjSjTjUjVjWjXjYjZj\j]j^j_j`jajbjcjdjejfjgjhjijjjkjljmjnjojpjqjrjsjtjujvjwjxkypGpzp{r|r}r~rrrrrrrrrmWyyyyyyyyyyyy#yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy{{{{{{{{{{{{ f{{{{{{{{{{{{{{ , . / 0 6 8 : < =      !"#$%&'()*+,-X./00123 y456789:;<=>?@ABCDEFGHIJKL MNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~f     ````````` !"#$%&'%&(%&)*+,-../01234556789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ y xa      aaddddddddddd !"#$%&'()*+,-./0123q4q5q6q7q8q9q:q;q<q=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~m~ Y [4      !"#$%&'()*+,-./012 Agda-2.3.2Agda.Utils.MonadAgda.Utils.VarSetAgda.Utils.SemiRingAgda.TypeChecking.Monad.DebugAgda.Utils.PointedAgda.Utils.MaybeAgda.Utils.CharAgda.Utils.HashAgda.Utils.UnicodeAgda.Utils.PointerAgda.Utils.TrieAgda.Utils.IO.BinaryAgda.Utils.FreshAgda.Utils.QuickCheckAgda.Utils.TestHelpersAgda.Termination.SemiringAgda.Termination.MatrixAgda.Utils.ReadPAgda.Utils.FunctionAgda.TypeChecking.Monad.BaseAgda.Utils.TimeAgda.Utils.IO.UTF8Agda.Utils.TupleAgda.Interaction.ResponseAgda.Utils.StringAgda.Utils.SizeAgda.Utils.ImpossibleAgda.ImpossibleTestAgda.Utils.ListAgda.Utils.PermutationAgda.Utils.SuffixAgda.Utils.EitherAgda.Auto.NarrowingSearchAgda.Auto.SyntaxAgda.Auto.SearchControlAgda.Auto.TypecheckAgda.Auto.CaseSplit Agda.VersionAgda.Utils.PrettyAgda.Interaction.EmacsCommandAgda.Termination.SparseMatrixAgda.Termination.CallGraphAgda.Termination.LexicographicAgda.Termination.TerminationAgda.Utils.FileNameAgda.Utils.MapAgda.Utils.GraphAgda.Interaction.OptionsAgda.Syntax.PositionAgda.Syntax.CommonAgda.Compiler.JS.SyntaxAgda.Compiler.JS.PrettyAgda.Compiler.JS.SubstitutionAgda.Compiler.JS.CaseAgda.Compiler.JS.ParserAgda.Utils.WarshallAgda.Syntax.Concrete.NameAgda.Interaction.FindFile#Agda.Interaction.Highlighting.RangeAgda.Syntax.NotationAgda.Syntax.FixityAgda.Syntax.Abstract.NameAgda.Syntax.LiteralAgda.Syntax.Concrete%Agda.Interaction.Highlighting.PreciseAgda.Syntax.Concrete.PrettyAgda.Syntax.Parser.Tokens$Agda.TypeChecking.Coverage.SplitTreeAgda.Syntax.Scope.BaseAgda.Utils.GeniplateAgda.Syntax.InternalAgda.TypeChecking.FreeAgda.Compiler.Epic.InterfaceAgda.Compiler.Epic.AuxAST Agda.TypeChecking.CompiledClauseAgda.Syntax.Internal.GenericAgda.Syntax.Internal.Pattern Agda.TypeChecking.Coverage.MatchAgda.Syntax.InfoAgda.Syntax.AbstractAgda.Syntax.Abstract.Views Agda.Syntax.Concrete.Definitions%Agda.Syntax.Concrete.Operators.ParserAgda.Syntax.Parser.MonadAgda.Syntax.Parser.AlexAgda.Syntax.Parser.LayoutAgda.Syntax.Parser.LookAheadAgda.Syntax.Parser.LexActionsAgda.Syntax.Parser.Comments!Agda.Syntax.Parser.StringLiteralsAgda.Syntax.Parser.LexerAgda.Syntax.Parser.ParserAgda.Syntax.ParserAgda.Interaction.ExceptionsAgda.Interaction.ImportsAgda.TypeChecking.ErrorsAgda.TypeChecking.MetaVarsAgda.TypeChecking.SubstituteAgda.TypeChecking.Abstract&Agda.Interaction.Highlighting.GenerateAgda.TypeChecking.Monad.BuiltinAgda.TypeChecking.Monad.OptionsAgda.TypeChecking.ConstraintsAgda.TypeChecking.Monad.ContextAgda.TypeChecking.Monad.State*Agda.Syntax.Translation.AbstractToConcrete"Agda.TypeChecking.Monad.StatisticsAgda.TypeChecking.Datatypes(Agda.TypeChecking.CompiledClause.Compile&Agda.TypeChecking.CompiledClause.Match#Agda.TypeChecking.InstanceArguments"Agda.TypeChecking.LevelConstraintsAgda.TypeChecking.Polarity!Agda.TypeChecking.Monad.ExceptionAgda.TypeChecking.Monad.EnvAgda.TypeChecking.Monad.OpenAgda.TypeChecking.Monad.ImportsAgda.TypeChecking.Monad.Mutual Agda.TypeChecking.ProjectionLikeAgda.Syntax.Scope.MonadAgda.Syntax.Abstract.CopatternsAgda.TypeChecking.Monad.SharingAgda.Syntax.Concrete.Operators"Agda.TypeChecking.Monad.SizedTypesAgda.TypeChecking.Monad.TraceAgda.TypeChecking.Rules.Term!Agda.TypeChecking.Monad.SignatureAgda.TypeChecking.Monad.Closure#Agda.TypeChecking.Monad.Constraints Agda.TypeChecking.Monad.MetaVarsAgda.Syntax.Abstract.Pretty*Agda.Syntax.Translation.ConcreteToAbstractAgda.Interaction.Monad!Agda.Interaction.Highlighting.DotAgda.Compiler.MAlonzo.CompilerAgda.TypeChecking.ConversionAgda.TypeChecking.RecordsAgda.TypeChecking.EtaContractAgda.TypeChecking.IrrelevanceAgda.TypeChecking.PrettyAgda.Compiler.CallCompiler#Agda.Interaction.Highlighting.LaTeXAgda.TypeChecking.Level!Agda.Interaction.Highlighting.VimAgda.TypeChecking.DropArgs+Agda.TypeChecking.Rules.Builtin.CoinductionAgda.TypeChecking.Rules.DeclAgda.TypeChecking.Rules.DefAgda.TypeChecking.Empty&Agda.TypeChecking.UniversePolymorphism Agda.TypeChecking.Patterns.MatchAgda.TypeChecking.ReduceAgda.TypeChecking.TelescopeAgda.Compiler.Epic.CompileStateAgda.Compiler.Epic.CaseOptsAgda.Compiler.Epic.NatDetectionAgda.Compiler.Epic.PrimitiveAgda.TypeChecking.DisplayForm*Agda.Syntax.Translation.InternalToAbstract"Agda.TypeChecking.MetaVars.MentionAgda.TypeChecking.ImplicitAgda.TypeChecking.Eliminators#Agda.Interaction.Highlighting.EmacsAgda.TypeChecking.SerialiseAgda.TypeChecking.SizedTypesAgda.Compiler.HaskellTypesAgda.Compiler.Epic.ForceConstrsAgda.Compiler.Epic.EpicAgda.Compiler.Epic.ErasureAgda.Compiler.Epic.StaticAgda.Compiler.Epic.FromAgdaAgda.Compiler.Epic.Injection Agda.TypeChecking.RecordPatterns!Agda.TypeChecking.MetaVars.Occurs"Agda.Interaction.Highlighting.HTMLAgda.TypeChecking.ForcingAgda.TypeChecking.RebindAgda.TypeChecking.PositivityAgda.TypeChecking.QuoteAgda.TypeChecking.PrimitiveAgda.TypeChecking.InjectivityAgda.TypeChecking.Rules.Data#Agda.TypeChecking.Rules.LHS.Problem!Agda.TypeChecking.Rules.LHS.UnifyAgda.Compiler.Epic.Smashing$Agda.TypeChecking.Rules.LHS.Implicit'Agda.TypeChecking.Rules.LHS.ProblemRest!Agda.TypeChecking.Rules.LHS.Split'Agda.TypeChecking.Rules.LHS.InstantiateAgda.Compiler.Epic.ForcingAgda.TypeChecking.Rules.LHSAgda.TypeChecking.CoverageAgda.TypeChecking.Rules.BuiltinAgda.Termination.TermCheckAgda.TypeChecking.Rules.RecordAgda.TypeChecking.WithAgda.Compiler.MAlonzo.MiscAgda.Compiler.MAlonzo.EncodeAgda.Compiler.MAlonzo.Pretty Agda.Compiler.MAlonzo.PrimitivesAgda.Compiler.Epic.CompilerAgda.Compiler.JS.CompilerAgda.Interaction.BasicOps(Agda.Interaction.CommandLine.CommandLineAgda.Interaction.MakeCase!Agda.TypeChecking.Test.GeneratorsAgda.TypeChecking.Tests Agda.TestsAgda.Auto.ConvertAgda.Auto.AutoAgda.Interaction.InteractionTopAgda.Interaction.GhcTop Agda.MainAgda.Packaging.TypesAgda.Packaging.MonadAgda.Packaging.DatabaseAgda.Packaging.Config Paths_AgdaAgda.Utils.HashMapAgda.TypeChecking.SubstitutionliftSmakeIncludeDirsAbsoluteLHSAgda.TypeChecking IrrelevanceDataTreeAgda.TypeChecking.Monad Agda.SyntaxCommonsimplifyLevelConstraintcompileClausesTypeChecking.Coverage.MatchbuildMPatternsAgda.TypeCheckerTest.QuickChecksizebaseControl.Applicative<*> Data.Functor<$>containers-0.5.0.0Data.IntSet.BasefromListtoList isSubsetOfunionunionsdelete singletonemptymemberSemiRingoplusotimesVarSetsubtractdebugPointedpoint fromMaybeM unzipMaybedecDigithexDigitoctDigithash isUnicodeIdconvertLineEndingsPtrnewPtrderefPtr updatePtrsetPtr updatePtrMTrieinsert lookupPathreadBinaryFile'HasFresh nextFreshfresh withFresh isSuccess quickCheck'quickCheckWith' associative commutativeisZeroidentityleftDistributiverightDistributivenaturalpositivelistOfElementselementsUnlessEmptymaybeGen maybeCoGentwothreerunTestsSemiringaddmulzeroHasZero zeroElementmultiplysemiringInvariantintegerSemiring boolSemiringtestsMatrixMIxrowcolSizerowscols sizeInvariant mIxInvariantmatrixInvariantmatrixUsingRowGenmatrix fromIndexList fromListstoListssquareisEmptydiagonal addColumnaddRowzipWithReadPparsegetlookpfail+++<++gathersatisfycharstringmunchmunch1choice skipSpacescountbetweenoptionoptionalmanymany1skipMany skipMany1sepBysepBy1endByendBy1chainrchainlchainr1chainl1manyTillparse'iterate'TCMTCMT ClockTime getClockTime readTextFilehPutStr writeFileList2list2-*-mapFstmapSnd/\fst3snd3thd3uncurry3uncurry4mapPairMmapFstMmapSndMInteractionOutputCallbackResponse defaultInteractionOutputCallbackquote showIndexaddFinalNewLineindentSized ImpossiblethrowImpossiblecatchImpossibleimpossibleTestSuffixPrefixmheadunconsdownFrom updateLast mapEitherdeal isSublistOfmaybePrefixMatchwordsBychopholessorteddistinct fastDistinctprop_distinct_fastDistinctallEqualgroupBy' prop_groupBy'groupOnextractNthElement'extractNthElementprop_extractNthElementgenericElemIndexprop_genericElemIndexzipWith' prop_zipWith' zipWithTailsuniqBy prop_uniqBy PermutationPerm permRange permPickspermuteidPtakePliftPcomposePinvertPcompactPreversePexpandPtopoSort SubscriptIndexPrimeNoSuffixisSubscriptDigittoSubscriptDigitfromSubscriptDigit nextSuffix suffixView addSuffixmapLeftmapRightisRightisLeftallRightChoice RightDisjunct LeftDisjunctSRes HandleSolQPBQPDoubleBlocked QPBlockedPBPDoubleBlockedPBlockedNotPBMBFailedBlockedNotBMetaEnvMMMetaNotMBlkInfo Refinable refinementsPair RefCreateEnvUndoRestorePrioMetaNoPrioSubConstraintsscflip sccomcountscsub1scsub2CTree ctpriometactsubctparent cthandlesMetavarmbindmprincipalpresentmobs mcompoint mextrarefsOKMetaOKHandleOKValProp ConnectHandleOr SideconditionAnd AddExtraRefErrorOKTermTravtraversePrio hequalMetavarnewMetainitMetanewCTreenewSubConstraints ureadIORef uwriteIORef umodifyIORefureadmodifyIORefrunUndonewPlaceholder newOKHandledryInstantiatemmcasemmmcasemmpcase doubleblockmbcasembpcasemmbpcasewaitokmbretmbfailedmpret expandbind topSearchextractblkinfosrecalcsseqcrecalcreccalccalcchoosePrioMeta propagatePriochooseEECtxCActionWeakSkipSubTrBrClos ICArgList CALConcatCALNilCExpICExp HNArgList HNALConParHNALConsHNALNilHNExpHNSortHNPiHNLamHNAppMArgListArgListALConParALProjALConsALNilMExpExp AbsurdLambdaSortPiLamAppType UnknownSortSetElrConstVarConstRefPatPatExpPatVar PatConAppClauseDeclCont Postulate ConstructorDatatypeDefConstDefcdnamecdorigincdtypecdcont cddeffreevarsAbsMIdNoIdIdFMode NotHiddenInstanceHiddenNatMyMBMyPBRefInfoRICheckProjIndex RICheckElim RIEqRState RIPickSubsvar RIUsedVarsRINotConstructorRIInferredTypeUnknown RIIotaStep RICopyInfo RIUnifInfo RIMainInfoRIEnvrieHintsrieDefFreeVarsrieEqReasoningConstsEqReasoningStateEqRSPrf3EqRSPrf2EqRSPrf1 EqRSChainEqRSNoneEqReasoningConstseqrcId eqrcBegineqrcStepeqrcEndeqrcSymeqrcCongHintMode HMRecCallHMNormalUIddontCaredetecteliminanddetectsemiflexcategorizedecl metaliseokh expandExpaddtrailingargsclosifysubsubiweakweaki weakarglistweakelrdoclos ExpRefInfoeriMaineriUnifseriInfTypeUnknowneriIsEliminand eriUsedVars eriIotaSteperiPickSubsVar eriEqRStategetinfounivarsubsvarsextraref costIncreasecostUnificationOccurscostUnification costAppVarcostAppVarUsed costAppHintcostAppHintUsedcostAppRecCallcostAppRecCallUsedcostAppConstructorcostAppConstructorSinglecostAppExtraRefcostLam costLamUnfoldcostPicostSort costIotaStepcostInferredTypeUnkown costAbsurdLam costEqStep costEqEnd costEqSym costEqCongprioNoprioTypeUnknown prioTypecheckprioTypecheckArgListprioInferredTypeUnknown prioCompBetaprioCompBetaStructured prioCompIotaprioCompChoice prioCompUnif prioCompCopyprioCompareArgList prioNoIotaprioAbsurdLambda prioProjIndexCMFlex CMFBlockedCMFSemiCMFFlexCModeCMRigidPEvalPEConAppPENoHNResHNMetaHNDoneHNNBlkstcExp getDatatypeconstructorImpossibleunequalsunequal traversePitcargsaddendcopyargnoblksaddblkhnnhnn_blks hnn_checkstephnn'hnbhnc hnarglistgetNArgs getAllArgsiotastep noiotastepnoiotastep_termcomp'checkeliminandmaybeor iotapossmetameta_not_constructor calcEqRStatepickidtcSearchSolCSPatI CSOmittedArgCSAbsurdCSWithCSPatExpCSPatVar CSPatConAppCSCtxCSPatHI abspatvarnamecostCaseSplitVeryHighcostCaseSplitHighcostCaseSplitLowcostAddVarDepthdrophidcaseSplitSearchcaseSplitSearch' infertypevarreplace betareduce concatargseqelrreplaceprmmmunifyexplift removevarnotequalfindpermfreevars applypermrenrenamerenamepseqctx depthofvarlocalTerminationEnvlocalTerminationSidecondgetblksversionPrettypretty prettyPrecpwordsfwordsmparensalignLispQLConsAresponse putResponse display_info'clearRunningInfodisplayRunningInfo isSingleton transpose intersectWith CallGraphCallsourcetargetcm CallMatrixmatOrderMatincreasedecreasedecrorderMatleltunknown decreasing.*.supremuminfimumcallMatrixInvariant callInvariant>*<callGraphInvariantcompleteprettyBehaviourColumn RecBehaviourRBcolumnscallsLexOrderrecBehaviourInvariant fromDiagonalslexOrder terminatesterminatesFilter AbsolutePathfilePath mkAbsoluteabsolute===doesFileExistCaseSensitiveContwhen_unless_whenJustwhenMunlessM whenJustMifMand2MandMor2MorMaltM1mapM'forM'thread zipWithM' mapMaybeMfinallybracketbracket_ localStatereadM EitherOrBothRB unionWithMinsertWithKeyM filterKeysunzipunzip3GraphunGraph invariantedges edgesFromnodes fromNodes removeNode removeEdge filterEdgeslookup neighbourssccs'sccsacyclictransitiveClosure1transitiveClosurefindPathallPathsnodeInedgeInFlag OptionsPragma PragmaOptionsoptShowImplicitoptShowIrrelevant optVerboseoptProofIrrelevanceoptAllowUnsolvedoptDisablePositivityoptTerminationCheckoptTerminationDepthoptCompletenessCheckoptUniverseCheck optSizedTypesoptInjectiveTypeConstructorsoptGuardingTypeConstructorsoptUniversePolymorphismoptIrrelevantProjectionsoptExperimentalIrrelevance optWithoutK optCopatternsCommandLineOptionsOptionsoptProgramName optInputFileoptIncludeDirsoptShowVersion optShowHelpoptInteractive optRunTestsoptGHCiInteraction optCompileoptEpicCompile optJSCompile optCompileDiroptGenerateVimFileoptGenerateLaTeXoptGenerateHTMLoptDependencyGraph optLaTeXDir optHTMLDir optCSSFileoptIgnoreInterfaces optForcing optGhcFlagsoptPragmaOptions optEpicFlagsoptSafe Verbosity isLiteratemapFlagdefaultVerbositydefaultInteractionOptionsdefaultOptions checkOptsunsafePragmaOptionsstandardOptions_parseStandardOptionsparsePragmaOptionsparsePluginOptionsusage KillRange killRangeSetRangesetRangeHasRangegetRangeRangeRange'Interval Interval'iStartiEndPosition Position'PnsrcFileposPosposLineposColpositionInvariantintervalInvariantrangeInvariant killRange1 killRange2 killRange3 killRange4 killRange5 killRange6 killRange7startPosnoRangemovePosmovePosByString backupPostakeIdropI posToRangerangeToInterval continuouscontinuousPerLinerStartrEnd fuseRanges fuseRange beginningOfbeginningOfFile withRangeOfConstrNameIdArity IsAbstract ConcreteDef AbstractDefAccess OnlyQualified PublicAccess PrivateAccessIsInfix PrefixDefInfixDefNamedArgNamednameOf namedThingArg argHiding argRelevanceunArgDom domHiding domRelevanceunDom Relevance UnusedArgForced Irrelevant NonStrictRelevantHiding Induction CoInductive InductiveDelayed NotDelayed moreRelevant argFromDom domFromArg mapDomHidingmapDomRelevance mapArgHidingmapArgRelevance makeInstancehide defaultArg isHiddenArg withArgsFromunnamednamednamedArgdefaultNamedArgupdateNamedArgGlobalsglobalsUsesusesModulemodNameexportsExportexpNamedefnMemberIdGlobalIdLocalIdPreOpBinOpIfLookupApplyObjectLambdaDoubleIntegerCharString UndefinedGlobalLocalSelfPrettiesprettiesbrunescape unescapesblockblock'modnamemapshift shiftFromshiftersubst substitutermap'subst'applyselffix curriedApply curriedLambdaempvineobjectTagPattTaggedVarPattCasepatsbodynumVarsnumVars'lambdalambda'popmatchrefinevisittagstagParser identifier wordBoundarytokenpunctparenedbraced bracketedquoted stringLit stringStr stringChrescChrintLitundeflocalidglobalidpreopbinopfieldfunction bracedBlock returnBlockifBlockexp0exp1exp2exp2'exp3exp3'exptopLevelDistanceDistSizeExpr SizeConstSizeVarSolution LegendMatrixrowdescrcoldescrGM flexScopenodeMapintMapnextNodegraph Constraints ConstraintArcNewFlexScopeFlexIdRigidIdNodeIdRigidRVarRConstNodeFlexWeightInfiniteFiniteAdjListwarshall warshallGincinfiniteisBelowemptyConstraints initGraphaddFlexaddNodeaddEdge addConstraint buildGraphmkMatrix emptySolutionextendSolution sizeRigidsolvegenGraph genGraph_ lookupEdge prop_smallernewEdgegenPath prop_pathmapNodes prop_disjoint prop_stableTopLevelModuleNamemoduleNamePartsQNameQualNamePartHoleNameNoNamenoName_noNameisNoName isOperator namePartsnameStringPartsqualify unqualify qnamePartstoTopLevelModuleNamemoduleNameToFileName projectRootisHoleisPrefix isPostfixisInfixisNonfixModuleToSourceRangesfromtorangesInvariant overlappingrangeToPositionsrangesToPositionsrToRminusGenPartIdPart NormalHoleBindHoleNotationHoleNameExprHole LambdaHoleholeName stringParts holeTargetisAHole isBindingHole isLambdaHole mkNotationdefaultNotation noNotation Precedence DotPatternCtx WithArgCtx WithFunCtxInsideOperandCtx ArgumentCtx FunctionCtxRightOperandCtxLeftOperandCtxFunctionSpaceDomainCtxTopCtxFixityNonAssoc RightAssoc LeftAssoc NewNotationThingWithFixityFixity' theFixity theNotationoldToNewNotationsyntaxOfdefaultFixity'noFixity fixityLevel defaultFixityhiddenArgumentCtx opBrackets lamBrackets appBracketswithAppBrackets piBracketsroundFixBracketsAmbiguousQNameAmbQunAmbQ ModuleNameMName mnameToListQNamedqnameqnamed qnameModule qnameNamenameId nameConcretenameBindingSite nameFixityisAnonymousModuleName withRangesOf withRangesOfQ mnameFromList noModuleNamemkNamemkName_ qnameToList qnameFromList qnameToMName mnameToQName showQNameIdqnameToConcretemnameToConcretequalifyMqualifyQ isSubModuleOf isInModule freshName freshName_ freshNoName freshNoName_nextNameLiteralLitQNameLitChar LitStringLitFloatLitIntAppViewPragmaNoTerminationCheckPragma EtaPragmaImpossiblePragma ImportPragma StaticPragmaCompiledJSPragmaCompiledEpicPragmaCompiledPragmaCompiledTypePragmaCompiledDataPragma BuiltinPragma OpenShortHandDontOpenDoOpenModuleApplicationRecordModuleIFS SectionApp Declaration ModuleMacroImportOpen PrimitivePrivateAbstractMutual PatternSynSyntaxInfixRecord RecordSigDataSig FunClauseFieldTypeSig TypeSignatureAsNameasNameasRangeRenamingrenFromrenTo renToRange ImportedNameImportedModule importedName UsingOrHidingUsingImportDirectiveimportDirRange usingOrHidingrenaming publicOpen WhereClause SomeWhereAnyWhereNoWhereRHS AbsurdRHSLHSCoreLHSProj lhsDestructor lhsPatsLeftlhsFocus lhsPatsRightLHSHead lhsDefNamelhsPatsWithExpr RewriteEqnEllipsislhsOriginalPatternlhsWithPattern lhsRewriteEqn lhsWithExpr Telescope TypedBindingTNoBindTBind BoundNameBName boundName bnameFixity TypedBindings LamBinding DomainFull DomainFreePatternLitPDotPAsPAbsurdPWildPParenP InstancePHiddenPOpAppPRawAppPAppPIdentPExprDontCareUnquote QuoteTermQuote QuoteGoalETelDotAsAbsurdParenLet RecUpdateRecSetNFun ExtendedLam AbsurdLam InstanceArg HiddenArgWithAppOpAppRawApp Underscore QuestionMarkLitIdentOrdinarySyntaxBindingLambda fromOrdinary mkBoundName_defaultImportDirtopLevelModuleNameappView patternHead patternNamesCompressedFilerangesHighlightingInfoFileMetaInfoaspect otherAspectsnotedefinitionSite OtherAspect TypeChecksIncompletePatternTerminationProblemUnsolvedConstraint UnsolvedMeta DottedPatternNameKindFunctionBoundAspect PrimitiveTypeSymbolNumberKeywordCommentseveral smallestPostoMapcompressedFileInvariantcompress decompress singletonCseveralCsplitAtC smallestPosCbraces'dbracesarrow underscorepHidden pRelevance showString' showChar'smashTel prettyOpAppTokenTokEOFTokDummy TokCommentTokTeXTokSetN TokString TokSymbol TokLiteralTokQIdTokId TokKeyword SymDotDot SymEllipsisSymClosePragma SymOpenPragmaSymCloseVirtualBraceSymOpenVirtualBrace SymCloseBrace SymOpenBraceSymDoubleCloseBraceSymDoubleOpenBrace SymCloseParen SymOpenParenSymAsSymQuestionMark SymUnderscore SymLambdaSymEqualSymArrowSymColonSymBarSymVirtualSemiSymSemiSymDot KwPatternSynKwSyntax KwUnquote KwQuoteTermKwQuote KwQuoteGoalKwSTATICKwNO_TERMINATION_CHECKKwETA KwIMPOSSIBLEKwIMPORT KwCOMPILED_JSKwCOMPILED_EPIC KwCOMPILEDKwCOMPILED_TYPEKwCOMPILED_DATAKwLINE KwBUILTIN KwOPTIONSKwPublicKwTo KwRenamingKwUsingKwHiding KwCoInductive KwInductiveKwField KwConstructorKwRecordKwForallKwPropKwSet KwRewriteKwWithKwInfixRKwInfixLKwInfix KwPrimitiveKwModuleKwImportKwOpen KwPrivate KwAbstractKwMutual KwPostulateKwCoDataKwDataKwWhereKwInKwLetlayoutKeywordsCNameSplitTreeLabellblConstructorName lblSplitArg lblBindings SplitTrees' SplitTree'SplitAtsplitArg splitTrees SplittingDone splitBindings SplitTrees SplitTreetoTreetoTreestestSplitTreePrintingAbstractModule AbsModuleamodName AbstractNameAbsName anameName anameKind KindOfNamePatternSynNameDefNameFldNameConNameInScope inScopeTag InScopeTag ModuleTagNameTagModulesInScope NamesInScope ThingsInScope NameSpacensNames nsModules LocalVars ScopeInfo scopeCurrent scopeModules scopeLocalsscopePrecedence NameSpaceIdOnlyQualifiedNS ImportedNSPublicNS PrivateNS scopeName scopeParentsscopeNameSpaces scopeImportsscopeDatatypeModulelocalNameSpacenameSpaceAccessscopeNameSpace inNameSpaceallKindsOfNames blockOfLines mergeNamesemptyNameSpace mapNameSpace zipNameSpace mapNameSpaceM emptyScopeemptyScopeInfomapScope mapScope_ mapScopeM mapScopeM_zipScope zipScope_ filterScopeallNamesInScopeallNamesInScope'exportedNamesInScope namesInScopeallThingsInScope thingsInScope mergeScope mergeScopessetScopeAccess setNameSpaceaddNamesToScopeaddNameToScopeaddModuleToScopeapplyImportDirectiverenameCanonicalNamesrestrictPrivateremoveOnlyQualified publicModuleseverythingInScope flattenScope scopeLookup scopeLookup'inverseScopeLookupinverseScopeLookupNameinverseScopeLookupModuledontDescendIntoinstanceUniverseBiT'instanceTransformBiMT'ConPVarP ClauseBodyNoBodyBindBody clauseRange clauseTel clausePerm clausePats clauseBody NotBlockedMetaId LevelAtomUnreducedLevel NeutralLevel BlockedLevel MetaLevel PlusLevelPlus ClosedLevelLevelMaxDLubInfTele ExtendTelEmptyTelElgetSortunElNoAbsabsNameunAbsElimProjArgsSharedMetaVCon patternVarsproperlyMatching ignoreSharingignoreSharingTypeshared sharedTypeupdateSharedFM updateSharedM updateShared pointerChaincompressPointerChainvar typeDontCaretopSortset0setpropsortvarSortsSuclevelSucmkTypeimpossibleTerm blockingMetablocked notBlockedignoreBlocking stripDontCarearityargNameFree OccurrenceUnusedFlexible WeaklyRigid StronglyRigid Irrelevantly NoOccurrenceFreeVarsFVstronglyRigidVarsweaklyRigidVars flexibleVarsirrelevantVars unusedVars rigidVarsallVars relevantVars occurrencefreeVarsfreeInfreeInIgnoringSortsfreeInIgnoringSortAnnrelevantInIgnoringSortAnn relevantIn isBinderUsed EInterface constrTags definitions defDelayedconAritymainName relevantArgs forcedArgs injectiveFuns InjectiveFuninjArginjArity RelevantArgs ForcedArgsRelIrr NotForcedPrimTagpairwiseFilter notForcedforcedBranchDefaultBrIntbrIntbrTagbrNamebrVarsbrExpr IMPOSSIBLEUNITLazyLFloatLStringLCharLIntEpicFun funEpicCode funInlinefunNamefunQName funCommentfunArgsfunExprInline getBrVarslettlazycaseeappssubsts substBranchfvCompiledClausesFailDoneBranches conBranches litBranchescatchAllBranch WithAritycontent:-> emptyBrancheslitCaseconCasecatchAllTermLike traverseTerm traverseTermMfoldTermcopyTermOneHolePatternOHConOneHolePatternsOHPatsplugHoleallHolesallHolesWithContentsMatchLit BlockingVars BlockingVarMatchBlockNoYesMPatWildMPLitMPConMPVarMPzipBlockingVars noMatchLit yesMatchLit matchLits matchClause matchPatsmatchPatPatInfo PatSourcePatRangeLHSInfoLHSRange MutualInfomutualTermCheck mutualRangeDeclInfodeclName declRangeDefInfo defFixity defAccess defAbstractdefInfoLetInfoLetRange ModuleInfo minfoRange minfoAsTo minfoAsNameminfoOpenShortminfoDirectiveExprInfo ExprSource ExprRange metaRange metaScope metaNumbermetaNameSuggestionInfoNope emptyMetaInfo mkDefInfoPatternsPattern' PatternSynP ImplicitPDefPLHSCore'lhsInfolhsCore lhsWithPatsSpineLHS spLhsInfo spLhsDefName spLhsPats spLhsWithPats RewriteRHSWithRHS clauseLHS clauseRHSclauseWhereDecls LetBindingLetOpenLetApply LetPatBindLetBind GetDefInfo getDefInfo ScopedDeclRecDefRecSigDataDefFunDefSectionAxiom ScopedExpr lhsToSpinelhsCoreToSpinelhsCoreAllPatternslhsCoreToPattern mapLHSHeadPatternSynDefnsPatternSynDefn AnyAbstract anyAbstractallNames axiomNameapp patternToExprlambdaLiftExpr substPattern substExprsubstLetBindingsubstTypedBindingssubstTypedBinding Application unAppViewisSetNiceDeclarationExceptionInvalidNoTerminationCheckPragmaAmbiguousFunClausesUselessAbstractUselessPrivateDeclarationPanicCodataUnknownNamesInFixityDeclNotAllowedInMutualWrongParametersWrongDefinitionMissingDataSignatureMissingTypeSignatureMissingWithClausesMissingDefinitionMultipleFixityDeclsNiceTypeSignatureNiceConstructorNiceDeclarationNicePatternSynFunSig NiceFunClause NiceDataSig NiceRecSig NicePragma NiceImportNiceOpenNiceModuleMacro NiceModule NiceMutualPrimitiveFunction NiceFieldrunNiceniceDeclarationsnotSoNiceDeclarationIsExprexprView unExprViewExprViewParenVLamV InstanceArgV HiddenArgVOpAppVAppVOtherVWildVLocalV recursivechainr1'chainl1'partPpostopopPrebuildrebuildBinding$$$prefixPpostfixPinfixlPinfixrPinfixPnonfixPappPatomP ParseResult ParseFailedParseOk ParseErrorerrPoserrInput errPrevTokenerrMsg ParseFlagsparseKeepComments LayoutContextLayoutNoLayoutLexState ParseStatePStateparsePos parseLastPosparseInp parsePrevCharparsePrevToken parseLayout parseLexState parseFlags initStatedefaultParseFlagsparsePosString parseFile setParsePos setLastPos setPrevTokengetParseInterval getLexState pushLexState popLexState getParseFlags parseError parseErrorAtlexError topContext popContext pushContextpushCurrentContext LexPredicate LexAction TokenLength CurrentInput PreviousInput AlexInputlexPoslexInput lexPrevCharalexInputPrevChar alexGetChar alexGetByte getLexInput setLexInput.&&..||.not' emptyLayoutnewLayoutContext offsideRule LookAheadgetInputsetInputnextCharsyncrollback eatNextCharmatch' runLookAheadinStateeof followedByliteralsymbolkeywordend_begin_endWithbegin withLayout withInterval' withIntervallexToken keepComments keepCommentsM nestedCommenthole skipBlock litStringlitChar AlexReturn AlexTokenAlexSkip AlexErrorAlexEOFliteratenormallayout empty_layoutbolimp_dirlexercode alexScanUser withInterval_end openBrace closeBrace tokensParser exprParser moduleParser parseLiterate parseFile'handleParseExceptionfailOnExceptionMonadTCMliftTCMunTCMTCErr PatternErr IOException Exception TypeError LHSOrPatSynIsPatSynIsLHSNeedOptionCopatternsSafeFlagPrimTrustMeSafeFlagNoTerminationCheckSafeFlagPragmaSafeFlagPostulateIFSNoCandidateInScopeAmbiguousParseForLHS NoParseForLHSAmbiguousParseForApplicationNoParseForApplicationPatternSynonymArityMismatchUnusedVariableInPatternSynonymNothingAppliedToInstanceArgNothingAppliedToHiddenArgNotAValidLetBindingNotAnExpressionNotAModuleExprRepeatedVariablesInPatternInvalidPatternDuplicateImportsModuleDoesntExportPatternShadowsConstructorClashingModuleImportClashingImportClashingModuleClashingDefinitionUninstantiatedModuleAmbiguousModule AmbiguousName NoSuchModule NotInScopeBothWithAndRHSModuleDefinedInOtherFileClashingFileNamesForModuleNameDoesntMatchFileNameAmbiguousTopLevelModuleNameOverlappingProjects FileNotFoundCyclicModuleDependencyUnsolvedConstraints UnsolvedMetasLocalVsImportedModuleClashNotStrictlyPositiveCoverageCantSplitTypeCoverageCantSplitIrrelevantTypeCoverageCantSplitOnUnreachableClausesCoverageFailureIncompletePatternMatchingModuleArityMismatchFieldOutsideRecordWithClausePatternMismatchUnexpectedWithPatternsDuplicateConstructorsDuplicateFields TooManyFields TooFewFieldsAbsurdPatternRequiresNoRHSNoRHSRequiresAbsurdPatternBuiltinInParameterisedModuleShadowedModuleNoSuchPrimitiveFunctionNoBindingForBuiltinDuplicateBuiltinBindingNoSuchBuiltinNameBuiltinMustBeConstructorGenericDocError GenericErrorMetaOccursInItselfMetaCannotDependOn NotLeqSortHeterogeneousEquality UnequalBecauseOfUniverseConflict UnequalSorts UnequalHidingUnequalRelevanceUnequalTelescopes UnequalTypes UnequalTerms UnequalLevelVariableIsIrrelevantDefinitionIsIrrelevantSplitOnIrrelevantSetOmegaNotValidTypeNotAProperTermShouldBeRecordPatternShouldBeRecordType ShouldBePi ShouldBeASort ShouldBeEmpty!WrongNumberOfConstructorArgumentsTooManyArgumentsInLHSIlltypedPatternUninstantiatedDotPattern NotInductiveWrongIrrelevanceInLambdaWrongHidingInApplicationWrongHidingInLambdaWrongHidingInLHSDifferentAritiesDoesNotConstructAnElementOfIndicesFreeInParametersIndexVariablesNotDistinct!IndicesNotConstructorApplications!ConstructorPatternInWrongDatatypeShouldBeApplicationOf&ShouldBeAppliedToTheDatatypeParameters#ShouldEndInApplicationOfTheDatatypeDataMustEndInSortPropMustBeSingletonTerminationCheckFailedCompilationError NotSupportedNotImplemented InternalErrorTerminationErrortermErrFunctions termErrCallsCallInfo callInfoRange callInfoCallOccPos ArgumentTo NonPositivelyOcc OccClause occFunction occClauseOccCon occDatatypeoccConstructor occPositionExpandInstancesDontExpandInstanceArgumentsExpandInstanceArguments ExpandHiddenDontExpandLast ExpandLast AbstractModeIgnoreAbstractMode ConcreteMode LetBindingsCtxId ContextEntryctxIdctxEntryContextTCEnv envContextenvLetBindingsenvCurrentModuleenvCurrentPathenvAnonymousModules envImportPathenvMutualBlockenvSolvingConstraintsenvAssignMetasenvActiveProblemsenvAbstractMode envRelevanceenvDisplayFormsEnabledenvReifyInteractionPointsenvEtaContractImplicitenvRangeenvHighlightingRangeenvCallenvEmacsenvHighlightingLevelenvHighlightingMethodenvModuleNestingLevelenvAllowDestructiveUpdateHighlightingMethodIndirectDirectHighlightingLevel InteractiveNonInteractiveNoneBuiltinPrim BuiltinThings BuiltinInfo builtinName builtinDescBuiltinDescriptorBuiltinUnknownBuiltinPostulate BuiltinPrimBuiltinDataCons BuiltinDataNoHighlighting ScopeCheckLHSScopeCheckDeclarationScopeCheckExprCheckSectionApplicationCheckWithFunctionType CheckIsEmptyCheckPrimitive CheckPragma CheckFunDefCheckConstructor CheckRecDef CheckDataDefCheckArgumentsInferDefInferVarIsType_ IsTypeCallCheckPatternShadowingCheckDotPattern CheckExpr InferExprCheckLetBinding CheckPattern CheckClause StatisticsMutualIdMutIdTermHeadConHeadPiHeadSortHeadFunctionInverse'Inverse NotInjectiveFunctionInversePrimFun primFunName primFunArityprimFunImplementationMaybeReducedArgs MaybeReducedMaybeRed isReduced ignoreReduced IsReducedReduced NotReduced YesReduction NoReductionFieldsDefn primAbstrprimName primClauses primCompiledconPars conSrcConconDataconAbstrconIndrecPars recClauserecCon recNamedCon recConType recFieldsrecTel recMutualrecEtaEquality recInduction recRecursiverecAbstrdataParsdataIxs dataInduction dataClausedataConsdataSort dataMutual dataAbstr funClauses funCompiledfunInv funMutualfunAbstr funDelayed funProjection funStaticfunCopy funTerminatesGuardPos StrictPosJustPosJustNegMixedCompiledRepresentation CompiledRepcompiledHaskell compiledEpic compiledJSPolarity Nonvariant Invariant Contravariant CovariantHaskellRepresentationHsTypeHsDefnJSCodeEpicCode HaskellType HaskellCode Definition defRelevancedefNamedefType defPolaritydefArgOccurrences defDisplay defMutualdefCompiledReptheDef DisplayTermDTermDDotDDefDConDWithApp DisplayFormDisplay secTelescope secFreeVars DefinitionsSections SignatureSig sigSectionssigDefinitions InteractionIdInteractionPoints MetaStore NamedMeta nmSuggestionnmidMetaNameSuggestion miClosRangemiMetaOccursCheckmiNameSuggestionRunMetaOccursCheckDontRunMetaOccursCheck MetaPriorityMetaInstantiationPostponedTypeCheckingProblem BlockedConstOpenIFSInstSInstVFrozen InstantiableListenerCheckConstraint EtaExpand MetaVariableMetaVarmvInfo mvPriority mvPermutation mvJudgementmvInstantiation mvListenersmvFrozen JudgementIsSortHasTypejMetaId jMetaType OpenThing ComparisonCmpLeqCmpEq FindInScopeIsEmptyGuardedUnBlockLevelCmpSortCmpTelCmpTypeCmpElimCmpValueCmpProblemConstraintPConstrconstraintProblem theConstraintClosure clSignatureclEnvclScopeclValue InterfaceiImportedModules iModuleNameiScope iInsideScope iSignatureiBuiltiniHaskellImports iHighlightingiPragmaOptions iPatternSynsDecodedModulesVisitedModules miInterface miWarnings miTimeStamp ProblemId FreshThingsFreshfMeta fInteractionfMutualfNamefCtxfProblemfIntPersistentTCStatePersistentTCStstDecodedModulesstPersistentOptionsTCStateTCSt stFreshThings stSyntaxInfostTokens stTermErrs stMetaStorestInteractionPointsstAwakeConstraintsstSleepingConstraintsstDirtystOccursCheckDefs stSignature stImportsstImportedModulesstModuleToSourcestVisitedModulesstCurrentModulestScope stPatternSynsstPatternSynImportsstPragmaOptions stStatisticsstExtLambdaTelestMutualBlocksstLocalBuiltinsstImportedBuiltinsstHaskellImports stPersistentstInteractionOutputCallbackstBuiltinThings buildClosurenormalMetaPrioritylowMetaPriorityhighMetaPriority getMetaInfo getMetaScope getMetaEnv getMetaSiggetMetaRelevanceemptySignaturedefaultDisplayForm noCompiledRep defIsRecorddefIsDataOrRecord notReducedreduced defClauses defCompileddefJSDef defEpicDefdefCopy ifTopLevelAndHighlightingLevelIsinitEnv catchError_mapTCMTpureTCM returnTCMTbindTCMTthenTCMTfmapTCMTapTCMTpatternViolation internalError typeErrorrunTCMrunTCM'forkTCMextendlambdanamescopeCheckImport prettyError ConditionnewNamedValueMeta newValueMeta newIFSMetaassignassignVetaExpandMetaSafe assignTerm newArgsMeta newArgsMeta'TelViewTelVSubst applySubst SubstitutionLift:#WkEmptySIdSabstractpiApplytelVars abstractArgsidSwkSraiseS singletonSdropScomposeSsplitS++# parallelSlookupSraise raiseFrom substUnder telFromList telToListtelView'mkPitelePitelePi_teleLamdLubabsAppabsBodymkAbsreAbsunderAbs underLambdassLublvlViewlevelMaxsortTm levelSortlevelTm unLevelAtom AbstractTerm abstractTermpiAbstractTermhighlightAsTypeCheckedCoinductionKit nameOfInf nameOfSharp nameOfFlatlitTypegetBuiltinThingsetBuiltinThingsbindBuiltinName bindPrimitive getBuiltin getBuiltin' getPrimitive primInteger primFloatprimChar primStringprimBoolprimTrue primFalseprimListprimNilprimConsprimIOprimNatprimSucprimZero primNatPlus primNatMinus primNatTimesprimNatDivSucAuxprimNatModSucAuxprimNatEquality primNatLessprimSize primSizeLt primSizeSuc primSizeInf primSizeMaxprimInf primSharpprimFlat primEqualityprimRefl primLevel primLevelZero primLevelSuc primLevelMax primIrrAxiom primQNameprimArg primArgArg primAgdaSort primAgdaTypeprimAgdaTypeEl primHiding primHidden primInstance primVisible primRelevance primRelevantprimIrrelevantprimAgdaSortSetprimAgdaSortLitprimAgdaSortUnsupported primAgdaTermprimAgdaTermVarprimAgdaTermLamprimAgdaTermDefprimAgdaTermConprimAgdaTermPiprimAgdaTermSortprimAgdaTermUnsupportedprimAgdaFunDefprimAgdaDataDefprimAgdaRecordDefprimAgdaDefinitionFunDefprimAgdaDefinitionDataDefprimAgdaDefinitionRecordDef!primAgdaDefinitionDataConstructorprimAgdaDefinitionPostulateprimAgdaDefinitionPrimitiveprimAgdaDefinition builtinNat builtinSuc builtinZerobuiltinNatPlusbuiltinNatMinusbuiltinNatTimesbuiltinNatDivSucAuxbuiltinNatModSucAuxbuiltinNatEqualsbuiltinNatLessbuiltinInteger builtinFloat builtinChar builtinString builtinBool builtinTrue builtinFalse builtinList builtinNil builtinCons builtinIO builtinSize builtinSizeLtbuiltinSizeSucbuiltinSizeInfbuiltinSizeMax builtinInf builtinSharp builtinFlatbuiltinEquality builtinReflbuiltinLevelMax builtinLevelbuiltinLevelZerobuiltinLevelSucbuiltinIrrAxiom builtinQNamebuiltinAgdaSortbuiltinAgdaSortSetbuiltinAgdaSortLitbuiltinAgdaSortUnsupportedbuiltinAgdaTypebuiltinAgdaTypeEl builtinHiding builtinHiddenbuiltinInstancebuiltinVisiblebuiltinRelevancebuiltinRelevantbuiltinIrrelevant builtinArg builtinArgArgbuiltinAgdaTermbuiltinAgdaTermVarbuiltinAgdaTermLambuiltinAgdaTermDefbuiltinAgdaTermConbuiltinAgdaTermPibuiltinAgdaTermSortbuiltinAgdaTermUnsupportedbuiltinAgdaFunDefbuiltinAgdaDataDefbuiltinAgdaRecordDefbuiltinAgdaDefinitionFunDefbuiltinAgdaDefinitionDataDefbuiltinAgdaDefinitionRecordDef$builtinAgdaDefinitionDataConstructorbuiltinAgdaDefinitionPostulatebuiltinAgdaDefinitionPrimitivebuiltinAgdaDefinitioncoinductionKitgetIncludeDirsifNoConstraints_ noConstraintssolveAwakeConstraints'solveConstraint getContextId getContext resetState resetAllStatesetScopegetScopegetPatternSynssetPatternSynsmodifyPatternSynsgetPatternSynImportslookupPatternSynsetExtLambdaTelegetExtLambdaTeleaddExtLambdaTele modifyScope withScope withScope_ localScopesetTopLevelModulewithTopLevelModuleaddHaskellImportgetHaskellImportsRangeAndPragma DontTouchMe ToConcrete toConcretebindToConcreteAbsToConEnvmakeEnv noTakenNames runAbsToConabstractToConcreteabstractToConcreteCtxabstractToConcrete_ toConcreteCtxticktickNtickMax getStatisticsgetConstructorData matchCompiledinitializeIFSMeta composePolcomputePolarityMonadExceptionthrowExceptioncatchException ExceptionT runExceptionT currentModulewithCurrentModulegetAnonymousVariableswithAnonymousModulewithEnvgetEnvwithIncreasedModuleNestingLevelmakeOpen makeClosedgetOpentryOpenmodifyContextEntrymodifyContextEntries modifyContextmkContextEntry inContext inTopContext escapeContextescapeContextToTopLeveladdCtx addContextaddCtxs addCtxString addCtxString_dummyDomunderAbstractionunderAbstraction_ addCtxTel addLetBindinggetContextSizegetContextArgsgetContextTermsgetContextTelescope typeOfBV'typeOfBVnameOfBV!!! getVarInfo addImportaddImportCycleCheck getImports isImported getImportPath visitModulesetVisitedModulesgetVisitedModules isVisitedgetVisitedModulegetDecodedModulessetDecodedModulesgetDecodedModulestoreDecodedModuledropDecodedModulewithImportPathcheckForImportCycle noMutualBlock inMutualBlocksetMutualBlockgetMutualBlockscurrentOrFreshMutualBlocklookupMutualBlockfindMutualBlockmakeProjectionSourceToModule FindError AmbiguousNotFoundtoIFilefindErrorToTypeErrorfindFile findFile' findFile''findInterfaceFilecheckModuleName moduleName' moduleNamesourceToModule GiveResult Give_NoParen Give_Paren Give_StringStatussShowImplicitArgumentssChecked DisplayInfo Info_ContextInfo_InferredTypeInfo_CurrentGoal Info_GoalTypeInfo_NormalFormInfo_ModuleContents Info_Auto Info_Intro Info_Error Info_AllGoalsInfo_ConstraintsInfo_CompilationOkResp_ClearHighlightingResp_ClearRunningInfoResp_RunningInfoResp_DisplayInfo Resp_SolveAll Resp_MakeCaseResp_MakeCaseActionResp_GiveActionResp_InteractionPointsResp_JumpToError Resp_StatusResp_HighlightingInfo VerboseKey RelativeTo CurrentDir ProjectRootsetPragmaOptionssetCommandLineOptions pragmaOptionscommandLineOptionssetOptionsFromPragmaenableDisplayFormsdisableDisplayFormsdisplayFormsEnableddontEtaContractImplicitdoEtaContractImplicitshouldEtaContractImplicitdontReifyInteractionPointsshouldReifyInteractionPointssetIncludeDirs setInputFile getInputFile hasInputFileproofIrrelevancehasUniversePolymorphismshowImplicitArgumentsshowIrrelevantArgumentswithShowAllArgumentsignoreInterfacespositivityCheckEnabled typeInType getVerbosity hasVerbosityemacsifyDebugMessagedisplayDebugMessageverboseSreportS reportSLn reportSDocverboseBracketWSMOutRen ResolvedName UnknownNamePatternSynResNameConstructorName FieldName DefinedNameVarNameScopeM notInScopeisDatatypeModulegetCurrentModulesetCurrentModulewithCurrentModule' getNamedScopegetCurrentScope createModulemodifyScopeInfo modifyScopesmodifyNamedScopemodifyCurrentScopemodifyNamedScopeMmodifyCurrentScopeMmodifyCurrentNameSpacesetContextPrecedencegetContextPrecedencewithContextPrecedence getLocalVars setLocalVars withLocalVarsfreshAbstractNamefreshAbstractName_freshAbstractQName resolveName resolveModule getFixity bindVariablebindName bindModule bindQModule stripNoNames copyScopeapplyImportDirectiveM openModule_translateCopatternClausesupdateSharedTermupdateSharedTermFupdateSharedTermTforceEqualTermsdisableDestructiveUpdate UseBoundNamesDontUseBoundNamesgetDefinedNames buildParserpatternAppViewparsePatparseLHS parsePatternparsePatternSynvalidConPattern patternQNamesqualifierModulesparseApplication fullParenparenmparen SizeMaxViewSizeViewComparableYesBelowYesAbove NotComparable DeepSizeView DOtherSize DSizeMetaDSizeVarDSizeInfOffsetSizeView OtherSizeSizeSucSizeInf BoundedSize BoundedNo BoundedLt isSizeTypeisSizeTypeTestgetBuiltinDefNamegetBuiltinSizeisSizeNameTestisSizeNameTestRawsizeType sizeSucNamesizeSucsizeSuc_sizeMaxsizeViewsizeViewComparable sizeViewSuc_ sizeViewPredsizeViewOffset removeSucs unSizeViewunDeepSizeView maxViewMax maxViewConssizeViewComparableWithMax maxViewSuc_ unMaxViewinterestingCall traceCallM traceCall traceCall_ traceCallCPS traceCallCPS_getCurrentRangesetCurrentRangecheckArguments checkExprisType_modifySignaturemodifyImportedSignature getSignaturegetImportedSignature setSignaturesetImportedSignature withSignatureupdateDefinition updateTheDef updateDefTypeupdateDefArgOccurrencesupdateDefPolarityupdateDefCompiledRep addConstant setTerminatesaddHaskellCodeaddHaskellType addEpicCode addJSCode markStaticunionSignatures addSection lookupSectionaddDisplayForms applySectionaddDisplayForm canonicalName whatInductionsingleConstructorType getConstInfo getPolarity getPolarity' setPolaritygetArgOccurrencesgetArgOccurrencesetArgOccurrences getMutual setMutualmutuallyRecursivegetSecFreeVarsgetModuleFreeVarsgetDefFreeVarsfreeVarsToApplyinstantiateDef makeAbstractinAbstractModeinConcreteModeignoreAbstractModetreatAbstractlytreatAbstractly' typeOfConst relOfConst sortOfConst isProjection enterClosurecurrentProblemstealConstraintssolvingProblemisProblemSolvedgetConstraintsForProblemgetAwakeConstraintswakeConstraintsdropConstraintsputAllConstraintsToSleeptakeAwakeConstraintgetAllConstraintswithConstraintbuildProblemConstraintbuildConstraintaddConstraint'addAwakeConstraintsnowSolvingConstraintsisSolvingConstraintsdontAssignMetas getMetaStoremodifyMetaStore lookupMeta updateMetaVargetMetaPriority isSortMeta getMetaTypeisInstantiatedMetacreateMetaInfocreateMetaInfo'setValueMetaNamegetMetaNameSuggestionsetMetaNameSuggestionupdateMetaVarRangeaddInteractionPointremoveInteractionPointgetInteractionPointsgetInteractionMetasisInteractionMetalookupInteractionIdjudgementInteractionIdnewMeta'getInteractionRange getMetaRangegetInteractionScope withMetaInfo' withMetaInfogetInstantiatedMetas getOpenMetas listenToMetaunlistenToMetagetMetaListenersclearMetaListeners freezeMetas unfreezeMetasisFrozenshowAprettyAshowATop prettyATop LeftHandSide AbstractRHS RightHandSideLetDefLetDefs TopLevelInfo topLevelDecls outsideScope insideScopeTopLevel OldModuleNameNewModuleQName NewModuleNameAPatNamePatNameOldNameOldQNameNewName ToAbstract toAbstractconcreteToAbstract_concreteToAbstractlocalToAbstractIMreadlinerunIMDotMDotState dsModules dsNameSupply dsConnectioninitialDotState addModule addConnectiondottify generateDottermleqType equalSort equalType equalTerm compareSort compareTel compareType compareElims compareArgs compareAtom compareTermisGeneratedRecordConstructoretaContractRecordgetRecordFieldNames isEtaRecordisRecord BinAppViewNoApp binAppView etaContractetaOnceirrelevantOrUnusedunusableRelevancecomposeRelevanceinverseComposeRelevance ignoreForcedirrToNonStrictnonStrictToIrrhideAndRelParamsinverseApplyRelevanceapplyRelevance workOnTypes doWorkOnTypes workOnTypes'applyRelevanceToContextwakeIrrelevantVars prop_galois PrettyTCM prettyTCM$$<+><>sepvcathsepfseptext callCompiler callCompiler' generateLaTeX levelViewvimFileescapematchestoVimgenerateVimFileDropArgsdropArgsbindBuiltinFlatbindBuiltinSharpbindBuiltinInfcheckSectionApplication checkDecl checkDecls checkFunDef' checkFunDef isEmptyType compareLevelDontKnow matchPatternsInstantiateFullinstantiateFull Normalise normaliseReducereducereduceB Instantiate instantiatetraceFun traceFun' ifBlocked ifBlockedTypeunfoldDefinition reduceDefCopy reduceDef reduceDef_appDefappDef'SplitTel firstPart secondPart splitPermrenameP renamingR flattenTel reorderTel reorderTel_ unflattenTel teleNames teleArgNamesteleArgssplitTelescopetelView telViewUpTo telViewUpTo'piApplyMCompile CompileState nameSupplycompiledModules curModuleimportedModulescurFuninitCompileState epicErrormodifyEIgetsEIgetTypeunqnameresetNameSupply getDelayed putDelayednewName putConstrTagassignConstrTagassignConstrTag' getConData getDataCon getConstrTag getConstrTag' addDefName topBindings getConArity putConArityputMaingetMain lookInterface constrInScope getForcedArgs putForcedArgs replaceAtconstructorAritybindExprcaseOpts caseOptsExpr getNatishisNatishnrRelisRecargIsDef PrimTransformPrimTFmapCon translateCaseprZeroprSucprTrueprFalseprPred prNatEquality primitivise initialPrims getBuiltinshead'' natPrimTF primNatCaseZS primNatCaseZD boolPrimTFprimFunprimExprLevelKitlvlTypelvlSuclvlMaxlvlZerotypeNamesucNamemaxNamezeroNamelevelSucFunctionbuiltinLevelKit requireLevelsunLevelreallyUnLevelView maybePrimCon maybePrimDeflevelLub displayFormmatchDisplayForm DataOrRecordIsRecordIsDatagetConstructorArity isDatatypeisDataOrRecordTypeisDataOrRecordgetNumberOfParameters NamedClauseReifyreify ReifyWhen reifyWhen reifyPatterns MentionsMeta mentionsMetaImplicitInsertionNoInsertNeeded NoSuchName BadImplicits ImpInsert implicitArgs impInsertinsertImplicitElimViewNoElimMetaElimConElimDefElimVarElimelimView PrettyContextDoccommacolonequals$+$nestbracesbracketsparens prettyList punctuateWarningsterminationProblemsunsolvedMetaVariablesunsolvedConstraintswarningsToError tcErrStringlispifyHighlightingInfoEmbPrjencodedecode encodeFile decodeFileSizeConstraintLeqSizeMetabuiltinSizeHook deepSizeView sizeMaxView trySizeUniv compareSizescompareMaxViewscompareBelowMaxcompareSizeViews isBoundedtrivialboundedSizeMetaHook isSizeProblemisSizeConstraintgetSizeConstraints getSizeMetascomputeSizeConstraintscomputeSizeConstraintsizeExprflexibleVariableshaveSizedTypescanonicalizeSizeConstraintsolveSizeConstraints orderFields recordModule getRecordDeffindPossibleRecordsgetRecordFieldTypesgetRecordTypeFieldsgetRecordConstructorTypegetRecordConstructorisInductiveRecordisEtaRecordTypeisRecordConstructorunguardedRecordrecursiveRecordetaExpandRecordisSingletonRecord isSingletonRecordModuloRelevanceisSingletonRecord'isSingletonTypeisSingletonTypeModuloRelevanceisSingletonType'emap HaskellKindhsStarhsKFunhsFunhsUnithsVarhsApphsForallnotAHaskellKindnotAHaskellType getHsTypegetHsVar isHaskellKind haskellKind haskellTypemakeForcedArgs forceConstrsforceFun prettyEpicFun prettyEpicErasure ErasureState relevanciesfunsisIrrisRel||-&&-erasure removeUnusedinitiate initialRelsrelevantstepdiffnormaliseStatic evaluateCC etaExpand evaluateTermfromAgda translateDefn reverseCCBody substTermsubstLitTagseqGroups constrGroupTagEqIsTagSameInjConstraints findInjection replaceFunCC isInjectiveremAbsisNoBody patternToTermnrBinds substForDotisInjectiveHerelitToConlitConinsertAtemptyCunionConstraints<: initialTagsunifysetTag mergeGroups unifiablerecordPatternToProjectionstranslateCompiledClausestranslateSplitTreetranslateRecordPatternsinitialIFSCandidates findInScope findInScope'getMetaTypeInContextcheckCandidatesapplyDroppingParameterssolveIrrelevantMetassolveMetaIfIrrelevantcatchConstraint newProblem newProblem_ifNoConstraintsguardConstraintwhenConstraintswakeupConstraintswakeupConstraints_solveAwakeConstraintssolveConstraint_ PruneResultPrunedEverythingPrunedSomething PrunedNothingNothingToPruneOccursoccurs metaOccursVarsUnfoldStrategyNoUnfold YesUnfold OccursCtxIrrelTopmodifyOccursCheckDefsinitOccursCheckdefNeedsCheckingtallyDefdefArgsunfoldleaveTopweaklystronglyabort goIrrelevant allowedVar takeRelevant liftUnderAbs occursCheckprune hasBadRigidrigidVarsNotContainedInkillArgs killedType performKillRes SubstCandFVsMetaKindLevelsSingletonRecordsRecordsfindIdx isBlockedTermisEtaExpandable assignTerm' newSortMetanewSortMetaCtx newTypeMeta newTypeMeta_ newIFSMetaCtxnewValueMetaCtx newValueMeta'newValueMetaCtx' newTelMeta trueConditionnewArgsMetaCtxnewArgsMetaCtx' newRecordMetanewRecordMetaCtxnewQuestionMark blockTermblockTermOnProblemunblockedTesterpostponeTypeCheckingProblem_postponeTypeCheckingProblemetaExpandListenerswakeupListener allMetaKinds etaExpandMetaetaExpandBlockedcheckLinearity inverseSubst updateMetaallMetasPartialFullprintHighlightingInfogenerateAndPrintSyntaxInfogenerateTokenInfoprintErrorInfoprintUnsolvedInfo generateHTMLaddForcingAnnotationsforcedVariablesforce rebindClauseEdgeArgNodeDefNodeComputeOccurrences occurrencesOccMOccEnvvarsinf OccurrencesItemADefAnArg OccursWhereUnknownHereInDefOfMatchedInClause IndArgType ConArgTypeMetaArgVarArgUnderInfDefArg LeftOfArrowcheckStrictlyPositive getDefArity>+< concatOccursoccursAshere onlyVarsUpTowithExtendedOccEnvgetOccurrencescomputeOccurrencesetaExpandClausebuildOccurrenceGraph computeEdge HasPolarity polaritiesneg polFromOcc nextPolaritypurgeNonvariantenablePhantomTypesdependentPolarityrelevantInIgnoringNonvariantmkUnusednonvariantToUnusedArgnonvariantToUnusedArgInDefnonvariantToUnusedArgInClause sizePolaritycheckSizeIndexpolarityunquote quotingKit quoteName quoteTerm quoteType agdaTermType qNameTypeisConunquoteFailedGeneric unquoteFailedunquoteHunquoteNPredOpFromTermfromTermFromTermFunctionToTermtoTermPrimTermprimTermPrimTypeprimTypeLvlunLvlunNatStrunStr PrimitiveImplPrimImplconstructorForm buildListredBind redReturnfromReducedTerm fromLiteral primTrustMe primQNameTypeprimQNameDefinitionprimDataConstructorsmkPrimLevelZeromkPrimLevelSucmkPrimLevelMax mkPrimFun1TCM mkPrimFun1 mkPrimFun2 mkPrimFun4-->.-->gpihPinPivarMgApply<@><#>listioeltsetargNdomNargHdomHprimitiveFunctionslookupPrimitiveFunctionlookupPrimitiveFunctionQStackunfoldCorecursionInvViewNoInvInv reduceHead headSymbolcheckInjectivityfunctionInverseuseInjectivitymlevelsameVars intersectVars equalAtom convError unifyPointers compareTerm'compareRelevancecompareIrrelevantcompareWithPolcoerceleqSortleqLevel equalLevel checkDataDefcheckConstructorbindParametersfitsIn constructs isCoinductiveisLevelConstraint matchPatternLHSState lhsProblemlhsSubstlhsDPIlhsAsB AsBindingAsBDotPatternInstDPI ProblemPartProblem SplitError SplitPanicNothingToSplit SplitProblemSplitFocusLitFocusfocusCon focusConArgs focusRange focusOutPat focusHoleIx focusDatatype focusParams focusIndices focusType ProblemRestrestPatsrestTypeProblem' problemInPat problemOutPat problemTel problemRest FlexibleVars ShapeViewElseShMetaShSortShLitShVarShDefShFunShPiShSubstHH substUnderHH trivialHHApplyHHapplyHH TelViewHHTelHHTypeHHTermHHHomHetHetHomUnificationResultNoUnifyUnifiesUReduceureduce UnifyStateUStuniSub uniConstrUnifyExceptionGenericUnifyExceptionStronglyRigidOccurrenceConstructorMismatchEqualityEqual UnifiablePossibly Definitely UnifyOutputUnifyEnvUnifyMayPostponeMayNotPostpone MayPostponeUnifyUunUnify emptyUEnv noPostponing askPostpone emptyUOutputreportPostponingifClean emptyUStateconstructorMismatchconstructorMismatchHHonSubmodSubcheckEqualities checkEqualitycheckEqualityHHforceHom addEquality addEqualityHHtakeEqualities|->makeSubstitutionflattenSubstitutionisHomfromHomleftHHrightHHabsAppHHsubstHH unifyIndices_ unifyIndicesdataOrRecordTypedataOrRecordType'dataOrRecordTypeHHisEtaRecordTypeHH shapeView shapeViewHH telViewUpToHHdefnParssmash'em inferable inferableTerm smashable buildLambdainsertImplicitProbleminsertImplicitPatternsuseNamesFromPattern noProblemResttypeFromProblemproblemFromPatsupdateProblemRest_updateProblemRestasViewexpandLitPattern splitProblemwellFormedIndices withTypesFrominstantiateTelnothingToSplitErrordataParametersdataParametersTCMreport piApplyM' insertTelemkConunifyItakeTele remForced forcedExpr replaceForced buildTerm findPositionflexiblePatternsdotPatternInstsinstantiatePatternisSolvedProblemnoShadowingOfConstructorscheckDotPattern bindLHSVarsbindAsPatternscheckLeftHandSidenoPatternMatchingOnCodataCoverMGenericSplitError CantSplitCoinductiveDatatypeIrrelevantDatatype NotADatatypeCovering covSplitArgcovSplitClauses SplitClauseSClausescTelscPermscPatsscSubstscTarget splitClausesclauseToSplitClause checkCoverage coverageCheckcover splitStrategycomputeNeighbourhoodsplitClauseWithAbs splitLastsplitblendInAbsurdClausesplitDbIndexToLeveldbIndexToLevelsplit'ClsClcompileWithSplitTreecompile nextSplitsplitOnsplitCexpandCatchAlls substBodyLamOrPiPiNotLamLamNotPiisType isTypeEqualToleqType_checkTelescope_checkTypedBindings_checkTypedBindingscheckTypedBinding checkLambda checkLiteral reduceConcheckArguments'unScope domainFree checkMeta inferMeta inferHeadinferDefcheckConstructorApplicationcheckHeadApplication traceCallEcheckArguments_ inferExprdefOrVar inferOrCheckinferExprForWith checkTermcheckLetBindingscheckLetBindingbindPostulatedName bindBuiltin typeOfInf typeOfSharp typeOfFlat DeBruijnPatResulttermDecl checkRecDefcheckRecordProjectionsshowPatwithFunctionTypebuildWithFunctionstripWithClausePatternswithDisplayForm patsToTermsWithFunctionProblem WithFunctionNoWithFunction checkAliastrailingImplicits dropNonHiddensplitTrailingImplicitspatchUpTrailingImplicitsinsertPatterns checkClausecheckWithFunction checkWherecontainsAbsurdPatternactualConstructor checkAxiomcheckPrimitive checkPragma checkMutualcheckTypeSignature checkSectioncheckModuleAritycheckSectionApplication' checkImportmergeInterfaceaddImportedThingsalreadyVisited typeCheck getInterface getInterface'highlightFromInterface readInterfacewriteInterfacecreateInterfacebuildInterface isNewerThan setInterfacecurIFcurSigcurMNamecurHsModcurDefssigMNameihnameunqhnametlmodOftlmnamexqualxhqnconhqnbltQualdsubnamehsVarUQmazstrmazNamemazMod'mazModmazerror mazCoercemazIncompleteMatchrtmIncompleteMatchmazRTErtmModrtmQualrtmVarrtmErrorunsafeCoerceModfakeDfakeDSfakeDQfakeTypefakeExpdummyencodeModuleNameWrapunwrap prettyPrintcheckTypeOfMainimportsForPrim declsForPrimmazNatToIntegermazIntegerToNat mazNatToInt mazIntToNatmazCharToIntegermazListToHListmazHListToListmazListToStringmazStringToListmazBoolToHBoolmazHBoolToBoolxForPrimprimBodyreplpconNamehasCompiledDatabltQual' compilerMainimports definitioncheckConstructorType checkCoverconArityAndParsclauseargpatts clausebodyterm'hslitlitqnamecondeclcdecltvaldeclinfodeclhsCasthsCast'hsCoerce writeModule rteModuleexplicitForAll compileDiroutFile'outFileoutFile_callGHCprefixjsMod jsFileNamejsMemberglobal'globalreorderreorder'isTopLevelValue isEmptyObject insertAfternumParsmappingmapping'pattern visitorName defProjectionargs dummyLambdaOutputConstraint'OfType'ofNameofExprOutputConstraint FindInScopeOF IsEmptyType TypedAssignAssignGuardCmpSortsJustSortCmpTeles CmpLevelsCmpTypesJustTypeCmpElim CmpInTypeOfType OutputFormRewrite Normalised HeadNormal InstantiatedAsIs parseExpr parseExprIngiveExprgiveaddDecl evalInCurrent evalInMetarewrite outputFormIdshowComparisonjudgToOutputFormgetConstraintsgetSolvedInteractionPoints typeOfMetaMI typeOfMetatypesOfVisibleMetastypesOfHiddenMetas contextOfMeta typeInCurrent typeInMetawithInteractionId withMetaId introTactic atTopLevelmoduleContentsCommandExitCodeReturn ContinueInContinue matchCommand interactioninteractionLoop continueAfterloadFileshowConstraints showMetas showScope metaParseExpr actOnMetagiveMeta refineMetaretryConstraintsevalInevalTermtypeOftypeIn showContext splashScreenhelp CaseContextExtendedLambda FunctionDef findClausemakeCasemakeAbsurdClausemakeAbstractClause deBruijnIndexKillVarkillVarShrinkCshrinkCnoShrink SizedList unSizedList unConName unDefName unVarNameNoTypeunNoTypeYesType unYesTypeGenCgenC UseLiteralsUseLit useLitInt useLitFloat useLitString useLitChar SortFreqssetFreqspropFreq HiddenFreqs hiddenFreq notHiddenFreq NameFreqsvarFreqdefFreqconFreq TermFreqsnameFreqlitFreqsortFreqlamFreqpiFreqfunFreq FrequenciesFreqs hiddenFreqs nameFreqs sortFreqs termFreqsTermConfigurationTermConftcDefinedNamestcConstructorNamestcFreeVariables tcLiterals tcFrequencies tcFixSizetcIsTypedefaultFrequenciesnoProp noLiterals fixSizeConf resizeConfdecrConfdivConf isTypeConf isntTypeConf extendConfextendWithTelConfmakeConfigurationfixSizegenArgsgenConfkillAbs isWellScopedprop_wellScopedVarsprop_telToListInvprop_flattenTelScopeprop_flattenTelInvprop_reorderTelStableprop_splitTelescopeScopeprop_splitTelescopePermScope testSuiteTOMSsConstssMetassEqssCurMeta sMainMetaMapSTModeTMAllOnorminitMapSpopMapStomygetConstgetdfvgetMetagetEqs tomyClauses tomyClausetomyPattomyBodyweakenweakenstomyTypetomyExptomyExpstomyIneqfmTypefmExpfmExpsfmLevelcnvhicnvhfrommy frommyType frommyExp frommyExps abslamvarnamemodifyAbstractExprmodifyAbstractClause constructPats frommyClausecontains_constructoretaContractBodynegtypefindClauseDeep matchTypeauto LowerMeta lowerMetaBackendJSEpicMAlonzo GoalCommandParseIOTCM Interaction Cmd_compute Cmd_make_caseCmd_show_module_contentsCmd_goal_type_context_inferCmd_goal_type_context Cmd_goal_type Cmd_infer Cmd_contextCmd_autoCmd_refine_or_intro Cmd_intro Cmd_refineCmd_giveToggleImplicitArgsShowImplicitArgsCmd_load_highlighting_infoCmd_compute_toplevelCmd_infer_toplevel Cmd_solveAll!Cmd_show_module_contents_toplevel Cmd_metasCmd_constraints Cmd_compileCmd_loadCommandM unCommandM CommandStatetheInteractionPointstheCurrentFileoptionsOnReloadinitCommandState runCommandM liftCommandMrevLift commandMToIO runSafeTCM liftCommandMTrunInteraction readsToParseparseToReadsPrecexact readParseparens' independent interpret cmd_load'give_gen give_gen'sortInteractionPointsprettyTypeOfMeta prettyContextcmd_goal_type_context_andshowModuleContentssetCommandLineOptions'status displayStatus display_info takenNameStr refreshStr nameModifierspreMeta preUscoreparseAndDoAtTopleveltellToUpdateHighlightingtellEmacsToJumpToError mimicGHCirunAgda printUsage printVersion optionErrormain$fSemiRingMaybe$fPointedMaybe $fPointed[] Data.MaybemapMaybe catMaybes listToMaybe maybeToList fromMaybefromJust isNothingisJustmaybeNothingJustMaybeptrTagptrReffreshVar $fNFDataPtr $fHashablePtr$fOrdPtr$fEqPtr$fTraversablePtr $fFoldablePtr $fFunctorPtr $fShowPtrModelValKey modelToTrie modelPath$fArbitraryModel$fArbitraryVal$fArbitraryKey $fShowVal $fShowKeyQuickCheck-2.5.1.1Test.QuickCheck.TestverboseCheckWithResultverboseCheckResultverboseCheckWith verboseCheckquickCheckWithResultquickCheckResultquickCheckWith quickCheckstdArgschattymaxSizemaxDiscardRatio maxSuccessreplayoutputlabelsnumTestsSuccessGaveUpreasonusedSizeusedSeed numShrinksFailureNoExpectedFailureTest.QuickCheck.Propertydisjoinconjoin.&. forAllShrinkforAllwithin==>classifycollectlabelonce expectFailureverbose whenFail'whenFail printTestCase shrinkingmapSizeProperty exhaustivepropertyTestableTest.QuickCheck.ModifiersBlindFixed getOrderedOrdered OrderedList getNonEmptyNonEmpty NonEmptyList getPositivePositive getNonZeroNonZerogetNonNegative NonNegativeShrink2Smart Shrinking shrinkState shrinkInit ShrinkStateTest.QuickCheck.Arbitrary orderedListvectorcoarbitraryEnumcoarbitraryShowcoarbitraryRealcoarbitraryIntegral><shrinkRealFracshrinkIntegral shrinkNothingarbitrarySizedBoundedIntegralarbitraryBoundedEnumarbitraryBoundedRandomarbitraryBoundedIntegralarbitrarySizedFractionalarbitrarySizedIntegralshrink arbitrary Arbitrary coarbitrary CoArbitraryTest.QuickCheck.ExceptiondiscardTest.QuickCheck.GenvectorOflistOf1listOfgrowingElementselements frequencyoneof suchThatMaybesuchThatsamplesample'promoteresizesizedvariantGenTest.QuickCheck.TextMkStrghc-prim GHC.TypesTrueBool$fHasZeroInteger integer-gmpGHC.Integer.Typeprop_integerSemiringprop_boolSemiring$fSemiRingInteger$fMonoidIntegerTMtoBoundsGHC.Listlength GHC.Classes==&&allMunMprop_Arbitrary_Sizeprop_Arbitrary_MIxprop_Arbitrary_Matrix prop_matrixprop_fromIndexListprop_fromLists_toLists prop_sizeprop_size_fromIndexListprop_addprop_mul prop_diagonalprop_addColumn prop_addRow$fCoArbitraryMatrix$fArbitraryMatrix $fShowMatrix$fCoArbitraryMIx$fArbitraryMIx$fCoArbitrarySize$fArbitrarySize readP_to_S readS_to_PPFinalLookGetfinalrunrun'$fMonadPlusReadP $fMonadReadP$fFunctorReadP $fMonadPlusP$fMonadPcatchIObindirlibdirdatadir libexecdir getBinDir getLibDir getDataDir getLibexecDirgetDataFileNameunordered-containers-0.2.3.3Data.HashMap.Strict fromListWithintersectionWith unionWithadjust insertWithData.HashMap.Baseelemskeysfilter filterWithKey foldrWithKeyfoldr foldlWithKey'foldl' intersection differencetraverseWithKey! lookupDefaultnullHashMapGHC.Showshow System.IOputStrLn $fSizedMaybe $fSizedSet $fSizedMap $fSized[]$fExceptionImpossible$fShowImpossibleOrdEqInt Data.ListgroupByGHC.Base.sortBycompare$fSizedPermutation$fShowPermutation Data.EitherEitherRightLeft prop_allRight$fRefinableOKValblk$fRefinableChoiceblk $fEqPrioMeta $fEqMetavar $fTravMMblk$fTravArgListRefInfo$fTravExpRefInfo$fTravTrBrRefInfo$fTrav(,)RefInfo $fTrav[]blk$fRefinableIORefRefInfo$fRefinableClosRefInfo$fRefinableExpRefInfo$fRefinableArgListRefInfo $fPrettyDocpretty-1.1.1.0Text.PrettyPrint.HughesPJMode OneLineModeLeftMode ZigZagModePageModeStylemode lineLengthribbonsPerLinestyle fullRender renderStylerenderfcatcathanghcat doubleQuotesquotesrationaldoublefloatintegerintrbracelbracerbracklbrackrparenlparenspacesemi zeroWidthText sizedTextptextChrPStr TextDetailsrunningInfoBufferName $fShowLisp $fPretty[] $fPrettyLisp toSparseRows transposeSizemergeAssocWithinterAssocWithstrictlySortedblowUpSparseVec$fPrettyMatrix Data.MonoidMonoid<=maxO callMatrix callGraphcombine isCompletecompletePreconditionensureCompletePrecondition$fPrettyCallGraph$fMonoidCallGraphcgDecrisOrder prop_decrcollapseokMminO orderSemiringprop_orderSemiringprop_Arbitrary_CallMatrixprop_callMatrix prop_cmMulprop_Arbitrary_Callprop_callGraph prop_completeprop_ensureCompletePrecondition$fCoArbitraryCall$fArbitraryCall$fCoArbitraryCallMatrix$fArbitraryCallMatrix$fCoArbitraryOrder$fArbitraryOrder $fPrettyOrder$fHasZeroOrder $fShowOrder noCallsLeftokColumn newBehaviourcorrectLexOrderprop_recBehaviour_Arbitraryprop_fromDiagonalsprop_newBehaviour prop_lexOrderprop_lexOrder_noArgs$fCoArbitraryRecBehaviour$fArbitraryRecBehaviourCGisDecrbuildCallGraphexample1example2example3example4example5example6 checkIdems checkIdemprop_terminates_example1prop_terminates_example2prop_terminates_example3prop_terminates_example4prop_terminates_example5prop_terminates_example6absolutePathInvariantdirectory-1.2.0.1System.DirectorycanonicalizePathprop_mkAbsoluterootPath$fArbitraryAbsolutePath$fShowAbsolutePath Control.MonadmapMtransformers-0.3.0.0Control.Monad.Trans.ErrorEGunEprop_nodes_fromNodesprop_transitiveClosure $fSemiRingE$fArbitraryGraphdefaultInteractionVerbositydefaultLaTeXDirdefaultHTMLDir parseOptions'defaultPragmaOptionsprop_defaultOptionsdefaultPragmaOptionsSafe inputFlag versionFlaghelpFlagsafeFlagproofIrrelevanceFlagexperimentalIrrelevanceFlagnoIrrelevantProjectionsFlagignoreInterfacesFlagallowUnsolvedFlagshowImplicitFlagshowIrrelevantFlag runTestsFlagghciInteractionFlagvimFlag latexFlag latexDirFlagnoPositivityFlagdontTerminationCheckFlagdontCompletenessCheckFlagdontUniverseCheckFlag sizedTypesinjectiveTypeConstructorFlagguardingTypeConstructorFlaguniversePolymorphismFlagnoUniversePolymorphismFlag noForcingFlag withoutKFlagcopatternsFlaginteractiveFlag compileFlagcompileEpicFlag compileJSFlagcompileDirFlagghcFlag epicFlagsFlaghtmlFlagdependencyGraphFlag htmlDirFlagcssFlag includeFlag verboseFlagterminationDepthFlagintegerArgumentstandardOptionsiLength fuseIntervals iPositions rPositions makeIntervalsetFileintervalInSameFileAsSrcFile importantPart prop_iLength prop_startPos prop_noRangeprop_takeI_dropIprop_rangeToIntervalprop_continuousprop_fuseIntervalsprop_fuseRangesprop_beginningOfprop_beginningOfFileprop_intervalInSameFileAs$fArbitraryRange'$fArbitraryInterval'$fArbitraryPosition' $fShowRange'$fShowInterval'$fShowPosition'$fKillRangeEither$fKillRangeMaybe$fKillRange(,,)$fKillRange(,) $fKillRange[]$fKillRangeRange'$fSetRangeRange'$fHasRangeMaybe$fHasRange(,,,,,,)$fHasRange(,,,,,)$fHasRange(,,,,)$fHasRange(,,,)$fHasRange(,,) $fHasRange(,) $fHasRange[]$fHasRangeRange'$fHasRangeInterval'$fOrdPosition' $fEqPosition'$fCoArbitraryInduction$fArbitraryInduction$fHashableNameId $fEnumNameId $fShowNamed $fSizedNamed$fKillRangeNamed$fHasRangeNamed $fShowArg $fSizedArg$fKillRangeArg $fHasRangeArg$fEqArg $fShowDom $fSizedDom$fKillRangeDom $fHasRangeDom$fOrdRelevance$fArbitraryRelevance$fKillRangeHiding$fKillRangeInduction$fKillRangeDelayed$fHasRangeInduction$fShowInduction$fGlobalsModule$fGlobalsExport $fGlobalsExp $fGlobalsMap $fGlobals[] $fUsesExport $fUsesExp $fUsesMap$fUses[]$fPrettyModule $fPrettyExp$fPrettyMemberId$fPrettyGlobalId$fPrettyLocalId $fPrettiesMap $fPretties[] $fPretty(,) $fShowTag $fPrettyPatt $fPrettyCase$fSemiRingDistance$fShowSizeExpr$fShowLegendMatrix$fShowConstraint $fShowNode$fSemiRingWeight $fOrdWeight $fShowWeight$fKillRangeName$fKillRangeQName$fSetRangeQName$fSetRangeName$fHasRangeQName$fHasRangeName$fCoArbitraryTopLevelModuleName$fArbitraryTopLevelModuleName$fPrettyTopLevelModuleName $fShowQName$fShowNamePart $fShowName $fOrdNamePart $fEqNamePart $fOrdName$fEqNameprop_rangesToPositions prop_minus$fArbitraryRanges$fCoArbitraryRange$fArbitraryRange$fKillRangeFixity'$fKillRangeFixity$fHasRangeFixity $fEqFixity$fSizedModuleName $fSizedQName$fKillRangeAmbiguousQName$fKillRangeModuleName$fSetRangeModuleName$fHashableQName $fOrdQName $fEqQName$fShowModuleName$fHashableName $fShowNameId$fHasRangeModuleName$fKillRangeLiteral$fSetRangeLiteral$fHasRangeLiteral $fOrdLiteral $fEqLiteral $fShowLiteral$fKillRangeWhereClause$fKillRangeUsingOrHiding$fKillRangeTypedBindings$fKillRangeTypedBinding$fKillRangeRHS$fKillRangeRenaming$fKillRangePragma$fKillRangePattern$fKillRangeOpApp$fKillRangeModuleApplication$fKillRangeLHS$fKillRangeLamBinding$fKillRangeImportedName$fKillRangeImportDirective$fKillRangeExpr$fKillRangeDeclaration$fKillRangeBoundName$fKillRangeAsName$fHasRangePattern$fHasRangeAsName$fHasRangeRenaming$fHasRangeImportedName$fHasRangeImportDirective$fHasRangeUsingOrHiding$fHasRangePragma $fHasRangeRHS$fHasRangeLHSCore $fHasRangeLHS$fHasRangeDeclaration$fHasRangeModuleApplication$fHasRangeWhereClause$fHasRangeBoundName$fHasRangeLamBinding$fHasRangeTypedBinding$fHasRangeTypedBindings$fHasRangeExpr$fHasRangeOpApp$fShowImportedName mergeMetaInfomergemergeC prop_compressprop_singleton prop_several prop_merge prop_splitAtCprop_smallestPos$fArbitraryCompressedFile$fCoArbitraryFile$fArbitraryFile$fCoArbitraryMetaInfo$fArbitraryMetaInfo$fCoArbitraryOtherAspect$fArbitraryOtherAspect$fCoArbitraryNameKind$fArbitraryNameKind$fCoArbitraryAspect$fArbitraryAspect$fMonoidCompressedFile $fMonoidFile$fMonoidMetaInfo$fPrettyImportedName$fPrettyUsingOrHiding$fPrettyImportDirective$fPrettyPattern $fPrettyNamed $fPrettyArg$fPrettyFixity$fPrettyPragma$fPrettyOpenShortHand$fPrettyDeclaration$fPrettyModuleApplication$fShowModuleApplication $fPretty[]0$fPrettyLHSCore $fShowLHSCore $fPrettyLHS $fShowLHS$fPrettyWhereClause$fShowWhereClause $fPrettyRHS$fPrettyTypedBinding$fPrettyTypedBindings$fPrettyLamBinding$fPrettyBoundName $fPrettyExpr $fPrettyOpApp$fPrettyInduction$fPrettyRelevance$fPrettyLiteral $fPrettyQName $fPrettyName$fPrettyThingWithFixity $fShowRHS $fShowPragma$fShowImportDirective$fShowLamBinding$fShowTypedBindings $fShowPattern$fShowDeclaration $fShowExpr$fHasRangeToken$fArbitraryCName $fShowCName$fArbitrarySplitTree'$fShowSplitTree'$fShowSplitTreeLabel$fSetRangeAbstractName$fHasRangeAbstractName$fShowAbstractModule$fShowAbstractName$fShowNameSpace$fShowNameSpaceId $fShowScope$fShowScopeInfo$fOrdAbstractModule$fEqAbstractModule$fOrdAbstractName$fEqAbstractName$fInScopeAbstractModule$fInScopeAbstractName$fKillRangeScopeInfogeniplate-0.6.0.3Data.Generics.GeniplateinstanceUniverseBiT universeBiinstanceTransformBiMT transformBiM$fKillRangeAbs$fKillRangeBlocked$fKillRangeTele$fKillRangeSort$fKillRangeType$fKillRangeLevelAtom$fKillRangePlusLevel$fKillRangeLevel$fKillRangeTerm $fSizedAbs $fSizedTele$fSizedLevelAtom$fSizedPlusLevel $fSizedLevel $fSizedType $fSizedTerm $fShowBlocked $fShowMetaId $fShowAbs$fHasRangeClause$fApplicativeBlocked$fUniverseBi(,)Pattern$fUniverseBi[]Pattern$fUniverseBi(,)Term$fUniverseBi[]Term$fUniverseBi[]Term0 fcIgnoreSorts IgnoreSorts IgnoreAllIgnoreInAnnotations IgnoreNotflexible irrelevantlyunused subtractFVFreeConf freeVars'$fFreeClauseBody $fFreeTele $fFreeAbs $fFreeDom $fFreeArg $fFree(,) $fFreeMaybe$fFree[]$fFreeLevelAtom$fFreePlusLevel $fFreeLevel $fFreeSort $fFreeType $fFreeTerm$fMonoidEInterface$fPrettyCompiledClauses$fPrettyWithArity$fShowCompiledClauses $fShowCase $fMonoidCase$fMonoidWithArity$fTermLikeType$fTermLikeLevelAtom$fTermLikePlusLevel$fTermLikeLevel$fTermLikeTerm $fTermLikePtr $fTermLikeAbs $fTermLike(,)$fTermLikeMaybe $fTermLike[] $fTermLikeDom $fTermLikeArg $fMonoidMatch$fKillRangePatInfo$fHasRangePatInfo $fShowPatInfo$fKillRangeLHSInfo$fHasRangeLHSInfo$fKillRangeMutualInfo$fHasRangeMutualInfo$fKillRangeDeclInfo$fSetRangeDeclInfo$fHasRangeDeclInfo$fKillRangeDefInfo$fSetRangeDefInfo$fHasRangeDefInfo$fKillRangeLetInfo$fHasRangeLetInfo$fKillRangeModuleInfo$fSetRangeModuleInfo$fHasRangeModuleInfo$fKillRangeExprInfo$fHasRangeExprInfo$fKillRangeMetaInfo$fHasRangeMetaInfo$fKillRangeLetBinding$fKillRangeClause$fKillRangeLHSCore'$fKillRangePattern'$fKillRangeThingWithFixity$fKillRangeRelevance$fSetRangePattern'$fHasRangeLetBinding$fHasRangeLHSCore'$fHasRangePattern'$fGetDefInfoDeclaration$fUniverseBiDeclarationQName%$fUniverseBiDeclarationAmbiguousQName$fUniverseBiDeclarationExpr!$fUniverseBiDeclarationLetBinding!$fUniverseBiDeclarationLamBinding#$fUniverseBiDeclarationTypedBinding$fUniverseBiDeclarationPattern'"$fUniverseBiDeclarationDeclaration!$fUniverseBiDeclarationModuleName$fAnyAbstractDeclaration$fAnyAbstract[]!$fUniverseBiDeclarationModuleInfoloneSigs DataRecOrFunFunNameRecNameDataName NotInMutualInMutualTerminationCheckgetSig checkLoneSigs parameters plusFixitiesfixitiesDeclKind OtherDeclLoneDefLoneSigNiceEnvfixsLoneSigsParams isFunNamesameKindterminationCheck initNiceEnv addLoneSig removeLoneSig noLoneSigsdeclKind$fShowDataRecOrFun$fShowDeclarationException$fErrorDeclarationException$fHasRangeNiceDeclaration$fHasRangeDeclarationExceptionunP initStatePos getLastPos setLexState setContext$fHasRangeParseError$fShowParseError$fMonadStateParseStateParser$fMonadErrorParseErrorParser$fApplicativeParser$fFunctorParser $fMonadParser$fExceptionParseError ErrorFunctionErrorFun throwError unLookAhead$fMonadLookAheadlitError stringToken lexString lexStringGaplexChar lexEscapereadNum readNumAccsillyEscapeCharspragmaalexScanGHC.Err undefined AlexAccPredAlexAccAlexAccSkipPred AlexAccSkip AlexLastAcc AlexLastSkipAlexNoneAlexAddrAlexA# alex_base alex_table alex_check alex_deflt alex_acceptbol_ empty_layout_imp_dir_layout_pragma_tex alex_action_0 alex_action_1 alex_action_4 alex_action_5 alex_action_8 alex_action_9alex_action_10alex_action_11alex_action_12alex_action_13alex_action_14alex_action_15alex_action_16alex_action_17alex_action_18alex_action_19alex_action_20alex_action_21alex_action_22alex_action_23alex_action_24alex_action_25alex_action_26alex_action_28alex_action_30alex_action_32alex_action_33alex_action_34alex_action_35alex_action_36alex_action_37alex_action_38alex_action_39alex_action_40alex_action_41alex_action_42alex_action_43alex_action_44alex_action_45alex_action_46alex_action_47alex_action_48alex_action_49alex_action_50alex_action_51alex_action_52alex_action_53alex_action_54alex_action_55alex_action_56alex_action_57alex_action_58alex_action_59alex_action_60alex_action_61alex_action_62alex_action_63alex_action_64alex_action_65alex_action_66alex_action_67alex_action_68alex_action_69alex_action_70alex_action_71alex_action_72alex_action_73alex_action_74alex_action_75alex_action_76alex_action_77alex_action_78alex_action_79alex_action_80alex_action_81alex_action_82alex_action_83alex_action_84alex_action_85alex_action_86alex_action_87alex_action_88alex_action_89alex_action_90alex_action_91alex_action_92alex_action_93alex_action_94alexIndexInt16OffAddralexIndexInt32OffAddr quickIndex alex_scan_tkn alexAndPredalexPrevCharIsalexPrevCharMatchesalexPrevCharIsOneOfalexRightContextiUnbox$fFunctorAlexLastAcc returnEOFskipTonewInputfoolAlex qualified postToken getOffside happyErrormkQNameisNameforallPiaddTypeverifyImportDirective splitOnDotsvalidHaskellModuleName exprToLHS exprToPattern exprToName HappyAddrHappyA#HappyStk Happy_IntList HappyCons RHSOrTypeSigs TypeSigsRHSJustRHSHappyAny HappyAbsSynhappyIn6 happyOut6happyIn7 happyOut7happyIn8 happyOut8happyIn9 happyOut9 happyIn10 happyOut10 happyIn11 happyOut11 happyIn12 happyOut12 happyIn13 happyOut13 happyIn14 happyOut14 happyIn15 happyOut15 happyIn16 happyOut16 happyIn17 happyOut17 happyIn18 happyOut18 happyIn19 happyOut19 happyIn20 happyOut20 happyIn21 happyOut21 happyIn22 happyOut22 happyIn23 happyOut23 happyIn24 happyOut24 happyIn25 happyOut25 happyIn26 happyOut26 happyIn27 happyOut27 happyIn28 happyOut28 happyIn29 happyOut29 happyIn30 happyOut30 happyIn31 happyOut31 happyIn32 happyOut32 happyIn33 happyOut33 happyIn34 happyOut34 happyIn35 happyOut35 happyIn36 happyOut36 happyIn37 happyOut37 happyIn38 happyOut38 happyIn39 happyOut39 happyIn40 happyOut40 happyIn41 happyOut41 happyIn42 happyOut42 happyIn43 happyOut43 happyIn44 happyOut44 happyIn45 happyOut45 happyIn46 happyOut46 happyIn47 happyOut47 happyIn48 happyOut48 happyIn49 happyOut49 happyIn50 happyOut50 happyIn51 happyOut51 happyIn52 happyOut52 happyIn53 happyOut53 happyIn54 happyOut54 happyIn55 happyOut55 happyIn56 happyOut56 happyIn57 happyOut57 happyIn58 happyOut58 happyIn59 happyOut59 happyIn60 happyOut60 happyIn61 happyOut61 happyIn62 happyOut62 happyIn63 happyOut63 happyIn64 happyOut64 happyIn65 happyOut65 happyIn66 happyOut66 happyIn67 happyOut67 happyIn68 happyOut68 happyIn69 happyOut69 happyIn70 happyOut70 happyIn71 happyOut71 happyIn72 happyOut72 happyIn73 happyOut73 happyIn74 happyOut74 happyIn75 happyOut75 happyIn76 happyOut76 happyIn77 happyOut77 happyIn78 happyOut78 happyIn79 happyOut79 happyIn80 happyOut80 happyIn81 happyOut81 happyIn82 happyOut82 happyIn83 happyOut83 happyIn84 happyOut84 happyIn85 happyOut85 happyIn86 happyOut86 happyIn87 happyOut87 happyIn88 happyOut88 happyIn89 happyOut89 happyIn90 happyOut90 happyIn91 happyOut91 happyIn92 happyOut92 happyIn93 happyOut93 happyIn94 happyOut94 happyIn95 happyOut95 happyIn96 happyOut96 happyIn97 happyOut97 happyIn98 happyOut98 happyIn99 happyOut99 happyIn100 happyOut100 happyIn101 happyOut101 happyIn102 happyOut102 happyIn103 happyOut103 happyIn104 happyOut104 happyIn105 happyOut105 happyIn106 happyOut106 happyIn107 happyOut107 happyIn108 happyOut108 happyIn109 happyOut109 happyIn110 happyOut110 happyIn111 happyOut111 happyIn112 happyOut112 happyIn113 happyOut113 happyIn114 happyOut114 happyIn115 happyOut115 happyIn116 happyOut116 happyIn117 happyOut117 happyIn118 happyOut118 happyIn119 happyOut119 happyIn120 happyOut120 happyIn121 happyOut121 happyIn122 happyOut122 happyIn123 happyOut123 happyIn124 happyOut124 happyIn125 happyOut125 happyIn126 happyOut126 happyIn127 happyOut127 happyIn128 happyOut128 happyIn129 happyOut129 happyIn130 happyOut130 happyIn131 happyOut131 happyIn132 happyOut132 happyIn133 happyOut133 happyIn134 happyOut134 happyIn135 happyOut135 happyInTok happyOutTokhappyActOffsetshappyGotoOffsetshappyDefActions happyCheck happyTablehappyReduceArr happy_n_termshappy_n_nonterms happyReduce_3happyReduction_3 happyReduce_4happyReduction_4 happyReduce_5happyReduction_5 happyReduce_6happyReduction_6 happyReduce_7happyReduction_7 happyReduce_8happyReduction_8 happyReduce_9happyReduction_9happyReduce_10happyReduction_10happyReduce_11happyReduction_11happyReduce_12happyReduction_12happyReduce_13happyReduction_13happyReduce_14happyReduction_14happyReduce_15happyReduction_15happyReduce_16happyReduction_16happyReduce_17happyReduction_17happyReduce_18happyReduction_18happyReduce_19happyReduction_19happyReduce_20happyReduction_20happyReduce_21happyReduction_21happyReduce_22happyReduction_22happyReduce_23happyReduction_23happyReduce_24happyReduction_24happyReduce_25happyReduction_25happyReduce_26happyReduction_26happyReduce_27happyReduction_27happyReduce_28happyReduction_28happyReduce_29happyReduction_29happyReduce_30happyReduction_30happyReduce_31happyReduction_31happyReduce_32happyReduction_32happyReduce_33happyReduction_33happyReduce_34happyReduction_34happyReduce_35happyReduction_35happyReduce_36happyReduction_36happyReduce_37happyReduction_37happyReduce_38happyReduction_38happyReduce_39happyReduction_39happyReduce_40happyReduction_40happyReduce_41happyReduction_41happyReduce_42happyReduction_42happyReduce_43happyReduction_43happyReduce_44happyReduction_44happyReduce_45happyReduction_45happyReduce_46happyReduction_46happyReduce_47happyReduction_47happyReduce_48happyReduction_48happyReduce_49happyReduction_49happyReduce_50happyReduction_50happyReduce_51happyReduction_51happyReduce_52happyReduction_52happyReduce_53happyReduction_53happyReduce_54happyReduction_54happyReduce_55happyReduction_55happyReduce_56happyReduction_56happyReduce_57happyReduction_57happyReduce_58happyReduction_58happyReduce_59happyReduction_59happyReduce_60happyReduction_60happyReduce_61happyReduction_61happyReduce_62happyReduction_62happyReduce_63happyReduction_63happyReduce_64happyReduction_64happyReduce_65happyReduction_65happyReduce_66happyReduction_66happyReduce_67happyReduction_67happyReduce_68happyReduction_68happyReduce_69happyReduction_69happyReduce_70happyReduction_70happyReduce_71happyReduction_71happyReduce_72happyReduction_72happyReduce_73happyReduction_73happyReduce_74happyReduction_74happyReduce_75happyReduction_75happyReduce_76happyReduction_76happyReduce_77happyReduction_77happyReduce_78happyReduction_78happyReduce_79happyReduction_79happyReduce_80happyReduction_80happyReduce_81happyReduction_81happyReduce_82happyReduction_82happyReduce_83happyReduction_83happyReduce_84happyReduction_84happyReduce_85happyReduction_85happyReduce_86happyReduction_86happyReduce_87happyReduction_87happyReduce_88happyReduction_88happyReduce_89happyReduction_89happyReduce_90happyReduction_90happyReduce_91happyReduction_91happyReduce_92happyReduction_92happyReduce_93happyReduction_93happyReduce_94happyReduction_94happyReduce_95happyReduction_95happyReduce_96happyReduction_96happyReduce_97happyReduction_97happyReduce_98happyReduction_98happyReduce_99happyReduction_99happyReduce_100happyReduction_100happyReduce_101happyReduction_101happyReduce_102happyReduction_102happyReduce_103happyReduction_103happyReduce_104happyReduction_104happyReduce_105happyReduction_105happyReduce_106happyReduction_106happyReduce_107happyReduction_107happyReduce_108happyReduction_108happyReduce_109happyReduction_109happyReduce_110happyReduction_110happyReduce_111happyReduction_111happyReduce_112happyReduction_112happyReduce_113happyReduction_113happyReduce_114happyReduction_114happyReduce_115happyReduction_115happyReduce_116happyReduction_116happyReduce_117happyReduction_117happyReduce_118happyReduction_118happyReduce_119happyReduction_119happyReduce_120happyReduction_120happyReduce_121happyReduction_121happyReduce_122happyReduction_122happyReduce_123happyReduction_123happyReduce_124happyReduction_124happyReduce_125happyReduction_125happyReduce_126happyReduction_126happyReduce_127happyReduction_127happyReduce_128happyReduction_128happyReduce_129happyReduction_129happyReduce_130happyReduction_130happyReduce_131happyReduction_131happyReduce_132happyReduction_132happyReduce_133happyReduction_133happyReduce_134happyReduction_134happyReduce_135happyReduction_135happyReduce_136happyReduction_136happyReduce_137happyReduction_137happyReduce_138happyReduction_138happyReduce_139happyReduction_139happyReduce_140happyReduction_140happyReduce_141happyReduction_141happyReduce_142happyReduction_142happyReduce_143happyReduction_143happyReduce_144happyReduction_144happyReduce_145happyReduction_145happyReduce_146happyReduction_146happyReduce_147happyReduction_147happyReduce_148happyReduction_148happyReduce_149happyReduction_149happyReduce_150happyReduction_150happyReduce_151happyReduction_151happyReduce_152happyReduction_152happyReduce_153happyReduction_153happyReduce_154happyReduction_154happyReduce_155happyReduction_155happyReduce_156happyReduction_156happyReduce_157happyReduction_157happyReduce_158happyReduction_158happyReduce_159happyReduction_159happyReduce_160happyReduction_160happyReduce_161happyReduction_161happyReduce_162happyReduction_162happyReduce_163happyReduction_163happyReduce_164happyReduction_164happyReduce_165happyReduction_165happyReduce_166happyReduction_166happyReduce_167happyReduction_167happyReduce_168happyReduction_168happyReduce_169happyReduction_169happyReduce_170happyReduction_170happyReduce_171happyReduction_171happyReduce_172happyReduction_172happyReduce_173happyReduction_173happyReduce_174happyReduction_174happyReduce_175happyReduction_175happyReduce_176happyReduction_176happyReduce_177happyReduction_177happyReduce_178happyReduction_178happyReduce_179happyReduction_179happyReduce_180happyReduction_180happyReduce_181happyReduction_181happyReduce_182happyReduction_182happyReduce_183happyReduction_183happyReduce_184happyReduction_184happyReduce_185happyReduction_185happyReduce_186happyReduction_186happyReduce_187happyReduction_187happyReduce_188happyReduction_188happyReduce_189happyReduction_189happyReduce_190happyReduction_190happyReduce_191happyReduction_191happyReduce_192happyReduction_192happyReduce_193happyReduction_193happyReduce_194happyReduction_194happyReduce_195happyReduction_195happyReduce_196happyReduction_196happyReduce_197happyReduction_197happyReduce_198happyReduction_198happyReduce_199happyReduction_199happyReduce_200happyReduction_200happyReduce_201happyReduction_201happyReduce_202happyReduction_202happyReduce_203happyReduction_203happyReduce_204happyReduction_204happyReduce_205happyReduction_205happyReduce_206happyReduction_206happyReduce_207happyReduction_207happyReduce_208happyReduction_208happyReduce_209happyReduction_209happyReduce_210happyReduction_210happyReduce_211happyReduction_211happyReduce_212happyReduction_212happyReduce_213happyReduction_213happyReduce_214happyReduction_214happyReduce_215happyReduction_215happyReduce_216happyReduction_216happyReduce_217happyReduction_217happyReduce_218happyReduction_218happyReduce_219happyReduction_219happyReduce_220happyReduction_220happyReduce_221happyReduction_221happyReduce_222happyReduction_222happyReduce_223happyReduction_223happyReduce_224happyReduction_224happyReduce_225happyReduction_225happyReduce_226happyReduction_226happyReduce_227happyReduction_227happyReduce_228happyReduction_228happyReduce_229happyReduction_229happyReduce_230happyReduction_230happyReduce_231happyReduction_231happyReduce_232happyReduction_232happyReduce_233happyReduction_233happyReduce_234happyReduction_234happyReduce_235happyReduction_235happyReduce_236happyReduction_236happyReduce_237happyReduction_237happyReduce_238happyReduction_238happyReduce_239happyReduction_239happyReduce_240happyReduction_240happyReduce_241happyReduction_241happyReduce_242happyReduction_242happyReduce_243happyReduction_243happyReduce_244happyReduction_244happyReduce_245happyReduction_245happyReduce_246happyReduction_246happyReduce_247happyReduction_247happyReduce_248happyReduction_248happyReduce_249happyReduction_249happyReduce_250happyReduction_250happyReduce_251happyReduction_251happyReduce_252happyReduction_252happyReduce_253happyReduction_253happyReduce_254happyReduction_254happyReduce_255happyReduction_255happyReduce_256happyReduction_256happyReduce_257happyReduction_257happyReduce_258happyReduction_258happyReduce_259happyReduction_259happyReduce_260happyReduction_260happyReduce_261happyReduction_261happyReduce_262happyReduction_262happyReduce_263happyReduction_263happyReduce_264happyReduction_264happyReduce_265happyReduction_265happyReduce_266happyReduction_266happyReduce_267happyReduction_267happyReduce_268happyReduction_268happyReduce_269happyReduction_269happyReduce_270happyReduction_270happyReduce_271happyReduction_271happyReduce_272happyReduction_272happyReduce_273happyReduction_273happyReduce_274happyReduction_274happyReduce_275happyReduction_275happyReduce_276happyReduction_276happyReduce_277happyReduction_277happyReduce_278happyReduction_278happyReduce_279happyReduction_279happyReduce_280happyReduction_280happyReduce_281happyReduction_281happyReduce_282happyReduction_282happyReduce_283happyReduction_283happyReduce_284happyReduction_284happyReduce_285happyReduction_285happyReduce_286happyReduction_286happyReduce_287happyReduction_287happyReduce_288happyReduction_288happyReduce_289happyReduction_289happyReduce_290happyReduction_290happyReduce_291happyReduction_291happyReduce_292happyReduction_292happyReduce_293happyReduction_293happyReduce_294happyReduction_294happyReduce_295happyReduction_295happyReduce_296happyReduction_296happyReduce_297happyReduction_297happyReduce_298happyReduction_298happyReduce_299happyReduction_299happyReduce_300happyReduction_300happyReduce_301happyReduction_301happyReduce_302happyReduction_302happyReduce_303happyReduction_303happyReduce_304happyReduction_304happyReduce_305happyReduction_305happyReduce_306happyReduction_306happyReduce_307happyReduction_307happyReduce_308happyReduction_308happyReduce_309happyReduction_309happyReduce_310happyReduction_310happyReduce_311happyReduction_311happyReduce_312happyReduction_312happyReduce_313happyReduction_313happyReduce_314happyReduction_314happyReduce_315happyReduction_315happyReduce_316happyReduction_316happyReduce_317happyReduction_317happyReduce_318happyReduction_318happyReduce_319happyReduction_319happyReduce_320happyReduction_320happyReduce_321happyReduction_321happyReduce_322happyReduction_322happyReduce_323happyReduction_323happyReduce_324happyReduction_324happyReduce_325happyReduction_325happyReduce_326happyReduction_326happyReduce_327happyReduction_327happyReduce_328happyReduction_328happyReduce_329happyReduction_329happyReduce_330happyReduction_330happyReduce_331happyReduction_331happyReduce_332happyReduction_332happyReduce_333happyReduction_333happyReduce_334happyReduction_334happyReduce_335happyReduction_335happyReduce_336happyReduction_336happyReduce_337happyReduction_337happyReduce_338happyReduction_338happyReduce_339happyReduction_339happyReduce_340happyReduction_340happyReduce_341happyReduction_341happyReduce_342happyReduction_342happyReduce_343happyReduction_343happyReduce_344happyReduction_344happyReduce_345happyReduction_345happyReduce_346happyReduction_346happyReduce_347happyReduction_347happyReduce_348happyReduction_348happyReduce_349happyReduction_349happyReduce_350happyReduction_350happyReduce_351happyReduction_351happyReduce_352happyReduction_352happyReduce_353happyReduction_353happyReduce_354happyReduction_354happyReduce_355happyReduction_355happyReduce_356happyReduction_356happyReduce_357happyReduction_357happyReduce_358happyReduction_358happyReduce_359happyReduction_359happyReduce_360happyReduction_360happyReduce_361happyReduction_361happyReduce_362happyReduction_362happyReduce_363happyReduction_363happyReduce_364happyReduction_364happyReduce_365happyReduction_365happyReduce_366happyReduction_366happyReduce_367happyReduction_367happyReduce_368happyReduction_368happyReduce_369happyReduction_369happyReduce_370happyReduction_370happyReduce_371happyReduction_371happyReduce_372happyReduction_372happyReduce_373happyReduction_373happyReduce_374happyReduction_374happyReduce_375happyReduction_375happyReduce_376happyReduction_376happyReduce_377happyReduction_377happyReduce_378happyReduction_378happyReduce_379happyReduction_379happyReduce_380happyReduction_380happyReduce_381happyReduction_381happyReduce_382happyReduction_382 happyNewToken happyError_ happyThen happyReturn happyThen1 happyReturn1 happyError'happySeqprop_splitOnDotsopAppExprToPattern parsePanicnamesOfPatternfunClauseOrTypeSigs happyParse happyAccept happyDoActionindexShortOffAddr happyShifthappySpecReduce_0happySpecReduce_1happySpecReduce_2happySpecReduce_3 happyReducehappyMonadReducehappyMonad2Reduce happyDrop happyDropStk happyGoto happyFail notHappyAtAll happyTcHack happyDoSeq happyDontSeq withCommentswithoutCommentsparserwrapwrapMparseLiterateFile $fMonadIOTCMT$fApplicativeTCMT $fFunctorTCMT $fMonadTCMT$fMonadTransTCMT$fMonadTCMErrorT$fMonadTCMTCMT$fMonadErrorTCErrTCMT$fMonadStateTCStateTCMT$fMonadReaderTCEnvTCMT$fExceptionTCErr$fHasRangeTCErr $fShowTCErr $fErrorTCErr$fErrorTypeError$fHasRangeCall$fNFDataOccurrence$fShowInteractionId$fSetRangeMetaVariable$fHasRangeMetaVariable$fShowNamedMeta$fShowMetaInstantiation $fOrdListener $fEqListener$fShowJudgement$fShowComparison$fHasRangeClosure $fShowClosure$fHasFreshiTCState$fHasFreshProblemIdFreshThings$fShowProblemId$fHasFreshIntFreshThings$fHasFreshCtxIdFreshThings$fHasFreshNameIdFreshThings"$fHasFreshInteractionIdFreshThings$fHasFreshMutualIdFreshThings$fHasFreshMetaIdFreshThings$fEqTerm$fKillRangeSubstitution$fSizedSubstitution$fOrdAbs$fEqAbs $fOrdTerm $fEqLevelAtom$fOrdPlusLevel$fSubstClauseBody $fSubst(,) $fSubst() $fSubst[] $fSubstMaybe $fSubstDom $fSubstArg $fSubstAbs $fSubstElim$fSubstConstraint $fSubstTele$fSubstDisplayTerm$fSubstDisplayForm$fSubstBlocked$fSubstPattern$fSubstLevelAtom$fSubstPlusLevel $fSubstLevel $fSubstSort $fSubstType $fSubstPtr $fSubstTerm$fSubstSubstitution $fAbstractMap$fAbstractMaybe $fAbstract[]$fAbstractClauseBody$fAbstractFunctionInverse'$fAbstractCase$fAbstractWithArity$fAbstractCompiledClauses$fAbstractClause$fAbstractPrimFun$fAbstractDefn $fAbstract[]0 $fAbstract[]1$fAbstractDefinition$fAbstractTele$fAbstractSort$fAbstractType$fAbstractTerm$fAbstractPermutation$fApplyPermutation $fApply(,,) $fApply(,) $fApplyMap $fApplyMaybe$fApplyBlocked $fApply[]$fApplyDisplayTerm$fApplyClauseBody$fApplyFunctionInverse' $fApplyCase$fApplyWithArity$fApplyCompiledClauses $fApplyClause$fApplyPrimFun $fApplyDefn $fApply[]0 $fApply[]1$fApplyDefinition $fApplyTele $fApplyPtr $fApplySort $fApplyType $fApplyTerm$fAbstractTerm(,)$fAbstractTermAbs$fAbstractTermMaybe$fAbstractTerm[]$fAbstractTermDom$fAbstractTermArg$fAbstractTermLevelAtom$fAbstractTermPlusLevel$fAbstractTermLevel$fAbstractTermSort$fAbstractTermType$fAbstractTermPtr$fAbstractTermTermunsafeQNameToNamebracket' bracketP_bracketP withInfixDeclbindToConcreteCtxtelToTypedBindingssHdHdDefHdConHdVar AsWhereDecls takenNames currentScope defaultEnvcurrentPrecedencewithPrecedence lookupName lookupQName lookupModulewithInfixDeclswithAbstractPrivatemakeDomainFreemergeSigAndDef openModule'declsToConcretenoImplicitArgsnoImplicitPats noImplicit appBrackets'cOpApptryToRecoverOpApptryToRecoverOpAppP recoverOpApp$fToConcretePattern'Pattern$fToConcreteLHSCore'Pattern$fToConcreteLHSLHS $fToConcreteRangeAndPragmaPragma$fToConcreteDeclaration[].$fToConcreteModuleApplicationModuleApplication$fToConcreteClause[]$fToConcreteConstrDeclaration$fToConcreteMaybeMaybe$fToConcreteRHS(,,,)#$fToConcreteAsWhereDeclsWhereClause$fToConcreteLetBinding[]$$fToConcreteTypedBindingTypedBinding&$fToConcreteTypedBindingsTypedBindings $fToConcreteLamBindingLamBinding$fToConcreteExprExpr$fToConcreteModuleNameQName$fToConcreteQNameQName$fToConcreteNameName$fToConcreteDontTouchMea$fToConcreteNamedNamed$fToConcreteArgArg$fToConcrete(,,)(,,)$fToConcrete(,)(,)$fToConcrete[][]tick':=< inequalities$fMonadTCMExceptionT$fMonadIOExceptionT$fMonadErrorerr'ExceptionT$fMonadReaderrExceptionT$fMonadStatesExceptionT$fApplicativeExceptionT$fFunctorExceptionT$fMonadTransExceptionT$fMonadExceptionerrWriterT$fMonadExceptionerrReaderT$fMonadExceptionerrExceptionT$fMonadExceptionTAlphapatsPEPaththePath groupClauses pathToRecord groupPathes $fEqPattern'alphaalpha'Renamerename'NameMapProjPath ProjEntryprojPE theContent mapContent clauseToPath lhsToPath pathHeads pathSplittell1$fEqLHS $fAlpha[] $fAlphaNamed $fAlphaArg $fAlphaLHS$fAlphaLHSCore'$fAlphaPattern' $fAlphaName $fRename[] $fRenameNamed $fRenameArg$fRenameDeclaration$fRenamePattern'$fRenameLHSCore' $fRenameLHS $fRenameRHS$fRenameClause$fRenameTypedBinding$fRenameTypedBindings$fRenameLamBinding$fRenameLetBinding $fRenameExpr$fHasRangeProjEntryPatternCheckConfigtopNameconNamesfldNames NotationStyle localNameslhsArgs'classifyPatternParseLHSNonfixPostfixInfixS FlatScope partsInScopefixStyle notationNameslhsArgs parseLHS'parsePatternOrSyn fullParen'$fIsExprPattern $fIsExprExprWithRHS' rhsRewriteEqn rhsWithExpr rhsSubclausescheckPatternLinearityrecordConstructorTypenotPublicWithoutOpen renamingRange toAbstractCtxlocalToAbstract' mkNamedArgmkArg'mkArg toAbstractDotscopeCheckModule niceDeclstoAbstractOpApp RewriteRHS'RHS' AbsurdRHS'rhs rhsWhereDecls ConstrDecl IsRecordConNoRecYesRecPatternSynPatName ConPatName VarPatNamenotAModuleExprnotAnExpressionnotAValidLetBindingnothingAppliedToHiddenArgnothingAppliedToInstanceArg printLocals printScope annotateDecl annotateDecls annotateExprexpandEllipsischeckModuleApplicationcheckModuleMacro setContextCPSlocalToAbstractCtxnameExpr freshQModulecheckForModuleClashtoAbstractOpArg toAbstractLammakeDomainFullbindConstructorNamewhereToAbstract qualifyName_withFunctionName$fToAbstractPatternPattern'$fToAbstractPattern'Pattern'$fToAbstractLHSCore'LHSCore'$fToAbstractNamedNamed$fToAbstractArgArg$fToAbstractLHSCoreLHSCore'$fToAbstractLeftHandSideLHS$fToAbstractRHSAbstractRHS$$fToAbstractRightHandSideAbstractRHS$fToAbstractAbstractRHSRHS$fToAbstractClauseClause$fToAbstractPragma[]!$fToAbstractConstrDeclDeclaration&$fToAbstractNiceDeclarationDeclaration$fToAbstractLetDef[]$fToAbstractLetDefs[]$fToAbstract[][] $fToAbstractTopLevelTopLevelInfo$$fToAbstractTypedBindingTypedBinding&$fToAbstractTypedBindingsTypedBindings $fToAbstractLamBindingLamBinding$fToAbstractExprExpr#$fToAbstractOldModuleNameModuleName$$fToAbstractNewModuleQNameModuleName#$fToAbstractNewModuleNameModuleName$fToAbstractOldNameQName$fToAbstractPatNameAPatName$fToAbstractOldQNameExpr$fToAbstractNewNameName$fToAbstractNewNameName0$fToAbstractMaybeMaybe$fToAbstract[][]0$fToAbstract(,,)(,,)$fToAbstract(,)(,)positioncolumninCodeLaTeXrunLaTeX nextToken'nonCodefixityspacestoLaTeXinfoTokensStatetokens indentPrev emptyState isInfixOf'isSpaces nextToken resetColumn moveColumn moveIndent resetIndent setIndentPrevresetIndentPrev setInCode unsetInCodenl beginCodeendCodeptOpenptOpen'ptCloseptClose'ptNL cmdPrefixcmdArg cmdIndentinfixl'infix'infixr'defaultStyFile processTokens$fDropArgsCompiledClauses$fDropArgsClause$fDropArgsClauseBody$fDropArgsTele$fDropArgsFunctionInverse'$fDropArgsPermutation$fInstantiateFullMaybe$fInstantiateFullQName$fInstantiateFullBuiltin$fInstantiateFullInterface$fInstantiateFullClause $fInstantiateFullCompiledClauses$fInstantiateFullCase$fInstantiateFullWithArity!$fInstantiateFullFunctionInverse'$fInstantiateFullDefn$fInstantiateFullDisplayTerm$fInstantiateFullDisplayForm$fInstantiateFullOpen$fInstantiateFullDefinition$fInstantiateFullChar$fInstantiateFullTele$fInstantiateFullSection$fInstantiateFullSignature$fInstantiateFullScope$fInstantiateFullModuleName$fInstantiateFullHashMap$fInstantiateFullMap$fInstantiateFullElim$fInstantiateFullConstraint"$fInstantiateFullProblemConstraint$fInstantiateFullClosure$fInstantiateFull(,,)$fInstantiateFull(,)$fInstantiateFull[]$fInstantiateFullDom$fInstantiateFullArg$fInstantiateFullAbs$fInstantiateFullClauseBody$fInstantiateFullPattern$fInstantiateFullLevelAtom$fInstantiateFullPlusLevel$fInstantiateFullLevel$fInstantiateFullTerm$fInstantiateFullType$fInstantiateFullSort$fInstantiateFullName$fNormaliseMaybe$fNormaliseMap$fNormaliseDisplayForm$fNormalisePattern$fNormaliseConstraint$fNormaliseProblemConstraint$fNormaliseTele$fNormaliseClosure$fNormalise(,,)$fNormalise(,) $fNormalise[]$fNormaliseDom$fNormaliseArg$fNormaliseAbs$fNormaliseClauseBody$fNormaliseLevelAtom$fNormalisePlusLevel$fNormaliseLevel$fNormaliseElim$fNormaliseTerm$fNormaliseType$fNormaliseSort $fReduceMap$fReduceConstraint $fReduceTele$fReduceClosure $fReduceTerm $fReduce(,,) $fReduce(,) $fReduceDom $fReduceArg $fReduce[] $fReduceAbs$fReduceLevelAtom$fReducePlusLevel $fReduceLevel $fReduceElim $fReduceSort $fReduceType$fInstantiateMap$fInstantiateConstraint$fInstantiateTele$fInstantiateClosure$fInstantiate(,,)$fInstantiate(,)$fInstantiate[]$fInstantiateDom$fInstantiateArg$fInstantiateAbs$fInstantiateElim$fInstantiateSort$fInstantiateType$fInstantiateBlocked$fInstantiateLevelAtom$fInstantiatePlusLevel$fInstantiateLevel$fInstantiateTerm $fMatchLevel $fMatchSort $fMatchTerm $fMatchArg $fMatch[]DotVarsnameFirstIfHidden $fDotVarsExpr $fReifyArgArgdotVarsnappsreifyAppexprInforeifyDisplayFormreifyDisplayFormP reifyTermstripImplicits$fReifyJudgementJudgement $fReify(,)(,) $fReify[][] $fReifyDomArg $fReifyTele[] $fReifyAbs(,)$fReifyLevelExpr$fReifySortExpr$fReifyTypeExpr$fReifyQNamedClause$fDotVarsTypedBinding$fDotVarsTypedBindings $fDotVarsRHS$fDotVarsPattern'$fDotVarsClause $fDotVars(,) $fDotVars[]$fDotVarsNamed $fDotVarsArg$fReifyClauseBodyRHS$fReifyElimExpr$fReifyNamedNamed$fReifyTermExpr$fReifyLiteralExpr$fReifyDisplayTermExpr$fReifyMetaIdExpr$fReifyExprExpr$fReifyWhenNamedNamed$fReifyWhenArgArg$fReifyWheniExpr$fMentionsMetaConstraint$fMentionsMetaProblemConstraint$fMentionsMetaTele$fMentionsMetaElim$fMentionsMetaClosure$fMentionsMeta(,,)$fMentionsMeta(,)$fMentionsMetaMaybe$fMentionsMeta[]$fMentionsMetaDom$fMentionsMetaArg$fMentionsMetaAbs$fMentionsMetaSort$fMentionsMetaType$fMentionsMetaLevelAtom$fMentionsMetaPlusLevel$fMentionsMetaLevel$fMentionsMetaTerm $fPrettyTCM[]$fPrettyTCMPrettyContext$fPrettyTCMTele$fPrettyTCMModuleName$fPrettyTCMQName$fPrettyTCMName$fPrettyTCMLiteral$fPrettyTCMConstraint$fPrettyTCMProblemConstraint$fPrettyTCMComparison$fPrettyTCMRelevance$fPrettyTCMName0$fPrettyTCMExpr$fPrettyTCMElim$fPrettyTCMDom$fPrettyTCMArg$fPrettyTCMNamed$fPrettyTCMBlocked$fPrettyTCMMetaId$fPrettyTCMJudgement$fPrettyTCMClauseBody$fPrettyTCMLevel$fPrettyTCMQNamed$fPrettyTCMDisplayTerm$fPrettyTCMSort$fPrettyTCMType$fPrettyTCMTerm$fPrettyTCMInt$fPrettyTCM[]0$fPrettyTCMClosureFalsesayWheresayWhenpanicnameWithBinding errorStringnotCmp$fPrettyTCMCall$fPrettyTCMTypeError$fPrettyTCMTCErrtoAtoms showMetaInfomodFileincludes HashTablehashtables-1.0.1.8Data.HashTable.IOCuckooHashTableBasicHashTableLinearHashTable malformed emptyDicticodevalueStnodeEstringEintegerEdoubleEnodeMemoMemoDictnodeDstringDintegerDdoubleDtermDnodeCstringCintegerCdoubleC sharingStatsfileModcurrentInterfaceVersionicodeXicodeNvcaseicode0icode1icode2icode3icode4icode5icode6icode7icode8icode9icode10icode11icode12icode13icode14icode0'icode1'icode2'icode3'icode4'icode5'icode6'icode7'icode8'icode9'icode10'icode11'icode12'icode13'icode14'valu0valu1valu2valu3valu4valu5valu6valu7valu8valu9valu10valu11valu12valu13valu14 $fEmbPrjTag$fEmbPrjForced$fEmbPrjRelevance$fEmbPrjInjectiveFun$fEmbPrjEInterface$fEmbPrjInterface$fEmbPrjCompressedFile$fEmbPrjScopeInfo$fEmbPrjPrecedence$fEmbPrjMetaInfo$fEmbPrjOtherAspect$fEmbPrjAspect$fEmbPrjNameKind$fEmbPrjBuiltin$fEmbPrjPattern$fEmbPrjDelayed$fEmbPrjClauseBody$fEmbPrjClause$fEmbPrjIsAbstract$fEmbPrjTermHead$fEmbPrjFunctionInverse'$fEmbPrjCompiledClauses $fEmbPrjCase$fEmbPrjWithArity $fEmbPrjDefn$fEmbPrjCompiledRepresentation$fEmbPrjOccurrence$fEmbPrjPolarity$fEmbPrjMemberId$fEmbPrjGlobalId$fEmbPrjLocalId $fEmbPrjExp$fEmbPrjHaskellRepresentation$fEmbPrjDefinition$fEmbPrjMutualId$fEmbPrjDisplayTerm $fEmbPrjCtxId $fEmbPrjOpen$fEmbPrjDisplayForm$fEmbPrjLiteral $fEmbPrjSort$fEmbPrjLevelAtom$fEmbPrjPlusLevel $fEmbPrjLevel $fEmbPrjTerm $fEmbPrjAbs $fEmbPrjType$fEmbPrjRelevance0$fEmbPrjHiding$fEmbPrjInduction $fEmbPrjDom $fEmbPrjArg$fEmbPrjPermutation $fEmbPrjTele$fEmbPrjSection$fEmbPrjHashMap$fEmbPrjSignature$fEmbPrjNameId$fEmbPrjLetBinding$fEmbPrjTypedBinding$fEmbPrjTypedBindings$fEmbPrjLamBinding$fEmbPrjPattern' $fEmbPrjExpr $fEmbPrjNamed $fEmbPrjName$fEmbPrjModuleName$fEmbPrjAmbiguousQName $fEmbPrjQName$fEmbPrjGenPart$fEmbPrjFixity'$fEmbPrjFixity$fEmbPrjKindOfName$fEmbPrjAbstractModule$fEmbPrjAbstractName$fEmbPrjNameSpace$fEmbPrjAccess$fEmbPrjNameSpaceId $fEmbPrjScope$fEmbPrjQName0$fEmbPrjNamePart $fEmbPrjName0 $fEmbPrjRange$fEmbPrjRange'$fEmbPrjInterval' $fEmbPrjSet $fEmbPrjMap $fEmbPrj[]$fEmbPrjTopLevelModuleName$fEmbPrjPosition'$fEmbPrjAbsolutePath $fEmbPrjBool $fEmbPrjMaybe $fEmbPrj(,,) $fEmbPrj(,) $fEmbPrj()$fEmbPrjDouble $fEmbPrjChar $fEmbPrjInt $fEmbPrjInt32$fEmbPrjInteger $fEmbPrj[]0$fShowSizeConstraintmany'curly prettyEpicBr prettyEpicLittypVar RecordTreeRecConLeafChangesVarPatDotPatKindRecPatMDropFromRecordSplitTreeRecordSplitNodesplitCon splitAritysplitRecordPattern conjColumns insertColumn cutSublistreplaceByProjections isRecordCaserecordSplitTree runRecPatMnextVar projections removeTreetranslatePatterntranslatePatterns recordTree translateTel translateBody permToSubst dropBindsdropFromRecordSplitTrees $fDropFrom[] $fDropFrom(,)$fDropFromSplitTree' $fOccurs[] $fOccurs(,) $fOccursDom $fOccursArg $fOccursAbs $fOccursSort $fOccursType$fOccursLevelAtom$fOccursPlusLevel $fOccursLevel$fOccursClause $fOccursDefn $fOccursQName $fOccursTerm $fError()$fPrettyTCM(,) NameKinds nameKindsgenerateConstructorInfocomputeUnsolvedMetaWarningscomputeUnsolvedConstraintsgenerate nameToFile nameToFileA concreteBaseconcreteQualifier bindingSitedefaultCSSFile modToFile generatePagepage$fSemiRingEdge$fSemiRingOccurrence$fPrettyTCMGraph$fPrettyTCM(,)0$fPrettyTCMOccurrence$fPrettyTCMNode$fComputeOccurrences(,)$fComputeOccurrences[]$fComputeOccurrencesDom$fComputeOccurrencesArg$fComputeOccurrencesAbs$fComputeOccurrencesTele$fComputeOccurrencesType$fComputeOccurrencesLevelAtom$fComputeOccurrencesPlusLevel$fComputeOccurrencesLevel$fComputeOccurrencesTerm$fComputeOccurrencesClause$fPrettyTCMOccursWhere$fHasPolarityLevelAtom$fHasPolarityPlusLevel$fHasPolarityLevel$fHasPolarityTerm$fHasPolarityType$fHasPolarity(,)$fHasPolarity[]$fHasPolarityAbs$fHasPolarityDom$fHasPolarityArg $fUnquoteTerm $fUnquoteType$fUnquoteLevel $fUnquoteSort $fUnquoteAbs$fUnquoteQName$fUnquoteRelevance$fUnquoteHiding $fUnquote[]$fUnquoteInteger $fUnquoteArg $fFromTerm[]$fFromTermBool$fFromTermQName $fFromTermStr$fFromTermChar$fFromTermDouble $fFromTermLvl $fFromTermNat$fFromTermInteger $fToTerm[] $fToTermType $fToTermBool $fToTermQName $fToTermStr $fToTermChar$fToTermDouble $fToTermLvl $fToTermNat$fToTermInteger $fPrimTermIO $fPrimTerm[]$fPrimTermType$fPrimTermQName $fPrimTermLvl $fPrimTermNat $fPrimTermStr$fPrimTermDouble$fPrimTermChar$fPrimTermBool$fPrimTermInteger $fPrimTypea$fPrimTerm(->) $fShowNat $fShowLvl$fMonoidProblemRest$fMonoidProblem'$fErrorSplitError$fPrettyTCMAsBinding$fPrettyTCMDotPatternInst$fSubstAsBinding$fSubstDotPatternInst$fSubstProblem'$fSubstProblemRest$fMonoidUnifiable$fSubstHHTeleTele$fSubstHH(,)(,)$fSubstHHAbsAbs$fSubstHHDomDom$fSubstHHArgArg$fSubstHHTypeHomHet$fSubstHHTermHomHet$fSubstHHHomHetHomHet $fApplyHHType $fApplyHHTerm$fPrettyTCMHomHet $fSubstHomHet$fUReduceMaybe$fUReduceHomHet $fUReduceType $fUReduceTerm$fSubstEquality$fMonadTCMUnify$fMonadStateTCStateUnify$fErrorUnifyException$fMonadReaderTCEnvUnify$fPrettyTCMSplitError $fErrorTypebuiltinPostulate coreBuiltinsinductiveCheckbindBuiltinInfoStripAllProjectionsDBPConfguardingTypeConstructorssharp currentTargetTargetConDBP termDecls termMutual termMutual' termFunction termSectiontermDefliftDBP termToDBPstripCoConstructors openClause termClausetermTerm maskSizeLtmakeCMaddGuardednessoffsetFromConstructor subPatternsisProjectionButNotFlatstripProjections compareVarVarstripAllProjectionsuseDotPatterns withSizeSucLitDBPVarDBP MutualNamesCalls reportCalls typeEndsInDef unusedVar adjIndexDBP targetElem isSubTermcompareConArgs compareVar$fStripAllProjectionsTerm$fStripAllProjections[]$fStripAllProjectionsArg$fPrettyTCMDeBruijnPat isModCharprop_encodeModuleName_injectiveprop_encodeModuleName_OKprop_encodeModuleName_preserved $fArbitraryM$fTransformBiModuleNameWrap$fTransformBiModuleNameWrap0$fTransformBiModuleNameWrap1$fTransformBiModuleNameWrap2initialAnalysis compileDefns setEpicDirrunEpic runEpicMaincallEpic callEpic'compilePreludereadEInterface compileModuleidPrint$fToConcreteNamedMetaExpr$fToConcreteInteractionIdExpr.$fToConcreteOutputConstraint'OutputConstraint'$fPrettyOutputConstraint',$fToConcreteOutputConstraintOutputConstraint $fToConcreteOutputFormOutputForm$fShowOutputConstraint$fShowOutputForm!$fReifyConstraintOutputConstraint$fReifyProblemConstraintClosure $fKillVar(,)$fKillVarMaybe $fKillVar[] $fKillVarAbs $fKillVarDom $fKillVarArg $fKillVarTele $fKillVarType $fKillVarTerm$fShrinkCTermTerm$fShrinkCTypeType$fShrinkCTeleTele$fShrinkCSortSort$fShrinkCBlockedBlocked$fShrinkCDomDom$fShrinkCArgArg$fShrinkCAbsAbs$fShrinkCHidingHiding$fShrinkCCharChar$fShrinkCLiteralLiteral$fShrinkCConNameQName$fShrinkCDefNameQName$fShrinkCVarNameInt$fShrinkC(,)(,) $fShrinkC[][]$fShrinkCNoTypeb$fShrinkCYesTypeb$fArbitraryTermConfiguration $fGenCTerm $fGenCType $fGenCTele $fGenCLiteral $fGenCInteger $fGenCDouble $fGenCChar $fGenCSort $fGenCAbs $fGenCDom $fGenCArg $fGenCHiding $fGenCRange' $fGenC(,)$fGenC[]$fGenCSizedList AutoHintMode AHMModuleAHMNoneMRefine MCaseSplitMNormalinsertAbsurdPatterngetNamedispmsg autohints insuffsols insuffcands parseargsControl.Monad.Trans.State.LazyStateTControl.Monad.Trans.Class runStateTControl.Monad.IO.ClassliftIO Text.Readreads$fLowerMetaNamed$fLowerMetaArg $fLowerMeta[]$fLowerMetaWhereClause$fLowerMetaModuleApplication$fLowerMetaDeclaration$fLowerMetaMaybe$fLowerMetaRHS$fLowerMetaTypedBinding$fLowerMetaTypedBindings$fLowerMetaLamBinding$fLowerMetaOpApp$fLowerMetaExpr$fReadPosition'$fReadAbsolutePath$fReadInterval' $fReadRange'$fReadInteractionIdlispifyResponselastTag showNumIId