P      !"#$%&'()*+,-. /0123456789:;<=>?@ABCD E F G H I J K L M N O P Q R S T U V WXYZ[\]^_`abcdef g h i j k l mnopqrstuvwxyz{|}~       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~     !""""" Safe-Inferred Transform/<format a text so that it is acceptable as a VHDL identifier NoneExternally defined primitive 0A primitive that carries additional information Additional information MA primitive that has a template that can be filled out by the backend render Name of the primitive Name of the primitive  Either a  declaration or an  expression template. Primitive Definitions None )A class that can generate unique numbers Get a new unique JCreate a TH expression that returns the a formatted string containing the  name of the module  5 is spliced into, and the line where it was spliced. %Cache the result of a monadic action JCache the result of a monadic action in a State 3 transformer layers down Spine-strict cache variant of  mkCachedT3 JRun a State-action using the State that is stored in a higher-layer Monad Functorial version of #$ Functorial version of #% 0Performs trace when first argument evaluates to  Monadic version of &' Monadic version of &( 7Composition 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 exist CUnsafe indexing, return a custom error message when indexing fails 6Split 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 cache The action to cache &The key the action is associated with *The Lens to the HashMap that is the cache The action to cache ,Lens to the State in the higher-layer monad The State-action to perform     NoneHGenerate a set of primitives that are found in the primitive definition ! files in the given directories. IParse a ByteString according to the given JSON template. Prints failures  on stdout, and returns  if parsing fails. 0Directories to search for primitive definitions Bytestring to parse None%Type variable &Term variable 'Variables in CoreHW (Constructor for term variables *Constructor for type variables -Change the name of a variable %&'()*+,- %&'()*+,- '*(+,+)&%- %&'*(+,+)-None Type Constructor /$Representations for primitive types 2!The RHS of an Algebraic Datatype 4The newtype DataCon 5!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. 7The DataCons of a TyCon 8TyCon reference 9(To close the loop on the type hierarchy :Primitive TyCons ;Representation <Algorithmic DataCons =Name of the TyCon Name of the TyCon Name of the TyCon >Kind of the TyCon Kind of the TyCon ?Number of type arguments Number of type arguments @DataCon definitions A!Create a Kind out of a TyConName B'Does the TyCon look like a tuple TyCon C&Get the DataCons belonging to a TyCon ) /0123456789:;<=>?@ABC /0123456789:;<=>?@ABC <:9=>?@=>?;=8263745/10ABC <:9=>?@=>?;=/102637458ABC None  Builtin Name  Builtin Name  Builtin Name  Builtin Name  Builtin Kind D Builtin Kind E Builtin Kind F Builtin Kind G Builtin Type H Builtin Type DEFGHDEFGHDEFGH DEFGH NoneI Term Literal L!Determines the Type of a Literal IJKLIJKLIKJLIKJL None .Data Constructor MDataCon reference N;Syntactical position of the DataCon in the type definition PName of the DataCon Q,Syntactical position in the type definition R Type of the 'DataCon S'Universally quantified type-variables, + these type variables are also part of the  result type of the DataCon T)Existentially quantified type-variables, 1 these type variables are not part of the result , of the DataCon, but only of the arguments. UArgument types VGGiven a DataCon and a list of types, the type variables of the DataCon N type are substituted for the list of types. The argument types are returned. MThe list of types should be equal to the number of type variables, otherwise  an error is reported. .MNOPQRSTUV .MNOPQRSTUV .OPQRSTUMNV .OPQRSTUMNVNoneTerm reference ETerm representation in the CoreHW language: System F + LetRec + Case W,Patterns in the LHS of a case-decomposition XDefault pattern YLiteral pattern ZDatatype pattern, '[TyVar]' bind existentially-quantified  type-variables of a DataCon [Binding in a LetRec construct \"Case-expression: subject, type of $ alternatives, list of alternatives ]Recursive let-binding ^Type-application _ Application `Type-abstraction aTerm-abstraction b Primitive cLiteral dDatatype constructor eVariable reference WXYZ[\]^_`abcde     WXYZ[\]^_`abcdeedcba`_^]\[WZYX edcba`_^]\WZYX[      NonefSubstitutes types in a type gSubstitutes a type in a type hSubstitutes kinds in a kind iSubstitutes a type in a term jSubstitutes types in a term kSubstitutes a term in a term lSubstitutes terms in a term fghijklfghijklfghijklfghijklNone# Reference to a Kind !Reference to a Type "The level above types #0Types in CoreHW: function and polymorphic types $Make a Type out of a TyCon mEither a Kind or a Type nLiteral Types qType Constants rFunction type s TyCon type tAn easier view on types uNeither of the above vApplied TyCon wFunction type x Type literal yType Application zPolymorphic Type {Type constant |Type variable }An easier view on types ~A transformation that renders Signal types transparent A view on types in which Signal$ types and newtypes are transparent Instantiate and Apply the RHS/%Original of a NewType with the given  list of argument types 4Make a function type of an argument and result type EMake a TyCon Application out of a TyCon and a list of argument types 7Split a TyCon Application in a TyCon and its arguments Is a type a Superkind? Determine the kind of a type Is a type polymorphic? 5Split a function type in an argument and result type JSplit a poly-function type in a: list of type-binders and argument types,  and the result type Is a type a function type? BApply a function type to an argument type and get the result type (Substitute the type variable of a type (z) with another type DSplit a type application in the applied type and the argument types 8 !"#$mnopqrstuvwxyz{|}~ !"#$%&# !"#$%mnopqrstuvwxyz{|}~##|{zyxtwvuqsrnpo"m !%}~$, !"#|{zyx$mnpoqsrtwvu}~ !"#$%& 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 Term NoneGlobal function binders None$Pretty printing Show-like typeclass !Print a Pretty thing to a String ?'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`a7'*)(+.-,/0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`aNoneKind environment/context Type environment/context Determine the type of a term ?Split a (Type)Application in the applied term and it arguments ISplit a (Type)Abstraction in the bound variables and the abstracted term HGet the result type of a polymorphic function given a list of arguments 7Get the list of term-binders out of a DataType pattern Make a type variable Make a term variable 7Abstract 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 term  Apply a list of terms to a term  Apply a list of types to a term "Does a term have a function 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 variable 1Make a term variable out of a variable reference None9 Bit literal High-impedance  Undefined Low High Literals used in an expression Vector literal Boolean literal  Bit literal Number literal (Expression used in RHS of a declaration 'Instantiation of a BlackBox expression Signal reference DataCon application Literal expression Expression Modifier ?See the expression in the context of a Vector append operation KSee expression in a DataCon context: (Type of the expression, DataCon tag) AIndex the expression: (Type of expression,DataCon tag,Field Tag) Internals of a Component Signal declaration &Instantiation of blackbox declaration #Instantiation of another component Conditional signal assignment:  Signal to assign  Scrutinized expression X List of: (Maybe expression scrutinized expression is compared with,RHS of alternative) Signal assignment:  Signal to assign  Assigned expression Representable hardware types :Reset 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 type  Bit type  Empty type @Size indication of a type (e.g. bit-size or number of elements) "Component: base unit of a Netlist Name of the component CPorts that have no correspondence the original function definition  Input ports  Output port Internal declarations Signal reference State of the NetlistMonad Global binders Type environment/context Number of signal declarations Number of create components Cached components Primitive Definitions State for the ) Monad $Hardcoded Type -> HWType translator State for the ) monad:  Previously encountered HWTypes  Product type counter 3 Cache for previously generated product type names LMonad that caches generated components (StateT) and remembers hidden inputs 2 of components that are being generated (WriterT) FbEE  bNoneState of a rewriting session "Number of applied transformations Global binders Supply of unique numbers #Hardcode Type -> HWType translator  Context in which a term appears  Subject of a case-decomposition MRHS of a case-alternative with the variables bound by the pattern on the LHS :Body of a TyLambda-term with the abstracted type-variable 3Body 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 session Debug Message Verbosity 9Show all sub-expressions on which a rewrite is attempted 0Show sub-expressions after a successful rewrite 'Show completely normalized expressions Don't show debug messages  A   action in the context of the   >Monadic action that transforms a term given a certain context  MTL convenience wrapper around  Monad that can do the same as  and in addition keeps track  if a transformation/'rewrite has been successfully applied. JMonad that keeps track how many transformations have been applied and can 1 generate fresh variables and unique identifiers %     c$     $           cNone  State of the  Global binders +Cache of previously specialised functions: I Key: (name of the original function, argument position, specialised term/type) C Elem: (name of specialised function,type of specialised function) -Cache of function where inlining took place: ) Key: function where inlining took place $ Elem: functions which were inlined +Inlined functions in the current traversal 'Function which is currently normalized A  Transform action in the context of the  RewriteMonad and  4RewriteSession with extra Normalisation information @State monad that stores specialisation and inlining information  ! !!   !None"BMonad that caches VHDL information and remembers hidden inputs of 0 black boxes that are being generated (WriterT) %OComponent instantiation hole. First argument indicates which function argument N to instantiate. Second argument corresponds to output and input assignments, O 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 hole *Type declaration hole + Reset hole ,'Clock hole (Maybe clk corresponding to 0 input, clk corresponding to output if Nothing) - Symbol hole . Literal hole / Input hole 0 Output hole 1Component instantiation hole 2 Constant 3*A BlackBox Template is a List of Elements 4HEither the name of the identifier, or a tuple of the identifier and the  corresponding clock 59Context used to fill in the holes of a BlackBox template 7Result name and type 8Argument names and types 9%Literal arguments (subset of inputs) :'Function arguments (subset of inputs): . (Blackbox Template,Partial Blackbox Concext) "#$%&'()*+,-./0123456789:"#$%&'()*+,-./0123456789:56789:43'210/.-,+*)(%&"#$"#$%&' 210/.-,+*)(3456789:None ;EParse a text as a BlackBoxTemplate, returns a list of errors in case  parsing fails d8Parse a BlackBoxTemplate (Declarations and Expressions) e Parse a single Template Element f"Parse the Text part of a Template g*Parse a Declaration or Expression element hParse a Declaration i$Parse the output tag of Declaration j#Parse the input tag of Declaration kParse an Expression element lParse a bracketed text m*Parse a token and eat trailing whitespace n0Parse the expression part of Blackbox Templates oParse an Expression or Text p;defghijklmno;;p;defghijklmnoNone <2Apply a transformation on the subtrees of an term =(Apply two transformations in succession >.Apply a transformation in a topdown traversal ?4Apply a transformation in a topdown traversal. Doesn't freshen bound  variables @/Apply a transformation in a bottomup traversal A5Apply a transformation in a bottomup traversal. Doesn't freshen bound  variables BFApply a transformation in a bottomup traversal, when a transformation K succeeds in a certain node, apply the transformation further in a topdown " traversal starting at that node. CFApply a transformation in a bottomup traversal, when a transformation K succeeds in a certain node, apply the transformation further in a topdown ' traversal starting at that node. Doesn't freshen bound variables D@Only apply the second transformation if the first one succeeds. E/Keep applying a transformation until it fails. <0Freshen variable references in abstracted terms ,The transformation to apply to the subtrees =>?@ABCDE <=>?@ABCDE <=>?@ABCDE <=>?@ABCDENoneHKSplit a normalized term into: a list of arguments, a list of let-bindings, I and a variable reference that is the body of the let-binding. Returns a G String containing the error is the term was not in a normalized form. IJConverts a Core type to a HWType given a function that translates certain = builtin types. Errors if the Core type is not translatable. J9Converts a Core type to a HWType within the NetlistMonad K6Returns the name of the clock corresponding to a type LJConverts a Core type to a HWType given a function that translates certain L builtin types. Returns a string containing the error message when the Core  type is not translatable. MSConverts an algebraic Core type (split into a TyCon and its argument) to a HWType. N0Simple check if a TyCon is recursively defined. OLDetermines if a Core type is translatable to a HWType given a function that # translates certain builtin types. P!Determines the bitsize of a type Q4Determines the bitsize of the constructor of a type R)Gives the length of length-indexed types SKGives the HWType corresponding to a term. Returns an error if the term has 3 a Core type that is not translatable to a HWType. TLTurns a Core variable reference to a Netlist expression. Errors if the term  is not a variable. UGUniquely rename all the variables and their references in a normalized  term VAppend a string to a name WPreserve the Netlist  and ! when executing a monadic action HIJKLM$Hardcoded Type -> HWType translator :String representation of the Core type for error messages  The TyCon Its applied arguments NOPQRSTUVWHIJKLMNOPQRSTUVWHIJKLMNOPQRSTUVWHIJKLMNOPQRSTUVWNoneX&Generate VHDL for a Netlist component YJGenerate a VHDL package containing type definitions for the given HWTypes Z(Convert a Netlist HWType to a VHDL type [4Convert a Netlist HWType to the root of a VHDL type \?Convert a Netlist HWType to a default VHDL value for that type ]6Turn a Netlist Declaration to a VHDL concurrent block ^1Turn a Netlist expression into a VHDL expression qXYrstuvwxyZ[\z{|]^Enclose in parenthesis? Expr to convert }~XYZ[\]^XYZ\[]^ qXYrstuvwxyZ[\z{|]^}~None _!Determine if the number of normalliteralfunction inputs of a blackbox I context at least matches the number of argument that is expected by the  template. `!Count the number of argument tags/holes in a blackbox template a"Counter the number of literal tags/holes in a blackbox template bCCount the number of function instantiations in a blackbox template cIUpdate all the symbol references in a template, and increment the symbol - counter for every newly encountered symbol. d+Get the name of the clock of an identifier eIRender a blackbox given a certain context. Returns a filled out template  and a list of hidden: inputs that must be added to the encompassing component. f!Render a single template element g0Fill out the template corresponding to an output/input assignment of a I component instantiation, and turn it into a single identifier so it can % be used for a new blackbox context. hFGive a context and a tagged hole (of a template), returns part of the + context that matches the tag of the hole. _Template to check against Blackbox to verify `abcdeBlackbox template !Context used to fill in the hole fgh _`abcdefgh _`abcdefgh _`abcdefghNonei1Lift an action working in the inner monad to the  j1Lift an action working in the inner monad to the  k2Record if a transformation is succesfully applied l#Perform a transformation on a Term m-Evaluate a RewriteSession to its inner monad n8Notify that a transformation has changed the expression oGIdentity function that additionally notifies that a transformation has  changed the expression p?Create a type and kind context out of a transformation context qJCreate a complete type and kind context out of the global binders and the  transformation context r4Make a new binder and variable reference for a term sEMake a new binder and variable reference for either a term or a type tDMake a new, unique, identifier and corresponding variable reference uAInline the binders in a let-binding that have a certain property vISubstitute the RHS of the first set of Let-binders for references to the O first set of Let-binders in: the second set of Let-binders and the additional  term wCalculate the local4 free variable of an expression: the free variables / that are not bound in the global environment. xKLift the binders in a let-binding to a global function that have a certain  property yJCreate a global function for a Let-binding and return a Let-binding where G the RHS is a reference to the new global function applied to the free  variables of the original RHS z-Make a global function for a name-term tuple {,Add a function to the set of global binders |ACreate a new name out of the given name, but with another unique }>Test whether a term is a variable reference to a local binder ~6Determine if a term cannot be represented in hardware Is the Context a Lambda/Term-abstraction context? ,Make a binder that should not be referenced OMake 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 specArg ijkName of the transformation Transformation to be applied lName of the transformation Transformation to perform Term to transform mnopqrName of the new binder  Term to bind sName of the new binder Type or Term to bind tName of the identifier uProperty test vLet-binders to substitute +Let-binders where substitution takes place *Expression where substitution takes place wxProperty test yzName of the function Term bound to the function 7Name with a proper unique and the type of the function {|}~$Name of the caller of this function 8Transformation Context in which this function is called  Subject of the case-composition #Lens into previous specialisations Original term AFunction part of the term, split into root and applied arguments Argument to specialize on ijklmnopqrstuvwxyz{|}~ijklmnopqrstuvwxyz{|}~ijklmnopqrstuvwxyz{|}~NoneADetermine if a function is already inlined in the context of the  NetlistMonad JMove the names of inlined functions collected during a traversal into the " permanent inlined function cache Determine if a term is closed *Determine if a term represents a constant Get the "Wrapped", function out of a normalized Term. Returns  if 0 the normalized term is not actually a wrapper. >Create a call graph for a set of global binders, given a root JDetermine the sets of recursive components given the edges of a callgraph /List of functions that should not be inspected Global binders Root of the call graph  "(calling function,[called function)] None3Generate the context for a BlackBox instantiation. ?Instantiate a BlackBox template according to the given context ;Create an template instantiation text for an argument term GCreate an template instantiation text for an argument term, given that  the term is a literal. Returns  if the term is not a literal. LCreate an template instantiation text and a partial blackbox content for an M argument term, given that the term is a function. Errors if the term is not  a function NInstantiate symbols references with a new symbol and increment symbol counter  Identifier binding the primitive/blackbox application Arguments of the primitive/blackbox application Template to instantiate %Context to instantiate template with The literal argument term -Identifier binding the encompassing primitive/blackbox application The function argument term NoneFVGenerate an expression for a DataCon application occurring on the RHS of a let-binder G4Generate a component for a given function (caching) DGenerate a hierarchical netlist out of a set of global binders with   topEntity at the top. 1Run a NetlistMonad action in a given environment *Generate a component for a given function 1Generate a list of Declarations for a let-binder YGenerate a list of Declarations for a let-binder where the RHS is a function application GGenerate an expression for a term occurring on the RHS of a let-binder F$HWType of the LHS of the let-binder Applied DataCon DataCon Arguments AReturned expression and a list of generate BlackBox declarations GName of the function %Starting value of the unique counter State for the ) Monad Global binders Primitive definitions $Hardcoded Type -> HWType translator  Symbol count  Name of the  topEntity State for the ) Monad Global binders Primitive Definitions #Hardcode Type -> HWType translator Action to run Name of the function Corresponding term %Starting value of the unique counter LHS of the let-binder RHS of the let-binder LHS of the let-binder Name of the applied function Function arguments "Type of the LHS of the let-binder !Term to convert to an expression AReturned expression and a list of generate BlackBox declarations FGGFFGNone5Inline non-recursive, non-representable let-bindings /Lift recursive, non-representable let-bindings #Specialize functions on their type 9Specialize functions on their non-representable argument ALift the let-bindings out of the subject of a Case-decomposition WMove a Case-decomposition from the subject of a Case-decomposition to the alternatives 5Inline function with a non-representable result if it's the subject  of a Case-decomposition JSpecialize a Case-decomposition (replace by the RHS of an alternative) if L 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-representable Ensure that top-level lambda',s eventually bind a let-expression of which # the body is a variable-reference. Remove unused let-bindings IInline let-bindings when the RHS is either a local variable reference or  is constant Inline nullary/closed functions 5Specialise functions on arguments which are constant Inline functions which simply "wrap" another function 7Propagate arguments of application inwards; except for a where the  argument becomes let-bound. ITurn an expression into a modified ANF-form. As opposed to standard ANF, $ constants do not become let-bound. Eta-expand top-level lambda's (DON'T use in a traversal!) KTurn a normalized recursive function, where the recursive calls only pass K along the unchanged original arguments, into let-recursive function. This O means that all recursive calls are replaced by the same variable reference as 4 found in the body of the top-level let-expression. NoneNormalisation transformation 6Simple cleanup transformation, currently only inlines "Wrappers" NUnsure that functions have representable arguments, results, and let-bindings :Brings representable function in the desired normal form:  Only top-level lambda's S Single Lambda-bound top-level Let-binding, where the body is a variable reference i Modified ANF (constants are not let-bound, non-representable arguments to primitives are not let-bound) $ All let-bindings are representable JPerform an inlining transformation using a bottomup traversal, and commit + inlined function names to the inlining log/cachce BRepeatedly apply a set of transformation in a bottom-up traversal  None.Run a NormalizeSession in a given environment #Normalize a list of global binders 8Rewrite a term according to the provided transformation Perform general "clean up", of the normalized (non-recursive) function  hierarchy. This includes:  Inlining functions that simply "wrap" another function ;Check if the call graph (second argument), starting at the topEnity L (first argument) is non-recursive. Returns the list of normalized terms if 7 call graph is indeed non-recursive, errors otherwise. !Level of debug messages to print  UniqueSupply Global Binders $Hardcoded Type -> HWType translator NormalizeSession to run Transformation to apply Term to transform #Names of the functions to clean up Global binders   topEntityList of normalized binders !NoneGGenerate a VHDL testbench for a component given a set of stimuli and a " set of matching expected outputs  Primitives Global binders Stimuli Expected output Component to generate TB for "None3Create a set of .VHDL files for a set of functions *Pretty print Components to VHDL Documents GPrepares the directory for writing VHDL files. This means creating the K dir if it does not exist and removing all existing .vhdl files from it. *Writes a VHDL file to the given directory Set of functions  Primitive / BlackBox Definitions  Hardcoded # ->  translator 6Debug information level for the normalization process *+,-../0123456789:;<=>?@ABCDEFGHIJKLMNOPQRQSPTUV WXYZ[\]^_`abcdefghijkl m n o p q r s t u v w x y z { | } ~ rR 4 rWr       !"##$%&'(()*+,-./01234567899:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~     !""""#$##%                        !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~)M!!!!!!! clash-lib-0.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-3.9.0.3Control.Lens.TH makeLenses mkBasicId PrimitiveprimTypeBlackBoxnametemplatePrimMapTyCon MonadUnique getUniqueMcurLoc makeCached makeCachedT3 makeCachedT3' liftStatefirstMsecondMtraceIf partitionM mapAccumLMdot ifThenElse<:> indexMaybe indexNote splitAtListgeneratePrimMapdecodeAndReportTmNameTermKiNameTyNameKindType mkTyConTyTyVarIdVarvarTypevarNamevarKind modifyVarNameDataConPrimRepVoidRepIntRep AlgTyConRhsNewTyCondataCon ntEtadRhs DataTyCondataCons TyConNameSuperKindTyCon PrimTyCon primTyConRepAlgTyCon tyConName tyConKind tyConArityalgTcRhs mkKindTyConisTupleTyConLike tyConDataConsliftedTypeKind typeNatKindtypeSymbolKind intPrimTy voidPrimTyLiteral StringLiteralIntegerLiteral literalTypeDcNameConTagMkDatadcNamedcTagdcType dcUnivTyVars dcExtTyVarsdcArgTysdataConInstArgTysPat DefaultPatLitPatDataPat LetBindingCaseLetrecTyAppAppTyLamLamPrimDatasubstTyssubstTy substKindWith substTyInTm substTysinTmsubstTmsubstTms KindOrTypeLitTySymTyNumTyConstTyArrowTypeView OtherTypeTyConAppFunTyAppTyForAllTyVarTytyView transparentTycoreViewmkFunTy mkTyConAppsplitTyConAppMtypeKindisPolyTy splitFunTysplitFunForallTyisFunTy applyFunTyapplyTy typeFreeVars termFreeVars termFreeIdstermFreeTyVars BindingMapPrettypprpprPrecshowDocDeltaGammatermType collectArgs collectBndrsapplyTypeToArgspatIdsmkTyVarmkId mkAbstractionmkTyLamsmkLamsmkAppsmkTmAppsmkTyAppsisFunisLamisLetisVarisConisPrimidToVarvarToIdBitZULHVecLitBoolLitBitLitNumLitExpr BlackBoxE IdentifierModifier VecAppendDCIndexed DeclarationNetDecl BlackBoxDInstDeclCondAssignment AssignmentHWTypeResetClockSPProductSumVectorUnsignedSignedIntegerBoolVoidSize Component componentName hiddenPortsinputsoutput declarations NetlistState _bindings_varEnv _varCount _cmpCount _components _primitives _vhdlMState_typeTranslator VHDLState NetlistMonad runNetlistbindingscmpCount components primitivestypeTranslatorvarCountvarEnv vhdlMState RewriteState_transformCounter _uniqSupply CoreContext CaseScrutCaseAlt TyLamBodyLamBodyLetBodyTyAppCAppArgAppFun RewriteEnvRE _dbgLevel DebugLevelDebugAll DebugApplied DebugFinal DebugNonetransformCounter uniqSupplyRewrite TransformRrunR RewriteMonadRewriteSessiondbgLevelNormalizeState _normalized_specialisations_inlined _newInlined_curFun NormRewriteNormalizeSessionNormalizeMonadcurFuninlined newInlined normalizedspecialisations BlackBoxMonadB runBlackBoxMDeclElementDefTypMTypRstClkSymIODCBlackBoxTemplateSyncIdentifierBlackBoxContextContextresult litInputs funInputsrunParseallR>->topdownRunsafeTopdownR bottomupRunsafeBottomupRupDownR unsafeUpDownR!->repeatRmkDcApplication genComponentsplitNormalizedunsafeCoreTypeToHWTypeunsafeCoreTypeToHWTypeMsynchronizedClkcoreTypeToHWTypemkADT 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'specArgBndrsAndVarsalreadyInlinedcommitNewInlinedisClosed isConstant getWrappedF callGraphrecursiveComponentsmkBlackBoxContext mkBlackBoxmkInput mkLitInput mkFunInputinstantiateSym genNetlistrunNetlistMonad genComponentTmkDeclarationsmkFunAppmkExpr bindNonRep liftNonReptypeSpec nonRepSpeccaseLetcaseCase inlineNonRepcaseCon nonRepANFtopLetdeadCodebindConstantVarinlineClosedTerm constantSpec inlineWrapperappPropmakeANFetaExpansionTL recToLetRec normalizationcleanup representablesimplificationdoInlinerepeatBottomuprunNormalization normalize rewriteExpr cleanupGraphcheckNonRecursive genTestBench generateVHDL createVHDL prepareDir writeVHDL EncodedString UserStringzEncode encodeDigitChencodeChencodeAsUnicodeChar unencodedChar$fFromJSONPrimitiveghc-prim GHC.TypesTruebase Data.MaybeNothing $fOrdEmbed$fHashableName$fMonadUniqueStateTControl.Applicative Applicative<*> Data.Functor<$>pure*** Data.Functionon Control.Monad<=<>=>rVarrVar1$fSubstTypeVar$fSubstTypeVar0$fSubstTermVar$fSubstTermVar0 $fAlphaVar$fRepVar $fOrdTyCon $fEqTyCon $fShowTyConrTyConrTyCon1 rAlgTyConRhs rAlgTyConRhs1rPrimRep rPrimRep1$fSubstTermPrimRep$fSubstTermAlgTyConRhs$fSubstTermTyCon$fSubstTypePrimRep$fSubstTypeAlgTyConRhs$fSubstTypeTyCon$fAlphaAlgTyConRhs $fAlphaTyCon$fAlphaPrimRep $fRepTyContySuperKindTyConNameliftedTypeKindTyConNametypeNatKindTyConNametypeSymbolKindTyConName tySuperKindintPrimTyConNamevoidPrimTyConName liftedPrimTCrLiteral rLiteral1$fSubstTermLiteral$fSubstTypeLiteral$fAlphaLiteral $fRepLiteral $fOrdDataCon $fEqDataCon $fShowDataConrDataCon rDataCon1$fSubstTermDataCon$fSubstTypeDataCon$fAlphaDataCon $fRepDataConrTermrTerm1rPatrPat1$fSubstTypeTerm$fSubstTypePat$fSubstTermTerm$fSubstTermPat $fAlphaPat $fAlphaTerm $fOrdTerm$fEqTerm $fRepTermnewTyConInstRhs isSuperKind splitTyAppMrTyperType1rLitTyrLitTy1rConstTy rConstTy1 kindFunResult $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$fHashableHWType$fMonadUniqueWriterT pBlackBoxDpElementpTextpTagDpDeclpOutputpInputpTagE pBracketspTokenWS pBlackBoxEpElemEParser topSortHWTys needsTyDectyDecfunDectyName tyImportsentity architecturedeclsdeclinsts otherSize vectorChainexprLittoBitsbitsbit_chartoSLVfromSLVdcToExprlarrowparenIf punctuate' NormRewriteW liftNormR collectANF delayedSignalrenderFloat2Dec genAssertprepareSignals termToList stimuliElemTy createSignal