q      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijk l m n o p SafeADT RHS.Type constructor. *Coercion. I have no idea what this does :)Y literal.Type binder for .Types are information that are useful to keep during symbolic execution in order to generate correct feeds into the SMT solver. Overapproxmation is currently performed, and is likely to be cut back in the future.nData Constructor consists of its tag, the type that corresponds to its ADT, and a list of paramters it takes.!AData Constructor tag that uniquely identifiers data constructors.#\t taken straight from STG can be either in constructor form, or function form. Empty parameter list denotes a thunk.& Recursive?)Binding+Alt Constructor/Alternatives utilize an ^9, a list of parameters of that match to the appropriate ,1 as applicable, and an expression for the result.1>Expressions closely correspond to their representation in GHC.8Primitive functions.:Atomic objects. ;* may be used for variable lookups, while < is used to denote literals.=lLiterals are largely augmented from the original GHC implementation, with additional annotations to denote F for lifting, G for value deriviation, H for symbolic literals, and I to represent symbolic literal evaluation, as literal manipulation functions are defined in the Haskell Prelude, and thus outside of scope for us.JVariables consist of a L and a Y.L3The occurrence name is defined as a string, with a q module name appearing. The r denotes a Unique4 translated from GHC. For instance, in the case of  Map.empty, the occurrence name is "empty",, while the module name is some variant of Just "Data.Map".NDVariables, data constructors, type variables, and type constructors.SA d' is defined as a list of bindings. The bnd: is an identifier that determines a unique binder to the var(. In practice, these are defined to be L and J respectively.e  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcde    !"#$%&(')*+,-./0167234589:;<=>?D@ABCEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdedcba`_^]\[ZYXWVUSTNOPQRLMJK=>?@ABCDEFGHI:;<891234567/0+,-.)*&'(#$%!"   %   !"#$%&'()*+,-./0123456789:;<= >?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdSafeVariable type. Literal type. Atom type.Primitive function type.,Data constructor type denoted as a function.Alt type%I wonder what this could possibly be?NoneMake IO String from Outputable.DGiven the project directory and the source file path, compiles the s and translates it into a SSTG Bindings.Captures a snapshot of the t and u in addition to the v in the s`. This allows compilation to be, in theory, more portable across different applications, since v7 is a crucial intermediary for compilation in general.w Make SSTG x.y Make SSTG Atom.z Make SSTG {.| Make SSTG }.~ Make SSTG VarMake SSTG Binding Make SSTG BindRhs. Make SSTG . Make SSTG . Make SSTG . Make SSTG PrimFun. Make SSTG . Make SSTG . Make SSTG . Make SSTG . Make SSTG AlgTyRhs. make SSTG . Make SSTG  literals. Make SSTG .wyz|~wyz|~ None Safel    !"#$%&(')*+,-./0167234589:;<=>?D@ABCEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdSafe%GSymbolic link tables helps keep track of what names went to what, what?IPath conditions denote logical paths taken in program execution thus far.Path constraints.^Evaluation of the current expression. We are either evaluating, or ready to return with some .1Globals are statically loaded at the time when a  is loaded. However, because uninterpreted / out-of-scope variables are made symbolic at runtime, it can be modified during execution. Heap objects. Heaps map  to , while keeping track of the last address that was allocated. This allows us to consistently allocate fresh addresses on the .Locals binds a J's L to its some .A G is something that we aim to reduce our current expression down into. 0 is a pointer to an object on the heap, such as  or ?, which are "returned" from expression evaluation in this form.!Memory address for things on the .Frames of a stack.2Execution stack used in graph reduction semnatics. State status.Symbolic variables. The Maybe (Expr, Locals) can be used to trace the source from which the symbolic variable was generated. For instance, this is useful during symbolic function application.r contains the information necessary to perform symbolic execution. Eval/Apply graph reduction semantics are used.Symbolic Transformation represents transformations applied to some State`(s). This is useful in allowing us to transfer from different actions within the engine.A L's occurrence string.Name's unique r key.Variable name.'s r value. lookup. insertion.List insertion into . lookup. allocation. Updates the last  kept in the .Allocate a list of  in a #, returning in the same order the & at which they have been allocated at. direct insertion at a specific .Insert a list of  at specified  locations. lookup. insertion.Insert a list of J and  pairs into }. This would typically occur for new symbolic variables created from uninterpreted / out-of-scope variables during runtime. lookup from the  first, then .# lookup. Returns the corresponding  and  if found.Type of  held at  , if found.*Monad instance of Symbolic Transformation.0Applicative instance of Symbolic Transformation.,Functor instance of Symbolic Transformation.FCF% Safe!All Ls in a .Ls in a .Ls in a .Ls in an _.L s in the L s in the .Ls in a .Ls in a .Ls in a \.Ls in a J.Ls in an b.Ls in .Ls in the current evaluation .Ls in an `.Ls in a Y.Ls in a a.Ls in a [.Ls in a Z.Ls in a X.Ls in a V.Ls in a W.Ls in a U.Ls in a ].Ls in a .Ls in a .Ls in a ."Create a fresh seed given any r, a  seed, and a Set of s that we do not want our new , to conflict with. The sole purpose of the r{ seed is to allow us tell us how much to multiply some prime number to "orbit" an index around a fixed list of acceptable s.#Fresh L given a list of L%s that acts as conflicts. The fresh L-s generated in this manner are prefixed with "fs?"V, which is not a valid identifier in Haskell, but okay in SSTG. we also specify the N under which the L, will be generated. This will generally be O in actual usage.$A fresh L generated from a seed L+, which will act as the prefix of the new L. We ues the same N as the seed L when generating this way.%Generate a list of L9s, each corresponding to the appropriate element of the N list.&List of seeded fresh Ls.!"#$%&!"#$%&!"#$%&!"#$%&SafeLift action wrapper type.''(s that are applied during STG reduction.Does not include R. i.e. if something points to this, we have nothing to do in terms of reducitons. Either a c or points to a 1 value (not LitObj!). If we find nothing in the j, then this means we can still upcast the var to a symbolic that we create additional mappings to in the .DIs the 1 in a normal form that cannot be reduced further? to c.Uneven  of two Lists, with the leftover stored.Lift uninterpreted Js into .Lift b1 if necessary (i.e. uinterpreted / out-of-scope).Lift a list of bs.Lift \.Lift \ list.Lift ].. _ branches in a 7.^ _ branches in a 7.Match - _ branches.Match Z _ branches.Negate .Lift _'s during branching caused by symbolics._ closure to .E6Reduce the state if it matches some type of reduction ' . Return 7 to denote that rule application has completely failed.2'()*+,-./0123456789:;<=>?@ABCDE'()*+,-./0123456789:;<=>?@ABCDE'()*+,-./0123456789:;<=>?@ABCED'()*+,-./0123456789:;<=>?@ABCDESafe JA " that is in value form. A list of ''s is kept to denote reduction history.KA G that is not in value form yet, capable of being evaluated. A list of '&s is kept to denote reduction history.Increment the  counter of a .Increment the  counter inside the .Given a list of  along with its list of past '7 reductions, apply STG reduction. If reduction yields , simply return itself.This is what we use the  over.L@Run bounded breadth-first-search of the execution space with an r0 to denote the maximum number of steps to take.M@Run bounded breadth-first-search of the execution state with an r to denote the maximum number of steps to take. We keep track of a list to track a history of all the execution snapshots. As it stands, this is currently very NOT optimized.N Currently  undefined.O Currently  undefined. JKLMNOJKLMNOKJLMNO JKLMNOSafePStep execution type.U Run flags.Z Load Result^Guess the main function as "main"7, which is consistent with a few experimental results._"Load from a specified entry point.Allocate BindingAllocate List of BindingsBinding Address to Name ValuesInitialize GlobalsForce Atom LookupFull Rhs Object Lift BindingLift Binding ListCReturn a sub-list of bindings in which the entry candidate appears.Bind FilteringSub-Bindings String Match Load Code;We need to do stupid tracing if it's THUNK'D by default >:(`Perform execution on a  given the run flags.aSimple Q based execution on a state.PQRSTUVWXYZ[\]^_`aPQRSTUVWXYZ[\]^_`a^_Z[\]UVWXYPQRST`aPQRSTUVWXYZ[\]^_`a Safe!"#$%&'()*+,-./0123456789:;<=>?@ABCDEJKLMNOPQRSTUVWXYZ[\]^_`aNone    !"#$%&(')*+,-./0167234589:;<=>?D@ABCEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcd!"#$%&'()*+,-./0123456789:;<=>?@ABCDEJKLMNOPQRSTUVWXYZ[\]^_`a None*kPrint K and J% that yield from execution snapshots.Print K.Print J.Print '.lPrint .Inject  into parantheses.Inject a list of  s with space.Inject a list of s with commas.Inject a list of s with newlines.Inject a list of 0s into a single string with commas and brackets.Inject a list of -s with newline separators of dashes length 5.Inject a list of .s wit hnewline separators of dashes length 10.Print .Print L.Print c.Print .Print .Print . Print the Maybe (Expr, Locals).Print .Print .Print .Print .Print .Print J.Print b.Print [.Print Z.Print a.Print ^.Print _.Print a list of _s.Print \.Print (Var, BindRhs).mPrint ].Print `.Print Y. NOTE: currently only prints "TyPE" because there is a lot of Y: information which makes analysis of dumps hard otherwise.Print .Print a list of Ls.Print .Print .Print .+klmklmlkm+klm NonenWrite  to a target file.o Recover a  from a stored file.  denotes failure.pGWrite a pretty-printed state to a file. Do not use this for execution  recovery; use n instead.nopnopnopnopNoneklmnopNone    !"#$%&(')*+,-./0167234589:;<=>?D@ABCEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcd!"#$%&'()*+,-./0123456789:;<=>?@ABCDEJKLMNOPQRSTUVWXYZ[\]^_`aklmnop !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[[\\]^_`abcdefg13h;iAjJCkclmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQQRSTUVWXYZ[\]^_`abcde f g h i j klmnopqrstruursvrswxryjz{r\\|r}]~rykr3r11ryAryirgreerfrlmopllmlm                                        #SSTG-0.1.0.7-AHlTI1AftaxLwVKb1g0EEcSSTG.Core.Syntax.LanguageSSTG.Core.Syntax.TypingSSTG.Core.Translation.HaskellSSTG.Core.Execution.SupportSSTG.Core.Execution.NamingSSTG.Core.Execution.RulesSSTG.Core.Execution.SteppingSSTG.Core.Execution.EngineSSTG.Utils.PrintingSSTG.Utils.FileIOSSTG.Core.TranslationSSTG.Core.SyntaxSSTG.Core.Execution SSTG.Core SSTG.UtilsSSTG GenAlgTyRhs AbstractTyCon DataTyCon TupleTyConNewTyConGenTyConFunTyConAlgTyCon SynonymTyCon FamilyTyCon PrimTyConPromotedTcTyCon GenCoercionCoercionTyLitNumTyLitStrTyLit GenTyBinder NamedTyBndr AnonTyBndrGenTypeTyVarTyAppTyForAllTyCastTyTyConApp CoercionTyLitTyFunTyBottom GenDataConDataCon GenConTagConTag GenBindRhsConFormFunFormRecFormRecNonRec GenBindingBinding GenAltConDataAltLitAltDefaultGenAltAltGenExprAtomPrimAppConAppFunAppLetCase GenPrimFunPrimFunGenAtomVarAtomLitAtomGenLitMachCharMachStrMachIntMachWord MachFloat MachDouble MachNullAddr MachLabel BlankAddrAddrLitSymLit SymLitEvalVarName NameSpace VarNSpace DataNSpaceTvNSpace TcClsNSpace GenProgramProgramAlgTyRhsTyConTyBinderTypeBindRhsAltConExprLit$fShowNameSpace $fEqNameSpace$fReadNameSpace$fOrdNameSpace $fShowName$fEqName $fReadName $fOrdName $fShowRecForm $fEqRecForm $fReadRecForm$fShowGenConTag $fEqGenConTag$fReadGenConTag $fShowTyLit $fEqTyLit $fReadTyLit$fShowGenAlgTyRhs$fEqGenAlgTyRhs$fReadGenAlgTyRhs$fShowGenTyCon $fEqGenTyCon$fReadGenTyCon$fShowGenDataCon$fEqGenDataCon$fReadGenDataCon $fShowGenType $fEqGenType $fReadGenType$fShowGenCoercion$fEqGenCoercion$fReadGenCoercion$fShowGenTyBinder$fEqGenTyBinder$fReadGenTyBinder$fShowGenPrimFun$fEqGenPrimFun$fReadGenPrimFun $fShowGenLit $fEqGenLit $fReadGenLit$fShowGenAltCon $fEqGenAltCon$fReadGenAltCon $fShowGenAtom $fEqGenAtom $fReadGenAtom $fShowGenExpr $fEqGenExpr $fReadGenExpr$fShowGenBinding$fEqGenBinding$fReadGenBinding$fShowGenBindRhs$fEqGenBindRhs$fReadGenBindRhs $fShowGenAlt $fEqGenAlt $fReadGenAlt$fShowGenProgram$fEqGenProgram$fReadGenProgram $fShowVar$fEqVar $fReadVarvarTypelitTypeatomType primFunType dataConTypealtTypeexprTypemkIOStrmkTargetBindingsmkCompileClosureSymLinksPathCondPathConsCodeEvaluateReturnGlobalsHeapObjLitObjSymObjConObjFunObj BlackholeHeapLocalsValueLitValMemValMemAddrFrame CaseFrame ApplyFrame UpdateFrameStackStatusstepsSymbolState state_status state_stack state_heap state_globals state_code state_names state_paths state_links SymbolicTrun nameOccStr nameUniquevarName memAddrInt lookupLocals insertLocalsinsertLocalsList lookupHeap allocHeap allocHeapList insertHeapinsertHeapList lookupGlobals insertGlobalsinsertGlobalsList lookupValue vlookupHeap memAddrType$fMonadSymbolicT$fApplicativeSymbolicT$fFunctorSymbolicT $fShowStatus $fEqStatus $fReadStatus $fShowMemAddr $fEqMemAddr $fReadMemAddr $fOrdMemAddr $fShowValue $fEqValue $fReadValue $fShowLocals $fEqLocals $fReadLocals $fShowFrame $fEqFrame $fReadFrame $fShowStack $fEqStack $fReadStack $fShowSymbol $fEqSymbol $fReadSymbol $fShowHeapObj $fEqHeapObj $fReadHeapObj $fShowHeap$fEqHeap $fReadHeap $fShowGlobals $fEqGlobals $fReadGlobals $fShowCode$fEqCode $fReadCode$fShowPathCond $fEqPathCond$fReadPathCond$fShowSymLinks $fEqSymLinks$fReadSymLinks $fShowState $fEqState $fReadStateallNames freshString freshNamefreshSeededName freshNameListfreshSeededNameListRule RuleAtomLitRuleAtomLitPtrRuleAtomValPtr RuleAtomUnInt RulePrimApp RuleConAppRuleFunAppExactRuleFunAppUnder RuleFunAppSymRuleFunAppConPtrRuleFunAppUnIntRuleLet RuleCaseLitRuleCaseConPtrRuleCaseAnyLitRuleCaseAnyConPtr RuleCaseSymRuleUpdateCThunkRuleUpdateDLitRuleUpdateDValPtrRuleCaseCCaseNonVal RuleCaseDLitRuleCaseDValPtrRuleApplyCFunThunkRuleApplyCFunAppOverRuleApplyDReturnFunRuleApplyDReturnSym RuleIdentityisStateValueFormreduce $fShowRule$fEqRule $fReadRule $fOrdRule DeadState LiveState runBoundedBFSrunBoundedBFSLogged runBoundedDFSrunBoundedDFSLoggedStepTypeBFSDFS BFSLogged DFSLoggedRunFlags step_count step_typedump_dir LoadResultLoadOkay LoadGuess LoadError loadStateloadStateEntryexecuteexecute1$fShowLoadResult$fEqLoadResult$fReadLoadResult$fShowStepType $fEqStepType$fReadStepType$fShowRunFlags $fEqRunFlags$fReadRunFlagspprLivesDeadsStr pprStateStr pprBindingStr writeState readStatewritePrettyStatebaseGHC.BaseMaybeghc-prim GHC.TypesIntghcHscTypes ModuleGraphDynFlagsHscEnvModGutsmkExprCoreSynmkAtommkName mkNameSpaceOccNamemkVar mkBindingmkRhsmkLit mkDataTag BasicTypesmkDatamkPrimOpmkAltmkAltConmkTypeTyCoRepmkTyCon mkAlgTyConRhsmkTyBndrmkTyLit mkCoercion stackNames frameNamesaltNames localsNames heapNames heapObjNames symbolNames bindRhsNamesvarNames atomNames globalsNames codeNames exprNames typeNames pfunNames conTagName dataNames tyBinderNames tyConNames coercionNames algTyRhsNames bindingNames pconsNames pcondNames linksNamesStringCharLiftActisHeapValueFormisExprValueForm valueToLit unevenZipGHC.Listzip liftUnIntliftAtom liftAtomList liftBindRhsliftBindRhsList liftBinding defaultAlts altConAlts matchLitAlts matchDataAltsnegatePathCons liftSymAltliftedAltToStateNothing incStatusincStatesteppass<*> allocBindingallocBindingListbndAddrsToNameVals initGlobalsforceLookupValue forceRhsObj liftBindings entryMatches bindFilter lhsMatchesloadCode traceArgs pprLiveStr pprDeadStr pprRuleStrsubinjSpaceinjComma injNewLine injIntoListinjNewLineSeps5injNewLineSeps10 pprMemAddrStr pprNameStr pprLitStr pprStatusStr pprStackStr pprFrameStrpprSymClosureStr pprHeapObjStr pprHeapStr pprGlobalsStr pprLocalsStr pprValueStr pprVarStr pprAtomStr pprConTagStr pprDataConStr pprPrimFunStr pprAltConStr pprAltStr pprAltsStr pprBindRhsStr pprBindStr pprExprStr pprTypeStr pprCodeStr pprNamesStr pprPConsStr pprPCondStr pprLinksStr pprRulesStr