)      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                   ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~9NoneNone  NoneIN MapList m a is a memoization of |[b]->a|, where m c is the memoization of b->c. Because we cannot memoize functions taking infinite lists (and long lists practically), functions are silently recomputed if the length if its argument list is more than the length limit.h      !"#$%&'()*+,-./01 length limit23456789:range;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]h      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]Y      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]NoneNone+      NoneY^_`abcdefghijklmnopqrstuvwxyz{|}~8^_`abcdefghijklmnopqrstuvwxyz{|}~U^_`abcdefghijklmnopqrstuvwxyz{|}~NoneNoneNone37... applies a function to the bag at each depth. // flattens each bag.00 converts bags to sets, by (possibly sorting each bag and) removing duplicates. Efficiency on lists with lots of duplicates is required.shrinkDB can be used instead of mergesortDepthWithBy when you want to shrink each depth in different ways using different annotations.~ !"#$%&'()*+,-./0Combiner, which is used when there are equivalent elements (compared by the comparer specified by the next argument). The return value of this combiner should also be equivalent to the two arguments.Comparer123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ     A !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZA?@AFG<=>9:;LM&'()*+,-./01H2345IJKNOVTUBCDEWPQRSX#$% !"Y678Z` !"#$%& '()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ     None7[Unlike ?, < , etc., the [ monad only keeps the best set of results. This makes the analytical synthesis like IgorII, and the exhaustive synthesis like Djinn, i.e., the resulting algorithms are more efficient, but cannot be used for (analytically-)generate-and-test.[\]^_`abcdefgh[\]^_`[\]^_hgfedcb`a [\]^_`abcdefghNoneD !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUV<WXYZ[ !"$%&')+-./0134568;<=>?@ABCDEFHIJLNOPQRST< !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUV ! None35\jreserveTVars takes the number of requested tvIDs, reserves consecutive tvIDs, and returns the first tvID. *]^_`abcdefghijklmnopqrstuvwxyz{|}\~"]^_`abcdefghijklmnopqrstuvwxyz{|}\(]^_`abcdefghijklmnopqrstuvwxyz{|}\~None NoneNone  None  Noneiii None<IN !None "None;<IJN #None $None   %NonereadHsTypeSigsR reads a module string and returns an Exp that can be supplied to MagicHaskeller.p  &None;IN  n can be used as a VarLib for testing and debugging. Currently this is used only by the analytical synthesizer. defaultPrimitives is the set of primitives that we want to make sure to appear in VarLib but may not appear in the primitive set with which to synthesize. In other words, it is the set of primitives we want to make sure to assign IDs to.8jkl   m !"#$%&'()n*+,-./01234567 8 9:;5jkl   m !"#$%&'()n*+,-./01234567 8 jkl   m !"#$%&'()n*+,-./01234567 8 9:;! 'NoneGIJN<< converts a->b->c->d->e->r into ((((a,b),c),d),e)->r Note that Arbitrary (a,b,c,d,e) is not defined in Test.QuickCheck.;=>?@ABCDEFGHIJKLMNOPQRSTUV<WXYZ[\]^_`abcdefghijklmnopqrstuvDINOPQST<YZaefj;=>?@ABCDEFGHIJKLMNOPQRSTUV<WXYZ[\]^_`abcdefghijklmnopqrstuv(Nonewxyz{|}~wxyz{wxyz{|}~)NonepRecompute instead of memoizing.qKUse the memoization table based on lazy evaluation, like in older versions.rUse the directory specified by FilePath% as the persistent memoization table.DGeneral-purposed memoizer (This could be put in a different module.) opqr4This will be used instead if the entry is not found.)look up the memoization table in the RAM.4This will be used instead if the entry is not found.parserprinterwhere to memoize invoked if there is no such file opqropqr*None<  Nones(options that limit the hypothesis space.uwUse this option if you want to use a different component library for the stage of solving the inhabitation problem. Nothing means using the same one. This option makes sense only when using *SF style generators, because otherwise the program generation is not staged. Using a minimal set for solving the inhabitation and a redundant library for the real program generation can be a good bet.vmemoization depth. (Sub)expressions within this size are memoized, while greater expressions will be recomputed (to save the heap space). Only effective when using ProgGen and unless using the  everythingIO family.wZThis represents when to memoize. It takes the query type and the query depth, and returns Truer if the corresponding entry should be looked up from the lazy memo table. Currently this only works for ProgGenSF.xpThis represents which memoization table to be used based on the query type and the search depth, when using the  everythingIO family.zJust ms sets the timeout to ms microseconds. Also, my implementation of timeout also catches inevitable exceptions like stack space overflow. Note that setting timeout makes the library referentially untransparent. (But currently  Just 20000) is the default!) Setting this option to Nothing0 disables both timeout and capturing exceptions.{If this option is True, +, instead of -. is used for timeout. The former is much heavier than the latter, but is more preemptive and thus is necessary for interrupting some infinite loops. This record is ignored if FORCIBLETO is not defined.|If this option is True5, the program guesses whether each function is a case catamorphismparamorphism or not. This information is used to filter out some duplicate expressions. (History: I once abandoned this guessing strategy around the time I moved to the library implementation, because I could not formally prove the exhaustiveness of the resulting algorithm. For this reason, the old standalone version of MagicHaskeller uses this strategy, but almost the same effect can be obtained by setting this option to True, or using / instead of 0. }RThis option is now obsolete, and we always assume True now. If this option was FalseC, data structures might not contain functions, and thus types like  [Int->Int], (Int->Bool, Char)G, etc. were not permitted. (NB: recently I noticed that making this False" might not improve the efficiency of generating lambda terms at all, though when I generated combinatory expressions it WAS necessary. In fact, I mistakenly turned this limitation off, and my code always regarded this as True, but I did not notice that, so this option can be obsoleted.)~If this option is True, matching at the antecedent of induction rules may occur, which constrains generation of existential types. You need to use prefixed (->)H to show that some parameter can be matched at the antecedent, e.g., pK [| ( []::[a], (:)::a->[a]->[a], foldr :: (a->b->b) -> b -> (->) [a] b ) |] See LibTH.hs for examples.QEach time the type variable which appears in the return type of a function (e.g. b in foldr::(a->b->b)->b->[a]->b) is expanded to a function type, the search priority of the current computation is lowered by this number. It's default value is 1, which means there is nothing special, and the priority for each expression corresponds to the number of function applications in the expression.Example: when tvndelay = 1,The priority of \xs -> foldr (\x y -> x+y) 0 xs is 5, because there are five $'s in 1\xs -> ((foldr $ (\x y -> ((+) $ x) $ y)) $ 0) xsThe priority of 5\xs ys -> foldr (\x y zs -> x : y zs) (\ws->ws) xs ys!is 7, because there are seven $'s in O\xs ys -> (((foldr $ (\x y zs -> (((:) $ x) $ y) $ zs)) $ (\ws->ws)) $ xs) $ ysExample: when tvndelay = 2,The priority of \xs -> foldr (\x y -> x+y) 0 xs is 5, because there are five $'s in 1\xs -> ((foldr $ (\x y -> ((+) $ x) $ y)) $ 0) xsThe priority of 5\xs ys -> foldr (\x y zs -> x : y zs) (\ws->ws) xs ys!is 8, because there are eight $'s in P\xs ys -> (((foldr $ (\x y zs -> (((:) $ x) $ y) $ zs)) $ (\ws->ws)) $ xs) $$ yswhere $$[ denotes the function application caused by expanding a type variable into a function type.If this option is True?, the return type of functions returning a type variable (e.g. b in foldr::(a->b->b)->b->[a]->b) can only be replaced with  Eval t => t and Eval t => u -> t , while if False with  Eval t => t, Eval t => u->t, Eval t => u->v->t, etc., where Eval t means t cannot be replaced with a function. The restriction can be amended if the tuple constructor and destructors are available.The random seed.xnumber of random samples at each depth, for each type, for the filter applied during synthesis (used by ProgGenSF, &c.).ynumber of random samples at each depth, for each type, for the filter applied after synthesis (used by filterThenF, &c.).default options options = Opt{ primopt = Nothing , memodepth = 10 , memoCondPure = \ _type depth -> 0<depth , memoCond = \ _type depth -> return $ if depth < 10 then Ram else Recompute , execute = unsafeExecute , timeout = Just 20000 , forcibleTimeout = False , guess = False , contain = True , constrL = False , tv1 = Falsestuvwxyz{|}~stuvwxyz{|}~stuvwxyz{|}~stuvwxyz{|}~1NoneN]seq or deepSeq(=Control.Parallel.Strategies.sforce). For our purposes seq is enough, because a is either  or . None353microsecs until timeout*3'2None<length of availsarity of the head function3NoneNone8     Rm     V     m'     4None*options for limiting the hypothesis space.;|mkTrie| creates the generator with the default parameters.Use memoization requiring IOUse memoization requiring IO0ProgramGenerator is a generalization of the old Memo type. ;|mkTrie| creates the generator with the default parameters.annotated 'Typed [CoreExpr]']]M5None<2      !"#$%&'()*+,-./0123456789    20      !"#$%&'()*+,-./0123456789 None35<The vanilla program generator corresponding to Version 0.7.*internal data representation :;<=>?@ABCDEFGHIJKLMNOrecursive callPQRS:;<=>?@ABCDEFGHIJKLMNOPQRS6NoneTUVWXYZ[\]^_`abcVYZ[\TUVWXYZ[\]^_`abc7Nonedefghijklmnopqrstuvrecursive callghptdefghijklmnopqrstuv None35?Program generator with synergetic filtration. This program generator employs filtration by random testing, and rarely generate semantically equivalent expressions more than once, while different expressions will eventually appear (for most of the types, represented with Prelude types, whose arguments are instance of Arbitrary and which return instance of Ord). The idea is to apply random numbers to the generated expressions, compute the quotient set of the resulting values at each depth of the search tree, and adopt the complete system of representatives for the depth and push the remaining expressions to one step deeper in the search tree. (Thus, adoption of expressions that may be equivalent to another already-generated-expression will be postponed until their "uniqueness" is proved.) As a result, (unlike ProgGenK,) expressions with size N may not appear at depth N but some deeper place. ProgGenSFA is more efficient along with a middle-sized primitive set (like  reallyall+ found in LibTH.hs), but is slower than ProgGen for a small-sized one.Also note that  ProgGenSFP depends on hard use of unsafe* stuff, so if there is a bug, it may segfault....Zwxyz{|}~ !"  !"  !"Ywxyz{|}~ !" None35#?Program generator with synergetic filtration. This program generator employs filtration by random testing, and rarely generate semantically equivalent expressions more than once, while different expressions will eventually appear (for most of the types, represented with Prelude types, whose arguments are instance of Arbitrary and which return instance of Ord). The idea is to apply random numbers to the generated expressions, compute the quotient set of the resulting values at each depth of the search tree, and adopt the complete system of representatives for the depth and push the remaining expressions to one step deeper in the search tree. (Thus, adoption of expressions that may be equivalent to another already-generated-expression will be postponed until their "uniqueness" is proved.) As a result, (unlike ProgGenK,) expressions with size N may not appear at depth N but some deeper place. ProgGenSFA is more efficient along with a middle-sized primitive set (like  reallyall+ found in LibTH.hs), but is slower than ProgGen for a small-sized one.Also note that  ProgGenSFP depends on hard use of unsafe* stuff, so if there is a bug, it may segfault....4#$#$$#3#$8None None<%&Fvisible modules (including package modules). You may omit the Prelude.'-modules to be loaded (except package modules)+visible modules (including package modules)()*+,-./0123456789:%&'()*+,-./0123456789%&'()*+,-./0123456789:%&'()*+,-./0123456789:9None Xexistential variable. When doing analytical synthesis, there is no functional variable.  suniversal variable. When doing analytical synthesis, there is no functional variable. Int0g0o0j0OTH.Name0vcO0c0_e0L00D *number of variables quantified with forall ?input example for each argument. The last argument comes first.  N applies a substitution which replaces existential variables to an expression. fusion of apply s and fresh f<  the to-be-sought list   !"#$%&' ()*+,-./0123456789:;<=>?@ABCD9     !"#$%&' ()*+,-./0123456789:;<=>?@A.      !"#$%&' ()*+,-./0123456789:;<=>?@ABCD:NoneEFMExpr a is a finite trie representing  Expr () -> aFGHIJEKLMNOPQRSTUVWXYZ[\]^_`abcFGHIJEKLMNOPQRSTUVWXYZ[\]^_`aFGHIJEKLMNOPQRSTUVWXYZ[\]^_`abc;None4 defghijklmn defghijklmndefghijklmn<None$opqrstuvwxyz{|}~$opqrstuvwxyz{|}~opqrstuvwxyz{|}~=None#function specification by examples.]the function is really a background knowledge (and thus there is no need for loop check)  it is actually a recursive call.:background knowledge.:3 None<IN@@Q eases use of this library by automating some function definitions. For example,  J$( define ''ProgGen "Foo" (p [| (1 :: Int, (+) :: Int -> Int -> Int) |]) )is equivalent to  memoFoo :: ProgGen memoFoo = mkPG (p [| (1 :: Int, (+) :: Int -> Int -> Int) |]) everyFoo :: Everything everyFoo = everything memoFoo filterFoo :: Filter filterFoo pred = filterThen pred everyFooeIf you do not think this function reduces the number of your keystrokes a lot, you can do without it.AAH is used to convert your primitive component set into the internal form.DC is defined as: <mkPG prims = mkPGSF (mkStdGen 123456) (repeat 5) prims primsFF and GZ are provided mainly for backward compatibility. These functions are defined only for the s whose names end with SF\ (i.e., generators with synergetic filtration). For such generators, they are defined as: mkPGSF gen nrnds optups tups = mkPGOpt (options{primopt = Just optups, contain = True, stdgen = gen, nrands = nrnds}) tups mkMemoSF gen nrnds optups tups = mkPGOpt (options{primopt = Just optups, contain = False, stdgen = gen, nrands = nrnds}) tupsGF and GZ are provided mainly for backward compatibility. These functions are defined only for the s whose names end with SF\ (i.e., generators with synergetic filtration). For such generators, they are defined as: mkPGSF gen nrnds optups tups = mkPGOpt (options{primopt = Just optups, contain = True, stdgen = gen, nrands = nrnds}) tups mkMemoSF gen nrnds optups tups = mkPGOpt (options{primopt = Just optups, contain = False, stdgen = gen, nrands = nrnds}) tupsP setPrimitives creates a ProgGen from the given set of primitives using the current set of options, and sets it as the current program generator. It used to be equivalent to  setPG . mkPGB which overwrites the options with the default, but it is not now.RR loads a component library file.S1f is supposed to be used by load, but not hidden.TT sets the timeout in microseconds. Also, my implementation of timeout also catches inevitable exceptions like stack space overflow. Note that setting timeout makes the library referentially untransparent. (But currently setTimeout 20000 is the default!)UU+ disables timeout. This is the safe choice.VCurrently the default depth is 10. You may want to lower the value if your computer often swaps, or increase it if you have a lot of memory.WW# uses the 'global' values set with set* functions. X is its filtered versionYY\ generates all the expressions that fit the inferred type, and their representations in the H form. It returns a stream of lists, which is equivalent to Spivey's Matrixv data type, i.e., that contains expressions consisted of n primitive components at the n-th element (n = 1,2,...). Z is its filtered versionZY\ generates all the expressions that fit the inferred type, and their representations in the H form. It returns a stream of lists, which is equivalent to Spivey's Matrixv data type, i.e., that contains expressions consisted of n primitive components at the n-th element (n = 1,2,...). Z is its filtered version_Those functions are like Y , but take ; as an argument, which may be polymorphic. For example, {( ([t| forall a. a->a->a |] >>= return . _ True 10 memo)& will print all the expressions using memo whose types unify with forall a. a->a->a. (At first I (Susumu) could not find usefulness in finding unifyable expressions, but seemingly Hoogle does something alike, and these functions might enhance it.)`Those functions are like Y , but take ; as an argument, which may be polymorphic. For example, {( ([t| forall a. a->a->a |] >>= return . _ True 10 memo)& will print all the expressions using memo whose types unify with forall a. a->a->a. (At first I (Susumu) could not find usefulness in finding unifyable expressions, but seemingly Hoogle does something alike, and these functions might enhance it.)aThose functions are like Y , but take ; as an argument, which may be polymorphic. For example, {( ([t| forall a. a->a->a |] >>= return . _ True 10 memo)& will print all the expressions using memo whose types unify with forall a. a->a->a. (At first I (Susumu) could not find usefulness in finding unifyable expressions, but seemingly Hoogle does something alike, and these functions might enhance it.)bThose functions are like Y , but take ; as an argument, which may be polymorphic. For example, {( ([t| forall a. a->a->a |] >>= return . _ True 10 memo)& will print all the expressions using memo whose types unify with forall a. a->a->a. (At first I (Susumu) could not find usefulness in finding unifyable expressions, but seemingly Hoogle does something alike, and these functions might enhance it.)cc pred finds an expression e that satisfies pred e == True, and returns it in . dd$ prints the expression found first. ef; prints all the expressions satisfying the given predicate.ff; prints all the expressions satisfying the given predicate.hh is like fq, but by itself it does not print anything. Instead, it creates a stream of expressions represented in tuples of ! and the expressions themselves. ll+ may be used to further filter the results.sio2predi converts a specification given as a set of I/O pairs to the predicate form which other functions accept.tt1 pretty prints the results to the console, using uu is the = version of pprsvpprsIOn depth eio is the counterpart of pprs (take depth eio), while  pprsIO eio is the counterpart of pprs eio. Example: EpprsIOn 5 (everythingIO (mlist::ProgGen) :: EveryIO ([Char]->[Char])) is like >?, but unqualifies (:) before pprinting in order to avoid printing "GHC.Types.:" which GHCi does not accept and sometimes annoys when doing some demo._;<=>?@A+Quote a tuple of primitive components here. This becomes  [Primitive] when spliced.BCDEF6number of random samples at each depth, for each type.G6number of random samples at each depth, for each type.HIJKLMNOPQR This becomes  [Primitive] when spliced.STtime in microsecondsUVmemoization depth. (Sub)expressions within this size are memoized, while greater expressions will be recomputed (to save the heap space).W2whether to include functions with unused argumentsX2whether to include functions with unused argumentsYprogram generator2whether to include functions with unused argumentsZprogram generator2whether to include functions with unused argumentsdummy argumentprogram generator2whether to include functions with unused arguments[dummy argumentprogram generator2whether to include functions with unused arguments\program generator2whether to include functions with unused arguments query depthdummy argumentprogram generator2whether to include functions with unused arguments]program generatordummy argumentprogram generator^_program generator query type`program generator query typeaprogram generator query typebprogram generator query typec2whether to include functions with unused argumentsd2whether to include functions with unused argumentse2whether to include functions with unused argumentsf2whether to include functions with unused argumentsg2whether to include functions with unused arguments2whether to include functions with unused argumentsh2whether to include functions with unused argumentsi2whether to include functions with unused argumentsjklmnopqrstuvwxyz{8      !"#$%&'()*+,-./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 { | } ~  ijklnopqrstuvwxyz{|}~$;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{d$APCFOEGHIJDKNstuvwxyz{|}~opqrLMRSVTU@<;>=cdfgshiljmWY\]_`XZabk^tuvwxyz{ljknieBQrpqno[?_;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{NoneJ replaces uncommon functions like catamorphisms with well-known functions.|}~2whether to include functions with unused arguments            !"#$%&'()*+,-./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 { | } ~  ijklnopqrstuvwxyz{|}~$;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      |}~      |}~      @None   makes sure the predicate string does not use either let or where, and may correct grammatical mistakes. This check should be done on both the CGI frontend side and the backend server side..  (   None35!! is a variant of ` for presenting I/O example pairs. It uses everythingF for generating printable functions. Here `good presentation' is more important than `good randomness'.=!"#$% annotater&'()*CGI.myPath, which is usually "cgi-binMagicHaskeller.cgi"'predicate before escaping single quotes+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]%!"#$%&'()*+,-./0123456789:;<=>?@ABC?'()*+,-.&/0%12345#$]\[Z67YXWVUT8!"9:;<SRQPONMLKJI=HG>F?@AEBDC;!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]None_;get1 can be used to synthesize one expression. For example,JputStrLn $ pprint $ get1 $(c [d| f [] = 0; f [a] = 1; f [a,b] = 2 |]) noBK> \a -> let fa (b@([])) = 0(> fa (b@(_ : d)) = succ (fa d)> in fa a`+getMany does what you expect from its name.bgetManyTyped is a variant of ` that generates typed expressions. This alone is not very useful, but the type info is required when compiling the expression and is used in MagicHaskeller.RunAnalytical.dAlso, ! $(c [d| ... |]) :: SplicedPrims  dL is a helper function for extracting some info from the quoted declarations.eExample:\runQ [d| f [] = 0; f [a] = 1; f [a,b] = 2 |] >>= \iops -> putStrLn $ pprint $ getOne iops []> \a -> let fa (b@([])) = 0(> fa (b@(_ : d)) = succ (fa d)> in fa ahh is like synth, but adds the infered type signature to each expression. This is useful for executing the expression at runtime using GHC API.^ _%target function definition by example4background knowledge function definitions by example`%target function definition by example4background knowledge function definitions by examplea%target function definition by example4background knowledge function definitions by exampleb%target function definition by example4background knowledge function definitions by examplecd efgh ^_`abcdefgh _`abcd^efgh^ _`abcd efgh ANonePijklmnopqrstuvwxyz{|}~Pijklmnopqrstuvwxyz{|}~Pijklmnopqrstuvwxyz{|}~NoneGJ replaces uncommon functions like catamorphisms with well-known functions. pijklmnopqrstuvwxyz{|}~pijklmnopqrvustwxyz{|}~ None    None Example of BquickStart [d| f [] = 0; f [a] = 1 |] noBKQ (\f -> f "12345" == 5)> \a -> let fa (b@([])) = 0(> fa (b@(c : d)) = succ (fa d)*> in fa a :: forall t2 . [t2] -> Int> ^CInterrupted. target I/O pairs,I/O pairs for background knowledge functions test function target I/O pairs,I/O pairs for background knowledge functions test function 1session in which synthesized expressions are run target I/O pairs test function 1session in which synthesized expressions are run target I/O pairs test function 1session in which synthesized expressions are run target I/O pairs,I/O pairs for background knowledge functions test function 1session in which synthesized expressions are run target I/O pairs,I/O pairs for background knowledge functions test function 1session in which synthesized expressions are run target I/O pairs,I/O pairs for background knowledge functions test function 1session in which synthesized expressions are run target I/O pairs,I/O pairs for background knowledge functionstarget I/O pairs,I/O pairs for background knowledge functions test functiontarget I/O pairs,I/O pairs for background knowledge functions test function 0session in which synthesized expressions are runtarget I/O pairs test function0session in which synthesized expressions are runtarget I/O pairs,I/O pairs for background knowledge functions test function0session in which synthesized expressions are runtarget I/O pairs,I/O pairs for background knowledge functions test function0session in which synthesized expressions are runtarget I/O pairs,I/O pairs for background knowledge functions test function0session in which synthesized expressions are runtarget I/O pairs,I/O pairs for background knowledge functions a      !"#$%&'()*+,-./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 { | } ~  ijklnopqrstuvwxyz{|}~$%&'()*+,-./0123456789;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{^_`abcdefgh    BCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyhz{|}~v&&&&&))))    222222222222 2 2 2 2 2222222222222 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQR4S4T 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/      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|K}~AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA      !"#$%&'()*+,-./0123,456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{B|}~~~~                  !!!!!!!!!!!!!!!!!!""""""""""""""""$$$$ $ $ $ $ $$$$$%%%%%%%%%%&&&& &!&"&#&$&%&&&'&(&)&*&+&,&-&.&/&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'['\']'^'H''_'`'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'{'|'}'~'''''''''(((((((((((((((()))^))))***********1111B|B|11111111111133444444444444444444444444444444444444444444444444444444444444444444444444444444444 4 4 4 4 44444455555H55555555555555 5!5"5#5$5%5&5'5(5)5*5+5,5-5.5/505152535455565557558595:5;5< Z = > ? @ A B C D E F G H I J ^  K L M N O P Q R S6T6U6V6W6X6Y6Z6[6\6]6^6_6`6a6b6c7Z7=7>7U7V7?7@7A7B7C7D7F7Y7J7^77Z7N7O d Z e = f g h i j k l m A D n o p q r G s t u v w x y z {  |  } ~                                            P    Z e = f g c i k l m A  q r H u   x y z { ^ | } ~                     P  88888888888888899999x99999899999'999999999999999999v9m9999999999999999999999I999z9:::::::: : : : : ::::::::::::::::::: ;!;!;";#;$;%;&;';(;);*<+<,<-<.</<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=u=v=w=x=y=z={=|=}=~========Ao      !"#$%&'()*+,-./~01~02~03456789:;<=><?@ABCDEFGHIJKLMNOPQRSTU~VW~VX~VY~VZ~V[~0\~0]~0^~0_~0`~0a~0b~0c~0d~0e~0f~0g~0h~0i~0j~0k~0l~0m~0n~0o~0p~0q~0r~0s~0t~0>~0u~0v~0w~0x~0y~0z~0{~|}~|}~~~~?45                                  ! " # $ % & ' ( ) )F * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ?O @ 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@6@ w@ x@ y@ z@ {@ |@ }@ ~@ @ @9@ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @                 Magic_IW47ygan3qv7Nj6NQMs38vMagicHaskellerMagicHaskeller.GetTimeMagicHaskeller.FastRatioMagicHaskeller.IOGenerator"Control.Monad.Search.CombinatorialControl.Monad.Search.BestMagicHaskeller.ExpressionMagicHaskeller.OptionsMagicHaskeller.ClassificationMagicHaskeller.ProgGenMagicHaskeller.ProgGenSFMagicHaskeller.ProgGenSFIORefMagicHaskeller.ExecuteAPI610MagicHaskeller.LibTHMagicHaskeller.AnalyticalMagicHaskeller.LibExcelMagicHaskeller.MinimalMagicHaskeller.RunAnalytical#MagicHaskeller.LibExcelStagedStagedPaths_MagicHaskeller Data.MemoMagicHaskeller.MyCheckMagicHaskeller.NearEqMagicHaskeller.T10MagicHaskeller.TypesMagicHaskeller.PriorSubstsMagicHaskeller.FMTypeMagicHaskeller.TyConLibMagicHaskeller.ReadTHTypeMagicHaskeller.MHTHMagicHaskeller.ReadTypeRepMagicHaskeller.PolyDynamicMagicHaskeller.DebMTMagicHaskeller.FakeDynamicMagicHaskeller.MyDynamicMagicHaskeller.ReadDynamicMagicHaskeller.ReadHsTypeMagicHaskeller.CoreLangMagicHaskeller.InstantiateMagicHaskeller.ShortStringMagicHaskeller.MemoToFilesMagicHaskeller.ExecuteSystem.Posix.Process forkProcessControl.ConcurrentforkIOinit075 initializeMagicHaskeller.TimeOutMagicHaskeller.ExprStagedMagicHaskeller.CombinatorsMagicHaskeller.ProgramGeneratorMagicHaskeller.ClassifyMagicHaskeller.ClassifyDMMagicHaskeller.ClassLibMagicHaskeller.ClassifyTr MagicHaskeller.Analytical.Syntax MagicHaskeller.Analytical.FMExprMagicHaskeller.Analytical.UniT MagicHaskeller.Analytical.Parser$MagicHaskeller.Analytical.SynthesizeLanguage.Haskell.THpprintMagicHaskeller.ExpToHtmlMagicHaskeller.LibExcelStagedghc-primGHC.Prim unsafeCoerce# batchWritebatchRuntimeshowZero showCPUTimelenPrecRationalRatio:%% numerator denominator notANumberreducechoose $fEnumRatio $fRealRatio $fShowRatio$fRealFracRatio$fFractionalRatio $fNumRatio $fEqRatio $fOrdRatioNearEq~=DBMemoDBMunDBMMemoabletabulate applyMemoDBoundTDBTunDBTDBoundDBunDBSearchfromRctoRcfromMxtoMxfromDBfromDFtoDFmapDepthcatBagsmergesortDepthWithByifDepthDelaydelayndelaygetDepth mapDepthDB zipDepthDBRecompTRcTunRcTRecompRcunRcMatrixMxunMxBagStreamcattoList/\\/diagmsumMxmsumRclistToRcrcToMxmxToRcconsMxconsRc zipDepthMx zipDepthRc zipDepth3Mx zipDepth3RcprintMxprintNMx zipWithBFscanl1BFscanlRcshrinkdbtToRcTBestResultgetBestszero fromLists$fMemoableBestBest $fSearchBest $fDelayBest$fMonadPlusBest$fAlternativeBest $fMonadBest$fApplicativeBest $fFunctorBest trToTHTypeHValueHV PrimitiveCoreExpr exprToTHExpMemoType RecomputeRamDiskOptprimopt memodepth memoCondPurememoCondexecutetimeoutforcibleTimeoutguesscontainconstrLtvndelaytv1tv0stdgennrandsfcnrandoptionsforgetnrndschopRndsfnrnds FiltrablefiltfiltFun unsafeFilt unsafeFiltFunRelation fromListBy fromListByDB/ appendWithBydiffBycEQ SStrategysfilterofilter arbitrariesarbs/~ nubSortBy nubSortByBot/</)$fRelationMaybe$fRelationOrdering$fRelationBool$fSStrategyDBound$fSStrategyMatrixseeseeTypeseesseesTypee2THE printTables printTable pprintTypemkVNamemkVNamesmkEsmkAsmkXsmkHdhdmnTHEQaimnTHEQhdmnTHEaimnTHEhdmntyaimntymkTVtvrstvastvrmaxArity maxLenavails maxDebindexmkCEmkCE_LambdaBoundHead ExpressionmkHeadtoCEfromCEmapCEaeAppErrappEnv toAnnExpr toAnnExprWindtoAnnExprWindWind fromAnnExpr reorganize reorganize' reorganizeId replaceVars' reorganizeId'MemoExprMEAnnExprAEaeToMEmeToAE<$>mkHeadAEwindTypedynSngetDyndynssmkDynx finiteDynar finiteDynarr finiteDynss finiteDynsssgetDyn_LambdaBoundHeaddynsssmkDyn_LambdaBoundHeaddynBK reorganizer reorganizerId replaceVars cvtAvailstkr10annotate reorganizeCE'replaceVarsCE' cvtAvails' uniqSorteruniqSort swapUniqSort uniqSortAVLuniqSortPatAVL$fExpressionAnnExpr$fExpressionCoreExpr $fOrdAnnExpr $fEqAnnExprOptionsProgramGeneratorClassLibCLProgGenPGmkCL mguProgramsPGSF ProgGenSF mkTrieOptSFIOfreezePS funApSub_ funApSub_speclookupNormalized tokoro10fstPGSFIORProgGenSFIORef pathToGHCloadObj prepareAPIpackageNameToFlagunsafeExecuteAPI executeAPI executeTHExpcompileCoreExpr unwrapCorece2b runCoreExprrunPrepedCoreExpr stmtToCoreperror thExpToStmt wrapLHsExprthExpToLHsExprcompileExprHscMainrepeatNrepeatIOforce$fEqExprFilter EverythingEveryIOEverymkCurriedDeclsdefinepp1mkPGmkPGXmkMemomkPGSFmkMemoSFmkPG075 mkMemo075mkPGOptmkPGXOptmkPGIO mkPGXOptIO mkPGXOptssetPG setPrimitives zipAppendloadf setTimeout unsetTimeoutsetDepth getEverythinggetEverythingF everything everythingFetup everythingM everythingIO stripEvery unifyablematching unifyableF matchingFfindOneprintOneprintAnyprintAll printAllF filterFirst filterFirstF filterThenFeveryF filterThenfpfpartial fpartialIOfpIOfIOmapIOio2predpprspprsIOpprsIOnlengths lengthsIO lengthsIOn lengthsIOnLnprintQOrderedOrd by1_compare EquivalenceEq--#==PartialPartundefsuccOnlyForNumberslast'tailgcdenumFromThenToinittv1tupletuple'mallmlistmlist'mnatmnaturalmlistnat mlistnaturalmnat_nchdmbmb'natnaturalnat' nat'woPrednatural'plusInt plusIntegernat_paranat_catalist''list'list list_parabooliF postprocessbyMapbyEqsbyOrdsskipskipEqskipOrd appearsInppLambdappvppopnppdropconstEflipEplusEdropEreverseElengthEsumEproductEprocSucc postprocessQexploitbooleanundefsby1_head--#!! prelPartialeq by1_eqMaybe eqMaybeBy by1_eqListeqListBy by2_eqEither eqEitherBy by2_eqPaireqPairByeqs prelEqRelateddataListEqRelated--#/=by1_elem by1_groupby1_nubby1_isPrefixOfby1_isSuffixOf by1_isInfixOfby1_stripPrefix by1_lookupcmp by1_cmpMaybecompareMaybeBy by1_cmpList compareListBy by2_cmpEithercompareEitherBy by2_cmpPair comparePairByordsprelOrdRelateddataListOrdRelated--#<=--#<by1_maxby1_minby1_sortintinstintinst1 intpartialsintinst2list1list1'list2list3list3'nats reallyall generatormixsosorichpoormixrarich'mxdebugpgfullpgfullsmkPgFull mkPgTotal mkDebugPgdebpgfullIOfull clspartialss tupartialsstupartialssNormalliterals fromPrelude fromDataList fromDataChar fromDataMaybepgWithDoubleRatiopgWithDoubleRatioswithDoubleRatio pgWithRatio pgWithRatiospgRatiopgRatios withRatioratioCls fromPrelRatio fromDataRatio pgWithDouble pgWithDoublesmkPgWithDouble withDouble doubleClsfromPrelDouble ShowArbitraryshowArbitraries IOGeneratorgenerateIOPairsAnnShowS ShownIOPairshowIOPairsHTMLshowIOPairsWithFormsHTMLshowIOPairsHTML'nubOn nubSortedOn nubSortedOn'iopairToInputs assToStringshowIOPairHTMLshowIOPairWithFormHTMLmkForm showsInputs escapeQuotegenerateIOPairsLitNum integralsmhGenerateIOPairssassasNumsasFalse sasIntegralmapSAchopBycvt showsListgenerateIOPairsFun$fIOGeneratora$fShowArbitrary(->)$fShowArbitrary[]$fShowArbitrary(,,)$fShowArbitrary(,)$fShowArbitraryEither$fShowArbitraryMaybe$fShowArbitraryRatio$fShowArbitraryOrdering$fShowArbitraryChar$fShowArbitraryDouble$fShowArbitraryFloat$fShowArbitraryInteger$fShowArbitraryInt$fShowArbitraryBool$fShowArbitrary()$fIOGenerator(->)$fIOGenerator(->)0$fIOGenerator(->)1$fIOGenerator(->)2$fIOGenerator(->)3$fIOGenerator(->)4$fIOGenerator(->)5$fIOGenerator(->)6$fIOGenerator(->)7$fIOGenerator(->)8 SplicedPrimsget1getManygetManyM getManyTypednoBKcgetOnesynthsynthM synthTypedcurry2curry3curry4curry5curry6upperlowerproperleft1right1leftrightdropLeftmidlen concatenate concatenatE concatenaTE concatenATE concateNATEcEILINGmroundfLOOR0fLOORrOUNDroundup rounddowntrimfINDifERRORaNDoRsignpowersQRTlOGlnpIaTAN2factcombinmODdegreesradiansgCDfindIxfinDchar sUBsTITUTE sUBSTITUTEsUBsUBST4countStrleft'2right'2 concatenate'2 cEILING'2mround'2rOUND'2 roundup'2 rounddown'2 ifERROR'2aND'2oR'2power'2lOG'2aTAN2'2combin'2mOD'2gCD'2iF'3mid'3fIND'3 sUBsTITUTE'3 concatenatE'3 concatenaTE'4 concatenATE'5 concateNATE'6ppExcelleftErightElenEabsEmkIF mkUncurriedmkSUBST4mkVarOpchar7lit0lit1 mkPgExcel mkPgExcels<>excelf1Ef1EFef1EIOf1EFIOnoBKQ quickStart quickStartF filterGetOne_ filterGetOnefilterGetOneBK synthFilt synthFiltFsynthAll$fFractionalInt $fRealFracIntcatchIOversionbindirlibdirdatadir libexecdir sysconfdir getBinDir getLibDir getDataDir getLibexecDir getSysconfDirgetDataFileNameMapListMapRealMapCharMapIxMIxMapNat MapIntegralMInegArrow nonnegArrowMapIntMapLargeIntegralMLI MapInteger MapFiniteListMFLnilArrow consArrowML MapTripletMapPairMP MapEitherMapMaybeMM MapOrderingMOMapBoolMBMapUnitMUFunctionProperty==> getFunctionmemoUnitappUnitmemoBoolappBoolprop_inverseBool memoOrdering appOrdering memoMaybeappMaybeprop_inverseMaybe memoEither appEitherprop_inverseEithermemoPairappPair memoTriplet appTripletprop_inverseTripletmemoList appList10appList5appList3appList1appListmemoFiniteList appFiniteList isLongerThanprop_inverseListprop_inverseListB memoInteger appIntegermemoLargeIntegralappLargeIntegralmemoIntappInt memoIntegral memoPosNat bitsToPosNat appIntegral appPosNat posNatToBitsprop_inverseIntegralprop_inversePosNatprop_bitsToFromPosNatmemoIx10memoIx3memoIxappIxmemoCharappCharprp_inverseCharmemoRealappRealprop_inverseRealheavy memoHeavy memoizedHeavyheavy2 memoHeavy2memoizedHeavy2 memoHeavy2'memoizedHeavy2'heavy3 memoHeavy3memoizedHeavy3 heavyList memoHeavyListmemoizedHeavyList Coarbitrary coarbitrary Arbitrary arbitraryCoarbGenunGensized arbitraryR arbitraryUnitcoarbitraryUnit arbitraryBoolcoarbitraryBool arbitraryIntcoarbitraryIntarbitraryIntegercoarbitraryIntegerarbitraryIntegral logvariant newvariantarbitraryFloatarbitraryDoublecoarbitraryFloatcoarbitraryDoublefractionarbitraryRealFloatcoarbitraryRealFloat arbitraryCharretSpcarbASCarbNumarbLowarbUppcoarbitraryChararbitraryOrderingarbitraryRatioarbitraryMaybe arbitraryListklglg'multiplyDeBruijnBitPosition arbitraryPairarbitraryEitherarbitraryTriplet arbitraryFunarbitraryRationalcoarbitraryOrderingcoarbitraryListcoarbitraryMaybecoarbitraryEithercoarbitraryRatiocoarbitraryPaircoarbitraryTripletcoarbitraryFun$fCoarbitraryRatio$fArbitraryRatio$fCoarbitrary(->)$fArbitrary(->)$fCoarbitrary(,,)$fArbitrary(,,)$fCoarbitraryEither$fArbitraryEither$fCoarbitrary(,)$fArbitrary(,)$fCoarbitrary[] $fArbitrary[]$fCoarbitraryMaybe$fArbitraryMaybe$fCoarbitraryOrdering$fArbitraryOrdering$fCoarbitraryChar$fArbitraryChar$fCoarbitraryDouble$fArbitraryDouble$fCoarbitraryFloat$fArbitraryFloat$fCoarbitraryInteger$fArbitraryInteger$fCoarbitraryInt$fArbitraryInt$fCoarbitraryBool$fArbitraryBool$fCoarbitrary() $fArbitrary() $fMonadGen$fApplicativeGen $fFunctorGen $fNearEq(,,) $fNearEq(,)$fNearEqEither $fNearEqMaybe $fNearEq[] $fNearEqRatio$fNearEqInteger $fNearEqInt $fNearEqChar$fNearEqOrdering $fNearEqBool $fNearEq() $fNearEqFloat$fNearEqDoubleliftListscan10mergesortWithBymergesortWithByBotmergesortWithByBotIOmergesortWithByBot'mergesortWithByBot'IOmerge_pairsBotmerge_pairsBotIO mergeWithBymergeWithByBotmergeWithByBotIO diffSortedBydiffSortedByBot tokoro10niltokoro10!?shrinkDBDepthFstnilsjOINconstrans categorizeDB categorizeuncategorizeDB uncategorizeswaptest''test'main$fMemoableDBMemoDBound$fMemoableMatrixRecomp$fSearchDBoundT$fSearchDBound$fDelayDBoundT $fDelayDBound$fMonadPlusDBoundT$fAlternativeDBoundT$fMonadPlusDBound$fAlternativeDBound$fMonadDBoundT$fApplicativeDBoundT $fMonadDBound$fApplicativeDBound $fShowDBound $fShowRecomp$fSearchMatrix$fSearchRecompT$fSearchRecomp $fSearch[] $fDelayStateT$fDelayRecompT $fDelayMatrix $fDelayRecomp $fDelay[] $fDBDBoundT $fDBDBound$fMonadPlusRecompT$fAlternativeRecompT$fMonadPlusRecomp$fAlternativeRecomp$fMonadRecompT$fApplicativeRecompT $fMonadRecomp$fApplicativeRecomp$fFunctorDBoundT$fFunctorRecompT$fFunctorDBound$fFunctorRecomp$fFunctorMatrix$fMonadPlusMatrix$fAlternativeMatrix $fMonadMatrix$fApplicativeMatrix$fMonoidRecompT$fMonoidRecomp$fMonoidMatrixSubstTyped:::DecoderDecTypeNameTyConTyVarKindTypeTVTCTA:>:->:=>tracesizemapTV negateTVIDs limitTypelt alltyvars alltyvars'tyvarstyvars'maxVarIDnormalizeVarIDs normalizeeqType saferQuantify negUnquantifyquantify quantify' unquantify unifyFunApuniFunApmguFunApmfa pushArgsCPSpushArgsgetRetgetArgsgetLongerAritygetArity splitArgsCPS splitArgs revSplitArgs revGetArgspopArgstypeetyper showsAssoc emptySubst unitSubstmatchmatch2Apmgumgu2ApvarBindsubstOK assertsubst plusSubst lookupSubstapply applyCheck $fShowType$fFunctorTyped GHC.TypesIntbaseGHC.IntInt8Int16Int32Int64 reserveTVars PriorSubstsPSunPS substOKPSmonsubstmkPSrunPSdelayPSndelayPS convertPSdistPSapplyPSupdatePS updateSubstPSsetSubstmguPSmgtPS varBindPSmatchPS lookupSubstPSgetSubstgetMxupdateMxunifynewTVarpsListToPSRecomppsRecompToPSListpsListToPSDBoundpsDBoundToPSListtup23tup32uniqBy$fFunctorPriorSubsts$fMonoidPriorSubsts$fMonoidPriorSubsts0$fDelayPriorSubsts$fMonadPlusPriorSubsts$fAlternativePriorSubsts$fMonadPriorSubsts$fApplicativePriorSubstsFMTypeEmptyFMTFMTtvFMTtcFMTtaFMTfnFMTfunFMT lookupFMT lookupFMTFMTmapFMTeltsFMT fmtToList fmToTypedVars fmToTypedCons updateFMTunitFMTunionFMT$fMonoidFMTypeTyConLibMap defaultTCL tyConsToTCL defaultTyConstupleMax tuplenameunitdisj nameToTyCon thTypesToTCLthTypesToTyConsthTypeToTyCons showTypeName thTypeToType thTypeToType'tyVarBndrToName typeToTHType typeToTHType'plainTV unPlainTVtvToNamesectionedArrow nameToNameStrshowName showVarName expToExpExp typeToExpType patToExpPat decsToExpDecs decToExpDecclauseToExpClausetrToTypefunTyConundefTCDynamicdynType unsafeFromDyndynExp unsafeToDynaLittleSafeFromDynfromDyn fromDynamicdynApplydynApp dynAppErrfromPDdynamicdynamicHp'px $fShowDynamicMapTypeMTtvMTtcMTgenMTtaMTfunMT PossibilitylookupMTretrievedecode decodeVarencodemkMTmkMT'mkMTIOmkMTIO'interleaveActionsdynSdynKdynIdynBdynCdynS'dynB'dynC'ssprimebprimecprimeundefTCLreadHsTypeSigsmkSigEhsQTypeToTHTypehsTypeToTHTypevarnameshsNameToTHNamehsNameToStringhsAsstToTHTypehsQNameToTHType readHsDecls defaultVarLibdefaultPrimitivesVarLib DictionaryDictundictSKIBCS'B'C'YLambdaX FunLambdaFunXTupleprimIdPrimConContext:$CaseFixVarNameVarisAbsentisa actualVarName stripByd_exprToTHExpLite exprToTHExp' funOccursIn lightBetareplaceliftFunnliftnliftIntnapplyisObviouslyBoringiOBmatchExpprimitivesToTCLprimitivesToVLlenDefaultPrimitives $fReadExp$fEqDictionary$fOrdDictionary uncurryTyArbMemoMap SpecialMapCoarbMapArbMapCmpMapMapTCRTrieTriesMaps GeneratorCmp PackedOrd ExpResultOrder mkUncurry uncurryDynmkCurrycurryDyn uniqueVarstypeToRandomsOrdtypeToRandomsOrdDMttro dynToCompare uncurryTy'pair mkRandTrieargTypeToRandomsargTypeToRandomssnubByCmpmkMapmkCmpMap compareMaybe compareRatiocompareRealFloat compareList compareEither comparePair typeToCompare typeToOrdmkArbMap mkSpecialMap combineTCs typeToArb mkCoarbMap typeToCoarb mkMemoMap memoLength typeToMemoarbitrariesByDyn arbsByDyn genAppDynarbitrariessByDynabd arbsByDyn'gens ShortString showsBriefly readsBriefly showBriefly readBriefly$fShortStringType$fShortString()$fShortString(,)$fShortString(,,)$fShortStringWord8$fShortStringInt8$fShortStringInt16$fShortStringInt$fShortStringCoreExpr$fShortStringBool$fShortString[] memoToFileMemoCondfps memoPSRTIOmemoRTIOmemoer unDeBruijnundeblambdaisFreeInfreeVar unsafeExecutefixunsafeWithPTOOptmaybeWithTOOpt unsafeWithPTO maybeWithTOBoolOrderingnewPTOunsafeOpWithPTO maybeWithTO'withTO' wrapExecutionmeasureExecutionTimecatchIthandler realHandler catchYield childHandlerrealChildHandler finiteHVss finiteHVsssmkTrieIOmatchingProgramsIOunifyingProgramsIOmkTriePrimCommonCmnopttclvlpvlrtProgramGeneratorIO mkTrieOptIO mkTrieOptmatchingProgramsmatchingProgramsWOAbsentsunifyingPrograms WithCommon extractCommon extractTCL extractVL extractRTriereducermkCommonretsTVar annotateTCEs splitPrims splitPrimssmapSumapplyDowindwind_fromAssumptionsretMono fromAvailmguAssumptionsmguAssumptions'matchAssumptionsmguAssumptions_mguAssumptions_' retPrimMonofunApSub funApSubOpfap mapAndFoldMretGenretGen' retGenOrdorderedAndUsedArgsusedArg retGenTV1 retGenTV0 filtExprs filterExprs getArgExprsgaeconstEqceqrecHead retSameValrsvrsv' returnsAtoA returnsIdisIdisId'isId''retValrvmapsub isConstrExprisClosed isClosed'includesStrictArganyRec recursiveconstRec belowIsUsedisUsedmkSubstsmkSubstmkRetty reorganizer_hitcombstailsmapFst3 decodeVarsPos decodeVarsCE decodeVarsCE' FiltrableBFCmpBotfilterBF spreexecute opreexecuteunscanlfilterDBfilterRc sfilterRcunscanlByListMxunscanlByListRcdeleteListByList comparers liftCompareliftCmpliftCompareBot liftCmpBotcmpBotcmpBotIOdlbBotdlbrepEqClsBy_simple repEqClsByMx repEqClsByRc eqClsBy_naivefcnrndcnrndstcnrnds repEqClsByeqClsBy eqClsByNth eqClsByFstNs isLongEnoughfilterEligiblesmergeBy ofilterRc unscanlBy///$fFiltrableBFDBound$fFiltrableBFRecomp$fFiltrableBFMatrixMemoDebMemoTrieBFMBFtraceTyfromMemotoMemolmtlookupFunsSharedlookupFunsPolyunifyingPossibilitiesunifyingPossibilitiesIOmkTriePGmkTrieMD mguProgramsIO mguProgsIOmguProgsmguFuns generateFuns lookupListrie$fProgramGeneratorIOProgGen$fProgramGeneratorProgGen$fWithCommonProgGen sortWithByBotselect spreexecuteDMsprDM forceList filterList filterListDBfilterDM filterDMIO filterDMlitelistCmp nthCompareBot listCmpBotnthCompareBotIO listCmpBotIO sfilterDMBitSetBFTTypeTrieExpTrieExpTip reorganize_ reorganizer'reorganizerId'classify traceExpTyfiltBFfDMfiltBFIOlmttymemocond matchProgsspecializedPossibleTypes mkTrieOptSFdbToCumulativeMxdbtToCumulativeMxmkMTtymkMTexpmondepthunBFM tokoro10apspecializedTypesspecializedCases specCases uniExprs_lookupReorganized specTypesfunApSub_forcingNilfunApSub_forcingNil_specfunApSub_forcingNil_contfunApSub_forcingNil_cont_specmguAssumptionsBitsmguAssumptionsBits' specCases'lookupWithAbsentslookupNormalizedSharedETunifyableExprs memocondexplookupTypeTrielookupTypeTrieAndExpTrielookupNormReorganized lookupNormlookupNormalizedShared countBitslookupNormalizedSharedBitsmatchFunctions matchFuns matchFuns'fromAssumptionsBits retMonoBitsretPrimMonoBits funApSubBitsfunApSubOpBitsfunApSubBits_resettingfunApSubOpBits_resettingfapBitsforceNilfunApSubBits_forcingNilfunApSubBits_forcingNil_contfunApSubOpBits_forcingNil_contfunApSubOpBits_forcingNil countBits32 retGenOrdBits retGenTV1Bits retGenTV0BitsmatchAssumptionsBits$fMonoidWord32$fWithCommonPGSF$fProgramGeneratorPGSFfiltBFminconsistentDBTToRcT computeExpTiplookupUniExprs makeUniExprsunifyableExprsIOlookupTypeTrieIOprocTuplookupReorganizedIOlmtIO ensureAtHand makeAtHand addToLastmkSinglematchFunctionsIO matchFunsIO$fWithCommonPGSFIOR$fProgramGeneratorIOPGSFIORTreeTrForestfilterTrbagCmp prop_mkTipmkTip mkForestsmkForestaccumulateForests mergeForests differencediff flattenTrremoveFirstOfFirstEU numUniIDsinputsapfreshTermStatTSunTSConstrExpranniDszctorfieldsTBSIOPairIOPoutputnormalizeMkIOPvrmapU maybeCtorhasExistentialvisibles unifyListbindoccursInfreshmapE applyIOPsapplyIOPmapIOPmapTypeeinitTSupdateTSevalTStermCritfullyLex revFullyLexaWiserevAWiselinearrevArgslessRevListsLex lessListsLex cmpExprsscmpExprs cmpExprSzscap $fFunctorExpr$fFunctorIOPairFMExprFMExprs EmptyFMEsFMEsnilFMEsconsFMEsEmptyFMEFMEexistentialFME universalFMEconApFME iopsToVisFME iopsToFMEvisIOP iop2Assoc assocsToFME updateFME updateFMEsemptyFME insertNthunifyFME unifyFME' unifyFMEsvalsFMEvalsFMEsmatchFME matchFME'matchExistential matchFMEs$fFunctorFMExprs$fFunctorFMExprStsubstnextVarUniTemptyStfreshIOPapplyUT applyIOPUTunifyUT appUnifyUTXVarLibXVLvarLib invVarLibzeroIDsuccIDnegateID mkXVarLib extractNameparseTypedIOPairssinferTypedIOPairssparseTypedIOPairss'plus parseTypes parseIOPairssclauseToIOPairclauseToIOPair' matchTypeunquantifySubstmguType inferTypeinferTfunApMfAM tapplyIOP tapplyExpr unzipTypedgetMbTypedConstrgetTypedConstr mkTypedConstrpatToExpstrToIntnatLimit natToConExpsmallNat thExpToExprFunBKFRec IntroUniT IntroducerBK maxNumBVsarityiopairsfmexpr toBeSoughtmkBKFunmkRecFun mkInitRecFun setIOPairsapplyFun analyticSynthanalyticSynthAndInfTypefastAnalSynthNoUniTfastAnalSynthmNoUniTanalSynthNoUniT analSynth analSynthm headSpine analSynthUTmmkArgs+++ ndelayIntrointroAny+/ introVarUTm introVarm introVarm'introVar introConstr divideIOP shareConstr sConstrIs introCasedropNthintroBKm introBKUTmintroBKsubtractIOPairsFromIOPairsBKUTmsubtractIOPairsBKUTmsubtractIOPairsFromIOPairsUTmsubtractIOPairsFromIOPairsUTm'subtractIOPairsUTmsubtractIOPairUTmsubtractIOPairsFromIOPairsmsubtractIOPairsFromIOPairsmFMEsubtractIOPairsmFMEsubtractIOPairsFromIOPairsBKm subtractIOPairsFromIOPairsBKmFMEsubtractIOPairsBKmFMEunifyingIOPairstemplate-haskellLanguage.Haskell.TH.SyntaxExppprintUCp1' useArrowTuAT primitivesp expIsAConstrnumCxtstoCxt primitivescmkPG'mkPGSF' refmemodeb defaultMDtrsToTCL trsToTCstrsetnoFiltermatchPs mxExprToEverymxExprFiltEveryunwrapAEeMeIOstripgenExpsfindDofpartfpartIOspawnIOunqConsnewNamemkNameunTypeLanguage.Haskell.TH.LibcharLstringLintegerLintPrimL wordPrimL floatPrimL doublePrimL rationalLlitPvarPtupPconPinfixPtildePbangPasPwildPrecPlistPsigPviewPfieldPatclausevarEconElitEappEinfixEinfixAppsectionLsectionRlamElamCaseEtupEcondEmultiIfEletEcaseEdoEcompEfromE fromThenEfromToE fromThenToElistEsigErecConErecUpdEstaticEfieldExpguardedBnormalBnormalGEpatGEbindSletSnoBindSparSfunDvalDdataDnewtypeDtySynDclassD instanceDsigDforImpDpragInlD pragSpecD pragSpecInlD pragSpecInstD pragRuleDpragAnnD familyNoKindD familyKindD dataInstD newtypeInstD tySynInstDclosedTypeFamilyKindDclosedTypeFamilyNoKindD roleAnnotDstandaloneDerivD defaultSigDcxtisStrict notStrictnormalCrecCinfixCforallC strictType varStrictTypeforallTvarTconTtupleTarrowTlistTappTsigT equalityTlitT promotedTpromotedTupleT promotedNilT promotedConsTnumTyLitstrTyLitnominalRrepresentationalRphantomRinferRvarKconKtupleKarrowKlistKappKstarK constraintKcCallstdCallcApiprim javaScriptunsafesafetypeFamdataFamtySynEqnruleVar typedRuleVarData.Typeable.InternalmkAppTyTypeableTypeRepMatchClauseQExpQDecQPatMatchQClauseQStmtQConQTypeQVarStrictTypeQ StrictTypeQFieldExpFieldPatNamePatQ FieldPatQFunDepPredPredQ TyVarBndrDecsQ RuleBndrQ TySynEqnQTExpNoInlineInline InlinableConLikeFunLike AllPhases FromPhase BeforePhase Data.Typeablegcast2gcast1gcasteqTcastrnfTyCon rnfTypeRep showsTypeReptypeOf7typeOf6typeOf5typeOf4typeOf3typeOf2typeOf1typeOftypeReptypeRepFingerprint tyConString typeRepArgs typeRepTyConmkTyCon3 funResultTy splitTyConAppmkFunTy mkTyConApp tyConName tyConModule tyConPackagetyConFingerprint Typeable1 Typeable2 Typeable3 Typeable4 Typeable5 Typeable6 Typeable7 Data.ProxyProxyData.Type.EqualityRefl:~:Language.Haskell.TH.Ppr pprParendTypepprPatpprLitpprExpppr_listpprPpr thisModuleappsEequalPclassP pragLineDstringE arithSeqElam1EuInfixEparensEglobaldynpatGnormalG fromThenToRfromToR fromThenRfromRparensPuInfixP stringPrimLInfoQTyLitQCxtQBodyQGuardQRangeQ defaultFixity maxPrecedenceunboxedTupleTypeNameunboxedTupleDataName tupleTypeName tupleDataName nameModulenameBaserunIOlocation isInstance reifyModulereifyAnnotations reifyRolesreifyInstancesreifylookupValueNamelookupTypeNamerecover reportWarning reportErrorreportrunQ NameSpaceloc_end loc_start loc_module loc_package loc_filenameLocTyVarIVarIDataConI PrimTyConIFamilyITyConIClassOpIClassIInfo ModuleInfo ParentNameArityUnlifted InstanceDecFixityInfixNInfixRInfixLFixityDirection StringPrimL DoublePrimL FloatPrimL WordPrimLIntPrimL RationalLIntegerLStringLCharLLitViewPSigPListPRecPWildPAsPBangPTildePParensPUInfixPInfixPConP UnboxedTupPTupPVarPLitPStaticERecUpdERecConESigEListE ArithSeqECompEDoECaseELetEMultiIfECondE UnboxedTupETupELamCaseELamEParensEUInfixEInfixEAppELitEConEVarENormalBGuardedBBodyPatGNormalGGuardParSNoBindSLetSBindSStmt FromThenToRFromToR FromThenRFromRRange DefaultSigDStandaloneDerivD RoleAnnotDClosedTypeFamilyD TySynInstD NewtypeInstD DataInstDFamilyDPragmaDInfixDForeignDSigD InstanceDClassDTySynDNewtypeDDataDValDFunDTySynEqnDataFamTypeFam FamFlavourExportFImportFForeign JavaScriptCApiStdCallCCallCallconv InterruptibleSafeUnsafeSafetyLinePAnnPRulePSpecialiseInstP SpecialisePInlinePPragma RuleMatchPhases TypedRuleVarRuleVarRuleBndrValueAnnotationTypeAnnotationModuleAnnotation AnnTargetCxtUnpacked NotStrictIsStrictStrictForallCInfixCRecCNormalCConLitT ConstraintTStarT PromotedConsT PromotedNilTPromotedTupleTListT EqualityTArrowT UnboxedTupleTTupleT PromotedTConTVarTSigTAppTForallTKindedTVPlainTVStrTyLitNumTyLitTyLitInferRPhantomRRepresentationalRNominalRRole AnnLookupNameAnnLookupModule AnnLookupreviewLanguageLHaskellLExcel LJavaScript QueryOptionsdepthabsents defaultQO versionInfo mhVersion ghcVersionexpToPlainString expToStringexpSigToStringpprnnreplaceRightArrowmkButtonusesBlackListedpartial escapeHTMLannotateString annotateWordxlmapannotateEverywhere annotateFree patsToNames patToNames annotateNamerefLinkrefermkLinkreferMb mapNameModulerepch3mkAssocpreludeNameBasesdataCharNameBases primssToStrs primsToStrs primsToNames referHackage hackageEncode referHoogleStrategyconEsconPs synthesizechopNprepare quickStartC quickStartCF filterGet1_ filterGet1 filterGet1BKgetFiltgetFiltFgetAll batchExamplethExpssToEvery