]K      !"#$%&'()*+,-./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 5 6 7 8 9 : ; < = > ? @ A B C D E F G H IJNone$%&+,/09:;<=ACDIOQRTb>  !"#$%&'()*+,-./0123456789:;<=; $  !"#%&'()*+,-./0182345679:>123456789:  !"#$%&'()*+,-./0=<; '  !"#$%&'()*+,-./01 23456789:;<=None$%&+,/09:;<=ACDIOQRTb!A concrete representation of the  type."Natural numbers on the type-level.EGet a static representation for a dynamically created natural number.Example:reifyNat (S (S Z)) show"2"AA template haskell function to create nicer looking number types.Example:$(nat 5) :: Natural $(natT 5)5c@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~U@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~c~}|{zyxwvutsrqponmlkjihgfedcba`_^]\[ZYXWVUTSRQPONMLKJIHGFEDCB@A^@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~None$%&+,/09:;<=ACDIOQRTb"Strongly typed heterogenous lists.A List e '[tp1,tp2,tp3] contains 3 elements of types e tp1, e tp2 and e tp3 respectively.5As an example, the following list contains two types:5int ::: bool ::: Nil :: List Repr '[IntType,BoolType][IntRepr,BoolRepr].Get a static representation of a dynamic list.?For example, to convert a list of strings into a list of types:]reifyList (\name f -> case name of { "int" -> f int ; "bool" -> f bool }) ["bool","int"] show"[BoolRepr,IntRepr]"?9?=9 None$%&+,/09:;<=ACDIOQRTbNone$%&+,/09:;<=ACDIOQRTb jA concrete representation of an SMT type. For aesthetic reasons, it's recommended to use the functions r, s, t, u or v.4Values that can be used as constants in expressions.CGet the data type from a valueD7How many polymorphic parameters does this datatype haveE)The name of the datatype. Must be unique.F,Get all of the constructors of this datatypeGGet the name of a constructorH;Test if a value is constructed using a specific constructorI#Get all the fields of a constructorJ%Construct a value using a constructorK>Deconstruct a value into a constructor and a list of argumentsLGet the name of a fieldMGet the type of a fieldN"Extract a field value from a valueUlDescribes the kind of all SMT types. It is only used in promoted form, for a concrete representation see  .r;A representation of the SMT Bool type. Holds the values   or $. Constants can be created using  .sA representation of the SMT Int type. Holds the unbounded positive and negative integers. Constants can be created using  .tA representation of the SMT Real type. Holds positive and negative reals x/y where x and y are integers. Constants can be created using  .uA typed representation of the SMT BitVec type. Holds bitvectors (a vector of booleans) of a certain bitwidth. Constants can be created using  .vA representation of the SMT Array type. Has a list of index types and an element type. Stores one value of the element type for each combination of the index types. Constants can be created using  .w?A representation of a user-defined datatype without parameters.x<A representation of a user-defined datatype with parameters.5Determine the number of elements a type contains. K& means the type has infinite elements.cGet the smallest bitvector value that is bigger than the given one. Also known as the successor.eGet the largest bitvector value that is smaller than the given one. Also known as the predecessor.ZGet the minimal value for a bitvector. If unsigned, the value is 0, otherwise 2^(bw-1).aGet the maximal value for a bitvector. If unsigned, the value is 2^(bw-1)-1, otherwise 2^bw-1.      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcAlready registered datatypesdefghijThe type containing parameters$The concrete type without parameters.Action to execute when a parameter is assignedklmnopqrstuThe width of the bitvectorvwxyz{|}~Signed bitvector?Signed bitvector?      !"#$%&'()*+,-./0123456789:;<=@AB>?ECDFGHIJKLMN@]^A_B`OPQRSTU[VWXYZ\abcdefghijklmnopqrstuvwxyz{|}~UVWXYZ[\TQRSPO=>?@ABCDEFGHIJKLMN<;6789:452301()*+,-./bcdefghijklmno#$%&'!" ]^_`pa     qrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\abcdefghijklmnopqrstuvwxyz{|}~]^_`None$%&+,/09:;<=ACDIOQRTb Free variable.MQuantified variable, i.e. a variable that's bound by a forall/exists quantor.;A function argument variable. Only used in function bodies."A variable bound by a let binding.Function applicationConstantAsArray converts a function into an array by using the function arguments as array indices and the return type as array element.0Bind variables using a forall or exists quantor.Bind variables to expressions.      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHHow to translate variables%How to translate quantified variablesHow to translate functions#How to translate function variablesHow to translate let variables How to translate sub-expressionsThe expression to translateIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|      !"#$%&(+=0*?'),/1234567;<89:@-.>ABCDEFGHIJKLMNOABCDE&'()*+,-./0123456789:;<=>?@$% !"#     |{zyxFGHIwvuJKLMNOtsrqponmlkjihgfedcba`_^]\[ZYXWVUTSRQPO        !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|None$%&+,/09:;<=ACDIOQRTb   None$%&+,/09:;<=ACDIOQRTb None$%&+,/09:;<=ACDIOQRTb)Solver information query type. Used with  .2Options controling the behaviour of the SMT solver6Whether or not to print "success" after each operation>Produce a satisfying assignment after each successful checkSat>Produce a proof of unsatisfiability after each failed checkSatBEnable the querying of unsatisfiable cores after a failed checkSat+Enable the generation of craig interpolants<Describe limits on the ressources that an SMT-solver can useSA limit on the amount of time the solver can spend on the problem (in milliseconds)AA limit on the amount of memory the solver can use (in megabytes)The result of a check-sat queryThe formula is satisfiableThe formula is unsatisfiable;The solver cannot determine the satisfiability of a formulaThe interpolation partition3A backend represents a specific type of SMT solver.0The monad in which the backend executes queries.!The internal type of expressions.The internal type of variables.*The internal type of quantified variables.,The internal type of user-defined functions.[     J[     %      None$%&+,/09:;<=ACDIOQRTb*jThe SMT monad is used to perform communication with the SMT solver. The type of solver is given by the b parameter.-)Execute an SMT action on a given backend..Like - but specialized to the LG monad so exeptions can be handled by gracefully exiting the solver.&'()*+,-'An action that creates a fresh backend.The SMT action to perform../0123456789:;&'()*+,-./0123456*+,&'();:987-./0123456&'()*+,-./0123456789:; None$%&+,/09:;<=ACDIOQRTbF6A user-supplied function. Can be used in embedding s or hs. Since we don't have function equality in haskell, an integer is provided to distinguish functions.O A class of M\s that can be used to form SMTLib expressions. The default instance of this class is the *( monad, together with its associated & type. An interesting instance is the N monad with the 5 type, which allows evaluation of SMTLib expressions.2<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklm!<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\2XOPQRSTUVWHIJKLMNmlFGkjihgCDEfedcbABa>?@`_^YZ<=[\]<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklm None$%&+,/09:;<=ACDIOQRTbs2All elements of this list must be of the same typeOZExtract the type that all elements of the list share. This is simply the first element.P\Convert a list of same elements to an all-equal list. This is just the identity function.&Matches constant boolean expressions ( or ).QWConvert an all-equal list to a list of elements of same type. This can fail (return K) when the list is empty.R The same as QG but also returns the original list. Only used for pattern matching.*Create a constant, for example an integer:Example: [do x <- declareVar int -- x is greater than 5 assert $ x .>. constant (IntValue 5) %Create a boolean constant expression.&Create an integer constant expression."Create a real constant expression.Example: 'import Data.Ratio x = creal (5 % 4) 'Create a constant bitvector expression.0Create an untyped constant bitvector expression.CCreate an expression by applying a function to a list of arguments.ICreate a typed list by appending an element to the front of another list.Create an empty list.UCreate a boolean expression that encodes that two expressions have the same value.Example: is5 ::   b =>   b W ->   b V is5 e = e   5 4Access an array element. The following law holds: # select (store arr i e) i .==. e A specialized version of ) when the index is just a single element.hWrite an element into an array and return the resulting array. The following laws hold (forall i/=j): Q select (store arr i e) i .==. e select (store arr i e) j .==. select arr j A specialized version of ) when the index is just a single element.HCreate an array where every element is the same. The following holds: % select (constArray tp e) i .==. e %Create the boolean expression "true".&Create the boolean expression "false".nopqrSTsUOPtuvwxyz{|}~VWXQRYZ[\?The value (negative values will be stored in two's-complement).$The bitwidth of the bitvector value.?The value (negative values will be stored in two's-complement).The bitwidth (must be >= 0).      !"#$%&'()*+nopqrstuvwxyz{|}~      !"#srnopqt"#     ~}yx|{zvu !wnopqrSTsUOPtuvwxyz{|}~VWXQRYZ[\      !"#$%&'()*+54444446677777322 None$%&+,/09:;<=ACDIOQRTb,Set an option controlling the behaviour of the SMT solver. Many solvers require you to specify what kind of queries you'll ask them after the model is specified.SFor example, when using interpolation, it is often required to do the following: odo setOption (ProduceInterpolants True) -- Declare model interp <- getInterpolant -- Use interpolant -.Query the solver for information about itself.Example: kisZ3Solver :: Backend b => SMT b Bool isZ3Solver = do name <- getInfo SMTSolverName return $ name=="Z3".DAsserts a boolean expression to be true. A successive successful 1F calls mean that the generated model is consistent with the assertion./ Works like .c, but additionally allows the user to find the unsatisfiable core of a set of assignments using B.0When using interpolation, use this function to specify if an assertion is part of the A-partition or the B-partition of the original formula.19Checks if the set of asserted expressions is satisfiable.2 The same as 1, but can specify an optional 1 that is used to give hints to the SMT solver on how to solve the problem and limits on the amount of time and memory that the solver is allowed to use. If the limits are exhausted, the solver must return Unknown.4After a successful 1^ query, query the concrete value for a given expression that the SMT solver assigned to it.5After a successful 1L query, return a satisfying assignment that makes all asserted formula true.6=Evaluate an expression in a model, yielding a concrete value.7Push a fresh frame on the solver stack. All variable definitions and assertions made in a frame are forgotten when it is 8'ed.8"Pop a frame from the solver stack.9NPerform an SMT action by executing it in a fresh stack frame. The frame is 8''ed once the action has been performed.:(Create a fresh variable of a given type.Example: Vdo -- Declare a single integer variable v <- declareVar int -- Use variable v ;Create a fresh variable (like :a), but also give it a name. Note that the name is a hint to the SMT solver that it may ignore.Example: kdo -- Declare a single boolean variable called "x" x <- declareVarNamed bool "x" -- Use variable x <<Create a new variable that is defined by a given expression.Example: }do -- x is an integer x <- declareVar int -- y is defined to be x+5 y <- defineVar $ x .+. cint 5 -- Use x and y =KCreate a new named variable that is defined by a given expression (like <).>@Create a new uninterpreted function by specifying its signature.Example: kdo -- Create a function from (int,bool) to int f <- declareFun (int ::: bool ::: Nil) int -- Use f ?ICreate a new uninterpreted function by specifying its signature (like >), but also give it a name.@Create a new interpreted function with a definition. Given a signature and a (haskell) function from the arguments to the resulting expression.Example: do -- Create a function from (int,int) to int that calculates the maximum max <- defineFun (int ::: int ::: Nil) $ (x ::: y ::: Nil) -> ite (x .>. y) x y -- Use max function A:Create a new interpreted function with a definition (like @) but also give it a name.BAfter a 1 query that returned Unsat, we can ask the SMT solver for a subset of the assertions that are enough to make the specified problem unsatisfiable. These assertions have to be created using /.Example: do setOption (ProduceUnsatCores True) x <- declareVar int y <- declareVar int cl1 <- assertId $ x .>. y cl2 <- assertId $ x .>. cint 5 cl3 <- assertId $ y .>. x checkSat core <- getUnsatCore -- core will contain cl1 and cl3CAfter a 1 query that returned Unsat-, we can ask the SMT solver for a formula C such that A (the A-partition) and (not C) is unsatisfiable while B (the B-partition) and C# is unsatisfiable. Furthermore, C0 will only mention variables that occur in both A and B.Example: Ndo setOption (ProduceInterpolants True) p <- declareVar bool q <- declareVar bool r <- declareVar bool t <- declareVar bool assertPartition ((not' (p .&. q)) .=>. ((not' r) .&. q)) PartitionA assertPartition t PartitionB assertPartition r PartitionB assertPartition (not' p) PartitionB checkSat getInterpolant DiConvert an expression in the SMT solver-specific format into a more general, pattern-matchable format.Example: isGE :: Backend b => Expr b tp -> SMT b Bool isGE e = do e' <- getExpr e case e' of _ :>=: _ -> return True _ -> return False ELInject a comment into the SMT command stream. Only useful when using the  smtlib2-debug* package to inspect the command stream.F2Use the SMT solver to simplify a given expression.GAfter a 1 query that returned UnsatW, we can ask the solver for a proof that the given instance is indeed unsatisfiable.H\Convert the solver-specific proof encoding into a more general, pattern-matchable format.,-./0123456789:The type of the variable;Type of the variableName of the variable<The definition expression=Name of the resulting variableDefinition of the variable>Function argument typesFunction result type?Function argument typesFunction result type Function name@Function argument typesFunction definitionABCDEFGH    U[VWXYZ\qrstuvwx*-.2Ouvwxyz{|}~      !"#,-./0123456789:;<=>?@ABCDEFGH*O-.,-:;<=>?@Aq"#     ~}yx|{zvu !wD.123/B0CGH7894562UVWXYZ[\    rstuvwxEF,-./0123456789:;<=>?@ABCDEFGHNone$%&+,/09:;<=ACDIOQRTbIJIJIJIJ] !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~?      !"#$%&&'()*+,-./01233456789::;;<<==>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'())*+,-./0123456789:;<=>?@HABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~             E G                         +                                                                             ! " # $ % & ' ( ) * + + , , - . . / / 0 1 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 >  = < ;   :              9         8 7 6 5 _  `  a b  c d  e 4 f 3 2 g    h " i j k # l m ! n / o p q r s . t - u v , w + x y z { |     } ~                                                                                                                                      "smtlib2-1.0-8pod1V4awXhLgGLjvCIrL0Language.SMTLib2.Strategy#Language.SMTLib2.Internals.Type.Nat$Language.SMTLib2.Internals.Type.List&Language.SMTLib2.Internals.Type.StructLanguage.SMTLib2.Internals.Type%Language.SMTLib2.Internals.Expression Language.SMTLib2.Internals.Proof#Language.SMTLib2.Internals.Evaluate"Language.SMTLib2.Internals.Backend Language.SMTLib2.Internals.Monad Language.SMTLib2.Internals.Embed$Language.SMTLib2.Internals.InterfaceLanguage.SMTLib2'Language.SMTLib2.Internals.Proof.VerifytrueLanguage.SMTLib2.Internalsfalsecboolcintcrealcbv constArraygetInfoBackendExprSMT QFLRATacticPArithBranchCutRatio BuiltInTactic QFLRATactic CustomTacticAnyParParBoolParInt ParDoubleProbeProbeBoolConst ProbeIntConstProbeAndProbeOrProbeNotProbeEqProbeGtProbeGeProbeLtProbeLeIsPB ArithMaxDeg ArithAvgDeg ArithMaxBW ArithAvgBWIsQFLIAIsQFLRAIsQFLIRAIsILPIsQFNIAIsQFNRAIsNIAIsNRA IsUnboundedMemoryDepthSizeNumExprs NumConsts NumBoolConstsNumArithConsts NumBVConsts ProduceProofs ProduceModelProduceUnsatCores HasPatternsIsPropositionalIsQFBVIsQFBVEQTacticSkipAndThenOrElseParOrParThenTryForIfFailIf UsingParams $fShowProbe$fShowBuiltInTactic $fShowTactic $fShowAnyPar$fShowQFLRATacticP IsNatural getNaturalN64N63N62N61N60N59N58N57N56N55N54N53N52N51N50N49N48N47N46N45N44N43N42N41N40N39N38N37N36N35N34N33N32N31N30N29N28N27N26N25N24N23N22N21N20N19N18N17N16N15N14N13N12N11N10N9N8N7N6N5N4N3N2N1N0<=-+NaturalZeroSuccNatZSnaturalToInteger naturalAdd naturalSub naturalSub' naturalLEQreifyNatnatnatTderiveIsNatural $fIsNaturalS $fIsNaturalZ$fGShowNatNatural$fGCompareNatNatural$fGEqNatNatural $fIntegralNat $fRealNat $fEnumNat$fNumNat$fOrdNat$fEqNat $fOrdNatural $fEqNatural $fShowNaturalListNil::: ReplicateConcatMapReverseDropLastLast StripPrefixTakeDropLengthAppendRemoveInsertIndexTailHeadlistnillist1list2list3 reifyListaccessaccess'headtailindexindexDyninsertremovemapM mapIndexMtraverseconsappendlengthdroptakelastdropLast stripPrefixreversemapunmapunmapMmapM'concat replicatetoList toListIndexfoldMzipWithM zipToListM mapAccumM $fGShow[]List $fShowList$fGCompare[]List $fOrdList $fGEq[]List$fEqList ElementIndexStruct SingletonTreeLeafNode accessElement elementIndexsizeflatten flattenIndex zipFlatten$fGShowTreeStruct $fShowStruct$fGCompareTreeStruct $fOrdStruct$fGEqTreeStruct $fEqStruct GetFunType getFunTypeGetTypegetTypeFunReprNumReprNumIntNumRealReprBoolReprIntReprRealRepr BitVecRepr ArrayReprDataRepr ParameterReprAnyValueValue BoolValueIntValue RealValue BitVecValue DataValueBitWidthbwSize DynamicValueDynValue DynamicFieldDynFieldDynamicConstructorDynConstructorDynamicDatatype DynDatatypedynDatatypeParametersdynDatatypeSigdynDatatypeName TypeRegistry allDatatypes revDatatypesallConstructorsrevConstructors allFields revFieldsAnyField AnyConstr AnyDatatypeConApp parameters' constructor arguments InstantiatedCType IsDatatype Parameters SignatureDatatypeConstrField datatypeGet parameters datatypeName constructors constrNametestfields construct deconstruct fieldName fieldTypefieldGetSndFstUnlift unliftTypeunliftTypeWithLiftedTypeBoolTypeIntTypeRealType BitVecType ArrayTypeDataType ParameterTypeDynDatatypeInfodynDatatypeInfo DynConstr DynField' ConstrValueemptyTypeRegistry dependencies signature constrSig instantiatectype determinescontainedParameter typeInferencetypeInferencespartialInstantiationpartialInstantiations registerTyperegisterTypeNamegetBwbwboolintrealbitvecarraydtdt' showBitVec valueTypeliftTypenumRepr asNumReprgetTypestypeSizetypeFiniteDomainwithBWbvAddbvSubbvMulbvDivbvModbvNegatebvSignumbvSuccbvPred bvMinValue bvMaxValuebwAdd datatypeEqdatatypeCompare$fShowBitWidth$fGetTypeNumRepr$fIntegralValue $fRealValue$fFiniteBitsValue $fBitsValue$fBoundedValue $fEnumValue $fNumValue$fRealFracValue$fFractionalValue $fRealValue0 $fNumValue0$fIntegralValue0 $fRealValue1 $fEnumValue0 $fNumValue1$fBoundedValue0 $fEnumValue1$fGShowTypeNumRepr$fGShowTypeRepr $fShowRepr$fGShowTypeValue $fShowValue$fGCompare(,)FunRepr$fGCompareTypeNumRepr $fOrdRepr$fGCompareTypeRepr$fGEq(,)FunRepr$fGEqTypeNumRepr$fEqRepr $fGEqTypeRepr $fOrdValue$fGCompareTypeValue $fEqValue$fGEqTypeValue$fGetTypeValue $fGetTypeRepr$fGCompareNatBitWidth$fGEqNatBitWidth $fEqBitWidth$fGCompareTypeField$fGEqTypeField$fGCompare[]Constr $fGEq[]Constr$fGCompare[]DynamicConstructor$fGEq[]DynamicConstructor$fShowDatatypeD:R:DatatypeDynamicValue0D:R:ConstrDynamicValuecsig0D:R:FieldDynamicValuetp0$fIsDatatypeDynamicValue $fOrdAnyField$fOrdAnyConstr$fOrdAnyDatatype $fEqAnyField $fEqAnyConstr$fEqAnyDatatype $fUnlift:idx $fUnlift:idx0 $fEqDatatype $fOrdDatatype$fEqDynamicDatatype$fOrdDynamicDatatype $fShowNumReprNoFieldNoField'NoConNoCon'NoFunNoFun'NoVarNoVar' RenderMode SMTRenderingSMTAritharithFromIntegerarithplusminusmultabs'SMTOrdltlegtge ExpressionVarQVarFVarLVarAppConstAsArrayQuantificationLet QuantifierForallExists LetBindingletVarletExprBVUnOpBVNotBVNegBVBinOpBVAddBVSubBVMulBVURemBVSRemBVUDivBVSDivBVSHLBVLSHRBVASHRBVXorBVAndBVOrBVCompOpBVULEBVULTBVUGEBVUGTBVSLEBVSLTBVSGEBVSGTLogicOpAndOrXOrImplies ArithOpIntDivModRemArithOpPlusMultMinusOrdOpGeGtLeLt AnyFunctionFunctionFunEqDistinctOrdArith ArithIntBinDivideAbsNotLogicToRealToIntITEBVCompBVBinBVUnSelectStore ConstArrayExtract ConstructorTest DivisibleAllEq allEqToList allEqFromListallEqOfmapAllEq functionTypeexpressionTypemapExpr mapFunctionrenderExprDefault renderExpr renderValuerenderFunction renderType renderTypes$fGetFunTypeFunction$fGetTypeExpression$fGetFunTypeNoFun$fGetTypeNoVar$fGShow(,)NoField $fShowNoField$fGShow(,)NoCon $fShowNoCon$fGShow(,)NoFun $fShowNoFun$fGShowTypeNoVar $fShowNoVar $fOrdNoField $fOrdNoCon $fOrdNoFun $fOrdNoVar $fEqNoField $fEqNoCon $fEqNoFun $fEqNoVar$fGCompare(,)NoField$fGCompare(,)NoCon$fGCompare(,)NoFun$fGCompareTypeNoVar$fGEq(,)NoField $fGEq(,)NoCon $fGEq(,)NoFun$fGEqTypeNoVar$fGCompare(,)Function$fGEq(,)Function$fOrdExpression$fGCompareTypeExpression$fEqExpression$fGEqTypeExpression$fGCompareTypeLetBinding$fGEqTypeLetBinding$fGShow(,)Function$fShowFunction$fGShowTypeExpression$fShowExpression$fSMTArithRealType$fSMTArithIntType$fSMTOrdRealType$fSMTOrdIntType $fEqFunction $fEqOrdOp $fOrdOrdOp $fShowOrdOp $fEqArithOp $fOrdArithOp $fShowArithOp$fEqArithOpInt$fOrdArithOpInt$fShowArithOpInt $fEqLogicOp $fOrdLogicOp $fShowLogicOp $fEqBVCompOp $fOrdBVCompOp$fShowBVCompOp $fEqBVBinOp $fOrdBVBinOp $fShowBVBinOp $fEqBVUnOp $fOrdBVUnOp $fShowBVUnOp$fEqQuantifier$fOrdQuantifier$fShowQuantifier$fEqRenderMode$fOrdRenderMode$fShowRenderModeProofRule ProofResult ProofExprEquivSat verifyProof renderProof renderProof'renderProofResultmapProof$fShowProofResult FieldEval FunctionEval ArrayModel ArrayConstArrayFunArrayMap ArrayStore EvalResult ValueResult ArrayResultevalResultTypearrayModelType evaluateArraytypeNumElements evalResultEq arrayModelEq evaluateExpr evaluateFungetArrayModelType geqArrayModelgcompareArrayModel$fGCompareTypeEvalResult$fGEqTypeEvalResult$fGShowTypeArrayModel$fGShowTypeEvalResult$fShowArrayModel$fShowEvalResult$fGetTypeEvalResultRenderedSubExpr UntypedFun UntypedVarSMTInfo SMTSolverNameSMTSolverVersion SMTOption PrintSuccess ProduceModelsProduceInterpolantsSMTLogic Assignment VarAssignment FunAssignmentAssignmentModel assignmentsCheckSatLimits limitTime limitMemoryCheckSatResultSatUnsatUnknown Partition PartitionA PartitionBSMTMonadFunArgClauseIdModel setOptioncommentpushpop declareVar createQVar createFunArg defineVar declareFun defineFunassertassertIdassertPartitioncheckSat getUnsatCoregetValuegetModel modelEvaluategetProof analyzeProofsimplify toBackend fromBackenddeclareDatatypes interpolateexit SMTAction mapActionshowsBackendExpr$fShowAssignmentModel$fShowAssignment$fGetFunTypeUntypedFun$fGetTypeUntypedVar$fGShow(,)UntypedFun$fGShowTypeUntypedVar$fShowUntypedFun$fShowUntypedVar$fGCompare(,)UntypedFun$fGCompareTypeUntypedVar$fGEq(,)UntypedFun$fGEqTypeUntypedVar$fOrdUntypedFun$fOrdUntypedVar$fEqUntypedFun$fEqUntypedVar$fGShowkRenderedSubExpr$fShowPartition $fEqPartition$fOrdPartition$fShowCheckSatResult$fEqCheckSatResult$fOrdCheckSatResult$fShowCheckSatLimits$fEqCheckSatLimits$fOrdCheckSatLimits$fShowSMTOption $fEqSMTOption$fOrdSMTOptionSMTStatebackend datatypesrunSMT withBackendwithBackendExitCleanlyliftSMTembedSMT embedSMT'registerDatatype defineVar'defineVarNamed' declareVar'declareVarNamed' $fMonadIOSMT$fMonadStateSMTStateSMT $fMonadSMT$fApplicativeSMT $fFunctorSMT AnalyzedExprSMTExprSMTQuant BackendInfoValueExtvalueExtUserFunExVarExQVarExFunExFunArgExLVarextractEmbedEmVarEmQVarEmFunEmFunArgEmLVarembedembedQuantifier embedTypeOf EmbedExpr encodeExpr decodeExpranalyze'analyze$fEmbedExceptTe$fExtract()SMTExpr$fGetTypeSMTExpr$fEmbedIdentitySMTExpr$fExtractBackendInfoExpr$fEmbedIdentityValueExt$fGCompareTypeValueExt$fGEqTypeValueExt$fGShowTypeValueExt$fGetTypeValueExt$fEmbedIdentityValue$fGShow(,)UserFun$fGetFunTypeUserFun$fGCompare(,)UserFun$fGEq(,)UserFun$fEmbedIdentityRepr$fEmbedSMTExprHasMonad MatchMonad MonadResultembedM IsSMTNumberSameIsMk:=>: ImpliesLstXOrLst:|:OrLst:&:AndLstLogicLst:/::*:MultLstNeg:-:MinusLst:+:PlusLstArithLst:<::<=::>::>=::/=: DistinctLst:==:EqLstConstBV ConstRealConstInt ConstBoolconstant cbvUntypedcdt asConstantfunapp.:..==../=.eqdistinctmap'ord.>=..>..<=..<..+..-..*.negrem'div'mod'./.not'logicand'or'xor'implies.&..|..=>.toRealtoIntitebvcompbvulebvultbvugebvugtbvslebvsltbvsgebvsgtbvbinbvaddbvsubbvmulbvurembvsrembvudivbvsdivbvshlbvlshrbvashrbvxorbvandbvorbvunbvnotbvnegselectselect1storestore1concat'extract'extractCheckedextractUntypedStartextractUntyped divisiblemkis.#.existsforall $fHasMonadm$fHasMonadList $fHasMonadm0 $fHasMonade$fIsSMTNumberRealType$fIsSMTNumberIntType$fSame:$fSame:0 checkSatWithnoLimitsstackdeclareVarNameddefineVarNameddeclareFunNameddefineFunNamedgetInterpolantgetExpr verifyZ3Proof verifyZ3RulebaseGHC.BaseNothingghc-prim GHC.TypesIOMonadData.Functor.IdentityIdentitysameType sameToAllEq allEqToSame allEqToSame' smtNumReprsmtFromIntegerSameType ArithLstP DistinctLstPEqLstP matchNumRepr matchNumRepr'sameAppgetBW