M      !"#$%&'()*+,-./0123 456789:;<=>?@ABCDEFGH I J K L M N O P Q R S T U V W X Y Z [ \ ]^_`abcdefghijkl m n o p q r stuvwxyz{|}~       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~              !""""" Safe-InferredETransform/format a text so that it is acceptable as a VHDL identifierNoneTExternally defined primitive/A primitive that carries additional informationAdditional informationLA primitive that has a template that can be filled out by the backend renderName of the primitiveName of the primitive Either a  declaration or an  expression template.Primitive Definitions    None24EHJKM (A class that can generate unique numbers Get a new unique^Create a TH expression that returns the a formatted string containing the name of the module 4 is spliced into, and the line where it was spliced.$Cache the result of a monadic actionICache the result of a monadic action in a State 3 transformer layers downSpine-strict cache variant of  mkCachedT3IRun a State-action using the State that is stored in a higher-layer MonadFunctorial version of #$Functorial version of #%0Performs trace when first argument evaluates to Monadic version of &'Monadic version of &(6Composition of a unary function with a binary function)if-then-else as a function on an argument&Applicative version of 'GHC.Types.(:)'Safe indexing, returns a  if the index does not existBUnsafe indexing, return a custom error message when indexing fails5Split the second list at the length of the first list %The key the action is associated with)The Lens to the HashMap that is the cacheThe action to cache%The key the action is associated with)The Lens to the HashMap that is the cacheThe action to cache+Lens to the State in the higher-layer monadThe State-action to perform      None!hGenerate a set of primitives that are found in the primitive definition files in the given directories."MParse a ByteString according to the given JSON template. Prints failures on stdout, and returns  if parsing fails.!/Directories to search for primitive definitions"Bytestring to parse!"!"!"None 2346M* Type variable+ Term variable,Variables in CoreHW-Constructor for term variables/Constructor for type variables2Change the name of a variable*+,-./012 *+,-./012 ,/-010.+*2 *+,/-010.2None2346 TyCon reference Type Constructor4#Representations for primitive types7 The RHS of an Algebraic Datatype9The newtype DataCon:The argument type of the newtype DataCon in eta-reduced form, which is just the representation of the TyCon. The TyName's are the type-variables from the corresponding TyCon.<The DataCons of a TyCon='To close the loop on the type hierarchy>Primitive TyCons?Representation@Algorithmic DataConsAName of the TyConName of the TyConName of the TyConBKind of the TyConKind of the TyConCNumber of type argumentsNumber of type argumentsDDataCon definitionsE Create a Kind out of a TyConNameF&Does the TyCon look like a tuple TyConG%Get the DataCons belonging to a TyCon- 456789:;<=>?@ABCDEFG      456789:;<=>?@ABCDEFG @>=ABCDABC?A 7;8<9:465EFG @>=ABCDABC?A4657;8<9:EFG      None  Builtin Name Builtin Name Builtin Name Builtin Name Builtin Kind Builtin Kind Builtin Kind Builtin Kind Builtin Type Builtin TypeHIJ KLMHIJKLMHIJKLMHIJ KLM None2346N Term LiteralR Determines the Type of a LiteralNOPQ!"R#$%&'()NOPQRNQPOR NQPO!"R#$%&'() None2346 3Data ConstructorSDataCon referenceT:Syntactical position of the DataCon in the type definitionVName of the DataConW+Syntactical position in the type definitionXType of the 'DataConYmUniversally quantified type-variables, these type variables are also part of the result type of the DataConZExistentially quantified type-variables, these type variables are not part of the result of the DataCon, but only of the arguments.[Argument types\Given a DataCon and a list of types, the type variables of the DataCon type are substituted for the list of types. The argument types are returned.cThe list of types should be equal to the number of type variables, otherwise an error is reported.3STUVWXYZ[*+,-.\/01234 3STUVWXYZ[\ 3UVWXYZ[ST\3UVWXYZ[ST*+,-.\/01234None2346#Term reference$DTerm representation in the CoreHW language: System F + LetRec + Case]+Patterns in the LHS of a case-decomposition^Default pattern_Literal pattern`VDatatype pattern, '[TyVar]' bind existentially-quantified type-variables of a DataConaBinding in a LetRec constructbECase-expression: subject, type of alternatives, list of alternativescRecursive let-bindingdType-applicatione ApplicationfType-abstractiongTerm-abstractionh PrimitiveiLiteraljDatatype constructorkVariable reference'#$]^_`abcdefghijk56789:;<=>?@ABCDEFGHIJ#$]^_`abcdefghijk$kjihgfedcb#a]`_^#$ kjihgfedcb]`_^a56789:;<=>?@ABCDEFGHIJ NonelSubstitutes types in a typemSubstitutes a type in a typenSubstitutes kinds in a kindoSubstitutes a type in a termpSubstitutes types in a termqSubstitutes a term in a termrSubstitutes terms in a termlmnopqrlmnopqrlmnopqrlmnopqrNone 2346%%Reference to a Kind&Reference to a Type'The level above types(/Types in CoreHW: function and polymorphic types)Make a Type out of a TyConsEither a Kind or a Typet Literal TypeswType Constantsx Function typey TyCon typezAn easier view on types{Neither of the above| Applied TyCon} Function type~ Type literalType ApplicationPolymorphic Type Type constant Type variableAn easier view on typesA transformation that renders Signal types transparentA view on types in which Signal# types and newtypes are transparentKZInstantiate and Apply the RHS/Original of a NewType with the given list of argument types3Make a function type of an argument and result typeDMake a TyCon Application out of a TyCon and a list of argument types6Split a TyCon Application in a TyCon and its argumentsLIs a type a Superkind?Determine the kind of a typeIs a type polymorphic?4Split a function type in an argument and result type^Split a poly-function type in a: list of type-binders and argument types, and the result type)Is a type a polymorphic or function type?/Is a type a polymorphic or function type under ?Is a type a function type?AApply a function type to an argument type and get the result type(Substitute the type variable of a type () with another typeMCSplit a type application in the applied type and the argument types>%&'()stuvwxyz{|}~NOPQRSKLTMUVWXYZ[\]^_`abcd%%&'()*stuvwxyz{|}~%(~z}|{wyxtvu's%&*)2%&'(~)stvuwyxz}|{NOPQRSKLTMUVWXYZ[\]^_`abcd None'Gives the free type-variables in a Type?Gives the free type-variables and free term-variables of a Term'Gives the free term-variables of a Term'Gives the free type-variables of a TermNoneGlobal function bindersNone 24#Pretty printing Show-like typeclass Print a Pretty thing to a String?efghijklmnopqrstuvwxyz{|}~7ehgfilkjmnopqrstuvwxyz{|}~NoneKind environment/contextType environment/contextDetermine the type of a term>Split a (Type)Application in the applied term and it argumentsHSplit a (Type)Abstraction in the bound variables and the abstracted termGGet the result type of a polymorphic function given a list of arguments6Get the list of term-binders out of a DataType patternMake a type variableMake a term variable6Abstract a term over a list of term and type variables-Abstract a term over a list of term variables-Abstract a term over a list of type variables)Apply a list of types and terms to a termApply a list of terms to a termApply a list of types to a term!Does a term have a function type?0Does a term have a function or polymorphic type?Is a term a term-abstraction?"Is a term a recursive let-binding?Is a term a variable reference?!Is a term a datatype constructor?Is a term a primitive?,Make variable reference out of term variable0Make a term variable out of a variable referenceNone0B: Bit literalHigh-impedance UndefinedLowHighLiterals used in an expressionVector literalBoolean literal Bit literalNumber literal'Expression used in RHS of a declaration&Instantiation of a BlackBox expressionSignal referenceDataCon applicationLiteral expressionExpression Modifier>See the expression in the context of a Vector append operationJSee expression in a DataCon context: (Type of the expression, DataCon tag)@Index the expression: (Type of expression,DataCon tag,Field Tag)Internals of a ComponentSignal declaration%Instantiation of blackbox declaration"Instantiation of another componentConditional signal assignment:Signal to assignScrutinized expressionVList of: (Maybe expression scrutinized expression is compared with,RHS of alternative)Signal assignment:Signal to assignAssigned expressionRepresentable hardware types9Reset type corresponding to clock with a specified period Clock type with specified period=Sum-of-Product type: Name and Constructor names + field types"Product type: Name and field types$Sum type: Name and Constructor names Vector type$Unsigned integer of a specified size"Signed integer of a specified size Integer type Boolean typeBit type Empty type?Size indication of a type (e.g. bit-size or number of elements)!Component: base unit of a NetlistName of the componentBPorts that have no correspondence the original function definition Input ports Output portInternal declarationsSignal referenceState of the NetlistMonadGlobal bindersType environment/contextNumber of signal declarationsNumber of create componentsCached componentsPrimitive DefinitionsState for the ) Monad#Hardcoded Type -> HWType translator TyCon cacheState for the ) monad:Previously encountered HWTypesProduct type counter1Cache for previously generated product type names}Monad that caches generated components (StateT) and remembers hidden inputs of components that are being generated (WriterT)KGK  None24BState of a rewriting session!Number of applied transformationsGlobal bindersSupply of unique numbers"Hardcode Type -> HWType translator TyCon cacheContext in which a term appearsSubject of a case-decompositionLRHS of a case-alternative with the variables bound by the pattern on the LHS9Body of a TyLambda-term with the abstracted type-variable 2Body of a lambda-term with the abstracted variable )Body of a Let-binding with the bound LHS' )RHS of a Let-binder with the sibling LHS' 'Function position of a type application #Argument position of an application#Function position of an application,Read-only environment of a rewriting sessionDebug Message Verbosity8Show all sub-expressions on which a rewrite is attempted/Show sub-expressions after a successful rewrite Names of applied transformations&Show completely normalized expressionsDon't show debug messagesA  action in the context of the "=Monadic action that transforms a term given a certain contextMTL convenience wrapper around ""Monad that can do the same as #X and in addition keeps track if a transformation/rewrite has been successfully applied.#zMonad that keeps track how many transformations have been applied and can generate fresh variables and unique identifiers(      !"#$%'      !"#$(     $#"% !       !"#$%None & State of the 1(Global binders)*Cache of previously specialised functions:NKey: (name of the original function, argument position, specialised term/type)AElem: (name of specialised function,type of specialised function)*2Cache of how many times a function was specialized+Number of time a function f can be specialized,,Cache of function where inlining took place:'Key: function where inlining took place=Elem: (functions which were inlined, number of times inlined)-Number of times a function f can be inlined in a function g.&Function which is currently normalized/A  Transform action in the context of the  RewriteMonad and 103RewriteSession with extra Normalisation information1?State monad that stores specialisation and inlining information&'()*+,-./012345678&'()*+,-./012345678&'()*+,-.876543210/ &'()*+,-./012345678NoneB9qMonad that caches VHDL information and remembers hidden inputs of black boxes that are being generated (WriterT)<Component instantiation hole. First argument indicates which function argument to instantiate. Second argument corresponds to output and input assignments, where the first element is the output assignment, and the subsequent elements are the consecutive input assignments.>Elements of a blackbox context?Default value hole@Type root holeAType declaration holeB Reset holeCVClock hole (Maybe clk corresponding to input, clk corresponding to output if Nothing)D Symbol holeE Literal holeF Input holeG Output holeHComponent instantiation holeIConstantJ)A BlackBox Template is a List of ElementsK\Either the name of the identifier, or a tuple of the identifier and the corresponding clockL8Context used to fill in the holes of a BlackBox templateNResult name and typeOArgument names and typesP$Literal arguments (subset of inputs)Q&Function arguments (subset of inputs):,(Blackbox Template,Partial Blackbox Concext)9:;<=>?@ABCDEFGHIJKLMNOPQ9:;<=>?@ABCDEFGHIJKLMNOPQLMNOPQKJ>IHGFEDCBA@?<=9:;9:;<=> IHGFEDCBA@?JKLMNOPQNone RSParse a text as a BlackBoxTemplate, returns a list of errors in case parsing fails7Parse a BlackBoxTemplate (Declarations and Expressions)Parse a single Template Element!Parse the Text part of a Template)Parse a Declaration or Expression elementParse a Declaration#Parse the output tag of Declaration"Parse the input tag of DeclarationParse an Expression elementParse a bracketed text)Parse a token and eat trailing whitespace/Parse the expression part of Blackbox TemplatesParse an Expression or TextRRRRNoneM S1Apply a transformation on the subtrees of an termT'Apply two transformations in successionU-Apply a transformation in a topdown traversalVOApply a transformation in a topdown traversal. Doesn't freshen bound variablesW.Apply a transformation in a bottomup traversalXPApply a transformation in a bottomup traversal. Doesn't freshen bound variablesY?Only apply the second transformation if the first one succeeds.Z<Only apply the second transformation if the first one fails.[.Keep applying a transformation until it fails. S/Freshen variable references in abstracted terms+The transformation to apply to the subtreesTUVWXYZ[\ STUVWXYZ[\ STUVWXYZ[\ STUVWXYZ[\None _Split a normalized term into: a list of arguments, a list of let-bindings, and a variable reference that is the body of the let-binding. Returns a String containing the error is the term was not in a normalized form.`Converts a Core type to a HWType given a function that translates certain builtin types. Errors if the Core type is not translatable.aKConverts a Core type to a HWType within the NetlistMonad; errors on failureb:Converts a Core type to a HWType within the NetlistMonad;  on failurec5Returns the name of the clock corresponding to a typedConverts a Core type to a HWType given a function that translates certain builtin types. Returns a string containing the error message when the Core type is not translatable.eRConverts an algebraic Core type (split into a TyCon and its argument) to a HWType.f/Simple check if a TyCon is recursively defined.gnDetermines if a Core type is translatable to a HWType given a function that translates certain builtin types.h Determines the bitsize of a typei3Determines the bitsize of the constructor of a typej(Gives the length of length-indexed typesk}Gives the HWType corresponding to a term. Returns an error if the term has a Core type that is not translatable to a HWType.l_Turns a Core variable reference to a Netlist expression. Errors if the term is not a variable.mLUniquely rename all the variables and their references in a normalized termnAppend a string to a nameoPreserve the Netlist  and  when executing a monadic action_`abcde#Hardcoded Type -> HWType translator TyCon cache9String representation of the Core type for error messages The TyConIts applied argumentsfghijklmno_`abcdefghijklmno_`abcdefghijklmno_`abcdefghijklmnoNone CEp%Generate VHDL for a Netlist componentqIGenerate a VHDL package containing type definitions for the given HWTypesr'Convert a Netlist HWType to a VHDL types3Convert a Netlist HWType to the root of a VHDL typet>Convert a Netlist HWType to a default VHDL value for that typeu5Turn a Netlist Declaration to a VHDL concurrent blockv0Turn a Netlist expression into a VHDL expression#pqrstuvEnclose in parenthesis?Expr to convertpqrstuvpqrtsuv#pqrstuvNone w!Determine if the number of normalliteralqfunction inputs of a blackbox context at least matches the number of argument that is expected by the template.x>Count the number of argument tags/holes in a blackbox templatey?Counter the number of literal tags/holes in a blackbox templatezBCount the number of function instantiations in a blackbox template{uUpdate all the symbol references in a template, and increment the symbol counter for every newly encountered symbol.|*Get the name of the clock of an identifier}XRender a blackbox given a certain context. Returns a filled out template and a list of hidden9 inputs that must be added to the encompassing component.~ Render a single template elementFill out the template corresponding to an output/input assignment of a component instantiation, and turn it into a single identifier so it can be used for a new blackbox context.pGive a context and a tagged hole (of a template), returns part of the context that matches the tag of the hole. wTemplate to check againstBlackbox to verifyxyz{|}Blackbox template Context used to fill in the hole~ wxyz{|}~ wxyz{|}~ wxyz{|}~None  -./EHJKM1Lift an action working in the inner monad to the "1Lift an action working in the inner monad to the #1Record if a transformation is succesfully applied"Perform a transformation on a Term,Evaluate a RewriteSession to its inner monad7Notify that a transformation has changed the expression^Identity function that additionally notifies that a transformation has changed the expression>Create a type and kind context out of a transformation contextaCreate a complete type and kind context out of the global binders and the transformation context3Make a new binder and variable reference for a termDMake a new binder and variable reference for either a term or a typeCMake a new, unique, identifier and corresponding variable reference@Inline the binders in a let-binding that have a certain propertySubstitute the RHS of the first set of Let-binders for references to the first set of Let-binders in: the second set of Let-binders and the additional termCalculate the localb free variable of an expression: the free variables that are not bound in the global environment.TLift the binders in a let-binding to a global function that have a certain propertyCreate a global function for a Let-binding and return a Let-binding where the RHS is a reference to the new global function applied to the free variables of the original RHS,Make a global function for a name-term tuple+Add a function to the set of global binders@Create a new name out of the given name, but with another unique=Test whether a term is a variable reference to a local binder5Determine if a term cannot be represented in hardware1Is the Context a Lambda/Term-abstraction context?+Make a binder that should not be referencedNMake a case-decomposition that extracts a field out of a (Sum-of-)Product type)Specialise an application on its argument)Specialise an application on its argument=Create binders and variable references for free variables in specArgName of the transformationTransformation to be appliedName of the transformationTransformation to performTerm to transform TyCon cacheName of the new binder Term to bind TyCon cacheName of the new binderType or Term to bindName of the identifier Property testLet-binders to substitute*Let-binders where substitution takes place)Expression where substitution takes place Property testName of the functionTerm bound to the function6Name with a proper unique and the type of the function#Name of the caller of this function TyCon cache7Transformation Context in which this function is calledSubject of the case-composition"Lens into previous specialisations$Lens into the specialisation history"Lens into the specialisation limit"Lens into previous specialisations Lens into specialisation history"Lens into the specialisation limit Original term@Function part of the term, split into root and applied argumentsArgument to specialize onNone TADetermine if a function is already inlined in the context of the  NetlistMonad(Specialize under the Normalization MonadDetermine if a term is closed)Determine if a term represents a constant=Create a call graph for a set of global binders, given a rootIDetermine the sets of recursive components given the edges of a callgraph .List of functions that should not be inspectedGlobal bindersRoot of the call graph "(calling function,[called function)]Original BindersDependency GraphRecursive blockLambda-dropped BindersDependency GraphRecursive blockRecursive block dominatorOriginal BindersRecursive block dominatorRecursive block dominator rootBlock sank binder   None 2Generate the context for a BlackBox instantiation.>Instantiate a BlackBox template according to the given context:Create an template instantiation text for an argument termgCreate an template instantiation text for an argument term, given that the term is a literal. Returns  if the term is not a literal.Create an template instantiation text and a partial blackbox content for an argument term, given that the term is a function. Errors if the term is not a functionMInstantiate symbols references with a new symbol and increment symbol counter5Identifier binding the primitive/blackbox application/Arguments of the primitive/blackbox applicationTemplate to instantiate$Context to instantiate template withThe literal argument termBIdentifier binding the encompassing primitive/blackbox applicationThe function argument termNoneE]UGenerate an expression for a DataCon application occurring on the RHS of a let-binder^3Generate a component for a given function (caching)EGenerate a hierarchical netlist out of a set of global binders with  topEntity at the top.0Run a NetlistMonad action in a given environment)Generate a component for a given function0Generate a list of Declarations for a let-binderXGenerate a list of Declarations for a let-binder where the RHS is a function applicationFGenerate an expression for a term occurring on the RHS of a let-binder]#HWType of the LHS of the let-binderApplied DataConDataCon Arguments@Returned expression and a list of generate BlackBox declarations^Name of the function$Starting value of the unique counterState for the ) MonadGlobal bindersPrimitive definitions TyCon cache#Hardcoded Type -> HWType translator Symbol count Name of the  topEntityState for the ) MonadGlobal bindersPrimitive Definitions TyCon cache"Hardcode Type -> HWType translator Action to runName of the functionCorresponding term$Starting value of the unique counterLHS of the let-binderRHS of the let-binderLHS of the let-binderName of the applied functionFunction arguments!Type of the LHS of the let-binder Term to convert to an expression@Returned expression and a list of generate BlackBox declarations]^^]]^None 4Inline non-recursive, non-representable let-bindings#Lift non-representable let-bindings"Specialize functions on their type8Specialize functions on their non-representable argument@Lift the let-bindings out of the subject of a Case-decompositionVMove a Case-decomposition from the subject of a Case-decomposition to the alternatives\Inline function with a non-representable result if it's the subject of a Case-decompositionSpecialize a Case-decomposition (replace by the RHS of an alternative) if the subject is (an application of) a DataCon; or if there is only a single alternative that doesn't reference variables bound by the pattern.lBring an application of a DataCon or Primitive in ANF, when the argument is is considered non-representablekEnsure that top-level lambda's eventually bind a let-expression of which the body is a variable-reference.Remove unused let-bindingsUInline let-bindings when the RHS is either a local variable reference or is constantInline nullary/closed functions4Specialise functions on arguments which are constant7Propagate arguments of application inwards; except for g' where the argument becomes let-bound.lTurn an expression into a modified ANF-form. As opposed to standard ANF, constants do not become let-bound.9Eta-expand top-level lambda's (DON'T use in a traversal!)Turn a normalized recursive function, where the recursive calls only pass along the unchanged original arguments, into let-recursive function. This means that all recursive calls are replaced by the same variable reference as found in the body of the top-level let-expression.+Inline a function with functional argumentsNoneNormalisation transformation+Topdown traversal, stops upon first success None-Run a NormalizeSession in a given environment7Rewrite a term according to the provided transformation;Check if the call graph (second argument), starting at the topEnity (first argument) is non-recursive. Returns the list of normalized terms if call graph is indeed non-recursive, errors otherwise.`Perform general "clean up" of the normalized (non-recursive) function hierarchy. This includes:6Inlining functions that simply "wrap" another function Level of debug messages to print UniqueSupplyGlobal Binders#Hardcoded Type -> HWType translator TyCon cacheNormalizeSession to runTransformation to applyTerm to transform  topEntityList of normalized bindersVisitedGlobal bindersRoot of the call graph !NonehGenerate a VHDL testbench for a component given a set of stimuli and a set of matching expected outputs  PrimitivesGlobal bindersStimuliExpected output Component to generate TB for "None2Create a set of .VHDL files for a set of functions)Pretty print Components to VHDL DocumentsPrepares the directory for writing VHDL files. This means creating the dir if it does not exist and removing all existing .vhdl files from it.)Writes a VHDL file to the given directorySet of functions Primitive / BlackBox Definitions TyCon cache Hardcoded ( ->  translator5Debug information level for the normalization process*+,-../0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWVXUYZ[ \]^_`abcdefghijklmnop q r s t u v w x y z { | } ~  wW 6 w\w        !"#$%&'()*+,-./012334567899:;<=>?@ABCDEFGHIJKLMNNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~              !""""#$##%      !"#$%&' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C  D E F G HIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~)!!!!!!!!clash-lib-0.2.2 CLaSH.UtilCLaSH.Netlist.IdCLaSH.Primitives.TypesCLaSH.Core.TyConCLaSH.Primitives.UtilCLaSH.Core.TermCLaSH.Core.TypeCLaSH.Core.VarCLaSH.Core.DataConCLaSH.Core.TysPrimCLaSH.Core.LiteralCLaSH.Core.SubstCLaSH.Core.FreeVarsCLaSH.Driver.TypesCLaSH.Core.PrettyCLaSH.Core.UtilCLaSH.Netlist.TypesCLaSH.Rewrite.TypesCLaSH.Normalize.TypesCLaSH.Netlist.BlackBox.TypesCLaSH.Netlist.BlackBox.ParserCLaSH.Rewrite.Combinators CLaSH.NetlistCLaSH.Netlist.UtilCLaSH.Netlist.VHDLCLaSH.Netlist.BlackBox.UtilCLaSH.Rewrite.UtilCLaSH.Normalize.UtilCLaSH.Netlist.BlackBoxCLaSH.Normalize.TransformationsCLaSH.Normalize.StrategyCLaSH.NormalizeCLaSH.Driver.TestbenchGen CLaSH.Driver Control.Arrowfirstsecond Data.List partition mapAccumLVHDLM lens-4.0.7Control.Lens.TH makeLenses mkBasicId PrimitiveprimTypeBlackBoxnametemplatePrimMap$fFromJSONPrimitive TyConNameTyCon MonadUnique getUniqueMcurLoc makeCached makeCachedT3 makeCachedT3S liftStatefirstMsecondMtraceIf partitionM mapAccumLMdot ifThenElse<:> indexMaybe indexNote splitAtList $fOrdEmbed$fHashableName$fMonadUniqueStateTgeneratePrimMapdecodeAndReportTmNameTermKiNameTyNameKindType mkTyConTyTyVarIdVarvarTypevarNamevarKind modifyVarNameDataConPrimRepVoidRepIntRep AlgTyConRhsNewTyCondataCon ntEtadRhs DataTyCondataConsSuperKindTyCon PrimTyCon primTyConRepAlgTyCon tyConName tyConKind tyConArityalgTcRhs mkKindTyConisTupleTyConLike tyConDataConsliftedTypeKind typeNatKindtypeSymbolKind intPrimTy voidPrimTy tysPrimMapLiteralRationalLiteral StringLiteralIntegerLiteral literalTypeDcNameConTagMkDatadcNamedcTagdcType dcUnivTyVars dcExtTyVarsdcArgTysdataConInstArgTysPat DefaultPatLitPatDataPat LetBindingCaseLetrecTyAppAppTyLamLamPrimDatasubstTyssubstTy substKindWith substTyInTm substTysinTmsubstTmsubstTms KindOrTypeLitTySymTyNumTyConstTyArrowTypeView OtherTypeTyConAppFunTyAppTyForAllTyVarTytyView transparentTycoreViewmkFunTy mkTyConAppsplitTyConAppMtypeKindisPolyTy splitFunTysplitFunForallTy isPolyFunTyisPolyFunCoreTyisFunTy applyFunTyapplyTy typeFreeVars termFreeVars termFreeIdstermFreeTyVars BindingMapPrettypprpprPrecshowDocDeltaGammatermType collectArgs collectBndrsapplyTypeToArgspatIdsmkTyVarmkId mkAbstractionmkTyLamsmkLamsmkAppsmkTmAppsmkTyAppsisFun isPolyFunisLamisLetisVarisConisPrimidToVarvarToIdBitZULHVecLitBoolLitBitLitNumLitExpr BlackBoxE IdentifierModifier VecAppendDCIndexed DeclarationNetDecl BlackBoxDInstDeclCondAssignment AssignmentHWTypeResetClockSPProductSumVectorUnsignedSignedIntegerBoolVoidSize Component componentName hiddenPortsinputsoutput declarations NetlistState _bindings_varEnv _varCount _cmpCount _components _primitives _vhdlMState_typeTranslator_tcCache VHDLState NetlistMonad runNetlist$fNFDataDeclaration$fNFDataHWType$fHashableHWType$fNFDataComponentbindingscmpCount components primitivestcCachetypeTranslatorvarCountvarEnv vhdlMState RewriteState_transformCounter _uniqSupply CoreContext CaseScrutCaseAlt TyLamBodyLamBodyLetBodyTyAppCAppArgAppFun RewriteEnvRE _dbgLevel DebugLevelDebugAll DebugApplied DebugName DebugFinal DebugNonetransformCounter uniqSupplyRewrite TransformRrunR RewriteMonadRewriteSessiondbgLevel$fMonadUniqueWriterTNormalizeState _normalized_specialisationCache_specialisationHistory_specialisationLimit_inlineHistory _inlineLimit_curFun NormRewriteNormalizeSessionNormalizeMonadcurFun inlineHistory inlineLimit normalizedspecialisationCachespecialisationHistoryspecialisationLimit BlackBoxMonadB runBlackBoxMDeclElementDefTypMTypRstClkSymIODCBlackBoxTemplateSyncIdentifierBlackBoxContextContextresult litInputs funInputsrunParseallR>->topdownRunsafeTopdownR bottomupRunsafeBottomupR!->>-!repeatRwhenRmkDcApplication genComponentsplitNormalizedunsafeCoreTypeToHWTypeunsafeCoreTypeToHWTypeMcoreTypeToHWTypeMsynchronizedClkcoreTypeToHWTypemkADT isRecursiveTyrepresentableTypetypeSizeconSize typeLength termHWType varToExprmkUniqueNormalized appendToNamepreserveVarEnvgenVHDL mkTyPackagevhdlType vhdlTypeMarkvhdlTypeDefaultinstexprverifyBlackBoxContext countArgs countLits countFunssetSym clkSyncIdrenderBlackBox renderElemlineToIdentifiermkSyncIdentifierliftRliftRSapply runRewriterunRewriteSession setChangedchanged contextEnvmkEnv mkTmBinderFor mkBinderFor mkInternalVar inlineBinderssubstituteBinders localFreeVars liftBinders liftBinding mkFunction addGlobalBindcloneVar isLocalVarisUntranslatableisLambdaBodyCtxmkWildValBindermkSelectorCase specialise specialise'specArgBndrsAndVarsuntranslatableFVsalreadyInlined addNewInlinespecializeNormisClosed isConstant callGraphrecursiveComponentslambdaDropPrep lambdaDrop dominator blockSinkmkBlackBoxContext mkBlackBoxmkInput mkLitInput mkFunInputinstantiateSym genNetlistrunNetlistMonad genComponentTmkDeclarationsmkFunAppmkExpr bindNonRep liftNonReptypeSpec nonRepSpeccaseLetcaseCase inlineNonRepcaseCon nonRepANFtopLetdeadCodebindConstantVar inlineClosed constantSpecappPropmakeANFetaExpansionTL recToLetRecinlineHO normalizationconstantPropgation topdownSucR innerMost applyManyCallTreeCBranchCLeafrunNormalization normalize normalize' rewriteExprcheckNonRecursive cleanupGraph mkCallTree stripArgs flattenNodeflattenCallTreecallTreeToList genTestBench generateVHDL createVHDL prepareDir writeVHDL EncodedString UserStringzEncode encodeDigitChencodeChencodeAsUnicodeChar unencodedCharghc-prim GHC.TypesTruebase Data.MaybeNothingControl.Applicative<*>pure Applicative*** Data.Functionon Data.Functor<$> Control.Monad<=<>=>rVarrVar1 $fNFDataVar$fSubstTypeVar$fSubstTypeVar0$fSubstTermVar$fSubstTermVar0 $fAlphaVar$fRepVar $fOrdTyCon $fEqTyCon $fShowTyConrTyConrTyCon1 rAlgTyConRhs rAlgTyConRhs1rPrimRep rPrimRep1$fNFDataPrimRep$fNFDataAlgTyConRhs $fNFDataName $fNFDataTyCon$fSubstTermPrimRep$fSubstTermAlgTyConRhs$fSubstTermTyCon$fSubstTypePrimRep$fSubstTypeAlgTyConRhs$fSubstTypeTyCon$fAlphaAlgTyConRhs $fAlphaTyCon$fAlphaPrimRep $fRepTyContySuperKindTyConNameliftedTypeKindTyConNametypeNatKindTyConNametypeSymbolKindTyConName tySuperKindtcliftedTypeKindtc typeNatKindtctypeSymbolKindtc intPrimTc voidPrimTc tySuperKindintPrimTyConNamevoidPrimTyConName liftedPrimTCrLiteral rLiteral1$fNFDataLiteral$fSubstTermLiteral$fSubstTypeLiteral$fAlphaLiteral $fSubstbRatio $fAlphaRatio $fRepLiteral $fOrdDataCon $fEqDataCon $fShowDataConrDataCon rDataCon1$fNFDataDataCon$fSubstTermDataCon$fSubstTypeDataCon$fAlphaDataCon $fRepDataConrTextrText1 $fAlphaText $fRepTextrTermrTerm1rPatrPat1 $fNFDataPat $fNFDataTerm$fSubstTypeText$fSubstTermText$fSubstTypeTerm$fSubstTypePat$fSubstTermTerm$fSubstTermPat $fAlphaPat $fAlphaTerm $fOrdTerm$fEqTerm $fRepTermnewTyConInstRhs isSuperKind splitTyAppMrTyperType1rLitTyrLitTy1rConstTy rConstTy1 kindFunResult $fNFDataLitTy$fNFDataConstTy $fNFDataType $fOrdType$fEqType$fSubstTypeType$fSubstTermType$fSubstTermConstTy$fSubstTypeConstTy$fSubstTermLitTy$fSubstTypeLitTy $fAlphaLitTy$fAlphaConstTy $fAlphaType $fRepTypeTypePrec TyConPrecFunPrecTopPrec BindingSiteLetBindCaseBind LambdaBindnoPrecopPrecappPrec prettyParenpprTopLevelBndrdcolonperiodrarrow pprPrecLam pprPrecTyLam pprPrecApp pprPrecTyApp pprPrecLetrec pprPrecCase pprPrecAltpprBndr maybeParenpprType pprParendTypeppr_type pprForAllType pprSigmaType pprForAll pprTvBndrpprKindpprTcApppprTypeNameApp pprInfixApp pprPrefixApp pprPrefixVar pprInfixVar pprArrowChain isSymNameisLexSym isLexConSym isLexVarSym startsConSym startsVarSym isSymbolASCII $fPrettyPat$fPrettyLiteral$fPrettyDataCon $fPrettyVar $fPrettyTerm $fPrettyLitTy $fPrettyTyCon $fPrettyVar0 $fPrettyType $fPretty(,) $fPretty[] $fPrettyName pBlackBoxDpElementpTextpTagDpDeclpOutputpInputpTagE pBracketspTokenWS pBlackBoxEpElemEParser mkUsedTys topSortHWTysmkVecZ needsTyDectyDecfunDec tyImportsentity architecture vhdlType'tyNamedeclsdeclinsts otherSize vectorChainexprLittoBitsbitsbit_chartoSLVfromSLVdcToExprlarrowparenIf punctuate' NormRewriteW liftNormR collectANF delayedSignalrenderFloat2Dec genAssertmkToStringDeclsprepareSignals termToList stimuliElemTy createSignal