_p      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHI J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o Safe SafeSafeSafeSafeADT RHS. Type constructor.*Coercion. I have no idea what this does :) 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.((t taken straight from STG can be either in constructor form, or function form. Empty parameter list denotes a thunk.+ Recursive?.Bindings0Alt Constructor4Alternatives utilize an 09, a list of parameters of that match to the appropriate 11 as applicable, and an expression for the result.6>Expressions closely correspond to their representation in GHC.=Primitive functions.?Atomic objects. A* may be used for variable lookups, while @ is used to denote literals.BlLiterals are largely augmented from the original GHC implementation, with additional annotations to denote K for lifting, L for value deriviation, and M to represent symbolic literal evaluation, as literal manipulation functions are defined in the Haskell Prelude, and thus outside of scope for us.NVariables consist of a P and a .P3The occurrence name is defined as a string, with a p module name appearing. The q 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".RDVariables, data constructors, type variables, and type constructors.WA W' is defined as a list of bindings. The Name: is an identifier that determines a unique binder to the var(. In practice, these are defined to be P and N respectively.Q  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXQ !# "$%&'()*+-,./0123456;<789:=>?@ABCDJEFGHIKLMNOPQRSTUVWXQWXRSTUVPQNOBCDEFGHIJKLM?@A=>6789:;<450123./+,-()*&' !"#$%     !"#$%&'()*+,-./0123456789:;<=>?@AB CDEFGHIJKLMNOPQRSTUVWXSafeVariable type. Literal type. Atom type.Primitive function type.,Data constructor type denoted as a function.Alt type%I wonder what this could possibly be?SafeAll Ps in a State.rPs in a ..A N's P-. Not to be confused with the other function.sPs in a N.tPs in a (.uPs in an 6.vPs in an ?.wPs in a =.xPs in a &.yPs in an 4.zPs in a .{Ps in a .|Ps in a  .}Ps in a .~Ps in a .A P's occurrence string.A P's unique int.Create a fresh seed given any q, a  seed, and a Set of s that we do not want our new , to conflict with. The sole purpose of the q{ 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 P given a list of P%s that acts as conflicts. The fresh P-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 R under which the P, will be generated. This will generally be S in actual usage.A fresh P generated from a seed P+, which will act as the prefix of the new P. We ues the same R as the seed P when generating this way.Generate a list of P9s, each corresponding to the appropriate element of the R list.List of seeded fresh Ps.rstuvwxyz{|}~ rstuvwxyz{|}~Safea !# "$%&'()*+-,./0123456;<789:=>?@ABCDJEFGHIKLMNOPQRSTUVWXNoneCompilation closure type.Make IO String from Outputable.DGiven the project directory and the source file path, compiles the  and translates it into a SSTG Bindss.Captures a snapshot of the  and  in addition to the  in the `. This allows compilation to be, in theory, more portable across different applications, since 7 is a crucial intermediary for compilation in general. Make SSTG . Make SSTG Atom. Make SSTG . Make SSTG . Make SSTG Var Make SSTG . Make SSTG BindRhs. Make SSTG .'s . Make SSTG . Make SSTG PrimFun. Make SSTG . Make SSTG . Make SSTG . Make SSTG . Make SSTG AlgTyRhs. make SSTG . Make SSTG  literals. Make SSTG .NoneSafe4EConstraints denote logical paths taken in program execution thus far.4Path constraints are the conjunctive normal form of s.^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 N's P 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.Null .'s q value.Initial . Increment  steps. Update the  id. Empty `Stack. pop. push. as list of s.Empty . lookup. insertion.List insertion into . to key value pairs.Empty . lookup. direct insertion at a specific .Insert a list of  at specified  locations.Insert a redirection  into the . 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. to key value pairs.Empty . lookup. insertion.Insert a list of N and  pairs into }. This would typically occur for new symbolic variables created from uninterpreted / out-of-scope variables during runtime. to key value pairs.Empty . insertion.Insert a list of  s into a . to list of s. lookup from the  first, then ." lookup. Returns the appropriate.  and  if found.Type of  held at  , if found.*Monad instance of Symbolic Transformation.0Applicative instance of Symbolic Transformation.,Functor instance of Symbolic Transformation.VRR4SafeLift 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 B 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 .CIs the 1 in a normal form that cannot be reduced further? to B.Uneven  of two Lists, with the leftover stored.Lift uninterpreted Ns into .Lift ?1 if necessary (i.e. uinterpreted / out-of-scope).Lift a list of ?s.Lift (.Lift ( list.Lift ..3 4 branches in a <.0 4 branches in a <.Match 2 4 branches.Match & 4 branches.Negate .Lift 4's during branching caused by symbolics.4 closure to .D6Reduce the state if it matches some type of reduction & . Return 7 to denote that rule application has completely failed.2&'()*+,-./0123456789:;<=>?@ABCD&'()*+,-./0123456789:;<=>?@ABCD&'()*+,-./0123456789:;<=>?@ABDC&'()*+,-./0123456789:;<=>?@ABCD Safe IA " that is in value form. A list of &'s is kept to denote reduction history.JA G that is not in value form yet, capable of being evaluated. A list of &&s is kept to denote reduction history.Custom hash function.IIncrement Status conditions, and shift the current / parent id as needed.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.K@Run bounded breadth-first-search of the execution space with an q0 to denote the maximum number of steps to take.L@Run bounded breadth-first-search of the execution state with an q to denote the maximum number of steps to take. We keep a list to track a history of all the execution snapshots. As it stands, this is currently very NOT optimized.M Currently  undefined.N Currently  undefined. IJKLMNIJKLMNJIKLMN IJKLMN SafeOStep execution type.T Run flags.Y Load Result]Guess the main function as "main"7, which is consistent with a few experimental results.^"Load from a specified entry point.Allocate BindsAllocate List of .sBinds Address to Name ValsInitialize GlobalsForce Atom LookupFull Rhs ObjectLift ..Lift Binds List@Return a sub-list of binds in which the entry candidate appears.Binds FilteringSub-Bindss 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.`Simple P based execution on a state.OPQRSTUVWXYZ[\]^_`OPQRSTUVWXYZ[\]^_`]^YZ[\TUVWXOPQRS_`OPQRSTUVWXYZ[\]^_`Safe&'()*+,-./0123456789:;<=>?@ABCDIJKLMNOPQRSTUVWXYZ[\]^_`None !# "$%&'()*+-,./0123456;<789:=>?@ABCDJEFGHIKLMNOPQRSTUVWX&'()*+,-./0123456789:;<=>?@ABCDIJKLMNOPQRSTUVWXYZ[\]^_` None)jPrint J and I% that yield from execution snapshots.Print J.Print I.Print &.kPrint .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 P.Print B.Print .Print .Print . Print the Maybe (Expr, Locals).Print 's redirection.Print s HeapObj`.Print .Print .Print .Print .Print N.Print ?.Print &.Print =.Print 0.Print 4.Print a list of 4s.Print (.Print (Var, BindRhs).lPrint ..Print 6.Print . NOTE: currently only prints "TyPE" because there is a lot of : information which makes analysis of dumps hard otherwise.Print .Print a list of Ps.Print .Print PathCond.*jkljklkjl*jkl NonemWrite  to a target file.n Recover a  from a stored file.  denotes failure.oGWrite a pretty-printed state to a file. Do not use this for execution  recovery; use m instead.mnomnomnomnoNonejklmnoNone !# "$%&'()*+-,./0123456;<789:=>?@ABCDJEFGHIKLMNOPQRSTUVWX&'()*+,-./0123456789:;<=>?@ABCDIJKLMNOPQRSTUVWXYZ[\]^_`jklmno !"#$%&'()*++,-./0123456789:;<<=>?@ABCCDEFGHHIJKLMNOPPJQRSTUVWXYZ[\]^__``abcdeffghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQ R S T U V W X Y Z [ \ ] ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v wxyz{|}~yzI``aS<<HD2$$/+                                                        #SSTG-0.1.1.5-CwTuXpsdbmmHlvh3Q8yd81SSTG.Core.Execution.SupportSSTG.Core.SMT.Syntax+SSTG.Core.Preprocessing.DefunctionalizationSSTG.Core.Language.SyntaxSSTG.Core.Language.TypingSSTG.Core.Language.NamingSSTG.Core.Translation.HaskellSSTG.Core.Execution.RulesSSTG.Core.Execution.SteppingSSTG.Core.Execution.EngineSSTG.Utils.PrintingSSTG.Utils.FileIO SSTG.Core.SMTSSTG.Core.PreprocessingSSTG.Core.LanguageSSTG.Core.TranslationSSTG.Core.Execution SSTG.Core SSTG.UtilsSSTGbaseGHC.Base>>=fmapreturn<*>pureSMTExprSMTEXPRdefunctionalizeAlgTyRhs AbstractTyCon DataTyConNewTyCon TupleTyConTyConFunTyConAlgTyCon SynonymTyCon FamilyTyCon PrimTyConPromotedCoercionTyLitNumTyLitStrTyLitTyBinder NamedTyBndr AnonTyBndrTypeTyVarTyAppTyForAllTyCastTyTyConApp CoercionTyLitTyFunTyBottomDataConBindRhsConFormFunFormRecFormRecNonRecBindsAltConDataAltLitAltDefaultAltExprAtomPrimAppConAppFunAppLetCasePrimFunLitAtomVarAtomLitMachCharMachStrMachIntMachWord MachFloat MachDouble MachLabel MachNullAddr BlankAddrAddrLitLitEvalVarName NameSpace VarNSpace DataNSpaceTvNSpace TcClsNSpaceProgram$fShowNameSpace $fEqNameSpace$fReadNameSpace$fOrdNameSpace $fShowName$fEqName $fReadName $fOrdName $fShowRecForm $fEqRecForm $fReadRecForm$fShowTyBinder $fEqTyBinder$fReadTyBinder $fShowTyLit $fEqTyLit $fReadTyLit$fShowAlgTyRhs $fEqAlgTyRhs$fReadAlgTyRhs $fShowTyCon $fEqTyCon $fReadTyCon $fShowDataCon $fEqDataCon $fReadDataCon $fShowType$fEqType $fReadType$fShowCoercion $fEqCoercion$fReadCoercion $fShowVar$fEqVar $fReadVar $fShowPrimFun $fEqPrimFun $fReadPrimFun $fShowLit$fEqLit $fReadLit $fShowAltCon $fEqAltCon $fReadAltCon $fShowAtom$fEqAtom $fReadAtom $fShowExpr$fEqExpr $fReadExpr $fShowBinds $fEqBinds $fReadBinds $fShowBindRhs $fEqBindRhs $fReadBindRhs $fShowAlt$fEqAlt $fReadAlt $fShowProgram $fEqProgram $fReadProgramvarTypelitTypeatomType primFunType dataConTypealtTypeexprTypeallNamesvarName nameOccStrnameIntfreshStr freshNamefreshSeededName freshNamesfreshSeededNamesCompileClosuremkIOStrmkTargetBindssmkCompileClosure ConstraintPathConsCodeEvaluateReturnGlobalsHeapObjLitObjSymObjConObjFunObj BlackholeHeapLocalsValLitValMemValMemAddrFrame CaseFrame ApplyFrame UpdateFrameStackStatus status_id status_parent status_stepsSymbolState state_status state_stack state_heap state_globals state_code state_names state_path SymbolicTrun null_addr memAddrInt init_statusincStatusStepsupdateStatusId empty_stackpopStack pushStack stackToList empty_locals lookupLocalsinsertLocalsValinsertLocalsVals localsToList empty_heap lookupHeap insertHeapObjinsertHeapObjsinsertHeapRedir allocHeapObj allocHeapObjs heapToList empty_globals lookupGlobalsinsertGlobalsValinsertGlobalsVals globalsToListempty_pathconsinsertPathConsinsertPathConsspathConsToList lookupVal vlookupHeap memAddrType$fMonadSymbolicT$fApplicativeSymbolicT$fFunctorSymbolicT $fShowStatus $fEqStatus $fReadStatus $fShowMemAddr $fEqMemAddr $fReadMemAddr $fOrdMemAddr $fShowVal$fEqVal $fReadVal $fShowLocals $fEqLocals $fReadLocals $fShowFrame $fEqFrame $fReadFrame $fShowStack $fEqStack $fReadStack $fShowSymbol $fEqSymbol $fReadSymbol $fShowHeapObj $fEqHeapObj $fReadHeapObj $fShowHeap$fEqHeap $fReadHeap $fShowGlobals $fEqGlobals $fReadGlobals $fShowCode$fEqCode $fReadCode$fShowConstraint$fEqConstraint$fReadConstraint$fShowPathCons $fEqPathCons$fReadPathCons $fShowState $fEqState $fReadStateRule RuleAtomLitRuleAtomLitPtrRuleAtomValPtr RuleAtomUnInt RulePrimApp RuleConAppRuleFunAppExactRuleFunAppUnder RuleFunAppSymRuleFunAppConPtrRuleFunAppUnIntRuleLet RuleCaseLitRuleCaseConPtrRuleCaseAnyLitRuleCaseAnyConPtr RuleCaseSymRuleUpdateCThunkRuleUpdateDLitRuleUpdateDValPtrRuleCaseCCaseNonVal RuleCaseDLitRuleCaseDValPtrRuleApplyCFunThunkRuleApplyCFunAppOverRuleApplyDReturnFunRuleApplyDReturnSym RuleIdentityisStateValFormreduce $fShowRule$fEqRule $fReadRule $fOrdRule DeadState LiveState runBoundedBFSrunBoundedBFSLogged runBoundedDFSrunBoundedDFSLoggedStepTypeBFSDFS BFSLogged DFSLoggedRunFlagsflag_step_countflag_step_type flag_dump_dir LoadResultLoadOkay LoadGuess LoadError loadStateloadStateEntryexecuteexecute1$fShowLoadResult$fEqLoadResult$fReadLoadResult$fShowStepType $fEqStepType$fReadStepType$fShowRunFlags $fEqRunFlags$fReadRunFlagspprLivesDeadsStr pprStateStr pprBindsStr writeState readStatewritePrettyStateMaybeghc-prim GHC.TypesInt bindsNamesvarNames bindRhsNames exprNames atomNames primFunNames dataConNamesaltNames typeNames tyBinderNames tyConNames coercionNames algTyRhsNamesStringCharghcHscTypes ModuleGraphDynFlagsHscEnvModGutsmkExprCoreSynmkAtommkName mkNameSpaceOccNamemkVarmkBindsBindmkRhsmkLit mkDataNamemkDatamkPrimOpmkAltmkAltConmkTypeTyCoRepmkTyCon mkAlgTyConRhs mkTyBindermkTyLit mkCoercionLiftAct isHeapValForm isExprValFormvalToLit unevenZipGHC.Listzip liftUnIntliftAtom liftAtoms liftBindRhs liftBindRhss liftBinds defaultAlts altConAlts matchLitAlts matchDataAltsnegateConstraint liftSymAltliftedAltToStateNothinghash incStatussteppass allocBinds allocBindssbindsAddrsToVarVals initGlobalsforceLookupVal forceRhsObjliftBindsAddrsliftBindsAddrss entryMatches isEntryBinds lhsMatchesloadCode traceArgs pprLiveStr pprDeadStr pprRuleStrsubinjSpaceinjComma injNewLine injIntoListinjNewLineSeps5injNewLineSeps10 pprMemAddrStr pprNameStr pprLitStr pprStatusStr pprStackStr pprFrameStrpprSymClosureStrpprMemRedirStrpprMemHeapObjStr pprHeapStr pprGlobalsStr pprLocalsStr pprValStr pprVarStr pprAtomStr pprDataConStr pprPrimFunStr pprAltConStr pprAltStr pprAltsStr pprBindRhsStr pprBindKVStr pprExprStr pprTypeStr pprCodeStr pprNamesStrpprPathConsStrpprConstraintStr pprRulesStr