2qq       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                           !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./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/5060708090:0;0<0=0>0?0@0A0B0C0D0E0F0G0H1I1J1K1L1M1N1O1P1Q1R1S2T2U3V3W3X3Y3Z4[4\5]6^6_6`6a6b6c6d6e6f6g6h6i6j6k6l6m6n6o6p6q6r6s6t6u7v7w7x7y7z7{7|7}7~77777888888888889999999999999999::::::::::::::::;;;<<<=============>>>>>>??????????@ABBBBBBBBBBBBBBBBBBBBCCCCCCDDDEEEEFFFGGHHIIIIIIIIIIJJKK K K K K LLLLLLLLLLLLLLLLLLL L!L"L#L$L%M&M'M(M)M*M+M,M-M.M/M0M1M2M3M4M5M6M7M8M9M:M;M<M=M>M?M@MAMBMCMDMEMFMGMHMIMJMKMLMMMNMOMPMQMRMSMTMUMVMWMXMYMZM[M\M]M^M_M`NaNbNcOdOeOfOgOhOiOjOkOlOmOnOoOpOqOrOsOtOuOvOwOxOyOzO{O|O}O~OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOPPPQQQQQRRRRRRRRRRRRRRRRRRRRRRRRRRSSSTTTTTTTTTTTUUVNone9;M !""!  !"NoneM #$%&'()*+,- #$%&'()*+, #$%&'()*+,- #$%&'()*+,-#4$5%5&5'5(3)3SafeM ./01234./01234./01243 ./01234None05M:Dsource files to checkE%path to directory for including specsFBcheck subset of binders modified (+ dependencies) since last checkG1uninterpreted integer multiplication and divisionH,interpretation of string theory in the logicI)allow higher order binders into the logicJallow higher order qualifiersK$allow function extentionality axiomsL%allow lambda alpha-equivalence axiomsM$allow lambda beta-equivalence axiomsN-allow lambda normalization-equivalence axiomsO'check all binders (overrides diffcheck)Psave fixpoint queryQset of binders to checkRIwhether to complain about specifications for unexported and unused valuesSdisable termination checkTenable gradual type checking UBCheck for termination and totality, Overrides no-termination flagsV*automatically construct proofs from axiomsW*disable warnings output (only show errors)X1disable creation of intermediate annotation filesY%type all internal variables with trueZdisable case expand[enable strata analysis\disable truing top level types]check totality in definitions^$enable prunning unsorted Refinements_)number of cores used to solve constraints`Minimum size of a partitiona2Maximum size of a partition. Overrides minPartSizebAthe maximum number of parameters to accept when mining qualifierscBname of smtsolver to use [default: try z3, cvc4, mathsat in order]d0drop module qualifers from pretty-printed names.e)don't show subtyping errors and contexts.fIfind and use .cabal file to include paths to sources for imported modulesg#command-line options to pass to GHCh..c files to compile and link against (for GHC)ieliminate (i.e. don't use qualifs for) for "none", "cuts" or "all" kvars , noEliminate :: Bool -- ^ don't eliminate non-top-level and non-recursive KVars , oldEliminate :: Bool -- ^ use old eliminate algorithm (for benchmarking only)jport at which lhi should listenk<Automatically generate singleton types for data constructorsl?Do not automatically lift data constructor fields into measuresm.scrape qualifiers from imported specificationsn*scrape qualifiers from auto specificationso4scrape qualifiers from used, imported specificationspprint eliminate statsq)eliminate upto given depth of KVar chainsr#print results (safe/errors) as JSONs3attempt to generate counter-examples to type errorst2check and time each (asserted) type-sig separatelyuAtreat code patterns (e.g. e1 >>= x -> e2) specially for inferencev9print full blown core (with untidy names) in verbose modew.simplify GHC core before constraint-generationxtreat non-linear kvars as cutsyHow to instantiate axiomsz"How to create automatic instances {Fuel for axiom instantiation |Debug Instantiation }!Disable non-concrete KVar slicing[56789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~R56789;:<=>?@ABCgr_`aGHiqpTKLMNx}PwvZF]USDEIJOQRVWXY[\^bcdefhjklmnostuyz{|~RBCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}5678~=>?@A9:;<56789:;<=>?@AB;CDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~Safe05M SafeM6Gross hack, to force dependency and loading of module. NoneM Safe 9:;<=DMRFunction Equality )proof operators with optional proof terms5Comparison operators requiring proof terms optionallyBecause provide lemmata ? or "5,Proof combinators (are Proofean combinators)Gproof goes from Int to resolve types for the optional proof combinators%proof operators requiring proof terms*Comparison operators requiring proof terms-& 3333332333333 SafeBM8 NoneLM5     5     5     5     None 0259;LM*KSimple unstructured type for panic ----------------------------------------KGeneric Type for Error Messages -------------------------------------------:INVARIANT : all Error constructors should have a pos fieldliquid type error(liquid type error with a counter-example liquid type error!condition failure error"specification parse error#sort error in specification$sort error in specification%#multiple alias with same name error&$multiple specs for same binder error'(multiple definitions of the same measure(bad data type specification (?))*refined datacon mismatches haskell datacon*Invariant sort error+Using sort error,Incompatible using error-Measure sort error.Haskell bad Measure error/Unbound symbol in specification0#GHC error: parsing or type checking1)Mismatch between Liquid and Haskell types27Mismatch in expected/actual args of abstract refinement3%Cyclic Refined Type Alias Definitions45Illegal RTAlias application (from BSort, eg. in PVar)6Termination Error7!Refined Class/Interfaces Conflict8Non well sorted Qualifier99Previously saved error, that carries over after DiffCheck< Sigh. Other.=haskell type locationSlq type locationaDifferent kinds of Check  Obligations% ------------------------------------b"Obligation that proves terminationc!Obligation that proves invariantsd,Obligation that proves subtyping constraintseKContext information for Error Messages ------------------------------------k'Construct and show an Error, then crashl'Construct and show an Error, then crashm'Construct and show an Error, then crashnConstruct and show an Error with an optional SrcSpan, then crash This function should be used to mark unimplemented functionalityoConstruct and show an Error with an optional SrcSpan, then crash This function should be used to mark impossible-to-reach codepaths !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~[ !"#$%&'()*+,-./0123456789:;<[ILH=Q>\GP_?@ABCDEFJKMNORSTUVWXYZ]^`abcdefghijklmnopqrs !"#$%&'()*+,-./0123456789:;<=>?@A=>BCA=>?@A=D>?E=>F=GH>=GI>=GJK=GK=GLK=G>=G>=M>=M>=NO>=P>=P>=G=>=GQRS=TGUVW=X=YZ=YZ>=[>=\]=^>=_>==>`=>efghiabcdjmlnokpsrq: !"#$%&'()*+,-./0123456789:;<=>?@A=>BCA=>?@A=D>?E=>F=GH>=GI>=GJK=GK=GLK=G>=G>=M>=M>=NO>=P>=P>=G=>=GQRS=TGUVW=X=YZ=YZ>=[>=\]=^>=_>==>`=>abcdefghijklmnopqrstuvwxyz{|}~SafeMNone$%&9;LMOTb                           ! " # $ % & ' ( ) * + , - . / 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 { | } ~  None %&9;LMOTKData type for high-level patterns -----------------------------------------e1 >>= x -> e2xm$dTet"return"xeC  x1,...,xni :: NatLT {len patBinds}KLift expressions into High-level patterns ---------------------------------KLower patterns back into expressions --------------------------------------  None$%&9;LMOTb KManipulating Source Spans -------------------------------------------------KDatatype For Holding GHC ModGuts ------------------------------------------KEncoding and Decoding Location --------------------------------------------KGeneric Helpers for Accessing GHC Innards ---------------------------------KPretty Printers -----------------------------------------------------------KManipulating CoreExpr -----------------------------------------------------KPredicates on CoreExpr and DataCons ---------------------------------------KSymbol Conversions --------------------------------------------------------KManipulating Symbols ------------------------------------------------------KGHC Compatibility Layer ---------------------------------------------------,Symbol Instances      !"#$%&'()*+,-./0o     0/.-,+*)('&%$#"!      y       !"#$%&'()*+,-./0None9;LMb456789:;<=>?@A456789:;7456A@?>8=<9:; 456789:;<=>?@ANoneMB A single spanC,binder for whom we are generating constraintDnearest known Source SpanE Opaque type for a stack of spansBCDE FGH IJBCDEFGHIBCDEFGHI BCDE FGH IJNone09:;LMT' K LM N    OPQKLMNKLMN#   K LM N    OPQNone %&9:;LMOT A  RewriteRule. is a function that maps a CoreExpr to anotherRKTop-level rewriter -------------------------------------------------------- KRewriting Pattern-Match-Tuples -------------------------------------------- `hasTuple ys e` CHECKS if e- contains a tuple that "looks like" (y1...yn) J`replaceTuple ys e e'` REPLACES tuples that "looks like" (y1...yn) with e' The substitution ( \) can change the type of the overall case-expression, so we must update the type of each  1 with its new, possibly updated type. See: Mhttps://github.com/ucsd-progsys/liquidhaskell/pull/752#issuecomment-228946210 8`substTuple xs ys e'` returns e' [y1 := x1,...,yn := xn] D`isVarTup xs e` returns `Just ys` if e == (y1, ... , yn) and xi ~ yi R                      ! "RR R                      ! "None9;ILMSKA-Normalize a module ------------------------------------------------------ #A-Normalize a CoreBind3 -------------------------------------------------- $*eta-expand CoreBinds with quantified types %KANF Environments ----------------------------------------------------------& & ' ( ) * + , - . / 0 1S 2 3 4 # 5 6 $ 7 8 9 : ; < = > ? @ A B % C D E F GSS & ' ( ) * + , - . / 0 1S 2 3 4 # 5 6 $ 7 8 9 : ; < = > ? @ A B % C D E F GNone!"*/023459:;<=IM^_KKVar Profile --------------------------------------------------------------`Recursive binder letrec x = ...aNon recursive binder  let x = ...eInt is the number of casesgProjecting out field ofhKOutput --------------------------------------------------------------------tCAnnotations -------------------------------------------------------Measures Measure Refinement: {v | v = e }Measure Refinement: {v | (? v)  = p }Measure Refinement: {v | p}KRefinement Type Aliases ---------------------------------------------------KModule Names --------------------------------------------------------------KSource Information Associated With Constraints ----------------------------KError Data Type -----------------------------------------------------------.The type used during constraint generation, used also to define contexts for errors, hence in this file, and NOT in elsewhere. **DO NOT ATTEMPT TO MOVE** Am splitting into + global : many bindings, shared across all constraints + local : few bindings, relevant to particular constraintsthe "global" names for modulethe "local" names for sub-exprsKConstructor and Destructors for RTypes ------------------------------------Refinement Type Aliasesname of the aliastype parametersvalue parameterswhat the alias expands tostart positionend positionData type refinementsType Constructor NameTyvar ParametersPVar ParametersPLabel Parameters  DataCon, [(fieldName, fieldType)]Source Position/Measure that should decrease in recursive callsEValues Related to Specifications ------------------------------------ x -> EVar xx -> f xEValues Related to Specifications ------------------------------------ERefined Instances --------------------------------------------------- A World is a Separation Logic predicate that is essentially a sequence of binders that satisfies two invariants (TODO:LIQUID): 1. Each `hs_addr :: Symbol` appears at most once, 2. There is at most one  in a list. RTProp is a convenient alias for RefM that will save a bunch of typing. In general, perhaps we need not expose Ref directly at all. Ref describes `Prop ` and HProp? arguments applied to type constructors. For example, in [a] {h- v > h}>, we apply (via ! ) * the ( denoted by `{h -> v > h}` to * the B denoted by `[]`. Thus, Ref is used for abstract-predicate (arguments) that are associated with _type constructors_ i.e. whose semantics are _dependent upon_ the data-type. In contrast, the O argument in  in the UReftR applies directly to any type and has semantics _independent of_ the data-type.$Abstract refinement associated with B "forall x y  z:: Nat, w :: Int7 . TYPE" ^^^^^^^^^^^^^^^^^^^ (rt_pvbind) "forall  zw$ . TYPE" ^^^^^ (rt_sbind)$5For expression arguments to type aliases see testspos vector2.hs';let LH match against the Haskell type and add k-vars, e.g. `x:_` see testsposHoles.hs=BCo- and Contra-variance for TyCon --------------------------------Indexes start from 0 and type or predicate arguments can be both covariant and contravaariant e.g., for the below Foo dataTypedata Foo a b c d  p:: b -6 Prop, q :: Int -> Prop, r :: a -> Prop> = F (a r -> b p) | Q (c -> a) | G (Int q -> a r)there will be:varianceTyArgs = [Bivariant , Covariant, Contravatiant, Invariant] variancePsArgs = [Covariant, Contravatiant, Bivariant]? variance info for type variables@%variance info for predicate variablesA>logical UNARY function that computes the size of the structureDGHC Type Constructor HPredicate ParametersE TyConInfoH$TyCon name with location informationI!Is this a class type constructor?JIs Promoted Data Con?QKPredicates ----------------------------------------------------------------U?Abstract Predicate Variables ----------------------------------[*Which Top-Level Binders Should be Verifiedz&The following is the overall type for specificationsA obtained from parsing the target source and dependent libraries|Asserted Reftypes}Assumed Reftypes~Auto generated SignaturesData Constructor Measure SigsDLiterals/Constants e.g. datacons: EQ, GT, string lits: "zombie",...%Measure Types eg. len :: [a] -> InthData Type Invariants that came from the definition of var measure eg. forall a. {v: [a] | len(v) >= 0}Data Type Invariant Aliases,Predicated Data-Constructors e.g. see testsposMap.hs,Predicated Type-Constructors eg. see testsposMap.hsList of  IH free in spec and corresponding GHC var eg. (Cons, Cons#7uz) from testsposex1.hsUHow to embed GHC Tycons into fixpoint sorts e.g. "embed Set as Set_set" from includeDataSet.spec*Qualifiers in Source/Spec files e.g testspos qualTest.hs5Top-level Binders To Verify (empty means ALL binders)8Lexicographically ordered size witnesses for termination5Lexicographically ordered expressions for termination?Mapping of new type type constructors with their refined types.AVariables that should be checked in the environment they are used-Binders to IGNORE during termination checking-Binders to IGNORE during termination checkingJBinders to expand with automatic axiom instances maybe with specified fuelConfiguration OptionsName's exported by the module being verifiedDictionary Environment!Axioms from axiomatized functionsRefinement type aliases=GHC Information : Code & Spec ------------------------------?HPrinter ----------------------------------------------------------------Accessors for RTyCon/HPPrint -----------------------------------------------------------------;For debugging.QKTyConable Instances -------------------------------------------------------JXYZ[\]^ J_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCD HEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~S   5678BCgr_`aGHiqpTKLMNx}PwvZF]USDEIJOQRVWXY[\^bcdefhjklmnostuyz{| !"#$%&'()*+,-./0123456789:;<[ILH=Q>\GP_?@ABCDEFJKMNORSTUVWXYZ]^`abcdefghijklmnopqrsXYZ[\]^_dfe`abcghijklmnopqrstuvwxyz{|}~     ! "#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWYXZ[]\^_a`bcdefghijklmnopqrstuvwxyz{|}~BCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}5678z{|}~[\] FGHIJMNBCDE=>?@A !"#$%&'()*+,)-./.0.123)*4.*5.67)89:.  KL   UVWXYZRSTOP^_`abcdefghijklmnop<;Qabcdtuopqrshijklmn |}~XYZ[\]vwxyz{_`abcdefg^vwxyqrstu>XYZ[\]^ J_`abcdefghijklmnopqrstuvwxyz{|}~     ) !"#$%&'()*+,)-./.0.123)*4.*5.67)89:.;<=>?@ABCD HEFGHIJKLMNOPQRSTUVWXYZ[\]^ _`abcdefghijklmnopqrstuvwxyz {|}~  K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~NoneM h i j k h i j kNone9;M l m n o p q l m n o p qNone059;M                    None*:LM rFrom GHC: TypeRep(KPretty Printing RefType ---------------------------------------------------5KA whole bunch of PPrint instances follow ----------------------------------1!"# s t u v w$ x y z { r | } ~  %&'()*+,-./012345!"#$$!"#1!"# s t u v w$ x y z { r | } ~  %&'()*+,-./012345None9;M 6 7866  6 78None%&*9:;<=LMOT KEmbedding RefTypes --------------------------------------------------------=)Various functions for converting vanilla   to SpecCKHelper Functions (RJ: Helping to do what?) --------------------------------_KType Substitutions --------------------------------------------------------hKAnnotations and Solutions -------------------------------------------------lKFrom Old Fixpoint ---------------------------------------------------------pTBinders generated by class predicates, typically for constraining tyvars (e.g. FNum)qKTermination Predicates ----------------------------------------------------{KPrinting Refinement Types -------------------------------------------------|LAuxiliary Stuff Used Elsewhere ---------------------------------------------}KConverting to Fixpoint ----------------------------------------------------KWrappers for GHC Type Elements --------------------------------------------JReftable Instances -------------------------------------------------------GSubable Instances ----------------------------------------------------- 9 :;<=>?@AB CDE F G HIJKL MN O P Q RSTU V WXYZ[\]^ _`abc d efghij klm n o p qrs t u v wxyz{|}~>9:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuv>BA=>?@jrsqu;<9XYnSTbgcIDCNMJKO_a`]^\[ZUVlptRWLfdhimkovQP:eEHGF  9 :;<=>?@AB CDE F G HIJKL MN O P Q RSTU V WXYZ[\]^ _`abc d efghij klm n o p qrs t u v wxyz{|}~None05:LMThe name of the bound(Type variables that appear in the bounds'These are abstract refinements, for nowThese are value variablesThe body of the bound    None9:M       None09:;LM pvarRType  returns a trivial RType2 corresponding to the function signature for a PVar . For example, if  :: T1 -> T2 -> T3 -> Prop then  pvarRType  returns an RType with an RTycon called  predRTyCon `RApp predRTyCon [T1, T2, T3]` Instantiate U with  0 ----------------------------------------------- replacePredsk is the main function used to substitute an (abstract) predicate with a concrete Ref, that is either an  or RHProp4 type. The substitution is invoked to obtain the  resulting at predicate application sites in VW. The range of the U substitutions are fresh or true RefType0. That is, there are no further _quantified_ U in the target.  Requires:  not $ null sB substRCon :: String -> (RPVar, SpecType) -> SpecType -> SpecTypeGInterface: Modified CoreSyn.exprType due to predApp -------------------#      ^_a`bcdefghijklmnop hijklmnop^_`abcdefg#     !None09:;LMT   "NoneLMThe TagKey is the top-level binder, and Tag is a singleton Int list    #NoneM 3Separating literate files into code/comment chunks.  type string  error string Bline number, total width of lines i.e. max (length (show lineNum))Loc -> (Var, Type)List of error intervalsAFormats Haskell source code using HTML and mouse-over annotationsAFormats Haskell source code using HTML and mouse-over annotations "annotTokenise is absurdly slow: O( tokens x errors) IThe code for classify is largely stolen from Language.Preprocessor.Unlit. ;Join up chunks of code/comment that are next to each other.3  Whether to include anchors.1Whether input document is literate haskell or not3Haskell source code, Annotations as comments at endColoured Haskell source code.Whether to include anchors.!Function to refine comment tokens1Whether input document is literate haskell or notHaskell Source, AnnotationsColoured Haskell source code.                   $                       None9:;MCConverting Results To Answers -------------------------------------This function is put in this module as it depends on the Exception instance, which depends on the PPrint instance, which depends on tidySpecType.Show an Error, then crashKPretty Printing Error Messages -------------------------------------------- Need to put  PPrint Error: instance here (instead of in Types), as it depends on PPrint SpecTypes, which lives in this module.        ! " # $ %            ! " # $ %    $None*59:;M User-defined properties for ADTs9Assumed (unchecked) types; including reflected signaturesImported functions and typesLocal type signaturesReflected type signaturesData type invariants"Data type invariants to be checkedLoaded spec module namesPredicated data definitionsPredicated new type definitionsIncluded qualifier filesRefType aliasesExpression aliasesGHC-Tycon-to-fixpoint Tycon mapQualifiers in source/spec files#Information on decreasing argumentsAVariables that should be checked in the environment they are used Ignore Termination Check in these Functions , axioms :: !(S.HashSet LocSymbol) -- ^ Binders to turn into SMT axioms!Binders to reflect"MAutomatically instantiate axioms in these Functions with maybe specified fuel#7Binders to turn into measures using haskell definitions$5Binders to turn into bounds using haskell definitions%;Binders to turn into logic inline using haskell definitions&4Type Constructors that get automatically sizing info'4Command-line configurations passed in through source(!Measures attached to a type-class)'Mappings from (measure,type) -> measure*Refined Type-Classes+$Terminating Conditions for functions;  !"#$%&'()*+,-./0123456 &7 ' ( ) * + , -8 . / 0 1 29:2XYZ[\] % ./!"#$&'()*+,-0123456782  !"#$%&'()*+,-./XYZ[\]210465378 " !"#$%&'()*+,-./0123456 &7 ' ( ) * + , -8 . / 0 1 29:%None09:;LM _KTop Level Parsing API -----------------------------------------------------5Used to parse .hs and .lhs files (via ApiAnnotations)`Used to parse .spec files 3~The top-level parser for "bare" refinement types. If refinements are not supplied, then the default "top" refinement is used. 4 For debugging 5-Parse a single top level liquid specification 6Try the given parser on the tail after matching the reserved word, and if it fails fall back to parsing it as a haskell signature for a function with the same name. 7KSame as tyBindsP, except the single initial symbol has already been matched 8 class measure 9LHS of the thing being defined :@Parsing Qualifiers ---------------------------------------------<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^ ; < = > ? @ A B_` Ca D E F G Hb I J K L M N O P Q R S T U 3 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 { | } ~  4 5 6 7 8 9 :'<YRHN]V=>?@ABCDEFGIJKLMOPQSTUWXZ[\^_`ab'_`a^<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]b?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^ ; < = > ? @ A B_` Ca D E F G Hb I J K L M N O P Q R S T U 3 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 { | } ~  4 5 6 7 8 9 :&NoneMg ggg 'None9;M h hh h (None9:;LM CJSON: Annotation Data Types ---------------------------------------ioutput" creates the pretty printed outputjannotate% actually renders the output to files DPandoc HTML Rendering (for lhs + markdown source) ------------------ DDirect HTML Rendering (for non-lhs/markdown source) ---------------- topAndTail True is used for standalone HTML; topAndTail False for embedded HTML IBuilding Annotation Maps ------------------------------------------------TThis function converts our annotation information into that which is required by VX& to generate mouseover annotations. ITokenizing Refinement Type Annotations in @-blocks ----------------------OThe token used for refinement symbols inside the highlighted types in @-blocks. ^The top-level function for tokenizing @-block annotations. Used to tokenize comments by ACSS. CCreating Vim Annotations ------------------------------------------ KLH Related Stuff ----------------------------------------------------------KA Little Unit Test --------------------------------------------------------pCJSON Instances ----------------------------------------------------= ij                klmnopijij7   ij                klmnop)None9;LMTrAttempt to canonicalize all   s in the B3 so we don't have to worry about relative paths. Updating optionsvCExit Function -----------------------------------------------------    q    r ! "s t # $u %v & ' ( ) * + , -wxyFqrstuvwqsutrvwF    q    r ! "s t # $u %v & ' ( ) * + , -wxy*None9:;M .3Intervals of line numbers that have been re-checked /-Map from saved-line-num ---> current-line-num 0"Variable dependencies "call-graph" 1Variable definitions 2&line at which binder definition starts 3$line at which binder definition ends 4name of binderzKData Types ----------------------------------------------------------------+Main type of value returned for diff-check. checkedNames@ returns the names of the top-level binders that will be checked returns a subset of the  [CoreBind] of the input targetm file which correspond to top-level binders whose code has changed and their transitive dependencies. 5~Add the specified signatures for vars-with-preserved-sigs, whose bodies have been pruned from [CoreBind] into the "assumes"thin cbs sp vs returns a subset of the cbs :: [CoreBind]+ which correspond to the definitions of vs and the functions transitively called therein for which there are *no* type signatures. Callees with type signatures are assumed to satisfy those signatures. 6(Given a call graph, and a list of vars,  6 checks all functions to see if they call any of the functions in the vars list. If any do, then they must also be rechecked. 7 7 cuts off the start-line to be no less than the line at which the binder is defined. Without this, i.e. if we ONLY use the ticks and spans appearing inside the definition of the binder (i.e. just eSp) then the generated span can be WAY before the actual definition binder, possibly due to GHC INLINE pragmas or dictionaries OR ... for an example: see the "INCCHECK: Def" generated by liquid -d benchmarksbytestring-0.9.2.1Data/ByteString.hs where spanEnd~ is a single line function around 1092 but where the generated span starts mysteriously at 222 where Data.List is imported. 8KDiff Interface ------------------------------------------------------------,`lineDiff new old` compares the contents of src with dst and returns the lines of src that are different. 9"Identifies lines that have changedsave" creates an .saved version of the target; file, which will be used to find what has changed the  next time target is checked. :getShift lm old returns Just  if the line number old shifts by  in the diff and returns Nothing otherwise. ;setShift (lo, hi, ) lm updates the interval map lm appropriatelyKAeson instances -----------------------------------------------------------N . / 0 1 < 2 3 4z{|}~ = > 5 ? @ A B C D 6 E F G H I 7 J K L M N O P Q 8 R 9 Starting lineList of lengths of diffsList of changed line numbers S T U V W X Y Z [ \ ] ^ : ; _ ` a b z{|}~ z{|}~F . / 0 1 < 2 3 4z{|}~ = > 5 ? @ A B C D 6 E F G H I 7 J K L M N O P Q 8 R 9 S T U V W X Y Z [ \ ] ^ : ; _ ` a b+None02LM c d e f g h i j k l m n o p q r c d e f g h i j k l m n o p q rYNoneM,NoneMBLH Primitive TyCons ----------------------------------------------BLH Primitive TyCons ---------------------------------------------- sALH Primitive Types ----------------------------------------------KPredicate Types for WiredIns ---------------------------------------------- s t u v w x   s t u v w x-NoneBM.None:CLMAKFixpoint Environment ------------------------------------------------------%Integer Keys for Fixpoint EnvironmentFixpoint Environment!Map from Symbol to current BindId yKHelper Types: Invariants --------------------------------------------------KHelper Types: HEnv --------------------------------------------------------KGeneration: Types ---------------------------------------------------------top-level fixpoint env subtyping constraints over RType%wellformedness constraints over RType.additional stratum constrains for let bindings$subtyping over Sort (post-splitting).tracks constraints that come from let-bindings5wellformedness constraints over Sort (post-splitting)"counter for generating fresh KVarsset of environment binderssource-position annotation map#information about type-constructors ? FIX THIS?Mapping of new type type constructors with their refined types.+Terminating Metrics for Recursive functions3Set of variables to ignore for termination checking)"Lazy binders", skip termination checking ? FIX THIS4primitive Sorts into which TyCons should be embedded>Fixpoint Kut variables (denoting "back-edges"/recursive KVars)$Fixpoint "packs" of correlated kvars&Global symbols in the refinement logic1Distinct constant symbols in the refinement logicCheck Termination (?)Check Strata (?)prune unsorted refinements#Errors during constraint generationProfiling distribution of KVars3number of recursive functions seen (for benchmarks)+Source Span associated with Fixpoint Binder"Refined Types of Data ConstructorsKSubtyping Constraints ----------------------------------------------------- Location in original source fileSpecTypes for Bindings in scope,Map from free Symbols (e.g. datacons) to VarDictionary EnvironmentGlobal literalsDistinct literalsFixpoint Environment0recursive defs being processed (for annotations)0recursive defs being processed (for annotations)Datatype invariantsKDatatype recursive invariants: ignored in the base case assumed in rec callDatatype checkable invariants6Top-level variables with (assert)-guarantees to verify&Top-level variables with assumed types6Top-level variables with auto generated internal types+How to embed GHC Tycons into fixpoint sorts*Map from top-level binders to fixpoint tagCurrent top-level binder6Type of recursive function with decreasing constraints6Let binding that have not been checked (c.f. LAZYVARs)&Types with holes, will need refreshingLogical ConstraintsMaxiom environment maps axiomatized Haskell functions to the logical functions{error that should be reported at the user , cgCfg :: !Config -- ^ top-level config optionstop-level GhcInfo top level function being checkedKForcing Strictness --------------------------------------------------------~ y z { | } ~       c     d     0 y z { | } ~!       /None 9:;<=LMT)KGeneration: Freshness -----------------------------------------------------FRight now, we generate NO new pvars. Rather than clutter code with =< calls, put it in one place where the above invariant is  obviously4 enforced. Constraint generation should ONLY use  freshTy_type and  freshTy_expr ~Used to generate "cut" kvars for fixpoint. Typically, KVars for recursive definitions, and also to update the KVar profile.) !"# $% &' ( )* + , -./01234  !#"$%&'()*+,  !"#$%'&()*,+& !"# $% &' ( )* + , -./012340None29:;<=ILMTc KRefinement Type Environments ----------------------------------------------# 5 67 8 9:; < = > ?@ABCD EFG56789:;<=>?@ABCDEFG@=:;?A>59687B<CDEFG# 5 67 8 9:; < = > ?@ABCD EFG1None:LMII2 adds a subtyping constraint into the global pool.J(addPost: RJ: what DOES this function do?KAdd Well formedness ConstraintL Add a warningMNAdd Identifier Annotations, used for annotation binders (i.e. at binder sites)O/Used for annotating reads (i.e. at Var x sites)PHUpdate annotations for a location, due to (ghost) predicate applications HIJKLMNOPQR HIJKLMNOPQR HIJKLMNOPQR HIJKLMNOPQR2None9;MST STTSST 3None:Mc KReftypes from F.Fixpoint Expressions --------------------------------------YKConstraint Generation Panic -----------------------------------------------U V W XYUVWXYWUVXYU V W XY4NoneMZ[ Z[Z[Z[ 5NoneM JReplace Predicate Arguments With Existentials ----------------------------\mNiki: please write more documentation for this, maybe an example? I can't really tell whats going on... (RJ) \ \\  \ 6None:MkKError-Reader-IO For Bare Transformation -----------------------------------]^_`abcdefghijklmno pq rst]^e_cf`abdghijklmnopqrstkji]^_`abcdefghpqrsltnom] ^_`abcdefghijklmno pq rst7None9;LM KExpand Alias Application --------------------------------------------------uv wxyz{|}~uvuvuv wxyz{|}~8None9:;MKQuerying GHC for Id, Type, Class, Con etc. --------------------------------0It's possible that we have already resolved the  : we are looking for, but have had to turn it back into a  , e.g. to be used in an Expr , as in {v:Ordering | v = EQ}$. In this case, the fully-qualified   ( GHC.Types.EQO) will likely not be in scope, so we store our own mapping of fully-qualified  s to  s and prefer pulling   s from it.    9None:M   JJ   :None9:;LM:                            ! " #  2                              ! " #;NoneM returns  $ for unhandled lits because otherwise string-literals show up as global int-constants which blow up qualifier instantiation. % & % &<NoneLM ' ( ) * ' ( ) *=None9:;LM + , + ,>None:LM -exprArg converts a tyVar to an exprVar because parser cannot tell HORRIBLE HACK To allow treating upperCase X as value variables X e.g. type Matrix a Row Col = List (List a Row) Col . / 0 1 2 3 4 5 6 7 - 8 9 : . / 0 1 2 3 4 5 6 7 - 8 9 :?None!":LM ;KExpand Measures ----------------------------------------------------------- ; < = > ? @ A B C D E F G H I J K L M N O P   ; < = > ? @ A B C D E F G H I J K L M N O P@NoneLM initializes the env needed to vQ refinements and types, that is, the below needs to be called *before* we use Z[ Q R S T U V W X Y Z [ \ ] ^ _ ` Q R S T U V W X Y Z [ \ ] ^ _ `ANone:M a b c d a b c dBNone:FLMKAPI: Bare Refinement Types ------------------------------------------------$ e f g h i j k l m n o p q r s t$ e f g h i j k l m n o p q r s tCNone:LM u v w x y z { | } ~ u v w x y z { | } ~DNone !":FLMT  checkRTypeO determines if a type is malformed in a given environment ---------------------  checkMeasuresO determines if a measure definition is wellformed -----------------------------!   !   ENone9:;M "Specification for Haskell function     FNone!"$:LM  NOTEREFLECT-IMPORTS nMAKE the full LiftedSpec, which will eventually, contain: makeHaskell{Inlines, Measures, Axioms, Bounds}+SAVE the LiftedSpec, which will be reloadedXThis step creates the aliases and inlines etc. It must be done BEFORE we compute the _ for (all, including the reflected binders), as we need the inlines and aliases to properly v the SpecTypes./   $z{|}~$z{|}~*    GNone$:McAUse explicitly given qualifiers .spec or source (.hs, .lhs) files MScrape qualifiers from function signatures (incr :: x:Int -> {v:Int | v > x}) LScrape qualifiers from refinement type aliases (type Nat = {v:Int | 0 <= 0})    HNone:M    INone9:;LMT KPer-Module Pipeline -------------------------------------------------------KGHC Interface Pipeline ----------------------------------------------------KGHC Configuration & Setup -------------------------------------------------KExtract Ids --------------------------------------------------------------- KExtract Specifications from GHC ------------------------------------------- KFinding & Parsing Files ---------------------------------------------------KHandle Spec Files ---------------------------------------------------------KPretty Printing ----------------------------------------------------------->           !"#$>           !"#$JNone 9:;<=LMT%&TODO: All this *should* happen inside Bare; but appears to happen after certain are signatures are fresh#-ed, which is why they are here.&'()*+,%-./0123&'()*+,%-./0123KNone/2349:;<=ILMTKConstraint Generation: Toplevel -------------------------------------------4KTERMINATION TYPE ----------------------------------------------------------5KConstraint Generation: Corebind -------------------------------------------6 varTemplate2 is only called with a `Just e` argument when the e corresponds to the body of a Rec binder.7lazVarTemplate is like 6 but for binders that are *not* termination checked and hence, the top-level refinement / KVar is stripped out. e.g. see testsnegrT743.hs varTemplate :: CGEnv -> (Var, Maybe CoreExpr) -> CG (Template SpecType) lazyVarTemplate  (x, eo) = dbg  $ (topRTypeBase  $)  $W varTemplate'  (x, eo) where dbg = traceShow ("LAZYVAR-TEMPLATE: " ++ show x)8 topSpecType5 strips out the top-level refinement of "derived var"9KConstraint Generation: Checking -------------------------------------------:instantiatePreds' peels away the universally quantified PVars of a RType, generates fresh Ref. for them and substitutes them in the body.;instantiateStrata generates fresh Strata: vars and substitutes them inside the body of the type.<KType Synthesis ------------------------------------------------------------=Type Synthesis for Special Pattern's -------------------------------------> consFreshE is used to *synthesize* types with a **fresh template**. e.g. at joins, recursive binders, polymorphic instantiations etc. It is the "portal" that connects < (synthesis) and 9 (checking)?? masks (i.e. true's out) all types EXCEPT those at given indices; it is used to simplify the environment used when projecting out fields of single-ctor datatypes.@BHelpers: Creating Fresh Refinement -------------------------------AKHelpers: Creating Refinement Types For Various Things ---------------------B/create singleton types for function applicationCRJ: nomeet replaces  strengthenS for R in the definition of D . Why does `tests/neg/strata.hs`$ fail EVEN if I just replace the E2 case? The fq file holds no answers, both are sat.FKCleaner Signatures For Rec-bindings ---------------------------------------]GHIJKL4MNOPQRSTUV5WXYZ[\]^_`abcdefghi6789jklm:;no<pq=rstuv>wxyz{?|}~@ADBCFYGHIJKL4MNOPQRSTUV5WXYZ[\]^_`abcdefghi6789jklm:;no<pq=rstuv>wxyz{?|}~@ADBCFLNone$%&*+,DFMQR  !"#$  !"#$  !"#  !"#$MNone!"$IMOT @Twhether to keep going after finding a counter-example, useful for checking coverageA_whether to stop after a certain number of successful tests, or enumerate the whole input spaceB+whether to use SmallCheck's notion of depthCextra options to pass to GHCP,Find the refined type of a data constructor.QGiven a data constructor d. and an action, create a new choice variable cG and execute the action while guarding any generated constraints with c . Returns (action-result, c).R'Generate a fresh variable of the given .UGiven a data constructor d1, create a new choice variable corresponding to d.VAsk the SMT solver for the   of the given variable.8%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVW2%&475(63*.')+,-/01289:;>A<=?@BCDEFGHIJKLMNOPQRSTUV2IJKLMSTNOPQRUFVDE%&'()*+,-./0123456789H:;<=>?@ABCG%&'()*+,-./0123456789: ;<=>?@ABCDEFGHIJKLMNOPQRSTUVWNNone$5M[`TEvaluate a refinement with the given expression substituted for the value variable.a~Evaluate a refinement with the given expression substituted for the value variable, in the given environment of free symbols. `ab`ab`ab `abONone69:;DMQRT[ ciA class of datatypes for which we can efficiently generate constrained values by querying an SMT solver.kIf possible, instances should not be written by hand, but rather by using the default implementations via  GHC.Generics, e.g. jimport GHC.Generics import Test.Target.Targetable data Foo = ... deriving Generic instance Targetable FoodPConstruct an SMT query describing all values of the given type up to the given .e/Reconstruct a Haskell value from the SMT model.f}Check whether a Haskell value inhabits the given type. Also returns a logical expression corresponding to the Haskell value.g4Translate a Haskell value into a logical expression.hOWhat is the Haskell type? (Mainly used to make the SMT queries more readable).jGiven a data constuctor d and a refined type for dFs output, return a list of types representing suitable arguments for d.kGiven a data constructor d and a list of expressions xs/, construct a new expression corresponding to d xs.lSplit a symbolic variable representing the application of a data constructor into a pair of the data constructor and the sub-variables.m(Given a symbolic variable and a list of  (choice, var) pairs, oneOf x choices asserts that x must equal one of the vars in choices.nGiven a symbolic variable x, figure out which of x-s choice varaibles was picked and return it.oCAssert a logical predicate, guarded by the current choice variable.pGiven a refinement {v | p} and an expression e, construct the predicate p[e/v].Xcdefghijklmnopqrstuvwxyz{|}~cefdghijklmnopcdefghhdgefijklmnopHc defghhdgefijklmnopqrstuvwxyz{|}~PNone $9:;DMRT  QNone!"$(*,9:;DMRT[9A class of functions that Target can test. A function is Testable iff! all of its component types are c$ and all of its argument types are able. You should never have to define a new  instance.|Test that a function inhabits the given refinement type by enumerating valid inputs and calling the function on the inputs.  RNone!"#%&*0ABDMT[Attempt to monomorphize a  & according to simple defaulting rules.The parsed statementSNone#LMTThis fellow does the real workTNone059;MJResponse -----------------------------------------------------------------JCommand ------------------------------------------------------------------JState -------------------------------------------------------------------- UNoneMNone$AMOTkTest whether a function inhabits its refinement type by enumerating valid inputs and calling the function.Like , but returns the % instead of printing to standard out.Like O, but accepts options to control the enumeration depth, solver, and verbosity.Like , but returns the % instead of printing to standard out.  the functionthe name of the function0the path to the module that defines the function!:;>A<=?@BCGcefdgh&cdefghhdgef:;<=>?@ABCG \]^_`a_`b_`c_`d_`e_fg_fh_fi_fj_fk_fl_mn_mo_mp_mq_mrstuvwxyz{|}~                             ! " # $ % & ' ( ) * + , - . / 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 tuvuwxyz{|}~k      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%%&'&()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXXYZ[\]^_^`abccdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQWRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~{w               !!!!!!!!! !!"""#"$"%"&"'#(#)#*##+#,#-#.#/#0#1#2#3#4#5#6#7#8#9#:J;<=>?@ABCDEFG$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$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/d0e0f0g0h0i0j0k0l0m0n0o0p0q0r0s0t0u0v0w1x1y1z1{1|1}1~11112233333445666666666f6T6666666666666677[777777777777888888888889999999999999999::::::::::::::::;;;<<<=============>>>>>>??????????@ABBBBBBBBBBB B B B B BBBBBCCCCCCDDDEEEEFFFGUG H!H"I#I$I%I&I'I(I)I*I+I,J-J.K/K0K1K2K3K4L5L6L7L8L9L:L;L<L=L>L?L@LALCLBLCLDLELFLLLGLHLILJMKMKMLMMMNMOMPMQMRMSMTMUMVMWMKMXMYMMZM[M\M]M]M^M_M`MaMbMcMdMeMMfMgMhMiMjMkMlMmMnMMoMpMqMQMrMsMtMuMvMwMxMyMzM{M|M}M~NNNOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOPPPQQQQQRRRRRRRRRRRRRRRRRRRRRRRRRRSSSTTTTTTT0TTTT8UU                                                                 !   "   #   $   %   &   '   (   )   *   +   ,   -   .   /   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   {   |   }   ~                                                                                                                                                                                                                                                          PQ         -            g                  ! " # $ % & ' ( ) * + , - . / 0 1 21 3 4 5 6 7 8 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 { | } ~ S                         s t         _                                                                 ! ! ! ! ! ! " " " " # ## # # # # # # # # # # # # # # # # # # # # # # # # # J# # # # # # #]#     ! " # $ % & ' ( ) *$ +$ ,$ -$ .$$ /$ 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. y. z. {. |.. }. ~. . . . . / / / / / / / / / / / / / / / / / / / / 0 0 0 0 0 0 0 0 0 0 0 00 0 0 0 2 2 2 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3'4 4 4 4 4 4 5 5 5Q5 5 5 5 5 5 5 5 5 5 5 5 6 6 7 7 7 7 7 7     8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 9 9 9 9 9 : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : :U: : : :    ; ; < < < !< "= #= $> %> &> '> (> )> *> +> ,> -> .> /> 0> 1> 2?i? 3? 4?U? 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@ VA WA XA YA ZB [B \B ]B ^B _B `B aB bB cB dB eB fB gB hB iB jC kC lC mC nC oC pC qC rC sC tD uD vD wD xD yD zD {D |D }D ~D D D D D D D D D D D D D D D D D D D D E EE DE E E E E E E E E E E E F F F F F F F F F F F F F F F F F F F F F F F FUF F F F F F F F F F F F F F F F F F F F G G G G G G G G G G G G G G G G G H H H H H H H H I I I I I I I I I I I I I I I I I I I I I I I I I I I I I IIIIIIIIII I I I I IIIIIIII IJJJJJJJJJSJJJ J!J"J#K$K%K&K'K(K)K*K+K,K-K.K/K0K1K2K3K4  5K6K7K8K9K:K;K<K=K>K?K@KAKBKCKDKEKFKGKHKIKJKKKLKMKNKOKPKQKRKSKTKUKVKWKXKYKZK[K\K]K^K_K`KaKbKcKdKeKfKgKhKiKjKkKlKmKnKoKpKqKrKsKtKuKvKwKxKyK KzK{K|K K}_~MMMMMNNNNNNNNNOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOPPPPPPPP QQQQQQQQSSSSSSSSSSSSST(TTU,liquidhaskell-0.8.0.1-BjK0AY2bhdNGOam19vgish Test.TargetLanguage.Haskell.Liquid.TypesLanguage.Haskell.Liquid.UX.TidyTest.Target.SerializeTest.Target.ExprPaths_liquidhaskell!Language.Haskell.Liquid.UX.Config&Language.Haskell.Liquid.Types.Variance,Language.Haskell.Liquid.Types.Specifications#Language.Haskell.Liquid.Types.Names(Language.Haskell.Liquid.ProofCombinatorsLanguage.Haskell.Liquid.PreludeLanguage.Haskell.Liquid.Misc$Language.Haskell.Liquid.Types.ErrorsLanguage.Haskell.Liquid.List#Language.Haskell.Liquid.GHC.TypeRep#Language.Haskell.Liquid.GHC.Resugar Language.Haskell.Liquid.GHC.Misc Language.Haskell.Liquid.GHC.Play%Language.Haskell.Liquid.GHC.SpanStack&Language.Haskell.Liquid.Transforms.Rec*Language.Haskell.Liquid.Transforms.Rewrite&Language.Haskell.Liquid.Transforms.ANF+Language.Haskell.Liquid.Transforms.Simplify$Language.Haskell.Liquid.Types.StrataTest.Target.Types)Language.Haskell.Liquid.Types.PrettyPrint+Language.Haskell.Liquid.Transforms.RefSplit%Language.Haskell.Liquid.Types.RefType$Language.Haskell.Liquid.Types.Bounds*Language.Haskell.Liquid.Types.Dictionaries&Language.Haskell.Liquid.Types.PredType&Language.Haskell.Liquid.Types.Visitors Language.Haskell.Liquid.UX.CTagsLanguage.Haskell.Liquid.UX.ACSSLanguage.Haskell.Liquid.MeasureLanguage.Haskell.Liquid.Parse"Language.Haskell.Liquid.Types.Meet!Language.Haskell.Liquid.UX.Errors#Language.Haskell.Liquid.UX.Annotate"Language.Haskell.Liquid.UX.CmdLine$Language.Haskell.Liquid.UX.DiffCheck&Language.Haskell.Liquid.UX.QuasiQuoterLanguage.Haskell.Liquid.WiredInLanguage.Haskell.Liquid.Foreign(Language.Haskell.Liquid.Constraint.Types(Language.Haskell.Liquid.Constraint.Fresh&Language.Haskell.Liquid.Constraint.Env(Language.Haskell.Liquid.Constraint.Monad-Language.Haskell.Liquid.Constraint.Constraint(Language.Haskell.Liquid.Constraint.Split#Language.Haskell.Liquid.Bare.ToBare(Language.Haskell.Liquid.Bare.Existential Language.Haskell.Liquid.Bare.Env#Language.Haskell.Liquid.Bare.Expand#Language.Haskell.Liquid.Bare.Lookup!Language.Haskell.Liquid.Bare.Misc.Language.Haskell.Liquid.Transforms.CoreToLogic&Language.Haskell.Liquid.Types.Literals$Language.Haskell.Liquid.Bare.Plugged$Language.Haskell.Liquid.Bare.Resolve#Language.Haskell.Liquid.Bare.OfType$Language.Haskell.Liquid.Bare.Measure"Language.Haskell.Liquid.Bare.RTEnv$Language.Haskell.Liquid.Bare.SymSort!Language.Haskell.Liquid.Bare.Spec%Language.Haskell.Liquid.Bare.DataType"Language.Haskell.Liquid.Bare.Check"Language.Haskell.Liquid.Bare.AxiomLanguage.Haskell.Liquid.Bare,Language.Haskell.Liquid.Constraint.Qualifier-Language.Haskell.Liquid.Constraint.ToFixpoint%Language.Haskell.Liquid.GHC.Interface'Language.Haskell.Liquid.Constraint.Init+Language.Haskell.Liquid.Constraint.GenerateTest.Target.UtilTest.Target.MonadTest.Target.EvalTest.Target.TargetableTest.Target.Targetable.FunctionTest.Target.TestableLanguage.Haskell.Liquid.ModelLanguage.Haskell.Liquid.Liquid)Language.Haskell.Liquid.Interactive.Types+Language.Haskell.Liquid.Interactive.HandlerLanguage.Haskell.Liquid ConstraintACSS LiquidHaskellExpandexpand*QuickCheck-2.10.0.1-ALuGysu7txTB2VnkPyDuTqTest.QuickCheck.All monomorphic.liquid-fixpoint-0.6.0.1-5dpacaGs3w6L7ctgGpcquMLanguage.Fixpoint.Types.Names dummyName tidySymbolisDummy LocSymbolLocTextLanguage.Fixpoint.Types.SpansdummyLocvallocElocLocLocated#Language.Fixpoint.Types.PrettyPrintshowpppprint pprintPrec pprintTidyPPrintSMTLIB2smt2smt2AppmkRelmkNesmt2ssmt2many$fSMTLIB2Triggered$fSMTLIB2Command $fSMTLIB2Expr $fSMTLIB2Brel $fSMTLIB2Bop$fSMTLIB2Located$fSMTLIB2Constant$fSMTLIB2SymConst $fSMTLIB2(,)$fSMTLIB2Symbol $fSMTLIB2Sorteqgelegtltiffimpappvarprop $fNumExprversion getBinDir getLibDir getDataDir getLibexecDir getSysconfDirgetDataFileName HasConfig getConfig patternFlaghigherOrderFlag ProofMethod ArithmeticRewrite AllMethods Instantiate NoInstances SMTInstancesLiquidInstancesLiquidInstancesLocalConfigfilesidirs diffchecklinear stringTheory higherorder higherorderqsextensionalityalphaEquivalencebetaEquivalence normalForm fullcheck saveQuerychecksnoCheckUnknown noterminationgradual totalHaskell autoproofs nowarnings noannotationstrustInternals nocaseexpandstrata notruetypestotality pruneUnsortedcores minPartSize maxPartSize maxParams smtsolver shortNames shortErrorscabalDir ghcOptionscFiles eliminateportexactDCnoMeasureFields scrapeImportsscrapeInternalsscrapeUsedImports elimStats elimBoundjsoncounterExamples timeBindsnoPatternInline untidyCorenoSimplifyCore nonLinCutsautoInstantiate proofMethodfueldebugInstantionationnoslice totalityCheckterminationCheckallowSMTInstationationallowLiquidInstationationallowLiquidInstationationGlobalallowLiquidInstationationLocal allowRewriteallowArithmetichasOpt$fHasConfigConfig$fShowInstantiate$fDefaultInstantiate$fShowProofMethod$fDefaultProofMethod$fSerializeConfig$fSerializeSMTSolver$fSerializeInstantiate$fSerializeProofMethod$fEqInstantiate$fDataInstantiate$fGenericInstantiate$fEqProofMethod$fDataProofMethod$fGenericProofMethod$fGenericConfig $fDataConfig $fShowConfig $fEqConfigVariance Invariant Bivariant Contravariant Covariant VarianceInfo$fNFDataVariance$fBinaryVariance$fDataVariance$fShowVariance$fGenericVariance specAnchor lenLocSymbol anyTypeSymbolArg>.<.>=.<=.==.==?QEDProoftrivial***∵?==>&&&prooftoProof simpleProof<=:<:>:==:castWithTheoremcast byTheorem=*=. $fOptGtab $fOptGta(->) $fOptLessab$fOptLessa(->) $fOptGEqaa $fOptGEqa(->) $fOptLEqab $fOptLEqa(->) $fOptEqab $fOptEqa(->)$fToProvea(->) $fToProveabplusminustimesneqleqgeq liquidAssertB liquidAssert liquidAssume liquidAssumeB liquidErrorcrashforcechooseisEvenisOdd safeZipWithNat timedAction!? safeFromJustfst4snd4 mapFourth4addFst3addThd3dropFst3dropThd3replaceNfourth4third4mapSndMfirstMsecondMfirst3Msecond3Mthird3Mthird3zip4 getIncludeDir getCssPathgetCoreToLogicPathsafeZipWithErrorsafeZip3WithErrormapNsmapN zipWithDefMsinglemapFst3mapSnd3mapThd3 firstMaybeshashMapMapWithKeyhashMapMapKeys concatMapM firstElems splitters bchopAltschopAltssortDiff angleBracketsmkGraph tryIgnore=>><<=condNull firstJust intToString mapAccumMifM WithModelNoModel UserErrorTError ErrSubTypeErrSubTypeModel ErrFCrash ErrAssTypeErrParse ErrTySpec ErrTermSpec ErrDupAlias ErrDupSpecs ErrDupMeas ErrBadData ErrDataConErrInvtErrIAl ErrIAlMisErrMeasErrHMeas ErrUnboundErrGhc ErrMismatch ErrPartPred ErrAliasCycleErrIllegalAliasApp ErrAliasApp ErrTermin ErrRClass ErrBadQualErrSaved ErrFilePragmaErrTyConErrOtherposmsgctxtacttexpctxMtactMoblcondpErrtypexpkindlocstyconinvtAstUsmshslqTylqPosectrargNexpNactNacyclednamedposbindclsinstsqnamenamtcnameObligOTermOInvOConsCtxErrorctErrctCtxerrorWithContext dropModeluErrorpanicDocpanictodo impossibleppErrorunpackRealSrcSpan realSrcSpanppError'$fFromJSONTError$fToJSONTError$fFromJSONSrcSpan$fToJSONSrcSpan$fFromJSONRealSrcSpan$fToJSONRealSrcSpan$fExceptionTError $fShowTError$fPPrintSrcSpan$fNFDataWithModel$fPPrintTError $fOrdTError $fEqTError$fNFDataParseError $fPPrintOblig $fNFDataOblig $fShowOblig $fBinaryOblig $fOrdCtxError $fEqCtxError$fPPrintParseError$fGenericOblig $fDataOblig$fFunctorWithModel$fShowWithModel $fEqWithModel$fGenericWithModel$fGenericTError$fFunctorTError$fFunctorCtxError transposeFunTymkTyArg $fEqCoercion $fEqTyBinder$fEqTypePatternPatBind PatReturn PatProjectpatE1patXpatE2patMpatDctpatTyApatTyBpatFFpatEpatTypatRetpatXEpatCtorpatBindspatIdxliftlowerPrecL MGIModGutsMI mgi_binds mgi_modulemgi_deps mgi_dir_imps mgi_rdr_envmgi_tcs mgi_fam_insts mgi_exports mgi_cls_instmkAlive miModGuts mg_dir_impsmgi_namestring srcSpanTick tickSrcSpan stringTyVar stringVar stringTyConstringTyConWithKindhasBaseTypeVar isBaseType validTyVartvIdtidyCBsunTick unTickExprisFractionalClasstracePprpprShow toFixSDocsDocDocpprDocshowPprshowSDoc myQualify showSDocDumptypeUniqueStringfSrcSpanfSrcSpanSrcSpansrcSpanFSrcSpansourcePos2SrcSpansourcePosSrcSpansourcePosSrcLocsrcSpanSourcePossrcSpanSourcePosEsrcSpanFilenamesrcSpanStartLoc srcSpanEndLoconeLinelineColrealSrcSpanSourcePosrealSrcSpanSourcePosE getSourcePos getSourcePosE locNamedThingnamedLocSymbol varLocInfocollectArgumentscollectTyBinderscollectValBinders'ignoreLetBinds isTupleId idDataConM isDataConIdgetDataConVarUniqueisDictionaryExpression realTcArity kindArity uniqueHash lookupRdrNamequalImportDecl ignoreInlinesymbolTyConWithKind symbolTyCon symbolTyVar varSymbolqualifiedNameSymbolfastStringTexttyConTyVarsDefsplitModuleNamedropModuleNamesAndUniquedropModuleNamestakeModuleNamesdropModuleUnique cmpSymbol sepModNames sepUnique mungeNames qualifySymbol isQualified wrapParens isParened isDictionary isInternal stripParensstripParensSym gHC_VERSIONsymbolFastStringlintCoreBindingssynTyConRhs_maybetcRnLookupRdrNameshowCBs findVarDefcoreBindSymbols simplesymbolbinders $fNFDataVar $fNFDataType $fNFDataTyCon $fNFDataClass $fShowTyCon $fShowClass $fShowVar $fShowName$fFixpointType$fFixpointName $fFixpointVar$fHashableTyCon $fHashableVar $fSymbolicVar$fSymbolicName$fSymbolicClass$fSymbolicTyCon$fSymbolicFastString$fHashableSrcSpan $fHashableLoc$fOutputableHashSet$fEqLoc$fOrdLoc $fShowLocSubablesubsubTydataConImplicitIdssubVar substTysWithmapTypestringClassArg $fSubableType $fSubableBind $fSubableVar $fSubable(,,)$fSubableCoercion $fSubableExprSpanVarTick SpanStackemptypushsrcSpanshowSpan $fShowSpantransformRecExprtransformScope outerScTr innerScTr$fFreshableVar$fFreshableUnique$fFreshableInt rewriteBinds anormalize $fFunctorDsM $fMonadDsM$fMonadUniqueDsM$fApplicativeDsMMSpecctorMapmeasMapcmeasMapimeasKVProfKVKindRecBindE NonRecBindE TypeInstE PredInstELamECaseELetEProjectEOutputOo_varso_typeso_templso_botso_resultAnnotAnnUseAnnDefAnnRDfAnnLocAnnInfoAIRClassrcNamercSupersrcTyVars rcMethodsCMeasureCMcNamecSortMeasureMnamesorteqnsDefmeasuredparamsctordsortbindsbodyBodyEPRRTEnvRTE typeAliases exprAliasesModTypeTarget SrcImport SpecImportModNameCinfoCici_locci_errci_varError ErrorResultREnvreGlobalreLocal UReftableofUReftRTypeRepty_varsty_preds ty_labelsty_bindsty_reftsty_argsty_resRTAliasRTArtNamertTArgsrtVArgsrtBodyrtPosrtPosEDataDeclDtycName tycTyVarstycPVars tycTyLabstycDCons tycSrcPostycSFunSizeFun IdSizeFun SymSizeFunAxiomEq axiomName axiomArgs axiomBodyaxiomEqHAxiomAxiomanamernameabindsatypesalhsarhsRDEnvDEnvRISig RIAssumed RInstanceRIriclassrityperisigsOkRT TyConableisFunisListisTupleppTyconisClassisEqualisNumCls isFracClsSubsTysubtStrataStratumSVarSDivSWhnfSFin LocSpecType LocBareTypeBRPropRRPropSpecPropSpecTypeBareTypePrTypeRReftRPVarBPVarRSortBSortRRTypeBRTypeUReftMkUReftur_reftur_pred ur_strataHSegHBindHVarhs_addrhs_valWorldRTPropRefRProprf_argsrf_bodyRTVInfo RTVNoInfortv_namertv_kind rtv_is_valRTVar ty_var_value ty_var_infoRTypeRVarRFunRAllTRAllPRAllSRAppRAllERExRExprArgRAppTyRRTyRHolert_varrt_reftrt_bindrt_inrt_out rt_tvbindrt_ty rt_pvbindrt_sbindrt_tyconrt_argsrt_pargs rt_allargrt_exargrt_argrt_resrt_envrt_refrt_oblPVURTVU TyConInfovarianceTyArgsvariancePsArgs sizeFunctionRTyConrtc_tcrtc_infoBTyConbtc_tc btc_classbtc_promRTyVarRTVBTyVarBTV PredicatePrUsedPVarPVKindPVPropPVHPropPVarPVpnameptypepargpargs TargetVarsAllVarsOnlyDataConPdc_loc freeTyVarsfreePred freeLabelstyConststyArgstyResdc_locETyConPty_loc freeTyVarsTy freePredTy freeLabelTy varianceTs variancePssizeFunLMaplmVarlmArgslmExprLogicMapLM logic_map axiom_mapGhcSpecSPgsTySigs gsAsmSigsgsInSigsgsCtorsgsLitsgsMeas gsInvariants gsIaliasesgsDconsPgsTconsP gsFreeSyms gsTcEmbeds gsQualifiers gsTgtVarsgsDecrgsTexprs gsNewTypesgsLvarsgsLazy gsAutosize gsAutoInstgsConfig gsExports gsMeasures gsTyconEnvgsDictsgsAxioms gsReflects gsLogicMap gsProofType gsRTAliasesGhcInfoGItarget targetModenvcbsderVarsimpVarsdefVarsuseVarshqFilesimportsincludesspecPPEnvPPppPsppTyVarppSsppShortppEnv ppEnvShort toLogicMap eAppWithMappvTypepvarsrtyVarUniqueSymboltyVarUniqueSymbol rtyVarTypemkBTyCon mkClassBTyConmkPromotedBTyConisBoolisRVar isClassBTyCon isClassRTyCon rTyConPVs rTyConPropVsisPropPVisEqType isClassTypedefaultTyConInfo ignoreOblig makeRTVar mapTyVarValue dropTyVarInfo rTVarToBindrPropPisSVarszFun mapRTAVars lmapEAlias fromRTypeRep toRTypeRepmkArrow bkArrowDeepbkArrow safeBkArrowmkUnivsbkUnivbkClassrFunrClsrRCls addInvCondpApppappSym isTrivialmapReftisBaseisFunTymapReftMmapPropMfoldReft foldReft' efoldReftmapBotmapBindofRSorttoRSort insertsSEnv rTypeValueVar rTypeReftstripRTypeBase topRTypeBase makeDivType makeFinType getStrata isSrcImport isSpecImport getModName getModStringmapRTmapRE emptyKVProf updKVProfholeisHolehasHole liquidBegin liquidEnd $fPPrintRef$fPPrintRTyVar$fPPrintBTyVar $fMonoidMSpec $fShowMSpec $fPPrintMSpec$fBifunctorMSpec $fShowDataCon$fPPrintDataCon$fSymbolicDataCon$fNFDataKVProf$fPPrintKVProf$fPPrintKVKind$fNFDataKVKind$fHashableKVKind$fMonoidOutput $fNFDataAnnot$fNFDataAnnInfo$fMonoidAnnInfo$fBinaryRClass$fSubableWithModel $fSubableBody $fSubableDef$fSubableMeasure$fShowCMeasure$fPPrintCMeasure $fShowMeasure$fPPrintMeasure $fPPrintDef $fPPrintBody$fBinaryMeasure $fBinaryDef $fBinaryBody$fBifunctorMeasure$fBifunctorDef $fMonoidRTEnv$fSymbolicModuleName$fSymbolicModName$fShowModuleName$fPPrintModName $fNFDataCinfo$fNFDataTError $fNFDataREnv$fPPrintPredicate $fPPrintPVar $fPPrint[]$fPPrintStratum $fShowStratum$fReftablePredicate$fSubableRType $fSubableRef$fSubableUReft$fExpressionUReft$fReftableUReft $fUReftable()$fUReftableUReft $fReftable[]$fSubableStratum$fBinaryRTAlias$fShowDataDecl $fOrdDataDecl $fEqDataDecl$fBinaryDataDecl$fBinarySizeFun$fNFDataSizeFun $fShowAxiom $fBinaryRISig$fBinaryRInstance $fShowBTyCon $fShowRTyCon$fPPrintBTyCon$fPPrintRTyCon$fFixpointCinfo$fFixpointBTyCon$fFixpointRTyCon $fEqBTyCon $fEqRTyCon$fTyConableBTyCon$fTyConableLocated$fTyConableSymbol$fTyConableTyCon$fTyConableRTyCon $fMonoid[]$fBinaryStratum$fNFDataStratum $fBinaryUReft $fNFDataRef $fBinaryRef$fBinaryRTVInfo$fNFDataRTVInfo $fNFDataRTVar $fBinaryRTVar $fEqRTVar $fNFDataRType $fBinaryRType $fShowRTVar$fShowTyConInfo$fNFDataTyConInfo$fDefaultTyConInfo$fNFDataRTyCon$fNFDataBTyCon$fSymbolicBTyCon$fBinaryBTyCon$fSymbolicRTyVar$fSymbolicBTyVar$fNFDataRTyVar$fNFDataBTyVar$fHashableBTyVar$fBinaryBTyVar$fIsStringBTyVar $fOrdBTyVar $fEqBTyVar $fNFDataUReft$fSubableQualifier$fSubablePredicate $fSubablePVar $fMonoidUReft$fMonoidPredicate$fNFDataPredicate$fBinaryPredicate$fNFDataPVKind$fBinaryPVKind$fHashablePVar $fNFDataPVar $fBinaryPVar $fOrdPVar$fEqPVar $fShowLMap$fMonoidLogicMap$fHasConfigGhcSpec$fHasConfigGhcInfo $fShowPPEnv$fShowLogicMap$fGenericPVKind $fDataPVKind$fFunctorPVKind$fFoldablePVKind$fTraversablePVKind $fShowPVKind $fGenericPVar $fDataPVar $fShowPVar $fFunctorPVar$fGenericPredicate$fDataPredicate $fShowBTyVar$fGenericBTyVar $fDataBTyVar$fGenericRTyVar $fDataRTyVar$fGenericBTyCon $fDataBTyCon$fGenericRTVInfo $fDataRTVInfo$fFunctorRTVInfo$fGenericRTVar $fDataRTVar $fGenericRef $fDataRef $fFunctorRef$fGenericRType $fDataRType$fFunctorRType $fGenericHSeg $fDataHSeg$fGenericWorld $fDataWorld$fGenericStratum $fDataStratum $fEqStratum$fGenericUReft $fDataUReft$fFunctorUReft$fFoldableUReft$fTraversableUReft$fGenericRISig$fFunctorRISig $fDataRISig $fShowRISig$fGenericRInstance$fFunctorRInstance$fDataRInstance$fShowRInstance $fMonoidDEnv $fShowDEnv $fDataSizeFun$fGenericSizeFun$fGenericTyConInfo$fDataTyConInfo$fGenericRTyCon $fDataRTyCon$fGenericDataConP$fDataDataConP$fGenericTyConP $fDataTyConP$fDataDataDecl$fGenericDataDecl $fDataRTAlias$fGenericRTAlias $fEqCinfo $fOrdCinfo$fGenericCinfo $fEqModType $fOrdModType $fShowModType $fEqModName $fOrdModName $fShowModName $fShowBody $fDataBody $fGenericBody$fEqBody $fShowDef $fDataDef $fGenericDef$fEqDef $fFunctorDef $fDataMeasure$fGenericMeasure$fFunctorMeasure$fDataCMeasure$fGenericCMeasure$fFunctorCMeasure $fShowRClass$fFunctorRClass $fDataRClass$fGenericRClass $fDataAnnInfo$fGenericAnnInfo$fFunctorAnnInfo $fDataAnnot$fGenericAnnot$fFunctorAnnot$fGenericOutput$fFunctorOutput$fGenericKVKind $fEqKVKind $fOrdKVKind $fShowKVKind $fDataKVKind$fGenericKVProf $fDataMSpec$fGenericMSpec$fFunctorMSpecsimplifyBounds SubStratumsubSsubsS<:= solveStrata$fSubStratumRType$fSubStratumAnnot$fSubStratum[]$fSubStratum(,)$fSubStratumStratumValVBVVVXVSVCResultPassedFailedErrored MeasureEnv DataConEnvValueVariableTargetExceptionSmtFailedToProduceOutputSmtErrorExpectedValuesPreconditionCheckFailed EvalError ensureValuesboolsort choicesort $fPPrintVal $fSMTLIB2[] $fSymbolic(,)$fExceptionTargetException$fShowTargetException $fShowResult $fGenericVal $fShowVal$fEqVal$fOrdValpprManyOrderedpprintLongList pprintSymbolrtypeDoc $fPPrintUReft $fPPrintTidy$fPPrintRTAlias $fPPrintRType$fPPrintLogicMap $fPPrintLMap $fShowAnnInfo$fPPrintAnnInfo $fPPrintAnnot$fShowPredicate $fPPrintClass $fPPrintType $fPPrintTyCon $fPPrintName $fPPrintVar$fPPrintSourceError$fPPrintErrMsgsplitXRelatedRefs $fShowUReft $fIsFreexFreeVarstrengthenDataConTypepdVarfindPVaruRTypeuRType' uRTypeGenuPVaruReftuToprVarrTyVar updateRTVar rTVarInfo kindToRType isValKindbTyVar symbolRTyVar bareRTyVar normalizePdsrExrApp tyConBTyConstrengthenRefTypeGenmeetable strengthen quantifyRTyquantifyFreeRTy addTyConInfo appRTyCon generalize tyClassessubsTyVars_meetsubsTyVars_nomeetsubsTyVar_nomeetsubsTyVar_meetsubsTyVar_meet'subts subvUReft subvPredicateofType bareOfType dataConReftisBaseTy dataConMsRefttoTyperTypeSortedReft rTypeSort applySolutionshiftVVtypeUniqueSymboltypeSort tyConNamemkDataConIdsTy classBinds makeNumEnv isDecreasing makeDecrType isSizeable makeLexRefa mkTyConInfo $fPPrintREnv $fShowRef $fShowRType $fShowRTyVar $fShowRTAlias$fExpressionVar$fSubsTytvtyRef$fSubsTyBTyVarRTypeRType$fSubsTyBTyVarRTypeBTyCon$fSubsTytvtyUReft$fSubsTytvRTypePredicate$fSubsTyRTyVarRTypeRType$fSubsTyRTyVarRTyVarRType$fSubsTyVarTypeRType$fSubsTyRTyVarRTypeRType0$fSubsTyRTyVarRTypeRType1$fSubsTyRTyVarRTypeRTyCon$fSubsTytvtyPVar$fSubsTytvtyPVKind$fSubsTyRTyVarRTypeSort$fSubsTySymbolRTypeSort$fSubsTyBTyVarRTypeSort$fSubsTytvty(,)$fSubsTytvtyExpr$fSubsTytvtyReft$fSubsTytvtySymbol$fSubsTytvty()$fSubsTyBTyVarRTypeRTVar$fSubsTyBTyVarRTypeBTyVar$fSubsTyRTyVarRTypeRTVar$fSubsTyRTyVarRTypeRTyVar$fHashableRTyCon $fOrdRTyCon$fHashableRTyVar $fOrdRTyVar $fEqRTyVar $fEqPredicate $fEqRType$fFreeVarBTyConBTyVar$fFreeVarRTyConRTyVar$fFixpointClass $fFixpoint[]$fReftableRType $fReftableRef$fReftableRef0$fReftableRef1$fReftableRef2$fReftableRef3 $fMonoidRef $fMonoidRTypeRRBEnvRBEnvRRBoundRBoundBoundbnametyvarsbparamsbargsbbody makeBound$fBifunctorBound $fPPrintBound $fShowBound $fEqBound$fHashableBound $fBinaryBound $fDataBound$fGenericBoundmakeDictionariesmakeDictionary dfromListdmaptymapRISig fromRISigdmapdinsertdlookupdhasinfo makeTyConInfodataConPSpecType dataConTyreplacePredsWithRefs pVartoRConc pvarRType replacePredspredType substParg pappAritypappSort$fShowDataConP$fPPrintDataConP $fShowTyConP$fPPrintTyConP CBVisitablefreeVarsreadVarsletVarsliterals$fCBVisitableAltCon$fCBVisitable(,,)$fCBVisitableExpr$fCBVisitableBind$fCBVisitable[]TagEnvTagKey defaultTag memTagEnv makeTagEnvgetTagStatusSafeUnsafeCrashAnnMapAnntypeserrorsstatushscolourhsannot srcModuleNamebreakS $fShowAnnMap $fEqStatus $fOrdStatus $fShowStatus$fShowAnnotation $fShowLitresulterrorToUserError cinfoError isTmpSymbol tidySpecType panicError $fException[]$fPPrintCtxError$fPPrintCtxError0$fResultFixResult$fResultTError $fResult[]$fResultTError0SpecmeasuresasmSigssigs localSigsreflSigs invariantsialiases dataDecls newtyDeclsaliasesealiasesembeds qualifiersdecrlvarslazyreflectsautoishmeashboundsinlinesautosizepragmas cmeasures imeasuresclasses termexprs rinstance dvarianceboundsdefs SpecMeasure BareMeasureBareSpec qualifySpecmkMmkMSpec'mkMSpec dataConTypes defRefType $fMonoidSpec $fBinarySpec $fGenericSpecPspecMeasAssmAsrtLAsrtAsrtsImptDDeclNTDeclInclInvtIAliasAliasEAliasEmbedQualifDecrLVarsLazyInstsHMeasReflectInlineASizeHBoundPBoundPragmaCMeasIMeasClassRInstVariaBFixDefineBPspechsSpecificationPspecSpecificationP singleSpecPparseSymbolToLogic $fEqPcScope $fShowPcScope $fDataPspec $fShowPspec meetVarTypes tidyErrormkOutputannotate$fToJSONAnnMap $fToJSONAssoc $fToJSON[] $fToJSONLoc$fToJSONAnnot1$fToJSONStatusgetOptscanonicalizePathsmkOpts withPragmas defConfigexitWithResult addErrors$fFixpointFixResult$fShowCtxError DiffCheckDCnewBinds oldOutputnewSpec checkedVarsslicethin filterBinds saveResult$fFromJSONOutput$fToJSONOutput$fFromJSONAnnInfo$fToJSONAnnInfo$fFromJSONHashMap$fToJSONHashMap $fFromJSONDoc $fToJSONDoc$fFromJSONFixResult$fToJSONFixResult$fFromJSONSourcePos$fToJSONSourcePos $fFunctorDiff$fPPrintDiffCheck$fOrdDef LiquidQuoteliquidQuoteSpeclq $fMonadSimpl$fApplicativeSimpl$fFunctorSimpl$fDataLiquidQuotewiredSortedSyms dictionaryVardictionaryTyVardictionaryBindcombineProofsNameproofTyConName wiredTyCons wiredDataCons pdVarReftintCSizecSizeIntmkPtr isNullPtrfpLenpLenderefeqPtrFEnvFEfeBindsfeEnvfeIdEnv RTyConIAl RTyConInvHEnvCGInfofEnvhsCshsWfssCsfixCsisBindfixWfs freshIndexannotMap tyConInfospecDecrnewTyEnv termExprs specLVarsspecLazyautoSize tyConEmbedkutskvPackscgLitscgConststcheckscheck pruneRefs logErrorskvProfrecCount bindSpansallowHOghcI dataConTysFixWfCFixSubCWfCSubCSubRsenvlhsrhsobligref LConstraintLCCGEnvCGEcgLocrenvsyenvdenvlitEnvconstEnvfenvrecsfargsinvsrinvsialgrtysassmsintysembtgEnvtgKeytreclcbholeslcsaenvcerrcgInfocgVarCG fromListHEnvelemHEnv addArgument addArguments mkRTyConInv mkRTyConIAl addRTyConInvaddRInvremoveInvariantrestoreInvariantmakeRecInvariants insertsFEnvinitFEnv$fNFDataCGInfo $fNFDataWfC $fNFDataSubC $fNFDataFEnv $fNFDataCGEnv $fNFDataRInv$fPPrintCGInfo$fSubStratumSubC $fPPrintWfC $fPPrintSubC $fShowCGEnv $fPPrintCGEnv$fMonoidLConstraint$fHasConfigCGEnv $fShowRInv Freshablefreshtruerefresh refreshTy refreshVVrefreshArgsTop refreshArgs refreshHoles freshTy_type freshTy_expraddKutstrueTy$fFreshablemRType$fFreshablem[]$fFreshablemUReft$fFreshablemReft$fFreshablem[]0$fFreshablemExpr$fFreshablemSymbol$fFreshableStateTInteger fromListREnv insertREnv lookupREnvlocalBindsOfType toListREnvextendEnvWithVV addBindersrTypeSortedReft'+= globalizeaddSEnv+++=-=?= setLocationsetBindsetRecssetTRec getLocation pushConsBindaddCaddPostaddW addWarningaddIdA boundRecVaraddLocA updateLocAaddA lookupNewTypeaddConstraintsconstraintToLogicsplitWsplitSsplitCenvToSub panicUnbound specToBare measureToBare txExpToBindBareEnvBEmodNametcEnvrtEnvvarEnvhscEnvlogicEnvaxSymsInlnEnvTCEnvWarnBareM setEmbedsaddDefsinsertLogicEnv insertAxiominModule withVArgs setRTAlias setREAliasexecBare ExpandAliases$fExpandAliases(,)$fExpandAliases[]$fExpandAliasesMaybe$fExpandAliasesLocated$fExpandAliasesUReft$fExpandAliasesDataConP$fExpandAliasesMeasure$fExpandAliasesDef$fExpandAliasesBody$fExpandAliasesRType$fExpandAliasesReft$fExpandAliasesExpr GhcLookup lookupNamelookupGhcThing lookupGhcVarlookupGhcTyConlookupGhcDataCon$fSymbolicFieldLbl$fGhcLookupFieldLbl$fGhcLookupName$fGhcLookupLocated MapTyVarSTMTVSTvmaperrmsgmakeDataConCheckermakeDataSelector makeSymbols initMapSt runMapTyVars mapTyVarsisKind matchKindArgs mkVarExprjoinVarsimpleSymbolVar hasBoolResult normalize logicTypestrengthenResultstrengthenResult' runToLogicrunToLogicWithBoolBinds coreToDef coreToFun coreToLogicmkLitmkImkS$fSimplify(,,)$fSimplifyBind$fSimplifyExpr $fShowExprliteralFRefType literalFReft literalConstmakePluggedSigsmakePluggedAsmSigsmakePluggedDataCons Resolvableresolve$fResolvable()$fResolvablePVar$fResolvablePredicate$fResolvableReft$fResolvableUReft$fResolvableSort$fResolvableSymbol$fResolvableLocated$fResolvableExpr$fResolvableQualifier$fResolvable[] ofBareType ofMeaSortofBSortofBPVar mkLSpecType mkSpecType'makeHaskellMeasuresmakeHaskellInlinesstrengthenHaskellInlinesstrengthenHaskellMeasuresmakeMeasureSelectorsmakeMeasureSpecmakeMeasureSpec'makeClassMeasureSpec varMeasuresmakeHaskellBounds makeRTEnv txRefSort makeClassesmakeQualifiers makeHintsmakeLVarmakeLazy makeAutoInstsmakeDefs makeHBounds makeTExpr makeHInlines makeHMeasmakeTargetVarsmakeAssertSpecmakeAssumeSpecmakeDefaultMethods makeIAliases makeNewTypesmakeInvariantsmakeSpecDictionaries makeBoundsmakeNumericInfo makeConTypes dataConSpecmeetDataConSpecmakeTyConEmbedsmakeRecordSelectorSigs checkGhcSpeccheckTerminationExprcheckTymakeHaskellAxioms makeGhcSpecsaveLiftedSpecloadLiftedSpec useSpcQuals fixConfig cgInfoFInfo getGhcInfos runLiquidGhc exportedVars isExportedVar pprintCBs$fResultSourceError$fPPrintTargetVars $fShowGhcInfo$fPPrintGhcInfo$fPPrintGhcSpecinitEnvinitCGIgenerateConstraints $fShowCinfo$fFunctorTemplate$fFoldableTemplate$fTraversableTemplate$fShowTemplateResArgsAllHave ConstraintsMapHListNil:::DepthiomyTracereftmakeDecl applyPreds propPsToProp propPToPropsplitEApp_maybe stripQualsgetSpecrunGhc loadModule $fShowHList TargetState variableschoices constraintsdepsrealizeddconEnvctorEnvmeasEnvembEnv tyconInfofreesyms constructorschosensortsfilePathmakingTy smtContext TargetOptsdepthsolververboselogging keepGoing maxSuccessscDepthghcOpts runTargetfreshInt defaultOpts initState whenVerbosenoteUsedaddDep addConstraintaddConstructormaking lookupCtorguardedaddSort addVariable freshChoicegetValue$fMonadThrowTarget$fFunctorTarget$fApplicativeTarget $fMonadTarget$fMonadIOTarget$fAlternativeTarget$fMonadStateTarget$fMonadCatchTarget$fMonadReaderTargetevalevalWithevalExpr TargetablequerydecodechecktoExprgetTypeqqueryunfoldapplyunapplyoneOfwhichOf constrainofReft$fGCheckFieldsU1$fGDecodeFieldsU1$fGQueryFieldsU1$fGRecursiveU1$fGToExprFieldsU1$fGCheckFieldsM1$fGDecodeFieldsM1$fGQueryFieldsM1$fGRecursiveM1$fGToExprFieldsM1$fGCheckFields:*:$fGDecodeFields:*:$fGQueryFields:*:$fGRecursive:*:$fGToExprFields:*: $fGCheckM1 $fGDecodeM1$fGQueryCtorsM1$fGToExprCtorM1 $fGCheck:+: $fGDecode:+:$fGQueryCtors:+:$fGToExprCtor:+:$fGCheckFieldsK1$fGDecodeFieldsK1 $fGQueryK1 $fGToExprK1 $fGCheckM10 $fGDecodeM10 $fGQueryM1 $fGToExprM1$fTargetable(,,,)$fTargetable(,,)$fTargetable(,)$fTargetableEither$fTargetableMaybe$fTargetable[]$fTargetableBool$fTargetableWord8$fTargetableChar$fTargetableInteger$fTargetableInt$fTargetable()$fTargetable(->)$fTargetable(->)0$fTargetable(->)1Testabletestsetup $fTestablea$fTestable(->)Su TargetDictDict getModelsgetModel getModel' withContexttoFixCfg dictProxy asTypeOfDictaddDictsaddDictaddDict' monomorphizemonomorphizeOnemonomorphizeFree hscParsedStmthandleWarnings ioMsgMaybe throwErrors getWarnings clearWarnings logWarningshscParsedDeclsMbEnvliquid runLiquidResponseCommandStatesCountsMbEnv$fSerializeStatus$fGenericStatus $fDataStatushandlerinitialTestTtargetTH targetResulttargetResultTH targetWith targetWithTHtargetResultWithtargetResultWithTHcatchIObindirlibdirdatadir libexecdir sysconfdirToProveOptGtOptLessOptGEqOptLEqOptEqsrcSpanContext srcSpanInfo getFileLinegetNth makeContextppObligerrSpan pprSrcSpanpprRealSrcSpannestssepVcat blankLineppFullppReqInContext pprintBindppReqModelInContextvsep pprintModelppPropInContexterrSavedppVarghcTyCoRep pprTcAppCo pprDataConsppr_typepprTyLitsubstCoVarBndrCallbacksubstForAllCoBndrCallbackextendTvSubstBinderextendCvSubstWithCloneextendTvSubstWithClone setCvSubstEnv coVarsOfCostyCoVarsOfProvtyCoVarsOfCoList tyCoFVsBndrTyLitNumTyLitStrTyLit KindCoercionsubstTyVarBndrCallbacksubstForAllCoBndrsubstTyWithBinderssubstTysWithCoVarssubstTyWithInScopezipTyBinderSubst zipCvSubstmkTyCoInScopeSetcloseOverKindsFVdelBinderVarFV delBinderVartidyCostidyCotidyKind tidyOpenKind tidyTopType tidyOpenType tidyOpenTypestidyType tidyTypes tidyTyVarOcctidyOpenTyCoVartidyOpenTyCoVarstidyFreeTyCoVars tidyTyBinders tidyTyBindertidyTyCoVarBndrtidyTyCoVarBndrs pprArrowChain pprPrefixApp pprTcAppTy pprTypeApp pprTvBndr pprTvBndrs pprForAllpprForAllImplicit pprUserForAll pprSigmaTypepprThetaArrowTypprTheta pprClassPred pprParendKindpprKind pprParendTypepprType maybeParencloneTyVarBndrscloneTyVarBndrsubstCoVarBndrsubstTyVarBndr lookupCoVar substCoVars substCoVarsubstCossubstCoUncheckedsubstCo lookupTyVar substTyVars substTyVarsubstThetaUnchecked substThetasubstTysUncheckedsubstTyssubstTyUncheckedsubstTysubstTyAddInScopesubstTyWithBindersUncheckedsubstTyWithCoVarssubstCoWithUnchecked substCoWithsubstTyWithUnchecked substTyWithzipCoEnvzipTyEnv mkTvSubstPrs zipTvSubst unionTCvSubstextendTvSubstListextendTvSubstAndInScope extendCvSubst extendTvSubstextendTCvSubstextendTCvInScopeSetextendTCvInScopeListextendTCvInScope zapTCvSubst setTvSubstEnvnotElemTCvSubst isInScopegetTCvSubstRangeFVs getTCvInScope getCvSubstEnv getTvSubstEnv mkTvSubst mkTCvSubstisEmptyTCvSubstmkEmptyTCvSubst emptyTCvSubstcomposeTCvSubstcomposeTCvSubstEnvemptyCvSubstEnvemptyTvSubstEnvpprTyThingCategory pprTyThingtyCoVarsOfTelescopecloseOverKindsDSetcloseOverKindsListcloseOverKinds coVarsOfCo coVarsOfTypes coVarsOfType tyCoFVsOfCos tyCoVarsOfCos tyCoFVsOfCotyCoVarsOfCoDSet tyCoVarsOfCotyCoFVsOfTypestyCoVarsOfTypesListtyCoVarsOfTypesDSettyCoVarsOfTypes tyCoFVsOfTypetyCoVarsOfTypeListtyCoVarsOfTypeDSettyCoVarsOfTypepickLRdropRuntimeRepArgsisRuntimeRepVarisRuntimeRepKindedTyisRuntimeRepTyisUnliftedTypeKindisLiftedTypeKind mkTyConTy isAnonBinder isNamedBinderisVisibleBinderisInvisibleBinder binderTypeisCoercionTypemkFunTysmkFunTy mkTyVarTys mkTyVarTysameVisVisibilityFlagVisible Specified Invisible KindOrType CoercionN CoercionR CoercionP CoercionHolechUnique chCoercion TvSubstEnv CvSubstEnvTyPrecTopPrecFunPrecTyOpPrec TyConPrec mkForAllTysTypeTyVarTyAppTyTyConAppForAllTyLitTyCastTy CoercionTyTyBinderNamedAnonTyThingAnIdAConLikeATyConACoAxiomCoercionReflUnivCo TyConAppCoAppCoForAllCoCoVarCo AxiomInstCoSymCoTransCo AxiomRuleCoNthCoLRCoInstCo CoherenceCoKindCoSubCo LeftOrRightCLeftCRightUnivCoProvenanceUnsafeCoerceProv PhantomProvProofIrrelProv PluginProvHoleProvTCvSubstPredTypeKind ThetaTypeexprArgsisunStack mbSrcSpan spanSrcSpan maybeSpanTrEnvTr_locTEinlineLoopBreakerinlineFailCases isTypeError isCaseArgscTranstransPgtransBd transExpr isNonPolyRecnonPolycollectNonRecLets appTysAndIdstrans makeTrans mkRecBindsmkSubs mkFreshIds freshUnique mapNonRecmapBndmapExprmapAltmapBdM RewriteRule_safeSimplifyPatTuplehasTuple replaceTuplefixCase substTupleCoreSynCaseisVarTupListNE simplifyCore tidyTuplesrewriteBindWith rewriteWith_tidyAltsimplifyPatTuplevarTuple takeBinds matchTypes isProjection _showExpr_showVar _errorSkipreplaceIrrefutPatreplaceIrrefutPat'isIrrefutErrorVarmkSubsteqVarsisVar secondHalfnormalizeTopBindnormalizeForAllTysfreshNormalVarAnfEnvaeVarEnv aeSrcSpanaeCfgDsMWDsSTst_bindsDsMrunDsM expandFlagmodGutsTypeEnvnormalizeTyVarssubst normalizeBind normalizeNameshouldNormalizeaddnormalizeLiteralstitchnormalizePatternexpandDefaultCaseexpandDefaultCase' cloneCase sortCasesanfOcc emptyAnfEnv lookupAnfEnv extendAnfEnvat rtc_pvarsSymbolKVP ppEnvCurrent_ppEnvPrintPredsdropAppisApppdTruepdAnd mapQualBodyisProp ty_var_is_valrtvinfo_is_valisClassOrSubClass isTauto_ureft ppTy_ureftppr_reftppr_strpToRefemapReftemapRefmapRefM mapBotRef mapBindRefstripAnnotationsstripAnnotationsRefmapRBase makeLTypeppr_pvar emptyOutput ppRefArgsppRefSym dropBoundLikeisBoundLikePredisImp simplifyLenallSVarsnoSVarnoUpdate updateFin updateDivsolvepprAnnInfoBindspprAnnInfoBindpprXOTppAliaspprints ppr_rtypeppTyConB shortModules ppr_rsubtypeppExists ppAllExprppReftPs ppr_dbind ppr_rty_fun ppr_rty_fun' ppr_forall ppr_rtvar_def ppr_symbolsppr_cls ppr_pvar_def ppr_pvar_kindppr_name ppr_pvar_sortppr_refdotIsFreeisFree splitRType splitUReftsplitRef splitReft splitPred ToTypeable#Language.Fixpoint.Types.RefinementsReftTyConvtcFVartcFTVartcFApptcFLiteqRSorteqpdrTVarbTVar bTVarInfo mkTVarInfo kindToBRType kindToRType_rPred tyConRTyConbAppaddPdsnlzPpprt_rawstrengthenRefTypestrengthenRefType_meets expandRApp rtPropToprtPropPVmkRTProppvArgs isNumeric addNumSizeFun subsTyVars subsTyVarsubsFree subsFreessubsFreeRAppTymkRApp refAppTyToFun subsFreeRefofType_ ofLitType isBaseDataCon appSolRefa tyConFTyContypeSortForAll typeSortFungrabArgsexpandProductType mkProductTy rTyVarSymbolmkDType mkDecrFun cmpLexRef makeLexReftmakeTyConVariancedataConsOfTyCon makeBoundType partitionPsisPApp toUsedPVars toUsedPVarmakeRefmakeDictionaryNamemakeDicTypeName substRConmkRTyCon rpredType predRTyCon wpredRTyCon symbolRTyCon substPredpad substPredP splitRPvar freeArgsPs freeArgsPsRefmeetListWithPSubsmeetListWithPSubsRefmeetListWithPSubmeetListWithPSubRefpredName wpredName symbolType predFTyCon exprFreeVars exprReadVars exprLetVars exprLiterals extendEnvbindings CallGraphcallGraphRanks makeCallGraphbindEqnsLiterrlin annotTokeniseclassifyjoinLCodeunLCommentTransform AnnotationAlitSpanshsannot' spanAnnotspanLineinRangetokeniseWithCommentTransform tokenSpansplusLocrenderAnnotTokenrenderTypAnnotrenderErrAnnotrenderLinAnnot lineStringinsertAnnotAnchorssplitSrcAndAnns tokenModule annotParse parseLines ppAnnotTyp ppAnnotErrallProg tidyValueVarstidyVV tidySymbolstidyLocalRefas tidyDSymbols tidyFunBinds tidyTyVars bindersTxtyVars subsTyVarsAllfunBinds ppSpecTypeErr ppSpecTypecheckDuplicateMeasuremakeDataConTypeextendresultTy noDummySymscombineDCTypes mapArgumens stitchArgspanicFieldNumMismatch panicDataConrefineWithCtorBodybodyPred bareTypePmkSpecspecP fallbackSpecP tyBindsRemP cMeasurePbinderPfTyConPPcScope PcImplicit PcExplicit PcNoSymbol ParamCompPC_pci_pctspecificationPmapRightparseWithErrorparseErrorError remParseError remLineColtoLogicP toLogicOnePdefinePangles stringLiteralnullPCbtPcompPcirclePholePC namedCirclePunnamedCirclePbareTypeBracesPbareArgP bareAtomP bareAtomBindP refBindBindPrefBindOptBindPrefPrefDefPoptBindPholePholeRefP refasHolePbbaseP lowerIdTailbTyConP classBTyConPstratumP bstratumP bbaseNoAppPmaybeP bareTyArgPbareAtomNoAppP constraintPconstraintEnvPrrTybareAllP tyVarDefsPtyVarIdP tyKindVarIdPkindP predVarDefsP predVarDefP predVarIdPbPVar predVarTypeP mkPredVarTypexyP dummyBindPisPropBareTypeisPrimBareType getClassesdummyPsymsP dummyRSort predicatesP predicate1PmmonoPredicatePmonoPredicatePmonoPredicate1P predVarUsePfunArgsPboundP infixGenPinfixPinfixlPinfixrP maybeDigitbRPropbRVarbLstbTupbConbAppTy reftUReft predUReft dummyReft dummyTyIdpragmaP autoinstPlazyVarPaxiomPhboundPinlinePasizeP decreaseP filePathP datavarianceP variancePtyBindsP tyBindNoLocPtyBindP termBareTypeP termTypeP invariantP invaliasP genBareTypePembedPaliasPealiasPrtAliasPaliasIdP hmeasurePmeasureP iMeasureP oneClassArg instanceP riMethodSigPclassPrawBodyPtyBodyP locUpperIdP' upperIdP'condIdP' infixCondIdP'grabs measureDefP measurePatPtupPatPconPatPconsPatPnilPatPnullaryConPatPmkTupPatmkNilPat mkConsPat tupDataCondataConFieldsP dataConFieldP predTypeDDPbbindPdataConP adtDataConP dataConNameP dataSizePnewtypeP dataDeclP meetErrorCtxMCtxtidyErrContexttidyCtxtidyCtxM stripReft stripRTypetidyREnv tidyREnvM expandFix tidyTemps niceTempsAssoc renderPandoc renderDirect topAndTailmkAnnMaprefTokentokAnnotvimAnnot_annsAnnot1A1identannrowcol AnnErrorsAnnTypesAsc doGeneratemkBotswriteFilesOrStrings generateHtml renderHtml renderPandoc' checkExitCode pandocCmd pandocPreProc htmlHeader htmlClosecssHTMLmkStatus mkAnnMapErrcinfoErr mkAnnMapTypmkAnnMapBinders closeAnnotscloseAfilterA collapseApickOneAtrimLiquidAnnottokBodyisMeasisDataisTypeisIncl spacePrefix tokeniseSpec chopAltDBGvimBindannTypesinsibaseGHC.IOFilePath canonConfigCErrordefaultMaxParamsconfig defaultPort cmdArgsRun' withSmtSolver findSmtSolver canonicalizeenvCfg copyright withPragma parsePragmadefFuel consoleResultconsoleResultFullconsoleResultJsonresultWithContextwriteCheckVars writeResultresDocs errToFCrashChkItvDepsstartendbinder assumeSpec dependsOn meetSpanslineDiff diffLinesgetShiftsetShift sliceSaved sliceSaved'diffVarssigVars globalDiffisDiffthinWithcoreDeps txClosurespecDefsspecSigscoreDefscoreDeflineSpancatSpansbindFilevarFile exprSpansaltSpans isJunkSpan lineDiff' diffShifts loadResult adjustOutput adjustTypes adjustResult errorsResult adjustErrors adjustSrcSpan isCheckedSpanisCheckedRealSpan adjustSpan adjustReal checkedItvfilelinelineESimpl Simplified FoundExprArg FoundHolelqDec throwErrorInQ mkSpecDecs symbolNamesimplifyBareTypesimplifyBareType'simplifyBareType''filterExprArgs locSourcePos dataToExpQ' textToExpQextQmaxAritywiredTyDataConslistTyDataConstupleTyDataConsmkpsmkps_RInv _rinv_args _rinv_type _rinv_name pprCGInfo lookupRInvgoodInvs unifiableconjoinInvariantShiftconjoinInvariant insertFEnvaddKVars trueRefTypetrueRefrefreshRefType refreshReffreshSym refreshVVRefrefreshArgsSub refreshPs refreshHoles'noHolesfreshTy_reftypeisKut specTypeKVarsofType'fixTy exprRefType exprRefType_ bindRefType_extendγ updREnvLocal filterREnv deleteREnv memberREnv globalREnvrenvMaps localsREnv globalsREnvaddBind addClassBindaddCGEnv normalizeVV _dupBindError++=setBind'constraintToLogicOnesubConstraintToLogicOne combinationsforallExprRefTypersplitWbsplitWbsplitW'splitsSWithVariancersplitsSWithVariancebsplitSrsplitSsplitfWithVariance updateEnvtraceTyparensrHolesplitsCWithVariancersplitsCWithVariancebsplitC addLhsInv checkStratumbsplitC'unifyVVrsplitCforallExprReftforallExprReft_forallExprReftLookup dataConToBare specToBareTC specToBareTVtxRTypetxRTVtxPVExStemappmap expToBindT expToBindReftgetBinds addExistsaddExist expToBindRef expToBind expToBindParg expToBindExpr freshSymbol setModule mkExprAlias expandApp txPredReft' expandExpr expandSym expandSym' expandEAppNameGHC.BaseStringlookupGhcThing'symbolicString symbolLookupwiredInsymbolLookupEnvsymbolLookupEnvOrig makeRdrNamemakeOccsymbolLookupEnvFulllookupTheModule lookupTheNameghcSplitModuleNameghcSymbolString isTupleDClookupGhcDataCon' freeSymbols mapTyRVarmatchKindArgs' varFunSymbolisFunVarSimplifysimplifyinlineLState symbolMapmkErrorltce boolbindsLogicMthrowgetStatevarRTypecoreToLg checkBoolAlts casesToLg checkDataConaltToLg coreToIte toPredApp toLogicApp liftBoolBindsmakeApp eVarWithMapvarExpr isPolyCstisCstbrelsbops splitArgs tomaybesymboltosymbol tosymbol'makesubmkR ignoreVarsimpleSymbolVar' isErasableisANFisDead isUndefinedNothing makeRTypeBasemkReft plugHolesaddRefs maybeTrue killHolesaddSymisConexprArgmapMPvar mkSpecTypetxParamtxPvarpredMaprtypePredBindsofBRType matchTyConfailRTAliasAppexpandRTAliasApp bareTCApptyAppexpandRTypeSynonymsmakeMeasureInlinemakeMeasureDefinitionerrHMeasstrengthenHaskellmeetLocmakeMeasureSelectormakeMeasureChecker mkMeasureDConmkMeasureDCon_ measureCtors mkMeasureSort isSimpleType varSpecTypemakeHaskellBound coreToFun'toBoundcapitalizeBound expandMeasureexpandMeasureDefexpandMeasureBodyNodeGraph AliasTable makeRTAliases makeREAliases graphExpandbuildAliasTablefromAliasSymbolbuildAliasGraphbuildAliasNodecheckCyclicAliases cycleAliasErrgenExpandOrderordNubbuildTypeEdgesbuildExprEdges addSymSort addSymSortRefaddSymSortRef' spliceArgs makeHIMeas varSymbols varsAftergrepClassAssertsgrepClassAssumes makeLocalSpecmakeSpec lookupIds mkVarSpec makeIAliases' makeNewTypes'makeInvariants'makeSpecDictionarymakeSpecDictionaryOneresolveDictionariesmkBoundmakeNumericInfoOne instanceTyCon makeConTypes' dataConSpec' ofBDataDeclgetPsSig getPsSigPsaddps ofBDataConmakeTyConEmbeds' checkRType checkMeasurescheckQualifierscheckQualifier checkSizeFun_checkRefinedClassescheckDuplicateFieldNamesfirstDuplicatecheckInvcheckIAl checkIAlOnecheckRTAliases checkBindcheckDupIntersectcheckDuplicatecheckDuplicateRTAlias checkMismatchtyCompaterrTypeMismatchtyToBind checkAppTys checkTcAritycheckAbstractRefs checkReft checkMeasure checkMBodycheckMBodyUnify checkMBody' dropNArgscheckClassMeasures axiomType updateLMapXVgetReflectDefsfindVarDefType makeAxiom makeSMTAxiommakeAssumeType isBoolBind strengthenRes updateLMapunDummy singletonAppmakeLiftedSpec0ReplaceM ReplaceState ReplaceEnvRE_reEnv_reFEnv_reEmb_reTyi initAxSymbolslistLMap postProcess ghcSpecEnvmakeLiftedSpec1insert _dumpSigs makeGhcSpec'addRTEnvmakeExactDataCons varInModule makeExact getReflects makeGhcAxioms makeLogicMap emptySpec makeGhcSpec0 makeGhcSpec1 makeGhcSpec2 makeGhcSpec3 makeGhcSpec4insertHMeasLogicEnvmakeGhcSpecCHOP1makeGhcSpecCHOP3makeMeasureInvariantsmeasureTypeToInvmakeGhcSpecCHOP2 txRefSort'replaceLocalBinds traverseExprs traverseBindswithExtendedEnvvarShortSymbolreplaceLocalBindsOne useSigQuals useAlsQuals maxQualParamsuseQuals alsQualifiers specAliases validQual sigQualifiersqualifyingBinders scrapeVars specBinders specAxiomVars refTypeQuals refTopQualsmkPQualmkQualenvSortignoreQualifiers targetFInfomakeAxiomEnvironment makeSimplify makeEquationsspecTypeToLogicspecTypeToResultRef makeAxiomsSpecEnvextractSpecCommentsfindAndParseSpecFiles DepGraphNodeDepGraph getGhcInfos'createTempDirectoryIfMissingconfigureDynFlagsconfigureGhcTargetssetTargetModules compileCFilesreachableModules buildDepGraphmkDepGraphNode isHomeModulemodSummaryImportsimportDeclModule classCons derivedVars derivedVs unfoldDepexprDep importVars definedVarsprocessModules processModulekeepRawTokenStreamloadDependenciesOf loadModule'processTargetModule toGhcSpecmodSummaryHsFilecachedBareSpecscheckFilePragmasextractSpecCommentextractSpecQuotesextractSpecQuoterefreshSymbols refreshSymbol getPatSpec getRealSpectransParseSpecsnoTerm parseSpecFile moduleHquals moduleFiles moduleFile specIncludesreqFilemakeMGIModGuts errMsgErrors predsUnifymakeDataConTypesmakeAutoDecrDataConslenOfmakeSizedDataConsmergeDataConTypes refreshArgs' strataUnifyassmgrtyassmGrtygrtyTopinfoLits coreBindLits makeDecrIndex consCBTop varTemplate varTemplate' topSpecTypecconsEinstantiatePredsinstantiateStrataconsE consPattern cconsFreshE projectTypes freshPredRefargType makeSingleton strengthenTop varRefType otherwiseexprLocTemplateAssertedAssumedInternalUnknownconsActmakeDecrIndexTyrecType checkIndex makeRecTypeunOConsmergecondition safeLogIndex checkHintcheckValidHint consCBLettrustVar derivedVar doTermCheckconsCBSizedTysconsCBWithExprs makeFinTy makeTermEnvs addObligationconsCBgrepDictionaryconsBind killSubst killSubstReftdefAnn addPToEnvextender unTemplateaddPostTemplatesafeFromAssertedcconsE'lambdaSignletonaddFunctionConstraintsplitConstraints substStrata cconsLazyLet caseKVKindupdateEnvironment checkMonadunRRTycastTycastTy' isClassConCo checkUnbound dropExistsdropConstraints cconsCasecaseEnvaltReftunfoldRinstantiateTysinstantiatePvs checkTyConcheckFuncheckAllcheckErrvarAnnargExprlamExpr??= varRefType'funExpr singletonReftstrengthenMeettopMeet isGenericLanguage.Fixpoint.Types.SortsSortseedsortTysarrowizeunObjevalPredfromExpr evalExpr'evalBrel applyMeasureevalSetevalBodyevalRelevalBop GCheckFields gcheckFields GDecodeFields gdecodeFields GQueryFields gqueryFields GRecursive gconArgTys GToExprFields gtoExprFields GQueryCtors gqueryCtors GToExprCtor gtoExprCtorGCheckgcheckGDecodegdecodeGQuerygqueryGToExprgtoExprreproxy reproxyRep reproxyGElemqualifyqualifiedDatatypeName reproxyLeft reproxyRight gisRecursive gqueryCtorgetCtorsdataConSymbol_noUniquegenFun stitchFungenExprevalTypefreshen evalTypesGHC.ShowShow queryArgs decodeArgsmkExprsprocessfunc checkManycheckOneactOrDiehandle liquidOnenewPrune maybeEither liquidQueries liquidQuerydumpCs pprintManysolveCse2uResOkResFail runLiquid'