h*yi      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q rstuvwxyz{|}~2.4.0 Safe-Inferred")1hasmtlibLift a .hasmtlibThe true constant.  =  hasmtlibThe false constant.  =  hasmtlibLogical conjunction.hasmtlib#Logical disjunction (inclusive or).hasmtlibLogical implication.hasmtlib(Logical implication with arrow reversed. $forall x y. (x ==> y) === (y <== x) hasmtlibLogical equivalence. hasmtlibLogical negation. hasmtlib Exclusive-or. hasmtlib*The logical conjunction of several values. hasmtlib*The logical disjunction of several values. hasmtlib2The negated logical conjunction of several values.   =   .  hasmtlib2The negated logical disjunction of several values.  =   .  hasmtlibThe logical conjunction of the mapping of a function over several values.hasmtlibThe logical disjunction of the mapping of a function over several values.hasmtlibDefined bitwise    32004 4 Safe-Inferred")1=hasmtlib<-like class for clean API. In context hide the Preludes .  Safe-Inferred")1p%hasmtlibAllC ensures that a list of constraints is applied to a poly-kinded  k :AllC '[] k = () AllC (c ': cs) k = (c k, AllC cs k) %% Safe-Inferred")1X&hasmtlibRender values to their sequential SMTLib2-Lisp form, represented as a  .(hasmtlib9Render values to their SMTLib2-Lisp form, represented as .&'()*+,-()*+,-&' Safe-Inferred"()16hasmtlib5Unsigned and length-indexed bitvector with MSB first.6879:;<=>?@ABCDEFGHI6879:;<=>?@ABCDEFGHI Safe-Inferred")13TUVWTUVW Safe-Inferred")1XXhasmtlibA " for Bitwuzla. Requires binary bitwuzla to be in path.As of v0.5 Bitwuzla uses Cadical as SAT-Solver by default. Make sure it's default SAT-Solver binary - probably cadical - is in path too.XX Safe-Inferred")1YhasmtlibA  for CVC5. Requires binary cvc5 to be in path.YY  Safe-Inferred")1ZhasmtlibA ! for MathSAT. Requires binary mathsat to be in path.[hasmtlibA % for OptiMathSAT. Requires binary  optimathsat to be in path.Z[Z[  Safe-Inferred")1E\hasmtlibA ! for OpenSMT. Requires binary opensmt to be in path.\\  Safe-Inferred")1]hasmtlibA  for Yices. Requires binary  yices-smt2 to be in path.]]  Safe-Inferred")1H^hasmtlibA  for Z3. Requires binary z3 to be in path.^^  Safe-Inferred ")1_hasmtlibA map-like array with a default constant value and partially overwritten values.chasmtlibClass that allows access to a map-like array where any value is either the default value or an overwritten values. Every index has a value by default. Values at indices can be overwritten manually.'Based on McCarthy`s basic array theory.)Therefore the following axioms must hold: *forall A i x: arrSelect (store A i x) == xforall A i j x: i /= j ==> (arrSelect (arrStore A i x) j === arrSelect A j)hhasmtlib Wrapper for d which hides the  _ba`cgfedhop cgfedh_ba`po Safe-Inferred")1 rhasmtlibOptions for SMT-Solvers.shasmtlib$Print "success" after each operationthasmtlib>Produce a satisfying assignment after each successful checkSatuhasmtlibIncremental solvingvhasmtlib=Custom options. First String is the option, second its value.rvutsrvuts Safe-Inferred  ")1 |hasmtlib'An existential wrapper that hides some  and a list of s holding for it.~hasmtlibCompute singleton  from it's promoted type .hasmtlibSingleton for .hasmtlib0Injective type-family that computes the Haskell  of an .hasmtlib5Sorts in SMTLib2 - used as promoted type (data-kind).hasmtlib Sort of Boolhasmtlib Sort of Inthasmtlib Sort of RealhasmtlibSort of BitVec with length nhasmtlib)Sort of Array with indices k and values vhasmtlibSort of Stringhasmtlib Wrapper for  which takes a |}~~|} Safe-Inferred "()1=3*hasmtlib? y assert $ x === min' 42 100 hasmtlib*Test two as on equality as SMT-Expression.9You can derive an instance of this class if your type is .  x <- var @RealType y <- var assert $ y === x && not (y /== x) hasmtlib5Test whether two values are equal in the SMT-Problem.hasmtlib9Test whether two values are not equal in the SMT-Problem.hasmtlib1If condition (p :: b) then (t :: a) else (f :: a)ite true "1" "2" "1"ite false 100 42 42hasmtlibAm SMT expression. For internal use only. For building expressions use the corresponding instances (Num, Boolean, ...).hasmtlibJust v if quantified var has been created already, Nothing otherwisehasmtlibJust v if quantified var has been created already, Nothing otherwisehasmtlib-An existential wrapper that hides some known .hasmtlibA wrapper for values of s.hasmtlibUnwrap a value from .hasmtlibWrap a value into .hasmtlib!Minimum of two as SMT-Expression.hasmtlib!Maximum of two as SMT-Expression.hasmtlib4Test multiple expressions on equality within in the SMT -Problem.hasmtlib8Test multiple expressions on distinctness within in the SMT -Problem.hasmtlib,A universal quantification for any specific . If the type cannot be inferred, apply a type-annotation. Nested quantifiers are also supported.Usage:  assert $ for_all @IntSort $ x -> x + 0 === x && 0 + x === x  The lambdas x is all-quantified here. It will only be scoped for the lambdas body.hasmtlib/An existential quantification for any specific  If the type cannot be inferred, apply a type-annotation. Nested quantifiers are also supported.Usage:  assert $ for_all @(BvSort 8) $ x -> exists $ y -> x - y === 0  The lambdas y is existentially quantified here. It will only be scoped for the lambdas body.hasmtlibSelect a value from an array.hasmtlibStore a value in an array.hasmtlibBitvector shift lefthasmtlibBitvector logical shift righthasmtlibConcat two bitvectorshasmtlibRotate bitvector lefthasmtlibRotate bitvector righthasmtlibConverts an expression of type  to type .hasmtlibConverts an expression of type  to type .hasmtlib%Checks whether an expression of type ! may be safely converted to type .hasmtlibLength of a string.hasmtlibSingleton string containing a character at given position or empty string when position is out of range. The leftmost position is 0.hasmtlib(strSubstring s i n)8 evaluates to the longest (unscattered) substring of s of length at most n starting at position i). It evaluates to the empty string if n is negative or i is not in the interval [0,l-1] where l is the length of s.hasmtlib+First string is a prefix of second one. (str.prefixof s t) is true iff s is a prefix of t.hasmtlib+First string is a suffix of second one. (str.suffixof s t) is true iff s is a suffix of t.hasmtlib$First string contains second one (str.contains s t) iff s contains t.hasmtlibIndex of first occurrence of second string in first one starting at the position specified by the third argument. (str.indexof s t i), with  0 <= i <= |s|/ is the position of the first occurrence of t in s at or after position i, if any. Otherwise, it is -1. Note that the result is i whenever i is within the range [0, |s|] and t is empty.hasmtlib(str.replace s t t') is the string obtained by replacing the first occurrence of t in s , if any, by t'. Note that if t' is empty, the result is to prepend t' to s ; also, if t does not occur in s then the result is s.hasmtlib(str.replace_all s t t@) is s if t is the empty string. Otherwise, it is the string obtained from s! by replacing all occurrences of t in s by t@, starting with the first occurrence and proceeding in left-to-right order.hasmtlib#Caution for quantified expressions:  will only be applied if quantification has taken place already.hasmtlib#Caution for quantified expressions: U will only be applied if quantification has taken place already.hasmtlibNot in the SMTLib2.6-standard. Solvers like CVC5 and MathSAT support it though.hasmtlibLexicographic ordering for 5 and reflexive closure of lexicographic ordering for 444444 Safe-Inferred")18Ihasmtlib Wrapper for  which takes a .hasmtlibOut of many bool-expressions build a formula which encodes how many of them are true.hasmtlibOut of many bool-expressions build a formula which encodes that at most k of them are true.hasmtlibOut of many bool-expressions build a formula which encodes that at least k of them are true.hasmtlibOut of many bool-expressions build a formula which encodes that exactly k of them are true. Safe-Inferred ")1;) hasmtlib!A solution for a single variable.hasmtlibA variable in the SMT-Problemhasmtlib-An assignment for this variable in a solutionhasmtlib Newtype for  ( so we can use it as right-hand-side of .hasmtlibA Solution is a dependent map  from s t to  t.hasmtlibResults of check-sat commands.hasmtlib9Function that turns a state into a result and a solution.hasmtlib-An existential wrapper that hides some known  with an  hasmtlibAlias class for constraint  ( t)hasmtlib Create a  from some s. Safe-Inferred "()1===hasmtlib)Lift values to SMT-Values or decode them.9You can derive an instance of this class if your type is .hasmtlibResult of decoding a.hasmtlib$Decode a value using given solution.hasmtlibEncode a value as constant.hasmtlibComputes a default   by distributing  to it's type arguments.hasmtlibDecode and evaluate expressions   Safe-Inferred")1JhasmtlibA  that holds an OMT-Problem. An OMT-Problem is a 'SMT-Problem' with additional optimization targets.hasmtlib8Minimizes a numerical expression within the OMT-Problem. For example, below minimization: .x <- var @IntSort assert $ x >? -2 minimize x  will give x := -1 as solution.hasmtlib8Maximizes a numerical expression within the OMT-Problem. For example, below maximization:  x <- var @(BvSort 8) maximize x  will give  x := 11111111 as solution.hasmtlibAsserts a soft boolean expression. May take a weight and an identifier for grouping.For example, below a soft constraint with weight 2.0 and identifier "myId" for grouping: 9x <- var @BoolSort assertSoft x (Just 2.0) (Just "myId") +Omitting the weight will default it to 1.0.  x <- var BoolSort y <- var 1BoolSort assertSoft x assertSoft y (Just "myId") hasmtlibA ! that allows incremental solving.hasmtlib6Push a new context (one) to the solvers context-stack.hasmtlib%Pop the solvers context-stack by one.hasmtlib%Run check-sat on the current problem.hasmtlibRun get-model on the current problem. This can be used to decode temporary models within the SMT-Problem. x <- var @RealSort y <- var assert $ x >? y && y print "Unsat. Cannot get model." r -> do model <- getModel liftIO $ print $ decode model x hasmtlibEvaluate any expressions value in the solvers model. Requires a  or  check-sat response beforehand. x <- var @RealSort assert $ x >? 10 res <- checkSat case res of Unsat -> print "Unsat. Cannot get value for x." r -> do x' <- getValue x liftIO $ print $ show r ++ ": x = " ++ show x' hasmtlibA  that holds an SMT-Problem.hasmtlibConstruct a variable. This is mainly intended for internal use. In the API use  instead. 2x :: SMTVar RealType <- smtvar' (Proxy @RealType) hasmtlib#Construct a variable as expression. -x :: Expr RealType <- var' (Proxy @RealType) hasmtlibAssert a boolean expression. 8x :: Expr IntType <- var @IntType assert $ x + 5 === 42 hasmtlibSet an SMT-Solver-Option. setOption $ Incremental True hasmtlib(Set the logic for the SMT-Solver to use. setLogic "QF_LRA" hasmtlib Wrapper for  which hides the .hasmtlib Wrapper for  which hides the . This is mainly intended for internal use. In the API use  instead.hasmtlibCreate a constant. constant True Constant (BoolValue True)"let x :: Integer = 10 ; constant x Constant (IntValue 10)constant @IntType 5 Constant (IntValue 5)constant @(BvType 8) 5 Constant (BvValue 0000101)hasmtlibMaybe assert a boolean expression. Asserts given expression if  is a . Does nothing otherwise.hasmtlibAssign quantified variables to all quantified subexpressions of an expression. This shall only be used internally. Usually before rendering an assert.hasmtlib First run  and then  on the current problem.hasmtlibLike , but forces a weight and omits the group-id. Trustworthy")1Nhasmtlib5States that can share expressions by comparing their s.hasmtlibA constraint on the monad used when asserting the shared node in .hasmtlibA  on a mapping between a  and it's  we may share.hasmtlibAsserts that a node-expression is represented by it's auxiliary node-variable: nodeExpr :: Expr t === nodeVar. Also gives access to the  of the original expression.hasmtlibShares all possible sub-expressions in given expression. Replaces each node in the expression-tree with an auxiliary variable. All nodes x y where $makeStableName x == makeStableName y are replaced with the same auxiliary variable. Therefore this creates a DAG.hasmtlibReturns an auxiliary variable representing this expression node. If such a shared auxiliary variable exists already, returns that. Otherwise creates one and returns it. Safe-Inferred ")1PlhasmtlibThe state of the SMT-problem.hasmtlibLast Id assigned to a new varhasmtlibAll constructed variableshasmtlibAll asserted formulashasmtlibLogic for the SMT-Solverhasmtlib*All manually configured SMT-Solver-OptionshasmtlibMapping between a  and it's  we may share Safe-Inferred ")1ST hasmtlibAn assertion of a booolean expression in OMT that may be weighted.hasmtlibThe underlying soft formulahasmtlibWeight of the soft formulahasmtlibGroup-Id of the soft formulahasmtlibThe state of the OMT-problem.hasmtlibThe underlying -ProblemhasmtlibAll expressions to minimizehasmtlibAll expressions to maximizehasmtlib*All soft assertions of boolean expressionshasmtlibA newtype for numerical expressions that are target of a maximization.hasmtlibA newtype for numerical expressions that are target of a minimization. Safe-Inferred")1S Safe-Inferred ")1W[hasmtlibA pipe to the solver. If  is  then all commands that do not expect an answer are sent to the queue. All commands that expect an answer have the queue to be sent to the solver before sending the command itself. If  is not 2, all commands are sent to the solver immediately.hasmtlibLast Id assigned to a new varhasmtlibLogic for the SMT-SolverhasmtlibMapping between a  and it's  we may sharehasmtlibIndex of each  (' ()) is incremental stack height where 0 representing auxiliary var that has been sharedhasmtlibActive pipe to the backendhasmtlibFlag if pipe shall debug Safe-Inferred")1[! hasmtlib,A type holding actions for debugging states.hasmtlibDebug the entire statehasmtlib#Debug the linewise-rendered problemhasmtlib#Debug the solvers raw response for  (check-sat)hasmtlib#Debug the solvers raw response for  (get-model)hasmtlib Creates a  from a .hasmtlibCreates a debugging  from a .hasmtlibCreates an interactive session with a solver by creating and returning an alive process-handle %. Queues commands by default, see .hasmtlibA  which holds an external process with a SMT-Solver. This will:  Encode the  -problem,0Start a new external process for the SMT-Solver,#Send the problem to the SMT-Solver,#Wait for an answer and parse it and-close the process and clean up all resources.   Safe-Inferred")1d hasmtlibData that can have a  which may be debugged.hasmtlibCreate a datum with a & and a 'Bool for whether to debug the .hasmtlib solver prob solves a SMT problem prob with the given solver". It returns a pair consisting of: A  that indicates if prob is satisfiable (), unsatisfiable (9), or if the solver could not determine any results ().A / answer that was decoded using the solution to prob6. Note that this answer is only meaningful if the  is  or " and the answer value is in a .&Here is a small example of how to use : import Language.Hasmtlib main :: IO () main = do res <- solveWith ;SMT (solver cvc5) $ do setLogic "QF_LIA" x <- var 8IntSort assert $ x >? 0 return x print res hasmtlibPipes an SMT-problem interactively to the solver. Enables incremental solving by default. Here is a small example of how to use it for solving a problem utilizing the solvers incremental stack: import Language.Hasmtlib import Control.Monad.IO.Class main :: IO () main = do cvc5Living <- interactiveSolver cvc5 interactiveWith Pipe cvc5Living $ do setOption $ Incremental True setOption $ ProduceModels True setLogic "QF_LIA" x <- var IntSort assert $ x >? 0 (res, sol) <- solve liftIO $ print res liftIO $ print $ decode sol x push y <- var @IntSort assert $ y V3 a /varV3 :: V3 (Expr RealType) <- variable ; varV36 V3 (Expr RealType) (Expr RealType) (Expr RealType)hasmtlib Wrapper for  which takes a  Safe-Inferred")1gHrstuv~|}cdefg_`abhop   XY^]\Z[ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUUVWXYZ[\]^_`abcdefghijklmnopqrstuvw x y z { | } } ~                de[bchasmtlib-2.4.0-inplaceLanguage.Hasmtlib.BooleanLanguage.Hasmtlib.Integraled%Language.Hasmtlib.Internal.Constraint!Language.Hasmtlib.Internal.Render!Language.Hasmtlib.Internal.Bitvec$Language.Hasmtlib.Internal.Uniplate1!Language.Hasmtlib.Solver.BitwuzlaLanguage.Hasmtlib.Solver.CVC5 Language.Hasmtlib.Solver.MathSAT Language.Hasmtlib.Solver.OpenSMTLanguage.Hasmtlib.Solver.YicesLanguage.Hasmtlib.Solver.Z3Language.Hasmtlib.Type.ArrayMapLanguage.Hasmtlib.Type.OptionLanguage.Hasmtlib.Type.SMTSortLanguage.Hasmtlib.Type.ExprLanguage.Hasmtlib.CountingLanguage.Hasmtlib.Type.SolutionLanguage.Hasmtlib.CodecLanguage.Hasmtlib.Type.MonadSMT"Language.Hasmtlib.Internal.SharingLanguage.Hasmtlib.Type.SMTLanguage.Hasmtlib.Type.OMT!Language.Hasmtlib.Internal.ParserLanguage.Hasmtlib.Type.PipeLanguage.Hasmtlib.Solver.CommonLanguage.Hasmtlib.Type.SolverLanguage.Hasmtlib.VariablehasmtlibLanguage.HasmtlibBooleanbooltruefalse&&||==><==<==>notxorandornandnorallany$fBooleanVector $fBooleanBit $fBooleanBool IntegraledquotremdivmodquotRemdivMod$fIntegraledConst$fIntegraledIdentity$fIntegraledWord64$fIntegraledWord32$fIntegraledWord16$fIntegraledWord8$fIntegraledNatural$fIntegraledWord$fIntegraledInteger$fIntegraledIntAllC RenderSeq renderSeqRenderrender renderUnary renderBinary renderTernary renderNary $fRenderText$fRenderBuilder $fRenderList $fRenderChar$fRenderDouble$fRenderInteger$fRenderNatural $fRenderBoolBitvecunBitvec bvReverse bvReplicate bvReplicate' bvGeneratebvConcatbvTake'bvDrop' bvSplitAt'bvToList bvFromListN bvFromListN'bvRotLbvRotRbvShLbvLShR bvZeroExtend bvExtract$fIntegralBitvec $fRealBitvec $fEnumBitvec$fBoundedBitvec $fNumBitvec$fRenderBitvec $fShowBitvec $fEqBitvec $fOrdBitvec$fBooleanBitvec Uniplate1 uniplate1 transformM1 lazyParaM1bitwuzlacvc5mathsat optimathsatopensmtyicesz3 ConstArray _arrConst_storedArrayMapasConst' viewConst arrSelectarrStoreasConst$fShowConstArray$fEqConstArray$fOrdConstArray$fFunctorConstArray$fFoldableConstArray$fTraversableConstArrayarrConststored$fArrayMapConstArraykv SMTOption PrintSuccess ProduceModels IncrementalCustom$fRenderSMTOption$fShowSMTOption $fEqSMTOption$fOrdSMTOption$fDataSMTOption SomeSMTSort KnownSMTSortsortSingSSMTSortSIntSort SRealSort SBoolSortSBvSort SArraySort SStringSort HaskellTypeSMTSortBoolSortIntSortRealSortBvSort ArraySort StringSort sortSing'$fRenderSSMTSort$fKnownSMTSortStringSort$fKnownSMTSortArraySort$fKnownSMTSortBvSort$fKnownSMTSortBoolSort$fKnownSMTSortRealSort$fKnownSMTSortIntSort$fGCompareSMTSortSSMTSort$fGEqSMTSortSSMTSort$fShowSomeSMTSort $fOrdSSMTSort $fEqSSMTSort$fShowSSMTSortSMTVar_varId $fShowSMTVar$fGenericSMTVar $fEqSMTVar $fOrdSMTVar GOrderable=?? GEquatable===# Equatable===/==IteableiteExprVarConstantPlusNegMulAbsModIDivDivLTHLTHEEQUDistinctGTHEGTHNotAndOrImplXorPiSqrtExpSinCosTanAsinAcosAtanToRealToIntIsIntIteBvNotBvAndBvOrBvXorBvNandBvNorBvNegBvAddBvSubBvMulBvuDivBvuRemBvShLBvLShRBvConcatBvRotLBvRotRBvuLTBvuLTHEBvuGTHEBvuGT ArrSelectArrStore StrConcat StrLengthStrLTStrLTHEStrAt StrSubstring StrPrefixOf StrSuffixOf StrContains StrIndexOf StrReplace StrReplaceAllForAllExistsSomeKnownSMTSortValueIntValue RealValue BoolValueBvValue ArrayValue StringValuevarId unwrapValue wrapValueisLeafmin'max'equaldistinctfor_allexistsselectstore toRealSort toIntSort isIntSort strLengthstrAt strSubstring strPrefixOf strSuffixOf strContains strIndexOf strReplace strReplaceAllrenderQuantifier$fRenderSMTVar $fShowValue$fGEqSMTSortValue$fGNFDataSMTSortExpr $fPlatedExpr$fUniplate1SMTSortExpr: $fIxedExpr $fIxedExpr0 $fShowExpr $fRenderExpr $fRenderValue$fIsStringExpr $fMonoidExpr$fSemigroupExpr $fBoundedExpr$fBoundedExpr0 $fBooleanExpr$fIntegraledExpr$fIntegraledExpr0$fFloatingExpr$fFractionalExpr $fNumExpr$fSuffixedExpr$fPrefixedExpr$fIteableExpr(,,,,,,,)$fIteableExpr(,,,,,,)$fIteableExpr(,,,,,)$fIteableExpr(,,,,)$fIteableExpr(,,,)$fIteableExpr(,,)$fIteableExpr(,)$fIteableExpr()$fIteableExprIdentity$fIteableExprDual$fIteableExprLast$fIteableExprFirst$fIteableExprProduct$fIteableExprSum$fIteableExprTree$fIteableExprSeq$fIteableExprMaybe$fIteableExprList$fIteableBoola$fIteableExprExpr$fGEquatablekM1$fGEquatablek:+:$fGEquatablek:*:$fGEquatablekV1$fGEquatablekU1 $fAsEmptyExpr$fBooleanExpr0$fEquatableIdentity$fEquatableDual$fEquatableLast$fEquatableFirst$fEquatableProduct$fEquatableSum$fEquatableEither$fEquatableMaybe$fEquatableTree$fEquatableList$fEquatable(,,,,,,,)$fEquatable(,,,,,,)$fEquatable(,,,,,)$fEquatable(,,,,)$fEquatable(,,,)$fEquatable(,,)$fEquatable(,)$fEquatableBool$fEquatableOrdering$fEquatableDouble$fEquatableFloat$fEquatableChar$fEquatableInt64$fEquatableInt32$fEquatableInt16$fEquatableInt8$fEquatableWord64$fEquatableWord32$fEquatableWord16$fEquatableWord8$fEquatableWord$fEquatableNatural$fEquatableInteger$fEquatableInt$fEquatableVoid $fEquatable()$fGEquatablekK1$fEquatableExpr$fGOrderablekM1$fGOrderablek:+:$fGOrderablek:*:$fGOrderablekV1$fGOrderablekU1$fSnocExprExprExprExpr$fConsExprExprExprExpr $fNumExpr0 $fNumExpr1$fOrderableIdentity$fOrderableDual$fOrderableLast$fOrderableFirst$fOrderableProduct$fOrderableSum$fOrderableEither$fOrderableMaybe$fOrderableTree$fOrderableList$fOrderable(,,,,,,,)$fOrderable(,,,,,,)$fOrderable(,,,,,)$fOrderable(,,,,)$fOrderable(,,,)$fOrderable(,,)$fOrderable(,)$fOrderableBool$fOrderableOrdering$fOrderableDouble$fOrderableFloat$fOrderableChar$fOrderableInt64$fOrderableInt32$fOrderableInt16$fOrderableInt8$fOrderableWord64$fOrderableWord32$fOrderableWord16$fOrderableWord8$fOrderableWord$fOrderableNatural$fOrderableInteger$fOrderableInt$fOrderableVoid $fOrderable()$fGOrderablekK1$fOrderableExpr$fOrderableExpr0$fOrderableExpr1$fOrderableExpr2 $fOrdValue $fEqValuecount'countatMostatLeastexactly SMTVarSol_solVar_solVal IntValueMapSolutionResultUnsatUnknownSatSolver$fShowSMTVarSol$fShowIntValueMap$fSemigroupIntValueMap$fMonoidIntValueMap $fShowResult $fEqResult $fOrdResultSomeKnownOrdSMTSortOrdHaskellTypesolValsolVarfromSomeVarSols$fOrdHaskellTypetGCodecGDecodedgdecodegencodeCodecDecodeddecodeencodeDefaultDecoded $fGCodecM1 $fGCodec:+: $fGCodec:*: $fGCodecV1 $fGCodecU1 $fGCodecK1 $fCodecMap $fCodecSeq $fCodecIntMap$fCodecIdentity $fCodecDual $fCodecLast $fCodecFirst$fCodecProduct $fCodecSum $fCodecEither $fCodecTree $fCodecMaybe $fCodecList$fCodec(,,,,,,,)$fCodec(,,,,,,)$fCodec(,,,,,) $fCodec(,,,,) $fCodec(,,,) $fCodec(,,) $fCodec(,) $fCodec() $fCodecExprMonadOMTminimizemaximize assertSoft MonadIncrSMTpushpopcheckSatgetModelgetValueMonadSMTsmtvar'var'assert setOptionsetLogicvarsmtvarconstant assertMaybequantifysolveassertSoftWeightedSharing SharingMonad stableMapassertSharedNode runSharingshareSMT _lastVarId_vars _formulas_mlogic_options _stableMapformulas lastVarIdmlogicoptionsvarsrenderSetLogicrenderDeclareVar renderAssert renderVars$fRenderSeqSMT$fMonadSMTSMTm $fSharingSMT $fDefaultSMT SoftFormula_formula_mWeight _mGroupId$fShowSoftFormulaOMT_smt_targetMinimize_targetMaximize _softFormulasMaximize _targetMaxMinimize _targetMinformulamGroupIdmWeightsmt softFormulastargetMaximizetargetMinimize$fRenderSeqOMT$fRenderMaximize$fRenderMinimize$fRenderSoftFormula$fMonadOMTOMTm$fMonadSMTOMTm $fSharingOMT $fDefaultOMT answerParser resultParseranyModelParserdefaultModelParsersmt2ModelParser parseSomeSol parseSomeSortparseSomeBitVecSortparseSomeArraySort parseExpr' parseExpr constantExpr anyBitvector binBitvector hexBitvectorliteralBitvector constArrayparseSmtStringunarybinaryternarynarysmtPianyValue negativeValueparseRatioDoubleparseToRealDouble parseBoolgetValueParserPipe_lastPipeVarId _mPipeLogic_pipeStableMap_incrSharedAuxs_pipe _isDebuggingincrSharedAuxs isDebugging lastPipeVarId mPipeLogicpipe pipeStableMap$fMonadOMTPipem$fMonadIncrSMTPipem$fMonadSMTPipem $fSharingPipeDebugger debugState debugProblemdebugResultResponsedebugModelResponsesolverdebuginteractiveSolver processSolver$fDefaultDebugger$fDefaultDebugger0 WithSolver withSolver solveWithinteractiveWithdebugInteractiveWithsolveMinimizedsolveMinimizedDebugsolveMaximizedsolveMaximizedDebug$fWithSolverPipe GVariable gvariableVariablevariable variable'$fGVariablekM1$fGVariablek:*:$fGVariablekU1$fGVariablekK1$fVariableEither$fVariableMaybe$fVariableCompose $fVariableAlt$fVariableConst$fVariableIdentity$fVariableDual$fVariableLast$fVariableFirst$fVariableProduct $fVariableSum$fVariable(,,,,,,,)$fVariable(,,,,,,)$fVariable(,,,,,)$fVariable(,,,,)$fVariable(,,,)$fVariable(,,) $fVariable(,) $fVariable()$fVariableExprghc-prim GHC.TypesBoolTrueFalsebaseGHC.RealIntegralTypecontainers-0.6.7Data.Sequence.InternalSeqbytestring-0.11.5.3 Data.ByteString.Builder.InternalBuildersmtlib-backends-process-0.3-ced344d257887c763fdf1a6be0ba4c19d8ef3ee1de2affb9ac8b08f16f58b0f0SMTLIB.Backends.ProcessConfig Data.ProxyProxy ConstraintInt GHC.GenericsGenericlens-5.3.2-cac4da5abd419cc536b4e6a9de4e8725350f2529490c0b98093bc2ddbae79e1dControl.Lens.PlatedplateData.IntMap.InternalIntMapdependent-map-0.4.0.0-e30eba93f1fe5e2e255996a0586d338cf42a9564b4352a57e1532b6a6f7c704bData.Dependent.Map.InternalDMap GHC.ClassesOrd mtl-2.3.1Control.Monad.State.Class MonadState GHC.MaybeMaybeJustGHC.StableName StableNameControl.Lens.TypeLens'smtlib-backends-0.4-36b7c32d9b849b5840ac2a4dea6977cb1b78c701dc4e32239363fba866136ee9SMTLIB.BackendsQueuingHandle