h&g      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          !!!!!!!!!!!!!!!!!"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""# Safe-Inferred "%&(&543210/.-,+*)('&%$#"!  6789:;<=>?@543210/.-,+*)('&%$#"!  6789:;<=>?@ Safe-Inferred "%&(,HBhevmB renders a  as a multi-line  complete with addressing, hex digits, and ASCII representation. Sample output Length: 100 (0x64) bytes 0000: 4b c1 ad 8a 5b 47 d7 57 48 64 e7 cc 5e b5 2f 6e K...[G.WHd..^./n 0010: c5 b3 a4 73 44 3b 97 53 99 2d 54 e7 1b 2f 91 12 ...sD;.S.-T../.. 0020: c8 1a ff c4 3b 2b 72 ea 97 e2 9f e2 93 ad 23 79 ....;+r.......#y 0030: e8 0f 08 54 02 14 fa 09 f0 2d 34 c9 08 6b e1 64 ...T.....-4..k.d 0040: d1 c5 98 7e d6 a1 98 e2 97 da 46 68 4e 60 11 15 ...~......FhN`.. 0050: d8 32 c6 0b 70 f5 2e 76 7f 8d f2 3b ed de 90 c6 .2..p..v...;.... 0060: 93 12 9c e1 ....ChevmC displays a number in hexidecimal and pads the number with 0 so that it has a minimum length of w.DhevmD converts a  to a - showing the octets grouped in 32-bit words. Sample output 4b c1 ad 8a 5b 47 d7 57hevm returns  for non-control ascii characters. These characters will all fit in a single character when rendered.hevm( breaks up a list into sublists of size n&. The last group may be smaller than n elements. When n8 less not positive the list is returned as one sublist.BCDBDC Safe-Inferred "%&(-hevm8Opaque representation of the C library's context struct.Ehevm5Run a given precompiled contract using the C library.Ehevm&The number of the precompiled contracthevmThe input bufferhevmThe desired output sizehevmHopefully, the output bufferEE Safe-Inferred "%&(.FhevmTurn a list state value into a widget given an item drawing function.Fhevm1Rendering function, True for the selected elementhevmWhether the list has focushevmThe List to be renderedhevmrendered widgetFGFG Safe-Inferred"%&()1<E%HhevmA four bit valueShevm https://docs.soliditylang.org/en/v0.8.19/abi-spec.html#function-selectorhevm'A specification for an initial VM statehevmWe have two variants here to optimize the fully concrete case. ConcreteRuntimeCode just wraps a ByteString SymbolicRuntimeCode is a fixed length vector of potentially symbolic bytes, which lets us handle symbolic pushdata (e.g. from immutable variables in solidity).hevmA contract is either in creation (running its "constructor") or post-creation, and code in these two modes is treated differently by instructions like  EXTCODEHASH+, so we distinguish these two code types.The definition follows the structure of code output by solc. We need to use some heuristics here to deal with symbolic data regions that may be present in the bytecode since the fully abstract case is impractical:initcode has concrete code, followed by an abstract data "section"runtimecode has a fixed length, but may contain fixed size symbolic regions (due to immutable)hopefully we do not have to deal with dynamic immutable before we get a real data section...hevm Constructor code, during contract creationhevmInstance code, after contract creationhevmThe cache is data that can be persisted for efficiency: any expensive query that is constant at least within a block.hevmA unique id for a given pchevmThe state of a contracthevmData about the blockhevmVarious environmental datahevmWhen doing symbolic execution, we have three different ways to model the storage of contracts. This determines not only the initial contract storage model but also how RPC or state fetched contracts will be modeled.hevmUses Concrete Storage. Reading / Writing from abstract locations causes a runtime failure. Can be nicely combined with RPC.hevmUses Symbolic Storage. Reading / Writing never reaches RPC, but always done using an SMT array with no default value.hevmUses Symbolic Storage. Reading / Writing never reaches RPC, but always done using an SMT array with 0 as the default value.hevm(The state that spans a whole transactionhevm:The "registers" of the VM along with memory and data stackhevm+The "accrued substate" across a transactionhevmCall/create infohevm(An entry in the VM's "call/create stack"hevmAlias for the type of e.g. exec1.hevm%The state of a stepwise EVM executionhevmhow many times we've visited a loc, and what the contents of the stack were when we were there lasthevm"The possible result states of a VMhevmAn operation failedhevm$Reached STOP, RETURN, or end-of-codehevm3An effect must be handled for execution to continuehevm$Execution could not continue furtherhevm)The possible return values of a SMT queryhevm0Execution could proceed down one of two brancheshevmQueries halt execution until resolved through RPC calls or SMT querieshevmEffect types used by the vm implementation for side effects & control flowhevm7Sometimes we can only partially execute a given programhevmCore EVM Error Typeshevm=Expr implements an abstract respresentation of an EVM programThis type can give insight into the provenance of a term which is useful, both for the aesthetic purpose of printing terms in a richer way, but also to allow optimizations on the AST instead of letting the SMT solver do all the heavy lifting.Memory, calldata, and returndata are all represented as a Buf. Semantically speaking a Buf is a byte array with of size 2^256.Bufs have two base constructors: - AbstractBuf: all elements are fully abstract values - ConcreteBuf bs: all elements past (length bs) are zeroBufs can be read from with: - ReadByte idx buf: read the byte at idx from buf - ReadWord idx buf: read the byte at idx from bufBufs can be written to with: - WriteByte idx val buf: write val to idx in buf - WriteWord idx val buf: write val to idx in buf - CopySlice srcOffset dstOffset size src dst: overwrite dstOffset -> dstOffset + size in dst with srcOffset -> srcOffset + size from srcNote that the shared usage of  does allow for the construction of some badly typed Expr instances (e.g. an MSTORE on top of the contents of calldata instead of some previous instance of memory), we accept this for the sake of simplifying pattern matches against a Buf expression.Storage expressions are similar, but instead of writing regions of bytes, we write a word to a particular key in a given addresses storage. Note that as with a Buf, writes can be sequenced on top of concrete, empty and fully abstract starting states.One important principle is that of local context: e.g. each term representing a write to a Buf  Storage  Logs will always contain a copy of the state that is being added to, this ensures that all context relevant to a given operation is contained within the term that represents that operation.When dealing with Expr instances we assume that concrete expressions have been reduced to their smallest possible representation (i.e. a , , or ). Failure to adhere to this invariant will result in your concrete term being treated as symbolic, and may produce unexpected errors. In the future we may wish to consider encoding the concreteness of a given term directly in the type of that term, since such type level shenanigans tends to complicate implementation, we skip this for now.hevmThis just overflows silently, and is generally a terrible footgun, should be removedHIJLKMNOPQRSUTV~}|{zyxwvutsrqponmlkjihgfedcba`_^]\[ZYXWV~}|{zyxwvutsrqponmlkjihgfedcba`_^]\[ZYXWSUTQROPMNJLKHI32444444.Generic traversal functions for Expr datatypes Safe-Inferred "%&(1Nhevm!Generic operations over AST termshevmRecursively folds a given function over a given expression Recursion schemes do this & a lot more, but defining them over GADT's isn't worth the hasslehevmRecursively applies a given function to every node in a given expr instance Recursion schemes do this & a lot more, but defining them over GADT's isn't worth the hassle   Safe-Inferred "%&(N  Safe-Inferred "%&(OhevmThe  function for our desired monadhevmThe  function for the same monadhevmThe puts and gets to execute&& +Expr passes to determine Keccak assumptions Safe-Inferred "%&(1P  Safe-Inferred "%&(1]hevmIf a given binary op is commutative, then we always force Lits to the lhs if only one argument is a Lit. This makes writing pattern matches in the simplifier easier.hevm.Extracts the byte at a given index from a Buf.We do our best to return a concrete value wherever possible, but fallback to an abstract expresion if nescessary. Note that a Buf is an infinite structure, so reads outside of the bounds of a ConcreteBuf return 0. This is inline with the semantics of calldata and memory, but not of returndata.hevmReads n bytes starting from idx in buf and returns a left padded word*If n is >= 32 this is the same as readWordhevm1Reads the word starting at idx from the given bufhevmCopies a slice of src into dst.0 srcOffset srcOffset + size length src J--------------J------------------J-----------------J src: | | ------ sl ------ | | J--------------J------------------J-----------------J0 dstOffset dstOffset + size length dst J--------J------------------J-----------------J dst: | hd | | tl | J--------J------------------J-----------------Jhevm$Returns the length of a given bufferIf there are any writes to abstract locations, or CopySlices with an abstract size or dstOffset, an abstract expresion will be returned.hevm=If a buffer has a concrete prefix, we return it's length herehevmReturn the minimum possible length of a buffer. In the case of an abstract buffer, it is the largest write that is made on a concrete location. Parameterized by an environment for buffer variables.hevm Returns the first n bytes of bufhevm/Returns everything but the first n bytes of bufhevm8Removes any irrelevant writes when reading from a bufferhevmStrips writes from the buffer that can be statically determined to be out of range TODO: are the bounds here correct? I think there might be some off by one mistakes...hevmReads the word at the given slot from the given storage expression.Note that we return a Nothing instead of a 0x0 if we are reading from a store that is backed by a ConcreteStore or an EmptyStore and there have been no explicit writes to the requested slot. This makes implementing rpc storage lookups much easier. If the store is backed by an AbstractStore we always return a symbolic value.hevm0Writes a value to a key in a storage expression.Concrete writes on top of a concrete or empty store will produce a new ConcreteStore, otherwise we add a new write to the storage expression.hevmSimple recursive match based AST simplification Note: may not terminate!hevm,Returns the byte at idx from the given word.hevmConverts a list of bytes into a W256. TODO: semantics if the input is too large?hevmTrue if the given expression contains any node that satisfies the input predicate  Safe-Inferred "%&(1^WVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~VWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~  Safe-Inferred "%&(_-Common subexpression elimination for Expr ast Safe-Inferred "%&(1a hevm.Common subexpression elimination pass for Exprhevm.Common subexpression elimination pass for Prophevm6Common subexpression elimination pass for list of Prophevm6Common subexpression elimination pass for list of PropUtilities for building and executing SMT queries from Expr instances Safe-Inferred"%&()1ihevma final post shrinking cex, buffers here are all represented as concrete bytestringshevmThis representation lets us store buffers of arbitrary length without exhausting the available memory, it closely matches the format used by smt-lib when returning models for arrayshevmA model for a buffer, either in it's compressed form (for storing parsed models from a solver), or as a bytestring (for presentation to users)hevmAttemps to collapse a compressed buffer representation down to a flattened onehevmReads all intermediate variables from the builder state and produces SMT declaring them as constantshevmThis function overapproximates the reads from the abstract storage. Potentially, it can return locations that do not read a slot directly from the abstract store but from subsequent writes on the store (e.g, SLoad addr idx (SStore addr idx val AbstractStore)). However, we expect that most of such reads will have been simplified away.hevmAsserts that buffer reads beyond the size of the buffer are equal to zero. Looks for buffer reads in the a list of given predicates and the buffer and storage environments.hevmFinds the maximum read index for each abstract buffer in the input propshevmReturns an SMT2 object with all buffers referenced from the input props declared, and with the appropriate cex extraction metadata attachedhevmStores a region of src into dsthevm:Unrolls an exponentiation into a series of multiplicationshevm4Concatenates a list of bytes into a larger bitvectorhevm4Concatenates a list of bytes into a larger bitvectorhevmQueries the solver for models for each of the expressions representing the max read index for a given bufferhevmGets the initial model for each buffer, these will often be much too large for our purposeshevmInterpret an N-dimensional array as a value of type a. Parameterized by an interpretation function for array values.hevm.Interpret an 1-dimensional array as a functionhevm.Interpret an 2-dimensional array as a functionSolver orchestration Safe-Inferred "%&()1ohevm#The result of a call to (check-sat)hevmA script to be executed, a list of models to be extracted in the case of a sat result, and a channel where the result should be writtenhevm)A channel representing a group of solvershevmA running solver instancehevmSupported solvershevm-Arguments used when spawing a solver instancehevmSpawns a solver instance, and sets the various global config options that we use for our querieshevm*Cleanly shutdown a running solver instnacehevmSends a list of commands to the solver. Returns the first error, if there was one.hevmSends a single command to the solver, returns the first available line from the output bufferhevmSends a string to the solver and appends a newline, returns the first available line from the output bufferhevmSends a string to the solver and appends a newline, doesn't return stdouthevmReturns a string representation of the model for the requested variablehevm1Reads lines from h until we have a balanced sexpr'';Assembler for EVM opcodes used in the HEVM symbolic checker Safe-Inferred "%&(1p Safe-Inferred "%&(1qhevmDecode a sequence type (e.g. tuple / array). Will fail for non sequence typeshevmPretty-print some .;; Safe-Inferred"%&(1=?y hevm,The various project types understood by hevmhevm5A mapping from source files to (maybe) their contentshevmSolidity source files are identified either by their location in the vfs, or by a src map identifierhevmA mapping from contract identifiers (filepath:name) to their ast json hevmA mapping from contract identifiers (filepath:name) to a SolcContract object hevm&specified to not read blockchain state hevm,specified to not modify the blockchain state hevm,function does not accept Ether - the default hevmfunction accepts Ether hevmReads all solc ouput json files found under the provided filepath and returns them merged into a BuildOutputhevmFinds all json files under the provided filepath, searches recursivelyhevmFilters out metadata json fileshevmReads a foundry json output hevm)Parses the standard json output from solc hevmWhen doing CREATE and passing constructor arguments, Solidity loads the argument data via the creation bytecode, since there is no "calldata" for CREATE.This interferes with our ability to look up the current contract by codehash, so we must somehow strip away this extra suffix. Luckily we can detect the end of the actual bytecode by looking for the "metadata hash". (Not 100% correct, but works in practice.)Actually, we strip away the entire BZZR suffix too, because as long as the codehash matches otherwise, we don't care if there is some difference there. hevmEvery node in the AST has an ID, and other nodes reference those IDs. This function recurses through the tree looking for objects with the "id" key and makes a big map from ID to value. for the EVM given a secret key Safe-Inferred "%&(| hevmWe don't want to introduce the machinery needed to sign with a random nonce, so we just use the same nonce every time (420). This is obviously very insecure, but fine for testing purposes.   Safe-Inferred"%&()1J hevm*A stack frame can be popped in three ways. hevmSTOP, RETURN, or no more code hevmREVERT hevmAny other error hevmAn "external" view of a contract's bytecode, appropriate for e.g.  EXTCODEHASH. hevm)Initialize empty contract with given code hevmUpdate program counter hevmExecutes the EVM one step hevmChecks a *CALL for failure; OOG, too many callframes, memory access etc. hevm5Construct RPC Query and halt execution until resolved hevm>Loads the selected contract as the current contract to execute hevm2Burn gas, failing if insufficient gas is available hevmreturns a wrapped boolean- if true, this address has been touched before in the txn (warm gas cost as in EIP 2929) otherwise cold hevmreturns a wrapped boolean- if true, this slot has been touched before in the txn (warm gas cost as in EIP 2929) otherwise cold hevmReplace a contract's code, like when CREATE returns from the constructor code. hevmThis function defines how to pop the current stack frame in either of the ways specified by  .It also handles the case when the current stack frame is the only one; in this case, we set the final _result of the VM execution. hevmThe length of the code ignoring any constructor args. This represents the region that can contain executable opcodes hevmThe length of the code including any constructor args. This can return an abstract value  Safe-Inferred "%&(1(   Safe-Inferred "%&(   Safe-Inferred "%&(   Safe-Inferred "%&(1S  Safe-Inferred "%&( hevm1bytecode modulo immutables, to identify contracts( (  Safe-Inferred "%&(  Safe-Inferred "%&(1   Safe-Inferred "%&( hevmutility function for getting a more useful representation of accesslistentries duplicates only matter for gas computation hevm,Increments origin nonce and pays gas deposit hevmGiven a valid tx loaded into the vm state, subtract gas payment from the origin, increment the nonce and pay receiving address$ $  Safe-Inferred "%&()1- hevm/Abstract representation of an RPC fetch request hevmChecks which branches are satisfiable, checking the pathconditions for consistency if the third argument is true. When in debug mode, we do not want to be able to navigate to dead paths, but for normal execution paths with inconsistent pathconditions will be pruned anyway.   Safe-Inferred "%&(1 hevm'Type alias for an operational monad of Action hevm-The instruction type of the operational monad hevm6Keep executing until an intermediate result is reached hevm5Keep executing until an intermediate state is reached hevmWait for a query to be resolved hevmMultiple things can happen hevmEmbed a VM state transformation hevmPerform an IO action hevm4Run the VM until final result, resolving all queries hevm Run the VM until its final state   Safe-Inferred "%&(1=y hevm8A method name, and the (ordered) types of it's arguments hevm%Abstract calldata argument generation hevmGenerates calldata matching given type signature, optionally specialized with concrete arguments. Any argument given as " symbolic8" or omitted at the tail of the list are kept symbolic. hevmInterpreter which explores all paths at branching points. Returns an 'Expr End' representing the possible executions. hevmLoop head detection heuristicThe main thing we wish to differentiate between, are actual loop heads, and branch points inside of internal functions that are called multiple times.One way to do this is to observe that for internal functions, the compiler must always store a stack item representing the location that it must jump back to. If we compare the stack at the time of the previous visit, and the time of the current visit, and notice that this location has changed, then we can guess that the location is a jump point within an internal function instead of a loop (where such locations should be constant between iterations).This heuristic is not perfect, and can certainly be tricked, but should generally be good enough for most compiler generated and non pathological user generated loops. hevm5Checks if an assertion violation has been encountered8hevm recognises the following as an assertion violation: &the invalid opcode (0xfe) (solc < 0.8)a revert with a reason of the form `abi.encodeWithSelector("Panic(uint256)", code)`, where code is one of the following (solc >= 0.8): - 0x00: Used for generic compiler inserted panics. - 0x01: If you call assert with an argument that evaluates to false. - 0x11: If an arithmetic operation results in underflow or overflow outside of an unchecked { ... } block. - 0x12; If you divide or modulo by zero (e.g. 5 / 0 or 23 % 0). - 0x21: If you convert a value that is too big or negative into an enum type. - 0x22: If you access a storage byte array that is incorrectly encoded. - 0x31: If you call .pop() on an empty array. - 0x32: If you access an array, bytesN or an array slice at an out-of-bounds or negative index (i.e. x[i] where i >= x.length or i < 0). - 0x41: If you allocate too much memory or create an array that is too large. - 0x51: If you call a zero-initialized variable of internal function type.see: https://docs.soliditylang.org/en/v0.8.6/control-structures.html?highlight=Panic#panic-via-assert-and-error-via-require hevm7By default hevm only checks for user-defined assertions hevm?Produces the revert message for solc >=0.8 assertion violations hevmBuilds a buffer representing calldata from the provided method description and concrete arguments hevmStepper that parses the result of Stepper.runFully into an Expr End hevmConverts a given top level expr into a list of final states and the associated path conditions for each state. hevmStrips unreachable branches from a given expr Returns a list of executed SMT queries alongside the reduced expression for debugging purposes Note that the reduced expression loses information relative to the original one if jump conditions are removed. This restriction can be removed once Expr supports attaching knowledge to AST nodes. Although this algorithm currently parallelizes nicely, it does not exploit the incremental nature of the task at hand. Introducing support for incremental queries might let us go even faster here. TODO: handle errors properly hevmEvaluate the provided proposition down to its most concrete result hevm+Extract contraints stored in Expr End nodes hevmSymbolically execute the VM and check all endstates against the postcondition, if available. hevmCompares two contract runtimes for trace equivalence by running two VMs and comparing the end states.We do this by asking the solver to find a common input for each pair of endstates that satisfies the path conditions for both sides and produces a differing output. If we can find such an input, then we have a clear equivalence break, and since we run this check for every pair of end states, the check is exhaustive. hevmTakes a buffer and a Cex and replaces all abstract values in the buf with concrete ones from the Cex.  Safe-Inferred "%&(1 hevm*This is like an unresolved source mapping.hevm&Generate VeriOpts from UnitTestOptionshevm$Top level CLI endpoint for hevm testhevmAssuming a constructor is loaded, this stepper will run the constructor to create the test contract, give it an initial balance, and run `setUp()'.hevmAssuming a test contract is loaded and initialized, this stepper will run the specified test method and return whether it succeeded.hevm;Randomly generates the calldata arguments and runs the testhevmRuns an invariant test, calls the invariant before execution beginshevm/Define the thread spawner for normal test caseshevm2Define the thread spawner for property based testshevm,Define the thread spawner for symbolic tests            !$Helpers for repl driven hevm hacking Safe-Inferred "%&(1hevm1Builds the Expr for the given evm bytecode object# Safe-Inferred "%&(R" Safe-Inferred"%&(1>hevmEach step command in the terminal should finish immediately with one of these outcomes.hevmProgram finishedhevmTook one step; more steps to gohevmRun a specific number of stepshevm Finish when a VM predicate holdshevm This turns a Stepper into a state action usable from within the TTY loop, yielding a  StepOutcome depending on the StepMode.$%&'(()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmmnnoppqqrrsstuvwxyz{|}~                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     !!!!!!!!!!!!!!!!!""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" """"""""""""""""""""""""""""""""""""""""""""########hevm-0.51.1-inplace EVM.FormatEVM.FeeSchedule EVM.HexdumpEVM.PrecompiledEVM.TTYCenteredList EVM.TypesEVM.TraversalsEVM.RLP EVM.Patricia EVM.KeccakEVM.ExprEVM.Op EVM.ConcreteEVM.CSEEVM.SMT EVM.Solvers EVM.AssemblerEVM.ABI EVM.SolidityEVM.SignEVM EVM.Facts EVM.Facts.GitEVM.Exec EVM.DebugEVM.DappEVM.StorageLayoutEVM.Transaction EVM.Fetch EVM.Stepper EVM.SymExec EVM.UnitTestEVM.DevEVM.TTY Paths_hevm&tree-view-0.5.1-BLZhtfODybXGW5XJ3sr6PoData.Tree.ViewshowTreeEIP FeeSchedule$sel:g_zero:FeeSchedule$sel:g_base:FeeSchedule$sel:g_verylow:FeeSchedule$sel:g_low:FeeSchedule$sel:g_mid:FeeSchedule$sel:g_high:FeeSchedule$sel:g_extcode:FeeSchedule$sel:g_balance:FeeSchedule$sel:g_sload:FeeSchedule$sel:g_jumpdest:FeeSchedule$sel:g_sset:FeeSchedule$sel:g_sreset:FeeSchedule$sel:r_sclear:FeeSchedule$sel:g_selfdestruct:FeeSchedule*$sel:g_selfdestruct_newaccount:FeeSchedule$sel:r_selfdestruct:FeeSchedule$sel:g_create:FeeSchedule$sel:g_codedeposit:FeeSchedule$sel:g_call:FeeSchedule$sel:g_callvalue:FeeSchedule$sel:g_callstipend:FeeSchedule$sel:g_newaccount:FeeSchedule$sel:g_exp:FeeSchedule$sel:g_expbyte:FeeSchedule$sel:g_memory:FeeSchedule$sel:g_txcreate:FeeSchedule$sel:g_txdatazero:FeeSchedule $sel:g_txdatanonzero:FeeSchedule$sel:g_transaction:FeeSchedule$sel:g_log:FeeSchedule$sel:g_logdata:FeeSchedule$sel:g_logtopic:FeeSchedule$sel:g_sha3:FeeSchedule$sel:g_sha3word:FeeSchedule$sel:g_initcodeword:FeeSchedule$sel:g_copy:FeeSchedule$sel:g_blockhash:FeeSchedule$sel:g_extcodehash:FeeSchedule$sel:g_quaddivisor:FeeSchedule$sel:g_ecadd:FeeSchedule$sel:g_ecmul:FeeSchedule $sel:g_pairing_point:FeeSchedule$sel:g_pairing_base:FeeSchedule$sel:g_fround:FeeSchedule$sel:r_block:FeeSchedule$sel:g_cold_sload:FeeSchedule&$sel:g_cold_account_access:FeeSchedule$$sel:g_warm_storage_read:FeeSchedule&$sel:g_access_list_address:FeeSchedule*$sel:g_access_list_storage_key:FeeScheduleeip150eip160 homestead metropoliseip1108eip1884eip2028eip2200istanbuleip2929berlin$fShowFeeSchedule prettyHex paddedShowHex simpleHexexecute renderListdrawListElementsNibbleAddr$sel:addressWord160:AddrW64W256 ByteStringSFunctionSelector($sel:unFunctionSelector:FunctionSelector GenericOpOpStopOpAddOpMulOpSubOpDivOpSdivOpModOpSmodOpAddmodOpMulmodOpExp OpSignextendOpLtOpGtOpSltOpSgtOpEqOpIszeroOpAndOpOrOpXorOpNotOpByteOpShlOpShrOpSarOpSha3 OpAddress OpBalanceOpOriginOpCaller OpCallvalueOpCalldataloadOpCalldatasizeOpCalldatacopy OpCodesize OpCodecopy OpGasprice OpExtcodesize OpExtcodecopyOpReturndatasizeOpReturndatacopy OpExtcodehash OpBlockhash OpCoinbase OpTimestampOpNumber OpPrevRandao OpGaslimit OpChainid OpSelfbalance OpBaseFeeOpPopOpMloadOpMstore OpMstore8OpSloadOpSstoreOpJumpOpJumpiOpPcOpMsizeOpGas OpJumpdestOpCreateOpCall OpStaticcall OpCallcodeOpReturnOpDelegatecall OpCreate2OpRevertOpSelfdestructOpDupOpSwapOpLogOpPush0OpPush OpUnknownOpVMOpts$sel:contract:VMOpts$sel:calldata:VMOpts$sel:initialStorage:VMOpts$sel:value:VMOpts$sel:priorityFee:VMOpts$sel:address:VMOpts$sel:caller:VMOpts$sel:origin:VMOpts$sel:gas:VMOpts$sel:gaslimit:VMOpts$sel:number:VMOpts$sel:timestamp:VMOpts$sel:coinbase:VMOpts$sel:prevRandao:VMOpts$sel:maxCodeSize:VMOpts$sel:blockGaslimit:VMOpts$sel:gasprice:VMOpts$sel:baseFee:VMOpts$sel:schedule:VMOpts$sel:chainId:VMOpts$sel:create:VMOpts$sel:txAccessList:VMOpts$sel:allowFFI:VMOpts TraceData EventTrace FrameTrace QueryTrace ErrorTrace EntryTrace ReturnTraceTrace$sel:opIx:Trace$sel:contract:Trace$sel:tracedata:Trace RuntimeCodeConcreteRuntimeCodeSymbolicRuntimeCode ContractCodeInitCodeCache$sel:fetchedContracts:Cache$sel:fetchedStorage:Cache$sel:path:Cache CodeLocationContract$sel:contractcode:Contract$sel:balance:Contract$sel:nonce:Contract$sel:codehash:Contract$sel:opIxMap:Contract$sel:codeOps:Contract$sel:external:ContractBlock$sel:coinbase:Block$sel:timestamp:Block$sel:number:Block$sel:prevRandao:Block$sel:gaslimit:Block$sel:baseFee:Block$sel:maxCodeSize:Block$sel:schedule:BlockEnv$sel:contracts:Env$sel:chainId:Env$sel:storage:Env$sel:origStorage:Env$sel:sha3Crack:Env StorageModel ConcreteS SymbolicSInitialSTxState$sel:gasprice:TxState$sel:gaslimit:TxState$sel:priorityFee:TxState$sel:origin:TxState$sel:toAddr:TxState$sel:value:TxState$sel:substate:TxState$sel:isCreate:TxState$sel:txReversion:TxState FrameState$sel:contract:FrameState$sel:codeContract:FrameState$sel:code:FrameState$sel:pc:FrameState$sel:stack:FrameState$sel:memory:FrameState$sel:memorySize:FrameState$sel:calldata:FrameState$sel:callvalue:FrameState$sel:caller:FrameState$sel:gas:FrameState$sel:returndata:FrameState$sel:static:FrameStateSubState$sel:selfdestructs:SubState$sel:touchedAccounts:SubState$sel:accessedAddresses:SubState!$sel:accessedStorageKeys:SubState$sel:refunds:SubState FrameContextCreationContext CallContext$sel:address:CreationContext$sel:codehash:CreationContext$$sel:createreversion:CreationContext$sel:substate:CreationContext$sel:target:CreationContext$sel:context:CreationContext$sel:offset:CreationContext$sel:size:CreationContext$sel:abi:CreationContext$sel:calldata:CreationContext"$sel:callreversion:CreationContext$sel:subState:CreationContextFrame$sel:context:Frame$sel:state:FrameVM$sel:result:VM $sel:state:VM$sel:frames:VM $sel:env:VM $sel:block:VM $sel:tx:VM $sel:logs:VM$sel:traces:VM $sel:cache:VM$sel:burned:VM$sel:iterations:VM$sel:constraints:VM$sel:keccakEqs:VM$sel:allowFFI:VM$sel:overrideCaller:VMVMResult VMFailure VMSuccess HandleEffect UnfinishedBranchConditionCaseUnknownChoosePleaseChoosePathQueryPleaseFetchContractPleaseFetchSlot PleaseAskSMT PleaseDoFFIEffect PartialExecUnexpectedSymbolicArgMaxIterationsReached$sel:pc:UnexpectedSymbolicArg$sel:msg:UnexpectedSymbolicArg$sel:args:UnexpectedSymbolicArg$sel:addr:UnexpectedSymbolicArgEvmError BalanceTooLowUnrecognizedOpcodeSelfDestruction StackUnderrunBadJumpDestinationRevertOutOfGasStackLimitExceededIllegalOverflowStateChangeWhileStaticInvalidMemoryAccessCallDepthLimitReachedMaxCodeSizeExceededMaxInitCodeSizeExceeded InvalidFormatPrecompileFailureReturnDataOutOfBounds NonceOverflow BadCheatCodePropPEqPLTPGTPGEqPLEqPNegPAndPOrPImplPBoolSomeExprExprLitVarGVarLitByte IndexWordEqByte JoinBytesPartialFailureSuccessITEAddSubMulDivSDivModSModAddModMulModExpSExMinMaxLTGTLEqGEqSLTSGTEqIsZeroAndOrXorNotSHLSHRSARKeccakSHA256Origin BlockHashCoinbase Timestamp BlockNumber PrevRandaoGasLimitChainIdBaseFee CallValueCallerAddressBalance SelfBalanceGasCodeSize ExtCodeHashLogEntryCreateCreate2CallCallCode DelegeateCall EmptyStore ConcreteStore AbstractStoreSLoadSStore ConcreteBuf AbstractBufReadWordReadByte WriteWord WriteByte CopySlice BufLengthBufVarStoreVarETypeBufStorageLogEWordByteEndInt512Word512toNum.&&.||.<.<=.>.>=.==./=pandporunifyCachedStorageunifyCachedContract wordField word64FieldtoChecksumAddress addrFieldaddrFieldMaybe toWord512 fromWord512 maybeLitByte maybeLitWordword256wordfromBEasBE word256Bytes word160ByteshilotoByte unpackNibbles packNibblestoWord64toIntbssToBsnum keccakBytesword32keccakkeccak' abiKeccak concatMapM regexMatchesreadNullpadLeftpadLeft'padRight padRight' formatString$fFiniteBitsWord512 $fBitsWord512 $fIxWord512$fHashableWord512 $fReadWord512 $fShowWord512$fIntegralWord512 $fRealWord512 $fNumWord512 $fEnumWord512$fBoundedWord512 $fOrdWord512 $fEqWord512$fDoubleWordWord512$fBinaryWordInt512$fFiniteBitsInt512 $fBitsInt512 $fIxInt512$fHashableInt512 $fReadInt512 $fShowInt512$fIntegralInt512 $fRealInt512 $fNumInt512 $fEnumInt512$fBoundedInt512 $fOrdInt512 $fEqInt512$fDoubleWordInt512$fBinaryWordWord512$fParseFieldStorageModel$fShowFunctionSelector$fToJSONByteStringS$fFromJSONByteStringS$fShowByteStringS$fParseRecordW256$fParseFieldsW256$fParseFieldW256$fFromJSONKeyW256$fFromJSONW256 $fToJSONW256 $fShowW256 $fReadW256 $fToJSONW64 $fShowW64 $fReadW64 $fFromJSONW64$fParseRecordAddr$fParseFieldsAddr$fParseFieldAddr$fFromJSONKeyAddr$fToJSONKeyAddr$fFromJSONAddr $fToJSONAddr $fShowAddr $fReadAddr $fOrdProp$fEqProp $fOrdSomeExpr $fEqSomeExpr$fEqContractCode $fMonoidCache$fSemigroupCache $fShowChoose $fShowQuery $fShowNibble $fNumNibble$fIntegralNibble $fRealNibble $fOrdNibble $fEnumNibble $fEqNibble$fBoundedNibble$fGenericNibble$fShowVM $fGenericVM $fShowTrace$fGenericTrace$fShowTraceData$fGenericTraceData $fShowVMOpts $fShowFrame$fShowFrameContext$fGenericFrameContext$fShowFrameState$fGenericFrameState $fShowTxState $fShowEnv $fGenericEnv $fShowBlock$fGenericBlock $fShowCache$fGenericCache$fShowContract$fShowContractCode$fOrdContractCode$fShowRuntimeCode$fEqRuntimeCode$fOrdRuntimeCode$fShowPartialExec$fEqPartialExec$fOrdPartialExec$fShowEvmError $fEqEvmError $fOrdEvmError$fShowSubState $fNumAddr$fIntegralAddr $fRealAddr $fOrdAddr $fEnumAddr$fEqAddr $fGenericAddr $fBitsAddr$fFiniteBitsAddr$fNumW64 $fIntegralW64 $fRealW64$fOrdW64 $fGenericW64 $fBitsW64$fFiniteBitsW64 $fEnumW64$fEqW64 $fBoundedW64 $fNumW256$fIntegralW256 $fRealW256 $fOrdW256 $fBitsW256 $fGenericW256$fFiniteBitsW256 $fEnumW256$fEqW256 $fBoundedW256$fEqByteStringS$fGenericByteStringS$fNumFunctionSelector$fEqFunctionSelector$fOrdFunctionSelector$fRealFunctionSelector$fEnumFunctionSelector$fIntegralFunctionSelector$fShowGenericOp $fEqGenericOp$fFunctorGenericOp$fReadStorageModel$fShowStorageModel$fShowBranchCondition $fDataInt512$fGenericInt512 $fDataWord512$fGenericWord512$fShowVMResult $fShowEffect $fShowProp$fShowSomeExpr $fOrdExpr$fEqExpr $fShowExpr $fOrdGVar$fEqGVar $fShowGVar$fLabelOptic"tx"kVMVMab$fLabelOptic"traces"kVMVMab$fLabelOptic"state"kVMVMab$fLabelOptic"result"kVMVMab#$fLabelOptic"overrideCaller"kVMVMab$fLabelOptic"logs"kVMVMab$fLabelOptic"keccakEqs"kVMVMab$fLabelOptic"iterations"kVMVMab$fLabelOptic"frames"kVMVMab$fLabelOptic"env"kVMVMab $fLabelOptic"constraints"kVMVMab$fLabelOptic"cache"kVMVMab$fLabelOptic"burned"kVMVMab$fLabelOptic"block"kVMVMab$fLabelOptic"allowFFI"kVMVMab+$fLabelOptic"static"kFrameStateFrameStateab*$fLabelOptic"stack"kFrameStateFrameStateab/$fLabelOptic"returndata"kFrameStateFrameStateab'$fLabelOptic"pc"kFrameStateFrameStateab/$fLabelOptic"memorySize"kFrameStateFrameStateab+$fLabelOptic"memory"kFrameStateFrameStateab($fLabelOptic"gas"kFrameStateFrameStateab-$fLabelOptic"contract"kFrameStateFrameStateab1$fLabelOptic"codeContract"kFrameStateFrameStateab)$fLabelOptic"code"kFrameStateFrameStateab.$fLabelOptic"callvalue"kFrameStateFrameStateab+$fLabelOptic"caller"kFrameStateFrameStateab-$fLabelOptic"calldata"kFrameStateFrameStateab$$fLabelOptic"value"kTxStateTxStateab*$fLabelOptic"txReversion"kTxStateTxStateab%$fLabelOptic"toAddr"kTxStateTxStateab'$fLabelOptic"substate"kTxStateTxStateab*$fLabelOptic"priorityFee"kTxStateTxStateab%$fLabelOptic"origin"kTxStateTxStateab'$fLabelOptic"isCreate"kTxStateTxStateab'$fLabelOptic"gasprice"kTxStateTxStateab'$fLabelOptic"gaslimit"kTxStateTxStateab0$fLabelOptic"touchedAccounts"kSubStateSubStateab.$fLabelOptic"selfdestructs"kSubStateSubStateab($fLabelOptic"refunds"kSubStateSubStateab4$fLabelOptic"accessedStorageKeys"kSubStateSubStateab2$fLabelOptic"accessedAddresses"kSubStateSubStateab$fLabelOptic"path"kCacheCacheab)$fLabelOptic"fetchedStorage"kCacheCacheab+$fLabelOptic"fetchedContracts"kCacheCacheab$$fLabelOptic"tracedata"kTraceTraceab$fLabelOptic"opIx"kTraceTraceab#$fLabelOptic"contract"kTraceTraceab"$fLabelOptic"value"kVMOptsVMOptsab)$fLabelOptic"txAccessList"kVMOptsVMOptsab&$fLabelOptic"timestamp"kVMOptsVMOptsab%$fLabelOptic"schedule"kVMOptsVMOptsab($fLabelOptic"priorityFee"kVMOptsVMOptsab'$fLabelOptic"prevRandao"kVMOptsVMOptsab#$fLabelOptic"origin"kVMOptsVMOptsab#$fLabelOptic"number"kVMOptsVMOptsab($fLabelOptic"maxCodeSize"kVMOptsVMOptsab+$fLabelOptic"initialStorage"kVMOptsVMOptsab%$fLabelOptic"gasprice"kVMOptsVMOptsab%$fLabelOptic"gaslimit"kVMOptsVMOptsab $fLabelOptic"gas"kVMOptsVMOptsab#$fLabelOptic"create"kVMOptsVMOptsab%$fLabelOptic"contract"kVMOptsVMOptsab%$fLabelOptic"coinbase"kVMOptsVMOptsab$$fLabelOptic"chainId"kVMOptsVMOptsab#$fLabelOptic"caller"kVMOptsVMOptsab%$fLabelOptic"calldata"kVMOptsVMOptsab*$fLabelOptic"blockGaslimit"kVMOptsVMOptsab$$fLabelOptic"baseFee"kVMOptsVMOptsab%$fLabelOptic"allowFFI"kVMOptsVMOptsab$$fLabelOptic"address"kVMOptsVMOptsab $fLabelOptic"state"kFrameFrameab"$fLabelOptic"context"kFrameFrameab/$fLabelOptic"target"kFrameContextFrameContextab1$fLabelOptic"substate"kFrameContextFrameContextab1$fLabelOptic"subState"kFrameContextFrameContextab-$fLabelOptic"size"kFrameContextFrameContextab/$fLabelOptic"offset"kFrameContextFrameContextab8$fLabelOptic"createreversion"kFrameContextFrameContextab0$fLabelOptic"context"kFrameContextFrameContextab1$fLabelOptic"codehash"kFrameContextFrameContextab6$fLabelOptic"callreversion"kFrameContextFrameContextab1$fLabelOptic"calldata"kFrameContextFrameContextab0$fLabelOptic"address"kFrameContextFrameContextab,$fLabelOptic"abi"kFrameContextFrameContextab($fLabelOptic"opIxMap"kContractContractab&$fLabelOptic"nonce"kContractContractab)$fLabelOptic"external"kContractContractab-$fLabelOptic"contractcode"kContractContractab)$fLabelOptic"codehash"kContractContractab($fLabelOptic"codeOps"kContractContractab($fLabelOptic"balance"kContractContractab$fLabelOptic"storage"kEnvEnvab $fLabelOptic"sha3Crack"kEnvEnvab"$fLabelOptic"origStorage"kEnvEnvab $fLabelOptic"contracts"kEnvEnvab$fLabelOptic"chainId"kEnvEnvab$$fLabelOptic"timestamp"kBlockBlockab#$fLabelOptic"schedule"kBlockBlockab%$fLabelOptic"prevRandao"kBlockBlockab!$fLabelOptic"number"kBlockBlockab&$fLabelOptic"maxCodeSize"kBlockBlockab#$fLabelOptic"gaslimit"kBlockBlockab#$fLabelOptic"coinbase"kBlockBlockab"$fLabelOptic"baseFee"kBlockBlockabTraversableTermmapTermfoldTermfoldPropfoldExprmapPropmapExprmapExprMmapPropM$fTraversableTermProp$fTraversableTermExprRLPBSListsliceitemInfo rlpdecode rlplengths rlpencode encodeLenrlpListoctets octetsFull octets160 rlpWord256 rlpWordFull rlpAddrFull rlpWord160 $fShowRLP$fEqRLPMapDBTrieNodeDBNodeEmptyShortcutFullRefHashLiteralPathDBKVPutGetinsertDBlookupDBrunDB encodePathrlpRefrlpNodeputNodegetNode lookupPathgetValemptyRef emptyRefs addPrefix insertRefupdatedeleteinsertlookupInrunTrierunMapDB insertValuescalcRoot $fShowRef$fShowDB $fShowNode$fEqNode$fEqRef $fFunctorDB$fApplicativeDB $fMonadDB $fFunctorKVkeccakAssumptions$fShowBuilderStateop1op2op3normArgsaddsubmuldivsdivmodsmodaddmodmulmodexpsexltgtleqgeqsltsgteqiszeroandorxornotshlshrsarreadByte readBytesreadWordreadWordFromBytesmaxBytes copySlice writeByte writeWord bufLength bufLengthEnv concPrefix minLength word256AttakedroptoListfromList simplifyReads stripWrites readStorage readStorage' writeStoragesimplifylitAddr exprToAddrlitCodeto512 isLitByte isLitWord indexWordpadByte bytesToW256 padBytesLeft joinByteseqByteminmax numBranchesallLit containsNode $fMonoidExpr$fSemigroupExpr intToOpNameopStringreadOpgetOpwordAtreadByteOrZero byteStringSliceWithDefaultZeroes sliceMemory writeMemory^ createAddresscreate2AddressStoreEnvBufEnv eliminateExpreliminatePropsSMT2SMTCex$sel:vars:SMTCex$sel:buffers:SMTCex$sel:store:SMTCex$sel:blockContext:SMTCex$sel:txContext:SMTCex CompressedBufBaseWrite$sel:byte:Base$sel:length:Base $sel:idx:Base$sel:next:BaseBufModelCompFlatCexVars$sel:calldata:CexVars$sel:buffers:CexVars$sel:storeReads:CexVars$sel:blockContext:CexVars$sel:txContext:CexVars flattenBufscollapsegetVar formatSMT2declareIntermediates assertPropsreferencedBufsGoreferencedBufsreferencedBufs'referencedVarsGoreferencedVarsreferencedVars'referencedFrameContextGoreferencedFrameContextreferencedFrameContext'referencedBlockContextGoreferencedBlockContextreferencedBlockContext'findStorageReadsfindBufferAccess assertReadsdiscoverMaxReads declareBufs declareVarsdeclareFrameContextdeclareBlockContextprelude exprToSMTspzeroone propToSMT expandExp concatBytes writeBytesencodeConcreteStore parseW256 parseIntegerparseW8parseSCparseErrparseVar parseBlockCtx parseFrameCtxgetVars queryMaxReadsgetBufsgetStore queryValueinterpretNDArrayinterpret1DArrayinterpret2DArray$fMonoidCexVars$fSemigroupCexVars $fMonoidSMT2$fSemigroupSMT2$fEqSMT2 $fShowSMT2 $fEqSMTCex $fShowSMTCex $fEqBufModel$fShowBufModel$fEqCompressedBuf$fShowCompressedBuf $fEqCexVars $fShowCexVarsCheckSatResultSatUnsatErrorTask$sel:script:Task$sel:resultChan:Task SolverGroupSolverInstance$sel:solvertype:SolverInstance$sel:stdin:SolverInstance$sel:stdout:SolverInstance$sel:stderr:SolverInstance$sel:process:SolverInstanceSolverZ3CVC5BitwuzlaCustomisSatisErrisUnsatcheckSat withSolversgetModel mkTimeout solverArgs spawnSolver stopSolver sendScript sendCommandsendLine sendLine'getValue readSExpr $fShowSolver$fShowCheckSatResult$fEqCheckSatResultassembleAbiValsNoValsCAbiSAbiSolErrorEventIndexed NotIndexed Anonymity Anonymous NotAnonymousAbiKindDynamicStaticAbiType AbiUIntType AbiIntTypeAbiAddressType AbiBoolType AbiBytesTypeAbiBytesDynamicType AbiStringTypeAbiArrayDynamicType AbiArrayType AbiTupleTypeAbiFunctionTypeAbiValueAbiUIntAbiInt AbiAddressAbiBoolAbiBytesAbiBytesDynamic AbiStringAbiArrayDynamicAbiArrayAbiTuple AbiFunctionabiTypeSolidityabiKind abiValueTypegetAbiputAbi getAbiSeqencodeAbiValuedecodeAbiValueselector abiMethod parseTypeNameemptyAbi genAbiValue makeAbiValue parseAbiValue decodeBufdecodeStaticArgs$fArbitraryAbiType $fShowAbiType$fArbitraryAbiValue$fShowAbiValue $fReadBoolz $fShowAbiVals$fShowSolError $fOrdSolError $fEqSolError$fGenericSolError $fShowEvent $fOrdEvent $fEqEvent$fGenericEvent $fShowIndexed $fOrdIndexed $fEqIndexed$fGenericIndexed$fShowAnonymity$fOrdAnonymity $fEqAnonymity$fGenericAnonymity $fShowAbiKind $fReadAbiKind $fEqAbiKind $fOrdAbiKind$fGenericAbiKind$fReadAbiValue $fEqAbiValue $fOrdAbiValue$fGenericAbiValue $fReadAbiType $fEqAbiType $fOrdAbiType$fGenericAbiType $fDataAbiTypeLanguageSolidityYulCodeTypeCreationRuntimeSrcMapSM$sel:offset:SM$sel:length:SM $sel:file:SM $sel:jump:SM$sel:modifierDepth:SMJumpTypeJumpIntoJumpFrom JumpRegular Reference$sel:start:Reference$sel:length:Reference SourceCache$sel:files:SourceCache$sel:lines:SourceCache$sel:asts:SourceCache ProjectType DappToolsFoundry BuildOutput$sel:contracts:BuildOutput$sel:sources:BuildOutput Contracts MutabilityPureView NonPayablePayableMethod$sel:output:Method$sel:inputs:Method$sel:name:Method$sel:methodSignature:Method$sel:mutability:Method SolcContract!$sel:runtimeCodehash:SolcContract"$sel:creationCodehash:SolcContract$sel:runtimeCode:SolcContract$sel:creationCode:SolcContract$sel:contractName:SolcContract#$sel:constructorInputs:SolcContract$sel:abiMap:SolcContract$sel:eventMap:SolcContract$sel:errorMap:SolcContract%$sel:immutableReferences:SolcContract$sel:storageLayout:SolcContract$sel:runtimeSrcmap:SolcContract $sel:creationSrcmap:SolcContractSlotTypeStorageMapping StorageValue StorageItem$sel:slotType:StorageItem$sel:offset:StorageItem$sel:slot:StorageItem makeSrcMapsreadBuildOutputmakeSourceCache lineSubrangereadSolcyul yulRuntimesolidity solcRuntime functionAbireadJSON readStdJSON signatureparseMethodInputcontainsLinkerHole solidity'yul'solcstdjsonstripBytecodeMetadatastripBytecodeMetadataSymastIdMap astSrcMap$fReadSlotType$fShowSlotType$fMonoidSourceCache$fSemigroupSourceCache$fFromJSONReference$fMonoidBuildOutput$fSemigroupBuildOutput$fToJSONStandardJSON$fShowLanguage$fShowCodeType $fEqCodeType $fOrdCodeType$fShowSrcMapParseState$fShowBuildOutput$fEqBuildOutput$fShowContracts $fEqContracts$fSemigroupContracts$fMonoidContracts$fShowSolcContract$fEqSolcContract$fGenericSolcContract $fShowSrcMap $fEqSrcMap $fOrdSrcMap$fGenericSrcMap$fShowJumpType $fEqJumpType $fOrdJumpType$fGenericJumpType$fShowReference $fEqReference$fShowSourceCache$fEqSourceCache$fGenericSourceCache$fEqProjectType$fShowProjectType$fReadProjectType$fParseFieldProjectType $fShowSources $fEqSources$fSemigroupSources$fMonoidSources $fShowSrcFile $fEqSrcFile $fOrdSrcFile $fShowAsts$fEqAsts$fSemigroupAsts $fMonoidAsts $fShowMethod $fEqMethod $fOrdMethod$fGenericMethod$fShowMutability$fEqMutability$fOrdMutability$fGenericMutability$fShowStorageItem$fEqStorageItem $fEqSlotType deriveAddrsignethsignecrec FrameResult FrameReturned FrameReverted FrameErrored CheatAction blankStatebytecodecurrentContractmakeVminitialContractnextexec1transfer callChecksprecompiledContractexecutePrecompile truncpadlit lazySliceparseModexpLengthisZero asIntegernooppushTopushToSequencegetCodeLocationquerychoosebranch fetchAccount accessStorage accountExists accountEmptyfinalize loadContract limitStack notStaticburn forceConcreteforceConcrete2forceConcrete3forceConcrete4forceConcrete5forceConcrete6forceConcreteBufrefundunRefund touchAccount selfdestruct accessAndBurnaccessAccountForGasaccessStorageForGas cheatCodecheat cheatActions delegateCall collisioncreate replaceCodereplaceCodeOfSelf resetStatevmErrorpartialwrapunderrun finishFrameaccessUnboundedMemoryRangeaccessMemoryRangeaccessMemoryWordcopyBytesToMemorycopyCallBytesToMemory readMemorywithTraceLocation pushTrace insertTracepopTracezipperRootForest traceForest traceTopLogpushpushSymstackOp1stackOp2stackOp3use' checkJumpisValidJumpDestopSize mkOpIxMapvmOpvmOpIx mkCodeOps costOfCall costOfCreateconcreteModexpGasFeecostOfPrecompile memoryCosthashcodeopslencodelentoBufcodelocceilDiv allButOne64thlog2$fShowFrameResultFile$sel:filePath:File$sel:fileData:FileData$sel:dataASCII:DataFact BalanceFact NonceFact StorageFactCodeFact$sel:addr:BalanceFact$sel:what:BalanceFact$sel:which:BalanceFact$sel:blob:BalanceFact contractFacts cacheFactsvmFactsapply applyCache factToFile fileToFact $fOrdFact$fAsASCIIByteString $fAsASCIIW256 $fAsASCIIAddr$fEqFile $fOrdFile $fShowFile$fEqData $fOrdData $fShowData$fEqPath $fOrdPath $fShowPath$fEqFact $fShowFactRepoAt saveFacts loadFacts $fEqRepoAt $fOrdRepoAt $fShowRepoAt ethrunAddressvmForEthrunCreationexecrun execWhileModeDebugRun JsonTraceobjectprettyContractprettyContracts srcMapCodePos srcMapCode$fEqMode $fShowModeTest ConcreteTest SymbolicTest InvariantTest DappContext$sel:info:DappContext$sel:env:DappContextCode $sel:raw:Code$sel:immutableLocations:CodeDappInfo$sel:root:DappInfo$sel:solcByName:DappInfo$sel:solcByHash:DappInfo$sel:solcByCode:DappInfo$sel:sources:DappInfo$sel:unitTests:DappInfo$sel:abiMap:DappInfo$sel:eventMap:DappInfo$sel:errorMap:DappInfo$sel:astIdMap:DappInfo$sel:astSrcMap:DappInfodappInfo emptyDappunitTestMarkerAbifindAllUnitTestsmkTest findUnitTestsunitTestMethodsFilteredunitTestMethods extractSig traceSrcMapsrcMapfindSrc lookupCode compareCodeshowTraceLocation $fShowTest $fShowCodefindContractDefinition storageLayoutstorageVariablesForContractnodeIsisStorageVariableDeclarationslotTypeForDeclarationgrokDeclarationTypegrokMappingType grokValueType showWordExactshowWordExplanationprettyIfConcreteWord showAbiValue textValues parenthesise showValues showValueshowCall showError formatBytes formatBinary showTraceTree unindexedcontractNamePartcontractPathPartprettyvmresultindent formatPartialformatSomeExpr formatExprstrip0xstrip0x' hexByteStringhexTextbsToHex$fShowSignedness Transaction$sel:txdata:Transaction$sel:gasLimit:Transaction$sel:gasPrice:Transaction$sel:nonce:Transaction$sel:r:Transaction$sel:s:Transaction$sel:toAddr:Transaction$sel:v:Transaction$sel:value:Transaction$sel:txtype:Transaction$sel:accessList:Transaction"$sel:maxPriorityFeeGas:Transaction$sel:maxFeePerGas:Transaction$sel:chainId:TransactionTxTypeLegacyTransactionAccessListTransactionEIP1559TransactionAccessListEntry$sel:address:AccessListEntry $sel:storageKeys:AccessListEntryemptyTransaction txAccessMapsender signingDataaccessListPrice txGasCost accountAt newAccountsetupTxinitTx$fFromJSONAccessListEntry$fToJSONAccessListEntry$fToJSONTxType$fFromJSONTransaction$fToJSONTransaction$fShowTransaction$fGenericTransaction $fShowTxType $fEqTxType$fGenericTxType$fShowAccessListEntry$fGenericAccessListEntryFetcherToRPCtoRPCRpcInfoLatestRpcQuery QueryCode QueryBlock QueryBalance QueryNonce QuerySlot QueryChainIdrpcreadText fetchQuery parseBlockfetchWithSessionfetchContractWithSessionfetchSlotWithSessionfetchBlockWithSessionfetchBlockFromfetchContractFrom fetchSlotFromfetchChainIdFromhttporacle checkBranch$fToRPCBlockNumber $fToRPCBool $fToRPCW256 $fToRPCAddr$fShowBlockNumber$fEqBlockNumber$fShowRpcQueryStepperActionExecWaitAskIOActwaitaskevmevmIO execFullyrunFullyenteringenter interpret UnsatCache Postcondition PreconditionCalldataFragmentStDyVeriOpts$sel:simp:VeriOpts$sel:debug:VeriOpts$sel:maxIter:VeriOpts$sel:askSmtIters:VeriOpts$sel:loopHeuristic:VeriOpts$sel:rpcInfo:VeriOpts EquivResult VerifyResult ProofResultQedCexTimeout LoopHeuristicNaive StackBasedSig isTimeoutisCexisQeddefaultVeriOpts rpcVeriOpts debugVeriOpts extractCexinRangebool symAbiArg symCalldatacdLen writeSelectorcombineFragments abstractVM loadSymVMmaxIterationsReachedaskSmtItersReached isLoopHead checkAssertcheckAssertionsdefaultPanicCodes allPanicCodespanicMsg mkCalldataverifyContractrunExpr flattenExpr reachableevalProp extractProps isPartial getPartialsverifyequivalenceCheckboth' produceModels showModel formatCexsubModel$fShowCalldataFragment$fEqCalldataFragment $fEqVeriOpts$fShowVeriOpts$fShowProofResult$fEqProofResult$fEqLoopHeuristic$fShowLoopHeuristic$fReadLoopHeuristic$fParseFieldLoopHeuristic$fParseFieldsLoopHeuristic$fParseRecordLoopHeuristic$fGenericLoopHeuristic ExploreTx CoverageState OpLocation$sel:srcContract:OpLocation$sel:srcOpIx:OpLocation ABIMethod TestVMParams$sel:address:TestVMParams$sel:caller:TestVMParams$sel:origin:TestVMParams$sel:gasCreate:TestVMParams$sel:gasCall:TestVMParams$sel:baseFee:TestVMParams$sel:priorityFee:TestVMParams$sel:balanceCreate:TestVMParams$sel:coinbase:TestVMParams$sel:number:TestVMParams$sel:timestamp:TestVMParams$sel:gaslimit:TestVMParams$sel:gasprice:TestVMParams$sel:maxCodeSize:TestVMParams$sel:prevrandao:TestVMParams$sel:chainId:TestVMParamsUnitTestOptions$sel:rpcInfo:UnitTestOptions$sel:solvers:UnitTestOptions$sel:verbose:UnitTestOptions$sel:maxIter:UnitTestOptions $sel:askSmtIters:UnitTestOptions$sel:smtDebug:UnitTestOptions$sel:maxDepth:UnitTestOptions$sel:smtTimeout:UnitTestOptions$sel:solver:UnitTestOptions$sel:covMatch:UnitTestOptions$sel:match:UnitTestOptions$sel:fuzzRuns:UnitTestOptions$sel:replay:UnitTestOptions$sel:vmModifier:UnitTestOptions$sel:dapp:UnitTestOptions$sel:testParams:UnitTestOptions$sel:ffiAllowed:UnitTestOptionsdefaultGasForCreatingdefaultGasForInvokingdefaultBalanceForTestContractdefaultMaxCodeSize makeVeriOptsunitTestinitializeUnitTest runUnitTestexecTestStepper exploreStep checkFailuresfuzzTestticksrcMapForOpLocationcurrentOpLocationexecWithCoveragerunWithCoverageinterpretWithCoveragecoverageReportcoverageForUnitTestContractrunUnitTestContractrunTest decodeCallsinitialExplorationStepperexplorationSteppergetTargetContracts exploreRunexecTestrunOnefuzzRunsymRun symFailureprettyCalldata showCalldatashowVal execSymTestcheckSymFailures indentLines passOutput failOutputformatTestLogs formatTestLogabiCall makeTxCallinitialUnitTestVm%getParametersFromEnvironmentVariables$fOrdOpLocation$fEqOpLocation$fShowOpLocation checkEquiv runDappTesttestOptsdoTest analyzeDaidaiExpr analyzeVatanalyzeDeposit reachable'showExpr summaryStoresafeAdd testContractvatinitVm buildExprdaiUiStateViewVm ViewContracts ViewPickerViewHelpUiBrowserState$sel:contracts:UiBrowserState$sel:vm:UiBrowserStateUiTestPickerState$sel:tests:UiTestPickerState$sel:dapp:UiTestPickerState$sel:opts:UiTestPickerState UiVmState$sel:vm:UiVmState$sel:step:UiVmState$sel:snapshots:UiVmState$sel:stepper:UiVmState$sel:showMemory:UiVmState$sel:testOpts:UiVmStateUiWidgetNameAbiPane StackPane BytecodePane TracePane SolidityPaneTestPickerPane BrowserPanePager$fEqName $fShowName $fOrdName%$fLabelOptic"vm"kUiVmStateUiVmStateab+$fLabelOptic"testOpts"kUiVmStateUiVmStateab*$fLabelOptic"stepper"kUiVmStateUiVmStateab'$fLabelOptic"step"kUiVmStateUiVmStateab,$fLabelOptic"snapshots"kUiVmStateUiVmStateab-$fLabelOptic"showMemory"kUiVmStateUiVmStateab8$fLabelOptic"tests"kUiTestPickerStateUiTestPickerStateab7$fLabelOptic"opts"kUiTestPickerStateUiTestPickerStateab7$fLabelOptic"dapp"kUiTestPickerStateUiTestPickerStateab/$fLabelOptic"vm"kUiBrowserStateUiBrowserStateab6$fLabelOptic"contracts"kUiBrowserStateUiBrowserStateab ContinuationStoppedContinueStepModeStep StepUntilPred_ViewVm_ViewContracts _ViewPicker _ViewHelpsnapshotInterval keepExecutingisUnitTestContractmkVty runFromVM initUiVmStatedebuggableTests isFuzzTestmaintakeStep backstepUntilbackstepappEventappinitialUiVmStateForTestmyThemedrawUi drawHelpViewdrawTestPicker drawVmBrowserdrawVm drawHelpBar stepOneOpcodeisNewTraceAddedisNextSourcePosition#isNextSourcePositionWithoutEnteringisExecutionHalted currentSrcMap drawStackPanemessagedrawBytecodePanedim withHighlightprettyIfConcrete drawTracePaneourWrap solidityListdrawSolidityPane ifTallEnoughopWidget selectedAttrdimAttrwordAttrboldAttr activeAttrbytestring-0.11.4.0Data.ByteString.Internal.Type ByteStringbaseGHC.BaseStringisWorthPrintingghc-prim GHC.TypesTruegroup EthjetContext mtl-2.2.2Control.Monad.State.ClassputgeteliminateExpr'eliminateProp'eliminateProps'SourcesSrcFileAsts findJsonFilesfilterMetadatareadFoundryJSONversiongetDataFileName getBinDir getLibDir getDynLibDir getDataDir getLibexecDir getSysconfDir