h*W       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                       !!!!!!!!!!!!!!!"""""""""################################$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$%%%%%%%&''''''''''((((((((((((( ( ( ( ( ( ( ( ( ( ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + , , , , , , , , , , , , , , , , , , - - - - - - - - - - - - - - - - - - - - - - - - . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . / / / / / / 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011112222222222222222222222222222222222222222222222222222222222222333333333333333333333333333333333333333333333333333333334444444444444444444444444444444444444444444444444444444444444444444455555555555555555555555555566666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666677777777777777777777777788888888888888889999999999999999999999999999999999999999999999999999999999999999999999:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::;;;;;;;;;;;;;;;;;<<<<<<<<<<<<<<<<<<<<<<<<<<<<==========>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>???????????????????????????????????????????????????????????????????????????????????????????????@AAAAAAAAAAAAABBCCCCDDDDDDDDDDDDDDDDDDDDEEEEEEEEEEEEEEEEEEEEEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGHHIIIIIIIIIIIIIJJJJJJJJKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKLLLLLLLLLMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNNNNNNNNNNNNNNNNNNOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOPPPPPPPPPPPPPQQQQQQQQQQRRRRRRRRRRRRSSSSSSSSSSSSSSSSSSSSSTTTTTTTTTTTTTTTUUUUUUUUUUUUUVVVVVVVVVVVVVWWWWWWX1.6Testing abstraction layer(c) Galois Inc, 2020BSD3kquick@galois.com Safe-InferredMu what4This is the generator monad for the Verification proxy tests. The inner monad will be the actual test implementation's monadic generator, and the a9 return type is the type returned by running this monad.Tests should only use the 'Gen TYPE' as an output; the constructors and internals should be used only by the test concretization. what4This is the reader environment for the surface level proxy testing monad. This environment will be provided by the actual test code to map these proxy operations to the specific testing implementation.what49Internal data structure to store the two elements to the  assumption operator.what4A class specifying things that can be verified by constructing a local Property.what4Local definition of a Property: intended to be a proxy for a QuickCheck Property or a Hedgehog Property. The " implementation function converts from these proxy Properties to the native Property implementation.Tests should only use the  type as an output; the constructors and internals should be used only by the test concretization.what42Used by testing code to assert a boolean property.what4The named form of the  assumption operatorwhat4The assumption operator that performs the property test (second element) only when the first argument is true (the assumption guard for the test). This is the analog to the corresponding QuickCheck ==> operator.what4+A test generator that returns True or Falsewhat4!A test generator that returns an 1 value between the specified (inclusive) bounds. what4!A test generator that returns an 1 value between the specified (inclusive) bounds.!what4A test generator that returns the current shrink size of the generator functionality."what4This function should be called by the testing code to convert the proxy tests in this module into the native tests (e.g. QuickCheck or Hedgehog). This function is provided with the mapping environment between the proxy tests here and the native equivalents, and a local Generator monad expression, returning a native Generator equivalent. ! " ! "09This module exports the types used in solver expressions.(c) Galois, Inc 2014-2020BSD3!Joe Hendrix  provisional Safe-Inferred)*/016V0what4?A runtime representation of a solver interface type. Parameter bt has kind K.>what4 Floating-point precision aliases?what4This computes the number of bits occupied by a floating-point format.Awhat4This data kind describes the types of floating-point formats. This consist of the standard IEEE 754-2008 binary floating point formats.Kwhat4This data kind enumerates the Crucible solver interface types, which are types that may be represented symbolically.what4 BaseBoolType denotes Boolean values.what4BaseIntegerType denotes an integer.what4 BaseRealType denotes a real number.what4 BaseBVType n denotes a bitvector with n-bits.what4BaseFloatType fpp& denotes a floating-point number with fpp precision.what4BaseStringType) denotes a sequence of Unicode codepointswhat4BaseComplexType/ denotes a complex number with real components.what4BaseStructType tps) denotes a sequence of values with types tps.what4BaseArrayType itps rtp$ denotes a function mapping indices itps to values of type rtp.It does not have bounds as one would normally expect from an array in a programming language, but the solver does provide operations for doing pointwise updates.what48-bit characterswhat416-bit characterswhat4Unicode code-pointsPwhat4+A Context where all the argument types are  instancesQwhat41Return the type of the indices for an array type.Rwhat4(Return the result type of an array type. @what4:: YZ -> YZ -> A.Bwhat4::  K -> K -> K.Cwhat4::  K -> K.Dwhat4:: K.Ewhat4:: K.Fwhat4:: A -> K.Gwhat4::  -> K.Hwhat4:: K.Iwhat4:: K.Jwhat4:: K.Lwhat4:: O.Mwhat4:: O.Nwhat4:: O.KJIHEGFDCBONMLA?@>=<;:0123456789./*+,-QRSTP-KJIHEGFDCBONMLA?@>=<;:0123456789./*+,-QRSTPMode values for controlling the "interpreted" floating point mode.(c) Galois, Inc 2014-2022BSD3rdockins@galois.com provisional Safe-Inferred)*01Z~what4In this mode "interpreted" floating-point values are treated as real-number values, to the extent possible. Expressions that would result in infinities or NaN will yield unspecified values in this mode, or directly produce runtime errors.what4In this mode "interpreted" floating-point values are treated as bitvectors of the appropriate width, and all operations on them are translated as uninterpreted functions.what4In this mode "interpreted" floating-point values are treated as bit-precise IEEE-754 floats.what4>Mode flag for how floating-point values should be interpreted.z{|}~z{|}~ Declarations for function names.(c) Galois, Inc 2014-2020BSD3!Joe Hendrix  provisional Safe-Inferred\Fwhat4For our purposes, a function name is just unicode text. Individual languages may want to further restrict names.what4(Name of function for starting simulator. Safe-Inferred)*1\what4This represents a concrete index value, and is used for creating arrays. Trustworthy^4what4 represents an error condition that should only arise due to a programming error. It will exit the program and print a message asking users to open a ticket.what4&Short name of where the error occured what4(More detailed description of the error  8Descriptions of the "features" that can occur in queries(c) Galois, Inc 2016-2020BSD3!Joe Hendrix  provisional Safe-Inferredepwhat4Allowed features represents features that the constraint solver will need to support to solve the problem.what45Indicates whether the problem uses linear arithmetic.what49Indicates whether the problem uses non-linear arithmetic.what4=Indicates whether the problem uses computable real functions.what41Indicates the problem contains integer variables.what4.Indicates whether the problem uses bitvectors.what4:Indicates whether the problem needs exists-forall support.what4Has general quantifier support.what43Indicates whether the problem uses symbolic arrays.what4*Indicates whether the problem uses structs.Structs are modeled using constructors in CVC4CVC5Z3, and tuples in Yices.what4*Indicates whether the problem uses strings9Strings have some symbolic support in CVC4, CVC5, and Z3.what41Indicates whether the problem uses floating-point?Floating-point has some symbolic support in CVC4, CVC5, and Z3.what4Indicates if the solver is able and configured to compute UNSAT cores.what4Indicates if the solver is able and configured to compute UNSAT assumptions.what4Indicates if the solver is able and configured to use uninterpreted functions.what4Indicates if the solver is able and configured to use defined functions.what4Indicates if the solver is able and configured to produce abducts.what4Tests if one set of problem features subsumes another. In particular, hasProblemFeature x y' is true iff the set of features in x is a superset of those in y. 'Datatype for handling program locations(c) Galois, Inc 2014-2020BSD3!Joe Hendrix  provisional Safe-Inferred9:;hdwhat4=A very small type that contains a function and PC identifier.what4*A value with a source position associated.what48A source position containing filename, line, and column.what4>A binary position containing a filename and address in memory.what4Some unstructured position information that doesn't fit into the other categories.what4Parses an SExp. If the input is a string (recognized by the  readString argument), return that as an 5; if the input is a single token, return that as an .what4Parses the body of an SExp after the opening '(' has already been parsed.what4A parser for string literals what4A parser for string literals what4A parser for string literals   Safe-Inferred "ywhat4The parsed declarations and definitions returned by "(get-model)"what4A line in the model responsewhat44This denotes an SMTLIB term over a fixed vocabulary.what4 IntTerm v denotes the SMTLIB expression v if v >= 0! and @(- `(negate v)) otherwise.what4 RatTerm r denotes the SMTLIB expression !(/ `(numerator r) `(denomator r)).what4StoreTerm a i v denotes the SMTLIB expression  (store a i v).what4IfEqTerm v c t f denotes the SMTLIB expression (ite (= v c) t f).what4 An SMT sort.what4&A named sort with the given arguments.what4!A bitvector with the given width.what4>floating point with exponent bits followed by significand bit.what4 An SMT symbolwhat4*Result of check-sat and check-sat-assumingwhat45Defines common operations for parsing SMTLIB results.what4Parser for values of this type.what4Read from a handle.what4-A parser monad that just reads from a handle.We use our own parser rather than Attoparsec or some other library so that we can incrementally request characters.We likely could replace this with Attoparsec by assuming that SMTLIB solvers always end their output responses with newlines, or feeding output one character at a time.what4%Peek ahead to get the next character.what48Drop characters until we get a non-whitespace character.what4Drop whitespace, and if next character matches expected return, otherwise fail.what40Drop whitespace until we reach the given string.what4parseUntilCloseParen p+ will drop whitespace characters, and run pwhat4takeChars' p prev h prepends characters read from h to prev until p, is false, and returns the resulting string.what4 takeChars p< returns the bytestring formed by reading characters until p is false.what4Parse a quoted string.what4Read the results of a  (check-sat) request.what4This skips whitespace than reads in the next alphabetic or dash characters.what49Read in whitespace, and then if next character is a parenwhat4.Parse the next characters as a decimal number.+Note. No whitespace may proceed the number.what4/Parses OsymbolO ( Osorted_varO* ) OsortO OtermOwhat4;This reads the model response from a "(get-model)" request.$$ Safe-Inferred ")*17<Fwhat4This is a subtype of the type of the same name in Data.SBV.Control.what47This represents a command to be sent to the SMT solver.what4'Denotes an expression in the SMT solverwhat4Sort for SMTLIB expressionswhat4?Identifies the set of predefined sorts and operators available.what4Use the QF_BV logicwhat4&Set the logic to all supported logics.what4&Set the logic to all supported logics.what4Use the Horn logicwhat4 Create a sort from a symbol namewhat4Booleanswhat4)Bitvectors with the given number of bits.what4Integerswhat4 Real numberswhat4 arraySort a b# denotes the set of functions from a to be b.what4Construct an expression with the given operator and list of arguments.what4Construct an expression with the given operator and single argument.what4Construct an expression with the given operator and two arguments.what42Construct a chainable term with the given relationchain_app p [x1, x2, ..., xn] is equivalent to p x1 x2  p x2 x3  ... / p x(n-1) xn.what4-Build a term for a left-associative operator.what4;Append a "name" to a term so that it will be printed when (get-assignment) is called.what4true Boolean termwhat4false Boolean termwhat4Complement a Booleanwhat4 implies c r is equivalent to c1 => c2 => .. cn => r.what4Conjunction of all termswhat4Disjunction of all termswhat4Xor of all termswhat4#Return true if all terms are equal.what42Construct a chainable term with the given relation pairwise_app p [x1, x2, ..., xn]+ is equivalent to forall_{i,j} p x_i x_j@.what4-Asserts that each term in the list is unique.what4"Create an if-then-else expression.what4forall_ vars t# denotes a predicate that holds if t* for every valuation of the variables in vars.what4exists_ vars t# denotes a predicate that holds if t) for some valuation of the variables in vars.what4Create a let binding. NOTE: SMTLib2 defines this to be a "parallel" let, which means that the bound variables are NOT in scope in the right-hand sides of other bindings, even syntactically-later ones.what4!Negate an integer or real number.what40Create a numeral literal from the given integer.what42Create a literal as a real from the given integer.what4sub x1 [x2, ..., xn] with n >= 1 returns x1 minus  x2 + ... + xn.$The terms are expected to have type Int or Real.what4add [x1, x2, ..., xn] with n >= 2 returns x1 minus  x2 + ... + xn.$The terms are expected to have type Int or Real.what4add [x1, x2, ..., xn] with n >= 2 returns x1 minus  x2 + ... + xn.$The terms are expected to have type Int or Real.what4div x1 [x2, ..., xn] with n >= 1 returns x1 div  x2 * ... * xn.$The terms are expected to have type Int.what4x1 ./ [x2, ..., xn] with n >= 1 returns x1 /  x2 * ... * xn.what4 mod x1 x2 returns x1 - x2 * (x1  [x2])@.$The terms are expected to have type Int.what4abs x1 returns the absolute value of x1."The term is expected to have type Int.what40Less than or equal over a chained list of terms.le [x1, x2, ..., xn] is equivalent to  x1 <= x2  x2 <= x3  ... / x(n-1) <= xn.This is defined in the Reals, Ints, and Reals_Ints theories, and the number of elements must be at least 2.With a strict interpretation of the SMTLIB standard, the terms should be all of the same type (i.e. Int or Real"), but existing solvers appear to implicitly all mixed terms.what4'Less than over a chained list of terms.lt [x1, x2, ..., xn] is equivalent to x1 < x2  x2 < x3  ... / x(n-1) < xn.With a strict interpretation of the SMTLIB standard, the terms should be all of the same type (i.e. Int or Real"), but existing solvers appear to implicitly all mixed terms.what43Greater than or equal over a chained list of terms.ge [x1, x2, ..., xn] is equivalent to  x1 >= x2  x2 >= x3  ... / x(n-1) >= xn.With a strict interpretation of the SMTLIB standard, the terms should be all of the same type (i.e. Int or Real"), but existing solvers appear to implicitly all mixed terms.what4*Greater than over a chained list of terms.gt [x1, x2, ..., xn] is equivalent to x1 > x2  x2 > x3  ... / x(n-1) > xn.With a strict interpretation of the SMTLIB standard, the terms should be all of the same type (i.e. Int or Real"), but existing solvers appear to implicitly all mixed terms.what4Maps a term with type Int to Real.what4Returns the largest integer not larger than the given real term.what4#Returns true if this is an integer.what4arrayConst t1 t2 c$ generates an array with index type t1 and value type t2 that always returns c.+This uses the non-standard SMTLIB2 syntax ((as const (Array t1 t2)) c) which is supported by CVC4, CVC5, and Z3 (and perhaps others).what4 select a i denotes the value of a at i.what4 store a i v& denotes the array whose valuation is v at index i and  select a j at every other index j.what4A 1-bit bitvector representing 0.what4A 1-bit bitvector representing 1.what4 bvbinary w x( constructs a bitvector term with width w equal to x  2^w. The width w must be positive.#The literal uses a binary notation.what4 bvdecimal x w( constructs a bitvector term with width w equal to x  2^w. The width w must be positive.$The literal uses a decimal notation.what4bvhexadecimal x w( constructs a bitvector term with width w equal to x  2^w. The width w" must be a positive multiple of 4.The literal uses hex notation.what4 concat x y( returns the bitvector with the bits of x followed by the bits of y.what4 extract i j x+ returns the bitvector containing the bits [j..i].what4Bitwise negation of term.what4Bitwise and of all arguments.what4$Bitwise include or of all arguments.what4(Bitvector exclusive or of all arguments.what4Negate the bitvectorwhat4Bitvector additionwhat4Bitvector subtractionwhat4Bitvector multiplicationwhat4 bvudiv x y returns floor (to_nat x / to_nat y) when y != 0.When y = 0, this returns not (from_nat 0).what4 bvurem x y returns x - y * bvudiv x y when y != 0.When y = 0, this returns  from_nat 0.what4 bvshl x y shifts the bits in x to the left by to_nat u bits.The new bits are zeros (false)what4 bvlshr x y shifts the bits in x to the right by to_nat u bits.The new bits are zeros (false)what4 bvult x y( returns a Boolean term that is true if to_nat x < to_nat y.what4 bvule x y( returns a Boolean term that is true if to_nat x <= to_nat y.Note. This is in QF_BV, but not the bitvector theory.what4 bvsle x y( returns a Boolean term that is true if to_int x <= to_int y.Note. This is in QF_BV, but not the bitvector theory.what4 bvslt x y( returns a Boolean term that is true if to_int x < to_int y.Note. This is in QF_BV, but not the bitvector theory.what4 bvuge x y( returns a Boolean term that is true if to_nat x <= to_nat y.Note. This is in QF_BV, but not the bitvector theory.what4 bvugt x y( returns a Boolean term that is true if to_nat x < to_nat y.Note. This is in QF_BV, but not the bitvector theory.what4 bvsge x y( returns a Boolean term that is true if to_int x <= to_int y.Note. This is in QF_BV, but not the bitvector theory.what4 bvsgt x y( returns a Boolean term that is true if to_int x < to_int y.Note. This is in QF_BV, but not the bitvector theory.what4 bvashr x y shifts the bits in x to the right by to_nat u bits.9The new bits are the same as the most-significant bit of x.Note. This is in QF_BV, but not the bitvector theory.what4 bvsdiv x y returns #round_to_zero (to_int x / to_int y) when y != 0.When y = 0, this returns not (from_nat 0).Note. This is in QF_BV, but not the bitvector theory.what4 bvsrem x y returns x - y * bvsdiv x y when y != 0.When y = 0, this returns  from_nat 0.Note. This is in QF_BV, but not the bitvector theory.what4bvsignExtend w x adds an additional w' bits to the most significant bits of x by sign extending x.Note. This is in QF_BV, but not the bitvector theory.what4bvzeroExtend w x adds an additional w, zero bits to the most significant bits of x.Note. This is in QF_BV, but not the bitvector theory.what4Set the logic of the SMT solverwhat4Set an option in the SMT solver6The name should not need to be prefixed with a colon."what4Set option to produce modelsThis is a widely used option so, we we have a custom command to make it.what4Request the SMT solver to exitwhat4Declare an uninterpreted sort with the given number of sort parameters.what4%Define a sort in terms of other sortswhat48Declare a constant with the given name and return types.what4Declare a function with the given name, argument types, and return type.what4Declare a function with the given name, argument types, and return type.what42Assert the predicate holds in the current context.what4Assert the predicate holds in the current context, and assign it a name so it can appear in unsatisfiable core results.what42Check the satisfiability of the current assertionswhat4Check the satisfiability of the current assertions and the additional ones in the list.what4Check satisfiability of the given atomic assumptions in the current context.NOTE! The names of variables passed to this function MUST be generated using a `declare-fun` statement, and NOT a `define-fun` statement. Thus, if you want to bind an arbitrary term, you must declare a new term and assert that it is equal to it's definition. Yes, this is quite irritating.what4/Get the model associated with the last call to  check-sat.what4?Get an abduct that entails the formula, and bind it to the namewhat47Get the next command, called after a get-abduct commandwhat4Declare a SyGuS function to synthesize with the given name, arguments, and return type.what46Declare a SyGuS variable with the given name and type.what4:Add the SyGuS constraint to the current synthesis problem.what4Ask the SyGuS solver to find a solution for the synthesis problem corresponding to the current functions-to-synthesize, variables and constraints.what4?Get the values associated with the terms from the last call to  check-sat.what4Empties the assertion stack and remove all global assertions and declarations.what48Push the given number of scope frames to the SMT solver.what47Pop the given number of scope frames to the SMT solver.what4A get-info commandwhat4Name of new sortwhat4 Parameters for polymorphic sortswhat4 DefinitionSimple datastructure for capturing the result of a SAT/SMT query(c) Galois, Inc 2015-2020BSD3!Joe Hendrix  provisional Safe-Inferred<  ;Definitions related to semiring structures over base types.(c) Galois Inc, 2019-2020BSD3rdockins@galois.com Safe-Inferred )*1what4The  family counts how many times a term occurs in a product. For most semirings, this is just a natural number representing the exponent. For the boolean ring of bitvectors, however, it is unit because the lattice operations are idempotent.what4$The constant values in the semiring.what4The subset of semirings that are equipped with an appropriate (order-respecting) total order.what44Data-kind representing the semirings What4 supports.what4Data-kind indicating the two flavors of bitvector semirings. The ordinary arithmetic semiring consists of addition and multiplication, and the "bits" semiring consists of bitwise xor and bitwise and.what4,Compute the base type of the given semiring.what4Compute the semiring corresponding to the given ordered semiring.what4 ::  ->  -> what4 :: what4 :: what4 :: what4 :: %%#Log msgs via a synchronized channel Safe-Inferred/ǃ what4Logging configuration.what4%User friendly names for threads. See  asyncNamed.what4 A log event.3Can be converted to a string later, or thrown away.what4The  Maybe String is the name of the enclosing function in which the logging function was called. Not always available, since it depends on the enclosing function having a  constraint.what4&ID of thread that generated the event.what4 Stored as  because [\ docs say a thread can't be GC'd as long as someone maintains a reference to its !!!what4!Monads with logger configuration.what4Access to the log config.Users should prefer  to binding the implicit param. The implicit param is an implementation detail, and we could change the implementation later, e.g. to use the  reflection package.?We use an implicit param to avoid having to change all code in  that wants to log to be in  and  classes.An even more convenient but more "unsafe" implementation would store the  in a global, unsafePerformIOd IORef (cf.  uniqueSource in ]^).what44Log levels, in increasing severity/precedence order.what4 Fine detailswhat4Tracking progresswhat4Something notable or suspiciouswhat4 Something badwhat4 Satisfy a  constraint..Users can call this function instead of using ImplicitParams themselves.what4Recover the log config.>Useful for going between implicit and monadic interfaces. E.g. flip runReaderT getLogCfg ...what4 Log in a .-If you want the name of function that called 7 to be included in the output, then you need to add a  constraint to it as well (see LogC,). Otherwise, one of two things will happen:if no enclosing function has a  constraint, then ???. will be used for the enclosing function name.)if at least one enclosing function has a  constraint, then the name of the *closest* enclosing function with that constraint will be used for the enclosing function name. So, for example, if you define outer by outer :: (MonadHasLogCfg m, Ghc.HasCallStack) => m Int outer = inner where inner = do log Debug "Inside 'inner' ..." return 42then the call to  in inner5 will have "outer" as the enclosing function name.what4 with an explicit configwhat4Log in pure code using unsafePerformIO, like _`.See .what4 Log in a .See .what4Signal to the log consumer that there are no more log messages and terminate the log consumer. This is useful for cases where the logger is running in a separate thread and the parent thread wants to wait until the logger has finished logging and has successfully flushed all log messages before terminating it.what4 Initialize a .The first argument is the human friendly name to assign to the current thread. Since logging should be configured as soon as possible on startup, "main" is probably the right name.See  asyncNamed for naming other threads.= Info) . leLevel# will only process messsages with  equal to  or higher, ignoring  level messages.what4A log event consumer that prints formatted log events to stderr.what4-A logger that writes to a user-specified file!Note that logs are opened in the w mode (i.e., overwrite). Callers should preserve old log files if they really want.what4A log event consumer that writes formatted log events to a tmp file.what43Run an IO action with a human friendly thread name.Any existing thread name will be restored when the action finishes.what4 Version of  for implicit log cfg.what4 Version of  for  monads.what4Format a log event.what4Write a  to the underlying channel."This is a low-level function. See , , and / for a high-level interface that supplies the  and  parameters automatically.However, those functions can't be used to build up custom loggers, since they infer call stack information automatically. If you want to define a custom logger (even something simple like debug msg = logM Debug msg ) then use .%% Safe-Inferred ")*1what4An identifier.what4A prefix followed by a string literal (.e.g, AStr "u" "Hello World" is serialize as `#u"Hello World"`).what4"Integer (i.e., unbounded) literal.what4!Natural (i.e., unbounded) literalwhat4Real (i.e., unbounded) literal.what4)A floating point literal (with precision)what4 Bitvector, width and then value.what4Boolean literal.what4Lift an unquoted identifier.what4Lift an integer.what4Lift a naturalwhat4 Lift a realwhat4 Lift a floatwhat4Lift a bitvector.what4Lift a boolean.what4Generates the the S-expression tokens represented by the sexpr argument, preceeded by a list of strings output as comments.what49Format a floating point value with no rounding in base 16what4This is only the base-level parsing of atoms. The full language parsing is handled by the base here and the Parser definitions. Safe-Inferred ")*1what4Parse 6 into the well-formed s-expression type from s-cargot.'Utilities relating to special functions(c) Galois, Inc 2021BSD3!Rob Dockins  Safe-Inferred)*01 what4Data type for wrapping a collction of actual arguments to special functions.what4Data type for wrapping the actual arguments to special functions.what4'An interval on real values, or a point.what4The endpoint of an interval, which may be inclusive or exclusive.what4Values that can appear in the definition of domain and range intervals for special functions.what4Data type for representing "special" functions. These include functions from standard and hyperbolic trigonometry, exponential and logarithmic functions, as well as other well-known mathematical functions.Generally, little solver support exists for such functions (although systems like dReal and Metatarski can prove some properties). Nonetheless, we may have some information about specific values these functions take, the domains on which they are defined, or the range of values their outputs may take, or specific relationships that may exists between these functions (e.g., trig identities). This information may, in some circumstances, be sufficent to prove properties of interest, even if the functions cannot be represented in their entirety.what4Phantom data index representing the real number line. Used for specifying the arity of special functions.what4Some special functions exhibit useful symmetries in their arguments. A function f is an odd function if  f(-x) = -f(x), and is even if  f(-x) = f(x). We extend this notion to arguments of more than one function by saying that a function is even/odd in its ith argument if it is even/odd when the other arguments are fixed.what4Compute function symmetry information for the given special function.what4Compute the range of values that may be returned by the given special function as its arguments take on the possible values of its domain. This may include limiting values if the function's domain includes infinities; for example  exp(-inf) = 0.what4Compute the domain of the given special function. As a mathematical entity, the value of the given function is not well-defined outside its domain. In floating-point terms, a special function will return a NaN0 when evaluated on arguments outside its domain.Datatype for representing names that can be communicated to solvers(c) Galois Inc, 2015-2020BSD3jhendrix@galois.com Safe-Inferredܧwhat4+This represents a name known to the solver.We have three types of symbols:The empty symbol A user symbolA system symbolA user symbol should consist of a letter followed by any combination of letters, digits, and underscore characters. It also cannot be a reserved word in Yices or SMTLIB.A system symbol should start with a letter followed by any number of letter, digit, underscore or an exclamation mark characters. It must contain at least one exclamation mark to distinguish itself from user symbols.what4This describes why a given text value was not a valid solver symbol.what4Return the empty symbol.what4This returns either a user symbol or the empty symbol if the string is empty.what4Attempts to create a user symbol from the given string. If this fails for some reason, the string is Z-encoded into a system symbol instead with the prefix "zenc!".what49This attempts to parse a string as a valid solver symbol.what4*This is the list of keywords in SMTLIB 2.55A finite map data structure with monoidal annotations(c) Galois Inc, 2019-2020BSD3huffman@galois.com Safe-Inferred9:;jwhat4for keys present in both maps what4for subtrees only in first map what4 for subtrees only in second map what4for keys present in both maps what4for subtrees only in first map what4 for subtrees only in second map *Utility functions for computing arithmetic(c) Galois, Inc 2015-2020BSD3!Joe Hendrix  provisional Safe-Inferred what4)Returns true if number is a power of two.what4Returns floor of log base 2.what4)Returns ceil of log base 2. We define  lgCeil 0 = 0what4Count trailing zeroswhat4Count leading zeroswhat4nextMultiple x y computes the next multiple m of x s.t. m >= y. E.g., nextMultiple 4 8 = 8 since 8 is a multiple of 8; nextMultiple 4 7 = 8; nextMultiple 8 6 = 8.what4nextPow2Multiple x n" returns the smallest multiple of 2^n not less than x.what4:This returns the sqrt of an integer if it is well-defined.what4Return the rational sqrt of awhat4;Evaluate a real to an integer with rounding away from zero.what4width what4value to rotate what4amount to rotate what4width what4value to rotate what4amount to rotate  (c) Galois Inc, 2019-2020BSD3huffman@galois.com Safe-Inferred )*1J(what4Pairs of nonzero integers (lo, hi) such that  1/lo <= 1/hi8. This pair represents the set of all nonzero integers x such that 1/lo <= 1/x <= 1/hi.what4A value of type BVDomain w* represents a set of bitvectors of width w. Each BVDomain can represent a single contiguous interval of bitvectors that may wrap around from -1 to 0.what4#The set of all bitvectors of width w. Argument caches 2^w-1.what4;Intervals are represented by a starting value and a size. BVDInterval mask l d+ represents the set of values of the form  x mod 2^w for x such that l <= x <= l + d$. It should satisfy the invariants  0 <= l < 2^w and  0 <= d < 2^w'. The first argument caches the value 2^w-1.what4=Compute how many concrete elements are in the abstract domainwhat4Test if the given integer value is a member of the abstract domainwhat4,Check if the domain satisfies its invariantswhat40Return the bitvector mask value from this domainwhat4"Random generator for domain valueswhat4'Generate a random element from a domainwhat4Generate a random domain and an element contained in that domain.what4 halfRange n returns 2^(n-1).what4$Return value if this is a singleton.what4"Return unsigned bounds for domain.what4 Return signed bounds for domain.what4 Return the (lo,sz), the low bound and size of the given arithmetic interval. A value x0 is in the set defined by this domain iff  (x - lo)  w <= sz holds. Returns Nothing# if the domain contains all values.what40Return true if domains contain a common element.what4Check if all elements in one domain are less than all elements in other.what4Check if all elements in one domain are less than all elements in other.what4 Check if (bvult (bvadd a c) (bvadd b c)) is equivalent to  (bvult a b).3This is true if and only if for all natural values i_a, i_b, i_c in a, b, c, either both  i_a + i_c and  i_b + i_c are less than 2^w7, or both are not. We prove this by contradiction. If  i_a = i_b-, then the property is trivial. Assume that  i_a < i_b. Then i_a + i_c < i_b + i_c0. If exactly one of the additions is less than 2^w, it must be the case that i_a + i_c < 2^w and 0 <= i_b + i_c - 2^w < 2^w. Since  i_b < 2^w, it follows that i_b + i_c < 2^w + i_c, that i_b + i_c - 2^w < i_c , and that i_b + i_c - 2^w < i_a + i_c. Thus, for these values of i_a, i_b, i_c,  (bvult a b) is true, but (bvult (bvadd a c) (bvadd b c))% is false, which is a contradiction.3We check this property by case analysis on whether c is a single non-wrapping interval, or it wraps around and is a union of two non-wrapping intervals. For a non-wrapping (sub)interval c' of c&, there are four possible cases: 1. a and b contain a single value. 2.  (bvadd a c') and  (bvadd b c')* do not wrap around for any values in a, b, c'. 3.  (bvadd a c') and  (bvadd b c') wrap around for all values in a, b, c'.This is used to simplify bvult.what4Represents all valueswhat43Create a bitvector domain representing the integer.what4 range w l u; returns domain containing all bitvectors formed from the w low order bits of some i in [l,u]. Note that per testBit&, the least significant bit has index 0.what4Unsafe constructor for internal use only. Caller must ensure that mask = maxUnsigned w , and that aw is non-negative.what4Create an abstract domain from an ascending list of elements. The elements are assumed to be distinct.what4Return union of two domains.what4 concat a y& returns domain where each element in a+ has been concatenated with an element in y". The most-significant bits are a%, and the least significant bits are y.what4 shrink i a drops the i least significant bits from a.what4 trunc n d selects the n least significant bits from d.what4 select i n a selects n bits starting from index i from a.what4Clamp the given shift amount to the word width indicated by the nat reprwhat4Choose a representative integer range (positive or negative) for the given bitvector domain such that the endpoints are as close to zero as possible.what4Nonzero signed values in a domain with the least and greatest reciprocals.what4Interval arithmetic for integer division (rounding towards 0). Given a and b with  al <= a <= ah and 1/bl <= 1/b <= 1/bh, *sdivRange (al, ah) (ReciprocalRange bl bh) returns (ql, qh) such that ql <= a  b <= qh.what4scaleDownRange (lo, hi) k returns an interval (ql, qh) such that for any x in [lo..hi], x  k is in [ql..qh].what4Complement bits in range.what4Return bitwise bounds for domain (i.e. logical AND of all possible values, paired with logical OR of all possible values).what4unknowns lo hi returns a bitmask representing the set of bit positions whose values are not constant throughout the range lo..hi.what4 fillright x rounds up x to the nearest 2^n-1.what4Check that a domain is proper, and that the given value is a member(c) Galois Inc, 2020BSD3huffman@galois.com Safe-Inferred )*1what4A bitwise interval domain, defined via a bitwise upper and lower bound. The ordering used here to construct the interval is the pointwise ordering on bits. In particular x [= y iff x .|. y == y, and a value x# is in the set defined by the pair (lo,hi) just when lo [= x && x [= hi.what4BVDBitInterval mask lo hi. mask caches the value of 2^w - 1what4+Test if the domain satisfies its invariantswhat4Test if the given integer value is a member of the abstract domainwhat4=Compute how many concrete elements are in the abstract domainwhat40Return the bitvector mask value from this domainwhat4Random generator for domain values. We always generate nonempty domain values.what4Generate a random nonempty domain and an element contained in that domain.what4$Unsafe constructor for internal use.what46Construct a domain from bitwise lower and upper boundswhat4Bitwise lower and upper boundswhat4Test if this domain contains a single value, and return it if sowhat4Returns true iff there is at least on element in this bitwise domain.what4/Return a domain containing just the given valuewhat4/Bitwise domain containing every bitvector valuewhat46Returns true iff the domains have some value in commonwhat4 concat a y& returns domain where each element in a+ has been concatenated with an element in y". The most-significant bits are a%, and the least significant bits are y.what4 shrink i a drops the i least significant bits from a.what4 trunc n d selects the n least significant bits from d.what4 select i n a selects n bits starting from index i from a.what4Check that a domain is proper, and that the given value is a member::(c) Galois Inc, 2019-2020BSD3huffman@galois.com Safe-Inferred )*1 what4A value of type BVDomain w* represents a set of bitvectors of width w. This is an alternate representation of the bitwise domain values, optimized to compute XOR operations.what4BVDXor mask hi unknown% represents a set of values where hi is a bitwise high bound, and unknown? represents the bits whose values are not known. The value mask caches the value 2^w-1.what4+Test if the domain satisfies its invariantswhat4Test if the given integer value is a member of the abstract domainwhat40Return the bitvector mask value from this domainwhat46Construct a domain from bitwise lower and upper boundswhat4$Unsafe constructor for internal use.what4Bitwise lower and upper boundswhat4Test if this domain contains a single value, and return it if sowhat4Random generator for domain values. We always generate nonempty domain values.what4Generate a random nonempty domain and an element contained in that domain.what4/Return a domain containing just the given valuewhat4Check that a domain is proper, and that the given value is a memberAbstract domains for bitvectors(c) Galois Inc, 2019-2020BSD3huffman@galois.com Safe-Inferred ()*1what4A value of type  w* represents a set of bitvectors of width w. A BVDomain represents either an arithmetic interval, or a bitwise interval.what40Return the bitvector mask value from this domainwhat4+Test if the domain satisfies its invariantswhat4Test if the given integer value is a member of the abstract domainwhat4=Compute how many concrete elements are in the abstract domainwhat4!Generate a random nonempty domainwhat4Generate a random element from a domain, which is assumed to be nonemptywhat4Generate a random nonempty domain and an element contained in that domain.what4$Return value if this is a singleton.what4Precondition:  x <= lomask'. Find the (arithmetically) smallest z above x which is bitwise above lomask%. In other words find the smallest z such that x <= z and lomask .|. z == z.what4Precondition: lomask <= x <= himask and lomask .|. himask == himask&. Find the (arithmetically) smallest z above x which is bitwise between lomask and himask%. In other words, find the smallest z such that x <= z and lomask .|. z = z and z .|. himask == himask.what4;Test if an arithmetic domain overlaps with a bitwise domainwhat40Return true if domains contain a common element.what4Return a list of "candidate" overlap elements. If two domains overlap, then they will definitely share one of the given values.what4Check if all elements in one domain are less than all elements in other.what4Check if all elements in one domain are less than all elements in other.what4Return Just if every bitvector in the domain has the same bit at the given index.what4Check if (bvult (bvadd a c) (bvadd b c)) is equivalent to (bvult a b)what4Represents all valueswhat43Create a bitvector domain representing the integer.what4 range w l u; returns domain containing all bitvectors formed from the w low order bits of some i in [l,u]. Note that per testBit&, the least significant bit has index 0.what4Create an abstract domain from an ascending list of elements. The elements are assumed to be distinct.what4Return union of two domains.what4 concat a y& returns domain where each element in a+ has been concatenated with an element in y". The most-significant bits are a%, and the least significant bits are y.what4 select i n a selects n bits starting from index i from a.what4Complement bits in range.what4Check that a domain is proper, and that the given value is a memberwhat4bvmask3, based on the width of the bitvectors in question what4 xwhat4 lomaskwhat4bvmask3, based on the width of the bitvectors in question what4 xwhat4 lomaskwhat4 himaskwhat41Index of bit (least-significant bit has index 0) Provides a complex representation that is more generic than Data.Complex.(c) Galois, Inc 2014-2020BSD3!Joe Hendrix  provisional Safe-Inferred )*9:;<Awhat4&A complex pair over an arbitrary type.what45Returns the "complex argument" of the complex number.what4Returns square of magnitude.what4 Sqrt functionwhat47Square-root function defined for non-negative values a.6 Safe-InferredProvides functions for finding an executable, and expanding a path with referenced to environment variables.(c) Galois, Inc 2013-2020BSD3!Joe Hendrix  provisional Safe-Inferredwhat4Given a mapping of variables to values, this replaces substrings of the form $VAR with the associated value in a string.what4!Find an executable from a string.what4Path to expand  Safe-Inferred")*-<T what46Rounding modes for IEEE-754 floating point operations.what4Round to nearest even.what4Round to nearest away.what4Round toward plus Infinity.what4Round toward minus Infinity.what4Round toward zero.what4=Make LibBF options for the given precision and rounding mode.what4Make a floating point number from an integer, using the given rounding modewhat4Make a floating point number from a rational, using the given rounding modewhat4;Convert a floating point number to a rational, if possible.what4;Convert a floating point number to an integer, if possible.! Safe-Inferred"what4Wrapper to help with reading from another process's standard out and stderr.We want to be able to read from another process's stderr and stdout without causing the process to stall because stdout or stderr becomes full. This data type will read from either of the handles, and buffer as much data as needed in the queue. It then provides a line-based method for reading that data as strict bytestrings. what48Create a new handle reader for reading the given handle.what42Stop the handle reader; cannot be used afterwards.what4 Safe-Inferred.what4Return the empty mapwhat4Find largest element that is less than or equal to key (if any).what43Find largest element that is at least key (if any).what46Find less than element that is less than key (if any).what46Find less than element that is less than key (if any).what4 lesser hi m returns all entries in m less than hi.what45Create a map from a list of keys in descending order.$Typeclass for monads generalizing ST(c) Galois, Inc 2014-2020BSD3!Joe Hendrix  provisional Safe-Inferred/%(c) Galois, Inc. 2020BSD3!Joe Hendrix  Safe-Inferred)*0what41This provides a GADT instance used to indicate a K must have value I.&IO stream utilities(c) Galois, Inc 2013-2020BSD3!Joe Hendrix  provisional Safe-Inferred1what4.Write from input stream to a logging function.what4Logging function' Safe-Inferred"6?2what4This method parses configuration files describing the upper and lower bounds of solver versions we expect to work correctly with What4. See the file "solverBounds.config" for examples of how such bounds are specified.  (-Utility definitions for wide (2-byte) strings(c) Galois, Inc 2019-2020BSD3!Rob Dockins  provisional Safe-Inferred7 what4A string of Word16 values, encoded as a bytestring in little endian (LE) order.We maintain the invariant that Word16Strings are represented by an even number of bytes.what4 Generate a  Word16String from a bytestring where the 16bit words are encoded as two bytes in little-endian order.PRECONDITION: the input bytestring must have a length which is a multiple of 2.what4/Return the underlying little endian bytestring.what4Return the empty stringwhat46Compute the string containing just the given characterwhat4!Test if the given string is emptywhat4 Retrive the nth character of the string. Out of bounds accesses will cause an error.what4Find the first index (if it exists) where the first string appears as a substring in the second what4Returns true if the first string appears somewhere in the second string.  )Utility definitions for strings(c) Galois, Inc 2019-2020BSD3!Rob Dockins  provisional Safe-Inferred)*1: what4Index of first occurrence of second string in first one starting at the position specified by the third argument. stringLitIndexOf s t k, with  0 <= k <= |s|/ is the position of the first occurrence of t in s at or after position k, if any. Otherwise, it is -1. Note that the result is k whenever k is within the range [0, |s|] and t is empty.what4 provisional Safe-Inferred)*/016>^ what4?A data type for representing the concrete values of base types. what45Compute the type representative for a concrete value.what4Pretty-print a rational number. what4Pretty-print a concrete value  .9Declares attributes for simulator configuration settings.(c) Galois, Inc 2015-2020BSD3!Rob Dockins  provisional Safe-Inferred")*/01u what4A  ConfigValue? bundles together the name of an option with its current value. what4A utility class for making working with option settings easier. The tp argument is a BaseType , and the a, argument is an associcated Haskell type. what4-Return the current value of the option, as a Maybe value. what4Attempt to set the value of an option. Return any errors or warnings. what4Set the value of an option. Return any generated warnings. Throws an OptSetFailure exception if a validation error occurs. what4Get the current value of an option. Throw an exception if the option is not currently set. what4The main configuration datatype. It consists of a Read/Write var containing the actual configuration data.what4Main configuration data type. It is organized as a trie based on the name segments of the configuration option name. what4A  ConfigDesc describes a configuration option before it is installed into a Config object. It consists of a  ConfigOption name for the option, an  OptionStyle describing the sort of option it is, and an optional help message describing the semantics of this option. what4 An inclusive or exclusive bound. what4An option defines some metadata about how a configuration option behaves. It contains a base type representation, which defines the runtime type that is expected for setting and querying this option at runtime. what4'base type representation of this option what4An operation for validating new option values. This action may also be used to take actions whenever an option setting is changed. NOTE! the onset action should not attempt to look up the values of other configuration settings, or deadlock may occur.The first argument is the current value of the option (if any). The second argument is the new value that is being set. If the validation fails, the operation should return a result describing why validation failed. Optionally, warnings may also be returned. what4Documentation for the option to be displayed in the event a user asks for information about this option. This message should contain information relevant to all options in this style (e.g., its type and range of expected values), not necessarily information about a specific option. what42This gives a default value for the option, if set. what4An  OptionSetting gives the direct ability to query or set the current value of an option. The  getOption field is an action that, when executed, fetches the current value of the option, if it is set. The  setOption method attempts to set the value of the option. If the associated  opt_onset validation method rejects the option, it will retain its previous value; otherwise it will be set to the given value. In either case, the generated OptionSetResult will be returned. what4When setting the value of an option, a validation function is called (as defined by the associated  OptionStyle3). The result of the validation function is an OptionSetResult. If the option value given is invalid for some reason, an error should be returned. Additionally, warning messages may be returned, which will be passed through to the eventual call site attempting to alter the option setting. what4A Haskell-land wrapper around the name of a configuration option. Developers are encouraged to define and use   values to avoid two classes of errors: typos in configuration option names; and dynamic type-cast failures. Both classes of errors can be lifted to statically-checkable failures (missing symbols and type-checking, respectively) by consistently using   values.3The following example indicates the suggested usage  asdfFrob :: ConfigOption BaseRealType asdfFrob = configOption BaseRealRepr "asdf.frob" asdfMaxBound :: ConfigOption BaseIntegerType asdfMaxBound = configOption BaseIntegerRepr "asdf.max_bound" what4 Construct a   from a string name. Idiomatic usage is to define a single top-level   value in the module where the option is defined to consistently fix its name and type for all subsequent uses.what4,Split a text value on ' characters. Return Nothing if the whole string, or any of its segments, is the empty string. what4>Get the individual dot-separated segments of an option's name. what44Reconstruct the original string name of this option. what44Reconstruct the original string name of this option. what4-Retrieve the run-time type representation of tp. what47Accept the new option value with no errors or warnings. what42Reject the new option value with an error message. what4Standard option style for boolean-valued configuration options what4;Standard option style for real-valued configuration options what4?Standard option style for integral-valued configuration options what4Option style for real-valued options with upper and lower bounds what47Option style for real-valued options with a lower bound what48Option style for real-valued options with an upper bound what4Option style for integer-valued options with upper and lower bounds what4:Option style for integer-valued options with a lower bound what4;Option style for integer-valued options with an upper bound what4A configuration style for options that must be one of a fixed set of text values what4A configuration syle for options that must be one of a fixed set of text values. Associated with each string is a validation/callback action that will be run whenever the named string option is selected. what4Used as a wrapper for an option that has been deprecated. If the option is actually set (as opposed to just using the default value) then this will emit an OptionSetResult warning that time, optionally mentioning the replacement option (if specified).There are three cases of deprecation: 1. Removing an option that no longer applies 2. Changing the name or heirarchical position of an option. 3. #2 and also changing the type. 4. Replacing an option by multiple new options (e.g. split url option into hostname and port options)In the case of #1, the option will presumably be ignored by the code and the warnings are provided to allow the user to clean the option from their configurations.In the case of #2, the old option and the new option will share the same value storage: changes to one can be seen via the other and vice versa. The code can be switched over to reference the new option entirely, and user configurations setting the old option will still work until they have been updated and the definition of the old option is removed entirely.NOTE: in order to support #2, the newer option should be declared (via $) *before* the option it deprecates.In the case of #3, it is not possible to share storage space, so during the deprecation period, the code using the option config value must check both locations and decide which value to utilize.Case #4 is an enhanced form of #3 and #2, and is generally treated as #3, but adds the consideration that deprecation warnings will need to advise about multiple new options. The inverse of #4 (multiple options being combined to a single newer option) is just treated as separate deprecations.NOTE: in order to support #4, the newer options should all be declared (via &) *before* the options they deprecate.Nested deprecations are valid, and replacement warnings are automatically transitive to the newest options.Any user-supplied value for the old option will result in warnings emitted to the OptionSetResult for all four cases. Code should ensure that these warnings are appropriately communicated to the user to allow configuration updates to occur.Note that for #1 and #2, the overhead burden of continuing to define the deprecated option is very small, so actual removal of the older config can be delayed indefinitely. what4A configuration style for options that are expected to be paths to an executable image. Configuration options with this style generate a warning message if set to a value that cannot be resolved to an absolute path to an executable file in the current OS environment. what42The most general method for constructing a normal  . what4Construct an option using a default style with a given initial value what4Construct an option using a default style with a given initial value. Also provide a validation function to check new values as they are set. what4Construct an option using a default style with no initial value. what4Construct an option using a default style with no initial value. Also provide a validation function to check new values as they are set. what4The copyOpt creates a duplicate ConfigDesc under a different name. This is typically used to taking a common operation and modify the prefix to apply it to a more specialized role (e.g. solver.strict_parsing --> solver.z3.strict_parsing). The style and help text of the input ConfigDesc are preserved, but any deprecation is discarded.what4The given list of name segments defines a lens into a config trie.what4The given nonempty list of name segments (with the initial segment given as the first argument) defines a lens into a  ConfigMap.what4Traverse an entire  ConfigMap. The first argument is the reversed heirarchical location of the starting map entry location.what4Traverse an entire  ConfigTrie.what4Traverse a subtree of a  ConfigMap,. If an empty path is provided, the entire  ConfigMap will be traversed.what4Add an option to the given  ConfigMap. If the option cannot be added (because it already exists in the map) the map is instead returned unchanged.what4Add an option to the given  ConfigMap or throws an   exception on error.Inserting an option multiple times is idempotent under equivalency modulo the opt_onset in the option's style, otherwise it is an error. what4Construct a new configuration from the given configuration descriptions. what4:Extend an existing configuration with new options. An   exception will be raised if any of the given options clash with options that already exists. what4Extend an existing configuration with new options. If any of the given options are already present in the configuration, nothing is done for that option and it is silently skipped. what4Create a new configuration object that shares the option settings currently in the given input config. However, any options added to either configuration using  extendConfig( will not be propagated to the other.Option settings that already exist in the input configuration will be shared between both; changes to those options will be visible in both configurations. what4Verbosity of the simulator. This option controls how much informational and debugging output is generated. 0 yields low information output; 5 is extremely chatty.what4-Built-in options that are installed in every Config object. what4Return an operation that will consult the current value of the verbosity option, and will print a string to the given Handle if the provided int is smaller than the current verbosity setting. what4 Throw an exception if the given OptionSetResult indicates an error. Otherwise, return any generated warnings. what4Given a unicode text value, set the named option to that value or generate an OptSetFailure exception if the option is not a unicode text valued option. what4Given an integer value, set the named option to that value or generate an OptSetFailure exception if the option is not an integer valued option. what4Given a boolean value, set the named option to that value or generate an OptSetFailure exception if the option is not a boolean valued option. what4Given a  ConfigOption name, produce an  OptionSetting> object for accessing and setting the value of that option.An exception is thrown if the named option cannot be found the Config& object, or if a type mismatch occurs. what4Given a text name, produce an  OptionSetting> object for accessing and setting the value of that option.;An exception is thrown if the named option cannot be found. what4Given the name of a subtree, return all the currently-set configuration values in that subtree.If the subtree name is empty, the entire tree will be traversed. what4Given the name of a subtree, compute help text for all the options available in that subtree.If the subtree name is empty, the entire tree will be traversed. what4*Fixes the name and the type of this optionwhat4Define the style of this optionwhat4 Help textwhat4A default value for this option what4*Fixes the name and the type of this optionwhat4Default value for the optionwhat4/An informational message describing this option what4*Fixes the name and the type of this optionwhat4Default value for the optionwhat4Validation function. Return `Just err` if the value to set is not valid.what4/An informational message describing this option what4*Fixes the name and the type of this optionwhat4/An informational message describing this option what4+Fixes the name and the type of this option what4Validation function. Return `Just err` if the value to set is not valid. what40An informational message describing this option what4A REVERSED LIST of the name segments that represent the context from the root to the current  ConfigMap. what4An action to apply to each leaf. The path to the leaf is provided. what4ConfigMap to traverse what4A REVERSED LIST of the name segments that represent the context from the root to the current  ConfigTrie. what4An action to apply to each leaf. The path to the leaf is provided. what4 ConfigTrie to traverse what4(Path indicating the subtree to traverse what4Action to apply to each leaf in the indicated subtree. The path to the leaf is provided. what4 ConfigMap to traverse what4Initial value for the   option what4Option descriptions to install / Safe-Inferred")*1 what4Utility function that runs a solver specified by the given config setting within a context. Errors can then be attributed to the solver. what4This runs a given external binary, providing the process handle and handles to input and output to the action. It takes care to terminate the process if any exception is thrown by the action. what4Close the connected process pipes and wait for the process to exit what40Start a process connected to this one via pipes. what4 Filtering function for use with  or  that filters out async exceptions so they are rethrown instead of captured what4Path to processwhat4Arguments to processwhat4Working directory if any.what4Action to run with process; should wait for process to terminate before returning. what4Path to executable what4Command-line arguments what4Optional working directory what4>process stdin, process stdout, process stderr, process handle   0.Main interface for constructing What4 formulae(c) Galois, Inc 2014-2020BSD3!Joe Hendrix  Safe-Inferred)*/01<Rv what4;Statistics gathered on a running expression builder. See  . what4;The number of times an expression node has been allocated. what4The number of non-linear operations, such as multiplications, that have occurred. what4This provides an interface for converting between Haskell values and a solver representation. what4This extends the interface for building expressions with operations for creating new symbolic constants and functions. what40Create a fresh top-level uninterpreted constant. what4Create a fresh latch variable. what4Create a fresh bitvector value with optional lower and upper bounds (which bound the unsigned value of the bitvector). If provided, the bounds are inclusive. If inconsistent or out-of-range bounds are given, an  InvalidRange exception will be thrown. what4Create a fresh bitvector value with optional lower and upper bounds (which bound the signed value of the bitvector). If provided, the bounds are inclusive. If inconsistent or out-of-range bounds are given, an InvalidRange exception will be thrown. what4Create a fresh integer constant with optional lower and upper bounds. If provided, the bounds are inclusive. If inconsistent bounds are given, an InvalidRange exception will be thrown. what4Create a fresh real constant with optional lower and upper bounds. If provided, the bounds are inclusive. If inconsistent bounds are given, an InvalidRange exception will be thrown. what4Return the set of uninterpreted constants in the given expression. what4Creates a bound variable.This will be treated as a free constant when appearing inside asserted expressions. These are intended to be bound using quantifiers or symbolic functions. what48Return an expression that references the bound variable. what4forallPred sym v e' returns an expression that represents  forall v . e. Throws a user error if bound var has already been used in a quantifier. what4existsPred sym v e' returns an expression that represents  exists v . e. Throws a user error if bound var has already been used in a quantifier. what4Return a function defined by an expression over bound variables. The predicate argument allows the user to specify when an application of the function should be unfolded and evaluated, e.g. to perform constant folding. what4Return a function defined by Haskell computation over symbolic expressions. what4$Create a new uninterpreted function. what40Apply a set of arguments to a symbolic function. what4Apply a variable substitution (variable to symbolic expression mapping) to a symbolic expression. what4Apply a function substitution (function to function mapping) to a symbolic expression. what4Transform a BV predicate into an LIA predicate by replacing all bitvector (BV) operations with LIA operations, and replacing all BV variables with LIA variables. This transformation is not sound, but in practice it is useful. It returns the transformed predicate and a map from the original uninterpreted function symbols to the trnasformed uninterpreted function symbols. what4Transform a LIA defined boolean function into a BV defined boolean function by replacing all LIA operations with BV operations. Currently, the BV width for function parameters is set to 64, and for operations is set to 72. what4This exception is thrown if the user requests to make a bounded variable, but gives incoherent or out-of-range bounds. what47Describes when we unfold the body of defined functions. what4What4 will not unfold the body of functions when applied to arguments what4The function will be unfolded into its definition whenever it is applied to arguments what4The function will be unfolded into its definition only if all the provided arguments are concrete. what4A class for extracting type representatives from symbolic functions what4%Get the argument types of a function. what4"Get the return type of a function. what4%Test whether two functions are equal.=The implementation may be incomplete, that is, if it returns 4 then the functions are equal, while if it returns < then the functions may or may not be equal. The result of   or   tests equal with itself. what4#Compare two functions for ordering.,The underlying equality test is provided by  . what4 Wrapper for  6 that concatenates the arguments and the return types. This is useful for implementing  and  instances for  , and for using   as a key or a value in a . what45A function that can be applied to symbolic arguments.-This type is used by some methods in classes   and  .what4This newtype is necessary for  bvJoinVector and  bvSplitVector. These both use functions from Data.Parameterized.Vector that that expect a wrapper of kind (Type -> Type), and we can't partially apply the type synonym (e.g. SymBv sym), whereas we can partially apply this newtype. what4>This class allows the simulator to build symbolic expressions.-Methods of this class refer to type families  sym and   sym.Note: Some methods in this class represent operations that are partial functions on their domain (e.g., division by 0). Such functions will have documentation strings indicating that they are undefined under some conditions. When partial functions are applied outside their defined domains, they will silently produce an unspecified value of the expected type. The unspecified value returned as the result of an undefined function is _not_ guaranteed to be equivalant to a free constant, and no guarantees are made about what properties such values will satisfy. what4Retrieve the configuration object corresponding to this solver interface. what4Install an action that will be invoked before and after calls to backend solvers. This action is primarily intended to be used for logging/profiling/debugging purposes. Passing & to this function disables logging. what4Get the currently-installed solver log listener, if one has been installed. what4Provide the given event to the currently installed solver log listener, if any. what4Get statistics on execution from the initialization of the symbolic interface to this point. May return zeros if gathering statistics isn't supported. what4;Get current location of program for term creation purposes. what4;Set current location of program for term creation purposes. what4Return true if two expressions are equal. The default implementation dispatches  ,  , ,  ,  ,  ,  , or  , depending on the type. what4Take the if-then-else of two expressions. The default implementation dispatches  ,  , ,  ,  ,  ,  , or  , depending on the type. what4Given a symbolic expression, annotate it with a unique identifier that can be used to maintain a connection with the given term. The  is intended to be used as the key in a hash table or map to additional data can be maintained alongside the terms. The returned  has the same semantics as the argument, but has embedded in it the > value so that it can be used later during term traversals.Note, the returned annotation is not necessarily fresh; if an already-annotated term is passed in, the same annotation value will be returned. what4(Project an annotation from an expression!It should be the case that using   on a term returned by  " returns the same annotation that   did. what4Project the original, unannotated term from an annotated term. This returns  for terms that do not have annotations, or for terms that cannot be separated from their annotations. what4Constant true predicate what4Constant false predicate what4Boolean negation what4Boolean conjunction what4Boolean disjunction what4Boolean implication what4Exclusive-or operation what4Equality of boolean values what4If-then-else on a predicate. what4Create an integer literal. what4Negate an integer. what4Add two integers. what4"Subtract one integer from another. what4 Multiply one integer by another. what4)Return the minimum value of two integers. what4)Return the maximum value of two integers. what4!If-then-else applied to integers. what4Integer equality. what4Integer less-than-or-equal. what4Integer less-than. what4)Compute the absolute value of an integer. what4 intDiv x y" computes the integer division of x by y. This division is interpreted the same way as the SMT-Lib integer theory, which states that div and mod are the unique Euclidean division operations satisfying the following for all y /= 0: y * (div x y) + (mod x y) == x  0 <= mod x y < abs y The value of  intDiv x y is undefined when y = 0.Integer division requires nonlinear support whenever the divisor is not a constant.Note: div x y is  floor (x/y) when y' is positive (regardless of sign of x) and  ceiling (x/y) when y is negative. This is neither of the more common "round toward zero" nor "round toward -inf" definitions.Some useful theorems that are true of this division/modulus pair: 'mod x y == mod x (- y) == mod x (abs y) div x (-y) == -(div x y) what4 intMod x y! computes the integer modulus of x by y. See   for more details. The value of  intMod x y is undefined when y = 0.Integer modulus requires nonlinear support whenever the divisor is not a constant. what4intDivisible x k is true whenever x8 is an integer divisible by the known natural number k. In other words `divisible x k` holds if there exists an integer z such that `x = k*z`. what42Create a bitvector with the given width and value. what4Concatenate two bitvectors. what4&Select a subsequence from a bitvector. what42's complement negation. what4Add two bitvectors. what4$Subtract one bitvector from another. what4"Multiply one bitvector by another. what4Unsigned bitvector division.The result of  bvUdiv x y is undefined when y' is zero, but is otherwise equal to floor( x / y ). what4Unsigned bitvector remainder.The result of  bvUrem x y is undefined when y' is zero, but is otherwise equal to x - (bvUdiv x y) * y. what4Returns true if the corresponding bit in the bitvector is set. what4%Return true if bitvector is negative. what4#If-then-else applied to bitvectors. what4$Return true if bitvectors are equal. what4'Return true if bitvectors are distinct. what4Unsigned less-than. what4Unsigned less-than-or-equal. what4Unsigned greater-than-or-equal. what4Unsigned greater-than. what4Signed less-than. what4Signed greater-than. what4Signed less-than-or-equal. what4Signed greater-than-or-equal. what40returns true if the given bitvector is non-zero. what4>Left shift. The shift amount is treated as an unsigned value. what4Logical right shift. The shift amount is treated as an unsigned value. what4Arithmetic right shift. The shift amount is treated as an unsigned value. what4Rotate left. The rotate amount is treated as an unsigned value. what4Rotate right. The rotate amount is treated as an unsigned value. what4Zero-extend a bitvector. what4Sign-extend a bitvector. what4Truncate a bitvector. what4Bitwise logical and. what4Bitwise logical or. what4Bitwise logical exclusive or. what4Bitwise complement. what4bvSet sym v i p returns a bitvector v' where bit i of v' is set to p7, and the bits at the other indices are the same as in v. what4bvFill sym w p returns a bitvector w?-bits long where every bit is given by the boolean value of p. what4Return the bitvector of the desired width with all 0 bits; this is the minimum unsigned integer. what4Return the bitvector of the desired width with all bits set; this is the maximum unsigned integer. what4Return the bitvector representing the largest 2's complement signed integer of the given width. This consists of all bits set except the MSB. what4Return the bitvector representing the smallest 2's complement signed integer of the given width. This consists of all 0 bits except the MSB, which is set. what4)Return the number of 1 bits in the input. what4Return the number of consecutive 0 bits in the input, starting from the most significant bit position. If the input is zero, all bits are counted as leading. what4Return the number of consecutive 0 bits in the input, starting from the least significant bit position. If the input is zero, all bits are counted as leading. what4Unsigned add with overflow bit. what4Signed add with overflow bit. Overflow is true if positive + positive = negative, or if negative + negative = positive. what4?Unsigned subtract with overflow bit. Overflow is true if x < y. what4Signed subtract with overflow bit. Overflow is true if positive - negative = negative, or if negative - positive = positive. what4Compute the carry-less multiply of the two input bitvectors. This operation is essentially the same as a standard multiply, except that the partial addends are simply XOR'd together instead of using a standard adder. This operation is useful for computing on GF(2^n) polynomials. what4unsignedWideMultiplyBV sym x y multiplies two unsigned w bit numbers x and y.%It returns a pair containing the top w+ bits as the first element, and the lower w bits as the second element. what4>Compute the unsigned multiply of two values with overflow bit. what4signedWideMultiplyBV sym x y multiplies two signed w bit numbers x and y.%It returns a pair containing the top w+ bits as the first element, and the lower w bits as the second element. what4= on two real numbers. what4Check > on two real numbers. what4If-then-else on real numbers. what4'Return the minimum of two real numbers. what4(Return the maxmimum of two real numbers. what4Negate a real number. what4Add two real numbers. what4Multiply two real numbers. what4Subtract one real from another. what4 realSq sym x returns x * x. what4realDiv sym x y returns term equivalent to x/y.The result is undefined when y is zero. what4 realMod x y returns the value of x - y * floor(x / y) when y is not zero and x when y is zero. what4 y.This test usually does NOT correspond to the not-equal tests found in programming languages. Instead, one generally takes the logical negation of the   test. what4Check if two floating point numbers are "unordered". This happens precicely when one or both of the inputs is NaN. what4Check IEEE-754 <= on two floating point numbers.1NOTE! This test returns false if either value is NaN; in particular NaN is not less-than-or-equal-to any other value! Moreover, positive and negative 0 are considered equal, despite having different bit patterns. what4Check IEEE-754 < on two floating point numbers.1NOTE! This test returns false if either value is NaN; in particular NaN is not less-than any other value! Moreover, positive and negative 0 are considered equal, despite having different bit patterns. what4Check IEEE-754 >= on two floating point numbers.1NOTE! This test returns false if either value is NaN; in particular NaN is not greater-than-or-equal-to any other value! Moreover, positive and negative 0 are considered equal, despite having different bit patterns. what4Check IEEE-754 > on two floating point numbers.1NOTE! This test returns false if either value is NaN; in particular NaN is not greater-than any other value! Moreover, positive and negative 0 are considered equal, despite having different bit patterns. what4&Test if a floating-point value is NaN. what4Test if a floating-point value is (positive or negative) infinity. what4>Test if a floating-point value is (positive or negative) zero. what4Test if a floating-point value is positive. NOTE! NaN is considered neither positive nor negative. what4Test if a floating-point value is negative. NOTE! NaN is considered neither positive nor negative. what4,Test if a floating-point value is subnormal. what4)Test if a floating-point value is normal. what4'If-then-else on floating point numbers. what40Change the precision of a floating point number. what43Round a floating point number to an integral value. what4Convert from binary representation in IEEE 754-2008 format to floating point. what4Convert from floating point from to the binary representation in IEEE 754-2008 format.NOTE! NaN has multiple representations, i.e. all bit patterns where the exponent is 0b1..1 and the significant is not 0b0..0. This functions returns the representation of positive "quiet" NaN,, i.e. the bit pattern where the sign is 0b0, the exponent is 0b1..1, and the significant is 0b10..0. what48Convert a unsigned bitvector to a floating point number. what46Convert a signed bitvector to a floating point number. what41Convert a real number to a floating point number. what48Convert a floating point number to a unsigned bitvector. what46Convert a floating point number to a signed bitvector. what41Convert a floating point number to a real number. what44Apply a special function to floating-point arguments what4,Create a complex from cartesian coordinates. what4 getRealPart x returns the real part of x. what4 getImagPart x returns the imaginary part of x. what4:Convert a complex number into the real and imaginary part. what4"Create a constant complex literal. what4#Create a complex from a real value. what4If-then-else on complex values. what4Negate a complex number. what4!Add two complex numbers together. what4)Subtract one complex number from another. what4&Multiply two complex numbers together. what4*Compute the magnitude of a complex number. what45Return the principal square root of a complex number. what4!Compute sine of a complex number. what4#Compute cosine of a complex number. what4&Compute tangent of a complex number.  cplxTan x is undefined when  cplxCos x is 0, which occurs only along the real line in the same conditions where  realCos x is 0. what4 hypotCplx x y returns sqrt(abs(x)^2 + abs(y)^2). what4 roundCplx x rounds complex number to nearest integer. Numbers with a fractional part of 0.5 are rounded away from 0. Imaginary and real parts are rounded independently. what4 cplxFloor x rounds to nearest integer less than or equal to x. Imaginary and real parts are rounded independently. what4 cplxCeil x rounds to nearest integer greater than or equal to x. Imaginary and real parts are rounded independently. what4 conjReal x, returns the complex conjugate of the input. what4(Returns exponential of a complex number. what4&Check equality of two complex numbers. what4*Check non-equality of two complex numbers. what4Symbolic natural numbers. what4This datatype describes events that involve interacting with solvers. A  SolverEvent1 will be provided to the action installed via setSolverLogListener) whenever an interesting event occurs. what4This class provides operations for recognizing when symbolic expressions represent concrete values, extracting the type from an expression, and for providing pretty-printed representations of an expression. what4"Evaluate if predicate is constant. what4-Return integer if this is a constant integer. what46Return any bounding information we have about the term what4,Return rational if this is a constant value.what41Return floating-point value if this is a constantwhat46Return any bounding information we have about the termwhat4+Return complex if this is a constant value.what43Return a bitvector if this is a constant bitvector.what4If we have bounds information about the term, return unsigned upper and lower bounds as integerswhat4If we have bounds information about the term, return signed upper and lower bounds as integerswhat4If this expression syntactically represents an "affine" form, return its components. When asAffineVar x = Just (c,r,o), then we have  x == c*r + o.what44Return the string value if this is a constant stringwhat4Return the representation of the string info for a string-typed term.what4Return the unique element value if this is a constant array, such as one made with  .what46Return the struct fields if this is a concrete struct.what4Get type of expression.what4Get the width of a bitvectorwhat40Get the precision of a floating-point expressionwhat49Print a sym expression for debugging or display purposes.what4Set the abstract value of an expression. This is primarily useful for symbolic expressions where the domain is known to be narrower than what is contained in the expression. Setting the abstract value to use the narrower domain can, in some cases, allow the expression to be further simplified.This is prefixed with unsafe- because it has the potential to introduce unsoundness if the new abstract value does not accurately represent the domain of the expression. As such, the burden is on users of this function to ensure that the new abstract value is used soundly.Note that composing expressions together can sometimes widen the abstract domains involved, so if you use this function to change an abstract value, be careful than subsequent operations do not widen away the value. As a potential safeguard, one can use   on the new expression to inhibit transformations that could change the abstract value.what4Type used to uniquely identify expressions that have been annotated.what46Type of bound variable associated with symbolic state.+This type is used by some methods in class  .what4The class for expressions.what4Symbolic strings.what4Symbolic bitvectors.what4Symbolic arrays.what4Symbolic structures.what4Symbolic complex numbers.what4 Symbolic floating point numbers.what4Symbolic real numbers.what4Symbolic integers.what4(Symbolic boolean values, AKA predicates.what4%Perform an ite on a predicate lazily.what40Return nat if this is a constant natural number.what4A natural number literal.what4Add two natural numbers.what4!Subtract one number from another.?The result is 0 if the subtraction would otherwise be negative.what4Multiply one number by another.what4 sym x y performs division on naturals.The result is undefined if y equals 0. and  satisfy the property that given , d <- natDiv sym x y m <- natMod sym x y and y > 0, we have that  y * d + m = x and m < y.what4 sym x y returns x mod y.See  for a description of the properties the return value is expected to satisfy.what4(If-then-else applied to natural numbers.what4'Equality predicate for natural numbers.what4 sym x y returns true if x <= y.what4 sym x y returns true if x < y.what4'Convert a natural number to an integer.what4+Convert a natural number to an integer. ' is just this operation lifted into IO.what47Convert the unsigned value of a bitvector to a natural.what4*Convert a natural number to a real number.what4'Convert an integer to a natural number.2For negative integers, the result is clamped to 0.what4*Convert a real number to a natural number.The result is undefined if the given real number does not represent a natural number.what4Create a fresh natural number constant with optional lower and upper bounds. If provided, the bounds are inclusive. If inconsistent bounds are given, an InvalidRange exception will be thrown.what4'Create a fresh natural number constant.what4Join a Vector of smaller bitvectors. The vector is interpreted in big endian order; that is, with most significant bitvector first.what4Split a bitvector to a Vector of smaller bitvectors. The returned vector is in big endian order; that is, with most significant bitvector first.what4"Implement LLVM's "bswap" intrinsicSee < 8https://llvm.org/docs/LangRef.html#llvm-bswap-intrinsics the LLVM bswap documentation.>&This is the implementation in SawCore: llvmBSwap :: (n :: Nat) -> bitvector (mulNat n 8) -> bitvector (mulNat n 8); llvmBSwap n x = join n 8 Bool (reverse n (bitvector 8) (split n 8 Bool x));what4*Swap the order of the bits in a bitvector.what4Create a literal from an .what4A utility combinator for combining actions that build terms with ifthenelse. If the given predicate is concretely true or false only the corresponding "then" or "else" action is run; otherwise both actions are run and combined with the given "ite" action.what4An iterated sequence of ifthenelse operations. The list of predicates and "then" results is constructed as-needed. The "default" value represents the result of the expression if none of the predicates in the given list is true.what4 Evaluates an  UnfoldPolicy on a collection of arguments.what4?This returns true if the value corresponds to a concrete value.what4Return some default value for each base type. For numeric types, this is 0; for booleans, false; for strings, the empty string. Structs are filled with default values for every field, default arrays are constant arrays of default values.what4)Return predicate equivalent to a Boolean.what4Create a value from a rational.what4Create a value from an integer.what4/Return 1 if the predicate is true; 0 otherwise.what4Extract the value of a rational expression; fail if the value is not a constant.what4Extract the value of a complex expression, which is assumed to be a constant real number. Fail if the number has nonzero imaginary component, or if it is not a constant.what4:Return a complex value as a constant integer if it exists.what40Return value as a constant integer if it exists.what40Return value as a constant integer if it exists.what44Compute the conjunction of a sequence of predicates.what44Compute the disjunction of a sequence of predicates.what41Return predicate that holds if value is non-zero.what4Return predicate that holds if imaginary part of number is zero.what4Divide one number by another. cplxDiv x y is undefined when y is 0.what4>Helper function that returns the principal logarithm of input.what43Returns the principal logarithm of the input value. cplxLog x is undefined when x is 0>, and has a cut discontinuity along the negative real line.what4+Returns logarithm of input at a given base.cplxLogBase b x is undefined when x is 0.what4Return a concrete representation of a value, if it is concrete.what46Create a literal symbolic value from a concrete value.what4This function is used for selecting a value from among potential values in a range.muxRange p ite f l h returns an expression denoting the value obtained from the value f i where i$ is the smallest value in the range [l..h] such that p i is true. If p i8 is true for no such value, then this returns the value f h. what4 An alias for  minUnsignedBv.Useful in contexts where you want to convey the zero-ness of the value more than its minimality.what4=<;:0123456789./*+,-PQRST              1 Safe-Inferred)*/01^)what4Fork an async action that is linked to the parent thread, but can be safely )d without also killing the parent thread.Note that if your async doesn't return unit, then you probably want to  for it instead, which eliminates the need for linking it. Also, if you plan to cancel the async near where you fork it, then  is a better choice than using this function and subsequently canceling, since it ensures cancellation.See  +https://github.com/simonmar/async/issues/25 for a perhaps more robust, but also harder to use version of this. The linked version is harder to use because it requires a special version of cancel.what4Handle asynchronous  exceptions without killing the parent thread. All other forms of asynchronous exceptions are rethrown.what4 A version of # that safely links the child. See .what4Try converting any  into a *. If it is an invalid symbol, then error.2"Dynamically-sized bitvector valuesGalois, Inc. 2018-2020BSD3rdockins@galois.com experimental"non-portable (language extensions) Safe-Inferred)*/019:;rJ2what4/type of binary operation that returns a booleanwhat41type of binary operation that returns a bitvectorwhat4%Type of unary operation on bitvectorswhat4A What4 symbolic bitvector where the size does not appear in the typewhat47Return the signed value if this is a constant bitvectorwhat49Return the unsigned value if this is a constant bitvectorwhat4Convert an integer to an unsigned bitvector. The input value is reduced modulo 2^w.what4/Interpret the bit-vector as an unsigned integerwhat4,Interpret the bit-vector as a signed integerwhat4Get the width of a bitvectorwhat41Create a bitvector with the given width and valuewhat4Returns true if the corresponding bit in the bitvector is set. NOTE bits are numbered in big-endian ordering, meaning the most-significant bit is bit 0what4Returns true if the corresponding bit in the bitvector is set. NOTE bits are numbered in little-endian ordering, meaning the least-significant bit is bit 0what4Set the numbered bit in the given bitvector to the given bit value. NOTE bits are numbered in big-endian ordering, meaning the most-significant bit is bit 0what4Set the numbered bit in the given bitvector to the given bit value. NOTE bits are numbered in big-endian ordering, meaning the most-significant bit is bit 0what4Concatenate two bitvectors.what4Select a subsequence from a bitvector, with bits numbered in Big Endian order (most significant bit is 0). This fails if idx + n is >= wwhat4Select a subsequence from a bitvector, with bits numbered in Little Endian order (least significant bit is 0). This fails if idx + n is >= wwhat4,Ceiling (log_2 x) adapted from saw-core-sbvsrcVerifierSAWSimulator/SBV.hswhat4#If-then-else applied to bitvectors.what4Explode a bitvector into a vector of booleans in Big Endian order (most significant bit first)what4Explode a bitvector into a vector of booleans in Little Endian order (least significant bit first)what4convert a vector of booleans to a bitvector. The input are used in Big Endian order (most significant bit first)what4convert a vector of booleans to a bitvector. The inputs are used in Little Endian order (least significant bit first)what4Convert a unary operation on length indexed bvs to a unary operation on what40convert binary operations that return bitvectorswhat45convert binary operations that return booleans (Pred)what4Bitwise complementwhat4Bitwise logical and.what4Bitwise logical or.what4Bitwise logical exclusive or.what42's complement negation.what4Add two bitvectors.what4$Subtract one bitvector from another.what4"Multiply one bitvector by another.what4Unsigned bitvector division.The result is undefined when y' is zero, but is otherwise equal to floor( x / y ).what4Unsigned bitvector remainder.The result is undefined when y' is zero, but is otherwise equal to x - (bvUdiv x y) * y.what4 Safe-Inferred")*01679:;<*what4A partial value represents a value that may or may not be valid.The  field represents a predicate (optionally with additional provenance information) embodying the value's partiality.what4/Either a partial value, or a straight-up error.what4 Create a 0 expression from a value that is always defined.what4A monad transformer which enables symbolic partial computations to run by maintaining a predicate on the value.what4A  is a  that provides no information about what went wrong. Its name is historic.what4=Create a part expression from a value that is always defined.what4,Create a part expression from a maybe value.what4 = ab .what4$If-then-else on partial expressions.what4Merge a collection of partial values in an if-then-else tree. For example, if we merge a list like [(xp,x),(yp,y),(zp,z)]6, we get a value that is morally equivalent to: if xp then x else (if yp then y else (if zp then z else undefined)).what4Run a partial computation.what4End the partial computation and just return the unassigned value.what4Lift a  value to a partial expression.what4Return a partial expression.This joins the partial expression with the current constraints on the current computation.what4:Add an extra condition to the current partial computation.what4'Operation to combine inner values. The 3 parameter is the if-then-else condition. what4condition to merge on what4'if' value what4'then' value what40Operation to combine inner values. The ) parameter is the if-then-else condition.what4values to merge what4Solver interfacewhat4Initial conditionwhat4Computation to run.5/Predicates with some metadata (a tag or label).(c) Galois, Inc 2019-2020BSD3&Langston Barrett  provisional Safe-Inferred 79:;<what48Information about an assertion that was previously made.what4Predicate that was asserted.what41Message added when assumption/assertion was made.what4Predicate that was asserted.what41Message added when assumption/assertion was made.what4Partition datastructures containing predicates by their possibly concrete values.The output format is (constantly true, constantly false, unknown/symbolic).what4Partition datastructures containing predicates by their possibly concrete values.The output format is (constantly true, constantly false, unknown/symbolic).what4?Partition labeled predicates by their possibly concrete values.The output format is (constantly true, constantly false, unknown/symbolic).what4'avoid "ambiguous type variable" errors what4'avoid "ambiguous type variable" errors what4'avoid "ambiguous type variable" errors  6 Safe-Inferred)*1y6what4A family of value-level representatives for floating-point types.what4This data kind describes the types of floating-point formats. This consist of the standard IEEE 754-2008 binary floating point formats, as well as the X86 extended 80-bit format and the double-double format.what4Helper interface for creating new symbolic floating-point constants and variables.what4?Create a fresh top-level floating-point uninterpreted constant.what4-Create a fresh floating-point latch variable.what4(Creates a floating-point bound variable.what4"Abstact floating point operations.what4Return floating point number +0.what4Return floating point number -0.what4Return floating point NaN.what4Return floating point  +infinity.what4Return floating point  -infinity.what48Create a floating point literal from a rational literal.what43Create a (single precision) floating point literal.what43Create a (double precision) floating point literal.what4=Create an (extended double precision) floating point literal.what4Negate a floating point number.what45Return the absolute value of a floating point number.what43Compute the square root of a floating point number.what4Add two floating point numbers.what4$Subtract two floating point numbers.what4$Multiply two floating point numbers.what4"Divide two floating point numbers.what4Compute the reminder:  x - y * n, where n in Z is nearest to x / y.what4-Return the min of two floating point numbers.what4-Return the max of two floating point numbers.what4/Compute the fused multiplication and addition:  (x * y) + z.what45Check logical equality of two floating point numbers.what49Check logical non-equality of two floating point numbers.what42Check IEEE equality of two floating point numbers.what43Check IEEE apartness of two floating point numbers.what4Check <= on two floating point numbers.what4Check < on two floating point numbers.what4Check >= on two floating point numbers.what4Check > on two floating point numbers.what4'If-then-else on floating point numbers.what40Change the precision of a floating point number.what43Round a floating point number to an integral value.what4Convert from binary representation in IEEE 754-2008 format to floating point.what4Convert from floating point from to the binary representation in IEEE 754-2008 format.what48Convert a unsigned bitvector to a floating point number.what46Convert a signed bitvector to a floating point number.what41Convert a real number to a floating point number.what48Convert a floating point number to a unsigned bitvector.what46Convert a floating point number to a signed bitvector.what41Convert a floating point number to a real number.what44Apply a special function to floating-point argumentswhat4*Access a 0-arity special function constantwhat4#Apply a 1-argument special functionwhat4#Apply a 2-argument special functionwhat4The associated BaseType representative of the floating point interpretation for each format.what4 Symbolic floating point numbers.what4*Interpretation of the floating point type.what4Representation of 80-bit floating values, since there's no native Haskell type for these.what45Two 64-bit floats fused in the "double-double" style.what4X86 80-bit extended floats.what4128 bit binary IEEE754.what464 bit binary IEEE754.what432 bit binary IEEE754.what416 bit binary IEEE754.7"A "unary" bitvector representation(c) Galois, Inc 2015-2020BSD3!Joe Hendrix  Safe-Inferred )*1what4A unary bitvector encoding where the map contains predicates such as u^.unaryBVMap^.at i$ holds iff the value represented by u is less than or equal to i.The map stored in the representation should always have a single element, and the largest integer stored in the map should be associated with a predicate representing "true". This means that if the map contains only a single binding, then it represents a constant.what4 splitLeq k m returns a pair (l,h) where l= contains all the bindings with a key less than or equal to k, and h contains the ones greater than k.what4Split a map into a lower bound, midpoint, and upperbound if non-empty.what4This function eliminates entries where the predicate has the same value.what49Returns the number of distinct values that this could be.what4.Create a unary bitvector term from a constant.what4.Create a unary bitvector term from a constant.what4unsignedRanges v returns a set of predicates and ranges where we know that for each entry (p,l,h) and each value i : l <= i & i <= h: p iff. v <= iwhat4Evaluate a unary bitvector as an integer given an evaluation function.what48Evaluate a unary bitvector given an evaluation function.This function is used to convert a unary bitvector into some other representation such as a binary bitvector or vector of bits.'It is polymorphic over the result type r:, and requires functions for manipulating values of type r to construct it.what4This function instantiates the predicates in a unary predicate with new predicates. The mapping f1 should be monotonic, that is for all predicates p and 'q, such that 'p |- q', f1 should satisfy the constraint that 'f p |- f q'.what4,Return potential values for abstract domain.what4This merges two maps used for a unary bitvector int a single map that combines them./'mergeWithKey sym cfn x y' should return a map z such that for all constants c$, 'z = c' iff 'cfn (x = c) (y = c)'.what4 mux sym c x y returns value equal to if c then x else y8. The number of entries in the return value is at most size x + size y.what44Return predicate that holds if bitvectors are equal.what4compareLt sym x y* returns predicate that holds if for any k, x < k & not (y <= k).what4>Return predicate that holds if first value is less than other.what4>Return predicate that holds if first value is less than other.what4Add two bitvectors.The number of integers in the result will be at most the product of the sizes of the individual bitvectors.what4Negate a bitvector. The size of the result will be equal to the size of the input.what4Perform a unsigned extensionwhat4Perform a signed extensionwhat4Perform a struncation.what4Function for mapping an integer to its bitvector representation.what4Function for performing an ite expression on r.what4Unary bitvector to evaluate.what4Map to merge intowhat4&Monotonic function to update keys withwhat4Function on predicate.8/Datastructure for sequences of appended strings(c) Galois Inc, 2019-2020BSD3rdockins@galois.com Safe-Inferred )*1what4Annotation value for string sequences. First value is the XOR hash of the sequence Second value is the string abstract domain.  98Low-level support for MATLAB-style arithmetic operations(c) Galois, Inc, 2016-2020BSD3!Joe Hendrix  Safe-Inferred)*1 what4Builtin functions that can be used to generate symbolic functions.These functions are expected to be total, but the value returned may not be specified. e.g. IntegerToNatFn must return some natural number for every integer, but for negative integers, the particular number is unspecified.what43Compute the clamped negation of a signed bitvector.The only difference between this operation and the usual 2's complement negation function is the handling of MIN_INT. The usual 2's complement negation sends MIN_INT to MIN_INT; however, the clamped version instead sends MIN_INT to MAX_INT.what49Compute the clamped absolute value of a signed bitvector.The only difference between this operation and the usual 2's complement operation is the handling of MIN_INT. The usual 2's complement absolute value function sends MIN_INT to MIN_INT; however, the clamped version instead sends MIN_INT to MAX_INT.what4This class is provides functions needed to implement the symbolic array intrinsic functionswhat43Create a Matlab solver function from its prototype.what4-Utilities to make a pair with the same value.what4Get arg tpyes of solver fn.what4Get return type of solver fn.what4Test  values for equality.:(c) Galois Inc, 2015-2020BSD3jhendrix@galois.com Safe-Inferred!"()*01<!'what4This represents a symbolic function in the simulator. Parameter t4 is a phantom type brand used to track nonces. The args and ret parameters define the types of arguments and the return type of the function.Type  t (Expr t) instantiates the type family   ( ExprBuilder t st).what4This describes information about an undefined or defined function. Parameter t4 is a phantom type brand used to track nonces. The args and ret parameters define the types of arguments and the return type of the function.what4Information about the argument type and return type of an uninterpreted function.what4Information about a defined function. Includes bound variables and an expression associated to a defined function, as well as a policy for when to unfold the body.what4This is a function that corresponds to a matlab solver function. It includes the definition as a ExprBuilder expr to enable export to other solvers.what4Type NonceApp t e tp* encodes the top-level application of an . It includes expression forms that bind variables (contrast with ). Parameter t: is a phantom type brand used to track nonces. Parameter e is used everywhere a recursive sub-expression would go. Uses of the ; type will tie the knot through this parameter. Parameter tp& indicates the type of the expression.what4.Information about bound variables. Parameter t. is a phantom type brand used to track nonces.Type  t instantiates the type family  ( ExprBuilder t st).,Selector functions are provided to destruct  values, but the constructor is kept hidden. The preferred way to construct a  is to use  .what4The Kind of a bound variable.what4%A variable appearing in a quantifier.what4&A variable appearing as a latch input.what40A variable appearing in a uninterpreted constantwhat4Type  e tp) encodes the top-level application of an  expression. It includes first-order expression forms that do not bind variables (contrast with ). Parameter e is used everywhere a recursive sub-expression would go. Uses of the ; type will tie the knot through this parameter. Parameter tp& indicates the type of the expression.what4The main ExprBuilder expression datastructure. The non-trivial Expr values constructed by this module are uniquely identified by a nonce value that is used to explicitly represent sub-term sharing. When traversing the structure of an Expr it is usually very important to memoize computations based on the values of these identifiers to avoid exponential blowups due to shared term structure.Type parameter t is a phantom type brand used to relate nonces to a specific nonce generator (similar to the s parameter of the ST monad). The type index tp of kind K indicates the type of the values denoted by the given expression.Type  t instantiates the type family  ( ExprBuilder t st).what4This type represents  values that were built from an . Parameter t. is a phantom type brand used to track nonces.,Selector functions are provided to destruct  values, but the constructor is kept hidden. The preferred way to construct an  from an  is to use  sbMakeExpr.what4This type represents  values that were built from a . Parameter t. is a phantom type brand used to track nonces.,Selector functions are provided to destruct  values, but the constructor is kept hidden. The preferred way to construct an  from a  is to use  sbNonceExpr.what4!Either a argument or text or textwhat4Contains the elements before, the index, doc, and width and the elements after.what4A fixed doc with length.what4A doc that can be let bound.what4 AppPPExpr6 represents a an application, and it may be let bound.what4.Length of AppPPExpr not including parenthesis.what4This privides a view of a semiring expr as a weighted sum of values.what4+Used to implement foldMapFc from traversal.what4$Check if two applications are equal.what4Hash an an application.what4Return true if an app represents a non-linear operation. Controls whether the non-linear counter ticks upward in the  .what4Destructor for the  constructor.what4Destructor for the  constructor.what4+Get abstract value associated with element.what4A slightly more aggressive syntactic equality check than testEquality,  will recurse through a small collection of known syntax formers.what4Pretty print a AppPPExprwhat4$Get length of Expr including parens.what4Pretty print PPExprwhat4Pretty print an ' using let bindings to create the term.what4(Pretty print the top part of an element.what48Return solver function associated with ExprSymFn if any.what4'Return an unconstrained abstract value.what42Return abstract domain associated with a nonce appwhat45Pretty print a code to identify the type of constant.;;Identifying the solver theory required by a core expression(c) Galois, Inc 2016-2020BSD3!Joe Hendrix  provisional Safe-Inferred)*ɡwhat4$The theory that a symbol belongs to.what4;Theory attributed to structs (equivalent to records in CVC4CVC5Z3, tuples in Yices)what4(Theory attributed application functions.<=Compute the bound and free variables appearing in expressions(c) Galois, Inc 2015-2020BSD3!Rob Dockins  provisional Safe-Inferred ()*1Ӏwhat47Information about bound variables outside this context.what4$List of errors found during parsing.what4Contains all information about a bound variable appearing in the expression.what45The outer term containing the binding (e.g., Ax.f(x))what4#The type of quantifier that appearswhat4The variable that is bound Variables may be bound multiple times.what4)The term that appears inside the binding.what4Describes types of functionality required by solver based on the problem.what4Expressions appearing in the problem as existentially quantified when the problem is expressed in negation normal form. This is a map from the existential quantifier element to the info.what4Expressions appearing in the problem as existentially quantified when the problem is expressed in negation normal form. This is a map from the existential quantifier element to the info.what48Return variables needed to define element as a predicatewhat47Main definitions of the What4 expression representation(c) Galois Inc, 2015-2020BSD3jhendrix@galois.com Safe-Inferred!"()*/01<;what4This decomposes A ExprBuilder array expression into a set of indices that have been updated, and an underlying index.what4 and the associated code implement bidirectional bitvector (BV) to/from linear integer arithmetic (LIA) transformations. This is done by replacing all BV operations with LIA operations, replacing all BV variables with LIA variables, and by replacing all BV function symbols with LIA function symbols. The reverse transformation works the same way, but in reverse. This transformation is not sound, but in practice it is useful.This is used to implement   and  ', which in turn are used to implement  runZ3Horn.0This is highly experimental and may be unstable.what4+Data structure used for caching evaluation.what4The CachedSymFn is used during evaluation to store the results of reducing the definitions of symbolic functions.0For each function it stores a pair containing a  that is true if the function changed as a result of evaluating it, and the reduced function after evaluation.The second arguments contains the arguments with the return type appended.what41An IdxCache is used to map expressions with type  Expr t tp& to values with a corresponding type f tp . It is a mutable map using an  hash table. Parameter t/ is a phantom type brand used to track nonces.what4(Cache for storing dag terms. Parameter t. is a phantom type brand used to track nonces.what4Constant zero.what4.Configuration object for this symbolic backendwhat4Flag used to tell the backend whether to evaluate ground rational values as double precision floats when a function cannot be evaluated as a rational.what4The maximum number of distinct values a term may have and use the unary representation.what4+The starting size when building a new cachewhat4If enabled, push certain  operations (e.g., zext) down to the branches of ite expressions. In some (but not all) circumstances, this can result in operations that are easier for SMT solvers to reason about.what4Counter to generate new unique identifiers for elements and functions.what4/Reference to current allocator for expressions.what4Number of times an . for a non-linear operation has been created.what4The current program locationwhat4User-provided statewhat4Cache for Matlab functionswhat4Flag dictating how floating-point values/operations are translated when passed to the solver.what4This describes what a given SolverSymbol is associated with. Parameter t. is a phantom type brand used to track nonces.what4Solverwhat4A bijective map between vars and their canonical name for printing purposes. Parameter t. is a phantom type brand used to track nonces.what4Empty symbol var bimapwhat4Return a new expr builder where the configuration object has been "split" using the  splitConfig operation. The returned sym will share any preexisting options with the input sym, but any new options added with  extendConfig will not be shared. This may be useful if the expression builder needs to be shared across threads, or sequentially for separate use cases. Note, however, that hash consing settings, solver loggers and the current program location will be shared.what4Return a new expr builder where all configuration settings have been isolated from the original. The Config object of the output expr builder will have only the default options that are installed via newExprBuilder, and configuration changes to either expr builder will not be visible to the other. This includes caching settings, the current program location, and installed solver loggers.what4Create a new IdxCachewhat45Return the value associated to the expr in the index.what4.Bind the value to the given expr in the index.what4 Remove a value from the IdxCachewhat4#Remove all values from the IdxCachewhat4Implements a cached evaluated using the given element. Given an element this function returns the value of the element if bound, and otherwise calls the evaluation function, stores the result in the cache, and returns the value.what4Implements a cached evaluated using the given element. Given an element this function returns the value of the element if bound, and otherwise calls the evaluation function, stores the result in the cache, and returns the value.what4#Create an element from a nonce app.what44Update the binding to point to the current variable.what4Creates a new bound var.what4Create fresh indexwhat45Maximum number of values in unary bitvector encoding..This option is named "backend.unary_threshold"what4The configuration option for setting the maximum number of values a unary threshold may have.what4%If this option enabled, push certain  operations (e.g., zext) down to the branches of ite expressions. In some (but not all) circumstances, this can result in operations that are easier for SMT solvers to reason about. The expressions that may be pushed down are determined on a case-by-case basis in the   instance for 9, but this control applies to all such push-down checks.,This option is named "backend.push_mux_ops".what4The   for .what4Get current variable bindings.what4%Stop caching applications in backend.what4Restart caching applications in backend (clears cache if it is currently caching).what4=This evaluate a symbolic function against a set of arguments.what4This runs one action, and if it returns a value different from the input, then it runs the second. Otherwise it returns the result value passed in.It is used when an action may modify a value, and we only want to run a second action if the value changed.what4This adds a binding from the variable to itself in the hashtable to ensure it can't be rebound.what4Evaluate a simple function.This returns whether the function changed as a Boolean and the function itself.what4This evaluates the term with the given bound variables rebound to the given arguments.The algorithm works by traversing the subterms in the term in a bottom-up fashion while using a hash-table to memoize results for shared subterms. The hash-table is pre-populated so that the bound variables map to the element, so we do not need any extra map lookup when checking to see if a variable is bound.NOTE: This function assumes that variables in the substitution are not themselves bound in the term (e.g. in a function definition or quantifier). If this is not respected, then  will call  with an error message.what45This attempts to lookup an entry in a symbolic array.*It patterns maps on the array constructor.what4Simplify an array lookup expression by slicing the array w.r.t. the index.Remove array update, copy and set operations at indices that are different from the lookup index.what4*Evaluate a weighted sum of integer values.what4'Evaluate a weighted sum of real values.what4This create a unary bitvector representing if the size is not too large.what4 Construct an  for an element.what4 Construct an  for an element.what4Return set of addresss in assignment that are written to by at least one exprwhat4Examine the list of terms, and determine if any one of them appears in the given BoolMap with the same polarity.what4If tryAndAbsorption x y returns True, that means that y implies x, so that the conjunction  x AND y = y. A False result gives no information.what4If tryOrAbsorption x y returns True, that means that x implies y, so that the disjunction  x OR y = y. A False result gives no information.what4Float interpretation mode (i.e., how are floats translated for the solver).what4(Initial state for the expression builderwhat4Nonce generator for nameswhat4First action to runwhat4Result if no change.what4Second action to runwhat4"Simple builder for creating terms.what4Array to lookup value in.what4A concrete index that corresponds to the index or nothing if the index is symbolic.what4The index to lookup.what4#recursive call for simplifications what4#recursive call for simplifications z{|}~ z{|}~ ? Safe-Inferred")*01!what4Necessary monadic operationswhat4All module inputs, in reverse order. We use Word64 for Nonces to avoid GHC bugs. For more detail:  0https://gitlab.haskell.org/ghc/ghc/-/issues/2595  1https://gitlab.haskell.org/ghc/ghc/-/issues/10856 1https://gitlab.haskell.org/ghc/ghc/-/issues/16501what4All module outputs, in reverse order. Includes the type, signedness, name, and initializer of each.what4All internal wires, in reverse order. Includes the type, signedness, name, and initializer of each.what4A map from the identifier nonces seen so far to their identifier names. These nonces exist for identifiers from the original term, but not intermediate Verilog variables.what4A set of all the identifiers used so far, including intermediate Verilog variables.what4An expression cache to preserve sharing present in the What4 representation.what4A cache of bit vector constants, to avoid duplicating constant declarations.what4A cache of Boolean constants, to avoid duplicating constant declarations.what4'The What4 symbolic backend to use with .what4;A data type for items that may show up in a Verilog module.what4A wrapper around the BV type allowing it to be put into a map or set. We use this to make sure we generate only one instance of each distinct constant.what4A type for Verilog expressions that enforces well-typedness, including bitvector size constraints.what4A type for Verilog expression names that enforces well-typedness. This type exists essentially to pair a name and type to avoid needing to repeat them and ensure that all uses of the name are well-typed.what4A type for Verilog unary operators that enforces well-typedness.what4A type for Verilog binary operators that enforces well-typedness, including bitvector size constraints.what4Create a let binding, associating a name with an expression. In Verilog, this is a new "wire".what4Indicate than an expression name is signed. This causes arithmetic operations involving this name to be interpreted as signed operations.what4Apply a binary operation to two expressions and bind the result to a new, returned name.what4A special binary operation for scalar multiplication. This avoids the need to call  at every call site.what4Return the (possibly-cached) name for a literal bitvector value.what4>Return the (possibly-cached) name for a literal Boolean value.what4Apply a unary operation to an expression and bind the result to a new, returned name.what4Create a conditional, with the given condition, true, and false branches, and bind the result to a new, returned name.what4Extract a single bit from a bit vector and bind the result to a new, returned name.what4Extract a range of bits from a bit vector and bind the result to a new, returned name. The two NatRepr values are the starting index and the number of bits to extract, respectively.what4Concatenate two bit vectors and bind the result to a new, returned name.what4Create a Verilog module in the context of a given What4 symbolic backend and a monadic computation that returns an expression name that corresponds to the module's output.what4Returns and records a fresh input with the given type and with a name constructed from the given base.what4Add an output to the current Verilog module state, given a type, a name, and an initializer expression.what4Add a new wire to the current Verilog module state, given a type, a signedness flag, a name, and an initializer expression.what4Create a fresh identifier by concatenating the given base with the current fresh identifier counter.what4Add a new wire to the current Verilog module state, given a type, a signedness flag, the prefix of a name, and an initializer expression. The name prefix will be freshened by appending current value of the fresh variable counter.@ Safe-Inferred")*01what4Convert a What4 expresssion into a Verilog expression and return a name for that expression's result.A Safe-Inferred"()*Kwhat4.Show non-negative Integral numbers in base 16.  B Safe-Inferredwhat4Convert the given What4 expressions, representing the outputs of a circuit, into a textual representation of a Verilog module of the given name.what4Convert the given What4 expressions, representing the outputs of a circuit, into a Verilog module of the given name.C?Simplification procedure for distributing operations through ifthenelse(c) Galois, Inc 2016-2020BSD3!Joe Hendrix  Safe-Inferred ()*0what47Simplify a Boolean expression by distributing over ite.what4Record an element occurs, and return condition indicating if it is new.what4Return a map from nonce indices to the number of times an elt with that nonce appears in the subterm.D?Computing ground values for expressions from solver assignments(c) Galois, Inc 2016-2020BSD3!Joe Hendrix  provisional Safe-Inferred014what4)A representation of a ground-value array.what4%Lookup function for querying by indexwhat42Default value and finite map of particular indiceswhat49A newtype wrapper around ground value for use in a cache.what4Function that calculates upper and lower bounds for real-valued elements. This type is used for solvers (e.g., dReal) that give only approximate solutions.what4A function that calculates ground values for elements. Clients of solvers should use the  groundEval, function for computing values in models.what4$Look up an index in an ground array.what4Update a ground array.what4-Convert a real standardmodel val to a double.what40Construct a default value for a given base type.what4Helper function for evaluating Expr expressions in a model.This function is intended for implementers of symbolic backends.what4Evaluate an element, when given an evaluation function for subelements. Instead of recursing directly,  calls into the given function on sub-elements to allow the caller to cache results if desired.However, sometimes we are unable to compute expressions outside the solver. In these cases, this function will return  in the `MaybeT IO` monad. In these cases, the caller should instead query the solver directly to evaluate the expression, if possible.what4Helper function for evaluating NonceApp expressions.This function is intended for implementers of symbolic backends.what4Helper function for evaluating App expressions.This function is intended for implementers of symbolic backends.EDefines the low-level interface between a particular solver and the SimpleBuilder family of backends.(c) Galois, Inc 2015-2020BSD3!Rob Dockins  provisional Safe-Inferred$R what4A collection of operations for producing output from solvers. Solvers can produce messages at varying verbosity levels that might be appropriate for user output by using the  operation. If a  is provided, the entire interaction sequence with the solver will be mirrored into that handle.what4&takes a verbosity and a message to logwhat4+the default verbosity; typical default is 2what4'the reason for performing the operationwhat40handle on which to mirror solver input/responseswhat4The main interface for interacting with a solver in an "offline" fashion, which means that a new solver process is started for each query.what45Configuration options relevant to this solver adapterwhat4Operation to check the satisfiability of a formula. The final argument is a callback that calculates the ultimate result from a SatResult and operations for finding model values in the event of a SAT result. Note: the evaluation functions may cease to be avaliable after the callback completes, so any necessary information should be extracted from them before returning.what4Write an SMTLib2 problem instance onto the given handle, incorporating any solver-specific tweaks appropriate to this solverwhat41Default featues to use for writing SMTLIB2 files.what4Test the ability to interact with a solver by peforming a check-sat query on a trivially unsatisfiable problem.FInfrastructure for rendering What4 expressions in the language of SMT solvers(c) Galois, Inc 2014-2020.BSD3!Joe Hendrix  Safe-Inferred")*01kwhat48Used when we need two way communication with the solver.what43Get functions for parsing values out of the solver.what4.Parse a set result from the solver's response.what4Parse a list of names of assumptions that form an unsatisfiable core. These correspond to previously-named assertions.what42Parse an abduct returned by the get-abduct commandwhat47Parse an abduct returned by the get-abduct-next commandwhat4Parse a list of names of assumptions that form an unsatisfiable core. The boolean indicates the polarity of the atom: true for an ordinary atom, false for a negated atom.what4Given a SMT term for a Boolean value, this should return an indication of whether the term is assigned true or false.what4Given a bitwidth, and a SMT term for a bitvector with that bitwidth, this should return an unsigned integer with the value of that bitvector.what4Given a SMT term for real value, this should return a rational value for that term.what4Given floating point format, and an SMT term for a floating-point value in that format, this returns an unsigned integer with the bits of the IEEE-754 representation.what4If , a function to read arrays whose domain and codomain are both bitvectors. If , signifies that we should fall back to index-selection representation of arrays.what4Given a SMT term representing as sequence of bytes, return the value as a bytestring.what4?This generates an error message from a solver and a type error.It issed for error reportingwhat4=This describes the result that was collected from the solver.what4"Result from sandboxed computation.what4List of bound variables.what4"Constants added during generation.what41List of Boolean predicates asserted by collector.what4The SMT term collectorwhat4#The state of a side collector monad6This has predicate for introducing new bound variableswhat4'freshBoundTerm nm args ret_type ret' will record that 'nm(args) = ret' ret_type should be the type of ret.what4Called when we need to need to assert a predicate about some variables.what41Function for create a new name given a base type.what4+Typeclass need to generate SMTLIB commands.what4Create a forall expressionwhat4Create an exists expressionwhat4Create a constant arrayThis may return Nothing if the solver does not support constant arrays.what4Select an element from an arraywhat49'arrayUpdate a i v' returns an array that contains value v at index i, and the same value as in a at every other index.what4-Create a command that just defines a comment.what4(Create a command that asserts a formula.what4Create a command that asserts a formula and attaches the given name to it (primarily for the purposes of later reporting unsatisfiable cores).what4Generates command (push 1)- that opens the corresponding assertion framewhat4Generates command (pop 1). that closes the corresponding assertion framewhat4Generates command (push 2)- that opens the corresponding assertion framewhat4Generates command (pop 2) that closes the corresponding assertion frame, used for abductionwhat4Pop several scopes.what4Reset the solver state, forgetting all pushed frames and assertionswhat4Check if the current set of assumption is satisfiable. May require multiple commands. The intial commands require an ack. The last one does not.what4Check if a collection of assumptions is satisfiable in the current context. The assumptions must be given as the names of literals already in scope.what4Ask the solver to return an unsatisfiable core from among the assumptions passed into the previous "check with assumptions" command.what4Ask the solver to return an unsatisfiable core from among the named assumptions previously asserted using the  after an unsatisfiable  checkCommand.what4"Ask the solver to return an abductwhat4Ask the solver for the next abduct, used after a get-abduct commandwhat4Set an option/parameter.what4Declare a new symbol with the given name, arguments types, and result type.what4Define a new symbol with the given name, arguments, result type, and associated expression.The argument contains the variable name and the type of the variable.what4Declare a new SyGuS function to synthesize with the given name, arguments, and result type.what4Declare a new SyGuS universal variables with the given name and type.what48Add a SyGuS formula to the set of synthesis constraints.what4Declare a struct datatype if is has not been already given the number of arguments in the struct.what43Build a struct term with the given types and fieldswhat42Project a field from a struct with the given typeswhat4,Produce a term representing a string literalwhat4Compute the length of a termwhat4stringIndexOf s t i5 computes the first index following or at i where t appears within s1 as a substring, or -1 if no such index existswhat43Test if the first string contains the second stringwhat49Test if the first string is a prefix of the second stringwhat49Test if the first string is a suffix of the second stringwhat4stringSubstring s off len extracts the substring of s starting at index off and having length len0. The result of this operation is undefined if off and len( to not specify a valid substring of s; in particular, we must have off+len <= length(s).what4Append the given stringswhat4,Forget all previously-declared struct types.what4"Write a command to the connection.what44Status to indicate when term value will be uncached.what4Never delete the termwhat41Delete the term when the current frame is popped.what4.Strictness level for parsing solver responses.what4:allows other output preceeding recognized solver responseswhat4?parse _only_ recognized solver responses; fail on anything elsewhat4An action for consuming an acknowledgement message from the solver, if it is configured to produce ack messages.what4,Name of writer for error reporting purposes.what4Handle to write towhat4Handle to read responses from. In some contexts, there are no responses expected (e.g., if we are writing a problem directly to a file); in these cases, the input stream might be the trivial stream  nullInput(, which just immediately returns EOF.what4Indicates if the writer can define constants or functions in terms of an expression.If this is not supported, we can only declare free variables, and assert that they are equal.what48Functions may be passed as arguments to other functions.We currently never allow SMT_FnType to appear in structs or array indices.what4;Allow the SMT writer to generate problems with quantifiers.what4Be strict in parsing SMTLib2 responses; no verbosity or variants allowedwhat4+Indicates features supported by the solver.what4A stack of pairs of hash tables, each stack entry corresponding to a lexical scope induced by frame push/pops. The entire stack is searched top-down when looking up element nonce values. Elements that are to persist across pops are written through the entire stack.what4Reference to current statewhat4Symbol variables.what4$The specific connection information.what4Consume an acknowledgement notifications the solver, if it produces onewhat4State for writer.what4An expresion for the SMT solver together with information about its type.what4A term in the output language.what45A class of values containing rational and operations.what4"Compare two elements for equality.what4%Compare two elements for in-equality.what4Create a let expression. This is a "sequential" let, which is syntactic sugar for a nested series of single let bindings. As a consequence, bound variables are in scope for the right-hand-sides of subsequent bindings.what4"Create an if-then-else expression.what4Add a list of values together.what4(Convert an integer expression to a real.what4(Convert a real expression to an integer.what4Convert an integer to a term.what4Convert a rational to a term.what4Less-then-or-equalwhat4 Less-thenwhat4 Greater thenwhat4Greater then or equalwhat4Integer theory termswhat4!Create expression from bitvector.what4$Concatenate two bitvectors together.what4bvExtract w i n v extracts bits [i..i+n) from v as a new bitvector. v must contain at least w elements, and i+n must be less than or equal to w. The result has n) elements. The least significant bit of v should have index 0.what4bvTestBit w i x% returns predicate that holds if bit i in x is set to true. w! should be the number of bits in x.what44Predicate that holds if a real number is an integer.what4*Apply the arguments to the given function.what4Update a function value to return a new value at the given point.This may be Nothing if solver has no builtin function for update.what4:Function for creating a lambda term if output supports it.Yices support lambda expressions, but SMTLIB2 does not. The function takes arguments and the expression.what4 defines how a given K maps to an SMTLIB type.It is necessary as there may be several ways in which a base type can be encoded.what4%Converts an SMT to a base expression.what4The next index to use in dynamically generating a variable name.what4Last position written to file.what4Position written to file.what4Create a new variableVariable names have a prefix, an exclamation mark and a unique number. The MSS system ensures that nowhat4Create a new variableVariable names have a prefix, an exclamation mark and a unique number. The MSS system ensures that nowhat4+An acknowledgement action that does nothingwhat42Clear the entry stack, and start with a fresh one.what4Pop all but the topmost stack entry. Return the number of entries on the stack prior to popping.what4Return the number of pushed stack frames. Note, this is one fewer than the number of entries in the stack beacuse the base entry is the top-level context that is not in the scope of any push.what4?Push a new frame to the stack for maintaining the writer cache.what4Given an optional override configuration option, return the SMT response parsing strictness that should be applied based on the override or thedefault strictSMTParsing configuration.what4Like findM, but also allows you to compute some additional information in the predicate.what4Monadic generalisation of .what4Like $, but where the test can be monadic.what4Construct a function/name bimap. Each function is associated with its cached name if there is one, otherwise with its original name.what4Run state with handle.what45Update the current program location to the given one.what4Write a command to the connection along with position information if it differs from the last position.what4Write a sequence of commands. All but the last should have acknowledgement.what4*Create a new variable with the given name.what4Consider the bound variable as free within the current assumption frame.what4$Assume that the given formula holds.what4Perform any necessary declarations to ensure that the mentioned type map sorts exist in the solver environment.what49Create a variable name eqivalent to the given expression.what49Create a variable name eqivalent to the given expression.what4Create a fresh constantwhat40Given a solver connection and a base type repr,  attempts to find the best encoding for a variable of that type supported by teh solver.what4This is a helper function for  that only returns values that can be passed as arguments to a function.what4Create a fresh bound term from the SMT expression with the given name.what4Create a fresh bound term from the SMT expression with the given name.what4Create a fresh bound term from the SMT expression with the given name.what4=Assert a predicate holds as a side condition to some formula.what4)This runs the collector on the connectionwhat42Create a forall expression from a CollectorResult.what4impliesAllExpr l r9 returns an expression equivalent to forall l implies r.what42Create a forall expression from a CollectorResult.what46This runs the side collector and collects the results.what4=Cache the result of writing an Expr named by the given nonce.what4Associate a bound variable with the givne SMT Expression until the awhat4'Checks whether a variable is supported.Returns the SMT type of the variable and a predicate (if needed) that the variable should be assumed to hold. This is used for Natural number variables.what40Check that the types can be passed to functions.what44Evaluate a base type repr as a first class SMT type.First class types are those that can be passed as function arguments and returned by functions.what4Convert structure to list.what4Convert structure to list.what4'Create index arguments with given type..Returns the name of the argument and the type.what4Get name associated with symbol binding if defined, creating it if needed.what4='defineSMTFunction conn var action' will introduce a functionIt returns the return type of the value. Note: This function is declared at a global scope. It bypasses any subfunctions. We need to investigate how to support nested functions.what4,Convert an expression into a SMT Expression.what4(Convert an element to a base expression.what4Convert structure to list.what42Create a SMT symbolic function from the ExprSymFn.(Returns the return type of the function.This is only called by .what46Generate a SMTLIB function for a ExprBuilder function.Since SimpleBuilder different simple builder values with the same type may have different SMTLIB types (particularly arrays), getSMTSymFn requires the argument types to call the function with. This is enforced to be compatible with the argument types expected by the simplebuilder.This function caches the result, and we currently generate the function based on the argument types provided the first time getSMTSymFn is called with a particular simple builder function. In subsequent calls, we validate that the same argument types are provided. In principal, a function could be called with one type of arguments, and then be called with a different type and this check would fail. However, due to limitations in the solvers we expect to support, this should never happen as the only time these may differ when arrays are used and one array is encoded using the theory of arrays, while the other uses a defined function. However, SMTLIB2 does not allow functions to be passed to other functions; yices does, but always encodes arrays as functions.Write assume formula predicates for asserting predicate holds.what4Return the terms associated with the given ground index variables.what4The function creates a function for evaluating elts to concrete values given a connection to an SMT solver along with some functions for evaluating different types of terms to concrete values.what4Name of variablewhat4Type for indiceswhat4Type for value.what4Constant to assign all values.what4Stream to write queries ontowhat43Input stream to read responses from (may be the  nullInput% stream if no responses are expected)what45An action to consume solver acknowledgement responseswhat4&Name of solver for reporting purposes.what4Be strict in parsing responses?what44Indicates what features are supported by the solver.what4A bijective mapping between variables and their canonical name (if any).what44State information specific to the type of connectionwhat4Name of variable to define Should not be defined or declared in the current SMT contextwhat4/Names of variables in term and associated type.what4Type of expression.what4/Names of variables in term and associated type.what4Type of expression.what4,The name of the constant based on its reaon.what4Type of the constant.what4 Arguments expected for function.what4Type of resultwhat4Result of functionwhat4&Reason that condition is being added. what4Predicate that should hold. what4Name to define.what4Nonce to associate term withwhat4Lifetime of termwhat4Action to create term.what4Variable to bindwhat4SMT Expression to bind to var.what4Action to generatewhat4 Function towhat4Connection to SMT solver.32444444G Safe-Inferred"qwhat41Called to get a response from the SMT connection.what4Gets a limited set of responses, throwing an exception when a response is not matched by the filter. Also throws exceptions for standard error results. The passed command and intent arguments are only used for marking error messages.Callers which do not want exceptions thrown for standard error conditions should feel free to use + and handle all response cases themselves.H:Commonly-used reexports from the expression representation(c) Galois, Inc 2015-2020BSD3!Rob Dockins  Safe-Inferreds}what4A "dummy" data type that can be used for the user state field of an 6 when there is no other interesting state to track.z{|}~ z{|}~  Safe-Inferred")*/01[what4Key for sharing SExpr construction. Internally indexes are expression nonces, but the let-binding identifiers are based on insertion order to the OMapwhat4.User provided configuration for serialization.what4+Internal counter for generating fresh nameswhat4Mapping from What4 expression nonces to the corresponding let-variable name (the fst)) and the corresponding bound term (the snd).what4Mapping from What4 ExprBoundVar to the fresh names assigned to them for serialization purposes.what4Mapping from What4 ExprSymFn to the fresh names assigned to them for serialization purposes.what4Set of currently in-scope What4 ExprBoundVars (i.e., ExprBoundVars for whom we are serializing the body of their binding form).what4The serialized term.what4The free BoundVars that were encountered during serialization and their associated fresh name that was used to generate the s-expression.what4The SymFns that were encountered during serialization and their associated fresh name that was used to generate the s-expression.what46Controls how expressions and functions are serialized.what4When True, any free What4  ExprBoundVar encountered is simply serialized with a unique name, and the mapping from What4 ExprBoundVar to unique names is returned after serialization. When False, an error is raised when a "free"  ExprBoundVar is encountered.what4When True, any encountered What4  ExprSymFn during serialization is simply assigned a unique name and the mapping from What4 ExprSymFn to unique name is returned after serialization. When @False, encountered ExprSymFns are serialized at the top level of the expression in a `(letfn ([f ...]) ...)`.what4Serialize a What4 Expr as a well-formed s-expression (i.e., one which contains no improper lists). Equivalent to )(resSExpr (serializeExpr' defaultConfig)). Sharing in the AST is achieved via a top-level let-binding around the emitted expression (unless there are no terms with non-atomic terms which can be shared).what4Serialize a What4 Expr as a well-formed s-expression (i.e., one which contains no improper lists) according to the configuration. Sharing in the AST is achieved via a top-level let-binding around the emitted expression (unless there are no terms with non-atomic terms which can be shared).what4Serialize a What4 ExprSymFn as a well-formed s-expression (i.e., one which contains no improper lists). Equivalent to +(resSExpr (serializeSymFn' defaultConfig)). Sharing in the AST is achieved via a top-level let-binding around the emitted expression (unless there are no terms with non-atomic terms which can be shared).what4Serialize a What4 ExprSymFn as a well-formed s-expression (i.e., one which contains no improper lists) according to the configuration. Sharing in the AST is achieved via a top-level let-binding around the emitted expression (unless there are no terms with non-atomic terms which can be shared).what4Run the given Memo computation to produce a well-formed s-expression (i.e., one which contains no improper lists) according to the configuration. Sharing in the AST is achieved via a top-level let-binding around the emitted expression (unless there are no terms with non-atomic terms which can be shared).what4)Serialize the given sexpression within a letfn which serializes and binds all of the encountered SymFns. Note: this recursively also discovers and then serializes SymFns referenced within the body of the SymFns encountered thus far.what4Converts the given What4 expression into an s-expression and clears the let-binding cache (since it just emitted a let binding with any necessary let-bound vars).what4Converts a What4 ExprSymFn into an s-expression within the Memo monad (i.e., no let or letfns are emitted).what42Allocate a fresh variable for the given nonce-key"s-expression and save the variable&expression mapping in the Memo monad.what4Converts a What 4 expression into an s-expression within the Memo monad (i.e., no let or letfns are emitted in the result).what49Serialize bound variables as the s-expression identifier  name_nonce. This allows us to preserve their human-readable name while ensuring they are globally unique w/ the nonce suffix.what4Convert an Assignment of base types into a list of base types SExpr, where the left-to-right syntactic ordering of the types is maintained.+ + I Safe-Inferred"()*01#what4Operator type descriptions for parsing s-expression of the form (operator operands ...).what4#Generic unary operator description.what4$Generic dyadic operator description.what4%Generic triadic operator description.what4&Generic tetradic operator description.what4Encapsulating type for a unary operation that takes one bitvector and returns another (in IO).what4Binop with a bitvector return type, e.g., addition or bitwise operations.what4Bitvector binop with a boolean return type, i.e., comparison operators.what4Stores a NatRepr along with proof that its type parameter is a bitvector of that length. Used for easy pattern matching on the LHS of a binding in a do-expression to extract the proof.what4The lexical environment for parsing s-expressions and procesing them into What4 terms.what4&The symbolic What4 backend being used.what4Parse a list of array updates where each entry in the list is:  (idxs, elt) where each idxs. is a list (assignment) of indexes (with type idxReprs) and each element is an expr.NOTE: We assume that there are no duplicates in the list and apply the updates in an arbitrary order. This is true for any map serialized by this library.what4Safe list indexingThis version only traverses the list once (compared to computing the length and then using unsafe indexing)what4Parse a single  out of a list of  (at the named index)/This is used to build the assignment of indexeswhat4Given the s-expressions for the bindings and body of a let, parse the bindings into the Reader monad's state and then parse the body with those newly bound variables.what4Parse an arbitrary expression.what4%Parse multiple expressions in a list.what4If the list is empty, return $. If the list is non-empty, return  (xs, x), where xs is equivalent to calling  on the list and x is equivalent to calling  on the list.what4Bindings in a let-expression.what4Body of the let-expression.what4Bindings in a let-expression.what4Body of the let-expression.J Safe-Inferred"()*01Jwhat4Apply some normalizations to make function call arguments more readable. Examples include:$Avoid wrapping single literals in a 3 and just represent them as a bare integer literalsAttempt to reduce function calls with constant arguments where possiblewhat4>Normalize an expression by passing it back through the builder:NOTE: We may want to audit the cases here for completenessKOnline solver interactions(c) Galois, Inc 2018-2020BSD3!Rob Dockins  Safe-Inferred )*p)what4The RunawaySolverTimeout is thrown when the solver cannot voluntarily limit itself to the requested solver-timeout period and has subsequently been forcibly stopped.what4.A live connection to a running solver process.This data structure should be used in a single-threaded manner or with external synchronization to ensure that only a single thread has access at a time. Unsynchronized multithreaded use will lead to race conditions and very strange results.what4)Writer for sending commands to the solverwhat4Callback for regular code paths to gracefully close associated pipes and wait for the process to shutdownwhat4Handle to the solver processwhat4;Indicate this solver's behavior following an error responsewhat4%Standard error for the solver processwhat41The functions used to parse values out of models.what4Some solvers will enter an UNSAT state early, if they can easily determine that context is unsatisfiable. If this IORef contains an integer value, it indicates how many "pop" operations need to be performed to return to a potentially satisfiable state. A Just 0 state indicates the special case that the top-level context is unsatisfiable, and must be "reset".what4Some solvers do not have support for the SMTLib2.6 operation (reset-assertions), or an equivalent. For these solvers, we instead make sure to always have at least one assertion frame pushed, and pop all outstanding frames (and push a new top-level one) as a way to mimic the reset behavior.what4The amount of time (in seconds) that a solver should spend trying to satisfy any particular goal before giving up. A value of zero indicates no time limit.Note that it is not sufficient to set just this value to control timeouts; this value is used as a reference for common code (e.g. SMTLIB2) to determine the timeout for the associated timer. When initialized, this field of the SolverProcess is initialized from a solver-specific timeout configuration (e.g. z3Timeout); the latter is the definitive reference for the timeout, and solver-specific code will likely use the the latter rather than this common field.what4The amount of time that a solver is allowed to attempt to satisfy any particular goal.)The timeout value may be retrieved with  or .what4This datatype describes how a solver will behave following an error.what4This indicates the solver will immediately exit following an errorwhat4This indicates the solver will remain live and respond to further commmands following an errorwhat4This class provides an API for starting and shutting down connections to various different solvers that support online interaction modes.what41Start a new solver process attached to the given .what4Shut down a solver process. The process will be asked to shut down in a "polite" way, e.g., by sending an (exit)) message, or by closing the process's . Use  killProcess/ instead to shutdown a process via a signal.what4Simple data-type encapsulating some implementation of an online solver.what4Get the SolverGoalTimeout raw numeric value in units of seconds.what4-Standard input stream for the solver process.what45The solver's stdout, for easier parsing of responses.what49An impolite way to shut down a solver. Prefer to use , unless the solver is unresponsive or in some unrecoverable error state.what4Check if the given formula is satisfiable in the current solver state, without requesting a model. This is done in a fresh frame, which is exited after the check call.what4get-abuct nm t queries the solver for the first abduct, which is returned as an SMT function definition named nm. The remaining abducts are obtained from the solver by successive invocations of the get-abduct-next: command, which return SMT functions bound to the same nm as the first. The name nm is bound within the current assertion frame. Note that this is an unstable API; we expect that the return type will change to a parsed expression in the futurewhat4Check if the formula is satisifiable in the current solver state. This is done in a fresh frame, which is exited after the continuation complets. The evaluation function can be used to query the model. The model is valid only in the given continuation.what4Pop all assumption frames and remove all top-level asserts from the global scope. Forget all declarations except those in scope at the top level.what4#Push a new solver assumption frame.what4'Pop a previous solver assumption frame.what4Pop a previous solver assumption frame, but allow this to fail if the solver has exited.what4 Safe-Inferred )*1^what4=The strategy to use to search for lower and upper bounds in .what4After making an initial guess for a bound, increase (for upper bounds) or decrease (for lower bounds) the initial guess by an exponentially increasing amount (1, 2, 4, 8, ...) until the bound has been exceeded. At that point, back off from exponential search and use binary search until the bound has been determined.1For many use cases, this is a reasonable default.what4-Use binary search to found each bound, using 0- as the leftmost bounds of the search and * as the rightmost bounds of the search.what4The results of an  trying to resolve a  as concrete.what4/A concrete bitvector, including its value as a .what4 A symbolic SymBV/, including its lower and upper bounds as a .what4Use an  to attempt to resolve a  as concrete. If it cannot, return the lower and upper bounds. This is primarly intended for compound expressions whose bounds cannot trivially be determined by using  or .what4The strategy to use when searching for lower and upper bounds. For many use cases,  is a reasonable default.what4The bitvector widthwhat4The online solver process to use to search for lower and upper bounds.what4The bitvector to resolve.M*Interface for solvers that consume SMTLib2(c) Galois, Inc 2014-2020BSD3!Rob Dockins  provisional Safe-Inferred"#()*1(what4Things that can go wrong while checking which solver version we've gotwhat4Run the solver in a session.what41This is an interactive session with an SMT solverwhat4Operator type descriptions for parsing s-expression of the form (operator operands ...).%Code is copy-pasted and adapted from cd, see -https://github.com/GaloisInc/what4/issues/228what4#Generic unary operator description.what4$Generic binary operator description.what4Encapsulating type for a unary operation that takes one bitvector and returns another (in IO).what4Binop with a bitvector return type, e.g., addition or bitwise operations.what4Bitvector binop with a boolean return type, i.e., comparison operators.what4Stores a NatRepr along with proof that its type parameter is a bitvector of that length. Used for easy pattern matching on the LHS of a binding in a do-expression to extract the proof.what4This class exists so that solvers supporting the SMTLib2 format can support features that go slightly beyond the standard.In particular, there is no standardized syntax for constant arrays (arrays which map every index to the same value). Solvers that support the theory of arrays and have custom syntax for constant arrays should implement . In addition, solvers may override the default representation of complex numbers if necessary. The default is to represent complex numbers as "(Array Bool Real)" and to build instances by updating a constant array.what4Return a representation of the type associated with a (multi-dimensional) symbolic array.By default, we encode symbolic arrays using a nested representation. If the solver, supports tuples/structs it may wish to change this.what4/The sort of structs with the given field types.By default, this uses SMTLIB2 datatypes and are not primitive to the language.what44Construct a struct value from the given field valueswhat4(Construct a struct field projection termwhat4Number of bits in exponentwhat4"Number of bits in the significand.what4&Set the logic to all supported logics.what4#Select a valued from a nested arraywhat4>Apply the SMTLib2.6 string escaping rules to a string literal.what4+Parse SMTLIb2.6 escaping rules for strings.&Note! The escaping rule that uses the "" sequence to encode a double quote has already been resolved by parseSMTLIb2String', so here we just need to parse the \u escape forms.what4Write check sat commandwhat46Set the produce models option (We typically want this)what4Write check-synth commandwhat4Parse a bitvector value returned by a solver. Most solvers give results of the right size, but ABC always gives hex results without leading zeros, so they may be larger or smaller than the actual size of the variable.what4:Parse an s-expression and return a bitvector and its widthwhat4Given an expression, monadically either returns proof that it is a bitvector or throws an error.what4Verify a list of arguments has a single argument and return it, else raise an error.what4Verify a list of arguments has two arguments and return it, else raise an error.what4Utility function for contextualizing errors. Prepends the given prefix whenever an error is thrown.what49Get a value from a solver (must be called after checkSat)what4runGetAbducts s nm p n, returns n formulas (as strings) the disjunction of which entails p (along with all the assertions in the context)what4&This function runs a check sat commandwhat4A default method for writing SMTLib2 problems without any solver-specific tweaks.what49Solver version bounds computed from "solverBounds.config"what4!Get the result of a version querywhat4)Query the solver's error behavior settingwhat4!Get the result of a version querywhat4 provisional Safe-Inferred")*8what4 Path to Z3what41Per-check timeout, in milliseconds (zero is none)what4Strict parsing specifically for Z3 interaction? If set, overrides solver.strict_parsing, otherwise defaults to solver.strict_parsing.what4 Z3 tacticwhat4Run Z3 in a session. Z3 will be configured to produce models, but otherwise left with the default configuration.what4Check the satisfiability of a set of constrained Horn clauses (CHCs).CHCs are represented as pure SMT-LIB2 implications. For more information, see the  ;https://microsoft.github.io/z3guide/docs/fixedpoints/intro/Z3 guide.There are two ways to solve the CHCs: either by directly solving the problem as is, or by transforming the problem into a set of linear integer arithmetic (LIA) CHCs and solving that instead. The latter is done by replacing all bitvector (BV) operations with LIA operations, and replacing all BV variables with LIA variables. This transformation is not sound, but in practice it is a useful heuristic. Then the result is transformed back into a BV result, and checked for satisfiability. The satisfiability check is necessary because the transformation is not sound, so LIA solution may not be a solution to the BV CHCs.what4Path to Z3 executablewhat4 Action to runOSolver adapter code for Yices(c) Galois, Inc 2015-2020BSD3!Rob Dockins  provisional Safe-Inferred"(1what4;Exceptions that can occur when reading responses from Yiceswhat4This data type bundles a Yices command (as a Text Builder) with an indication as to whether it is safe to issue in an inconsistent context. Unsafe commands are the ones that Yices will complain about to stderr if issued, causing interaction to hang.what4Denotes a type in yices.what4&This is a tag used to indicate that a . is a connection to a specific Yices process.what45Attempt to interpret a Config value as a Yices value.what4Tell yices to show a modelwhat4Create yices set command value.what4Send a check command to Yices.what4"Print a command to show the model.what4Get the sat result from a previous SAT command. Throws an exception if something goes wrong.what4 Call eval to get a Rational termwhat4 Call eval to get a Boolean term.what4&Send eval command and get result back.what4 Path to yiceswhat4Enable the MC-SAT solverwhat49Enable interactive mode (necessary for per-goal timeouts)what4"Set a per-goal timeout in seconds.what4Control strict parsing for Yices solver responses (defaults to solver.strict-parsing option setting).what4This checks that the element is in a logic fragment supported by Yices, and returns whether the exists-forall solver should be used.what4Write a yices file that checks the satisfiability of the given predicate.what4"Run writer and get a yices result.what4+Indicates the problem features to support. what4%Builder for getting current bindings.what4 Path to filewhat4Predicate to checkPSolver adapter code for STP(c) Galois, Inc 2015-2020BSD3!Joe Hendrix  provisional Safe-Inferred"rwhat4 Path to stpwhat41Per-check timeout, in milliseconds (zero is none)what4Control strict parsing for Boolector solver responses (defaults to solver.strict-parsing option setting).what4Run STP in a session. STP will be configured to produce models, buth otherwise left with the default configuration.what4Path to STP executablewhat4 Action to run  QSolver adapter code for an external ABC process via SMT-LIB2.(c) Galois, Inc 2020BSD3Aaron Tomb  provisional Safe-Inferred ")*what4 Path to ABCwhat4Control strict parsing for ABC solver responses (defaults to solver.strict-parsing option setting).RInterface for running dReal(c) Galois, Inc 2014-2020BSD3!Rob Dockins  provisional Safe-Inferred"1what4 Path to dRealwhat4propositions to check  SSolver adapter code for cvc5(c) Galois, Inc 2022BSD3!Rob Dockins  provisional Safe-Inferred ")*what4 implements a " instance that is different from 9 in that it provides SyGuS specific implementations for defaultSolverArgs and setDefaultLogicAndOptions.what4 Path to cvc5what41Per-check timeout, in milliseconds (zero is none)what4Control strict parsing for cvc5 solver responses (defaults to solver.strict-parsing option setting).what4Run cvc5 in a session. cvc5 will be configured to produce models, but otherwise left with the default configuration.what4=Find a solution to a Syntax-Guided Synthesis (SyGuS) problem.For more information, see the  https://sygus.org/SyGuS standard.what4 provisional Safe-Inferred ")*>what4 Path to cvc4what41Per-check timeout, in milliseconds (zero is none)what4Control strict parsing for CVC4 solver responses (defaults to solver.strict-parsing option setting).what4Run CVC4 in a session. CVC4 will be configured to produce models, but otherwise left with the default configuration.what4Path to CVC4 executablewhat4 Action to run  UInterface for running Boolector(c) Galois, Inc 2014-2020BSD3!Rob Dockins  provisional Safe-Inferred ")*what4Path to boolectorwhat41Per-check timeout, in milliseconds (zero is none)what4Control strict parsing for Boolector solver responses (defaults to solver.strict-parsing option setting).what4Run Boolector in a session. Boolector will be configured to produce models, but otherwise left with the default configuration.what4Path to Boolector executablewhat4 Action to run  VInterface for running Bitwuzla(c) Galois, Inc 2014-2023BSD3Ryan Scott  provisional Safe-Inferred")*what4Path to bitwuzlawhat41Per-check timeout, in milliseconds (zero is none)what4Control strict parsing for Bitwuzla solver responses (defaults to solver.strict-parsing option setting).what4Run Bitwuzla in a session. Bitwuzla will be configured to produce models, but otherwise left with the default configuration.what4Path to Bitwuzla executablewhat4 Action to run  e"Reexports for working with solvers(c) Galois, Inc 2015-2020BSD3!Rob Dockins  Safe-Inferred#W.Datastructure for mapping bitvectors to values(c) Galois, Inc 2014-2020BSD3!Rob Dockins  Safe-Inferred1what4A WordMap: represents a finite partial map from bitvectors of width w to elements of type tp.what43Create a word map where every element is undefined.what4Compute a pointwise if-then-else operation on the elements of two word maps.what4%Update a word map at the given index.what4+Lookup the value of an index in a word map.what4index what4 new value what4word map to update what4index fghijkilmnoopqrpqstuvtuwtuxtyzty{|}}~                                                                                  _                     !!!!!!!!!!!!!!!"""""""""################################$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$%%%%%%%&''''''''''(((((((((((((((((((((()))))))))))))))))))))))))))**************************************** * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * + + + + + + + + + + + + + ++ + + +++ ++ ++ + + + + + + + + + + + + + + + + + + + + + + + + + , , ,,, ,,,,,,,, , , , , , - - - - - - - - - - - - - - - - - - - - - - - - . . . . . . . . . . . . . . . . . ... . . . . . . . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . / / / / / / 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 2 2 2 222 2 2 2 2 2 2 22 22222222 222222222 2 2 2 2 2 2 2222222 222222222 2 2 2 2 2 2 2 2333333333333333333333333333333333333333333333333333333334444444444444444444444444444444444444444444444444444444444444444444455555555555555555555555555566666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666677777 7 77777777777777777788888888888888889999999999999999999999999999999999999999999999999999999999999999999999:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::;;;;;;;;;;;;;;;;;<<<<<<<<<<<<<<<<<<<<<<<<<<<<==========>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>???????????????????????????????????????????????????????????????????????????????????????????????@AAAAAAAAAAAAABBCCCCDDDDDDDDDDDDDDDDDDDDEEEEEEEEEEEEEEEEEEEEEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF FFFFFFFFFFFFFFFFFFFFFFFFFF F F F F F FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF F F F FF F F F FFFFFFFFFFFFF F F F FFFFF F F F F F F F F F F F F F F F F F F F F F F F F F F F F FF F F F FF F F F F FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGHH  I I III I IIIIIIIJJJJJJJJKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKLLLLLLLLLMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNNNNNNNNNNNNNNNNNNOOOOOOOOOOOOOO OOOOOOOOOOOOOOOOOOOPPPPPPPPPPPPPQQQQQQQQQQRRRRRRRRRRRRSSSSSSSSSSSSSSSSSSSSSTTTTTTTTTTTTTTTUUUUUUUUUUUUUVVVVVVVVVVVVVWWWWWWfpiYZiYiYiYiiiiippppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppp     i  d\ifiiiilii$)***+++++++-............iiipqp0001i222222234i77777789<<<<<<<<<<f>>>>f>>>>>>>>>>>>>>>>>>>>>>i>>>>>>>>>>>CDDFFFFFFFFFFFFFFFFFFFFFFFiaFiFFFFF FFFFFFFFFFFFFFFFFFFFFFFFFIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIiiIJKiMMMMMMMMMMMMMMMMMMMMMNOOOOOOOOOOOPQSSTUV what4-1.6-BBg7nDHY79y4KlLMepMan6What4.Utils.MonadST What4.PanicWhat4.BaseTypesWhat4.Serialize.PrinterTest.VerificationWhat4.FloatModeWhat4.FunctionNameWhat4.IndexLitWhat4.ProblemFeaturesWhat4.ProgramLocWhat4.Protocol.PolyRootWhat4.Protocol.ReadDecimalWhat4.Protocol.SExpWhat4.Protocol.SMTLib2.ParseWhat4.Protocol.SMTLib2.SyntaxWhat4.SatResultWhat4.SemiRingWhat4.Serialize.LogWhat4.Serialize.SETokensWhat4.Serialize.FastSExprWhat4.SpecialFunctions What4.SymbolWhat4.Utils.AnnotatedMapWhat4.Utils.ArithmeticWhat4.Utils.BVDomain.ArithWhat4.Utils.BVDomain.BitwiseWhat4.Utils.BVDomain.XORWhat4.Utils.BVDomainWhat4.Utils.ComplexWhat4.Utils.EndianWhat4.Utils.EnvironmentWhat4.Utils.FloatHelpersWhat4.Utils.HandleReaderWhat4.Utils.IncrHashWhat4.Expr.BoolMapWhat4.Utils.LeqMapWhat4.Utils.OnlyIntReprWhat4.Utils.StreamsWhat4.Utils.VersionsWhat4.Utils.Word16StringWhat4.Utils.StringLiteralWhat4.Utils.AbstractDomainsWhat4.Expr.WeightedSumWhat4.Expr.ArrayUpdateMapWhat4.Concrete What4.ConfigWhat4.Utils.ProcessWhat4.InterfaceWhat4.Utils.Serialize What4.SWord What4.SFloat What4.PartialWhat4.LabeledPredWhat4.InterpretedFloatingPointWhat4.Expr.UnaryBVWhat4.Expr.StringSeqWhat4.Expr.MATLABWhat4.Expr.AppWhat4.Expr.AppTheoryWhat4.Expr.VarIdentificationWhat4.Expr.AllocatorWhat4.Expr.Builder What4.Protocol.VerilogWriter.AST$What4.Protocol.VerilogWriter.Backend'What4.Protocol.VerilogWriter.ABCVerilogWhat4.Protocol.VerilogWriterWhat4.Expr.SimplifyWhat4.Expr.GroundEvalWhat4.Solver.AdapterWhat4.Protocol.SMTWriterWhat4.Protocol.SMTLib2.Response What4.ExprWhat4.Serialize.ParserWhat4.Serialize.NormalizeWhat4.Protocol.OnlineWhat4.Utils.ResolveBounds.BVWhat4.Protocol.SMTLib2What4.Solver.Z3What4.Solver.YicesWhat4.Solver.STPWhat4.Solver.ExternalABCWhat4.Solver.DRealWhat4.Solver.CVC5What4.Solver.CVC4What4.Solver.BoolectorWhat4.Solver.Bitwuzla What4.WordMapwhat4 GHC.TypeNatsNatControl.ConcurrentThreadIdDataUniqueDebugTrace Data.Maybe fromMaybeWhat4.SerializeParser What4.Solverghc-primGHC.Prim RealWorldbaseGHC.STSTGHC.Stack.Types HasCallStack$panic-0.4.0.1-95UTn9gXDkY8KmNg8PmkpRPanic2parameterized-utils-2.1.8.0-KU5xzBsCZv5CDsI2M6ZFpDData.Parameterized.Classes KnownRepr knownRepr's-cargot-0.1.6.0-72ja8OOPi595SJH2jXgDUOData.SCargot.ReprWellFormedSExprWFSListWFSAtomData.SCargot.Repr.WellFormedALGenGenEnv genChooseBool genChooseIntgenChooseInteger genGetSize AssumptionAssuming preCondition assumedProp Verifiable verifyingProperty BoolPropertyAssumptionProppropertyassuming==> chooseBool chooseInt chooseIntegergetSizetoNativeProperty$fVerifiableProperty$fVerifiableBool $fMonadGen$fApplicativeGen $fFunctorGen$fShowAssumption$fShowPropertyStringInfoRepr Char8Repr Char16Repr UnicodeReprFloatPrecisionReprFloatingPointPrecisionRepr BaseTypeRepr BaseBoolRepr BaseBVReprBaseIntegerRepr BaseRealRepr BaseFloatReprBaseStringReprBaseComplexReprBaseStructRepr BaseArrayReprPrec128Prec80Prec64Prec32Prec16FloatPrecisionBitsFloatingPointPrecisionFloatPrecision BaseArrayTypeBaseStructTypeBaseComplexTypeBaseStringType BaseFloatType BaseBVType BaseRealTypeBaseIntegerType BaseBoolTypeBaseTypeUnicodeChar16Char8 StringInfoKnownCtxarrayTypeIndicesarrayTypeResultfloatPrecisionToBVTypelemmaFloatPrecisionIsPos$fKnownReprFloatPrecisionFloatPrecisionReprFloatingPointPrecision*$fKnownReprStringInfoStringInfoReprUnicode)$fKnownReprStringInfoStringInfoReprChar16($fKnownReprStringInfoStringInfoReprChar8,$fKnownReprBaseTypeBaseTypeReprBaseArrayType-$fKnownReprBaseTypeBaseTypeReprBaseStructType.$fKnownReprBaseTypeBaseTypeReprBaseComplexType,$fKnownReprBaseTypeBaseTypeReprBaseFloatType)$fKnownReprBaseTypeBaseTypeReprBaseBVType-$fKnownReprBaseTypeBaseTypeReprBaseStringType+$fKnownReprBaseTypeBaseTypeReprBaseRealType.$fKnownReprBaseTypeBaseTypeReprBaseIntegerType+$fKnownReprBaseTypeBaseTypeReprBaseBoolType$fOrdFStringInfoStringInfoRepr$fEqStringInfoRepr&$fTestEqualityStringInfoStringInfoRepr&$fOrdFFloatPrecisionFloatPrecisionRepr$fEqFloatPrecisionRepr.$fTestEqualityFloatPrecisionFloatPrecisionRepr$fOrdFBaseTypeBaseTypeRepr$fEqBaseTypeRepr"$fTestEqualityBaseTypeBaseTypeRepr$fShowFStringInfoStringInfoRepr$fShowStringInfoRepr$fPrettyStringInfoRepr'$fShowFFloatPrecisionFloatPrecisionRepr$fShowFloatPrecisionRepr$fPrettyFloatPrecisionRepr$fShowFBaseTypeBaseTypeRepr$fShowBaseTypeRepr$fPrettyBaseTypeRepr$fHashableStringInfoRepr#$fHashableFStringInfoStringInfoRepr$fHashableFloatPrecisionRepr+$fHashableFFloatPrecisionFloatPrecisionRepr$fHashableBaseTypeRepr$fHashableFBaseTypeBaseTypeRepr FloatModeRepr FloatIEEEReprFloatUninterpretedRepr FloatRealRepr FloatRealFloatUninterpreted FloatIEEE FloatMode$$fTestEqualityFloatModeFloatModeRepr*$fKnownReprFloatModeFloatModeReprFloatReal3$fKnownReprFloatModeFloatModeReprFloatUninterpreted*$fKnownReprFloatModeFloatModeReprFloatIEEE$fShowFFloatModeFloatModeRepr$fShowFloatModeRepr FunctionName functionNamestartFunctionNamefunctionNameFromText$fPrettyFunctionName$fShowFunctionName$fIsStringFunctionName$fEqFunctionName$fOrdFunctionName$fHashableFunctionNameIndexLit IntIndexLit BVIndexLit hashIndexLit$fShowFBaseTypeIndexLit$fShowIndexLit$fHashableFBaseTypeIndexLit$fHashableIndexLit$fOrdFBaseTypeIndexLit$fTestEqualityBaseTypeIndexLit $fEqIndexLitWhat4panic$fPanicComponentWhat4ProblemFeatures noFeaturesuseLinearArithmeticuseNonlinearArithmeticuseComputableRealsuseIntegerArithmetic useBitvectorsuseExistForalluseQuantifiersuseSymbolicArrays useStructs useStringsuseFloatingPoint useUnsatCoresuseUnsatAssumptionsuseUninterpFunctionsuseDefinedFunctionsuseProduceAbductshasProblemFeature$fEqProblemFeatures$fBitsProblemFeatures HasProgramLoc programLoc ProgramLoc plFunction plSourceLocPosdpospos_valPosition SourcePos BinaryPosOtherPos InternalPos sourcePos startOfFile ppNoFileNameinitializationLoc mkProgramLoc$fPrettyPosition$fNFDataPosition$fShowPosition $fNFDataPosd$fShowProgramLoc$fEqProgramLoc$fOrdProgramLoc $fFunctorPosd$fFoldablePosd$fTraversablePosd $fShowPosd$fEqPosd $fEqPosition $fOrdPositionRoot approximateparseYicesRoot fromYicesText$fPrettySingPoly $fPrettyRoot $fShowRoot$fFunctorSingPoly$fFoldableSingPoly$fTraversableSingPoly$fShowSingPoly readDecimalSExpSAtomSStringSAppskipSpaceOrNewline parseNextWord parseSExp parseSExpBody stringToSExp asNegAtomList asAtomList sExpToString$fIsStringSExp$fEqSExp $fOrdSExp $fShowSExpGetModelResponse ModelResponseDeclareSortResponseDefineFunResponse DefineFun funSymbolfunArgs funResultSortfunDefTerm SymbolTermAsConstBVTermIntTermRatTerm StoreTermIfEqTermSortBitVec FloatingPointSymbolCheckSatResponse SatResponse UnsatResponseUnknownResponseCheckSatUnsupported CheckSatErrorArray RoundingModeRealIntBoolreadCheckSatResponsereadGetModelResponse$fIsStringParser$fMonadFailParser $fMonadParser$fCanParseInteger$fCanParseCheckSatResponse$fCanParseSymbol$fIsStringSymbol $fShowSymbol$fCanParseSort$fCanParseTerm$fCanParseModelResponse $fEqSymbol$fFunctorParser$fApplicativeParser SMTInfoFlagNameVersion ErrorBehavior InfoKeywordCommandCmdT renderTermunSortLogic builder_listqf_bv allSupportedallLogic hornLogicvarSortboolSortbvSortintSortrealSort arraySortterm_appun_appbin_app namedTermtruefalsenotimpliesandorxoreq pairwise_appdistinctiteforall_exists_ letBindernegatenumeraldecimalsubaddmuldiv./modabsleltgegttoRealtoIntisInt arrayConstselectstorebit0bit1bvbinary bvdecimal bvhexadecimalconcatextractbvnotbvandbvorbvxorbvnegbvaddbvsubbvmulbvudivbvurembvshlbvlshrbvultbvulebvslebvsltbvugebvugtbvsgebvsgtbvashrbvsdivbvsrem bvsignExtend bvzeroExtendsetLogic setOptionsetProduceModelsexit declareSort defineSort declareConst declareFun defineFunassert assertNamedcheckSatcheckSatAssumingcheckSatWithAssumptionsgetModelgetUnsatAssumptions getUnsatCore getAbduct getAbductNextsynthFun declareVar constraint checkSynthgetValueresetAssertionspushpopgetInfo getVersiongetNamegetErrorBehavior$fDataSMTInfoFlag$fEqSMTInfoFlag$fOrdSMTInfoFlag$fGenericSMTInfoFlag$fShowSMTInfoFlag$fIsStringTerm $fMonoidTerm$fSemigroupTerm SatResultSatUnsatUnknowntraverseSatResultisSatisUnsat isUnknownforgetModelAndCore$fShowSatResult$fGenericSatResult Occurrence Coefficient SemiRingBaseOrderedSemiRingReprOrderedSemiRingIntegerReprOrderedSemiRingRealRepr SemiRingReprSemiRingIntegerReprSemiRingRealReprSemiRingBVRepr BVFlavorRepr BVArithRepr BVBitsRepr SemiRingBV SemiRingRealSemiRingIntegerBVBitsBVArithSemiRingBVFlavor semiRingBaseorderedSemiRing sr_comparesr_hashWithSaltocc_oneocc_add occ_countocc_eqocc_hashWithSalt occ_comparezeroone$fHashableSemiRingRepr$fHashableFSemiRingSemiRingRepr$fHashableOrderedSemiRingRepr&$fHashableFSemiRingOrderedSemiRingRepr$fHashableBVFlavorRepr$fHashableFBVFlavorBVFlavorRepr$fOrdFSemiRingSemiRingRepr!$fOrdFSemiRingOrderedSemiRingRepr$fOrdFBVFlavorBVFlavorRepr$fEqSemiRingRepr"$fTestEqualitySemiRingSemiRingRepr$fEqOrderedSemiRingRepr)$fTestEqualitySemiRingOrderedSemiRingRepr$fEqBVFlavorRepr"$fTestEqualityBVFlavorBVFlavorReprLogCfgLogEvent leCallSiteleLevelleMsg leThreadIdleTimeMonadHasLogCfg getLogCfgM HasLogCfgLogMsgLogLevelInfoWarnError withLogCfg getLogCfglogIO logIOWithlogTracelogM logEndWithmkLogCfg mkNonLogCfg withLoggingconsumeUntilEndstdErrLogEventConsumerfileLogEventConsumertmpFileLogEventConsumernamednamedIOnamedMprettyLogEvent writeLogEvent$fShowLogLevel $fEqLogLevel $fOrdLogLevel$fReadLogLevelAtomAIdAStrAIntANatARealAFloatABVABoolstringstring'identident'intnatrealfloatbitvecbool printSExpr printAtom parseSExpr $fShowAtom$fEqAtom $fOrdAtom#$fShowErrorComponentWhat4ParseError$fShowWhat4ParseError$fEqWhat4ParseError$fOrdWhat4ParseError SpecialFnArgs SpecialFnArg RealInterval RealPoint RealBoundInclExclZeroNegOnePosOneNegInfPosInfNegPiPosPi NegHalfPi PosHalfPiSpecialFunctionPiHalfPi QuarterPi OneOverPi TwoOverPiTwoOverSqrt_PiSqrt_2 Sqrt_OneHalfELog2_ELog10_ELn_2Ln_10SinCosTanArcsinArccosArctanSinhCoshTanhArcsinhArccoshArctanhHypotArctan2PowExpLogExpm1Log1pExp2Log2Exp10Log10RFunctionSymmetry NoSymmetry EvenFunction OddFunctionspecialFnSymmetryspecialFnRangespecialFnDomain$fShowSpecialFunction$fShowRealPoint$fShowRealInterval$fShowFunctionSymmetrytraverseSpecialFnArgtraverseSpecialFnArgs$fHashableSpecialFnArgs$fOrdSpecialFnArgs$fEqSpecialFnArgs$fHashableFTYPESpecialFnArg$fOrdFTYPESpecialFnArg$fTestEqualityTYPESpecialFnArg$fOrdFCtxSpecialFunction$fEqSpecialFunction $fTestEqualityCtxSpecialFunction$fHashableSpecialFunction$fHashableFCtxSpecialFunction SolverSymbolsolverSymbolAsTextSolverSymbolErrorppSolverSymbolError emptySymbol userSymbol systemSymbol safeSymbol$fShowSolverSymbolError$fShowSolverSymbol$fEqSolverSymbol$fOrdSolverSymbol$fHashableSolverSymbol AnnotatedMap annotationtoList fromAscListeqBynullempty singletonsizeinsertlookupdeletealteralterFunion unionWithunionWithKeyMaybefiltermapMaybemapMaybeWithKeytraverseMaybeWithKey difference mergeWithKeymergeA mergeWithKeyM $fMonoidTag$fSemigroupTag$fMeasuredTagEntry$fTraversableAnnotatedMap$fFoldableAnnotatedMap$fFunctorAnnotatedMap$fFunctorEntry$fFoldableEntry$fTraversableEntryisPow2lglgCeilctzclz rotateRight rotateLeft nextMultiplenextPow2Multiple tryIntSqrttryRationalSqrt roundAwayDomainBVDAny BVDIntervalmemberproperbvdMask genDomain genElementgenPair asSingletonuboundssboundsarithDomainDatadomainsOverlapsltultisUltSumCommonEquivanyrangeintervalfromAscEltListzextsextshllshrashrscaleudivuremsdivsrem bitboundsunknowns fillrightpmember correct_anycorrect_uboundscorrect_sboundscorrect_singletoncorrect_overlap correct_unioncorrect_zero_extcorrect_sign_extcorrect_concatcorrect_shrink correct_trunccorrect_select correct_add correct_neg correct_not correct_mul correct_scalecorrect_scale_eq correct_udiv correct_uremcorrect_sdivRange correct_sdiv correct_srem correct_shl correct_lshr correct_ashr correct_eq correct_ult correct_sltcorrect_isUltSumCommonEquivcorrect_unknownscorrect_bitbounds $fShowDomain BVBitIntervalbitlenonempty intersectiontestBitrolrorcorrect_intersection correct_rol correct_ror correct_and correct_or correct_xorcorrect_testBitBVDXor and_scalarcorrect_and_scalarBVDomainBVDArith BVDBitwisebitwiseToXorDomainarithToXorDomainxorToBitwiseDomain asXorDomain fromXorDomain asArithDomainasBitwiseDomainbitwiseRoundAbovebitwiseRoundBetweenpopcntcorrect_arithToBitwisecorrect_bitwiseToArithcorrect_bitwiseToXorDomaincorrect_arithToXorDomaincorrect_xorToBitwiseDomaincorrect_asXorDomaincorrect_fromXorDomain correct_bra1 correct_bra2 correct_brb1 correct_brb2precise_overlapcorrect_popcnt correct_ctz correct_clz$fShowBVDomainComplex:+realPartimagPart complexNegate complexAdd complexSub complexMul complexDiv complexRecip magnitude magnitudeSq tryMagnitudetryComplexSqrtcomplexAsRational$fRealFracComplex$fFloatingComplex$fFractionalComplex $fRealComplex $fNumComplex $fShowComplex$fPolyEqComplexComplex$fHashableComplex$fTraversableComplex $fEqComplex $fOrdComplex$fFoldableComplex$fFunctorComplex$fGenericComplexEndian LittleEndian BigEndian $fEqEndian $fShowEndian $fOrdEndianexpandEnvironmentPathfindExecutableRNERNARTPRTNRTZbfStatusfppOpts toRoundModefpOptsfloatFromIntegerfloatFromRationalfloatToRationalfloatToIntegerfloatRoundToInt$fHashableRoundingMode$fEqRoundingMode$fGenericRoundingMode$fOrdRoundingMode$fShowRoundingMode$fEnumRoundingMode HandleReaderhrChanhrHandle hrThreadIdteeInputStreamteeOutputStreamlineBufferedOutputStreamdemuxProcessHandles streamLinesstartHandleReaderstopHandleReaderwithHandleReader readNextLine readAllLinesIncrHash mkIncrHash toIncrHashtoIncrHashWithSalt$fHashableIncrHash$fMonoidIncrHash$fSemigroupIncrHash $fEqIncrHash $fOrdIncrHash BoolMapView BoolMapUnitBoolMapDualUnit BoolMapTermsBoolMapWrapunWrapPolarityPositiveNegativenegatePolarity traverseVars viewBoolMapisInconsistentisNullvaraddVarfromVarscombinecontainsreversePolarities removeVar$fHashablePolarity$fHashableWrap $fOrdWrap$fEqWrap$fHashableBoolMap $fEqBoolMap $fEqPolarity $fOrdPolarity$fShowPolarityLeqMapfindMaxfindMinmapKeysMonotonicsplitLeq splitEntrylookupLElookupGElookupLTlookupGTfilterGtfilterLt foldlWithKey'keysminViewWithKey deleteFindMin deleteFindMax toDescListfromDistinctAscListfromDistinctDescList$fTraversableLeqMap$fFoldableLeqMap$fFunctorLeqMap $fEqLeqMapMonadSTliftST$fMonadSTsWriterT$fMonadSTsWriterT0$fMonadSTsStateT$fMonadSTsStateT0$fMonadSTsReaderT$fMonadSTsContT $fMonadSTsST$fMonadSTRealWorldIO OnlyIntReprtoBaseTypeRepr$fHashableFBaseTypeOnlyIntRepr$fHashableOnlyIntRepr$fEqOnlyIntRepr!$fTestEqualityBaseTypeOnlyIntReprlogErrorStream SolverBoundslowerupper recommendedveremptySolverBoundsparseSolverBoundscomputeDefaultSolverBounds$fLiftBoxedRepSolverBounds Word16StringfromLEByteStringtoLEByteStringindexdroptakeappendlengthfoldl' findSubstring isInfixOf isPrefixOf isSuffixOf$fHashableWord16String$fShowWord16String$fOrdWord16String$fEqWord16String$fMonoidWord16String$fSemigroupWord16String StringLiteralUnicodeLiteral Char8Literal Char16LiteralstringLiteralInfofromUnicodeLit fromChar8Lit fromChar16LitstringLitLengthstringLitEmpty stringLitNullstringLitContainsstringLitIsPrefixOfstringLitIsSuffixOfstringLitSubstringstringLitIndexOfstringLitBounds$fIsStringStringLiteral$fSemigroupStringLiteral$fHashableStringLiteral"$fHashableFStringInfoStringLiteral$fShowStringLiteral$fShowFStringInfoStringLiteral$fOrdStringLiteral$fOrdFStringInfoStringLiteral$fEqStringLiteral%$fTestEqualityStringInfoStringLiteral AbstractableavJoin avOverlap avCheckEqConcreteValueWrapperunwrapCV ConcreteValueAbstractValueWrapperunwrapAV HasAbsValue getAbsValue AbstractValueStringAbstractValue StringAbs_stringAbsLengthRealAbstractValueRAVravRange ravIsInteger ValueRange SingleRangeUnboundedRangeMinRangeMaxRange IntervalRange ValueBound Unbounded Inclusive MultiRange minValueBound maxValueBound intAbsRange intDivRange intModRangeaddRangerangeScalarMul negateRangemulRange rangeLowBound rangeHiBound joinRange rangeCheckEq rangeCheckLeunboundedRange concreteRange singleRange valueRange asSingleRangemapRange ravUnbounded ravSingleravConcreteRangeravAdd ravScalarMulravMulravJoin ravCheckEq ravCheckLeabsAndabsOrrangeMaxrangeMin stringAbsTopstringAbsEmpty stringAbsJoinstringAbsSinglestringAbsOverlapstringAbsConcatstringAbsSubstringstringAbsContainsstringAbsIsPrefixOfstringAbsIsSuffixOfstringAbsIndexOfstringAbsLengthavTopavSinglewithAbstractable avContains$fMonadValueBound$fApplicativeValueBound$fAbstractableBaseStructType$fAbstractableBaseArrayType$fAbstractableBaseComplexType$fAbstractableBaseFloatType$fAbstractableBaseBVType$fAbstractableBaseRealType$fAbstractableBaseIntegerType$fAbstractableBaseStringType$fAbstractableBaseBoolType$fFunctorValueBound$fShowValueBound$fEqValueBound$fOrdValueBoundSemiRingProductprodRepr WeightedSumsumReprTm sumAbsValue sumOffset asConstantisZero asAffineVar asWeightedVarasVarconstanttraverseCoeffstraverseProdVars scaledVaraddVars addConstant fromTerms transformSumevalMevalreduceIntSumMod extractCommonnullProd asProdVar prodAbsValue prodContainsprodVarprodMulprodEval prodEvalM$fSemigroupSRAbsValue$fHashableWrapF $fEqWrapF $fOrdWrapF$fSemigroupNote$fSemigroupProdNote$fHashableWeightedSum$fEqWeightedSum!$fTestEqualitySemiRingWeightedSum$fHashableSemiRingProduct$fEqSemiRingProduct%$fTestEqualitySemiRingSemiRingProductArrayUpdateMaparrayUpdateAbstraverseArrayUpdateMapmergeMkeysSettoMap$fSemigroupArrayUpdateNote$fHashableArrayUpdateMap$fEqArrayUpdateMap ConcreteVal ConcreteBoolConcreteInteger ConcreteReal ConcreteFloatConcreteStringConcreteComplex ConcreteBVConcreteStruct ConcreteArrayfromConcreteBoolfromConcreteIntegerfromConcreteRealfromConcreteComplexfromConcreteStringfromConcreteBV concreteType$fShowConcreteVal$fShowFBaseTypeConcreteVal ppConcrete$fOrdConcreteVal$fOrdFBaseTypeConcreteVal$fEqConcreteVal!$fTestEqualityBaseTypeConcreteVal ConfigValue OptGetFailure OptSetFailureOpt getMaybeOpt trySetOptsetOptgetOptConfigOptCreateFailure ConfigDescBound Exclusive OptionStyleopt_type opt_onsetopt_helpopt_default_value OptionSettingoptionSettingName getOptionOptionSetResultoptionSetErroroptionSetWarnings ConfigOption configOptionconfigOptionNamePartsconfigOptionNameconfigOptionTextconfigOptionTypeoptOKoptErroptWarn set_opt_onsetset_opt_default boolOptSty realOptSty integerOptSty stringOptStyrealWithRangeOptStyrealWithMinOptStyrealWithMaxOptStyintegerWithRangeOptStyintegerWithMinOptStyintegerWithMaxOptSty enumOptSty listOptSty deprecatedOptexecutablePathOptStymkOptoptoptVoptUoptUVcopyOpt initialConfig extendConfigtryExtendConfig splitConfig verbosityverbosityLoggercheckOptSetResult setUnicodeOpt setIntegerOpt setBoolOptgetOptionSettinggetOptionSettingFromTextgetConfigValues configHelp$fShowConfigOption$fMonoidOptionSetResult$fSemigroupOptionSetResult$fShowFBaseTypeOptionSetting$fShowOptionSetting$fShowConfigDesc$fShowOptCreateFailure$fExceptionOptCreateFailure$fShowOptSetFailure$fExceptionOptSetFailure $fShowOptRef$fShowOptGetFailure$fExceptionOptGetFailure$fOptBaseRealTypeRatio$fOptBaseBoolTypeBool$fOptBaseIntegerTypeInteger$fOptBaseStringTypeText$fPrettyConfigValueresolveSolverPathfindSolverPathwithProcessHandlescleanupProcess startProcess filterAsync Statistics statAllocsstatNonLinearOps SymEncodersymEncoderType symFromExpr symToExprIsSymExprBuilder freshConstant freshLatchfreshBoundedBVfreshBoundedSBVfreshBoundedIntfreshBoundedRealexprUninterpConstants freshBoundVarvarExpr forallPred existsPred definedFninlineDefineFunfreshTotalUninterpFn applySymFnsubstituteBoundVarssubstituteSymFnstransformPredBV2LIAtransformSymFnLIA2BV InvalidRange UnfoldPolicy NeverUnfold AlwaysUnfoldUnfoldConcreteIsSymFn fnArgTypes fnReturnTypefnTestEquality fnCompare SymFnWrapper SomeSymFnSymFn IsExprBuildergetConfigurationsetSolverLogListenergetSolverLogListenerlogSolverEvent getStatisticsgetCurrentProgramLocsetCurrentProgramLocisEq baseTypeIte annotateTerm getAnnotationgetUnannotatedTermtruePred falsePrednotPredandPredorPred impliesPredxorPredeqPreditePredintLitintNegintAddintSubintMulintMinintMaxintIteintEqintLeintLtintAbsintDivintMod intDivisiblebvLitbvConcatbvSelectbvNegbvAddbvSubbvMulbvUdivbvUrembvSdivbvSrem testBitBVbvIsNegbvItebvEqbvNebvUltbvUlebvUgebvUgtbvSltbvSgtbvSlebvSge bvIsNonzerobvShlbvLshrbvAshrbvRolbvRorbvZextbvSextbvTrunc bvAndBitsbvOrBits bvXorBits bvNotBitsbvSetbvFill minUnsignedBV maxUnsignedBV maxSignedBV minSignedBV bvPopcountbvCountLeadingZerosbvCountTrailingZeros addUnsignedOF addSignedOF subUnsignedOF subSignedOFcarrylessMultiplyunsignedWideMultiplyBV mulUnsignedOFsignedWideMultiplyBV mulSignedOFmkStruct structFieldstructEq structIte constantArray arrayFromFnarrayMap arrayUpdate arrayLookup arrayCopyarraySet arrayRangeEq arrayFromMaparrayUpdateAtIdxLitsarrayItearrayEqallTrueEntriesarrayTrueOnEntries integerToReal bvToInteger sbvToIntegerpredToBV uintToReal sbvToReal realRound realRoundEven realFloorrealCeil realTrunc integerToBV realToIntegerrealToBV realToSBVclampedIntToSBVclampedIntToBV intSetWidth uintSetWidth intToUInt uintToInt stringEmpty stringLitstringEq stringIte stringConcatstringContainsstringIsPrefixOfstringIsSuffixOf stringIndexOf stringLengthstringSubstringrealZerorealLitsciLitrealEqrealNerealLerealLtrealGerealGtrealIterealMinrealMaxrealNegrealAddrealMulrealSubrealSqrealDivrealMod isInteger realIsNonNegrealSqrtrealPirealLogrealExprealSinrealCosrealTanrealSinhrealCoshrealTanhrealAbs realHypot realAtan2realSpecialFunctionrealSpecialFunction0realSpecialFunction1realSpecialFunction2 floatPZero floatNZerofloatNaN floatPInf floatNInffloatLitRationalfloatLitfloatNegfloatAbs floatSqrtfloatAddfloatSubfloatMulfloatDivfloatRemfloatMinfloatMaxfloatFMAfloatEqfloatNe floatFpEq floatFpApartfloatFpUnorderedfloatLefloatLtfloatGefloatGt floatIsNaN floatIsInf floatIsZero floatIsPos floatIsNegfloatIsSubnorm floatIsNormfloatIte floatCast floatRoundfloatFromBinary floatToBinary bvToFloat sbvToFloat realToFloat floatToBV floatToSBV floatToRealfloatSpecialFunction mkComplex getRealPart getImagPart cplxGetParts mkComplexLit cplxFromRealcplxItecplxNegcplxAddcplxSubcplxMulcplxMagcplxSqrtcplxSincplxCoscplxTan cplxHypot cplxRound cplxFloorcplxCeilcplxConjcplxExpcplxEqcplxNeSymNatSolverEndSATQuerySolverEndSATQueryRecsatQueryResult satQueryErrorSolverStartSATQuerySolverStartSATQueryRecsatQuerySolverNamesatQueryReason SolverEventArrayResultWrapperunwrapArrayResultIsExprasConstantPred asInteger integerBounds asRationalasFloatrationalBounds asComplexasBVunsignedBVBoundssignedBVBoundsasString stringInfoasConstantArrayasStructexprTypebvWidthfloatPrecision printSymExprunsafeSetAbstractValue SymAnnotationBoundVarSymExpr SymStringSymBVSymArray SymStructSymCplxSymFloatSymReal SymIntegerPreditePredMasNatnatLitnatAddnatSubnatMulnatDivnatModnatItenatEqnatLenatLt natToIntegernatToIntegerPurebvToNat natToReal integerToNat realToNatfreshBoundedNatfreshNat printSymNat bvJoinVector bvSplitVectorbvSwap bvBitreverseindexLititeMiteList shouldUnfoldbaseIsConcretebaseDefaultValue backendPred mkRationalmkReal predToRealcplxExprAsRationalcplxExprAsIntegerrationalAsIntegerrealExprAsIntegerandAllOforOneOf isNonZeroisRealcplxDivcplxLog cplxLogBase asConcrete concreteToSymmuxRangezeroStatisticsbvZerobvOne%$fHashableFBaseTypeArrayResultWrapper($fTestEqualityBaseTypeArrayResultWrapper$fHashableSymNat $fOrdSymNat $fEqSymNat$fOrdFCtxSymFnWrapper$fTestEqualityCtxSymFnWrapper$fOrdSomeSymFn $fEqSomeSymFn$fShowInvalidRange$fExceptionInvalidRange$fShowStatistics$fEqUnfoldPolicy$fOrdUnfoldPolicy$fShowUnfoldPolicy$fShowSolverEvent$fGenericSolverEvent$fShowSolverEndSATQuery$fGenericSolverEndSATQuery$fShowSolverStartSATQuery$fGenericSolverStartSATQuery asyncLinkedwithAsyncLinked makeSymbol withRoundingSWordDBVZBVbvAsSignedIntegerbvAsUnsignedIntegerfreshBVbvAtBEbvAtLEbvSetBEbvSetLEbvJoin bvSliceBE bvSliceLE bvUnpackBE bvUnpackLEbvPackBEbvPackLEbvNotbvAndbvOrbvXorbvForallbvUDivbvURembvSDivbvSRembvLg2 $fShowSWord SFloatRelSFloatBinArith FPTypeError fpExpectedfpActualUnsupportedFloatfpWho exponentBits precisionBitsSFloatfpReprfpReprOffpSizefpAsLitfpFreshfpNaNfpPosInffpNegInf fpFromLitfpFromRationalLit fpFromBinary fpToBinaryfpNegfpAbsfpSqrtfpAddfpSubfpMulfpDivfpMinfpMaxfpFMAfpItefpEqfpEqIEEEfpLtIEEEfpGtIEEEfpRoundfpToReal fpFromReal fpFromIntegerfpFromRational fpToRationalfpIsInffpIsNaNfpIsZerofpIsNeg fpIsSubnormfpIsNorm$fExceptionUnsupportedFloat$fExceptionFPTypeError$fShowFPTypeError$fShowUnsupportedFloatPartial _partialPred _partialValue $fDataPartial $fEqPartial$fFunctorPartial$fGenericPartial$fGeneric1TYPEPartial$fFoldablePartial$fTraversablePartial $fOrdPartial $fShowPartial partialPred partialValue$fBifunctorPartial$fBifoldablePartial$fBitraversablePartial $fEq1Partial $fEq2Partial $fOrd1Partial $fOrd2Partial$fShow1PartialPartialWithErrNoErrErr$fShow2Partial$fDataPartialWithErr$fEqPartialWithErr$fFunctorPartialWithErr$fGenericPartialWithErr$fGeneric1TYPEPartialWithErr$fFoldablePartialWithErr$fTraversablePartialWithErr$fOrdPartialWithErr$fShowPartialWithErr$fBifunctorPartialWithErr$fBifoldablePartialWithErr$fBitraversablePartialWithErr$fEq1PartialWithErr$fEq2PartialWithErr$fOrd1PartialWithErr$fOrd2PartialWithErr$fShow1PartialWithErrPartialT unPartialPartExprPE UnassignedmkPE justPartExpr maybePartExpr joinMaybePE mergePartial mergePartials runPartialTreturnUnassigned returnMaybe returnPartial addCondition$fShow2PartialWithErr$fMonadIOPartialT$fMonadTransPartialT$fMonadFailPartialT$fMonadPartialT$fApplicativePartialT$fFunctorPartialT LabeledPred _labeledPred_labeledPredMsg$fEqLabeledPred$fDataLabeledPred$fFunctorLabeledPred$fFoldableLabeledPred$fGenericLabeledPred$fGeneric1TYPELabeledPred$fOrdLabeledPred$fShowLabeledPred$fTraversableLabeledPred$fBifunctorLabeledPred$fBifoldableLabeledPred$fBitraversableLabeledPred$fEq1LabeledPred$fEq2LabeledPred$fOrd1LabeledPred$fOrd2LabeledPred$fShow1LabeledPred labeledPredlabeledPredMsgpartitionByPredsMpartitionByPredspartitionLabeledPreds$fShow2LabeledPred FloatInfoRepr HalfFloatReprSingleFloatReprDoubleFloatRepr QuadFloatReprX86_80FloatReprDoubleDoubleFloatReprDoubleDoubleFloat X86_80Float QuadFloat DoubleFloat SingleFloat HalfFloat FloatInfo2$fKnownReprFloatInfoFloatInfoReprDoubleDoubleFloat,$fKnownReprFloatInfoFloatInfoReprX86_80Float*$fKnownReprFloatInfoFloatInfoReprQuadFloat,$fKnownReprFloatInfoFloatInfoReprDoubleFloat,$fKnownReprFloatInfoFloatInfoReprSingleFloat*$fKnownReprFloatInfoFloatInfoReprHalfFloat IsInterpretedFloatSymExprBuilderfreshFloatConstantfreshFloatLatchfreshFloatBoundVarIsInterpretedFloatExprBuilder iFloatPZero iFloatNZero iFloatNaN iFloatPInf iFloatNInfiFloatLitRationaliFloatLitSingleiFloatLitDoubleiFloatLitLongDouble iFloatNeg iFloatAbs iFloatSqrt iFloatAdd iFloatSub iFloatMul iFloatDiv iFloatRem iFloatMin iFloatMax iFloatFMAiFloatEqiFloatNe iFloatFpEq iFloatFpApartiFloatLeiFloatLtiFloatGeiFloatGt iFloatIsNaN iFloatIsInf iFloatIsZero iFloatIsPos iFloatIsNegiFloatIsSubnorm iFloatIsNorm iFloatIte iFloatCast iFloatRoundiFloatFromBinaryiFloatToBinary iBVToFloat iSBVToFloat iRealToFloat iFloatToBV iFloatToSBV iFloatToRealiFloatSpecialFunctioniFloatSpecialFunction0iFloatSpecialFunction1iFloatSpecialFunction2iFloatBaseTypeReprSymInterpretedFloatSymInterpretedFloatType X86_80ValFloatInfoToBitWidthFloatPrecisionToInfoFloatInfoToPrecisionfloatInfoToPrecisionReprfloatPrecisionToInfoReprfloatInfoToBVTypeRepr fp80ToBitsfp80ToRational$fOrdFFloatInfoFloatInfoRepr$fEqFloatInfoRepr$$fTestEqualityFloatInfoFloatInfoRepr$fShowFFloatInfoFloatInfoRepr$fShowFloatInfoRepr$fPrettyFloatInfoRepr$fHashableFloatInfoRepr!$fHashableFFloatInfoFloatInfoRepr$fShowX86_80Val $fEqX86_80Val$fOrdX86_80ValUnaryBVwidth traversePredsunsignedRangesunsignedEntriesevaluate sym_evaluate instantiatedomainmuxneguexttrunc$fHashableUnaryBV $fEqUnaryBV$fTestEqualityNaturalUnaryBV StringSeqStringSeqEntryStringSeqLiteral StringSeqTerm stringSeqAbstraverseStringSeq$fMonoidStringSeqNote$fSemigroupStringSeqNote%$fMeasuredStringSeqNoteStringSeqEntry$fHashableStringSeq$fHashableFStringInfoStringSeq $fEqStringSeq!$fTestEqualityStringInfoStringSeqMatlabSolverFnBoolOrFn IsIntegerFnIntLeFn BVToIntegerFnSBVToIntegerFnIntegerToRealFnRealToIntegerFnPredToIntegerFnIntSeqFn RealSeqFnIndicesInRangeIsEqFn BVIsNonZeroFnClampedIntNegFnClampedIntAbsFnClampedIntAddFnClampedIntSubFnClampedIntMulFnClampedUIntAddFnClampedUIntSubFnClampedUIntMulFn IntSetWidthFnUIntSetWidthFn UIntToIntFn IntToUIntFnRealIsNonZeroFn RealCosFn RealSinFn RealToSBVFn RealToUBVFn PredToBVFnCplxIsNonZeroFn CplxIsRealFnRealToComplexFnRealPartOfCplxFnImagPartOfCplxFn CplxNegFn CplxAddFn CplxSubFn CplxMulFn CplxRoundFn CplxFloorFn CplxCeilFn CplxMagFn CplxSqrtFn CplxExpFn CplxLogFn CplxLogBaseFn CplxSinFn CplxCosFn CplxTanFn clampedIntAdd clampedIntSub clampedIntMul clampedIntNeg clampedIntAbsclampedUIntAddclampedUIntSubclampedUIntMulMatlabSymbolicArrayBuildermkMatlabSolverFntraverseMatlabSolverFnmatlabSolverArgTypesmatlabSolverReturnTypeppMatlabSolverFntestSolverFnEqevalMatlabSolverFn$fHashableMatlabSolverFn$fEqMatlabSolverFn ExprSymFnsymFnId symFnName symFnInfosymFnLoc SymFnInfoUninterpFnInfo DefinedFnInfoMatlabSolverFnInfoNonceApp AnnotationForallExists ArrayFromFn MapOverArraysArrayTrueOnEntriesFnApp ExprBoundVarBVarbvarIdbvarLocbvarNamebvarTypebvarKindbvarAbstractValueVarKindQuantifierVarKind LatchVarKindUninterpVarKindAppBaseIteBaseEqNotPredConjPred SemiRingSum SemiRingProd SemiRingLe RealIsIntegerIntDivIntModIntAbs IntDivisibleRealDivRealSqrtRealSpecialFunction BVTestBitBVSltBVUltBVOrBits BVUnaryTermBVConcatBVSelectBVFillBVUdivBVUremBVSdivBVSremBVShlBVLshrBVAshrBVRolBVRorBVZextBVSext BVPopcountBVCountTrailingZerosBVCountLeadingZerosFloatNegFloatAbs FloatSqrtFloatAddFloatSubFloatMulFloatDivFloatRemFloatFMA FloatFpEqFloatLeFloatLt FloatIsNaN FloatIsInf FloatIsZero FloatIsPos FloatIsNegFloatIsSubnorm FloatIsNorm FloatCast FloatRoundFloatFromBinary FloatToBinary BVToFloat SBVToFloat RealToFloat FloatToBV FloatToSBV FloatToRealFloatSpecialFunctionArrayMap ConstantArray UpdateArray SelectArray CopyArraySetArrayEqualArrayRange IntegerToReal RealToInteger BVToInteger SBVToInteger IntegerToBV RoundReal RoundEvenReal FloorRealCeilRealCplxRealPartImagPartStringContainsStringIsPrefixOfStringIsSuffixOf StringIndexOfStringSubstring StringAppend StringLength StructCtor StructFieldBVOrSetBVOrNoteExprSemiRingLiteralBoolExpr FloatExpr StringExprAppExpr NonceAppExpr BoundVarExpr AppExprCtor appExprId appExprLoc appExprAppappExprAbsValueNonceAppExprCtor nonceExprId nonceExprLoc nonceExprAppnonceExprAbsValue PrettyApp PrettyArg PrettyText PrettyFuncSplitPPExprList PPExprOptsppExpr_maxWidthppExpr_useDecimalPPExpr FixedPPExpr AppPPExprAPEapeIndexapeLocapeNameapeExprs apeLength BoundVarMapOccurrenceTablePPIndex ExprPPIndex RatPPIndex SemiRingView SR_ConstantSR_SumSR_Prod SR_GeneralCplxExprRealExpr IntegerExprBVExprDummy traverseAppappEqFhashAppisNonLinearApptraverseArrayResultWrapper$traverseArrayResultWrapperAssignmentasApp asNonceAppexprLocmkExpriteSize asSemiRingLit asSemiRingSumasSemiRingProd viewSemiRing asWeightedSum asConjunction asDisjunction asPosAtom asNegAtom exprAbsValue compareExprsameTermcountOccurrences incOccurrencecountOccurrences'cache boundVars boundVars'apeDoc textPPExpr stringPPExpr ppExprLengthparenIf ppExprDocdefaultPPExprOptsppExpr ppExprTopfindExprToRemoveppExpr' symFnArgTypessymFnReturnTypeasMatlabSolverFntestExprSymFnEqtraverseBVOrSet bvOrInsert bvOrSingleton bvOrContains bvOrUnion bvOrToListbvOrAbs nonceAppTypeappTypeunconstrainedAbsValue quantAbsEval abstractEval reduceAppppVar ppBoundVar ppVarTypeCode exprPrettyArgexprPrettyIndicesstringPrettyArg showPrettyArg prettyApp ppNonceAppppApp' $fShowApp$fShowFBaseTypeExprBoundVar$fShowExprBoundVar$fHashableBVOrSet $fEqBVOrSet$fSemigroupBVOrNote$fIsSymFnExprSymFn$fHashableExprSymFn $fEqExprSymFn$fShowExprSymFn$fHashableFBaseTypeExprBoundVar$fHashableExprBoundVar$fOrdFBaseTypeExprBoundVar$fOrdExprBoundVar"$fTestEqualityBaseTypeExprBoundVar$fEqExprBoundVar$fShowFBaseTypeExpr $fPrettyExpr $fShowExpr$fHashableFBaseTypeExpr$fHashableExpr $fOrdExpr$fEqExpr$fOrdFBaseTypeExpr$fTestEqualityBaseTypeExpr$fOrdNonceAppExpr$fEqNonceAppExpr$fOrdFBaseTypeNonceAppExpr"$fTestEqualityBaseTypeNonceAppExpr$fHasAbsValueExpr $fIsExprExpr$fPolyEqExprExpr'$fTraversableFCBaseTypeBaseTypeNonceApp$$fFoldableFCBaseTypeBaseTypeNonceApp#$fFunctorFCBaseTypeBaseTypeNonceApp$fHashableFBaseTypeNonceApp$fTestEqualityBaseTypeNonceApp $fEqNonceApp$fHashableFBaseTypeApp$fTestEqualityBaseTypeApp$fEqApp$fFoldableFCBaseTypeBaseTypeApp$fHasAbsValueDummy$fHashableFkDummy $fOrdFkDummy $fOrdDummy$fTestEqualitykDummy $fEqFkDummy $fEqDummy$fHashablePPIndex $fPrettyApp $fEqPPIndex $fOrdPPIndex$fGenericPPIndex AppTheory BoolTheoryLinearArithTheoryNonlinearArithTheoryComputableArithTheoryBitvectorTheoryQuantifierTheory StringTheoryFloatingPointTheory ArrayTheory StructTheoryFnTheory quantTheory typeTheory appTheory $fEqAppTheory$fOrdAppTheoryScope ExistsOnly ExistsForall VarRecorderCollectedVarInfoQuantifierInfoMapQuantifierInfoBVI boundTopTerm boundQuantboundVarboundInnerTerm BoundQuant ForallBound ExistBoundproblemFeaturesuninterpConstantsexistQuantifiersforallQuantifierslatches varErrorspredicateVarInfocollectVarInforecordExprVars$fFunctorVarRecorder$fApplicativeVarRecorder$fMonadVarRecorder$fMonadSTsVarRecorder ExprAllocatorappExpr nonceExprcacheStartSizeOptioncacheStartSizeDesc cacheTerms cacheOptDesc newStoragenewCachedStorageIdxCache ExprBuilderFlags SomeExprSymFnExprSymFnWrapper SymbolBindingVarSymbolBindingFnSymbolBindingSymbolVarBimapemptySymbolVarBimaplookupBindingOfSymbollookupSymbolOfBinding exprCounter userStateunaryThresholdcacheStartSize pushMuxOpsexprBuilderSplitConfigexprBuilderFreshConfig newIdxCachelookupIdxValue lookupIdxinsertIdxValuedeleteIdxValue clearIdxCache exprMaybeId idxCacheEval idxCacheEval' curProgramLoc sbNonceExpr sbMakeExprunaryThresholdOptionpushMuxOpsOptionnewExprBuildergetSymbolVarBimap stopCaching startCaching evalBoundVarsintSumrealSumbvSumbvUnary scalarMul$fOrdSymbolBinding$fEqSymbolBinding$fHashableFCtxMatlabFnWrapper $fTestEqualityCtxMatlabFnWrapper$fShowSomeExprSymFn$fHashableSomeExprSymFn$fOrdSomeExprSymFn$fEqSomeExprSymFn'$fMatlabSymbolicArrayBuilderExprBuilder-$fIsInterpretedFloatSymExprBuilderExprBuilder*$fIsInterpretedFloatExprBuilderExprBuilder+$fIsInterpretedFloatExprBuilderExprBuilder0+$fIsInterpretedFloatExprBuilderExprBuilder1$fIsSymExprBuilderExprBuilder$fIsExprBuilderExprBuilder$fFunctorExprTransformer$fApplicativeExprTransformer$fMonadExprTransformer$fMonadIOExprTransformer1$fMonadReaderExprTransformerTablesExprTransformer$fMonadErrorListExprTransformerModuleVerilogM ModuleStatevsInputs vsOutputsvsWires vsSeenNoncesvsUsedIdentifiers vsExpCache vsBVCache vsBoolCachevsSymItemInputOutputWireAssignBVConstIExpBinopUnop BVRotateL BVRotateRMuxBit BitSelectConcatBVLitBoolLitLHSLHSBitIdentNotBVNotAndOrXorEqNeLtLeBVAndBVOrBVXorBVAddBVSubBVMulBVDivBVRemBVPowBVShiftLBVShiftR BVShiftRA Identifier binopTypeiexpTypeexpTypemkLetsignedbinopscalMultlitBVlitBoolunopbit bitSelectconcat2mkModuleinitModuleState runVerilogM execVerilogM addBoundInput addFreshInput addOutputaddWirefreshIdentifier addFreshWire $fOrdBVConst$fFunctorVerilogM$fApplicativeVerilogM$fMonadVerilogM$fMonadStateModuleStateVerilogM$fMonadErrorListVerilogM$fMonadIOVerilogM $fEqBVConstexprToVerilogExpr moduleDoctypeDocidentDoclhsDocinputDocwireDocunopDocbinopDochexDocdecDociexpDoc rotateDocexpDoc exprsVerilog exprsToModulesimplifycount_subterms$fApplicativeOr $fFunctorOr GroundArray ArrayMapping ArrayConcreteGroundValueWrapperGVWunGVWExprRangeBindings GroundEvalFn groundEval GroundValue lookupArraydefaultValueForTypeevalGroundExprtryEvalGroundExprevalGroundNonceAppgroundEq evalGroundApp$fApplicativeMAnd $fFunctorMAndLogDatalogCallbackVerbose logVerbosity logReason logHandle SolverAdaptersolver_adapter_namesolver_adapter_config_optionssolver_adapter_check_satsolver_adapter_write_smt2 logCallbackdefaultLogDatadefaultWriteSMTLIB2FeaturesdefaultSolverAdaptersolverAdapterOptions smokeTest$fOrdSolverAdapter$fEqSolverAdapter$fShowSolverAdapter SMTReadWriter smtEvalFuns smtSatResultsmtUnsatCoreResultsmtAbductResultsmtAbductNextResultsmtUnsatAssumptionsResultSMTEvalFunctions smtEvalBool smtEvalBV smtEvalReal smtEvalFloatsmtEvalBvArray smtEvalStringSMTEvalBVArrayWrapperunEvalBVArrayWrapperSMTEvalBVArrayFnCollectorResultscrResult crBindingscrFreeConstants crSideConds DefineStyleFunctionDefinitionEqualityDefinition SMTWriter forallExpr existsExpr arrayConstant arraySelectcommentCommand assertCommandassertNamedCommand pushCommand popCommand push2Command pop2CommandpopManyCommands resetCommand checkCommandscheckWithAssumptionsCommandsgetUnsatAssumptionsCommandgetUnsatCoreCommandgetAbductCommandgetAbductNextCommand setOptCommanddeclareCommand defineCommandsynthFunCommanddeclareVarCommandconstraintCommanddeclareStructDatatype structCtor structProj stringTerm stringAppendresetDeclaredStructs writeCommandResponseStrictnessLenientStrictAcknowledgementAction AckAction runAckAction WriterConn smtWriterName connHandleconnInputHandlesupportFunctionDefssupportFunctionArgumentssupportQuantifiers strictParsingsupportedFeatures connStateSupportTermOpsboolExprnotExprandAllorAll.&&.||.==./= impliesExprletExprsumExprtermIntegerToRealtermRealToInteger integerTerm rationalTerm.<=.<.>.>=bvTermbvSLebvULebvSLtbvULt bvExtract bvTestBit bvSumExpr floatTerm realIsInteger realATan2smtFnApp smtFnUpdate lambdaTermfromTextArrayConstantFnTypeMap BoolTypeMapIntegerTypeMap RealTypeMap BVTypeMap FloatTypeMapUnicodeTypeMapComplexToStructTypeMapComplexToArrayTypeMapPrimArrayTypeMapFnArrayTypeMap StructTypeMapappapp_listnullAcknowledgementActionresetEntryStackpopEntryStackToTopentryStackHeightpushEntryStack popEntryStack newWriterConnparserStrictnesscacheLookupFnNameBimap addCommandaddCommandNoAck addCommands mkFreeVar bindVarAsFree assumeFormulaassumeFormulaWithNameassumeFormulaWithFreshName addSynthFun addDeclareVar addConstraintfreshBoundVarNametypeMap runInSandbox mkBaseExpr mkSMTTerm mkFormulamkAtomicFormulaassumesmtExprGroundEvalFn$fTestEqualityBaseTypeTypeMap $fEqTypeMap $fShowTypeMap$fShowFBaseTypeTypeMap$fEqDefineStyle$fShowDefineStyle$fEqTermLifetime$fEqResponseStrictness$fShowResponseStrictnessSMTLib2ExceptionSMTLib2Unsupported SMTLib2ErrorSMTLib2ParseErrorSMTLib2ResponseUnrecognizedSMTLib2InvalidResponse SMTResponse AckSuccessAckUnsupportedAckErrorAckSatAckUnsat AckUnknown AckInfeasibleAckFailRspName RspVersionRspErrBehaviorRspOutOfMemoryRspRsnIncomplete RspUnkReasonAckSuccessSExp AckSkippedstrictSMTParsingstrictSMTParseOptsmtParseOptionsgetSolverResponsegetLimitedSolverResponse$fExceptionSMTLib2Exception$fShowSMTLib2Exception$fEqSMTResponse$fShowSMTResponseEmptyExprBuilderStateResultresSExpr resFreeVarEnv resSymFnEnvcfgAllowFreeVarscfgAllowFreeSymFnsSExpr ppFreeVarEnvppFreeSymFnEnv defaultConfig serializeExprserializeExprWithConfigserializeSymFnserializeSymFnWithConfigserializeBaseTypeconvertBaseTypes$fEqSKey $fOrdSKey $fShowSKey cSymFnLookup cExprLookupdeserializeExprdeserializeExprWithConfigdeserializeSymFndeserializeSymFnWithConfigdeserializeBaseType readBaseTypesExprEquivResultExprEquivalentExprNormEquivalent ExprUnequal normSymFnnormExpr testEquivExprtestEquivSymFn SolverProcess solverConnsolverCleanupCallback solverHandlesolverErrorBehavior solverStderrsolverEvalFuns solverLogFn solverNamesolverEarlyUnsatsolverSupportsResetAssertionssolverGoalTimeoutSolverGoalTimeoutgetGoalTimeoutInMilliSeconds ImmediateExitContinueOnError OnlineSolverstartSolverProcessshutdownSolverProcessAnOnlineSolvergetGoalTimeoutInSeconds solverStdinsolverResponse killSolvercheckSatisfiable getAbductscheckSatisfiableWithModelresettryPop inNewFrameinNewFrame2OpeninNewFrame2CloseinNewFrameWithVarscheckWithAssumptionscheckWithAssumptionsAndModelcheckcheckAndGetModel getSatResultwithLocalGoalTimeout$fShowSolverGoalTimeout$fPrettySolverGoalTimeout$fExceptionRunawaySolverTimeout$fShowRunawaySolverTimeoutSearchStrategyExponentialSearch BinarySearch ResolvedSymBV BVConcrete BVSymbolic resolveSymBV$fShowResolvedSymBV$fPrettySearchStrategySMTLib2GenericSolverdefaultSolverPathdefaultSolverArgsdefaultFeaturessupportsResetAssertionssetDefaultLogicAndOptionsnewDefaultWriter withSolverrunSolverInOverrideSession sessionWritersessionResponseWriter SMTLib2Tweaks smtlib2tweakssmtlib2exitCommandsmtlib2arrayTypesmtlib2arrayConstantsmtlib2arraySelectsmtlib2arrayUpdatesmtlib2StringSortsmtlib2StringTermsmtlib2StringLengthsmtlib2StringAppendsmtlib2StringContainssmtlib2StringIndexOfsmtlib2StringIsPrefixOfsmtlib2StringIsSuffixOfsmtlib2StringSubstringsmtlib2StructSortsmtlib2StructCtorsmtlib2StructProjsmtlib2declareStructCmd all_supportedsmtlib2Options arrayStore asSMT2Type newWriter writeCheckSat writeExit writeGetValuewriteGetAbductwriteGetAbductNextwriteCheckSynth parseFnModel parseFnValues runGetAbducts runCheckSat smtAckResultsmtLibEvalFunswriteDefaultSMT2defaultFileWriter startSolvershutdownSolverdefaultSolverBoundsppSolverVersionCheckErrorppSolverVersionError nameResultqueryErrorBehavior versionResultcheckSolverVersion'checkSolverVersion$fSupportTermOpsTerm $fNumTerm$fSMTLib2Tweaks()$fSMTWriterWriter$fSMTReadWriterWriter$fFunctorProcessor$fApplicativeProcessor$fMonadProcessor$fMonadIOProcessor$fMonadErrorListProcessor"$fMonadReaderProcessorEnvProcessor $fEqAssoc $fOrdAssoc $fShowAssoc$fEqSMTFloatPrecision$fOrdSMTFloatPrecisionZ3z3Path z3Timeoutz3Tacticz3TacticDefault z3Options z3Adapter z3FeatureswriteZ3SMT2FilerunZ3InOverridewithZ3 runZ3HornwriteZ3HornSMT2File$fOnlineSolverWriter$fSMTLib2GenericSolverZ3$fSMTLib2TweaksZ3$fShowZ3YicesExceptionYicesUnsupported YicesErrorYicesParseError Connection yicesTypeefSolveCommand newConnection sendChecksendCheckExistsForall assertForallsetParamsetYicesParams yicesEvalBoolyicesDefaultFeatures yicesAdapter yicesPathyicesEnableMCSatyicesEnableInteractiveyicesGoalTimeout yicesOptionswriteYicesFilerunYicesInOverride$fOnlineSolverConnection$fSupportTermOpsYicesTerm$fNumYicesTerm$fSMTWriterConnection$fExceptionYicesException$fShowYicesException$fSMTReadWriterConnection#$fExceptionUnparseableYicesResponse$fShowUnparseableYicesResponseSTPstpPath stpTimeout stpOptions stpAdapter stpFeaturesrunSTPInOverridewithSTP$fSMTLib2GenericSolverSTP$fSMTLib2TweaksSTP $fShowSTP ExternalABCabcPath abcOptionsexternalABCAdapterwriteABCSMT2FilerunExternalABCInOverride!$fSMTLib2GenericSolverExternalABC$fSMTLib2TweaksExternalABC$fShowExternalABC DRealBindingsDReal drealPath drealOptions drealAdapterwriteDRealSMT2FilegetAvgBindingsgetBoundBindingsrunDRealInOverride$fSMTLib2TweaksDReal $fShowDRealCVC5cvc5Path cvc5Timeout cvc5Options cvc5Adapter cvc5FeatureswriteMultiAsmpCVC5SMT2FilewriteCVC5SMT2FilerunCVC5InOverridewithCVC5 runCVC5SyGuSwithCVC5_SyGuSwriteCVC5SyFile$fSMTLib2GenericSolverCVC5$fSMTLib2TweaksCVC5 $fSMTLib2GenericSolverCVC5_SyGuS$fSMTLib2TweaksCVC5_SyGuS$fShowCVC5_SyGuS $fShowCVC5CVC4cvc4Path cvc4Timeout cvc4Options cvc4Adapter cvc4FeatureswriteMultiAsmpCVC4SMT2FilewriteCVC4SMT2FilerunCVC4InOverridewithCVC4$fSMTLib2GenericSolverCVC4$fSMTLib2TweaksCVC4 $fShowCVC4 Boolector boolectorPathboolectorTimeoutboolectorOptionsboolectorAdapterrunBoolectorInOverride withBoolectorboolectorFeatures$fSMTLib2GenericSolverBoolector$fSMTLib2TweaksBoolector$fShowBoolectorBitwuzla bitwuzlaPathbitwuzlaTimeoutbitwuzlaOptionsbitwuzlaAdapterrunBitwuzlaInOverride withBitwuzlabitwuzlaFeatures$fSMTLib2GenericSolverBitwuzla$fSMTLib2TweaksBitwuzla$fShowBitwuzlaWordMap SimpleWordMap emptyWordMap muxWordMap insertWordMap lookupWordMap GHC.Types ghc-bignumGHC.Num.IntegerIntegerData.Parameterized.CtxCtx-+* Data.Type.Ord<=Data.Type.Equality TestEquality testEquality:~:Refl#Data.Parameterized.NatRepr.InternalNatReprnatValue NatComparisonNatLTNatEQNatGTData.Parameterized.SomeSomeData.Parameterized.NatReprNatCases NatCaseLT NatCaseEQ NatCaseGTLeqProof IsZeroNatZeroNat NonZeroNat withKnownNatknownNat minUnsigned maxUnsigned minSigned maxSigned unsignedClamp signedClampmaxNatdivNat compareNatintValuewidthVal isZeroNat isZeroOrGT1decNatpredNatincNathalfNataddNatsubNat withDivModNat natMultiply toUnsignedtoSignedsomeNat mkNatReprplusComm plusAssocmulCommmul2PlusplusMinusCancelminusPlusCanceladdMulDistribRightwithAddMulDistribRightwithSubMulDistribRight decideLeq testStrictLeq testNatCaseslessThanIrreflexivelessThanAsymmetrictestLeqleqReflleqSuccleqTransleqZeroleqAdd2leqSub2leqProof withLeqProofisPosNat leqMulCongr leqMulPos leqMulMonoleqAdd leqAddPosleqSubaddIsLeqaddPrefixIsLeq dblPosIsPos addIsLeqLeft1withAddPrefixLeq withAddLeq natForEach natFromZeronatRec natRecStrong natRecBoundednatRecStrictlyBounded mulCancelRlemmaMulSingPolyfromMappos_monomonorootFromRationalGHC.Base. readDecimal' readDigitsCanParseparsereadFromHandlepeekChardropWhitespace matchChar matchStringparseUntilCloseParen takeChars' takeCharsparseQuotedStringmatchApp checkParen parseDecimalparseDefineFun chain_app assoc_app lcThreadMapStringIOControl.Monad.IO.ClassMonadIO GHC.Floatlog GHC.MaybeNothing CallStack formatFloatparseId text-2.0.2Data.Text.InternalTextparseAnySymbolsmtlibKeywords mergeGenericReciprocalRange halfRangeGHC.Realshrinkclampzboundsrbounds sdivRangequotscaleDownRangemixedDomainsOverlapoverlapCandidatesphase expandVarslesserbsFindSubstringrangeIsInteger rangeOverlap mapAntiRangeNotemkNote sumMapHashSumMap unfilteredSumsumMapmkProd ppRational ConfigTrie splitPath defaultOpt set_opt_help insertOptionadjustConfigTrieadjustConfigMaptraverseConfigMaptraverseConfigTrietraverseSubtreetryInsertOption builtInOptsControl.Exception.Base catchJusttryJustJustOrdFData.Parameterized.MapMapFSymBV'realExprAsRationalcplxLog'(unliftio-0.2.25.0-2sxG0tBpVbrLTvgSDr75DTUnliftIO.Internals.AsynccancelwaitthreadKilledHandlerGHC.IO.Exception ThreadKilled withAsyncPredBinSWordBinSWordUnw_bvLg2bvUnbvBin bvBinPred unsupportedtotalMaybestripDuplicatePreds compareLt completeList StringSeqNotebinCtx _varErrorsaddFeaturesForVarType addBothVarrecordAssertionVarsrecurseAssertedNonceAppExprVarsrecurseAssertedAppExprVarsrecurseNonceAppVarsrecurseExprVars addExistVar addForallVarFalse ArrayMapViewExprTransformerEvalHashTables CachedSymFnsbZerosbConfiguration sbFloatReducesbUnaryThresholdsbCacheStartSize sbPushMuxOps sbExprCountersbCurAllocatorsbNonLinearOps sbProgramLoc sbUserStatesbMatlabFnCache sbFloatModeupdateVarBindingsbMakeBoundVar sbFreshIndexunaryThresholdDescpushMuxOpsDesc betaReduce runIfChangedrecordBoundVar evalSimpleFnControl.Monad.FailfailsbConcreteLookupsliceArrayLookupUpdatesbTryUnaryTerm viewArrayMapunderlyingArrayMapExprconcreteArrayEntriescheckAbsorptiontryAndAbsorptiontryOrAbsorption semiRingLe semiRingEq recordExpr updateArraytoDouble SMTSource SMTCollectorSMTCollectorStatefreshBoundTermFnrecordSideCondFn FreshVarFn TermLifetime DeleteNever DeleteOnPop entryStackstateRef varBindingsconsumeAcknowledgement WriterStateSMTExprasBase nextTermIdx lastPositionposition freshVarName freshVarName' firstJustMmaybeMmaybewhenMwhenwithWriterStateupdateProgramLoc declareTypes defineSMTVartypeMapFirstClass freshBoundFnfreshBoundTermfreshBoundTerm'addSideConditionrunOnLiveConnection forallResultimpliesAllExpr existsResultcacheWriterResultbindVarcheckVarTypeSupportcheckArgumentTypesevalFirstClassTypeReprmkIndexLitTermmkIndexLitTermscreateTypeMapArgsForArray getSymbolNamedefineSMTFunctionmkIndicesTerms mkSMTSymFn getSMTSymFnsmtIndicesTermsfreshSandboxBoundTermSKey envConfig envIdCounterenvLetBindings envFreeVarEnvenvFreeSymFnEnv envBoundVarsserializeSomethingletFnconvertExprWithLet convertSymFn addLetBinding convertExprconvertBoundVarExprOpOp1Op2Op3Op4BVOp1BVOp2BVComp2BVProof ProcessorEnvprocSymprocSymFnLookupprocExprLookup procLetEnv procLetFnEnv prefixErrorfromMaybeError getBVProoflookupOp readOneArg readTwoArgs readThreeArgsreadApp intToNatMexpectArrayUpdateMap!? parseIndexLit readLetExprreadExpr readExprsunsnocGHC.Listinitlast readLetFnExpr normAppExprRunawaySolverTimeoutGHC.IO.StdHandlesstdin%bv-sized-1.0.5-8LpT1qlv2ViHkYuuaiyyO1Data.BitVector.Sized.InternalBVSolverVersionCheckErrorsmtFloatExponentBitssmtFloatSignificandBitsnestedArrayUpdate textToTerm unescapeTextparseBvSolverValueparseBVLitHelper runGetValuenatBVz3StrictParsing YicesCommand YicesTypeasYicesConfigValueshowModelCommandsetParamCommand sendShowModelgetSatResponse yicesEvalReal yicesEvalBVyicesStrictParsingcheckSupportedByYicesstpStrictParsingabcStrictParsing CVC5_SyGuScvc5StrictParsingcvc4StrictParsingboolectorStrictParsingbitwuzlaStrictParsing