iԄ      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxy z { | } ~ SafeADT 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?+Binding-Alt Constructor1Alternatives utilize an _9, a list of parameters of that match to the appropriate .1 as applicable, and an expression for the result.3>Expressions closely correspond to their representation in GHC.:Primitive 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 H for lifting, I for value deriviation, J for symbolic literals, and K to represent symbolic literal evaluation, as literal manipulation functions are defined in the Haskell Prelude, and thus outside of scope for us.LVariables consist of a N and a [.N3The occurrence name is defined as a string, with a  module name appearing. The  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".PDVariables, data constructors, type variables, and type constructors.UA e' 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 N and L respectively.a  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdea    !"#$%&'(*)+,-./0123894567:;<=>?@AFBCDEGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdeaedcba`_^]\[ZYXWUVPQRSTNOLM?@ABCDEFGHIJK<=>:;345678912-./0+,()*%&'#$ !"  #    !"#$%&'()*+,-./0123456789:;<=>? @ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdeSafeVariable 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  and translates it into a SSTG Bindings.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 VarMake SSTG Binding 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 . None Safeh    !"#$%&'(*)+,-./0123894567:;<=>?@AFBCDEGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdeSafe7GSymbolic link tables helps keep track of what names went to what, what?EConstraints 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 L's N 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 N's occurrence string.N imique .Variable name.Null .'s  value. Empty `Stack. pop. push. as list of s.Empty . lookup. insertion.List insertion into . to key value pairs.Empty . 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. to key value pairs.Empty . lookup. insertion.Insert a list of L 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.Empty . insertion. to list of key value pairs. 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.ZUU7 Safe/All Ns in a .Ns in a .Ns in a .Ns in an `.N s in the N s in the .Ns in a .Ns in a .Ns in a ].Ns in a L.Ns in an c.Ns in .Ns in the current evaluation .Ns in an a.Ns in a [.Ns in a b.Ns in a \.Ns in a Z.Ns in a X.Ns in a Y.Ns in a W.Ns in a ^.Ns in a .Ns in a .Ns in a .0Create a fresh seed given any , a  seed, and a Set of s that we do not want our new , to conflict with. The sole purpose of the { 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.1Fresh N given a list of N%s that acts as conflicts. The fresh N-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 P under which the N, will be generated. This will generally be Q in actual usage.2A fresh N generated from a seed N+, which will act as the prefix of the new N. We ues the same P as the seed N when generating this way.3Generate a list of N9s, each corresponding to the appropriate element of the P list.4List of seeded fresh Ns./01234/01234/01234/01234SafeLift action wrapper type.55(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 d 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 .RIs the 1 in a normal form that cannot be reduced further? to d.Uneven  of two Lists, with the leftover stored.Lift uninterpreted Ls into .Lift c1 if necessary (i.e. uinterpreted / out-of-scope).Lift a list of cs.Lift ].Lift ] list.Lift ^.0 ` branches in a 9._ ` branches in a 9.Match / ` branches.Match \ ` branches.Negate .Lift `'s during branching caused by symbolics.` closure to .S6Reduce the state if it matches some type of reduction 5 . Return 7 to denote that rule application has completely failed.256789:;<=>?@ABCDEFGHIJKLMNOPQRS56789:;<=>?@ABCDEFGHIJKLMNOPQRS56789:;<=>?@ABCDEFGHIJKLMNOPQSR56789:;<=>?@ABCDEFGHIJKLMNOPQRSSafe XA " that is in value form. A list of 5's is kept to denote reduction history.YA G that is not in value form yet, capable of being evaluated. A list of 5&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 57 reductions, apply STG reduction. If reduction yields , simply return itself.This is what we use the  over.Z@Run bounded breadth-first-search of the execution space with an 0 to denote the maximum number of steps to take.[@Run bounded breadth-first-search of the execution state with an  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.\ Currently  undefined.] Currently  undefined. XYZ[\]XYZ[\]YXZ[\] XYZ[\]Safe^Step execution type.c Run flags.h Load ResultlGuess the main function as "main"7, which is consistent with a few experimental results.m"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 >:(nPerform execution on a  given the run flags.oSimple _ based execution on a state.^_`abcdefghijklmno^_`abcdefghijklmnolmhijkcdefg^_`abno^_`abcdefghijklmno Safe/0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSXYZ[\]^_`abcdefghijklmnoNone    !"#$%&'(*)+,-./0123894567:;<=>?@AFBCDEGHIJKLMNOPQRSTUVWXYZ[\]^_`abcde/0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSXYZ[\]^_`abcdefghijklmno None)yPrint Y and X% that yield from execution snapshots.Print Y.Print X.Print 5.zPrint .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 N.Print d.Print .Print .Print . Print the Maybe (Expr, Locals).Print .Print .Print .Print .Print .Print L.Print c.Print \.Print b.Print _.Print `.Print a list of `s.Print ].Print (Var, BindRhs).{Print ^. Print a. 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 Ns. Print .Print PathCond.Print .*yz{     yz{zy{*yz{      None|Write  to a target file.} Recover a  from a stored file.  denotes failure.~GWrite a pretty-printed state to a file. Do not use this for execution  recovery; use | instead.|}~|}~|}~|}~Noneyz{|}~None    !"#$%&'(*)+,-./0123894567:;<=>?@AFBCDEGHIJKLMNOPQRSTUVWXYZ[\]^_`abcde/0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSXYZ[\]^_`abcdefghijklmnoyz{|}~ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^__``abcdefghi%jk7l?mEnNGogpqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghhijklmnopqrstuvwxyz{| } ~    n``ao77Emkiij%                                        #SSTG-0.1.1.0-E8ktYjVPRmH11n3Xkt4CtOSSTG.Core.Execution.SupportSSTG.Core.Syntax.LanguageSSTG.Core.Syntax.TypingSSTG.Core.Translation.HaskellSSTG.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.UtilsSSTGbaseGHC.Base>>=fmapreturn<*>pure GenAlgTyRhs AbstractTyCon DataTyConNewTyCon TupleTyConGenTyConFunTyConAlgTyCon SynonymTyCon FamilyTyCon PrimTyConPromoted GenCoercionCoercionTyLitNumTyLitStrTyLit GenTyBinder NamedTyBndr AnonTyBndrGenTypeTyVarTyAppTyForAllTyCastTyTyConApp CoercionTyLitTyFunTyBottom GenDataConDataCon 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$fShowGenTyBinder$fEqGenTyBinder$fReadGenTyBinder $fShowTyLit $fEqTyLit $fReadTyLit$fShowGenAlgTyRhs$fEqGenAlgTyRhs$fReadGenAlgTyRhs$fShowGenTyCon $fEqGenTyCon$fReadGenTyCon$fShowGenDataCon$fEqGenDataCon$fReadGenDataCon $fShowGenType $fEqGenType $fReadGenType$fShowGenCoercion$fEqGenCoercion$fReadGenCoercion$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 dataConTypealtTypeexprTypemkIOStrmkTargetBindingsmkCompileClosureSymLinks ConstraintPathConsCodeEvaluateReturnGlobalsHeapObjLitObjSymObjConObjFunObjAddrObj BlackholeHeapLocalsValueLitValMemValMemAddrFrame CaseFrame ApplyFrame UpdateFrameStackStatusstepsSymbolState state_status state_stack state_heap state_globals state_code state_names state_paths state_links SymbolicTrun nameOccStr nameUniquevarName null_addraddrInt empty_stackpopStack pushStack stackToList empty_locals lookupLocals insertLocalsinsertLocalsList localsToList empty_heap lookupHeap allocHeap allocHeapList insertHeapinsertHeapList heapToList empty_globals lookupGlobals insertGlobalsinsertGlobalsList globalsToListempty_pathconsinsertPathConsinsertPathConsListpathconsToListempty_symlinksinsertSymLinkssymlinksToList 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$fShowConstraint$fEqConstraint$fReadConstraint$fShowPathCons $fEqPathCons$fReadPathCons$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 readStatewritePrettyStateMaybeghc-prim GHC.TypesIntghcHscTypes ModuleGraphDynFlagsHscEnvModGutsmkExprCoreSynmkAtommkName mkNameSpaceOccNamemkVar mkBindingmkRhsmkLit mkDataNamemkDatamkPrimOpmkAltmkAltConmkTypeTyCoRepmkTyCon mkAlgTyConRhsmkTyBndrmkTyLit mkCoercion stackNames frameNamesaltNames localsNames heapNames heapObjNames symbolNames bindRhsNamesvarNames atomNames globalsNames codeNames exprNames typeNames pfunNames dataNames tyBinderNames tyConNames coercionNames algTyRhsNames bindingNames pconsNamesconstraintNames linksNamesStringCharLiftActisHeapValueFormisExprValueForm valueToLit unevenZipGHC.Listzip liftUnIntliftAtom liftAtomList liftBindRhsliftBindRhsList liftBinding defaultAlts altConAlts matchLitAlts matchDataAltsnegateConstraint liftSymAltliftedAltToStateNothing incStatusincStatesteppass allocBindingallocBindingListbndAddrsToVarVals 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 pprDataConStr pprPrimFunStr pprAltConStr pprAltStr pprAltsStr pprBindRhsStr pprBindStr pprExprStr pprTypeStr pprCodeStr pprNamesStrpprPathConsStrpprConstraintStrpprSymLinksStr pprRulesStr