Schematic assert merge
This page describes the organizational forces that limit change.  It explains how to overcome them when necessary. 

Power& tradition holding back progress
This page uses an example to illustrate how:
  • A business can gain focus from targeting key customers,
  • Business planning activities performed by the whole organization can build awareness, empowerment and coherence. 
  • A program approach can ensure strategic alignment. 
Be responsive to market dynamics
This page uses the example of HP's printer organization freeing itself from its organizational constraints to sell a printer targeted at the IBM pc user. 
The constraints are described. 
The techniques to overcome them are implied. 
Overcome reactionaries
Primary Navigation

Application assertion about merge streams

Summary
This page discusses how a
This page describes the Adaptive Web framework (AWF) test system and the agent programming framework (Smiley) that supports its operation. 
Example test system statements are included.  To begin a test a test statement is loaded into Smiley while Smiley executes on the Perl interpreter. 
Part of Smiley's Perl code focused on setting up the infrastructure is included bellow. 
The setup includes:
  • Loading the 'Meta file' specification,
  • Initializing the Slipnet, and Workspaces and loading them
  • So that the Coderack can be called. 
The Coderack, which is the focus of a separate page of the Perl frame then schedules and runs the codelets that are invoked by the test statement structures. 
Smiley
based application the event processor test program's operational phase is structured. 
The goals of the event processor test application are described
The implementation strategy is outlined
Synchronization of Smiley setup completion and operation phase initiation is discussed
The association of structural
This page describes the Copycat Workspace. 
The specialized use of the Workspace by the adaptive web framework's (AWF) Smiley is discussed. 
How text and XML are imported into the Smiley Workspace is described. 
Telomeric aging of schematic structures is introduced. 
The internal data structure used to represent the state of each workspace object is included. 
The Workspace infrastructure functions are included. 
Workspace
s for state representation is discussed
An application specific codelet merge streams assert responds to the nature of the assertion is a hypothesis which can be tested and found to be true or false.  In the adaptive web framework's (AWF) Smiley assertion statements are used to define the test that will be applied by the application's codelets.  The statements must include schematic strings which can group complete and become associated with codelets.  Smileys own codelets: Coderack generated part and statement enforces the syntax of the assertion.  The specific form of the statements is defined in the application's Meta file.  Statement codelets also support the operation of the application's Shewhart cycle. 
.  It does not have an emergent structure.  Instead it reflects software engineering practice.  It includes:
The operation is setup, inhibited, initiated, and managed by iterative phase check-pointing provided by Smiley codelets. 
Schematic synchronization of parallel codelet cascades is performed structurally. 
The assert merge operon cascade is included
The
This page describes the Copycat Slipnet. 
The goal of the Slipnet is reviewed. 
Smiley's specialized use of the Slipnet is introduced. 
The initial Slipnet network used by the 'Merge Streams' and 'Virtual Robot' agent-based applications is setup in initchemistry and is included. 
The Slipnet infrastructure and initialization functions are included. 
Slipnet
concept network for merge streams is included
The codelets and supporting functions are included
Introduction
Assert process 'merge streams' is an
This page discusses the mechanisms and effects of emergence underpinning any complex adaptive system (CAS).  Key research is reviewed. 
emergent
complex adaptive system (
This page introduces the complex adaptive system (CAS) theory frame.  The theory is positioned relative to the natural sciences.  It catalogs the laws and strategies which underpin the operation of systems that are based on the interaction of emergent agents. 
John Holland's framework for representing complexity is outlined.  Links to other key aspects of CAS theory discussed at the site are presented. 
CAS
)
Plans are interpreted and implemented by agents.  This page discusses the properties of agents in a complex adaptive system (CAS). 
It then presents examples of agents in different CAS.  The examples include a computer program where modeling and actions are performed by software agents.  These software agents are aggregates. 
The participation of agents in flows is introduced and some implications of this are outlined. 
agent
.  It provides the operational phases of testing the adaptive web framework (AWF) event processor awfpbs.  It is composed of a number of codelets which cooperate under the control of a
Plans emerge in complex adaptive systems (CAS) to provide the instructions that agents use to perform actions.  The component architecture and structure of the plans is reviewed. 
schematic plan
to act via the
This page describes the Copycat Coderack. 
The details of the codelet architecture are described. 
The specialized use of the Coderack by the adaptive web framework's (AWF) Smiley is discussed. 
The codelet scheduling mechanism is discussed. 
A variety of Smiley extensions to the Coderack are reviewed. 
The Coderack infrastructure functions are included. 
Coderack
&
This page describes the Copycat Slipnet. 
The goal of the Slipnet is reviewed. 
Smiley's specialized use of the Slipnet is introduced. 
The initial Slipnet network used by the 'Merge Streams' and 'Virtual Robot' agent-based applications is setup in initchemistry and is included. 
The Slipnet infrastructure and initialization functions are included. 
Slipnet
on
Agents use sensors to detect events in their environment.  This page reviews how these events become signals associated with beneficial responses in a complex adaptive system (CAS).  CAS signals emerge from the Darwinian information model.  Signals can indicate decision summaries and level of uncertainty. 
signals
from the
The complex adaptive system (CAS) nature of a value delivery system is first introduced.  It's a network of agents acting as relays. 

The critical nature of hub agents and the difficulty of altering an aligned network is reviewed. 

The nature of and exceptional opportunities created by platforms are discussed. 

Finally an example of aligning a VDS is presented. 
environment
and each other.  The agent is composed of an AWF 
This page describes the Adaptive Web framework (AWF) test system and the agent programming framework (Smiley) that supports its operation. 
Example test system statements are included.  To begin a test a test statement is loaded into Smiley while Smiley executes on the Perl interpreter. 
Part of Smiley's Perl code focused on setting up the infrastructure is included bellow. 
The setup includes:
  • Loading the 'Meta file' specification,
  • Initializing the Slipnet, and Workspaces and loading them
  • So that the Coderack can be called. 
The Coderack, which is the focus of a separate page of the Perl frame then schedules and runs the codelets that are invoked by the test statement structures. 
Smiley
agent-based application supported by Smiley codelets and infrastructure. 
Operational goals of the event processor test application
The testing operation involves comparing a test assertion is a hypothesis which can be tested and found to be true or false.  In the adaptive web framework's (AWF) Smiley assertion statements are used to define the test that will be applied by the application's codelets.  The statements must include schematic strings which can group complete and become associated with codelets.  Smileys own codelets: Coderack generated part and statement enforces the syntax of the assertion.  The specific form of the statements is defined in the application's Meta file.  Statement codelets also support the operation of the application's Shewhart cycle. 
about an event processor web frame definition file with the resulting web page generated by the event processor.  It must build a representative model of the test assertion, the web frame definition and the web page and then judge the truth of the assertion. 

Additionally AWF developed the application to gain experience with the development is a phase during the operation of a CAS agent.  It allows for schematic strategies to be iteratively blended with environmental signals to solve the logistical issues of migrating newly built and transformed sub-agents.  That is needed to achieve the adult configuration of the agent and optimize it for the proximate environment.  Smiley includes examples of the developmental phase agents required in an emergent CAS.  In situations where parents invest in the growth and memetic learning of their offspring the schematic grab bag can support optimizations to develop models, structures and actions to construct an adept adult.  In humans, adolescence leverages neural plasticity, elder sibling advice and adult coaching to help prepare the deploying neuronal network and body to successfully compete. 
of agent-based programs. 
Event processor test application implementation strategy
The test application implements a single eukaryotic, a relatively large multi-component cell type from which yeast and multi-celled plants and animals, including humans, is constructed.  It contains modules including a nucleus and production functions such as mitochondria.   cell abstraction to represent the application state, and focus codelet deployment and execution.  The single cell abstraction is relatively simple but it results in limitations which constrain the power of the application.  In particular the state that can be represented is limited.  Describing the relationship between the web frame definition file and the output HTML proved impossible.  Cooperative multi-cellular strategies such as neuronal, specialized eukaryotic cells include channels which control flows of sodium and potassium ions across the massively extended cell membrane supporting an electro-chemical wave which is then converted into an outgoing chemical signal transmission from synapses which target nearby neuron or muscle cell receptors.  Neurons are supported by glial cells.  Neurons include a:
  • Receptive element - dendrites
  • Transmitting element - axon and synaptic terminals 
circuits, a network of interconnected neurons which perform signalling, modeling and control functions.  In Cajal's basic neural circuits the signalling is unidirectional.  He identified three classes of neurons in the circuits:
  • Sensory, Interneurons, Motor; which are biochemically distinct and suffer different disease states. 
provide one evolved solution to developing such a representation. 

The 'merge streams' application performs two goals in parallel:
  1. Decoding and executing the assert test claim.  This assertion is a hypothesis which can be tested and found to be true or false.  In the adaptive web framework's (AWF) Smiley assertion statements are used to define the test that will be applied by the application's codelets.  The statements must include schematic strings which can group complete and become associated with codelets.  Smileys own codelets: Coderack generated part and statement enforces the syntax of the assertion.  The specific form of the statements is defined in the application's Meta file.  Statement codelets also support the operation of the application's Shewhart cycle. 
    may be iterative in nature.  In particular it may include case statements that must be resolved before they can be analyzed, and the resolving may be iterative over different case selectors. 
  2. Organizing the operation through a cycle of phases.  The phases include planning and modeling, doing, checking the results, and acting on results that diverge from the plans models. 
The two goals support one another.  The application's two goals are integrated in its schematic plan and the adaptive actions of the interacting codelets the plan coordinates.  Otherwise the application appears to be just a set of disjoint codelets. 
Decoding and executing the assert test claim
As a Smiley application the test operation can use the
This page looks at how Smiley processes the statement, such as a test request, to ensure that the statement contains all required parts. 
Smiley does this through the operation of a statement codelet which indirectly sponsors the modeling of the whole statement. 
The modeling itself is performed by model codelets. 
The group models' Slipnet associations are included. 
The codelets and supporting functions are included. 
statement
codelet to validate the syntax of the test assertion and to
This page looks at Smiley's statement codelet. 
What the codelet's goals are. 
The three aspects of its operations are described. 
The indirect nature of its support for the applications programs and Shewhart cycles are illustrated. 
It describes how the application codelets are inhibited from action until the Statement codelet concludes the application's assertion or implementation statement is viable.  An application assertion statement is described and the schematic string included. 
The statement codelet Perl and its support infrastructure are included. 
support the execution
of the
This page discusses how Smiley can support the start of the development phase of an agent-based application. 
Startup is an artificial operation not found in living systems.  But Smiley must do it and so we discuss an example of starting the development phase. 
With the Smiley infrastructure and the application integrated the application's development phase is reviewed.
The association of structural Workspaces for state representation is discussed. 
The aggregation of schematic associations of codelets defines a development agent.  At the application level it processes the application's schematic strings. 
The schematic nature of the data processed by the test application suggests the use of an indirect integration framework.  This supports the binding of codelets to the schematic data and detecting and responding to the control operons. 
An application polymerase complex emerges. 
The codelets and supporting functions are included. 
development phase
of the application.  Both these activities must be completed before the test operation codelets can do any useful work.  The 'merge streams' agent's codelets are initially dormant, due to the action of an application provided inhibitor, in an enzyme catalyzed reaction an inhibitor can stop the reaction.  It may be competitive, uncompetitive or noncompetitive.  Competitive inhibitors compete with the substrate for access to the active site.  Uncompetitive inhibitors react only with the enzyme-substrate complex creating an inhibited complex.  Noncompetitive inhibitors combine with the enzyme away from the active site and change the shape of the enzyme and its active site.  The adaptive web framework's (AWF) Smiley inhibitors are uncompetitive.  But the inhibition can be removed (reversed) by deploying descriptors. 
codelet.  The statement codelet will decide when to allow the application codelet specified in a test or operational specification to run (
This page discusses the benefits of constraining the flows in a complex adaptive system (CAS) until you are ready to act. 
maintain restrictions
).  Until then the specified codelet, and hence the agent (schemata, functions), expects to remain inhibited

When inhibition ceases the test statement <assert> <process> schematic group such as '<merge> <streams> <file>'
This page describes the adaptive web framework (AWF) Smiley agent progamming infrastructure's codelet based Copycat grouping operation. 
The requirements needed for a group to complete are described. 
The association of group completion with a Slipnet defined operon is described.  Either actions or signals result from the association. 
How a generated signal is transported to the nucleus of the cell and matched with an operon is described. 
A match with an operon can result in deployment of a schematic string to the original Workspace.  But eventually the deployed string will be destroyed. 
Smiley infrastructure amplification of the group completion operation is introduced.  This includes facilities to inhibit crowding out of offspring. 
A test file awfart04 is included. 
The group codelet and supporting functions are included. 
group complete
finally results in the sps signalling, is an emergent capability which is used by cooperating agents to support coordination & rival agents to support control and dominance.  In eukaryotic cells signalling is used extensively.  A signal interacts with the exposed region of a receptor molecule inducing it to change shape to an activated form.  Chains of enzymes interact with the activated receptor relaying, amplifying and responding to the signal to change the state of the cell.  Many of the signalling pathways pass through the nuclear membrane and interact with the DNA to change its state.  Enzymes sensitive to the changes induced in the DNA then start to operate generating actions including sending further signals.  Cell signalling is reviewed by Helmreich.  Signalling is a fundamental aspect of CAS theory and is discussed from the abstract CAS perspective in signals and sensors.  In AWF the eukaryotic signalling architecture has been abstracted in a codelet based implementation.  To be credible signals must be hard to fake.  To be effective they must be easily detected by the target recipient.  To be efficient they are low cost to produce and destroy. 
of the merge streams initiator codelet's evaluator msiopevaluator.  Upon subsequent running on the
This page describes the Copycat Coderack. 
The details of the codelet architecture are described. 
The specialized use of the Coderack by the adaptive web framework's (AWF) Smiley is discussed. 
The codelet scheduling mechanism is discussed. 
A variety of Smiley extensions to the Coderack are reviewed. 
The Coderack infrastructure functions are included. 
Coderack
of the merge streams initiator codelet's builder it must
An operational Workspace structure allows the representation of application state
The msiop codelet is an example of a structural codelet, constructing a Workspace
Plans emerge in complex adaptive systems (CAS) to provide the instructions that agents use to perform actions.  The component architecture and structure of the plans is reviewed. 
schemata
with the operon is an addressable control structure which is used in biological cells to control access to other regions of the DNA. 
binding <mergestreams> <sequence> <integration> <transcription> <factor> <sequence> <integration> <inhibition> <sequence> <integration> for the cascade of codelets that instantiate the assertion is a hypothesis which can be tested and found to be true or false.  In the adaptive web framework's (AWF) Smiley assertion statements are used to define the test that will be applied by the application's codelets.  The statements must include schematic strings which can group complete and become associated with codelets.  Smileys own codelets: Coderack generated part and statement enforces the syntax of the assertion.  The specific form of the statements is defined in the application's Meta file.  Statement codelets also support the operation of the application's Shewhart cycle. 
process.  With the context set, underlying schema binding codelets, such as those supporting the development process,
This page describes the Smiley infrastructure that supports the associative binding of schematic strings to codelets defined in the Meta file and Slipnet. 
The infrastructure supporting the associations is introduced. 
The role of Jeff Hawkins neocortical attributes is discussed. 
Relevant Slipnet configurations are included. 
The codelets and supporting functions are included. 
associated
schematically through the
This page describes the Copycat Slipnet. 
The goal of the Slipnet is reviewed. 
Smiley's specialized use of the Slipnet is introduced. 
The initial Slipnet network used by the 'Merge Streams' and 'Virtual Robot' agent-based applications is setup in initchemistry and is included. 
The Slipnet infrastructure and initialization functions are included. 
Slipnet
with the application can operate. 

The merge streams assert codelet is application specific
The merge streams assert codelet (msao) is associated with msiop's signal indirectly by the Slipnet with the test's schematic context.  Hence it can be provided by the application and be application specific.  The msao builder can
This page reviews the potential to benefit from strategy in a complex adaptive system (CAS).  The challenges described by Dorner require a careful search of the proximate environment. 
make the application specific decision
about which application schemata to indirectly launch (
Agents use sensors to detect events in their environment.  This page reviews how these events become signals associated with beneficial responses in a complex adaptive system (CAS).  CAS signals emerge from the Darwinian information model.  Signals can indicate decision summaries and level of uncertainty. 
signal
),
This page discusses the interdependence of perception and representation in a complex adaptive system (CAS).  Hofstadter and Mitchell's research with Copycat is reviewed. 
given its situation
.  In particular it must decide how to handle case.  Depending on the
This page describes the Adaptive Web framework (AWF) test system and the agent programming framework (Smiley) that supports its operation. 
Example test system statements are included.  To begin a test a test statement is loaded into Smiley while Smiley executes on the Perl interpreter. 
Part of Smiley's Perl code focused on setting up the infrastructure is included bellow. 
The setup includes:
  • Loading the 'Meta file' specification,
  • Initializing the Slipnet, and Workspaces and loading them
  • So that the Coderack can be called. 
The Coderack, which is the focus of a separate page of the Perl frame then schedules and runs the codelets that are invoked by the test statement structures. 
test specification
it may:
The msao codelet uses direct control
The msao codelet's decision making is directly coded into the Perl is Larry Wall's programming language.  It is designed to make easy tasks easy and hard tasks possible.  It has powerful text processing features and can interpret a string of text as code.  .  There is no way that this coding strategy could be generated
This page discusses the mechanisms and effects of emergence underpinning any complex adaptive system (CAS).  Key research is reviewed. 
emergently
, or could be used by
Plans change in complex adaptive systems (CAS) due to the action of genetic operations such as mutation, splitting and recombination.  The nature of the operations is described. 
genetic operators
to contribute to
This page reviews the implications of selection, variation and heredity in a complex adaptive system (CAS).  The mechanism and its emergence are discussed. 
evolved
development is a phase during the operation of a CAS agent.  It allows for schematic strategies to be iteratively blended with environmental signals to solve the logistical issues of migrating newly built and transformed sub-agents.  That is needed to achieve the adult configuration of the agent and optimize it for the proximate environment.  Smiley includes examples of the developmental phase agents required in an emergent CAS.  In situations where parents invest in the growth and memetic learning of their offspring the schematic grab bag can support optimizations to develop models, structures and actions to construct an adept adult.  In humans, adolescence leverages neural plasticity, elder sibling advice and adult coaching to help prepare the deploying neuronal network and body to successfully compete. 
of the application.  Instead each decision point should be
Rather than oppose the direct thrust of some environmental flow agents can improve their effectiveness with indirect responses.  This page explains how agents are architected to do this and discusses some examples of how it can be done. 
indirect
and under control of schematic operons is an addressable control structure which is used in biological cells to control access to other regions of the DNA. 

Resolving case
If the merge streams assert codelet's simple models of the statement lead it to respond that the application is case specific and it must resolve case to proceed it will signal the initialization of a
This page discusses the program strategy in a complex adaptive system (CAS).  Programs generate coherent end-to-end activity.  The mechanism is reviewed. 
program
Plans emerge in complex adaptive systems (CAS) to provide the instructions that agents use to perform actions.  The component architecture and structure of the plans is reviewed. 
operon
that will separate the operation into stages:
  1. Resolving the case instance, this includes a binder complex traversing the application schemata and describing the application specific details.  The mergestreams application schema includes sub schemata, within certain of its structures, which must be detected, entered and traversed.  Mergestreams uses sub-programs for this process. 
  2. Deploying the resolved schemata, and then
  3. Instantiating the test assertion
For the awfart04 test statement the mps signal is matched in the nucleus, a membrane bounded module in a eukaryotic cell where the DNA is encapsulated and operated on. 
with just one schematic subgroup sps signal <mergestreams> <for> <case> <resolved> <assert> <initialise> which is associated by a Slipnet binding with the initpdca evaluator.  This launches the initpdcabuilder to instantiate the case resolution and application processing.  The application specific setup of the 'do' phase is actioned by the msadob codelet (e, b). 

Merge stream specific case modeling
The presence of a test assumption defining the case setting should imply that the value be consistent with the name scope of the case selector associated with each named case operation.  This assumption is modeled by the 'assume case selector assign override' (acsao) builder.  The selector list name should have been identified during
This page discusses how Smiley can support the start of the development phase of an agent-based application. 
Startup is an artificial operation not found in living systems.  But Smiley must do it and so we discuss an example of starting the development phase. 
With the Smiley infrastructure and the application integrated the application's development phase is reviewed.
The association of structural Workspaces for state representation is discussed. 
The aggregation of schematic associations of codelets defines a development agent.  At the application level it processes the application's schematic strings. 
The schematic nature of the data processed by the test application suggests the use of an indirect integration framework.  This supports the binding of codelets to the schematic data and detecting and responding to the control operons. 
An application polymerase complex emerges. 
The codelets and supporting functions are included. 
development
processing by endlistkwbuilder.  When present the test statement's case assumptions should have been reported to the statement codelet by a dascg builder.  If the situation matches the acsao model it will be described by an {acsaoevaluator} descriptor. 

Traversal and describing ivalw codelets (e, b) are aware of the application schematic structures.  They describe the presence and details of the detected structures, and if the structures include the 'gowithin'
This page describes the Smiley infrastructure and codelets that instantiate the epiphenomena defined in the Meta file and Slipnet. 
Infrastructure sensors are introduced. 
The role of phenomena in shaping the environment is discussed. 
The focusing of forces by phenomena in Smiley is discussed. 
The Meta file association of case keywords with phenomena is included. 
The codelets and supporting functions are included. 
property
initiate a sub-program to explore and describe any sub-structure. 

Modeling codelets describe the presence of acceptable case specification components.  A manager crsm codelet accepts the case structure if the modelers describe acceptance of the must have facets of each case aspect present (for, if, elsif, else, match, melse). 

Case if specifications describe alternative options of a case record, so multiple models can be present in a single case record. 

Merge streams case sub-programs
Stacks of sub-programs may be deployed to process each case list.  The case modeling codelets follow the trail of descriptors, left by the ivalw codelets, into the sub-program Workspaces. 

A bcsubps codelet (e, b) follows the ivalw codelet's descriptions and initiates traversal of the sub-structure.  It signals other codelets to assist it:
  • bcsubpc codelet (e, b) detects the completion of the substructure. 
  • ivalw codelet describes the structures, and performs 'gowithin's. 
  • crsm codelet (e, b) manages modeling of the semantics of the structures. 
The dynamics of the signalling, deployment and operations of the interacting sub-program codelets is complex.  Because of deployment failures, crowding out, and positive feedback from amplifiers, the operations of the sub-program codelets include adaptive behaviors, shared descriptions and signalling:
Merge stream sets up resolving structural context
When the application icompd codelet (builder) decides the case modeling is complete and successful it describes the conclusion and signals the resolving cascade.  The application must setup the context for this binder complex.  msadobbuilder deploys a resolving specific structural Workspace and sends a tailored signal, via strategy msadoboppi, generating the context which the case resolving binder complex can operate in

Application integration with statement assumptions
The merge streams describe resolved assume streams virtual codelet is associated into the application cascade as the structural codelet desrasst (builder) which checks for the statement WSO (lb codelet's) stream descriptor and if successful then waits for the deployment of a description of the availability of a resolved merge stream.  It then initiates a binder complex cascade to describe the statement referenced streams.  

The execution of the test assertion
With the activation of waiting test assertion is a hypothesis which can be tested and found to be true or false.  In the adaptive web framework's (AWF) Smiley assertion statements are used to define the test that will be applied by the application's codelets.  The statements must include schematic strings which can group complete and become associated with codelets.  Smileys own codelets: Coderack generated part and statement enforces the syntax of the assertion.  The specific form of the statements is defined in the application's Meta file.  Statement codelets also support the operation of the application's Shewhart cycle. 
codelet (builder) the application becomes focused on executing the statement's verb on the object and validating that the result matches the subject specified. 

The verb is expected to be associated with the specification.  For example <replace> and <mreplace> can both be modeled as appropriate verbs to associate with specification statements about mreplaces.  However, the <mreplace> models should be more salient in that case. 
The application as an iterative phase check pointed program
The application utilizes a series of schematic cascades that allow the test specification statement to influence the outcome of the application, and support the iterative operation of the application. 

A Shewhart cycle (
Walter Shewhart's iterative development process is found in many complex adaptive systems (CAS).  The mechanism is reviewed and its value in coping with random events is explained. 
1
) is aggregated into the
Plans emerge in complex adaptive systems (CAS) to provide the instructions that agents use to perform actions.  The component architecture and structure of the plans is reviewed. 
schematic plan
of the application
Plans are interpreted and implemented by agents.  This page discusses the properties of agents in a complex adaptive system (CAS). 
It then presents examples of agents in different CAS.  The examples include a computer program where modeling and actions are performed by software agents.  These software agents are aggregates. 
The participation of agents in flows is introduced and some implications of this are outlined. 
agent
.  The Shewhart cycle separates the application into phases, which help control the resolving of the case specification:
The iterative cycle uses
This page discusses the tagging of signals in a complex adaptive system (CAS).  Tagged signals can be used to control filtering of an event stream.  Examples of CAS filters are reviewed. 
structural schematic tags
<transcription> <factor> <sequence> <integration> and <inhibitor> <sequence> <integration> that are expected to be present within the mergestreams program structural Workspace to describe the current state of the application cascade. 

The <inhibitor> <sequence> <integration> tag allows the inhibitor, in an enzyme catalyzed reaction an inhibitor can stop the reaction.  It may be competitive, uncompetitive or noncompetitive.  Competitive inhibitors compete with the substrate for access to the active site.  Uncompetitive inhibitors react only with the enzyme-substrate complex creating an inhibited complex.  Noncompetitive inhibitors combine with the enzyme away from the active site and change the shape of the enzyme and its active site.  The adaptive web framework's (AWF) Smiley inhibitors are uncompetitive.  But the inhibition can be removed (reversed) by deploying descriptors. 
machinery prb, and p53 is a tumor suppressor which improves the specificity of transcription's DNA binding and promotes the transcriptional activity of E2F.  P53's activity is controlled by phosphorylation by cyclin Cdk complexes allowing indirect control of the cell cycle.  Among the many genes controlled by p53 are cyclin genes, genes for an inhibitor of cyclin-dependent kinases (Cdk), and the bax gene, which promotes apoptosis.  p53 can thus promote cell proliferation.  It can drive cells into apoptosis.  But it can also stop cell proliferation by arresting the cell cycle.  Normally there is a dynamic balance between proliferation of cells and their death.  In cancer proliferation may become unregulated due to oncogenic mutations or over expression of key regulatory signalling G proteins such as Ras.  Mutations of the p53 suppressor gene are the most frequent suppressor gene mutations in human cancers.  Elephants like humans, have a relatively low buildup of cancer with age.  Elephant's cells have twenty copies of p53 gene pairs which ensure cells with damaged DNA go into apoptosis blocking cancer onset. 
to interact with the application codelets, transcription factors are enzymes which associate with a transcription complex to bind to the DNA and control its transcription and hence translation into proteins.  The regulation of DNA transcription and protein synthesis are reviewed by Tsonis.  In AWF the transcription, translation and deployment infrastructure of the eukaryotic cell has been abstracted in a codelet based implementation. 
and Shewhart cycle codelets, within the context of the merge streams program.  The icompd codelet identifies that the application planning has completed.  In describing the conclusion to the inhibitor machinery prb is able to release its inhibition of e2ftf allowing the Shewhart cycle to advance.  
Synchronization of parallel flows
The merge streams application emerges as a set of parallel codelet cascades which must be synchronized before subsequent cascades can proceed:
  • Planning cascade - performs the initial assessment of the application's schematic plan including its structure and semantics.  When successful it will result in signals being sent to initiate the do and streams cascades. 
  • mergestreams do cascade - Compares models of the schematic plan with the structural and semantic descriptions. 
  • lb streams cascade - Checks that the application streams required by the assert are resolved. 
The synchronization uses schematic structures, and general descriptors deployed onto them, positioned downstream of a synchronization operon is an addressable control structure which is used in biological cells to control access to other regions of the DNA. 
, to allow a general wait and relay service available to a synchronizing codelet such as uwars (e, b) to hold a cascade until the others have completed successfully. 

The problem is general to emergent systems, and has forced solutions in each.  Neuron networks, a network of interconnected neurons which perform signalling, modeling and control functions.  In Cajal's basic neural circuits the signalling is unidirectional.  He identified three classes of neurons in the circuits:
  • Sensory, Interneurons, Motor; which are biochemically distinct and suffer different disease states. 
for example can include a NMDA channel, an active membrane spanning protein with a central pore through which a targeted ion is driven until the channel is opened by a signal which then allows the ions back across the channel continuing the electro-chemical wave. 
, within a neuron, specialized eukaryotic cells include channels which control flows of sodium and potassium ions across the massively extended cell membrane supporting an electro-chemical wave which is then converted into an outgoing chemical signal transmission from synapses which target nearby neuron or muscle cell receptors.  Neurons are supported by glial cells.  Neurons include a:
  • Receptive element - dendrites
  • Transmitting element - axon and synaptic terminals 
's synapses, a neuron structure which provides a junction with other neurons.  It generates signal molecules, either excitatory or inhibitory, which are kept in vesicles until the synapse is stimulated when the signal molecules are released across the synaptic cleft from the neuron.  The provisioning of synapses is under genetic control and is part of long term memory formation as identified by Eric Kandel.  Modulation signals (from slow receptors) initiate the synaptic strengthening which occurs in memory. 
, which performs an AND of its many inputs.  
The assert merge operon
The assert merge schematic operon provides sub group schemata for the alternatives of case and non-case variants of istrings lists within the Workspace. 

Sub-groups define associations between the schematic group's goals and actions.  The actions are associated indirectly through Slipnet bindings of codelet evaluators to the sub-group schematic sequence.  This type of association means that recombinations of groups and sub-groups have the potential to alter the actions that respond to a goal. 

The blending of Shewhart cycle schemata and binder complex schemata creates a sophisticated
Plans are interpreted and implemented by agents.  This page discusses the properties of agents in a complex adaptive system (CAS). 
It then presents examples of agents in different CAS.  The examples include a computer program where modeling and actions are performed by software agents.  These software agents are aggregates. 
The participation of agents in flows is introduced and some implications of this are outlined. 
agent
with discrete management and operational roles. 

Certain keywords and the length of the sub-group schemata are highly constrained.  For example a change to the number of keywords in a sub-group schemata will alter the binder context Workspace that the associated codelet requests. 

The codelet builder schbindbuilder creates the core of a structural complex, bound to application schemata, with which other codelets operating within the assert merge group
This page describes the Smiley infrastructure that supports the associative binding of schematic strings to codelets defined in the Meta file and Slipnet. 
The infrastructure supporting the associations is introduced. 
The role of Jeff Hawkins neocortical attributes is discussed. 
Relevant Slipnet configurations are included. 
The codelets and supporting functions are included. 
associate
.  

The codelet builder slocbuilder supports the binder identifying the initial application keyword's position and describing it in the complex that other indirect codelets participate in. 

The codelet builder ivalwbuilder processes schematic application strings.   Since these strings may contain embedded schemata ivalwbuilder can detect these events, and in such cases transactionally is an operation which guarantees to complete a defined set of activities or return to the initial state.  For a fee the postal service will ensure that a parcel is delivered to its recipient or will return the parcel to the sender.  To provide the service it may have to undo the act of trying to deliver the parcel with a compensating action.  Since the parcel could be lost or destroyed the service may have to return an equivalent value to the sender. 
signal the nucleus for appropriate actions, and act as initial cascade sponsor of any sub-program codelets. 

The codelet builder bcsubpsbuilder initiates sub-program operation and sponsors the
This page discusses how Smiley provides deployment guarantees to its agent-based applications. 
Smiley's transaction services are reviewed. 
The complex interactions of codelets participating in a deployment cascade are discussed including: 
  • The implementation of schematic switches. 
  • The cooperative use of goal suppression.  
  • Evaluator codelets promotion of other siblings. 
Challenges of initiation of a cascade are discussed. 
Tools to associate transaction protection to an operon deployed codelet are described. 
Special support for sub-program codelets is described.  Completion of transactional sub-programs presents special challenges. 
Priority and synchronization support includes:
  • Delaying the operaton of the cascade sponsor. 
  • Delaying the notgcompleting cascade participant. 
  • Waiting for completion of parallel operations with the wait and relay service.  
The need to sustain resource pools is reviewed. 
The use of signals to coordinate siblings is described. 
The structural binding operon for the wait and relay service is included. 
The codelets and supporting functions are included.
cascade of codelets
that the application has schematically associated with the processing of the embedded string.  The bcsubpsbuilder, bcsubpcbuilder, endlistkwbuilder and ivalwbuilder adapt to each other's actions and signals to support the cascade. 

The codelet builder bcsubpcbuilder completes sub-program operation and deploys the descriptors that signal the completion.  It uses
Representing state in emergent entities is essential but difficult.  Various structures are used to enhance the rate and scope of state transitions.  Examples are discussed. 
structurally enhanced state
to wait for the completion of its children. 

The codelet builder desrasstbuilder completes the description of streams referenced in the assert assumptions. 

The codelet builder cassertbuilder initiates the execution of the application's assert operation.




#<!-- start tag smo -->

The following schematic strings are loaded by convbws.  They are group schemata which are associated with nuclear agents (nuclabm evaluator & builder) which respond to codelet signals by deploying the included sub-group schemata to the active
This page describes the Copycat Workspace. 
The specialized use of the Workspace by the adaptive web framework's (AWF) Smiley is discussed. 
How text and XML are imported into the Smiley Workspace is described. 
Telomeric aging of schematic structures is introduced. 
The internal data structure used to represent the state of each workspace object is included. 
The Workspace infrastructure functions are included. 
Workspace


The Meta-keyword <comment> toggles convbws loading between comment mode and processing active <keywords>.  In the following the initial <comment> switches convbws into active mode. 

The active keywords include meta-keyword instructions for convbws, such as <rhlmspg> and <memgroup> and schematic keywords that will be processed during nuclear operations.  The first keyword of a schematic string also identifies the start of the group and the start of the deployed subgroup. 




MSIOP signalled assert
The msiop builder's 'assert' alternative
This page discusses how Smiley provides signalling to its agent-based applications. 
Alternative strategies for initiating the signalling are reviewed. 
The codelets and supporting functions are included.
signal
(<mergestreams> <schema> <merge> <streams> <assert>) is associated with a meme group.  The nuclabm nuclear codelet (builder) matches the signal with all the identically named nuclear Workspace deployed meme groups and heuristically selects subgroup schematic strings from the complete set to send for deployment.  The signal's Slipnet description associates codelet forces (nuclabmevaluator) with the signal. 

 


<comment> (<rhlmspg> <memgroup> <mergestreams> <schema> <merge> <streams> <assert> <mergestreams> <for> <case> <deploy> <assert> </memgroup> </rhlmspg> )<comment> msao



MSAO signalled case test
The msao builder's 'test case operation' alternative
This page discusses how Smiley provides signalling to its agent-based applications. 
Alternative strategies for initiating the signalling are reviewed. 
The codelets and supporting functions are included.
signal
(<mergestreams> <schema> <case> <assert>) is associated with a meme group.  The nuclabm nuclear codelet (builder) matches the signal with all the identically named nuclear Workspace deployed meme groups and heuristically selects subgroup schematic strings from the complete set to send for deployment.  The signal's Slipnet description associates codelet forces (nuclabmevaluator) with the signal. 

 


<comment> (<rhlmspg> <memgroup> <mergestreams> <schema> <case> <assert> <mergestreams> <for> <case> <deploy> <assert> </memgroup> </rhlmspg> )<comment> ?



MSAO signalled meme
The msao builder's 'resolve case with specific selector' alternative
This page discusses how Smiley provides signalling to its agent-based applications. 
Alternative strategies for initiating the signalling are reviewed. 
The codelets and supporting functions are included.
signal
(<mergestreams> <schema> <initialise> <deploy> <case> <assert>) is associated with a meme group.  The nuclabm nuclear codelet (builder) matches the signal with all the identically named nuclear Workspace deployed meme groups and heuristically selects subgroup schematic strings from the complete set to send for deployment.  The signal's Slipnet description associates codelet forces (nuclabmevaluator) with the signal. 

 


<comment> (<rhlmspg> <memgroup> <mergestreams> <schema> <initialise> <deploy> <case> <assert> <mergestreams> <for> <case> <resolved> <assert> <initialise> </memgroup> </rhlmspg> )<comment> initpdca



ipdca signalled meme
The init
Walter Shewhart's iterative development process is found in many complex adaptive systems (CAS).  The mechanism is reviewed and its value in coping with random events is explained. 
pdca
builder's
This page discusses how Smiley provides signalling to its agent-based applications. 
Alternative strategies for initiating the signalling are reviewed. 
The codelets and supporting functions are included.
signal
(<mergestreams> <schema> <deploy> <case> <assert>) is associated with a meme group.  The nuclabm nuclear codelet (builder) matches the signal with all the identically named nuclear Workspace deployed meme groups and heuristically selects subgroup schematic strings from the complete set to send for deployment.  The signal's Slipnet description associates codelet forces (nuclabmevaluator) with the signal. 

 


<comment> (<rhlmspg> <memgroup> <mergestreams> <schema> <deploy> <case> <assert> <mergestreams> <for> <statementcomplete> <program> <initiate> </memgroup> </rhlmspg> )<comment> spdca

#<!-- end tag scs -->

<comment> (<rhlmspg> <memgroup> <mergestreams> <schema> <deploy> <case> <assert> <mergestreams> <for> <case> <resolved> <assert> <investigation> <supervise> </memgroup> </rhlmspg> )<comment> supervisor invsup

<comment> (<rhlmspg> <memgroup> <mergestreams> <schema> <deploy> <case> <assert> <mergestreams> <for> <case> <resolved> <assert> <investigation> <model> </memgroup> </rhlmspg> )<comment> model invmod

#<!-- start tag scs -->

<comment> (<rhlmspg> <memgroup> <mergestreams> <schema> <deploy> <case> <assert> <mergestreams> <for> <program> <transcription> <factor> </memgroup> </rhlmspg> )<comment> e2ftf

<comment> (<rhlmspg> <memgroup> <mergestreams> <schema> <deploy> <case> <assert> <mergestreams> <for> <program> <pdca> <change> <inhibitor> </memgroup> </rhlmspg> )<comment> prb

#<!-- end tag scs -->

<comment> (<rhlmspg> <memgroup> <mergestreams> <schema> <deploy> <case> <assert> <mergestreams> <for> <case> <resolved> <execute> <assert> </memgroup> </rhlmspg> )<comment> schbind

<comment> (<rhlmspg> <memgroup> <mergestreams> <schema> <deploy> <case> <assert> <mergestreams> <for> <case> <resolved> <assert> <initial> </memgroup> </rhlmspg> )<comment> sloc



mssloc signalled meme
The sloc builder's
This page discusses how Smiley provides signalling to its agent-based applications. 
Alternative strategies for initiating the signalling are reviewed. 
The codelets and supporting functions are included.
signal
(<mergestreams> <schema> <assert> <initial>) is associated with a meme group.  The nuclabm nuclear codelet (builder) matches the signal with all the identically named nuclear Workspace deployed meme groups and heuristically selects subgroup schematic strings from the complete set to send for deployment.  The signal's Slipnet description associates codelet forces (nuclabmevaluator) with the signal. 

 


<comment> (<rhlmspg> <memgroup> <mergestreams> <schema> <assert> <initial> <mergestreams> <for> <case> <resolved> <assert> <startlistkw> </memgroup> </rhlmspg> )<comment> slistkw



msslistkw signalled meme
The slistkw builder's
This page discusses how Smiley provides signalling to its agent-based applications. 
Alternative strategies for initiating the signalling are reviewed. 
The codelets and supporting functions are included.
signal
(<mergestreams> <schema> <assert> <startlistkw>) is associated with a meme group.  The nuclabm nuclear codelet (builder) matches the signal with all the identically named nuclear Workspace deployed meme groups and heuristically selects subgroup schematic strings from the complete set to send for deployment.  The signal's Slipnet description associates codelet forces (nuclabmevaluator) with the signal. 

 


<comment> (<rhlmspg> <memgroup> <mergestreams> <schema> <assert> <startlistkw> <mergestreams> <for> <case> <resolved> <assert> <ivalw> </memgroup> </rhlmspg> )<comment> ivalw

<comment> (<rhlmspg> <memgroup> <mergestreams> <schema> <assert> <startlistkw> <mergestreams> <for> <case> <resolved> <assert> <semantics> <ivalw> </memgroup> </rhlmspg> )<comment> acsao

#<!-- end tag sca -->

<comment> (<rhlmspg> <memgroup> <mergestreams> <schema> <assert> <startlistkw> <mergestreams> <for> <case> <resolved> <assert> <startrcdkw> </memgroup> </rhlmspg> )<comment> srcdkw

<comment> (<rhlmspg> <memgroup> <mergestreams> <schema> <assert> <startlistkw> <mergestreams> <for> <case> <resolved> <assert> <cbody> </memgroup> </rhlmspg> )<comment> cbody

#<!-- start tag sca -->


mssrcdkw signalled meme
The srcdkw builder's
This page discusses how Smiley provides signalling to its agent-based applications. 
Alternative strategies for initiating the signalling are reviewed. 
The codelets and supporting functions are included.
signal
(<mergestreams> <schema> <assert> <startrcdkw>) is associated with a meme group.  The nuclabm nuclear codelet (builder) matches the signal with all the identically named nuclear Workspace deployed meme groups and heuristically selects subgroup schematic strings from the complete set to send for deployment.  The signal's Slipnet description associates codelet forces (nuclabmevaluator) with the signal. 

 


#<!-- end tag sca -->
<comment> (<rhlmspg> <memgroup> <mergestreams> <schema> <assert> <startrcdkw> <mergestreams> <for> <case> <resolved> <assert> <target> </memgroup> </rhlmspg> )<comment> itarg

<comment> (<rhlmspg> <memgroup> <mergestreams> <schema> <assert> <startrcdkw> <mergestreams> <for> <case> <resolved> <assert> <ivalw> </memgroup> </rhlmspg> )<comment> ivalw

#<!-- start tag sca -->

<comment> (<rhlmspg> <memgroup> <mergestreams> <schema> <assert> <startrcdkw> <mergestreams> <for> <case> <resolved> <assert> <semantics> <startrcdkw> </memgroup> </rhlmspg> )<comment> crsm

#<!-- end tag sca -->

<comment> (<rhlmspg> <memgroup> <mergestreams> <schema> <assert> <startrcdkw> <mergestreams> <for> <case> <resolved> <assert> <endrcdkw> </memgroup> </rhlmspg> )<comment> endrcdkw



msivalw signalled meme
The ivalw builder's
This page discusses how Smiley provides signalling to its agent-based applications. 
Alternative strategies for initiating the signalling are reviewed. 
The codelets and supporting functions are included.
signal
(<mergestreams> <schema> <assert> <ivalw>) is associated with a meme group.  The nuclabm nuclear codelet (builder) matches the signal with all the identically named nuclear Workspace deployed meme groups and heuristically selects subgroup schematic strings from the complete set to send for deployment.  The signal's Slipnet description associates codelet forces (nuclabmevaluator) with the signal. 

 


<comment> (<rhlmspg> <memgroup> <mergestreams> <schema> <assert> <ivalw> <mergestreams> <for> <case> <resolved> <subprogram> <assert> <initiate> </memgroup> </rhlmspg> )<comment> bcsubps

#<!-- start tag sca -->


msbcsubps signalled meme
The bcsubps builder's
This page discusses how Smiley provides signalling to its agent-based applications. 
Alternative strategies for initiating the signalling are reviewed. 
The codelets and supporting functions are included.
signal
(<mergestreams> <schema> <subprogram> <assert> <initiate>) is associated with a meme group.  The nuclabm nuclear codelet (builder) matches the signal with all the identically named nuclear Workspace deployed meme groups and heuristically selects subgroup schematic strings from the complete set to send for deployment.  The signal's Slipnet description associates codelet forces (nuclabmevaluator) with the signal. 

 


#<!-- end tag sca -->
<comment> (<rhlmspg> <memgroup> <mergestreams> <schema> <subprogram> <assert> <initiate> <mergestreams> <for> <case> <resolved> <subprogram> <assert> <ivalw> </memgroup> </rhlmspg> )<comment> ivalw

<comment> (<rhlmspg> <memgroup> <mergestreams> <schema> <subprogram> <assert> <initiate> <mergestreams> <for> <case> <resolved> <subprogram> <assert> <target> </memgroup> </rhlmspg> )<comment> itarg

<comment> (<rhlmspg> <memgroup> <mergestreams> <schema> <subprogram> <assert> <initiate> <mergestreams> <for> <case> <resolved> <subprogram> <assert> <completed> </memgroup> </rhlmspg> )<comment> bcsubpc

#<!-- start tag sca -->

<comment> (<rhlmspg> <memgroup> <mergestreams> <schema> <subprogram> <assert> <initiate> <mergestreams> <for> <case> <resolved> <subprogram> <assert> <semantics> <startrcdkw> </memgroup> </rhlmspg> )<comment> crsm

#<!-- end tag sca -->



msivalw signalled sub
The ivalw builder's
This page discusses how Smiley provides signalling to its agent-based applications. 
Alternative strategies for initiating the signalling are reviewed. 
The codelets and supporting functions are included.
signal
(<mergestreams> <schema> <subprogram> <assert> <ivalw>) is associated with a meme group.  The nuclabm nuclear codelet (builder) matches the signal with all the identically named nuclear Workspace deployed meme groups and heuristically selects subgroup schematic strings from the complete set to send for deployment.  The signal's Slipnet description associates codelet forces (nuclabmevaluator) with the signal. 

 


<comment> (<rhlmspg> <memgroup> <mergestreams> <schema> <subprogram> <assert> <ivalw> <mergestreams> <for> <case> <resolved> <subprogram> <assert> <initiate> </memgroup> </rhlmspg> )<comment> bcsubps



msendrcdkw signalled meme
The endrcdkw builder's
This page discusses how Smiley provides signalling to its agent-based applications. 
Alternative strategies for initiating the signalling are reviewed. 
The codelets and supporting functions are included.
signal
(<mergestreams> <schema> <assert> <endrcdkw>) is associated with a meme group.  The nuclabm nuclear codelet (builder) matches the signal with all the identically named nuclear Workspace deployed meme groups and heuristically selects subgroup schematic strings from the complete set to send for deployment.  The signal's Slipnet description associates codelet forces (nuclabmevaluator) with the signal. 

 


<comment> (<rhlmspg> <memgroup> <mergestreams> <schema> <assert> <endrcdkw> <mergestreams> <for> <case> <resolved> <assert> <startrcdkw> </memgroup> </rhlmspg> )<comment> srcdkw

<comment> (<rhlmspg> <memgroup> <mergestreams> <schema> <assert> <endrcdkw> <mergestreams> <for> <case> <resolved> <assert> <endlistkw> </memgroup> </rhlmspg> )<comment> endlistkw

<comment> (<rhlmspg> <memgroup> <mergestreams> <schema> <assert> <endrcdkw> <mergestreams> <for> <case> <resolved> <assert> <target> </memgroup> </rhlmspg> )<comment> itarg

<comment> (<rhlmspg> <memgroup> <mergestreams> <schema> <assert> <endrcdkw> <mergestreams> <for> <case> <resolved> <assert> <ivalw> </memgroup> </rhlmspg> )<comment> ivalw

<comment> (<rhlmspg> <memgroup> <mergestreams> <schema> <assert> <endrcdkw> <mergestreams> <for> <case> <resolved> <assert> <skipwso> </memgroup> </rhlmspg> )<comment> skipwso

#<!-- start tag sca -->


msendlistkw signalled meme
The endlistkw builder's
This page discusses how Smiley provides signalling to its agent-based applications. 
Alternative strategies for initiating the signalling are reviewed. 
The codelets and supporting functions are included.
signal
(<mergestreams> <schema> <assert> <endlistkw>) is associated with a meme group.  The nuclabm nuclear codelet (builder) matches the signal with all the identically named nuclear Workspace deployed meme groups and heuristically selects subgroup schematic strings from the complete set to send for deployment.  The signal's Slipnet description associates codelet forces (nuclabmevaluator) with the signal. 

 


#<!-- end tag sca -->
<comment> (<rhlmspg> <memgroup> <mergestreams> <schema> <assert> <endlistkw> <mergestreams> <for> <case> <resolved> <assert> <completed> <investigation> </memgroup> </rhlmspg> )<comment> icompd

#<!-- start tag sca -->

<comment> (<rhlmspg> <memgroup> <mergestreams> <schema> <assert> <endlistkw> <mergestreams> <for> <case> <resolved> <assert> <semantics> <startrcdkw> </memgroup> </rhlmspg> )<comment> crsm

#<!-- end tag sca -->



msicompd signalled meme
The icompd builder's
This page discusses how Smiley provides signalling to its agent-based applications. 
Alternative strategies for initiating the signalling are reviewed. 
The codelets and supporting functions are included.
signal
(<mergestreams> <schema> <assert> <completed> <investigation>) is associated with a meme group.  Its signal must also be synchronized with the wait and relay uwars codelet (builder) which holds the unbind signal.  The nuclabm nuclear codelet (builder) matches the signal with all the identically named nuclear Workspace deployed meme groups and heuristically selects subgroup schematic strings from the complete set to send for deployment.  The signal's Slipnet description associates codelet forces (nuclabmevaluator) with the signal. 

 


<comment> (<rhlmspg> <memgroup> <mergestreams> <schema> <assert> <completed> <investigation> <mergestreams> <for> <case> <resolved> <assert> <replace> <investigation> </memgroup> </rhlmspg> )<comment> uwars



mswait to unbind signalled meme
The wait to unbind builder's
This page discusses how Smiley provides signalling to its agent-based applications. 
Alternative strategies for initiating the signalling are reviewed. 
The codelets and supporting functions are included.
signal
(<mergestreams> <schema> <assert> <replace> <investigation>) is associated with a meme group.  Its signal must also be synchronized with the icompd signal where the <replace> becomes <completed>.  It will wait and relay the signal to the unbind codelet once all the synchronization conditions are met.  The nuclabm nuclear codelet (builder) matches the signal with all the identically named nuclear Workspace deployed meme groups and heuristically selects subgroup schematic strings from the complete set to send for deployment.  The signal's Slipnet description associates codelet forces (nuclabmevaluator) with the signal. 

 


<comment> (<rhlmspg> <memgroup> <mergestreams> <schema> <assert> <replace> <investigation> <mergestreams> <for> <case> <resolved> <assert> <unbind> </memgroup> </rhlmspg> )<comment> unbind schemata is and must be aligned with icompd

<comment> (<rhlmspg> <memgroup> <mergestreams> <schema> <assert> <completed> <investigation> <mergestreams> <for> <case> <resolved> <assert> <each> <stream> </memgroup> </rhlmspg> )<comment> desrasst



msdesrasst signalled meme
The desrasst builder's
This page discusses how Smiley provides signalling to its agent-based applications. 
Alternative strategies for initiating the signalling are reviewed. 
The codelets and supporting functions are included.
signal
(<mergestreams> <schema> <assert> <each> <stream>) is associated with a meme group.  The nuclabm nuclear codelet (builder) matches the signal with all the identically named nuclear Workspace deployed meme groups and heuristically selects subgroup schematic strings from the complete set to send for deployment.  The signal's Slipnet description associates codelet forces (nuclabmevaluator) with the signal. 

 


<comment> (<rhlmspg> <memgroup> <mergestreams> <schema> <assert> <each> <stream> <mergestreams> <for> <stream> <execute> <assert> </memgroup> </rhlmspg> )<comment> schbind

<comment> (<rhlmspg> <memgroup> <mergestreams> <schema> <assert> <each> <stream> <mergestreams> <for> <stream> <file> <sloc> <resolved> <assert> <initial> </memgroup> </rhlmspg> )<comment> sloc



mssloc stream signalled meme
The sloc builder's
This page discusses how Smiley provides signalling to its agent-based applications. 
Alternative strategies for initiating the signalling are reviewed. 
The codelets and supporting functions are included.
signal
(<mergestreams> <schema> <sloc> <resolved> <assert> <initial>) is associated with a meme group.  The nuclabm nuclear codelet (builder) matches the signal with all the identically named nuclear Workspace deployed meme groups and heuristically selects subgroup schematic strings from the complete set to send for deployment.  The signal's Slipnet description associates codelet forces (nuclabmevaluator) with the signal. 

 


<comment> (<rhlmspg> <memgroup> <mergestreams> <schema> <sloc> <resolved> <assert> <initial> <mergestreams> <for> <stream> <resolved> <file> </memgroup> </rhlmspg> )<comment> lbstream

<comment> (<rhlmspg> <memgroup> <mergestreams> <schema> <sloc> <resolved> <assert> <initial> <mergestreams> <for> <stream> <resolved> <completed> </memgroup> </rhlmspg> )<comment> lbstreamcomp

comment (<rhlmspg> <memgroup> <mergestreams> <schema> <stream> <resolved> <completed> <mergestreams> <for> <stream> <resolved> <replace> <completed> </memgroup> </rhlmspg> ) comment uwars

comment (<rhlmspg> <memgroup> <mergestreams> <schema> <stream> <replace> <completed> <mergestreams> <for> <stream> <resolved> <unbind> </memgroup> </rhlmspg> ) comment unbind



mslbstreamcomp signalled meme
The lbstreamcomp builder's
This page discusses how Smiley provides signalling to its agent-based applications. 
Alternative strategies for initiating the signalling are reviewed. 
The codelets and supporting functions are included.
signal
(<mergestreams> <schema> <stream> <resolved> <completed>) is associated with a meme group.  The nuclabm nuclear codelet (builder) matches the signal with all the identically named nuclear Workspace deployed meme groups and heuristically selects subgroup schematic strings from the complete set to send for deployment.  The signal's Slipnet description associates codelet forces (nuclabmevaluator) with the signal. 

 


<comment> (<rhlmspg> <memgroup> <mergestreams> <schema> <stream> <resolved> <completed> <mergestreams> <for> <stream> <resolved> <unbind> </memgroup> </rhlmspg> )<comment> unbind

<comment> (<rhlmspg> <memgroup> <mergestreams> <schema> <assert> <endlistkw> <mergestreams> <for> <case> <resolved> <assert> <startlistkw> </memgroup> </rhlmspg> )<comment> slistkw

#<!-- start tag sca -->



mscrsm signalled meme
The crsm builder's
This page discusses how Smiley provides signalling to its agent-based applications. 
Alternative strategies for initiating the signalling are reviewed. 
The codelets and supporting functions are included.
signal
(<mergestreams> <schema> <assert> <semantics>) is associated with a meme group.  The nuclabm nuclear codelet (builder) matches the signal with all the identically named nuclear Workspace deployed meme groups and heuristically selects subgroup schematic strings from the complete set to send for deployment.  The signal's Slipnet description associates codelet forces (nuclabmevaluator) with the signal. 

 


<comment> (<rhlmspg> <memgroup> <mergestreams> <schema> <assert> <semantics> <mergestreams> <for> <case> <resolved> <assert> <aggregate> <semantics> </memgroup> </rhlmspg> )<comment> crsmox



mscrsm signalled sub
The crsm builder's
This page discusses how Smiley provides signalling to its agent-based applications. 
Alternative strategies for initiating the signalling are reviewed. 
The codelets and supporting functions are included.
signal
(<mergestreams> <schema> <subprogram> <assert> <semantics>) is associated with a meme group.  The nuclabm nuclear codelet (builder) matches the signal with all the identically named nuclear Workspace deployed meme groups and heuristically selects subgroup schematic strings from the complete set to send for deployment.  The signal's Slipnet description associates codelet forces (nuclabmevaluator) with the signal. 

 


<comment> (<rhlmspg> <memgroup> <mergestreams> <schema> <subprogram> <assert> <semantics> <mergestreams> <for> <case> <resolved> <subprogram> <assert> <aggregate> <semantics> </memgroup> </rhlmspg> )<comment> crsmox

#<!-- end tag sca --> <!-- start tag scs -->




#<!-- start tag smo -->


msspdca signalled meme
The spdca builder's
This page discusses how Smiley provides signalling to its agent-based applications. 
Alternative strategies for initiating the signalling are reviewed. 
The codelets and supporting functions are included.
signal
(<mergestreams> <program> <initiate>) is associated with a meme group.  The nuclabm nuclear codelet (builder) matches the signal with all the identically named nuclear Workspace deployed meme groups and heuristically selects subgroup schematic strings from the complete set to send for deployment.  The signal's Slipnet description associates codelet forces (nuclabmevaluator) with the signal. 

 


<comment> (<rhlmspg> <memgroup> <mergestreams> <program> <initiate> <mergestreams> <for> <program> <initiate> </memgroup> </rhlmspg> )<comment> dcycip



msdcycip signalled meme
The dcycip builder's
This page discusses how Smiley provides signalling to its agent-based applications. 
Alternative strategies for initiating the signalling are reviewed. 
The codelets and supporting functions are included.
signal
(<mergestreams> <program> <do>) is associated with a meme group.  The nuclabm nuclear codelet (builder) matches the signal with all the identically named nuclear Workspace deployed meme groups and heuristically selects subgroup schematic strings from the complete set to send for deployment.  The signal's Slipnet description associates codelet forces (nuclabmevaluator) with the signal. 

 


<comment> (<rhlmspg> <memgroup> <mergestreams> <program> <do> <mergestreams> <for> <case> <resolved> <assert> <true> </memgroup> </rhlmspg> )<comment> cassert



mscassert signalled meme
The cassert builder's
This page discusses how Smiley provides signalling to its agent-based applications. 
Alternative strategies for initiating the signalling are reviewed. 
The codelets and supporting functions are included.
signal
(<mergestreams> <source> <target> <assert> <true>) is associated with a meme group.  The nuclabm nuclear codelet (builder) matches the signal with all the identically named nuclear Workspace deployed meme groups and heuristically selects subgroup schematic strings from the complete set to send for deployment.  The signal's Slipnet description associates codelet forces (nuclabmevaluator) with the signal. 

 


<comment> (<rhlmspg> <memgroup> <mergestreams> <source> <target> <assert> <true> <mergestreams> <for> <source> <target> <compare> <list> </memgroup> </rhlmspg> )<comment> stbind

<comment> (<rhlmspg> <memgroup> <mergestreams> <source> <target> <assert> <true> <mergestreams> <for> <source> <target> <list> <initial> </memgroup> </rhlmspg> )<comment> indsloc



msindsloc signalled meme
The indsloc builder's
This page discusses how Smiley provides signalling to its agent-based applications. 
Alternative strategies for initiating the signalling are reviewed. 
The codelets and supporting functions are included.
signal
(<mergestreams> <source> <target> <list> <initial>) is associated with a meme group.  The nuclabm nuclear codelet (builder) matches the signal with all the identically named nuclear Workspace deployed meme groups and heuristically selects subgroup schematic strings from the complete set to send for deployment.  The signal's Slipnet description associates codelet forces (nuclabmevaluator) with the signal. 

 


<comment> (<rhlmspg> <memgroup> <mergestreams> <schema> <source> <target> <list> <initial> <mergestreams> <for> <source> <target> <merge> <initial> </memgroup> </rhlmspg> )<comment> shsloc




msshsloc signalled meme
The shsloc builder's
This page discusses how Smiley provides signalling to its agent-based applications. 
Alternative strategies for initiating the signalling are reviewed. 
The codelets and supporting functions are included.
signal
(<mergestreams> <source> <target> <merge> <initial>) is associated with a meme group.  The nuclabm nuclear codelet (builder) matches the signal with all the identically named nuclear Workspace deployed meme groups and heuristically selects subgroup schematic strings from the complete set to send for deployment.  The signal's Slipnet description associates codelet forces (nuclabmevaluator) with the signal. 

 


<comment> (<rhlmspg> <memgroup> <mergestreams> <schema> <source> <target> <merge> <initial> <mergestreams> <for> <source> <target> <compare> <streams> </memgroup> </rhlmspg> )<comment> rchpair



msrchpair signalled meme
The rchpair builder's
This page discusses how Smiley provides signalling to its agent-based applications. 
Alternative strategies for initiating the signalling are reviewed. 
The codelets and supporting functions are included.
signal
(<mergestreams> <source> <target> <compare> <streams>) is associated with a meme group.  The nuclabm nuclear codelet (builder) matches the signal with all the identically named nuclear Workspace deployed meme groups and heuristically selects subgroup schematic strings from the complete set to send for deployment.  The signal's Slipnet description associates codelet forces (nuclabmevaluator) with the signal. 

 


<comment> (<rhlmspg> <memgroup> <mergestreams> <schema> <source> <target> <compare> <streams> <mergestreams> <for> <source> <target> <integrate> <compare> <streams> </memgroup> </rhlmspg> )<comment> rchpint

comment (<rhlmspg> <memgroup> <mergestreams> <schema> <source> <target> <merge> <initial> <mergestreams> <for> <source> <target> <match> <name> </memgroup> </rhlmspg> ) comment ripkwm

comment (<rhlmspg> <memgroup> <mergestreams> <schema> <source> <target> <match> <name> <mergestreams> <for> <source> <target> <integrate> <match> <name> </memgroup> </rhlmspg> ) comment rpkwmint

#<!-- end tag sir -->
<comment> (<rhlmspg> <memgroup> <mergestreams> <program> <do> <mergestreams> <for> <program> <do> </memgroup> </rhlmspg> )<comment> ecycdop



pdcaecycdop signalled meme
The ecycdop builder's
This page discusses how Smiley provides signalling to its agent-based applications. 
Alternative strategies for initiating the signalling are reviewed. 
The codelets and supporting functions are included.
signal
([<mergestreams> in
This page discusses how a Smiley based application the event processor test program's operational phase is structured. 
The goals of the event processor test application are described. 
The implementation strategy is outlined. 
Synchronization of Smiley setup completion and operation phase initiation is discussed. 
The association of structural Workspaces for state representation is discussed. 
An application specific codelet merge streams assert responds to the nature of the assertion.  It does not have an emergent structure.  Instead it reflects software engineering practice.  It includes:
  • Merge stream case specific
    • Modeling with sub-programs
    • Resolving of case
  • Non case assertion
The operation is setup, inhibited, initiated, and managed by iterative phase check-pointing provided by Smiley codelets. 
Schematic synchronization of parallel codelet cascades is performed structurally. 
The assert merge operon cascade is included. 
The Slipnet concept network for merge streams is included. 
The codelets and supporting functions are included. 
merge streams
This page discusses how Smiley provides deployment guarantees to its agent-based applications. 
Smiley's transaction services are reviewed. 
The complex interactions of codelets participating in a deployment cascade are discussed including: 
  • The implementation of schematic switches. 
  • The cooperative use of goal suppression.  
  • Evaluator codelets promotion of other siblings. 
Challenges of initiation of a cascade are discussed. 
Tools to associate transaction protection to an operon deployed codelet are described. 
Special support for sub-program codelets is described.  Completion of transactional sub-programs presents special challenges. 
Priority and synchronization support includes:
  • Delaying the operaton of the cascade sponsor. 
  • Delaying the notgcompleting cascade participant. 
  • Waiting for completion of parallel operations with the wait and relay service.  
The need to sustain resource pools is reviewed. 
The use of signals to coordinate siblings is described. 
The structural binding operon for the wait and relay service is included. 
The codelets and supporting functions are included.
cascade
substitution] <program> <check>) is associated with a meme group.  The nuclabm nuclear codelet (builder) matches the signal with all the identically named nuclear Workspace deployed meme groups and heuristically selects subgroup schematic strings from the complete set to send for deployment.  The signal's merge stream cascade Slipnet description associates codelet forces (nuclabmevaluator) with the signal. 

 


<comment> (<rhlmspg> <memgroup> <mergestreams> <program> <check> <mergestreams> <for> <program> <check> </memgroup> </rhlmspg> )<comment> acycchp



pdcaacycchp signalled meme
The acycchp builder's
This page discusses how Smiley provides signalling to its agent-based applications. 
Alternative strategies for initiating the signalling are reviewed. 
The codelets and supporting functions are included.
signal
([<mergestreams> in
This page discusses how a Smiley based application the event processor test program's operational phase is structured. 
The goals of the event processor test application are described. 
The implementation strategy is outlined. 
Synchronization of Smiley setup completion and operation phase initiation is discussed. 
The association of structural Workspaces for state representation is discussed. 
An application specific codelet merge streams assert responds to the nature of the assertion.  It does not have an emergent structure.  Instead it reflects software engineering practice.  It includes:
  • Merge stream case specific
    • Modeling with sub-programs
    • Resolving of case
  • Non case assertion
The operation is setup, inhibited, initiated, and managed by iterative phase check-pointing provided by Smiley codelets. 
Schematic synchronization of parallel codelet cascades is performed structurally. 
The assert merge operon cascade is included. 
The Slipnet concept network for merge streams is included. 
The codelets and supporting functions are included. 
merge streams
This page discusses how Smiley provides deployment guarantees to its agent-based applications. 
Smiley's transaction services are reviewed. 
The complex interactions of codelets participating in a deployment cascade are discussed including: 
  • The implementation of schematic switches. 
  • The cooperative use of goal suppression.  
  • Evaluator codelets promotion of other siblings. 
Challenges of initiation of a cascade are discussed. 
Tools to associate transaction protection to an operon deployed codelet are described. 
Special support for sub-program codelets is described.  Completion of transactional sub-programs presents special challenges. 
Priority and synchronization support includes:
  • Delaying the operaton of the cascade sponsor. 
  • Delaying the notgcompleting cascade participant. 
  • Waiting for completion of parallel operations with the wait and relay service.  
The need to sustain resource pools is reviewed. 
The use of signals to coordinate siblings is described. 
The structural binding operon for the wait and relay service is included. 
The codelets and supporting functions are included.
cascade
substitution] <program> <act>) is associated with a meme group.  The nuclabm nuclear codelet (builder) matches the signal with all the identically named nuclear Workspace deployed meme groups and heuristically selects subgroup schematic strings from the complete set to send for deployment.  The signal's merge stream cascade Slipnet description associates codelet forces (nuclabmevaluator) with the signal. 

 


<comment> (<rhlmspg> <memgroup> <mergestreams> <program> <act> <mergestreams> <for> <program> <act> </memgroup> </rhlmspg> )<comment> bcycacp



pdcabcycacp signalled meme
The bcycacp builder's
This page discusses how Smiley provides signalling to its agent-based applications. 
Alternative strategies for initiating the signalling are reviewed. 
The codelets and supporting functions are included.
signal
([<mergestreams> in
This page discusses how a Smiley based application the event processor test program's operational phase is structured. 
The goals of the event processor test application are described. 
The implementation strategy is outlined. 
Synchronization of Smiley setup completion and operation phase initiation is discussed. 
The association of structural Workspaces for state representation is discussed. 
An application specific codelet merge streams assert responds to the nature of the assertion.  It does not have an emergent structure.  Instead it reflects software engineering practice.  It includes:
  • Merge stream case specific
    • Modeling with sub-programs
    • Resolving of case
  • Non case assertion
The operation is setup, inhibited, initiated, and managed by iterative phase check-pointing provided by Smiley codelets. 
Schematic synchronization of parallel codelet cascades is performed structurally. 
The assert merge operon cascade is included. 
The Slipnet concept network for merge streams is included. 
The codelets and supporting functions are included. 
merge streams
This page discusses how Smiley provides deployment guarantees to its agent-based applications. 
Smiley's transaction services are reviewed. 
The complex interactions of codelets participating in a deployment cascade are discussed including: 
  • The implementation of schematic switches. 
  • The cooperative use of goal suppression.  
  • Evaluator codelets promotion of other siblings. 
Challenges of initiation of a cascade are discussed. 
Tools to associate transaction protection to an operon deployed codelet are described. 
Special support for sub-program codelets is described.  Completion of transactional sub-programs presents special challenges. 
Priority and synchronization support includes:
  • Delaying the operaton of the cascade sponsor. 
  • Delaying the notgcompleting cascade participant. 
  • Waiting for completion of parallel operations with the wait and relay service.  
The need to sustain resource pools is reviewed. 
The use of signals to coordinate siblings is described. 
The structural binding operon for the wait and relay service is included. 
The codelets and supporting functions are included.
cascade
substitution] <program> <initiate>) is associated with a meme group.  The nuclabm nuclear codelet (builder) matches the signal with all the identically named nuclear Workspace deployed meme groups and heuristically selects subgroup schematic strings from the complete set to send for deployment.  The signal's merge stream cascade Slipnet description associates codelet forces (nuclabmevaluator) with the signal. 

 


<comment> (<rhlmspg> <memgroup> <mergestreams> <program> <terminate> <mergestreams> <for> <program> <terminate> </memgroup> </rhlmspg> )<comment> dcyctp

<comment> (<rhlmspg> <memgroup> <mergestreams> <schema> <assert> <completed> <investigation> <mergestreams> <for> <case> <resolved> <histone> <case> <do> </memgroup> </rhlmspg> )<comment> msadob



msadob signalled meme
The msadob builder's
This page discusses how Smiley provides signalling to its agent-based applications. 
Alternative strategies for initiating the signalling are reviewed. 
The codelets and supporting functions are included.
signal
(<hdo> <schema> <histone> <case> <do>) is associated with a meme group.  The nuclabm nuclear codelet (builder) matches the signal with all the identically named nuclear Workspace deployed meme groups and heuristically selects subgroup schematic strings from the complete set to send for deployment.  The signal's Slipnet description associates codelet forces (nuclabmevaluator) with the signal. 

 


<comment> (<rhlmspg> <memgroup> <hdo> <schema> <histone> <case> <do> <hdo> <for> <histone> <do> <case> </memgroup> </rhlmspg> )<comment> schbind

<comment> (<rhlmspg> <memgroup> <hdo> <schema> <histone> <case> <do> <hdo> <for> <histone> <case> <initial> </memgroup> </rhlmspg> )<comment> sloc



msdosloc signalled meme
The sloc builder's
This page discusses how Smiley provides signalling to its agent-based applications. 
Alternative strategies for initiating the signalling are reviewed. 
The codelets and supporting functions are included.
signal
(<hdo> <schema> <initial>) is associated with a meme group.  The nuclabm nuclear codelet (builder) matches the signal with all the identically named nuclear Workspace deployed meme groups and heuristically selects subgroup schematic strings from the complete set to send for deployment.  The signal's Slipnet description associates codelet forces (nuclabmevaluator) with the signal. 

 


<comment> (<rhlmspg> <memgroup> <hdo> <schema> <initial> <hdo> <for> <case> <resolved> <histone> <case> <initialise> </memgroup> </rhlmspg> )<comment> dcrdoinit



msdcrdoinit signalled meme
The dcrdoinit builder's
This page discusses how Smiley provides signalling to its agent-based applications. 
Alternative strategies for initiating the signalling are reviewed. 
The codelets and supporting functions are included.
signal
(<hdo> <schema> <histone> <case> <initialise>) is associated with a meme group.  The nuclabm nuclear codelet (builder) matches the signal with all the identically named nuclear Workspace deployed meme groups and heuristically selects subgroup schematic strings from the complete set to send for deployment.  The signal's Slipnet description associates codelet forces (nuclabmevaluator) with the signal. 

 


<comment> (<rhlmspg> <memgroup> <hdo> <schema> <histone> <case> <initialise> <hdo> <for> <case> <resolved> <histone> <replace> </memgroup> </rhlmspg> )<comment> dcrdowars



msdcrdowars signalled meme
The dcrdowars builder's
This page discusses how Smiley provides signalling to its agent-based applications. 
Alternative strategies for initiating the signalling are reviewed. 
The codelets and supporting functions are included.
signal
(<hdo> <schema> <histone> <replace>) is associated with a meme group.  The nuclabm nuclear codelet (builder) matches the signal with all the identically named nuclear Workspace deployed meme groups and heuristically selects subgroup schematic strings from the complete set to send for deployment.  The signal's Slipnet description associates codelet forces (nuclabmevaluator) with the signal. 

 


<comment> (<rhlmspg> <memgroup> <hdo> <schema> <histone> <replace> <hdo> <for> <histone> <resolved> <assert> <unbind> </memgroup> </rhlmspg> )<comment> unbind

<comment> (<rhlmspg> <memgroup> <hdo> <schema> <histone> <case> <initialise> <hdo> <for> <case> <resolved> <histone> <startlistkw> </memgroup> </rhlmspg> )<comment> dcrdoslist



msdcrdoslist signalled meme
The dcrdoslist builder's
This page discusses how Smiley provides signalling to its agent-based applications. 
Alternative strategies for initiating the signalling are reviewed. 
The codelets and supporting functions are included.
signal
(<hdo> <schema> <histone> <startlistkw>) is associated with a meme group.  The nuclabm nuclear codelet (builder) matches the signal with all the identically named nuclear Workspace deployed meme groups and heuristically selects subgroup schematic strings from the complete set to send for deployment.  The signal's Slipnet description associates codelet forces (nuclabmevaluator) with the signal. 

 


<comment> (<rhlmspg> <memgroup> <hdo> <schema> <histone> <startlistkw> <hdo> <for> <case> <resolved> <histone> <skipwso> </memgroup> </rhlmspg> )<comment> dcrdononrec

<comment> (<rhlmspg> <memgroup> <hdo> <schema> <histone> <startlistkw> <hdo> <for> <case> <resolved> <histone> <startrcdkw> </memgroup> </rhlmspg> )<comment> dcrdosrecord

<comment> (<rhlmspg> <memgroup> <hdo> <schema> <histone> <startlistkw> <hdo> <for> <case> <resolved> <histone> <else> </memgroup> </rhlmspg> )<comment> dcrdoncasedesc

<comment> (<rhlmspg> <memgroup> <hdo> <schema> <histone> <startlistkw> <hdo> <for> <case> <resolved> <histone> <if> </memgroup> </rhlmspg> )<comment> dcrdocasedesc

<comment> (<rhlmspg> <memgroup> <hdo> <schema> <histone> <startlistkw> <hdo> <for> <case> <resolved> <histone> <subprogram> </memgroup> </rhlmspg> )<comment> dcrdogowithin

#<!-- end tag sca -->



MSAO signalled meme2
The msao builder's 'no case to resolve' alternative
This page discusses how Smiley provides signalling to its agent-based applications. 
Alternative strategies for initiating the signalling are reviewed. 
The codelets and supporting functions are included.
signal
(<mergestreams> <schema> <statementcomplete> <assert>) is associated with a meme group.  The nuclabm nuclear codelet (builder) matches the signal with all the identically named nuclear Workspace deployed meme groups and heuristically selects subgroup schematic strings from the complete set to send for deployment.  The signal's Slipnet description associates codelet forces (nuclabmevaluator) with the signal. 

 


<comment> (<rhlmspg> <memgroup> <mergestreams> <schema> <statementcomplete> <assert> <mergestreams> <for> <case> <deploy> <assert> </memgroup> </rhlmspg> )<comment> ?





comment (<rhlmspg> <memgroup> <mergestreams> <schema> <assert> <completed> <investigation> <mergestreams> <for> <case> <resolved> <histone> <case> <do> </memgroup> </rhlmspg> ) comment msadob





comment (<rhlmspg> <memgroup> <mergestreams> <schema> <merge> <streams> <assert> <mergestreams> <for> <case> <deploy> <assert> </memgroup> </rhlmspg> ) comment msao

comment (<rhlmspg> <memgroup> <mergestreams> <schema> <case> <assert> <mergestreams> <for> <case> <deploy> <assert> </memgroup> </rhlmspg> ) comment ?

#<!-- start tag scs -->


comment (<rhlmspg> <memgroup> <mergestreams> <schema> <initialise> <deploy> <case> <assert> <mergestreams> <for> <case> <resolved> <assert> <initialise> </memgroup> </rhlmspg> ) comment initpdca

comment (<rhlmspg> <memgroup> <mergestreams> <schema> <deploy> <case> <assert> <mergestreams> <for> <statementcomplete> <program> <initiate> </memgroup> </rhlmspg> ) comment spdca

#<!-- end tag scs -->

comment (<rhlmspg> <memgroup> <mergestreams> <schema> <deploy> <case> <assert> <mergestreams> <for> <case> <resolved> <assert> <investigation> <supervise> </memgroup> </rhlmspg> ) comment supervisor invsup

comment (<rhlmspg> <memgroup> <mergestreams> <schema> <deploy> <case> <assert> <mergestreams> <for> <case> <resolved> <assert> <investigation> <model> </memgroup> </rhlmspg> ) comment model invmod

#<!-- start tag scs -->

comment (<rhlmspg> <memgroup> <mergestreams> <schema> <deploy> <case> <assert> <mergestreams> <for> <program> <transcription> <factor> </memgroup> </rhlmspg> ) comment e2ftf

comment (<rhlmspg> <memgroup> <mergestreams> <schema> <deploy> <case> <assert> <mergestreams> <for> <program> <pdca> <change> <inhibitor> </memgroup> </rhlmspg> ) comment prb

#<!-- end tag scs -->

comment (<rhlmspg> <memgroup> <mergestreams> <schema> <deploy> <case> <assert> <mergestreams> <for> <case> <resolved> <execute> <assert> </memgroup> </rhlmspg> ) comment schbind

comment (<rhlmspg> <memgroup> <mergestreams> <schema> <deploy> <case> <assert> <mergestreams> <for> <case> <resolved> <assert> <initial> </memgroup> </rhlmspg> ) comment sloc

comment (<rhlmspg> <memgroup> <mergestreams> <schema> <assert> <initial> <mergestreams> <for> <case> <resolved> <assert> <startlistkw> </memgroup> </rhlmspg> ) comment slistkw

comment (<rhlmspg> <memgroup> <mergestreams> <schema> <assert> <startlistkw> <mergestreams> <for> <case> <resolved> <assert> <ivalw> </memgroup> </rhlmspg> ) comment ivalw

#<!-- start tag sca -->

comment (<rhlmspg> <memgroup> <mergestreams> <schema> <assert> <startlistkw> <mergestreams> <for> <case> <resolved> <assert> <semantics> <ivalw> </memgroup> </rhlmspg> ) comment acsao

#<!-- end tag sca -->

comment (<rhlmspg> <memgroup> <mergestreams> <schema> <assert> <startlistkw> <mergestreams> <for> <case> <resolved> <assert> <startrcdkw> </memgroup> </rhlmspg> ) comment srcdkw

comment (<rhlmspg> <memgroup> <mergestreams> <schema> <assert> <startlistkw> <mergestreams> <for> <case> <resolved> <assert> <cbody> </memgroup> </rhlmspg> ) comment cbody

comment (<rhlmspg> <memgroup> <mergestreams> <schema> <assert> <startrcdkw> <mergestreams> <for> <case> <resolved> <assert> <target> </memgroup> </rhlmspg> ) comment itarg

comment (<rhlmspg> <memgroup> <mergestreams> <schema> <assert> <startrcdkw> <mergestreams> <for> <case> <resolved> <assert> <ivalw> </memgroup> </rhlmspg> ) comment ivalw

#<!-- start tag sca -->

comment (<rhlmspg> <memgroup> <mergestreams> <schema> <assert> <startrcdkw> <mergestreams> <for> <case> <resolved> <assert> <semantics> <startrcdkw> </memgroup> </rhlmspg> ) comment crsm

#<!-- end tag sca -->

comment (<rhlmspg> <memgroup> <mergestreams> <schema> <assert> <startrcdkw> <mergestreams> <for> <case> <resolved> <assert> <endrcdkw> </memgroup> </rhlmspg> ) comment endrcdkw

comment (<rhlmspg> <memgroup> <mergestreams> <schema> <assert> <ivalw> <mergestreams> <for> <case> <resolved> <subprogram> <assert> <initiate> </memgroup> </rhlmspg> ) comment bcsubps

comment (<rhlmspg> <memgroup> <mergestreams> <schema> <subprogram> <assert> <initiate> <mergestreams> <for> <case> <resolved> <subprogram> <assert> <ivalw> </memgroup> </rhlmspg> ) comment ivalw

comment (<rhlmspg> <memgroup> <mergestreams> <schema> <subprogram> <assert> <initiate> <mergestreams> <for> <case> <resolved> <subprogram> <assert> <target> </memgroup> </rhlmspg> ) comment itarg

comment (<rhlmspg> <memgroup> <mergestreams> <schema> <subprogram> <assert> <initiate> <mergestreams> <for> <case> <resolved> <subprogram> <assert> <completed> </memgroup> </rhlmspg> ) comment bcsubpc

#<!-- start tag sca -->

comment (<rhlmspg> <memgroup> <mergestreams> <schema> <subprogram> <assert> <initiate> <mergestreams> <for> <case> <resolved> <subprogram> <assert> <semantics> <startrcdkw> </memgroup> </rhlmspg> ) comment crsm

#<!-- end tag sca -->

comment (<rhlmspg> <memgroup> <mergestreams> <schema> <subprogram> <assert> <ivalw> <mergestreams> <for> <case> <resolved> <subprogram> <assert> <initiate> </memgroup> </rhlmspg> ) comment bcsubps

comment (<rhlmspg> <memgroup> <mergestreams> <schema> <assert> <endrcdkw> <mergestreams> <for> <case> <resolved> <assert> <startrcdkw> </memgroup> </rhlmspg> ) comment srcdkw

comment (<rhlmspg> <memgroup> <mergestreams> <schema> <assert> <endrcdkw> <mergestreams> <for> <case> <resolved> <assert> <endlistkw> </memgroup> </rhlmspg> ) comment endlistkw

comment (<rhlmspg> <memgroup> <mergestreams> <schema> <assert> <endrcdkw> <mergestreams> <for> <case> <resolved> <assert> <target> </memgroup> </rhlmspg> ) comment itarg

comment (<rhlmspg> <memgroup> <mergestreams> <schema> <assert> <endrcdkw> <mergestreams> <for> <case> <resolved> <assert> <ivalw> </memgroup> </rhlmspg> ) comment ivalw

comment (<rhlmspg> <memgroup> <mergestreams> <schema> <assert> <endrcdkw> <mergestreams> <for> <case> <resolved> <assert> <skipwso> </memgroup> </rhlmspg> ) comment skipwso

comment (<rhlmspg> <memgroup> <mergestreams> <schema> <assert> <endlistkw> <mergestreams> <for> <case> <resolved> <assert> <completed> <investigation> </memgroup> </rhlmspg> ) comment icompd

#<!-- start tag sca -->

comment (<rhlmspg> <memgroup> <mergestreams> <schema> <assert> <endlistkw> <mergestreams> <for> <case> <resolved> <assert> <semantics> <startrcdkw> </memgroup> </rhlmspg> ) comment crsm

#<!-- end tag sca -->

comment (<rhlmspg> <memgroup> <mergestreams> <schema> <assert> <completed> <investigation> <mergestreams> <for> <case> <resolved> <assert> <replace> <investigation> </memgroup> </rhlmspg> ) comment uwars

comment (<rhlmspg> <memgroup> <mergestreams> <schema> <assert> <replace> <investigation> <mergestreams> <for> <case> <resolved> <assert> <unbind> </memgroup> </rhlmspg> ) comment unbind schemata is and must be aligned with icompd

comment (<rhlmspg> <memgroup> <mergestreams> <schema> <assert> <completed> <investigation> <mergestreams> <for> <case> <resolved> <assert> <each> <stream> </memgroup> </rhlmspg> ) comment desrasst

comment (<rhlmspg> <memgroup> <mergestreams> <schema> <assert> <each> <stream> <mergestreams> <for> <stream> <execute> <assert> </memgroup> </rhlmspg> ) comment schbind

comment (<rhlmspg> <memgroup> <mergestreams> <schema> <assert> <each> <stream> <mergestreams> <for> <stream> <file> <sloc> <resolved> <assert> <initial> </memgroup> </rhlmspg> ) comment sloc

comment (<rhlmspg> <memgroup> <mergestreams> <schema> <sloc> <resolved> <assert> <initial> <mergestreams> <for> <stream> <resolved> <file> </memgroup> </rhlmspg> ) comment lbstream

comment (<rhlmspg> <memgroup> <mergestreams> <schema> <sloc> <resolved> <assert> <initial> <mergestreams> <for> <stream> <resolved> <completed> </memgroup> </rhlmspg> ) comment lbstreamcomp

comment (<rhlmspg> <memgroup> <mergestreams> <schema> <stream> <resolved> <completed> <mergestreams> <for> <stream> <resolved> <replace> <completed> </memgroup> </rhlmspg> ) comment uwars

comment (<rhlmspg> <memgroup> <mergestreams> <schema> <stream> <replace> <completed> <mergestreams> <for> <stream> <resolved> <unbind> </memgroup> </rhlmspg> ) comment unbind

comment (<rhlmspg> <memgroup> <mergestreams> <schema> <stream> <resolved> <completed> <mergestreams> <for> <stream> <resolved> <unbind> </memgroup> </rhlmspg> ) comment unbind

comment (<rhlmspg> <memgroup> <mergestreams> <schema> <assert> <endlistkw> <mergestreams> <for> <case> <resolved> <assert> <startlistkw> </memgroup> </rhlmspg> ) comment slistkw

#<!-- start tag sca -->

comment (<rhlmspg> <memgroup> <mergestreams> <schema> <assert> <semantics> <mergestreams> <for> <case> <resolved> <assert> <aggregate> <semantics> </memgroup> </rhlmspg> ) comment crsmox

comment (<rhlmspg> <memgroup> <mergestreams> <schema> <subprogram> <assert> <semantics> <mergestreams> <for> <case> <resolved> <subprogram> <assert> <aggregate> <semantics> </memgroup> </rhlmspg> ) comment crsmox

#<!-- end tag sca -->
#<!-- start tag scs -->
#<!-- start tag smo -->

comment (<rhlmspg> <memgroup> <mergestreams> <program> <initiate> <mergestreams> <for> <program> <initiate> </memgroup> </rhlmspg> ) comment dcycip

comment (<rhlmspg> <memgroup> <mergestreams> <program> <do> <mergestreams> <for> <case> <resolved> <assert> <true> </memgroup> </rhlmspg> ) comment cassert

comment (<rhlmspg> <memgroup> <mergestreams> <source> <target> <assert> <true> <mergestreams> <for> <source> <target> <compare> <list> </memgroup> </rhlmspg> ) comment stbind

comment (<rhlmspg> <memgroup> <mergestreams> <source> <target> <assert> <true> <mergestreams> <for> <source> <target> <list> <initial> </memgroup> </rhlmspg> ) comment indsloc

comment (<rhlmspg> <memgroup> <mergestreams> <schema> <source> <target> <list> <initial> <mergestreams> <for> <source> <target> <merge> <initial> </memgroup> </rhlmspg> ) comment shsloc

comment (<rhlmspg> <memgroup> <mergestreams> <schema> <source> <target> <merge> <initial> <mergestreams> <for> <source> <target> <compare> <streams> </memgroup> </rhlmspg> ) comment rchpair

#<!-- start tag sir -->
<comment> (<rhlmspg> <memgroup> <mergestreams> <schema> <source> <target> <merge> <initial> <mergestreams> <for> <source> <target> <match> <name> </memgroup> </rhlmspg> )<comment> ripkwm

comment (<rhlmspg> <memgroup> <mergestreams> <schema> <source> <target> <compare> <streams> <mergestreams> <for> <source> <target> <integrate> <compare> <streams> </memgroup> </rhlmspg> ) comment rchpint

<comment> (<rhlmspg> <memgroup> <mergestreams> <schema> <source> <target> <match> <name> <mergestreams> <for> <source> <target> <integrate> <match> <name> </memgroup> </rhlmspg> )<comment> rpkwmint

#<!-- end tag sir -->
comment (<rhlmspg> <memgroup> <mergestreams> <program> <do> <mergestreams> <for> <program> <do> </memgroup> </rhlmspg> ) comment ecycdop

comment (<rhlmspg> <memgroup> <mergestreams> <program> <check> <mergestreams> <for> <program> <check> </memgroup> </rhlmspg> ) comment acycchp

comment (<rhlmspg> <memgroup> <mergestreams> <program> <act> <mergestreams> <for> <program> <act> </memgroup> </rhlmspg> ) comment bcycacp

comment (<rhlmspg> <memgroup> <mergestreams> <program> <terminate> <mergestreams> <for> <program> <terminate> </memgroup> </rhlmspg> ) comment dcyctp

#<!-- end tag smo -->
#<!-- end tag scs -->

comment (<rhlmspg> <memgroup> <mergestreams> <schema> <statementcomplete> <assert> <mergestreams> <for> <case> <deploy> <assert> </memgroup> </rhlmspg> ) comment ?

    my ($pconc, $jhlsid);
# development

    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnd}
      [$Awfif::memes-> {snnh} {development}] = 8;
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc}
      [$Awfif::memes-> {snnh} {development}][0] = 35;
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc}
      [$Awfif::memes-> {snnh} {development}][1] = 36;
# mergestreams must be setup prior to all the items that reference its slipnet
# mergestreams

    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnd}
      [$Awfif::memes-> {snnh} {mergestreams}] = 1;
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc}
      [$Awfif::memes-> {snnh} {mergestreams}][0] = 13;#13
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc}
      [$Awfif::memes-> {snnh} {mergestreams}][1] = 12;#5
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {mergestreams}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namedcategory},$Awfif::memes-> {snnh} {mergestreams},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {mergestreams}]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {mergestreams}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {testcategory},$Awfif::memes-> {snnh} {mergestreams},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {mergestreams}]);
# hdo must be setup prior to all the items that reference its slipnet
# hdo

    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnd}
      [$Awfif::memes-> {snnh} {hdo}] = 1;
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc}
      [$Awfif::memes-> {snnh} {hdo}][0] = 13;#13
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc}
      [$Awfif::memes-> {snnh} {hdo}][1] = 12;#5
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {hdo}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namedcategory},$Awfif::memes-> {snnh} {hdo},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {hdo}]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {hdo}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {testcategory},$Awfif::memes-> {snnh} {hdo},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {hdo}]);
# msiopbindtomsiggv
# setup the binding string for the multi path signal to control merge streams assert operation processing - assert codelets launch nuclabmcodelets which ignore the concept as long as it had an evaluator

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [1], 8, $Awfif::memes-> {currentwsbi});
# next want to setup the operon
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {mpsignal}, $pconc, 2, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc), $pconc,# ****
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {mergestreams}, $Awfif::memes-> {snnh} {sequence}, $Awfif::memes-> {snnh} {integration}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
# msaobindtomsiggv
# setup the binding string for the multi path signal to control merge streams assert operation processing - assert codelets launch nuclabmcodelets which ignore the concept as long as it had an evaluator

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [1], 8, $Awfif::memes-> {currentwsbi});
# next want to setup the operon
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {mpsignal}, $pconc, 2, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc), $pconc,# ****
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {mergestreams}, $Awfif::memes-> {snnh} {schema}, $Awfif::memes-> {snnh} {merge}, $Awfif::memes-> {snnh} {streams}, $Awfif::memes-> {snnh} {assert}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
# msinibindtomsiggv
# setup the binding string for the multi path signal to control merge streams assert operation processing - assert codelets launch nuclabmcodelets which ignore the concept as long as it had an evaluator

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [1], 8, $Awfif::memes-> {currentwsbi});
# next want to setup the operon
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {mpsignal}, $pconc, 2, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc), $pconc,# ****
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {mergestreams}, $Awfif::memes-> {snnh} {schema}, $Awfif::memes-> {snnh} {assert}, $Awfif::memes-> {snnh} {initial}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
#<!-- start tag sca -->
# msslkwbindtomsiggv
# setup the binding string for the multi path signal to control merge streams assert operation processing - assert codelets launch nuclabmcodelets which ignore the concept as long as it had an evaluator

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [1], 8, $Awfif::memes-> {currentwsbi});
# next want to setup the operon
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, ($jhlsid = Awfif::addjhlst ($Awfif::memes-> {snnh} {mpsignal}, $pconc, 2, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc)), $pconc,# ****
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {mergestreams}, $Awfif::memes-> {snnh} {schema}, $Awfif::memes-> {snnh} {assert}, $Awfif::memes-> {snnh} {startlistkw}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'acsaobuilder');
    &Awfif::addjhlstm ($jhlsid, 'ivalwbuilder');
# mselkwbindtomsiggv
# setup the binding string for the multi path signal to control merge streams assert operation processing - assert codelets launch nuclabmcodelets which ignore the concept as long as it had an evaluator

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [1], 8, $Awfif::memes-> {currentwsbi});
# next want to setup the operon
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, ($jhlsid = Awfif::addjhlst ($Awfif::memes-> {snnh} {mpsignal}, $pconc, 2, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc)), $pconc,# ****
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {mergestreams}, $Awfif::memes-> {snnh} {schema}, $Awfif::memes-> {snnh} {assert}, $Awfif::memes-> {snnh} {endlistkw}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'icompdbuilder');
    &Awfif::addjhlstm ($jhlsid, 'crsmbuilder');
# mshinibindtomsiggv
# setup the binding string for the multi path signal to control merge streams assert operation processing - assert codelets launch nuclabmcodelets which ignore the concept as long as it had an evaluator

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [1], 8, $Awfif::memes-> {currentwsbi});
# next want to setup the operon
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, ($jhlsid = Awfif::addjhlst ($Awfif::memes-> {snnh} {mpsignal}, $pconc, 2, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc)), $pconc,# ****
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {mergestreams}, $Awfif::memes-> {snnh} {schema}, $Awfif::memes-> {snnh} {initial}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
# msrsdinibindtomsiggv
# setup the binding string for the multi path signal to control merge streams assert operation processing - assert codelets launch nuclabmcodelets which ignore the concept as long as it had an evaluator

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [1], 8, $Awfif::memes-> {currentwsbi});
# next want to setup the operon
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, ($jhlsid = Awfif::addjhlst ($Awfif::memes-> {snnh} {mpsignal}, $pconc, 2, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc)), $pconc,# ****
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
# &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {mergestreams}, $Awfif::memes-> {snnh} {schema}, $Awfif::memes-> {snnh} {stream}, $Awfif::memes-> {snnh} {file}, $Awfif::memes-> {snnh} {sloc}, $Awfif::memes-> {snnh} {resolved}, $Awfif::memes-> {snnh} {assert}, $Awfif::memes-> {snnh} {initial}, $Awfif::memes-> {snnh} {attribr});
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {mergestreams}, $Awfif::memes-> {snnh} {schema}, $Awfif::memes-> {snnh} {sloc}, $Awfif::memes-> {snnh} {resolved}, $Awfif::memes-> {snnh} {assert}, $Awfif::memes-> {snnh} {initial}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'lbstreambuilder');
    &Awfif::addjhlstm ($jhlsid, 'skipwsobuilder');
    &Awfif::addjhlstm ($jhlsid, 'lbstreamcompbuilder');
# msraribindtomsiggv
# setup the binding string for the multi path signal to control merge streams assert operation processing - assert codelets launch nuclabmcodelets which ignore the concept as long as it had an evaluator

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [1], 8, $Awfif::memes-> {currentwsbi});
# next want to setup the operon
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, ($jhlsid = Awfif::addjhlst ($Awfif::memes-> {snnh} {mpsignal}, $pconc, 2, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc)), $pconc,# ****
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {mergestreams}, $Awfif::memes-> {snnh} {schema}, $Awfif::memes-> {snnh} {assert}, $Awfif::memes-> {snnh} {replace}, $Awfif::memes-> {snnh} {investigation}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'unbindbuilder');
# mslscbindtomsiggv
# setup the binding string for the multi path signal to control stream complete processing - assert codelets launch nuclabmcodelets which ignore the concept as long as it had an evaluator

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [1], 8, $Awfif::memes-> {currentwsbi});
# next want to setup the operon
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, ($jhlsid = Awfif::addjhlst ($Awfif::memes-> {snnh} {mpsignal}, $pconc, 2, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc)), $pconc,# ****
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {mergestreams}, $Awfif::memes-> {snnh} {schema}, $Awfif::memes-> {snnh} {stream}, $Awfif::memes-> {snnh} {resolved}, $Awfif::memes-> {snnh} {completed}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'unbindbuilder');
# &Awfif::addjhlstm ($jhlsid, 'uwarsbuilder');
#<!-- end tag sca -->
#<!-- start tag scc -->
# waropbindtobis

# setup the binding string for the wait and relay operon
    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {waitarelay}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {waitarelay}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {waitarelay}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {waitarelay}, $Awfif::memes-> {snnh} {schema}, $Awfif::memes-> {snnh} {integration}, $Awfif::memes-> {snnh} {attribr});
#<!-- end tag scc -->
# mswaropbindtobis

# setup the binding string for the wait and relay operon
    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {waitarelay}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {waitarelay}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {waitarelay}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {waitarelay}, $Awfif::memes-> {snnh} {schema}, $Awfif::memes-> {snnh} {mergestreams}, $Awfif::memes-> {snnh} {attribr});
# msdowaropbindtobis

# setup the do binding string for the wait and relay operon
    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {waitarelay}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {waitarelay}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {waitarelay}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {waitarelay}, $Awfif::memes-> {snnh} {schema}, $Awfif::memes-> {snnh} {do}, $Awfif::memes-> {snnh} {mergestreams}, $Awfif::memes-> {snnh} {attribr});
# msswaropbindtobis

# setup the stream binding string for the wait and relay operon
    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {waitarelay}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {waitarelay}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {waitarelay}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {waitarelay}, $Awfif::memes-> {snnh} {schema}, $Awfif::memes-> {snnh} {mergestreams}, $Awfif::memes-> {snnh} {stream}, $Awfif::memes-> {snnh} {attribr});
# hwaropbindtobis

# setup the binding string for the wait and relay operon
    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {waitarelay}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {waitarelay}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {waitarelay}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {waitarelay}, $Awfif::memes-> {snnh} {schema}, $Awfif::memes-> {snnh} {hdo}, $Awfif::memes-> {snnh} {attribr});
# msadscbindtomsiggv
# setup the binding string for the multi path signal to control merge streams assert case subprogram completion processing - assert codelets launch nuclabmcodelets which ignore the concept as long as it had an evaluator

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [1], 8, $Awfif::memes-> {currentwsbi});
# next want to setup the operon
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, ($jhlsid = Awfif::addjhlst ($Awfif::memes-> {snnh} {mpsignal}, $pconc, 2, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc)), $pconc,# ****
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {mergestreams}, $Awfif::memes-> {snnh} {schema}, $Awfif::memes-> {snnh} {assert}, $Awfif::memes-> {snnh} {ivalw}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'bcsubpsbuilder');
# msadscbindtomsiggvs
# setup the binding string for the multi path signal to control merge streams assert case subprogram completion processing - assert codelets launch nuclabmcodelets which ignore the concept as long as it had an evaluator

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [1], 8, $Awfif::memes-> {currentwsbi});
# next want to setup the operon
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, ($jhlsid = Awfif::addjhlst ($Awfif::memes-> {snnh} {mpsignal}, $pconc, 2, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc)), $pconc,# ****
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {mergestreams}, $Awfif::memes-> {snnh} {schema}, $Awfif::memes-> {snnh} {subprogram}, $Awfif::memes-> {snnh} {assert}, $Awfif::memes-> {snnh} {ivalw}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'bcsubpsbuilder');
# msadscsibindtomsiggv
# setup the binding string for the multi path signal to control merge streams assert case subprogram completion processing - assert codelets launch nuclabmcodelets which ignore the concept as long as it had an evaluator

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [1], 8, $Awfif::memes-> {currentwsbi});
# next want to setup the operon
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, ($jhlsid = Awfif::addjhlst ($Awfif::memes-> {snnh} {mpsignal}, $pconc, 2, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc)), $pconc,# ****
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {mergestreams}, $Awfif::memes-> {snnh} {schema}, $Awfif::memes-> {snnh} {subprogram}, $Awfif::memes-> {snnh} {assert}, $Awfif::memes-> {snnh} {initiate}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'ivalwbuilder');
    &Awfif::addjhlstm ($jhlsid, 'bcsubpcbuilder');
    &Awfif::addjhlstm ($jhlsid, 'crsmbuilder');
# mssrkwbindtomsiggv
# setup the binding string for the multi path signal to control merge streams assert operation processing - assert codelets launch nuclabmcodelets which ignore the concept as long as it had an evaluator

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [1], 8, $Awfif::memes-> {currentwsbi});
# next want to setup the operon
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, ($jhlsid = Awfif::addjhlst ($Awfif::memes-> {snnh} {mpsignal}, $pconc, 2, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc)), $pconc,# ****
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {mergestreams}, $Awfif::memes-> {snnh} {schema}, $Awfif::memes-> {snnh} {assert}, $Awfif::memes-> {snnh} {startrcdkw}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'crsmbuilder');
    &Awfif::addjhlstm ($jhlsid, 'ivalwbuilder');
# msasrsbindtomsiggv
# setup the binding string for the multi path signal to control merge streams assert operation processing - assert codelets launch nuclabmcodelets which ignore the concept as long as it had an evaluator

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [1], 8, $Awfif::memes-> {currentwsbi});
# next want to setup the operon
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, ($jhlsid = Awfif::addjhlst ($Awfif::memes-> {snnh} {mpsignal}, $pconc, 2, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc)), $pconc,# ****
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {mergestreams}, $Awfif::memes-> {snnh} {schema}, $Awfif::memes-> {snnh} {assert}, $Awfif::memes-> {snnh} {semantics}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'crsmoxbuilder');
# &Awfif::addjhlstm ($jhlsid, 'crsmoebuilder');
# &Awfif::addjhlstm ($jhlsid, 'crsmofbuilder');
# &Awfif::addjhlstm ($jhlsid, 'crsmoibuilder');
# &Awfif::addjhlstm ($jhlsid, 'crsmoeibuilder');
# &Awfif::addjhlstm ($jhlsid, 'crsmombuilder');
# &Awfif::addjhlstm ($jhlsid, 'crsmomebuilder');
    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [1], 8, $Awfif::memes-> {currentwsbi});
# next want to setup the operon
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, ($jhlsid = Awfif::addjhlst ($Awfif::memes-> {snnh} {mpsignal}, $pconc, 2, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc)), $pconc,# ****
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {mergestreams}, $Awfif::memes-> {snnh} {schema}, $Awfif::memes-> {snnh} {subprogram}, $Awfif::memes-> {snnh} {assert}, $Awfif::memes-> {snnh} {semantics}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'crsmoxbuilder');
# &Awfif::addjhlstm ($jhlsid, 'crsmoebuilder');
# &Awfif::addjhlstm ($jhlsid, 'crsmofbuilder');
# &Awfif::addjhlstm ($jhlsid, 'crsmoibuilder');
# &Awfif::addjhlstm ($jhlsid, 'crsmoeibuilder');
# &Awfif::addjhlstm ($jhlsid, 'crsmombuilder');
# &Awfif::addjhlstm ($jhlsid, 'crsmomebuilder');
# msendrkwbindtomsiggv
# setup the binding string for the multi path signal to control merge streams assert operation processing - assert codelets launch nuclabmcodelets which ignore the concept as long as it had an evaluator

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [1], 8, $Awfif::memes-> {currentwsbi});
# next want to setup the operon
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, ($jhlsid = Awfif::addjhlst ($Awfif::memes-> {snnh} {mpsignal}, $pconc, 2, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc)), $pconc,# ****
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {mergestreams}, $Awfif::memes-> {snnh} {schema}, $Awfif::memes-> {snnh} {assert}, $Awfif::memes-> {snnh} {endrcdkw}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'ivalwbuilder');
# &Awfif::addjhlstm ($jhlsid, 'endlistkwbuilder');
#<!-- start tag scs -->
# msciobindtomsiggv
# setup the binding string for the multi path signal to control merge streams program initiation - statement codelets launch nuclabmcodelets which ignore the concept as long as it had an evaluator

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [1], 8, $Awfif::memes-> {currentwsbi});
# next want to setup the operon
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, ($jhlsid = Awfif::addjhlst ($Awfif::memes-> {snnh} {mpsignal}, $pconc, 2, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc)), $pconc,# ****
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {mergestreams}, $Awfif::memes-> {snnh} {program}, $Awfif::memes-> {snnh} {initiate}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'dcycipbuilder');
# mscdobindtomsiggv
# setup the binding string for the multi path signal to control merge streams program do - statement codelets launch nuclabmcodelets which ignore the concept as long as it had an evaluator

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [1], 8, $Awfif::memes-> {currentwsbi});
# next want to setup the operon
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, ($jhlsid = Awfif::addjhlst ($Awfif::memes-> {snnh} {mpsignal}, $pconc, 2, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc)), $pconc,# ****
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {mergestreams}, $Awfif::memes-> {snnh} {program}, $Awfif::memes-> {snnh} {do}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'ecycdopbuilder');
    &Awfif::addjhlstm ($jhlsid, 'cassertbuilder');
# msccheckbindtomsiggv
# setup the binding string for the multi path signal to control merge streams program check - statement codelets launch nuclabmcodelets which ignore the concept as long as it had an evaluator

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [1], 8, $Awfif::memes-> {currentwsbi});
# next want to setup the operon
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, ($jhlsid = Awfif::addjhlst ($Awfif::memes-> {snnh} {mpsignal}, $pconc, 2, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc)), $pconc,# ****
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {mergestreams}, $Awfif::memes-> {snnh} {program}, $Awfif::memes-> {snnh} {check}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'acycchpbuilder');
# mscactbindtomsiggv
# setup the binding string for the multi path signal to control merge streams program act - statement codelets launch nuclabmcodelets which ignore the concept as long as it had an evaluator

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [1], 8, $Awfif::memes-> {currentwsbi});
# next want to setup the operon
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, ($jhlsid = Awfif::addjhlst ($Awfif::memes-> {snnh} {mpsignal}, $pconc, 2, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc)), $pconc,# ****
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {mergestreams}, $Awfif::memes-> {snnh} {program}, $Awfif::memes-> {snnh} {act}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'bcycacpbuilder');
# mscassbindtomsiggv
# setup the binding string for the multi path signal to control merge streams source target assert true - statement codelets launch nuclabmcodelets which ignore the concept as long as it had an evaluator

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [1], 8, $Awfif::memes-> {currentwsbi});
# next want to setup the operon
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, ($jhlsid = Awfif::addjhlst ($Awfif::memes-> {snnh} {mpsignal}, $pconc, 2, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc)), $pconc,# ****
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {mergestreams}, $Awfif::memes-> {snnh} {source}, $Awfif::memes-> {snnh} {target}, $Awfif::memes-> {snnh} {assert}, $Awfif::memes-> {snnh} {true}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'stbindbuilder');
    &Awfif::addjhlstm ($jhlsid, 'indslocbuilder');
# sdindslocbindtomsiggv
# setup the binding string for the multi path signal to control merge streams assert operation processing - assert codelets launch nuclabmcodelets which ignore the concept as long as it had an evaluator

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [1], 8, $Awfif::memes-> {currentwsbi});
# next want to setup the operon
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, ($jhlsid = Awfif::addjhlst ($Awfif::memes-> {snnh} {mpsignal}, $pconc, 2, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc)), $pconc,# ****
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {mergestreams}, $Awfif::memes-> {snnh} {schema}, $Awfif::memes-> {snnh} {source}, $Awfif::memes-> {snnh} {target}, $Awfif::memes-> {snnh} {list}, $Awfif::memes-> {snnh} {initial}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'shslocbuilder');
#<!-- start tag sir -->
# sdshslocbindtomsiggv
# setup the binding string for the multi path signal to control merge streams assert operation processing - assert codelets launch nuclabmcodelets which ignore the concept as long as it had an evaluator

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [1], 8, $Awfif::memes-> {currentwsbi});
# next want to setup the operon
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, ($jhlsid = Awfif::addjhlst ($Awfif::memes-> {snnh} {mpsignal}, $pconc, 2, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc)), $pconc,# ****
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {mergestreams}, $Awfif::memes-> {snnh} {schema}, $Awfif::memes-> {snnh} {source}, $Awfif::memes-> {snnh} {target}, $Awfif::memes-> {snnh} {merge}, $Awfif::memes-> {snnh} {initial}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'rchpairbuilder');
    &Awfif::addjhlstm ($jhlsid, 'ripkwmbuilder');
# sdshchpbindtomsiggv
# setup the binding string for the multi path signal to control merge streams assert operation processing - assert codelets launch nuclabmcodelets which ignore the concept as long as it had an evaluator

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [1], 8, $Awfif::memes-> {currentwsbi});
# next want to setup the operon
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, ($jhlsid = Awfif::addjhlst ($Awfif::memes-> {snnh} {mpsignal}, $pconc, 2, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc)), $pconc,# ****
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {mergestreams}, $Awfif::memes-> {snnh} {schema}, $Awfif::memes-> {snnh} {source}, $Awfif::memes-> {snnh} {target}, $Awfif::memes-> {snnh} {compare}, $Awfif::memes-> {snnh} {streams}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'rchpintbuilder');
#<!-- end tag sir -->
# msctobindtomsiggv
# setup the binding string for the multi path signal to control merge streams program termination - statement codelets launch nuclabmcodelets which ignore the concept as long as it had an evaluator

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [1], 8, $Awfif::memes-> {currentwsbi});
# next want to setup the operon
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {mpsignal}, $pconc, 2, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc), $pconc,# ****
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {mergestreams}, $Awfif::memes-> {snnh} {program}, $Awfif::memes-> {snnh} {terminate}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
#<!-- end tag scs -->
# msactbindtomsiggv
# setup the binding string for the multi path signal to control merge streams assert case test operation processing - assert codelets launch nuclabmcodelets which ignore the concept as long as it had an evaluator

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [1], 8, $Awfif::memes-> {currentwsbi});
# next want to setup the operon
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {mpsignal}, $pconc, 2, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc), $pconc,# ****
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {mergestreams}, $Awfif::memes-> {snnh} {schema}, $Awfif::memes-> {snnh} {case}, $Awfif::memes-> {snnh} {assert}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
# msrcatbindtomsiggv
# setup the binding string for the multi path signal to control merge streams case resolve assert test operation processing - assert codelets launch nuclabmcodelets which ignore the concept as long as it had an evaluator

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [1], 8, $Awfif::memes-> {currentwsbi});
# next want to setup the operon
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {mpsignal}, $pconc, 2, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc), $pconc,# ****
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {mergestreams}, $Awfif::memes-> {snnh} {schema}, $Awfif::memes-> {snnh} {deploy}, $Awfif::memes-> {snnh} {case}, $Awfif::memes-> {snnh} {assert}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
# msrcaibindtomsiggv
# setup the binding string for the multi path signal to control merge streams case resolve assert initialise operation processing - assert codelets launch nuclabmcodelets which ignore the concept as long as it had an evaluator

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [1], 8, $Awfif::memes-> {currentwsbi});
# next want to setup the operon
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {mpsignal}, $pconc, 2, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc), $pconc,# ****
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {mergestreams}, $Awfif::memes-> {snnh} {schema}, $Awfif::memes-> {snnh} {initialise}, $Awfif::memes-> {snnh} {deploy}, $Awfif::memes-> {snnh} {case}, $Awfif::memes-> {snnh} {assert}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
# msricompbindtomsiggv
# setup the binding string for the multi path signal to control merge streams case resolve assert investigation complete processing - assert codelets launch nuclabmcodelets which ignore the concept as long as it had an evaluator

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [1], 8, $Awfif::memes-> {currentwsbi});
# next want to setup the operon
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, ($jhlsid = Awfif::addjhlst ($Awfif::memes-> {snnh} {mpsignal}, $pconc, 2, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc)), $pconc,# ****
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {mergestreams}, $Awfif::memes-> {snnh} {schema}, $Awfif::memes-> {snnh} {assert}, $Awfif::memes-> {snnh} {completed}, $Awfif::memes-> {snnh} {investigation}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'uwarsbuilder');
    &Awfif::addjhlstm ($jhlsid, 'msadobbuilder');
    &Awfif::addjhlstm ($jhlsid, 'desrasstbuilder');
#<!-- start tag sca -->
# msadobbindtomsiggv
# setup the binding string for the multi path signal to control merge streams case resolve assert do begin processing - assert codelets launch nuclabmcodelets which ignore the concept as long as it had an evaluator

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {hdo}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {hdo}] [1], 8, $Awfif::memes-> {currentwsbi});
# next want to setup the operon
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, ($jhlsid = Awfif::addjhlst ($Awfif::memes-> {snnh} {mpsignal}, $pconc, 2, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc)), $pconc,# ****
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {hdo}, $Awfif::memes-> {snnh} {schema}, $Awfif::memes-> {snnh} {histone}, $Awfif::memes-> {snnh} {case}, $Awfif::memes-> {snnh} {do}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
# msadoibindtomsiggv
# setup the binding string for the multi path signal to control merge streams case resolve assert do begin processing - assert codelets launch nuclabmcodelets which ignore the concept as long as it had an evaluator

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {hdo}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {hdo}] [1], 8, $Awfif::memes-> {currentwsbi});
# next want to setup the operon
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, ($jhlsid = Awfif::addjhlst ($Awfif::memes-> {snnh} {mpsignal}, $pconc, 2, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc)), $pconc,# ****
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {hdo}, $Awfif::memes-> {snnh} {schema}, $Awfif::memes-> {snnh} {histone}, $Awfif::memes-> {snnh} {case}, $Awfif::memes-> {snnh} {initialise}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'dcrdoslistbuilder');
    &Awfif::addjhlstm ($jhlsid, 'dcrdowarsbuilder');
# msadowarsbindtomsiggv
# setup the binding string for the multi path signal to control merge streams case resolve assert do relay processing - assert codelets launch nuclabmcodelets which ignore the concept as long as it had an evaluator

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {hdo}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {hdo}] [1], 8, $Awfif::memes-> {currentwsbi});
# next want to setup the operon
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, ($jhlsid = Awfif::addjhlst ($Awfif::memes-> {snnh} {mpsignal}, $pconc, 2, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc)), $pconc,# ****
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {hdo}, $Awfif::memes-> {snnh} {schema}, $Awfif::memes-> {snnh} {histone}, $Awfif::memes-> {snnh} {replace}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'unbindbuilder');
# msadoslibindtomsiggv
# setup the binding string for the multi path signal to control merge streams case resolve assert do slist processing - assert codelets launch nuclabmcodelets which ignore the concept as long as it had an evaluator

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {hdo}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {hdo}] [1], 8, $Awfif::memes-> {currentwsbi});
# next want to setup the operon
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, ($jhlsid = Awfif::addjhlst ($Awfif::memes-> {snnh} {mpsignal}, $pconc, 2, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc)), $pconc,# ****
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {hdo}, $Awfif::memes-> {snnh} {schema}, $Awfif::memes-> {snnh} {histone}, $Awfif::memes-> {snnh} {startlistkw}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'dcrdononrecbuilder');
    &Awfif::addjhlstm ($jhlsid, 'dcrdocasedescbuilder');
    &Awfif::addjhlstm ($jhlsid, 'dcrdoncasedescbuilder');
    &Awfif::addjhlstm ($jhlsid, 'dcrdogowithinbuilder');
    &Awfif::addjhlstm ($jhlsid, 'dcrdosrecordbuilder');
# msadrasbindtomsiggv
# setup the binding string for the multi path signal to control merge streams case resolve assert each stream processing - assert codelets launch nuclabmcodelets which ignore the concept as long as it had an evaluator

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [1], 8, $Awfif::memes-> {currentwsbi});
# next want to setup the operon
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, ($jhlsid = Awfif::addjhlst ($Awfif::memes-> {snnh} {mpsignal}, $pconc, 2, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc)), $pconc,# ****
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {mergestreams}, $Awfif::memes-> {snnh} {schema}, $Awfif::memes-> {snnh} {assert}, $Awfif::memes-> {snnh} {each}, $Awfif::memes-> {snnh} {stream}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'schbindbuilder');
    &Awfif::addjhlstm ($jhlsid, 'slocbuilder');
#<!-- end tag sca -->
# msncatbindtomsiggv
# setup the binding string for the multi path signal to control merge streams no case assert test operation processing - assert codelets launch nuclabmcodelets which ignore the concept as long as it had an evaluator

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [1], 8, $Awfif::memes-> {currentwsbi});
# next want to setup the operon
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {mpsignal}, $pconc, 2, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc), $pconc,# ****
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {mergestreams}, $Awfif::memes-> {snnh} {schema}, $Awfif::memes-> {snnh} {statementcomplete}, $Awfif::memes-> {snnh} {assert}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
# msiopbindtosig
# setup the binding string for the single path signal to initiate a asopevaluator/builder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {assert}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {assert}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {merge}, $Awfif::memes-> {snnh} {streams}, $Awfif::memes-> {snnh} {file}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {msiopevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
# msiopibindtosig
# $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
# [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {inspector}, $Awfif::memes-> {snnh} {asopinspector}, $pconc,
# $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
# msiopbindtoinhib

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {assert}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {assert}] [1], 8, $Awfif::memes-> {currentwsbi});
    &Awfif::addjhlinhib ($pconc, $Awfif::memes-> {snnh} {merge}, $Awfif::memes-> {snnh} {streams}, $Awfif::memes-> {snnh} {file}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {inhibitor}, $Awfif::memes-> {snnh} {msiopinhibitor}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
# msiopgsbindtobis
# setup the binding string for the goal suppressor

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {mergestreams}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {mergestreams}, $Awfif::memes-> {snnh} {selector}, $Awfif::memes-> {snnh} {schema}, $Awfif::memes-> {snnh} {attribr});
# msaobindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {mergestreams}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {case}, $Awfif::memes-> {snnh} {deploy}, $Awfif::memes-> {snnh} {assert}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {msaoevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {mergestreams}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {mergestreams},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {mergestreams}]);
#<!-- start tag vbt -->
# vbttmbindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {supervise}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttmorevbbindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
#<!-- start tag preseass1 -->
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {supervise}, $Awfif::memes-> {snnh} {replace}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttmorevbevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
#<!-- end tag preseass1 -->
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttmoretsbindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {supervise}, $Awfif::memes-> {snnh} {deploy}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttmoretsevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttmoregsbindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {supervise}, $Awfif::memes-> {snnh} {genetic}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttmoregsevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom00c10c00bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom00c10c00evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom00c10c01bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom00c10c01evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom00c10bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom00c10evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom00ncbindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom00ncevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom00c00c01bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom00c00c01evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom0recbindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {random}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom0recevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom00c00bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom00c00evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom00c01bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom00c01evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom00c10c01c00bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom00c10c01c00evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom01ncbindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom01ncevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom01c00bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom01c00evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom01c01bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom01c01evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom01c11bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom01c11evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom01c00c11bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom01c00c11evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom01c00c11c02bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {two}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom01c00c11c02evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom01c01c11c02bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {two}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom01c01c11c02evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom01c00c01bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom01c00c01evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom01c00c01c02bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {two}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom01c00c01c02evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom01c00c01c11bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom01c00c01c11evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom01c00c01c11c02bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {two}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom01c00c01c11c02evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom01c01c11bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom01c01c11evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom01c02bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {two}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom01c02evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom01c00c02bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {two}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom01c00c02evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom01c01c02bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {two}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom01c01c02evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom01c11c02bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {two}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom01c11c02evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom09c19c09bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom09c19c09evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom09c19c08bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {eight}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom09c19c08evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom09c19bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom09c19evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom09ncbindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom09ncevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom09c09c08bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {eight}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom09c09c08evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom09c09bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom09c09evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom09c08bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {eight}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom09c08evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom09c19c08c09bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {eight}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom09c19c08c09evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom19ncbindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom19ncevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom19c09bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom19c09evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom19c19bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom19c19evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom19c18bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {eight}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom19c18evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom19c09c18bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {eight}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom19c09c18evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom19c09c18c29bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {eight}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {two}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom19c09c18c29evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom19c19c18c29bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {eight}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {two}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom19c19c18c29evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom19c09c19bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom19c09c19evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom19c09c19c29bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {two}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom19c09c19c29evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom19c09c19c18bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {eight}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom19c09c19c18evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom19c09c19c18c29bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {eight}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {two}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom19c09c19c18c29evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom19c19c18bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {eight}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom19c19c18evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom19c29bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {two}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom19c29evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom19c09c29bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {two}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom19c09c29evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom19c19c29bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {two}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom19c19c29evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom19c18c29bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {eight}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {two}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom19c18c29evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom99c89c99bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {eight}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom99c89c99evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom99c89c98bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {eight}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {eight}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom99c89c98evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom99c89bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {eight}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom99c89evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom99ncbindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom99ncevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom99c99c98bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {eight}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom99c99c98evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom99c99bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom99c99evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom99c98bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {eight}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom99c98evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom99c89c98c99bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {eight}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {eight}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom99c89c98c99evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom98ncbindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {eight}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom98ncevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom98c99bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {eight}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom98c99evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom98c98bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {eight}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {eight}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom98c98evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom98c88bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {eight}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {eight}, $Awfif::memes-> {snnh} {eight}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom98c88evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom98c99c88bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {eight}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {eight}, $Awfif::memes-> {snnh} {eight}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom98c99c88evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom98c99c88c97bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {eight}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {eight}, $Awfif::memes-> {snnh} {eight}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {seven}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom98c99c88c97evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom98c98c88c97bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {eight}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {eight}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {eight}, $Awfif::memes-> {snnh} {eight}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {seven}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom98c98c88c97evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom98c99c98bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {eight}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {eight}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom98c99c98evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom98c99c98c97bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {eight}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {eight}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {seven}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom98c99c98c97evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom98c99c98c88bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {eight}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {eight}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {eight}, $Awfif::memes-> {snnh} {eight}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom98c99c98c88evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom98c99c98c88c97bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {eight}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {eight}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {eight}, $Awfif::memes-> {snnh} {eight}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {seven}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom98c99c98c88c97evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom98c98c88bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {eight}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {eight}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {eight}, $Awfif::memes-> {snnh} {eight}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom98c98c88evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom98c97bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {eight}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {seven}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom98c97evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom98c99c97bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {eight}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {seven}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom98c99c97evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom98c98c97bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {eight}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {eight}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {seven}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom98c98c97evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom98c88c97bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {eight}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {eight}, $Awfif::memes-> {snnh} {eight}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {seven}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom98c88c97evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom90c80c90bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {eight}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom90c80c90evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom90c80c91bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {eight}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom90c80c91evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom90c80bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {eight}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom90c80evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom90ncbindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom90ncevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom90c90c91bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom90c90c91evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom90c90bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom90c90evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom90c91bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom90c91evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom90c80c91c90bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {eight}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom90c80c91c90evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom10ncbindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom10ncevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom10c20bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {two}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom10c20evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom10c10bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom10c10evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom10c11bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom10c11evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom10c20c11bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {two}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom10c20c11evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom10c20c11c00bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {two}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom10c20c11c00evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom10c10c11c00bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom10c10c11c00evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom10c20c10bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {two}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom10c20c10evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom10c20c10c00bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {two}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom10c20c10c00evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom10c20c10c11bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {two}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom10c20c10c11evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom10c20c10c11c00bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {two}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom10c20c10c11c00evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom10c10c11bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom10c10c11evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom10c00bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom10c00evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom10c20c00bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {two}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom10c20c00evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom10c10c00bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom10c10c00evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom10c11c00bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom10c11c00evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom11ncbindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom11ncevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom11c21bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {two}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom11c21evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom11c11bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom11c11evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom11c12bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {two}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom11c12evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom11c21c12bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {two}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {two}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom11c21c12evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom11c21c12c01bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {two}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {two}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom11c21c12c01evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom11c11c12c01bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {two}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom11c11c12c01evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom11c21c11bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {two}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom11c21c11evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom11c21c11c01bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {two}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom11c21c11c01evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom11c21c11c12bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {two}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {two}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom11c21c11c12evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom11c21c11c12c01bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {two}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {two}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom11c21c11c12c01evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom11c11c12bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {two}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom11c11c12evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom11c01bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom11c01evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom11c21c01bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {two}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom11c21c01evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom11c11c01bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom11c11c01evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom11c12c01bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {two}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom11c12c01evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom11c10bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom11c10evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom11c21c10bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {two}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom11c21c10evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom11c11c10bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom11c11c10evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom11c12c10bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {two}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom11c12c10evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom11c21c12c10bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {two}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {two}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom11c21c12c10evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom11c21c12c01c10bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {two}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {two}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom11c21c12c01c10evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom11c11c12c01c10bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {two}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom11c11c12c01c10evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom11c21c11c10bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {two}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom11c21c11c10evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom11c21c11c01c10bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {two}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom11c21c11c01c10evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom11c21c11c12c10bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {two}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {two}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom11c21c11c12c10evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom11c21c11c12c01c10bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {two}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {two}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom11c21c11c12c01c10evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom11c11c12c10bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {two}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom11c11c12c10evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom11c01c10bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom11c01c10evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom11c21c01c10bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {two}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom11c21c01c10evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom11c11c01c10bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom11c11c01c10evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttom11c12c01c10bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {two}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttom11c12c01c10evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttoamsbindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {south}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttoamsevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttoamnbindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {north}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttoamnevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttoamebindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {east}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttoameevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttoamwbindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {west}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttoamwevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttoamrbindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {random}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttoamrevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbttoapcbindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {vbt}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {pickup}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbttoapcevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
#<!-- end tag vbt -->
# testt01bindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {test}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {test}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {test}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {transaction}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {initiator}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {rttrans01evaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {test}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {test},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {test}]);
# testt01rbindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {test}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {test}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {test}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {transaction}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {target}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {rttrans01revaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {test}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {test},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {test}]);
# msacebindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {mergestreams}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {case}, $Awfif::memes-> {snnh} {resolved}, $Awfif::memes-> {snnh} {execute}, $Awfif::memes-> {snnh} {assert}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {schbindevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
#<!-- start tag sca -->
# msadobgsbindtobis
# setup the binding string for the goal suppressor

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {hdo}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {hdo}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {hdo}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {hdo}, $Awfif::memes-> {snnh} {selector}, $Awfif::memes-> {snnh} {schema}, $Awfif::memes-> {snnh} {attribr});
#<!-- end tag sca -->
#<!-- start tag aso -->
# comparestbgsbindtobis
# setup the binding string for the goal suppressor

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {mergestreams}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {source}, $Awfif::memes-> {snnh} {target}, $Awfif::memes-> {snnh} {selector}, $Awfif::memes-> {snnh} {schema}, $Awfif::memes-> {snnh} {attribr});
#<!-- start tag dli -->
# case

    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnd}
      [$Awfif::memes-> {snnh} {case}] = 8;
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc}
      [$Awfif::memes-> {snnh} {case}][0] = 30;#13
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc}
      [$Awfif::memes-> {snnh} {case}][1] = 31;#12
# casebindtobis
# setup the binding string for the binder
    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {case}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {case}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {case}, $Awfif::memes-> {snnh} {sequence}, $Awfif::memes-> {snnh} {integration}, $Awfif::memes-> {snnh} {attribr});
# caseresolvedbindtobis
# setup the binding string for the binder
    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {case}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {case}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {case}, $Awfif::memes-> {snnh} {resolved}, $Awfif::memes-> {snnh} {sequence}, $Awfif::memes-> {snnh} {integration}, $Awfif::memes-> {snnh} {attribr});
# caseresolvedspbindtobis
# setup the binding string for the binder
    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {case}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {case}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {case}, $Awfif::memes-> {snnh} {resolved}, $Awfif::memes-> {snnh} {subprogram}, $Awfif::memes-> {snnh} {sequence}, $Awfif::memes-> {snnh} {integration}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {case}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {successor},$Awfif::memes-> {snnh} {selector},$Awfif::memes-> {snnh} {case},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {case}]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {case}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {successor},$Awfif::memes-> {snnh} {type},$Awfif::memes-> {snnh} {case},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {case}]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {case}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {devcategory},$Awfif::memes-> {snnh} {case},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {case}]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {case}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {indirectroot},$Awfif::memes-> {snnh} {case},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {case}]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {case}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namedcategory},$Awfif::memes-> {snnh} {case},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {case}]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {case}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {testcategory},$Awfif::memes-> {snnh} {case},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {case}]);
#<!-- end tag dli -->
# pdcabindtobis
# setup the binding string for the binder
    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {pdca}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {pdca}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {pdca}, $Awfif::memes-> {snnh} {sequence}, $Awfif::memes-> {snnh} {integration}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {pdca}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {successor},$Awfif::memes-> {snnh} {selector},$Awfif::memes-> {snnh} {pdca},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {pdca}]);
# tfbindtobis
# setup the binding string for the binder
    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {transcription}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {transcription}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {transcription}, $Awfif::memes-> {snnh} {factor}, $Awfif::memes-> {snnh} {sequence}, $Awfif::memes-> {snnh} {integration}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {transcription}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {successor},$Awfif::memes-> {snnh} {selector},$Awfif::memes-> {snnh} {transcription},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {transcription}]);
# inhibitorbindtobis
# setup the binding string for the binder
    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {inhibitor}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {inhibitor}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {inhibitor}, $Awfif::memes-> {snnh} {sequence}, $Awfif::memes-> {snnh} {integration}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {pdca}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {successor},$Awfif::memes-> {snnh} {selector},$Awfif::memes-> {snnh} {inhibitor},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {inhibitor}]);
# receptorhbindtobis
# setup the binding string for the binder
    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {signal}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {signal}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {signal}, $Awfif::memes-> {snnh} {schema}, $Awfif::memes-> {snnh} {integration}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {signal}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {successor},$Awfif::memes-> {snnh} {schema},$Awfif::memes-> {snnh} {signal},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {signal}]);
# receptorbindtobis
# setup the binding string for the binder
    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {signal}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {signal}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {signal}, $Awfif::memes-> {snnh} {integrate}, $Awfif::memes-> {snnh} {sequence}, $Awfif::memes-> {snnh} {integration}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {signal}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {successor},$Awfif::memes-> {snnh} {integrate},$Awfif::memes-> {snnh} {signal},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {signal}]);
# receptorrchpbindtobis
# setup the binding string for the binder
    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {signal}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {signal}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {signal}, $Awfif::memes-> {snnh} {compare}, $Awfif::memes-> {snnh} {streams}, $Awfif::memes-> {snnh} {sequence}, $Awfif::memes-> {snnh} {integration}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {signal}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {successor},$Awfif::memes-> {snnh} {compare},$Awfif::memes-> {snnh} {signal},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {signal}]);
# receptorripkwbindtobis
# setup the binding string for the binder
    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {signal}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {signal}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {signal}, $Awfif::memes-> {snnh} {match}, $Awfif::memes-> {snnh} {name}, $Awfif::memes-> {snnh} {sequence}, $Awfif::memes-> {snnh} {integration}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {signal}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {successor},$Awfif::memes-> {snnh} {match},$Awfif::memes-> {snnh} {signal},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {signal}]);
#<!-- start tag vbt -->
# squareh0bindtobis
# setup the binding string for the binder
    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {square}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {square}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {square}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {schema}, $Awfif::memes-> {snnh} {integration}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {square}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {successor},$Awfif::memes-> {snnh} {schema},$Awfif::memes-> {snnh} {square},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {square}]);
# squareh1bindtobis
# setup the binding string for the binder
    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {square}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {square}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {square}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {schema}, $Awfif::memes-> {snnh} {integration}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {square}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {successor},$Awfif::memes-> {snnh} {schema},$Awfif::memes-> {snnh} {square},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {square}]);
# squareh2bindtobis
# setup the binding string for the binder
    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {square}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {square}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {square}, $Awfif::memes-> {snnh} {two}, $Awfif::memes-> {snnh} {schema}, $Awfif::memes-> {snnh} {integration}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {square}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {successor},$Awfif::memes-> {snnh} {schema},$Awfif::memes-> {snnh} {square},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {square}]);
# squareh3bindtobis
# setup the binding string for the binder
    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {square}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {square}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {square}, $Awfif::memes-> {snnh} {three}, $Awfif::memes-> {snnh} {schema}, $Awfif::memes-> {snnh} {integration}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {square}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {successor},$Awfif::memes-> {snnh} {schema},$Awfif::memes-> {snnh} {square},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {square}]);
# squareh4bindtobis
# setup the binding string for the binder
    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {square}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {square}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {square}, $Awfif::memes-> {snnh} {four}, $Awfif::memes-> {snnh} {schema}, $Awfif::memes-> {snnh} {integration}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {square}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {successor},$Awfif::memes-> {snnh} {schema},$Awfif::memes-> {snnh} {square},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {square}]);
# squareh5bindtobis
# setup the binding string for the binder
    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {square}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {square}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {square}, $Awfif::memes-> {snnh} {five}, $Awfif::memes-> {snnh} {schema}, $Awfif::memes-> {snnh} {integration}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {square}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {successor},$Awfif::memes-> {snnh} {schema},$Awfif::memes-> {snnh} {square},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {square}]);
# squareh6bindtobis
# setup the binding string for the binder
    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {square}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {square}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {square}, $Awfif::memes-> {snnh} {six}, $Awfif::memes-> {snnh} {schema}, $Awfif::memes-> {snnh} {integration}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {square}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {successor},$Awfif::memes-> {snnh} {schema},$Awfif::memes-> {snnh} {square},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {square}]);
# squareh7bindtobis
# setup the binding string for the binder
    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {square}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {square}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {square}, $Awfif::memes-> {snnh} {seven}, $Awfif::memes-> {snnh} {schema}, $Awfif::memes-> {snnh} {integration}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {square}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {successor},$Awfif::memes-> {snnh} {schema},$Awfif::memes-> {snnh} {square},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {square}]);
# squareh8bindtobis
# setup the binding string for the binder
    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {square}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {square}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {square}, $Awfif::memes-> {snnh} {eight}, $Awfif::memes-> {snnh} {schema}, $Awfif::memes-> {snnh} {integration}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {square}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {successor},$Awfif::memes-> {snnh} {schema},$Awfif::memes-> {snnh} {square},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {square}]);
# squareh9bindtobis
# setup the binding string for the binder
    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {square}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {square}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {square}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {schema}, $Awfif::memes-> {snnh} {integration}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {square}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {successor},$Awfif::memes-> {snnh} {schema},$Awfif::memes-> {snnh} {square},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {square}]);
#<!-- end tag vbt -->
# cbody

    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnd}
      [$Awfif::memes-> {snnh} {cbody}] = 1;
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc}
      [$Awfif::memes-> {snnh} {cbody}][0] = 14;
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc}
      [$Awfif::memes-> {snnh} {cbody}][1] = 5;
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {cbody}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namedcategory},$Awfif::memes-> {snnh} {cbody},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {cbody}]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {cbody}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {testcategory},$Awfif::memes-> {snnh} {cbody},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {cbody}]);
# compare

    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnd}
      [$Awfif::memes-> {snnh} {compare}] = 1;
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc}
      [$Awfif::memes-> {snnh} {compare}][0] = 14;
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc}
      [$Awfif::memes-> {snnh} {compare}][1] = 5;
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {compare}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namedcategory},$Awfif::memes-> {snnh} {compare},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {compare}]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {compare}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {testcategory},$Awfif::memes-> {snnh} {compare},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {compare}]);
# completed

    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnd}
      [$Awfif::memes-> {snnh} {completed}] = 1;
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc}
      [$Awfif::memes-> {snnh} {completed}][0] = 14;
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc}
      [$Awfif::memes-> {snnh} {completed}][1] = 5;
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {completed}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namedcategory},$Awfif::memes-> {snnh} {completed},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {completed}]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {completed}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {testcategory},$Awfif::memes-> {snnh} {completed},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {completed}]);
# waitarelay

    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnd}
      [$Awfif::memes-> {snnh} {waitarelay}] = 1;
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc}
      [$Awfif::memes-> {snnh} {waitarelay}][0] = 14;
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc}
      [$Awfif::memes-> {snnh} {waitarelay}][1] = 5;
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {waitarelay}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namedcategory},$Awfif::memes-> {snnh} {waitarelay},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {waitarelay}]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {waitarelay}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {testcategory},$Awfif::memes-> {snnh} {waitarelay},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {waitarelay}]);

Functions

#
sub findtdesc {# type structure i.e. bond or group
    my ($linksi, $structure, $typest, $toost) = @_;#
    my ($structpresent, $linki);
# checked for slipnet per workspace

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("findtdesc linksi $linksi ");
      };
    $structpresent = 0;
    $linki = $linksi;#the head attribute
# all objects should have at least one descriptor - but ....
    if ($linki != 0) {# at least one descriptor for this object

      while (($linki != 0) && (($structpresent == 0))) {
        if ((defined ($typest)) && (defined ($toost))) {
          if (($Awfif::workspace-> {l} [$linki] [4] == $structure)
          && ($Awfif::workspace-> {l} [$linki] [3] == $typest)
          && ($Awfif::workspace-> {l} [$linki] [2] == $toost)
        ){

            $structpresent = $linki;
            };#if
          }#if
        elsif ((!defined ($typest)) && (!defined ($toost)) ){
          if (($Awfif::workspace-> {l} [$linki] [4] == $structure)){

            $structpresent = $linki;
            };#if
          }#if
        else {
          if (($Awfif::workspace-> {l} [$linki] [4] == $structure)
          && ($Awfif::workspace-> {l} [$linki] [3] == $typest)
          ){

            $structpresent = $linki;
            };#if
          };#else
        $linki = $Awfif::workspace-> {l} [$linki] [0];
        };#while
      };# there are descriptors to check
    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("findtdescx ret ($structpresent)\n");
      };
    return $structpresent
    }# findtdesc
#
#<!-- end tag phe -->
#
sub findmodel {#
    my ($linksi, $too, $three) = @_;#
    my ($structpresent, $linki);
# checked for slipnet per workspace

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      my ($pr, $pr2);
      $pr = $Awfif::memes-> {snnih} {$too};
      $pr2 = $Awfif::memes-> {snnih} {$three};
      print ("findtdesc linksi $linksi too $pr($too) three $pr2($three) ");
      };
    $structpresent = 0;
    $linki = $linksi;#the head attribute
# all objects should have at least one descriptor - but ....
    if ($linki != 0) {# at least one descriptor for this object

      while (($linki != 0) && (($structpresent == 0))) {
        if (($Awfif::workspace-> {l} [$linki] [4] == $Awfif::memes-> {snnh} {model})
        && ($Awfif::workspace-> {l} [$linki] [2] == $too)
        && ($Awfif::workspace-> {l} [$linki] [3] == $three)
        ){

          $structpresent = $linki;
          };#if
        $linki = $Awfif::workspace-> {l} [$linki] [0];
        };#while
      };# there are descriptors to check
    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("findmodelx ret ($structpresent)\n");
      };
    return $structpresent
    }# findmodel
#
sub donelement {# identify if there is another element in list to process
    my ($myli, $recordi, $lrecordi, $arecordi, $eos) = @_;#
    my ($proceed);
# checked for slipnet per workspace

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      my ($pr);
      $pr = $Awfif::codelet-> {l} [$myli] [36];
      print ("donelement myli $myli(36:$pr) recordi($$recordi) lrecordi($$lrecordi) arecordi($$arecordi) ");
      };
    if ( $$recordi == 0 ){

      $proceed = '';
      if (($Awfif::codelet-> {l} [$myli] [36] == 0)
      && (findtdesc ($Awfif::wsol-> {l} [ awsoadr (trwsoadr($$lrecordi, 1))] [2], $Awfif::memes-> {snnh} {listend}) != 0)
      ){

        $$eos = 't';
        };#if
      }#if
    else {

      $$lrecordi = $$recordi;
      $$arecordi = awsoadr ($$recordi);#arecordi is set to the incoming recordi
      $$recordi = findtdesc ($Awfif::wsol-> {l} [ $$arecordi] [2], $Awfif::memes-> {snnh} {recordlink});
      $proceed = 't';
      };#else

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      my ($pr);
      if ($$recordi > 0) {
        $pr = $Awfif::workspace-> {l} [$$recordi] [2] - $Awfif::memes-> {snnh} {wsi};
        $pr = ' ->('.$pr.')';
        }#if
      else {
        $pr = '';
        };#else
      print ("donelementx recordi($$recordi $pr) lrecordi($$lrecordi) arecordi($$arecordi) eos($$eos) ret ($proceed)\n");
      };
    return $proceed
    }# donelement
#
#
sub getbcompcontext {
    my ($myli, $cws, $strategy)=@_;
    my ($cwsbi, $bcwso);
    my ($sponsor, $signal, $schema, $swstype, $noswstype, $sponsortype,
    $grkwp, $grkwpr, $cdn, $cdnx);
# get the binder complex schematic jhlabel context

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("getbcompcontext myli $myli cws($cws) ");
      }
#
# checked for merged workspaces

    $cwsbi = $Awfif::memes-> {currentwsbi};
    $noswstype = '';
    if (getcontext ($myli, \$sponsor, \$signal, \$schema, \$swstype, \$grkwp, \$grkwpr, $noswstype, \$cdn, \$cdnx, 3)) {
      my ($sigcount, @lomatchs, @lola, @loconcs, @lostrts, @loends, @logb, @loge, $twso, $asponsor, $cws, $bcwso);
      $twso = trwsoadr (fgrpend ($sponsor), 1);
      $asponsor = awsoadr ($sponsor);
      $sponsortype = wsbasetype ($sponsor);

      if ( (ifindb ($myli, $sponsor, $strategy, \$sigcount, \@lomatchs, \@lola, \@loconcs, \@lostrts, \@loends, \@logb, \@loge) == 1)
      ){#

        $bcwso = getfbws ($myli, $sigcount, \@lomatchs, \@lola, \$$cws);
        };#if
      };#if
    $Awfif::memes-> {currentwsbi} = $cwsbi;

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("getbcompcontextx cws($$cws) ret($bcwso)\n");
      };# trace
    return $bcwso
    }; #getbcompcontext
#
#
sub getmystatement {
    my($myli, $wsoid, $kwp, $kwpr)=@_;
    my ($found, $asponsor, $cwsbi);
# scan back from the start of the operon looking for a statement
#

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("getmystatement wso id = $wsoid ");
      };

    $cwsbi = $Awfif::memes-> {currentwsbi};
    if ( (defined ( $Awfif::codelet-> {l} [$myli] [20])) && ($Awfif::codelet-> {l} [$myli] [20] != 0) ){

      $Awfif::memes-> {currentwsbi} = $Awfif::codelet-> {l} [$myli] [20];
      };
    if ( defined ($Awfif::wsbl-> {getmys}-> {awsoadr ($wsoid)}) ){

      $found = $Awfif::wsbl-> {getmys}-> {awsoadr ($wsoid)}
      }#use cache to help vbotga
    else {

      $asponsor = awsoadr ($Awfif::codelet-> {l} [$myli] [17]);
      $found = igetmynowner ($myli, $wsoid, 'bustatement', $kwp, $kwpr, $asponsor);
      $Awfif::wsbl-> {getmys}-> {awsoadr ($wsoid)} = $found;
      if (($Awfif::memes-> {pstment}) && (!defined($Awfif::memes-> {statementwso}))) {

        $Awfif::memes-> {statementwso} = $found;
        $Awfif::memes-> {statementws} = $Awfif::memes-> {currentwsbi};
        };#if
      };#else

    $Awfif::memes-> {currentwsbi} = $cwsbi;

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("getmystatement ret $found\n");
      };
    return $found
    }# getmystatement
#
sub igetmynowner {
    my($myli, $wsoid, $strategy, $kwp, $kwpr, $iowner)=@_;
    my ($i1, $term, $reject, $found, $sgdi, $sponsor, $gsponsor, $athead, $atdesc);
# scan back from the start of the operon looking for the named owner
# unless this is ie in which case if ieowner is set for this ws return that
# if find named owner and ie and ieowner not set for this ws set ieowner
#

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("igetmynowner wso id = $wsoid ");
      };

    $found = 0;
    $reject = 0;
    $term = trwsoadr ($kwpr,-1);

    if (($strategy eq 'bustatement')
    && ((defined ($iowner)) && ($iowner != 0))
    && (defined ($Awfif::wsbl-> {statement} {$iowner}))
    ){

      $found = $Awfif::wsbl-> {statement} {$iowner};
      }#if
# igetmynownerieu1
# unless this is ie in which case if ieowner is set for this ws return that
    elsif (
    (($athead = awsoadr (trwsoadr( $sponsor = $Awfif::codelet-> {l} [$myli][17],-1))) != 0)
    && ( ($atdesc = findtdesc ($Awfif::wsol-> {l} [ $athead ] [2], $Awfif::memes-> {snnh} {mindequiv})) != 0 )
    ){

      if ( (defined ($Awfif::memes-> {ieowner} [$Awfif::codelet-> {l} [$myli] [20] ]))
      && ($Awfif::memes-> {ieowner} [$Awfif::codelet-> {l} [$myli] [20] ] != 0)
      ){

        $found = $Awfif::memes-> {ieowner} [$Awfif::codelet-> {l} [$myli] [20] ];
        };#if
      }#elsif
    else {

      $sponsor = $Awfif::codelet-> {l} [$myli][17];
      for ($i1 = trwsoadr ($wsoid,-1); (($i1 != $term) && ($i1 != 0) && (!($found != 0)) && (!$reject));
      $i1 = trwsoadr ($i1, -1)) {
        if (($Awfif::memes-> {binds}-> {$strategy}-> ($myli, $i1, $kwp, $term, \$reject)) > 0) {

          $found = $i1;
          }#if
        elsif (($strategy eq 'bustatement')
        && (fgrpd ($Awfif::memes-> {codeleth}, $i1, \$sgdi, $Awfif::memes->{snnh}{groupcategory}))
        && (($gsponsor = fgrpsponsor ($i1, $Awfif::workspace-> {l} [$sgdi] [3], $Awfif::memes-> {snnh} {groupcategory})) != 0)
        && ($gsponsor != $sponsor)
        && ((defined ($Awfif::wsbl-> {statement} {awsoadr ($gsponsor)}))
        or (($found = igetmynowner ($myli, $gsponsor, 'bustatement', $kwp, $kwpr, awsoadr ($gsponsor)))>0) )
        ){

          $found = $Awfif::wsbl-> {statement} {awsoadr ($gsponsor)};
          };#elsif
        };#for
      if (($strategy eq 'bustatement')
      && ((defined ($iowner)) && ($iowner != 0))
      ){

        $Awfif::wsbl-> {statement} {$iowner} = $found;
        };#if
      };#else
    if ( ($found > 0) #setup ie if appropriate
    ){

      if ( ((defined ($atdesc))
        or ($atdesc != 0))
      && ((!defined($Awfif::memes-> {ieowner} [$Awfif::codelet-> {l} [$myli] [20] ]))
        or ($Awfif::memes-> {ieowner} [$Awfif::codelet-> {l} [$myli] [20] ] == 0) )
      ){

        $Awfif::memes-> {ieowner} [$Awfif::codelet-> {l} [$myli] [20] ] = $found;
        }#if
      elsif (
      ((!defined($Awfif::memes-> {ieowner} [$Awfif::codelet-> {l} [$myli] [20] ]))
        or ($Awfif::memes-> {ieowner} [$Awfif::codelet-> {l} [$myli] [20] ] == 0) )
      && ((($athead = awsoadr (trwsoadr( $sponsor = $Awfif::codelet-> {l} [$myli][17],-1))) != 0)
        or ( ($atdesc = findtdesc ($Awfif::wsol-> {l} [ $athead ] [2], $Awfif::memes-> {snnh} {mindequiv})) == 0 ))
      ){

        $Awfif::memes-> {ieowner} [$Awfif::codelet-> {l} [$myli] [20] ] = $found;
        };#elsif
      };#if

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("igetmynowner ret $found\n");
      };
    return $found
    }# igetmynowner
#
sub checkwithin {
    my($myli, $gwdsc, $sponsortype, $kwp, $kwpr)=@_;
    my ($bws, $bbwso, $abbwso, $cwsbi, $found);
# process through a gowithin
#

    $cwsbi = $Awfif::memes-> {currentwsbi};
    $found = '';
    $bws = $Awfif::workspace-> {l} [$gwdsc] [3] - $Awfif::memes-> {snnh}{wsi};
    $bbwso = $Awfif::workspace-> {l} [$gwdsc] [2] - $Awfif::memes-> {snnh}{wsi};
    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      my ($pr);
      $pr = $Awfif::memes-> {snnih}{$sponsortype};
      print ("checkwithin myli $myli gwdsc $gwdsc ->($bws:$bbwso) sponsortype $sponsortype($pr) kwp($kwp) kwpr($kwpr) ");
      };

    my ($listi, $recordi, $seldsc, $arecordi);
    $Awfif::memes-> {currentwsbi} = $bws;
    $abbwso = awsoadr ($bbwso);
# now pickup the listlink
    if (($listi = findtdesc ($Awfif::wsol-> {l} [ $abbwso] [2], $Awfif::memes-> {snnh} {listlink})) != 0
    ){

      $recordi = ($Awfif::workspace-> {l} [$listi] [2] - $Awfif::memes-> {snnh} {wsi});
# now check each record until get a match or run out
      if ( (findbond ($Awfif::wsol-> {l} [($arecordi = awsoadr ($recordi))] [2], $Awfif::memes-> {snnh} {casinopp}, $sponsortype, $Awfif::memes-> {snnh} {model}))
      && ( ($seldsc = findtdesc ($Awfif::wsol-> {l} [ $arecordi] [2], $Awfif::memes-> {snnh} {casemodel})) == 0
      or ($Awfif::workspace-> {l} [$seldsc] [10] != $Awfif::memes-> {snnh} {casedeploys}) )
      ){

        $found = 't';
        };#if
# if decide on recursive strategy then uncomment this

      while ( (!$found)
      && (($recordi = findtdesc ($Awfif::wsol-> {l} [ ($arecordi = awsoadr ($recordi))] [2], $Awfif::memes-> {snnh} {recordlink})) != 0)
      && ($recordi = ($Awfif::workspace-> {l} [$recordi] [2] - $Awfif::memes-> {snnh} {wsi}))
      ){

        if ( (findbond ($Awfif::wsol-> {l} [$arecordi] [2], $Awfif::memes-> {snnh} {casinopp}, $sponsortype, $Awfif::memes-> {snnh} {model}))
        && ( (($seldsc = findtdesc ($Awfif::wsol-> {l} [ $arecordi] [2], $Awfif::memes-> {snnh} {casemodel})) == 0)
        or ($Awfif::workspace-> {l} [$seldsc] [10] != $Awfif::memes-> {snnh} {casedeploys}) )
        ){

          $found = 't';
          };#if
        };#while
      };#if
    $Awfif::memes-> {currentwsbi} = $cwsbi;

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("checkwithinx ret ($found)\n");
      };
    return $found
    }# checkwithin
#
sub endsubpstream {
    my($myli, $arecordi, $abbwso)=@_;
    my ($recdsc, $stopdsc, $cwsbi, $endofsub);
# check sub for end of stream record
#

    $cwsbi = $Awfif::memes-> {currentwsbi};
    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("endsubpstream abbwso $abbwso ");
      &itwsoloutput ($arecordi);
      };

    $endofsub = '';
    if ( ($Awfif::codelet-> {l} [$myli] [36] > 0)
    && (($recdsc = findtdesc ($Awfif::wsol-> {l} [ $arecordi] [2], $Awfif::memes-> {snnh} {record})) != 0)
    && (($stopdsc = findtdesc ($Awfif::wsol-> {l} [ $abbwso] [2], $Awfif::memes-> {snnh} {subprogram}, $Awfif::memes-> {snnh} {stop})) != 0)
    && ($Awfif::workspace-> {l} [$recdsc] [2] == $Awfif::workspace-> {l} [$stopdsc] [2])
    ){
      $endofsub = 't';
      };#if
    $Awfif::memes-> {currentwsbi} = $cwsbi;

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("endsubpstreamx ret ($endofsub)\n");
      };
    return $endofsub
    }# endsubpstream
#<!-- start tag uts -->
#
sub notgcompleted {
    my($myli, $gsoid, $teltwso, $esupp, $strategy, $dontamp, $stws, $issubp, $subp, $nodebug, $nodelayselect, $delayselamp, $usepooling, $notracking)=@_;
    my ($found, $linki, $gslinki, $gelinki, $agsoid, $gs, $ge, $istrategy, $cwsbi, $kwp, $kwpr);

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("notgcompleted gs id $gsoid ");
      if (defined ($usepooling)){
        print ("usepooling($usepooling) ");
        };#if
      };
# look for a group start or end descriptors given a specific group sponsor wso
# updated for merged workspaces
    $cwsbi = $Awfif::memes-> {currentwsbi};
    $found = '';
    if (!ngccltct($myli )) {

      $agsoid = awsoadr ($gsoid);
      if ( $Awfif::wsol-> {l}[$agsoid][ $Awfif::memes-> {wsogcsponsor}] != 0){#*** submacrok ***#

        my ($ngcsponsor);
        $ngcsponsor =
          $Awfif::wsol-> {l}[$agsoid][ $Awfif::memes-> {wsogcsponsor}]; #*** submacrok ***#

        if (($Awfif::memes-> {notgcngcspbreak}) && ($ngcsponsor != 0) && ($Awfif::memes-> {currentwsbi} == 3)) {&break ()};
        $Awfif::wsol-> {l}[$agsoid][ $Awfif::memes-> {wsogcsponsor}] = 0;#*** submacrok ***#
        };
      &isetupdescc ($agsoid);
      $linki = $Awfif::wsol-> {l} [$agsoid][2];

# all objects should have at least one descriptor - but ....
      if ($linki != 0) {# at least one descriptor

        $gs = 0;
        $ge = 0;

        while (($linki != 0)
        && (($gs == 0)
        or ($ge == 0))
        ){

# if a group has completed reduce the salience of the group
          if (($Awfif::memes-> {snnh} {groupstart} == $Awfif::workspace-> {l} [$linki][4]) # in a key relation
          or ($Awfif::memes-> {snnh} {groupend} == $Awfif::workspace-> {l} [$linki][4])) {

            $found = 't';
            if ($Awfif::memes-> {snnh} {groupstart} == $Awfif::workspace-> {l} [$linki][4]) {

              $gs = ($Awfif::workspace-> {l} [$linki][2] - $Awfif::memes-> {snnh}{wsi});
              $gslinki = $linki;
              }#if
            else {

              $ge = ($Awfif::workspace-> {l} [$linki][2] - $Awfif::memes-> {snnh}{wsi});
              $gelinki = $linki;
              };# else
            $Awfif::workspace-> {l} [$linki][4] = $Awfif::workspace-> {l} [$linki][4] + 1;
            } # if
          elsif (($Awfif::memes-> {snnh} {wasgroupstart} == $Awfif::workspace-> {l} [$linki][4]) # in a key relation
          or ($Awfif::memes-> {snnh} {wasgroupend} == $Awfif::workspace-> {l} [$linki][4])) {

            $found = 't';
            if ($Awfif::memes-> {snnh} {wasgroupstart} == $Awfif::workspace-> {l} [$linki][4]) {

              $gs = ($Awfif::workspace-> {l} [$linki][2] - $Awfif::memes-> {snnh}{wsi});
              $gslinki = $linki;
              }#if
            else {

              $ge = ($Awfif::workspace-> {l} [$linki][2] - $Awfif::memes-> {snnh}{wsi});
              $gelinki = $linki;
              };# else
            }; # if

          $linki = $Awfif::workspace-> {l} [$linki][0];
          }; # while
        };# if

      if ($found) {
# notgctmgrampup1
        my ($ltransmgrid, $patelhwso, $activec, $from, $mask, $val);
        if ( (defined ($myli)) && ($Awfif::codelet-> {l} [$myli] [37] > 0) && ($Awfif::codelet-> {l} [$myli] [36] > 0)) {

          $ltransmgrid = $Awfif::codelet-> {l} [$myli] [37];
          $patelhwso = awsoadr (trwsoadr ($gs, -1));
          $activec = 1;
          $from = $Awfif::workspace-> {l} [$gslinki][4];
          if (getcmstate ($from) ) {

            $from--;
            };
          $mask = -1;
          $val = -1;
          &gettmgrdesc ($patelhwso, $Awfif::memes-> {snnh} {rtran}, $ltransmgrid, $from, \$mask, \$val);
          if ($mask >= 0) {
# update the gs descriptor to ensure that it matches this tranmgrid, and is active

            if ($Awfif::workspace-> {l} [$gslinki][11] != $ltransmgrid) {
# update the trans managed data if necessary to mask set

              $Awfif::workspace-> {l} [$gslinki][11] = $ltransmgrid;
              };#if
            if ($mask == 0) {

              $mask = 1;
              &updtmgrdesc ($patelhwso, $Awfif::memes-> {snnh} {rtran}, $ltransmgrid, $from, $mask, $Awfif::workspace-> {l} [$gslinki][9]);
              };#if
            }# if found an associated transaction for the gs descriptor
          else {#create a trans mgr descriptor association for gs descriptor
# update the gs descriptor to ensure that it matches this tranmgrid, and is active

            if ($Awfif::workspace-> {l} [$gslinki][11] != $ltransmgrid) {
# update the trans managed data if necessary to mask set

              $Awfif::workspace-> {l} [$gslinki][11] = $ltransmgrid;
              };#if

            $mask = 1;
            &addtmgrdesc ($patelhwso, $Awfif::memes-> {snnh} {rtran}, $ltransmgrid, $from, $mask, $Awfif::workspace-> {l} [$gslinki] [9]);
            };#else
          $from = $Awfif::workspace-> {l} [$gelinki][4];
          if (getcmstate ($from) ) {

            $from--;
            };
          $mask = -1;
          $val = -1;
          &gettmgrdesc ($patelhwso, $Awfif::memes-> {snnh} {rtran}, $ltransmgrid, $from, \$mask, \$val);
          if ($mask >= 0) {
# update the ge descriptor to ensure that it matches this tranmgrid, and is active

            if ($Awfif::workspace-> {l} [$gelinki][11] != $ltransmgrid) {
# update the trans managed data if necessary to mask set

              $Awfif::workspace-> {l} [$gelinki][11] = $ltransmgrid;
              };#if
            if ($mask == 0) {

              $mask = 1;
              &updtmgrdesc ($patelhwso, $Awfif::memes-> {snnh} {rtran}, $ltransmgrid, $from, $mask, $Awfif::workspace-> {l} [$gelinki][9]);
              };#if
            }# if found an associated transaction for the gs descriptor
          else {#create a trans mgr descriptor association for gs descriptor
# update the gs descriptor to ensure that it matches this tranmgrid, and is active

            if ($Awfif::workspace-> {l} [$gelinki][11] != $ltransmgrid) {
# update the trans managed data if necessary to mask set

              $Awfif::workspace-> {l} [$gelinki][11] = $ltransmgrid;
              };#if

            $mask = 1;
            &addtmgrdesc ($patelhwso, $Awfif::memes-> {snnh} {rtran}, $ltransmgrid, $from, $mask, $Awfif::workspace-> {l} [$gelinki] [9]);
            };#else
          };#if
# notgcudsel1
        if ( (!defined ($nodelayselect))
        || (!$nodelayselect)
        ){

          my ($ags, $counteri);
          $ags = awsoadr ($gs);
          $Awfif::wsol-> {l} [$ags][2]
            = inccounter (
              undef (),#pltype
              undef (),#pto
              $Awfif::memes-> {snnh} {delayselect}, #from
              $Awfif::wsol-> {l} [ $ags] [2],#dlinkh
# notgcutmgrdsel1
              $ags,#awso
              undef(),#synccod
              undef(),#sltype
              undef(),#spto
              $ltransmgrid,#transmgrid
              $patelhwso,#atelhwso
              $activec);#active
          &findcounter ($Awfif::wsol-> {l} [$ags][2], $Awfif::memes-> {snnh} {delayselect}, \$counteri);
# notgcdsampu1
          if ((defined ($delayselamp)) && ($delayselamp)) {

            $Awfif::workspace-> {l} [$counteri] [9] += ($Awfif::memes-> {wsi} + ($Awfif::memes-> {delayselcount} * $Awfif::memes-> {tdfsampds}));
            }#if
          else {

            $Awfif::workspace-> {l} [$counteri] [9] += ($Awfif::memes-> {wsi} + $Awfif::memes-> {delayselcount});
            };#else
          };#if
# notgcusupp1
# engage suppressor
        my ($sigcount, @lomatchs, @lola, @loconcs, @lostrts, @loends, @logb, @loge, $gsws, $gswso, $agswso, $cwsbi2);
        if ( (defined ($esupp))
        && ($esupp)
        &&(ifindb ($myli, 1, 'goalsupp', \$sigcount, \@lomatchs, \@lola, \@loconcs, \@lostrts, \@loends, \@logb, \@loge, $kwp, $kwpr, \@{$Awfif::memes-> {sactset}}, $stws, $issubp, $subp) == 1)
        ){#

          $gswso = getfbws ($myli, $sigcount, \@lomatchs, \@lola, \$gsws, undef(), $stws, $subp);
          if ((defined ($strategy)) && ($strategy ne '')) {

            $istrategy = $strategy;
            }#if
          else {

            $istrategy = 'goalscon';
            };#else
          if ( (ifindb ($myli, 1, $istrategy, \$sigcount, \@lomatchs, \@lola, \@loconcs, \@lostrts, \@loends, \@logb, \@loge, $kwp, $kwpr, \@{$Awfif::memes-> {sactset}}, $gsws, $issubp, $subp) == 1)
          ){#

            $gswso = getstsbws ($myli, $sigcount, \@lomatchs, \@lola, $gsws, $stws, $subp);
            $cwsbi2 = $Awfif::memes-> {currentwsbi};
            $Awfif::memes-> {currentwsbi} = $gsws;
            $agswso = awsoadr ($gswso);
            $Awfif::wsol-> {l} [$agswso][2]
              = inccounter (
                undef (),
                undef (),
                $Awfif::memes-> {snnh} {notgcompleted},
                $Awfif::wsol-> {l} [$agswso] [2],
                $agswso);
            $Awfif::memes-> {currentwsbi} = $cwsbi2;
            };#if goal suppressor present
          };#if
# change the status of all the wso in the group
        my ($reset38, $i, $ai, $ati);
# send activation to the gs wso

        $ai = awsoadr ($gs);
# notgcubmyli1
        $ati = awsoadr (trwsoadr ($gs, -1));
        if ( (!defined ($nodebug)) && ($Awfif::memes-> {breakmyli} == $myli) && ($Awfif::memes-> {bmbcindex} > 0) ){

          if ($Awfif::memes-> {breakmyli} == $Awfif::memes-> {breakcodelet} [$Awfif::memes-> {bmbcindex}]) {#remove only if not been replaced by submit

            &remarrent ($Awfif::memes-> {bmbcindex}, \@{$Awfif::memes-> {breakcodelet}});
            &remarrent ($Awfif::memes-> {bmbcindex}, \@{$Awfif::memes-> {breaksubp}});
            };#
          $Awfif::memes-> {breakthwso} [ ++$Awfif::memes-> {breakthwso} [0]] = $ati;
          $Awfif::memes-> {breakthsubp} [ ++$Awfif::memes-> {breakthsubp} [0]] = $Awfif::codelet-> {l} [$myli] [36];
          };#if

        if ( (!defined ($notracking) ) or (!$notracking) ){
          &trackcodelet ($myli, $myli, $Awfif::memes-> {snnh} {telomere}, undef(), $ati, $Awfif::codelet-> {l} [$myli] [36]);
          };#if
        &setusalcwsocache ($ai, undef(), (($Awfif::memes-> {strbool}[$Awfif::memes-> {streh} {tdgroup}]) | $Awfif::memes-> {strbool}[$Awfif::memes-> {streh} {bugroup}] | $Awfif::memes-> {strbool}[$Awfif::memes-> {streh} {delta}]), undef());
        $Awfif::wsol-> {l} [$ai][2]
          = inccounter (
            undef (),
            undef (),
            $Awfif::memes-> {snnh} {amplify},
            $Awfif::wsol-> {l} [$ai] [2],
            $ai,
            undef(),
            undef(),
            undef(),
            $ltransmgrid,
            $patelhwso,
            $activec);
# notgcusepoolu1

        if ((defined ($usepooling))
        && ($usepooling)
        && ($Awfif::codelet-> {l} [$myli] [38] > 1)
        ){

          my ($counteri);
          if (findcounter ($Awfif::wsol-> {l} [$ai] [2], $Awfif::memes-> {snnh}{amplify}, \$counteri) ){

            $Awfif::workspace-> {l} [$counteri] [9] += $Awfif::codelet-> {l} [$myli] [38];
            $reset38 = 't';
            };#if
          };#if
        &isetupdescc ($ai);
        &actnodes ( wsbasetype ($gs), $Awfif::memes-> {actth} + 10, (($Awfif::memes-> {strbool}[$Awfif::memes-> {streh} {tdgroup}]) | $Awfif::memes-> {strbool}[$Awfif::memes-> {streh} {bugroup}] | $Awfif::memes-> {strbool}[$Awfif::memes-> {streh} {delta}]));
        &invcaches (wsbasetype ($gs), (($Awfif::memes-> {strbool}[$Awfif::memes-> {streh} {tdgroup}]) | $Awfif::memes-> {strbool}[$Awfif::memes-> {streh} {bugroup}] | $Awfif::memes-> {strbool}[$Awfif::memes-> {streh} {delta}]));
        if ( $Awfif::wsol-> {l}[$ai][ $Awfif::memes-> {wsogcsponsor}] != 0){#*** submacrok ***#

          my ($ngcsponsor);
          $ngcsponsor =
            $Awfif::wsol-> {l}[$ai][ $Awfif::memes-> {wsogcsponsor}]; #*** submacrok ***#

          if (($Awfif::memes-> {notgcngcspbreak}) && ($ngcsponsor != 0) && ($Awfif::memes-> {currentwsbi} == 3)) {&break ()};
          $Awfif::wsol-> {l}[$ai][ $Awfif::memes-> {wsogcsponsor}] = 0;#*** submacrok ***#
          };
        for ($i = trwsoadr ($gs, 1);
        $i != $ge; $i = trwsoadr ($i,1)
        ) {
# send activation to the involved Slipnet nodes but this should just be a delta scope

          $ai = awsoadr ($i);
          &setusalcwsocache ($ai, undef(), (($Awfif::memes-> {strbool}[$Awfif::memes-> {streh} {tdgroup}]) | $Awfif::memes-> {strbool}[$Awfif::memes-> {streh} {bugroup}] | $Awfif::memes-> {strbool}[$Awfif::memes-> {streh} {delta}]), undef());
          $Awfif::wsol-> {l} [$ai][2]
            = inccounter (
              undef (),
              undef (),
              $Awfif::memes-> {snnh} {amplify},
              $Awfif::wsol-> {l} [$ai] [2],
              $ai);
# notgcusepoolu2

          if ((defined ($usepooling))
          && ($usepooling)
          && ($Awfif::codelet-> {l} [$myli] [38] > 1)
          ){

            my ($counteri);
            if (findcounter ($Awfif::wsol-> {l} [$ai] [2], $Awfif::memes-> {snnh}{amplify}, \$counteri) ){

              $Awfif::workspace-> {l} [$counteri] [9] += $Awfif::codelet-> {l} [$myli] [38];
              };#if
            };#if
          &isetupdescc ($ai);
          &actnodes ( wsbasetype ($i), $Awfif::memes-> {actth} + 10, (($Awfif::memes-> {strbool}[$Awfif::memes-> {streh} {tdgroup}]) | $Awfif::memes-> {strbool}[$Awfif::memes-> {streh} {bugroup}] | $Awfif::memes-> {strbool}[$Awfif::memes-> {streh} {delta}]));
          &invcaches (wsbasetype ($i), (($Awfif::memes-> {strbool}[$Awfif::memes-> {streh} {tdgroup}]) | $Awfif::memes-> {strbool}[$Awfif::memes-> {streh} {bugroup}] | $Awfif::memes-> {strbool}[$Awfif::memes-> {streh} {delta}]));
          if ( $Awfif::wsol-> {l}[$ai][ $Awfif::memes-> {wsogcsponsor}] != 0){#*** submacrok ***#

            my ($ngcsponsor);
            $ngcsponsor =
              $Awfif::wsol-> {l}[$ai][ $Awfif::memes-> {wsogcsponsor}]; #*** submacrok ***#

            if (($Awfif::memes-> {notgcngcspbreak}) && ($ngcsponsor != 0) && ($Awfif::memes-> {currentwsbi} == 3)) {&break ()};
            $Awfif::wsol-> {l}[$ai][ $Awfif::memes-> {wsogcsponsor}] = 0;#*** submacrok ***#
            };
          };#for
        if ($reset38) {

          $Awfif::codelet-> {l} [$myli] [38] = 1;#freecodelet should still do all the work when freeing this codelet
          };#if
        &isetupdescc (awsoadr ($ge));
        &actnodes ( wsbasetype ($ge), $Awfif::memes-> {actth} + 10, (($Awfif::memes-> {strbool}[$Awfif::memes-> {streh} {tdgroup}]) | $Awfif::memes-> {strbool}[$Awfif::memes-> {streh} {bugroup}] | $Awfif::memes-> {strbool}[$Awfif::memes-> {streh} {delta}]));
        &invcaches (wsbasetype ($ge), (($Awfif::memes-> {strbool}[$Awfif::memes-> {streh} {tdgroup}]) | $Awfif::memes-> {strbool}[$Awfif::memes-> {streh} {bugroup}] | $Awfif::memes-> {strbool}[$Awfif::memes-> {streh} {delta}]));
# notgcwscup
        &wsclinv (0, $Awfif::memes-> {currentwsbi}, $Awfif::memes-> {strbool}[$Awfif::memes-> {streh} {bugroup}] | $Awfif::memes-> {strbool}[$Awfif::memes-> {streh} {delta}]);# force the bottom-up group workspace cache to delta reset
        if ( $Awfif::wsol-> {l}[awsoadr ($ge)][ $Awfif::memes-> {wsogcsponsor}] != 0){#*** submacrok ***#

          my ($ngcsponsor);
          $ngcsponsor =
            $Awfif::wsol-> {l}[awsoadr ($ge)][ $Awfif::memes-> {wsogcsponsor}]; #*** submacrok ***#

          if (($Awfif::memes-> {notgcngcspbreak}) && ($ngcsponsor != 0) && ($Awfif::memes-> {currentwsbi} == 3)) {&break ()};
          $Awfif::wsol-> {l}[awsoadr ($ge)][ $Awfif::memes-> {wsogcsponsor}] = 0;#*** submacrok ***#
          };
        }#if
      elsif (($teltwso ne '') && ($teltwso != 0)) {
# send activation to the involved Slipnet nodes but this should just be a delta scope
# deploy an amplification descriptor in the real schema wsos
# notgctmgrampup2

        my ($i, $ai, $ltransmgrid, $patelhwso, $activec);
        if (($Awfif::codelet-> {l} [$myli] [37] > 0) && ($Awfif::codelet-> {l} [$myli] [36] > 0)) {

          $ltransmgrid = $Awfif::codelet-> {l} [$myli] [37];
          $patelhwso = awsoadr (trwsoadr ($gsoid, -1));
          $activec = 1;
          };#if

        $ai = awsoadr ($gsoid);
        &setusalcwsocache ($ai, undef(), (($Awfif::memes-> {allwsstr} ^ $Awfif::memes-> {strbool}[$Awfif::memes-> {streh} {bustatement}]) | $Awfif::memes-> {strbool}[$Awfif::memes-> {streh} {delta}]), undef());
        if ((!defined ($dontamp)) or ((defined ($dontamp)) && (!$dontamp))) {

          $Awfif::wsol-> {l} [$ai][2]
            = inccounter (
              undef (),
              undef (),
              $Awfif::memes-> {snnh} {amplify},
              $Awfif::wsol-> {l} [$ai] [2],
              $ai,
              undef(),
              undef(),
              undef(),
              $ltransmgrid,
              $patelhwso,
              $activec);
          };#if

        my ($ngcsponsor);
        $ngcsponsor =
          $Awfif::wsol-> {l}[$ai][ $Awfif::memes-> {wsogcsponsor}]; #*** submacrok ***#

        if (($Awfif::memes-> {notgcngcspbreak}) && ($ngcsponsor != 0) && ($Awfif::memes-> {currentwsbi} == 3)) {&break ()};
        $Awfif::wsol-> {l}[$ai][ $Awfif::memes-> {wsogcsponsor}] = 0;#*** submacrok ***#
        for ($i = trwsoadr ($gsoid, 1);
        $i != $teltwso;
        $i = trwsoadr ($i,1)) {
# send activation to the involved Slipnet nodes but this should just be a delta scope
# deploy an amplification descriptor in the real schema wsos

          $ai = awsoadr ($i);
          &setusalcwsocache ($ai, undef(), (($Awfif::memes-> {allwsstr} ^ $Awfif::memes-> {strbool}[$Awfif::memes-> {streh} {bustatement}]) | $Awfif::memes-> {strbool}[$Awfif::memes-> {streh} {delta}]), undef());
          if ((!defined ($dontamp)) or ((defined ($dontamp)) && (!$dontamp))) {

            $Awfif::wsol-> {l} [$ai][2]
              = inccounter (
                undef (),
                undef (),
                $Awfif::memes-> {snnh} {amplify},
                $Awfif::wsol-> {l} [$ai] [2],
                $ai);
            };#if
          $ngcsponsor =
            $Awfif::wsol-> {l}[$ai][ $Awfif::memes-> {wsogcsponsor}]; #*** submacrok ***#

          if (($Awfif::memes-> {notgcngcspbreak}) && ($ngcsponsor != 0) && ($Awfif::memes-> {currentwsbi} == 3)) {&break ()};
          $Awfif::wsol-> {l}[$ai][ $Awfif::memes-> {wsogcsponsor}] = 0;#*** submacrok ***#
          };#for
        }#elsif
      else {

        &break ();#should not get this situation
        };#else
      };#if did not reach threshold

    $Awfif::memes-> {currentwsbi} = $cwsbi;
    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("notgcompletedx ret ($found)\n");
      };

    return ($found)
    }# notgcompleted
#<!-- end tag uts -->
#<!-- start tag scc -->
#<!-- start tag ctr -->
#
sub subpstate {
    my($subpid)=@_;
    my ($state, $i, $ftransid, $fi);

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("subpstate ");
      };
# return the current aggregate state if this is a subprogram schemata

    $state = $Awfif::memes-> {snnh} {incomplete};
    if (($subpid > 0)
    && (defined ($Awfif::subpl-> {l} [$subpid] [11][0]))
    ) {

      my ($incomplete);
      $incomplete = '';
      for ($i = 1; ((!$incomplete) && ($i <= $Awfif::tral-> {i}[$Awfif::subpl-> {l} [$subpid] [11][$Awfif::subpl-> {l} [$subpid] [11][0]]] [0])); $i++) {

        $ftransid = checksameas (undef(), $Awfif::subpl-> {l} [$subpid] [11][$Awfif::subpl-> {l} [$subpid] [11][0]], $i, \$fi);
        if ($Awfif::tral-> {w}[$ftransid] [$fi] == $Awfif::memes-> {snnh} {incomplete}) {
          $incomplete = 't';
          };#if
        };#for
      if (!$incomplete) {

        $state = $Awfif::memes-> {snnh} {completed};
        };#if
      };#if

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      my ($pr);
      $pr = $Awfif::memes-> {snnih} {$state};
      print ("subpstatex ret $pr($state)\n");
      };

    return ($state)
    }# subpstate
#
#<!-- start tag sia -->
#
sub subtrancomp {
    my($myli, $subp11i)=@_;
    my ($state, $i, $subpid, $ftransid, $fi);

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("subtrancomp subp11i($subp11i) ");
      };
# return true if this sub-transaction is completed
    if (($Awfif::codelet-> {l} [$myli] [36] > 0)
    && ($subp11i > 0)
    ){

      $subpid = $Awfif::codelet-> {l} [$myli] [36];
      $state = 't';
      for ($i = 1; $i <= $Awfif::tral-> {i}[$Awfif::subpl-> {l} [$subpid] [11][$subp11i] ] [0]; $i++) {

        $ftransid = checksameas (undef(), $Awfif::subpl-> {l} [$subpid] [11][$subp11i], $i, \$fi);
        if ($Awfif::tral-> {w}[$ftransid] [$fi] == $Awfif::memes-> {snnh} {incomplete}) {

          $state = '';
          };#if
        };#for
      }#if
    else {

      $state = '';
      };
    if (($Awfif::memes-> {subtrancfoundbreak}) && ($state)) {

      &break ();
      };#if

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("subtrancompx ret ($state)\n");
      };

    return ($state)
    }# subtrancomp
#
#<!-- end tag sia -->
#
sub mysubtrancomp {
    my($myli, $subp11i, $iprocname)=@_;
    my ($state, $i, $subpid, $procname);

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("subtrancomp subp11i $subp11i ");
      if (defined ($iprocname)){
        print ("iprocname $iprocname ");
        };#if
      };
    if ( ($subp11i > 0)
    ){
# return true if this sub-transaction matching part is completed

      $procname = setupprocname ($myli, $iprocname);
      $subpid = $Awfif::codelet-> {l} [$myli] [36];
      $state = 't';
      for ($i = 1; $i <= $Awfif::tral-> {i}[$Awfif::subpl-> {l} [$subpid] [11][$subp11i] ] [0]; $i++) {

        if ( ($Awfif::tral-> {i}[$Awfif::subpl-> {l} [$subpid] [11][$subp11i] ] [$i] eq $procname)
        && (($Awfif::tral-> {w}[$Awfif::subpl-> {l} [$subpid] [11][$subp11i] ] [$i] == $Awfif::memes-> {snnh} {incomplete})
        or ($Awfif::tral-> {w}[$Awfif::subpl-> {l} [$subpid] [11][$subp11i] ] [$i] == $Awfif::memes-> {snnh} {terminated}) )
        ){

          $state = '';
          };#if
        };#for
      }#if
    else {

      $state = '';
      };#else

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("subtrancompx ret ($state)\n");
      };

    return ($state)
    }# mysubtrancomp
#
sub tralcomp {#part of subtrancomp
    my($myli, $transid)=@_;
    my ($state, $i, $ftransid, $fi);

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("tralcomp transid $transid ");
      };
# return true if this sub-transaction is completed
    if ( ($transid > 0)
    ){

      $state = 't';
      for ($i = 1; (($state) && ($i <= $Awfif::tral-> {i}[$transid ] [0])); $i++) {

        $ftransid = checksameas ($myli, $transid, $i, \$fi);
        if (($Awfif::tral-> {w}[$ftransid ] [$fi] == $Awfif::memes-> {snnh} {incomplete})
        or ($Awfif::tral-> {w}[$ftransid ] [$fi] == $Awfif::memes-> {snnh} {terminated})
        ) {

          $state = '';
          };#if
        };#for
      }#if
    else {

      $state = '';
      };#else

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("tralcompx ret ($state)\n");
      };

    return ($state)
    }# tralcomp
#
sub notralitemcomp {#
    my($myli, $transid)=@_;
    my ($state, $i, $ftransid, $fi);

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("notralitemcomp transid $transid ");
      };
# return true if this sub-transaction has no item completed
    if ( ($transid > 0)
    ){

      $state = 't';
      for ($i = 1; (($state) && ($i <= $Awfif::tral-> {i}[$transid ] [0])); $i++) {

        $ftransid = checksameas ($myli, $transid, $i, \$fi);
        if ($Awfif::tral-> {w}[$ftransid ] [$fi] == $Awfif::memes-> {snnh} {completed}) {

          $state = '';
          };#if
        };#for
      }#if
    else {

      $state = '';
      };#else

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("notralitemcompx ret ($state)\n");
      };

    return ($state)
    }# notralitemcomp
#
#<!-- end tag ctr -->
#
sub trackcodelet {#
    my($myli, $newli, $function, $freemode, $ati, $subpid, $clp)=@_;
    my ($cwsbi);

    if ($Awfif::memes-> {trackcactive}) {
      if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
        my ($pr);
        $pr = $Awfif::memes-> {snnih} {$function};
        print ("trackcodelet myli $myli newli($newli) function($pr) free mode($freemode) ati($ati) subpid($subpid) ");
        if (defined ($clp->{action}->{subpi})) {

          print ("clpsubpi($clp->{action}->{subpi}) ");
          };#if
        };
      $cwsbi = $Awfif::memes-> {currentwsbi};
# keep track of codelets through their life time
      if ($function == $Awfif::memes-> {snnh} {add}) {

        if (($Awfif::codelet-> {l} [$myli] [21] > 0)
        && ($Awfif::codelet-> {l} [$myli] [19] > 0)
        ){

          $Awfif::memes-> {currentwsbi} = $Awfif::codelet-> {l} [$myli] [19];
          $Awfif::clet-> {assoc}-> {$newli} = awsoadr ($Awfif::codelet-> {l} [$myli] [21]);
          $Awfif::cletassocc [$Awfif::clet-> {assoc}-> {$newli}]++;
          };#if
        }#if
      elsif ($function == $Awfif::memes-> {snnh} {assocf1}){#codelet is regenerating

        $Awfif::clet-> {assoc}-> {$newli} = $Awfif::clet-> {assoc}-> {$myli};
        $Awfif::cletassocc [$Awfif::clet-> {assoc}-> {$newli}]++;
        }#elsif
      elsif ($function == $Awfif::memes-> {snnh} {telomere}){#converts codelet to schematic address

        if ((defined ($ati)) && ($ati > 0) ){

          $Awfif::clet-> {assocsa}-> {$ati} = $Awfif::clet-> {assoc}-> {$myli};
          };#if
        }#elsif
      elsif ($function == $Awfif::memes-> {snnh} {group}){#groupcomplete converts back to codelet

        if ((defined ($ati)) && ($ati > 0) ){#need to check this association It is possible that there could be > 1 original sponsor to associate

          $Awfif::clet-> {assoc}-> {$newli} = $Awfif::clet-> {assocsa}-> {$ati};
          $Awfif::cletassocc [$Awfif::clet-> {assoc}-> {$newli}]++;
          };#if
        }#elsif
      elsif ($function == $Awfif::memes-> {snnh} {free}){#releases the codelet. It better have actioned

        $Awfif::memes-> {currentwsbi} = $Awfif::codelet-> {l} [$myli] [20];
        if (defined ($Awfif::clet-> {assoc}-> {$myli})) {

          my ($sws, $wso, $csdesc);
          $sws = checkwsmd ($Awfif::clet-> {assoc}-> {$myli}, $Awfif::memes-> {wsowsi});
          if ($sws != $Awfif::memes-> {currentwsbi}){

            $Awfif::memes-> {currentwsbi} = $sws;
            $wso = grwsoadr ($Awfif::clet-> {assoc}-> {$myli});
            $Awfif::memes-> {currentwsbi} = $Awfif::codelet-> {l} [$myli] [20];
            }#if
          else {

            $wso = grwsoadr ($Awfif::clet-> {assoc}-> {$myli});
            };#else
          $csdesc = findtdesc ($Awfif::wsol-> {l} [$Awfif::clet-> {assoc}-> {$myli}][2], $Awfif::memes-> {snnh}{cassponsor});#watchout this is a special use of findmdesc - groupstart does not conform in general to the setupmdesc framework. Its part of inccounter framework
          if (($freemode != 1)
          && ($Awfif::memes-> {trackcf1break})
          && (checkgcstate ($sws, $wso, $wso))#sponsor is group completed
          && (($csdesc == 0)#not cassponsor
            or (($Awfif::workspace-> {l} [$csdesc] [2] - $Awfif::memes-> {snnh} {wsi}) == 0) )
          && (!tcsponsored ($myli))
          && ($Awfif::cletassocc [$Awfif::clet-> {assoc}-> {$myli}] <= 1)
          ){#this codelet has not been run

            &break ();
            };#if

          $Awfif::cletassocc [$Awfif::clet-> {assoc}-> {$myli}]--;
          $Awfif::clet-> {assoc}-> {$myli} = undef ();
          };#if
        }#elsif
      else {#invalid function value

        &break ();
        };#else
      $Awfif::memes-> {currentwsbi} = $cwsbi;

      if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
        print ("trackcodeletx \n");
        };
      };#if track codelet active

    }# trackcodelet
#
sub tcsponsored {#
    my($myli)=@_;
    my ($cwsbi, $result, @sponsored);

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("tcsponsored myli $myli ");
      };

    $cwsbi = $Awfif::memes-> {currentwsbi};
# report if this sponsor is supported by a cascade sponsor
    $sponsored [++$sponsored [0] ] = 'crsmbuilder';#crsm codelet is cascaded by bcsubps codelet
    $sponsored [++$sponsored [0] ] = 'bcsubpcbuilder';#bcsubpc codelet is cascaded by bcsubps codelet
    $sponsored [++$sponsored [0] ] = 'ivalwbuilder';#ivalw codelet is cascaded by bcsubps codelet
    if (($Awfif::codelet-> {l} [$myli] [35] > 0)
    && (matchsaelement (\@sponsored, $Awfif::tral-> {l} [$Awfif::codelet-> {l} [$myli] [35]] [3]) != 0)
    ){

      $result = 't';
      }#if
    else {

      $result = '';
      };#else
    $Awfif::memes-> {currentwsbi} = $cwsbi;

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("tcsponsoredx ret ($result)\n");
      };
    return $result

    }# tcsponsored
#
#<!-- start tag inh -resweb -->
#
sub ictficomp {#check if transcription factor inhibition is complete
    my($myli, $jhlsi, $kwp, $kwpr, $sactset, $found, $factor, $e2ftwso, $pws)=@_;
    my ($continue, $ilinkp, $linkp, $cwsbi);

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("ictficomp ");
      &itjhloutput ($jhlsi);
      };

    $cwsbi = $Awfif::memes-> {currentwsbi};
    $continue = 't';
    if ((defined ($Awfif::jhls-> {l} [$jhlsi][17])) && ($Awfif::jhls-> {l} [$jhlsi][17] != 0)) {

      $continue = '';
# in this case only continue if find the descriptor we are interested in
      my ($bcount, $sigcount, $icpt, $pdcawso, @lomatchs, @lola, @loconcs, @lostrts, @loends, @logb, @loge, $stwso);
      $bcount = ifindb ($myli, undef (), 'pdcab', \$sigcount, \@lomatchs, \@lola, \@loconcs, \@lostrts, \@loends, \@logb, \@loge, $kwp, $kwpr, \@$sactset);
      $pdcawso = getfbws ($myli, $sigcount, \@lomatchs, \@lola, \$$pws);
# find the inhibitor binding and check if there is an a cyclin generated inhibitor
      if ($bcount == 1) {
# now look at the transcription factor sub structure

        $bcount = ifindb ($myli, $stwso, 'tfactorb', \$sigcount, \@lomatchs, \@lola, \@loconcs, \@lostrts, \@loends, \@logb, \@loge, $kwp, $kwpr, \@$sactset, $$pws);
        $$e2ftwso = getstsbws ($myli, $sigcount, \@lomatchs, \@lola, $$pws);
        if ($bcount == 1) {#check for the a cyclin generated inhibitory descriptor

          $ilinkp = $Awfif::jhls-> {l} [$jhlsi][17];
          $$found = '';
          while (($ilinkp != 0) && (!$$found)) {

            $icpt = $Awfif::trfl-> {l} [$ilinkp] [2];
            $linkp = $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$icpt];

            while (($linkp != 0) && (!$$found)) {
              if (($Awfif::slipnet-> {l}[$linkp][3] == $Awfif::memes-> {snnh}{factor})
              && (defined($Awfif::memes-> {binds}-> {$Awfif::memes->{snnih}{$Awfif::slipnet-> {l} [$linkp][2]}}))) {#

                $$found = 't';
                $$factor = $Awfif::slipnet-> {l} [$linkp][2];
                }
              $linkp = $Awfif::slipnet-> {l} [$linkp] [0];
              };#while

            $ilinkp = $Awfif::trfl-> {l} [$ilinkp] [0];
            };#while

          if ($$found) {

            my ($ae2ftwso, $aid, $counteri);
            $Awfif::memes-> {currentwsbi} = $$pws;
            $ae2ftwso = awsoadr ($$e2ftwso);
            if ( (($aid = findcounter ($Awfif::wsol-> {l} [$ae2ftwso][2], ($Awfif::memes-> {snnh} {tfactor}), \$counteri, $Awfif::memes-> {snnh} {$$factor})))
            ){#found descriptor

              $continue = 't';
              };#if
            };#if
          };#if
        };#if
      };#if
    $Awfif::memes-> {currentwsbi} = $cwsbi;
    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("ictficompx found($$found) factor($$factor) e2ftwso($$e2ftwso) pws($$pws) ret ($continue)\n");
      };

    return ($continue)
    }# ictficomp
#<!-- end tag inh -->
#<!-- end tag scs -->
#<!-- end tag gc -->
#<!-- end tag sia -->
#<!-- end tag cr -->
#<!-- start tag sir -->
#
sub ctcicomp {
    my($myli, $sactset, $type, $rwso, $rws, $strategy)=@_;
    my ($result, $cwsbi, $counteri);

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("ctcicomp ");
      };

    $cwsbi = $Awfif::memes-> {currentwsbi};
    $result = $Awfif::memes-> {snnh}{act};#proceed with local action

# in this case only continue if find the descriptor we are interested in
    my ($bcount, $sigcount, $receptorhwso, @lomatchs, @lola, @loconcs, @lostrts, @loends, @logb, @loge, $stwso);
    $bcount = ifindb ($myli, undef (), 'receptorh', \$sigcount, \@lomatchs, \@lola, \@loconcs, \@lostrts, \@loends, \@logb, \@loge, undef (), undef (), \@$sactset);
    $receptorhwso = getfbws ($myli, $sigcount, \@lomatchs, \@lola, \$$rws);
# find the receptor buffer binding and check if there is modeled descriptor
    if ($bcount >= 1) {
# now look at the receptor sub structure

      $bcount = ifindb ($myli, $stwso, $strategy, \$sigcount, \@lomatchs, \@lola, \@loconcs, \@lostrts, \@loends, \@logb, \@loge, undef (), undef (), \@$sactset, $$rws);
      $$rwso = getstsbws ($myli, $sigcount, \@lomatchs, \@lola, $$rws);
      if ($bcount == 1) {#check for the receptor generated inhibitory descriptor

        $Awfif::memes-> {currentwsbi} = $$rws;
        if ( ((findcounter ($Awfif::wsol-> {l} [ (awsoadr ($$rwso)) ] [2], $Awfif::memes-> {snnh} {signal}, \$counteri, $Awfif::memes-> {snnh}{act}, $type )) )
        or ((findcounter ($Awfif::wsol-> {l} [ (awsoadr ($$rwso)) ] [2], $Awfif::memes-> {snnh} {signal}, \$counteri, $Awfif::memes-> {snnh}{signal}, $type )) )
        ) {

          $result = ($Awfif::workspace-> {l} [$counteri] [2] - $Awfif::memes-> {snnh} {wsi});#proceed with buffered action signal or act
          }#if
        else {#there is no counter yet

          $result = $Awfif::memes-> {snnh} {signal};#signal the cascade
          };#else continue to signal
        };#if
      };#if
    $Awfif::memes-> {currentwsbi} = $cwsbi;
    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      my ($pr);
      $pr = $Awfif::memes-> {snnih} {$result};
      print ("ctcicompx rwso($$rwso) rws($$rws) ret ($result:$pr)\n");
      };

    return ($result)
    }# ctcicomp
#<!-- end tag sir -->
#
sub countdset {
    my($structure, $supcount, $aidwso)=@_;
    my ($continue, $structpresent, $linki, );

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("countdset supcount $supcount aidwso ");
      &itwsoloutput ($aidwso);
      };

    $continue = '';
    $structpresent = 0;
    $linki = $Awfif::wsol-> {l} [$aidwso][2];
    while (($linki != 0) && (!$continue)) {
      if (($Awfif::workspace-> {l} [$linki] [4] == $structure)
      ){

        $structpresent++;
        if ($structpresent >= $supcount) {

          $continue = 't';
          };#if
        };#if
      $linki = $Awfif::workspace-> {l} [$linki] [0];
      };#while
    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("countdsetx ret ($continue)\n");
      };

    return ($continue)
    }# countdset
#
sub depcdesc {
    my($myli, $stwso, $waitoneval, $sactset)=@_;
    my ($cwsi, $kwp, $kwpr);

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("depcdesc myli $myli stwso($stwso) ");
      if (defined ($waitoneval)) {
        my ($pr);
        $pr = $Awfif::memes-> {snnih}{$waitoneval};
        print ("waitoneval ($pr($waitoneval)) ");
        };#if
      };
    $cwsi = $Awfif::memes-> {currentwsbi};# to later restore current state
# from the wso can look up its primary description in the meta schema

    my ($e2ftwso, $ae2ftwso, $pws);
    my ($bcount, $sigcount, @lomatchs, @lola, @loconcs, @lostrts, @loends, @logb, @loge);
    if (defined($waitoneval)){
      $bcount = ifindb ($myli, $stwso, 'pdcab', \$sigcount, \@lomatchs, \@lola, \@loconcs, \@lostrts, \@loends, \@logb, \@loge, $kwp, $kwpr, \@$sactset);
      &getfbws ($myli, $sigcount, \@lomatchs, \@lola, \$pws);
      $bcount = ifindb ($myli, $stwso, 'e2finhibb', \$sigcount, \@lomatchs, \@lola, \@loconcs, \@lostrts, \@loends, \@logb, \@loge, $kwp, $kwpr, \@$sactset, $pws);
      $e2ftwso = getstsbws ($myli, $sigcount, \@lomatchs, \@lola, $pws);
      $Awfif::memes-> {currentwsbi} = $pws;
      $ae2ftwso = awsoadr ($e2ftwso);
      $Awfif::wsol-> {l} [$ae2ftwso][2]
      = inccounter ( $waitoneval, #pltype
          ($Awfif::memes-> {snnh} {wsi} + $Awfif::memes-> {snnh} {completed}), #pto
          $Awfif::memes-> {snnh} {model}, #from
          $Awfif::wsol-> {l} [$ae2ftwso] [2],#dlinkh
          $ae2ftwso,#awso
          't',#synccod
          $waitoneval,#sltype
          $Awfif::memes-> {snnh} {completed});#spto
      };#if
    $Awfif::memes-> {currentwsbi} = $cwsi;

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("depcdescx \n");
      };
    }# depcdesc
#
#<!-- start tag sca -->
#
sub depwardesc {
    my($myli, $stwso, $strategy, $sactset)=@_;
    my ($cwsi, $kwp, $kwpr);

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("depwardesc myli $myli stwso($stwso) ");
      if (defined ($strategy)) {
        print ("strategy ($strategy) ");
        };#if
      };
    $cwsi = $Awfif::memes-> {currentwsbi};# to later restore current state
# from the wso can look up its primary description in the meta schema

    my ($warwso, $awarwso, $warws);
    my ($bcount, $sigcount, @lomatchs, @lola, @loconcs, @lostrts, @loends, @logb, @loge);
    if (defined($strategy)){
      $bcount = ifindb ($myli, $stwso, 'warb', \$sigcount, \@lomatchs, \@lola, \@loconcs, \@lostrts, \@loends, \@logb, \@loge, $kwp, $kwpr, \@$sactset);
      &getfbws ($myli, $sigcount, \@lomatchs, \@lola, \$warws);
      $bcount = ifindb ($myli, $stwso, $strategy, \$sigcount, \@lomatchs, \@lola, \@loconcs, \@lostrts, \@loends, \@logb, \@loge, $kwp, $kwpr, \@$sactset, $warws);
      $warwso = getstsbws ($myli, $sigcount, \@lomatchs, \@lola, $warws);
      $Awfif::memes-> {currentwsbi} = $warws;
      $awarwso = awsoadr ($warwso);
      $Awfif::wsol-> {l} [$awarwso][2]
      = inccounter ( $Awfif::memes-> {snnh} {waitarelay},
          ($Awfif::memes-> {snnh} {wsi} + $Awfif::memes-> {snnh} {completed}), #lets start with one
          $Awfif::memes-> {snnh} {model},
          $Awfif::wsol-> {l} [$awarwso] [2],
          $awarwso,
          't',
          $Awfif::memes-> {snnh} {waitarelay},
          $Awfif::memes-> {snnh} {completed});
      };#if
    $Awfif::memes-> {currentwsbi} = $cwsi;

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("depwardescx \n");
      };
    }# depwardesc
#
#<!-- end tag sca -->
#
sub getnamefqpair {
    my($myli, $sldesc, $stnws, $stnwsoid, $stayinplace)=@_;
    my ($stname, $nwsoid, $tws, $cwsi, $char, $wsotype, $endquote);
# having been called look along the application workspace for a quote and then capture the name until further quote
# The position descriptors wso will be provided so that end of workspace can be described

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("getnamefqpair myli $myli sldesc $sldesc ");
      if (defined ($stayinplace) ){
        print ("stayinplace($stayinplace) ");
        };#if
      };
    $cwsi = $Awfif::memes-> {currentwsbi};# to later restore current state
    $stname = '';
    $$stnws = 0;
    $$stnwsoid = 0;
    $wsotype = 0;
# move along the workspace looking for a quoted string

    $nwsoid = ($Awfif::workspace-> {l} [$sldesc] [2] - $Awfif::memes-> {snnh} {wsi});
    $tws = ($Awfif::workspace-> {l} [$sldesc] [3] - $Awfif::memes-> {snnh} {wsi});
    $Awfif::memes-> {currentwsbi} = $tws;
    $nwsoid = trwsoadr ($nwsoid, 1);
    while (
    ($nwsoid != 0)
    && (($wsotype = wsbasetype ($nwsoid)) == $Awfif::memes-> {snnh} {char})
    && (($char = getwsost4 ($nwsoid)) ne '"')
    && ($char ne '\'')
    && ($char ne '<rhldq>')
    && ($char ne '<rhlsq>')
      ){ #get next wso

      $nwsoid = trwsoadr ($nwsoid, 1);
      };#
    if ($wsotype == $Awfif::memes-> {snnh} {char}) {#got some sort of quote

      $endquote = $char;
      $$stnws = $tws;
      $$stnwsoid = $nwsoid;
      $nwsoid = trwsoadr ($nwsoid, 1);

      while (
      ($nwsoid != 0)
      && (($char = getwsost4 ($nwsoid)) ne $endquote)
      ){ #get next wso

        if (($wsotype = wsbasetype ($nwsoid)) == $Awfif::memes-> {snnh} {char}) {

          $stname .= $char;
          }#if
        else {#rebuild the string

          $stname = $stname . '<'. $char . '>';
          };#else
        $nwsoid = trwsoadr ($nwsoid, 1);
        };#collect name until end quote
# position the complex at the end quote
      if ( (!defined ($stayinplace))
      or ( (defined ($stayinplace)) && (!$stayinplace))
      ){
        $Awfif::workspace-> {l} [$sldesc] [2] = $nwsoid + $Awfif::memes-> {snnh}{wsi};
        };#if move
      };#process the name

    $Awfif::memes-> {currentwsbi} = $cwsi;
    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("getnamefqpairx stnws $$stnws stnwsoid $$stnwsoid ret ($stname)\n");
      };
    return $stname
    }# getnamefqpair
#
sub warfindops {
    my($myli, $stwso, $warws, $warbwso, $sactset)=@_;
    my ($cwsi, $i, $bcount, @result);
# generate a list of wait requesters.

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("warfindops myli $myli stwso($stwso) ");
      };
    $cwsi = $Awfif::memes-> {currentwsbi};# to later restore current state

    my ($sigcount, @lomatchs, @lola, @loconcs, @lostrts, @loends, @logb, @loge);
    $bcount = ifindb ($myli, $stwso, 'warb', \$sigcount, \@lomatchs, \@lola, \@loconcs, \@lostrts, \@loends, \@logb, \@loge, undef(), undef(), \@$sactset);
    $$warbwso = getfbws ($myli, $sigcount, \@lomatchs, \@lola, \$$warws);
# find the transcription factor binding
    if ($bcount >= 1) {

      $bcount = ifindb ($myli, $stwso, 'warasb', \$sigcount, \@lomatchs, \@lola, \@loconcs, \@lostrts, \@loends, \@logb, \@loge, undef(), undef(), \@$sactset, $$warws, undef (), undef (), 't', 't');
      $result[0] = 0;

      for ($i = 0; (($i < $sigcount)) ; $i++) {

        if ($lomatchs[$i]) {

          if (( ($Awfif::jhls-> {l} [$lola[$i]][4] == $Awfif::memes-> {snnh}{stbinding})
          && ($Awfif::jhls-> {l} [$lola[$i]][7] == $$warws)
          && ($Awfif::jhls-> {l} [$lola[$i]][8] != $$warbwso) )#exclude the wait and relay workspace operon
          && (matchaelement (\@result, $Awfif::jhls-> {l} [$lola[$i]] [8]) == 0) # its not already deployed to this subpid
          ){

            $result [++$result[0]] = $Awfif::jhls-> {l} [$lola[$i]] [8];
            };#if
          };#if
        };#for
      $Awfif::memes-> {currentwsbi} = $$warws;
      };#if

    $Awfif::memes-> {currentwsbi} = $cwsi;
    if (!defined ($Awfif::memes-> {currentwsbi})) {&break()};
    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("warfindopsx warws($$warws) warbwso($$warbwso) ");
      print ("ret ($result[0])\n");
      };
    return @result
    }# warfindops
#
sub addsubpscdef {
# setup the structures to support linked details of subps deferred codelets
    my ($myli, $codeletdef, $slinkh) = @_;# must be the subpscdef head's index for this structure list or 0
    my ($nslinkh);
#
# checked for merged workspaces

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("addsubpscdef ");
      if ( (defined ($myli)) ){
        print ("myli $myli ");
        };#if
      print ("slink $slinkh ");
      };
    $nslinkh = addhli ($slinkh, \$Awfif::subpscdefl);

    if ($nslinkh == $Awfif::subpscdefl-> {f}) {&break();};
# setup the links data

    $Awfif::subpscdefl-> {l} [$nslinkh][2] = $codeletdef;

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("addsubpscdefx ret $nslinkh\n");
      };

    return $nslinkh
    }# addsubpscdef
#
sub freesubpscdef {
    my ($myli, $subpid, $head, $abcwso) = @_;
#
# checked for merged workspaces

# move the codelet datastructure to the inactive list
    my ($lnk, $plink, $found);
    $lnk = $head;
    $plink = $head;
    $found = 0;

    while (($lnk != 0) && ($found == 0)) {
      if (($Awfif::codelet-> {l} [$Awfif::subpscdefl-> {l} [$lnk] [2]] [36] == $subpid)
      && (inapplycodelet ($myli, $abcwso) != 2)#not in apply since if am then will not be the subpscdef codelet
      ){

        $found = $lnk;
        if ($myli != $Awfif::subpscdefl-> {l} [$lnk] [2]) {&break()};#freeing the deferred codelet but have not run it!
        };#if
      $lnk = $Awfif::subpscdefl-> {l} [$lnk] [0];
      };#while

    if ($found != 0){

      if ($found == $head){

        $plink = freehli ($found, \$Awfif::subpscdefl);
        }#if
      else {

        &freehli ($found, \$Awfif::subpscdefl);
        };#else
      $Awfif::subpscdefl-> {l} [$found] [2] = 0;
      };#if
    return $plink
    }#freesubpscdef
#
#<!-- start tag vbt -->
#<!-- start tag phe -->
#
sub addwfcdef {
# setup the structures to support linked details of vbot wf deferred codelets
    my ($myli, $codeletdef, $slinkh) = @_;# must be the subpscdef head's index for this structure list or 0
    my ($nslinkh);
#
# checked for merged workspaces

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("addwfcdef ");
      if ( (defined ($myli)) ){
        print ("myli $myli ");
        };#if
      print ("slink $slinkh ");
      };
    $nslinkh = addhli ($slinkh, \$Awfif::wfcdefl);

    if ($nslinkh == $Awfif::wfcdefl-> {f}) {&break();};
# setup the links data

    $Awfif::wfcdefl-> {l} [$nslinkh][2] = $codeletdef;

    if (($Awfif::wfcdefl-> {hash} {$codeletdef})
    && ($Awfif::wfcdefl-> {l} [$Awfif::wfcdefl-> {hash} {$codeletdef}] [6])
    ){#remove any stale wfcdefl item still hanging around

      $Awfif::memes-> {wfcdef} = freewfcdef ($codeletdef, $Awfif::wfcdefl-> {hash} {$codeletdef}, $Awfif::memes-> {wfcdef});
      }#if
    elsif (($Awfif::wfcdefl-> {hash} {$codeletdef})
    ){#inconsistant item still using codeletdef

      &break ();
      };#elsif
    if ( (defined ($codeletdef))
    && ($codeletdef > 0)
    ){

      $Awfif::wfcdefl-> {hash} {$codeletdef} = $nslinkh;
      };#if

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("addwfcdefx ret $nslinkh\n");
      };

    return $nslinkh
    }# addwfcdef
#
sub freewfcdef {
    my ($codelet, $delid, $head) = @_;
#
# checked for merged workspaces

# move the wfcdef item to the inactive list
    my ($plink, $found, $name);
    $plink = $head;
    $found = $delid;

    if ($found != 0){

      $name = $Awfif::wfchchainl-> {l} [$Awfif::wfcdefl-> {l} [$found] [7]] [3];
      &freewfchchain ($Awfif::wfcdefl-> {l} [$found] [7]);
      if ($found == $head){

        $plink = freehli ($found, \$Awfif::wfcdefl);
        }#if
      else {

        &freehli ($found, \$Awfif::wfcdefl);
        };#else
      $Awfif::wfcdefl-> {l} [$found] [2] = 0;#codeletid
      $Awfif::wfcdefl-> {l} [$found] [3] = ();#direction
      $Awfif::wfcdefl-> {l} [$found] [4] = ();#desstate
      $Awfif::wfcdefl-> {l} [$found] [5] = ();#desname
      $Awfif::wfcdefl-> {l} [$found] [6] = ();#activated
      $Awfif::wfcdefl-> {l} [$found] [7] = ();#hchain element
      if ((defined ($codelet)) && ($Awfif::wfcdefl-> {hash} {$codelet} == $found)){

        $Awfif::wfcdefl-> {hash} {$codelet} = ();#linkid
        };#if
      if ($Awfif::wfcdefl-> {hashb} {$Awfif::wfcdefl-> {l} [$found] [8]} == $found){

        $Awfif::wfcdefl-> {hashb} {$Awfif::wfcdefl-> {l} [$found] [8]} = ();
        };#if
      $Awfif::wfcdefl-> {l} [$found] [8] = ();#builder id
      };#if
    return $plink
    }#freewfcdef
#
#<!-- end tag phe -->
#<!-- end tag vbt -->
#<!-- start tag al -resweb -->
#
sub addjhlch {
# setup the structures to support linked details of jhls concepts
    my ($jhlsid, $concept, $pconcept) = @_;# must be the jhlch head's index for this structure list or 0
    my ($nslinkh, $slinkh);
#
# Will add this jhlsid to the concept and pseudoconcept lists, and adjust the max and min if necessary. Hence using these lists as a filter only [p]concept matching jhls elements should be processed by msublabel

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("addjhlch ");
      print ("jhlsid $jhlsid ");
      };
    if ($Awfif::jhlchl-> {chash} {$concept}) {

      $slinkh = $Awfif::jhlchl-> {chash} {$concept};
      }#if
    else {

      $slinkh = 0;
      };#else
    $nslinkh = addhli ($slinkh, \$Awfif::jhlchl);
    if ($slinkh == 0){

      $Awfif::jhlchl-> {chasht} {$concept} = $nslinkh;
      };#if

    if ($nslinkh == $Awfif::jhlchl-> {f}) {&break();};
# setup the links data

    $Awfif::jhlchl-> {l} [$nslinkh] [2] = $jhlsid;
# update the max and min jhlsid values for this concept
    if ( ( (defined ($Awfif::jhlchl-> {jhclmax} {$concept}))
      && ($Awfif::jhlchl-> {jhclmax} {$concept} < $jhlsid) )
    or (!defined ($Awfif::jhlchl-> {jhclmax} {$concept}))
    ){

      $Awfif::jhlchl-> {jhclmax} {$concept} = $jhlsid;
      };#if
    if ( ( (defined ($Awfif::jhlchl-> {jhclmin} {$concept}))
      && ($Awfif::jhlchl-> {jhclmin} {$concept} > $jhlsid) )
    or (!defined ($Awfif::jhlchl-> {jhclmin} {$concept}))
    ){

      $Awfif::jhlchl-> {jhclmin} {$concept} = $jhlsid;
      };#if


    if ((!defined($Awfif::jhlchl-> {chash} {$concept}))
    or ($Awfif::jhlchl-> {l} [$Awfif::jhlchl-> {chash} {$concept}] [1] == $nslinkh)
    ) {#update the head pointer

      $Awfif::jhlchl-> {chash} {$concept} = $nslinkh;
      };
    if (($concept != $pconcept)
    ){

      if (($Awfif::jhlchl-> {pchash} {$pconcept})
      ){

        $slinkh = $Awfif::jhlchl-> {pchash} {$pconcept};
        }#if
      else {

        $slinkh = 0;
        };#else
      $nslinkh = addhli ($slinkh, \$Awfif::jhlchl);
      if ($slinkh == 0){

        $Awfif::jhlchl-> {pchasht} {$pconcept} = $nslinkh;
        };#if

      if ($nslinkh == $Awfif::jhlchl-> {f}) {&break();};
# setup the links data

      $Awfif::jhlchl-> {l} [$nslinkh] [2] = $jhlsid;
# update the max and min jhlsid values for this concept
      if ( ( (defined ($Awfif::jhlchl-> {jhpclmax} {$pconcept}))
        && ($Awfif::jhlchl-> {jhpclmax} {$pconcept} < $jhlsid) )
      or (!defined ($Awfif::jhlchl-> {jhpclmax} {$pconcept}))
      ){

        $Awfif::jhlchl-> {jhpclmax} {$pconcept} = $jhlsid;
        };#if
      if ( ( (defined ($Awfif::jhlchl-> {jhpclmin} {$pconcept}))
        && ($Awfif::jhlchl-> {jhpclmin} {$pconcept} > $jhlsid) )
      or (!defined ($Awfif::jhlchl-> {jhpclmin} {$pconcept}))
      ){

        $Awfif::jhlchl-> {jhpclmin} {$pconcept} = $jhlsid;
        };#if
      if ((!defined($Awfif::jhlchl-> {pchash} {$pconcept}))
      or ($Awfif::jhlchl-> {l} [$Awfif::jhlchl-> {pchash} {$pconcept}] [1] == $nslinkh)
      ) {#update the head pointer

        $Awfif::jhlchl-> {pchash} {$pconcept} = $nslinkh;
        };
      };#if

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("addjhlchx\n");
      };
    }# addjhlch
#
sub freejhlch {
    my ($head) = @_;
#
# checked for merged workspaces

# move the codelet datastructure to the inactive list
    my ($lnk, $plink, $found);
    $lnk = $head;
    $plink = $head;
    $found = 0;


    if ($found != 0){

      if ($found == $head){

        $plink = freehli ($found, \$Awfif::jhlchl);
        }#if
      else {

        &freehli ($found, \$Awfif::jhlchl);
        };#else
      $Awfif::jhlchl-> {l} [$found] [2] = 0;
      };#if
    return $plink
    }#freejhlch
#
sub iteratejhlch {
    my ($tmpi, $jhlslist, $jhlslcount, $state, $failed) = @_;
# if need to uncomment tracing then $failed will be referenced so it is left in the parameter block
    my ($nindex, $i4, $usestate3, $setstate3);
#
# This iterates over the set of jhlchl-> {l} elements with a matching concept, or pconcept and if the current [p]concepts jhlsid is in the jhlslist its jhlslist index (or -1) is returned in turn along with a controlling state update

# a tmpi (a concept or pconcept value) can generate 0, 1 or more i4 values (jhlslist index) as multiple jhls entries can have the same concept and/or pconcept
# call with a tmpi while $$state [0] is defined
# return the next $i4 while state indicates more to process
# if (($Awfif::memes-> {iteratejhlchbreak}) && (defined ($Awfif::jhlchl-> {pchash} {$tmpi})) && ($Awfif::jhlchl-> {pchash} {$tmpi} != $Awfif::jhlchl-> {pchasht} {$tmpi}) && (!defined ($$state[0]))) {&break();};
# if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
# my ($pr);
# print ("iteratejhlch ");
# $pr = $Awfif::memes-> {snnih} {$tmpi};
# print ("tmpi($pr($tmpi)) jhlslcount($jhlslcount) state(0($$state[0])1($$state[1])2($$state[2])3($$state[3]) failed($failed) ");
# $pr = $Awfif::jhlchl-> {chash} {$tmpi};
# print ("chash($pr) ");
# $pr = $Awfif::jhlchl-> {chasht} {$tmpi};
# print ("chasht($pr) ");
# $pr = $Awfif::jhlchl-> {jhclmax} {$tmpi};
# print ("jhclmax($pr) ");
# $pr = $Awfif::jhlchl-> {jhclmin} {$tmpi};
# print ("jhclmin($pr) ");
# $pr = $Awfif::jhlchl-> {l} [$pr] [2];
# print ("chasht-> jhls($pr) ");
# $pr = $Awfif::jhlchl-> {pchash} {$tmpi};
# print ("pchash($pr) ");
# $pr = $Awfif::jhlchl-> {pchasht} {$tmpi};
# print ("pchasht($pr) ");
# $pr = $Awfif::jhlchl-> {jhpclmax} {$tmpi};
# print ("jhpclmax($pr) ");
# $pr = $Awfif::jhlchl-> {jhpclmin} {$tmpi};
# print ("jhpclmin($pr) ");
# };
    $nindex = 0;
    if (!defined ($$state[0])
    && (defined ($Awfif::jhlchl-> {chasht} {$tmpi}))
    ){

      if ( !(($$jhlslist [0] > $Awfif::jhlchl-> {jhclmax} {$tmpi}) or ($$jhlslist [$jhlslcount - 1] < $Awfif::jhlchl-> {jhclmin} {$tmpi})) ){#worth searching as flitered list intersects with the max and min of our list for this [p]concept

        $$state[0] = 0;#state 0 indicates if using chash chain == 0 or pchash chain == 1 or not setup == undef
        $$state [1] = $Awfif::jhlchl-> {chasht} {$tmpi};#state 1 is the index of the jhlchl-> {l} item being used
        if ( (defined ($$state [2])) && ($$state [2] == $tmpi) && (defined ($$state [3]))){#state 2 is record of the $tmpi that state is based on

          $usestate3 = 't';#state 3 is the i4 value that is being returned It tries to cache the response of matchaelement
          }#if
        else {

          $$state [2] = $tmpi;
          $setstate3 = 't';
          $$state [3] = ();#until its set
          };#else
        }#if
      elsif ( (defined ($Awfif::jhlchl-> {pchasht} {$tmpi}))
      && ( !( ($$jhlslist [0] > $Awfif::jhlchl-> {jhpclmax} {$tmpi}) or ($$jhlslist [$jhlslcount - 1] < $Awfif::jhlchl-> {jhpclmin} {$tmpi}) ) )
      ){#not disjoint with pseudo concept list

        $$state [0] = 1;
        $$state [1] = $Awfif::jhlchl-> {pchasht} {$tmpi};
        if ( (defined ($$state [2])) && ($$state [2] == $tmpi) && (defined ($$state [3]))){#state 2 is record of the $tmpi that state is based on

          $usestate3 = 't';#state 3 is the i4 value that is being returned It tries to cache the response of matchaelement
          }#if
        else {

          $$state [2] = $tmpi;
          $setstate3 = 't';
          $$state [3] = ();#until its set
          };#else
        };#elsif were elements of filter list that could overlap with the pconcepts index list
      }#if
    elsif ($$state [0] == 0){#have been processing concept list

      if ( ($Awfif::jhlchl-> {l} [ $$state [1]] [1] == 0)#end of list
      && ($Awfif::jhlchl-> {pchasht} {$tmpi})
      && ( !( ($$jhlslist [0] > $Awfif::jhlchl-> {jhpclmax} {$tmpi}) or ($$jhlslist [$jhlslcount - 1] < $Awfif::jhlchl-> {jhpclmin} {$tmpi}) ) )
      ){#reached end of list but there is the other non disjointlist

        $$state [0] = 1;
        $$state [1] = $Awfif::jhlchl-> {pchasht} {$tmpi};
        }#if
      elsif ( ($Awfif::jhlchl-> {l} [ $$state [1]] [1] == 0)
      ){#reached end of pseudo list too

        $$state [0] = ();
        }#elsif
      else {

        $$state [1] = $Awfif::jhlchl-> {l} [ $$state [1]] [1];
        };#else
      }#elsif
    elsif ($$state [0] == 1){#have been processing pconcept list

      if ( ($Awfif::jhlchl-> {l} [ $$state [1]] [1] == 0)
      ){#reached end of pseudo list too

        $$state [0] = ();
        }#if
      else {

        $$state [1] = $Awfif::jhlchl-> {l} [ $$state [1]] [1];
        };#else
      }#elsif
    if ((defined ($$state [0]))
    ) {#processing a list

      if ( ($usestate3)
      && (defined ($i4 = $$state [3]))
      or (($i4 = matchaelement (\@$jhlslist, $Awfif::jhlchl-> {l} [$$state[1]] [2], $jhlslcount)) != -1)
      ){

        $nindex = $i4;
        if ($setstate3) {

          $$state [3] = $i4;
          };#if
        }#if
      elsif ($setstate3) {#no match for this tmpi
        $$state [3] = -1;
        if (($$state [0] == 1)
        && ($Awfif::jhlchl-> {l} [ $$state [1]] [1] == 0)
        or ( ($$state [0] == 0)
        && ($Awfif::jhlchl-> {l} [ $$state [1]] [1] == 0)
        && (!defined ($Awfif::jhlchl-> {pchasht} {$tmpi})) )
        ){

          $$state [0] = ();#terminate the state operation
          };#if
        }#elsif
      else {
        if (($$state [0] == 1)
        && ($Awfif::jhlchl-> {l} [ $$state [1]] [1] == 0)
        or ( ($$state [0] == 0)
        && ($Awfif::jhlchl-> {l} [ $$state [1]] [1] == 0)
        && (!defined ($Awfif::jhlchl-> {pchasht} {$tmpi})) )
        ){

          $$state [0] = ();#terminate the state operation
          };#if
        };#else
      };#if
# if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
# my ($pr);
# print ("iteratejhlchx ");
# $pr = $Awfif::memes-> {snnih} {$tmpi};
# print ("state(0($$state[0])1($$state[1])2($$state[2])3($$state[3]) setstate3($setstate3) usestate3($usestate3) ret($nindex) ");
# if ($nindex > 0){
# print ("-> jhls($$jhlslist[$nindex]) ");
# };#if
# print ("\n");
# };
    return $nindex
    }#iteratejhlch
#<!-- end tag al -->
#
sub inewlist {
    my ($myli, $cws, $bcwso, $sponsor, $sldesc, $grkwp, $grkwpr, $binding, $amkrwso) = @_;
#
# setup a list description - listhead, listlink, recordhead
    my ($abcwso, $cwsbi, $slhdesc, $slldesc, $cwsbi);
#
# inverted from slistkwbuilder
# checked for merged workspaces

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("inewlist sponsor $sponsor grkwp $$grkwp grkwpr $grkwpr binding $binding ");
      };

    $cwsbi = $Awfif::memes-> {currentwsbi};
    $Awfif::memes-> {currentwsbi} = $cws;
    $abcwso = awsoadr ($bcwso);
# checks the list start list for a head reference. If none exists initialise one in the context wso
    if ( ( ($slhdesc = findtdesc ($Awfif::wsol-> {l} [ $abcwso] [2], $Awfif::memes-> {snnh} {listhead})) != 0 )
    && ($Awfif::workspace-> {l} [$sldesc] [2] != ($Awfif::memes-> {snnh} {wsi} + 0))
    ){#have identified there is a list head get the associated list link

      $slldesc = findtdesc ($Awfif::wsol-> {l} [ $abcwso] [2], $Awfif::memes-> {snnh} {listlink});
      }# if head exists
    else {# create the head & list link descriptors

      $Awfif::wsol-> {l} [$abcwso][2]
        = setupdesc ( ($Awfif::memes-> {snnh} {wsi} + $cws), #should probably be the app kw mf ref as a type differentiator
            ($Awfif::memes-> {snnh} {wsi} + $bcwso), #point this to where the list link has been initialised
            $Awfif::memes-> {snnh} {listhead},
            $Awfif::wsol-> {l} [$abcwso] [2],
            $abcwso);

      $slhdesc = $Awfif::wsol-> {l} [$abcwso] [2];
      $Awfif::wsol-> {l} [$abcwso][2]
        = setupdesc ( ($Awfif::memes-> {snnh} {wsi} + $cws),
            ($Awfif::memes-> {snnh} {wsi} + 0),
            $Awfif::memes-> {snnh} {listlink},
            $Awfif::wsol-> {l} [$abcwso] [2],
            $abcwso);
      $slldesc = $Awfif::wsol-> {l} [$abcwso] [2];
      };#else
# slistkwbuildercstb
# deploy <mkwordref> the listref wso for this list structure
    my ($buffer, $insymbol, @inmsymbol, @started, $end, $depstag, $depttag, $dephtag, $setwsclinv);

    $buffer = '<mkwordref>';
    $depstag = '';
    $depttag = 0;
    $dephtag = 0;
    $insymbol = '';
    @inmsymbol = ();
    $started[0] = 0;
    $started[1] = 't';
    $setwsclinv = '';
    &convbws ($myli, \$buffer, \$$grkwp, $grkwpr, $Awfif::memes-> {kwmi}, $Awfif::memes-> {kwmir}, $sponsor, \$insymbol, \@inmsymbol, \@started, \$end, \$depstag, \$depttag, \$dephtag, $cws, $binding,
        $Awfif::memes-> {strbool}[$Awfif::memes-> {streh} {budesc}],
        '', #dont energize the base type
        \$setwsclinv
        );
# deploy an initialised record head descriptor in the <mkwordref> wso
    my ($mkrwso, $chead);

    $mkrwso = $Awfif::wsbl-> {wsoh} [$cws];
    $$amkrwso = awsoadr ($mkrwso);
    $Awfif::wsol-> {l} [$$amkrwso][2]
      = setupdesc ( ($Awfif::memes-> {snnh} {wsi} + $cws),
          ($Awfif::memes-> {snnh} {wsi} + 0),
          $Awfif::memes-> {snnh} {recordhead},
          $Awfif::wsol-> {l} [$$amkrwso] [2],
          $$amkrwso);
# deploy an initialised record link descriptor in the <mkwordref> wso

    $Awfif::wsol-> {l} [$$amkrwso][2]
      = setupdesc ( ($Awfif::memes-> {snnh} {wsi} + $cws),
          ($Awfif::memes-> {snnh} {wsi} + 0),
          $Awfif::memes-> {snnh} {recordlink},
          $Awfif::wsol-> {l} [$$amkrwso] [2],
          $$amkrwso);
# deploy an initialised list next descriptor to the <mkwordref> wso
# have to get the listlink in the current head

    $chead = ($Awfif::workspace-> {l} [$slhdesc] [2] - $Awfif::memes-> {snnh} {wsi});
    $slldesc = findtdesc ($Awfif::wsol-> {l} [ awsoadr($chead)] [2], $Awfif::memes-> {snnh} {listlink});
# update this which should be initialised with the address of the <mkwordref> where the next listlink is being deployed
    $Awfif::workspace-> {l} [$slldesc] [2] = $Awfif::workspace-> {l} [$slldesc] [2] + $mkrwso;
    $Awfif::wsol-> {l} [$$amkrwso][2]
      = setupdesc ( ($Awfif::memes-> {snnh} {wsi} + $cws),
          ($Awfif::memes-> {snnh} {wsi} + 0),
          $Awfif::memes-> {snnh} {listlink},
          $Awfif::wsol-> {l} [$$amkrwso] [2],
          $$amkrwso);
# update the list head
    $Awfif::workspace-> {l} [$slhdesc] [2] = $mkrwso + $Awfif::memes-> {snnh} {wsi};
    $Awfif::memes-> {currentwsbi} = $cwsbi;

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("inewlistx\n");
      };
    }#inewlist
#
sub inewrcd {
    my ($myli, $cws, $bcwso, $sponsor, $sldesc, $slhdesc, $grkwp, $grkwpr, $binding, $amkrwso) = @_;
#
# setup a list description - listhead, listlink, recordhead
    my ($abcwso, $cwsbi, $cwsbi);
#
# inverted from slistkwbuilder
# checked for merged workspaces

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("inewrcd sponsor $sponsor grkwp $$grkwp grkwpr $grkwpr binding $binding ");
      };

    $cwsbi = $Awfif::memes-> {currentwsbi};
    $Awfif::memes-> {currentwsbi} = $cws;
    $abcwso = awsoadr ($bcwso);
# if its ok then deploy <recordref> really an mkwordref to the record wso
    my ($buffer, $insymbol, @inmsymbol, @started, $end, $depstag, $depttag, $dephtag, $setwsclinv);

    $buffer = '<mkwordref>';
    $depstag = '';
    $depttag = 0;
    $dephtag = 0;
    $insymbol = '';
    @inmsymbol = ();
    $started[0] = 0;
    $started[1] = 't';
    $setwsclinv = '';
    &convbws ($myli, \$buffer, \$grkwp, $grkwpr, $Awfif::memes-> {kwmi}, $Awfif::memes-> {kwmir}, $sponsor, \$insymbol, \@inmsymbol, \@started, \$end, \$depstag, \$depttag, \$dephtag, $cws, $binding,
        $Awfif::memes-> {strbool}[$Awfif::memes-> {streh} {budesc}],
        '',#dont energize the base concepts
        \$setwsclinv
        );
# dirrdcwso1
# deploy an initialised record ref descriptor in the <mkwordref> wso
    my ($mkrwso);

    $mkrwso = $Awfif::wsbl-> {wsoh} [$cws];
    $$amkrwso = awsoadr ($mkrwso);
    $Awfif::wsol-> {l} [$$amkrwso][2]
      = setupdesc ( ($Awfif::memes-> {snnh} {wsi} + ($Awfif::workspace-> {l} [$sldesc] [3] - $Awfif::memes-> {snnh} {wsi})),
          ($Awfif::memes-> {snnh} {wsi} + ($Awfif::workspace-> {l} [$sldesc] [2] - $Awfif::memes-> {snnh} {wsi})),
          $Awfif::memes-> {snnh} {record},
          $Awfif::wsol-> {l} [$$amkrwso] [2],
          $$amkrwso);
# deploy an initialised record link descriptor in the <mkwordref> wso

    $Awfif::wsol-> {l} [$$amkrwso][2]
      = setupdesc ( ($Awfif::memes-> {snnh} {wsi} + $cws),
          ($Awfif::memes-> {snnh} {wsi} + 0),
          $Awfif::memes-> {snnh} {recordlink},
          $Awfif::wsol-> {l} [$$amkrwso] [2],
          $$amkrwso);
# lrhlltwso1
# link the record head's link to the record mkwordref and move the record head wso address

    my ($rcdhwso, $rcdlwso, $rcdhdesc);
    $rcdhwso = $Awfif::workspace->{l} [$slhdesc][2] - $Awfif::memes-> {snnh} {wsi};
    $rcdhdesc = findtdesc ($Awfif::wsol-> {l} [ awsoadr($rcdhwso)] [2], $Awfif::memes-> {snnh} {recordhead});
    $rcdlwso = $Awfif::workspace->{l} [$rcdhdesc][2] - $Awfif::memes-> {snnh} {wsi};
    $Awfif::workspace-> {l} [$rcdhdesc] [2] = $mkrwso + $Awfif::memes-> {snnh} {wsi};
# link the previous record head's record link to the record mkwordref
# if the record head is 0 its initialised and we should use the listhead for the record link wso address

    my ($rcdldesc);
    if ($rcdlwso != 0) {
      $rcdldesc = findtdesc ($Awfif::wsol-> {l} [ awsoadr($rcdlwso)] [2], $Awfif::memes-> {snnh} {recordlink});
      }#if
    else {#initial link is co-resident in the wso with the head descriptor
      $rcdldesc = findtdesc ($Awfif::wsol-> {l} [ awsoadr($rcdhwso)] [2], $Awfif::memes-> {snnh} {recordlink});
      };#else
    $Awfif::workspace-> {l} [$rcdldesc] [2] = $mkrwso + $Awfif::memes-> {snnh} {wsi};
    $Awfif::memes-> {currentwsbi} = $cwsbi;

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("inewrcdx\n");
      };
    }#inewrcd
#
sub depcmodel {
    my ($myli, $iws, $recordi, $arecordi, $token, $casefor, $target) = @_;
#
# deploy a case model -
    my ($seldsc, $cwsbi, $ws);
#
# inverted from icrsmoxbuilder
# checked for merged workspaces

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("depcmodel myli $myli token $token casefor $casefor target $target ");
      if ( (defined ($recordi)) ){

        print ("recordi($recordi) ");
        };#if
      if ( (defined ($iws)) ){

        print ("iws($iws) ");
        }#if
      else {
        print ("currentwsbi($Awfif::memes->{currentwsbi}) ");
        };#else
      if ( (defined ($arecordi)) ){

        print ("arecordi($arecordi) ");
        };#if
      };

    $cwsbi = $Awfif::memes-> {currentwsbi};
    if (defined ($iws)) {

      $ws = $iws;
      }#if
    else {

      $ws = $Awfif::memes-> {currentwsbi};
      };#else
    if (defined ($recordi)) {

      if ((!defined ($arecordi)) ){

        $Awfif::memes-> {currentwsbi} = $ws;
        $arecordi = awsoadr ($recordi);
        };#if
      if ((($seldsc = findtdesc ($Awfif::wsol-> {l} [ $arecordi] [2], $Awfif::memes-> {snnh} {casemodel})) == 0)
      or ($Awfif::workspace-> {l} [$seldsc] [11] != $token)
      ){

        $Awfif::wsol-> {l} [$arecordi][2]
          = setupdesc ( ($Awfif::memes-> {snnh} {wsi} + $casefor),
              ($Awfif::memes-> {snnh} {wsi} + $target),
              $Awfif::memes-> {snnh} {casemodel},
              $Awfif::wsol-> {l} [$arecordi][2],
              $arecordi);
        $Awfif::workspace-> {l} [ $Awfif::wsol-> {l} [$arecordi][2]] [10] = $Awfif::memes-> {snnh} {casedeploys};
        $Awfif::workspace-> {l} [ $Awfif::wsol-> {l} [$arecordi][2]] [11] = $token;
        };#if
      };#if
    $Awfif::memes-> {currentwsbi} = $cwsbi;

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("depcmodelx\n");
      };
    }#depcmodel
#
sub findcot {
    my ($myli, $token, $targsel, $ival, $i, $caseop, $target) = @_;
#
# find caseop & target -
    my ($aws, $cwsbi, $conforms, $descfits, $count, $caseopupd, $targetupd );
#
# inverted from icrsmoxbuilder
# checked for merged workspaces

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      my ($pr, $pr2);
      $pr = $Awfif::memes-> {snnih} {$token};
      $pr2 = $Awfif::memes-> {snnih} {$targsel};
      print ("findcot myli $myli token $pr($token) targsel $pr2($targsel) ");
      };

    $cwsbi = $Awfif::memes-> {currentwsbi};
    $targetupd = '';
    $caseopupd = '';
    if ( ( ($Awfif::memes-> {currentwsbi} = ($aws = ($Awfif::workspace-> {l} [ $$ival [$i] ] [3] - $Awfif::memes-> {snnh} {wsi}))) != 0 )
    && (($count = findgm ($myli, ($Awfif::workspace-> {l} [ $$ival [$i] ] [12]), \$descfits, \$conforms, $Awfif::wsbl-> {wsoh} [$aws], $Awfif::wsbl-> {wsft} [$aws],
      $Awfif::memes-> {snnh} {tokencategory}, $Awfif::memes-> {snnh} {case},
      $Awfif::memes-> {snnh} {andcategory}, $targsel,
      $Awfif::memes-> {snnh} {andcategory}, $Awfif::memes-> {snnh} {instance},
      $Awfif::memes-> {snnh} {andcategory}, $token )>0))# <rhlcasertspo>
    && ($conforms)
    && ($descfits)
    ){

      $targetupd = 't';
      $$target = $$ival [$i];#target of for is selector in an if
      }#if
    elsif ( ( ($Awfif::memes-> {currentwsbi} = ($aws = ($Awfif::workspace-> {l} [ $$ival [$i] ] [3] - $Awfif::memes-> {snnh} {wsi}))) != 0 )
    && (($count = findgm ($myli, ($Awfif::workspace-> {l} [ $$ival [$i] ] [12]), \$descfits, \$conforms, $Awfif::wsbl-> {wsoh} [$aws], $Awfif::wsbl-> {wsft} [$aws],
      $Awfif::memes-> {snnh} {tokencategory}, $Awfif::memes-> {snnh} {instance},
      $Awfif::memes-> {snnh} {andcategory}, $Awfif::memes-> {snnh} {value},
      $Awfif::memes-> {snnh} {andcategory}, $token,
      $Awfif::memes-> {snnh} {andcategory}, $Awfif::memes-> {snnh} {small},
      $Awfif::memes-> {snnh} {andcategory}, $Awfif::memes-> {snnh} {case} )>0))# <rhlcaseisspo>
    && ($conforms)
    && ($descfits)
    ){

      $caseopupd = 't';if ($token == $Awfif::memes-> {snnh} {$Awfif::memes-> {findcotd}}) {&break ()};
      $$caseop = $$ival [$i];
      };#if
    $Awfif::memes-> {currentwsbi} = $cwsbi;

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("findcotx count($count) ");
      if ($targetupd) {
        print ("target($$target) ");
        };#if
      if ($caseopupd) {
        print ("caseop($$caseop) ");
        };#if
      print ("\n");
      };
    }#findcot
#
sub listival {
    my ($myli, $iws, $recordi, $arecordi, $ival, $token, $modeled) = @_;
#
# find caseop & target -
    my ($linki, $ws, $cwsbi, $ivalc );
#
# inverted from icrsmoxbuilder
# checked for merged workspaces

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      my ($pr);
      print ("listival myli $myli ");
      if ( (defined ($recordi)) ){

        print ("recordi($recordi) ");
        };#if
      if ( (defined ($iws)) ){

        print ("iws($iws) ");
        }#if
      else {
        print ("currentwsbi($Awfif::memes->{currentwsbi}) ");
        };#else
      if ( (defined ($arecordi)) ){

        print ("arecordi($arecordi) ");
        };#if
      if ( (defined ($token)) ){

        $pr = $Awfif::memes-> {snnih} {$token};
        print ("token $pr($token) ");
        };#if
      };

    $cwsbi = $Awfif::memes-> {currentwsbi};
    if (defined ($iws)) {

      $ws = $iws;
      }#if
    else {

      $ws = $Awfif::memes-> {currentwsbi};
      };#else
    if (defined ($recordi)) {

      if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
        &itwsoutput ($recordi);
        };
      if ((!defined ($arecordi)) ){

        $Awfif::memes-> {currentwsbi} = $ws;
        $arecordi = awsoadr ($recordi);
        };#if
      $linki = $Awfif::wsol-> {l} [ $arecordi] [2];
      }#if
    else {

      $linki = 0;
      };#else
    $ivalc = 0;
    @$modeled = ();
    while ( ($linki != 0)
    ){

      if ($Awfif::workspace-> {l} [$linki] [4] == $Awfif::memes-> {snnh} {ivalue}) {

        $$ival [$ivalc++] = $linki;
        };#if
# if find a matching model it means already processed the rest of this workspace
      if (($Awfif::workspace-> {l} [$linki] [4] == $Awfif::memes-> {snnh} {casemodel})
      && ($Awfif::workspace-> {l} [$linki] [11] == $token)
      ){

        $$modeled [$ivalc] = 't';#should end up signalling during the pair
        };#if
      $linki = $Awfif::workspace-> {l} [ $linki] [0];
      };#while
    $Awfif::memes-> {currentwsbi} = $cwsbi;

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("listivalx ret($ivalc)\n");
      };
    return $ivalc
    }#listival
#
sub ibawswalk {
    my ($myli, $sponsor, $stwso, $mstrategy, $sstrategy, $sactset, $bcount, $msws, $msb, $bws, $bbwso) = @_;
#
# setup base addressing for workspace walk
# mstrategy might be binderp1
# sstrategy might be bindercs or equivalent
    my ($cwsbi, $kwp, $kwpr);
    my ($proceed, $bwsdesc, $amsb, $sigcount, @lomatchs, @lola, @loconcs, @lostrts, @loends, @logb, @loge);
#
# inverted from icrsmoxbuilder
# checked for merged workspaces

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("ibawswalk myli $myli stwso $stwso mstrategy($mstrategy) sstrategy($sstrategy) ");
      };

    $cwsbi = $Awfif::memes-> {currentwsbi};
    $Awfif::memes-> {currentwsbi} = $Awfif::codelet-> {l} [$myli] [20];
    $proceed = '';
    if ($Awfif::codelet-> {l} [$myli] [36] == 0) {#setup the base addressing for walking the case workspace

      $$bcount = ifindb ($myli, $stwso, $mstrategy, \$sigcount, \@lomatchs, \@lola, \@loconcs, \@lostrts, \@loends, \@logb, \@loge, $kwp, $kwpr, \@$sactset);
      $$msb = getfbws ($myli, $sigcount, \@lomatchs, \@lola, \$$msws);
# now need to find the ws and base wso the slistkwbuilder described and switch to it

      $Awfif::memes-> {currentwsbi} = $$msws;
      $amsb = awsoadr ($$msb);
      if (($bwsdesc = findtdesc ($Awfif::wsol-> {l} [ $amsb] [2], $Awfif::memes-> {snnh} {slistkwevaluator})) != 0
      ){# if undefined foundgap then no records to process; if foundgap == false then records exist but not a gap; if foundgap == t then should model the gap

        $$bbwso = ($Awfif::workspace-> {l} [$bwsdesc] [2] - $Awfif::memes-> {snnh} {wsi});
        $$bws = $Awfif::workspace-> {l} [$bwsdesc] [3];
        $proceed = 't';
        };#if
      }#if
    else {#subprogram

      $$bcount = ifindb ($myli, $sponsor, $sstrategy, \$sigcount, \@lomatchs, \@lola, \@loconcs, \@lostrts, \@loends, \@logb, \@loge, $kwp, $kwpr, \@$sactset);
      if ($$bcount == 1) {

        $proceed = 't';
        $$bbwso = getfbws ($myli, $sigcount, \@lomatchs, \@lola, \$$bws);
        };#if
      };#else subprogram
    $Awfif::memes-> {currentwsbi} = $cwsbi;

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("ibawswalkx bcount($$bcount) msws($$msws) msb($$msb) bws($$bws) bbwso($$bbwso) ret($proceed)\n");
      };
    return $proceed
    }#ibawswalk
#
sub findgap {
    my ($myli, $arecordi, $kwdi, $req2, $req3, $req4, $term4, $term10, $term11, $ivalue) = @_;
#
# find any gap to be filled -
    my ($linki, $cwsbi, $gap, $found, $completed );
#
# checked for merged workspaces

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      my ($pr, $pr1, $pr2, $pr3, $pr4, $pr10, $pr11);
      $pr2 = $Awfif::memes-> {snnih}{$req2};
      $pr3 = $Awfif::memes-> {snnih}{$req3};
      $pr4 = $Awfif::memes-> {snnih}{$req4};
      $pr = $Awfif::memes-> {snnih}{$term4};
      $pr10 = $Awfif::memes-> {snnih}{$term10};
      $pr11 = $Awfif::memes-> {snnih}{$term11};
      $pr1 = $Awfif::memes-> {snnih}{$ivalue};
      print ("findgap myli $myli kwdi($kwdi) req2($req2:$pr2) req3($req3:$pr3) req4($req4:$pr4) term4($term4:$pr) term10($term10:$pr10) term11($term11:$pr11) ivalue($ivalue:$pr1) ");
      &itwsoloutput ($arecordi);
      };

    $cwsbi = $Awfif::memes-> {currentwsbi};
    $gap = '';
    $found = '';
    $linki = $kwdi;
    while ( ($linki != 0) && (!$found)
    ){

      if (($Awfif::workspace-> {l} [$linki] [4] == $req4)
      && ($Awfif::workspace-> {l} [$linki] [3] == $req3)
      && ($Awfif::workspace-> {l} [$linki] [2] == ($req2 + $Awfif::memes-> {snnh} {wsi}))
      ){

        $found = 't';
        $completed = '';
        $linki = $kwdi;#have found the required descriptor
        while ( ($linki != 0) && (!$completed)
        ){
# if find a matching model it means already processed the rest of this workspace

          if (($Awfif::workspace-> {l} [$linki] [4] == $term4)
          && ($Awfif::workspace-> {l} [$linki] [10] == $term10)
          && ($Awfif::workspace-> {l} [$linki] [11] == $term11)
          ){

            $completed = 't';#should end up signalling during the pair
            }#if
          elsif (($Awfif::workspace-> {l} [$linki] [4] == $ivalue)
          ){
            $gap = 't';
            $completed = 't';
            };#elsif
          $linki = $Awfif::workspace-> {l} [ $linki] [0];
          };#while
        };#if
      if (!$found) {
        $linki = $Awfif::workspace-> {l} [ $linki] [0];
        };#if
      };#while
    $Awfif::memes-> {currentwsbi} = $cwsbi;

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("findgapx ret($gap)\n");
      };
    return $gap
    }#findgap
#
#<!-- end tag dli -->
#<!-- start tag ds -resweb -->
#
sub addpoolc {
# setup the structures to support linked details of applycodelet match sets
    my ($newcodelet, $slinkh) = @_;#
    my ($nslinkh);
#
# checked for merged workspaces

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("addpoolc newcodelet $newcodelet ");
      print ("slink $slinkh ");
      };
    $nslinkh = addhli ($slinkh, \$Awfif::poolcl);
# setup the links data

    $Awfif::poolcl-> {l} [$nslinkh][2] = $newcodelet;#should be the reference to a $Awfif::codelet-> {l} element
    if ($Awfif::poolcl-> {l} [$nslinkh] [0] > 0) {#all elements of the list should have the [38] set up so sel/normcodelet do not have to search

      $Awfif::codelet-> {l} [ $Awfif::poolcl-> {l} [$nslinkh] [2] ] [38] = $Awfif::codelet-> {l} [ $Awfif::poolcl-> {l} [ $Awfif::poolcl-> {l} [$nslinkh] [0] ] [2] ] [38];
      };#if
    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("addpoolcx ret $nslinkh\n");
      };

    return $nslinkh
    }# addpoolc
#
#<!-- start tag sia -->
#
sub freepoolc {
    my ($cslnk) = @_;
#
# checked for merged workspaces

# move the amoff element to the inactive list
    my ($head, $linki);
# if this is the only item then remove it and clear the head reference
    if ( ($Awfif::poolcl-> {l} [$cslnk] [1] == 0)
    && ($Awfif::poolcl-> {l} [$cslnk] [0] == 0)
    ){

      $head = freehli ($cslnk, \$Awfif::poolcl);
      $Awfif::poolcl-> {l} [$cslnk] [2] = undef();
      }#if
# else if this is the tail item transfer its pooling count to the previous item and then remove the tail item
# else if this is any other item then just remove the item from the element list
    else {#return the current head item

      $linki = $Awfif::poolcl-> {l} [$cslnk] [1];
      $head = $linki;
      while ($linki != 0) {
        if ($Awfif::poolcl-> {l} [$linki] [1] != 0) {

          $head = $Awfif::poolcl-> {l} [$linki] [1];
          };#if
        $linki = $Awfif::poolcl-> {l} [$linki] [1];
        };#while

      &freehli ($cslnk, \$Awfif::poolcl);
      $Awfif::poolcl-> {l} [$cslnk] [2] = undef();
      };#else
    return $head
    }#freepoolc
#
#
sub findgm {
    my ($myli, $nextinstance, $descfits, $conforms, $kwp, $kwpr )=@_;
    my ($count, $i, $i2, $inc, $dec, $parambase, $parammax, $failure, $gotillend, $checked, $ignore);

    $parambase = 6;
    $parammax = $parambase + 45;
    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("findgm myli $myli, nextinstance $nextinstance kwp $kwp kwpr $kwpr ");
      };#if trace
    $checked = 0;
    $ignore = 0;
    $i = $nextinstance;
    for ($i2 = $parambase; $i2 <= $parammax; $i2++) {#assumes the tokens are at the end of the param block
      if (defined($_[$i2])) {

        if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {

          my ($pr, $pr2);
          $pr = $Awfif::memes-> {snnih}{$_[$i2]};
          $pr2 = $i2-($parambase-1);
          print ("s$pr2 $pr, ");
          };#trace
        if (($_[$i2] == $Awfif::memes-> {snnh}{tokencategory}) && ($i2++ != 0) ) {

          if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {

            my ($pr, $pr2);
            $pr = $Awfif::memes-> {snnih}{$_[$i2]};
            $pr2 = $i2-($parambase-1);
            print ("s$pr2 $pr, ");
            };#trace
          $checked++;
          }#if
        elsif (($_[$i2] == $Awfif::memes-> {snnh}{andcategory}) && (++$ignore != 0) && ($i2++ != 0) ) {

          if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {

            my ($pr, $pr2);
            $pr = $Awfif::memes-> {snnih}{$_[$i2]};
            $pr2 = $i2-($parambase-1);
            print ("s$pr2 $pr, ");
            };#trace
          }#elsif
        else {

          $checked++;
          };
        }#if
      else {

        $i2 = $parammax+1;# terminate the loop
        };# if not specified
      }#for
    $count = 0;
# for each typed wso triple count if they are the sequence specified
    $$descfits = 't';
    $$conforms = 't';
    $failure = '';
    $inc = 0;
    $dec = 0;
    for ($i2 = $parambase; $i2 <= $parammax; $i2++) {#assumes the tokens are at end of parameters
      if (defined($_[$i2 + $inc])) {

        my ($type, $conforms, $ni);
        if (($_[$i2 + $inc] == $Awfif::memes-> {snnh}{tokencategory})
        ){#special case

          if ($i2 == $parambase) {

            $ni = $i;
            }#if
          else {

            $ni = trwsoadr ($i, $i2 - $parambase + $dec);
            };#else

          $inc++;#since this specification takes up two inputs
          if (!chmdefis ($myli, $ni, $_[$i2 +$inc], \$conforms, $kwp, $kwpr)) {#

            $failure = 't';
            $i2 = $parammax + 1;# terminate the loop
            $$descfits = '';
            };
          }#if special case
        elsif (($_[$i2 + $inc] == $Awfif::memes-> {snnh}{andcategory})
          ){#special case

          $dec--;
          if ($i2 == $parambase) {

            $ni = $i;
            }#if
          else {

            $ni = trwsoadr ($i, $i2 - $parambase + $dec);
            };#else
          $inc++;#since this specification takes up two inputs
          if (!chmdefis ($myli, $ni, $_[$i2 +$inc], \$conforms, $kwp, $kwpr)) {#

            $failure = 't';
            $i2 = $parammax + 1;# terminate the loop
            $$descfits = '';
            };
          }#if special case
        elsif (($_[$i2 + $inc] == $Awfif::memes-> {snnh}{qmark})
          ){#matches anything

          }#if matches anything
        else {

          if ($i2 == $parambase) {

            $type = wsbasetype ($i);
            }#if
          else {

            $type = wsbasetype (trwsoadr ($i, $i2 - $parambase + $dec));
            };#else
          if (($type != $_[$i2+$inc])
            ){

            $failure = 't';
            $i2 = $parammax + 1;# terminate the loop
            $$descfits = '';
            };# if no match
          };#else normal case
        } # if specified
      else {

        $i2 = $parammax + 1;# terminate the loop
        if (!$failure) {

          $count++;
          $gotillend = '';
          };# if match then count
        };# if not specified
      };#for
    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("findgmx conforms ($$conforms) descfits ($$descfits) ret ($count)\n");
      };

    return ($count);
    };# findgm
#
sub stmtpart {# select a salient workspace part
    my($myli, $ws, $part)=@_;
    my ($i, $wso, $found);
    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("stmtpart myli $myli ws $ws part $part ");
      };
# updated for merged workspaces

    $found = '';
    $wso = 0;

    my ($swstype);
    for ($i = 1; ((!$found) && ($i < $Awfif::pcache-> {p} [$ws]));$i++) {

      $swstype = wsbasetype ($Awfif::pcache-> {l} [$ws][$i]);

      if ($swstype == $part) {

        $found = 't';
        $wso = $Awfif::pcache-> {l} [$ws][$i];
        }; #if match
      };# for check each candidate for match

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("stmtpart ret $wso\n");
      };
    return $wso
    }# stmtpart
#
#<!-- start tag dli -->
#<!-- start tag al -->
#
sub ifindb {# see if there is a bound workspace with the schematic string
    my($myli, $sti, $strategy, $sigcount, $lomatchs, $lola, $loconcs, $lostrts, $loends, $logb, $loge, $kwp, $kwpr, $sactset, $stws, $issubp, $subp, $dontcallbreak, $dontusebice)=@_;
    my ($i, $bcount, $linki, $cwsbi, $static, $labcount, $hchain, $srws, $erws);
    my (@lab );

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      my ($pr);
      $pr = $Awfif::memes-> {currentwsbi};
      print ("ifindb myli $myli currentwsbi $pr ");
      };
# updated for merged workspaces

    $cwsbi = $Awfif::memes-> {currentwsbi};
    $bcount = 0;

    $static = '';
    $labcount = $Awfif::memes-> {binds}-> {$strategy}->
        ($myli, $sti, \@lab, $kwp, $kwpr, \@$sactset, \$static);
# ifindbcrelu1

    $srws = 0; #must be defined for relifindb
    $erws = 0; #must be defined for relifindb
    &relifindb ($myli, \$Awfif::ifbhcl, \$srws, \$erws);

    if (((!defined ($dontusebice)) or (!$dontusebice))
    && (($linki = getifb ($myli, $strategy, $labcount, \@lab, \$hchain, $subp, $stws, $srws, $erws)) != 0)
    && ($hchain != 0)
    ) {#usebice cache setup

      $$sigcount = usebice ($Awfif::ifbhcl-> {l} [$linki][4], \@$lomatchs, \@$lola, \@$loconcs, \@$lostrts, \@$loends, \@$logb, \@$loge);
      $bcount = $Awfif::bicl-> {l} [$Awfif::ifbhcl-> {l} [$linki][4]][3];
      }#if
    else {

      if ((defined ($stws)) && (defined ($srws)) && (defined ($erws)) ){#use structural ws sequence for search

        $$sigcount = labinv2 ($myli, \@lab, $labcount, \@$lomatchs, \@$lola, \@$loconcs, \@$lostrts, \@$loends, \@$logb, \@$loge, 'wsseqstbinding', undef (), $srws, $erws);
        }#if
      elsif ((!defined ($stws)) && (defined ($srws)) && (defined ($erws)) ){#use specific stws only for search

        $$sigcount = labinv2 ($myli, \@lab, $labcount, \@$lomatchs, \@$lola, \@$loconcs, \@$lostrts, \@$loends, \@$logb, \@$loge, 'wsseqoporstbinding', undef (), $srws, $erws);
        }#elsif
      elsif ((defined ($stws)) && (defined ($issubp)) ){#use specific stws only for search

        $$sigcount = labinv2 ($myli, \@lab, $labcount, \@$lomatchs, \@$lola, \@$loconcs, \@$lostrts, \@$loends, \@$logb, \@$loge, 'specsubpstonly', $stws);
        }#elsif
      elsif ((defined ($stws)) ){#use specific stws only for search

        $$sigcount = labinv2 ($myli, \@lab, $labcount, \@$lomatchs, \@$lola, \@$loconcs, \@$lostrts, \@$loends, \@$logb, \@$loge, 'specstonly', $stws);
        }#elsif
      else {

        $$sigcount = labinv2 ($myli, \@lab, $labcount, \@$lomatchs, \@$lola, \@$loconcs, \@$lostrts, \@$loends, \@$logb, \@$loge, 'onlyoporstbinding');
        };#else
      if ($$sigcount > 0) {

        for ($i = 0; $i < $$sigcount; $i++) {
          if ($$lomatchs[$i]) {

            if ( (defined ($issubp))
            && ($Awfif::jhls-> {l} [$$lola[$i]][4] == $issubp)
            ){
              $bcount++;
              }#if
            elsif (($Awfif::jhls-> {l} [$$lola[$i]][4] == $Awfif::memes-> {snnh}{subpstbinding}) && ( ($$lola[$i] == $Awfif::subpl-> {l} [$Awfif::codelet-> {l} [$myli] [36]] [4]) or ($$lola[$i] == $Awfif::subpl-> {l} [$Awfif::codelet-> {l} [$myli] [36]] [8]) or ($$lola[$i] == $Awfif::subpl-> {l} [$Awfif::codelet-> {l} [$myli] [36]] [5])) ) {

              $bcount++;
              }#elsif
            elsif ($Awfif::jhls-> {l} [$$lola[$i]][4] == $Awfif::memes-> {snnh}{stbinding}) {

              $bcount++;
              }#elsif
            else {
              $$lomatchs [$i] = '';
              };#else ignore this one
            };#if
          };#for
        };#if
      if ( ($bcount > 0)
      && ((!defined ($dontusebice)) or (!$dontusebice)) ) {
# ifindbcrelu2

        &addifb ($myli, $strategy, $labcount, \@lab, addbice ($Awfif::memes-> {currentwsbi}, $bcount, 5, $$sigcount, \@$lomatchs, \@$lola, \@$loconcs, \@$lostrts, \@$loends, \@$logb, \@$loge), $subp, $stws, $srws, $erws);
        };#stable answer can be cached
      };#else
    if (($bcount == 0)
    && !($dontcallbreak)
    ){

      &break ();
      };#if

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("ifindbx ret ($bcount)\n");
      };
    $Awfif::memes-> {currentwsbi} = $cwsbi;
    return $bcount
    }# ifindb
#
#<!-- end tag dli -->
#
sub getstsbws {# get the index of the first bound workspace
    my($myli, $sigcount, $lomatchs, $lola, $ws, $stws, $subp)=@_;
    my ($i, $bwso, $found, $cwsbi);

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("getstsbws myli $myli ");
      };
# updated for merged workspaces

    $cwsbi = $Awfif::memes-> {currentwsbi};
    $found = '';
    for ($i = 0; (($i < $sigcount) && (!$found)) ; $i++) {
      if ($$lomatchs[$i]) {
        if (( ($Awfif::jhls-> {l} [$$lola[$i]][4] == $Awfif::memes-> {snnh}{stbinding})
        && ($Awfif::jhls-> {l} [$$lola[$i]][7] == $ws) )
        or ( subpst ($myli, $$lola[$i], $stws, $subp) )
        ){
          $bwso = $Awfif::jhls-> {l} [$$lola[$i]] [8];
          $found = 't';
          };#if
        };#if
      };#for

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("getstsbwsx ret ($bwso)\n");
      };
    $Awfif::memes-> {currentwsbi} = $cwsbi;
    return $bwso
    }# getstsbws
#
#<!-- end tag al -->
#<!-- xtart tag sia -->
#
sub assieojhlc {# inversion of groupbuilders ie jhlabel operon association - no callers!
    my($myli, $sponsor, $ws, $as, $ae)=@_;
    my ($i, $cwsbi, $newjhlsi, $atelhwso, $teldesc, $asponsor, $sigcount, @lomatchs, @logb, @loge, @loconcs, @lola, @lostrts, @loends);

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("assieojhlc myli $myli sponsor($sponsor) ws($ws) as($as) ae($ae) ");
      };
# updated for merged workspaces

    $cwsbi = $Awfif::memes-> {currentwsbi};
    $Awfif::memes-> {currentwsbi} = $ws;
# see if there is an operon within the as ae group by binding with it
# apply the linking function of group completion

    $sigcount = labinv1 ($myli, $as, $ae, '', '', \@lomatchs, \@lola, \@loconcs, \@lostrts, \@loends, \@logb, \@loge, 'notoporstbinding');
    if ($sigcount > 0) {

      my ($atti);
      for ($i = 0; $i < $sigcount; $i++) {

        if ($lomatchs[$i]) {#there is a link use the association
#

          if (($Awfif::jhls-> {l} [$lola[$i]][4] != $Awfif::memes-> {snnh}{operon}) && ($Awfif::jhls-> {l} [$lola[$i]][4] != $Awfif::memes-> {snnh}{stbinding}) && ($Awfif::jhls-> {l} [$lola[$i]][4] != $Awfif::memes-> {snnh}{subpstbinding})) {
# now setup a cache for it

            if ($Awfif::wsol-> {l}[($asponsor = awsoadr ($sponsor))][ $Awfif::memes-> {wsogcspjhlsi}] == 0) {#this is a new group complete

              ©sn1 ($Awfif::memes-> {currentwsbi}, $Awfif::memes->{snnih}{$Awfif::jhls-> {l} [$lola[$i]] [6]});
# add a jhlabel for this workspace group
              $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}] {snnl} [$Awfif::memes-> {snnh}{operon}] = newnlink ($Awfif::memes-> {snnh} {attrib}, ($newjhlsi = addjhlst ($Awfif::memes-> {snnh} {groupcategory}, $Awfif::memes-> {snnh} {operon}, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}] {snnl}[$Awfif::memes-> {snnh}{operon}], $Awfif::jhls-> {l} [$lola[$i]] [6], $Awfif::memes-> {currentwsbi}, $lostrts[$i], $loends[$i], $Awfif::jhls-> {l} [$lola[$i]] [15] [0])), $Awfif::memes-> {snnh}{operon}, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh}{operon}]);
# if this schemata has indequiv true check the telomeric head wso (logically sponsor - 1) for a mindeqiv descriptor
# if find one update that jhls with newly created jhls id
              if (($Awfif::jhls-> {l} [$lola[$i]][15] [0])
              && ($Awfif::wsol-> {l} [($atelhwso = awsoadr ( trwsoadr($sponsor,-1)))] [2] != 0)
              && ( ($teldesc = findtdesc ($Awfif::wsol-> {l} [ ($atelhwso)] [2], $Awfif::memes-> {snnh} {mindequiv})) != 0 )
              ){

                $Awfif::jhls-> {l} [($Awfif::workspace-> {l} [$teldesc][2] - $Awfif::memes-> {snnh} {wsi})][15][2] = $newjhlsi;
                }; #if
              if (writeiecok ($sponsor)
              ){

                $Awfif::jhls-> {l} [$newjhlsi][16][2] = addbice ($Awfif::memes-> {currentwsbi} , $as, $ae, $sigcount, \@lomatchs, \@lola, \@loconcs, \@lostrts, \@loends, \@logb, \@loge);
                $Awfif::jhls-> {l} [$newjhlsi][15][1] = 't';
                $Awfif::jhls-> {l} [$newjhlsi][16][0] = $as;
                $Awfif::jhls-> {l} [$newjhlsi][16][1] = $ae;
# if the new jhls is indeqiv then write a descriptor in the sponsor
                $Awfif::wsol-> {l} [$asponsor][2]
                  = setupdesc ( $Awfif::memes-> {snnh} {zero},
                  ($newjhlsi + $Awfif::memes-> {snnh} {wsi}),
                  $Awfif::memes-> {snnh} {indequiv},
                  $Awfif::wsol-> {l} [$asponsor] [2],
                  $asponsor);
                };#if
# $lola[$i] is the index of the jhls when $lomatchs[$i] is true so can copy over its attributes

              $atti = $Awfif::jhls-> {l} [$lola[$i]] [5];
              $atti = $Awfif::attribs-> {l} [$atti][1];#move past the start attribute
              while (($Awfif::attribs-> {l} [$atti][2]) != $Awfif::memes-> {snnh}{attribe}) {

                &addjhlattrib ($Awfif::memes-> {snnh}{operon}, $Awfif::attribs-> {l} [$atti][3], $Awfif::attribs-> {l} [$atti][4]);
                $atti = $Awfif::attribs-> {l} [$atti][1];#next
                };

              &addjhlattribs ($Awfif::memes-> {snnh}{operon});
              $Awfif::wsol-> {l}[$asponsor][ $Awfif::memes-> {wsogcspjhlsi}] = $Awfif::slipnet-> {l} [$Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}] {snnl} [$Awfif::memes-> {snnh}{operon}]] [2];#*** submacrok ***#
              $Awfif::wsol-> {l}[$asponsor][ $Awfif::memes-> {wsogcjhlsi}] = $Awfif::slipnet-> {l} [$Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}] {snnl} [$Awfif::memes-> {snnh}{operon}]] [2];#*** submacrok ***#
# now add the sponsor info to the jhls
              $Awfif::jhls-> {l} [$Awfif::wsol-> {l}[$asponsor][ $Awfif::memes-> {wsogcjhlsi}]] [14][0] = $Awfif::memes-> {currentwsbi};#*** submacrok ***#
              $Awfif::jhls-> {l} [$Awfif::wsol-> {l}[$asponsor][ $Awfif::memes-> {wsogcjhlsi}]] [14][1] = $sponsor;#*** submacrok ***#
# and initialise the codelet count in the jhls
              $Awfif::jhls-> {l} [$Awfif::wsol-> {l}[$asponsor][ $Awfif::memes-> {wsogcjhlsi}]] [14][2] = 0;#*** submacrok ***#
# and initialise the codelet count in the jhls
              };#first time associating operon
            };#if
          };#if
        };#for
      };#if

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("assieojhlcx\n");
      };
    $Awfif::memes-> {currentwsbi} = $cwsbi;
    }# assieojhlc
#
#<!-- end tag sia -->
#<!-- start tag sss -->
#
sub ilaunchnc {# inversion of part of launchmodel
    my($myli, $sti, $strategy, $comptype, $giveup, $kwp, $kwpr, $sactset, $mparams, $usetrans, $transid, $transtatus, $subprogram, $jhlabeli, $jhlabeloi, $newli, $hiurg, $usepooling, $buildoffurg, $remvboosturg)=@_;
    my ($i, $linki, $cwsbi, $launched, $usedbice, $subp, $usedpooling );
    my ($labcount, $sigcount, $hchain, $bcount);
    my (@lomatchs, @lola, @loconcs, @lostrts, @loends, @logb, @loge, @lab);

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      my ($pr);
      $pr = $Awfif::memes-> {currentwsbi};
      print ("ilaunchnc myli $myli ws $pr ");
      if (defined ($strategy)) {
        print ("strategy $strategy ");
        };#if
      if (defined ($comptype)) {
        print ("comptype $comptype ");
        };#if
      if (defined ($$giveup)) {
        print ("giveup $$giveup ");
        };#if
      if (defined ($mparams)) {
        print ("mparams $mparams ");
        };#if
      if (defined ($usetrans)) {
        print ("usetrans $usetrans ");
        };#if
      if (defined ($$transid)) {
        print ("transid $$transid ");
        };#if
      if (defined ($subprogram)) {
        print ("subprogram $subprogram ");
        };#if
      if (defined ($hiurg)) {
        print ("hiurg $hiurg ");
        };#if
      if (defined ($$usepooling)) {
        print ("usepooling($$usepooling) ");
        };#if
      if (defined ($buildoffurg)) {
        print ("buildoffurg($buildoffurg) ");
        };#if
      if (defined ($remvboosturg)) {
        print ("remvboosturg($remvboosturg) ");
        };#if
      };
# updated for merged workspaces

    $cwsbi = $Awfif::memes-> {currentwsbi};
    $launched = '';
# ilncupoolu3
    if ((defined ($$usepooling)) && ($$usepooling > 0)) {

      my ($linkp, $bcindex);
      $linkp = $$usepooling;
# ilncupoolu4
      $bcindex = matchbreakcodelet ($myli);
      while ($linkp != 0) {

        $Awfif::codelet-> {l} [ $Awfif::poolcl-> {l} [$linkp] [2] ] [38]++;#add to each element of the pool
        $linkp = $Awfif::poolcl-> {l} [$linkp] [0];
        if (($bcindex > 0) #handle break codelet
        && (matchbreakcodelet ($Awfif::poolcl-> {l} [$linkp] [2]) == 0) #not already in list
        ){

          $Awfif::memes-> {breakcodelet} [++$Awfif::memes-> {breakcodelet} [0]] = $Awfif::poolcl-> {l} [$linkp] [2];
          if ($Awfif::codelet-> {l} [$myli] [36] > 0) {

            $Awfif::memes-> {breaksubp} [++$Awfif::memes-> {breaksubp} [0]] = $Awfif::codelet-> {l} [$myli] [36];
            };#if subprogram
          };#if
        };#while not at tail
      if ($bcindex > 0) {

        &remarrent ($bcindex, \@{$Awfif::memes-> {breakcodelet}});
        &remarrent ($bcindex, \@{$Awfif::memes-> {breaksubp}});
        };#if
      }#if
    else {
    $labcount = $Awfif::memes-> {binds}-> {$strategy}->
          ($myli, $sti, \@lab, $kwp, $kwpr, \@$sactset);

    $usedbice = '';
    if ($Awfif::codelet-> {l} [$myli][36] > 0) {

      $subp = $Awfif::codelet-> {l} [$myli][36];
      };# if - or if 0 subp will be undef
    if ((($linki = getilab ($myli, $strategy, $labcount, \@lab, \$hchain, $subp)) != 0)
    && ($hchain != 0)
    ) {#usebice cache setup

      $sigcount = usebice ($Awfif::ilabhcl-> {l} [$linki][4], \@lomatchs, \@lola, \@loconcs, \@lostrts, \@loends, \@logb, \@loge);
      $usedbice = 't';
      }#if
    else {

      $bcount = 0;
      $sigcount = labinv2 ($myli, \@lab, $labcount, \@lomatchs, \@lola, \@loconcs, \@lostrts, \@loends, \@logb, \@loge, 'notoporstbinding');
      };#else
# apply the linking function of group completion
# if the groups labels result in a match with a signal then raise the signal
#

    if ($sigcount > 0) {
      for ($i = 0; $i < $sigcount; $i++) {
        if ($lomatchs[$i]) {#there is a link launch the model scout
# ilncufilu1

# unless this is an operon where it should be filtered out
          if (($Awfif::jhls-> {l} [$lola[$i]][4] != $Awfif::memes-> {snnh}{operon}) && ($Awfif::jhls-> {l} [$lola[$i]][4] != $Awfif::memes-> {snnh}{stbinding}) && ($Awfif::jhls-> {l} [$lola[$i]][4] != $Awfif::memes-> {snnh}{subpstbinding})) {

            $Awfif::clp = ();
            if ((defined($myli))
            && ((!defined($Awfif::codelet-> {l} [$myli] [13]))
              or ((defined($Awfif::codelet-> {l} [$myli] [13])) && ($Awfif::codelet-> {l} [$myli] [13] == 0)))
            && (((defined ($Awfif::wsol-> {l} [awsoadr ($sti)] [8]) )
              && ( $Awfif::wsol-> {l} [awsoadr ($sti)] [8] != 0))
                      or (
                        $Awfif::wsol-> {l}[awsoadr ($sti)][ $Awfif::memes-> {wsologucount}]#*** submacrok ***#
                          != 0))) {&break()};
            $Awfif::clp-> {log} = $Awfif::codelet-> {l} [$myli][13];
            if ( (defined ($buildoffurg)) && ($buildoffurg)
            ){#

              $Awfif::clp-> {urgency} *= $Awfif::memes-> {pappbu};
              };#if
            if ( (defined ($remvboosturg)) && ($remvboosturg) ) {

              if ( (defined ($hiurg)) && ($hiurg) ) {

                $Awfif::clp-> {urgency} = (($Awfif::codelet-> {l} [$myli][3] * $Awfif::memes-> {evlaunchhim}) / $Awfif::memes-> {vbttoamxmult});#already hiurg
                }#if
              else {

                $Awfif::clp-> {urgency} = (($Awfif::codelet-> {l} [$myli][3] * $Awfif::memes-> {evlaunchm}) / $Awfif::memes-> {vbttoamxmult});
                };#else
              }#if
            elsif ( (defined ($hiurg)) && ($hiurg) ) {

              $Awfif::clp-> {urgency} = ($Awfif::codelet-> {l} [$myli][3] * $Awfif::memes-> {evlaunchhim});
              }#elsif
            else {

              $Awfif::clp-> {urgency} = ($Awfif::codelet-> {l} [$myli][3] * $Awfif::memes-> {evlaunchm});
              };#else
            if ($Awfif::codelet-> {l}[$myli][19] ne '') {

              $Awfif::clp-> {wsi} = $Awfif::codelet-> {l}[$myli][19];
              }#wsi set
            else {

              $Awfif::clp-> {wsi} = $Awfif::memes-> {currentwsbi};
              };
# ilnctgu
            if ( (defined ($usetrans)) && ( defined ($Awfif::jhls-> {l} [$lola[$i]][18])) ){#transactional protection
# there are transactionally protected members

              if ( ($usetrans > 0) ){#transaction id already allocated

                $Awfif::clp-> {action}-> {transid} = $usetrans;
                }#if
              else {#new transaction to setup

                $$transid = transalloc ($myli, $Awfif::memes-> {snnh} {transid}, $lola[$i], undef(), \$$transtatus);
                $Awfif::clp-> {action}-> {transid} = $$transid;
                };#else
              };#if
            if ((defined ($subprogram)) && ($subprogram > 0) ){#
# ilnctsubpu

              $Awfif::clp-> {action}-> {subpi} = $subprogram;
              }#if
            $Awfif::clp-> {strategy} = "tmodelscout";
            $Awfif::clp-> {action}-> {sponsor} = $sti;

            $Awfif::clp-> {action}-> {signal} = findsignal ($loconcs[$i]);
            $Awfif::clp-> {action}-> {schema} = $loconcs[$i];
            $Awfif::clp-> {action}-> {sws} = $Awfif::memes->{currentwsbi};
            $Awfif::clp-> {action}-> {wss} = $lostrts[$i];
            $Awfif::clp-> {action}-> {wse} = $loends[$i];
# ilncupoolu
            if (defined ($$usepooling)) {

              $usedpooling = 't';
              };#if
            if (($logb[$i] != 0)
            && ($logb[$i] != $loge[$i]) ){

              $Awfif::clp-> {action}-> {wsgs} = $logb[$i];
              $Awfif::clp-> {action}-> {wsge} = $loge[$i];
              };#operon has a gap
            $Awfif::clp-> {action}-> {jhlabeli} = $lola[$i];
# ilncolu
            $Awfif::clp-> {action}-> {jhlabeloi} = $Awfif::codelet-> {l} [$myli][30];
            $Awfif::clp-> {action}-> {wsoname} = 0;#models don't use a wso
# ilncmpu
            $newli = mcdsubmitcodelet ($myli, \$Awfif::clp, $mparams);
# ilncupoolu2

            if ($usedpooling){

              my ($linkp);
              $$usepooling = addpoolc ($newli, $$usepooling);#addpoolc will ensure the [38] of each codelet is the same across the elements in the list
              $linkp = $$usepooling;

              $Awfif::codelet-> {l} [ $Awfif::poolcl-> {l} [$linkp] [2] ] [38] = 1;#add to the pool
              };#if
            &trackcodelet ($myli, $newli, $Awfif::memes-> {snnh} {add});
            $launched = 't';
            $bcount++;
            if ( (defined ($$jhlabeli)) && (defined ($$jhlabeloi)) ){

              $$jhlabeli = $lola[$i];
              $$jhlabeloi = $Awfif::codelet-> {l} [$myli][30];
              };#if
            }; #if its not an operon
          };#launch the action scout
        };#for
      };
    if (!$launched) {

      break ();
      }#if
    elsif (!$usedbice) {

      &addilab ($myli, $strategy, $labcount, \@lab, addbice ($Awfif::memes-> {currentwsbi}, $bcount, 5, $sigcount, \@lomatchs, \@lola, \@loconcs, \@lostrts, \@loends, \@logb, \@loge), $subp);
      };#elsif
      };#else
    $Awfif::memes-> {currentwsbi} = $cwsbi;

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("ilaunchncx\n");
      };
    }# ilaunchnc
#
#<!-- start tag sia -->
#<!-- end tag sss -->
#
sub iasslnc {# inversion of part of ilaunchnc for subpid association
    my($myli, $sti, $strategy, $kwp, $kwpr, $sactset, $mparams, $usetrans, $transid, $subprogram, $jhlabeli, $jhlabeloi, $usetmass)=@_;
    my ($i, $cwsbi, $launched );

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      my ($pr);
      $pr = $Awfif::memes-> {currentwsbi};
      print ("iasslnc myli $myli ws $pr ");
      if (defined ($strategy)) {
        print ("strategy $strategy ");
        };#if
      if (defined ($mparams)) {
        print ("mparams $mparams ");
        };#if
      if (defined ($usetrans)) {
        print ("usetrans $usetrans ");
        };#if
      if (defined ($$transid)) {
        print ("transid $$transid ");
        };#if
      if (defined ($subprogram)) {
        print ("subprogram $subprogram ");
        };#if
      if (defined ($usetmass)) {
        print ("usetmass $usetmass ");
        };#if
      };
# updated for merged workspaces

    $cwsbi = $Awfif::memes-> {currentwsbi};
    $launched = '';
    my ($iedesc, $found, $bicei, $sponsor, $labcount, $sigcount, @lomatchs, @lola, @loconcs, @lostrts, @loends, @logb, @loge, $bcount);
    my (@lab);
    $found = '';
    $labcount = $Awfif::memes-> {binds}-> {$strategy}->
          ($myli, $sti, \@lab, $kwp, $kwpr, \@$sactset);
    $sponsor = $Awfif::codelet-> {l} [$myli] [21];
    $Awfif::memes-> {currentwsbi} = $Awfif::codelet-> {l} [$myli] [20];
    if ( ( ($iedesc = findtdesc ($Awfif::wsol-> {l} [ awsoadr ($sponsor)] [2], $Awfif::memes-> {snnh} {indequiv})) != 0)
    && (($bicei = $Awfif::workspace-> {l} [$iedesc] [3]) != 0)
    ){

      $sigcount = usebice ($bicei, \@lomatchs, \@lola, \@loconcs, \@lostrts, \@loends, \@logb, \@loge);
      }#if
    else {

      if ( ($Awfif::memes-> {ssiasslncusetmass})
      && ((!defined($usetrans)) or ($usetrans == 0))
      && (defined ($usetmass))
      && ($usetmass)
      && ($usetmass ne $Awfif::tral-> {l} [(getsubptransid ($myli, $subprogram))] [3])#this is being called from a codelet that knows the transid of the subcascade codelets is in its schematas tmassl and is not referenced by subpl[11]
      ){# no point

        $sigcount = 0;
        }#if
      else {

        $sigcount = labinv2 ($myli, \@lab, $labcount, \@lomatchs, \@lola, \@loconcs, \@lostrts, \@loends, \@logb, \@loge, 'notoporstbinding');
        };#else
      };#if
# apply the linking function of group completion
# if the groups labels result in a match with a signal then raise the signal
#

    if ($sigcount > 0) {
      my ($done, $i1, $i2, $i3, $match);
      $done = '';
      for ($i = 0; ((!$done) && ($i < $sigcount)); $i++) {
        if ($lomatchs[$i]) {#there is a link

# unless this is an operon
          $done = 't';
          if (($Awfif::jhls-> {l} [$lola[$i]][4] != $Awfif::memes-> {snnh}{operon}) && ($Awfif::jhls-> {l} [$lola[$i]][4] != $Awfif::memes-> {snnh}{stbinding}) && ($Awfif::jhls-> {l} [$lola[$i]][4] != $Awfif::memes-> {snnh}{subpstbinding})) {

            if ( (defined ($usetrans)) && ( defined ($Awfif::jhls-> {l} [$lola[$i]][18])) ){#transactional protection
# there are transactionally protected members

              if ( ($usetrans > 0) ){#transaction id already allocated

                $$transid = $usetrans;
                $found = 't';
                }#if
              elsif ((defined ($usetmass)) && ($usetmass) && ($usetmass eq $Awfif::tral-> {l} [($$transid = getsubptransid ($myli, $subprogram))] [3])) {#this is being called from a codelet that knows the transid of the subcascade codelets is in its schematas tmassl and is not referenced by subpl[11]

                if ($$transid > 0) {

                  $bcount++;
                  for ($i2 = 1; ((!$found) && ($i2 <= $Awfif::tral-> {i} [$$transid] [0])); $i2++){#each builder string in {i}

                    for ($i3 = 1; ((!$found) && ($i3 <= $Awfif::jhls-> {l} [$lola[$i]][18][0])); $i3++){#each builder string in {18}
                      if ($Awfif::tral-> {i} [$$transid][$i2] eq $Awfif::jhls-> {l} [$lola[$i]][18][$i3] ){

                        $found = 't';
                        };#if
                      };#for i3
                    };#for i2
                  };#if
                }
# iasslcu1
              else {#find the 'new' transaction setup by ilaunchnc

                $match = 1;
                $found = '';
# iasslcu2
# iterate until the transaction matches the builder to be sponsored
                for ($i1 = 1; ((!$found) && ($i1 <= $Awfif::subpl-> {l} [$subprogram] [11][0] )); $i1++ ){#each item in 11

                  for ($i2 = 1; ((!$found) && ($i2 <= $Awfif::tral-> {i} [$Awfif::subpl-> {l} [$subprogram] [11][$i1]] [0])); $i2++){#each builder string in {i}

                    for ($i3 = 1; ((!$found) && ($i3 <= $Awfif::jhls-> {l} [$lola[$i]][18][0])); $i3++){#each builder string in {18}
                      if ($Awfif::tral-> {i} [$Awfif::subpl-> {l} [$subprogram] [11][$i1]][$i2] eq $Awfif::jhls-> {l} [$lola[$i]][18][$i3] ){

                        $found = 't';
                        $match = $i1;#have a match for the codelet string between jhls of msublabel and builder strings in
                        };#if
                      };#for i3
                    };#for i2
                  };#for i1

                if ($found) {

                  $$transid = $Awfif::subpl-> {l} [$subprogram] [11][$match];#match the index to the transaction to be initiated
                  };#if
                };#else
              };#if

            if ($found) {

              $$jhlabeli = $lola[$i];#$done guards this $i
              $$jhlabeloi = $Awfif::codelet-> {l} [$myli][30];
              };#if
            }; #if its not an operon
          };#if use the link
        };#for
      }; #if
    if ( ( (!defined($bicei)) or ($bicei == 0)) && ($found)) {

      $bicei = addbice ($Awfif::memes-> {currentwsbi}, 1, 5, $sigcount, \@lomatchs, \@lola, \@loconcs, \@lostrts, \@loends, \@logb, \@loge);
      $Awfif::workspace-> {l} [$iedesc] [3] = $bicei;
      };#stable answer can be cached
    $Awfif::memes-> {currentwsbi} = $cwsbi;

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("iasslncx ");
      if (defined ($$jhlabeli)) {
        print ("jhlabeli $$jhlabeli ");
        };#if
      if (defined ($$jhlabeloi)) {
        print ("jhlabeloi $$jhlabeloi ");
        };#if
      print ("ret ($found)\n");
      };
    return $found
    }# iasslnc
#
#<!-- start tag ctr -->
#
sub findsubpicnm {# inversion of part of iasslnc for subpid transaction match
    my($myli, $subprogram, $submatch)=@_;
    my ($i1, $i2, $found, $match, $cwsbi, $ftransid, $fi );
    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("findsubpicnm myli $myli subprogram $subprogram submatch $submatch ");
      };
# updated for merged workspaces

    $cwsbi = $Awfif::memes-> {currentwsbi};

    $found = '';
    $match = 0;
    if ($subprogram > 0) {
# iterate until the transaction matches the builder to be sponsored
      for ($i1 = 1; ((!$found) && ($i1 <= $Awfif::subpl-> {l} [$subprogram] [11][0])); $i1++ ){#each item in 11

        for ($i2 = 1; ((!$found) && ($i2 <= $Awfif::tral-> {i} [$Awfif::subpl-> {l} [$subprogram] [11][$i1]] [0])); $i2++){#each builder string in {i}

          $ftransid = checksameas (undef(), $Awfif::subpl-> {l} [$subprogram] [11][$i1], $i2, \$fi);
          if ($Awfif::tral-> {i} [$ftransid][$fi] eq $submatch ){

            $found = 't';
            $match = $i1;#have a match for the codelet string between jhls of msublabel and builder strings in
            };#if
          };#for i2
        };#for i1
      };#if subprogram
    $Awfif::memes-> {currentwsbi} = $cwsbi;

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("findsubpicnmx ret ($match)\n");
      };
    return $match
    }# findsubpicnm
#
#<!-- end tag ctr -->
#<!-- end tag sia -->
#<!-- start tag dli -->
#
sub icompletesc {
    my ($myli, $strategy, $sponsor, $cws, $kwp, $kwpr, $sactset, $rbdwso) = @_;
    my ($launch);
# complete schematic structure when detect end sequence
#

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("icompletesc myli $myli strategy($strategy) sponsor($sponsor) ");
      };
    $launch = '';
    my (@typel, $sigcount, @lomatchs, @lola, @loconcs, @lostrts, @loends, @logb, @loge, $twso, $asponsor, $sldesc, $bdwso, $cwsbi, $aws);
    $twso = trwsoadr (fgrpend ($sponsor), 1);
    $asponsor = awsoadr ($sponsor);
    $typel[0] = wsbasetype (trwsoadr ($twso, -3));
    $typel[1] = wsbasetype (trwsoadr ($twso, -2));
    $typel[2] = wsbasetype (trwsoadr ($twso, -1));
    if ($strategy ne 'unbindbuilder'){

      $typel[2] = $Awfif::memes-> {snnh} {unbind};
      };#if

    $cwsbi = $Awfif::memes-> {currentwsbi};
    if ( (ifindb ($myli, $sponsor, 'binderc', \$sigcount, \@lomatchs, \@lola, \@loconcs, \@lostrts, \@loends, \@logb, \@loge, $$kwp, $kwpr, \@$sactset) == 1)
    ){#

      $bdwso = getfbws ($myli, $sigcount, \@lomatchs, \@lola, \$$cws);
      if (defined($rbdwso)){

        $$rbdwso = $bdwso;
        };#if
      my ($count, $descfits, $conforms);
      $Awfif::memes-> {currentwsbi} = $$cws;

      if ( ( ($sldesc = findtdesc ($Awfif::wsol-> {l} [ awsoadr ($bdwso)] [2], $Awfif::memes-> {snnh} {wsposition})) != 0 )
      && ($Awfif::workspace-> {l} [$sldesc] [2] != ($Awfif::memes-> {snnh} {wsi} + 0))
      && ( ($Awfif::memes-> {currentwsbi} = ($aws = ($Awfif::workspace-> {l} [$sldesc] [3] - $Awfif::memes-> {snnh} {wsi}))) != 0 )
      && (($count = ipartseqcount ('onematch', $myli, ($Awfif::workspace-> {l} [$sldesc] [2] - $Awfif::memes-> {snnh} {wsi}), trwsoadr(($Awfif::workspace-> {l} [$sldesc] [2] - $Awfif::memes-> {snnh} {wsi}), 3), \$descfits, \$conforms, $Awfif::wsbl-> {wsoh} [$aws], $Awfif::wsbl-> {wsft} [$aws],
        $Awfif::memes-> {snnh} {tokencategory}, $typel [0],
        $Awfif::memes-> {snnh} {tokencategory}, $typel [1],
        $Awfif::memes-> {snnh} {tokencategory}, $typel [2])>0))
      && ($conforms)
      && ($descfits)
      ){#launch builder

        $launch = 't';
        };#if
      };#if binderc
    $Awfif::memes-> {currentwsbi} = $cwsbi;

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("icompletescx cws($$cws) ret($launch)\n");
      };
    return $launch
    }# icompletesc
#
#
sub mapnonsubtotmgrid {# select the best (== first non-zero 35) zero subpid to map back a transaction mgr id
    my($atelhwso, $rtran, $subpid, $transid, $usehead)=@_;
    my ($linki, $transmgrid, @tranp);

no strict 'refs';
    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      my ($pr);
      $pr = $Awfif::memes-> {snnih} {$rtran};
      print ("mapnonsubtotmgrid atelhwso $atelhwso rtran $pr($rtran) subpid $subpid ");
      if (defined ($$transid)) {
        print ("transid $$transid ");
        };#if
      if (defined ($usehead)) {
        print ("usehead ($usehead) ");
        };#if
      };#if
    $transmgrid = 0;
    if ($Awfif::memes-> {nomapnonsubtotm}){#vbot GA must not use transactions

      if (defined ($$transid)){

        $$transid = 0;
        };#if
      }#if
    elsif (($subpid == -1) or ($subpid == 0)) {

      if ($rtran == $Awfif::memes-> {snnh} {stran}) {

        @tranp = \@{$Awfif::tmassl-> {s}};
        }#if
      elsif ($rtran == $Awfif::memes-> {snnh} {rtran}) {

        @tranp = \@{$Awfif::tmassl-> {r}};
        };#elsif
# see if get a transid and subpid from the transmgr
      if ((defined ($Awfif::tmassl-> {l} [$Awfif::tmassl-> {wsot}{$atelhwso}][2])) && ($Awfif::tmassl-> {l} [$Awfif::tmassl-> {wsot}{$atelhwso}][2] > 0)) {

        my ($it, $inc, $found, $found0, $found35, $found35val);
        $inc = 0;
        $found = '';
        if ((defined ($usehead)) && ($usehead)) {
          $linki = $Awfif::tmassl-> {wsoh}{$atelhwso};
          }#if
        else {
          $linki = $Awfif::tmassl-> {wsot}{$atelhwso};
          };#else
        while (($linki != 0) && (!$found)){

          $found0 = '';
          $found35 = 0;
          $found35val = 0;
          for ($it = 1; (($it <= $Awfif::tmassl-> {l} [$linki][2]) && (!$found)); $it ++) {

            if ( ($tranp [0][$linki] [$it] [0] == $Awfif::memes-> {snnh}{codeletslice} )
            && ($tranp [0][$linki] [$it] [1] == 36)
            && ($tranp [0][$linki] [$it] [2] == 0)
            ){

              $found0 = 't';
              };#if

            if ( ($tranp [0][$linki] [$it] [0] == $Awfif::memes-> {snnh}{codeletslice} )
            && ($tranp [0][$linki] [$it] [1] == 35)
            && ($tranp [0][$linki] [$it] [2] > 0)
            ){

              $found35 = $tranp [0][$linki] [$it] [2];
              };#if
# mapnons35valu1
            if ( ($tranp [0][$linki] [$it] [0] == $Awfif::memes-> {snnh}{codeletslice} )
            && ($tranp [0][$linki] [$it] [1] == 35)
            && ($tranp [0][$linki] [$it] [2] == 0)
            && (defined ($tranp [0][$linki] [$it] [3]) )
            ){

              $found35val = $tranp [0][$linki] [$it] [3];
              };#if
            };#for
          if ( ($found35 != 0) && ($found0) ){

            $transmgrid = $linki;
            if (defined ($$transid)){

              $$transid = $found35;
              };#if
            $found = 't';
            }#if
          elsif ( ($found35val != 0) && ($found0) && (defined($Awfif::tral-> {sameash} [$found35val]))){
# mapnons35valu2

            $transmgrid = $linki;
            if (defined ($$transid)){

              $$transid = $found35val;
              };#if
            };#else
          if ((defined ($usehead)) && ($usehead)) {
            $linki = $Awfif::tmassl-> {l} [$linki][0];#move to the tail
            }#if
          else {
            $linki = $Awfif::tmassl-> {l} [$linki][1];#move to the head
            };#else
          };#while
        };#if
      };#if

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("mapnonsubtotmgridx ");
      if (defined ($$transid)) {
        print ("transid $$transid ");
        };#if
      print ("ret ($transmgrid)\n");
      };
    @tranp = ();
    return $transmgrid
    }# mapnonsubtotmgrid
#
#<!-- start tag vbt -->
#
sub checksameas {# see if there is a sameas match and can resolve the proc in which case use its transid
    my($myli, $itransid, $trindex, $findex)=@_;
    my ($i, $activetransid, $found);

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("checksameas myli $myli itransid ($itransid) trindex($trindex) ");
      };#if

    $activetransid = $itransid;
    $$findex = $trindex;
# now ensure that the sameas applies to this procedure

    if ( defined ($Awfif::tral-> {sameas} [$itransid] [$trindex] [1] )
    && ($Awfif::tral-> {sameas} [$itransid] [$trindex] [1] == $Awfif::memes-> {snnh} {valid} )
    ){

      $activetransid = $Awfif::tral-> {sameas} [$itransid] [$trindex] [0];
      for ($i = 1; ((!$found) && ($i <= $Awfif::tral-> {i} [$activetransid] [0])) ; $i++ ){
        if ($Awfif::tral-> {i} [$activetransid] [$i] eq $Awfif::tral-> {i} [$itransid] [$trindex]){

          $$findex = $i;
          $found = 't';
          };#if
        };#for
      };#if

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("checksameasx findex($$findex) ret ($activetransid)\n");
      };
    return $activetransid
    }# checksameas
#
#<!-- end tag vbt -->
#
sub crsmann {
    my ($myli, $token, $targsel, $stwso, $sponsortype, $ivalc, $ival, $casefor, $target, $eos, $bws, $bbwso, $kwp, $kwpr, $sactset) = @_;
    my ($sponsor, $recordi, $lrecordi, $arecordi, $foundgap, $bcount, $cwsbi, $abbwso);
#
# checked for merged workspaces
    my ($proceed, $msws, $msb, $listi, $i);
    $cwsbi = $Awfif::memes-> {currentwsbi};
    $Awfif::memes-> {currentwsbi} = $Awfif::codelet-> {l} [$myli] [20];
    if (($proceed = ibawswalk ($myli, $sponsor, $stwso, 'binderp1', 'bindercs', \@$sactset, \$bcount, \$msws, \$msb, \$$bws, \$$bbwso) )){
      $foundgap = '';#undefined found -> no list; false found -> list but no missing models; true -> found missing models
      };#if
    if ($proceed) {#walk the workspace identifying case descriptors that are not associated with a model

      $Awfif::memes-> {currentwsbi} = $$bws;
      $abbwso = awsoadr ($$bbwso);
# now pickup the listlink
      if (($listi = findtdesc ($Awfif::wsol-> {l} [ $abbwso] [2], $Awfif::memes-> {snnh} {listlink})) != 0
      ){
# now convert the listi to reference the first list record

        $listi = ($Awfif::workspace-> {l} [$listi] [2] - $Awfif::memes-> {snnh} {wsi});
# now get the first record link descriptor and then turn it into the record wso index
        if ( (($recordi = findtdesc ($Awfif::wsol-> {l} [ ($arecordi = awsoadr ($listi))] [2], $Awfif::memes-> {snnh} {recordlink})) != 0)
        ){
# now check each record until get a match or run out - move in to the first record

          $recordi = ($Awfif::workspace-> {l} [$recordi] [2] - $Awfif::memes-> {snnh} {wsi});
          $arecordi = awsoadr ( $recordi);
          $foundgap = findgap ($myli, $arecordi, $Awfif::wsol-> {l} [$arecordi] [2], $Awfif::memes-> {snnh} {casinopp}, $sponsortype, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {casemodel}, $Awfif::memes-> {snnh} {casedeploys}, $token, $Awfif::memes-> {snnh} {ivalue});
          };#if
# now process each record until reach end of stream

        while ( donelement ($myli, \$recordi, \$lrecordi, \$arecordi, \$$eos)
        ){
          $foundgap = findgap ($myli, $arecordi, $Awfif::wsol-> {l} [$arecordi] [2], $Awfif::memes-> {snnh} {casinopp}, $sponsortype, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {casemodel}, $Awfif::memes-> {snnh} {casedeploys}, $token, $Awfif::memes-> {snnh} {ivalue});
          $recordi = ($Awfif::workspace-> {l} [$recordi] [2] - $Awfif::memes-> {snnh} {wsi});
          if (((defined ($foundgap)) && ($foundgap))
          && ($bcount == 1)
          ){#find all ivalue descriptors in the record so that can match them to parameterized model

            my (@modeled);
            $$ivalc = listival ($myli, $$bws, $lrecordi, $arecordi, \@$ival, $token, \@modeled);
# if find a record without a model

            for ($i = 0; (($i < $$ivalc) && ((!defined ($modeled[$i])) or (!$modeled[$i])) );$i++) {

              &findcot ($myli, $token, $targsel, \@$ival, $i, \$casefor, \$target);
              if ((defined ($target)) && (defined ($casefor))) {

                &depcmodel ($myli, $$bws, $lrecordi, $arecordi, $token, $casefor, $target);
                $target = undef ();
                $casefor = undef ();
                };#if report success
              };#for
            };#if
# check if the subprogram has been completed

          if ( (endsubpstream ($myli, $arecordi, $abbwso))
          && (bcsubpcompsub ($myli) )
          ){#its a subprogram's last record and the bcsubpc has completed

            $$eos = 't';
            }#if
          elsif ( ($Awfif::codelet-> {l} [$myli] [36] == 0)
          && ((findtdesc ($Awfif::wsol-> {l} [ $arecordi] [2], $Awfif::memes-> {snnh} {listend})) != 0)
          ){

            $$eos = 't';
            };#elsif
          };#while
        };#if
      };# if

    $Awfif::memes-> {currentwsbi} = $cwsbi;
    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("crsmannx ivalc($$ivalc) casefor($$casefor) target($$target) eos($$eos) bws($$bws) bbwso($$bbwso)\n");
      };
    }# crsmann
#
#
sub getf1tmgr {# associate sub-programs with parents
    my($myli, $atelhwso, $asponsor, $subpid, $transid, $transmgrid, $csubs, $nocompleted)=@_;
    my ($result, @tranp, @f1sub, $cwsbi);

no strict 'refs';
    $cwsbi = $Awfif::memes-> {currentwsbi};
    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("getf1tmgr myli $myli atelhwso $atelhwso ");
      if (defined ($subpid)) {
        print ("subpid $subpid ");
        };#if
      if ($Awfif::memes-> {tmasstrace}) {
        $Awfif::memes-> {currentwsbi} = $Awfif::codelet-> {l} [$myli] [20];
        &ittmassoutput (grwsoadr ($atelhwso), $Awfif::codelet-> {l} [$myli] [20]);
        $Awfif::memes-> {currentwsbi} = $cwsbi;
        };#if
      };#if

    $result = 0;
    @tranp = \@{$Awfif::tmassl-> {r}};
# see if get a transid and subpid from the transmgr
    if ((defined ($Awfif::tmassl-> {l} [$Awfif::tmassl-> {wsot}{$atelhwso}][2])) && ($Awfif::tmassl-> {l} [$Awfif::tmassl-> {wsot}{$atelhwso}][2] > 0)) {

      @f1sub = getf1list ($myli, $atelhwso, $subpid, $nocompleted);

      if (($f1sub [0] > 0)){

        my ($s35, $i, $i2, $compc, $trans, @f1comp);
        if ((defined ($csubs)) && ($$csubs [0] > 0)){
          for ($i = 1; $i <= $f1sub[0]; $i++) {#capture any completed subprograms

            $trans = $Awfif::subpl-> {l} [$f1sub[$i]][11] [$Awfif::subpl-> {l} [$f1sub[$i]][11][0]];
            if ($trans > 0) {

              $compc = 0;
              for ($i2 = 1; $i2 <= $Awfif::tral-> {i}[ $trans] [0];$i2++) {

                if ($Awfif::tral-> {w} [$trans] [$i2] == $Awfif::memes-> {snnh} {completed}) {

                  $compc++;
                  if (($compc == $Awfif::tral-> {i}[ $trans] [0]) #all active parts of the transaction are completed
                  && (matchaelement (\@$csubs, $f1sub [$i]) > 0)#if its also in the set of completed sub-programs then it is complete
                  ){

                    $f1comp [++$f1comp [0]] = $f1sub [$i];
                    };#if
                  };#if
                };#for
              };#if
            };#for
          };#if
        if ($f1comp [0] > 0) {

          $result = $f1comp [1 + int (rand($f1comp [0]))];#weighted to completed
          }#if
        else {

          $result = $f1sub [1 + int (rand($f1sub [0]))];#
          };#else
        $$transmgrid = mapsubtotmgrid ($asponsor, $Awfif::memes-> {snnh} {stran}, $result);
        $s35 = 35;
        &gettmass ($myli, $asponsor, $Awfif::memes-> {snnh} {stran}, $$transmgrid, $Awfif::memes-> {snnh} {codeletslice}, \$s35, \$$transid);
        };#if
      };#if

    $Awfif::memes-> {currentwsbi} = $cwsbi;
    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("getf1tmgrx ");
      if ( (defined ($$transmgrid)) ){
        print ("transmgrid $$transmgrid ");
        };#if
      if ( (defined ($$transid)) ){
        print ("transid $$transid ");
        };#if
      print ("ret ");
      print ("($result)\n");
      };
    @tranp = ();
    return $result
    }# getf1tmgr
#
sub getf1list {# associate sub-programs with parents
    my($myli, $atelhwso, $subpid, $nocompleted)=@_;
    my ($linki, @tranp, @f1sub, $cwsbi);

no strict 'refs';
    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("getf1list myli $myli atelhwso $atelhwso ");
      if (defined ($subpid)) {
        print ("subpid $subpid ");
        };#if
      };#if

    $cwsbi = $Awfif::memes-> {currentwsbi};
    @tranp = \@{$Awfif::tmassl-> {r}};
# see if get a transid and subpid from the transmgr
    if ((defined ($Awfif::tmassl-> {l} [$Awfif::tmassl-> {wsot}{$atelhwso}][2])) && ($Awfif::tmassl-> {l} [$Awfif::tmassl-> {wsot}{$atelhwso}][2] > 0)) {

      my ($it, $found);
      $linki = $Awfif::tmassl-> {wsot}{$atelhwso};
      $f1sub [0] = 0;
      while ($linki != 0){

        $found = '';
        for ($it = 1; (($it <= $Awfif::tmassl-> {l} [$linki][2]) && (!$found)); $it ++) {

          if ( ($tranp [0][$linki] [$it] [0] == $Awfif::memes-> {snnh}{assocf1} )
          && (($subpid == -1)#want a list of all subpids
            or ($tranp [0][$linki] [$it] [1] == $subpid) )
          && (((!defined ($nocompleted) or (!$nocompleted)))
            or ((subpstate ($tranp [0][$linki] [$it] [2]) != $Awfif::memes-> {snnh} {completed})) )
          ){

            $f1sub [++$f1sub [0]] = $tranp [0][$linki] [$it] [2];
            };#if
          };#for
        $linki = $Awfif::tmassl-> {l} [$linki][1];#move to the head
        };#while
      };#if

    $Awfif::memes-> {currentwsbi} = $cwsbi;
    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("getf1listx ");
      print ("ret ");
      print ("($f1sub[0])\n");
      };
    @tranp = ();
    return @f1sub
    }# getf1list
#
#
sub spicompsub {# see if this subprogram transaction part is complete according to a completion report - Should only be used to encourage other codelets in the part to run
    my($myli, $strategy)=@_;
    my ($result, $subi, $sponsor, $subpid, $i, $isubpt, $cwsbi, $ftransid, $fi);

no strict 'refs';
    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("spicompsub myli $myli ");
      };#if

    $cwsbi = $Awfif::memes-> {currentwsbi};
    $result = '';
    $Awfif::memes-> {currentwsbi} = $Awfif::codelet-> {l} [$myli] [20];
    $subpid = $Awfif::codelet-> {l} [$myli][36];
    $sponsor = $Awfif::codelet-> {l} [$myli][21];
    if (($subpid > 0)
    && (defined ($Awfif::subpl-> {l} [$subpid] [11][0]))
    ) {
# and transaction managed

      my ($sigcount, $bcwso, $abcwso, $cws, $reportdesc, $areportwso, @lomatchs, @lola, @loconcs, @lostrts, @loends, @logb, @loge);
      if ( (ifindb ($myli, $sponsor, $strategy, \$sigcount, \@lomatchs, \@lola, \@loconcs, \@lostrts, \@loends, \@logb, \@loge, undef(), undef(), \@{$Awfif::memes-> {sactset}}) == 1)
      ){#

        $bcwso = getfbws ($myli, $sigcount, \@lomatchs, \@lola, \$cws);
        $Awfif::memes-> {currentwsbi} = $cws;
        $abcwso = awsoadr ($bcwso);
        if (($reportdesc = findtdesc ($Awfif::wsol-> {l} [($abcwso)] [2], $Awfif::memes-> {snnh} {completed})) != 0 ){

          for ($isubpt = 1; ((!$result) && ($isubpt <= $Awfif::subpl-> {l} [$subpid] [11][0])); $isubpt++) {#look through subp for transaction match with caller

            if (($subi = matchsubtbname ($myli, $isubpt)) != 0) {#use the matching sub to check transaction status
              for ($i = 1; ((!$result) && ($i <= $Awfif::tral-> {i}[$Awfif::subpl-> {l} [$subpid] [11][$isubpt]] [0])); $i++) {#look at each

                $ftransid = checksameas (undef(), $Awfif::subpl-> {l} [$subpid] [11][$isubpt], $i, \$fi);
                if ($Awfif::tral-> {w}[$ftransid] [$fi] == $Awfif::memes-> {snnh} {completed}) {

                  $Awfif::memes-> {currentwsbi} = ($Awfif::workspace-> {l} [$reportdesc] [3] - $Awfif::memes-> {snnh} {wsi});
                  $areportwso = awsoadr (($Awfif::workspace-> {l} [$reportdesc] [2] - $Awfif::memes-> {snnh} {wsi}));
                  if (( (findbond ($Awfif::wsol-> {l} [ $areportwso] [2], $Awfif::codelet-> {l} [$myli] [36], $Awfif::memes-> {snnh} {completed}, $Awfif::memes-> {snnh} {subprogram})))) {

                    $result = 't';
                    };#if
                  };#if
                };#for $i
              };#if
            };#for $isubp
          };#if report defined
# then return true
        };#if
      };#if

    $Awfif::memes-> {currentwsbi} = $cwsbi;
    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("spicompsubx ");
      print ("ret ");
      print ("($result)\n");
      };
    return $result
    }# spicompsub
#
sub bcsubpcompsub {# see if bcsubpc is complete according to a completion report - Should only be used to encourage other codelets in the part to run
    my($myli)=@_;
    my ($result, $sponsor, $subpid, $cwsbi);

no strict 'refs';
    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("bcsubpcompsub myli $myli ");
      };#if

    $cwsbi = $Awfif::memes-> {currentwsbi};
    $result = '';
    $Awfif::memes-> {currentwsbi} = $Awfif::codelet-> {l} [$myli] [20];
    $subpid = $Awfif::codelet-> {l} [$myli][36];
    $sponsor = $Awfif::codelet-> {l} [$myli][21];
# if subpid
    if (($subpid > 0)
    && (defined ($Awfif::subpl-> {l} [$subpid] [11][0]))
    ) {
# and transaction managed

      my ($sigcount, $bcwso, $abcwso, $cws, $reportdesc, $areportwso, @lomatchs, @lola, @loconcs, @lostrts, @loends, @logb, @loge);
      if ( (ifindb ($myli, $sponsor, 'bindercs', \$sigcount, \@lomatchs, \@lola, \@loconcs, \@lostrts, \@loends, \@logb, \@loge, undef(), undef(), \@{$Awfif::memes-> {sactset}}) == 1)
      ){#

        $bcwso = getfbws ($myli, $sigcount, \@lomatchs, \@lola, \$cws);
        $Awfif::memes-> {currentwsbi} = $cws;
        $abcwso = awsoadr ($bcwso);
        if (($reportdesc = findtdesc ($Awfif::wsol-> {l} [($abcwso)] [2], $Awfif::memes-> {snnh} {completed})) != 0 ){

          $Awfif::memes-> {currentwsbi} = ($Awfif::workspace-> {l} [$reportdesc] [3] - $Awfif::memes-> {snnh} {wsi});
          $areportwso = awsoadr (($Awfif::workspace-> {l} [$reportdesc] [2] - $Awfif::memes-> {snnh} {wsi}));
          if (( (findbond ($Awfif::wsol-> {l} [ $areportwso] [2], $Awfif::codelet-> {l} [$myli] [36], $Awfif::memes-> {snnh} {completed}, $Awfif::memes-> {snnh} {subprogram})))) {

            $result = 't';
            };#if
          };#if
# then return true
        };#if
      };#if

    $Awfif::memes-> {currentwsbi} = $cwsbi;
    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("bcsubpcompsubx ");
      print ("ret ");
      print ("($result)\n");
      };
    return $result
    }# bcsubpcompsub
#
sub matchsubtbname {# identify the callers buildername, see if it matches a transaction recipient and return true if it does
    my($myli, $isubpt)=@_;
    my ($result, $subpid, $i, $cwsbi, $procname, $codeletname);

no strict 'refs';
    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("matchsubtbname myli $myli isubpt $isubpt ");
      };#if

    $cwsbi = $Awfif::memes-> {currentwsbi};
    $result = 0;
    $Awfif::memes-> {currentwsbi} = $Awfif::codelet-> {l} [$myli] [20];
    $subpid = $Awfif::codelet-> {l} [$myli][36];
# identify the callers builder name
# now check for a match to the transaction sponsor
    for ($i = 1; ( (!$result) && ($i <= $Awfif::tral-> {i} [ $Awfif::subpl-> {l} [$subpid] [11][$isubpt] ] [0])); $i++) {
      if ($Awfif::tral-> {i} [$Awfif::subpl-> {l} [$subpid] [11][$isubpt] ] [$i] eq $codeletname) {

        $result = $i;
        };#if
      };#for

    $Awfif::memes-> {currentwsbi} = $cwsbi;
    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("matchsubtbnamex ");
      print ("ret ");
      print ("($result)\n");
      };
    return $result
    }# matchsubtbname
#
#<!-- start tag sia -->
#<!