q      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJ 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 p 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?.Bind0Alt 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, M for symbolic literals, and N to represent symbolic literal evaluation, as literal manipulation functions are defined in the Haskell Prelude, and thus outside of scope for us.OVariables consist of a Q and a .Q3The 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".SDVariables, data constructors, type variables, and type constructors.XA X' 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 Q and O respectively.R  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYR !# "$%&'()*+-,./0123456;<789:=>?@ABCDJEFGHIKLMNOPQRSTUVWXYRXYSTUVWQROPBCDEFGHIJKLMN?@A=>6789:;<450123./+,-()*&' !"#$%     !"#$%&'()*+,-./0123456789:;<=>?@AB CDEFGHIJKLMNOPQRSTUVWXYSafeVariable type. Literal type. Atom type.Primitive function type.,Data constructor type denoted as a function.Alt type%I wonder what this could possibly be?Safe6EConstraints 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 O's Q 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 Q's occurrence string.Q imique r.Variable name.Null .'s r 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. 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 O 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 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.YstuvwxUU6stuvwxSafeAll Qs in a .yQs in a .zQs in a .{Qs in an 4.|Q s in the }Q s in the .~Qs in a .Qs in a .Qs in a (.Qs in a O.Qs in an ?.Qs in .Qs in the current evaluation .Qs in an 6.Qs in a .Qs in a =.Qs in a &.Qs in a .Qs in a  .Qs in a .Qs in a .Qs in a ..Qs in a .Qs 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 Q given a list of Q%s that acts as conflicts. The fresh Q-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 S under which the Q, will be generated. This will generally be T in actual usage. A fresh Q generated from a seed Q+, which will act as the prefix of the new Q. We ues the same S as the seed Q when generating this way.!Generate a list of Q9s, each corresponding to the appropriate element of the S list."List of seeded fresh Qs.yz{|}~ !" !" !"yz{|}~ !"Safe !# "$%&'()*+-,./0123456;<789:=>?@ABCDJEFGHIKLMNOPQRSTUVWXY !"None#Compilation closure type.$Make IO String from Outputable.%DGiven the project directory and the source file path, compiles the  and translates it into a SSTG s.&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 .#$%&#$%&#&%$#$%&None#$%&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 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 .DIs the 1 in a normal form that cannot be reduced further? to B.Uneven  of two Lists, with the leftover stored.Lift uninterpreted Os 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 .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:;<=>?@ABCDE Safe 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.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.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 JKLMNO SafePStep 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 BindAllocate List of .sBind Address to Name ValuesInitialize GlobalsForce Atom LookupFull Rhs ObjectLift ..Lift Bind List@Return a sub-list of binds in which the entry candidate appears.Bind FilteringSub-Binds 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[\]^_`aSafe7'()*+,-./0123456789:;<=>?@ABCDEJKLMNOPQRSTUVWXYZ[\]^_`aNone !# "$%&'()*+-,./0123456;<789:=>?@ABCDJEFGHIKLMNOPQRSTUVWXY !"#$%&'()*+,-./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 Q.Print B.Print .Print .Print . Print the Maybe (Expr, Locals).Print .Print .Print .Print .Print .Print O.Print ?.Print &.Print =.Print 0.Print 4.Print a list of 4s.Print (.Print (Var, BindRhs).mPrint ..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 Qs.Print .Print PathCond.)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 !# "$%&'()*+-,./0123456;<789:=>?@ABCDJEFGHIKLMNOPQRSTUVWXY !"#$%&'()*+,-./0123456789:;<=>?@ABCDEJKLMNOPQRSTUVWXYZ[\]^_`aklmnop !"#$%&'()*++,-./0123456789:;<<=>?@ABCCDEFGHHIJKLMNOPPJQRSTUVWXYZ[\]^_``aabcdefgghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQR 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 w xyz{|}~z{CIaabS<<HD2$$/+                                                       #SSTG-0.1.1.3-6t3axJd06TwIBSqrHMd8wPSSTG.Core.Language.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 CoercionTyLitTyFunTyBottomDataConBindRhsConFormFunFormRecFormRecNonRecBindAltConDataAltLitAltDefaultAltExprAtomPrimAppConAppFunAppLetCasePrimFunLitAtomVarAtomLitMachCharMachStrMachIntMachWord MachFloat MachDouble MachLabel MachNullAddr BlankAddrAddrLitSymLit SymLitEvalVarName 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 $fShowPrimFun $fEqPrimFun $fReadPrimFun $fShowVar$fEqVar $fReadVar $fShowLit$fEqLit $fReadLit $fShowAltCon $fEqAltCon $fReadAltCon $fShowAtom$fEqAtom $fReadAtom $fShowExpr$fEqExpr $fReadExpr $fShowBind$fEqBind $fReadBind $fShowBindRhs $fEqBindRhs $fReadBindRhs $fShowAlt$fEqAlt $fReadAlt $fShowProgram $fEqProgram $fReadProgramvarTypelitTypeatomType primfunType dataconTypealtTypeexprType ConstraintPathConsCodeEvaluateReturnGlobalsHeapObjLitObjSymObjConObjFunObjAddrObj BlackholeHeapLocalsValueLitValMemValMemAddrFrame CaseFrame ApplyFrame UpdateFrameStackStatus status_id status_parent status_stepsSymbolState state_status state_stack state_heap state_globals state_code state_names state_paths SymbolicTrun nameOccStr nameUniquevarName null_addraddrInt init_statusincStatusStepsupdateStatusId empty_stackpopStack pushStack stackToList empty_locals lookupLocals insertLocalsinsertLocalsList localsToList empty_heap lookupHeap allocHeap allocHeapList insertHeapinsertHeapList heapToList empty_globals lookupGlobals insertGlobalsinsertGlobalsList globalsToListempty_pathconsinsertPathConsinsertPathConsListpathconsToList 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 $fShowState $fEqState $fReadStateallNames freshString freshNamefreshSeededName freshNameListfreshSeededNameListCompileClosure mkIOString mkTargetBindsmkCompileClosureRule RuleAtomLitRuleAtomLitPtrRuleAtomValPtr RuleAtomUnInt RulePrimApp RuleConAppRuleFunAppExactRuleFunAppUnder RuleFunAppSymRuleFunAppConPtrRuleFunAppUnIntRuleLet RuleCaseLitRuleCaseConPtrRuleCaseAnyLitRuleCaseAnyConPtr RuleCaseSymRuleUpdateCThunkRuleUpdateDLitRuleUpdateDValPtrRuleCaseCCaseNonVal RuleCaseDLitRuleCaseDValPtrRuleApplyCFunThunkRuleApplyCFunAppOverRuleApplyDReturnFunRuleApplyDReturnSym RuleIdentityisStateValueFormreduce $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 pprBindStr writeState readStatewritePrettyStateMaybeghc-prim GHC.TypesInt stackNames frameNamesaltNames localsNames heapNames heapObjNames symbolNames bindRhsNamesvarNames atomNames globalsNames codeNames exprNames typeNames pfunNames dataNames tyBinderNames tyConNames coercionNames algTyRhsNames bindNames pconsNamesconstraintNamesStringCharghcHscTypes ModuleGraphCoreSynDynFlagsHscEnvModGutsmkExprmkAtommkName mkNameSpaceOccNamemkVarmkBindmkRhsmkLit mkDataNamemkDatamkPrimOpmkAltmkAltConmkTypeTyCoRepmkTyCon mkAlgTyConRhs mkTyBindermkTyLit mkCoercionLiftActisHeapValueFormisExprValueForm valueToLit unevenZipGHC.Listzip liftUnIntliftAtom liftAtomList liftBindRhsliftBindRhsListliftBind defaultAlts altConAlts matchLitAlts matchDataAltsnegateConstraint liftSymAltliftedAltToStateNothinghash incStatussteppass allocBind allocBindListbndAddrsToVarVals initGlobalsforceLookupValue forceRhsObj liftBinds 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 pprBindKVStr pprExprStr pprTypeStr pprCodeStr pprNamesStrpprPathConsStrpprConstraintStr pprRulesStr