Virtual robot
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

Virtual Robot genetic algorithm

Summary
This page discusses a 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
) implementation of a
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 algorithm
(GA), Melanie Mitchell's robot-janitor built as a set of
This page discusses the interdependence of perception and representation in a complex adaptive system (CAS).  Hofstadter and Mitchell's research with Copycat is reviewed. 
Copycat
codelets integrated using agent-based programming.  The improvement in the operation of the robots over succeeding generations of applying the GA is graphed

The CAS that generated, and operated the robot is reviewed, including the implementation details and codelet operational program flow, and the challenges and limitations of this implementation. 

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 strings
which make up the robot's genotype is the set of control structures and recipes which describe how to construct an emergent system such as a cell or body.  The constructed system is the phenotypic expression of the genotype. 
, as well as the
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
which are sent to the nucleus, a membrane bounded module in a eukaryotic cell where the DNA is encapsulated and operated on. 
of the robot's agents so that the agents can deploy the appropriate response strings (which activate codelets) are listed.  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
configuration required by the system to associate the schematic strings with programmatic forces (codelets) is also listed.  The codelets and supporting perl are also listed

In the conclusion the limitations of the robot-janitor abstraction in studying
This page discusses the mechanisms and effects of emergence underpinning any complex adaptive system (CAS).  Key research is reviewed. 
emergence
and creative
This page reviews the implications of selection, variation and heredity in a complex adaptive system (CAS).  The mechanism and its emergence are discussed. 
evolution
are discussed and alternative experimental frameworks are proposed.  One such, the schematic cell is the subject of a
This page describes a schematic system about abstracted 'animal' and 'plant' cells competing in a small world. 
The schematic cell was designed to focus in on the nature of mutation and the adjacent possible. 
THE IMPLEMENTATION IS INCOMPLETE AND ONGOING. 
The codelets and infrastructure are included. 
separate page
in this web frame

Introduction
The adaptive web framework (AWF) virtual robot is a
This page discusses the interdependence of perception and representation in a complex adaptive system (CAS).  Hofstadter and Mitchell's research with Copycat is reviewed. 
Copycat (perception & representation)
based instantiation of Melanie Mitchell's robot-janitor.  As such Copycat codelets implement Holland's
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 algorithm(GA)
to apply pressure to a population of
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
to improve their compatibility and access to well matched niches within the robot-janitor's
This web page reviews opportunities to find and capture new niches based on studying fitness landscapes using complex adaptive system (CAS) theory. 
fitness landscape


With the test statement (vbt01) AWF's
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
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. 
ensures
each of the two hundred different robots in the population is set the 'simple goal' of wandering around its environment and picking up cans.  In a development phase the environment has been deployed and the cans have been built and deployed randomly into the environment.  Each robot is tested in a variety of can deployments to improve the GA's selection process. 

The robot's who achieve the best relative scores are then selected to supply the schematic strings that are used to develop the next generation of competitors.  Over 1000 generations the schemata are seen to change as the genetic algorithm parallel searches the population and schema space for improved competitive advantage in scoring points for picking up cans and not getting penalties. 

The focus of the GA is on alterations to the schemata in the area of decisions about actions associated with picking up cans.  This is legitimate since while other schematic changes may impact the fitness of the robot they will be independent.  As such they will only slow down the actions of the GA.  Hence the focus can be viewed as an optimization. 

The use of explicit fitness, in Mitchell's scenario, overcomes major challenges for
This page discusses the mechanisms and effects of emergence underpinning any complex adaptive system (CAS).  Key research is reviewed. 
emergent
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. 
agents
and their
This page reviews the implications of selection, variation and heredity in a complex adaptive system (CAS).  The mechanism and its emergence are discussed. 
evolution
.  Typically the contribution of an action to an agent's fitness will only become obvious after many other adaptive events have occurred.  For the virtual robot the results are available as soon as the action has been performed.  This considerably simplifies both the
The agents in complex adaptive systems (CAS) must model their environment to respond effectively to it.  Samuel modeling is described as an approach. 
modeling
and genetic algorithm. 
Virtual robot system implementation
The AWFvbot operates in an environment defined by a Meta file is loaded by the adaptive web framework's (AWF) Smiley.  It defines the application system's basic rules, its keywords and their properties and the form of the assertion or implementation statement the application uses.   which indirectly includes:
Board model naming map
00
10

..
..
80
90
01
11
21



91

12



















08
18



88
98
09
19
29
..
..
89
99

A robot developed using
This presentation applies complex adaptive system (CAS) agents to computer programming. 
agent-based programming
AWFvbot extends Mitchell's GA requiring the use of active AWF
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
structures to implement the robots.  This is because in AWF the genetic strings interact with the VBOT agents through a simulation of cellular 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. 
.  The codelets which drive the actions of the agents use signals to the nuclear genetic strings to initiate transcription is the process where DNA is converted into messenger m-RNA.  A complex of enzymes cooperates to bind to the DNA and generate the m-RNA copy.  There are a number of such transcription complexes which are based on RNA polymerase I, II or III. 
of follow-on codelets.  This
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 mechanism
allows the genetic strings to influence the form and function of the agents is the system that results from the controlled expression of the genes.  It is typically represented by a bacterial cell or the body of a multi-cell animal or plant.  The point is that the genes provide the control surface and the abstract recipe that has been used to generate the cell. 
through the composition of the aggregate of codelets transcribed.  The workspace structures include:
As such the schemata
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
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. 
phenomena
and
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
with
The agents in complex adaptive systems (CAS) must model their environment to respond effectively to it.  Samuel modeling is described as an approach. 
models
and
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. 
actions


With these additional constraints a
This page discusses the interdependence of perception and representation in a complex adaptive system (CAS).  Hofstadter and Mitchell's research with Copycat is reviewed. 
perception and representation architecture
can be implemented.  This architecture enables fully emergent models and action agents to support the development of perceptive robots. 

Mitchell designs the full range of complementary receptors, in biological cells these proteins are able to span the cell membrane and present an active site which is tailored to interact with a specific signal.  When the receptor pairs with its signal, its overall shape changes resulting in changes in the part internal to the cell which can be relayed by the cells signalling infrastructure.  In neuron synapses one type of receptor (fast) is associated with an ion channel.  The other (slow) is associated with a signalling enzyme chain and modulates the neuron's response. 
based on her analysis of the environment, and associates each, and every, specific environmental possibility with a potential genetic action.   The AWFvbot's modeling codelets should become aggregates and associate the best action agents purely through the action of the genetic operators on the vbot's schemata.  In a fully emergent implementation the robot's grab bag of codelet based tools is all that it has to fashion receptors that can respond effectively to the various situations that can arise.  It is helped by the environment and cans being developed with these same tools.  But the initial AWF modeling codelets are not emergent either.  They were also predesigned as an aggregate to model the total robot world. 

By making an individual robot a 'c is a small portable computer programming language developed by Dennis Ritchie of AT&T Bell Labs to support implementaton of a portable UNIX operating system. 
' data structure mapping each situation to an action that the GA code can directly perform, Mitchell's GA will execute a test run very efficiently on a computer and regular operating system.  Her goal is to evolve effective strategies, so how the robots execute, and are described by data structures, is not important.  Her GA 'c' code implementation can be written to solve this specific 'pickup cans in square' problem only. 

In contrast the AWFvbot goals required that the data structures allow emergence and the agents be Copycat codelet aggregates.  With these additional constraints the operational overheads expand illuminating a number of typical hurdles faced by evolving CAS agents.  These hurdles provide genetic operators with opportunities for niche exploration and competitive specialization. 

Mitchell's evolution process, instantiated within the GA,  implements an optimizing subset of
This page reviews the implications of selection, variation and heredity in a complex adaptive system (CAS).  The mechanism and its emergence are discussed. 
natural selection
's effects, and does not apply
This page describes the consequences of the asymmetries caused by genotypic traits creating a phenotypic signal in males and selection activity in the female - sexual selection.   
The impact of this asymmetry is to create a powerful alternative to natural selection with sexual selection's leverage of positive returns.  The mechanisms are described. 
sexual selection
at all. 
Program flow
When the test statement (vbt01) is deployed into a Workspace its operons is an addressable control structure which is used in biological cells to control access to other regions of the DNA. 
are acted on by bottom up group codelets sponsored by 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
.  But as the operons group complete and deconstruct the test specification they initiate deployment of a cascade of top down codelets.  The flow of codelets depends on the schematic associations which are logically of the form:
  1. part and statement codelets validate the test statement.  If it is well formed the statement builder terminates AWFvbot development inhibitors allowing
  2. development (vbtdev) codelets to initiate a
    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
    which sets up the:
  3. Once freed from inhibition by deployment of the development cascade completion descriptor a testing initiator vbtiop codelet sets up the Workspace environment for the first test and signals the nuclear operon which includes the test manager agent aggregate.  The vbtiop codelet checks for any history of agent memetic strings using retrievevbtgmfromfiles.  The $Awfif::vbotga record structure includes the 0, and current generations memetic schemata loaded from the file. 
  4. The test manager agent includes:
    1. vbttm builder then signals the nuclear operon which includes the vbot model aggregate
      1. The vbot model codelet which matches the current environment of the robot signals its schematically associated action: move north, south, east, west or random; or pick up can.
      2. The action codelet signalled, such as vbttoams, evaluates its appropriateness, and if so the builder performs its actions.  This includes 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. 
        the vbttm codelet sustaining a cycle. 
  5. The vbtiop builder nuclear operon also includes sub operons for the:
Gaining time to operate the test
A major practical challenge in executing the genetic algorithm is the time taken to setup the infrastructure and for the robots to perform each test run.  The import of schematic strings which define the robots is so costly using Smiley's convbws that Mitchell's proposed strategy of importing each robot's schemata when they are selected to perform was abandoned.  Instead the template for one robot is imported and then transformed to generate the other robot's schemata. 

The competition between codelets to deploy and execute consumes CPU time.  In particular the signalling of all the model evaluators, initiating deployment of move action codelets creates contention for the CPU.  To overcome this typical challenge (contstraint on flows) faced by competing agents a number of Smiley based strategies exist:
These strategies start to contribute once the codelets and environment have interacted to drive deployment of the most aligned models and actions.  As in most emergent systems the development phase includes a considerable period when agents develop to cope with their environment. 

Still with Mitchell's parameters a Copycat based system takes a very considerable time to execute even a structurally optimized strategy, which must still include: the local set of model evaluators and the specific model builder, and action evaluator and builder.  As Eric Kandel demonstrated, in focusing on the giant marine snail Aplysia, a giant Californian marine snail has a limited neural network and large neurons.  Eric Kandel used it as an experimental system for studying neurons and was able to explain how long term memory is recorded by the Aplysia neurons. 
, it is worth searching for a more optimized test system.  So:
  • The vbot's parameters were reduced. 
  • Execution of various traps (repeated crashing into wall, repeated failed can pickup, two point repeated 'loop';) were identified in the inverted vbttoa[xx]builders and driven to vbot instance test completion. 
Test statement structures the test activities
vbot schemata deal with the test statement deconstruction: part whole (development), part valid, part constrained, statement whole.  Since the vbot statement (vbt01) is formed from standalone component parts partintegrated will become true when pmmanevaluator runs and sees that all the low level models indicate the parts are standalone.  vbot schemata also control:
The test platform
The infrastructure platform supporting the AWFvbot includes:
Conclusions
The vbot system allowed the integration of CAS architecture with a genetic algorithm.  But this agent-based infrastructure did not have sufficient performance to operate the agents unaided to complete Mitchell's goal.  The simple nature of the goal for a human, or programmer, was beyond the capabilities of the system that was constructed to achieve without compromising the CAS architecture.  So overall the system did not support the study of emergence or exploration of fitness landscapes.  Still the limitations and work-arounds were revealing. 
Limitations of the initial implementation
The vbot is a poor
The agents in complex adaptive systems (CAS) must model their environment to respond effectively to it.  Samuel modeling is described as an approach. 
model
for a true living system.  The world sensing model codelets, such as vbttom00c10c01, are not
This page discusses the mechanisms and effects of emergence underpinning any complex adaptive system (CAS).  Key research is reviewed. 
emergent
.  They are blessed with a priori awareness of wall, can and empty.  This feature could be replaced with emergent mechanisms and operations. 
Adding emergence to the Vbot
But to wander around a square, looking for and picking up cans, is really a sophisticated activity.  The emergent animals able to perform equivalent tasks, have integrated vision, and movement.  The vision systems are supported by 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. 
which transform the visual signals into cooperating models that associate 'can' signals with can actions, and place the can and animal within a positional framework. 

The movevbot utility directly maps 'wall' to a constraint on movement.  That limitation on movement should instead emerge from the underlying physics and chemistry.  As a consequence of there being no Slipnet relation between the concepts wall and a square keyword direct movement translations based on trwsoadris a Workspace list operation which moves the focus of the Smiley list infrastructure from the current Workspace object (WSO) being operated on forwards or backwards along the WSO list. 
should be rejected.  That leaves the virtual robot system the opportunity to search the
This web page reviews opportunities to find and capture new niches based on studying fitness landscapes using complex adaptive system (CAS) theory. 
adjacent possible
for ways over the wall, if that created competitive advantage.

The
This page reviews the implications of selection, variation and heredity in a complex adaptive system (CAS).  The mechanism and its emergence are discussed. 
evolutionary
improvement of the virtual robot's strategies based on competitive exploration of the adjacent possible demonstrates how the robot's grab bag of tools can be used
This page discusses the mechanisms and effects of emergence underpinning any complex adaptive system (CAS).  Key research is reviewed. 
emergently


vbot specialized data structures
vbot optimizations to improve the CPU usage leverage some specialized data structures setup in vbtiopbuilder, and utilized by the Smiley 'Transcription is the process where DNA is converted into messenger m-RNA.  A complex of enzymes cooperates to bind to the DNA and generate the m-RNA copy.  There are a number of such transcription complexes which are based on RNA polymerase I, II or III. 
like' codelet nuclabmbuilder through rtokenmatch:
The vbot fitness is described using a list data structure vfhist (data:init) which is utilized by itvfitoutput.  vbot fitness
          over generations

The vbotga::scmap has been compressed onto disc with the compression script. 

The presence, and effect, of these non-emergent data structures should be factored out in any analysis of vbot emergence.



AWF test vbt01
The vbt01 test statement shown following this description includes multiple parts:
The test framework should respond to this statement, decoding it's
This page introduces the many ways a complex modeling and coordination activity can be implemented using agent-based programming (see presentation). 

It describes how salient schematic alternative strings can be used to model a situation and make a decision under evolved control. 

It also introduces bottom up model codelets and complex techniques that are covered more fully on other pages. 

Constraints on the modeling process including requirements for timeliness, parallelism, synchronization and emergence of new models are discussed. 

Once a schematic sequence is selected by a group codelet or any additional type of modeling codelet the codelet will initiate an iterative cycle of detect, signal, match, deploy.  This allows the actions of a schematically selected sequence of model codelets to aggregate into a focused agent. 

A series of example signals sent by complex modeling codelets along with their associated operons and subgroup schematic sequences are included.  The signals are sent by the:
  • merge streams spdca builder - The initiator of merge streams's pdca cycle (see schematic pdca).
  • merge streams dcycip builder - The initiator of the planning phase of the merge streams's pdca cycle. 
  • merge streams cassert builder - The initiator of the mergestreams's case resolved assert true conditional cascade.  It is a structurally enhanced codelet which activates at the end of the 'do' phase and signals the nucleus. 
  • merge streams indsloc builder - The start locator codelet finds the application schemata's start operon
  • merge streams shsloc builder - A start locator codelet that finds an alternative start operon in the application schematic operon
  • merge streams rchpair builder - A receptor that detects and relays an application signal
  • pdca ecycdop builder - A cyclin simulation codelet which signals entry to the 'do' phase of the pdca. 
  • pdca acycchp builder - A cyclin simulation codelet which signals entry to the 'check' phase of the pdca. 
  • pdca bcycacp builder - A cyclin simulation codelet which signals entry to the 'act' phase of the pdca. 
And the Slipnet configuration which activates the schematic subgroup sequence <mergestreams> <for> <case> <resolved> <assert> <true> is included. 
parts
and then if it conforms to 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. 
expected statement structure
,
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. 
operating the statement
and thus initiating the test application executing first a
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 codelet cascade
and then a
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. 
Shewhart cycle
This page describes the specialized codelets that provide life-cycle and checkpoint capabilities for Smiley applications. 
The codelets implement a Shewhart cycle. 
The structural schematic nature of the cycle is described. 
Transcription factor codelets operate the phase change controls. 
How inhibitory agents are integrated into the cycle is described. 
An application agent with management and operational roles emerges. 
The codelets and supporting functions are included. 
managed
analysis of the direct and indirect details 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. 
.


<implement> <process> <rhlmsge> <genetic> <algorithm> <vbot> </rhlmsge> <subject>
<rhlmsge> <execute> <vbot> </rhlmsge> </subject> <verb>
<rhlmsge> <pickup> <in> <square> </rhlmsge> </verb> <object>
<rhlmsge> <each> <cans> </rhlmsge> </object>
<development>
<rhlmsge> <develop> <square> <cans> </rhlmsge> </development> </implement> <comment> <br>




Awfvbt virtual robot initial generation schemata
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. 


vbttom00nc signalled meme
The vbttom00nc 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
(<vbt> <schema> <naught> <naught> <model>) is associated with a meme group.  The group is the fist in a series which together define the ability of the robot ganitor to
The agents in complex adaptive systems (CAS) must model their environment to respond effectively to it.  Samuel modeling is described as an approach. 
model
its situation and issue a signal in response to its current assessment.  (The vbttom00c10c01 signaled meme description, which appears slightly later in this sequence, provides an additional link to that 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. 
codelet's builder.)  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 awfvbt01 cascade based Slipnet description associates codelet forces (nuclabmevaluator) with the signal.  The genetic
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. 
recombination and mutation operations of Holland's genetic algorithm
, applied by vbotga, alter the active schematic target of the signal, generation by generation, between the designed alternatives:
  • <vbt><for><vbot><process><north>
  • <vbt><for><vbot><process><south>
  • <vbt><for><vbot><process><east>
  • <vbt><for><vbot><process><west>
  • <vbt><for><vbot><process><pickup>
  • <vbt><for><vbot><process><random>

with 'south' being the randomly assigned intial generation target. 

 


comment (<rhlmspg> <memgroup> <vbt> <schema> <naught> <naught> <model> <vbt> <for> <vbot> <process> <south> </memgroup> </rhlmspg> )<comment> toams
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <naught> <one> <model> <vbt> <for> <vbot> <process> <south> </memgroup> <tmbinding> 'vbttoamsbuilder'</tmbinding> </rhlmspg> )<comment> toams
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <naught> <nine> <model> <vbt> <for> <vbot> <process> <east> </memgroup> </rhlmspg> )<comment> toame
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <one> <nine> <model> <vbt> <for> <vbot> <process> <east> </memgroup> </rhlmspg> )<comment> toame
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <nine> <nine> <model> <vbt> <for> <vbot> <process> <north> </memgroup> </rhlmspg> )<comment> toamn
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <nine> <eight> <model> <vbt> <for> <vbot> <process> <north> </memgroup> </rhlmspg> )<comment> toamn
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <nine> <naught> <model> <vbt> <for> <vbot> <process> <west> </memgroup> </rhlmspg> )<comment> toamw
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <one> <naught> <model> <vbt> <for> <vbot> <process> <south> </memgroup> <tmbinding> 'vbttoamsbuilder'</tmbinding> </rhlmspg> )<comment> toams
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <one> <one> <model> <vbt> <for> <vbot> <process> <random> </memgroup> </rhlmspg> )<comment> toamr

<comment> (<rhlmspg> <memgroup> <vbt> <schema> <naught> <naught> <cans> <naught> <one> <model> <vbt> <for> <vbot> <process> <south> </memgroup> </rhlmspg> )<comment> toams
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <naught> <naught> <cans> <one> <naught> <model> <vbt> <for> <vbot> <process> <south> </memgroup> </rhlmspg> )<comment> toams
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <naught> <naught> <cans> <naught> <naught> <model> <vbt> <for> <vbot> <process> <pickup> </memgroup> </rhlmspg> )<comment> toapc



vbttom00c10c01 signalled meme
The vbttom00c10c01 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
(<vbt> <schema> <naught> <naught> <cans> <one> <naught <naught> <one> <model>) 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 awfvbt01 cascade based Slipnet description associates codelet forces (nuclabmevaluator) with the signal.  The genetic
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. 
recombination and mutation operations of Holland's genetic algorithm
, applied by vbotga, alter the active schematic target of the signal, generation by generation, between the designed alternatives:
  • <vbt><for><vbot><process><north>
  • <vbt><for><vbot><process><south>
  • <vbt><for><vbot><process><east>
  • <vbt><for><vbot><process><west>
  • <vbt><for><vbot><process><pickup>
  • <vbt><for><vbot><process><random>
with 'south' being the randomly assigned intial generation target. 

 


<comment> (<rhlmspg> <memgroup> <vbt> <schema> <naught> <naught> <cans> <one> <naught> <naught> <one> <model> <vbt> <for> <vbot> <process> <south> </memgroup> </rhlmspg> )<comment> toams
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <naught> <naught> <cans> <one> <naught> <cans> <naught> <naught> <model> <vbt> <for> <vbot> <process> <south> </memgroup> </rhlmspg> )<comment> toams
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <naught> <naught> <cans> <naught> <naught> <cans> <naught> <one> <model> <vbt> <for> <vbot> <process> <pickup> </memgroup> </rhlmspg> )<comment> toapc
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <naught> <naught> <cans> <one> <naught> <naught> <one> <naught> <naught> <model> <vbt> <for> <vbot> <process> <random> </memgroup> <tmbinding> 'vbttoamrbuilder'</tmbinding> </rhlmspg> )<comment> toamr expect it to be associated with a different signal
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <naught> <random> <model> <vbt> <for> <vbot> <process> <random> </memgroup> </rhlmspg> )<comment> toamr

<comment> (<rhlmspg> <memgroup> <vbt> <schema> <naught> <one> <cans> <one> <one> <model> <vbt> <for> <vbot> <process> <south> </memgroup> </rhlmspg> )<comment> toams
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <naught> <one> <cans> <naught> <one> <model> <vbt> <for> <vbot> <process> <south> </memgroup> </rhlmspg> )<comment> toams
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <naught> <one> <cans> <naught> <two> <model> <vbt> <for> <vbot> <process> <south> </memgroup> </rhlmspg> )<comment> toams
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <naught> <one> <cans> <one> <one> <cans> <naught> <two> <model> <vbt> <for> <vbot> <process> <south> </memgroup> </rhlmspg> )<comment> toams
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <naught> <one> <cans> <naught> <one> <cans> <one> <one> <model> <vbt> <for> <vbot> <process> <south> </memgroup> </rhlmspg> )<comment> toams
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <naught> <one> <cans> <naught> <naught> <model> <vbt> <for> <vbot> <process> <south> </memgroup> </rhlmspg> )<comment> toams
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <naught> <one> <cans> <naught> <naught> <cans> <one> <one> <model> <vbt> <for> <vbot> <process> <south> </memgroup> </rhlmspg> )<comment> toams
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <naught> <one> <cans> <naught> <one> <cans> <naught> <two> <model> <vbt> <for> <vbot> <process> <south> </memgroup> </rhlmspg> )<comment> toams
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <naught> <one> <cans> <naught> <naught> <cans> <naught> <one> <model> <vbt> <for> <vbot> <process> <south> </memgroup> </rhlmspg> )<comment> toams
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <naught> <one> <cans> <naught> <naught> <cans> <naught> <two> <model> <vbt> <for> <vbot> <process> <south> </memgroup> </rhlmspg> )<comment> toams
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <naught> <one> <cans> <naught> <one> <cans> <one> <one> <cans> <naught> <two> <model> <vbt> <for> <vbot> <process> <south> </memgroup> </rhlmspg> )<comment> toams
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <naught> <one> <cans> <naught> <naught> <cans> <naught> <one> <cans> <one> <one> <model> <vbt> <for> <vbot> <process> <south> </memgroup> </rhlmspg> )<comment> toams
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <naught> <one> <cans> <naught> <naught> <cans> <one> <one> <cans> <naught> <two> <model> <vbt> <for> <vbot> <process> <south> </memgroup> </rhlmspg> )<comment> toams
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <naught> <one> <cans> <naught> <naught> <cans> <naught> <one> <cans> <naught> <two> <model> <vbt> <for> <vbot> <process> <south> </memgroup> </rhlmspg> )<comment> toams
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <naught> <one> <cans> <naught> <naught> <cans> <naught> <one> <cans> <one> <one> <cans> <naught> <two> <model> <vbt> <for> <vbot> <process> <south> </memgroup> </rhlmspg> )<comment> toams

<comment> (<rhlmspg> <memgroup> <vbt> <schema> <naught> <nine> <cans> <naught> <eight> <model> <vbt> <for> <vbot> <process> <east> </memgroup> </rhlmspg> )<comment> toame
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <naught> <nine> <cans> <naught> <nine> <model> <vbt> <for> <vbot> <process> <pickup> </memgroup> </rhlmspg> )<comment> toapc
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <naught> <nine> <cans> <one> <nine> <model> <vbt> <for> <vbot> <process> <east> </memgroup> </rhlmspg> )<comment> toame
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <naught> <nine> <cans> <one> <nine> <cans> <naught> <nine> <model> <vbt> <for> <vbot> <process> <pickup> </memgroup> </rhlmspg> )<comment> toapc
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <naught> <nine> <cans> <one> <nine> <naught> <eight> <model> <vbt> <for> <vbot> <process> <east> </memgroup> </rhlmspg> )<comment> toame
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <naught> <nine> <cans> <naught> <nine> <cans> <naught> <eight> <model> <vbt> <for> <vbot> <process> <pickup> </memgroup> </rhlmspg> )<comment> toapc
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <naught> <nine> <cans> <one> <nine> <naught> <eight> <naught> <nine> <model> <vbt> <for> <vbot> <process> <random> </memgroup> </rhlmspg> )<comment> toamr expect it to be associated with a different signal

<comment> (<rhlmspg> <memgroup> <vbt> <schema> <one> <nine> <cans> <naught> <nine> <model> <vbt> <for> <vbot> <process> <east> </memgroup> </rhlmspg> )<comment> toame
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <one> <nine> <cans> <one> <nine> <model> <vbt> <for> <vbot> <process> <east> </memgroup> </rhlmspg> )<comment> toame
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <one> <nine> <cans> <two> <nine> <model> <vbt> <for> <vbot> <process> <east> </memgroup> </rhlmspg> )<comment> toame
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <one> <nine> <cans> <one> <eight> <model> <vbt> <for> <vbot> <process> <east> </memgroup> </rhlmspg> )<comment> toame
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <one> <nine> <cans> <naught> <nine> <cans> <one> <nine> <model> <vbt> <for> <vbot> <process> <east> </memgroup> </rhlmspg> )<comment> toame
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <one> <nine> <cans> <naught> <nine> <cans> <two> <nine> <model> <vbt> <for> <vbot> <process> <east> </memgroup> </rhlmspg> )<comment> toame
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <one> <nine> <cans> <naught> <nine> <cans> <one> <eight> <model> <vbt> <for> <vbot> <process> <east> </memgroup> </rhlmspg> )<comment> toame
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <one> <nine> <cans> <one> <nine> <cans> <two> <nine> <model> <vbt> <for> <vbot> <process> <east> </memgroup> </rhlmspg> )<comment> toame
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <one> <nine> <cans> <one> <eight> <cans> <two> <nine> <model> <vbt> <for> <vbot> <process> <east> </memgroup> </rhlmspg> )<comment> toame
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <one> <nine> <cans> <one> <nine> <cans> <one> <eight> <model> <vbt> <for> <vbot> <process> <east> </memgroup> </rhlmspg> )<comment> toame
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <one> <nine> <cans> <naught> <nine> <cans> <one> <nine> <cans> <two> <nine> <model> <vbt> <for> <vbot> <process> <east> </memgroup> </rhlmspg> )<comment> toame
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <one> <nine> <cans> <naught> <nine> <cans> <one> <nine> <cans> <one> <eight> <model> <vbt> <for> <vbot> <process> <east> </memgroup> </rhlmspg> )<comment> toame
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <one> <nine> <cans> <naught> <nine> <cans> <one> <eight> <cans> <two> <nine> <model> <vbt> <for> <vbot> <process> <east> </memgroup> </rhlmspg> )<comment> toame
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <one> <nine> <cans> <one> <nine> <cans> <one> <eight> <cans> <two> <nine> <model> <vbt> <for> <vbot> <process> <east> </memgroup> </rhlmspg> )<comment> toame
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <one> <nine> <cans> <naught> <nine> <cans> <one> <nine> <cans> <one> <eight> <cans> <two> <nine> <model> <vbt> <for> <vbot> <process> <east> </memgroup> </rhlmspg> )<comment> toame

<comment> (<rhlmspg> <memgroup> <vbt> <schema> <nine> <nine> <cans> <nine> <nine> <model> <vbt> <for> <vbot> <process> <pickup> </memgroup> </rhlmspg> )<comment> toapc
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <nine> <nine> <cans> <nine> <eight> <model> <vbt> <for> <vbot> <process> <north> </memgroup> </rhlmspg> )<comment> toamn
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <nine> <nine> <cans> <eight> <nine> <model> <vbt> <for> <vbot> <process> <north> </memgroup> </rhlmspg> )<comment> toamn
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <nine> <nine> <cans> <eight> <nine> <cans> <nine> <nine> <model> <vbt> <for> <vbot> <process> <pickup> </memgroup> </rhlmspg> )<comment> toapc
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <nine> <nine> <cans> <eight> <nine> <nine> <eight> <model> <vbt> <for> <vbot> <process> <north> </memgroup> </rhlmspg> )<comment> toamn
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <nine> <nine> <cans> <nine> <nine> <cans> <nine> <eight> <model> <vbt> <for> <vbot> <process> <pickup> </memgroup> </rhlmspg> )<comment> toapc
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <nine> <nine> <cans> <eight> <nine> <nine> <eight> <nine> <nine> <model> <vbt> <for> <vbot> <process> <random> </memgroup> </rhlmspg> )<comment> toamr expect it to be associated with a different signal

<comment> (<rhlmspg> <memgroup> <vbt> <schema> <nine> <eight> <cans> <eight> <eight> <model> <vbt> <for> <vbot> <process> <north> </memgroup> </rhlmspg> )<comment> toamn
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <nine> <eight> <cans> <nine> <eight> <model> <vbt> <for> <vbot> <process> <north> </memgroup> </rhlmspg> )<comment> toamn
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <nine> <eight> <cans> <nine> <seven> <model> <vbt> <for> <vbot> <process> <north> </memgroup> </rhlmspg> )<comment> toamn
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <nine> <eight> <cans> <nine> <nine> <model> <vbt> <for> <vbot> <process> <north> </memgroup> </rhlmspg> )<comment> toamn
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <nine> <eight> <cans> <nine> <nine> <cans> <nine> <eight> <model> <vbt> <for> <vbot> <process> <north> </memgroup> </rhlmspg> )<comment> toamn
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <nine> <eight> <cans> <nine> <nine> <cans> <nine> <seven> <model> <vbt> <for> <vbot> <process> <north> </memgroup> </rhlmspg> )<comment> toamn
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <nine> <eight> <cans> <nine> <nine> <cans> <eight> <eight> <model> <vbt> <for> <vbot> <process> <north> </memgroup> </rhlmspg> )<comment> toamn
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <nine> <eight> <cans> <nine> <eight> <cans> <nine> <seven> <model> <vbt> <for> <vbot> <process> <north> </memgroup> </rhlmspg> )<comment> toamn
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <nine> <eight> <cans> <eight> <eight> <cans> <nine> <seven> <model> <vbt> <for> <vbot> <process> <north> </memgroup> </rhlmspg> )<comment> toamn
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <nine> <eight> <cans> <nine> <eight> <cans> <eight> <eight> <model> <vbt> <for> <vbot> <process> <north> </memgroup> </rhlmspg> )<comment> toamn
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <nine> <eight> <cans> <nine> <eight> <cans> <eight> <eight> <cans> <nine> <seven> <model> <vbt> <for> <vbot> <process> <north> </memgroup> </rhlmspg> )<comment> toamn
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <nine> <eight> <cans> <nine> <nine> <cans> <nine> <eight> <cans> <nine> <seven> <model> <vbt> <for> <vbot> <process> <north> </memgroup> </rhlmspg> )<comment> toamn
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <nine> <eight> <cans> <nine> <nine> <cans> <nine> <eight> <cans> <eight> <eight> <model> <vbt> <for> <vbot> <process> <north> </memgroup> </rhlmspg> )<comment> toamn
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <nine> <eight> <cans> <nine> <nine> <cans> <eight> <eight> <cans> <nine> <seven> <model> <vbt> <for> <vbot> <process> <north> </memgroup> </rhlmspg> )<comment> toamn
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <nine> <eight> <cans> <nine> <nine> <cans> <nine> <eight> <cans> <eight> <eight> <cans> <nine> <seven> <model> <vbt> <for> <vbot> <process> <north> </memgroup> </rhlmspg> )<comment> toamn

<comment> (<rhlmspg> <memgroup> <vbt> <schema> <nine> <naught> <cans> <eight> <naught> <model> <vbt> <for> <vbot> <process> <west> </memgroup> </rhlmspg> )<comment> toamw
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <nine> <naught> <cans> <nine> <naught> <model> <vbt> <for> <vbot> <process> <pickup> </memgroup> </rhlmspg> )<comment> toapc
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <nine> <naught> <cans> <nine> <one> <model> <vbt> <for> <vbot> <process> <west> </memgroup> </rhlmspg> )<comment> toamw
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <nine> <naught> <cans> <eight> <naught> <cans> <nine> <naught> <model> <vbt> <for> <vbot> <process> <pickup> </memgroup> </rhlmspg> )<comment> toapc
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <nine> <naught> <cans> <eight> <naught> <nine> <one> <model> <vbt> <for> <vbot> <process> <west> </memgroup> </rhlmspg> )<comment> toamw
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <nine> <naught> <cans> <nine> <naught> <cans> <nine> <one> <model> <vbt> <for> <vbot> <process> <pickup> </memgroup> </rhlmspg> )<comment> toapc
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <nine> <naught> <cans> <eight> <naught> <nine> <one> <nine> <naught> <model> <vbt> <for> <vbot> <process> <random> </memgroup> </rhlmspg> )<comment> toamr expect it to be associated with a different signal

<comment> (<rhlmspg> <memgroup> <vbt> <schema> <one> <naught> <cans> <one> <one> <model> <vbt> <for> <vbot> <process> <west> </memgroup> </rhlmspg> )<comment> toamw
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <one> <naught> <cans> <one> <naught> <model> <vbt> <for> <vbot> <process> <west> </memgroup> </rhlmspg> )<comment> toamw
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <one> <naught> <cans> <naught> <naught> <model> <vbt> <for> <vbot> <process> <west> </memgroup> </rhlmspg> )<comment> toamw
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <one> <naught> <cans> <two> <naught> <model> <vbt> <for> <vbot> <process> <west> </memgroup> </rhlmspg> )<comment> toamw
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <one> <naught> <cans> <two> <naught> <cans> <one> <naught> <model> <vbt> <for> <vbot> <process> <west> </memgroup> </rhlmspg> )<comment> toamw
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <one> <naught> <cans> <two> <naught> <cans> <naught> <naught> <model> <vbt> <for> <vbot> <process> <west> </memgroup> </rhlmspg> )<comment> toamw
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <one> <naught> <cans> <two> <naught> <cans> <one> <one> <model> <vbt> <for> <vbot> <process> <west> </memgroup> </rhlmspg> )<comment> toamw
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <one> <naught> <cans> <one> <naught> <cans> <naught> <naught> <model> <vbt> <for> <vbot> <process> <west> </memgroup> </rhlmspg> )<comment> toamw
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <one> <naught> <cans> <one> <one> <cans> <naught> <naught> <model> <vbt> <for> <vbot> <process> <west> </memgroup> </rhlmspg> )<comment> toamw
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <one> <naught> <cans> <one> <naught> <cans> <one> <one> <model> <vbt> <for> <vbot> <process> <west> </memgroup> </rhlmspg> )<comment> toamw
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <one> <naught> <cans> <one> <naught> <cans> <one> <one> <cans> <naught> <naught> <model> <vbt> <for> <vbot> <process> <west> </memgroup> </rhlmspg> )<comment> toamw
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <one> <naught> <cans> <two> <naught> <cans> <one> <naught> <cans> <naught> <naught> <model> <vbt> <for> <vbot> <process> <west> </memgroup> </rhlmspg> )<comment> toamw
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <one> <naught> <cans> <two> <naught> <cans> <one> <naught> <cans> <one> <one> <model> <vbt> <for> <vbot> <process> <west> </memgroup> </rhlmspg> )<comment> toamw
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <one> <naught> <cans> <two> <naught> <cans> <one> <one> <cans> <naught> <naught> <model> <vbt> <for> <vbot> <process> <west> </memgroup> </rhlmspg> )<comment> toamw
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <one> <naught> <cans> <two> <naught> <cans> <one> <naught> <cans> <one> <one> <cans> <naught> <naught> <model> <vbt> <for> <vbot> <process> <west> </memgroup> </rhlmspg> )<comment> toamw

<comment> (<rhlmspg> <memgroup> <vbt> <schema> <one> <one> <cans> <one> <two> <model> <vbt> <for> <vbot> <process> <random> </memgroup> </rhlmspg> )<comment> toamr
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <one> <one> <cans> <two> <one> <model> <vbt> <for> <vbot> <process> <random> </memgroup> </rhlmspg> )<comment> toamr
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <one> <one> <cans> <one> <one> <model> <vbt> <for> <vbot> <process> <random> </memgroup> </rhlmspg> )<comment> toamr
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <one> <one> <cans> <naught> <one> <model> <vbt> <for> <vbot> <process> <random> </memgroup> </rhlmspg> )<comment> toamr
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <one> <one> <cans> <two> <one> <cans> <one> <one> <model> <vbt> <for> <vbot> <process> <random> </memgroup> </rhlmspg> )<comment> toamr
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <one> <one> <cans> <two> <one> <cans> <naught> <one> <model> <vbt> <for> <vbot> <process> <random> </memgroup> </rhlmspg> )<comment> toamr
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <one> <one> <cans> <two> <one> <cans> <one> <two> <model> <vbt> <for> <vbot> <process> <random> </memgroup> </rhlmspg> )<comment> toamr
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <one> <one> <cans> <two> <one> <cans> <one> <one> <cans> <naught> <one> <model> <vbt> <for> <vbot> <process> <random> </memgroup> </rhlmspg> )<comment> toamr
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <one> <one> <cans> <two> <one> <cans> <one> <one> <cans> <one> <two> <model> <vbt> <for> <vbot> <process> <random> </memgroup> </rhlmspg> )<comment> toamr
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <one> <one> <cans> <two> <one> <cans> <one> <two> <cans> <naught> <one> <model> <vbt> <for> <vbot> <process> <random> </memgroup> </rhlmspg> )<comment> toamr
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <one> <one> <cans> <one> <one> <cans> <naught> <one> <model> <vbt> <for> <vbot> <process> <random> </memgroup> </rhlmspg> )<comment> toamr
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <one> <one> <cans> <one> <two> <cans> <naught> <one> <model> <vbt> <for> <vbot> <process> <random> </memgroup> </rhlmspg> )<comment> toamr
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <one> <one> <cans> <one> <one> <cans> <one> <two> <model> <vbt> <for> <vbot> <process> <random> </memgroup> </rhlmspg> )<comment> toamr
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <one> <one> <cans> <one> <one> <cans> <one> <two> <cans> <naught> <one> <model> <vbt> <for> <vbot> <process> <random> </memgroup> </rhlmspg> )<comment> toamr
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <one> <one> <cans> <two> <one> <cans> <one> <one> <cans> <one> <two> <cans> <naught> <one> <model> <vbt> <for> <vbot> <process> <random> </memgroup> </rhlmspg> )<comment> toamr

<comment> (<rhlmspg> <memgroup> <vbt> <schema> <one> <one> <cans> <one> <naught> <model> <vbt> <for> <vbot> <process> <random> </memgroup> </rhlmspg> )<comment> toamr
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <one> <one> <cans> <two> <one> <cans> <one> <naught> <model> <vbt> <for> <vbot> <process> <random> </memgroup> </rhlmspg> )<comment> toamr
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <one> <one> <cans> <one> <one> <cans> <one> <naught> <model> <vbt> <for> <vbot> <process> <random> </memgroup> </rhlmspg> )<comment> toamr
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <one> <one> <cans> <naught> <one> <cans> <one> <naught> <model> <vbt> <for> <vbot> <process> <random> </memgroup> </rhlmspg> )<comment> toamr
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <one> <one> <cans> <one> <two> <cans> <one> <naught> <model> <vbt> <for> <vbot> <process> <random> </memgroup> </rhlmspg> )<comment> toamr
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <one> <one> <cans> <two> <one> <cans> <one> <one> <cans> <one> <naught> <model> <vbt> <for> <vbot> <process> <random> </memgroup> </rhlmspg> )<comment> toamr
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <one> <one> <cans> <two> <one> <cans> <naught> <one> <cans> <one> <naught> <model> <vbt> <for> <vbot> <process> <random> </memgroup> </rhlmspg> )<comment> toamr
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <one> <one> <cans> <two> <one> <cans> <one> <two> <cans> <one> <naught> <model> <vbt> <for> <vbot> <process> <random> </memgroup> </rhlmspg> )<comment> toamr
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <one> <one> <cans> <one> <one> <cans> <naught> <one> <cans> <one> <naught> <model> <vbt> <for> <vbot> <process> <random> </memgroup> </rhlmspg> )<comment> toamr
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <one> <one> <cans> <one> <two> <cans> <naught> <one> <cans> <one> <naught> <model> <vbt> <for> <vbot> <process> <random> </memgroup> </rhlmspg> )<comment> toamr
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <one> <one> <cans> <one> <one> <cans> <one> <two> <cans> <one> <naught> <model> <vbt> <for> <vbot> <process> <random> </memgroup> </rhlmspg> )<comment> toamr
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <one> <one> <cans> <one> <one> <cans> <one> <two> <cans> <naught> <one> <cans> <one> <naught> <model> <vbt> <for> <vbot> <process> <random> </memgroup> </rhlmspg> )<comment> toamr
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <one> <one> <cans> <two> <one> <cans> <one> <one> <cans> <naught> <one> <cans> <one> <naught> <model> <vbt> <for> <vbot> <process> <random> </memgroup> </rhlmspg> )<comment> toamr
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <one> <one> <cans> <two> <one> <cans> <one> <one> <cans> <one> <two> <cans> <one> <naught> <model> <vbt> <for> <vbot> <process> <random> </memgroup> </rhlmspg> )<comment> toamr
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <one> <one> <cans> <two> <one> <cans> <one> <two> <cans> <naught> <one> <cans> <one> <naught> <model> <vbt> <for> <vbot> <process> <random> </memgroup> </rhlmspg> )<comment> toamr
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <one> <one> <cans> <two> <one> <cans> <one> <one> <cans> <one> <two> <cans> <naught> <one> <cans> <one> <naught> <model> <vbt> <for> <vbot> <process> <random> </memgroup> </rhlmspg> )<comment> toamr




vbttm signalled meme
The vbttm 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
(<vbt> <schema> <process>) 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 awfvbt01 cascade based Slipnet description associates codelet forces (nuclabmevaluator) with the signal. 

 


<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <naught> <naught> <cans> <one> <naught> <cans> <naught> <naught> <model> </memgroup> </rhlmspg> )<comment> tom00c10c00
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <naught> <naught> <cans> <one> <naught> <naught> <one> <model> </memgroup> </rhlmspg> )<comment> tom00c10c01
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <naught> <naught> <model> </memgroup> </rhlmspg> )<comment> tom00nc
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <naught> <naught> <cans> <naught> <naught> <model> </memgroup> </rhlmspg> )<comment> tom00c00
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <naught> <naught> <cans> <naught> <naught> <cans> <naught> <one> <model> </memgroup> </rhlmspg> )<comment> tom00c00c01
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <naught> <naught> <cans> <naught> <one> <model> </memgroup> </rhlmspg> )<comment> tom00c01
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <naught> <naught> <cans> <one> <naught> <model> </memgroup> </rhlmspg> )<comment> tom00c10
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <naught> <naught> <cans> <one> <naught> <naught> <one> <naught> <naught> <model> </memgroup> </rhlmspg> )<comment> tom00c10c01c00
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <naught> <random> <model> </memgroup> </rhlmspg> )<comment> tom0rec

<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <naught> <one> <model> </memgroup> </rhlmspg> )<comment> tom01nc
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <naught> <one> <cans> <one> <one> <model> </memgroup> </rhlmspg> )<comment> tom01c11
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <naught> <one> <cans> <naught> <one> <model> </memgroup> </rhlmspg> )<comment> tom01c01
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <naught> <one> <cans> <naught> <two> <model> </memgroup> </rhlmspg> )<comment> tom01c02
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <naught> <one> <cans> <naught> <naught> <model> </memgroup> </rhlmspg> )<comment> tom01c00
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <naught> <one> <cans> <naught> <naught> <cans> <naught> <one> <model> </memgroup> </rhlmspg> )<comment> tom01c00c01
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <naught> <one> <cans> <naught> <naught> <cans> <naught> <two> <model> </memgroup> </rhlmspg> )<comment> tom01c00c02
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <naught> <one> <cans> <naught> <naught> <cans> <naught> <one> <cans> <naught> <two> <model> </memgroup> </rhlmspg> )<comment> tom01c00c01c02
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <naught> <one> <cans> <naught> <naught> <cans> <naught> <one> <cans> <one> <one> <model> </memgroup> </rhlmspg> )<comment> tom01c00c01c11
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <naught> <one> <cans> <naught> <naught> <cans> <one> <one> <model> </memgroup> </rhlmspg> )<comment> tom01c00c11
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <naught> <one> <cans> <naught> <naught> <cans> <one> <one> <cans> <naught> <two> <model> </memgroup> </rhlmspg> )<comment> tom01c00c11c02
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <naught> <one> <cans> <naught> <naught> <cans> <naught> <one> <cans> <one> <one> <cans> <naught> <two> <model> </memgroup> </rhlmspg> )<comment> tom01c00c01c11c02
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <naught> <one> <cans> <naught> <one> <cans> <naught> <two> <model> </memgroup> </rhlmspg> )<comment> tom01c01c02
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <naught> <one> <cans> <one> <one> <cans> <naught> <two> <model> </memgroup> </rhlmspg> )<comment> tom01c11c02
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <naught> <one> <cans> <naught> <one> <cans> <one> <one> <cans> <naught> <two> <model> </memgroup> </rhlmspg> )<comment> tom01c01c11c02
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <naught> <one> <cans> <naught> <one> <cans> <one> <one> <model> </memgroup> </rhlmspg> )<comment> tom01c01c11

<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <naught> <nine> <cans> <one> <nine> <cans> <naught> <nine> <model> </memgroup> </rhlmspg> )<comment> tom09c19c09
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <naught> <nine> <cans> <one> <nine> <naught> <eight> <model> </memgroup> </rhlmspg> )<comment> tom09c19c08
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <naught> <nine> <model> </memgroup> </rhlmspg> )<comment> tom09nc
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <naught> <nine> <cans> <naught> <nine> <model> </memgroup> </rhlmspg> )<comment> tom09c09
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <naught> <nine> <cans> <naught> <nine> <cans> <naught> <eight> <model> </memgroup> </rhlmspg> )<comment> tom09c09c08
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <naught> <nine> <cans> <naught> <eight> <model> </memgroup> </rhlmspg> )<comment> tom09c08
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <naught> <nine> <cans> <one> <nine> <model> </memgroup> </rhlmspg> )<comment> tom09c19
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <naught> <nine> <cans> <one> <nine> <naught> <eight> <naught> <nine> <model> </memgroup> </rhlmspg> )<comment> tom09c19c08c09

<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <one> <nine> <model> </memgroup> </rhlmspg> )<comment> tom19nc
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <one> <nine> <cans> <one> <eight> <model> </memgroup> </rhlmspg> )<comment> tom19c18
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <one> <nine> <cans> <one> <nine> <model> </memgroup> </rhlmspg> )<comment> tom19c19
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <one> <nine> <cans> <two> <nine> <model> </memgroup> </rhlmspg> )<comment> tom19c29
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <one> <nine> <cans> <naught> <nine> <model> </memgroup> </rhlmspg> )<comment> tom19c09
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <one> <nine> <cans> <naught> <nine> <cans> <one> <nine> <model> </memgroup> </rhlmspg> )<comment> tom19c09c19
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <one> <nine> <cans> <naught> <nine> <cans> <two> <nine> <model> </memgroup> </rhlmspg> )<comment> tom19c09c29
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <one> <nine> <cans> <naught> <nine> <cans> <one> <nine> <cans> <two> <nine> <model> </memgroup> </rhlmspg> )<comment> tom19c09c19c29
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <one> <nine> <cans> <naught> <nine> <cans> <one> <nine> <cans> <one> <eight> <model> </memgroup> </rhlmspg> )<comment> tom19c09c19c18
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <one> <nine> <cans> <naught> <nine> <cans> <one> <eight> <model> </memgroup> </rhlmspg> )<comment> tom19c09c18
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <one> <nine> <cans> <naught> <nine> <cans> <one> <eight> <cans> <two> <nine> <model> </memgroup> </rhlmspg> )<comment> tom19c09c18c29
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <one> <nine> <cans> <naught> <nine> <cans> <one> <nine> <cans> <one> <eight> <cans> <two> <nine> <model> </memgroup> </rhlmspg> )<comment> tom19c09c19c18c29
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <one> <nine> <cans> <one> <nine> <cans> <two> <nine> <model> </memgroup> </rhlmspg> )<comment> tom19c19c29
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <one> <nine> <cans> <one> <eight> <cans> <two> <nine> <model> </memgroup> </rhlmspg> )<comment> tom19c18c29
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <one> <nine> <cans> <one> <nine> <cans> <one> <eight> <cans> <two> <nine> <model> </memgroup> </rhlmspg> )<comment> tom19c19c18c29
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <one> <nine> <cans> <one> <nine> <cans> <one> <eight> <model> </memgroup> </rhlmspg> )<comment> tom19c19c18

<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <nine> <nine> <cans> <eight> <nine> <cans> <nine> <nine> <model> </memgroup> </rhlmspg> )<comment> tom99c89c99
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <nine> <nine> <cans> <eight> <nine> <nine> <eight> <model> </memgroup> </rhlmspg> )<comment> tom99c89c98
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <nine> <nine> <model> </memgroup> </rhlmspg> )<comment> tom99nc
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <nine> <nine> <cans> <nine> <nine> <model> </memgroup> </rhlmspg> )<comment> tom99c99
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <nine> <nine> <cans> <nine> <nine> <cans> <nine> <eight> <model> </memgroup> </rhlmspg> )<comment> tom99c99c98
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <nine> <nine> <cans> <nine> <eight> <model> </memgroup> </rhlmspg> )<comment> tom99c98
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <nine> <nine> <cans> <eight> <nine> <model> </memgroup> </rhlmspg> )<comment> tom99c89
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <nine> <nine> <cans> <eight> <nine> <nine> <eight> <nine> <nine> <model> </memgroup> </rhlmspg> )<comment> tom99c89c98c99

<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <nine> <eight> <model> </memgroup> </rhlmspg> )<comment> tom98nc
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <nine> <eight> <cans> <eight> <eight> <model> </memgroup> </rhlmspg> )<comment> tom98c88
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <nine> <eight> <cans> <nine> <eight> <model> </memgroup> </rhlmspg> )<comment> tom98c98
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <nine> <eight> <cans> <nine> <seven> <model> </memgroup> </rhlmspg> )<comment> tom98c97
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <nine> <eight> <cans> <nine> <nine> <model> </memgroup> </rhlmspg> )<comment> tom98c99
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <nine> <eight> <cans> <nine> <nine> <cans> <nine> <eight> <model> </memgroup> </rhlmspg> )<comment> tom98c99c98
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <nine> <eight> <cans> <nine> <nine> <cans> <nine> <seven> <model> </memgroup> </rhlmspg> )<comment> tom98c99c97
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <nine> <eight> <cans> <nine> <nine> <cans> <nine> <eight> <cans> <nine> <seven> <model> </memgroup> </rhlmspg> )<comment> tom98c99c98c97
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <nine> <eight> <cans> <nine> <nine> <cans> <nine> <eight> <cans> <eight> <eight> <model> </memgroup> </rhlmspg> )<comment> tom98c99c98c88
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <nine> <eight> <cans> <nine> <nine> <cans> <eight> <eight> <model> </memgroup> </rhlmspg> )<comment> tom98c99c88
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <nine> <eight> <cans> <nine> <nine> <cans> <eight> <eight> <cans> <nine> <seven> <model> </memgroup> </rhlmspg> )<comment> tom98c99c88c97
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <nine> <eight> <cans> <nine> <nine> <cans> <nine> <eight> <cans> <eight> <eight> <cans> <nine> <seven> <model> </memgroup> </rhlmspg> )<comment> tom98c99c98c88c97
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <nine> <eight> <cans> <nine> <eight> <cans> <nine> <seven> <model> </memgroup> </rhlmspg> )<comment> tom98c98c97
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <nine> <eight> <cans> <eight> <eight> <cans> <nine> <seven> <model> </memgroup> </rhlmspg> )<comment> tom98c88c97
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <nine> <eight> <cans> <nine> <eight> <cans> <eight> <eight> <cans> <nine> <seven> <model> </memgroup> </rhlmspg> )<comment> tom98c98c88c97
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <nine> <eight> <cans> <nine> <eight> <cans> <eight> <eight> <model> </memgroup> </rhlmspg> )<comment> tom98c98c88

<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <nine> <naught> <cans> <eight> <naught> <cans> <nine> <naught> <model> </memgroup> </rhlmspg> )<comment> tom90c80c90
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <nine> <naught> <cans> <eight> <naught> <nine> <one> <model> </memgroup> </rhlmspg> )<comment> tom90c80c91
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <nine> <naught> <model> </memgroup> </rhlmspg> )<comment> tom90nc
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <nine> <naught> <cans> <nine> <naught> <model> </memgroup> </rhlmspg> )<comment> tom90c90
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <nine> <naught> <cans> <nine> <naught> <cans> <nine> <one> <model> </memgroup> </rhlmspg> )<comment> tom90c90c91
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <nine> <naught> <cans> <nine> <one> <model> </memgroup> </rhlmspg> )<comment> tom90c91
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <nine> <naught> <cans> <eight> <naught> <model> </memgroup> </rhlmspg> )<comment> tom90c80
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <nine> <naught> <cans> <eight> <naught> <nine> <one> <nine> <naught> <model> </memgroup> </rhlmspg> )<comment> tom90c80c91c90

<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <one> <naught> <model> </memgroup> </rhlmspg> )<comment> tom10nc
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <one> <naught> <cans> <one> <one> <model> </memgroup> </rhlmspg> )<comment> tom10c11
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <one> <naught> <cans> <one> <naught> <model> </memgroup> </rhlmspg> )<comment> tom10c10
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <one> <naught> <cans> <naught> <naught> <model> </memgroup> </rhlmspg> )<comment> tom10c00
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <one> <naught> <cans> <two> <naught> <model> </memgroup> </rhlmspg> )<comment> tom10c20
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <one> <naught> <cans> <two> <naught> <cans> <one> <naught> <model> </memgroup> </rhlmspg> )<comment> tom10c20c10
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <one> <naught> <cans> <two> <naught> <cans> <naught> <naught> <model> </memgroup> </rhlmspg> )<comment> tom10c20c00
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <one> <naught> <cans> <two> <naught> <cans> <one> <naught> <cans> <naught> <naught> <model> </memgroup> </rhlmspg> )<comment> tom10c20c10c00
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <one> <naught> <cans> <two> <naught> <cans> <one> <naught> <cans> <one> <one> <model> </memgroup> </rhlmspg> )<comment> tom10c20c10c11
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <one> <naught> <cans> <two> <naught> <cans> <one> <one> <model> </memgroup> </rhlmspg> )<comment> tom10c20c11
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <one> <naught> <cans> <two> <naught> <cans> <one> <one> <cans> <naught> <naught> <model> </memgroup> </rhlmspg> )<comment> tom10c20c11c00
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <one> <naught> <cans> <two> <naught> <cans> <one> <naught> <cans> <one> <one> <cans> <naught> <naught> <model> </memgroup> </rhlmspg> )<comment> tom10c20c10c11c00
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <one> <naught> <cans> <one> <naught> <cans> <naught> <naught> <model> </memgroup> </rhlmspg> )<comment> tom10c10c00
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <one> <naught> <cans> <one> <one> <cans> <naught> <naught> <model> </memgroup> </rhlmspg> )<comment> tom10c11c00
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <one> <naught> <cans> <one> <naught> <cans> <one> <one> <cans> <naught> <naught> <model> </memgroup> </rhlmspg> )<comment> tom10c10c11c00
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <one> <naught> <cans> <one> <naught> <cans> <one> <one> <model> </memgroup> </rhlmspg> )<comment> tom10c10c11

<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <one> <one> <model> </memgroup> </rhlmspg> )<comment> tom11nc
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <one> <one> <cans> <one> <two> <model> </memgroup> </rhlmspg> )<comment> tom11c12
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <one> <one> <cans> <one> <one> <model> </memgroup> </rhlmspg> )<comment> tom11c11
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <one> <one> <cans> <naught> <one> <model> </memgroup> </rhlmspg> )<comment> tom11c01
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <one> <one> <cans> <two> <one> <model> </memgroup> </rhlmspg> )<comment> tom11c21
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <one> <one> <cans> <two> <one> <cans> <one> <one> <model> </memgroup> </rhlmspg> )<comment> tom11c21c11
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <one> <one> <cans> <two> <one> <cans> <naught> <one> <model> </memgroup> </rhlmspg> )<comment> tom11c21c01
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <one> <one> <cans> <two> <one> <cans> <one> <one> <cans> <naught> <one> <model> </memgroup> </rhlmspg> )<comment> tom11c21c11c01
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <one> <one> <cans> <two> <one> <cans> <one> <one> <cans> <one> <two> <model> </memgroup> </rhlmspg> )<comment> tom11c21c11c12
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <one> <one> <cans> <two> <one> <cans> <one> <two> <model> </memgroup> </rhlmspg> )<comment> tom11c21c12
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <one> <one> <cans> <two> <one> <cans> <one> <two> <cans> <naught> <one> <model> </memgroup> </rhlmspg> )<comment> tom11c21c12c01
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <one> <one> <cans> <two> <one> <cans> <one> <one> <cans> <one> <two> <cans> <naught> <one> <model> </memgroup> </rhlmspg> )<comment> tom11c21c11c12c01
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <one> <one> <cans> <one> <one> <cans> <naught> <one> <model> </memgroup> </rhlmspg> )<comment> tom11c11c01
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <one> <one> <cans> <one> <two> <cans> <naught> <one> <model> </memgroup> </rhlmspg> )<comment> tom11c12c01
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <one> <one> <cans> <one> <one> <cans> <one> <two> <cans> <naught> <one> <model> </memgroup> </rhlmspg> )<comment> tom11c11c12c01
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <one> <one> <cans> <one> <one> <cans> <one> <two> <model> </memgroup> </rhlmspg> )<comment> tom11c11c12

<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <one> <one> <cans> <one> <naught> <model> </memgroup> </rhlmspg> )<comment> tom11c10
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <one> <one> <cans> <one> <two> <cans> <one> <naught> <model> </memgroup> </rhlmspg> )<comment> tom11c12c10
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <one> <one> <cans> <one> <one> <cans> <one> <naught> <model> </memgroup> </rhlmspg> )<comment> tom11c11c10
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <one> <one> <cans> <naught> <one> <cans> <one> <naught> <model> </memgroup> </rhlmspg> )<comment> tom11c01c10
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <one> <one> <cans> <two> <one> <cans> <one> <naught> <model> </memgroup> </rhlmspg> )<comment> tom11c21c10
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <one> <one> <cans> <two> <one> <cans> <one> <one> <cans> <one> <naught> <model> </memgroup> </rhlmspg> )<comment> tom11c21c11c10
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <one> <one> <cans> <two> <one> <cans> <naught> <one> <cans> <one> <naught> <model> </memgroup> </rhlmspg> )<comment> tom11c21c01c10
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <one> <one> <cans> <two> <one> <cans> <one> <one> <cans> <naught> <one> <cans> <one> <naught> <model> </memgroup> </rhlmspg> )<comment> tom11c21c11c01c10
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <one> <one> <cans> <two> <one> <cans> <one> <one> <cans> <one> <two> <cans> <one> <naught> <model> </memgroup> </rhlmspg> )<comment> tom11c21c11c12c10
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <one> <one> <cans> <two> <one> <cans> <one> <two> <cans> <one> <naught> <model> </memgroup> </rhlmspg> )<comment> tom11c21c12c10
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <one> <one> <cans> <two> <one> <cans> <one> <two> <cans> <naught> <one> <cans> <one> <naught> <model> </memgroup> </rhlmspg> )<comment> tom11c21c12c01c10
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <one> <one> <cans> <two> <one> <cans> <one> <one> <cans> <one> <two> <cans> <naught> <one> <cans> <one> <naught> <model> </memgroup> </rhlmspg> )<comment> tom11c21c11c12c01c10
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <one> <one> <cans> <one> <one> <cans> <naught> <one> <cans> <one> <naught> <model> </memgroup> </rhlmspg> )<comment> tom11c11c01c10
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <one> <one> <cans> <one> <two> <cans> <naught> <one> <cans> <one> <naught> <model> </memgroup> </rhlmspg> )<comment> tom11c12c01c10
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <one> <one> <cans> <one> <one> <cans> <one> <two> <cans> <naught> <one> <cans> <one> <naught> <model> </memgroup> </rhlmspg> )<comment> tom11c11c12c01c10
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <process> <vbt> <for> <vbot> <process> <one> <one> <cans> <one> <one> <cans> <one> <two> <cans> <one> <naught> <model> </memgroup> </rhlmspg> )<comment> tom11c11c12c10




vbtiop signalled meme
The vbtiop 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
(<vbt> <schema> <genetic> <algorithm> <implement>) 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 awfvbt01 cascade based Slipnet description associates codelet forces (nuclabmevaluator) with the signal. 

 


<comment> (<rhlmspg> <memgroup> <vbt> <schema> <genetic> <algorithm> <implement> <vbt> <for> <vbot> <supervise> <process> </memgroup> </rhlmspg> )<comment> vbttm
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <genetic> <algorithm> <implement> <vbt> <for> <vbot> <supervise> <replace> </memgroup> <tmbinding> 'vbttmorevbbuilder'</tmbinding> </rhlmspg> )<comment> vbttmorevb
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <genetic> <algorithm> <implement> <vbt> <for> <vbot> <supervise> <deploy> </memgroup> <tmbinding> 'vbttmoretsbuilder'</tmbinding> </rhlmspg> )<comment> vbttmorets
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <genetic> <algorithm> <implement> <vbt> <for> <vbot> <supervise> <genetic> </memgroup> <tmbinding> 'vbttmoregsbuilder'</tmbinding> </rhlmspg> )<comment> vbttmoregs



vbttoams signalled meme
The vbttoams 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
(<vbt> <schema> <south>) 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 awfvbt01 cascade based Slipnet description associates codelet forces (nuclabmevaluator) with the signal. 

 


<comment> (<rhlmspg> <memgroup> <vbt> <schema> <south> <vbt> <for> <vbot> <supervise> <process> </memgroup> </rhlmspg> )<comment> vbttm


vbttoamr signalled meme
The vbttoamr 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
(<vbt> <schema> <random>) 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 awfvbt01 cascade based Slipnet description associates codelet forces (nuclabmevaluator) with the signal. 

 


<comment> (<rhlmspg> <memgroup> <vbt> <schema> <random> <vbt> <for> <vbot> <supervise> <process> </memgroup> </rhlmspg> )<comment> vbttm


vbttoapc signalled meme
The vbttoapc 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
(<vbt> <schema> <pickup>) 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 awfvbt01 cascade based Slipnet description associates codelet forces (nuclabmevaluator) with the signal. 

 


<comment> (<rhlmspg> <memgroup> <vbt> <schema> <pickup> <vbt> <for> <vbot> <supervise> <process> </memgroup> </rhlmspg> )<comment> vbttm


vbttoamn signalled meme
The vbttoamn 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
(<vbt> <schema> <north>) 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 awfvbt01 cascade based Slipnet description associates codelet forces (nuclabmevaluator) with the signal. 

 


<comment> (<rhlmspg> <memgroup> <vbt> <schema> <north> <vbt> <for> <vbot> <supervise> <process> </memgroup> </rhlmspg> )<comment> vbttm


vbttoame signalled meme
The vbttoame 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
(<vbt> <schema> <east>) 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 awfvbt01 cascade based Slipnet description associates codelet forces (nuclabmevaluator) with the signal. 

 


<comment> (<rhlmspg> <memgroup> <vbt> <schema> <east> <vbt> <for> <vbot> <supervise> <process> </memgroup> </rhlmspg> )<comment> vbttm


vbttoamw signalled meme
The vbttoamw 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
(<vbt> <schema> <west>) 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 awfvbt01 cascade based Slipnet description associates codelet forces (nuclabmevaluator) with the signal. 

 


<comment> (<rhlmspg> <memgroup> <vbt> <schema> <west> <vbt> <for> <vbot> <supervise> <process> </memgroup> </rhlmspg> )<comment> vbttm

#<!-- start tag preseasms1 -->
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <south> <vbt> <for> <vbot> <supervise> <replace> </memgroup> <tmbinding> 'vbttmorevbbuilder'</tmbinding> </rhlmspg> )<comment> vbttmorevb
#<!-- end tag preseasms1 -->
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <random> <vbt> <for> <vbot> <supervise> <replace> </memgroup> <tmbinding> 'vbttmorevbbuilder'</tmbinding> </rhlmspg> )<comment> vbttmorevb
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <pickup> <vbt> <for> <vbot> <supervise> <replace> </memgroup> <tmbinding> 'vbttmorevbbuilder'</tmbinding> </rhlmspg> )<comment> vbttmorevb
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <north> <vbt> <for> <vbot> <supervise> <replace> </memgroup> <tmbinding> 'vbttmorevbbuilder'</tmbinding> </rhlmspg> )<comment> vbttmorevb
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <east> <vbt> <for> <vbot> <supervise> <replace> </memgroup> <tmbinding> 'vbttmorevbbuilder'</tmbinding> </rhlmspg> )<comment> vbttmorevb
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <west> <vbt> <for> <vbot> <supervise> <replace> </memgroup> <tmbinding> 'vbttmorevbbuilder'</tmbinding> </rhlmspg> )<comment> vbttmorevb

<comment> (<rhlmspg> <memgroup> <vbt> <schema> <south> <vbt> <for> <vbot> <supervise> <deploy> </memgroup> <tmbinding> 'vbttmoretsbuilder'</tmbinding> </rhlmspg> )<comment> vbttmorets
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <random> <vbt> <for> <vbot> <supervise> <deploy> </memgroup> <tmbinding> 'vbttmoretsbuilder'</tmbinding> </rhlmspg> )<comment> vbttmorets
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <pickup> <vbt> <for> <vbot> <supervise> <deploy> </memgroup> <tmbinding> 'vbttmoretsbuilder'</tmbinding> </rhlmspg> )<comment> vbttmorets
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <north> <vbt> <for> <vbot> <supervise> <deploy> </memgroup> <tmbinding> 'vbttmoretsbuilder'</tmbinding> </rhlmspg> )<comment> vbttmorets
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <east> <vbt> <for> <vbot> <supervise> <deploy> </memgroup> <tmbinding> 'vbttmoretsbuilder'</tmbinding> </rhlmspg> )<comment> vbttmorets
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <west> <vbt> <for> <vbot> <supervise> <deploy> </memgroup> <tmbinding> 'vbttmoretsbuilder'</tmbinding> </rhlmspg> )<comment> vbttmorets

<comment> (<rhlmspg> <memgroup> <vbt> <schema> <south> <vbt> <for> <vbot> <supervise> <genetic> </memgroup> <tmbinding> 'vbttmoregsbuilder'</tmbinding> </rhlmspg> )<comment> vbttmoregs
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <random> <vbt> <for> <vbot> <supervise> <genetic> </memgroup> <tmbinding> 'vbttmoregsbuilder'</tmbinding> </rhlmspg> )<comment> vbttmoregs
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <pickup> <vbt> <for> <vbot> <supervise> <genetic> </memgroup> <tmbinding> 'vbttmoregsbuilder'</tmbinding> </rhlmspg> )<comment> vbttmoregs
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <north> <vbt> <for> <vbot> <supervise> <genetic> </memgroup> <tmbinding> 'vbttmoregsbuilder'</tmbinding> </rhlmspg> )<comment> vbttmoregs
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <east> <vbt> <for> <vbot> <supervise> <genetic> </memgroup> <tmbinding> 'vbttmoregsbuilder'</tmbinding> </rhlmspg> )<comment> vbttmoregs
<comment> (<rhlmspg> <memgroup> <vbt> <schema> <west> <vbt> <for> <vbot> <supervise> <genetic> </memgroup> <tmbinding> 'vbttmoregsbuilder'</tmbinding> </rhlmspg> )<comment> vbttmoregs



vbtpartwhole signalled meme
The partwhole function'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
(<model> <schema> <partscategory> (<subject>| <object>| <verb>| <development>) <groupcomplete>) 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 statement's generic signal cascade is represented within the vbot partwhole signalled meme subgroups which result in deployment of mgpart and msalthr codelets (builders).
The signal's cascade based subject| object| verb| development Slipnet descriptions associates codelet forces (nuclabmevaluator) with the signals. 

 
 

 


<comment> (<rhlmspg> <memgroup> <execute> <vbot> </memgroup> </rhlmspg> )<comment> this is needed to induce an operon <br>
<comment> (<rhlmspg> <memgroup> <each> <cans> </memgroup> </rhlmspg> )<comment>
<comment> (<rhlmspg> <memgroup> <develop> <square> <cans> </memgroup> </rhlmspg> )<comment> this is needed to induce vbtdev codelet
<comment> (<rhlmspg> <memgroup> <genetic> <algorithm> <vbot> </memgroup> </rhlmspg> )<comment> this is needed to induce vbtiop codelet
<comment> (<rhlmspg> <memgroup> <model> <schema> <partscategory> <subject> <groupcomplete> <model> <partscategory> <subject> <salience> <threshold> <model> <partscategory> <subject> <jhlabel> <groupcomplete> </memgroup> </rhlmspg> )<comment> mgpart

<comment> (<rhlmspg> <memgroup> <model> <schema> <partscategory> <object> <groupcomplete> <model> <partscategory> <object> <salience> <threshold> <model> <partscategory> <object> <jhlabel> <groupcomplete> </memgroup> </rhlmspg> )<comment> mgpart

<comment> (<rhlmspg> <memgroup> <model> <schema> <partscategory> <verb> <groupcomplete> <model> <partscategory> <verb> <salience> <threshold> <model> <partscategory> <verb> <jhlabel> <groupcomplete> </memgroup> </rhlmspg> )<comment> mgpart





<comment> (<rhlmspg> <memgroup> <model> <schema> <partscategory> <development> <groupcomplete> <model> <partscategory> <development> <salience> <threshold> </memgroup> </rhlmspg> )(<rhlmspg> <memgroup> <model> <schema> <partscategory> <development> <groupcomplete> <model> <partscategory> <development> <jhlabel> <groupcomplete> </memgroup> </rhlmspg> )<comment> msalthr mgpart <br>



vbtpartvalid signalled meme
The partvalid function'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
(<model> <schema> <partscategory> (<subject>| <object>| <verb>) <groupvalid>) is associated with 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. 
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 statement's generic signal cascade is focused by the vbot specific meme subgroups which result in deployment of vbtmactsverb, vbtmres(s|o) and vbtmsorm codelets (builders).
The statement schematic structures subject| object| verb
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
description associates codelet forces (nuclabmevaluator) with the signals. 

 
 

 



<comment> (<rhlmspg> <memgroup> <model> <schema> <partscategory> <subject> <groupvalid> <model> <partscategory> <subject> <vbot> <jhlabel> <groupvalid> </memgroup> </rhlmspg> )<comment> vbtmress comment
(<rhlmspg> <memgroup> <model> <schema> <partscategory> <subject> <groupvalid> <model> <partscategory> <subject> <jhlabel> <mcgroupvalid> </memgroup> </rhlmspg> ) comment mmcr comment
(<rhlmspg> <memgroup> <model> <schema> <partscategory> <subject> <groupvalid> <model> <partscategory> <subject> <case> <groupvalid> </memgroup> </rhlmspg> ) comment mcssub <comment>
(<rhlmspg> <memgroup> <model> <schema> <partscategory> <subject> <groupvalid> <model> <partscategory> <subject> <vbot> <multiple> <groupvalid> </memgroup> </rhlmspg> )<comment> msorm

<comment> (<rhlmspg> <memgroup> <model> <schema> <partscategory> <object> <groupvalid> <model> <partscategory> <object> <vbot> <jhlabel> <groupvalid> </memgroup> </rhlmspg> )<comment> vbtmreso comment
(<rhlmspg> <memgroup> <model> <schema> <partscategory> <object> <groupvalid> <model> <partscategory> <object> <jhlabel> <mcgroupvalid> </memgroup> </rhlmspg> ) comment mmct comment
(<rhlmspg> <memgroup> <model> <schema> <partscategory> <object> <groupvalid> <model> <partscategory> <object> <case> <groupvalid> </memgroup> </rhlmspg> ) comment mcsob <comment>
(<rhlmspg> <memgroup> <model> <schema> <partscategory> <object> <groupvalid> <model> <partscategory> <object> <vbot> <multiple> <groupvalid> </memgroup> </rhlmspg> )<comment> msorm <br>

<comment> (<rhlmspg> <memgroup> <model> <schema> <partscategory> <verb> <groupvalid> <model> <partscategory> <verb> <vbot> <jhlabel> <groupvalid> </memgroup> </rhlmspg> )<comment> vbtmactsverb comment
(<rhlmspg> <memgroup> <model> <schema> <partscategory> <verb> <groupvalid> <model> <partscategory> <verb> <case> <groupvalid> </memgroup> </rhlmspg> ) comment mactcverb comment
(<rhlmspg> <memgroup> <model> <schema> <partscategory> <verb> <groupvalid> <model> <partscategory> <verb> <jhlabel> <mcgroupvalid> <model> <partscategory> <iterator> <groupvalid> </memgroup> </rhlmspg> ) comment mmcv <comment>
(<rhlmspg> <memgroup> <model> <schema> <partscategory> <verb> <groupvalid> <model> <partscategory> <verb> <vbot> <multiple> <groupvalid> </memgroup> </rhlmspg> )<comment> msorm <br>



vbtpartconstrained signalled meme
The partconstrained function'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
(<model> <schema> <partscategory> (<subject>| <object>| <verb>) <partconstrained>) 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 statement's generic signal cascade is focused by the vbot partconstrained signalled meme subgroups which result in deployment of vbtmc(s|v|o)p codelets (builders).
The statement schematic structures subject| object| verb Slipnet description associates codelet forces (nuclabmevaluator) with the signals. 

 
 

 



<comment> (<rhlmspg> <memgroup> <model> <schema> <partscategory> <subject> <partconstrained> <model> <partscategory> <subject> <vbot> <jhlabel> <partconstrained> </memgroup> </rhlmspg> )<comment> vbtmcsp
<comment> (<rhlmspg> <memgroup> <model> <schema> <partscategory> <object> <partconstrained> <model> <partscategory> <object> <vbot> <jhlabel> <partconstrained> </memgroup> </rhlmspg> )<comment> vbtmcop <br>
<comment> (<rhlmspg> <memgroup> <model> <schema> <partscategory> <verb> <partconstrained> <model> <partscategory> <verb> <vbot> <jhlabel> <partconstrained> </memgroup> </rhlmspg> )<comment> vbtmcvp <br>



vbtstatementwhole signalled meme
The statementwhole function'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
(<model> <schema> <statementcategory> <assert> <statementcomplete>) 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 statement's generic signal cascade is focused by the vbot statementwhole signalled meme subgroups which result in deployment of mwsta and mwstd codelets (builders).
The statement schematic structure Slipnet description associates codelet forces (nuclabmevaluator) with the signal. 

 
 

 



<comment> (<rhlmspg> <memgroup> <model> <schema> <statementcategory> <assert> <statementcomplete> <model> <statementcategory> <assert> <process> <statementwhole> </memgroup> </rhlmspg> )<comment> mwsta
<comment> (<rhlmspg> <memgroup> <model> <schema> <statementcategory> <implement> <statementcomplete> <model> <statementcategory> <implement> <process> <statementwhole> </memgroup> </rhlmspg> )<comment> mwsta





<comment> (<rhlmspg> <memgroup> <model> <schema> <devcategory> <development> <statementcomplete> <model> <schema> <development> <devcategory> <statementwhole> </memgroup> </rhlmspg> )<comment> mwstd



vbtdev signalled meme
The vbtdev 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
(<development> <schema> <square> <cans>) 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 awfvbt01 cascade based Slipnet description associates codelet forces (nuclabmevaluator) with the signal. 

 


<comment> (<rhlmspg> <memgroup> <development> <schema> <square> <cans> <development> <for> <vbot> <do> <deploy> <square> </memgroup> </rhlmspg> )<comment> devbtwld



vbtdevbtwld signalled meme
The devbtwld 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
(<development> <schema> <deploy> <square>) 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 awfvbt01 cascade based Slipnet description associates codelet forces (nuclabmevaluator) with the signal. 

 


<comment> (<rhlmspg> <memgroup> <development> <schema> <deploy> <square> <development> <for> <vbot> <do> <deploy> <cans> </memgroup> </rhlmspg> )<comment> devbtcns

Vbt Board

The virtual robot board is 10 by 10.

 
<vbtboardx>x dimension</vbtboardx><vbtboardy>y dimension</vbtboardy>


Control flow


Include

A recursive inclusion and merge of include blocks of istring source provides inversion of the source stream.

 
<rhlincr><rhlincdirspo>path command</rhlincdirspo><rhlincfilespo>file name</rhlincfilespo><rhlincblkspo>block name</rhlincblkspo>(<rhlinctagspo>tag</rhlinctagspo>)?</rhlincr>



Escaped inputs

  • <rhldq> is replaced by '"' once the input string pair has been matched and the data is being loaded. 
  • <rhldq2> is replaced by '<rhldq>'
  • <rhlsq> is replaced by "'" once the input string pair has been matched and the data is being loaded. 
  • <rhlsq2> is replaced by '<rhlsq>'
  • <rhlemsge> is instantiated by case histones & string handler as '<rhlmsge>'
  • </rhlemsge> is instantiated by case histones & string handler as '</rhlmsge>'
  • <rhl2emsge> is instantiated by string handler as '<rhlemsge>'
  • </rhl2emsge> is instantiated by string handler as '</rhlemsge>'



Tokens

Tokens can associate physical characteristics to themselves by including special sequences. 

Cytosolic

Tokens become cytosolic when they have small polar attributes [spo], and eventually have been transported through to the cytosol by an active transport. 

Memetic Symbols

Memetic Symbols can associate special characteristics to the tokens they wrap.

  <rhlmspg> following keywords and non keywords are in a completed group </rhlmspg>
<rhlmsge> following keywords and non keywords are in an edged group </rhlmsge>
<indequiv> makes the edge group it occurs within, and at end of, independent and equivalent
<rhlbmsge> following keywords and non keywords are in a char buffer </rhlbmsge>
<rhlmpch> following keywords and non keywords are in an inactive histone </rhlmpch>
<tmbinding> following builder is transactionally bound to this schematic relation </tmbinding>
<comment> anything enclosed between comments is ignored - can actually toggle between comments rather than use end comment </comment>


Memetic Subgroups

Memetic Subgroups use memetic symbols to create schemata that are used as nuclear workspace material.

  <memgroup> following keywords and non keywords are in a completed group </memgroup>
<model>
<schema>
<partscategory>
<partconstrained>
<statementcomplete>
<devcategory>
<statementcategory>
<statementwhole>
<mcgroupvalid>
<pdca>
<plan>
<pdcacomplete>
<groupcomplete>
<groupvalid>
<salience>
<threshold>
<jhlabel>
<multiple>
<iterator>
<telstring> following keywords and non keywords are in a telomeric long lived string </telstring>


Test Specification Symbols

The test specification symbols allow description of test assertions.

  <implement>#process(1), #subject(1), #object(1), #verb(1) #development(1) specification of file process relationships and implementation command regarding a named operation </implement>
<assert> #process(1), #subject(1), #object(1), #verb(1), #assume(1) #development(1) #equals(1) #truthassertion(1) </assert> specification of file process relationships and test assertion regarding a named operation
<process>
<equals>
<file>
<qmark>
<in>
<merge>
<name>
<mkeyword> characterises token set describing an application keyword </mkeyword>
<mkwordref> ref to an application keyword
<object> characterises what will be the object of the assertion </object>
<record>
<ivariable>
<replace>
<source>
<stream>
<subject> characterises what resource the agent performed the action with to complete the operation on the object. If valid this resouce will be used to model the operation to verify the assertion </subject>
<target>
<truthassertion>
<verb> characterises what will perform the actions of the assertion </verb>
<resolved>
<resource>
<for>
<each>
<typedinstance>
<development> defines the development schema start label to achieve differentiation needed to process the statement </development>
<develop>
<lists>
<sequence>
<integration>
<assume> characterises assumptions required to process the assertion </assume>
<referenced>
<streams>
<specified>
<deploy>
<case>
<selector>
<list>
<type>
<is>
<initial>
<startlistkw>
<namest>
<skipwso>
<startrcdkw>
<endrcdkw>
<endlistkw>
<seltst>
<unbind>
<mergestreams>
<sloc>
<hdo>
<execute>
<initialise>
<transcription>
<factor>
<inhibitor>
<investigation>
<supervise>
<initiate>
<true>
<do>
<check>
<act>
<change>
<terminate>
<program>
<ivalw>
<semantics>
<cbody>
<histone>
<if>
<elsif>
<match>
<melse>
<waitarelay>
<compare>
<completed>
<subprogram>
<signal>
<aggregate>
<integrate>
<first>
<image>
<else>
<vbot>
<vbt>
<genetic>
<algorithm>
<square>
<cans>
<pickup>
<wall>
<naught>
<one>
<two>
<three>
<four>
<five>
<six>
<seven>
<eight>
<nine>
<north>
<south>
<east>
<west>
<random>
<test>
<transaction>
<and>



#
    my ($pconc, $jhlsid);
# algorithm

    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnd}
      [$Awfif::memes-> {snnh} {algorithm}] = 1;
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc}
      [$Awfif::memes-> {snnh} {algorithm}][0] = 13;#13
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc}
      [$Awfif::memes-> {snnh} {algorithm}][1] = 12;#5
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {algorithm}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namedcategory},$Awfif::memes-> {snnh} {algorithm},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {algorithm}]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {algorithm}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {testcategory},$Awfif::memes-> {snnh} {algorithm},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {algorithm}]);
# vbot is used as the application binder complex identifier
# while vbt is the schematic set and seperator keyword
# vbot

    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnd}
      [$Awfif::memes-> {snnh} {vbot}] = 1;
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc}
      [$Awfif::memes-> {snnh} {vbot}][0] = 13;#13
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc}
      [$Awfif::memes-> {snnh} {vbot}][1] = 12;#5
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbot}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namedcategory},$Awfif::memes-> {snnh} {vbot},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbot}]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbot}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {testcategory},$Awfif::memes-> {snnh} {vbot},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbot}]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbot}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {successor},$Awfif::memes-> {snnh} {process},$Awfif::memes-> {snnh} {vbot},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbot}]);
# vbotiopbindtomsiggv
# setup the binding string for the multi path signal to associate the vbot development context structural workspace with a jhls pseudo concept

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbot}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbot}] [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} {vbot}, $Awfif::memes-> {snnh} {do}, $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]);
# vbt must be setup prior to all the items that reference its slipnet
# vbt

    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnd}
      [$Awfif::memes-> {snnh} {vbt}] = 1;
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc}
      [$Awfif::memes-> {snnh} {vbt}][0] = 13;#13
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc}
      [$Awfif::memes-> {snnh} {vbt}][1] = 12;#5
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namedcategory}, $Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {testcategory},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {vbt}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {successor},$Awfif::memes-> {snnh} {for},$Awfif::memes-> {snnh} {vbt},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {vbt}]);
# vbtiopbindtomsiggv
# setup the binding string for the multi path signal to control vbot implement operation processing - implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $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]);
# vbotiopbindtomsiggv
# setup the binding string for the multi path signal to control vbot implement operation processing - implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbot}, $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]);
# vbttmbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $Awfif::memes-> {snnh} {genetic}, $Awfif::memes-> {snnh} {algorithm}, $Awfif::memes-> {snnh} {implement}, $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, 'vbttmbuilder');
# vbttom00ncbindtomsiggv
# vbttom0recbindtomsiggv
# vbttom00c00bindtomsiggv
# vbttom00c00c01bindtomsiggv
# vbttom00c01bindtomsiggv
# vbttom00c10bindtomsiggv
# vbttom00c10c00bindtomsiggv
# vbttom00c10c01bindtomsiggv
# vbttom00c10c01c00bindtomsiggv
# vbttom01ncbindtomsiggv
# vbttom01c00bindtomsiggv
# vbttom01c01bindtomsiggv
# vbttom01c11bindtomsiggv
# vbttom01c00c11bindtomsiggv
# vbttom01c01c11bindtomsiggv
# vbttom01c02bindtomsiggv
# vbttom01c00c01bindtomsiggv
# vbttom01c00c02bindtomsiggv
# vbttom01c01c02bindtomsiggv
# vbttom01c00c11c02bindtomsiggv
# vbttom01c01c02bindtomsiggv
# vbttom01c01c11c02bindtomsiggv
# vbttom01c00c01c11bindtomsiggv
# vbttom01c00c01c11c02bindtomsiggv
# vbttom01c11c02bindtomsiggv
# vbttom09ncbindtomsiggv
# vbttom09c09bindtomsiggv
# vbttom09c09c08bindtomsiggv
# vbttom09c08bindtomsiggv
# vbttom09c19bindtomsiggv
# vbttom09c19c09bindtomsiggv
# vbttom09c19c08bindtomsiggv
# vbttom09c19c08c09bindtomsiggv
# vbttom19ncbindtomsiggv
# vbttom19c09bindtomsiggv
# vbttom19c09c18bindtomsiggv
# vbttom19c09c19bindtomsiggv
# vbttom19c09c29bindtomsiggv
# vbttom19c09c18c29bindtomsiggv
# vbttom19c09c19c29bindtomsiggv
# vbttom19c09c19c18bindtomsiggv
# vbttom19c09c19c18c29bindtomsiggv
# vbttom19c18bindtomsiggv
# vbttom19c18c29bindtomsiggv
# vbttom19c19bindtomsiggv
# vbttom19c19c18bindtomsiggv
# vbttom19c19c29bindtomsiggv
# vbttom19c19c18c29bindtomsiggv
# vbttom19c29bindtomsiggv
# vbttom99ncbindtomsiggv
# vbttom99c99bindtomsiggv
# vbttom99c99c98bindtomsiggv
# vbttom99c98bindtomsiggv
# vbttom99c89bindtomsiggv
# vbttom99c89c99bindtomsiggv
# vbttom99c89c98bindtomsiggv
# vbttom99c89c98c99bindtomsiggv
# vbttom98ncbindtomsiggv
# vbttom98c99bindtomsiggv
# vbttom98c99c88bindtomsiggv
# vbttom98c99c98bindtomsiggv
# vbttom98c99c97bindtomsiggv
# vbttom98c99c88c97bindtomsiggv
# vbttom98c99c98c97bindtomsiggv
# vbttom98c99c98c88bindtomsiggv
# vbttom98c99c98c88c97bindtomsiggv
# vbttom98c88bindtomsiggv
# vbttom98c88c97bindtomsiggv
# vbttom98c98bindtomsiggv
# vbttom98c98c88bindtomsiggv
# vbttom98c98c97bindtomsiggv
# vbttom98c98c88c97bindtomsiggv
# vbttom98c97bindtomsiggv
# vbttom90ncbindtomsiggv
# vbttom90c90bindtomsiggv
# vbttom90c90c91bindtomsiggv
# vbttom90c91bindtomsiggv
# vbttom90c80bindtomsiggv
# vbttom90c80c90bindtomsiggv
# vbttom90c80c91bindtomsiggv
# vbttom90c80c91c90bindtomsiggv
# vbttom10ncbindtomsiggv
# vbttom10c20bindtomsiggv
# vbttom10c20c11bindtomsiggv
# vbttom10c20c10bindtomsiggv
# vbttom10c20c00bindtomsiggv
# vbttom10c20c11c00bindtomsiggv
# vbttom10c20c10c00bindtomsiggv
# vbttom10c20c10c11bindtomsiggv
# vbttom10c20c10c11c00bindtomsiggv
# vbttom10c11bindtomsiggv
# vbttom10c11c00bindtomsiggv
# vbttom10c10bindtomsiggv
# vbttom10c10c11bindtomsiggv
# vbttom10c10c00bindtomsiggv
# vbttom10c10c11c00bindtomsiggv
# vbttom10c00bindtomsiggv
# vbttom11ncbindtomsiggv
# vbttom11c21bindtomsiggv
# vbttom11c21c12bindtomsiggv
# vbttom11c21c11bindtomsiggv
# vbttom11c21c01bindtomsiggv
# vbttom11c21c12c01bindtomsiggv
# vbttom11c21c11c01bindtomsiggv
# vbttom11c21c11c12bindtomsiggv
# vbttom11c21c11c12c01bindtomsiggv
# vbttom11c12bindtomsiggv
# vbttom11c12c01bindtomsiggv
# vbttom11c11bindtomsiggv
# vbttom11c11c12bindtomsiggv
# vbttom11c11c01bindtomsiggv
# vbttom11c11c12c01bindtomsiggv
# vbttom11c01bindtomsiggv
# vbttom11c10bindtomsiggv
# vbttom11c21c10bindtomsiggv
# vbttom11c21c12c10bindtomsiggv
# vbttom11c21c11c10bindtomsiggv
# vbttom11c21c01c10bindtomsiggv
# vbttom11c21c12c01c10bindtomsiggv
# vbttom11c21c11c01c10bindtomsiggv
# vbttom11c21c11c12c10bindtomsiggv
# vbttom11c21c11c12c01c10bindtomsiggv
# vbttom11c12c10bindtomsiggv
# vbttom11c12c01c10bindtomsiggv
# vbttom11c11c10bindtomsiggv
# vbttom11c11c12c10bindtomsiggv
# vbttom11c11c01c10bindtomsiggv
# vbttom11c11c12c01c10bindtomsiggv
# vbttom11c01c10bindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttom00ncbuilder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom0recbuilder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom00c00builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom00c00c01builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom00c01builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom00c10builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom00c10c00builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom00c10c01builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom00c10c01c00builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom01ncbuilder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom01c00builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom01c01builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom01c11builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom01c00c11builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom01c01c11builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom01c02builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom01c00c02builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom01c00c01builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom01c01c02builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom01c00c11c02builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom01c01c02builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom01c01c11c02builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom01c00c01c11builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom01c00c01c11c02builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom01c11c02builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom09ncbuilder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom09c09builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom09c09c08builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom09c08builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom09c19builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom09c19c09builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom09c19c08builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom09c19c08c09builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom19ncbuilder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom19c09builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom19c09c18builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom19c09c29builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom19c09c19builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom19c09c18c29builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom19c09c19c29builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom19c09c19c18builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom19c09c19c18c29builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom19c18builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom19c18c29builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom19c19builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom19c19c18builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom19c19c29builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom19c19c29builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom19c19c18c29builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom19c29builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom99ncbuilder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom99c99builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom99c99c98builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom99c98builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom99c89builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom99c89c99builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom99c89c98builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom99c89c98c99builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom98ncbuilder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom98c99builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom98c89c88builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom98c99c97builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom98c99c98builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom98c99c88c97builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom98c99c98c97builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom98c99c98c88builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom98c99c98c88c97builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom98c88builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom98c88c97builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom98c98builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom98c98c88builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom98c98c97builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom98c98c88c97builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom98c97builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom90ncbuilder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom90c90builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom90c90c91builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom90c91builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom90c80builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom90c80c90builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom90c80c91builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom90c80c91c00builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom10ncbuilder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom10c20builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom10c10c11builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom10c20c00builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom10c20c10builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom10c20c11c00builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom10c20c10c00builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom10c20c10c11builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom10c20c10c11c00builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom10c11builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom10c11c00builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom10c10builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom10c10c11builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom10c10c00builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom10c10c11c00builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom10c00builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom11ncbuilder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom11c21builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom11c11c12builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom11c21c01builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom11c21c11builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom11c21c12c01builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom11c21c11c01builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom11c21c11c12builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom11c21c11c12c01builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom11c12builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom11c12c01builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom11c11builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom11c11c12builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom11c11c01builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom11c11c12c01builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom11c01builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom11c10builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom11c21c10builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom11c11c12c10builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom11c21c01c10builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom11c21c11c10builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom11c21c12c01c10builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom11c21c11c01c10builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom11c21c11c12c10builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom11c21c11c12c01c10builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom11c12c10builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom11c12c01c10builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom11c11c10builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom11c11c12c10builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom11c11c01c10builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom11c11c12c01c10builder');
    &Awfif::addjhlstm ($jhlsid, 'vbttom11c01c10builder');
# vbttoamsbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamsbuilder');
# vbttoams09c19c08bindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamebuilder');
# vbttoams99c89c98bindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamnbuilder');
# vbttoams90c80c91bindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamwbuilder');
# vbttmsbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttmbuilder');
# vbttoamnbindtomsiggv
# vbttoamrbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
# &Awfif::addjhlstm ($jhlsid, 'vbttoamnbuilder');
    &Awfif::addjhlstm ($jhlsid, 'vbttoamrbuilder');
# vbttoa09c19c08c09bindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
# &Awfif::addjhlstm ($jhlsid, 'vbttoamnbuilder');
    &Awfif::addjhlstm ($jhlsid, 'vbttoamrbuilder');
# vbttoa99c89c98c99bindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
# &Awfif::addjhlstm ($jhlsid, 'vbttoamnbuilder');
    &Awfif::addjhlstm ($jhlsid, 'vbttoamrbuilder');
# vbttoa90c80c91c90bindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamrbuilder');
# vbttmsbindtomsiggvn
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttmbuilder');
# vbttoamebindtomsiggve
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttmbuilder');
# vbttoamwbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {cans}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {eight}, $Awfif::memes-> {snnh} {naught}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamwbuilder');
# vbttoamrbindtomsiggv2
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $Awfif::memes-> {snnh} {nine}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {cans}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamrbuilder');
# vbttoapcbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoapcbuilder');
# vbttoamwbindtomsiggvw
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttmbuilder');
# vbttoamrbindtomsiggvr
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttmbuilder');
# vbttoamscebindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamsbuilder');
# vbttoams09c19bindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamebuilder');
# vbttoams99c89bindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamnbuilder');
# vbttoams90c80bindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamwbuilder');
# vbttoamscecstbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamsbuilder');
# vbttoams09c19c09tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoapcbuilder');
# vbttoams99c89c99tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoapcbuilder');
# vbttoams90c80c90tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoapcbuilder');
# vbttoamsnctbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamsbuilder');
# vbttoams9nctbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamebuilder');
# vbttoams99nctbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamnbuilder');
# vbtto90c90amnctbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamwbuilder');
# vbttoams90nctbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamwbuilder');
# vbttoam0rectbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamrbuilder');
# vbttoa01msnctbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamebuilder');
# vbttoa19menctbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamebuilder');
# vbttoa98menctbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamnbuilder');
# vbttoa10menctbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamwbuilder');
# vbttoa11menctbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamrbuilder');
# vbttoa11mrc10tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamrbuilder');
# vbttoa01msc01tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamsbuilder');
# vbttoa19msc19tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamebuilder');
# vbttoa98msc98tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamnbuilder');
# vbttoa10msc10tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamwbuilder');
# vbttoa11msc11tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamrbuilder');
# vbttoa11msc11c10tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamrbuilder');
# vbttoa01msc11tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamsbuilder');
# vbttoa19msc18tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamebuilder');
# vbttoa98msc88tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamnbuilder');
# vbttoa10msc11tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamwbuilder');
# vbttoa11msc12tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamrbuilder');
# vbttoa11msc12c10tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamrbuilder');
# vbttoa01msc00c11tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamsbuilder');
# vbttoa19msc09c18tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamebuilder');
# vbttoa98msc99c88tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamnbuilder');
# vbttoa10msc20c11tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamwbuilder');
# vbttoa11msc21c12tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamrbuilder');
# vbttoa11msc21c12c10tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamrbuilder');
# vbttoa01msc00tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamsbuilder');
# vbttoa19msc09tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamebuilder');
# vbttoa98msc99tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamnbuilder');
# vbttoa10msc20tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamwbuilder');
# vbttoa11msc21tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamrbuilder');
# vbttoa11msc21c10tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamrbuilder');
# vbttoa01msc01c11tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamsbuilder');
# vbttoa01msc00c01c11tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamsbuilder');
# vbttoa19msc09c19c18tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamebuilder');
# vbttoa19msc19c18tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamebuilder');
# vbttoa98msc98c88tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamnbuilder');
# vbttoa10msc10c11tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamwbuilder');
# vbttoa11msc11c12tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamrbuilder');
# vbttoa11msc11c12c10tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamrbuilder');
# vbttoa01msc02tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamsbuilder');
# vbttoa19msc29tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamebuilder');
# vbttoa98msc97tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamnbuilder');
# vbttoa10msc00tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamwbuilder');
# vbttoa11msc01tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamrbuilder');
# vbttoa11msc01c10tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamrbuilder');
# vbttoa01msc00c02tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamsbuilder');
# vbttoa19msc09c29tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamebuilder');
# vbttoa98msc99c97tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamnbuilder');
# vbttoa10msc20c00tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamwbuilder');
# vbttoa11msc21c01tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamrbuilder');
# vbttoa11msc21c01c10tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamrbuilder');
# vbttoa01msc01c02tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamsbuilder');
# vbttoa19msc19c29tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamebuilder');
# vbttoa98msc98c97tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamnbuilder');
# vbttoa10msc10c00tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamwbuilder');
# vbttoa11msc11c01tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamrbuilder');
# vbttoa11msc11c01c10tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamrbuilder');
# vbttoa01msc11c02tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamsbuilder');
# vbttoa19msc18c29tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamebuilder');
# vbttoa98msc88c97tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamnbuilder');
# vbttoa10msc11c00tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamwbuilder');
# vbttoa11msc12c01tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamrbuilder');
# vbttoa11msc12c01c10tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamrbuilder');
# vbttoa01msc00c11c02tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamsbuilder');
# vbttoa19msc09c18c29tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamebuilder');
# vbttoa98msc99c88c97tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamnbuilder');
# vbttoa10msc20c11c00tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamwbuilder');
# vbttoa11msc21c12c01tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamrbuilder');
# vbttoa11msc21c12c01c10tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamrbuilder');
# vbttoa01msc01c11c02tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamsbuilder');
# vbttoa19msc19c18c29tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamebuilder');
# vbttoa98msc98c88c97tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamnbuilder');
# vbttoa10msc10c11c00tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamwbuilder');
# vbttoa11msc11c12c01tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamrbuilder');
# vbttoa11msc11c12c01c10tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamrbuilder');
# vbttoa01msc00c01tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamsbuilder');
# vbttoa19msc09c19tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamebuilder');
# vbttoa98msc99c98tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamnbuilder');
# vbttoa10msc20c10tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamwbuilder');
# vbttoa11msc21c11tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamrbuilder');
# vbttoa11msc21c11c10tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamrbuilder');
# vbttoa01msc00c01c02tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamsbuilder');
# vbttoa19msc09c19c29tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamebuilder');
# vbttoa98msc99c98c97tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamnbuilder');
# vbttoa10msc20c10c00tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamwbuilder');
# vbttoa11msc21c11c01tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamrbuilder');
# vbttoa11msc21c11c01c10tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamrbuilder');
# vbttoa01msc00c01c11c02tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamsbuilder');
# vbttoa19msc09c19c18c29tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamebuilder');
# vbttoa98msc99c98c88c97tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamnbuilder');
# vbttoa98msc99c98c88tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamnbuilder');
# vbttoa10msc20c10c11c00tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamwbuilder');
# vbttoa10msc20c10c11tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamwbuilder');
# vbttoa11msc21c11c12c01tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamrbuilder');
# vbttoa11msc21c11c12tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamrbuilder');
# vbttoa11msc21c11c12c01c10tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamrbuilder');
# vbttoa11msc21c11c12c10tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamrbuilder');
# vbttoa00pcc00c01tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoapcbuilder');
# vbttoa09pcc09c08tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoapcbuilder');
# vbttoa99pcc99c98tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoapcbuilder');
# vbttoa90pcc90c91tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoapcbuilder');
# vbttoamscstbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamsbuilder');
# vbttoams09c08tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamebuilder');
# vbttoams99c98tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamnbuilder');
# vbttoams90c91tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoamwbuilder');
# vbttoams09c09tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoapcbuilder');
# vbttoams99c99tbindtomsiggv
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttoapcbuilder');
# vbttoapcbindtomsiggvp
# setup the binding string for the multi path signal to control genetic algorithm implement 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} {vbt}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {vbt}] [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} {vbt}, $Awfif::memes-> {snnh} {schema}, $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} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlstm ($jhlsid, 'vbttmbuilder');
# 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}]);
# genetic

    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnd}
      [$Awfif::memes-> {snnh} {genetic}] = 1;
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc}
      [$Awfif::memes-> {snnh} {genetic}][0] = 13;#13
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc}
      [$Awfif::memes-> {snnh} {genetic}][1] = 12;#5
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {genetic}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namedcategory},$Awfif::memes-> {snnh} {genetic},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {genetic}]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {genetic}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {testcategory},$Awfif::memes-> {snnh} {genetic},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {genetic}]);
# vbtiopbindtosig
# setup the binding string for the single path signal to initiate a vbtevaluator/builder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {implement}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {implement}] [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} {genetic}, $Awfif::memes-> {snnh} {algorithm}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {vbtiopevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
# vbtiopbindtoinhib

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {implement}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {implement}] [1], 8, $Awfif::memes-> {currentwsbi});
    &Awfif::addjhlinhib ($pconc, $Awfif::memes-> {snnh} {genetic}, $Awfif::memes-> {snnh} {algorithm}, $Awfif::memes-> {snnh} {vbot}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {inhibitor}, $Awfif::memes-> {snnh} {vbtiopinhibitor}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
# vbtiopgsbindtobis
# 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} {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} {vbt}, $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} {vbt}, $Awfif::memes-> {snnh} {selector}, $Awfif::memes-> {snnh} {schema}, $Awfif::memes-> {snnh} {attribr});
# naught

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

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

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

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

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

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

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

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

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

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

    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnd}
      [$Awfif::memes-> {snnh} {square}] = 1;
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc}
      [$Awfif::memes-> {snnh} {square}][0] = 13;#13
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc}
      [$Awfif::memes-> {snnh} {square}][1] = 12;#5
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {square}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namedcategory},$Awfif::memes-> {snnh} {square},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {square}]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {square}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {testcategory},$Awfif::memes-> {snnh} {square},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {square}]);
# 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 strin