^;      !"#$%&'()*+,-./0123456789:;<=>?@ A B C D E F G H I J K L M N O P Q R S T U V W X YZ[\]^_`abcdefghijk l m n o p q r s t u v wxyz{|}~       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                !!!!!!! !!"#$%&'"(#)#*#+#,#-#.#/#0#1#2#3#4#5#6$7$8$9$:$'%Safe ;<=>?@ABCDEFG<BCDEFG ;<=>?@ABCDEFGSafe DTransform/format a text so that it is acceptable as a HDL identifier HIJKLMNOP HIJKLMNOPSafeComponent 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.eThe LHS of the tuple is the name of the signal, while the RHS of the tuple is the type of the signalElements of a blackbox contextConstantComponent instantiation hole  Output hole  Input hole  Literal hole  Symbol hole VClock hole (Maybe clk corresponding to input, clk corresponding to output if Nothing) Reset holeType declaration holeType root holeError value hole&Select element type from a vector typeIHole for the name of the component in which the blackbox is instantiatedAIndex data type hole, the field is the (exclusive) maximum indexSize of a type holeLength of a vector hole*Hole containing a filepath for a data fileGHole marking beginning (True) or end (False) of a generative construct)A BlackBox Template is a List of Elements    NoneSParse a text as a BlackBoxTemplate, returns a list of errors in case parsing failsQ7Parse a BlackBoxTemplate (Declarations and Expressions)RParse a single Template ElementS!Parse the Text part of a TemplateT)Parse a Declaration or Expression elementUParse a DeclarationV#Parse the output tag of DeclarationW"Parse the input tag of DeclarationXParse an Expression elementYParse a bracketed textZ)Parse a token and eat trailing whitespace[/Parse the expression part of Blackbox Templates\Parse an Expression or Text] Parse SigD^(Text excluding square brackets and tilde_QRSTUVWXYZ[\]^_QRSTUVWXYZ[\]^NoneUExternally defined primitiveLA primitive that has a template that can be filled out by the backend renderName of the primitive  Either a  declaration or an  expression template.!/A primitive that carries additional information"Additional information#Primitive Definitions !"#$ !"# #! "$! "#$None35FIN)(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 action-ICache the result of a monadic action in a State 3 transformer layers down.Spine-strict cache variant of  mkCachedT3/IRun a State-action using the State that is stored in a higher-layer Monad0Functorial version of &'1Functorial version of &(30Performs trace when first argument evaluates to `4Monadic version of )*5Monadic version of )+66Composition of a unary function with a binary function7)if-then-else as a function on an argument8&Applicative version of 'GHC.Types.(:)'9Safe indexing, returns a a if the index does not exist:BUnsafe indexing, return a custom error message when indexing fails;5Split the second list at the length of the first list=ceiling (log_2(c)))*+,%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 perform0123456789:;<=> bcdefghijk)*+,-./0123456789:;<=)*>+,-./0123456789:;<=)*+,-./0123456789:;<=>8,NonelMParse a ByteString according to the given JSON template. Prints failures on stdout, and returns a if parsing fails.lBytestring to parsellNone?hGenerate a set of primitives that are found in the primitive definition files in the given directories.?/Directories to search for primitive definitions???-None357mnopmnop None027E Type variableF Term variableGVariables in CoreHWHConstructor for type variablesKConstructor for term variablesMChange the name of a variable EFGHIJKLMqrs EFGHIJKLM GHKIJILFEMEFGHKIJILMqrs None02357 NDataCon referenceO:Syntactical position of the DataCon in the type definitionPData ConstructorRName of the DataConS+Syntactical position in the type definitionTType of the 'DataConUmUniversally quantified type-variables, these type variables are also part of the result type of the DataConVExistentially quantified type-variables, these type variables are not part of the result of the DataCon, but only of the arguments.WArgument typesXGiven 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.NThe list of types should be equal to the number of type variables, otherwise Nothing is returned.NOPQRSTUVWXtuvwx NOPQRSTUVWX PQRSTUVWNOX NOPQRSTUVWXtuvwxNone02357%TyCon reference&Type ConstructorY The RHS of an Algebraic Datatype[The DataCons of a TyCon]The 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._Algorithmic DataCons`Name of the TyConaKind of the TyConbNumber of type argumentscDataCon definitionsd$Function TyCons (e.g. type families)e&List of: ([LHS match types], RHS type)fPrimitive TyConsg'To close the loop on the type hierarchyh Create a Kind out of a TyConNamei&Does the TyCon look like a tuple TyConj%Get the DataCons belonging to a TyCon%&YZ[\]^_`abcdefghijyz{|%&YZ[\]^_`abcdefghij&_dfg`abc`abe`ab`%YZ\[]^hij %&_dfg`abc`abe`ab`YZ\[]^hijyz{| None } Builtin Name~ Builtin Name Builtin Name Builtin Name Builtin Kind Builtin Kind Builtin Kind Builtin Kind Builtin Type Builtin Type Builtin Type}~klmnopqklmnopqklmnopq}~klmnopq None02357r Term Literalv Determines the Type of a LiteralrstuvrstuvrstuvrstuvNone02357'Term reference(DTerm representation in the CoreHW language: System F + LetRec + Casew+Patterns in the LHS of a case-decompositionxVDatatype pattern, '[TyVar]' bind existentially-quantified type-variables of a DataConyLiteral patternzDefault pattern{Binding in a LetRec construct|Variable reference}Datatype constructor~Literal PrimitiveTerm-abstractionType-abstraction ApplicationType-applicationRecursive let-bindingECase-expression: subject, type of alternatives, list of alternatives'(wxyz{|}~'(wxyz{|}~(|}~'{wxyz '( |}~wxyz{NoneSubstitutes types in a typeSubstitutes a type in a typeSubstitutes kinds in a kindSubstitutes a type in a termSubstitutes types in a termSubstitutes a term in a termSubstitutes terms in a term None 02357%@Reference to a KindAReference to a TypeBThe level above typesC/Types in CoreHW: function and polymorphic typesDMake a Type out of a TyConEither a Kind or a Type Literal TypesType Constants TyCon type Function typeAn easier view on types Function type Applied TyConNeither of the above Type variable Type constantPolymorphic TypeType Application Type literalAn easier view on typesA transformation that renders Signal types transparentA view on types in which SignalU types and newtypes are transparent, and type functions are evaluated when possible.ZInstantiate 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 argumentsIs 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 typeCSplit a type application in the applied type and the argument types3@ABCD'@ABCDE'CB@AED'@ABCDNone'Gives the free type-variables in a Type'Gives the free term-variables of a Term'Gives the free type-variables of a TermNone 35#Pretty printing Show-like typeclass Print a Pretty thing to a String?7None Kind 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 reference$Create a vector of supplied elements&Append elements to the supplied vectorCreate let-bindings with case-statements that select elements out of a vector. Returns both the variables to which element-selections are bound and the let-bindings*Determine whether a type is isomorphic to CLaSH.Signal.Internal.Signal' It is i.e.: Signal' clk a(Signal' clk a, Signal' clk b)Vec n (Signal' clk a)data Wrap = W (Signal clk' Int)etc.The Nil constructorThe Cons (:>) constructor Element typeLength of the vectorElements to put in the vectorThe Cons (:>) constructor Element type$The vector to append the elements toLength of the vectorElements to appendThe Cons (:>) constructorThe element type*Char to append to the bound variable namesLength of the vector The vectorNone0CA\Either the name of the identifier, or a tuple of the identifier and the corresponding clock8Context used to fill in the holes of a BlackBox templateResult name and type2Argument names, types, and whether it is a literal&Function arguments (subset of inputs):,(Blackbox Template,Partial Blackbox Concext) Bit literalHighLow UndefinedHigh-impedanceLiterals used in an expressionNumber literal Bit literalBoolean literalVector literalString literal'Expression used in RHS of a declarationLiteral expressionDataCon applicationSignal referenceLeft e : tagToEnum, @Right e@: dataToTag&Instantiation of a BlackBox expressionExpression Modifier@Index the expression: (Type of expression,DataCon tag,Field Tag)JSee expression in a DataCon context: (Type of the expression, DataCon tag)>See the expression in the context of a Vector append operationInternals of a ComponentSignal assignment:Signal to assignAssigned expressionConditional signal assignment:Signal to assignType of the result/alternativesScrutinized expressionVList of: (Maybe expression scrutinized expression is compared with,RHS of alternative)"Instantiation of another component%Instantiation of blackbox declarationSignal declarationRepresentable hardware types Empty type Boolean type Integer typeBitVector of a specified size9Unsigned integer with specified (exclusive) upper bounder"Signed integer of a specified size$Unsigned integer of a specified size Vector type$Sum type: Name and Constructor names"Product type: Name and field types=Sum-of-Product type: Name and Constructor names + field types)Clock type with specified name and periodBReset type corresponding to clock with a specified name and period?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 ports Internal declarations Signal reference State of the NetlistMonad Global bindersType environment/contextNumber of signal declarationsNumber of create componentsCached componentsPrimitive Definitions#Hardcoded Type -> HWType translator TyCon cache"Name of the module containing the  topEntity}Monad that caches generated components (StateT) and remembers hidden inputs of components that are being generated (WriterT)Y      !"#$%&'()*U      !"#$%&'()*Y     *)('&%$#"!        !"#$%&'()*None357C+State of a rewriting session-!Number of applied transformations.Global binders/Supply of unique numbers0&Function which is currently normalized1 Used for 2Additional state3Context in which a term appears4#Function position of an application5#Argument position of an application6'Function position of a type application7)RHS of a Let-binder with the sibling LHS'8)Body of a Let-binding with the bound LHS'92Body of a lambda-term with the abstracted variable::Body of a TyLambda-term with the abstracted type-variable;MRHS of a case-alternative with the variables bound by the pattern on the LHS<Subject of a case-decomposition=,Read-only environment of a rewriting session?(Lvl at which we print debugging messages@"Hardcode Type -> HWType translatorA TyCon cacheB&Hardcoded evaluator (delta-reduction)}CDebug Message VerbosityDDon't show debug messagesE&Show completely normalized expressionsF Names of applied transformationsG/Show sub-expressions after a successful rewriteH8Show all sub-expressions on which a rewrite is attemptedOA P action in the context of the QP=Monadic action that transforms a term given a certain contextQMonad that keeps track how many transformations have been applied and can generate fresh variables and unique identifiers. In addition, it keeps track if a transformation/rewrite has been successfully applied.5+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_-+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVW53456789:;<+,-./012NMLKJICDEFGH=>?@ABWVUTQRS_^]\[ZYXPO+,-./0123 456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_NonefGlobal function binders`abcdef`abcdeff`abcde`abcdefNone g State of the riGlobal bindersj*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)k2Cache of how many times a function was specializedlNumber of time a function f can be specializedm,Cache of function where inlining took place:'Key: function where inlining took place=Elem: (functions which were inlined, number of times inlined)nNumber of times a function f can be inlined in a function goKSize of a function below which it is always inlined if it is not recursivepA  Transform action in the context of the Q and rq3RewriteSession with extra Normalisation informationr?State monad that stores specialisation and inlining informationghijklmnopqrstuvwxyghijklmnopqrstuvwxyghijklmnoyxwvutsrqp ghijklmnopqrstuvwxyNoneN z1Apply a transformation on the subtrees of an term{'Apply two transformations in succession|JApply two transformations in succession, and perform a deepseq in between.}-Apply a transformation in a topdown traversal~OApply a transformation in a topdown traversal. Doesn't freshen bound variables.Apply a transformation in a bottomup traversalPApply a transformation in a bottomup traversal. Doesn't freshen bound variables?Only apply the second transformation if the first one succeeds.<Only apply the second transformation if the first one fails..Keep applying a transformation until it fails.<Only traverse downwards when the assertion evaluates to true z/Freshen variable references in abstracted terms+The transformation to apply to the subtrees{|}~ z{|}~ z{|}~ z{|}~{|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.KConverts a Core type to a HWType within the NetlistMonad; errors on failure:Converts a Core type to a HWType within the NetlistMonad; a on failure@Returns the name and period of the clock corresponding to a typeConverts 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.RConverts an algebraic Core type (split into a TyCon and its argument) to a HWType./Simple check if a TyCon is recursively defined.nDetermines if a Core type is translatable to a HWType given a function that translates certain builtin types. Determines the bitsize of a type3Determines the bitsize of the constructor of a type(Gives the length of length-indexed types}Gives the HWType corresponding to a term. Returns an error if the term has a Core type that is not translatable to a HWType.2Gives the HWType corresponding to a term. Returns aC if the term has a Core type that is not translatable to a HWType._Turns a Core variable reference to a Netlist expression. Errors if the term is not a variable.LUniquely rename all the variables and their references in a normalized termAppend a string to a namePreserve the Netlist  and  when executing a monadic action TyCon cache#Hardcoded Type -> HWType translator TyCon cache9String representation of the Core type for error messages The TyConIts applied argumentsNoneINLift an action working in the 2 state to the Q1Record 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 propertyRDetermine whether a binder is a join-point created for a complex case expression.lA join-point is when a local function only occurs in tail-call positions, and when it does, more than once.GCount the number of (only) tail calls of a function in an expression. aB indicates that the function was used in a non-tail call position.Substitute 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 hardware5Determine if a type 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 testF of the local binder'Expression in which the binder is boundFunction to checkExpression to check it inLet-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 onNoneUADetermine 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 Function we want to inline1Function in which we want to perform the inliningFunction we want to inline1Function in which we want to perform the inlining.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 Replace an application of the CLaSH.Sized.Vector.zipWith) primitive on vectors of a known length n3, by the fully unrolled recursive "definition" of CLaSH.Sized.Vector.zipWithReplace an application of the CLaSH.Sized.Vector.map) primitive on vectors of a known length n3, by the fully unrolled recursive "definition" of CLaSH.Sized.Vector.mapReplace an application of the CLaSH.Sized.Vector.traverse#) primitive on vectors of a known length n3, by the fully unrolled recursive "definition" of CLaSH.Sized.Vector.traverse#Create the traversable vectore.g. for a length '2' input vector, we get *(:>) <$> x0 <*> ((:>) <$> x1 <*> pure Nil)Replace an application of the CLaSH.Sized.Vector.foldr) primitive on vectors of a known length n3, by the fully unrolled recursive "definition" of CLaSH.Sized.Vector.foldrReplace an application of the CLaSH.Sized.Vector.fold) primitive on vectors of a known length n3, by the fully unrolled recursive "definition" of CLaSH.Sized.Vector.foldReplace an application of the CLaSH.Sized.Vector.dfold) primitive on vectors of a known length n3, by the fully unrolled recursive "definition" of CLaSH.Sized.Vector.dfoldReplace an application of the CLaSH.Sized.Vector.head) primitive on vectors of a known length n4, by a projection of the first element of a vector.Replace an application of the CLaSH.Sized.Vector.tail) primitive on vectors of a known length n+, by a projection of the tail of a vector.Replace an application of the CLaSH.Sized.Vector.(++)) primitive on vectors of a known length n3, by the fully unrolled recursive "definition" of CLaSH.Sized.Vector.(++)Replace an application of the CLaSH.Sized.Vector.unconcat) primitive on vectors of a known length n3, by the fully unrolled recursive "definition" of CLaSH.Sized.Vector.unconcatReplace an application of the CLaSH.Sized.Vector.transpose) primitive on vectors of a known length n3, by the fully unrolled recursive "definition" of CLaSH.Sized.Vector.transpose Length of the vector(s)Type of the lhs of the functionType of the rhs of the function"Type of the result of the functionThe zipWith'd functionsThe 1st vector argumentThe 2nd vector argumentLength of the vectorArgument type of the functionResult type of the functionThe map'd functionThe map'd over vectorLength of the vector#Element type of the argument vectorThe type of the applicative!Element type of the result vectorThe  Applicative dictionaryThe function to traverse withThe argument vector Vec tconNil conCons cond termc term termb tyLength of the vectorElements of the vectorLength of the vector#Element type of the argument vectorType of the starting elementThe function to fold withThe starting valueThe argument vectorLength of the vector#Element type of the argument vectorThe function to fold withThe argument vectorLength of the vector#Element type of the argument vectorFunction to fold withStarting valueThe vector to foldLength of the vectorElement type of the vectorThe argument vectorLength of the vectorElement type of the vectorThe argument vectorLength of the LHS argLenght of the RHS argElement type of the vectorsThe LHS argumentThe RHS argumentLength of the result vector+Length of the elements of the result vector Element typeArgument vectorLength of the result vector+Length of the elements of the result vector Element typeArgument vector   None EInline non-recursive, non-representable, non-join-point, 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 functionsInline small functions4Specialise functions on arguments which are constant7Propagate arguments of application inwards; except for ' 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 argumentsDSimplified CSE, only works on let-bindings, works from top to bottomReplace primitives by their "definition" if they would lead to let-bindings with a non-representable type when a function is in ANF. This happens for example when CLaSH.Size.Vector.map consumes or produces a vector of non-representable elements.Basically what this transformation does is replace a primitive the completely unrolled recursive definition that it represents. e.g. 8zipWith ($) (xs :: Vec 2 (Int -> Int)) (ys :: Vec 2 Int)is replaced by: let (x0 :: (Int -> Int)) = case xs of (:>) _ x xr -> x (xr0 :: Vec 1 (Int -> Int)) = case xs of (:>) _ x xr -> xr (x1 :: (Int -> Int)( = case xr0 of (:>) _ x xr -> x (y0 :: Int) = case ys of (:>) _ y yr -> y (yr0 :: Vec 1 Int) = case ys of (:>) _ y yr -> xr (y1 :: Int = case yr0 of (:>) _ y yr -> y in (($) x0 y0 :> ($) x1 y1 :> Nil)3Currently, it only handles the following functions: CLaSH.Sized.Vector.mapCLaSH.Sized.Vector.zipWithCLaSH.Sized.Vector.traverse#CLaSH.Sized.Vector.foldrCLaSH.Sized.Vector.foldCLaSH.Sized.Vector.dfoldCLaSH.Sized.Vector.(++)CLaSH.Sized.Vector.headCLaSH.Sized.Vector.tailNoneNormalisation transformation+Topdown traversal, stops upon first successNone-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 cache%Hardcoded evaluator (delta-reduction)NormalizeSession to runTransformation to applyTerm to transform  topEntityList of normalized bindersVisitedGlobal bindersRoot of the call graph NoneInitial state for state monad&Location for the primitive definitionsmName of backend, used for directory to put output files in. Should be | constant function / ignore argument."File extension for target langauge!Get the set of types out of state$Generate HDL for a Netlist componentHGenerate a HDL package containing type definitions for the given HWTypes-Convert a Netlist HWType to a target HDL type<Convert a Netlist HWType to an HDL error value for that type9Convert a Netlist HWType to the root of a target HDL typeHCreate a signal declaration from an identifier (Text) and Netlist HWType*Create a generative block statement marker4Turn a Netlist Declaration to a HDL concurrent block /Turn a Netlist expression into a HDL expression    None 4U !Determine if the number of normalliteralqfunction inputs of a blackbox context at least matches the number of argument that is expected by the 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 identifierXRender 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. Blackbox to verifyTemplate to check against   Blackbox template Context used to fill in the hole            !NoneF2Generate the context for a BlackBox instantiation.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 application&Put BlackBox expression in parenthesis(Treat BlackBox expression as declarationBIdentifier binding the encompassing primitive/blackbox applicationThe function argument term    NoneFUGenerate an expression for a DataCon application occurring on the RHS of a let-binderFGenerate an expression for a term occurring on the RHS of a let-binder3Generate 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 function$0Generate a list of Declarations for a let-binder%XGenerate a list of Declarations for a let-binder where the RHS is a function application #HWType of the LHS of the let-binderApplied DataConDataCon Arguments@Returned expression and a list of generate BlackBox declarations(Treat BlackBox expression as declaration!Type of the LHS of the let-binder Term to convert to an expression@Returned expression and a list of generate BlackBox declarationsName of the function$Starting value of the unique counter! (Starting number of the component counterGlobal bindersPrimitive definitions TyCon cache#Hardcoded Type -> HWType translator Symbol count"Name of the module containing the  topEntitySet of collected data-files Name of the  topEntity"(Starting number of the component counterGlobal bindersPrimitive Definitions TyCon cache"Hardcode Type -> HWType translator"Name of the module containing the  topEntitySet of collected data-files Action to run#Name of the functionCorresponding term$Starting value of the unique counter$LHS of the let-binderRHS of the let-binder%LHS of the let-binderName of the applied functionFunction arguments& !"#$%& !"#$%& !"#$%&"None'gGenerate a HDL testbench for a component given a set of stimuli and a set of matching expected outputs' PrimitivesGlobal bindersStimuli Expected output "Name of the module containing the  topEntity Set of collected data-files Component to generate TB for'''#(C) 2015, University of TwenteBSD2 (see the file LICENSE)-Christiaan Baaij <christiaan.baaij@gmail.com>NoneF (ICreate a wrapper around a component, potentially initiating clock sources)(Create extra input ports for the wrapper*)Create extra output ports for the wrapper+Generate input port mappings,$Create a Vector chain for a list of  s-Generate output port mappings.Create clock generators0Create a single clock generator2Create a single clock path3Generate resets4YGenerate a reset synchroniser that synchronously de-asserts an asynchronous reset signal5The  NetListMonad is an transformer stack with  at the bottom. So we must use .(TopEntity specifications"Name of the module containing the  topEntityEntity to wrap)*+,-./012345()*+,-./012345()*+,-./012345()*+,-./012345$NoneN67Create a set of target HDL files for a set of functions7(Pretty print Components to HDL Documents8Prepares the directory for writing HDL files. This means creating the dir if it does not exist and removing all existing .hdl files from it.9(Writes a HDL file to the given directory6Set of functions Primitive / BlackBox Definitions TyCon cache Hardcoded C ->  translator%Hardcoded evaluator (delta-reduction)5Debug information level for the normalization process7BackendList of components89:6789:6789:6789:./01234456789:;<=>?@ABCDEFGHIJKLMNOLPQRSTUVWXYZ[\]^_`abcdefghijklm n o p q r s t u s v w t x y z { | } ~       u      T           : |     !"#$D%%&'()* ++,-./01234567789:;<=>?@ABCDEFGHIIJ,KLMNOPQRSTUVWXXY23Z[\]^_`>abcdefghijklEFmnopqrstuuvwxyz{{|}~     N      ! " # $ % & ' ( ) *!+!,!-!.!/!0!1!2345678"9#:#;#<#=#>#?#@#A#B#C#D#E#F#G$H$I$J$K$L%M%N%O%P%Q%R%S%T%U%V%W%X%YZ[\]^_`abcdefghijklmnopqrstuvwu&'uvxuvyuvzu{|u}~u}u&u&(u,----                                       uv""""""rsuclash_0brcBbGzkCiLLrZljq0KjI CLaSH.UtilCLaSH.Netlist.IdCLaSH.Netlist.BlackBox.TypesCLaSH.Netlist.BlackBox.ParserCLaSH.Primitives.TypesCLaSH.Core.TyConCLaSH.Core.TermCLaSH.Primitives.UtilCLaSH.Core.TypeCLaSH.Core.VarCLaSH.Core.DataConCLaSH.Core.TysPrimCLaSH.Core.LiteralCLaSH.Core.SubstCLaSH.Core.FreeVarsCLaSH.Core.PrettyCLaSH.Core.UtilCLaSH.Netlist.TypesCLaSH.Rewrite.TypesCLaSH.Driver.TypesCLaSH.Normalize.TypesCLaSH.Rewrite.CombinatorsCLaSH.Netlist.UtilCLaSH.Rewrite.UtilCLaSH.Normalize.Util#CLaSH.Normalize.PrimitiveReductionsCLaSH.Normalize.TransformationsCLaSH.Normalize.StrategyCLaSH.Normalize CLaSH.Netlist CLaSH.BackendCLaSH.Netlist.BlackBox.UtilCLaSH.Netlist.BlackBoxCLaSH.Driver.TestbenchGenCLaSH.Driver.TopWrapper CLaSH.DriverPaths_clash_lib Control.Arrowfirstsecond Data.List partition mapAccumLData.Aeson.Extra&Unbound.Generics.LocallyNameless.Extralens_7kluSRXEixn2fpwVEEJDenControl.Lens.TH makeLenses mkBasicId mkBasicId'stripDollarPrefixesDeclElementCDOILSymClkRstTypTypMErrTypElemCompName IndexTypeSizeLengthFilePathGenIFSigDBlackBoxTemplaterunParse PrimitiveBlackBoxnametemplateprimTypePrimMap$fFromJSONPrimitive TyConNameTyConTmNameTerm MonadUnique getUniqueMcurLoc makeCached makeCachedT3 makeCachedT3S liftStatefirstMsecondMcombineMtraceIf partitionM mapAccumLMdot ifThenElse<:> indexMaybe indexNote splitAtListclashLibVersionclog2$fMonadUniqueStateTgeneratePrimMapKiNameTyNameKindType mkTyConTyTyVarIdVarvarNamevarKindvarType modifyVarNameDcNameConTagDataConMkDatadcNamedcTagdcType dcUnivTyVars dcExtTyVarsdcArgTysdataConInstArgTys AlgTyConRhs DataTyCondataConsNewTyCondataCon ntEtadRhsAlgTyCon tyConName tyConKind tyConArityalgTcRhsFunTyCon tyConSubst PrimTyConSuperKindTyCon mkKindTyConisTupleTyConLike tyConDataConsliftedTypeKind typeNatKindtypeSymbolKind intPrimTy stringPrimTy voidPrimTy tysPrimMapLiteralIntegerLiteral StringLiteralRationalLiteral literalTypePatDataPatLitPat DefaultPat LetBindingDataPrimLamTyLamAppTyAppLetrecCasesubstTyssubstTy substKindWith substTyInTm substTysinTmsubstTmsubstTms KindOrTypeLitTyNumTySymTyConstTyArrowTypeViewFunTyTyConApp OtherTypeVarTyForAllTyAppTytyView transparentTycoreViewmkFunTy mkTyConAppsplitTyConAppMtypeKindisPolyTy splitFunTy splitFunTyssplitFunForallTy isPolyFunTyisPolyFunCoreTyisFunTy applyFunTyapplyTy findFunSubst typeFreeVars termFreeIdstermFreeTyVarsPrettypprpprPrecshowDocDeltaGammatermType collectArgs collectBndrsapplyTypeToArgspatIdsmkTyVarmkId mkAbstractionmkTyLamsmkLamsmkAppsmkTmAppsmkTyAppsisFun isPolyFunisLamisLetisVarisConisPrimidToVarvarToIdtermSizemkVec appendToVec extractElems isSignalTypeSyncExprSyncIdentifierBlackBoxContextContextbbResultbbInputs bbFunctionsBitHUZNumLitBitLitBoolLitVecLit StringLitExpr IdentifierDataTag BlackBoxEModifierIndexedDC VecAppend Declaration AssignmentCondAssignmentInstDecl BlackBoxDNetDeclHWTypeVoidBoolInteger BitVectorIndexSignedUnsignedVectorSumProductSPClockReset Component componentName hiddenPortsinputsoutputs declarations NetlistState _bindings_varEnv _varCount _cmpCount _components _primitives_typeTranslator_tcCache_modNm _curCompNm _dataFiles NetlistMonad runNetlistemptyBBContext$fNFDataDeclaration$fNFDataHWType$fHashableHWType$fNFDataComponentbindingscmpCount components curCompNm dataFilesmodNm primitivestcCachetypeTranslatorvarCountvarEnv RewriteState_transformCounter _uniqSupply_curFun _nameCounter_extra CoreContextAppFunAppArgTyAppCLetBodyLamBody TyLamBodyCaseAlt CaseScrut RewriteEnv _dbgLevel _evaluator DebugLevel DebugNone DebugFinal DebugName DebugAppliedDebugAllcurFunextra nameCountertransformCounter uniqSupplyRewrite Transform RewriteMonadRrunRdbgLevel evaluator#$fMonadReaderRewriteEnvRewriteMonad$fMonadWriterAnyRewriteMonad$fMonadUniqueRewriteMonad$fFreshRewriteMonad$$fMonadStateRewriteStateRewriteMonad$fMonadRewriteMonad$fApplicativeRewriteMonad$fFunctorRewriteMonad CLaSHOptsopt_inlineLimit opt_specLimitopt_inlineBelow opt_dbgLevel BindingMapNormalizeState _normalized_specialisationCache_specialisationHistory_specialisationLimit_inlineHistory _inlineLimit _inlineBelow NormRewriteNormalizeSessionNormalizeMonad inlineBelow inlineHistory inlineLimit normalizedspecialisationCachespecialisationHistoryspecialisationLimitallR>->>-!->topdownRunsafeTopdownR bottomupRunsafeBottomupR!->>-!repeatRwhenR bottomupWhenRsplitNormalizedunsafeCoreTypeToHWTypeunsafeCoreTypeToHWTypeMcoreTypeToHWTypeMsynchronizedClkcoreTypeToHWTypemkADT isRecursiveTyrepresentableTypetypeSizeconSize typeLength termHWType termHWTypeM varToExprmkUniqueNormalized appendToNamepreserveVarEnv dcToLiteral zoomExtraapply runRewriterunRewriteSession setChangedchanged contextEnvmkEnv mkTmBinderFor mkBinderFor mkInternalVar inlineBinders isJoinPointIn tailCallssubstituteBinders localFreeIds liftBinders liftBinding mkFunction addGlobalBindcloneVar isLocalVarisUntranslatableisUntranslatableTypeisLambdaBodyCtxmkWildValBindermkSelectorCase specialise specialise'specArgBndrsAndVarsalreadyInlined addNewInlinespecializeNormisClosed isConstant callGraphrecursiveComponentslambdaDropPrep lambdaDrop dominator blockSink reduceZipWith reduceMapreduceTraverse mkTravVec reduceFoldr reduceFold reduceDFold reduceHead reduceTail reduceAppendreduceUnconcatreduceTranspose bindNonRep liftNonReptypeSpec nonRepSpeccaseLetcaseCase inlineNonRepcaseCon nonRepANFtopLetdeadCodebindConstantVar inlineClosed inlineSmall constantSpecappPropmakeANFetaExpansionTL recToLetRecinlineHO simpleCSE reduceConstreduceNonRepPrim normalizationconstantPropgation topdownSucR innerMost applyManyCallTreeCLeafCBranchrunNormalization normalize normalize' rewriteExprcheckNonRecursive cleanupGraph mkCallTree stripArgs flattenNodeflattenCallTreecallTreeToListmkDcApplicationmkExpr genComponentBackend initBackendprimDir extension extractTypesgenHDL mkTyPackagehdlTypehdlTypeErrValue hdlTypeMarkhdlSiggenStmtinstexprverifyBlackBoxContextextractLiteralssetSym setCompName setClocksfindAndSetDataFilesrenderFilePath clkSyncIdrenderBlackBox renderElem parseFailsyncIdToSyncExprlineToIdentifier lineToType renderTagmkBlackBoxContextprepareBlackBox mkArgument mkPrimitive mkFunInputinstantiateSyminstantiateCompNamecollectFilePaths genNetlistrunNetlistMonad genComponentTmkDeclarationsmkFunApp toSimpleVar genTestBench mkTopWrapperextraInextraOutmkInput mkVectorChainmkOutputmkClocks stringToVarmkClock mkClockDecl clockPortsmkResets genSyncResetunsafeRunNetlist generateHDL createHDL prepareDirwriteHDL copyDataFilescatchIOversionbindirlibdirdatadir libexecdir sysconfdir getBinDir getLibDir getDataDir getLibexecDir getSysconfDirgetDataFileName EncodedString UserStringzEncode encodeDigitChencodeChencodeAsUnicodeChar unencodedChar maybeTuple countCommas pBlackBoxDpElementpTextpTagDpDeclpOutputpInputpTagE pBracketspTokenWS pBlackBoxEpElemEpSigD pLimitedTextParserghc-prim GHC.TypesTruebaseGHC.BaseNothing<*>pure Applicative Data.Functor<$> Control.Monad<=<>=>*** Data.FunctionondecodeAndReport $fSubstbText $fAlphaText$fHashableName $fSubstbRatio$fSubstTypeVar$fSubstTermVar $fAlphaVar$fSubstaDataCon$fAlphaDataCon $fOrdDataCon $fEqDataCon $fShowDataCon $fAlphaTyCon $fOrdTyCon $fEqTyCon $fShowTyContySuperKindTyConNameliftedTypeKindTyConNametypeNatKindTyConNametypeSymbolKindTyConName tySuperKindtcliftedTypeKindtc typeNatKindtctypeSymbolKindtc intPrimTc stringPrimTc voidPrimTc tySuperKindintPrimTyConNamestringPrimTyConNamevoidPrimTyConName liftedPrimTC$fSubstaLiteral$fAlphaLiteral$fSubstTypeTerm$fSubstTermTerm$fSubstTermPat$fSubstTypePat $fAlphaTerm $fOrdTerm$fEqTermnewTyConInstRhs isSuperKind splitTyAppM kindFunResult funSubstsfunSubst $fOrdType$fEqType$fSubstTypeType$fSubstTermType$fSubstaConstTy $fSubstaLitTy $fAlphaTypeTypePrecTopPrecFunPrec TyConPrec BindingSite LambdaBindCaseBindLetBindnoPrecopPrecappPrec 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[] $fPrettyNameunbou_KT7P3sY76weCufDNzZETAT&Unbound.Generics.LocallyNameless.FreshFreshfmap NormRewriteW caseOneAlt collectANFreduceBindersFix reduceBindersgenClockgenReset genFinishgenDone genStimuli genVerifierIOGHC.IOunsafePerformIO