Slipnet
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

Phenomenological relations infrastructure for Copycat

Summary
This page describes the
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
Slipnet. 
The goal of the Slipnet is reviewed
Smiley's specialized use of the Slipnet is introduced
The initial Slipnet network used by the '
This page discusses how a Smiley based application the event processor test program's operational phase is structured. 
The goals of the event processor test application are described. 
The implementation strategy is outlined. 
Synchronization of Smiley setup completion and operation phase initiation is discussed. 
The association of structural Workspaces for state representation is discussed. 
An application specific codelet merge streams assert responds to the nature of the assertion.  It does not have an emergent structure.  Instead it reflects software engineering practice.  It includes:
  • Merge stream case specific
    • Modeling with sub-programs
    • Resolving of case
  • Non case assertion
The operation is setup, inhibited, initiated, and managed by iterative phase check-pointing provided by Smiley codelets. 
Schematic synchronization of parallel codelet cascades is performed structurally. 
The assert merge operon cascade is included. 
The Slipnet concept network for merge streams is included. 
The codelets and supporting functions are included. 
Merge Streams
' and '
This page discusses a complex adaptive system (CAS) implementation of a genetic algorithm (GA), Melanie Mitchell's robot-janitor built as a set of 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 schematic strings which make up the robot's genotype, as well as the signals which are sent to the nucleus of the robot's agents so that the agents can deploy the appropriate response strings (which activate codelets) are listed.  The 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 emergence and creative evolution are discussed and alternative experimental frameworks are proposed.  One such, the schematic cell is the subject of a separate page in this web frame. 

Virtual Robot
'
Plans are interpreted and implemented by agents.  This page discusses the properties of agents in a complex adaptive system (CAS). 
It then presents examples of agents in different CAS.  The examples include a computer program where modeling and actions are performed by software agents.  These software agents are aggregates. 
The participation of agents in flows is introduced and some implications of this are outlined. 
agent-based
applications is setup in initchemistry and is included
The Slipnet infrastructure and initialization functions are included. 
Introduction
Smiley, an
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. 
agent programming framework
, needs a mechanism to define and adapt the attributes of the
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
that can populate its physical environment the
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
.  To do this we 'repurposed' Copycat's solution, the Slipnet. 
Hofstadter and Mitchell's goal for the Slipnet
Copycat, Douglas Hofstadter & Melanie Mitchell's implementation of 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 & representation
architecture, integrates a conceptual model with its local perceptions of its situation.  The conceptual model has named concepts.  The concepts are linked to each other via relations.  The relations are also named concepts.  Any concept can be activated (actnodes), when it is identified as being part of the perceptions.  Overtime the activation will decay away (actdecay). 

Hofstadter & Mitchell gave the concepts depth, an indication of how abstract the concepts are Hofstadter argues, - but which works well as the weighting in
The agents in complex adaptive systems (CAS) must model their environment to respond effectively to it.  Samuel modeling is described as an approach. 
Samuel modeling
, and placed them at distances from each other.  Activation can flow from one concept to another (
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
-> supactivatn) if the distance is short enough (bondurgency), or the resistance is low.  When the link's concepts are activated the link's resistance lowers.  Related concepts can also slip into one another (
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
-> perfslips). 
Smiley's additional use of the Slipnet
The Slipnet provides a flexible foundation for describing, and adapting, the physical phenomena, forces, relations and
Barriers are particular types of constraints on flows.  They can enforce separation of a network of agents allowing evolution to build diversity.  Examples of different types of barriers and their effects are described. 
barriers
with which chemical properties are associated with
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
objects.  The descriptor codelets activate salient, Douglas Hofstadter controlled the amount of attention a Workspace object in Copycat would receive from codelets via its salience.  The more descriptions, analogous to geons, an object has and the more highly activated the nodes involved therin, the more important the object is.  Modulating this tendency is any relative lack of connections from the object to the rest of the objects in the Workspace.  Salience is a dynamic number that takes into account both these factors.  In Smiley the instantaneous salience of a Workspace's objects is calculated by itsalience.   descriptor structures in the Workspace via uselinkcategory

Phenomena are represented physically as tokens such as pttruet.  The physical nature of the concepts present in the Workspace depends on what tokens make up the keyword which represents the concept.  That nature depends on the tokens bound to the keyword specified in the 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.  

The Smiley Slipnet provides structural forces via Perl operations:

Complex structures, such as operons is an addressable control structure which is used in biological cells to control access to other regions of the DNA. 
- sets of adjacent concepts that
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. 
bind associatively
to active sites, on the external surface of folded proteins present amino acids which become catalytic structures.   of
This page reviews the catalytic impact of infrastructure on the expression of phenotypic effects by an agent.  The infrastructure reduces the cost the agent must pay to perform the selected action.  The catalysis is enhanced by positive returns. 
infrastructure amplifiers
in the system, emerge from the chemical interactions.  Many models within AWF are defined by an operon based on the concept model.
 
 

Functions

#
sub bondurgency {
    my ($nidl, $pidl, $bsnn1, $bsnn2) = @_;
# nidl and pidl are link indexes since this is easy for codelets to obtain
    my ($urgency, $x1, $x2);
# checked for merged workspaces
    if ($Awfif::memes-> {trace} == $Awfif::memes-> {traceurg}) {
      my ($pr);
      $pr = $Awfif::memes-> {snnih}{$Awfif::slipnet-> {l} [$nidl][4]};
      print ("bondurgency ni $pr, ");
      $pr = $Awfif::memes-> {snnih}{$Awfif::slipnet-> {l} [$pidl][4]};
      print ("pi $pr, ");
      $pr = $Awfif::memes-> {snnih}{$bsnn1}.'('.$bsnn1.')';
      print ("bsnn1 $pr ");
      $pr = $Awfif::memes-> {snnih}{$bsnn2}.'('.$bsnn2.')';
      print ("bsnn2 $pr ");
      };
# urgency is proportional to the distance between nodes which is shortened by activation of links node

    $urgency = 0;
    $x1 = $Awfif::memes-> {coordmax} + $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snna} {$Awfif::memes-> {snnih} {$bsnn1}} - abs ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::slipnet-> {l} [$nidl][4]] [0] - $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::slipnet-> {l} [$pidl][4]] [0]);
    if ($x1 > 0) {

      $x2 = $Awfif::memes-> {coordmax} + $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snna} {$Awfif::memes-> {snnih} {$bsnn2}}-abs ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::slipnet-> {l} [$nidl][4]] [1] - $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::slipnet-> {l} [$pidl][4]] [1]);
      if ($x2 > 0) {

        $urgency = $x1 * $x2 * $Awfif::memes-> {coordamp};
        }
      else {

        $urgency = 0;
        };
      }#keep going
    else {

      $urgency = 0;
      };

    if ($Awfif::memes-> {trace} == $Awfif::memes-> {traceurg}) {
      print ("bondurgency ret int($urgency)\n");
      };
    return int ($urgency)
    } #bondurgency
#
#<!-- end tag cr -->
#
sub actdecay {
    my($nodename)=@_;
    my($decay, $snna, $snnac, $snnaf);

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

# critical reduction has been moved to the scout completion point
# checked for merged workspaces
    $decay = 0;
    $snnac = $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnac} {$nodename};
    if ($snnac > 0) {
# do nothing
      } #activated node
    else {
      $snnaf = $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnaf}{$nodename};
      if ($snnaf > 0) {

        $snnaf --;
        $snna = 1;
        } # fatigued node
      else {

        $snna = $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snna} {$nodename};
        $decay = $Awfif::memes-> {ndecay};
        }# normal decay
      if ($decay >= $snna) {

        $decay = $snna - 1;
        };# decay back to 1 only

      $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snna} {$nodename} = $snna;
      $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnac} {$nodename} = $snnac;
      $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnaf}{$nodename} = $snnaf;
      };#else
    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      my ($pr);
      $pr = $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snna}{$nodename};
      print ("actdecay snna $pr ret $decay\n");
      };
    return $decay
    } #actdecay
#
sub actchange {
    my($wslp, $actchanged);

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

    $actchanged = '';
    $wslp = $Awfif::wsbl->{h};
    while (($wslp != 1) && ($wslp != $Awfif::wsbl->{t}) && (!$actchanged)) {#look for activation changes

      if ($Awfif::memes-> {activationchange} [$wslp] != 0) {
        $actchanged = 't';
        };
      $wslp = $Awfif::wsbl->{l}[$wslp][0];
      };#while each active workspace

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("actchangex ret ($actchanged)\n");
      };
    return $actchanged
    } #actchange
#
#<!-- start tag ctr -->
#
sub supactivatn {
    my($kwp, $kwpr, $sactset )=@_;
    my ($snlink, $snnode, $sn3, $endloop, $dchange, $ugroup, $groupact, $cleariudp, $clearediudp, $conclass, $feedback,
    $sec, $min, $hour, $mday, $mon, $year, $wday, $yday, $isdat
    );

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("supactivatn kwp($kwp) kwpr($kwpr)");
      };
# This procedure scans for slipnet nodes that are above their thresholds and
# submits a top down codelet to instantiate the activation
# As it performs the scan of the slipnet it decays nodes activation based on depth.
#
# Top-down bond scouts are given a predefined bond-related concept from the Slipnet
# (e.g. a certain bond-category, like successor),
# and the first object is chosen as a probabilistic function of its unhappiness and
# the number of occurrences of that bond (successor) in its surroundings (its string).
# checked for merged workspaces
    if ($Awfif::memes-> {trace} == $Awfif::memes-> {tracehrtime}) {
      use Time::HiRes 'time';
      ($sec, $min, $hour, $mday, $mon, $year, $wday, $yday, $isdat) = localtime(time);
      };
# $Awfif::memes-> {time} [$Awfif::memes-> {satime}] [$Awfif::memes-> {starttime}] = time ();

    $cleariudp = $Awfif::memes-> {activationchange} [$Awfif::memes-> {currentwsbi}];
# supactcdeltau
    $Awfif::memes-> {activationchange} [$Awfif::memes-> {currentwsbi}] = 0;
    $clearediudp = '';
# tgroupsfsau0
    $feedback = addfeedback (undef(), 'tgroupscout', $Awfif::memes-> {cpcountth});
    for my $act (@$sactset) {
      if ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snna} {$act} > 1 ) {
# clear cache lines

# $starttime = time ();
      if ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snna} {$act} > $Awfif::memes-> {actth} ) {

        $ugroup = '';
        $conclass = gencclass ($act);
        $groupact = $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnacla} {$act} [$conclass];
# if this node is a child of bondcategory then launch a bond scount

        $snnode = $Awfif::slipnet-> {l} [$Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl} [$Awfif::memes-> {snnh} {bondcategory}]] [2];
        $snlink = $Awfif::slipnet-> {l} [$Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl} [$Awfif::memes-> {snnh} {bondcategory}]] [0];
        $sn3 = $Awfif::slipnet-> {l} [$Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl} [$Awfif::memes-> {snnh} {bondcategory}]] [3];
        if (($snlink == 0) && ($ugroup)) {

          $endloop = 't';
          }#bond and group checked
        elsif ($snlink == 0) {#check group

          $ugroup = 't';
# if this node is a child of groupcategory then launch a group scount
          $snnode = $Awfif::slipnet-> {l} [$Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl} [$Awfif::memes-> {snnh} {groupcategory}]] [2];
          $snlink = $Awfif::slipnet-> {l} [$Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl} [$Awfif::memes-> {snnh} {groupcategory}]] [0];
          $sn3 = $Awfif::slipnet-> {l} [$Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl} [$Awfif::memes-> {snnh} {groupcategory}]] [3];
          if ($snnode == 0) {

            $endloop = "T";
            }
          else {
            $endloop = "";
            };#else

          }
        else {
          $endloop = "";
          };#else
        while (!($endloop) ) {
# supactivatnsnnacla

          if (($snnode == $Awfif::memes-> {snnh}{$act}) ) {#group or bond

            if ((!$ugroup) && (($conclass == 2) or ($conclass == 4)) && ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnacla} {$act} [$conclass] > 0)) {#critical allows deployment

              $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnacla}{$act} [$conclass] --;
              $Awfif::clp = ();
              $Awfif::clp-> {wsi} = $Awfif::memes-> {currentwsbi};
              $Awfif::clp-> {urgency} = $Awfif::memes-> {tdbsurg};#check how this should be set
              $Awfif::clp-> {strategy} = "tbondscout";
              $Awfif::clp-> {bond} -> {category} = $Awfif::memes-> {snnh}{$act};
              &Awfif::submitcodelet ('',\$Awfif::clp);
              }#bond

            elsif (($ugroup) && (($conclass == 3) or ($conclass == 4)) && ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnacla} {$act} [$conclass] > 0)) {#critical allows deployment

              $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnacla}{$act} [$conclass] --;
              $Awfif::clp = ();
              $Awfif::clp-> {wsi} = $Awfif::memes-> {currentwsbi};
# tgroupsfsau1
              if ($feedback != $Awfif::memes-> {cpcountth}) {

                $Awfif::clp-> {urgency} = ($Awfif::memes-> {tdgsurg}/10);
                }#if
              else {

                $Awfif::clp-> {urgency} = $Awfif::memes-> {tdgsurg};#check how this should be set
                };#else
              $Awfif::clp-> {strategy} = "tgroupscout";
              $Awfif::clp-> {bond} -> {category} = $Awfif::memes-> {snnh}{$act};
              &Awfif::submitcodelet ('',\$Awfif::clp);
              };

            if (($conclass == 1) && ($snnode == $Awfif::memes-> {snnh}{$act}) && ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnacla} {$act} [$conclass] > 0)) {

              $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnacla}{$act} [1] --;
              $Awfif::clp = ();
              $Awfif::clp-> {urgency} = $Awfif::memes-> {tddsurg};#check how this should be set
              $Awfif::clp-> {wsi} = $Awfif::memes-> {currentwsbi};
              $Awfif::clp-> {strategy} = "tdescscout";
              $Awfif::clp-> {bond} -> {category} = $Awfif::memes-> {snnh}{$act};
              &Awfif::submitcodelet ('',\$Awfif::clp);
              };
            };#if match

          if ($snlink != 0) {
            $snnode = $Awfif::slipnet-> {l} [$snlink][2];#
            $sn3 = $Awfif::slipnet-> {l} [$snlink][3];#
            $snlink = $Awfif::slipnet-> {l} [$snlink] [0]; #check siblings
            }
          elsif (($snlink == 0) && ($ugroup)) {

            if (($ugroup) && (($conclass == 3) or ($conclass == 4)) && ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnacla} {$act} [$conclass] > 0)) {#critical allows deployment

              $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnacla}{$act} [$conclass] --;
              $Awfif::clp = ();
              $Awfif::clp-> {wsi} = $Awfif::memes-> {currentwsbi};
# tgroupsfsau2
              if ($feedback != $Awfif::memes-> {cpcountth}) {

                $Awfif::clp-> {urgency} = ($Awfif::memes-> {tdgsurg}/10);
                }#if
              else {

                $Awfif::clp-> {urgency} = $Awfif::memes-> {tdgsurg};#check how this should be set
                };#else
              $Awfif::clp-> {strategy} = "tgroupscout";
              $Awfif::clp-> {bond} -> {category} = $Awfif::memes-> {snnh}{$act};
              &Awfif::submitcodelet ('',\$Awfif::clp);
              };
            $endloop = "T";
            }#bond and group checked
          elsif ($snlink == 0) {#check group
# even though no bond matched it may be that bonded does
            if ((!$ugroup) && (($conclass == 2) or ($conclass == 4)) && ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnacla} {$act} [$conclass] > 0)) {#critical allows deployment

              $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnacla}{$act} [$conclass] --;
              $Awfif::clp = ();
              $Awfif::clp-> {wsi} = $Awfif::memes-> {currentwsbi};
              $Awfif::clp-> {urgency} = $Awfif::memes-> {tdbsurg};#check how this should be set
              $Awfif::clp-> {strategy} = "tbondscout";
              $Awfif::clp-> {bond} -> {category} = $Awfif::memes-> {snnh}{$act};
              &Awfif::submitcodelet ('',\$Awfif::clp);
              };#bond

            $ugroup = 't';
# if this node is a child of groupcategory then launch a group scount
            $snnode = $Awfif::slipnet-> {l} [$Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl} [$Awfif::memes-> {snnh} {groupcategory}]] [2];
            $snlink = $Awfif::slipnet-> {l} [$Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl} [$Awfif::memes-> {snnh} {groupcategory}]] [0];
            $sn3 = $Awfif::slipnet-> {l} [$Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl} [$Awfif::memes-> {snnh} {groupcategory}]] [3];
            if ($snnode == 0) {

              $endloop = "T";
              }
            else {

              $endloop = "";
              };#else
            };#elsif setup for group

          }; # while
        };#if
# $endtime = time ();
# $Awfif::memes-> {time} [$Awfif::memes-> {saltime}] [$Awfif::memes-> {sumtime}] = $Awfif::memes-> {time} [$Awfif::memes-> {saltime}] [$Awfif::memes-> {sumtime}] + $endtime - $starttime;
# decay the activation

# $starttime = time ();
      $dchange = $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snna} {$act};
      $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snna} {$act} = $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snna} {$act}
# $endtime = time ();
# $Awfif::memes-> {time} [$Awfif::memes-> {saddtime}] [$Awfif::memes-> {sumtime}] = $Awfif::memes-> {time} [$Awfif::memes-> {saddtime}] [$Awfif::memes-> {sumtime}] + $endtime - $starttime;

# $starttime = time ();
      if (($dchange != $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snna} {$act})
      && (($dchange ) >= $Awfif::memes-> {actth})
      && ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snna} {$act} < $Awfif::memes-> {actth})) {

        if ($Awfif::memes-> {snw}[$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh}{$act}] > 0) {#node is defined
          &wsclinv ($Awfif::memes-> {snnh}{$act}, $Awfif::memes-> {currentwsbi}, ($Awfif::memes-> {allwsstr} ^ $Awfif::memes-> {strbool}[$Awfif::memes-> {streh} {bustatement}]));
          };
        &wsclinv (0, $Awfif::memes-> {currentwsbi}, ($Awfif::memes-> {allwsstr} ^ $Awfif::memes-> {strbool}[$Awfif::memes-> {streh} {bustatement}]));

        &salcinv ($Awfif::memes-> {snnh}{$act});
# clear the selfacet cache lines

        &isfcache ();
        };
# $endtime = time ();
# $Awfif::memes-> {time} [$Awfif::memes-> {sadctime}] [$Awfif::memes-> {sumtime}] = $Awfif::memes-> {time} [$Awfif::memes-> {sadctime}] [$Awfif::memes-> {sumtime}] + $endtime - $starttime;
      };#if
      };# for
      if (($cleariudp != 0) && (!$clearediudp)) {

        $clearediudp = 't';
        };

# $Awfif::memes-> {time} [$Awfif::memes-> {satime}] [$Awfif::memes-> {endtime}] = time ();
# $Awfif::memes-> {time} [$Awfif::memes-> {satime}] [$Awfif::memes-> {sumtime}] = $Awfif::memes-> {time} [$Awfif::memes-> {satime}] [$Awfif::memes-> {sumtime}] + $Awfif::memes-> {time} [$Awfif::memes-> {satime}] [$Awfif::memes-> {endtime}] - $Awfif::memes-> {time} [$Awfif::memes-> {satime}] [$Awfif::memes-> {starttime}];
    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("supactivatnx\n");
      };
    }#supactivatn
#
#<!-- end tag ctr -->
#
sub gencclass {
    my($act )=@_;
    my ($snlink, $snnode, $sn3, $endloop, $ugroup, $group, $bond, $desc, $gandb, $result );

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      my ($pr);
      $pr = $Awfif::memes-> {snnh} {$act};
      print ("gencclass concept $act ($pr) ");
      };
# This procedure generates a class index from the slipnet structures for a concept
# checked for merged workspaces

    $result = 1;
    $desc = 1;
    $bond = 2;
    $group = 3;
    $gandb = 4;

    $ugroup = '';

    $snnode = $Awfif::slipnet-> {l} [$Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl} [$Awfif::memes-> {snnh} {bondcategory}]] [2];
    $snlink = $Awfif::slipnet-> {l} [$Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl} [$Awfif::memes-> {snnh} {bondcategory}]] [0];
    $sn3 = $Awfif::slipnet-> {l} [$Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl} [$Awfif::memes-> {snnh} {bondcategory}]] [3];

    if (($snlink == 0)
    ) {

      $ugroup = 't';
# if this node is a child of groupcategory then return group
      $snnode = $Awfif::slipnet-> {l} [$Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl} [$Awfif::memes-> {snnh} {groupcategory}]] [2];
      $snlink = $Awfif::slipnet-> {l} [$Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl} [$Awfif::memes-> {snnh} {groupcategory}]] [0];
      $sn3 = $Awfif::slipnet-> {l} [$Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl} [$Awfif::memes-> {snnh} {groupcategory}]] [3];
      if ($snnode == 0) {

        $endloop = "T";
        }
      else {
        $endloop = "";
        };#else

      }
    else {
      $endloop = "";
      };#else
    while (!($endloop) ) {

      if (($snnode == $Awfif::memes-> {snnh}{$act}) && ($sn3 == $Awfif::memes-> {snnh}{cibp}) && ($act ne 'bondcategory') && ($act ne 'groupcategory')) {

        if (($ugroup) && ($result == $bond)) {

          $result = $gandb;
          }# if
        elsif ($ugroup) {

          $result = $group;
          }#if
        else {

          $result = $bond;
          };#else
        };

      if ($snlink != 0) {
        $snnode = $Awfif::slipnet-> {l} [$snlink][2];#
        $sn3 = $Awfif::slipnet-> {l} [$snlink][3];#
        $snlink = $Awfif::slipnet-> {l} [$snlink] [0]; #check siblings
        }
      elsif (($snlink == 0) && ($ugroup)) {

        $endloop = "T";
        }#bond and group checked
      elsif ($snlink == 0) {#check group

        $ugroup = 't';
# if this node is a child of groupcategory then launch a group scount
        $snnode = $Awfif::slipnet-> {l} [$Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl} [$Awfif::memes-> {snnh} {groupcategory}]] [2];
        $snlink = $Awfif::slipnet-> {l} [$Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl} [$Awfif::memes-> {snnh} {groupcategory}]] [0];
        $sn3 = $Awfif::slipnet-> {l} [$Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl} [$Awfif::memes-> {snnh} {groupcategory}]] [3];
        if ($snnode == 0) {

          $endloop = "T";
          }
        else {

          $endloop = "";
          };#else
        };#setup for group

      }; # while
# tdclassing
# The following code should be un-commented when bondedcategory & groupedcategory classing are implemented
    if (($result == $desc) && (matchsnn ($Awfif::memes-> {snnh} {$act}, $Awfif::memes-> {snnh} {bondedcategory})) ) {
      $result = $bond;
      };
    if (($result == $desc) && (matchsnn ($Awfif::memes-> {snnh} {$act}, $Awfif::memes-> {snnh} {groupedcategory})) ) {
      $result = $group;
      }#if
    elsif (($result == $bond) && (matchsnn ($Awfif::memes-> {snnh} {$act}, $Awfif::memes-> {snnh} {groupedcategory})) ) {
      $result = $gandb;
      };#elsif

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("gencclassx ret ($result)\n");
      };
    return $result
    }#gencclass
#
sub matchsnn {
    my($act, $category )=@_;
    my ($snlink, $snnode, $result );

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      my ($pr);
      $pr = $Awfif::memes-> {snnih} {$act};
      print ("matchsnn concept $pr ($act) ");
      $pr = $Awfif::memes-> {snnih} {$category};
      print ("category $pr ($category) ");
      };
# This procedure responds true if a concept matches slipnet node of the specified category
# checked for merged workspaces

    $result = '';
    if ($Awfif::memes->{snw} [$Awfif::memes->{currentwsbi}]-> {msnn} [$category][$act] == 1) {
      $result = 't';
      }
# now check the stop list
    elsif ($Awfif::memes->{snw} [$Awfif::memes->{currentwsbi}]-> {msnn} [$category][$act] == 2) {
      $result = '';
      }
    else {

      $snnode = $Awfif::slipnet-> {l} [$Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl} [$category]] [2];
      $snlink = $Awfif::slipnet-> {l} [$Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl} [$category]] [0];
      if (($snlink != 0)) {

        while (!($snlink == 0) && (!$result)) {

          if (($snnode == $act)) {

            $result = 't';
            $Awfif::memes->{snw}[$Awfif::memes->{currentwsbi}]-> {msnn} [$category][$act] = 1;
            }# if
          else {

            $snnode = $Awfif::slipnet-> {l} [$snlink][2];#
            $snlink = $Awfif::slipnet-> {l} [$snlink] [0]; #check siblings
            };
          };#while

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

          my ($pr);
          $pr = $Awfif::memes-> {snnih} {$act};
          print ("bad act $pr ($act) ");
          };#if
        }; # if
      };#else

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("matchsnnx ret ($result)\n");
      };
    return $result
    }#matchsnn
#
sub genmsnnsl {
    my($wsi, $category )=@_;
    my ($i, $result );

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      my ($pr);
      $pr = $Awfif::memes-> {snnih} {$category};
      print ("genmsnnsl for category($pr) in ws($wsi) ");
      };
# This procedure generates the matchsnn "cache" stop list for $category in $ws

    $result = '';
    if ($category == $Awfif::memes-> {snnh}{bondedcategory} ) {

      for ($i = $Awfif::memes-> {snnh} {naught}; $i <= $Awfif::memes-> {snnh} {wsil};$i++) {
        $Awfif::memes->{snw} [$wsi]-> {msnn} [$category] [ $i ] = 2;
        };#for
      }
    else {

      $Awfif::memes->{snw} [$wsi]-> {msnn} [$category] [ $Awfif::memes-> {snnh} {replace} ] = 2;
      $Awfif::memes->{snw} [$wsi]-> {msnn} [$category] [ $Awfif::memes-> {snnh} {identity} ] = 2;
      $Awfif::memes->{snw} [$wsi]-> {msnn} [$category] [ $Awfif::memes-> {snnh} {attribute} ] = 2;
      $Awfif::memes->{snw} [$wsi]-> {msnn} [$category] [ $Awfif::memes-> {snnh} {cfile} ] = 2;
      $Awfif::memes->{snw} [$wsi]-> {msnn} [$category] [ $Awfif::memes-> {snnh} {civariable} ] = 2;
      $Awfif::memes->{snw} [$wsi]-> {msnn} [$category] [ $Awfif::memes-> {snnh} {crecord} ] = 2;
      $Awfif::memes->{snw} [$wsi]-> {msnn} [$category] [ $Awfif::memes-> {snnh} {cdata} ] = 2;
      $Awfif::memes->{snw} [$wsi]-> {msnn} [$category] [ $Awfif::memes-> {snnh} {groupd} ] = 2;
      $Awfif::memes->{snw} [$wsi]-> {msnn} [$category] [ $Awfif::memes-> {snnh} {groupu} ] = 2;
      $Awfif::memes->{snw} [$wsi]-> {msnn} [$category] [ $Awfif::memes-> {snnh} {relfacet} ] = 2;
      $Awfif::memes->{snw} [$wsi]-> {msnn} [$category] [ $Awfif::memes-> {snnh} {descfacet} ] = 2;
      $Awfif::memes->{snw} [$wsi]-> {msnn} [$category] [ $Awfif::memes-> {snnh} {bondfacet} ] = 2;
      $Awfif::memes->{snw} [$wsi]-> {msnn} [$category] [ $Awfif::memes-> {snnh} {namedcategory} ] = 2;
      $Awfif::memes->{snw} [$wsi]-> {msnn} [$category] [ $Awfif::memes-> {snnh} {objectcategory} ] = 2;
      $Awfif::memes->{snw} [$wsi]-> {msnn} [$category] [ $Awfif::memes-> {snnh} {testcategory} ] = 2;
      $Awfif::memes->{snw} [$wsi]-> {msnn} [$category] [ $Awfif::memes-> {snnh} {namescategory} ] = 2;
      $Awfif::memes->{snw} [$wsi]-> {msnn} [$category] [ $Awfif::memes-> {snnh} {iname} ] = 2;
      $Awfif::memes->{snw} [$wsi]-> {msnn} [$category] [ $Awfif::memes-> {snnh} {dname} ] = 2;
      $Awfif::memes->{snw} [$wsi]-> {msnn} [$category] [ $Awfif::memes-> {snnh} {assume} ] = 2;
      $Awfif::memes->{snw} [$wsi]-> {msnn} [$category] [ $Awfif::memes-> {snnh} {truthassertion} ] = 2;
      $Awfif::memes->{snw} [$wsi]-> {msnn} [$category] [ $Awfif::memes-> {snnh} {lateral} ] = 2;
      $Awfif::memes->{snw} [$wsi]-> {msnn} [$category] [ $Awfif::memes-> {snnh} {msormevaluator} ] = 2;
      $Awfif::memes->{snw} [$wsi]-> {msnn} [$category] [ $Awfif::memes-> {snnh} {miterevaluator} ] = 2;
      $Awfif::memes->{snw} [$wsi]-> {msnn} [$category] [ $Awfif::memes-> {snnh} {goodmverb} ] = 2;
      $Awfif::memes->{snw} [$wsi]-> {msnn} [$category] [ $Awfif::memes-> {snnh} {dropmverb} ] = 2;
      $Awfif::memes->{snw} [$wsi]-> {msnn} [$category] [ $Awfif::memes-> {snnh} {outgroup} ] = 2;
      $Awfif::memes->{snw} [$wsi]-> {msnn} [$category] [ $Awfif::memes-> {snnh} {mviintevaluator} ] = 2;
      $Awfif::memes->{snw} [$wsi]-> {msnn} [$category] [ $Awfif::memes-> {snnh} {iforall} ] = 2;
      $Awfif::memes->{snw} [$wsi]-> {msnn} [$category] [ $Awfif::memes-> {snnh} {miforallevaluator} ] = 2;
      $Awfif::memes->{snw} [$wsi]-> {msnn} [$category] [ $Awfif::memes-> {snnh} {miforallinspector} ] = 2;
      $Awfif::memes->{snw} [$wsi]-> {msnn} [$category] [ $Awfif::memes-> {snnh} {goodtarget} ] = 2;
      $Awfif::memes->{snw} [$wsi]-> {msnn} [$category] [ $Awfif::memes-> {snnh} {badtarget} ] = 2;
      $Awfif::memes->{snw} [$wsi]-> {msnn} [$category] [ $Awfif::memes-> {snnh} {goodscope} ] = 2;
      $Awfif::memes->{snw} [$wsi]-> {msnn} [$category] [ $Awfif::memes-> {snnh} {misevaluator} ] = 2;
      $Awfif::memes->{snw} [$wsi]-> {msnn} [$category] [ $Awfif::memes-> {snnh} {misinspector} ] = 2;
      $Awfif::memes->{snw} [$wsi]-> {msnn} [$category] [ $Awfif::memes-> {snnh} {dascgevaluator} ] = 2;
      $Awfif::memes->{snw} [$wsi]-> {msnn} [$category] [ $Awfif::memes-> {snnh} {assumecsp} ] = 2;
      $Awfif::memes->{snw} [$wsi]-> {msnn} [$category] [ $Awfif::memes-> {snnh} {dascginspector} ] = 2;
      $Awfif::memes->{snw} [$wsi]-> {msnn} [$category] [ $Awfif::memes-> {snnh} {casesaevaluator} ] = 2;
      $Awfif::memes->{snw} [$wsi]-> {msnn} [$category] [ $Awfif::memes-> {snnh} {casesainspector} ] = 2;
      $Awfif::memes->{snw} [$wsi]-> {msnn} [$category] [ $Awfif::memes-> {snnh} {goodcverb} ] = 2;
      $Awfif::memes->{snw} [$wsi]-> {msnn} [$category] [ $Awfif::memes-> {snnh} {dropcverb} ] = 2;
      $Awfif::memes->{snw} [$wsi]-> {msnn} [$category] [ $Awfif::memes-> {snnh} {mactcverbevaluator} ] = 2;
      $Awfif::memes->{snw} [$wsi]-> {msnn} [$category] [ $Awfif::memes-> {snnh} {mcssubevaluator} ] = 2;
      $Awfif::memes->{snw} [$wsi]-> {msnn} [$category] [ $Awfif::memes-> {snnh} {mcsobevaluator} ] = 2;
      $Awfif::memes->{snw} [$wsi]-> {msnn} [$category] [ $Awfif::memes-> {snnh} {dropcresddr} ] = 2;
      $Awfif::memes->{snw} [$wsi]-> {msnn} [$category] [ $Awfif::memes-> {snnh} {devevaluator} ] = 2;
      $Awfif::memes->{snw} [$wsi]-> {msnn} [$category] [ $Awfif::memes-> {snnh} {devinhibitor} ] = 2;
      $Awfif::memes->{snw} [$wsi]-> {msnn} [$category] [ $Awfif::memes-> {snnh} {indirectroot} ] = 2;
      $Awfif::memes->{snw} [$wsi]-> {msnn} [$category] [ $Awfif::memes-> {snnh} {devinspector} ] = 2;
      $Awfif::memes->{snw} [$wsi]-> {msnn} [$category] [ $Awfif::memes-> {snnh} {indirectcategory} ] = 2;
      $Awfif::memes->{snw} [$wsi]-> {msnn} [$category] [ $Awfif::memes-> {snnh} {ruleless} ] = 2;
      $Awfif::memes->{snw} [$wsi]-> {msnn} [$category] [ $Awfif::memes-> {snnh} {mwstdevaluator} ] = 2;
      $Awfif::memes->{snw} [$wsi]-> {msnn} [$category] [ $Awfif::memes-> {snnh} {fastroute} ] = 2;
      $Awfif::memes->{snw} [$wsi]-> {msnn} [$category] [ $Awfif::memes-> {snnh} {blockedroute} ] = 2;
      $Awfif::memes->{snw} [$wsi]-> {msnn} [$category] [ $Awfif::memes-> {snnh} {blockedbproute} ] = 2;
      for ($i = $Awfif::memes-> {snnh} {blrpartscategory}; $i < $Awfif::memes-> {snnh} {wsil};$i++) {

        $Awfif::memes->{snw} [$wsi]-> {msnn} [$category] [ $i ] = 2;
        };#for all needed blocked items
      };#else

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("genmsnnslx \n");
      };
    }#genmsnnsl
#
#<!-- start tag cr -resweb -->
#
sub perfslips {
    my ($activenode, $iactivation, $slipnode, $linktype, $urgency) = @_;
    my ($activation );
# checked for merged workspaces

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      my($pr);
      $pr = $Awfif::memes-> {snnih}{$activenode};
      print ("perfslips anode $pr input activation $iactivation snode $slipnode ltype $linktype urgency $urgency ");
      };
    $activation = $iactivation + $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snna} {$Awfif::memes-> {snnih} {$activenode}};
    if (($urgency > ($Awfif::memes-> {depththamp} * $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnd} [$slipnode]))
    && ($Awfif::memes-> {temp} [$Awfif::memes-> {currentwsbi}] > $Awfif::memes-> {slipth})) {# slip if valid linktype

      if ((($linktype == $Awfif::memes-> {snnh} {opposite}) && ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnac} {$Awfif::memes-> {snnih} {$slipnode}} == 0) && ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnaf} {$Awfif::memes-> {snnih} {$slipnode}} == 0)) #not critical or fatigued
      or (($linktype == $Awfif::memes-> {snnh} {associative}) && ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnac} {$Awfif::memes-> {snnih} {$slipnode}} == 0) && ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnaf} {$Awfif::memes-> {snnih} {$slipnode}} == 0))) {

        &actnodes ($slipnode, $iactivation + $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snna}{$Awfif::memes-> {snnih} {$activenode}});
        $activation = 0;
        };# if slip links
      };#if

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("perfslips ret $activation");
      };
    return $activation
    }# perfslips
#
#
sub igsnconcl {
    my ($myli, $snconcept, $snconcl, $cid, $ni) = @_;
    my ($family, $ignore, $linkp);
# figure out if the selsnlnc cache's snconcl of the snconcept is to be ignored for this codelet family
# updated for merged workspaces

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      my ($pr );
      $pr = $Awfif::memes-> {snnih} {$snconcept};
      print ("igsnconcl snconcept $pr snconcl $snconcl cid $cid ");
      };
    $ignore = '';

    if (($Awfif::codelet-> {l} [$myli][2] eq 'descscout') && ($cid eq 'de')) {

      $family = $Awfif::memes-> {igdesc};
      }
    elsif (($Awfif::codelet-> {l} [$myli][2] eq 'tdescscout') && ($cid eq 'de')) {

      $family = $Awfif::memes-> {igdesc};
      }
    elsif (($Awfif::codelet-> {l} [$myli][2] eq 'descscout') && ($cid eq 're')) {

      $family = $Awfif::memes-> {igrel};
      }
    elsif (($Awfif::codelet-> {l} [$myli][2] eq 'tdescscout') && ($cid eq 're')) {

      $family = $Awfif::memes-> {igrel};
      }
    else {#not setup so don't ignore it

      $family = -1;
      };
    if (checkcache ('tddescl', $snconcept, $snconcl, undef(), $Awfif::memes-> {snlcigch}) == 0 ) {

      $ignore = '';
      }
    else {

      $linkp = checkcache ('tddescl', $snconcept, $snconcl, undef(), $Awfif::memes-> {snlcigch});
      while (($linkp != 0) && (!$ignore)) {

        if (($Awfif::clnk-> {l}[$linkp][2] == awsoadr($ni)) && (($Awfif::clnk-> {l}[$linkp][3] ^ $family) != 0)) {

          $ignore = 't';
          };
        $linkp = $Awfif::clnk-> {l}[$linkp][0];
        };
# and the ni is included in the set of wso refs linked from the head

      };

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("igsnconclx ret ($ignore) \n");
      };
    return $ignore
    }# igsnconcl
#
sub rigsnconcl {
    my ($myli, $snconcept, $snconcl, $cid) = @_;
# Initialise the interest salience cache lines for the specified concept for all families
# checked for merged workspaces

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      my ($pr );
      $pr = $Awfif::memes-> {snnih} {$snconcept};
      print ("rigsnconcl myli $myli snconcept $pr snconcl $snconcl cid $cid ");
      };
# enable all snconcls of this concept to be used

# free any links to wsos that are now invalid

    while (checkcache ('tddescl', $snconcept, $snconcl, undef(), $Awfif::memes-> {snlcigch}) != 0 ) {
      &setcache ('tddescl', $snconcept, $snconcl, undef(), $Awfif::memes-> {snlcigch}, freeclnk (checkcache ('tddescl', $snconcept, $snconcl, undef(), $Awfif::memes-> {snlcigch})));
      };
    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("rigsnconclx\n");
      };
    }# rigsnconcl
#
sub ignpsnconcl {
    my ($snconcept, $snconcl, $cid, $ni) = @_;
    my ($linkp, $found);
# Ignore the interest salience cache lines for the specified concept, family & wso
# updated for merged workspaces

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      my ($pr );
      $pr = $Awfif::memes-> {snnih} {$snconcept};
      print ("ignpsnconcl snconcept $pr snconcl $snconcl cid $cid ni $ni ");
      };
    $found = '';

# Ignoring a concept means that the wso must be added to the list of ignore address links for this concept & snconcl
# and the mask will be associated indicating which codelets don't want to hear.

    if ($cid eq 'de') {
# this cache entry is of no interest to the desc family for ni
# create a link for ni if none in the chain already
# head of chain is in the cache entry [5]

      $linkp = checkcache ('tddescl', $snconcept, $snconcl, undef(), $Awfif::memes-> {snlcigch});
      while (($linkp != 0) && (!$found)) {
        if ($Awfif::clnk->{l}[$linkp][2] == awsoadr($ni)) {#entry already present mask in this request

          $found = 't';
          $Awfif::clnk->{l}[$linkp][3] &= $Awfif::memes->{igdesc};
          };
        $linkp = $Awfif::clnk-> {l}[$linkp][0];
        } # while
      if (!$found) {#create a new entry linked into the head

        &setcache ('tddescl', $snconcept, $snconcl, undef(), $Awfif::memes-> {snlcigch}, addclnk (
          $Awfif::memes->{igdesc},
          awsoadr($ni),
          checkcache ('tddescl', $snconcept, $snconcl, undef(), $Awfif::memes-> {snlcigch})));
        };
      } # de
    elsif ($cid eq 're') {
# this cache entry is of no interest to the desc family for ni
# create a link for ni if none in the chain already
# head of chain is in the cache entry [5]

      $linkp = checkcache ('tddescl', $snconcept, $snconcl, undef(), $Awfif::memes-> {snlcigch});
      while ($linkp != 0) {
        if ($Awfif::clnk->{l}[$linkp][2] == awsoadr($ni)) {#entry already present mask in this request

          $found = 't';
          $Awfif::clnk->{l}[$linkp][3] &= $Awfif::memes->{igrel};
          };
        $linkp = $Awfif::clnk-> {l}[$linkp][0];
        } # while

      if (!$found) {#create a new entry linked into the head

        &setcache ('tddescl', $snconcept, $snconcl, undef(), $Awfif::memes-> {snlcigch}, addclnk (
          $Awfif::memes->{igrel},
          awsoadr($ni),
          checkcache ('tddescl', $snconcept, $snconcl, undef(), $Awfif::memes-> {snlcigch})));
        };
      } # de

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("ignpsnconclx\n");
      };
    }# ignpsnconcl
#
sub salcinv {
    my ($node) = @_;
# Invalidate the salience cache lines for the specified concept id all across the slipnet
# checked for merged workspaces

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      my ($pr );
      $pr = $Awfif::memes-> {snnih} {$node};
      print ("salcinv node $pr ");
      };
# Scan the slipnet for tuples that will have their cache lines invalidated

    &setcache ('budescl', $node, undef(), undef(), $Awfif::memes-> {snlcvalid}, 0);
    &setcache ('tddescl', $node, undef(), undef(), $Awfif::memes-> {snlcvalid}, 0);
    &itscachecor ($node, 'budescl', 'seq','salcinv');
    &itscachecor ($node, 'tddescl', 'seq','salcinv');
    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("salcinv\n");
      };
    }# salcinv
#
#
sub actnodes {
    my ($node, $activation, $strscope) = @_;
    my ($snnval, $snlink, $urgency, $pactivation, $conclass, $cwsbi);
# Activate a slipnet node with specified quantity of activation
#
# checked for merged workspaces

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      my ($pr );
      $pr = $Awfif::memes-> {snnih} {$node};
      print ("actnodes node $pr, act $activation ");
      $pr = $Awfif::memes->{snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$node];
      print ("snnl $pr, ");
      $pr = $Awfif::memes->{snw} [$Awfif::memes-> {currentwsbi}]-> {snnaf}{$Awfif::memes-> {snnih} {$node}};
      print ("snnaf $pr, ");
      &pscope ($strscope);
      };
    $cwsbi = $Awfif::memes-> {currentwsbi};

    if ($Awfif::memes->{snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$node] > 0) {#worth activating
      $snnval = $node;#start point
# activate this node unless its fatigued
      if ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnaf} {$Awfif::memes-> {snnih} {$snnval}} == 0) {#can activate
        my($use);
# actnodecdeltau

        $use = 2;
        if ($strscope & ($Awfif::memes-> {strbool}[$Awfif::memes-> {streh} {delta}])) {#delta
          $use = 1;#
          };#if
# invalidate caches if activation changes
        if (($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snna}{$Awfif::memes-> {snnih} {$node}} < $Awfif::memes-> {actth})
        && (($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snna}{$Awfif::memes-> {snnih} {$node}} + $activation) >= $Awfif::memes-> {actth})) {

          &invcaches ($node, $strscope);
          if (!($strscope & ($Awfif::memes-> {strbool}[$Awfif::memes-> {streh} {delta}]))) {#delta
            &itwscachecor ('tddesc', $node, 'seq', 'actnodes');
            &itwscachecor ('budesc', $node, 'seq', 'actnodes');
            &itwscachecor ('tdbond', $node, 'seq', 'actnodes');
            &itwscachecor ('bubond', $node, 'seq', 'actnodes');
            &itwscachecor ('bugroup', $node, 'seq', 'actnodes');
            };
          &itwscachecor ('tdgroup', $node, 'seq', 'actnodes');
          &itwscachecor ('bustatement', $node, 'seq', 'actnodes');
          };
        if (($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snna} {$Awfif::memes-> {snnih} {$snnval}} + $activation) > 1) {
          $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snna} {$Awfif::memes-> {snnih} {$snnval}} = $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snna} {$Awfif::memes-> {snnih} {$snnval}} + $activation;
          }#if
        else {
          $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snna} {$Awfif::memes-> {snnih} {$snnval}} = 1;
          };#else
        $Awfif::memes-> {activationchange} [$Awfif::memes-> {currentwsbi}] = $use;
        if ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snna} {$Awfif::memes-> {snnih} {$snnval}} > $Awfif::memes-> {actth} ) {

          $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnac} {$Awfif::memes-> {snnih} {$snnval}} = $Awfif::memes-> {critical};
# actnodessnnacla
          $conclass = gencclass ($Awfif::memes-> {snnih} {$snnval});
          $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnacla} {$Awfif::memes-> {snnih} {$snnval}} [$conclass] = $Awfif::memes-> {critical};#set topdown launch set to critical size
          if ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snna} {$Awfif::memes-> {snnih} {$snnval}} > $Awfif::memes-> {actmax} ) {

            $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snna} {$Awfif::memes-> {snnih} {$snnval}} = $Awfif::memes-> {actmax};
            };# clip at max
          };# make critical
        };# not in fatigue
      $snlink = $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$snnval];#head of nodes list
      while ($snlink != 0) {
# now share activation with linked nodes based on their urgency
# ignore backpointer links
        if (($Awfif::slipnet-> {l} [$snlink] [3] != $Awfif::memes-> {snnh} {cibp}) && ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnac} {$Awfif::memes-> {snnih} {$node}} > 0)) {
# first own children & then siblings (other links of this activated node)

          $urgency = bondurgency ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl} [$snnval], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl} [$Awfif::slipnet-> {l} [$snlink][2]],
            $Awfif::slipnet-> {l} [$snlink] [3],
            $Awfif::slipnet-> {l} [$snlink] [3] );
          if (perfslips ($snnval, $activation, $Awfif::slipnet-> {l} [$snlink][2], $Awfif::slipnet-> {l} [$snlink][3], $urgency) == 0) {

            };# slipped so deactivate the supplying node - ??why??
          $pactivation = int (($activation * $urgency) /$Awfif::memes-> {actdamper});
          if ($pactivation <= 1) { # terminate the activation

            }#
          else {

            if (($Awfif::slipnet-> {l} [$snlink][2] != 0) && ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnac} {$Awfif::memes-> {snnih} {$Awfif::slipnet-> {l} [$snlink][2]}} == 0) && ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnaf} {$Awfif::memes-> {snnih} {$Awfif::slipnet-> {l} [$snlink][2]}} == 0)) {#get head of slipnet node's attributes

              &actnodes ($Awfif::slipnet-> {l} [$snlink][2], $pactivation, $strscope); # back up - find out why leaf or match
              };
            };#else
          }; #process forward links

        $snlink = $Awfif::slipnet-> {l} [$snlink][0]; #check siblings
        };# while sn links to traverse
      };# node has rules

    $Awfif::memes-> {currentwsbi} = $cwsbi;
    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("actnodes\n");
      };
    }# actnodes
#
sub actobj {# activate all the descriptors in a wso
    my($wsoid, $strscope, $amp )=@_;
    my ($linki, $iamp);
# updated for merged workspaces

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("actobj wso id $wsoid ");
      };
#
    $iamp = 1;
    if ($amp != '') {

      $iamp = $amp;
      };

    $linki = $Awfif::wsol-> {l} [ awsoadr($wsoid)][2]; #head
# all objects should have at least one descriptor - but ....
    if ($linki != 0) {# at least one descriptor

      while ($linki != 0) {
# activate the 2 3 and 4 of each descriptor in the list

        &actnodes ( $Awfif::workspace-> {l} [$linki] [3], $Awfif::memes-> {groupatype} * $iamp, $strscope);
        if (($Awfif::workspace-> {l} [$linki] [2] > 0) && ($Awfif::workspace-> {l} [$linki] [2] < $Awfif::memes-> {snnh}{wsil})) {

          &actnodes ( $Awfif::workspace-> {l} [$linki] [2], $Awfif::memes-> {groupato} * $iamp, $strscope);
          };#concept

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

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("actobjx\n");
      };
    }# actobj
#
#<!-- start tag ca -->
#
sub uselinkcategory {
    my ($myli, $ni, $nidl, $pidl, $snnindex, $match2, $plink, $cid, $kwp, $kwpr) = @_;
    my ($needmatch, $havematch, $stilll,
    @matches, @matchns, @smatches, $found, $tinstances);
#
# checked for merged workspaces

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("uselinkcategory nidl $nidl pidl $pidl plink $plink ");
      };

    $needmatch = "T";
    $havematch = 0;
    $stilll = "T";
    $found = '';
# invert code
    $havematch = usedescproperty ($nidl, \@matches, \@matchns, $plink, 1);

    if (($havematch != 0)) {# found matches for first now get second
# sort the matches by activation
      &dsort (\@matches, $havematch, \@smatches,'rsort');
# iterate starting most active first until get a match
# for second
# if get second match fix up $$match1 and $$match2
      $found = salsnlnc ($matchns [$smatches [$havematch-1]], $myli, $ni, \$tinstances, \$$snnindex, $cid, $kwp, $kwpr, 'budescl');
      if ($found) {
        $$match2 = $$snnindex;
        $needmatch = '';
        }
      else {#punich the failure

        &redcrit ($matchns [$smatches [$havematch-1]]);
        };
      };

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("uselinkcategory ret !($needmatch)\n");
      };
    return (!($needmatch));
    }# uselinkcategory
#
sub userlinkcategory {
    my ($myli, $ni, $nidl, $pidl, $snnindex, $match2, $snconcept, $plink, $cid, $kwp, $kwpr) = @_;
    my ($needmatch, $havematch, $stilll, $found, $tinstances);
#
# checked for merged workspaces

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("userlinkcategory nidl $nidl pidl $pidl plink $plink ");
      };

    $needmatch = 't';
    $havematch = 0;
    $stilll = 't';
    $found = '';
# invert code

    $found = salsnlnc ($snconcept, $myli, $ni, \$tinstances, \$$snnindex, $cid, $kwp, $kwpr, 'budescl');
    if ($found) {
      $$match2 = $$snnindex;
      $needmatch = '';
      }
    else {#concept is an issue
      &redcrit($snconcept);
      };

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("userlinkcategory ret !($needmatch)\n");
      };
    return (!($needmatch));
    }# userlinkcategory
#
#<!-- end tag ca -->
#
sub ransalst {# strategy implementation within ransalfor
    my($snconcept, $snptarget, $myli, $item, $snnode, $sneind, $kwp, $kwpr, $strategy, $i, $tinstances, $change, $part, $found, $rsna, $rsi)=@_;
    my ($i3, $rsnnode);
#
# checked for merged workspaces

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("ransalst snconcept($snconcept) snptarget($snptarget) i $i ");
      };
    $rsnnode = $snnode;

    for ($i3 = 2; $i3 <= 4; $i3++) {

      if ($$part [$i3]) {

        my($change1);
        $$change = $$change + $Awfif::memes-> {binds}-> {$strategy}->
          ($myli, $i, $kwp, $kwpr, \$change1); #mean change
        };# if
      };# for
    if (($item <= ($$tinstances+$$change)) && !($$found)) {

      $rsnnode = $sneind;
      $$found = 'T';
      };

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      my ($ti);
      print ("ransalstx rsi $$rsi ");
      if ($$rsi > 1) {
        for ($ti = 1;$ti <= $$rsi; $ti++) {
          print ("rsna $$rsna[$ti] ");
          };#for
        };#if
      print ("ret $rsnnode\n");
      };

    return $rsnnode
    }# ransalst
#
sub ransalfor {# reduce complexity
    my($snconcept, $snptarget, $myli, $item, $snnode, $sneind, $kwp, $kwpr, $strategy, $i, $tinstances, $linki, $found, $rsna, $rsi)=@_;
    my ($i3, $snptarget, $rsnnode);
#
# checked for merged workspaces

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("ransalfor snconcept($snconcept) i $i ");
      };
    $rsnnode = $snnode;
    if (
      ($snptarget == $Awfif::workspace-> {l} [$linki] [2])
    or ($snptarget == $Awfif::workspace-> {l} [$linki] [3])
    or
      ($snptarget == $Awfif::workspace-> {l} [$linki] [4])){
      for ($i3 = 2; $i3<=4; $i3++) {
        $$sneind = $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl} [ $Awfif::workspace-> {l} [$linki][$i3]];
        while ($$sneind != 0) {

          if ( $Awfif::memes-> {snnh} {cibp} != $Awfif::slipnet-> {l} [$$sneind] [3]) {
            my($change1);
            $$tinstances = $$tinstances + $Awfif::memes-> {binds}-> {$strategy}->
              ($myli, $i, $kwp, $kwpr, \$change1); #mean change
            $$rsna [$$rsi] = $$sneind;
            $$rsi++;
            };#not backpointer
          if (($item <= $$tinstances) && !($$found)) {

            $rsnnode = $$sneind;
            $$found = 'T';
            };
          $$sneind = $Awfif::slipnet-> {l} [$$sneind] [0];
          };# while
        };#for each aspect of the descriptor
      };# if
    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      my ($ti);
      print ("ransalforx rsi $$rsi ");
      if ($$rsi > 1) {
        for ($ti = 1;$ti <= $$rsi; $ti++) {
          print ("rsna $$rsna[$ti] ");
          };#for
        };#if
      print ("ret $rsnnode\n");
      };
    return $rsnnode
    }# ransalfor
#
#<!-- start tag ca -->
#
sub ransalsnl {# randomly select a salient slipnet link for the slipnet concept
    my($snconcept, $myli, $ni, $item, $kwp, $kwpr, $strategy)=@_;
    my ($i, $i2, $i4, $linki, $tinstances, $notreached, $found, $snptarget,
      $snconcl, $rsnnode, @rsna, $rsi,
    @xcoord, @ycoord, @node, @hsx, @hsy, $hsi, $hsmax, $cfound, $lb, $ub, $snnind, @part, $change );
#
# updated for merged workspaces
    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      my ($pr );
      $pr = $Awfif::memes-> {snnih} {$snconcept};
      print ("ransalsnl snconcept $pr strategy $strategy ");
      };

    $tinstances = 0;
    $rsnnode = 0;
    $rsi = 1;
    $notreached = "T";
    $found = '';

    if (checkcache ($strategy, $snconcept, undef(), undef(), $Awfif::memes-> {snlcvalid}) != 0) {
      $snconcl = checkcache ($strategy, $snconcept, 0, undef(), $Awfif::memes-> {snlcsnconcl});
      }
    else {#cache not loaded
      $snconcl = halodlnc ($snconcept,-1, \@xcoord, \@ycoord, \@node, \@hsx, \@hsy, \$hsi, \$hsmax, \$cfound);
      };
    while ($snconcl != 0) {

      $snptarget = $Awfif::slipnet-> {l} [$snconcl][2];
      if ($Awfif::slipnet-> {l} [$snconcl][3] != $Awfif::memes-> {snnh}{cibp}) {
        $i = $ni - 1;
        $i++;
        $change = 0;
        $i2 = 0;
        &calbounds ($i, 1,\$ub, \$lb, $kwp, $kwpr);
        $i4 = $lb;
        if (($lb != 0) && ($ub != 0)) {
          while (($i4 != 0) && ($ub > 0) ) {
            $linki = $Awfif::wsol-> {l} [ awsoadr($i4)][2]; #head
# all objects should have at least one descriptor - but ....
            if ($linki != 0) {# at least one descriptor
              while ($linki != 0) {

                if ( srelconc ($snptarget, $linki, \@part, $i, $kwp, $kwpr, \@rsna, \$rsi )) {
                  $rsnnode = ransalst ($snconcept, $snptarget, $myli, $item, $rsnnode, $snnind, $kwp, $kwpr, $strategy, $i, \$tinstances, \$change, \@part, \$found, \@rsna, \$rsi);
                  };# if

                $linki = $Awfif::workspace-> {l} [$linki] [0]; #walk back from head
                }# while
              };#if $link != 0
            $ub--;
            $i4 = trwsoadr ($i4, 1);
            }; #while
          }# for ws spread -> if
        $tinstances = $tinstances + $change;
        $change = 0;
        }; #if not cibp

#
      $i = $ni - 1;
      if (checkcache ($strategy, $snconcept, $snconcl, undef(), $Awfif::memes-> {snlcpcv}) ){
        $rsna [$rsi] = $snconcl;
        $rsi++;
        };
      if (checkcache ($strategy, $snconcept, undef(), undef(), $Awfif::memes-> {snlcvalid}) != 0) {
        $snconcl = checkcache ($strategy, $snconcept, $snconcl+1, undef(), $Awfif::memes-> {snlcsnconcl});
        }
      else {
        $snconcl = halodlnc($snconcept, $snconcl, \@xcoord, \@ycoord, \@node, \@hsx, \@hsy, \$hsi, \$hsmax, \$cfound);
        };
      }; #while snconcl not 0
    if ($rsi > 1) {
      $rsnnode = $rsna [int (rand ($rsi))+1];
      };

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("ransalsnl ret $rsnnode\n");
      };
    return $rsnnode;
    }# ransalsnl
#
sub normsalsnl {# normalize a salient slipnet link for the slipnet concept
    my($snconcept, $myli, $ni, $item, $kwp, $kwpr, $strategy)=@_;
    my ($i, $i2, $i4, $linki, $tinstances, $notreached, $found,
    $snptarget, $snconcl, $rsnnode, @rsna, $rsi,
    @xcoord, @ycoord, @node, @hsx, @hsy, $hsi, $hsmax, $cfound, $lb, $ub, $snnind, @part, $change );
#
# updated for merged workspaces

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      my ($pr );
      $pr = $Awfif::memes-> {snnih} {$snconcept};
      print ("normsalsnl snconcept $pr item $item strategy $strategy ");
      };

    $tinstances = 0;
    $rsnnode = 0;
    $notreached = "T";
    $rsi = 1;
    $found = '';
    $i = $ni -1;

    if (checkcache ($strategy, $snconcept, undef(), undef(), $Awfif::memes-> {snlcvalid}) != 0) {

      $snconcl = checkcache ($strategy, $snconcept, 0, undef(), $Awfif::memes-> {snlcsnconcl});
      }
    else {#cache not loaded

      $snconcl = halodlnc ($snconcept,-1, \@xcoord, \@ycoord, \@node, \@hsx, \@hsy, \$hsi, \$hsmax, \$cfound);
      };
    while (($snconcl != 0)&&($item > $tinstances)) {

      do {

        if ($item > $tinstances) {

          $notreached = "T";
          };
        if (($item <= $tinstances) or ($i >= $ni)) {

          $notreached = "";
          }#reached the ws item
        else {#still not reached

          if (checkcache ($strategy, $snconcept, undef(), undef(), $Awfif::memes-> {snlcvalid}) != 0) {

            $tinstances = $tinstances + checkcache ($strategy, $snconcept, $snconcl, awsoadr ($i+1), $Awfif::memes-> {snlctinst});
            $i++;
            $rsnnode = $snconcl;
            }
          else {
            $snptarget = $Awfif::slipnet-> {l} [$snconcl][2];

            if ($Awfif::slipnet-> {l} [$snconcl][3] != $Awfif::memes-> {snnh}{cibp}) {

              $i = $ni - 1;
              $i++;
              $change = 0;
              $i2 = 0;
              &calbounds ($i, 1,\$ub, \$lb, $kwp, $kwpr);
              $i4 = $lb;
              if (($lb != 0) && ($ub != 0)) {

                while (($i4 != 0) && ($ub > 0) ) {

                  $linki = $Awfif::wsol-> {l} [ awsoadr($i4)][2]; #head
# all objects should have at least one descriptor - but ....
                  if ($linki != 0) {# at least one descriptor

                    while ($linki != 0) {

                      if ( srelconc ($snptarget, $linki, \@part, $i, $kwp, $kwpr, \@rsna, \$rsi )) {

                        $rsnnode = ransalst ($snconcept, $snptarget, $myli, $item, $rsnnode, $snnind, $kwp, $kwpr, $strategy, $i, \$tinstances, \$change, \@part, \$found, \@rsna, \$rsi);
                        };

                      $linki = $Awfif::workspace-> {l} [$linki] [0]; #walk back from head
                      }# while
                    };#if $link != 0

                  $ub--;
                  $i4 = trwsoadr ($i4,1);
                  };#while
                }#for wso spread -> if

              $tinstances = $tinstances + $change;
              $change = 0;
              }; #if not cibp
            };#else not cached
#
          }# else
        }# do

      while ($notreached);
      $i = $ni - 1;

      if (checkcache ($strategy, $snconcept, $snconcl, undef(), $Awfif::memes-> {snlcpcv}) ){

        $rsna [$rsi] = $snconcl;
        $rsi++;
        };
      if (checkcache ($strategy, $snconcept, undef(), undef(), $Awfif::memes-> {snlcvalid}) != 0) {

        $snconcl = checkcache ($strategy, $snconcept, $snconcl+1, undef(), $Awfif::memes-> {snlcsnconcl});
        }
      else {

        $snconcl = halodlnc($snconcept, $snconcl, \@xcoord, \@ycoord, \@node, \@hsx, \@hsy, \$hsi, \$hsmax, \$cfound);
        };
      if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
        print ("normsalsnl tinst $tinstances of $item\n");
        };
      }; #while snconcl not 0

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      my ($pr);
      if ($rsnnode != 0) {
        $pr = $Awfif::memes->{snnih}{$Awfif::slipnet-> {l}[$rsnnode][4]};
        print ("normsalsnl ret [$rsnnode]->snn (4:$pr");
        $pr = $Awfif::memes->{snnih}{$Awfif::slipnet-> {l}[$rsnnode][3]};
        print (", 3:$pr");
        $pr = $Awfif::memes->{snnih}{$Awfif::slipnet-> {l}[$rsnnode][2]};
        print (", 2:$pr)\n");
        }
      else {
        print ("normsalsnl ret $rsnnode\n");
        };
      };
    return $rsnnode;
    }# normsalsnl
#
#<!-- end tag ca -->
#
sub halodlnc {# select a halo slipnet link for the slipnet concept
    my($snconcept, $plink, $xcoord, $ycoord, $node, $hsx, $hsy, $hsi, $hsmax, $cfound)=@_;
    my ($i, $nlink, $haloxs, $haloxe, $haloys, $haloye, $ix, $iy, $acti);
#
# checked for merged workspaces

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      my ($pr );
      $pr = $Awfif::memes-> {snnih} {$snconcept};
      print ("halodlnc snconcept $pr plink $plink ");
      };

    if ($plink < 0) {# initial condition
      $nlink = $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl} [$snconcept];
      $i = 0;
# setup initial state
# The {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} coordinates of snconcept are the halo centre
# The start is snconcept's activation/max activation * max threshold + x/y coord
# unless that start is less than 0 in which case the start is 0

      $$cfound = '';#look out for any critical activation within this halo
      &gethalo ($snconcept, \$haloxs, \$haloxe, \$haloys, \$haloye );
# record the initial position of the iterators
      $$hsx[0] = $haloxs;#current position in x
      $$hsx[1] = $haloxs;#start of x
      $$hsx[2] = $haloxe;#end of x
      $$hsy[0] = $haloys;#current position in y
      $$hsy[1] = $haloys;#start of y
      $$hsy[2] = $haloye;#end of y
      $$hsi = 1; # index into node arrays
#
      for ($acti = $Awfif::memes-> {snnh} {zero}; $acti < $Awfif::memes-> {snnh} {zero}; $acti++) {

        my ($haloaxs, $haloaxe, $haloays, $haloaye, $actmatch);
        $actmatch = '';
        &gethalo ($acti, \$haloaxs, \$haloaxe, \$haloays, \$haloaye );
        $ix = $haloxs;
        while (($ix <= $haloxe) && (!$actmatch)) {
          $iy = $haloys;
          while (($iy <= $haloye) && (!$actmatch)) {
# want the intersection to be match if the halo of $act overlaps ix and iy
            if (($haloaxs <= $ix) && ($haloaxe >= $ix)
            && ($haloays <= $iy) && ($haloaye >= $iy)) {

              $i++;
# setup map from coords to concept
              $$xcoord[$i] = $ix;
              $$ycoord[$i] = $iy;
              $$node[$i] = $acti;
              $actmatch = 't';
              if ( $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnac} {$Awfif::memes-> {snnih} {$acti}} > 0) {

                $$cfound = 't';
                }
              }; #if
            $iy++;
            }; # while iy
          $ix++;
          }; # while ix
        };# for each concept in sactset
      if ($$cfound) {

        $nlink = $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl} [$$node[$$hsi]];
        while (($nlink !=0)
        && ( ($Awfif::slipnet-> {l} [$nlink][3] == $Awfif::memes-> {snnh}{cinstance})
          or ($Awfif::slipnet-> {l} [$nlink][3] == $Awfif::memes-> {snnh}{cibp}) )) {#ignore this one
          $nlink = $Awfif::slipnet-> {l}[$nlink][0];
          if (($nlink == 0) && ($$hsi > $$hsmax)) {#stop

            $nlink = 0;
            }
# otherwise deploy the next node
          elsif ($nlink == 0) {

            while (($nlink == 0) && ($$hsi <= $$hsmax)) {

              $nlink = $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl} [$$node[$$hsi]];
              $$hsi++;
              };
            };
          };#while ignore
        }
      else {

        $nlink = 0;
        };
      $$hsmax = $i;
      $$hsi++;

      }# initial setup
    elsif ($plink == 0) {#at end of the concept set

      $nlink = 0;
      }
    else {# deploy next element of the halo concept
# if there are more links for this concept return them

      $nlink = $Awfif::slipnet->{l}[$plink][0];
      while (($nlink !=0)
      && ( ($Awfif::slipnet-> {l} [$nlink][3] == $Awfif::memes->{snnh}{cinstance})
        or ($Awfif::slipnet-> {l} [$nlink][3] == $Awfif::memes->{snnh}{cibp}) )) {#ignore this one
        $nlink = $Awfif::slipnet-> {l} [$nlink][0];
        if (($nlink == 0) && ($$hsi > $$hsmax)) {#stop

          $nlink = 0;
          }
# otherwise deploy the next node
        elsif ($nlink == 0) {

          while (($nlink == 0) && ($$hsi <= $$hsmax)) {

            $nlink = $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl} [$$node[$$hsi]];
            $$hsi++;
            };
          };
        };#while ignore
      if (($nlink == 0) && ($$hsi > $$hsmax)) {#stop

        $nlink = 0;
        }
# otherwise deploy the next node
      elsif ($nlink == 0) {

        while (($nlink == 0) && ($$hsi <= $$hsmax)) {

          $nlink = $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl} [$$node[$$hsi]];
          $$hsi++;
          };
        while (($nlink !=0)
        && ( ($Awfif::slipnet-> {l} [$nlink][3] == $Awfif::memes->{snnh}{cinstance})
          or ($Awfif::slipnet-> {l} [$nlink][3] == $Awfif::memes->{snnh}{cibp}) )) {#ignore this one
          $nlink = $Awfif::slipnet-> {l} [$nlink][0];
          if (($nlink == 0) && ($$hsi > $$hsmax)) {#stop

            $nlink = 0;
            }
# otherwise deploy the next node
          elsif ($nlink == 0) {

            while (($nlink == 0) && ($$hsi <= $$hsmax)) {

              $nlink = $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl} [$$node[$$hsi]];
              $$hsi++;
              };
            };
          };#while ignore
        };
      };

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("halodlnc ret $nlink\n");
      };
    return $nlink
    }# halodlnc
#
sub gethalo {# return the parameters of a concepts instantaneous halo
    my($snconcept, $haloxs, $haloxe, $haloys, $haloye)=@_;
    my ($halosize);
#
# checked for merged workspaces

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      my ($pr );
      $pr = $Awfif::memes-> {snnih} {$snconcept};
      print ("gethalo snconcept $pr ");
      };

    $halosize = int(($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snna} {$Awfif::memes-> {snnih} {$snconcept}}*$Awfif::memes-> {coordmax}) / (2*$Awfif::memes-> {actmax}));
    if ($halosize > $Awfif::memes-> {halomax}) {

      $halosize = $Awfif::memes-> {halomax};
      };
    $$haloxs = $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc}[$snconcept][0] - $halosize;
    if ($$haloxs < 0) {

      $$haloxs = 0;
      };
    $$haloys = $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc}[$snconcept][1] - $halosize;
    if ($$haloys < 0) {

      $$haloys = 0;
      };

    $$haloxe = $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc}[$snconcept][0] + $halosize;
    if ($$haloxe > $Awfif::memes-> {coordmax}) {

      $$haloxe = $Awfif::memes-> {coordmax};
      };
    $$haloye = $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc}[$snconcept][1] + $halosize;
    if ($$haloye > $Awfif::memes-> {coordmax}) {

      $$haloye = $Awfif::memes-> {coordmax};
      };

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("gethalox ys $$haloys ye $$haloye xs $$haloxs xe $$haloxe\n");
      };
    }# gethalo
#
sub fsalsnl {# find first match in salient slipnet link between a pair of wsobjects
# link must operate from foind base to toind base
    my($snconcept, $rlink, $foind, $toind)=@_;
    my ($notreached, $found,
    $snconcl, $rsnnode, $rsi,
    @xcoord, @ycoord, @node, @hsx, @hsy, $hsi, $hsmax, $cfound );
# checked for merged workspaces

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      my ($pr );
      $pr = $Awfif::memes-> {snnih} {$snconcept};
      print ("fsalsnl snconcept $pr from $foind to $toind ");
      };

    $rsnnode = 0;
    $notreached = "T";
    $rsi = 1;
    $found = '';

    $snconcl = halodlnc ($snconcept,-1, \@xcoord, \@ycoord, \@node, \@hsx, \@hsy, \$hsi, \$hsmax, \$cfound);
    while (($snconcl != 0)&&($notreached)) {
      if (($Awfif::slipnet ->{l} [$snconcl][4] == wsbasetype( $foind))
      && ($Awfif::slipnet ->{l} [$snconcl][3] == $rlink)
      && ($Awfif::slipnet ->{l} [$snconcl][2] == wsbasetype( $toind))
# the following should not be explicit but should use the indirect mechanism used elsewhere
      or ($Awfif::slipnet ->{l} [$snconcl][4] == wsbasetype($foind))
      && ($Awfif::slipnet ->{l} [$snconcl][4] == wsbasetype($toind))
      && ($Awfif::slipnet ->{l} [$snconcl][2] == $Awfif::memes-> {snnh}{identity})
        ) {
        $notreached = "";
        $rsnnode = $snconcl;
        }#got a link
      else {#still not found a match

        $snconcl = halodlnc($snconcept, $snconcl, \@xcoord, \@ycoord, \@node, \@hsx, \@hsy, \$hsi, \$hsmax, \$cfound);
        };#else
      }; #while snconcl not 0

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("fsalsnlx ret $rsnnode\n");
      };
    return $rsnnode;
    }# fsalsnl
#
sub snlinke {# find first match in slipnet between a pair of wsobjects
# link must operate from foind base to toind base
    my($pcind, $foind, $toind)=@_;
    my ($notreached, $found,
    $snconcl, $rsnnode, $rnode );
#
# checked for merged workspaces

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      my ($pr );
      $pr = $Awfif::memes-> {snnih} {$pcind};
      print ("snlinke pconcept $pr from $foind to $toind ");
      };

    $rnode = 0;
    $notreached = "T";
    $found = '';

    $snconcl = $Awfif::memes->{snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pcind];
    while (($snconcl != 0)&&($notreached)) {
      $rsnnode = $Awfif::memes->{snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[wsbasetype($foind)];

      while (($rsnnode != 0) && ($notreached)) {
        if (($Awfif::slipnet ->{l} [$rsnnode][3] == $Awfif::slipnet -> {l} [$snconcl][2])
        && ($Awfif::slipnet ->{l} [$snconcl][3] == $Awfif::memes-> {snnh}{cibp})
        && ($Awfif::slipnet ->{l} [$rsnnode][2] == wsbasetype($toind))

# the following should use the indirect mechanism used elsewhere
        or ($Awfif::slipnet ->{l} [$rsnnode][4] == wsbasetype($toind))
        && ($Awfif::slipnet ->{l} [$snconcl][2] == $Awfif::slipnet ->{l} [$rsnnode][3])
        && ($Awfif::slipnet ->{l} [$snconcl][3] == $Awfif::memes-> {snnh}{cibp})
        && ($Awfif::slipnet ->{l} [$rsnnode][2] == $Awfif::memes-> {snnh}{identity})

        or ($Awfif::slipnet ->{l} [$rsnnode][3] == $Awfif::slipnet -> {l} [$snconcl][2])
        && ($Awfif::slipnet ->{l} [$snconcl][3] == $Awfif::memes-> {snnh}{cibp})
# these must be changed to procedurally find group's lateral slipnet links
        && ($Awfif::slipnet ->{l} [$rsnnode][2] == $Awfif::memes-> {snnh}{succgroup})
        && (&groupable($toind,+1, $Awfif::memes->{snnh}{succgroup}))

        ) {

          $notreached = "";
          $rnode = $rsnnode;
          }#got a link
        $rsnnode = $Awfif::slipnet->{l}[$rsnnode][0];
        }# while

      $snconcl = $Awfif::slipnet->{l}[$snconcl][0];
      }; #while snconcl not 0

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("snlinkex ret $rnode\n");
      };
    return $rnode;
    }# snlinke
#
#
sub srelgrp {
# check for local relevence of a concept within a workspace object
# must include acceptance of too of identity
    my($tooid )=@_;
    my ($snnind, $found );
#
# checked for merged workspaces

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      my ($pr );
      $pr = $Awfif::memes-> {snnih} {$tooid};
      print ("srelgrp tooid $pr ");
      };
    $found = '';
# check if the too is one of the group items
    $snnind = $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl} [$Awfif::memes-> {snnh} {groupcategory}];
    while (($snnind != 0) && (!($found)) && ($Awfif::memes-> {snnh}{cibp} == $Awfif::slipnet-> {l} [$snnind][3])) {
      if ($tooid == $Awfif::slipnet-> {l} [$snnind][2]) {
        $found = 't';
        };
      $snnind = $Awfif::slipnet-> {l} [$snnind][0];
      };#look for match

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

    return $found
    }# srelgrp
#
sub srelconc {
# check for local relevence of a concept within a workspace object
# must include acceptance of too of identity
    my($snptarget, $linki, $part, $ni, $kwp, $kwpr, $rsna, $rsi )=@_;
    my ($i3, $snnind, $found );
#
# checked for merged workspaces

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      my ($pr );
      $pr = $Awfif::memes-> {snnih} {$snptarget};
      print ("srelconc snptarget $pr ni $ni linki $linki ");
      if ($ni != 0) {
        print ("\n");
        };
      };
    $found = '';
    if ($ni == 0) {
      if (
        ($snptarget == $Awfif::workspace-> {l} [$linki][2])
      or ($snptarget == $Awfif::workspace-> {l} [$linki][3])
      or
        ($snptarget == $Awfif::workspace-> {l} [$linki][4])
      or ($snptarget == $Awfif::memes->{snnh}{identity})
      or (srelgrp($snptarget))){

        for ($i3 = 2; $i3<=4; $i3++) {
          $snnind = $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl} [$Awfif::workspace-> {l} [$linki] [$i3]];
          while ($snnind != 0) {
            if ($Awfif::memes-> {snnh} {cibp} != $Awfif::slipnet-> {l} [$snnind] [3]) {

              $found = 't';
              $$part[$i3] = 't';
              $$rsna [$$rsi] = $snnind;
              $$rsi++;
              };#not backpointer

            $snnind = $Awfif::slipnet-> {l} [$snnind][0];
            };# while
          };#for each aspect of the descriptor
        }; # if
      } recursion
    else {#check ni and originally its predecessor and successor

      for ($i3 = 2; $i3<=4; $i3++) {
        $$part [$i3] = '';
        };
      if (srelconc ($snptarget, $linki, \@$part, 0, $kwp, $kwpr, \@$rsna, \$$rsi )) {

        $found = 't';
        };#if
      };

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

    return $found
    }# srelconc
#
#
sub getscjhls {
# associate a jhlsid with an attribute parameter set
#
    my ($rlist ) = @_;# first null attribute is taken as end
    my ($labcount, $i, $sigcount, @lomatchs, @lola, @loconcs, @lostrts, @loends, @logb, @loge,
    @jhlsid);
#
# checked for merged workspaces

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("getscjhls ");
      };
    $labcount = 0;
    $jhlsid [0] = 0;

    $sigcount = imscjhls (\@lomatchs, \@lola, \@loconcs, \@lostrts, \@loends, \@logb, \@loge, 'notoporstbinding', @_);
# apply the linking function of group completion
# if the groups labels result in a match with a signal then add the inhibitor
#

    if ($sigcount > 0) {
      for ($i = 0; $i < $sigcount; $i++) {
        if ($lomatchs[$i]) {#there is a link to the inhibitor
# unless this is an operon

          if (($Awfif::jhls-> {l} [$lola[$i]][4] != $Awfif::memes-> {snnh}{operon}) && ($Awfif::jhls-> {l} [$lola[$i]][4] != $Awfif::memes-> {snnh}{stbinding}) && ($Awfif::jhls-> {l} [$lola[$i]][4] != $Awfif::memes-> {snnh}{subpstbinding})) {

            $jhlsid [ ++ $jhlsid [0] ] = $lola[$i];
            };#if not operon
          };#if link
        };#for each potential signal
      };# if sigcount +ve

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("getscjhlsx ret ($jhlsid[0])\n");
      };
    return @jhlsid
    }# getscjhls
#
#<!-- start tag ds -resweb -->
#<!-- start tag sss -->
#
sub attlload {
# load lab with an attribute parameter set
#
    my ($lab ) = @_;# first null attribute is taken as end
    my ($labcount, $i);
#
# checked for merged workspaces

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("attlload ");
      };
    $labcount = 0;

    for ($i = 9; $i <= 27; $i++) {#assumes the tokens are in params 8 to 16
    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      my ($pr);
      $pr = $Awfif::memes-> {snnih}{$_[$i]};
      print ("attr$i $pr($_[$i]) ");
      };
      if (defined($_[$i])) {

        $labcount = labload (\@$lab, $labcount, $_[$i]);
        } # if specified
      else {
        $i = 30;# terminate the loop
        };# if not specified
      };#for
#

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("attlloadx ret ($labcount)\n");
      };
    return $labcount
    }# attlload
#
sub imscjhls {
# match a schematic parameter set jhlsid with an attribute parameter set
#
    my ($lomatchs, $lola, $loconcs, $lostrts, $loends, $logb, $loge, $strategy ) = @_;# first null attribute is taken as end
    my ($labcount, $sigcount);
    my (@lab);
#
# checked for merged workspaces

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

    $labcount = attlload (\@lab, @_);
    $sigcount = labinv2 (undef(), \@lab, $labcount, \@$lomatchs, \@$lola, \@$loconcs, \@$lostrts, \@$loends, \@$logb, \@$loge, $strategy);
#

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("imscjhlsx ret ($sigcount)\n");
      };
    return $sigcount
    }# imscjhls
#
#<!-- end tag sss -->
#<!-- end tag ds -->
#<!-- start tag ca -->
#
sub salsnlnc {# select a salient slipnet link for the slipnet concept
    my($snconcept, $myli, $ni, $tinstances, $nextinstance, $cid, $kwp, $kwpr, $strategy)=@_;
    my ($i, $i2, $i3, $i4, $ic, $linki, $found, $snptarget, $snconcl, $rsnnode, @part,
    @xcoord, @ycoord, @node, @hsx, @hsy, $hsi, $hsmax, $cfound, $loadcache, $change, $ub, $lb, @rsna, $rsi);
#
# updated for merged workspaces

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      my ($pr );
      $pr = $Awfif::memes-> {snnih} {$snconcept};
      print ("salsnlnc snconcept $pr strategy $strategy ");
      };
    $found = "";
    $$tinstances = 0;
    $ic = 0;
# dummy use of rsna to allow inversion of srelconc & ransalfor
    $rsi = 1;
    $loadcache = '';
# Look through the workspace to calculate the salience of items that include
# snconcept and its activated halo
#
# monitor the cache activation correlation

    &itscachecor ($snconcept, $strategy, 'seq', 'salsnlnc');
    if (checkcache ($strategy, $snconcept, 0, undef(), $Awfif::memes-> {snlcactd}) == $Awfif::memes-> {tscacheth}) {# report threshold reached

      &itscachecor ($snconcept, $strategy, 'threshold');
      };
    if (checkcache ($strategy, $snconcept, undef(), undef(), $Awfif::memes-> {snlclact}) != $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snna} {$Awfif::memes-> {snnih} {$snconcept}}) {# activation at last load

      &setcache ($strategy, $snconcept, 0, undef(), $Awfif::memes-> {snlcactd}, checkcache ($strategy, $snconcept, 0, undef(), $Awfif::memes-> {snlcactd}) + 1);
      &setcache ($strategy, $snconcept, undef(), undef(), $Awfif::memes-> {snlclact}, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snna} {$Awfif::memes-> {snnih} {$snconcept}});
      };# correlation monitoring

    if (checkcache ($strategy, $snconcept, undef(), undef(), $Awfif::memes-> {snlcvalid}) == 0) {

      $loadcache = 't';
      &setcache ($strategy, $snconcept, undef(), undef(), $Awfif::memes-> {snlcvalid}, 1);
# reloading cache role correlation counts into mean[7] and zero counter[6]
      &setcache ($strategy, $snconcept, 0, undef(), $Awfif::memes-> {snlcave},
        (checkcache ($strategy, $snconcept, 0, undef(), $Awfif::memes-> {snlcave}) +
        checkcache ($strategy, $snconcept, 0, undef(), $Awfif::memes-> {snlcactd})));
      &setcache ($strategy, $snconcept, 0, undef(), $Awfif::memes-> {snlcave},
        (checkcache ($strategy, $snconcept, 0, undef(), $Awfif::memes-> {snlcave}) /2 ));
      &setcache ($strategy, $snconcept, 0, undef(), $Awfif::memes-> {snlcactd}, 0);
      &itscachecor ($snconcept, $strategy);
# no changes found yet for this snconcl

      $snconcl = halodlnc ($snconcept,-1, \@xcoord, \@ycoord, \@node, \@hsx, \@hsy, \$hsi, \$hsmax, \$cfound);
      &setcache ($strategy, $snconcept, 0, undef(), $Awfif::memes-> {snlcsnconcl}, $snconcl);

      &rigsnconcl ($myli, $snconcept, $snconcl, $cid);
      }#if
    else {

      $snconcl = checkcache ($strategy, $snconcept, 0, undef(), $Awfif::memes-> {snlcsnconcl});
      };#else
# initialise that there has been no change
    &setcache ($strategy, $snconcept, $snconcl, undef(), $Awfif::memes-> {snlcpcv}, 0);
    &updatelog ($myli,'ssnl',1, $snconcl);
    while ($snconcl != 0) {
      if ( !igsnconcl ($myli, $snconcept, $snconcl, $cid, $ni)) {#don't do all this on a rejected item
      $snptarget = $Awfif::slipnet-> {l}[$snconcl] [2];
      if ($Awfif::slipnet-> {l} [$snconcl][3] != $Awfif::memes-> {snnh}{cibp}) {

        $i = $ni;
        if (!$loadcache) {# cache loaded

          $$tinstances = $$tinstances + checkcache ($strategy, $snconcept, $snconcl, awsoadr ($i), $Awfif::memes-> {snlctinst});
          }
        else {

          $change = 0;
          $i2 = 0;
          &calbounds ($i, 1,\$ub, \$lb, $kwp, $kwpr);

          $i4 = $lb;
          if (($lb != 0) && ($ub != 0)) {
            while (($i4 != 0) && ($ub > 0) ) {
              $linki = $Awfif::wsol-> {l} [ awsoadr($i4)][2]; #head
# all objects should have at least one descriptor - but ....
              if ($linki != 0) {# at least one descriptor
                while ($linki != 0) {
                  if ( srelconc ($snptarget, $linki, \@part, $i, $kwp, $kwpr, \@rsna, \$rsi )) {

                    for ($i3 = 2; $i3<=4; $i3++) {
                      if ($part[$i3]) {
                        my($change1);

                        $change = $change + $Awfif::memes-> {binds}-> {$strategy}->
                        ($myli, $i, $kwp, $kwpr, \$change1); #mean change
                        };#part contributes
                      };#for each aspect of the descriptor
                    }; # if some part of the descriptor implies contribution

                  $linki = $Awfif::workspace-> {l} [$linki] [0]; #walk back from head
                  }# while
                }; # if at least one
              $ub--;
              $i4 = trwsoadr ($i4,1);
              };# while
            };#for each in the area -> if

          $$tinstances = $$tinstances + $change;
          &setcache ($strategy, $snconcept, $snconcl, awsoadr ($i), $Awfif::memes-> {snlctinst}, $change);
          if ($change > 0) {

            &setcache ($strategy, $snconcept, $snconcl, undef(), $Awfif::memes-> {snlcpcv}, 1);
            };#change occured
          };#else no cache object
        };# if not back pointer

      if (checkcache ($strategy, $snconcept, $snconcl, undef(), $Awfif::memes-> {snlcpcv})) {

        $ic++;
        };

        };#ok to use this snconcl
      if ($loadcache) {# cache being loaded
        my ($osnconcl);
        $osnconcl = $snconcl;
        $snconcl = halodlnc ( $snconcept, $snconcl, \@xcoord, \@ycoord, \@node, \@hsx, \@hsy, \$hsi, \$hsmax, \$cfound );
        &setcache ($strategy, $snconcept, $osnconcl+1, undef(), $Awfif::memes-> {snlcsnconcl}, $snconcl);
        }#if
      else {
        $snconcl = checkcache ($strategy, $snconcept, $snconcl+1, undef(), $Awfif::memes-> {snlcsnconcl});
        };#else
# initialise that there has been no change
      &setcache ($strategy, $snconcept, $snconcl, undef(), $Awfif::memes-> {snlcpcv}, 0);
      };# while

    &updatelog ($myli,'ssnl',6, $snconcept);
    &updatelog ($myli,'ssnl',7, $loadcache);
    if ($loadcache) {# cache being loaded

      &setcache ($strategy, $snconcept, undef(), undef(), $Awfif::memes-> {snlcic}, $ic);
      }#if
    else {

      $ic = checkcache ($strategy, $snconcept, undef(), undef(), $Awfif::memes-> {snlcic});
      };# else complete the loading of the cache

    &updatelog ($myli,'ssnl',2, $ic);
    &updatelog ($myli,'ssnl',3, $$tinstances);
    if (($$tinstances > 0) && ($ic >= $Awfif::memes-> {minnorm})) {

      $$nextinstance = 1 + int (rand ($$tinstances)); # is between 1 and (totalwsobjects);
      &updatelog ($myli,'ssnl',8, $$nextinstance);
      $rsnnode = normsalsnl ($snconcept, $myli, $ni, $$nextinstance, $kwp, $kwpr, $strategy);
      &updatelog ($myli,'ssnl',4, $rsnnode);
      if ($rsnnode > 0) {

        $found = 't';
        $$nextinstance = $rsnnode;
        };#if
      }# were tinstances
    elsif ($$tinstances > 0) {

      $$nextinstance = ransalsnl ($snconcept, $myli, $ni, $$nextinstance, $kwp, $kwpr, $strategy);
      &updatelog ($myli,'ssnl',5, $$nextinstance);
      if ($$nextinstance != 0 ) {

        $found = 't';
        };#if
      };#elsif
#
    &uslehist ($$nextinstance); #update the slipnet element useage history

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("salsnlncx nextinstance $$nextinstance ret $found\n");
      };

    return $found
    }# salsnlnc
#
#<!-- end tag ca -->
#
sub newnlink {
    my ($type, $to, $from, $froml) = @_;
# type is an snnh number == node name
# to is an snnh number == node name
# from is 0 or an snel index of the from head
    my ($link, $hlink);

    if ((!defined ($type))
    or ($type == 0)
    or (!defined ($to))
    or ($to == 0) ){

      print ("bad slipnet node (type($type) to($to) from($from) froml($froml)) - moving to next file\n");
      &break ();
      &actnodes ($Awfif::memes-> {snnh} {terminate}, $Awfif::memes-> {actmax});
      };#if
    $link = newsnlink ($type, $to, $from, $froml,\$Awfif::slipnet);
# create a record for the history of each elements use
    $hlink = $Awfif::memes-> {snehih};
    $hlink = Awfif::newlink ($hlink, \$Awfif::slehist);
    $Awfif::slehist-> {l} [$hlink][2] = $link;
    $Awfif::slehist-> {l} [$hlink][3] = 0; #count of usage
    $Awfif::memes-> {snehih} = $hlink;
    $Awfif::slipnet-> {l} [$link][5] = $hlink;
    return $link;

    }#newnlink
#
sub newsnlink {
    my ($type, $to, $from, $froml, $arrayref) = @_;
# type is a "snnh" number == node name
# to is an "snnh" number == node name
# from is 0 or an snel index of the from head

    my ($link, $plink);
    if ($froml == 0) {#start new set of links
      $$arrayref-> {l}[$$arrayref-> {p}][3] = $type;
      $$arrayref-> {l}[$$arrayref-> {p}][4] = $from;
# setup the first list element
      $$arrayref-> {l}[$$arrayref-> {p}][0] = 0;#sentinal
      $$arrayref-> {l}[$$arrayref-> {p}][1] = 0;#sentinal
      $$arrayref-> {l}[$$arrayref-> {p}][2] = $to;
# note the head
      $link = $$arrayref-> {p};
      }

    else {#add a link to this set
      $$arrayref-> {l}[$froml][1] = $$arrayref-> {p};
      $$arrayref-> {l}[$$arrayref-> {p}][3] = $type;
      $$arrayref-> {l}[$$arrayref-> {p}][4] = $from;
# setup the first list element
      $$arrayref-> {l}[$$arrayref-> {p}][0] = $froml;#sentinal
      $$arrayref-> {l}[$$arrayref-> {p}][1] = 0;#sentinal
      $$arrayref-> {l}[$$arrayref-> {p}][2] = $to;
# note the head
      $link = $$arrayref-> {p};
      };

    if ($type == $Awfif::memes-> {snnh}{cinstance}) {# link this element in both directions
# first get the 'to' head
      $plink = $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$to];# if this is the first use of "to" this will not exist
# create a new element - use snep+1 item

# If the target has not been setup yet it will not have a node to link back
      if ($plink == 0) {#create a new node for the back pointers
        $$arrayref-> {l}[$$arrayref-> {p}+1][3] = $Awfif::memes-> {snnh}{cibp};
        $$arrayref-> {l}[$$arrayref-> {p}+1][4] = $to;
        $$arrayref-> {l}[$$arrayref-> {p}+1][0] = 0;
        $$arrayref-> {l}[$$arrayref-> {p}+1][1] = 0;
        $$arrayref-> {l}[$$arrayref-> {p}+1][2] = $from;
# setup the head
        $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$to] = $$arrayref-> {p}+1;
        }

      else {#a node exists at the $to so link the new return node to it
        # we have been given the to head
        $$arrayref-> {l}[$$arrayref-> {p}+1][3] = $Awfif::memes-> {snnh}{cibp};
        $$arrayref-> {l}[$$arrayref-> {p}+1][4] = $to;
        $$arrayref-> {l}[$$arrayref-> {p}+1][0] = $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$to];
        $$arrayref-> {l}[$$arrayref-> {p}+1][1] = 0;# ?? is this correct ??
        $$arrayref-> {l}[$$arrayref-> {p}+1][2] = $from;
# move the head to point to the new item
        $$arrayref-> {l}[$Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$to]][1] = $$arrayref-> {p}+1;
        $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$to] = $$arrayref-> {p}+1;
        };
# better increment snep an extra time

      $$arrayref-> {p}++;
      }; #ci
    $$arrayref-> {p}++;
    return $link;
    } # newsnlink
#
#
sub updateslipnet {
    my ($myli, $ws, $ipconc) = @_;
    my ($cwsbi, $pconc, $jhlsid, @jhlsa, $start);
# handle stop for sinkskeyword
#
# checked for merged workspaces

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

    $cwsbi = $Awfif::memes->{currentwsbi};
    $Awfif::memes->{currentwsbi} = $ws;
    if ( (defined ($ipconc)) && ($ipconc > 0)) {

      $pconc = $ipconc;
      }#if
    else {
# updateslasnnu1
# setup the memes snnh and snnih updates

      $start = $Awfif::memes-> {snnh} {iappkwid};
      $Awfif::memes-> {snnh} {rpkwmintevaluator} = (++$start);
      $Awfif::memes-> {snnih} {$start} = 'rpkwmintevaluator';
# and the ch

      @jhlsa = getscjhls ($Awfif::memes-> {snnh} {mergestreams}, $Awfif::memes-> {snnh} {schema}, $Awfif::memes-> {snnh} {source}, $Awfif::memes-> {snnh} {target}, $Awfif::memes-> {snnh} {merge}, $Awfif::memes-> {snnh} {initial});
      if ($jhlsa [0] != 1) {&break ()};
      $jhlsid = $jhlsa [1];
# now can proceed with setup of pconc
# setup the binding string for the multi path signal to control merge streams assert operation processing - assert codelets launch nuclabmcodelets which ignore the concept as long as it had an evaluator

      $Awfif::memes-> {maxoper}++;
      $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [1], 8, $Awfif::memes-> {currentwsbi});
      };#else
# next want to setup the operon


    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, ($jhlsid = Awfif::addjhlst ($Awfif::memes-> {snnh} {mpsignal}, $pconc, 2, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc)), $pconc,# ****
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {mergestreams}, $Awfif::memes-> {snnh} {schema}, $Awfif::memes-> {snnh} {source}, $Awfif::memes-> {snnh} {target}, $Awfif::memes-> {snnh} {match}, $Awfif::memes-> {snnh} {name}, $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, 'rpkwmintbuilder');
# mscirpkwmintebindtobis

    $Awfif::memes-> {maxoper}++;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {mergestreams}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {source}, $Awfif::memes-> {snnh} {target}, $Awfif::memes-> {snnh} {integrate}, $Awfif::memes-> {snnh} {match}, $Awfif::memes-> {snnh} {name}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {rpkwmintevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes->{currentwsbi} = $cwsbi;

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("updateslipnetx ret ($pconc)\n");
      };
    return $pconc
    }# updateslipnet
#

Functions


sub initchemistry {
    my ($kwp, $kwpr, $sactset, $csset, $strset, $restoring) = @_;
#<!-- end tag tfw -->
    my ($i);
#<!-- start tag aso --><!-- start tag vbt --><!-- start tag sir --><!-- start tag scs --><!-- start tag dli --><!-- start tag smo --><!-- start tag swp --><!-- start tag sm --><!-- start tag pc --><!-- start tag inp --><!-- start tag ssc --><!-- start tag sma --><!-- start tag scl --><!-- start tag inh --><!-- start tag sca --><!-- start tag scc --><!-- start tag al -->
    my ($pconc, $jhlsid);
#<!-- end tag al --><!-- end tag scc --><!-- end tag sca --><!-- end tag inh --><!-- end tag scl --><!-- end tag sma --><!-- end tag ssc --><!-- end tag inp --><!-- end tag pc --><!-- end tag sm --><!-- end tag swp --><!-- end tag smo --><!-- end tag dli --><!-- end tag scs --><!-- end tag sir --><!-- end tag vbt --><!-- end tag aso -->
    if ((!defined ($restoring)) or (!$restoring)){
# chemconsts
# dont set these up if using restored data structures in persistant startup
    $Awfif::memes-> {loopcheck} = 't';
    $Awfif::memes-> {loopth} = 10000;
    $Awfif::memes-> {waitforuserinput} = 't';
    $Awfif::memes-> {j} = ();
    $Awfif::memes-> {jhlabel} = (); #this will hash labels to indexes in the Hawkins label space
    $Awfif::memes-> {jhlp} = 1;
    $Awfif::memes-> {trace} = 0; #outputs when trace higher than control
    $Awfif::memes-> {ptrace} = 0; #delta for detecting trace setting changes
    $Awfif::memes-> {fatp} = 10000;# initial intermediate energy pool that can drive forward reactions
    $Awfif::memes-> {gatp} = 10000;# group completion reward
    $Awfif::memes-> {batp} = 100; # bond completion reward
    $Awfif::memes-> {datp} = 10; # description completion reward
    $Awfif::memes-> {bgtp} = 100; # dopa completion reward
    $Awfif::memes-> {ggtp} = 10000;# dopa group completion reward
    $Awfif::memes-> {failatpr} = 50000;# failure decrease in atp level
    $Awfif::memes-> {lderr} = 5; #+/- error range for ld change
    $Awfif::memes-> {ldlcyclemax} = 99;
# ldlearningmcmax
    $Awfif::memes-> {ldmcyclemax} = 1000;-> 10000 innerloop
    $Awfif::memes-> {ldlcycle} = $Awfif::memes-> {ldlcyclemax};
    $Awfif::memes-> {ldmcycle} = 0;
    $Awfif::memes-> {ldsignal} = 0; #signal from ld learning system 0 is no change
    $Awfif::memes-> {ldbuffer}
      [$Awfif::memes-> {ldlcyclemax}] = $Awfif::memes-> {fgtp};
    $Awfif::memes-> {ldoav} = $Awfif::memes-> {ldbuffer} [$Awfif::memes-> {ldlcyclemax}];
    for ($i = 0; $i < $Awfif::memes-> {ldlcyclemax}; $i++) {
      $Awfif::memes-> {ldbuffer} [$i] = $Awfif::memes-> {fgtp} -1 - $i;
      $Awfif::memes-> {ldoav} = $Awfif::memes-> {ldoav} + $Awfif::memes-> {ldbuffer} [$i];
      };# initialise ldbuffer
    $Awfif::memes-> {ldoav} = int($Awfif::memes-> {ldoav}/($Awfif::memes-> {ldlcyclemax}+1));
    $Awfif::memes-> {ldav} = $Awfif::memes-> {ldoav}-1;
    $Awfif::memes-> {maxldav} = 10000;
    $Awfif::memes-> {minldav} = -10000;
    $Awfif::memes-> {log} = 0; #generates log items when matches log entry
    $Awfif::memes-> {traceurg} = 8; #urgency control
    $Awfif::memes-> {traceentry} = 15; #entry & exit control
    $Awfif::memes-> {traceadentry} = $Awfif::memes->{traceentry} * 2;#address entry & exit control
    $Awfif::memes-> {traceimentry} = $Awfif::memes->{traceentry} + 1;#incmatch entry & exit control
    $Awfif::memes-> {logentry} = 1; #logging control
    $Awfif::memes-> {lsbase} = 8; #
    $Awfif::memes-> {lsnbase} = $Awfif::memes-> {lsbase} + 13; #salsnlc
    $Awfif::memes-> {lebase} = $Awfif::memes-> {lsnbase} + 9;
    $Awfif::memes-> {lbbase} = $Awfif::memes-> {lebase} + 17;
    $Awfif::memes-> {telomeretrace} = 0; #$Awfif::memes-> {traceentry} + 1; #telomere trace control
    $Awfif::memes-> {tracetemp} = 9; #temp trace control
    $Awfif::memes-> {tracephase} = 3; #phase and dist trace control
    $Awfif::memes-> {tracetree} = 250; #tree walk detail
    $Awfif::memes-> {tracescache} = 9; #slipnet salience cache meter
    $Awfif::memes-> {tracemcache} = 10; #slipnet matchtree cache meter
    $Awfif::memes-> {tracedpcache} = 11; #slipnet descproperty cache meter
    $Awfif::memes-> {tracewscache} = 12; #slipnet descproperty cache meter
    $Awfif::memes-> {tracevcentry} = 500; #vector cache tracing
    $Awfif::memes-> {traceclogentry} = 500; #clogstat tracing control
    $Awfif::memes-> {ratcoth} = 300; crowding out ratio threshold
    $Awfif::memes-> {abscoth} = 150; crowding out absolute threshold
    $Awfif::memes-> {worldsws} = (); #will be setup when world deployed
    $Awfif::memes-> {worldews} = (); #will be setup when world deployed
    $Awfif::memes-> {worldswso} = (); #will be setup when world deployed
    $Awfif::memes-> {worldewso} = (); #will be setup when world deployed
    $Awfif::memes-> {acsaobasscibreak} = ''; #if true acsaobuilder direct search for 'case selector is' will call break
    $Awfif::memes-> {valemainpbreak} = ''; #if true filtered main program ivalevaluator operation will call break
    $Awfif::memes-> {valesubpbreak} = ''; #if true filtered subprogram ivalevaluator operation will call break
    $Awfif::memes-> {valesubpspbreak} = (); #if defined and equal to sub number ival evaluator subprogram will call break on entry
    $Awfif::memes-> {valbmainpbreak} = ''; #if true filtered main program ivalbuilder operation will call break
    $Awfif::memes-> {valbsubpbreak} = ''; #if true filtered subprogram ivalbuilder operation will call break
    $Awfif::memes-> {valbsubpspbreak} = (); #if defined and equal to sub number ival evaluator & builder subprogram will call break on entry
    $Awfif::memes-> {valbsubpspcbreak} = (); #if defined and equal to sub number ival builder subprogram will call break on transaction completion
    $Awfif::memes-> {valbsubpnspwcbreak} = ''; #if true and is subprogram ival builder subprogram will call break on was->completingf1
    $Awfif::memes-> {valccompspibreak} = ''; #if true and removing completed subs and transaction is complete and spig not done ival builder will call break
    $Awfif::memes-> {valclearsubmbreak} = 't'; #if true and removing submitted and blocked ival builder will call break
    $Awfif::memes-> {valignifu} = 't'; #if true ival builder will signal cascade even when ifindupri says dont
# valbsubpnspc
    $Awfif::memes-> {valbsubpnspcbreak} = ''; #if defined and true ival builder subprogram will call break on transaction completion
    $Awfif::memes-> {valskngcbreak} = 't'; #if defined and true ival builder will call break on skipping notgcompleted
    $Awfif::memes-> {endlkwbesdbreak} = ''; #if defined and true endlistkw builder subprogram will call break on describing end of stream
    $Awfif::memes-> {endlkwhiu2break} = ''; #if defined and true endlistkw builder will call break on reset of hiurg
    $Awfif::memes-> {endlkwacompbreak} = ''; #if defined and true endlistkw builder will call break on signal - all subprograms complete
    $Awfif::memes-> {endlkwbstcompbreak} = ''; #if defined and true endlistkw builder will call break on setting stcomp true
    $Awfif::memes-> {endlkwbndsel} = 't'; #if defined and true endlistkw builder will call notgcompleted with nodelayselect = 't'
    $Awfif::memes-> {unbindhiu2break} = ''; #if defined and true unbind builder will call break on reset of hiurg
    $Awfif::memes-> {crsmesubpcbreak} = ''; #if icrsmox [subid] runs crsm builder operation will call break on completion
    $Awfif::memes-> {crsmesubpspbreak}[0] = 0; #
    $Awfif::memes-> {crsmbnsubpebreak} = ''; #if true main crsm builder operation will call break on entry
    $Awfif::memes-> {crsmbnsubpcbreak} = ''; #if true main crsm builder operation will call break on completion
    $Awfif::memes-> {crsmbnsubpspbreak} = ''; #if defined and equal to true crsm builder subprogram will call break on main program specified
    $Awfif::memes-> {crsmbsubpspbreak} = (); #if defined and equal to sub number crsm builder subprogram will call break on entry
    $Awfif::memes-> {crsmbsubpspcbreak} = (); #if defined and equal to sub number crsm builder subprogram will call break on transaction completion
    $Awfif::memes-> {crsmbsubpspspbreak} = (); #if defined and equal to sub number crsm builder subprogram will call break on subprogram specified
    $Awfif::memes-> {crsmbsubpspsigbreak} = (); #if defined and equal to sub number crsm builder subprogram will call break on signaling cascade
    $Awfif::memes-> {crsmbsubpnspsigbreak} = ''; #if true crsm builder subprogram will call break on signaling cascade
# crsmbsubpnspc
    $Awfif::memes-> {crsmbsubpnspcbreak} = ''; #if defined and true crsm builder subprogram will call break on transaction completion
    $Awfif::memes-> {crsmbsubpspabreak} = (); #if defined and true crsm builder subprogram will call break on attempting amplification
    $Awfif::memes-> {crsmbnsubpeosbreak} = ''; #if defined and true crsm builder main program will call break on list end found
    $Awfif::memes-> {crsmbcdabreak} = ''; #if defined and true crsm builder main program will call break on setting up itacaseoutput assist
    $Awfif::memes-> {icrsmbnsubpeosbreak} = ''; #if defined and true icrsmox builder main program will call break on eos
    $Awfif::memes-> {icrsmoxbsubpspabreak} = ''; #if defined and true icrsmox builder subprogram will call break on attempting amplification
    $Awfif::memes-> {icrsmoxsubpspbreak} = (); #if defined and equal to sub number icrsmox builder subprogram will call break on entry
    $Awfif::memes-> {icrsmoxsubpnspbreak} = ''; #if defined and true icrsmox builder subprogram will call break on entry
# icrsmoxsubpnspc
    $Awfif::memes-> {icrsmoxsubpnspcbreak} = ''; #if defined and true icrsmox builder subprogram will call break on transaction completion
    $Awfif::memes-> {icrsmoxsubpspcbreak} = (); #if defined and equal to sub number icrsmox builder subprogram will call break on transaction completion
    $Awfif::memes-> {bcsubpsesubpspbreak} = (); #if defined and equal to sub number ibcsubps evaluator subprogram will call break on entry
    $Awfif::memes-> {bcsubpsesubpnspbreak} = ''; #if defined and true ibcsubps evaluator subprogram will call break on entry
    $Awfif::memes-> {bcsubpsbsubpspbreak} = (); #if defined and equal to sub number bcsubps builder subprogram will call break on entry
    $Awfif::memes-> {bcsubpsbsubpnspbreak} = ''; #if defined and true bcsubps builder subprogram will call break on entry
    $Awfif::memes-> {bcsubpsbsubpspsigbreak} = (); #if defined and equal to sub number bcsubps builder subprogram will call break on signaling cascade
    $Awfif::memes-> {bcsubpsbsubpspclbreak} = (); #if defined and equal to sub number bcsubps builder subprogram will call break on ?
    $Awfif::memes-> {bcsubpsbsubpspcbreak} = (); #if defined and equal to sub number bcsubps builder subprogram will call break on transaction completion
# bcsubpsbsubpnspc
    $Awfif::memes-> {bcsubpsbsubpnspcbreak} = ''; #if defined and true bcsubps builder subprogram will call break on transaction completion
    $Awfif::memes-> {bcsubpsbsubpsptrbreak} = (); #if defined and equal to sub number bcsubps builder subprogram will call break on cascade transfer
    $Awfif::memes-> {crsmusesubptrachanged} = ''; #if defined and equal to true crsm evaluator will apply subtrachanged
    $Awfif::memes-> {crsmbgrabb} = ''; #if defined and true crsmbuilder will call break on setting grab
    $Awfif::memes-> {crsmbiwaitb} = ''; #if defined and true crsmbuilder will call break on ignoring wait
    $Awfif::memes-> {crsmbiwaitnsb} = 't'; #if defined and true crsmbuilder will call break on ignoring signal
    $Awfif::memes-> {crsmboxsubpnspbreak} = ''; #if defined and true crsmbox builder subprogram will call break on entry
    $Awfif::memes-> {crsmboxsubpspbreak} = (); #if defined and equal to sub number crsmbox builder subprogram will call break on entry
    $Awfif::memes-> {crsmboxnsubpeosbreak} = ''; #if defined and true crsmox builder main program will call break on eos
    $Awfif::memes-> {crsmoxsubpspcbreak} = (); #if defined and equal to sub number crsmox builder subprogram will call break on transaction completion
# crsmoxsubpnspc
    $Awfif::memes-> {crsmoxsubpnspcbreak} = ''; #if defined and true crsmox builder subprogram will call break on transaction completion
    $Awfif::memes-> {crsmoxbsubpspabreak} = ''; #if defined and true crsmox builder subprogram will call break on attempting amplification
    $Awfif::memes-> {bcsubpcbsubpnspbreak} = ''; #if defined and true bcsubpc builder subprogram will call break on entry
    $Awfif::memes-> {bcsubpcbsubpbspbreak} = (); #if defined and equal to sub number bcsubpc builder subprogram will call break on entry
# bcsubpcbnspc
    $Awfif::memes-> {bcsubpcbsubpnspcbreak} = ''; #if defined and true bcsubpc builder subprogram will call break on transaction completion
    $Awfif::memes-> {bcsubpcbsubpspcbreak} = (); #if defined and equal to sub number bcsubpc builder subprogram will call break on transaction completion
    $Awfif::memes-> {bcsubpcbsubpnspabreak} = ''; #if defined and true bcsubpc builder subprogram will call break on resuming amplification
    $Awfif::memes-> {bcsubpcbsubpspabreak} = (); #if defined and equal to sub number bcsubpc builder subprogram will call break on resuming amplification
    $Awfif::memes-> {bcsubpcbsubpnspwbreak} = ''; #if defined and true bcsubpc builder subprogram will call break on waiting on sub transaction completion
    $Awfif::memes-> {bcsubpcbsubpspwbreak} = (); #if defined and equal to sub number bcsubpc builder subprogram will call break on waiting on sub transaction completion
    $Awfif::memes-> {freecabreak} = ''; #if defined and true freecodelet will call break on allocating amplification
    $Awfif::memes-> {spigsubpidb} = (); #if defined and equal to subpid being cloned/launched spigrabamp will call break on initiating loop
    $Awfif::memes-> {spigrabb} = ''; #if defined and true spigrabamp will call break on allowing grab
    $Awfif::memes-> {spigncompnsb} = ''; #if defined and true spigrabamp will call break on finding no completion in full amplifier loop
    $Awfif::memes-> {spigcompnsb} = ''; #if defined and true spigrabamp will call break on detecting completion
    $Awfif::memes-> {spigcompsb} = (); #if defined and equal to subpid being cloned/launched spigrabamp will call break on detecting completion
    $Awfif::memes-> {spig15nexistb} = ''; #if defined and true spigrabamp will call break on c15 tral not existing
    $Awfif::memes-> {dcrdoslbsubpspbreak} = (); #if defined and equal to sub number dcrdoslist builder subprogram will call break on entry
    $Awfif::memes-> {dcrdoslbnsubpebreak} = ''; #if true main dcrdoslist builder operation will call break on entry
    $Awfif::memes-> {dcrdoslbnsubpwbreak} = ''; #if true main dcrdoslist builder operation will call break on starting to do work
    $Awfif::memes-> {dcrdoslbnsubplbreak} = ''; #if true main dcrdoslist builder operation will call break on signaling nucleus
    $Awfif::memes-> {dcrdoslbtrbreak} = ''; #if true dcrdoslist builder operation will call break on recording signaling transaction
    $Awfif::memes-> {dcrdoslbtrrbreak} = ''; #if true dcrdoslist builder operation will call break on removing signaling transaction
    $Awfif::memes-> {dcrdoslbcbreak} = ''; #if true dcrdoslist builder operation will call break on completing sponsors transaction
    $Awfif::memes-> {dcrdogwnafbreak} = (); #if defined and equal to oldframe index dcrdogowithin will call break on addframe
    $Awfif::memes-> {dcrdoeifsfbreak} = (); #if defined and equal to framelevel will call break on eif assignment to framel [11]
    $Awfif::memes-> {applycfbreak} = ''; #if defined and true applycodelet will call break on applyfailed
    $Awfif::memes-> {trackcactive} = 't'; #if defined and true trackcodelet will operate
    $Awfif::memes-> {trackcf1break} = 't'; #if defined and true and trackcactive == 't' trackcodelet will call break on free function with mode != 1
    $Awfif::memes-> {subtrancfoundbreak} = ''; #if defined and equal to true and subtrancomp is true will call break
    $Awfif::memes-> {telojhls} = ''; #if defined and true itteloutput will append jhls associated operon bindings to the operon list
    $Awfif::memes-> {checktsameas} = ''; #if defined and true assandmaptran will call break before relocates subpid transaction
    $Awfif::memes-> {checkprocsameas} = ''; #if defined and true igetcontext will call break as it associates subprogram string with transaction back references
    $Awfif::memes-> {checkcompsameas} = ''; #if defined and true transalloc will call break as it launches queued subprograms
    $Awfif::memes-> {checkcomptsameas} = ''; #if defined and true transalloc will call break as it completes dependent sub transactions
    $Awfif::memes-> {checkzsameas} = ''; #if defined and true addsamet will call break if Awfif::codelet [35] is zero
    $Awfif::memes-> {checksubpsameas} = (); #if defined and equal to sub number assandmaptran will call break and maptmgridtotransid will call break on finding transid match
    $Awfif::memes-> {checksubpnesameas} = (); #if defined and equal to sub number assandmaptran will call break and maptmgridtotransid will call break on finding transid match
    $Awfif::memes-> {checkfreehli} = ''; #if true freehli will scan free list and call break if item is in list
    $Awfif::memes-> {alignt35valbreak} = ''; #if true aligntmgrr will call break if transaction is 0 and has backreference transactions
    $Awfif::memes-> {icompdlbreak} = ''; #if true icompdbuilder will call break when issues signals
    $Awfif::memes-> {icompdcbreak} = ''; #if true icompdbuilder will call break if transaction is > 0 and sub-transaction has completed
    $Awfif::memes-> {grpbsp21break} = (); #if defined and a match for sponsor (21) groupbuilder will call break
    $Awfif::memes-> {gburgampbreak} = ''; #if defined and true groupbuilder will call break as it tries to adjust urgency with amplify descriptor data
    $Awfif::memes-> {doampdescbreak} = ''; #if defined and true ampdesc will call break if amplifier is > 1
    $Awfif::memes-> {doccodescs} = ''; #if true ccodescs will operate
    $Awfif::memes-> {pcof1descsd} = ''; #if defined and true pcof1descs will call break on subprogram entry
    $Awfif::memes-> {ccof1descsd} = ''; #if defined and true ccof1descs will call break on entry
    $Awfif::memes-> {ccof1descs35d} = ''; #if defined and true ccof1descs will call break on entry
    $Awfif::memes-> {ccodescsd} = (); #if defined and 0 ccodescs will call break on 36 == 0 entry if > 0 then when 36 > 0
    $Awfif::memes-> {itanald} = ''; #if defined and true itanalyco will call break on entry
    $Awfif::memes-> {cletcosd} = ''; #if defined and true cletcostate will call break on entry
    $Awfif::memes-> {chstoff1d} = (); #if defined and true chstoff1d will call break on entry
    $Awfif::memes-> {subpinitdb} = (); #if defined and true subpinitiated will call break on starting to search for subprogram-(initiate)->subpid
    $Awfif::memes-> {assansamebreak} = ''; #if defined and true assandmaptran will call break on finding transaction is same as current
    $Awfif::memes-> {iwaitarsb} = ''; #if defined and equal to $cdn iwaitarelaysb will call break on signal
    $Awfif::memes-> {nomcrsmgrab} = 't'; #if defined and true mcrsmgrab will not do any modeling or transform
    $Awfif::memes-> {binderchis} = ''; #if defined and true binderc will call break on shistone
    $Awfif::memes-> {findcotd} = (); #if defined and string 'for' it will break on <rhlcaseisspo> and $token == for etc
    $Awfif::memes-> {freecupoolb} = (); #if defined and equal to sub number freecodelet will call break on reseting {q}
    $Awfif::memes-> {nsdepschemabreak} = (); #if defined and equal to schematic sponsor wso nsdepbuilder will call break on notgcompleted
    $Awfif::memes-> {ssiasslncusetmass} = 't'; #if defined and true iasslnc will not operate if usetmass is assigned and subtran is not found
    $Awfif::memes-> {sinkskhsbreak} = ''; #if defined and true sinkskeyword will break if handlestop true
    $Awfif::memes-> {gacicharbreak} = ''; #if defined and true grab and applycodelet will break if st4 becomes char or ichar
    $Awfif::memes-> {partwholebreak} = 't'; #if defined and true partwhole will break if deploys terminate descriptor
    $Awfif::memes-> {gsigenamebreak} = ''; #if defined and true gsigename will break if more than one structure is returned from msublabel
    $Awfif::memes-> {matchtreebreak} = 't'; #if defined and true matchtree will break if reaches call threshold
    $Awfif::memes-> {mtsnlvlth} = 25; #matchtree call threshold
    $Awfif::memes-> {nuclabmbbreak} = 't'; #if defined and true nuclabmbuilder will break if reaches loop threshold
    $Awfif::memes-> {nuclabmblth} = 25; #nuclabmbuilder loop threshold
    $Awfif::memes-> {iwfccountdelbreak} = 't'; #if defined and true iwfccount will break if attempts to delete codelet
    $Awfif::memes-> {listrelinking} = ''; #list code is altering a list if 't'
# msubnocallu2
    $Awfif::memes-> {msublnocop} = 't'; #msublabel will use noc match restart optimization if 't'
    $Awfif::memes-> {gcnfcsuse} = ''; #if true groupbuilder will itcsuse on repeat ie group completes
# vbotphysvars
    $Awfif::memes-> {vbottstepsmax} = 200; -> 100 vbot test agent will operate for this number of steps
# vbottrialmax
    $Awfif::memes-> {vbottrialmax} = 50; -> 50 vbot test operation will be applied to this number of different can deployments for the present population
# vbottgenmax
    $Awfif::memes-> {vbottgenmax} = 30000; -> 1500 -> 2000 -> 2500 -> 3000 -> 4000 -> 6000 -> 10000 -> 15000 -> 20000 for initialization vbot test agent will operate for this number of generations
# vbottpopmax
    $Awfif::memes-> {vbottpopmax} = 100; -> 100 vbot test agent will operate for this number of schematic individuals - should always we even number
    $Awfif::memes-> {vbotpgdsc} = (); #vbot pop gen dsc will be setup when the descriptor is allocated for tracing
    $Awfif::memes-> {vbotwspdsc} = (); #vbot ws dsc will be setup when the descriptor is allocated for tracing
    $Awfif::memes-> {vbotatpdsc} = (); #vbot atp dsc will be setup when the descriptor is allocated for tracing
    $Awfif::memes-> {vbotfitnessdsc} = (); #vbot fitness dsc will be setup when the descriptor is allocated for tracing
    $Awfif::memes-> {canx} [0] = 0; #vbot setupcans will allocate this array for tracing
    $Awfif::memes-> {cany} [0] = 0; #vbot setupcans will allocate this array for tracing
    $Awfif::memes-> {vbotgacat} = ''; #vbot iop builder will setup grab/apply filial catalysis if 't'
    $Awfif::memes-> {usewaitonsquare} = 't'; #vbot model action codelets use descriptive state if 't'
    $Awfif::memes-> {usewaitonsbreak} = ''; #vbot model/action codelets break on use of descriptive state if 't'
    $Awfif::memes-> {usevbotga} = 't'; #vbot applies computed genetic algorithm if 't'
    $Awfif::memes-> {usevbotgabreak} = ''; #vbot computed genetic algorithm breaks if 't'
    $Awfif::memes-> {vbotltrapbreak} = 't'; #vbot loop trap will break if actions trap in vbot 1 if 't'
    $Awfif::memes-> {freewsongcspbreak} = 't'; #freewso will break on zero nuclear gcsponsor if 't'
    $Awfif::memes-> {notgcngcspbreak} = 't'; #notgcompleted will break on zero nuclear gcsponsor if 't'
    $Awfif::memes-> {roleincngcspbreak} = 't'; #roleincounters will break on zero nuclear gcsponsor if 't'
    $Awfif::memes-> {nomapnonsubtotm} = ''; #vbot GA will set true while using models
# vbotgadispcans
    $Awfif::memes-> {vbotgadispcans} = ''; #vbot GA will display cans on each vbot step if 't'
    $Awfif::memes-> {wfscdef} = (); #list of vbot model deferred codelets
    $Awfif::memes-> {selcptrbreak} = ''; #selcodelet will break when resets pseudo tail
    $Awfif::memes-> {vbttoamxmult} = 100; -> 100000000 vbttoamx builder urgency amplifier
# vbotmutateprb
    $Awfif::memes-> {vbotmutateprb} = 96; -> 96 -> 86 (4050) vbotmutate will apply a mutation with 99 - x probability to total pop of which top ten only are selected so mutation rate much lower
    $Awfif::memes-> {vbtcmaxamp} = 2; -> 2 expand codelet queues when focused vbot receptor
    $Awfif::memes-> {iteratejhlchbreak} = ''; #msublabel iteratejhlch will break on condition if 't'
    $Awfif::memes-> {itvfitbreak} = ''; #itvfitoutput will break on entry if 't'
    $Awfif::memes-> {itvfitlmax} = 20; size of list of top fitness elements
    $Awfif::memes-> {movevbotbreak} = ''; #movevbot will break on not allomove if 't'
    $Awfif::memes-> {waitfhashbreak} = ''; #waitforme and waitforsquare will break on bad hash match if 't'
    $Awfif::memes-> {iwfccountclbreak} = 't'; #iwfccount will break on cyclic link if 't'
    $Awfif::memes-> {vbotlstepbreak} = 't'; #vbotga will break on last step == step if 't'
# nocpdist
    $Awfif::memes-> {nocpdist} = 't'; #itcpdist will not process if 't'
    $Awfif::memes-> {wfcoptdep} = 't'; #if true nuclabmbuilder will attempt to optimize vbot mapped depolyment via wfc data
    $Awfif::memes-> {usegrpends} = 't'; #if true fgrpend will attempt to cache end descriptor gend
    $Awfif::memes-> {chmdefga} = ''; #if true chmdefis will attempt to cache pass and fail data
    $Awfif::memes-> {incmatchbreak} = ''; #incmatch will break on $i >= $rlablei if 't'
    $Awfif::memes-> {freectcantdbreak} = ''; #freecodelet will break if cant delete active tail codelet if 't'
# tracetime
    $Awfif::memes-> {tracetime} = 13; #report timeing counts
    $Awfif::memes-> {tracehrtime} = 23; #report highres timeing counts
    $Awfif::memes-> {tscacheth} = 30; #slipnet salience cache threshold
    $Awfif::memes-> {tmcacheth} = 30; #matchtree cache threshold
    $Awfif::memes-> {twscacheth} = 30; #workspace salience cache threshold
    $Awfif::memes-> {tellifeth} = 2; # 2 threshold for evaluation of removal of telomeric structure
    $Awfif::memes-> {telcountth} = 10; # 30 -> 15 -> 5 -> 30 -> 40 -> 20 threshold for destructionbuilder of removal of counted telomeric structure
    $Awfif::memes-> {inhuramp} = 500; # 2 -> 50 multiplier for inhibitor urgency
    $Awfif::memes-> {tracefull} = 200;
    $Awfif::memes-> {tmasstrace} = 't'; # list the tmass entries in salient codelet
    $Awfif::memes-> {usewcf1d} = 't'; #if true subprogram ivalbuilder operation will deploy completingf1 on f1 completion
# swmoddeparu1
    $Awfif::memes-> {usetdfmod} = ''; #if true transactional deployment failures will be monitored
    $Awfif::memes-> {tdfsampth} = 30; -> 25 -> 100 -> 75 -> 30 threshold for responding to transactional deployment failures
    $Awfif::memes-> {tdfsampds} = 15; -> 25 -> 15 amp of delayselect to limit competition with signalled codelets
    $Awfif::memes-> {tdfsampacc} = ''; #if false amp inhibition extends to applycodelet
    $Awfif::memes-> {mainco} = 0; #counter of crowding out of ONLY the main program
    $Awfif::memes-> {maininc} = 5; #increment of crowding out of ONLY the main program
    $Awfif::memes-> {freeampth} = 300; 50 freecodelet sub threshold for inhibiting amplification
    $Awfif::memes-> {maxusefree} = 4; iterations of spigrabamp prior to adding pressure of freecodelet
    $Awfif::memes-> {cruna}[0] = 0; #count of codelets that are running and protected from freecodelet
    $Awfif::memes-> {bcsubpsindex} = 0;
    $Awfif::memes-> {ivalwindex} = 1;
    $Awfif::memes-> {crsmindex} = 2;
    $Awfif::memes-> {totup} = 3; #should be equal to the total number of indexes
    $Awfif::memes-> {temp} [1] = 70;
    $Awfif::memes-> {structamp} = 3;
    $Awfif::memes-> {strbcont} = 50;
    $Awfif::memes-> {strnbcont} = 10;
    $Awfif::memes-> {bugsmax} = 500; #max bottom up group sqeeking increment
    $Awfif::memes-> {actamp} = 1.8; # at 1.01 activations go hugely positive(for clause,equals,exists,file,in, merge, name,object,replace, source,subject,target,verb), no bonds form, and loops in normwsitem;
# at 2 degrades temp to 0 with little structure. Activations drop to single digits
    $Awfif::memes-> {actth} = 59;
# vbtkillthu1
    $Awfif::memes-> {killth} = 1; -> 0
    $Awfif::memes-> {actweight} = 80000;
    $Awfif::memes-> {actramp} = 2;
    $Awfif::memes-> {actfocus} = 5;
    $Awfif::memes-> {actmax} = 200; #100
    $Awfif::memes-> {ampramp} = 2; -> 50 -> 200 -> 1000 -> 50 -> 10
    $Awfif::memes-> {waitamp} = 2; #10
    $Awfif::memes-> {activationchange}[2] = 1;
    $Awfif::memes-> {ndecay} = 1; the amount activation will decay each instance of actdecay
    $Awfif::memes-> {ntact} = $Awfif::memes-> {actth} - 20; #The activation provided on group no target
    $Awfif::memes-> {bondatype} = $Awfif::memes-> {actth} + 11;
    $Awfif::memes-> {bondato} = 20;
    $Awfif::memes-> {bondafrom} = $Awfif::memes-> {actth} + 21;
    $Awfif::memes-> {convfrom} = $Awfif::memes-> {actth} + 71;
# $Awfif::memes-> {termetype} = 1; #$Awfif::memes-> {actth} * 2;
    $Awfif::memes-> {openatype} = $Awfif::memes-> {actth} + 11;
    $Awfif::memes-> {openato} = 20;
    $Awfif::memes-> {openafrom} = $Awfif::memes-> {actth} + 21;
    $Awfif::memes-> {descatype} = $Awfif::memes-> {actth} + 1;
    $Awfif::memes-> {descato} = 20;
    $Awfif::memes-> {descafrom} = $Awfif::memes-> {actth} + 21;
    $Awfif::memes-> {relatype} = $Awfif::memes-> {actth} + 21;
    $Awfif::memes-> {relato} = 10;
    $Awfif::memes-> {relafrom} = 10;
    $Awfif::memes-> {groupatype} = $Awfif::memes-> {actth} + 11;
    $Awfif::memes-> {groupato} = 20;
    $Awfif::memes-> {groupafrom} = $Awfif::memes-> {actth} + 21;
    $Awfif::memes-> {actdamper} = 1000;
    $Awfif::memes-> {bondamp} = 1.02;#2
    $Awfif::memes-> {bondbar} = 2;2
    $Awfif::memes-> {bondrwd} = 20;#5
    $Awfif::memes-> {buscu} = 1; <- 4 1 scout priority
    $Awfif::memes-> {bumscu} = 2; -> 10 management scout priority
    $Awfif::memes-> {tdbsurg} = 8; -> 400 40 top down bond scout urgency
    $Awfif::memes-> {tddsurg} = 1.05; -> 20 -> 10 5 top down description scout urgency
    $Awfif::memes-> {tdgsurg} = 50; -> 1000 -> 200 -> 100 50 10 top down group scout urgency
    $Awfif::memes-> {tdgsramp} = 10; -> 20 -> 500 -> 100 50
    $Awfif::memes-> {geramp} = 10; -> 10 -> 20 50
    $Awfif::memes-> {gerhiamp} = 1000; -> 10 -> 20 50
    $Awfif::memes-> {budescu} = 50; bottom up description evaluator urgency
    $Awfif::memes-> {budestscu} = 20; bottom up destruction scout urgency
    $Awfif::memes-> {acteu} = 50; action evaluator urgency
    $Awfif::memes-> {pappbu} = 200; # 40000 pseudo app builder urgency
# $Awfif::memes-> {backoffactive} = 0; # if backoff linked to active descriptor will be set to 3
# $Awfif::memes-> {backoffactives} = 0; # counter and semaphore on 0 to 1 transition
    $Awfif::memes-> {parteu} = 100; -> 1000 500 part evaluator urgency
    $Awfif::memes-> {evlaunchm} = 1.02; 1.02 multiplier for evaluator launching
# swmoddeparu2
    $Awfif::memes-> {evlaunchhim} = 1000; multiplier for hipri evaluator launching
    $Awfif::memes-> {blaunchm} = 1.02; => 2 multiplier for builder launching
    $Awfif::memes-> {ilaunchm} = 10; # 50 multiplier for builder launching
    $Awfif::memes-> {icompdlaunchm} = 1; #multiplier for icomp signal
    $Awfif::memes-> {coordmax} = 30;
    $Awfif::memes-> {coordamp} = 100;
    $Awfif::memes-> {critical} = 2; #3-5->20
    $Awfif::memes-> {depthamp} = 2;
    $Awfif::memes-> {depthslp} = 1; # at 5
    $Awfif::memes-> {depththamp} = 10; # used as a threshold for urgency in sliping
    $Awfif::memes-> {desbar} = -1;
    $Awfif::memes-> {desrwd} = 20;
    $Awfif::memes-> {subgrouponly} = 't'; #crsubmitcodelets to focus on group and higher
    $Awfif::memes-> {halomax} = 3; #3
    $Awfif::memes-> {minnorm} = 5; #20
    $Awfif::memes-> {relbar} = 10; #200
    $Awfif::memes-> {relrwd} = 20;
    $Awfif::memes-> {relamp} = 10;
    $Awfif::memes-> {rtemp} = 50;
    $Awfif::memes-> {destthreshold} = 99;
    $Awfif::memes-> {manthreshold} = 1;
    $Awfif::memes-> {bondthreshold} = 65;
    $Awfif::memes-> {descthreshold} = 60;
# $Awfif::memes-> {statementbtemp} = 50;
    $Awfif::memes-> {pstment} = 't'; #output details of statement
    $Awfif::memes-> {pactive} = 't'; #output count of active codelets
    $Awfif::memes-> {psubprogram} = 't'; #output summary info about subprograms
    $Awfif::memes-> {ptelcount} = 't'; #if true itcpdist will output details of telomere count
    $Awfif::memes-> {pwscount} = ''; #if true itcpdist will output details of codelet count per workspace
    $Awfif::memes-> {acodelets} = 0; #count of active codelets
    $Awfif::memes-> {tcodelets} = 0;
    $Awfif::memes-> {tcodeletmax} = 200; -> 200 -> 100 -> 50 -> 200 -> 800 -> 100 should be increased when add new codelet types
    $Awfif::memes-> {mincodelets} = 20; #
    $Awfif::memes-> {breakcodelet}[0] = 0;
    $Awfif::memes-> {breaksubp}[0] = 0;
    $Awfif::memes-> {breakthwso} [0] = 0;
    $Awfif::memes-> {breakthsubp} [0] = 0;
    $Awfif::memes-> {breaksalwso}[0] = 0;
    $Awfif::memes-> {breakmyli} = 0;
    $Awfif::memes-> {bmbcindex} = 0;
    $Awfif::memes-> {fcodelets} = 0;
    $Awfif::memes-> {fatigue} = 2; # 2 cycles of coderack when activation can't pass to this node
    $Awfif::memes-> {slipth} = 40; # temperature above which slips can occur
    $Awfif::memes-> {uhmax} = 800; # 100 this really is the entropic contribution to the temperature
    $Awfif::memes-> {uhth} = 200; # 50 A threshold used to decide if to try shouting
    $Awfif::memes-> {shout} = ''; # state of squeaker shouting
    $Awfif::memes-> {cpmax} = 38; # this is the upper bound of the codelet parameters
    $Awfif::memes-> {crwait} = 4000; # 4000
    $Awfif::memes-> {drwait} = 0;
    $Awfif::memes-> {crfocuswin} = 40; # 40 window for cr to focus onto
    $Awfif::memes-> {iphase} = 0; # in initial phase of coderack processing
    $Awfif::memes-> {iphasecomp} = 1; # 4
    $Awfif::memes-> {peaksal} = 2; # how many times a peak must be larger than mean salience value
    $Awfif::memes-> {mrework} = 50; # how many times a scout can rework its investigation
    $Awfif::memes-> {maxoper} = 0; # how many operational routines exist
    $Awfif::memes-> {maxact} = 1; # how many action routines exist
    $Awfif::memes-> {grcompaward} = 8000; # 6000 -> 8000 salience thresholding award for group being complete
    $Awfif::memes-> {salthr} = 1000; # salience threshold
    $Awfif::memes-> {mmratio} = 2; # management meeting ratio reduction
    $Awfif::memes-> {dmratio} = 100; # 20 destruction ratio reduction
# $Awfif::memes-> {verb} = 0;
    $Awfif::memes-> {verbsrcws} = 0;
    $Awfif::memes-> {verbtaws} = 0;
    $Awfif::memes-> {clogbplist} = 'Awfif::groupbuilder1'; #conditional logging begin codelet list
    $Awfif::memes-> {clogeplist} = 'Awfif::groupbuilder1x'; #end list add x
    $Awfif::memes-> {clogs} = ''; #conditional logging boolean
    $Awfif::memes-> {leavein} [0] = 1; #count of keyword in leavein array
    $Awfif::memes-> {leavein} [1] = 'mpchrhl'; #keywords which have ptleaveint token
    $Awfif::memes-> {comprocessing} = 0; #comment processing boolean
    $Awfif::memes-> {cbprocessing} = 0; #char buffer processing boolean
    $Awfif::memes-> {csprocessing} = 0; #catch string processing boolean
    $Awfif::memes-> {maxnormitems} = 20; -> 5 -> 3 -> 10 -> 20 the maximum number of tinstance cut values per workspace
    $Awfif::memes-> {cpcountth} = 5; the threshold for multiple cycles through tgroupscout1
    $Awfif::memes-> {maxtdgloop} = ($Awfif::memes-> {maxnormitems} - $Awfif::memes-> {cpcountth}); #max number of cycles through tgroupscout1
    $Awfif::memes-> {itswsallc} = 16; #the number of list elements reported from $Awfif::itswsall by &itswsal
    $Awfif::memes-> {wsoname} = 1; #name associated with a deployed wso
# $Awfif::memes-> {ngcompth} = 5; #threshold for notgcompleted codelets
    $Awfif::memes-> {buildfbth} = 100000; #threshold for builder to inhibit
    $Awfif::memes-> {delayselcount} = 20; -> 30 -> 20 wait before selcodelet moves to active codelet list
    $Awfif::memes-> {delayamp} = 2; -> 100 -> 10 -> 2 amplifies the delay once codelet in selectcodelet waitqueue
    $Awfif::memes-> {tgnth} = 1000; #threshold for salient item to be present
    $Awfif::memes-> {doprsib} = 't'; #use promotesib
    $Awfif::memes-> {chckadd} = ''; #check addwsoli entry / exit if true
    $Awfif::memes-> {checktransidnz} = 't'; #check transid is non zero or call debug
    $Awfif::memes-> {checksubpidnz} = ''; #check transid is non zero or call debug
    $Awfif::memes-> {tral} = 1; #should be unique number for each allocated transaction
    $Awfif::memes-> {applycmin} = 2; 5 catalysis won't work between 30 and 0
    $Awfif::memes-> {iapplycth} = 5; 10 100 30 applycth marks the switch from
    $Awfif::memes-> {applycth} = $Awfif::memes-> {iapplycth}; 10 100 applycth marks the switch from
    $Awfif::memes-> {iapplyramp} = 1000; 80 500
    $Awfif::memes-> {applyramp} = $Awfif::memes-> {iapplyramp};
    $Awfif::memes-> {applycount} = $Awfif::memes-> {applycth} + $Awfif::memes-> {applyramp};
    $Awfif::memes-> {applyactive} = ''; #histerisis for applycodelet
    $Awfif::memes-> {applyspigdiv} = 10; #spigrabamp iapplyramp divider
    $Awfif::memes-> {newdep} = 0; #nsdepbuilder will set true if new telomeric structures are deployed
    $Awfif::memes-> {bnotsalient} = 0; #builder not salient
    $Awfif::memes-> {bsalient} = 100; #builder salient
    $Awfif::memes-> {submult} = 100; multiplier for sub program groupcomplete promotion
    $Awfif::memes-> {submitted} = undef(); #most recently submitted codelet
    $Awfif::memes-> {casetrmcws} = 0; #crsm and other case modeling managers should set this to assist the case display application utility
    $Awfif::memes-> {casetrmbcwso} = 0;
    $Awfif::memes-> {subptrachcount} = 20; how many times to allow false return
    $Awfif::memes-> {acaseoutputps} = 20; #itacaseoutput page size in lines
    $Awfif::memes-> {subprefctr} = 2; ivalwbuilder subpref check counter;
    $Awfif::memes-> {allowspigrabmax} = 5; # 30 300 50 300 80 10 80 30 iterations of main coderack loop prior to restarting spigrabamp
    $Awfif::memes-> {veccah} = 0; #vec col awso head array allocator
    $Awfif::memes-> {veccab} = 50; #vec col awso head list bucket size
    $Awfif::memes-> {fjhls8} = (); #jhls check 8 control variable
    };#if not restoring
# constants can be setup at each initialisation
    $Awfif::memes-> {stbbpersist} = 't'; #stbind builder persist
# timesensing
# time tracing constants
    $Awfif::memes-> {coderacktime} = 0;
    $Awfif::memes-> {codelettime} = 1;
    $Awfif::memes-> {spctime} = 2;# specific codelet
    $Awfif::memes-> {sttime} = 3;# strengths
    $Awfif::memes-> {sltime} = 4;# salience
    $Awfif::memes-> {hatime} = 5;# happiness
    $Awfif::memes-> {tetime} = 6;# temp
    $Awfif::memes-> {seltime} = 7;# selectcodelet
    $Awfif::memes-> {fotime} = 8;# focus
    $Awfif::memes-> {ldtime} = 8;# learning
    $Awfif::memes-> {frtime} = 9;# free
    $Awfif::memes-> {satime} = 10;# supactivatn
    $Awfif::memes-> {ststime} = 11;# strength
    $Awfif::memes-> {stsmttime} = 12;# strength (match tree part)
    $Awfif::memes-> {stsdtime} = 13;# strength (depth part)
    $Awfif::memes-> {stftime} = 14;# fit
    $Awfif::memes-> {saltime} = 15;# supactivatn (launch part)
    $Awfif::memes-> {saddtime} = 16;# supactivatn (decay part)
    $Awfif::memes-> {sadctime} = 17;# supactivatn (cache init part)
    $Awfif::memes-> {tgrwtime} = 18;# tgroup scout (rework part)
    $Awfif::memes-> {starttime} = 0;
    $Awfif::memes-> {endtime} = 1;
    $Awfif::memes-> {sumtime} = 2;
    $Awfif::memes-> {sswicsum} = 3;# salwsitem cache item
    $Awfif::memes-> {sswinsum} = 4;# salwsitem normalized item
    $Awfif::memes-> {sswiisum} = 5;# salwsitem iterated item
    $Awfif::memes-> {sswist} = 6;# salwsitem start time
    $Awfif::memes-> {sswiet} = 7;# salwsitem end time
    $Awfif::memes-> {stbbsum} = 8;# statement builder b
    $Awfif::memes-> {stbcsum} = 9;# statement builder c
    $Awfif::memes-> {stbpdcasum} = 10;# statement builder pdca
    $Awfif::memes-> {boposum} = 11;# bindoptoinsp1 operonmatch
    $Awfif::memes-> {boplsum} = 12;# bindoptoinsp1 launch
    $Awfif::memes-> {tgsbsum} = 13;# tgroupscout b
    $Awfif::memes-> {tgscsum} = 14;# tgroupscout c
    $Awfif::memes-> {tgsrsum} = 15;# tgroupscout recovery
    $Awfif::memes-> {convbsum} = 16;# convbws entry to exit
    $Awfif::memes-> {convwsum} = 17;# convbws whitespace
    $Awfif::memes-> {convcsum} = 18;# convbws cache
    $Awfif::memes-> {convcbsum} = 19;# convbws c buffer
    $Awfif::memes-> {convfsum} = 20;# convbws flip
    $Awfif::memes-> {convosum} = 21;# convbws other
    $Awfif::memes-> {convoasum} = 22;# convbws other actnodes
    $Awfif::memes-> {newwsum} = 23;# newwso total
    $Awfif::memes-> {newwasum} = 24;# newwso addwsoli
    $Awfif::memes-> {newwsdsum} = 25;# newwso setupdesc
    $Awfif::memes-> {newwmdsum} = 26;# newwso wsmd
    $Awfif::memes-> {keywmsum} = 27;# keywmatch total
    $Awfif::memes-> {deploytsum} = 28;# deploymd total
    $Awfif::memes-> {msubltsum} = 29;# msublabel total
    $Awfif::memes-> {gbiesum} = 30;# groupbuilder ie
    $Awfif::memes-> {gbosum} = 31;# groupbuilder other
    $Awfif::memes-> {gbiec} = 0;# groupbuilder ie entry counter
    $Awfif::memes-> {gboc} = 0;# groupbuilder other entry counter
# swsiclfwso
# $Awfif::memes-> {swsiclfwso} = 2;# 11 -> 2 selsalwsitem cache loaded for wso
# swsiclfi
# $Awfif::memes-> {swsiclfi} = 3;# 10 -> 3 selsalwsitem cache loaded for $i
    $Awfif::memes-> {psortinc} = 10000;#psort inc is used to maintain a gap to the dec point
#<!-- start tag ctr -->
# ctsregtst
    $Awfif::memes-> {ctsregtst} = '';# if true bottom up regression testing codelets will be generated
# ctsinittran1
    $Awfif::memes-> {ctsinittran1} = 't';# if true regression transaction initiation test branch 1 enabled
#<!-- end tag ctr -->
# initialise random seed for coderack
    srand;
#

#<!-- ntart tag sl -->
#
# sactsetlist
    @$sactset = qw (
    zero naught one two three four five six seven eight nine and assert case char deploy dname each endlistkw endrcdkw equals file
    for groupcomplete groupvalid implement in iname initial is ivariable jhlabel
    list mcgroupvalid merge mkwordref model mreplaces name namest object partscategory
    partconstrained process rhlemsge rhlemsgs resource resolved replaces replace
    record salience schema selector seltst skipwso startlistkw startrcdkw
    statementcomplete statementwhole subject threshold target type typedinstance
    verb stream streams source mkeywords mkeyworde development develop lists unbind
    mergestreams hdo execute initialise pdca transcription factor inhibitor investigation
    supervise initiate terminate program do check act change ivalw semantics cbody if
    elsif match melse completed waitarelay compare else histone true sloc aggregate signal
    integrate vbt genetic algorithm vbot square cans pickup wall north south east west random
    scl scell membrane buffer external internal liposome pcell cycle evolution replication
    test transaction
    subprogram cc1 cc2 cc3 cc4 cc5 cc6 sub5program sub6program

    start stop begin end value svalue mstart bslash colon qmark fix cat single persist
    phys small polar instance body exc any alternate
    either or page title version
    activator on off hkey proc growthp banner
    clause identity bondfacet adjacent predecessor
    successor openfacet position contents bondcategory opencategory testcategory tokencategory groupcategory objectcategory
    exists iexists adjgroup predgroup succgroup cinstance cibp opposite associative lateral
    ingroup cfile crecord cdata namescategory equivalent contains property
    namedcategory relfacet descfacet within slip attribute chardcategory groupdcategory posdcategory equatedcategory
    filedcategory recorddcategory streamdcategory listdcategory groupstart wasgroupstart groupend wasgroupend actioncategory
    spsignal mpsignal signalcategory loadbuffer attrib lhead attribc attribt attribi attribs
    attribe attribr groupd groupu evaluator lbevaluator mkeyword whitespace ichar loadibuffer
    libevaluator mattrib growthevaluator memccategory msuccbond msuccrel msuccgroup msgsponsor msuccgstart msuccgend mtmbindstart mtmbindend
    msuccgedges msuccgedgee rhlmspgs rhlmspge rhlmspgegs rhlmspgege escape1 escape2 memgst
    memgsp telomere teld telr ltail matchkword opercategory operon assemblylist
    declaration dcnevaluator error waserror drevaluator drecord modelcategory
    group complete telomerest telomeresp telomericst telomericsp wind
    unwind mkwevaluator msalthrevaluator nuclabmevaluator dropthreshold mgpartevaluator dropopcheck whole
    mresddrevaluator mresadrevaluator valid invalid divariable civariable tsubsequent
    sprevious workspacebi partnerwsi href hname includest mmerge dropmresddr
    goodresddr lbinhibitor statementcategory partstatement constrained mcspevaluator mmcrevaluator
    mcvariable dropmresmc comments commente mcomment mcomcategory mcscategory mactsverbevaluator goodsverb
    dropsverb mcvpevaluator mcopevaluator statement requires operation invalidatescategory failscategory
    mwstaevaluator reqmissing bondedcategory groupedcategory conditional inspector mkwinspector trap
    plan pdcacomplete errorcategory externalrescategory assume referenced specified dassgevaluator dassginspector
    assumessp mmctevaluator mmcvevaluator multiple andcategory orcategory pmmanager pmmaninspector sregex cregex
    msormevaluator miterevaluator iterator goodmverb dropmverb outgroup mviintevaluator iforall all first last miforallevaluator
    miforallinspector goodtarget badtarget goodscope misevaluator missp istream misinspector dascgevaluator
    assumecsp iassselector icselector dascginspector casesaevaluator casesainspector goodcverb dropcverb mactcverbevaluator
    mcssubevaluator mcsobevaluator dropcresddr rhlmpchs rhlmpche sethead
    devevaluator devinhibitor indirectroot devcategory devinspector devcsp indirectcategory ruleless
    mwstdevaluator devwhole fastroute mcasehstart mcasehend wait stbinding sequence integration deviwhole devbuilder schbindevaluator stbindevaluator indslocevaluator
    bind wsposition slocevaluator truthassertion devpwhole appkwid rhlbmspgegs slistkwevaluator
    cancontain listhead listlink recordhead mcharbuffer mcbcategory namestevaluator
    skipwsoevaluator eos waseos stname srcdkwevaluator casbound casinit casinopp casinsopp
    jhlsoi destroyok cascompsopp recordlink seltstevaluator selvalue ivalue endrcdkwevaluator
    endlistkwevaluator dcrdoslistevaluator dcrdononrecevaluator dcrdoncasedescevaluator dcrdocasedescevaluator dcrdogowithinevaluator dcrdosrecordevaluator
    cascompopp listend indequiv mindequiv pindequiv amplify wasamplify cassponsor wascassponsor getcassponsor casrelay wascasrelay notcasrelay
    cexcluded block casecategory notgcompleted wasnotgcompleted backoff wasbackoff lpnotgcomplete waslpnotgcomplete dropsalience
    wasdropsalience descriptorlink usep2 usep3 usep4 usep5 unbindevaluator casunbind msiopevaluator msiopinhibitor
    initiation operate msiopbuilder msaoevaluator msacres mstracasetestp mstraresctestp mstranoctestp delayselect wasdelayselect
    initpdcaevaluator initpdcascevaluator dcyclin ecyclin acyclin bcyclin invsupevaluator catalysis wascatalysis catref invmodevaluator atp wasatp deltaatp costatp
    dcycipevaluator dcyctpevaluator spdcaevaluator spdcascevaluator pdcaprogram waspdcaprogram ecycdopevaluator acycchpevaluator bcycacpevaluator e2ftfevaluator
    cassertevaluator desrasstevaluator dcrdowarsevaluator lbstreamevaluator lbstreamcompevaluator uwarsevaluator
    inhibition wasinhibition tfactor wastfactor prbevaluator supervisor wassupervisor count ivalwevaluator ivalwbuilder itargevaluator acsaoevaluator
    transid wastransid incomplete deleted accepted casparticipant cbodyevaluator crsmevaluator crsmbuilder casemodel casedeploys icompdevaluator
    msadobevaluator msadobbuilder dcrdoinitevaluator
    crsmoxevaluator crsmoxbuilder crsmofevaluator crsmofbuilder crsmoievaluator crsmoibuilder crsmoeievaluator crsmoeibuilder crsmoeevaluator crsmoebuilder crsmomevaluator crsmombuilder
    crsmomeevaluator crsmomebuilder subpstbinding gowithin bcsubpcevaluator bcsubpcbuilder bcsubpsevaluator bcsubpsbuilder subpdeployed wassubpdeployed
    subpref update stran rtran assoctran assocdesc assoccspon disassoccspon assoccrel disassoccrel codeletslice add next assocf1 assocsub remove grab wasgrab nuclear
    running terminated cwaitondesc wascwaitondesc completingf1 wascompletingf1 initgw found
    deferred active free csresevaluator csresbuilder wsframe waswsframe schemastring crowdingout wascrowdingout crsmbuilderf1 shslocevaluator shwsposition
    shappkwid rchpairevaluator stays ripkwmevaluator rchpintevaluator first image defer oktomove wasoktomove waitonsquare waswaitonsquare waitonme waswaitonme
    stay empty canposition can wascan canattrib vbotsteps wasvbotsteps fitness vbttoamn vbttoams vbttoame vbttoamw vbttoamr vbttoapc
    rttrans01evaluator rttrans01builder rttrans01revaluator rttrans01rbuilder
    devpcellevaluator devpcellbuilder devscellevaluator devscwldevaluator relative absolute
    vbtiopevaluator vbtiopbuilder vbtiopinhibitor vbtdevevaluator vbtdevinhibitor vbtdevinspector mdvevaluator mdvinspector
    mdvsp vbtmressevaluator vbtmresoevaluator vbtmsormevaluator vbtmactsverbevaluator vbtmcspevaluator vbtmcopevaluator vbtmcvpevaluator vbtdevbuilder devbtwldevaluator devbtcnsevaluator devsccnsevaluator vbttmevaluator vbttmbuilder vbttmorevbevaluator ivbttmorevbevaluator vbttmorevbbuilder vbttmoretsevaluator ivbttmoretsevaluator vbttmoretsbuilder vbttmoregsevaluator ivbttmoregsevaluator vbttmoregsbuilder vbttoamsevaluator ivbttoamsevaluator ivbttoamnevaluator ivbttoameevaluator ivbttoamwevaluator ivbttoamrevaluator ivbttoapcevaluator
    vbttom00c10c01evaluator ivbttom00c10c01evaluator vbttom00c10c00evaluator ivbttom00c10c00evaluator vbttom00c10c01c00evaluator ivbttom00c10c01c00evaluator
    vbttom00ncevaluator ivbttom00ncevaluator vbttom0recevaluator ivbttom0recevaluator vbttom00c00c01evaluator ivbttom00c00c01evaluator
    vbttom00c00evaluator ivbttom00c00evaluator vbttom00c01evaluator ivbttom00c01evaluator vbttom00c10evaluator ivbttom00c10evaluator
    vbttom01ncevaluator ivbttom01ncevaluator vbttom01c00evaluator ivbttom01c00evaluator vbttom01c00c01evaluator ivbttom01c00c01evaluator vbttom01c00c01c11evaluator ivbttom01c00c01c11evaluator vbttom01c00c11evaluator ivbttom01c00c11evaluator vbttom01c01evaluator ivbttom01c01evaluator vbttom01c11evaluator ivbttom01c11evaluator vbttom01c01c11evaluator ivbttom01c01c11evaluator vbttom01c00c01c02evaluator ivbttom01c00c01c02evaluator vbttom01c00c11c02evaluator ivbttom01c00c11c02evaluator vbttom01c01c11c02evaluator ivbttom01c01c11c02evaluator vbttom01c00c01c11c02evaluator ivbttom01c00c01c11c02evaluator vbttom01c02evaluator ivbttom01c02evaluator vbttom01c00c02evaluator ivbttom01c00c02evaluator vbttom01c01c02evaluator ivbttom01c01c02evaluator vbttom01c11c02evaluator ivbttom01c11c02evaluator
    vbttoamnevaluator vbttoameevaluator vbttoamwevaluator vbttoamrevaluator vbttoapcevaluator
    vbttom09c19c08evaluator ivbttom09c19c08evaluator vbttom09c19c09evaluator ivbttom09c19c09evaluator vbttom09c19c08c09evaluator ivbttom09c19c08c09evaluator
    vbttom09ncevaluator ivbttom09ncevaluator vbttom09c09c08evaluator ivbttom09c09c08evaluator
    vbttom09c09evaluator ivbttom09c09evaluator vbttom09c08evaluator ivbttom09c08evaluator vbttom09c19evaluator ivbttom09c19evaluator
    vbttom19ncevaluator ivbttom19ncevaluator vbttom19c09evaluator ivbttom19c09evaluator vbttom19c09c19evaluator ivbttom19c09c19evaluator vbttom19c09c19c18evaluator ivbttom19c09c19c18evaluator vbttom19c09c18evaluator ivbttom19c09c18evaluator vbttom19c19evaluator ivbttom19c19evaluator vbttom19c18evaluator ivbttom19c18evaluator vbttom19c19c18evaluator ivbttom19c19c18evaluator vbttom19c09c19c29evaluator ivbttom19c09c19c29evaluator vbttom19c09c18c29evaluator ivbttom19c09c18c29evaluator vbttom19c19c18c29evaluator ivbttom19c19c18c29evaluator vbttom19c09c19c18c29evaluator ivbttom19c09c19c18c29evaluator vbttom19c29evaluator ivbttom19c29evaluator vbttom19c09c29evaluator ivbttom19c09c29evaluator vbttom19c19c29evaluator ivbttom19c19c29evaluator vbttom19c18c29evaluator ivbttom19c18c29evaluator
    vbttom99c89c98evaluator ivbttom99c89c98evaluator vbttom99c89c99evaluator ivbttom99c89c99evaluator vbttom99c89c98c99evaluator ivbttom99c89c98c99evaluator
    vbttom99ncevaluator ivbttom99ncevaluator vbttom99c99c98evaluator ivbttom99c99c98evaluator
    vbttom99c99evaluator ivbttom99c99evaluator vbttom99c98evaluator ivbttom99c98evaluator vbttom99c89evaluator ivbttom99c89evaluator
    vbttom98ncevaluator ivbttom98ncevaluator vbttom98c99evaluator ivbttom98c99evaluator vbttom98c99c98evaluator ivbttom98c99c98evaluator vbttom98c99c98c88evaluator ivbttom98c99c98c88evaluator vbttom98c99c88evaluator ivbttom98c99c88evaluator vbttom98c98evaluator ivbttom98c98evaluator vbttom98c88evaluator ivbttom98c88evaluator vbttom98c98c88evaluator ivbttom98c98c88evaluator vbttom98c99c98c97evaluator ivbttom98c99c98c97evaluator vbttom98c99c88c97evaluator ivbttom98c99c88c97evaluator vbttom98c98c88c97evaluator ivbttom98c98c88c97evaluator vbttom98c99c98c88c97evaluator ivbttom98c99c98c88c97evaluator vbttom98c97evaluator ivbttom98c97evaluator vbttom98c99c97evaluator ivbttom98c99c97evaluator vbttom98c98c97evaluator ivbttom98c98c97evaluator vbttom98c88c97evaluator ivbttom98c88c97evaluator
    vbttom90c80c91evaluator ivbttom90c80c91evaluator vbttom90c80c90evaluator ivbttom90c80c90evaluator vbttom90c80c91c90evaluator ivbttom90c80c99c90evaluator
    vbttom90ncevaluator ivbttom90ncevaluator vbttom90c90c91evaluator ivbttom90c90c91evaluator
    vbttom90c90evaluator ivbttom90c90evaluator vbttom90c91evaluator ivbttom90c91evaluator vbttom90c80evaluator ivbttom90c80evaluator
    vbttom10ncevaluator ivbttom10ncevaluator vbttom10c20evaluator ivbttom10c20evaluator vbttom10c20c10evaluator ivbttom10c20c10evaluator vbttom10c20c10c11evaluator ivbttom10c20c10c11evaluator vbttom10c20c11evaluator ivbttom10c20c11evaluator vbttom10c10evaluator ivbttom10c10evaluator vbttom10c11evaluator ivbttom10c11evaluator vbttom10c10c11evaluator ivbttom10c10c11evaluator vbttom10c20c10c00evaluator ivbttom10c20c10c00evaluator vbttom10c20c11c00evaluator ivbttom10c20c11c00evaluator vbttom10c10c11c00evaluator ivbttom10c10c11c00evaluator vbttom10c20c10c11c00evaluator ivbttom10c20c10c11c00evaluator vbttom10c00evaluator ivbttom10c00evaluator vbttom10c20c00evaluator ivbttom10c20c00evaluator vbttom10c10c00evaluator ivbttom10c10c00evaluator vbttom10c11c00evaluator ivbttom10c11c00evaluator
    vbttom11c10evaluator ivbttom11c10evaluator vbttom11c21c10evaluator ivbttom11c21c10evaluator vbttom11c21c11c10evaluator ivbttom11c21c11c10evaluator vbttom11c21c11c12c10evaluator ivbttom11c21c11c12c10evaluator vbttom11c21c12c10evaluator ivbttom11c21c12c10evaluator vbttom11c11c10evaluator ivbttom11c11c10evaluator vbttom11c12c10evaluator ivbttom11c12c10evaluator vbttom11c11c12c10evaluator ivbttom11c11c12c10evaluator vbttom11c21c11c01c10evaluator ivbttom11c21c11c01c10evaluator vbttom11c21c12c01c10evaluator ivbttom11c21c12c01c10evaluator vbttom11c11c12c01c10evaluator ivbttom11c11c12c01c10evaluator vbttom11c21c11c12c01c10evaluator ivbttom11c21c11c12c01c10evaluator vbttom11c01c10evaluator ivbttom11c01c10evaluator vbttom11c21c01c10evaluator ivbttom11c21c01c10evaluator vbttom11c11c01c10evaluator ivbttom11c11c01c10evaluator vbttom11c12c01c10evaluator ivbttom11c12c01c10evaluator
    vbttom11ncevaluator ivbttom11ncevaluator vbttom11c21evaluator ivbttom11c21evaluator vbttom11c21c11evaluator ivbttom11c21c11evaluator vbttom11c21c11c12evaluator ivbttom11c21c11c12evaluator vbttom11c21c12evaluator ivbttom11c21c12evaluator vbttom11c11evaluator ivbttom11c11evaluator vbttom11c12evaluator ivbttom11c12evaluator vbttom11c11c12evaluator ivbttom11c11c12evaluator vbttom11c21c11c01evaluator ivbttom11c21c11c01evaluator vbttom11c21c12c01evaluator ivbttom11c21c12c01evaluator vbttom11c11c12c01evaluator ivbttom11c11c12c01evaluator vbttom11c21c11c12c01evaluator ivbttom11c21c11c12c01evaluator vbttom11c01evaluator ivbttom11c01evaluator vbttom11c21c01evaluator ivbttom11c21c01evaluator vbttom11c11c01evaluator ivbttom11c11c01evaluator vbttom11c12c01evaluator ivbttom11c12c01evaluator
    iappkwid rpkwmintevaluator nc2 nc3 nc4 nc5 nc6 nc7 nc8 nc9
    nc10 nc11 nc12 nc13 nc14 nc15 nc16 nc17 nc18 nc19

    blockedroute blockedbproute blrand blrpartscategory blrselector
    blrthreshold blrtarget blrsalience blrschema blrrhlemsge blrrhlemsgs blrresource blrresolved blrcheck blrsloc blract blrreplaces
    blrreplace blrrecord blrpartconstrained blrname blrverb blrtypedinstance blrtype blrtrue blrstream blrsource blrsubject
    blrstatementwhole blrstatementcomplete blrprocess blrobject blrmreplaces blrmodel blrmerge blrmcgroupvalid blrhistone blrmatch blrmelse blrlist blrjhlabel
    blrivariable blris blriname blrin blrimplement blrgroupvalid blrgroupcomplete blrfor blrif blrelsif blrfile blrmkwordref
    blrequals blreach blrdname blrdeploy blrdevelopment blrdevelop blrchar blrcase blrinitial blrstartlistkw blrnamest blrskipwso blrintegration
    blrstartrcdkw blrassert blrbuffer blrseltst blrendrcdkw blrendlistkw blrunbind blrmergestreams blrhdo blrexecute blrinitialise
    blrtranscription blrfactor blrinhibitor blrinvestigation blrsupervise blrinitiate blrterminate blrprogram blrdo blrchange
    blrnaught blrone blrtwo blrthree blrfour blrfive blrsix blrseven blreight blrnine
    blrivalw blrsemantics blrcbody blrwaitarelay blrcompleted blrintegrate blrvbt blrgenetic blralgorithm blrvbot blrsquare blrcans blrpickup blrwall blrnorth blrsouth blreast blrwest blrrandom blrsequence blrcrecord blrcfile
    blrscl blrscell blrpcell blrmembrane blrexternal blrinternal blrliposome blrcycle blrevolution blrreplication
    blrtest blrtransaction
    blrcompare blrsubprogram blrelse blraggregate blrsignal blrsub5program blrsub6program blrcivariable
    blc0 blc1 blc2 blc3 blc4 blc5 blc6 blc7 blc8 blc9
    blc10 blc11 blc12 blc13 blc14 blc15 blc16 blc17 blc18 blc19
    rhlbmspgege
    pcb pc1 pc2 pc3 pc4 pc5 pc6 pc7 pc8 pc9
    pc10 pc11 pc12 pc13 pc14 pc15 pc16 pc17 pc18 pc19
    pc20 pc21 pc22 pc23 pc24 pc25 pc26 pc27 pc28 pc29
    pc30 pc31 pc32 pc33 pc34 pc35 pc36 pc37 pc38 pc39
    pc40 pc41 pc42 pc43 pc44 pc45 pc46 pc47 pc48 pc49
    pc50 pc51 pc52 pc53 pc54 pc55 pc56 pc57 pc58 pc59
    pc60 pc61 pc62 pc63 pc64 pc65 pc66 pc67 pc68 pc69
    pc70 pc71 pc72 pc73 pc74 pc75 pc76 pc77 pc78 pc79
    pc80 pc81 pc82 pc83 pc84 pc85 pc86 pc87 pc88 pc89
    pc90 pc91 pc92 pc93 pc94 pc95 pc96 pc97 pc98 pc99
    pc100 pc101 pc102 pc103 pc104 pc105 pc106 pc107 pc108 pc109
    pc110 pc111 pc112 pc113 pc114 pc115 pc116 pc117 pc118 pc119
    pc120 pc121 pc122 pc123 pc124 pc125 pc126 pc127 pc128 pc129
    pc130 pc131 pc132 pc133 pc134 pc135 pc136 pc137 pc138 pc139
    pc140 pc141 pc142 pc143 pc144 pc145 pc146 pc147 pc148 pc149
    pc150 pc151 pc152 pc153 pc154 pc155 pc156 pc157 pc158 pc159
    pc160 pc161 pc162 pc163 pc164 pc165 pc166 pc167 pc168 pc169
    pc170 pc171 pc172 pc173 pc174 pc175 pc176 pc177 pc178 pc179
    pc180 pc181 pc182 pc183 pc184 pc185 pc186 pc187 pc188 pc189
    pc190 pc191 pc192 pc193 pc194 pc195 pc196 pc197 pc198 pc199
    pc200 pc201 pc202 pc203 pc204 pc205 pc206 pc207 pc208 pc209
    pc210 pc211 pc212 pc213 pc214 pc215 pc216 pc217 pc218 pc219
    pc220 pc221 pc222 pc223 pc224 pc225 pc226 pc227 pc228 pc229
    pc230 pc231 pc232 pc233 pc234 pc235 pc236 pc237 pc238 pc239
    pc240 pc241 pc242 pc243 pc244 pc245 pc246 pc247 pc248 pc249
    pc250 pc251 pc252 pc253 pc254 pc255 pc256 pc257 pc258 pc259
    pc260 pc261 pc262 pc263 pc264 pc265 pc266 pc267 pc268 pc269
    pc270 pc271 pc272 pc273 pc274 pc275 pc276 pc277 pc278 pc279
    pc280 pc281 pc282 pc283 pc284 pc285 pc286 pc287 pc288 pc289
    pc290 pc291 pc292 pc293 pc294 pc295 pc296 pc297 pc298 pc299
    pc300 pc301 pc302 pc303 pc304 pc305 pc306 pc307 pc308 pc309
    pc310 pc311 pc312 pc313 pc314 pc315 pc316 pc317 pc318 pc319
    pc320 pc321 pc322 pc323 pc324 pc325 pc326 pc327 pc328 pc329
    pc330 pc331 pc332 pc333 pc334 pc335 pc336 pc337 pc338 pc339
    pc340 pc341 pc342 pc343 pc344 pc345 pc346 pc347 pc348 pc349
    pc350 pc351 pc352 pc353 pc354 pc355 pc356 pc357 pc358 pc359
    pc360 pc361 pc362 pc363 pc364 pc365 pc366 pc367 pc368 pc369
    pc370 pc371 pc372 pc373 pc374 pc375 pc376 pc377 pc378 pc379
    pc380 pc381 pc382 pc383 pc384 pc385 pc386 pc387 pc388 pc389
    pc390 pc391 pc392 pc393 pc394 pc395 pc396 pc397 pc398 pc399
    pc400 pc401 pc402 pc403 pc404 pc405 pc406 pc407 pc408 pc409
    pc410 pc411 pc412 pc413 pc414 pc415 pc416 pc417 pc418 pc419
    pc420 pc421 pc422 pc423 pc424 pc425 pc426 pc427 pc428 pc429
    pc430 pc431 pc432 pc433 pc434 pc435 pc436 pc437 pc438 pc439
    pc440 pc441 pc442 pc443 pc444 pc445 pc446 pc447 pc448 pc449
    pc450 pc451 pc452 pc453 pc454 pc455 pc456 pc457 pc458 pc459
    pc460 pc461 pc462 pc463 pc464 pc465 pc466 pc467 pc468 pc469
    pc470 pc471 pc472 pc473 pc474 pc475 pc476 pc477 pc478 pc479
    pc480 pc481 pc482 pc483 pc484 pc485 pc486 pc487 pc488 pc489
    pc490 pc491 pc492 pc493 pc494 pc495 pc496 pc497 pc498 pc499
    pc500 pc501 pc502 pc503 pc504 pc505 pc506 pc507 pc508 pc509
    pc510 pc511 pc512 pc513 pc514 pc515 pc516 pc517 pc518 pc519
    pc520 pc521 pc522 pc523 pc524 pc525 pc526 pc527 pc528 pc529
    pc530 pc531 pc532 pc533 pc534 pc535 pc536 pc537 pc538 pc539
    pc540 pc541 pc542 pc543 pc544 pc545 pc546 pc547 pc548 pc549
    pc550 pc551 pc552 pc553 pc554 pc555 pc556 pc557 pc558 pc559
    pc560 pc561 pc562 pc563 pc564 pc565 pc566 pc567 pc568 pc569
    pc570 pc571 pc572 pc573 pc574 pc575 pc576 pc577 pc578 pc579
    pc580 pc581 pc582 pc583 pc584 pc585 pc586 pc587 pc588 pc589
    pc590 pc591 pc592 pc593 pc594 pc595 pc596 pc597 pc598 pc599
    wsil
    wsi);#wsi must be last
#<!-- start tag tfw -->
# cssetlist

    @$csset = qw (
    zero destructionscout destructionevaluator destructionbuilder tmodelscout modelevaluator modelbuilder tgoalscout goalevaluator goalbuilder tdescscout descscout descevaluator descbuilder relevaluator relbuilder tbondscout bondscout bondevaluator
    bondbuilder tgroupscout groupscout groupevaluator groupbuilder tnuclabgscout nuclabgevaluator nuclabgbuilder tnuclabmscout nuclabmevaluator nuclabmbuilder tnsdepscout nsdepevaluator nsdepbuilder
    lbevaluator lbbuilder lbinhibitor libevaluator libbuilder drevaluator drbuilder dcnevaluator dcnbuilder misevaluator misbuilder mkwevaluator mkwbuilder mkwinspector miforallevaluator miforallbuilder miforallinspector mittarevaluator mittarbuilder
    miterevaluator miterbuilder dassgevaluator dassgbuilder dassginspector dascgevaluator dascgbuilder dascginspector casesaevaluator casesabuilder casesainspector partscout partevaluator partbuilder
    msalthrevaluator msalthrbuilder mgpartevaluator mgpartbuilder msormevaluator msormbuilder tpmmanscout pmmanevaluator pmmanbuilder pmmaninspector mresddrevaluator mresddrbuilder mresadrevaluator mresadrbuilder mcssubevaluator mcssubbuilder
    mcsobevaluator mcsobbuilder mactsverbevaluator mactsverbbuilder mactcverbevaluator mactcverbbuilder
    mmcrevaluator mmcrbuilder mmctevaluator mmctbuilder mmcvevaluator mmcvbuilder
    mcspevaluator mcspbuilder mcvpevaluator mcvpbuilder mcopevaluator mcopbuilder mviintevaluator mviintbuilder tcasescout tstreamscout mwstaevaluator mwstabuilder mwstdevaluator mwstdbuilder
    statementscout statementevaluator statementbuilder devevaluator devbuilder devinhibitor devinspector schbindevaluator schbindbuilder
    slocevaluator slocbuilder slistkwevaluator slistkwbuilder namestevaluator namestbuilder skipwsoevaluator skipwsobuilder srcdkwevaluator srcdkwbuilder seltstevaluator seltstbuilder endrcdkwevaluator endrcdkwbuilder
    endlistkwevaluator endlistkwbuilder unbindevaluator unbindbuilder
    msiopevaluator msiopbuilder msiopinhibitor msaoevaluator msaobuilder
    initpdcaevaluator initpdcabuilder initpdcascevaluator initpdcascbuilder dcycipevaluator dcycipbuilder dcyctpevaluator dcyctpbuilder spdcaevaluator spdcabuilder spdcascevaluator spdcascbuilder ecycdopevaluator ecycdopbuilder acycchpevaluator acycchpbuilder bcycacpevaluator bcycacpbuilder e2ftfevaluator e2ftfbuilder prbevaluator prbbuilder
    invsupevaluator invsupbuilder invmodevaluator invmodbuilder
    icompdevaluator icompdbuilder
    ivalwevaluator ivalwbuilder
    bcsubpcevaluator bcsubpcbuilder bcsubpsevaluator bcsubpsbuilder itargevaluator itargbuilder acsaoevaluator acsaobuilder
    cbodyevaluator cbodybuilder crsmevaluator crsmbuilder crsmoxevaluator crsmoxbuilder crsmofevaluator crsmofbuilder crsmoievaluator crsmoibuilder crsmoeievaluator crsmoeibuilder crsmoeevaluator crsmoebuilder crsmomevaluator crsmombuilder crsmomeevaluator crsmomebuilder
    uwarsevaluator uwarsbuilder
    msadobevaluator msadobbuilder dcrdoinitevaluator dcrdoinitbuilder dcrdoslistevaluator dcrdoslistbuilder
    dcrdononrecevaluator dcrdononrecbuilder dcrdoncasedescevaluator dcrdoncasedescbuilder dcrdocasedescevaluator dcrdocasedescbuilder dcrdogowithinevaluator dcrdogowithinbuilder dcrdosrecordevaluator dcrdosrecordbuilder dcrdowarsevaluator dcrdowarsbuilder csresevaluator csresbuilder
    desrasstevaluator desrasstbuilder lbstreamevaluator lbstreambuilder lbstreamcompevaluator lbstreamcompbuilder cassertevaluator cassertbuilder stbindevaluator stbindbuilder indslocevaluator indslocbuilder shslocevaluator shslocbuilder
    rchpairevaluator rchpairbuilder rchpintevaluator rchpintbuilder ripkwmevaluator ripkwmbuilder rpkwmintevaluator rpkwmintbuilder mdvevaluator mdvbuilder mdvinspector
    rttrans01evaluator rttrans01builder rttrans01revaluator rttrans01rbuilder
    devpcellevaluator devpcellbuilder devscellevaluator devscellbuilder devscwldevaluator devscwldbuilder devsccnsevaluator devsccnsbuilder
    vbtmressevaluator vbtmressbuilder vbtmresoevaluator vbtmresobuilder vbtmsormevaluator vbtmsormbuilder vbtmactsverbevaluator vbtmactsverbbuilder vbtmcspevaluator vbtmcspbuilder vbtmcopevaluator vbtmcopbuilder vbtmcvpevaluator vbtmcvpbuilder
    vbtdevevaluator vbtdevbuilder vbtdevinhibitor vbtdevinspector devbtwldevaluator devbtwldbuilder devbtcnsevaluator devbtcnsbuilder vbtiopevaluator vbtiopbuilder vbtiopinhibitor vbttmevaluator vbttmbuilder vbttmorevbevaluator vbttmorevbbuilder vbttmoretsevaluator vbttmoretsbuilder vbttmoregsevaluator vbttmoregsbuilder
    vbttom00ncevaluator vbttom00ncbuilder vbttom0recevaluator vbttom0recbuilder vbttom00c00evaluator vbttom00c00builder vbttom00c01evaluator vbttom00c01builder vbttom00c10evaluator vbttom00c10builder vbttom00c10c00evaluator vbttom00c10c00builder vbttom00c00c01evaluator vbttom00c00c01builder vbttom00c10c01evaluator vbttom00c10c01builder vbttom00c10c01c00evaluator vbttom00c10c01c00builder
    vbttom01ncevaluator vbttom01ncbuilder vbttom01c00evaluator vbttom01c00builder vbttom01c00c01evaluator vbttom01c00c01builder vbttom01c00c01c11evaluator vbttom01c00c01c11builder vbttom01c00c11evaluator vbttom01c00c11builder vbttom01c00c01c02evaluator vbttom01c00c01c02builder vbttom01c01evaluator vbttom01c01builder vbttom01c11evaluator vbttom01c11builder vbttom01c01c11evaluator vbttom01c01c11builder vbttom01c00c11c02evaluator vbttom01c00c11c02builder vbttom01c01c11c02evaluator vbttom01c01c11c02builder vbttom01c00c01c11c02evaluator vbttom01c00c01c11c02builder vbttom01c02evaluator vbttom01c02builder vbttom01c00c02evaluator vbttom01c00c02builder vbttom01c01c02evaluator vbttom01c01c02builder vbttom01c11c02evaluator vbttom01c11c02builder
    vbttom09ncevaluator vbttom09ncbuilder vbttom09c09evaluator vbttom09c09builder vbttom09c08evaluator vbttom09c08builder vbttom09c19evaluator vbttom09c19builder vbttom09c19c09evaluator vbttom09c19c09builder vbttom09c09c08evaluator vbttom09c09c08builder vbttom09c19c08evaluator vbttom09c19c08builder vbttom09c19c08c09evaluator vbttom09c19c08c09builder
    vbttom19ncevaluator vbttom19ncbuilder vbttom19c09evaluator vbttom19c09builder vbttom19c09c19evaluator vbttom19c09c19builder vbttom19c09c19c18evaluator vbttom19c09c19c18builder vbttom19c09c18evaluator vbttom19c09c18builder vbttom19c09c19c29evaluator vbttom19c09c19c29builder vbttom19c19evaluator vbttom19c19builder vbttom19c18evaluator vbttom19c18builder vbttom19c19c18evaluator vbttom19c19c18builder vbttom19c09c18c29evaluator vbttom19c09c18c29builder vbttom19c19c18c29evaluator vbttom19c19c18c29builder vbttom19c09c19c18c29evaluator vbttom19c09c19c18c29builder vbttom19c29evaluator vbttom19c29builder vbttom19c09c29evaluator vbttom19c09c29builder vbttom19c19c29evaluator vbttom19c19c29builder vbttom19c18c29evaluator vbttom19c18c29builder
    vbttom99ncevaluator vbttom99ncbuilder vbttom99c99evaluator vbttom99c99builder vbttom99c98evaluator vbttom99c98builder vbttom99c89evaluator vbttom99c89builder vbttom99c89c99evaluator vbttom99c89c99builder vbttom99c99c98evaluator vbttom99c99c98builder vbttom99c89c98evaluator vbttom99c89c98builder vbttom99c89c98c99evaluator vbttom99c89c98c99builder
    vbttom98ncevaluator vbttom98ncbuilder vbttom98c99evaluator vbttom98c99builder vbttom98c99c98evaluator vbttom98c99c98builder vbttom98c99c98c88evaluator vbttom98c99c98c88builder vbttom98c99c88evaluator vbttom98c99c88builder vbttom98c99c98c97evaluator vbttom98c99c98c97builder vbttom98c98evaluator vbttom98c98builder vbttom98c88evaluator vbttom98c88builder vbttom98c98c88evaluator vbttom98c98c88builder vbttom98c99c88c97evaluator vbttom98c99c88c97builder vbttom98c98c88c97evaluator vbttom98c98c88c97builder vbttom98c99c98c88c97evaluator vbttom98c99c98c88c97builder vbttom98c97evaluator vbttom98c97builder vbttom98c99c97evaluator vbttom98c99c97builder vbttom98c98c97evaluator vbttom98c98c97builder vbttom98c88c97evaluator vbttom98c88c97builder
    vbttom90ncevaluator vbttom90ncbuilder vbttom90c90evaluator vbttom90c90builder vbttom90c91evaluator vbttom90c91builder vbttom90c80evaluator vbttom90c80builder vbttom90c80c90evaluator vbttom90c80c90builder vbttom90c90c91evaluator vbttom90c90c91builder vbttom90c80c91evaluator vbttom90c80c91builder vbttom90c80c91c90evaluator vbttom90c80c91c90builder
    vbttom10ncevaluator vbttom10ncbuilder vbttom10c20evaluator vbttom10c20builder vbttom10c20c10evaluator vbttom10c20c10builder vbttom10c20c10c11evaluator vbttom10c20c10c11builder vbttom10c20c11evaluator vbttom10c20c11builder vbttom10c20c10c00evaluator vbttom10c20c10c00builder vbttom10c10evaluator vbttom10c10builder vbttom10c11evaluator vbttom10c11builder vbttom10c10c11evaluator vbttom10c10c11builder vbttom10c20c11c00evaluator vbttom10c20c11c00builder vbttom10c10c11c00evaluator vbttom10c10c11c00builder vbttom10c20c10c11c00evaluator vbttom10c20c10c11c00builder vbttom10c00evaluator vbttom10c00builder vbttom10c20c00evaluator vbttom10c20c00builder vbttom10c10c00evaluator vbttom10c10c00builder vbttom10c11c00evaluator vbttom10c11c00builder
    vbttom11ncevaluator vbttom11ncbuilder vbttom11c21evaluator vbttom11c21builder vbttom11c21c11evaluator vbttom11c21c11builder vbttom11c21c11c12evaluator vbttom11c21c11c12builder vbttom11c21c12evaluator vbttom11c21c12builder vbttom11c21c11c01evaluator vbttom11c21c11c01builder vbttom11c11evaluator vbttom11c11builder vbttom11c12evaluator vbttom11c12builder vbttom11c11c12evaluator vbttom11c11c12builder vbttom11c21c12c01evaluator vbttom11c21c12c01builder vbttom11c11c12c01evaluator vbttom11c11c12c01builder vbttom11c21c11c12c01evaluator vbttom11c21c11c12c01builder vbttom11c01evaluator vbttom11c01builder vbttom11c21c01evaluator vbttom11c21c01builder vbttom11c11c01evaluator vbttom11c11c01builder vbttom11c12c01evaluator vbttom11c12c01builder
    vbttom11c10evaluator vbttom11c10builder vbttom11c21c10evaluator vbttom11c21c10builder vbttom11c21c11c10evaluator vbttom11c21c11c10builder vbttom11c21c11c12c10evaluator vbttom11c21c11c12c10builder vbttom11c21c12c10evaluator vbttom11c21c12c10builder vbttom11c21c11c01c10evaluator vbttom11c21c11c01c10builder vbttom11c11c10evaluator vbttom11c11c10builder vbttom11c12c10evaluator vbttom11c12c10builder vbttom11c11c12c10evaluator vbttom11c11c12c10builder vbttom11c21c12c01c10evaluator vbttom11c21c12c01c10builder vbttom11c11c12c01c10evaluator vbttom11c11c12c01c10builder vbttom11c21c11c12c01c10evaluator vbttom11c21c11c12c01c10builder vbttom11c01c10evaluator vbttom11c01c10builder vbttom11c21c01c10evaluator vbttom11c21c01c10builder vbttom11c11c01c10evaluator vbttom11c11c01c10builder vbttom11c12c01c10evaluator vbttom11c12c01c10builder
    vbttoamnevaluator vbttoamnbuilder vbttoamsevaluator vbttoamsbuilder vbttoameevaluator vbttoamebuilder vbttoamwevaluator vbttoamwbuilder vbttoamrevaluator vbttoamrbuilder vbttoapcevaluator vbttoapcbuilder
    );
#<!-- end tag tfw -->
# strsetlist

    @$strset = qw (
    zero tddesc budesc tdbond bubond bugroup tdgroup budescl tddescl selfacetc usedescpc
    matchtree bustatement budevelopment delta
    );
#<!-- nnd tag sl -->
#<!-- start tag sys -->
# ptstartsymb
    $Awfif::symbolsets-> {meta}{start} = "ptstartt";
    $Awfif::symbolsets-> {imeta}{ptstartt} = "start";
    $Awfif::symbolsets-> {meta}{stop} = "ptstopt";
    $Awfif::symbolsets-> {imeta}{ptstopt} = "stop";
    $Awfif::symbolsets-> {meta}{begin} = "ptbegint";
    $Awfif::symbolsets-> {imeta}{ptbegint} = "begin";
    $Awfif::symbolsets-> {meta}{end} = "ptendt";
    $Awfif::symbolsets-> {imeta}{ptendt} = "end";
    $Awfif::symbolsets-> {meta}{type} = "pttypet";
    $Awfif::symbolsets-> {imeta}{pttypet} = "type";
    $Awfif::symbolsets-> {meta}{list} = "ptlistt";
    $Awfif::symbolsets-> {imeta}{ptlistt} = "list";
    $Awfif::symbolsets-> {meta}{name} = "ttnamet";
    $Awfif::symbolsets-> {imeta}{ttnamet} = "name";
    $Awfif::symbolsets-> {meta}{record} = "ttrecordt";
    $Awfif::symbolsets-> {imeta}{ttrecordt} = "record";
    $Awfif::symbolsets-> {meta}{value} = "ptvaluet";
    $Awfif::symbolsets-> {imeta}{ptvaluet} = "value";
    $Awfif::symbolsets-> {meta}{svalue} = "ptsvaluet";
    $Awfif::symbolsets-> {imeta}{ptsvaluet} = "svalue";
# pttruesymb
    $Awfif::symbolsets-> {meta}{true} = "pttruet";
    $Awfif::symbolsets-> {imeta}{pttruet} = "true";
# ptstayssymb
    $Awfif::symbolsets-> {meta}{stays} = "ptstayst";
    $Awfif::symbolsets-> {imeta}{ptstayst} = "stays";
# ptintegratesymb
    $Awfif::symbolsets-> {meta}{integrate} = "ptintegratet";
    $Awfif::symbolsets-> {imeta}{ptintegratet} = "integrate";
# ptfirstsymb
    $Awfif::symbolsets-> {meta}{first} = "ptfirstt";
    $Awfif::symbolsets-> {imeta}{ptfirst} = "first";
# ptimagesymb
    $Awfif::symbolsets-> {meta}{image} = "ptimaget";
    $Awfif::symbolsets-> {imeta}{ptimaget} = "image";
# ttsignalsymb
    $Awfif::symbolsets-> {meta}{signal} = "ttsignalt";
    $Awfif::symbolsets-> {imeta}{ttsignalt} = "signal";
# ttexcludesymb
    $Awfif::symbolsets-> {meta}{cexcluded} = "ttexcludet";
    $Awfif::symbolsets-> {imeta}{ttexcludet} = "cexcluded";
    $Awfif::symbolsets-> {meta}{truthassertion} = "tttrutht";
    $Awfif::symbolsets-> {imeta}{tttrutht} = "truthassertion";
    $Awfif::symbolsets-> {meta}{gowithin} = "ptgowithint";
    $Awfif::symbolsets-> {imeta}{ptgowithint} = "gowithin";
    $Awfif::symbolsets-> {meta}{phys} = "ptphysicst";
    $Awfif::symbolsets-> {imeta}{ptphysicst} = "phys";
    $Awfif::symbolsets-> {meta}{small} = "ptsmallt";
    $Awfif::symbolsets-> {imeta}{ptsmallt} = "small";
    $Awfif::symbolsets-> {meta}{polar} = "ptpolart";
    $Awfif::symbolsets-> {imeta}{ptpolart} = "polar";
    $Awfif::symbolsets-> {meta}{instance} = "ptinstancet";
    $Awfif::symbolsets-> {imeta}{ptinstancet} = "instance";
    $Awfif::symbolsets-> {meta}{case} = "ptcaset";
    $Awfif::symbolsets-> {imeta}{ptcaset} = "case";
    $Awfif::symbolsets-> {meta}{alternate} = "ptalternatet";
    $Awfif::symbolsets-> {imeta}{ptalternatet} = "alternate";
    $Awfif::symbolsets-> {meta}{for} = "ptfort";
    $Awfif::symbolsets-> {imeta}{ptfort} = "for";
    $Awfif::symbolsets-> {meta}{if} = "ptift";
    $Awfif::symbolsets-> {imeta}{ptift} = "if";
    $Awfif::symbolsets-> {meta}{elsif} = "ptelsift";
    $Awfif::symbolsets-> {imeta}{ptelsift} = "elsif";
    $Awfif::symbolsets-> {meta}{match} = "ptmat";
    $Awfif::symbolsets-> {imeta}{ptmat} = "match";
    $Awfif::symbolsets-> {meta}{melse} = "ptmelset";
    $Awfif::symbolsets-> {imeta}{ptmelset} = "melse";
    $Awfif::symbolsets-> {meta}{selector} = "ptselectort";
    $Awfif::symbolsets-> {imeta}{ptselectort} = "selector";
    $Awfif::symbolsets-> {meta}{body} = "ptbodyt";
    $Awfif::symbolsets-> {imeta}{ptbodyt} = "body";
    $Awfif::symbolsets-> {meta}{exc} = "ptexclusivet";
    $Awfif::symbolsets-> {imeta}{ptexclusivet} = "exc";
    $Awfif::symbolsets-> {meta}{replace} = "ptreplacet";
    $Awfif::symbolsets-> {imeta}{ptreplacet} = "replace";
    $Awfif::symbolsets-> {meta}{replaces} = "ptreplacest";
    $Awfif::symbolsets-> {imeta}{ptreplacest} = "replaces";
    $Awfif::symbolsets-> {meta}{target} = "tttargett";
    $Awfif::symbolsets-> {imeta}{tttargett} = "target";
    $Awfif::symbolsets-> {meta}{in} = "ttint";
    $Awfif::symbolsets-> {imeta}{ttint} = "in";
    $Awfif::symbolsets-> {meta}{either} = "pteithert";
    $Awfif::symbolsets-> {imeta}{pteithert} = "either";
    $Awfif::symbolsets-> {meta}{or} = "ptort";
    $Awfif::symbolsets-> {imeta}{ptort} = "or";
    $Awfif::symbolsets-> {meta}{is} = "ptist";
    $Awfif::symbolsets-> {imeta}{ptist} = "is";
    $Awfif::symbolsets-> {meta}{page} = "ptpaget";
    $Awfif::symbolsets-> {imeta}{ptpaget} = "page";
    $Awfif::symbolsets-> {meta}{reference} = "ptreft";
    $Awfif::symbolsets-> {imeta}{ptreft} = "reference";
# $Awfif::symbolsets-> {meta}{var} = "ptvart";
# $Awfif::symbolsets-> {imeta}{ptvart} = "var";#see ivariable
    $Awfif::symbolsets-> {meta}{file} = "ttfilet";
    $Awfif::symbolsets-> {imeta}{ttfilet} = "file";
    $Awfif::symbolsets-> {meta}{source} = "ttsourcet";
    $Awfif::symbolsets-> {imeta}{ttsourcet} = "source";
    $Awfif::symbolsets-> {meta}{version} = "ptversiont";
    $Awfif::symbolsets-> {imeta}{ptversiont} = "version";
    $Awfif::symbolsets-> {meta}{activator} = "ptactivatort";
    $Awfif::symbolsets-> {imeta}{ptactivatort} = "activator";
    $Awfif::symbolsets-> {meta}{on} = "ptont";
    $Awfif::symbolsets-> {imeta}{ptont} = "on";
    $Awfif::symbolsets-> {meta}{off} = "ptofft";
    $Awfif::symbolsets-> {imeta}{ptofft} = "off";
    $Awfif::symbolsets-> {meta}{hkey} = "pthashkt";
    $Awfif::symbolsets-> {imeta}{pthashkt} = "hkey";
    $Awfif::symbolsets-> {meta}{proc} = "ptsubt";
    $Awfif::symbolsets-> {imeta}{ptsubt} = "proc";
    $Awfif::symbolsets-> {meta}{growthp} = "ptgrowthpt";
    $Awfif::symbolsets-> {imeta}{ptgrowthpt} = "growthp";
    $Awfif::symbolsets-> {meta}{memgroup} = "ptwindt";
    $Awfif::symbolsets-> {imeta}{ptwindt} = "memgroup";
    $Awfif::symbolsets-> {meta}{'/memgroup'} = "ptunwindt";
    $Awfif::symbolsets-> {imeta}{ptunwindt} = "/memgroup";
    $Awfif::symbolsets-> {meta}{memgst} = "ptwindt";
    $Awfif::symbolsets-> {imeta}{ptwindt} = "memgst";
    $Awfif::symbolsets-> {meta}{memgsp} = "ptunwindt";
    $Awfif::symbolsets-> {imeta}{ptunwindt} = "memgsp";
# $Awfif::symbolsets-> {meta}{mkeyword} = "mkeywords";
# $Awfif::symbolsets-> {imeta}{mkeywords} = "mkeyword";
# $Awfif::symbolsets-> {meta}{'/mkeyword'} = "mkeyworde";
# $Awfif::symbolsets-> {imeta}{mkeyworde} = "/mkeyword";
    $Awfif::symbolsets-> {meta}{mkeyword} = "ptmkeywordst";
    $Awfif::symbolsets-> {imeta}{ptmkeywordst} = "mkeyword";
    $Awfif::symbolsets-> {meta}{'/mkeyword'} = "ptmkeywordet";
    $Awfif::symbolsets-> {imeta}{ptmkeywordet} = "/mkeyword";
    $Awfif::symbolsets-> {meta}{mkeywords} = "ptmkeywordst";
    $Awfif::symbolsets-> {imeta}{ptmkeywordst} = "mkeywords";
    $Awfif::symbolsets-> {meta}{mkeyworde} = "ptmkeywordet";
    $Awfif::symbolsets-> {imeta}{ptmkeywordet} = "mkeyworde";
# ptvbtsymb
    $Awfif::symbolsets-> {meta}{vbt} = "ptvbtt";
    $Awfif::symbolsets-> {imeta}{ptvbtt} = "vbt";
# ptvbotsymb
    $Awfif::symbolsets-> {meta}{vbot} = "ptvbott";
    $Awfif::symbolsets-> {imeta}{ptvbott} = "vbot";
# ptperformsymb
    $Awfif::symbolsets-> {meta}{perform} = "ptperformt";
    $Awfif::symbolsets-> {imeta}{ptperformt} = "perform";
# ptgeneticsymb
    $Awfif::symbolsets-> {meta}{genetic} = "ptgenetict";
    $Awfif::symbolsets-> {imeta}{ptgenetict} = "genetic";
# ptalgorithmsymb
    $Awfif::symbolsets-> {meta}{algorithm} = "ptalgorithmt";
    $Awfif::symbolsets-> {imeta}{ptalgorithmt} = "algorithm";
# ptsquaresymb
    $Awfif::symbolsets-> {meta}{square} = "ptsquaret";
    $Awfif::symbolsets-> {imeta}{ptsquaret} = "square";
# ptcanssymb
    $Awfif::symbolsets-> {meta}{cans} = "ptcanst";
    $Awfif::symbolsets-> {imeta}{ptcanst} = "cans";
# ptwallsymb
    $Awfif::symbolsets-> {meta}{wall} = "ptwallt";
    $Awfif::symbolsets-> {imeta}{ptwallt} = "wall";
# ptpickupsymb
    $Awfif::symbolsets-> {meta}{pickup} = "ptpickupt";
    $Awfif::symbolsets-> {imeta}{ptpickupt} = "pickup";
# ptnorthsymb
    $Awfif::symbolsets-> {meta}{north} = "ptnortht";
    $Awfif::symbolsets-> {imeta}{ptnortht} = "north";
# ptsouthsymb
    $Awfif::symbolsets-> {meta}{south} = "ptsoutht";
    $Awfif::symbolsets-> {imeta}{ptsoutht} = "south";
# pteastsymb
    $Awfif::symbolsets-> {meta}{east} = "pteastt";
    $Awfif::symbolsets-> {imeta}{pteastt} = "east";
# ptwestsymb
    $Awfif::symbolsets-> {meta}{west} = "ptwestt";
    $Awfif::symbolsets-> {imeta}{ptwestt} = "west";
# ptrandomsymb
    $Awfif::symbolsets-> {meta}{random} = "ptrandomt";
    $Awfif::symbolsets-> {imeta}{ptrandomt} = "random";
# ttmergestreamssymb
    $Awfif::symbolsets-> {meta}{mergestreams} = "ttmergestreamst";
    $Awfif::symbolsets-> {imeta}{ttmergestreamst} = "mergestreams";
# tthdosymb
    $Awfif::symbolsets-> {meta}{hdo} = "tthdot";
    $Awfif::symbolsets-> {imeta}{tthdot} = "hdo";
# ttexecutesymb
    $Awfif::symbolsets-> {meta}{execute} = "ttexecutet";
    $Awfif::symbolsets-> {imeta}{ttexecutet} = "execute";
# ttinitialisesymb
    $Awfif::symbolsets-> {meta}{initialise} = "ttinitialiset";
    $Awfif::symbolsets-> {imeta}{ttinitialiset} = "initialise";
# tttranscriptionsymb
    $Awfif::symbolsets-> {meta}{transcription} = "tttranscriptiont";
    $Awfif::symbolsets-> {imeta}{tttranscriptiont} = "transcription";
# ttfactorsymb
    $Awfif::symbolsets-> {meta}{factor} = "ttfactort";
    $Awfif::symbolsets-> {imeta}{ttfactort} = "factor";
# ttinhibitorsymb
    $Awfif::symbolsets-> {meta}{inhibitor} = "ttinhibitort";
    $Awfif::symbolsets-> {imeta}{ttinhibitort} = "inhibitor";
# ptbuffersymb
    $Awfif::symbolsets-> {meta}{buffer} = "ptbuffert";
    $Awfif::symbolsets-> {imeta}{ptbuffert} = "buffer";
# ttinvestigationsymb
    $Awfif::symbolsets-> {meta}{investigation} = "ttinvestigationt";
    $Awfif::symbolsets-> {imeta}{ttinvestigationt} = "investigation";
# ttsupervisesymb
    $Awfif::symbolsets-> {meta}{supervise} = "ttsuperviset";
    $Awfif::symbolsets-> {imeta}{ttsuperviset} = "supervise";
# ttsubprogramsymb
    $Awfif::symbolsets-> {meta}{subprogram} = "ttsubprogramt";
    $Awfif::symbolsets-> {imeta}{ttsubprogramt} = "subprogram";
# ttelsesymb
    $Awfif::symbolsets-> {meta}{else} = "ptelset";
    $Awfif::symbolsets-> {imeta}{ptelset} = "else";
# ttsub2programsymb
    $Awfif::symbolsets-> {meta}{sub2program} = "ttsub2programt";
    $Awfif::symbolsets-> {imeta}{ttsub2programt} = "sub2program";
# ttaggregatesymb
    $Awfif::symbolsets-> {meta}{aggregate} = "ttaggregatet";
    $Awfif::symbolsets-> {imeta}{ttaggregatet} = "aggregate";
# tttestsymb
    $Awfif::symbolsets-> {meta}{test} = "tttestt";
    $Awfif::symbolsets-> {imeta}{tttestt} = "test";
# tttransactionsymb
    $Awfif::symbolsets-> {meta}{transaction} = "tttransactiont";
    $Awfif::symbolsets-> {imeta}{tttransactiont} = "transaction";
# ptsclsymb
    $Awfif::symbolsets-> {meta}{scl} = "ptsclt";
    $Awfif::symbolsets-> {imeta}{ptsclt} = "scl";
# ptscellsymb
    $Awfif::symbolsets-> {meta}{scell} = "ptscellt";
    $Awfif::symbolsets-> {imeta}{ptscellt} = "scell";
# ttsub5programsymb
    $Awfif::symbolsets-> {meta}{sub5program} = "ttsub5programt";
    $Awfif::symbolsets-> {imeta}{ttsub5programt} = "sub5program";
# ttsub6programsymb
    $Awfif::symbolsets-> {meta}{sub6program} = "ttsub6programt";
    $Awfif::symbolsets-> {imeta}{ttsub6programt} = "sub6program";
# ttinitiatesymb
    $Awfif::symbolsets-> {meta}{initiate} = "ttinitiatet";
    $Awfif::symbolsets-> {imeta}{ttinitiatet} = "initiate";
# ttdosymb
    $Awfif::symbolsets-> {meta}{do} = "ttdot";
    $Awfif::symbolsets-> {imeta}{ttdot} = "do";
# ttactsymb
    $Awfif::symbolsets-> {meta}{act} = "ttactt";
    $Awfif::symbolsets-> {imeta}{ttactt} = "act";
# ttchangesymb
    $Awfif::symbolsets-> {meta}{change} = "ttchanget";
    $Awfif::symbolsets-> {imeta}{ttchanget} = "change";
# ptsetheadsymb
    $Awfif::symbolsets-> {meta}{sethead} = "ptsetheadt";
    $Awfif::symbolsets-> {imeta}{ptsetheadt} = "sethead";
# ttterminatesymb
    $Awfif::symbolsets-> {meta}{terminate} = "ttterminatet";
    $Awfif::symbolsets-> {imeta}{ttterminatet} = "terminate";
# ttprogramsymb
    $Awfif::symbolsets-> {meta}{program} = "ttprogramt";
    $Awfif::symbolsets-> {imeta}{ttprogramt} = "program";
# ptmkwordrefsymb
    $Awfif::symbolsets-> {meta}{mkwordref} = "ptmkwordreft";
    $Awfif::symbolsets-> {imeta}{ptmkwordreft} = "mkwordref";
    $Awfif::symbolsets-> {meta}{escape1} = "ptesc1t";
    $Awfif::symbolsets-> {imeta}{ptesc1t} = "escape1";
    $Awfif::symbolsets-> {meta}{escape2} = "ptesc2t";
    $Awfif::symbolsets-> {imeta}{ptesc2t} = "escape2";
    $Awfif::symbolsets-> {meta}{escapes1} = "ptescs1t";
    $Awfif::symbolsets-> {imeta}{ptescs1t} = "escapes1";
    $Awfif::symbolsets-> {meta}{escapes2} = "ptescs2t";
    $Awfif::symbolsets-> {imeta}{ptescs2t} = "escapes2";
    $Awfif::symbolsets-> {meta}{msuccbond} = "ptmsbondt";
    $Awfif::symbolsets-> {imeta}{ptmsbondt} = "msuccbond";
    $Awfif::symbolsets-> {meta}{msuccrel} = "ptmsrelt";
    $Awfif::symbolsets-> {imeta}{ptmsrelt} = "msuccrel";
    $Awfif::symbolsets-> {meta}{msuccgroup} = "ptmsgroupt";
    $Awfif::symbolsets-> {imeta}{ptmsgroupt} = "msuccgroup";
    $Awfif::symbolsets-> {meta}{msgsponsor} = "ptmsgsponsort";
    $Awfif::symbolsets-> {imeta}{ptmsgsponsort} = "msgsponsor";
# pttmbindingsymb
    $Awfif::symbolsets-> {meta}{mtmbindstart} = "pttmbindstartt";
    $Awfif::symbolsets-> {imeta}{pttmbindstartt} = "mtmbindstart";
    $Awfif::symbolsets-> {meta}{mtmbindend} = "pttmbindendt";
    $Awfif::symbolsets-> {imeta}{pttmbindendt} = "mtmbindend";
    $Awfif::symbolsets-> {meta}{msuccgstart} = "ptmsgstartt";
    $Awfif::symbolsets-> {imeta}{ptmsgstartt} = "msuccgstart";
    $Awfif::symbolsets-> {meta}{msuccgend} = "ptmsgendt";
    $Awfif::symbolsets-> {imeta}{ptmsgendt} = "msuccgend";
    $Awfif::symbolsets-> {meta}{msuccgedges} = "ptmssgedget";
    $Awfif::symbolsets-> {imeta}{ptmssgedget} = "msuccgedges";
    $Awfif::symbolsets-> {meta}{msuccgedgee} = "ptmsegedget";
    $Awfif::symbolsets-> {imeta}{ptmsegedget} = "msuccgedgee";
    $Awfif::symbolsets-> {meta}{rhlemsgs} = "rhlemsg";#***********
    $Awfif::symbolsets-> {imeta}{rhlemsg} = "rhlemsgs";#**********
    $Awfif::symbolsets-> {meta}{rhlemsge} = "/rhlemsg";#***********
    $Awfif::symbolsets-> {imeta}{'/rhlemsg'} = "rhlemsge";#**********
    $Awfif::symbolsets-> {meta}{rhlmspgs} = "rhlmspg";
    $Awfif::symbolsets-> {imeta}{rhlmspg} = "rhlmspgs";
    $Awfif::symbolsets-> {meta}{rhlmspge} = "/rhlmspg";
    $Awfif::symbolsets-> {imeta}{'/rhlmspg'} = "rhlmspge";
    $Awfif::symbolsets-> {meta}{rhlmspgegs} = "rhlmsge";
# ptfilterssymb
    $Awfif::symbolsets-> {imeta}{rhlwphfilters} = "rhlsfilters";
    $Awfif::symbolsets-> {meta}{rhlsfilters} = "rhlwphfilters";
    $Awfif::symbolsets-> {imeta}{'/rhlwphfilters'} = "rhlefilters";
    $Awfif::symbolsets-> {meta}{rhlefilters} = "/rhlwphfilters";
    $Awfif::symbolsets-> {imeta}{rhlmsge} = "rhlmspgegs";
    $Awfif::symbolsets-> {meta}{rhlmspgege} = "/rhlmsge";
    $Awfif::symbolsets-> {imeta}{'/rhlmsge'} = "rhlmspgege";
    $Awfif::symbolsets-> {meta}{rhlbmspgegs} = "rhlbmsge";
    $Awfif::symbolsets-> {imeta}{rhlbmsge} = "rhlbmspgegs";
    $Awfif::symbolsets-> {meta}{rhlbmspgege} = "/rhlbmsge";
    $Awfif::symbolsets-> {imeta}{'/rhlbmsge'} = "rhlbmspgege";
# $Awfif::symbolsets-> {meta}{memgst} = "memgroup";
# $Awfif::symbolsets-> {imeta}{memgroup} = "memgst";
# $Awfif::symbolsets-> {meta}{memgsp} = "/memgroup";
# $Awfif::symbolsets-> {imeta}{'/memgroup'} = "memgsp";
    $Awfif::symbolsets-> {meta}{mcasehstart} = "ptmchstartt";
    $Awfif::symbolsets-> {imeta}{ptmchstartt} = "mcasehstart";
    $Awfif::symbolsets-> {meta}{mcasehend} = "ptmchendt";
    $Awfif::symbolsets-> {imeta}{ptmchendt} = "mcasehend";
    $Awfif::symbolsets-> {meta}{mcase} = "ptmcaset";
    $Awfif::symbolsets-> {imeta}{ptmcaset} = "mcase";
    $Awfif::symbolsets-> {meta}{rhlmpchs} = "rhlmpch";#******
    $Awfif::symbolsets-> {imeta}{rhlmpch} = "rhlmpchs";#*****
    $Awfif::symbolsets-> {meta}{rhlmpche} = "/rhlmpch";#******
    $Awfif::symbolsets-> {imeta}{'/rhlmpch'} = "rhlmpche";#******
# tthistonesymb
    $Awfif::symbolsets-> {meta}{histone} = "tthistonet";
    $Awfif::symbolsets-> {imeta}{tthistonet} = "histone";
# ptindexsymb
    $Awfif::symbolsets-> {meta}{rhlindex} = "ptindext";
    $Awfif::symbolsets-> {imeta}{ptindext} = "rhlindex";
    $Awfif::symbolsets-> {meta}{equals} = "ttequalst";
    $Awfif::symbolsets-> {imeta}{ttequalst} = "equals";
    $Awfif::symbolsets-> {meta}{char} = "ttchart";
    $Awfif::symbolsets-> {imeta}{ttchart} = "char";
    $Awfif::symbolsets-> {meta}{merge} = "ttmerget";
    $Awfif::symbolsets-> {imeta}{ttmerget} = "merge";
# ptmembranesymb
    $Awfif::symbolsets-> {meta}{membrane} = "ptmembranet";
    $Awfif::symbolsets-> {imeta}{ptmembranet} = "membrane";
# ptpcellsymb
    $Awfif::symbolsets-> {meta}{pcell} = "ptpcellt";
    $Awfif::symbolsets-> {imeta}{ptpcellt} = "pcell";
# ptexternalsymb
    $Awfif::symbolsets-> {meta}{external} = "ptexternalt";
    $Awfif::symbolsets-> {imeta}{ptexternalt} = "external";
# ptinternalsymb
    $Awfif::symbolsets-> {meta}{internal} = "ptinternalt";
    $Awfif::symbolsets-> {imeta}{ptinternalt} = "internal";
# ptcyclesymb
    $Awfif::symbolsets-> {meta}{cycle} = "ptcyclet";
    $Awfif::symbolsets-> {imeta}{ptcyclet} = "cycle";
# ptevolutionsymb
    $Awfif::symbolsets-> {meta}{evolution} = "ptevolutiont";
    $Awfif::symbolsets-> {imeta}{ptevolutiont} = "evolution";
# ptreplicationsymb
    $Awfif::symbolsets-> {meta}{replication} = "ptreplicationt";
    $Awfif::symbolsets-> {imeta}{ptreplicationt} = "replication";
# ptliposomesymb
    $Awfif::symbolsets-> {meta}{liposome} = "ptliposomet";
    $Awfif::symbolsets-> {imeta}{ptliposomet} = "liposome";
# ptnaughtsymb
    $Awfif::symbolsets-> {meta}{naught} = "ptnaughtt";
    $Awfif::symbolsets-> {imeta}{ptnaughtt} = "naught";
# ptonesymb
    $Awfif::symbolsets-> {meta}{one} = "ptonet";
    $Awfif::symbolsets-> {imeta}{ptonet} = "one";
# ptonesymb
    $Awfif::symbolsets-> {meta}{two} = "pttwot";
    $Awfif::symbolsets-> {imeta}{pttwot} = "two";
# ptthreesymb
    $Awfif::symbolsets-> {meta}{three} = "ptthreet";
    $Awfif::symbolsets-> {imeta}{ptthreet} = "three";
# ptfoursymb
    $Awfif::symbolsets-> {meta}{four} = "ptfourt";
    $Awfif::symbolsets-> {imeta}{ptfourt} = "four";
    $Awfif::symbolsets-> {meta}{assert} = "ttassertt";
# ptfivesymb
    $Awfif::symbolsets-> {meta}{five} = "ptfivet";
    $Awfif::symbolsets-> {imeta}{ptfivet} = "five";
# ptsixsymb
    $Awfif::symbolsets-> {meta}{six} = "ptsixt";
    $Awfif::symbolsets-> {imeta}{ptsixt} = "six";
# ptsevensymb
    $Awfif::symbolsets-> {meta}{seven} = "ptsevent";
    $Awfif::symbolsets-> {imeta}{ptsevent} = "seven";
# pteightsymb
    $Awfif::symbolsets-> {meta}{eight} = "pteightt";
    $Awfif::symbolsets-> {imeta}{pteightt} = "eight";
# ptninesymb
    $Awfif::symbolsets-> {meta}{nine} = "ptninet";
    $Awfif::symbolsets-> {imeta}{ptninet} = "nine";
    $Awfif::symbolsets-> {imeta}{ttassertt} = "assert";
    $Awfif::symbolsets-> {meta}{subject} = "ttsubjectt";
    $Awfif::symbolsets-> {imeta}{ttsubjectt} = "subject";
    $Awfif::symbolsets-> {meta}{verb} = "ttverbt";
    $Awfif::symbolsets-> {imeta}{ttverbt} = "verb";
    $Awfif::symbolsets-> {meta}{object} = "ttobjectt";
    $Awfif::symbolsets-> {imeta}{ttobjectt} = "object";
    $Awfif::symbolsets-> {meta}{assume} = "ttassumet";
    $Awfif::symbolsets-> {imeta}{ttassumet} = "assume";
    $Awfif::symbolsets-> {meta}{clause} = "ttclauset";
    $Awfif::symbolsets-> {imeta}{ttclauset} = "clause";
    $Awfif::symbolsets-> {meta}{stream} = "ptstreamt";
    $Awfif::symbolsets-> {imeta}{ptstreamt} = "stream";
    $Awfif::symbolsets-> {meta}{qmark} = "ptqmarkt";
    $Awfif::symbolsets-> {imeta}{ptqmarkt} = "qmark";
    $Awfif::symbolsets-> {meta}{lhead} = "ptlheadt";
    $Awfif::symbolsets-> {imeta}{ptlheadt} = "lhead";
    $Awfif::symbolsets-> {meta}{ltail} = "ptltailt";
    $Awfif::symbolsets-> {imeta}{ptltailt} = "ltail";
    $Awfif::symbolsets-> {meta}{telomerest} = "pttelomerestt";
    $Awfif::symbolsets-> {imeta}{pttelomerestt} = "telomerest";
    $Awfif::symbolsets-> {meta}{telomeresp} = "pttelomerespt";
    $Awfif::symbolsets-> {imeta}{pttelomerespt} = "telomeresp";
    $Awfif::symbolsets-> {meta}{teld} = "ptteldt";
    $Awfif::symbolsets-> {imeta}{ptteldt} = "teld";
    $Awfif::symbolsets-> {meta}{telr} = "pttelrt";
    $Awfif::symbolsets-> {imeta}{pttelrt} = "telr";
    $Awfif::symbolsets-> {meta}{model} = "ptmodelt";
    $Awfif::symbolsets-> {imeta}{ptmodelt} = "model";
    $Awfif::symbolsets-> {meta}{partscategory} = "ttpartt";
    $Awfif::symbolsets-> {imeta}{ttpartt} = "partscategory";
# ptconstrainedsymb
    $Awfif::symbolsets-> {meta}{partconstrained} = "ptconstrainedt";
    $Awfif::symbolsets-> {imeta}{ptconstrainedt} = "partconstrained";
# ptstatementwholesymb
    $Awfif::symbolsets-> {meta}{statementwhole} = "ptstatementwholet";
    $Awfif::symbolsets-> {imeta}{ptstatementwholet} = "statementwhole";
# ptstatementcompletesymb
    $Awfif::symbolsets-> {meta}{statementcomplete} = "ptstatementcompletet";
    $Awfif::symbolsets-> {imeta}{ptstatementcompletet}= "statementcomplete";
# ptstatementcategorysymb
    $Awfif::symbolsets-> {meta}{statementcategory} = "ptstatementt";
    $Awfif::symbolsets-> {imeta}{ptstatementt} = "statementcategory";
# ptdevcategorysymb
    $Awfif::symbolsets-> {meta}{devcategory} = "ptdevcatt";
    $Awfif::symbolsets-> {imeta}{ptdevcatt} = "devcategory";
    $Awfif::symbolsets-> {meta}{schema} = "ptschemat";
    $Awfif::symbolsets-> {imeta}{ptschemat} = "schema";
    $Awfif::symbolsets-> {meta}{complete} = "ptcompletet";
    $Awfif::symbolsets-> {imeta}{ptcompletet} = "complete";
    $Awfif::symbolsets-> {meta}{group} = "ptgroupt";
    $Awfif::symbolsets-> {imeta}{ptgroupt} = "group";
# ptinitialsymb
    $Awfif::symbolsets-> {meta}{initial} = "ptinitialt";
    $Awfif::symbolsets-> {imeta}{ptinitialt} = "initial";
# ptstartlistkwsymb
    $Awfif::symbolsets-> {meta}{startlistkw} = "ptstartlistkwt";
    $Awfif::symbolsets-> {imeta}{ptstartlistkwt} = "startlistkw";
# ptstartrcdkwsymb
    $Awfif::symbolsets-> {meta}{startrcdkw} = "ptstartrcdkwt";
    $Awfif::symbolsets-> {imeta}{ptstartrcdkwt} = "startrcdkw";
# ptendrcdkwsymb
    $Awfif::symbolsets-> {meta}{endrcdkw} = "ptendrcdkwt";
    $Awfif::symbolsets-> {imeta}{ptendrcdkwt} = "endrcdkw";
# ptendlistkwsymb
    $Awfif::symbolsets-> {meta}{endlistkw} = "ptendlistkwt";
    $Awfif::symbolsets-> {imeta}{ptendlistkwt} = "endlistkw";
# ptskipwsosymb
    $Awfif::symbolsets-> {meta}{skipwso} = "ptskipwsot";
    $Awfif::symbolsets-> {imeta}{ptskipwsot} = "skipwso";
# ptseltstsymb
    $Awfif::symbolsets-> {meta}{seltst} = "ptseltstt";
    $Awfif::symbolsets-> {imeta}{ptseltstt} = "seltst";
# ptivalwsymb
    $Awfif::symbolsets-> {meta}{ivalw} = "ptivalwt";
    $Awfif::symbolsets-> {imeta}{ptivalwt} = "ivalw";
# ptcbodysymb
    $Awfif::symbolsets-> {meta}{cbody} = "ptcbodyt";
    $Awfif::symbolsets-> {imeta}{ptcbodyt} = "cbody";
# ptwaitarelaysymb
    $Awfif::symbolsets-> {meta}{waitarelay} = "ptwaitarelayt";
    $Awfif::symbolsets-> {imeta}{ptwaitarelayt} = "waitarelay";
# ptcompletedsymb
    $Awfif::symbolsets-> {meta}{completed} = "ptcompletedt";
    $Awfif::symbolsets-> {imeta}{ptcompletedt} = "completed";
# ptcomparesymb
    $Awfif::symbolsets-> {meta}{compare} = "ptcomparet";
    $Awfif::symbolsets-> {imeta}{ptcomparet} = "compare";
# ptsemanticssymb
    $Awfif::symbolsets-> {meta}{semantics} = "ptsemanticst";
    $Awfif::symbolsets-> {imeta}{ptsemanticst} = "semantics";
# ptunbindsymb
    $Awfif::symbolsets-> {meta}{unbind} = "ptunbindt";
    $Awfif::symbolsets-> {imeta}{ptunbindt} = "unbind";
# ptnamestsymb
    $Awfif::symbolsets-> {meta}{namest} = "ptnamestt";
    $Awfif::symbolsets-> {imeta}{ptnamestt} = "namest";
# ptindequivsymb
    $Awfif::symbolsets-> {meta}{mindequiv} = "ptindequivt";#mindequiv is the token used in deploymd & memccategory tupple
    $Awfif::symbolsets-> {imeta}{ptindequivt} = "mindequiv";#ptindequivt is the token used in metafile while <indequiv> is the keyword used externally
# ptplansymb
    $Awfif::symbolsets-> {meta}{plan} = "ptplant";
    $Awfif::symbolsets-> {imeta}{ptplant} = "plan";
# ptpdcasymb
    $Awfif::symbolsets-> {meta}{pdca} = "ptpdcat";
    $Awfif::symbolsets-> {imeta}{ptpdcat} = "pdca";
# ptdevelopsymb
    $Awfif::symbolsets-> {meta}{develop} = "ptdevelopt";
    $Awfif::symbolsets-> {imeta}{ptdevelopt} = "develop";
# ptlistssymb
    $Awfif::symbolsets-> {meta}{lists} = "ptlistst";
    $Awfif::symbolsets-> {imeta}{ptlistst} = "lists";
# ptpdcacompletesymb
    $Awfif::symbolsets-> {meta}{pdcacomplete} = "ptpdcacompletet";
    $Awfif::symbolsets-> {imeta}{ptpdcacompletet} = "pdcacomplete";
    $Awfif::symbolsets-> {meta}{attribs} = "ptattribst";
    $Awfif::symbolsets-> {imeta}{ptattribst} = "attribs";
    $Awfif::symbolsets-> {meta}{attribe} = "ptattribet";
    $Awfif::symbolsets-> {imeta}{ptattribet} = "attribe";
    $Awfif::symbolsets-> {meta}{salience} = "ptsaliencet";
    $Awfif::symbolsets-> {imeta}{ptsaliencet} = "salience";
    $Awfif::symbolsets-> {meta}{threshold} = "ptthresholdt";
    $Awfif::symbolsets-> {imeta}{ptthresholdt} = "threshold";
    $Awfif::symbolsets-> {meta}{telomericst} = "telstring";
    $Awfif::symbolsets-> {imeta}{telstring} = "telomericst";
    $Awfif::symbolsets-> {meta}{telomericsp} = "/telstring";
    $Awfif::symbolsets-> {imeta}{'/telstring'} = "telomericsp";
    $Awfif::symbolsets-> {meta}{wind} = "ptwindt";
    $Awfif::symbolsets-> {imeta}{ptwindt} = "wind";
    $Awfif::symbolsets-> {meta}{unwind} = "ptunwindt";
    $Awfif::symbolsets-> {imeta}{ptunwindt} = "unwind";
    $Awfif::symbolsets-> {meta}{jhlabel} = "ptjhlabelt";
    $Awfif::symbolsets-> {imeta}{ptjhlabelt} = "jhlabel";
    $Awfif::symbolsets-> {meta}{process} = "ttprocesst";
    $Awfif::symbolsets-> {imeta}{ttprocesst} = "process";
    $Awfif::symbolsets-> {meta}{development} = "ttdevelopmentt";
    $Awfif::symbolsets-> {imeta}{ttdevelopmentt} = "development";
    $Awfif::symbolsets-> {meta}{sequence} = "ttsequencet";
    $Awfif::symbolsets-> {imeta}{ttsequencet} = "sequence";
    $Awfif::symbolsets-> {meta}{integration} = "ttintegrationt";
    $Awfif::symbolsets-> {imeta}{ttintegrationt} = "integration";
    $Awfif::symbolsets-> {meta}{resolved} = "ttresolvedt";
    $Awfif::symbolsets-> {imeta}{ttresolvedt} = "resolved";
# ttchecksymb
    $Awfif::symbolsets-> {meta}{check} = "ttcheckt";
    $Awfif::symbolsets-> {imeta}{ttcheckt} = "check";
# ptslocsymb
    $Awfif::symbolsets-> {meta}{sloc} = "ptsloct";
    $Awfif::symbolsets-> {imeta}{ptsloct} = "sloc";
    $Awfif::symbolsets-> {meta}{resource} = "ttresourcet";
    $Awfif::symbolsets-> {imeta}{ttresourcet} = "resource";
    $Awfif::symbolsets-> {meta}{valid} = "ptvalidt";
    $Awfif::symbolsets-> {imeta}{ptvalidt} = "valid";
    $Awfif::symbolsets-> {meta}{ivariable} = "ptvart";
    $Awfif::symbolsets-> {imeta}{ptvart} = "ivariable";
    $Awfif::symbolsets-> {meta}{mcvariable} = "ptmcvart";
    $Awfif::symbolsets-> {imeta}{ptmcvart} = "mcvariable";
    $Awfif::symbolsets-> {meta}{sprevious} = "ptsprevioust";
    $Awfif::symbolsets-> {imeta}{ptsprevioust} = "sprevious";
    $Awfif::symbolsets-> {meta}{tsubsequent} = "pttsubsequentt";
    $Awfif::symbolsets-> {imeta}{pttsubsequentt} = "tsubsequent";
    $Awfif::symbolsets-> {meta}{href} = "tthreft";
    $Awfif::symbolsets-> {imeta}{tthreft} = "href";
    $Awfif::symbolsets-> {meta}{hname} = "tthnamet";
    $Awfif::symbolsets-> {imeta}{tthnamet} = "hname";
    $Awfif::symbolsets-> {meta}{includest} = "ptincludestt";
    $Awfif::symbolsets-> {imeta}{ptincludestt} = "includest";
    $Awfif::symbolsets-> {meta}{mmerge} = "ttmmerget";
    $Awfif::symbolsets-> {imeta}{ttmmerget} = "mmerge";
    $Awfif::symbolsets-> {meta}{mreplaces} = "ptmreplacest";
    $Awfif::symbolsets-> {imeta}{ptmreplacest} = "mreplaces";
    $Awfif::symbolsets-> {meta}{mcharbuffer} = "ptbscmsget";
    $Awfif::symbolsets-> {imeta}{ptbscmsget} = "mcharbuffer";
    $Awfif::symbolsets-> {meta}{mcomment} = "ptmcommentt";
    $Awfif::symbolsets-> {imeta}{ptmcommentt} = "mcomment";
# $Awfif::symbolsets-> {meta}{comments} = "comment";
# $Awfif::symbolsets-> {imeta}{'comment'} = "comments";
# $Awfif::symbolsets-> {meta}{commente} = "/comment";
# $Awfif::symbolsets-> {imeta}{'/comment'} = "commente";
    $Awfif::symbolsets-> {meta}{deploy} = "ptdeployt";
    $Awfif::symbolsets-> {imeta}{ptdeployt} = "deploy";
    $Awfif::symbolsets-> {meta}{each} = "pteacht";
    $Awfif::symbolsets-> {imeta}{pteacht} = "each";
    $Awfif::symbolsets-> {meta}{typedinstance} = "pttypedinstancet";
    $Awfif::symbolsets-> {imeta}{pttypedinstancet} = "typedinstance";
    $Awfif::symbolsets-> {meta}{statement} = "ttstatementt";
    $Awfif::symbolsets-> {imeta}{ttstatementt} = "statement";
    $Awfif::symbolsets-> {meta}{implement} = "ttimplementt";
    $Awfif::symbolsets-> {imeta}{ttimplementt} = "implement";
    $Awfif::symbolsets-> {meta}{requires} = "ttrequirest";
    $Awfif::symbolsets-> {imeta}{ttrequirest} = "requires";
    $Awfif::symbolsets-> {meta}{conditional} = "ttconditionalt";
    $Awfif::symbolsets-> {imeta}{ttconditionalt} = "conditional";
    $Awfif::symbolsets-> {meta}{operation} = "ttoperationt";
    $Awfif::symbolsets-> {imeta}{ttoperationt} = "operation";
# ptlablistsymb
# place to add lablist if becomes hi priority
    $Awfif::symbolsets-> {meta}{rhlpush} = "ptpusht";
    $Awfif::symbolsets-> {imeta}{ptpusht} = "rhlpush";
    $Awfif::symbolsets-> {meta}{rhlpop} = "ptpopt";
    $Awfif::symbolsets-> {imeta}{ptpopt} = "rhlpop";
    $Awfif::symbolsets-> {meta}{referenced} = "ttreferencedt";
    $Awfif::symbolsets-> {imeta}{ttreferencedt} = "referenced";
    $Awfif::symbolsets-> {meta}{streams} = "ttstreamst";
    $Awfif::symbolsets-> {imeta}{ttstreamst} = "streams";
    $Awfif::symbolsets-> {meta}{specified} = "ttspecifiedt";
    $Awfif::symbolsets-> {imeta}{ttspecifiedt} = "specified";
    $Awfif::symbolsets-> {meta}{single} = "ttsinglet";
    $Awfif::symbolsets-> {imeta}{ttsinglet} = "single";
    $Awfif::symbolsets-> {meta}{multiple} = "ttmultiplet";
    $Awfif::symbolsets-> {imeta}{ttmultiplet} = "multiple";
    $Awfif::symbolsets-> {meta}{iterator} = "ttiteratort";
    $Awfif::symbolsets-> {imeta}{ttiteratort} = "iterator";
    $Awfif::symbolsets-> {meta}{groupcomplete} = "ttgroupcompt";
    $Awfif::symbolsets-> {imeta}{ttgroupcompt} = "groupcomplete";
    $Awfif::symbolsets-> {meta}{groupvalid} = "ttgroupvalt";
    $Awfif::symbolsets-> {imeta}{ttgroupvalt} = "groupvalid";
    $Awfif::symbolsets-> {meta}{mcgroupvalid} = "ttmcgvalt";
    $Awfif::symbolsets-> {imeta}{ttmcgvalt} = "mcgroupvalid";
#<!-- end tag sys -->

#
# codeletbindings
# process the testing parameters
    $Awfif::memes-> {bh}{"matchstring1b"} = *Awfif::matchstring1{CODE};
    $Awfif::memes-> {bh}{"matchstring1a"} = *Awfif::matchstring1a{CODE};
    $Awfif::memes-> {bh}{"matchstring2b"} = *Awfif::matchstring2{CODE};
    $Awfif::memes-> {bh}{"matchstring2a"} = *Awfif::matchstring2a{CODE};
    $Awfif::memes-> {bh}{"matchstring3b"} = *Awfif::matchstring3{CODE};
    $Awfif::memes-> {bh}{"matchstring3a"} = *Awfif::matchstring3a{CODE};
    $Awfif::memes-> {binds}{"matchstring1"} = $Awfif::memes-> {bh}{"matchstring1a"};
    $Awfif::memes-> {binds}{"matchstring2"} = $Awfif::memes-> {bh}{"matchstring2a"};
    $Awfif::memes-> {binds}{"matchstring3"} = $Awfif::memes-> {bh}{"matchstring3a"};
    $Awfif::memes-> {bh}{"bondbuilder1"} = *Awfif::bondbuilder1{CODE};
    $Awfif::memes-> {bh}{"groupbuilder1"} = *Awfif::groupbuilder1{CODE};
    $Awfif::memes-> {bh}{"partbuilder1"} = *Awfif::partbuilder1{CODE};
    $Awfif::memes-> {bh}{"pmmanbuilder1"} = *Awfif::pmmanbuilder1{CODE};
    $Awfif::memes-> {bh}{"statementbuilder1"} = *Awfif::statementbuilder1{CODE};
    $Awfif::memes-> {bh}{"destructionbuilder1"} = *Awfif::destructionbuilder1{CODE};
    $Awfif::memes-> {bh}{"bondscout1"} = *Awfif::bondscout1{CODE};
    $Awfif::memes-> {bh}{"tnuclabgscout1"} = *Awfif::tnuclabgscout1{CODE};
    $Awfif::memes-> {bh}{"tnuclabgscout2"} = *Awfif::tnuclabgscout2{CODE};
    $Awfif::memes-> {bh}{"nuclabgevaluator1"} = *Awfif::nuclabgevaluator1{CODE};
    $Awfif::memes-> {bh}{"nuclabgbuilder1"} = *Awfif::nuclabgbuilder1{CODE};
    $Awfif::memes-> {bh}{"tnsdepscout1"} = *Awfif::tnsdepscout1{CODE};
    $Awfif::memes-> {bh}{"nsdepevaluator1"} = *Awfif::nsdepevaluator1{CODE};
    $Awfif::memes-> {bh}{"nsdepbuilder1"} = *Awfif::nsdepbuilder1{CODE};
    $Awfif::memes-> {bh}{"tnuclabmscout1"} = *Awfif::tnuclabmscout1{CODE};
    $Awfif::memes-> {bh}{"nuclabmevaluator1"} = *Awfif::nuclabmevaluator1{CODE};
    $Awfif::memes-> {bh}{"nuclabmbuilder1"} = *Awfif::nuclabmbuilder1{CODE};
    $Awfif::memes-> {bh}{"groupscout1"} = *Awfif::groupscout1{CODE};
    $Awfif::memes-> {bh}{"partscout1"} = *Awfif::partscout1{CODE};
    $Awfif::memes-> {bh}{"tpmmanscout1"} = *Awfif::tpmmanscout1{CODE};
    $Awfif::memes-> {bh}{"statementscout1"} = *Awfif::statementscout1{CODE};
    $Awfif::memes-> {bh}{"destructionscout1"} = *Awfif::destructionscout1{CODE};
    $Awfif::memes-> {bh}{"bubond1"} = *Awfif::bubond1{CODE};
    $Awfif::memes-> {bh}{"bugroup1"} = *Awfif::bugroup1{CODE};
    $Awfif::memes-> {bh}{"bustatement1"} = *Awfif::bustatement1{CODE};
    $Awfif::memes-> {bh}{"budevelopment1"} = *Awfif::budevelopment1{CODE};
    $Awfif::memes-> {bh}{"tdgroup1"} = *Awfif::tdgroup1{CODE};
    $Awfif::memes-> {bh}{"bondevaluator1"} = *Awfif::bondevaluator1{CODE};
    $Awfif::memes-> {bh}{"groupevaluator1"} = *Awfif::groupevaluator1{CODE};
    $Awfif::memes-> {bh}{"statementevaluator1"} = *Awfif::statementevaluator1{CODE};
    $Awfif::memes-> {bh}{"destructionevaluator1"} = *Awfif::destructionevaluator1{CODE};
    $Awfif::memes-> {bh}{"partevaluator1"} = *Awfif::partevaluator1{CODE};
    $Awfif::memes-> {bh}{"pmmanevaluator1"} = *Awfif::pmmanevaluator1{CODE};
    $Awfif::memes-> {bh}{"growthevaluator1"} = *Awfif::growthevaluator1{CODE};
    $Awfif::memes-> {bh}{"misevaluator1"} = *Awfif::misevaluator1{CODE};
    $Awfif::memes-> {bh}{"mdvevaluator1"} = *Awfif::mdvevaluator1{CODE};
    $Awfif::memes-> {bh}{"budesc1"} = *Awfif::budesc1{CODE};
    $Awfif::memes-> {bh}{"budescl1"} = *Awfif::budescl1{CODE};
    $Awfif::memes-> {bh}{"goalsupp1"} = *Awfif::goalsupp1{CODE};
    $Awfif::memes-> {bh}{"descbuilder1"} = *Awfif::descbuilder1{CODE};
    $Awfif::memes-> {bh}{"descscout1"} = *Awfif::descscout1{CODE};
    $Awfif::memes-> {bh}{"descevaluator1"} = *Awfif::descevaluator1{CODE};
    $Awfif::memes-> {bh}{"relbuilder1"} = *Awfif::relbuilder1{CODE};
    $Awfif::memes-> {bh}{"relevaluator1"} = *Awfif::relevaluator1{CODE};
    $Awfif::memes-> {bh}{"tbondscout1"} = *Awfif::tbondscout1{CODE};
    $Awfif::memes-> {bh}{"tdescscout1"} = *Awfif::tdescscout1{CODE};
    $Awfif::memes-> {bh}{"tgroupscout1"} = *Awfif::tgroupscout1{CODE};
    $Awfif::memes-> {bh}{"tcasescout1"} = *Awfif::tcasescout1{CODE};
    $Awfif::memes-> {bh}{"tstreamscout1"} = *Awfif::tstreamscout1{CODE};
    $Awfif::memes-> {bh}{"tgoalscout1"} = *Awfif::tgoalscout1{CODE};
    $Awfif::memes-> {bh}{"goalevaluator1"} = *Awfif::goalevaluator1{CODE};
    $Awfif::memes-> {bh}{"goalbuilder1"} = *Awfif::goalbuilder1{CODE};
    $Awfif::memes-> {bh}{"tmodelscout1"} = *Awfif::tmodelscout1{CODE};
    $Awfif::memes-> {bh}{"modelevaluator1"} = *Awfif::modelevaluator1{CODE};
    $Awfif::memes-> {bh}{"modelbuilder1"} = *Awfif::modelbuilder1{CODE};
    $Awfif::memes-> {bh}{"msalthrevaluator1"} = *Awfif::msalthrevaluator1{CODE};
    $Awfif::memes-> {bh}{"msalthrbuilder1"} = *Awfif::msalthrbuilder1{CODE};
    $Awfif::memes-> {bh}{"mittarevaluator1"} = *Awfif::mittarevaluator1{CODE};
    $Awfif::memes-> {bh}{"mittarbuilder1"} = *Awfif::mittarbuilder1{CODE};
    $Awfif::memes-> {bh}{"mwstaevaluator1"} = *Awfif::mwstaevaluator1{CODE};
    $Awfif::memes-> {bh}{"mwstabuilder1"} = *Awfif::mwstabuilder1{CODE};
    $Awfif::memes-> {bh}{"mwstdevaluator1"} = *Awfif::mwstdevaluator1{CODE};
    $Awfif::memes-> {bh}{"mwstdbuilder1"} = *Awfif::mwstdbuilder1{CODE};
    $Awfif::memes-> {bh}{"slocevaluator1"} = *Awfif::slocevaluator1{CODE};
    $Awfif::memes-> {bh}{"slocbsmodeler1"} = *Awfif::slocbsmodeler1{CODE};
    $Awfif::memes-> {bh}{"slocbuilder1"} = *Awfif::slocbuilder1{CODE};
    $Awfif::memes-> {bh}{"slistkwevaluator1"} = *Awfif::slistkwevaluator1{CODE};
    $Awfif::memes-> {bh}{"islistkwevaluator1"} = *Awfif::islistkwevaluator1{CODE};
    $Awfif::memes-> {bh}{"slistkwbuilder1"} = *Awfif::slistkwbuilder1{CODE};
    $Awfif::memes-> {bh}{"endrcdkwevaluator1"} = *Awfif::endrcdkwevaluator1{CODE};
    $Awfif::memes-> {bh}{"iendrcdkwevaluator1"} = *Awfif::iendrcdkwevaluator1{CODE};
    $Awfif::memes-> {bh}{"endrcdkwbsmodeler1"} = *Awfif::endrcdkwbsmodeler1{CODE};
    $Awfif::memes-> {bh}{"endrcdkwbuilder1"} = *Awfif::endrcdkwbuilder1{CODE};
    $Awfif::memes-> {bh}{"endlistkwevaluator1"} = *Awfif::endlistkwevaluator1{CODE};
    $Awfif::memes-> {bh}{"iendlistkwevaluator1"} = *Awfif::iendlistkwevaluator1{CODE};
    $Awfif::memes-> {bh}{"endlistkwbsmodeler1"} = *Awfif::endlistkwbsmodeler1{CODE};
    $Awfif::memes-> {bh}{"endlistkwbuilder1"} = *Awfif::endlistkwbuilder1{CODE};
    $Awfif::memes-> {bh}{"dcrdoslistevaluator1"} = *Awfif::dcrdoslistevaluator1{CODE};
    $Awfif::memes-> {bh}{"idcrdoslistevaluator1"} = *Awfif::idcrdoslistevaluator1{CODE};
    $Awfif::memes-> {bh}{"dcrdoslistbsmodeler1"} = *Awfif::dcrdoslistbsmodeler1{CODE};
    $Awfif::memes-> {bh}{"dcrdoslistbuilder1"} = *Awfif::dcrdoslistbuilder1{CODE};
    $Awfif::memes-> {bh}{"dcrdononrecevaluator1"} = *Awfif::dcrdononrecevaluator1{CODE};
    $Awfif::memes-> {bh}{"idcrdononrecevaluator1"} = *Awfif::idcrdononrecevaluator1{CODE};
    $Awfif::memes-> {bh}{"dcrdononrecbsmodeler1"} = *Awfif::dcrdononrecbsmodeler1{CODE};
    $Awfif::memes-> {bh}{"dcrdononrecbuilder1"} = *Awfif::dcrdononrecbuilder1{CODE};
    $Awfif::memes-> {bh}{"dcrdoncasedescevaluator1"}= *Awfif::dcrdoncasedescevaluator1{CODE};
    $Awfif::memes-> {bh}{"idcrdoncasedescevaluator1"}= *Awfif::idcrdoncasedescevaluator1{CODE};
    $Awfif::memes-> {bh}{"dcrdoncasedescbsmodeler1"}= *Awfif::dcrdoncasedescbsmodeler1{CODE};
    $Awfif::memes-> {bh}{"dcrdoncasedescbuilder1"} = *Awfif::dcrdoncasedescbuilder1{CODE};
    $Awfif::memes-> {bh}{"dcrdocasedescevaluator1"} = *Awfif::dcrdocasedescevaluator1{CODE};
    $Awfif::memes-> {bh}{"idcrdocasedescevaluator1"}= *Awfif::idcrdocasedescevaluator1{CODE};
    $Awfif::memes-> {bh}{"dcrdocasedescbsmodeler1"} = *Awfif::dcrdocasedescbsmodeler1{CODE};
    $Awfif::memes-> {bh}{"dcrdocasedescbuilder1"} = *Awfif::dcrdocasedescbuilder1{CODE};
    $Awfif::memes-> {bh}{"dcrdogowithinevaluator1"} = *Awfif::dcrdogowithinevaluator1{CODE};
    $Awfif::memes-> {bh}{"idcrdogowithinevaluator1"}= *Awfif::idcrdogowithinevaluator1{CODE};
    $Awfif::memes-> {bh}{"dcrdogowithinbsmodeler1"} = *Awfif::dcrdogowithinbsmodeler1{CODE};
    $Awfif::memes-> {bh}{"dcrdogowithinbuilder1"} = *Awfif::dcrdogowithinbuilder1{CODE};
    $Awfif::memes-> {bh}{"dcrdosrecordevaluator1"} = *Awfif::dcrdosrecordevaluator1{CODE};
    $Awfif::memes-> {bh}{"idcrdosrecordevaluator1"}= *Awfif::idcrdosrecordevaluator1{CODE};
    $Awfif::memes-> {bh}{"dcrdosrecordbsmodeler1"} = *Awfif::dcrdosrecordbsmodeler1{CODE};
    $Awfif::memes-> {bh}{"dcrdosrecordbuilder1"} = *Awfif::dcrdosrecordbuilder1{CODE};
    $Awfif::memes-> {bh}{"seltstevaluator1"} = *Awfif::seltstevaluator1{CODE};
    $Awfif::memes-> {bh}{"seltstbsmodeler1"} = *Awfif::seltstbsmodeler1{CODE};
    $Awfif::memes-> {bh}{"seltstbuilder1"} = *Awfif::seltstbuilder1{CODE};
    $Awfif::memes-> {bh}{"ivalwevaluator1"} = *Awfif::ivalwevaluator1{CODE};
    $Awfif::memes-> {bh}{"iivalevaluator1"} = *Awfif::iivalevaluator1{CODE};
    $Awfif::memes-> {bh}{"ivalwbsmodeler1"} = *Awfif::ivalwbsmodeler1{CODE};
    $Awfif::memes-> {bh}{"ivalwbuilder1"} = *Awfif::ivalwbuilder1{CODE};
    $Awfif::memes-> {bh}{"itargevaluator1"} = *Awfif::itargevaluator1{CODE};
    $Awfif::memes-> {bh}{"itargbsmodeler1"} = *Awfif::itargbsmodeler1{CODE};
    $Awfif::memes-> {bh}{"itargbuilder1"} = *Awfif::itargbuilder1{CODE};
    $Awfif::memes-> {bh}{"acsaoevaluator1"} = *Awfif::acsaoevaluator1{CODE};
    $Awfif::memes-> {bh}{"iacsaoevaluator1"} = *Awfif::iacsaoevaluator1{CODE};
    $Awfif::memes-> {bh}{"acsaobsmodeler1"} = *Awfif::acsaobsmodeler1{CODE};
    $Awfif::memes-> {bh}{"acsaobuilder1"} = *Awfif::acsaobuilder1{CODE};
    $Awfif::memes-> {bh}{"cbodyevaluator1"} = *Awfif::cbodyevaluator1{CODE};
    $Awfif::memes-> {bh}{"cbodybsmodeler1"} = *Awfif::cbodybsmodeler1{CODE};
    $Awfif::memes-> {bh}{"cbodybuilder1"} = *Awfif::cbodybuilder1{CODE};
    $Awfif::memes-> {bh}{"icompdevaluator1"} = *Awfif::icompdevaluator1{CODE};
    $Awfif::memes-> {bh}{"iicompdevaluator1"} = *Awfif::iicompdevaluator1{CODE};
    $Awfif::memes-> {bh}{"icompdbsmodeler1"} = *Awfif::icompdbsmodeler1{CODE};
    $Awfif::memes-> {bh}{"icompdbuilder1"} = *Awfif::icompdbuilder1{CODE};
    $Awfif::memes-> {bh}{"msadobevaluator1"} = *Awfif::msadobevaluator1{CODE};
    $Awfif::memes-> {bh}{"msadobbuilder1"} = *Awfif::msadobbuilder1{CODE};
    $Awfif::memes-> {bh}{"dcrdoinitevaluator1"} = *Awfif::dcrdoinitevaluator1{CODE};
    $Awfif::memes-> {bh}{"idcrdoinitevaluator1"} = *Awfif::idcrdoinitevaluator1{CODE};
    $Awfif::memes-> {bh}{"dcrdoinitbuilder1"} = *Awfif::dcrdoinitbuilder1{CODE};
    $Awfif::memes-> {bh}{"crsmevaluator1"} = *Awfif::crsmevaluator1{CODE};
    $Awfif::memes-> {bh}{"icrsmevaluator1"} = *Awfif::icrsmevaluator1{CODE};
    $Awfif::memes-> {bh}{"crsmbsmodeler1"} = *Awfif::crsmbsmodeler1{CODE};
    $Awfif::memes-> {bh}{"crsmbuilder1"} = *Awfif::crsmbuilder1{CODE};
    $Awfif::memes-> {bh}{"iicrsmoxevaluator1"} = *Awfif::iicrsmoxevaluator1{CODE};
    $Awfif::memes-> {bh}{"crsmoxevaluator1"} = *Awfif::crsmoxevaluator1{CODE};
    $Awfif::memes-> {bh}{"crsmoxbsmodeler1"} = *Awfif::crsmoxbsmodeler1{CODE};
    $Awfif::memes-> {bh}{"crsmoxbuilder1"} = *Awfif::crsmoxbuilder1{CODE};
    $Awfif::memes-> {bh}{"crsmofevaluator1"} = *Awfif::crsmofevaluator1{CODE};
    $Awfif::memes-> {bh}{"crsmofbsmodeler1"} = *Awfif::crsmofbsmodeler1{CODE};
    $Awfif::memes-> {bh}{"crsmofbuilder1"} = *Awfif::crsmofbuilder1{CODE};
    $Awfif::memes-> {bh}{"crsmoievaluator1"} = *Awfif::crsmoievaluator1{CODE};
    $Awfif::memes-> {bh}{"crsmoibsmodeler1"} = *Awfif::crsmoibsmodeler1{CODE};
    $Awfif::memes-> {bh}{"crsmoibuilder1"} = *Awfif::crsmoibuilder1{CODE};
    $Awfif::memes-> {bh}{"crsmoeievaluator1"} = *Awfif::crsmoeievaluator1{CODE};
    $Awfif::memes-> {bh}{"crsmoeibsmodeler1"} = *Awfif::crsmoeibsmodeler1{CODE};
    $Awfif::memes-> {bh}{"crsmoeibuilder1"} = *Awfif::crsmoeibuilder1{CODE};
    $Awfif::memes-> {bh}{"crsmoeevaluator1"} = *Awfif::crsmoeevaluator1{CODE};
    $Awfif::memes-> {bh}{"crsmoebsmodeler1"} = *Awfif::crsmoebsmodeler1{CODE};
    $Awfif::memes-> {bh}{"crsmoebuilder1"} = *Awfif::crsmoebuilder1{CODE};
    $Awfif::memes-> {bh}{"crsmomevaluator1"} = *Awfif::crsmomevaluator1{CODE};
    $Awfif::memes-> {bh}{"crsmombsmodeler1"} = *Awfif::crsmombsmodeler1{CODE};
    $Awfif::memes-> {bh}{"crsmombuilder1"} = *Awfif::crsmombuilder1{CODE};
    $Awfif::memes-> {bh}{"crsmomeevaluator1"} = *Awfif::crsmomeevaluator1{CODE};
    $Awfif::memes-> {bh}{"crsmomebsmodeler1"} = *Awfif::crsmomebsmodeler1{CODE};
    $Awfif::memes-> {bh}{"crsmomebuilder1"} = *Awfif::crsmomebuilder1{CODE};
    $Awfif::memes-> {bh}{"bcsubpcevaluator1"} = *Awfif::bcsubpcevaluator1{CODE};
    $Awfif::memes-> {bh}{"ibcsubpcevaluator1"} = *Awfif::ibcsubpcevaluator1{CODE};
    $Awfif::memes-> {bh}{"bcsubpcbsmodeler1"} = *Awfif::bcsubpcbsmodeler1{CODE};
    $Awfif::memes-> {bh}{"bcsubpcbuilder1"} = *Awfif::bcsubpcbuilder1{CODE};
    $Awfif::memes-> {bh}{"bcsubpsevaluator1"} = *Awfif::bcsubpsevaluator1{CODE};
    $Awfif::memes-> {bh}{"ibcsubpsevaluator1"} = *Awfif::ibcsubpsevaluator1{CODE};
    $Awfif::memes-> {bh}{"bcsubpsbsmodeler1"} = *Awfif::bcsubpsbsmodeler1{CODE};
    $Awfif::memes-> {bh}{"bcsubpsbuilder1"} = *Awfif::bcsubpsbuilder1{CODE};
    $Awfif::memes-> {bh}{"csresevaluator1"} = *Awfif::csresevaluator1{CODE};
    $Awfif::memes-> {bh}{"icsresevaluator1"} = *Awfif::icsresevaluator1{CODE};
    $Awfif::memes-> {bh}{"csresbsmodeler1"} = *Awfif::csresbsmodeler1{CODE};
    $Awfif::memes-> {bh}{"csresbuilder1"} = *Awfif::csresbuilder1{CODE};
    $Awfif::memes-> {bh}{"unbindevaluator1"} = *Awfif::unbindevaluator1{CODE};
    $Awfif::memes-> {bh}{"unbindbuilder1"} = *Awfif::unbindbuilder1{CODE};
    $Awfif::memes-> {bh}{"initpdcaevaluator1"} = *Awfif::initpdcaevaluator1{CODE};
    $Awfif::memes-> {bh}{"initpdcabsmodeler1"} = *Awfif::initpdcabsmodeler1{CODE};
    $Awfif::memes-> {bh}{"initpdcabuilder1"} = *Awfif::initpdcabuilder1{CODE};
    $Awfif::memes-> {bh}{"initpdcascevaluator1"} = *Awfif::initpdcascevaluator1{CODE};
    $Awfif::memes-> {bh}{"initpdcascbsmodeler1"} = *Awfif::initpdcascbsmodeler1{CODE};
    $Awfif::memes-> {bh}{"initpdcascbuilder1"} = *Awfif::initpdcascbuilder1{CODE};
    $Awfif::memes-> {bh}{"invsupevaluator1"} = *Awfif::invsupevaluator1{CODE};
    $Awfif::memes-> {bh}{"iinvsupevaluator1"} = *Awfif::iinvsupevaluator1{CODE};
    $Awfif::memes-> {bh}{"invsupbsmodeler1"} = *Awfif::invsupbsmodeler1{CODE};
    $Awfif::memes-> {bh}{"invsupbuilder1"} = *Awfif::invsupbuilder1{CODE};
    $Awfif::memes-> {bh}{"invmodevaluator1"} = *Awfif::invmodevaluator1{CODE};
    $Awfif::memes-> {bh}{"iinvmodevaluator1"} = *Awfif::iinvmodevaluator1{CODE};
    $Awfif::memes-> {bh}{"invmodbsmodeler1"} = *Awfif::invmodbsmodeler1{CODE};
    $Awfif::memes-> {bh}{"spdcaevaluator1"} = *Awfif::spdcaevaluator1{CODE};
    $Awfif::memes-> {bh}{"spdcascevaluator1"} = *Awfif::spdcascevaluator1{CODE};
    $Awfif::memes-> {bh}{"ispdcaevaluator1"} = *Awfif::ispdcaevaluator1{CODE};
    $Awfif::memes-> {bh}{"spdcabsmodeler1"} = *Awfif::spdcabsmodeler1{CODE};
    $Awfif::memes-> {bh}{"spdcabuilder1"} = *Awfif::spdcabuilder1{CODE};
    $Awfif::memes-> {bh}{"spdcascbsmodeler1"} = *Awfif::spdcascbsmodeler1{CODE};
    $Awfif::memes-> {bh}{"spdcascbuilder1"} = *Awfif::spdcascbuilder1{CODE};
    $Awfif::memes-> {bh}{"invmodbuilder1"} = *Awfif::invmodbuilder1{CODE};
    $Awfif::memes-> {bh}{"ecycdopevaluator1"} = *Awfif::ecycdopevaluator1{CODE};
    $Awfif::memes-> {bh}{"iecycdopevaluator1"} = *Awfif::iecycdopevaluator1{CODE};
    $Awfif::memes-> {bh}{"ecycdopbsmodeler1"} = *Awfif::ecycdopbsmodeler1{CODE};
    $Awfif::memes-> {bh}{"ecycdopbuilder1"} = *Awfif::ecycdopbuilder1{CODE};
    $Awfif::memes-> {bh}{"acycchpevaluator1"} = *Awfif::acycchpevaluator1{CODE};
    $Awfif::memes-> {bh}{"iacycchpevaluator1"} = *Awfif::iacycchpevaluator1{CODE};
    $Awfif::memes-> {bh}{"acycchpbsmodeler1"} = *Awfif::acycchpbsmodeler1{CODE};
    $Awfif::memes-> {bh}{"acycchpbuilder1"} = *Awfif::acycchpbuilder1{CODE};
    $Awfif::memes-> {bh}{"bcycacpevaluator1"} = *Awfif::bcycacpevaluator1{CODE};
    $Awfif::memes-> {bh}{"ibcycacpevaluator1"} = *Awfif::ibcycacpevaluator1{CODE};
    $Awfif::memes-> {bh}{"bcycacpbsmodeler1"} = *Awfif::bcycacpbsmodeler1{CODE};
    $Awfif::memes-> {bh}{"bcycacpbuilder1"} = *Awfif::bcycacpbuilder1{CODE};
    $Awfif::memes-> {bh}{"e2ftfevaluator1"} = *Awfif::e2ftfevaluator1{CODE};
    $Awfif::memes-> {bh}{"ie2ftfevaluator1"} = *Awfif::ie2ftfevaluator1{CODE};
    $Awfif::memes-> {bh}{"e2ftfbsmodeler1"} = *Awfif::e2ftfbsmodeler1{CODE};
    $Awfif::memes-> {bh}{"e2ftfbuilder1"} = *Awfif::e2ftfbuilder1{CODE};
    $Awfif::memes-> {bh}{"prbevaluator1"} = *Awfif::prbevaluator1{CODE};
    $Awfif::memes-> {bh}{"iprbevaluator1"} = *Awfif::iprbevaluator1{CODE};
    $Awfif::memes-> {bh}{"prbbsmodeler1"} = *Awfif::prbbsmodeler1{CODE};
    $Awfif::memes-> {bh}{"prbbuilder1"} = *Awfif::prbbuilder1{CODE};
    $Awfif::memes-> {bh}{"dcycipevaluator1"} = *Awfif::dcycipevaluator1{CODE};
    $Awfif::memes-> {bh}{"idcycipevaluator1"} = *Awfif::idcycipevaluator1{CODE};
    $Awfif::memes-> {bh}{"dcycipbsmodeler1"} = *Awfif::dcycipbsmodeler1{CODE};
    $Awfif::memes-> {bh}{"dcycipbuilder1"} = *Awfif::dcycipbuilder1{CODE};
    $Awfif::memes-> {bh}{"dcyctpevaluator1"} = *Awfif::dcyctpevaluator1{CODE};
    $Awfif::memes-> {bh}{"idcyctpevaluator1"} = *Awfif::idcyctpevaluator1{CODE};
    $Awfif::memes-> {bh}{"dcyctpbsmodeler1"} = *Awfif::dcyctpbsmodeler1{CODE};
    $Awfif::memes-> {bh}{"dcyctpbuilder1"} = *Awfif::dcyctpbuilder1{CODE};
    $Awfif::memes-> {bh}{"e2finhibb1"} = *Awfif::e2finhibb1{CODE};
    $Awfif::memes-> {bh}{"tfactorb1"} = *Awfif::tfactorb1{CODE};
    $Awfif::memes-> {bh}{"receptorb1"} = *Awfif::receptorb1{CODE};
    $Awfif::memes-> {bh}{"receptorbi1"} = *Awfif::receptorbi1{CODE};
    $Awfif::memes-> {bh}{"receptorh1"} = *Awfif::receptorh1{CODE};
    $Awfif::memes-> {bh}{"warb1"} = *Awfif::warb1{CODE};
    $Awfif::memes-> {bh}{"warasb1"} = *Awfif::warasb1{CODE};
    $Awfif::memes-> {bh}{"warmab1"} = *Awfif::warmab1{CODE};
    $Awfif::memes-> {bh}{"warmsb1"} = *Awfif::warmsb1{CODE};
    $Awfif::memes-> {bh}{"warmdob1"} = *Awfif::warmdob1{CODE};
    $Awfif::memes-> {bh}{"warhdob1"} = *Awfif::warhdob1{CODE};
    $Awfif::memes-> {bh}{"vworldb1"} = *Awfif::vworldb1{CODE};
    $Awfif::memes-> {bh}{"vwxstartb1"} = *Awfif::vwxstartb1{CODE};
    $Awfif::memes-> {bh}{"vcansb1"} = *Awfif::vcansb1{CODE};
    $Awfif::memes-> {bh}{"self1"} = *Awfif::self1{CODE};
    $Awfif::memes-> {bh}{"ecyclino1"} = *Awfif::ecyclino1{CODE};
    $Awfif::memes-> {bh}{"acyclino1"} = *Awfif::acyclino1{CODE};
    $Awfif::memes-> {bh}{"bcyclino1"} = *Awfif::bcyclino1{CODE};
    $Awfif::memes-> {bh}{"dcyclino1"} = *Awfif::dcyclino1{CODE};
    $Awfif::memes-> {bh}{"cassertevaluator1"} = *Awfif::cassertevaluator1{CODE};
    $Awfif::memes-> {bh}{"icassertevaluator1"} = *Awfif::icassertevaluator1{CODE};
    $Awfif::memes-> {bh}{"cassertbsmodeler1"} = *Awfif::cassertbsmodeler1{CODE};
    $Awfif::memes-> {bh}{"cassertbuilder1"} = *Awfif::cassertbuilder1{CODE};
    $Awfif::memes-> {bh}{"desrasstevaluator1"} = *Awfif::desrasstevaluator1{CODE};
    $Awfif::memes-> {bh}{"idesrasstevaluator1"} = *Awfif::idesrasstevaluator1{CODE};
    $Awfif::memes-> {bh}{"desrasstbsmodeler1"} = *Awfif::desrasstbsmodeler1{CODE};
    $Awfif::memes-> {bh}{"desrasstbuilder1"} = *Awfif::desrasstbuilder1{CODE};
    $Awfif::memes-> {bh}{"dcrdowarsevaluator1"} = *Awfif::dcrdowarsevaluator1{CODE};
    $Awfif::memes-> {bh}{"idcrdowarsevaluator1"} = *Awfif::idcrdowarsevaluator1{CODE};
    $Awfif::memes-> {bh}{"dcrdowarsbsmodeler1"} = *Awfif::dcrdowarsbsmodeler1{CODE};
    $Awfif::memes-> {bh}{"dcrdowarsbuilder1"} = *Awfif::dcrdowarsbuilder1{CODE};
    $Awfif::memes-> {bh}{"uwarsevaluator1"} = *Awfif::uwarsevaluator1{CODE};
    $Awfif::memes-> {bh}{"iuwarsevaluator1"} = *Awfif::iuwarsevaluator1{CODE};
    $Awfif::memes-> {bh}{"uwarsbsmodeler1"} = *Awfif::uwarsbsmodeler1{CODE};
    $Awfif::memes-> {bh}{"uwarsbuilder1"} = *Awfif::uwarsbuilder1{CODE};
    $Awfif::memes-> {bh}{"lbstreamevaluator1"} = *Awfif::lbstreamevaluator1{CODE};
    $Awfif::memes-> {bh}{"ilbstreamevaluator1"} = *Awfif::ilbstreamevaluator1{CODE};
    $Awfif::memes-> {bh}{"lbstreambsmodeler1"} = *Awfif::lbstreambsmodeler1{CODE};
    $Awfif::memes-> {bh}{"lbstreambuilder1"} = *Awfif::lbstreambuilder1{CODE};
    $Awfif::memes-> {bh}{"lbstreamcompevaluator1"} = *Awfif::lbstreamcompevaluator1{CODE};
    $Awfif::memes-> {bh}{"lbstreamcompbuilder1"} = *Awfif::lbstreamcompbuilder1{CODE};
    $Awfif::memes-> {bh}{"skipwsoevaluator1"} = *Awfif::skipwsoevaluator1{CODE};
    $Awfif::memes-> {bh}{"iskipwsoevaluator1"} = *Awfif::iskipwsoevaluator1{CODE};
    $Awfif::memes-> {bh}{"skipwsobsmodeler1"} = *Awfif::skipwsobsmodeler1{CODE};
    $Awfif::memes-> {bh}{"skipwsobuilder1"} = *Awfif::skipwsobuilder1{CODE};
    $Awfif::memes-> {bh}{"srcdkwevaluator1"} = *Awfif::srcdkwevaluator1{CODE};
    $Awfif::memes-> {bh}{"isrcdkwevaluator1"} = *Awfif::isrcdkwevaluator1{CODE};
    $Awfif::memes-> {bh}{"srcdkwbsmodeler1"} = *Awfif::srcdkwbsmodeler1{CODE};
    $Awfif::memes-> {bh}{"srcdkwbuilder1"} = *Awfif::srcdkwbuilder1{CODE};
    $Awfif::memes-> {bh}{"namestevaluator1"} = *Awfif::namestevaluator1{CODE};
    $Awfif::memes-> {bh}{"inamestevaluator1"} = *Awfif::inamestevaluator1{CODE};
    $Awfif::memes-> {bh}{"namestbsmodeler1"} = *Awfif::namestbsmodeler1{CODE};
    $Awfif::memes-> {bh}{"namestbuilder1"} = *Awfif::namestbuilder1{CODE};
    $Awfif::memes-> {bh}{"schbindevaluator1"} = *Awfif::schbindevaluator1{CODE};
    $Awfif::memes-> {bh}{"schbindbsmodeler1"} = *Awfif::schbindbsmodeler1{CODE};
    $Awfif::memes-> {bh}{"schbindbuilder1"} = *Awfif::schbindbuilder1{CODE};
    $Awfif::memes-> {bh}{"devscwldevaluator1"} = *Awfif::devscwldevaluator1{CODE};
    $Awfif::memes-> {bh}{"devscwldbsmodeler1"} = *Awfif::devscwldbsmodeler1{CODE};
# devscwldbbhcode
    $Awfif::memes-> {bh}{"devscwldbuilder1"} = *Awfif::devbtwldbuilder1{CODE};
    $Awfif::memes-> {bh}{"devpcellevaluator1"} = *Awfif::devpcellevaluator1{CODE};
    $Awfif::memes-> {bh}{"devpcellbsmodeler1"} = *Awfif::devpcellbsmodeler1{CODE};
    $Awfif::memes-> {bh}{"devpcellbuilder1"} = *Awfif::devpcellbuilder1{CODE};
    $Awfif::memes-> {bh}{"devscellevaluator1"} = *Awfif::devscellevaluator1{CODE};
    $Awfif::memes-> {bh}{"devscellbsmodeler1"} = *Awfif::devscellbsmodeler1{CODE};
    $Awfif::memes-> {bh}{"devscellbuilder1"} = *Awfif::devscellbuilder1{CODE};
    $Awfif::memes-> {bh}{"devbtwldevaluator1"} = *Awfif::devbtwldevaluator1{CODE};
    $Awfif::memes-> {bh}{"devbtwldbsmodeler1"} = *Awfif::devbtwldbsmodeler1{CODE};
    $Awfif::memes-> {bh}{"devbtwldbuilder1"} = *Awfif::devbtwldbuilder1{CODE};
    $Awfif::memes-> {bh}{"devbtcnsevaluator1"} = *Awfif::devbtcnsevaluator1{CODE};
    $Awfif::memes-> {bh}{"devbtcnsbsmodeler1"} = *Awfif::devbtcnsbsmodeler1{CODE};
    $Awfif::memes-> {bh}{"devbtcnsbuilder1"} = *Awfif::devbtcnsbuilder1{CODE};
    $Awfif::memes-> {bh}{"devsccnsevaluator1"} = *Awfif::devsccnsevaluator1{CODE};
    $Awfif::memes-> {bh}{"devsccnsbsmodeler1"} = *Awfif::devsccnsbsmodeler1{CODE};
    $Awfif::memes-> {bh}{"devsccnsbuilder1"} = *Awfif::devsccnsbuilder1{CODE};
    $Awfif::memes-> {bh}{"stbindevaluator1"} = *Awfif::stbindevaluator1{CODE};
    $Awfif::memes-> {bh}{"stbindbsmodeler1"} = *Awfif::stbindbsmodeler1{CODE};
    $Awfif::memes-> {bh}{"stbindbuilder1"} = *Awfif::stbindbuilder1{CODE};
    $Awfif::memes-> {bh}{"indslocevaluator1"} = *Awfif::indslocevaluator1{CODE};
    $Awfif::memes-> {bh}{"indslocbsmodeler1"} = *Awfif::indslocbsmodeler1{CODE};
    $Awfif::memes-> {bh}{"indslocbuilder1"} = *Awfif::indslocbuilder1{CODE};
    $Awfif::memes-> {bh}{"shslocevaluator1"} = *Awfif::shslocevaluator1{CODE};
    $Awfif::memes-> {bh}{"shslocbsmodeler1"} = *Awfif::shslocbsmodeler1{CODE};
    $Awfif::memes-> {bh}{"shslocbuilder1"} = *Awfif::shslocbuilder1{CODE};
    $Awfif::memes-> {bh}{"rchpairevaluator1"} = *Awfif::rchpairevaluator1{CODE};
    $Awfif::memes-> {bh}{"rchpairbsmodeler1"} = *Awfif::rchpairbsmodeler1{CODE};
    $Awfif::memes-> {bh}{"rchpairbuilder1"} = *Awfif::rchpairbuilder1{CODE};
    $Awfif::memes-> {bh}{"ripkwmevaluator1"} = *Awfif::ripkwmevaluator1{CODE};
    $Awfif::memes-> {bh}{"ripkwmbsmodeler1"} = *Awfif::ripkwmbsmodeler1{CODE};
    $Awfif::memes-> {bh}{"ripkwmbuilder1"} = *Awfif::ripkwmbuilder1{CODE};
    $Awfif::memes-> {bh}{"rpkwmintevaluator1"} = *Awfif::rpkwmintevaluator1{CODE};
    $Awfif::memes-> {bh}{"rpkwmintbsmodeler1"} = *Awfif::rpkwmintbsmodeler1{CODE};
    $Awfif::memes-> {bh}{"rpkwmintbuilder1"} = *Awfif::rpkwmintbuilder1{CODE};
    $Awfif::memes-> {bh}{"rchpintevaluator1"} = *Awfif::rchpintevaluator1{CODE};
    $Awfif::memes-> {bh}{"rchpintbsmodeler1"} = *Awfif::rchpintbsmodeler1{CODE};
    $Awfif::memes-> {bh}{"rchpintbuilder1"} = *Awfif::rchpintbuilder1{CODE};
    $Awfif::memes-> {bh}{"mgpartevaluator1"} = *Awfif::mgpartevaluator1{CODE};
    $Awfif::memes-> {bh}{"mgpartbuilder1"} = *Awfif::mgpartbuilder1{CODE};
    $Awfif::memes-> {bh}{"msormevaluator1"} = *Awfif::msormevaluator1{CODE};
    $Awfif::memes-> {bh}{"msormbuilder1"} = *Awfif::msormbuilder1{CODE};
    $Awfif::memes-> {bh}{"msormevaluator1"} = *Awfif::msormevaluator1{CODE};
    $Awfif::memes-> {bh}{"vbtmsormevaluator1"} = *Awfif::vbtmsormevaluator1{CODE};
    $Awfif::memes-> {bh}{"vbtmsormbuilder1"} = *Awfif::vbtmsormbuilder1{CODE};
    $Awfif::memes-> {bh}{"vbtmiterevaluator1"} = *Awfif::vbtmiterevaluator1{CODE};
    $Awfif::memes-> {bh}{"miterbuilder1"} = *Awfif::miterbuilder1{CODE};
    $Awfif::memes-> {bh}{"mviintevaluator1"} = *Awfif::mviintevaluator1{CODE};
    $Awfif::memes-> {bh}{"mviintbuilder1"} = *Awfif::mviintbuilder1{CODE};
    $Awfif::memes-> {bh}{"mresddrevaluator1"} = *Awfif::mresddrevaluator1{CODE};
    $Awfif::memes-> {bh}{"mresddrbuilder1"} = *Awfif::mresddrbuilder1{CODE};
    $Awfif::memes-> {bh}{"vbtmressevaluator1"} = *Awfif::vbtmressevaluator1{CODE};
    $Awfif::memes-> {bh}{"vbtmressbuilder1"} = *Awfif::vbtmressbuilder1{CODE};
    $Awfif::memes-> {bh}{"vbtmresoevaluator1"} = *Awfif::vbtmresoevaluator1{CODE};
    $Awfif::memes-> {bh}{"vbtmresobuilder1"} = *Awfif::vbtmresobuilder1{CODE};
    $Awfif::memes-> {bh}{"mresadrevaluator1"} = *Awfif::mresadrevaluator1{CODE};
    $Awfif::memes-> {bh}{"mresadrbuilder1"} = *Awfif::mresadrbuilder1{CODE};
    $Awfif::memes-> {bh}{"mcssubevaluator1"} = *Awfif::mcssubevaluator1{CODE};
    $Awfif::memes-> {bh}{"mcssubbuilder1"} = *Awfif::mcssubbuilder1{CODE};
    $Awfif::memes-> {bh}{"mcsobevaluator1"} = *Awfif::mcsobevaluator1{CODE};
    $Awfif::memes-> {bh}{"mcsobbuilder1"} = *Awfif::mcsobbuilder1{CODE};
    $Awfif::memes-> {bh}{"mactsverbevaluator1"} = *Awfif::mactsverbevaluator1{CODE};
    $Awfif::memes-> {bh}{"mactsverbbuilder1"} = *Awfif::mactsverbbuilder1{CODE};
    $Awfif::memes-> {bh}{"mactcverbevaluator1"} = *Awfif::mactcverbevaluator1{CODE};
    $Awfif::memes-> {bh}{"mactcverbbuilder1"} = *Awfif::mactcverbbuilder1{CODE};
    $Awfif::memes-> {bh}{"vbtmactsverbevaluator1"} = *Awfif::vbtmactsverbevaluator1{CODE};
    $Awfif::memes-> {bh}{"vbtmactsverbbuilder1"} = *Awfif::vbtmactsverbbuilder1{CODE};
    $Awfif::memes-> {bh}{"mmcrevaluator1"} = *Awfif::mmcrevaluator1{CODE};
    $Awfif::memes-> {bh}{"mmcrbuilder1"} = *Awfif::mmcrbuilder1{CODE};
    $Awfif::memes-> {bh}{"mmctevaluator1"} = *Awfif::mmctevaluator1{CODE};
    $Awfif::memes-> {bh}{"mmctbuilder1"} = *Awfif::mmctbuilder1{CODE};
    $Awfif::memes-> {bh}{"mmcvevaluator1"} = *Awfif::mmcvevaluator1{CODE};
    $Awfif::memes-> {bh}{"mmcvbuilder1"} = *Awfif::mmcvbuilder1{CODE};
    $Awfif::memes-> {bh}{"mcspevaluator1"} = *Awfif::mcspevaluator1{CODE};
    $Awfif::memes-> {bh}{"mcspbuilder1"} = *Awfif::mcspbuilder1{CODE};
    $Awfif::memes-> {bh}{"vbtmcspevaluator1"} = *Awfif::vbtmcspevaluator1{CODE};
    $Awfif::memes-> {bh}{"vbtmcspbuilder1"} = *Awfif::vbtmcspbuilder1{CODE};
    $Awfif::memes-> {bh}{"mcvpevaluator1"} = *Awfif::mcvpevaluator1{CODE};
    $Awfif::memes-> {bh}{"mcvpbuilder1"} = *Awfif::mcvpbuilder1{CODE};
    $Awfif::memes-> {bh}{"vbtmcvpevaluator1"} = *Awfif::vbtmcvpevaluator1{CODE};
    $Awfif::memes-> {bh}{"vbtmcvpbuilder1"} = *Awfif::vbtmcvpbuilder1{CODE};
    $Awfif::memes-> {bh}{"mcopevaluator1"} = *Awfif::mcopevaluator1{CODE};
    $Awfif::memes-> {bh}{"mcopbuilder1"} = *Awfif::mcopbuilder1{CODE};
    $Awfif::memes-> {bh}{"vbtmcopevaluator1"} = *Awfif::vbtmcopevaluator1{CODE};
    $Awfif::memes-> {bh}{"vbtmcopbuilder1"} = *Awfif::vbtmcopbuilder1{CODE};
    $Awfif::memes-> {bh}{"lbevaluator1"} = *Awfif::lbevaluator1{CODE};
    $Awfif::memes-> {bh}{"lbinhibitor1"} = *Awfif::lbinhibitor1{CODE};
    $Awfif::memes-> {bh}{"msaoevaluator1"} = *Awfif::msaoevaluator1{CODE};
    $Awfif::memes-> {bh}{"msaobsmodeler1"} = *Awfif::msaobsmodeler1{CODE};
    $Awfif::memes-> {bh}{"msiopevaluator1"} = *Awfif::msiopevaluator1{CODE};
    $Awfif::memes-> {bh}{"msiopbsmodeler1"} = *Awfif::msiopbsmodeler1{CODE};
    $Awfif::memes-> {bh}{"msiopinhibitor1"} = *Awfif::msiopinhibitor1{CODE};
    $Awfif::memes-> {bh}{"vbtiopevaluator1"} = *Awfif::vbtiopevaluator1{CODE};
    $Awfif::memes-> {bh}{"vbtiopbsmodeler1"} = *Awfif::vbtiopbsmodeler1{CODE};
    $Awfif::memes-> {bh}{"vbtiopinhibitor1"} = *Awfif::vbtiopinhibitor1{CODE};
    $Awfif::memes-> {bh}{"devevaluator1"} = *Awfif::devevaluator1{CODE};
    $Awfif::memes-> {bh}{"devinhibitor1"} = *Awfif::devinhibitor1{CODE};
    $Awfif::memes-> {bh}{"devinspector1"} = *Awfif::devinspector1{CODE};
    $Awfif::memes-> {bh}{"vbtdevevaluator1"} = *Awfif::vbtdevevaluator1{CODE};
    $Awfif::memes-> {bh}{"vbtdevinhibitor1"} = *Awfif::vbtdevinhibitor1{CODE};
    $Awfif::memes-> {bh}{"vbtdevinspector1"} = *Awfif::vbtdevinspector1{CODE};
    $Awfif::memes-> {bh}{"vbttmevaluator1"} = *Awfif::vbttmevaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttmorevbevaluator1"} = *Awfif::vbttmorevbevaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttmoretsevaluator1"} = *Awfif::vbttmoretsevaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttmoregsevaluator1"} = *Awfif::vbttmoregsevaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom00ncevaluator1"} = *Awfif::vbttom00ncevaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom0recevaluator1"} = *Awfif::vbttom0recevaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom00c00evaluator1"} = *Awfif::vbttom00c00evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom00c00c01evaluator1"}= *Awfif::vbttom00c00c01evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom00c01evaluator1"} = *Awfif::vbttom00c01evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom00c10evaluator1"} = *Awfif::vbttom00c10evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom00c10c01evaluator1"}= *Awfif::vbttom00c10c01evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom00c10c00evaluator1"}= *Awfif::vbttom00c10c00evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom00c10c01c00evaluator1"}= *Awfif::vbttom00c10c01c00evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom01ncevaluator1"} = *Awfif::vbttom01ncevaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom01c00evaluator1"} = *Awfif::vbttom01c00evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom01c00c02evaluator1"}= *Awfif::vbttom01c00c02evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom01c00c01evaluator1"}= *Awfif::vbttom01c00c01evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom01c00c01c02evaluator1"}= *Awfif::vbttom01c00c01c02evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom01c00c01c11evaluator1"}= *Awfif::vbttom01c00c01c11evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom01c00c01c11c02evaluator1"}= *Awfif::vbttom01c00c01c11c02evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom01c00c11evaluator1"}= *Awfif::vbttom01c00c11evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom01c00c11c02evaluator1"}= *Awfif::vbttom01c00c11c02evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom01c01evaluator1"} = *Awfif::vbttom01c01evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom01c11evaluator1"} = *Awfif::vbttom01c11evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom01c01c11evaluator1"}= *Awfif::vbttom01c01c11evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom01c02evaluator1"} = *Awfif::vbttom01c02evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom01c01c02evaluator1"}= *Awfif::vbttom01c01c02evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom01c11c02evaluator1"}= *Awfif::vbttom01c11c02evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom01c01c11c02evaluator1"}= *Awfif::vbttom01c01c11c02evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom09ncevaluator1"} = *Awfif::vbttom09ncevaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom09c09evaluator1"} = *Awfif::vbttom09c09evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom09c09c08evaluator1"}= *Awfif::vbttom09c09c08evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom09c08evaluator1"} = *Awfif::vbttom09c08evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom09c19evaluator1"} = *Awfif::vbttom09c19evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom09c19c08evaluator1"}= *Awfif::vbttom09c19c08evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom09c19c09evaluator1"}= *Awfif::vbttom09c19c09evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom09c19c08c09evaluator1"}= *Awfif::vbttom09c19c08c09evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom19ncevaluator1"} = *Awfif::vbttom19ncevaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom19c09evaluator1"} = *Awfif::vbttom19c09evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom19c09c29evaluator1"}= *Awfif::vbttom19c09c29evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom19c09c19evaluator1"}= *Awfif::vbttom19c09c19evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom19c09c19c29evaluator1"}= *Awfif::vbttom19c09c19c29evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom19c09c19c18evaluator1"}= *Awfif::vbttom19c09c19c18evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom19c09c19c18c29evaluator1"}= *Awfif::vbttom19c09c19c18c29evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom19c09c18evaluator1"}= *Awfif::vbttom19c09c18evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom19c09c18c29evaluator1"}= *Awfif::vbttom19c09c18c29evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom19c19evaluator1"} = *Awfif::vbttom19c19evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom19c18evaluator1"} = *Awfif::vbttom19c18evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom19c19c18evaluator1"}= *Awfif::vbttom19c19c18evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom19c29evaluator1"} = *Awfif::vbttom19c29evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom19c19c29evaluator1"}= *Awfif::vbttom19c19c29evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom19c18c29evaluator1"}= *Awfif::vbttom19c18c29evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom19c19c18c29evaluator1"}= *Awfif::vbttom19c19c18c29evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom99ncevaluator1"} = *Awfif::vbttom99ncevaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom99c99evaluator1"} = *Awfif::vbttom99c99evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom99c99c98evaluator1"}= *Awfif::vbttom99c99c98evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom99c98evaluator1"} = *Awfif::vbttom99c98evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom99c89evaluator1"} = *Awfif::vbttom99c89evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom99c89c98evaluator1"}= *Awfif::vbttom99c89c98evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom99c89c99evaluator1"}= *Awfif::vbttom99c89c99evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom99c89c98c99evaluator1"}= *Awfif::vbttom99c89c98c99evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom90ncevaluator1"} = *Awfif::vbttom90ncevaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom90c90evaluator1"} = *Awfif::vbttom90c90evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom90c90c91evaluator1"}= *Awfif::vbttom90c90c91evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom90c91evaluator1"} = *Awfif::vbttom90c91evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom90c80evaluator1"} = *Awfif::vbttom90c80evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom90c80c91evaluator1"}= *Awfif::vbttom90c80c91evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom90c80c90evaluator1"}= *Awfif::vbttom90c80c90evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom90c80c91c90evaluator1"}= *Awfif::vbttom90c80c91c90evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom98ncevaluator1"} = *Awfif::vbttom98ncevaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom98c99evaluator1"} = *Awfif::vbttom98c99evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom98c99c97evaluator1"}= *Awfif::vbttom98c99c97evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom98c99c98evaluator1"}= *Awfif::vbttom98c99c98evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom98c99c98c97evaluator1"}= *Awfif::vbttom98c99c98c97evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom98c99c98c88evaluator1"}= *Awfif::vbttom98c99c98c88evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom98c99c98c88c97evaluator1"}= *Awfif::vbttom98c99c98c88c97evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom98c99c88evaluator1"}= *Awfif::vbttom98c99c88evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom98c99c88c97evaluator1"}= *Awfif::vbttom98c99c88c97evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom98c98evaluator1"} = *Awfif::vbttom98c98evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom98c88evaluator1"} = *Awfif::vbttom98c88evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom98c98c88evaluator1"}= *Awfif::vbttom98c98c88evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom98c97evaluator1"} = *Awfif::vbttom98c97evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom98c98c97evaluator1"}= *Awfif::vbttom98c98c97evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom98c88c97evaluator1"}= *Awfif::vbttom98c88c97evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom98c98c88c97evaluator1"}= *Awfif::vbttom98c98c88c97evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom10ncevaluator1"} = *Awfif::vbttom10ncevaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom10c20evaluator1"} = *Awfif::vbttom10c20evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom10c20c00evaluator1"}= *Awfif::vbttom10c20c00evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom10c20c10evaluator1"}= *Awfif::vbttom10c20c10evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom10c20c10c00evaluator1"}= *Awfif::vbttom10c20c10c00evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom10c20c10c11evaluator1"}= *Awfif::vbttom10c20c10c11evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom10c20c10c11c00evaluator1"}= *Awfif::vbttom10c20c10c11c00evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom10c20c11evaluator1"}= *Awfif::vbttom10c20c11evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom10c20c11c00evaluator1"}= *Awfif::vbttom10c20c11c00evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom10c10evaluator1"} = *Awfif::vbttom10c10evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom10c11evaluator1"} = *Awfif::vbttom10c11evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom10c10c11evaluator1"}= *Awfif::vbttom10c10c11evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom10c00evaluator1"} = *Awfif::vbttom10c00evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom10c10c00evaluator1"}= *Awfif::vbttom10c10c00evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom10c11c00evaluator1"}= *Awfif::vbttom10c11c00evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom10c10c11c00evaluator1"}= *Awfif::vbttom10c10c11c00evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom11ncevaluator1"} = *Awfif::vbttom11ncevaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom11c21evaluator1"} = *Awfif::vbttom11c21evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom11c21c01evaluator1"}= *Awfif::vbttom11c21c01evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom11c21c11evaluator1"}= *Awfif::vbttom11c21c11evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom11c21c11c01evaluator1"}= *Awfif::vbttom11c21c11c01evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom11c21c11c12evaluator1"}= *Awfif::vbttom11c21c11c12evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom11c21c11c12c01evaluator1"}= *Awfif::vbttom11c21c11c12c01evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom11c21c12evaluator1"}= *Awfif::vbttom11c21c12evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom11c21c12c01evaluator1"}= *Awfif::vbttom11c21c12c01evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom11c11evaluator1"} = *Awfif::vbttom11c11evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom11c12evaluator1"} = *Awfif::vbttom11c12evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom11c11c12evaluator1"}= *Awfif::vbttom11c11c12evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom11c01evaluator1"} = *Awfif::vbttom11c01evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom11c11c01evaluator1"}= *Awfif::vbttom11c11c01evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom11c12c01evaluator1"}= *Awfif::vbttom11c12c01evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom11c11c12c01evaluator1"}= *Awfif::vbttom11c11c12c01evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom11c10evaluator1"} = *Awfif::vbttom11c10evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom11c21c10evaluator1"}= *Awfif::vbttom11c21c10evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom11c21c01c10evaluator1"}= *Awfif::vbttom11c21c01c10evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom11c21c11c10evaluator1"}= *Awfif::vbttom11c21c11c10evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom11c21c11c01c10evaluator1"}= *Awfif::vbttom11c21c11c01c10evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom11c21c11c12c10evaluator1"}= *Awfif::vbttom11c21c11c12c10evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom11c21c11c12c01c10evaluator1"}= *Awfif::vbttom11c21c11c12c01c10evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom11c21c12c10evaluator1"}= *Awfif::vbttom11c21c12c10evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom11c21c12c01c10evaluator1"}= *Awfif::vbttom11c21c12c01c10evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom11c11c10evaluator1"}= *Awfif::vbttom11c11c10evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom11c12c10evaluator1"}= *Awfif::vbttom11c12c10evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom11c11c12c10evaluator1"}= *Awfif::vbttom11c11c12c10evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom11c01c10evaluator1"}= *Awfif::vbttom11c01c10evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom11c11c01c10evaluator1"}= *Awfif::vbttom11c11c01c10evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom11c12c01c10evaluator1"}= *Awfif::vbttom11c12c01c10evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttom11c11c12c01c10evaluator1"}= *Awfif::vbttom11c11c12c01c10evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttoamsevaluator1"} = *Awfif::vbttoamsevaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttoameevaluator1"} = *Awfif::vbttoameevaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttoamwevaluator1"} = *Awfif::vbttoamwevaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttoamrevaluator1"} = *Awfif::vbttoamrevaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttoapcevaluator1"} = *Awfif::vbttoapcevaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttmorevbevaluator1"} = *Awfif::ivbttmorevbevaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttmoretsevaluator1"} = *Awfif::ivbttmoretsevaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttmoregsevaluator1"} = *Awfif::ivbttmoregsevaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttoamsevaluator1"} = *Awfif::ivbttoamsevaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttoamnevaluator1"} = *Awfif::ivbttoamnevaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttoameevaluator1"} = *Awfif::ivbttoameevaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttoamwevaluator1"} = *Awfif::ivbttoamwevaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttoamrevaluator1"} = *Awfif::ivbttoamrevaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttoapcevaluator1"} = *Awfif::ivbttoapcevaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom00ncevaluator1"} = *Awfif::ivbttom00ncevaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom0recevaluator1"} = *Awfif::ivbttom0recevaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom00c00evaluator1"} = *Awfif::ivbttom00c00evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom00c00c01evaluator1"}= *Awfif::ivbttom00c00c01evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom00c01evaluator1"} = *Awfif::ivbttom00c01evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom00c10evaluator1"} = *Awfif::ivbttom00c10evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom00c10c01evaluator1"}= *Awfif::ivbttom00c10c01evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom00c10c00evaluator1"}= *Awfif::ivbttom00c10c00evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom00c10c01c00evaluator1"}= *Awfif::ivbttom00c10c01c00evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom01ncevaluator1"} = *Awfif::ivbttom01ncevaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom01c00evaluator1"} = *Awfif::ivbttom01c00evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom01c00c01evaluator1"}= *Awfif::ivbttom01c00c01evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom01c00c01c02evaluator1"}= *Awfif::ivbttom01c00c01c02evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom01c00c01c11evaluator1"}= *Awfif::ivbttom01c00c01c11evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom01c00c01c11c02evaluator1"}= *Awfif::ivbttom01c00c01c11c02evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom01c00c02evaluator1"}= *Awfif::ivbttom01c00c02evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom01c00c11evaluator1"}= *Awfif::ivbttom01c00c11evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom01c00c11c02evaluator1"}= *Awfif::ivbttom01c00c11c02evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom01c01evaluator1"} = *Awfif::ivbttom01c01evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom01c11evaluator1"} = *Awfif::ivbttom01c11evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom01c01c11evaluator1"}= *Awfif::ivbttom01c01c11evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom01c02evaluator1"} = *Awfif::ivbttom01c02evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom01c01c02evaluator1"}= *Awfif::ivbttom01c01c02evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom01c11c02evaluator1"}= *Awfif::ivbttom01c11c02evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom01c01c11c02evaluator1"}= *Awfif::ivbttom01c01c11c02evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom09ncevaluator1"} = *Awfif::ivbttom09ncevaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom09c09evaluator1"} = *Awfif::ivbttom09c09evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom09c09c08evaluator1"}= *Awfif::ivbttom09c09c08evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom09c08evaluator1"} = *Awfif::ivbttom09c08evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom09c19evaluator1"} = *Awfif::ivbttom09c19evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom09c19c08evaluator1"}= *Awfif::ivbttom09c19c08evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom09c19c09evaluator1"}= *Awfif::ivbttom09c19c09evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom09c19c08c09evaluator1"}= *Awfif::ivbttom09c19c08c09evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom19ncevaluator1"} = *Awfif::ivbttom19ncevaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom19c09evaluator1"} = *Awfif::ivbttom19c09evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom19c09c19evaluator1"}= *Awfif::ivbttom19c09c19evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom19c09c19c29evaluator1"}= *Awfif::ivbttom19c09c19c29evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom19c09c19c18evaluator1"}= *Awfif::ivbttom19c09c19c18evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom19c09c19c18c29evaluator1"}= *Awfif::ivbttom19c09c19c18c29evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom19c09c29evaluator1"}= *Awfif::ivbttom19c09c29evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom19c09c18evaluator1"}= *Awfif::ivbttom19c09c18evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom19c09c18c29evaluator1"}= *Awfif::ivbttom19c09c18c29evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom19c19evaluator1"} = *Awfif::ivbttom19c19evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom19c18evaluator1"} = *Awfif::ivbttom19c18evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom19c19c18evaluator1"}= *Awfif::ivbttom19c19c18evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom19c29evaluator1"} = *Awfif::ivbttom19c29evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom19c19c29evaluator1"}= *Awfif::ivbttom19c19c29evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom19c18c29evaluator1"}= *Awfif::ivbttom19c18c29evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom19c19c18c29evaluator1"}= *Awfif::ivbttom19c19c18c29evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom99ncevaluator1"} = *Awfif::ivbttom99ncevaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom99c99evaluator1"} = *Awfif::ivbttom99c99evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom99c99c98evaluator1"}= *Awfif::ivbttom99c99c98evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom99c98evaluator1"} = *Awfif::ivbttom99c98evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom99c89evaluator1"} = *Awfif::ivbttom99c89evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom99c89c98evaluator1"}= *Awfif::ivbttom99c89c98evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom99c89c99evaluator1"}= *Awfif::ivbttom99c89c99evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom99c89c98c99evaluator1"}= *Awfif::ivbttom99c89c98c99evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom98ncevaluator1"} = *Awfif::ivbttom98ncevaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom98c99evaluator1"} = *Awfif::ivbttom98c99evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom98c99c98evaluator1"}= *Awfif::ivbttom98c99c98evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom98c99c98c97evaluator1"}= *Awfif::ivbttom98c99c98c97evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom98c99c98c88evaluator1"}= *Awfif::ivbttom98c99c98c88evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom98c99c98c88c97evaluator1"}= *Awfif::ivbttom98c99c98c88c97evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom98c99c97evaluator1"}= *Awfif::ivbttom98c99c97evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom98c99c88evaluator1"}= *Awfif::ivbttom98c99c88evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom98c99c88c97evaluator1"}= *Awfif::ivbttom98c99c88c97evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom98c98evaluator1"} = *Awfif::ivbttom98c98evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom98c88evaluator1"} = *Awfif::ivbttom98c88evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom98c98c88evaluator1"}= *Awfif::ivbttom98c98c88evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom98c97evaluator1"} = *Awfif::ivbttom98c97evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom98c98c97evaluator1"}= *Awfif::ivbttom98c98c97evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom98c88c97evaluator1"}= *Awfif::ivbttom98c88c97evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom98c98c88c97evaluator1"}= *Awfif::ivbttom98c98c88c97evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom90ncevaluator1"} = *Awfif::ivbttom90ncevaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom90c90evaluator1"} = *Awfif::ivbttom90c90evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom90c90c91evaluator1"}= *Awfif::ivbttom90c90c91evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom90c91evaluator1"} = *Awfif::ivbttom90c91evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom90c80evaluator1"} = *Awfif::ivbttom90c80evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom90c80c91evaluator1"}= *Awfif::ivbttom90c80c91evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom90c80c90evaluator1"}= *Awfif::ivbttom90c80c90evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom90c80c91c90evaluator1"}= *Awfif::ivbttom90c80c91c90evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom10ncevaluator1"} = *Awfif::ivbttom10ncevaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom10c20evaluator1"} = *Awfif::ivbttom10c20evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom10c20c10evaluator1"}= *Awfif::ivbttom10c20c10evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom10c20c10c00evaluator1"}= *Awfif::ivbttom10c20c10c00evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom10c20c10c11evaluator1"}= *Awfif::ivbttom10c20c10c11evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom10c20c10c11c00evaluator1"}= *Awfif::ivbttom10c20c10c11c00evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom10c20c00evaluator1"}= *Awfif::ivbttom10c20c00evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom10c20c11evaluator1"}= *Awfif::ivbttom10c20c11evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom10c20c11c00evaluator1"}= *Awfif::ivbttom10c20c11c00evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom10c10evaluator1"} = *Awfif::ivbttom10c10evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom10c11evaluator1"} = *Awfif::ivbttom10c11evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom10c10c11evaluator1"}= *Awfif::ivbttom10c10c11evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom10c00evaluator1"} = *Awfif::ivbttom10c00evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom10c10c00evaluator1"}= *Awfif::ivbttom10c10c00evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom10c11c00evaluator1"}= *Awfif::ivbttom10c11c00evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom10c10c11c00evaluator1"}= *Awfif::ivbttom10c10c11c00evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom11ncevaluator1"} = *Awfif::ivbttom11ncevaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom11c21evaluator1"} = *Awfif::ivbttom11c21evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom11c21c11evaluator1"}= *Awfif::ivbttom11c21c11evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom11c21c11c01evaluator1"}= *Awfif::ivbttom11c21c11c01evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom11c21c11c12evaluator1"}= *Awfif::ivbttom11c21c11c12evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom11c21c11c12c01evaluator1"}= *Awfif::ivbttom11c21c11c12c01evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom11c21c01evaluator1"}= *Awfif::ivbttom11c21c01evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom11c21c12evaluator1"}= *Awfif::ivbttom11c21c12evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom11c21c12c01evaluator1"}= *Awfif::ivbttom11c21c12c01evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom11c11evaluator1"} = *Awfif::ivbttom11c11evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom11c12evaluator1"} = *Awfif::ivbttom11c12evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom11c11c12evaluator1"}= *Awfif::ivbttom11c11c12evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom11c01evaluator1"} = *Awfif::ivbttom11c01evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom11c11c01evaluator1"}= *Awfif::ivbttom11c11c01evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom11c12c01evaluator1"}= *Awfif::ivbttom11c12c01evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom11c11c12c01evaluator1"}= *Awfif::ivbttom11c11c12c01evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom11c10evaluator1"} = *Awfif::ivbttom11c10evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom11c21c10evaluator1"}= *Awfif::ivbttom11c21c10evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom11c21c11c10evaluator1"}= *Awfif::ivbttom11c21c11c10evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom11c21c11c01c10evaluator1"}= *Awfif::ivbttom11c21c11c01c10evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom11c21c11c12c10evaluator1"}= *Awfif::ivbttom11c21c11c12c10evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom11c21c11c12c01c10evaluator1"}= *Awfif::ivbttom11c21c11c12c01c10evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom11c21c01c10evaluator1"}= *Awfif::ivbttom11c21c01c10evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom11c21c12c10evaluator1"}= *Awfif::ivbttom11c21c12c10evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom11c21c12c01c10evaluator1"}= *Awfif::ivbttom11c21c12c01c10evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom11c11c10evaluator1"} = *Awfif::ivbttom11c11c10evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom11c12c10evaluator1"} = *Awfif::ivbttom11c12c10evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom11c11c12c10evaluator1"}= *Awfif::ivbttom11c11c12c10evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom11c01c10evaluator1"} = *Awfif::ivbttom11c01c10evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom11c11c01c10evaluator1"}= *Awfif::ivbttom11c11c01c10evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom11c12c01c10evaluator1"}= *Awfif::ivbttom11c12c01c10evaluator1{CODE};
    $Awfif::memes-> {bh}{"ivbttom11c11c12c01c10evaluator1"}= *Awfif::ivbttom11c11c12c01c10evaluator1{CODE};
    $Awfif::memes-> {bh}{"vbttoamnevaluator1"} = *Awfif::vbttoamnevaluator1{CODE};
    $Awfif::memes-> {bh}{"drevaluator1"} = *Awfif::drevaluator1{CODE};
    $Awfif::memes-> {bh}{"dcnevaluator1"} = *Awfif::dcnevaluator1{CODE};
    $Awfif::memes-> {bh}{"mkwevaluator1"} = *Awfif::mkwevaluator1{CODE};
    $Awfif::memes-> {bh}{"mkwinspector1"} = *Awfif::mkwinspector1{CODE};
    $Awfif::memes-> {bh}{"pmmaninspector1"} = *Awfif::pmmaninspector1{CODE};
    $Awfif::memes-> {bh}{"mkwbuilder1"} = *Awfif::mkwbuilder1{CODE};
    $Awfif::memes-> {bh}{"misbuilder1"} = *Awfif::misbuilder1{CODE};
    $Awfif::memes-> {bh}{"mdvbuilder1"} = *Awfif::mdvbuilder1{CODE};
    $Awfif::memes-> {bh}{"miforallevaluator1"} = *Awfif::miforallevaluator1{CODE};
    $Awfif::memes-> {bh}{"miforallinspector1"} = *Awfif::miforallinspector1{CODE};
    $Awfif::memes-> {bh}{"miforallbuilder1"} = *Awfif::miforallbuilder1{CODE};
    $Awfif::memes-> {bh}{"dassgevaluator1"} = *Awfif::dassgevaluator1{CODE};
    $Awfif::memes-> {bh}{"dassginspector1"} = *Awfif::dassginspector1{CODE};
    $Awfif::memes-> {bh}{"dassgbuilder1"} = *Awfif::dassgbuilder1{CODE};
    $Awfif::memes-> {bh}{"dascgevaluator1"} = *Awfif::dascgevaluator1{CODE};
    $Awfif::memes-> {bh}{"dascginspector1"} = *Awfif::dascginspector1{CODE};
    $Awfif::memes-> {bh}{"dascgbuilder1"} = *Awfif::dascgbuilder1{CODE};
    $Awfif::memes-> {bh}{"casesaevaluator1"} = *Awfif::casesaevaluator1{CODE};
    $Awfif::memes-> {bh}{"casesainspector1"} = *Awfif::casesainspector1{CODE};
    $Awfif::memes-> {bh}{"casesabuilder1"} = *Awfif::casesabuilder1{CODE};
    $Awfif::memes-> {bh}{"libevaluator1"} = *Awfif::libevaluator1{CODE};
    $Awfif::memes-> {bh}{"lbbuilder1"} = *Awfif::lbbuilder1{CODE};
    $Awfif::memes-> {bh}{"devbuilder1"} = *Awfif::devbuilder1{CODE};
    $Awfif::memes-> {bh}{"vbtdevbuilder1"} = *Awfif::vbtdevbuilder1{CODE};
    $Awfif::memes-> {bh}{"vbttmbuilder1"} = *Awfif::vbttmbuilder1{CODE};
    $Awfif::memes-> {bh}{"vbttmorevbbuilder1"} = *Awfif::vbttmorevbbuilder1{CODE};
    $Awfif::memes-> {bh}{"vbttmoretsbuilder1"} = *Awfif::vbttmoretsbuilder1{CODE};
    $Awfif::memes-> {bh}{"vbttmoregsbuilder1"} = *Awfif::vbttmoregsbuilder1{CODE};
    $Awfif::memes-> {bh}{"vbttom00ncbuilder1"} = *Awfif::vbttom00ncbuilder1{CODE};
    $Awfif::memes-> {bh}{"vbttom0recbuilder1"} = *Awfif::vbttom0recbuilder1{CODE};
    $Awfif::memes-> {bh}{"vbttom00c00builder1"} = *Awfif::vbttom00c00builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom00c00c01builder1"} = *Awfif::vbttom00c00c01builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom00c01builder1"} = *Awfif::vbttom00c01builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom00c10builder1"} = *Awfif::vbttom00c10builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom00c10c00builder1"} = *Awfif::vbttom00c10c00builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom00c10c01builder1"} = *Awfif::vbttom00c10c01builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom00c10c01c00builder1"}= *Awfif::vbttom00c10c01c00builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom01ncbuilder1"} = *Awfif::vbttom01ncbuilder1{CODE};
    $Awfif::memes-> {bh}{"vbttom01c00builder1"} = *Awfif::vbttom01c00builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom01c00c01builder1"}= *Awfif::vbttom01c00c01builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom01c00c01c02builder1"}= *Awfif::vbttom01c00c01c02builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom01c00c01c11builder1"}= *Awfif::vbttom01c00c01c11builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom01c00c01c11c02builder1"}= *Awfif::vbttom01c00c01c11c02builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom01c00c02builder1"} = *Awfif::vbttom01c00c02builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom01c00c11builder1"} = *Awfif::vbttom01c00c11builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom01c01builder1"} = *Awfif::vbttom01c01builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom01c11builder1"} = *Awfif::vbttom01c11builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom01c01c11builder1"} = *Awfif::vbttom01c01c11builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom01c02builder1"} = *Awfif::vbttom01c02builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom01c01c02builder1"} = *Awfif::vbttom01c01c02builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom01c11c02builder1"} = *Awfif::vbttom01c11c02builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom01c00c11c02builder1"}= *Awfif::vbttom01c00c11c02builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom01c01c11c02builder1"}= *Awfif::vbttom01c01c11c02builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom09ncbuilder1"} = *Awfif::vbttom09ncbuilder1{CODE};
    $Awfif::memes-> {bh}{"vbttom09c09builder1"} = *Awfif::vbttom09c09builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom09c09c08builder1"} = *Awfif::vbttom09c09c08builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom09c08builder1"} = *Awfif::vbttom09c08builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom09c19builder1"} = *Awfif::vbttom09c19builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom09c19c09builder1"} = *Awfif::vbttom09c19c09builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom09c19c08builder1"} = *Awfif::vbttom09c19c08builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom09c19c08c09builder1"}= *Awfif::vbttom09c19c08c09builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom19ncbuilder1"} = *Awfif::vbttom19ncbuilder1{CODE};
    $Awfif::memes-> {bh}{"vbttom19c09builder1"} = *Awfif::vbttom19c09builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom19c09c19builder1"}= *Awfif::vbttom19c09c19builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom19c09c19c29builder1"}= *Awfif::vbttom19c09c19c29builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom19c09c19c18builder1"}= *Awfif::vbttom19c09c19c18builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom19c09c19c18c29builder1"}= *Awfif::vbttom19c09c19c18c29builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom19c09c29builder1"} = *Awfif::vbttom19c09c29builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom19c09c18builder1"} = *Awfif::vbttom19c09c18builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom19c19builder1"} = *Awfif::vbttom19c19builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom19c18builder1"} = *Awfif::vbttom19c18builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom19c19c18builder1"} = *Awfif::vbttom19c19c18builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom19c29builder1"} = *Awfif::vbttom19c29builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom19c19c29builder1"} = *Awfif::vbttom19c19c29builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom19c18c29builder1"} = *Awfif::vbttom19c18c29builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom19c09c18c29builder1"}= *Awfif::vbttom19c09c18c29builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom19c19c18c29builder1"}= *Awfif::vbttom19c19c18c29builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom99ncbuilder1"} = *Awfif::vbttom99ncbuilder1{CODE};
    $Awfif::memes-> {bh}{"vbttom99c99builder1"} = *Awfif::vbttom99c99builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom99c99c98builder1"} = *Awfif::vbttom99c99c98builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom99c98builder1"} = *Awfif::vbttom99c98builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom99c89builder1"} = *Awfif::vbttom99c89builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom99c89c99builder1"} = *Awfif::vbttom99c89c99builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom99c89c98builder1"} = *Awfif::vbttom99c89c98builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom99c89c98c99builder1"}= *Awfif::vbttom99c89c98c99builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom98ncbuilder1"} = *Awfif::vbttom98ncbuilder1{CODE};
    $Awfif::memes-> {bh}{"vbttom98c99builder1"} = *Awfif::vbttom98c99builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom98c99c98builder1"}= *Awfif::vbttom98c99c98builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom98c99c98c97builder1"}= *Awfif::vbttom98c99c98c97builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom98c99c98c88builder1"}= *Awfif::vbttom98c99c98c88builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom98c99c98c88c97builder1"}= *Awfif::vbttom98c99c98c88c97builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom98c99c97builder1"} = *Awfif::vbttom98c99c97builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom98c99c88builder1"} = *Awfif::vbttom98c99c88builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom98c98builder1"} = *Awfif::vbttom98c98builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom98c88builder1"} = *Awfif::vbttom98c88builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom98c98c88builder1"} = *Awfif::vbttom98c98c88builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom98c97builder1"} = *Awfif::vbttom98c97builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom98c98c97builder1"} = *Awfif::vbttom98c98c97builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom98c88c97builder1"} = *Awfif::vbttom98c88c97builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom98c99c88c97builder1"}= *Awfif::vbttom98c99c88c97builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom98c98c88c97builder1"}= *Awfif::vbttom98c98c88c97builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom90ncbuilder1"} = *Awfif::vbttom90ncbuilder1{CODE};
    $Awfif::memes-> {bh}{"vbttom90c90builder1"} = *Awfif::vbttom90c90builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom90c90c91builder1"} = *Awfif::vbttom90c90c91builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom90c91builder1"} = *Awfif::vbttom90c91builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom90c80builder1"} = *Awfif::vbttom90c80builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom90c80c90builder1"} = *Awfif::vbttom90c80c90builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom90c80c91builder1"} = *Awfif::vbttom90c80c91builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom90c80c91c90builder1"}= *Awfif::vbttom90c80c91c90builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom10ncbuilder1"} = *Awfif::vbttom10ncbuilder1{CODE};
    $Awfif::memes-> {bh}{"vbttom10c20builder1"} = *Awfif::vbttom10c20builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom10c20c10builder1"}= *Awfif::vbttom10c20c10builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom10c20c10c00builder1"}= *Awfif::vbttom10c20c10c00builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom10c20c10c11builder1"}= *Awfif::vbttom10c20c10c11builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom10c20c10c11c00builder1"}= *Awfif::vbttom10c20c10c11c00builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom10c20c00builder1"} = *Awfif::vbttom10c20c00builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom10c20c11builder1"} = *Awfif::vbttom10c20c11builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom10c10builder1"} = *Awfif::vbttom10c10builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom10c11builder1"} = *Awfif::vbttom10c11builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom10c10c11builder1"} = *Awfif::vbttom10c10c11builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom10c00builder1"} = *Awfif::vbttom10c00builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom10c10c00builder1"} = *Awfif::vbttom10c10c00builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom10c11c00builder1"} = *Awfif::vbttom10c11c00builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom10c20c11c00builder1"}= *Awfif::vbttom10c20c11c00builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom10c10c11c00builder1"}= *Awfif::vbttom10c10c11c00builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom11ncbuilder1"} = *Awfif::vbttom11ncbuilder1{CODE};
    $Awfif::memes-> {bh}{"vbttom11c21builder1"} = *Awfif::vbttom11c21builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom11c21c11builder1"}= *Awfif::vbttom11c21c11builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom11c21c11c01builder1"}= *Awfif::vbttom11c21c11c01builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom11c21c11c12builder1"}= *Awfif::vbttom11c21c11c12builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom11c21c11c12c01builder1"}= *Awfif::vbttom11c21c11c12c01builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom11c21c01builder1"} = *Awfif::vbttom11c21c01builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom11c21c12builder1"} = *Awfif::vbttom11c21c12builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom11c11builder1"} = *Awfif::vbttom11c11builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom11c12builder1"} = *Awfif::vbttom11c12builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom11c11c12builder1"} = *Awfif::vbttom11c11c12builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom11c01builder1"} = *Awfif::vbttom11c01builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom11c11c01builder1"} = *Awfif::vbttom11c11c01builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom11c12c01builder1"} = *Awfif::vbttom11c12c01builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom11c21c12c01builder1"}= *Awfif::vbttom11c21c12c01builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom11c11c12c01builder1"}= *Awfif::vbttom11c11c12c01builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom11c10builder1"} = *Awfif::vbttom11c10builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom11c21c10builder1"} = *Awfif::vbttom11c21c10builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom11c21c11c10builder1"}= *Awfif::vbttom11c21c11c10builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom11c21c11c01c10builder1"}= *Awfif::vbttom11c21c11c01c10builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom11c21c11c12c10builder1"}= *Awfif::vbttom11c21c11c12c10builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom11c21c11c12c01c10builder1"}= *Awfif::vbttom11c21c11c12c01c10builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom11c21c01c10builder1"} = *Awfif::vbttom11c21c01c10builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom11c21c12c10builder1"} = *Awfif::vbttom11c21c12c10builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom11c11c10builder1"} = *Awfif::vbttom11c11c10builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom11c12c10builder1"} = *Awfif::vbttom11c12c10builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom11c11c12c10builder1"} = *Awfif::vbttom11c11c12c10builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom11c01c10builder1"} = *Awfif::vbttom11c01c10builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom11c11c01c10builder1"} = *Awfif::vbttom11c11c01c10builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom11c12c01c10builder1"} = *Awfif::vbttom11c12c01c10builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom11c21c12c01c10builder1"}= *Awfif::vbttom11c21c12c01c10builder1{CODE};
    $Awfif::memes-> {bh}{"vbttom11c11c12c01c10builder1"}= *Awfif::vbttom11c11c12c01c10builder1{CODE};
    $Awfif::memes-> {bh}{"vbttoamsbuilder1"} = *Awfif::vbttoamsbuilder1{CODE};
    $Awfif::memes-> {bh}{"vbttoamebuilder1"} = *Awfif::vbttoamebuilder1{CODE};
    $Awfif::memes-> {bh}{"vbttoamwbuilder1"} = *Awfif::vbttoamwbuilder1{CODE};
    $Awfif::memes-> {bh}{"vbttoamrbuilder1"} = *Awfif::vbttoamrbuilder1{CODE};
    $Awfif::memes-> {bh}{"vbttoapcbuilder1"} = *Awfif::vbttoapcbuilder1{CODE};
    $Awfif::memes-> {bh}{"vbttoamnbuilder1"} = *Awfif::vbttoamnbuilder1{CODE};
    $Awfif::memes-> {bh}{"msiopbuilder1"} = *Awfif::msiopbuilder1{CODE};
    $Awfif::memes-> {bh}{"vbtiopbuilder1"} = *Awfif::vbtiopbuilder1{CODE};
    $Awfif::memes-> {bh}{"msaobuilder1"} = *Awfif::msaobuilder1{CODE};
    $Awfif::memes-> {bh}{"drbuilder1"} = *Awfif::drbuilder1{CODE};
    $Awfif::memes-> {bh}{"dcnbuilder1"} = *Awfif::dcnbuilder1{CODE};
    $Awfif::memes-> {bh}{"libbuilder1"} = *Awfif::libbuilder1{CODE};
    $Awfif::memes-> {bh}{"tdbond1"} = *Awfif::tdbond1{CODE};
    $Awfif::memes-> {bh}{"dsortqs1"} = *Awfif::dsortqs1{CODE};
    $Awfif::memes-> {bh}{"dsortqs2"} = *Awfif::dsortqs2{CODE};
    $Awfif::memes-> {bh}{"dsortr1"} = *Awfif::dsortr1{CODE};
    $Awfif::memes-> {bh}{"padname1"} = *Awfif::padname1{CODE};
    $Awfif::memes-> {bh}{"painame1"} = *Awfif::painame1{CODE};
    $Awfif::memes-> {bh}{"statementpdcal1"} = *Awfif::statementpdcal1{CODE};
    $Awfif::memes-> {bh}{"screplicate1"} = *Awfif::screplicate1{CODE};
    $Awfif::memes-> {bh}{"statementlabel1"} = *Awfif::statementlabel1{CODE};
    $Awfif::memes-> {bh}{"alljhlsbinding1"} = *Awfif::alljhlsbinding1{CODE};
    $Awfif::memes-> {bh}{"notoporstbinding1"} = *Awfif::notoporstbinding1{CODE};
    $Awfif::memes-> {bh}{"opbinding1"} = *Awfif::opbinding1{CODE};
    $Awfif::memes-> {bh}{"onlyoporstbinding1"} = *Awfif::onlyoporstbinding1{CODE};
    $Awfif::memes-> {bh}{"specstonly1"} = *Awfif::specstonly1{CODE};
    $Awfif::memes-> {bh}{"specwsonlyopbinding1"} = *Awfif::specwsonlyopbinding1{CODE};
    $Awfif::memes-> {bh}{"wsseqstbinding1"} = *Awfif::wsseqstbinding1{CODE};
    $Awfif::memes-> {bh}{"wsseqoporstbinding1"} = *Awfif::wsseqoporstbinding1{CODE};
    $Awfif::memes-> {bh}{"specsubpstonly1"} = *Awfif::specsubpstonly1{CODE};
    $Awfif::memes-> {bh}{"goalscon1"} = *Awfif::goalscon1{CODE};
    $Awfif::memes-> {bh}{"msiopscon1"} = *Awfif::msiopscon1{CODE};
    $Awfif::memes-> {bh}{"vbtiopscon1"} = *Awfif::vbtiopscon1{CODE};
    $Awfif::memes-> {bh}{"devscon1"} = *Awfif::devscon1{CODE};
    $Awfif::memes-> {bh}{"vbtdevscon1"} = *Awfif::vbtdevscon1{CODE};
    $Awfif::memes-> {bh}{"hdoscon1"} = *Awfif::hdoscon1{CODE};
    $Awfif::memes-> {bh}{"developmentlabel1"} = *Awfif::developmentlabel1{CODE};
    $Awfif::memes-> {bh}{"mstracasetestpi1"} = *Awfif::mstracasetestpi1{CODE};
    $Awfif::memes-> {bh}{"mstraresctestpi1"} = *Awfif::mstraresctestpi1{CODE};
    $Awfif::memes-> {bh}{"pdcasappi1"} = *Awfif::pdcasappi1{CODE};
    $Awfif::memes-> {bh}{"mstrarescinitpi1"} = *Awfif::mstrarescinitpi1{CODE};
    $Awfif::memes-> {bh}{"mstranoctestpi1"} = *Awfif::mstranoctestpi1{CODE};
    $Awfif::memes-> {bh}{"mergestreamsb1"} = *Awfif::mergestreamsb1{CODE};
    $Awfif::memes-> {bh}{"mergestreamsi1"} = *Awfif::mergestreamsi1{CODE};
    $Awfif::memes-> {bh}{"developmentb1"} = *Awfif::developmentb1{CODE};
    $Awfif::memes-> {bh}{"vbtb1"} = *Awfif::vbtb1{CODE};
    $Awfif::memes-> {bh}{"vbti1"} = *Awfif::vbti1{CODE};
    $Awfif::memes-> {bh}{"hdob1"} = *Awfif::hdob1{CODE};
    $Awfif::memes-> {bh}{"hdoi1"} = *Awfif::hdoi1{CODE};
    $Awfif::memes-> {bh}{"comparestb1"} = *Awfif::comparestb1{CODE};
    $Awfif::memes-> {bh}{"comparesti1"} = *Awfif::comparesti1{CODE};
    $Awfif::memes-> {bh}{"pdcab1"} = *Awfif::pdcab1{CODE};
    $Awfif::memes-> {bh}{"imemb1"} = *Awfif::imemb1{CODE};
    $Awfif::memes-> {bh}{"developmenti1"} = *Awfif::developmenti1{CODE};
    $Awfif::memes-> {bh}{"comparest1"} = *Awfif::comparest1{CODE};
    $Awfif::memes-> {bh}{"casoppi1"} = *Awfif::casoppi1{CODE};
    $Awfif::memes-> {bh}{"msadoboppi1"} = *Awfif::msadoboppi1{CODE};
    $Awfif::memes-> {bh}{"cassuboppi1"} = *Awfif::cassuboppi1{CODE};
    $Awfif::memes-> {bh}{"casopai1"} = *Awfif::casopai1{CODE};
    $Awfif::memes-> {bh}{"binderp11"} = *Awfif::binderp11{CODE};
    $Awfif::memes-> {bh}{"binderc1"} = *Awfif::binderc1{CODE};
    $Awfif::memes-> {bh}{"binderc41"} = *Awfif::binderc41{CODE};
    $Awfif::memes-> {bh}{"binderc71"} = *Awfif::binderc71{CODE};
    $Awfif::memes-> {bh}{"binderc91"} = *Awfif::binderc91{CODE};
    $Awfif::memes-> {bh}{"binderc101"} = *Awfif::binderc101{CODE};
    $Awfif::memes-> {bh}{"binderc111"} = *Awfif::binderc111{CODE};
    $Awfif::memes-> {bh}{"binderc131"} = *Awfif::binderc131{CODE};
    $Awfif::memes-> {bh}{"binderc161"} = *Awfif::binderc161{CODE};
    $Awfif::memes-> {bh}{"binderc191"} = *Awfif::binderc191{CODE};
    $Awfif::memes-> {bh}{"bindercml1"} = *Awfif::bindercml1{CODE};
    $Awfif::memes-> {bh}{"binderrc1"} = *Awfif::binderrc1{CODE};
    $Awfif::memes-> {bh}{"bindercs1"} = *Awfif::bindercs1{CODE};
    $Awfif::memes-> {bh}{"bindercs21"} = *Awfif::bindercs21{CODE};
    $Awfif::memes-> {bh}{"bindercst1"} = *Awfif::bindercst1{CODE};
    $Awfif::memes-> {bh}{"subpc1"} = *Awfif::subpc1{CODE};
    $Awfif::memes-> {bh}{"partlabel1"} = *Awfif::partlabel1{CODE};
    $Awfif::memes-> {binds}{"bondbuilder"} = $Awfif::memes-> {bh}{"bondbuilder1"};
    $Awfif::memes-> {binds}{"groupbuilder"} = $Awfif::memes-> {bh}{"groupbuilder1"};
    $Awfif::memes-> {binds}{"partbuilder"} = $Awfif::memes-> {bh}{"partbuilder1"};
    $Awfif::memes-> {binds}{"pmmanbuilder"} = $Awfif::memes-> {bh}{"pmmanbuilder1"};
    $Awfif::memes-> {binds}{"statementbuilder"} = $Awfif::memes-> {bh}{"statementbuilder1"};
    $Awfif::memes-> {binds}{"destructionbuilder"} = $Awfif::memes-> {bh}{"destructionbuilder1"};
    $Awfif::memes-> {binds}{"bondscout"} = $Awfif::memes-> {bh}{"bondscout1"};
    $Awfif::memes-> {binds}{"groupscout"} = $Awfif::memes-> {bh}{"groupscout1"};
    $Awfif::memes-> {binds}{"partscout"} = $Awfif::memes-> {bh}{"partscout1"};
    $Awfif::memes-> {binds}{"tpmmanscout"} = $Awfif::memes-> {bh}{"tpmmanscout1"};
    $Awfif::memes-> {binds}{"statementscout"} = $Awfif::memes-> {bh}{"statementscout1"};
    $Awfif::memes-> {binds}{"destructionscout"} = $Awfif::memes-> {bh}{"destructionscout1"};
    $Awfif::memes-> {binds}{"bubond"} = $Awfif::memes-> {bh}{"bubond1"};
    $Awfif::memes-> {binds}{"bugroup"} = $Awfif::memes-> {bh}{"bugroup1"};
    $Awfif::memes-> {binds}{"bustatement"} = $Awfif::memes-> {bh}{"bustatement1"};
    $Awfif::memes-> {binds}{"budevelopment"} = $Awfif::memes-> {bh}{"budevelopment1"};
    $Awfif::memes-> {binds}{"bondevaluator"} = $Awfif::memes-> {bh}{"bondevaluator1"};
    $Awfif::memes-> {binds}{"groupevaluator"} = $Awfif::memes-> {bh}{"groupevaluator1"};
    $Awfif::memes-> {binds}{"partevaluator"} = $Awfif::memes-> {bh}{"partevaluator1"};
    $Awfif::memes-> {binds}{"pmmanevaluator"} = $Awfif::memes-> {bh}{"pmmanevaluator1"};
    $Awfif::memes-> {binds}{"statementevaluator"} = $Awfif::memes-> {bh}{"statementevaluator1"};
    $Awfif::memes-> {binds}{"destructionevaluator"} = $Awfif::memes-> {bh}{"destructionevaluator1"};
    $Awfif::memes-> {binds}{"descbuilder"} = $Awfif::memes-> {bh}{"descbuilder1"};
    $Awfif::memes-> {binds}{"budesc"} = $Awfif::memes-> {bh}{"budesc1"};
    $Awfif::memes-> {binds}{"budescl"} = $Awfif::memes-> {bh}{"budescl1"};
# mgoalsupp
    $Awfif::memes-> {binds}{"goalsupp"} = $Awfif::memes-> {bh}{"goalsupp1"};
    $Awfif::memes-> {binds}{"tddescl"} = $Awfif::memes-> {bh}{"tdbond1"};
    $Awfif::memes-> {binds}{"descscout"} = $Awfif::memes-> {bh}{"descscout1"};
    $Awfif::memes-> {binds}{"descevaluator"} = $Awfif::memes-> {bh}{"descevaluator1"};
    $Awfif::memes-> {binds}{"relbuilder"} = $Awfif::memes-> {bh}{"relbuilder1"};
    $Awfif::memes-> {binds}{"relevaluator"} = $Awfif::memes-> {bh}{"relevaluator1"};
    $Awfif::memes-> {binds}{"mittarbuilder"} = $Awfif::memes-> {bh}{"mittarbuilder1"};
    $Awfif::memes-> {binds}{"mittarevaluator"} = $Awfif::memes-> {bh}{"mittarevaluator1"};
    $Awfif::memes-> {binds}{"tbondscout"} = $Awfif::memes-> {bh}{"tbondscout1"};
    $Awfif::memes-> {binds}{"tdescscout"} = $Awfif::memes-> {bh}{"tdescscout1"};
    $Awfif::memes-> {binds}{"tgroupscout"} = $Awfif::memes-> {bh}{"tgroupscout1"};
    $Awfif::memes-> {binds}{"tcasescout"} = $Awfif::memes-> {bh}{"tcasescout1"};
    $Awfif::memes-> {binds}{"tstreamscout"} = $Awfif::memes-> {bh}{"tstreamscout1"};
    $Awfif::memes-> {binds}{"tnuclabgscout"} = $Awfif::memes-> {bh}{"tnuclabgscout2"};
    $Awfif::memes-> {binds}{"nuclabgevaluator"} = $Awfif::memes-> {bh}{"nuclabgevaluator1"};
    $Awfif::memes-> {binds}{"nuclabgbuilder"} = $Awfif::memes-> {bh}{"nuclabgbuilder1"};
    $Awfif::memes-> {binds}{"msalthrbuilder"} = $Awfif::memes-> {bh}{"msalthrbuilder1"};
    $Awfif::memes-> {binds}{"mgpartbuilder"} = $Awfif::memes-> {bh}{"mgpartbuilder1"};
    $Awfif::memes-> {binds}{"mwstabuilder"} = $Awfif::memes-> {bh}{"mwstabuilder1"};
    $Awfif::memes-> {binds}{"mwstdbuilder"} = $Awfif::memes-> {bh}{"mwstdbuilder1"};
    $Awfif::memes-> {binds}{"slocbuilder"} = $Awfif::memes-> {bh}{"slocbuilder1"};
    $Awfif::memes-> {binds}{"slistkwbuilder"} = $Awfif::memes-> {bh}{"slistkwbuilder1"};
    $Awfif::memes-> {binds}{"endrcdkwbuilder"} = $Awfif::memes-> {bh}{"endrcdkwbuilder1"};
    $Awfif::memes-> {binds}{"endlistkwbuilder"} = $Awfif::memes-> {bh}{"endlistkwbuilder1"};
    $Awfif::memes-> {binds}{"dcrdoslistbuilder"} = $Awfif::memes-> {bh}{"dcrdoslistbuilder1"};
    $Awfif::memes-> {binds}{"dcrdononrecbuilder"} = $Awfif::memes-> {bh}{"dcrdononrecbuilder1"};
    $Awfif::memes-> {binds}{"dcrdoncasedescbuilder"}= $Awfif::memes-> {bh}{"dcrdoncasedescbuilder1"};
    $Awfif::memes-> {binds}{"dcrdocasedescbuilder"} = $Awfif::memes-> {bh}{"dcrdocasedescbuilder1"};
    $Awfif::memes-> {binds}{"dcrdogowithinbuilder"} = $Awfif::memes-> {bh}{"dcrdogowithinbuilder1"};
    $Awfif::memes-> {binds}{"dcrdosrecordbuilder"} = $Awfif::memes-> {bh}{"dcrdosrecordbuilder1"};
    $Awfif::memes-> {binds}{"seltstbuilder"} = $Awfif::memes-> {bh}{"seltstbuilder1"};
    $Awfif::memes-> {binds}{"ivalwbuilder"} = $Awfif::memes-> {bh}{"ivalwbuilder1"};
    $Awfif::memes-> {binds}{"itargbuilder"} = $Awfif::memes-> {bh}{"itargbuilder1"};
    $Awfif::memes-> {binds}{"acsaobuilder"} = $Awfif::memes-> {bh}{"acsaobuilder1"};
    $Awfif::memes-> {binds}{"cbodybuilder"} = $Awfif::memes-> {bh}{"cbodybuilder1"};
    $Awfif::memes-> {binds}{"icompdbuilder"} = $Awfif::memes-> {bh}{"icompdbuilder1"};
    $Awfif::memes-> {binds}{"msadobbuilder"} = $Awfif::memes-> {bh}{"msadobbuilder1"};
    $Awfif::memes-> {binds}{"dcrdoinitbuilder"} = $Awfif::memes-> {bh}{"dcrdoinitbuilder1"};
    $Awfif::memes-> {binds}{"crsmbuilder"} = $Awfif::memes-> {bh}{"crsmbuilder1"};
    $Awfif::memes-> {binds}{"crsmoxbuilder"} = $Awfif::memes-> {bh}{"crsmoxbuilder1"};
    $Awfif::memes-> {binds}{"crsmofbuilder"} = $Awfif::memes-> {bh}{"crsmofbuilder1"};
    $Awfif::memes-> {binds}{"crsmoibuilder"} = $Awfif::memes-> {bh}{"crsmoibuilder1"};
    $Awfif::memes-> {binds}{"crsmoeibuilder"} = $Awfif::memes-> {bh}{"crsmoeibuilder1"};
    $Awfif::memes-> {binds}{"crsmoebuilder"} = $Awfif::memes-> {bh}{"crsmoebuilder1"};
    $Awfif::memes-> {binds}{"crsmombuilder"} = $Awfif::memes-> {bh}{"crsmombuilder1"};
    $Awfif::memes-> {binds}{"crsmomebuilder"} = $Awfif::memes-> {bh}{"crsmomebuilder1"};
    $Awfif::memes-> {binds}{"bcsubpcbuilder"} = $Awfif::memes-> {bh}{"bcsubpcbuilder1"};
    $Awfif::memes-> {binds}{"bcsubpsbuilder"} = $Awfif::memes-> {bh}{"bcsubpsbuilder1"};
    $Awfif::memes-> {binds}{"csresbuilder"} = $Awfif::memes-> {bh}{"csresbuilder1"};
    $Awfif::memes-> {binds}{"unbindbuilder"} = $Awfif::memes-> {bh}{"unbindbuilder1"};
    $Awfif::memes-> {binds}{"initpdcabuilder"} = $Awfif::memes-> {bh}{"initpdcabuilder1"};
    $Awfif::memes-> {binds}{"initpdcascbuilder"} = $Awfif::memes-> {bh}{"initpdcascbuilder1"};
    $Awfif::memes-> {binds}{"invsupbuilder"} = $Awfif::memes-> {bh}{"invsupbuilder1"};
    $Awfif::memes-> {binds}{"invmodbuilder"} = $Awfif::memes-> {bh}{"invmodbuilder1"};
    $Awfif::memes-> {binds}{"dcycipbuilder"} = $Awfif::memes-> {bh}{"dcycipbuilder1"};
    $Awfif::memes-> {binds}{"ecycdopbuilder"} = $Awfif::memes-> {bh}{"ecycdopbuilder1"};
    $Awfif::memes-> {binds}{"acycchpbuilder"} = $Awfif::memes-> {bh}{"acycchpbuilder1"};
    $Awfif::memes-> {binds}{"bcycacpbuilder"} = $Awfif::memes-> {bh}{"bcycacpbuilder1"};
    $Awfif::memes-> {binds}{"e2ftfbuilder"} = $Awfif::memes-> {bh}{"e2ftfbuilder1"};
    $Awfif::memes-> {binds}{"prbbuilder"} = $Awfif::memes-> {bh}{"prbbuilder1"};
    $Awfif::memes-> {binds}{"spdcabuilder"} = $Awfif::memes-> {bh}{"spdcabuilder1"};
    $Awfif::memes-> {binds}{"spdcascbuilder"} = $Awfif::memes-> {bh}{"spdcascbuilder1"};
    $Awfif::memes-> {binds}{"cassertbuilder"} = $Awfif::memes-> {bh}{"cassertbuilder1"};
    $Awfif::memes-> {binds}{"desrasstbuilder"} = $Awfif::memes-> {bh}{"desrasstbuilder1"};
    $Awfif::memes-> {binds}{"dcrdowarsbuilder"} = $Awfif::memes-> {bh}{"dcrdowarsbuilder1"};
    $Awfif::memes-> {binds}{"uwarsbuilder"} = $Awfif::memes-> {bh}{"uwarsbuilder1"};
    $Awfif::memes-> {binds}{"lbstreambuilder"} = $Awfif::memes-> {bh}{"lbstreambuilder1"};
    $Awfif::memes-> {binds}{"lbstreamcompbuilder"} = $Awfif::memes-> {bh}{"lbstreamcompbuilder1"};
    $Awfif::memes-> {binds}{"skipwsobuilder"} = $Awfif::memes-> {bh}{"skipwsobuilder1"};
    $Awfif::memes-> {binds}{"srcdkwbuilder"} = $Awfif::memes-> {bh}{"srcdkwbuilder1"};
    $Awfif::memes-> {binds}{"namestbuilder"} = $Awfif::memes-> {bh}{"namestbuilder1"};
    $Awfif::memes-> {binds}{"schbindbuilder"} = $Awfif::memes-> {bh}{"schbindbuilder1"};
    $Awfif::memes-> {binds}{"devscwldbuilder"} = $Awfif::memes-> {bh}{"devscwldbuilder1"};
    $Awfif::memes-> {binds}{"devpcellbuilder"} = $Awfif::memes-> {bh}{"devpcellbuilder1"};
    $Awfif::memes-> {binds}{"devscellbuilder"} = $Awfif::memes-> {bh}{"devscellbuilder1"};
    $Awfif::memes-> {binds}{"devbtwldbuilder"} = $Awfif::memes-> {bh}{"devbtwldbuilder1"};
    $Awfif::memes-> {binds}{"devbtcnsbuilder"} = $Awfif::memes-> {bh}{"devbtcnsbuilder1"};
    $Awfif::memes-> {binds}{"devsccnsbuilder"} = $Awfif::memes-> {bh}{"devsccnsbuilder1"};
    $Awfif::memes-> {binds}{"stbindbuilder"} = $Awfif::memes-> {bh}{"stbindbuilder1"};
    $Awfif::memes-> {binds}{"indslocbuilder"} = $Awfif::memes-> {bh}{"indslocbuilder1"};
    $Awfif::memes-> {binds}{"shslocbuilder"} = $Awfif::memes-> {bh}{"shslocbuilder1"};
    $Awfif::memes-> {binds}{"rchpairbuilder"} = $Awfif::memes-> {bh}{"rchpairbuilder1"};
    $Awfif::memes-> {binds}{"ripkwmbuilder"} = $Awfif::memes-> {bh}{"ripkwmbuilder1"};
    $Awfif::memes-> {binds}{"rpkwmintbuilder"} = $Awfif::memes-> {bh}{"rpkwmintbuilder1"};
    $Awfif::memes-> {binds}{"rchpintbuilder"} = $Awfif::memes-> {bh}{"rchpintbuilder1"};
    $Awfif::memes-> {binds}{"mresddrbuilder"} = $Awfif::memes-> {bh}{"mresddrbuilder1"};
    $Awfif::memes-> {binds}{"vbtmressbuilder"} = $Awfif::memes-> {bh}{"vbtmressbuilder1"};
    $Awfif::memes-> {binds}{"vbtmresobuilder"} = $Awfif::memes-> {bh}{"vbtmresobuilder1"};
    $Awfif::memes-> {binds}{"mcssubbuilder"} = $Awfif::memes-> {bh}{"mcssubbuilder1"};
    $Awfif::memes-> {binds}{"mcsobbuilder"} = $Awfif::memes-> {bh}{"mcsobbuilder1"};
    $Awfif::memes-> {binds}{"msormbuilder"} = $Awfif::memes-> {bh}{"msormbuilder1"};
    $Awfif::memes-> {binds}{"vbtmsormbuilder"} = $Awfif::memes-> {bh}{"vbtmsormbuilder1"};
    $Awfif::memes-> {binds}{"miterbuilder"} = $Awfif::memes-> {bh}{"miterbuilder1"};
    $Awfif::memes-> {binds}{"mviintbuilder"} = $Awfif::memes-> {bh}{"mviintbuilder1"};
    $Awfif::memes-> {binds}{"mresadrbuilder"} = $Awfif::memes-> {bh}{"mresadrbuilder1"};
    $Awfif::memes-> {binds}{"mactsverbbuilder"} = $Awfif::memes-> {bh}{"mactsverbbuilder1"};
    $Awfif::memes-> {binds}{"mactcverbbuilder"} = $Awfif::memes-> {bh}{"mactcverbbuilder1"};
    $Awfif::memes-> {binds}{"vbtmactsverbbuilder"} = $Awfif::memes-> {bh}{"vbtmactsverbbuilder1"};
    $Awfif::memes-> {binds}{"mmcrbuilder"} = $Awfif::memes-> {bh}{"mmcrbuilder1"};
    $Awfif::memes-> {binds}{"mmctbuilder"} = $Awfif::memes-> {bh}{"mmctbuilder1"};
    $Awfif::memes-> {binds}{"mmcvbuilder"} = $Awfif::memes-> {bh}{"mmcvbuilder1"};
    $Awfif::memes-> {binds}{"mcspbuilder"} = $Awfif::memes-> {bh}{"mcspbuilder1"};
    $Awfif::memes-> {binds}{"vbtmcspbuilder"} = $Awfif::memes-> {bh}{"vbtmcspbuilder1"};
    $Awfif::memes-> {binds}{"mcopbuilder"} = $Awfif::memes-> {bh}{"mcopbuilder1"};
    $Awfif::memes-> {binds}{"vbtmcopbuilder"} = $Awfif::memes-> {bh}{"vbtmcopbuilder1"};
    $Awfif::memes-> {binds}{"mcvpbuilder"} = $Awfif::memes-> {bh}{"mcvpbuilder1"};
    $Awfif::memes-> {binds}{"vbtmcvpbuilder"} = $Awfif::memes-> {bh}{"vbtmcvpbuilder1"};
    $Awfif::memes-> {binds}{"tnsdepscout"} = $Awfif::memes-> {bh}{"tnsdepscout1"};
# $Awfif::memes-> {binds}{"nsdepevaluator"} = $Awfif::memes-> {bh}{"nsdepevaluator1"};
    $Awfif::memes-> {binds}{"nsdepevaluator"} = $Awfif::memes-> {bh}{"nsdepbuilder1"};
    $Awfif::memes-> {binds}{"nsdepbuilder"} = $Awfif::memes-> {bh}{"nsdepbuilder1"};
# $Awfif::memes-> {binds}{"tnuclabmscout"} = $Awfif::memes-> {bh}{"tnuclabmscout1"};
    $Awfif::memes-> {binds}{"tnuclabmscout"} = $Awfif::memes-> {bh}{"nuclabmevaluator1"};
    $Awfif::memes-> {binds}{"nuclabmevaluator"} = $Awfif::memes-> {bh}{"nuclabmevaluator1"};
    $Awfif::memes-> {binds}{"nuclabmbuilder"} = $Awfif::memes-> {bh}{"nuclabmbuilder1"};
    $Awfif::memes-> {binds}{"misbuilder"} = $Awfif::memes-> {bh}{"misbuilder1"};
    $Awfif::memes-> {binds}{"mdvbuilder"} = $Awfif::memes-> {bh}{"mdvbuilder1"};
    $Awfif::memes-> {binds}{"mkwbuilder"} = $Awfif::memes-> {bh}{"mkwbuilder1"};
    $Awfif::memes-> {binds}{"miforallbuilder"} = $Awfif::memes-> {bh}{"miforallbuilder1"};
    $Awfif::memes-> {binds}{"dassgbuilder"} = $Awfif::memes-> {bh}{"dassgbuilder1"};
    $Awfif::memes-> {binds}{"dascgbuilder"} = $Awfif::memes-> {bh}{"dascgbuilder1"};
    $Awfif::memes-> {binds}{"casesabuilder"} = $Awfif::memes-> {bh}{"casesabuilder1"};
    $Awfif::memes-> {binds}{"tgoalscout"} = $Awfif::memes-> {bh}{"tgoalscout1"};
    $Awfif::memes-> {binds}{"goalevaluator"} = $Awfif::memes-> {bh}{"goalevaluator1"};
    $Awfif::memes-> {binds}{"goalbuilder"} = $Awfif::memes-> {bh}{"goalbuilder1"};
# $Awfif::memes-> {binds}{"tmodelscout"} = $Awfif::memes-> {bh}{"tmodelscout1"};
    $Awfif::memes-> {binds}{"tmodelscout"} = $Awfif::memes-> {bh}{"modelevaluator1"};
    $Awfif::memes-> {binds}{"modelevaluator"} = $Awfif::memes-> {bh}{"modelevaluator1"};
# $Awfif::memes-> {binds}{"modelevaluator"} = $Awfif::memes-> {bh}{"modelbuilder1"};
    $Awfif::memes-> {binds}{"modelbuilder"} = $Awfif::memes-> {bh}{"modelbuilder1"};
    $Awfif::memes-> {binds}{"dcnbuilder"} = $Awfif::memes-> {bh}{"dcnbuilder1"};
    $Awfif::memes-> {binds}{"lbbuilder"} = $Awfif::memes-> {bh}{"lbbuilder1"};
    $Awfif::memes-> {binds}{"devbuilder"} = $Awfif::memes-> {bh}{"devbuilder1"};
    $Awfif::memes-> {binds}{"vbtdevbuilder"} = $Awfif::memes-> {bh}{"vbtdevbuilder1"};
    $Awfif::memes-> {binds}{"vbttmbuilder"} = $Awfif::memes-> {bh}{"vbttmbuilder1"};
    $Awfif::memes-> {binds}{"vbttmorevbbuilder"} = $Awfif::memes-> {bh}{"vbttmorevbbuilder1"};
    $Awfif::memes-> {binds}{"vbttmoretsbuilder"} = $Awfif::memes-> {bh}{"vbttmoretsbuilder1"};
    $Awfif::memes-> {binds}{"vbttmoregsbuilder"} = $Awfif::memes-> {bh}{"vbttmoregsbuilder1"};
    $Awfif::memes-> {binds}{"vbttom00ncbuilder"} = $Awfif::memes-> {bh}{"vbttom00ncbuilder1"};
    $Awfif::memes-> {binds}{"vbttom0recbuilder"} = $Awfif::memes-> {bh}{"vbttom0recbuilder1"};
    $Awfif::memes-> {binds}{"vbttom00c00builder"} = $Awfif::memes-> {bh}{"vbttom00c00builder1"};
    $Awfif::memes-> {binds}{"vbttom00c00c01builder"}= $Awfif::memes-> {bh}{"vbttom00c00c01builder1"};
    $Awfif::memes-> {binds}{"vbttom00c01builder"} = $Awfif::memes-> {bh}{"vbttom00c01builder1"};
    $Awfif::memes-> {binds}{"vbttom00c10builder"} = $Awfif::memes-> {bh}{"vbttom00c10builder1"};
    $Awfif::memes-> {binds}{"vbttom00c10c00builder"}= $Awfif::memes-> {bh}{"vbttom00c10c00builder1"};
    $Awfif::memes-> {binds}{"vbttom00c10c01builder"}= $Awfif::memes-> {bh}{"vbttom00c10c01builder1"};
    $Awfif::memes-> {binds}{"vbttom00c10c01c00builder"}= $Awfif::memes-> {bh}{"vbttom00c10c01c00builder1"};
    $Awfif::memes-> {binds}{"vbttom01ncbuilder"} = $Awfif::memes-> {bh}{"vbttom01ncbuilder1"};
    $Awfif::memes-> {binds}{"vbttom01c00builder"} = $Awfif::memes-> {bh}{"vbttom01c00builder1"};
    $Awfif::memes-> {binds}{"vbttom01c00c01builder"}= $Awfif::memes-> {bh}{"vbttom01c00c01builder1"};
    $Awfif::memes-> {binds}{"vbttom01c00c01c02builder"}= $Awfif::memes-> {bh}{"vbttom01c00c01c02builder1"};
    $Awfif::memes-> {binds}{"vbttom01c00c01c11builder"}= $Awfif::memes-> {bh}{"vbttom01c00c01c11builder1"};
    $Awfif::memes-> {binds}{"vbttom01c00c01c11c02builder"}= $Awfif::memes-> {bh}{"vbttom01c00c01c11c02builder1"};
    $Awfif::memes-> {binds}{"vbttom01c00c02builder"}= $Awfif::memes-> {bh}{"vbttom01c00c02builder1"};
    $Awfif::memes-> {binds}{"vbttom01c00c11builder"}= $Awfif::memes-> {bh}{"vbttom01c00c11builder1"};
    $Awfif::memes-> {binds}{"vbttom01c00c11c02builder"}= $Awfif::memes-> {bh}{"vbttom01c00c11c02builder1"};
    $Awfif::memes-> {binds}{"vbttom01c01builder"} = $Awfif::memes-> {bh}{"vbttom01c01builder1"};
    $Awfif::memes-> {binds}{"vbttom01c11builder"} = $Awfif::memes-> {bh}{"vbttom01c11builder1"};
    $Awfif::memes-> {binds}{"vbttom01c01c11builder"}= $Awfif::memes-> {bh}{"vbttom01c01c11builder1"};
    $Awfif::memes-> {binds}{"vbttom01c02builder"} = $Awfif::memes-> {bh}{"vbttom01c02builder1"};
    $Awfif::memes-> {binds}{"vbttom01c01c02builder"}= $Awfif::memes-> {bh}{"vbttom01c01c02builder1"};
    $Awfif::memes-> {binds}{"vbttom01c11c02builder"}= $Awfif::memes-> {bh}{"vbttom01c11c02builder1"};
    $Awfif::memes-> {binds}{"vbttom01c01c11c02builder"}= $Awfif::memes-> {bh}{"vbttom01c01c11c02builder1"};
    $Awfif::memes-> {binds}{"vbttom09ncbuilder"} = $Awfif::memes-> {bh}{"vbttom09ncbuilder1"};
    $Awfif::memes-> {binds}{"vbttom09c09builder"} = $Awfif::memes-> {bh}{"vbttom09c09builder1"};
    $Awfif::memes-> {binds}{"vbttom09c09c08builder"}= $Awfif::memes-> {bh}{"vbttom09c09c08builder1"};
    $Awfif::memes-> {binds}{"vbttom09c08builder"} = $Awfif::memes-> {bh}{"vbttom09c08builder1"};
    $Awfif::memes-> {binds}{"vbttom09c19builder"} = $Awfif::memes-> {bh}{"vbttom09c19builder1"};
    $Awfif::memes-> {binds}{"vbttom09c19c09builder"}= $Awfif::memes-> {bh}{"vbttom09c19c09builder1"};
    $Awfif::memes-> {binds}{"vbttom09c19c08builder"}= $Awfif::memes-> {bh}{"vbttom09c19c08builder1"};
    $Awfif::memes-> {binds}{"vbttom09c19c08c09builder"}= $Awfif::memes-> {bh}{"vbttom09c19c08c09builder1"};
    $Awfif::memes-> {binds}{"vbttom19ncbuilder"} = $Awfif::memes-> {bh}{"vbttom19ncbuilder1"};
    $Awfif::memes-> {binds}{"vbttom19c09builder"} = $Awfif::memes-> {bh}{"vbttom19c09builder1"};
    $Awfif::memes-> {binds}{"vbttom19c09c19builder"}= $Awfif::memes-> {bh}{"vbttom19c09c19builder1"};
    $Awfif::memes-> {binds}{"vbttom19c09c19c29builder"}= $Awfif::memes-> {bh}{"vbttom19c09c19c29builder1"};
    $Awfif::memes-> {binds}{"vbttom19c09c19c18builder"}= $Awfif::memes-> {bh}{"vbttom19c09c19c18builder1"};
    $Awfif::memes-> {binds}{"vbttom19c09c19c18c29builder"}= $Awfif::memes-> {bh}{"vbttom19c09c19c18c29builder1"};
    $Awfif::memes-> {binds}{"vbttom19c09c29builder"}= $Awfif::memes-> {bh}{"vbttom19c09c29builder1"};
    $Awfif::memes-> {binds}{"vbttom19c09c18builder"}= $Awfif::memes-> {bh}{"vbttom19c09c18builder1"};
    $Awfif::memes-> {binds}{"vbttom19c09c18c29builder"}= $Awfif::memes-> {bh}{"vbttom19c09c18c29builder1"};
    $Awfif::memes-> {binds}{"vbttom19c19builder"} = $Awfif::memes-> {bh}{"vbttom19c19builder1"};
    $Awfif::memes-> {binds}{"vbttom19c18builder"} = $Awfif::memes-> {bh}{"vbttom19c18builder1"};
    $Awfif::memes-> {binds}{"vbttom19c19c18builder"}= $Awfif::memes-> {bh}{"vbttom19c19c18builder1"};
    $Awfif::memes-> {binds}{"vbttom19c29builder"} = $Awfif::memes-> {bh}{"vbttom19c29builder1"};
    $Awfif::memes-> {binds}{"vbttom19c19c29builder"}= $Awfif::memes-> {bh}{"vbttom19c19c29builder1"};
    $Awfif::memes-> {binds}{"vbttom19c18c29builder"}= $Awfif::memes-> {bh}{"vbttom19c18c29builder1"};
    $Awfif::memes-> {binds}{"vbttom19c19c18c29builder"}= $Awfif::memes-> {bh}{"vbttom19c19c18c29builder1"};
    $Awfif::memes-> {binds}{"vbttom99ncbuilder"} = $Awfif::memes-> {bh}{"vbttom99ncbuilder1"};
    $Awfif::memes-> {binds}{"vbttom99c99builder"} = $Awfif::memes-> {bh}{"vbttom99c99builder1"};
    $Awfif::memes-> {binds}{"vbttom99c99c98builder"}= $Awfif::memes-> {bh}{"vbttom99c99c98builder1"};
    $Awfif::memes-> {binds}{"vbttom99c98builder"} = $Awfif::memes-> {bh}{"vbttom99c98builder1"};
    $Awfif::memes-> {binds}{"vbttom99c89builder"} = $Awfif::memes-> {bh}{"vbttom99c89builder1"};
    $Awfif::memes-> {binds}{"vbttom99c89c99builder"}= $Awfif::memes-> {bh}{"vbttom99c89c99builder1"};
    $Awfif::memes-> {binds}{"vbttom99c89c98builder"}= $Awfif::memes-> {bh}{"vbttom99c89c98builder1"};
    $Awfif::memes-> {binds}{"vbttom99c89c98c99builder"}= $Awfif::memes-> {bh}{"vbttom99c89c98c99builder1"};
    $Awfif::memes-> {binds}{"vbttom98ncbuilder"} = $Awfif::memes-> {bh}{"vbttom98ncbuilder1"};
    $Awfif::memes-> {binds}{"vbttom98c99builder"} = $Awfif::memes-> {bh}{"vbttom98c99builder1"};
    $Awfif::memes-> {binds}{"vbttom98c99c98builder"}= $Awfif::memes-> {bh}{"vbttom98c99c98builder1"};
    $Awfif::memes-> {binds}{"vbttom98c99c98c97builder"}= $Awfif::memes-> {bh}{"vbttom98c99c98c97builder1"};
    $Awfif::memes-> {binds}{"vbttom98c99c98c88builder"}= $Awfif::memes-> {bh}{"vbttom98c99c98c88builder1"};
    $Awfif::memes-> {binds}{"vbttom98c99c98c88c97builder"}= $Awfif::memes-> {bh}{"vbttom98c99c98c88c97builder1"};
    $Awfif::memes-> {binds}{"vbttom98c99c97builder"}= $Awfif::memes-> {bh}{"vbttom98c99c97builder1"};
    $Awfif::memes-> {binds}{"vbttom98c99c88builder"}= $Awfif::memes-> {bh}{"vbttom98c99c88builder1"};
    $Awfif::memes-> {binds}{"vbttom98c99c88c97builder"}= $Awfif::memes-> {bh}{"vbttom98c99c88c97builder1"};
    $Awfif::memes-> {binds}{"vbttom98c98builder"} = $Awfif::memes-> {bh}{"vbttom98c98builder1"};
    $Awfif::memes-> {binds}{"vbttom98c88builder"} = $Awfif::memes-> {bh}{"vbttom98c88builder1"};
    $Awfif::memes-> {binds}{"vbttom98c98c88builder"}= $Awfif::memes-> {bh}{"vbttom98c98c88builder1"};
    $Awfif::memes-> {binds}{"vbttom98c97builder"} = $Awfif::memes-> {bh}{"vbttom98c97builder1"};
    $Awfif::memes-> {binds}{"vbttom98c98c97builder"}= $Awfif::memes-> {bh}{"vbttom98c98c97builder1"};
    $Awfif::memes-> {binds}{"vbttom98c88c97builder"}= $Awfif::memes-> {bh}{"vbttom98c88c97builder1"};
    $Awfif::memes-> {binds}{"vbttom98c98c88c97builder"}= $Awfif::memes-> {bh}{"vbttom98c98c88c97builder1"};
    $Awfif::memes-> {binds}{"vbttom90ncbuilder"} = $Awfif::memes-> {bh}{"vbttom90ncbuilder1"};
    $Awfif::memes-> {binds}{"vbttom90c90builder"} = $Awfif::memes-> {bh}{"vbttom90c90builder1"};
    $Awfif::memes-> {binds}{"vbttom90c90c91builder"}= $Awfif::memes-> {bh}{"vbttom90c90c91builder1"};
    $Awfif::memes-> {binds}{"vbttom90c91builder"} = $Awfif::memes-> {bh}{"vbttom90c91builder1"};
    $Awfif::memes-> {binds}{"vbttom90c80builder"} = $Awfif::memes-> {bh}{"vbttom90c80builder1"};
    $Awfif::memes-> {binds}{"vbttom90c80c90builder"}= $Awfif::memes-> {bh}{"vbttom90c80c90builder1"};
    $Awfif::memes-> {binds}{"vbttom90c80c91builder"}= $Awfif::memes-> {bh}{"vbttom90c80c91builder1"};
    $Awfif::memes-> {binds}{"vbttom90c80c91c90builder"}= $Awfif::memes-> {bh}{"vbttom90c80c91c90builder1"};
    $Awfif::memes-> {binds}{"vbttom10ncbuilder"} = $Awfif::memes-> {bh}{"vbttom10ncbuilder1"};
    $Awfif::memes-> {binds}{"vbttom10c20builder"} = $Awfif::memes-> {bh}{"vbttom10c20builder1"};
    $Awfif::memes-> {binds}{"vbttom10c20c10builder"}= $Awfif::memes-> {bh}{"vbttom10c20c10builder1"};
    $Awfif::memes-> {binds}{"vbttom10c20c10c00builder"}= $Awfif::memes-> {bh}{"vbttom10c20c10c00builder1"};
    $Awfif::memes-> {binds}{"vbttom10c20c10c11builder"}= $Awfif::memes-> {bh}{"vbttom10c20c10c11builder1"};
    $Awfif::memes-> {binds}{"vbttom10c20c10c11c00builder"}= $Awfif::memes-> {bh}{"vbttom10c20c10c11c00builder1"};
    $Awfif::memes-> {binds}{"vbttom10c20c00builder"}= $Awfif::memes-> {bh}{"vbttom10c20c00builder1"};
    $Awfif::memes-> {binds}{"vbttom10c20c11builder"}= $Awfif::memes-> {bh}{"vbttom10c20c11builder1"};
    $Awfif::memes-> {binds}{"vbttom10c20c11c00builder"}= $Awfif::memes-> {bh}{"vbttom10c20c11c00builder1"};
    $Awfif::memes-> {binds}{"vbttom10c10builder"} = $Awfif::memes-> {bh}{"vbttom10c10builder1"};
    $Awfif::memes-> {binds}{"vbttom10c11builder"} = $Awfif::memes-> {bh}{"vbttom10c11builder1"};
    $Awfif::memes-> {binds}{"vbttom10c10c11builder"}= $Awfif::memes-> {bh}{"vbttom10c10c11builder1"};
    $Awfif::memes-> {binds}{"vbttom10c00builder"} = $Awfif::memes-> {bh}{"vbttom10c00builder1"};
    $Awfif::memes-> {binds}{"vbttom10c10c00builder"}= $Awfif::memes-> {bh}{"vbttom10c10c00builder1"};
    $Awfif::memes-> {binds}{"vbttom10c11c00builder"}= $Awfif::memes-> {bh}{"vbttom10c11c00builder1"};
    $Awfif::memes-> {binds}{"vbttom10c10c11c00builder"}= $Awfif::memes-> {bh}{"vbttom10c10c11c00builder1"};
    $Awfif::memes-> {binds}{"vbttom11ncbuilder"} = $Awfif::memes-> {bh}{"vbttom11ncbuilder1"};
    $Awfif::memes-> {binds}{"vbttom11c21builder"} = $Awfif::memes-> {bh}{"vbttom11c21builder1"};
    $Awfif::memes-> {binds}{"vbttom11c21c11builder"}= $Awfif::memes-> {bh}{"vbttom11c21c11builder1"};
    $Awfif::memes-> {binds}{"vbttom11c21c11c01builder"}= $Awfif::memes-> {bh}{"vbttom11c21c11c01builder1"};
    $Awfif::memes-> {binds}{"vbttom11c21c11c12builder"}= $Awfif::memes-> {bh}{"vbttom11c21c11c12builder1"};
    $Awfif::memes-> {binds}{"vbttom11c21c11c12c01builder"}= $Awfif::memes-> {bh}{"vbttom11c21c11c12c01builder1"};
    $Awfif::memes-> {binds}{"vbttom11c21c01builder"}= $Awfif::memes-> {bh}{"vbttom11c21c01builder1"};
    $Awfif::memes-> {binds}{"vbttom11c21c12builder"}= $Awfif::memes-> {bh}{"vbttom11c21c12builder1"};
    $Awfif::memes-> {binds}{"vbttom11c21c12c01builder"}= $Awfif::memes-> {bh}{"vbttom11c21c12c01builder1"};
    $Awfif::memes-> {binds}{"vbttom11c11builder"} = $Awfif::memes-> {bh}{"vbttom11c11builder1"};
    $Awfif::memes-> {binds}{"vbttom11c12builder"} = $Awfif::memes-> {bh}{"vbttom11c12builder1"};
    $Awfif::memes-> {binds}{"vbttom11c11c12builder"}= $Awfif::memes-> {bh}{"vbttom11c11c12builder1"};
    $Awfif::memes-> {binds}{"vbttom11c01builder"} = $Awfif::memes-> {bh}{"vbttom11c01builder1"};
    $Awfif::memes-> {binds}{"vbttom11c11c01builder"}= $Awfif::memes-> {bh}{"vbttom11c11c01builder1"};
    $Awfif::memes-> {binds}{"vbttom11c12c01builder"}= $Awfif::memes-> {bh}{"vbttom11c12c01builder1"};
    $Awfif::memes-> {binds}{"vbttom11c11c12c01builder"}= $Awfif::memes-> {bh}{"vbttom11c11c12c01builder1"};
    $Awfif::memes-> {binds}{"vbttom11c10builder"} = $Awfif::memes-> {bh}{"vbttom11c10builder1"};
    $Awfif::memes-> {binds}{"vbttom11c21c10builder"}= $Awfif::memes-> {bh}{"vbttom11c21c10builder1"};
    $Awfif::memes-> {binds}{"vbttom11c21c11c10builder"}= $Awfif::memes-> {bh}{"vbttom11c21c11c10builder1"};
    $Awfif::memes-> {binds}{"vbttom11c21c11c01c10builder"}= $Awfif::memes-> {bh}{"vbttom11c21c11c01c10builder1"};
    $Awfif::memes-> {binds}{"vbttom11c21c11c12c10builder"}= $Awfif::memes-> {bh}{"vbttom11c21c11c12c10builder1"};
    $Awfif::memes-> {binds}{"vbttom11c21c11c12c01c10builder"}= $Awfif::memes-> {bh}{"vbttom11c21c11c12c01c10builder1"};
    $Awfif::memes-> {binds}{"vbttom11c21c01c10builder"}= $Awfif::memes-> {bh}{"vbttom11c21c01c10builder1"};
    $Awfif::memes-> {binds}{"vbttom11c21c12c10builder"}= $Awfif::memes-> {bh}{"vbttom11c21c12c10builder1"};
    $Awfif::memes-> {binds}{"vbttom11c21c12c01c10builder"}= $Awfif::memes-> {bh}{"vbttom11c21c12c01c10builder1"};
    $Awfif::memes-> {binds}{"vbttom11c11c10builder"}= $Awfif::memes-> {bh}{"vbttom11c11c10builder1"};
    $Awfif::memes-> {binds}{"vbttom11c12c10builder"}= $Awfif::memes-> {bh}{"vbttom11c12c10builder1"};
    $Awfif::memes-> {binds}{"vbttom11c11c12c10builder"}= $Awfif::memes-> {bh}{"vbttom11c11c12c10builder1"};
    $Awfif::memes-> {binds}{"vbttom11c01c10builder"}= $Awfif::memes-> {bh}{"vbttom11c01c10builder1"};
    $Awfif::memes-> {binds}{"vbttom11c11c01c10builder"}= $Awfif::memes-> {bh}{"vbttom11c11c01c10builder1"};
    $Awfif::memes-> {binds}{"vbttom11c12c01c10builder"}= $Awfif::memes-> {bh}{"vbttom11c12c01c10builder1"};
    $Awfif::memes-> {binds}{"vbttom11c11c12c01c10builder"}= $Awfif::memes-> {bh}{"vbttom11c11c12c01c10builder1"};
    $Awfif::memes-> {binds}{"vbttoamsbuilder"} = $Awfif::memes-> {bh}{"vbttoamsbuilder1"};
    $Awfif::memes-> {binds}{"vbttoamebuilder"} = $Awfif::memes-> {bh}{"vbttoamebuilder1"};
    $Awfif::memes-> {binds}{"vbttoamwbuilder"} = $Awfif::memes-> {bh}{"vbttoamwbuilder1"};
    $Awfif::memes-> {binds}{"vbttoamrbuilder"} = $Awfif::memes-> {bh}{"vbttoamrbuilder1"};
    $Awfif::memes-> {binds}{"vbttoapcbuilder"} = $Awfif::memes-> {bh}{"vbttoapcbuilder1"};
    $Awfif::memes-> {binds}{"vbttoamnbuilder"} = $Awfif::memes-> {bh}{"vbttoamnbuilder1"};
    $Awfif::memes-> {binds}{"msiopbuilder"} = $Awfif::memes-> {bh}{"msiopbuilder1"};
    $Awfif::memes-> {binds}{"vbtiopbuilder"} = $Awfif::memes-> {bh}{"vbtiopbuilder1"};
    $Awfif::memes-> {binds}{"msaobuilder"} = $Awfif::memes-> {bh}{"msaobuilder1"};
    $Awfif::memes-> {binds}{"drbuilder"} = $Awfif::memes-> {bh}{"drbuilder1"};
    $Awfif::memes-> {binds}{"libbuilder"} = $Awfif::memes-> {bh}{"libbuilder1"};
    $Awfif::memes-> {binds}{"tdbond"} = $Awfif::memes-> {bh}{"tdbond1"};
    $Awfif::memes-> {binds}{"tddesc"} = $Awfif::memes-> {bh}{"tdbond1"};
    $Awfif::memes-> {binds}{"tdgroup"} = $Awfif::memes-> {bh}{"tdgroup1"};
    $Awfif::memes-> {binds}{"qsort"} = $Awfif::memes-> {bh}{"dsortqs1"};
    $Awfif::memes-> {binds}{"qssort"} = $Awfif::memes-> {bh}{"dsortqs2"};
    $Awfif::memes-> {binds}{"rsort"} = $Awfif::memes-> {bh}{"dsortr1"};
    $Awfif::memes-> {binds}{"dname"} = $Awfif::memes-> {bh}{"padname1"};
    $Awfif::memes-> {binds}{"iname"} = $Awfif::memes-> {bh}{"painame1"};
    $Awfif::memes-> {binds}{"statementpdcal"} = $Awfif::memes-> {bh}{"statementpdcal1"};
    $Awfif::memes-> {binds}{"screplicate"} = $Awfif::memes-> {bh}{"screplicate1"};
    $Awfif::memes-> {binds}{"statementlabel"} = $Awfif::memes-> {bh}{"statementlabel1"};
# alljhlsbtocode
    $Awfif::memes-> {binds}{"alljhlsbinding"} = $Awfif::memes-> {bh}{"alljhlsbinding1"};
# notoporstbtocode
    $Awfif::memes-> {binds}{"notoporstbinding"} = $Awfif::memes-> {bh}{"notoporstbinding1"};
# opbtocode
    $Awfif::memes-> {binds}{"opbinding"} = $Awfif::memes-> {bh}{"opbinding1"};
# onlyoporstbtocode
    $Awfif::memes-> {binds}{"onlyoporstbinding"} = $Awfif::memes-> {bh}{"onlyoporstbinding1"};
# specstonlybtocode
    $Awfif::memes-> {binds}{"specstonly"} = $Awfif::memes-> {bh}{"specstonly1"};
# specwsonlyopbindingbtocode
    $Awfif::memes-> {binds}{"specwsonlyopbinding"} = $Awfif::memes-> {bh}{"specwsonlyopbinding1"};
# wsseqstbindingbtocode
    $Awfif::memes-> {binds}{"wsseqstbinding"} = $Awfif::memes-> {bh}{"wsseqstbinding1"};
# wsseqoporstbindingbtocode
    $Awfif::memes-> {binds}{"wsseqoporstbinding"} = $Awfif::memes-> {bh}{"wsseqoporstbinding1"};
# specsubpstonlybtocode
    $Awfif::memes-> {binds}{"specsubpstonly"} = $Awfif::memes-> {bh}{"specsubpstonly1"};
# goalsconbtocode
    $Awfif::memes-> {binds}{"goalscon"} = $Awfif::memes-> {bh}{"goalscon1"};
# msiopsconbtocode
    $Awfif::memes-> {binds}{"msiopscon"} = $Awfif::memes-> {bh}{"msiopscon1"};
# vbtiopsconbtocode
    $Awfif::memes-> {binds}{"vbtiopscon"} = $Awfif::memes-> {bh}{"vbtiopscon1"};
# devsconbtocode
    $Awfif::memes-> {binds}{"devscon"} = $Awfif::memes-> {bh}{"devscon1"};
# vbtdevsconbtocode
    $Awfif::memes-> {binds}{"vbtdevscon"} = $Awfif::memes-> {bh}{"vbtdevscon1"};
# devlbtocode
    $Awfif::memes-> {binds}{"developmentlabel"} = $Awfif::memes-> {bh}{"developmentlabel1"};
# mergestreamsbbtocode
    $Awfif::memes-> {binds}{"mergestreamsb"} = $Awfif::memes-> {bh}{"mergestreamsb1"};
# mergestreamsibtocode
    $Awfif::memes-> {binds}{"mergestreamsi"} = $Awfif::memes-> {bh}{"mergestreamsi1"};
# vbtbbtocode
    $Awfif::memes-> {binds}{"vbtb"} = $Awfif::memes-> {bh}{"vbtb1"};
# vbtibtocode
    $Awfif::memes-> {binds}{"vbti"} = $Awfif::memes-> {bh}{"vbti1"};
# hdobbtocode
    $Awfif::memes-> {binds}{"hdob"} = $Awfif::memes-> {bh}{"hdob1"};
# hdoibtocode
    $Awfif::memes-> {binds}{"hdoi"} = $Awfif::memes-> {bh}{"hdoi1"};
# cstbbtocode
    $Awfif::memes-> {binds}{"comparestb"} = $Awfif::memes-> {bh}{"comparestb1"};
# cstibtocode
    $Awfif::memes-> {binds}{"comparesti"} = $Awfif::memes-> {bh}{"comparesti1"};
# mstracasetestpibtocode
    $Awfif::memes-> {binds}{"mstracasetestpi"} = $Awfif::memes-> {bh}{"mstracasetestpi1"};
# mstraresctestpibtocode
    $Awfif::memes-> {binds}{"mstraresctestpi"} = $Awfif::memes-> {bh}{"mstraresctestpi1"};
# pdcasappibtocode
    $Awfif::memes-> {binds}{"pdcasappi"} = $Awfif::memes-> {bh}{"pdcasappi1"};
# mstrarescinitpibtocode
    $Awfif::memes-> {binds}{"mstrarescinitpi"} = $Awfif::memes-> {bh}{"mstrarescinitpi1"};
# mstranoctestpibtocode
    $Awfif::memes-> {binds}{"mstranoctestpi"} = $Awfif::memes-> {bh}{"mstranoctestpi1"};
# pdcabbtocode
    $Awfif::memes-> {binds}{"pdcab"} = $Awfif::memes-> {bh}{"pdcab1"};
# imembbtocode
    $Awfif::memes-> {binds}{"imemb"} = $Awfif::memes-> {bh}{"imemb1"};
# ecyclinobtocode
    $Awfif::memes-> {binds}{"ecyclino"} = $Awfif::memes-> {bh}{"ecyclino1"};
# acyclinobtocode
    $Awfif::memes-> {binds}{"acyclino"} = $Awfif::memes-> {bh}{"acyclino1"};
# bcyclinobtocode
    $Awfif::memes-> {binds}{"bcyclino"} = $Awfif::memes-> {bh}{"bcyclino1"};
# dcyclinobtocode
    $Awfif::memes-> {binds}{"dcyclino"} = $Awfif::memes-> {bh}{"dcyclino1"};
# devbbtocode
    $Awfif::memes-> {binds}{"developmentb"} = $Awfif::memes-> {bh}{"developmentb1"};
    $Awfif::memes-> {binds}{"developmenti"} = $Awfif::memes-> {bh}{"developmenti1"};
# vbtdevbbtocode
    $Awfif::memes-> {binds}{"vbtdevelopmentb"} = $Awfif::memes-> {bh}{"developmentb1"};
    $Awfif::memes-> {binds}{"vbtdevelopmenti"} = $Awfif::memes-> {bh}{"developmenti1"};
# comparestbtocode
    $Awfif::memes-> {binds}{"comparest"} = $Awfif::memes-> {bh}{"comparest1"};
# msadoboppibtocode
    $Awfif::memes-> {binds}{"msadoboppi"} = $Awfif::memes-> {bh}{"msadoboppi1"};
# casoppibtocode
    $Awfif::memes-> {binds}{"casoppi"} = $Awfif::memes-> {bh}{"casoppi1"};
    $Awfif::memes-> {binds}{"cassuboppi"} = $Awfif::memes-> {bh}{"cassuboppi1"};
# casopaibtocode
    $Awfif::memes-> {binds}{"casopai"} = $Awfif::memes-> {bh}{"casopai1"};
    $Awfif::memes-> {binds}{"binderp1"} = $Awfif::memes-> {bh}{"binderp11"};
    $Awfif::memes-> {binds}{"binderc"} = $Awfif::memes-> {bh}{"binderc1"};
# binderc4ibtocode
    $Awfif::memes-> {binds}{"binderc4"} = $Awfif::memes-> {bh}{"binderc41"};
# binderc7ibtocode
    $Awfif::memes-> {binds}{"binderc7"} = $Awfif::memes-> {bh}{"binderc71"};
# binderc9ibtocode
    $Awfif::memes-> {binds}{"binderc9"} = $Awfif::memes-> {bh}{"binderc91"};
# binderc10ibtocode
    $Awfif::memes-> {binds}{"binderc10"} = $Awfif::memes-> {bh}{"binderc101"};
# binderc11ibtocode
    $Awfif::memes-> {binds}{"binderc11"} = $Awfif::memes-> {bh}{"binderc111"};
# binderc13ibtocode
    $Awfif::memes-> {binds}{"binderc13"} = $Awfif::memes-> {bh}{"binderc131"};
# binderc16ibtocode
    $Awfif::memes-> {binds}{"binderc16"} = $Awfif::memes-> {bh}{"binderc161"};
# binderc19ibtocode
    $Awfif::memes-> {binds}{"binderc19"} = $Awfif::memes-> {bh}{"binderc191"};
    $Awfif::memes-> {binds}{"bindercs"} = $Awfif::memes-> {bh}{"bindercs1"};
    $Awfif::memes-> {binds}{"bindercs2"} = $Awfif::memes-> {bh}{"bindercs21"};
    $Awfif::memes-> {binds}{"bindercml"} = $Awfif::memes-> {bh}{"bindercml1"};
# bindcstbtocode
    $Awfif::memes-> {binds}{"bindercst"} = $Awfif::memes-> {bh}{"bindercst1"};
    $Awfif::memes-> {binds}{"binderrc"} = $Awfif::memes-> {bh}{"binderrc1"};
    $Awfif::memes-> {binds}{"subpc"} = $Awfif::memes-> {bh}{"subpc1"};
    $Awfif::memes-> {binds}{"partlabel"} = $Awfif::memes-> {bh}{"partlabel1"};
# hissconbtocode
    $Awfif::memes-> {binds}{"hdoscon"} = $Awfif::memes-> {bh}{"hdoscon1"};
# $Awfif::memes-> {binds}{"histoneb"} = $Awfif::memes-> {bh}{"histoneb1"};
# $Awfif::memes-> {binds}{"histonei"} = $Awfif::memes-> {bh}{"histonei1"};
#
# Assign other "physical" properties
    $Awfif::memes-> {wslocality}{"start"} = 1;
    $Awfif::memes-> {wslocality}{"end"} = 1;
# chemical properties should not be initialised if restarting from persistant store
    if ((!defined ($restoring)) or (!$restoring)){
# Assign "chemical" properties

    $Awfif::memes-> {pstream} = "istream";
    $Awfif::memes-> {snehih} = 0; #the head of the element use history is not used yet
    $Awfif::memes-> {wsohih} = 0; #the head of the element use history is not used yet
    $Awfif::memes-> {codeleth} = 0;
    $Awfif::memes-> {codeletw} = 0;
    $Awfif::memes-> {codeletdef} = 0;
    $Awfif::memes-> {codelett} = 0;
    $Awfif::memes-> {codeletpt} = 0; #the pseudo tail identifies the first item from the tail of the active codelet list that can be deleted or the current head if negative
    $Awfif::memes-> {codeletf} = 0;
    $Awfif::memes-> {jhldesf} = 0;
    $Awfif::memes-> {attribdesf} = 0;
    $Awfif::memes-> {attribdesh} = 0;
# awflistinit

    $Awfif::clnk-> {f} = 0;
    $Awfif::clnk-> {h} = 0;
    $Awfif::clnk-> {t} = 0;
# $Awfif::clnk-> {fclnk} = 0;
    $Awfif::clnk-> {flistl} = 0;
    $Awfif::aspl-> {f} = 0;
    $Awfif::aspl-> {h} = 0;
    $Awfif::aspl-> {t} = 0;
    $Awfif::aspl-> {flistl} = 0;
    $Awfif::inhibl-> {f} = 0;
    $Awfif::inhibl-> {h} = 0;
    $Awfif::inhibl-> {t} = 0;
    $Awfif::inhibl-> {flistl} = 0;
    $Awfif::trfl-> {f} = 0;
    $Awfif::trfl-> {h} = 0;
    $Awfif::trfl-> {t} = 0;
    $Awfif::trfl-> {flistl} = 0;
    $Awfif::kwl-> {f} = 0;
    $Awfif::kwl-> {h} = 0;
    $Awfif::kwl-> {t} = 0;
    $Awfif::kwl-> {flistl} = 0;
    $Awfif::wontgroupc-> {f} = 0;
    $Awfif::wontgroupc-> {h} = 0;
    $Awfif::wontgroupc-> {t} = 0;
    $Awfif::wontgroupc-> {flistl} = 0;
    $Awfif::wontgroupc-> {caller} = 0;
    $Awfif::norml-> {f} = 0;
    $Awfif::norml-> {flistl} = 0;
    $Awfif::mkwl-> {f} = 0;
    $Awfif::mkwl-> {h} = 0;
    $Awfif::mkwl-> {t} = 0;
    $Awfif::mkwl-> {flistl} = 0;
# sametlinit
    $Awfif::sametl-> {f} = 0;
    $Awfif::sametl-> {h} = 0;
    $Awfif::sametl-> {t} = 0;
    $Awfif::sametl-> {flistl} = 0;
    $Awfif::tral-> {f} = 0;
    $Awfif::tral-> {h} = 0;
    $Awfif::tral-> {t} = 0;
    $Awfif::tral-> {flistl} = 0;
    $Awfif::tmassl-> {f} = 0;
    $Awfif::tmassl-> {h} = 0;
    $Awfif::tmassl-> {t} = 0;
    $Awfif::tmassl-> {flistl} = 0;
    $Awfif::histonel-> {f} = 0;
    $Awfif::histonel-> {h} = 0;
    $Awfif::histonel-> {t} = 0;
    $Awfif::histonel-> {flistl} = 0;
# subplinit
    $Awfif::subpl-> {f} = 0;
    $Awfif::subpl-> {h} = 0;
    $Awfif::subpl-> {t} = 0;
    $Awfif::subpl-> {flistl} = 0;
# costatelinit
    $Awfif::costatel-> {f} = 0;
    $Awfif::costatel-> {h} = 0;
    $Awfif::costatel-> {t} = 0;
    $Awfif::costatel-> {flistl} = 0;
# amofflinit
    $Awfif::amoffl-> {f} = 0;
    $Awfif::amoffl-> {h} = 0;
    $Awfif::amoffl-> {t} = 0;
    $Awfif::amoffl-> {flistl} = 0;
# poolclinit
    $Awfif::poolcl-> {f} = 0;
    $Awfif::poolcl-> {h} = 0;
    $Awfif::poolcl-> {t} = 0;
    $Awfif::poolcl-> {flistl} = 0;
# synclinit
    $Awfif::syncl-> {f} = 0;
    $Awfif::syncl-> {h} = 0;
    $Awfif::syncl-> {t} = 0;
    $Awfif::syncl-> {flistl} = 0;
# synccodlinit
    $Awfif::synccodl-> {f} = 0;
    $Awfif::synccodl-> {h} = 0;
    $Awfif::synccodl-> {t} = 0;
    $Awfif::synccodl-> {flistl} = 0;
# vfhistinit
    $Awfif::vfhist-> {tvf} = 0;
    $Awfif::vfhist-> {f} = 0;
    $Awfif::vfhist-> {h} = 0;
    $Awfif::vfhist-> {t} = 0;
# cswsolinit
    $Awfif::cswsol-> {f} = 0;
    $Awfif::cswsol-> {h} = 0;
    $Awfif::cswsol-> {t} = 0;
    $Awfif::cswsol-> {flistl} = 0;
# subpscdeflinit
    $Awfif::subpscdefl-> {f} = 0;
    $Awfif::subpscdefl-> {h} = 0;
    $Awfif::subpscdefl-> {t} = 0;
    $Awfif::subpscdefl-> {flistl} = 0;
# wfcdeflinit
    $Awfif::wfcdefl-> {f} = 0;
    $Awfif::wfcdefl-> {h} = 0;
    $Awfif::wfcdefl-> {t} = 0;
    $Awfif::wfcdefl-> {flistl} = 0;
# wfchchainlinit
    $Awfif::wfchchainl-> {f} = 0;
    $Awfif::wfchchainl-> {h} = 0;
    $Awfif::wfchchainl-> {t} = 0;
    $Awfif::wfchchainl-> {flistl} = 0;
# jhlchlinit
    $Awfif::jhlchl-> {f} = 0;
    $Awfif::jhlchl-> {h} = 0;
    $Awfif::jhlchl-> {t} = 0;
    $Awfif::jhlchl-> {flistl} = 0;
# framelinit
    $Awfif::framel-> {f} = 0;
    $Awfif::framel-> {h} = 0;
    $Awfif::framel-> {t} = 0;
    $Awfif::framel-> {flistl} = 0;
# fblinit
    $Awfif::fbl-> {f} = 0;
    $Awfif::fbl-> {h} = 0;
    $Awfif::fbl-> {t} = 0;
    $Awfif::fbl-> {flistl} = 0;
# veccolinit

    $Awfif::veccol-> {f} = 0;
    $Awfif::veccol-> {h} = 0;
    $Awfif::veccol-> {t} = 0;
    $Awfif::veccol-> {flistl} = 0;
    $Awfif::veccol-> {vcstate} = 0;
    $Awfif::veccol-> {strategy} {'tddesc'} = 1;
    $Awfif::veccol-> {strategy} {'budesc'} = 2;
    $Awfif::veccol-> {strategy} {'tdbond'} = 3;
    $Awfif::veccol-> {strategy} {'bubond'} = 4;
    $Awfif::veccol-> {strategy} {'bugroup'} = 5;
    $Awfif::veccol-> {strategy} {'tdgroup'} = 6;
    $Awfif::veccol-> {strategy} {'budescl'} = 7;
    $Awfif::veccol-> {strategy} {'tddescl'} = 8;
    $Awfif::veccol-> {strategy} {'selfacetc'} = 9;
    $Awfif::veccol-> {strategy} {'usedescpc'} = 10;
    $Awfif::veccol-> {strategy} {'matchtree'} = 11;
    $Awfif::veccol-> {strategy} {'bustatement'} = 12;
    $Awfif::veccol-> {strategy} {'budevelopment'} = 13;
    $Awfif::veccol-> {index} {'tddesc'} = undef();
    $Awfif::veccol-> {index} {'budesc'} = undef();
    $Awfif::veccol-> {index} {'tdbond'} = undef();
    $Awfif::veccol-> {index} {'bubond'} = undef();
    $Awfif::veccol-> {index} {'bugroup'} = undef();
    $Awfif::veccol-> {index} {'tdgroup'} = undef();
    $Awfif::veccol-> {index} {'budescl'} = undef();
    $Awfif::veccol-> {index} {'tddescl'} = undef();
    $Awfif::veccol-> {index} {'selfacetc'} = undef();
    $Awfif::veccol-> {index} {'usedescpc'} = undef();
    $Awfif::veccol-> {index} {'matchtree'} = undef();
    $Awfif::veccol-> {index} {'bustatement'} = undef();
    $Awfif::veccol-> {index} {'budevelopment'} = undef();
# $Awfif::veccol-> {get} {'tddesc'} = undef();
# $Awfif::veccol-> {get} {'budesc'} = undef();
# $Awfif::veccol-> {get} {'tdbond'} = undef();
# $Awfif::veccol-> {get} {'bubond'} = undef();
# $Awfif::veccol-> {get} {'bugroup'} = undef();
# $Awfif::veccol-> {get} {'tdgroup'} = undef();
# $Awfif::veccol-> {get} {'budescl'} = undef();
# $Awfif::veccol-> {get} {'tddescl'} = undef();
# $Awfif::veccol-> {get} {'selfacetc'} = undef();
# $Awfif::veccol-> {get} {'usedescpc'} = undef();
# $Awfif::veccol-> {get} {'matchtree'} = undef();
# $Awfif::veccol-> {get} {'bustatement'} = undef();
# $Awfif::veccol-> {get} {'budevelopment'} = undef();
    $Awfif::veccol-> {ststate} [$Awfif::memes-> {cvalid}][$Awfif::veccol-> {strategy}{'bugroup'}] = 14;
    $Awfif::veccol-> {ststate} [$Awfif::memes-> {cchange}][$Awfif::veccol-> {strategy}{'bugroup'}] = 0;
    $Awfif::veccol-> {ststate} [$Awfif::memes-> {ci2}][$Awfif::veccol-> {strategy}{'bugroup'}] = 14;
    $Awfif::veccol-> {ststate} [$Awfif::memes-> {ctinst}][$Awfif::veccol-> {strategy}{'bugroup'}] = 14;
    $Awfif::veccol-> {ststate} [$Awfif::memes-> {cvpci}][$Awfif::veccol-> {strategy}{'bugroup'}] = 0;
    $Awfif::veccol-> {ststate} [$Awfif::memes-> {cvpcwso}][$Awfif::veccol-> {strategy}{'bugroup'}] = 0;
    $Awfif::veccol-> {ststate} [$Awfif::memes-> {cvalid}][$Awfif::veccol-> {strategy}{'tdgroup'}] = 14;
    $Awfif::veccol-> {ststate} [$Awfif::memes-> {cchange}][$Awfif::veccol-> {strategy}{'tdgroup'}] = 0;
    $Awfif::veccol-> {ststate} [$Awfif::memes-> {ci2}][$Awfif::veccol-> {strategy}{'tdgroup'}] = 14;
    $Awfif::veccol-> {ststate} [$Awfif::memes-> {ctinst}][$Awfif::veccol-> {strategy}{'tdgroup'}] = 14;
    $Awfif::veccol-> {ststate} [$Awfif::memes-> {cvpci}][$Awfif::veccol-> {strategy}{'tdgroup'}] = 0;
    $Awfif::veccol-> {ststate} [$Awfif::memes-> {cvpcwso}][$Awfif::veccol-> {strategy}{'tdgroup'}] = 0;
    $Awfif::veccol-> {ststate} [$Awfif::memes-> {cvalid}][$Awfif::veccol-> {strategy}{'budesc'}] = 14;
    $Awfif::veccol-> {ststate} [$Awfif::memes-> {cchange}][$Awfif::veccol-> {strategy}{'budesc'}] = 0;
    $Awfif::veccol-> {ststate} [$Awfif::memes-> {ci2}][$Awfif::veccol-> {strategy}{'budesc'}] = 14;
    $Awfif::veccol-> {ststate} [$Awfif::memes-> {ctinst}][$Awfif::veccol-> {strategy}{'budesc'}] = 14;
    $Awfif::veccol-> {ststate} [$Awfif::memes-> {cvpci}][$Awfif::veccol-> {strategy}{'budesc'}] = 0;
    $Awfif::veccol-> {ststate} [$Awfif::memes-> {cvpcwso}][$Awfif::veccol-> {strategy}{'budesc'}] = 0;
    $Awfif::veccol-> {ststate} [$Awfif::memes-> {cvalid}][$Awfif::veccol-> {strategy}{'tddesc'}] = 14;
    $Awfif::veccol-> {ststate} [$Awfif::memes-> {cchange}][$Awfif::veccol-> {strategy}{'tddesc'}] = 0;
    $Awfif::veccol-> {ststate} [$Awfif::memes-> {ci2}][$Awfif::veccol-> {strategy}{'tddesc'}] = 14;
    $Awfif::veccol-> {ststate} [$Awfif::memes-> {ctinst}][$Awfif::veccol-> {strategy}{'tddesc'}] = 14;
    $Awfif::veccol-> {ststate} [$Awfif::memes-> {cvpci}][$Awfif::veccol-> {strategy}{'tddesc'}] = 0;
    $Awfif::veccol-> {ststate} [$Awfif::memes-> {cvpcwso}][$Awfif::veccol-> {strategy}{'tddesc'}] = 0;
    $Awfif::veccol-> {ststate} [$Awfif::memes-> {cvalid}][$Awfif::veccol-> {strategy}{'bubond'}] = 14;
    $Awfif::veccol-> {ststate} [$Awfif::memes-> {cchange}][$Awfif::veccol-> {strategy}{'bubond'}] = 0;
    $Awfif::veccol-> {ststate} [$Awfif::memes-> {ci2}][$Awfif::veccol-> {strategy}{'bubond'}] = 14;
    $Awfif::veccol-> {ststate} [$Awfif::memes-> {ctinst}][$Awfif::veccol-> {strategy}{'bubond'}] = 14;
    $Awfif::veccol-> {ststate} [$Awfif::memes-> {cvpci}][$Awfif::veccol-> {strategy}{'bubond'}] = 0;
    $Awfif::veccol-> {ststate} [$Awfif::memes-> {cvpcwso}][$Awfif::veccol-> {strategy}{'bubond'}] = 0;
    $Awfif::veccol-> {ststate} [$Awfif::memes-> {cvalid}][$Awfif::veccol-> {strategy}{'tdbond'}] = 14;
    $Awfif::veccol-> {ststate} [$Awfif::memes-> {cchange}][$Awfif::veccol-> {strategy}{'tdbond'}] = 0;
    $Awfif::veccol-> {ststate} [$Awfif::memes-> {ci2}][$Awfif::veccol-> {strategy}{'tdbond'}] = 14;
    $Awfif::veccol-> {ststate} [$Awfif::memes-> {ctinst}][$Awfif::veccol-> {strategy}{'tdbond'}] = 14;
    $Awfif::veccol-> {ststate} [$Awfif::memes-> {cvpci}][$Awfif::veccol-> {strategy}{'tdbond'}] = 0;
    $Awfif::veccol-> {ststate} [$Awfif::memes-> {cvpcwso}][$Awfif::veccol-> {strategy}{'tdbond'}] = 0;
    $Awfif::veccol-> {ststate} [$Awfif::memes-> {cvalid}][$Awfif::veccol-> {strategy}{'bustatement'}] = 14;
    $Awfif::veccol-> {ststate} [$Awfif::memes-> {cchange}][$Awfif::veccol-> {strategy}{'bustatement'}] = 0;
    $Awfif::veccol-> {ststate} [$Awfif::memes-> {ci2}][$Awfif::veccol-> {strategy}{'bustatement'}] = 14;
    $Awfif::veccol-> {ststate} [$Awfif::memes-> {ctinst}][$Awfif::veccol-> {strategy}{'bustatement'}] = 14;
    $Awfif::veccol-> {ststate} [$Awfif::memes-> {cvpci}][$Awfif::veccol-> {strategy}{'bustatement'}] = 0;
    $Awfif::veccol-> {ststate} [$Awfif::memes-> {cvpcwso}][$Awfif::veccol-> {strategy}{'bustatement'}] = 0;
    $Awfif::veccol-> {ststate} [$Awfif::memes-> {cvalid}][$Awfif::veccol-> {strategy}{'budevelopment'}] = 14;
    $Awfif::veccol-> {ststate} [$Awfif::memes-> {cchange}][$Awfif::veccol-> {strategy}{'budevelopment'}] = 0;
    $Awfif::veccol-> {ststate} [$Awfif::memes-> {ci2}][$Awfif::veccol-> {strategy}{'budevelopment'}] = 14;
    $Awfif::veccol-> {ststate} [$Awfif::memes-> {ctinst}][$Awfif::veccol-> {strategy}{'budevelopment'}] = 14;
    $Awfif::veccol-> {ststate} [$Awfif::memes-> {cvpci}][$Awfif::veccol-> {strategy}{'budevelopment'}] = 0;
    $Awfif::veccol-> {ststate} [$Awfif::memes-> {cvpcwso}][$Awfif::veccol-> {strategy}{'budevelopment'}] = 0;
    $Awfif::veccol-> {ststate} [$Awfif::memes-> {snlcic}][$Awfif::veccol-> {strategy}{'budescl'}] = 14;
    $Awfif::veccol-> {ststate} [$Awfif::memes-> {snlcpcv}][$Awfif::veccol-> {strategy}{'budescl'}] = 14;
    $Awfif::veccol-> {ststate} [$Awfif::memes-> {snlcsnconcl}][$Awfif::veccol-> {strategy}{'budescl'}] = 14;
    $Awfif::veccol-> {ststate} [$Awfif::memes-> {snlclact}][$Awfif::veccol-> {strategy}{'budescl'}] = 14;
    $Awfif::veccol-> {ststate} [$Awfif::memes-> {snlcactd}][$Awfif::veccol-> {strategy}{'budescl'}] = 14;
    $Awfif::veccol-> {ststate} [$Awfif::memes-> {snlcave}][$Awfif::veccol-> {strategy}{'budescl'}] = 14;
    $Awfif::veccol-> {ststate} [$Awfif::memes-> {snlcvalid}][$Awfif::veccol-> {strategy}{'budescl'}] = 14;
    $Awfif::veccol-> {ststate} [$Awfif::memes-> {snlctinst}][$Awfif::veccol-> {strategy}{'budescl'}] = 14;
    $Awfif::veccol-> {ststate} [$Awfif::memes-> {snlcigch}][$Awfif::veccol-> {strategy}{'budescl'}] = 14;
    $Awfif::veccol-> {ststate} [$Awfif::memes-> {snlcic}][$Awfif::veccol-> {strategy}{'tddescl'}] = 14;
    $Awfif::veccol-> {ststate} [$Awfif::memes-> {snlcpcv}][$Awfif::veccol-> {strategy}{'tddescl'}] = 14;
    $Awfif::veccol-> {ststate} [$Awfif::memes-> {snlcsnconcl}][$Awfif::veccol-> {strategy}{'tddescl'}] = 14;
    $Awfif::veccol-> {ststate} [$Awfif::memes-> {snlclact}][$Awfif::veccol-> {strategy}{'tddescl'}] = 14;
    $Awfif::veccol-> {ststate} [$Awfif::memes-> {snlcactd}][$Awfif::veccol-> {strategy}{'tddescl'}] = 14;
    $Awfif::veccol-> {ststate} [$Awfif::memes-> {snlcave}][$Awfif::veccol-> {strategy}{'tddescl'}] = 14;
    $Awfif::veccol-> {ststate} [$Awfif::memes-> {snlcvalid}][$Awfif::veccol-> {strategy}{'tddescl'}] = 14;
    $Awfif::veccol-> {ststate} [$Awfif::memes-> {snlctinst}][$Awfif::veccol-> {strategy}{'tddescl'}] = 14;
    $Awfif::veccol-> {ststate} [$Awfif::memes-> {snlcigch}][$Awfif::veccol-> {strategy}{'tddescl'}] = 14;
    $Awfif::veccol-> {ststate} [$Awfif::memes-> {mtcv}][$Awfif::veccol-> {strategy}{'matchtree'}] = 0;
    $Awfif::veccol-> {ststate} [$Awfif::memes-> {mtcm}][$Awfif::veccol-> {strategy}{'matchtree'}] = 0;
    $Awfif::veccol-> {ststate} [$Awfif::memes-> {selcv}][$Awfif::veccol-> {strategy}{'selfacetc'}] = 14;
    $Awfif::veccol-> {ststate} [$Awfif::memes-> {selctinst}][$Awfif::veccol-> {strategy}{'selfacetc'}] = 14;
    $Awfif::veccol-> {ststate} [$Awfif::memes-> {selcchange}][$Awfif::veccol-> {strategy}{'selfacetc'}] = 14;
    $Awfif::veccol-> {ststate} [$Awfif::memes-> {udpcv}][$Awfif::veccol-> {strategy}{'usedescpc'}] = 0;
    $Awfif::veccol-> {ststate} [$Awfif::memes-> {udpcit}][$Awfif::veccol-> {strategy}{'usedescpc'}] = 0;
    $Awfif::veccol-> {ststate} [$Awfif::memes-> {udpcme}][$Awfif::veccol-> {strategy}{'usedescpc'}] = 0;
    $Awfif::veccol-> {ststate} [$Awfif::memes-> {udpcmn}][$Awfif::veccol-> {strategy}{'usedescpc'}] = 0;
    $Awfif::ifbhcl-> {f} = 0;
    $Awfif::ifbhcl-> {h} = 0;
    $Awfif::ifbhcl-> {t} = 0;
    $Awfif::ifbhcl-> {flistl} = 0;
    $Awfif::ilabhcl-> {f} = 0;
    $Awfif::ilabhcl-> {h} = 0;
    $Awfif::ilabhcl-> {t} = 0;
    $Awfif::ilabhcl-> {flistl} = 0;
    $Awfif::itswsall-> {f} = 0;
    $Awfif::itswsall-> {h} = 0;
    $Awfif::itswsall-> {t} = 0;
    $Awfif::itswsall-> {flistl} = 0;
    $Awfif::bicl-> {f} = 0;
    $Awfif::bicl-> {h} = 0;
    $Awfif::bicl-> {t} = 0;
    $Awfif::bicl-> {flistl} = 0;
    $Awfif::workspace-> {f} = 0; # no items in the workspace descriptor free list initially
    $Awfif::workspace-> {h} = 0;
    $Awfif::workspace-> {t} = 0;
    $Awfif::workspace-> {flistl} = 0;
    $Awfif::codelet-> {p} = 1;
# $Awfif::memes-> {wsodesf} = 0; #old ws mechamism
    $Awfif::workspace-> {p} = 1;
    $Awfif::slipnet-> {p} = 1;
    $Awfif::clnk-> {p} = 1;
    $Awfif::costatel-> {p} = 1;
    $Awfif::aspl-> {p} = 1;
    $Awfif::inhibl-> {p} = 1;
    $Awfif::trfl-> {p} = 1;
    $Awfif::kwl-> {p} = 1;
    $Awfif::wontgroupc-> {p} = 1;
    $Awfif::histonel-> {p} = 1;
    $Awfif::subpl-> {p} = 1;
    $Awfif::amoffl-> {p} = 1;
    $Awfif::poolcl-> {p} = 1;
    $Awfif::syncl-> {p} = 1;
    $Awfif::synccodl-> {p} = 1;
    $Awfif::vfhist-> {p} = 1;
    $Awfif::cswsol-> {p} = 1;
    $Awfif::subpscdefl-> {p} = 1;
    $Awfif::wfcdefl-> {p} = 1;
    $Awfif::wfchchainl-> {p} = 1;
    $Awfif::jhlchl-> {p} = 1;
    $Awfif::veccol-> {p} = 1;
    $Awfif::ifbhcl-> {p} = 1;
    $Awfif::framel-> {p} = 1;
    $Awfif::fbl-> {p} = 1;
    $Awfif::ilabhcl-> {p} = 1;
    $Awfif::itswsall-> {p} = 1;
    $Awfif::bicl-> {p} = 1;
    $Awfif::bicl-> {cp} = 1;
    $Awfif::norml-> {p} = 1;
    $Awfif::mkwl-> {p} = 1;
    $Awfif::sametl-> {p} = 1;
    $Awfif::tral-> {p} = 1;
    $Awfif::tmassl-> {p} = 1;
    $Awfif::slehist-> {p} = 1;
    $Awfif::wsohist-> {p} = 1;
    $Awfif::csehist-> {p} = 1;
    $Awfif::attribs-> {p} = 1;
    $Awfif::jhls-> {p} = 1;
# cachestrhash
# initialise the cache
    $Awfif::pcache-> {p}
    [$Awfif::memes-> {currentwsbi}] = 1; #parts cache is just a list
    $Awfif::pcache-> {t}
    [$Awfif::memes-> {currentwsbi}] = ''; #parts cache t is used to record terminal presence
    $Awfif::cache-> {h}{'tddesc'} = 3;#change back to 1 if seperate tddesc and tdbond bh structures
    $Awfif::cache-> {h}{'budesc'} = 2;
    $Awfif::cache-> {h}{'tdbond'} = 3;
    $Awfif::cache-> {h}{'bubond'} = 4;
    $Awfif::cache-> {h}{'bugroup'} = 5;
    $Awfif::cache-> {h}{'tdgroup'} = 6;
    $Awfif::cache-> {h}{'budescl'} = 7;
    $Awfif::cache-> {h}{'tddescl'} = 8;
    $Awfif::cache-> {h}{'selfacetc'} = 9;
    $Awfif::cache-> {h}{'usedescpc'} = 10;
    $Awfif::cache-> {h}{'matchtree'} = 11;
    $Awfif::cache-> {h}{'bustatement'} = 12;
    $Awfif::cache-> {h}{'budevelopment'} = 13;
    };#if not restore
#
# codelethash
# initialise the codelet type hash

    my ($i2);
    $i2 = 0;
    for my $act (@$csset) {
      $Awfif::memes-> {ch}{$act} = $i2++;
      };#for
    if ((!defined ($restoring)) or (!$restoring)){
#
#<!-- ntart tag sl -->
# setup initial slipnet
# including links, depths coordinates and activation

    &Awfif::iudpcache (\@$sactset);
    &Awfif::initsn (1);

    };#if not restore
    $Awfif::memes-> {binds}{lbevaluator} = $Awfif::memes-> {bh}{"lbevaluator1"};
    $Awfif::memes-> {binds}{lbinhibitor} = $Awfif::memes-> {bh}{"lbinhibitor1"};
    $Awfif::memes-> {binds}{libevaluator} = $Awfif::memes-> {bh}{"libevaluator1"};
# msaobindtocode
    $Awfif::memes-> {binds}{msaoevaluator} = $Awfif::memes-> {bh}{"msaoevaluator1"};
    $Awfif::memes-> {binds}{msaobsmodeler} = $Awfif::memes-> {bh}{"msaobsmodeler1"};
# msiopbindtocode
    $Awfif::memes-> {binds}{msiopevaluator} = $Awfif::memes-> {bh}{"msiopevaluator1"};
    $Awfif::memes-> {binds}{msiopbsmodeler} = $Awfif::memes-> {bh}{"msiopbsmodeler1"};
# msiopibindtocode
    $Awfif::memes-> {binds}{msiopinhibitor} = $Awfif::memes-> {bh}{"msiopinhibitor1"};
# vbtiopbindtocode
    $Awfif::memes-> {binds}{vbtiopevaluator} = $Awfif::memes-> {bh}{"vbtiopevaluator1"};
    $Awfif::memes-> {binds}{vbtiopbsmodeler} = $Awfif::memes-> {bh}{"vbtiopbsmodeler1"};
# vbtiopibindtocode
    $Awfif::memes-> {binds}{vbtiopinhibitor} = $Awfif::memes-> {bh}{"vbtiopinhibitor1"};
# devbindtocode
    $Awfif::memes-> {binds}{devevaluator} = $Awfif::memes-> {bh}{"devevaluator1"};
# vbtdevbindtocode
    $Awfif::memes-> {binds}{vbtdevevaluator} = $Awfif::memes-> {bh}{"vbtdevevaluator1"};
# vbttmbindtocode
    $Awfif::memes-> {binds}{vbttmevaluator} = $Awfif::memes-> {bh}{"vbttmevaluator1"};
# vbttmorevbbindtocode
    $Awfif::memes-> {binds}{vbttmorevbevaluator} = $Awfif::memes-> {bh}{"vbttmorevbevaluator1"};
    $Awfif::memes-> {binds}{ivbttmorevbevaluator} = $Awfif::memes-> {bh}{"ivbttmorevbevaluator1"};
# vbttmoretsbindtocode
    $Awfif::memes-> {binds}{vbttmoretsevaluator} = $Awfif::memes-> {bh}{"vbttmoretsevaluator1"};
    $Awfif::memes-> {binds}{ivbttmoretsevaluator} = $Awfif::memes-> {bh}{"ivbttmoretsevaluator1"};
# vbttmoregsbindtocode
    $Awfif::memes-> {binds}{vbttmoregsevaluator} = $Awfif::memes-> {bh}{"vbttmoregsevaluator1"};
    $Awfif::memes-> {binds}{ivbttmoregsevaluator} = $Awfif::memes-> {bh}{"ivbttmoregsevaluator1"};
# vbttom00ncbindtocode
    $Awfif::memes-> {binds}{vbttom00ncevaluator} = $Awfif::memes-> {bh}{"vbttom00ncevaluator1"};
# vbttom0recbindtocode
    $Awfif::memes-> {binds}{vbttom0recevaluator} = $Awfif::memes-> {bh}{"vbttom0recevaluator1"};
# vbttom00c00bindtocode
    $Awfif::memes-> {binds}{vbttom00c00evaluator} = $Awfif::memes-> {bh}{"vbttom00c00evaluator1"};
# vbttom00c00c01bindtocode
    $Awfif::memes-> {binds}{vbttom00c00c01evaluator} = $Awfif::memes-> {bh}{"vbttom00c00c01evaluator1"};
# vbttom00c01bindtocode
    $Awfif::memes-> {binds}{vbttom00c01evaluator} = $Awfif::memes-> {bh}{"vbttom00c01evaluator1"};
# vbttom00c10bindtocode
    $Awfif::memes-> {binds}{vbttom00c10evaluator} = $Awfif::memes-> {bh}{"vbttom00c10evaluator1"};
# vbttom00c10c00bindtocode
    $Awfif::memes-> {binds}{vbttom00c10c00evaluator} = $Awfif::memes-> {bh}{"vbttom00c10c00evaluator1"};
# vbttom00c10c01bindtocode
    $Awfif::memes-> {binds}{vbttom00c10c01evaluator} = $Awfif::memes-> {bh}{"vbttom00c10c01evaluator1"};
# vbttom01ncbindtocode
    $Awfif::memes-> {binds}{vbttom01ncevaluator} = $Awfif::memes-> {bh}{"vbttom01ncevaluator1"};
# vbttom01c00bindtocode
    $Awfif::memes-> {binds}{vbttom01c00evaluator} = $Awfif::memes-> {bh}{"vbttom01c00evaluator1"};
# vbttom01c00c02bindtocode
    $Awfif::memes-> {binds}{vbttom01c00c02evaluator} = $Awfif::memes-> {bh}{"vbttom01c00c02evaluator1"};
# vbttom01c00c11bindtocode
    $Awfif::memes-> {binds}{vbttom01c00c11evaluator} = $Awfif::memes-> {bh}{"vbttom01c00c11evaluator1"};
# vbttom01c00c01bindtocode
    $Awfif::memes-> {binds}{vbttom01c00c01evaluator} = $Awfif::memes-> {bh}{"vbttom01c00c01evaluator1"};
# vbttom01c00c01c02bindtocode
    $Awfif::memes-> {binds}{vbttom01c00c01c02evaluator} = $Awfif::memes-> {bh}{"vbttom01c00c01c02evaluator1"};
# vbttom01c00c01c11bindtocode
    $Awfif::memes-> {binds}{vbttom01c00c01c11evaluator} = $Awfif::memes-> {bh}{"vbttom01c00c01c11evaluator1"};
# vbttom01c00c01c11c02bindtocode
    $Awfif::memes-> {binds}{vbttom01c00c01c11c02evaluator} = $Awfif::memes-> {bh}{"vbttom01c00c01c11c02evaluator1"};
# vbttom01c00c11c02bindtocode
    $Awfif::memes-> {binds}{vbttom01c00c11c02evaluator} = $Awfif::memes-> {bh}{"vbttom01c00c11c02evaluator1"};
# vbttom01c01bindtocode
    $Awfif::memes-> {binds}{vbttom01c01evaluator} = $Awfif::memes-> {bh}{"vbttom01c01evaluator1"};
# vbttom01c11bindtocode
    $Awfif::memes-> {binds}{vbttom01c11evaluator} = $Awfif::memes-> {bh}{"vbttom01c11evaluator1"};
# vbttom01c01c11bindtocode
    $Awfif::memes-> {binds}{vbttom01c01c11evaluator} = $Awfif::memes-> {bh}{"vbttom01c01c11evaluator1"};
# vbttom01c02bindtocode
    $Awfif::memes-> {binds}{vbttom01c02evaluator} = $Awfif::memes-> {bh}{"vbttom01c02evaluator1"};
# vbttom01c01c11c02bindtocode
    $Awfif::memes-> {binds}{vbttom01c01c11c02evaluator} = $Awfif::memes-> {bh}{"vbttom01c01c11c02evaluator1"};
# vbttom01c01c02bindtocode
    $Awfif::memes-> {binds}{vbttom01c01c02evaluator} = $Awfif::memes-> {bh}{"vbttom01c01c02evaluator1"};
# vbttom01c11c02bindtocode
    $Awfif::memes-> {binds}{vbttom01c11c02evaluator} = $Awfif::memes-> {bh}{"vbttom01c11c02evaluator1"};
# vbttom09ncbindtocode
    $Awfif::memes-> {binds}{vbttom09ncevaluator} = $Awfif::memes-> {bh}{"vbttom09ncevaluator1"};
# vbttom09c09bindtocode
    $Awfif::memes-> {binds}{vbttom09c09evaluator} = $Awfif::memes-> {bh}{"vbttom09c09evaluator1"};
# vbttom09c09c08bindtocode
    $Awfif::memes-> {binds}{vbttom09c09c08evaluator} = $Awfif::memes-> {bh}{"vbttom09c09c08evaluator1"};
# vbttom09c08bindtocode
    $Awfif::memes-> {binds}{vbttom09c08evaluator} = $Awfif::memes-> {bh}{"vbttom09c08evaluator1"};
# vbttom09c19bindtocode
    $Awfif::memes-> {binds}{vbttom09c19evaluator} = $Awfif::memes-> {bh}{"vbttom09c19evaluator1"};
# vbttom09c19c09bindtocode
    $Awfif::memes-> {binds}{vbttom09c19c09evaluator} = $Awfif::memes-> {bh}{"vbttom09c19c09evaluator1"};
# vbttom09c19c08bindtocode
    $Awfif::memes-> {binds}{vbttom09c19c08evaluator} = $Awfif::memes-> {bh}{"vbttom09c19c08evaluator1"};
# vbttom19ncbindtocode
    $Awfif::memes-> {binds}{vbttom19ncevaluator} = $Awfif::memes-> {bh}{"vbttom19ncevaluator1"};
# vbttom19c09bindtocode
    $Awfif::memes-> {binds}{vbttom19c09evaluator} = $Awfif::memes-> {bh}{"vbttom19c09evaluator1"};
# vbttom19c09c29bindtocode
    $Awfif::memes-> {binds}{vbttom19c09c29evaluator} = $Awfif::memes-> {bh}{"vbttom19c09c29evaluator1"};
# vbttom19c09c18bindtocode
    $Awfif::memes-> {binds}{vbttom19c09c18evaluator} = $Awfif::memes-> {bh}{"vbttom19c09c18evaluator1"};
# vbttom19c09c19bindtocode
    $Awfif::memes-> {binds}{vbttom19c09c19evaluator} = $Awfif::memes-> {bh}{"vbttom19c09c19evaluator1"};
# vbttom19c09c19c29bindtocode
    $Awfif::memes-> {binds}{vbttom19c09c19c29evaluator} = $Awfif::memes-> {bh}{"vbttom19c09c19c29evaluator1"};
# vbttom19c09c19c18bindtocode
    $Awfif::memes-> {binds}{vbttom19c09c19c18evaluator} = $Awfif::memes-> {bh}{"vbttom19c09c19c18evaluator1"};
# vbttom19c09c19c18c29bindtocode
    $Awfif::memes-> {binds}{vbttom19c09c19c18c29evaluator} = $Awfif::memes-> {bh}{"vbttom19c09c19c18c29evaluator1"};
# vbttom19c09c18c29bindtocode
    $Awfif::memes-> {binds}{vbttom19c09c18c29evaluator} = $Awfif::memes-> {bh}{"vbttom19c09c18c29evaluator1"};
# vbttom19c19bindtocode
    $Awfif::memes-> {binds}{vbttom19c19evaluator} = $Awfif::memes-> {bh}{"vbttom19c19evaluator1"};
# vbttom19c18bindtocode
    $Awfif::memes-> {binds}{vbttom19c18evaluator} = $Awfif::memes-> {bh}{"vbttom19c18evaluator1"};
# vbttom19c19c18bindtocode
    $Awfif::memes-> {binds}{vbttom19c19c18evaluator} = $Awfif::memes-> {bh}{"vbttom19c19c18evaluator1"};
# vbttom19c29bindtocode
    $Awfif::memes-> {binds}{vbttom19c29evaluator} = $Awfif::memes-> {bh}{"vbttom19c29evaluator1"};
# vbttom19c19c18c29bindtocode
    $Awfif::memes-> {binds}{vbttom19c19c18c29evaluator} = $Awfif::memes-> {bh}{"vbttom19c19c18c29evaluator1"};
# vbttom19c19c29bindtocode
    $Awfif::memes-> {binds}{vbttom19c19c29evaluator} = $Awfif::memes-> {bh}{"vbttom19c19c29evaluator1"};
# vbttom19c18c29bindtocode
    $Awfif::memes-> {binds}{vbttom19c18c29evaluator} = $Awfif::memes-> {bh}{"vbttom19c18c29evaluator1"};
# vbttom99ncbindtocode
    $Awfif::memes-> {binds}{vbttom99ncevaluator} = $Awfif::memes-> {bh}{"vbttom99ncevaluator1"};
# vbttom99c99bindtocode
    $Awfif::memes-> {binds}{vbttom99c99evaluator} = $Awfif::memes-> {bh}{"vbttom99c99evaluator1"};
# vbttom99c99c98bindtocode
    $Awfif::memes-> {binds}{vbttom99c99c98evaluator} = $Awfif::memes-> {bh}{"vbttom99c99c98evaluator1"};
# vbttom99c98bindtocode
    $Awfif::memes-> {binds}{vbttom99c98evaluator} = $Awfif::memes-> {bh}{"vbttom99c98evaluator1"};
# vbttom99c89bindtocode
    $Awfif::memes-> {binds}{vbttom99c89evaluator} = $Awfif::memes-> {bh}{"vbttom99c89evaluator1"};
# vbttom99c89c99bindtocode
    $Awfif::memes-> {binds}{vbttom99c89c99evaluator} = $Awfif::memes-> {bh}{"vbttom99c89c99evaluator1"};
# vbttom99c89c98bindtocode
    $Awfif::memes-> {binds}{vbttom99c89c98evaluator} = $Awfif::memes-> {bh}{"vbttom99c89c98evaluator1"};
# vbttom98ncbindtocode
    $Awfif::memes-> {binds}{vbttom98ncevaluator} = $Awfif::memes-> {bh}{"vbttom98ncevaluator1"};
# vbttom98c99bindtocode
    $Awfif::memes-> {binds}{vbttom98c99evaluator} = $Awfif::memes-> {bh}{"vbttom98c99evaluator1"};
# vbttom98c99c97bindtocode
    $Awfif::memes-> {binds}{vbttom98c99c97evaluator} = $Awfif::memes-> {bh}{"vbttom98c99c97evaluator1"};
# vbttom98c99c88bindtocode
    $Awfif::memes-> {binds}{vbttom98c99c88evaluator} = $Awfif::memes-> {bh}{"vbttom98c99c88evaluator1"};
# vbttom98c99c98bindtocode
    $Awfif::memes-> {binds}{vbttom98c99c98evaluator} = $Awfif::memes-> {bh}{"vbttom98c99c98evaluator1"};
# vbttom98c99c98c97bindtocode
    $Awfif::memes-> {binds}{vbttom98c99c98c97evaluator} = $Awfif::memes-> {bh}{"vbttom98c99c98c97evaluator1"};
# vbttom98c99c98c88bindtocode
    $Awfif::memes-> {binds}{vbttom98c99c98c88evaluator} = $Awfif::memes-> {bh}{"vbttom98c99c98c88evaluator1"};
# vbttom98c99c98c88c97bindtocode
    $Awfif::memes-> {binds}{vbttom98c99c98c88c97evaluator} = $Awfif::memes-> {bh}{"vbttom98c99c98c88c97evaluator1"};
# vbttom98c99c88c97bindtocode
    $Awfif::memes-> {binds}{vbttom98c99c88c97evaluator} = $Awfif::memes-> {bh}{"vbttom98c99c88c97evaluator1"};
# vbttom98c98bindtocode
    $Awfif::memes-> {binds}{vbttom98c98evaluator} = $Awfif::memes-> {bh}{"vbttom98c98evaluator1"};
# vbttom98c88bindtocode
    $Awfif::memes-> {binds}{vbttom98c88evaluator} = $Awfif::memes-> {bh}{"vbttom98c88evaluator1"};
# vbttom98c98c88bindtocode
    $Awfif::memes-> {binds}{vbttom98c98c88evaluator} = $Awfif::memes-> {bh}{"vbttom98c98c88evaluator1"};
# vbttom98c97bindtocode
    $Awfif::memes-> {binds}{vbttom98c97evaluator} = $Awfif::memes-> {bh}{"vbttom98c97evaluator1"};
# vbttom98c98c88c97bindtocode
    $Awfif::memes-> {binds}{vbttom98c98c88c97evaluator} = $Awfif::memes-> {bh}{"vbttom98c98c88c97evaluator1"};
# vbttom98c98c97bindtocode
    $Awfif::memes-> {binds}{vbttom98c98c97evaluator} = $Awfif::memes-> {bh}{"vbttom98c98c97evaluator1"};
# vbttom98c88c97bindtocode
    $Awfif::memes-> {binds}{vbttom98c88c97evaluator} = $Awfif::memes-> {bh}{"vbttom98c88c97evaluator1"};
# vbttom90ncbindtocode
    $Awfif::memes-> {binds}{vbttom90ncevaluator} = $Awfif::memes-> {bh}{"vbttom90ncevaluator1"};
# vbttom90c90bindtocode
    $Awfif::memes-> {binds}{vbttom90c90evaluator} = $Awfif::memes-> {bh}{"vbttom90c90evaluator1"};
# vbttom90c90c91bindtocode
    $Awfif::memes-> {binds}{vbttom90c90c91evaluator} = $Awfif::memes-> {bh}{"vbttom90c90c91evaluator1"};
# vbttom90c91bindtocode
    $Awfif::memes-> {binds}{vbttom90c91evaluator} = $Awfif::memes-> {bh}{"vbttom90c91evaluator1"};
# vbttom90c80bindtocode
    $Awfif::memes-> {binds}{vbttom90c80evaluator} = $Awfif::memes-> {bh}{"vbttom90c80evaluator1"};
# vbttom90c80c90bindtocode
    $Awfif::memes-> {binds}{vbttom90c80c90evaluator} = $Awfif::memes-> {bh}{"vbttom90c80c90evaluator1"};
# vbttom90c80c91bindtocode
    $Awfif::memes-> {binds}{vbttom90c80c91evaluator} = $Awfif::memes-> {bh}{"vbttom90c80c91evaluator1"};
# vbttom10ncbindtocode
    $Awfif::memes-> {binds}{vbttom10ncevaluator} = $Awfif::memes-> {bh}{"vbttom10ncevaluator1"};
# vbttom10c20bindtocode
    $Awfif::memes-> {binds}{vbttom10c20evaluator} = $Awfif::memes-> {bh}{"vbttom10c20evaluator1"};
# vbttom10c20c00bindtocode
    $Awfif::memes-> {binds}{vbttom10c20c00evaluator} = $Awfif::memes-> {bh}{"vbttom10c20c00evaluator1"};
# vbttom10c20c11bindtocode
    $Awfif::memes-> {binds}{vbttom10c20c11evaluator} = $Awfif::memes-> {bh}{"vbttom10c20c11evaluator1"};
# vbttom10c20c10bindtocode
    $Awfif::memes-> {binds}{vbttom10c20c10evaluator} = $Awfif::memes-> {bh}{"vbttom10c20c10evaluator1"};
# vbttom10c20c10c00bindtocode
    $Awfif::memes-> {binds}{vbttom10c20c10c00evaluator} = $Awfif::memes-> {bh}{"vbttom10c20c10c00evaluator1"};
# vbttom10c20c10c11bindtocode
    $Awfif::memes-> {binds}{vbttom10c20c10c11evaluator} = $Awfif::memes-> {bh}{"vbttom10c20c10c11evaluator1"};
# vbttom10c20c10c11c00bindtocode
    $Awfif::memes-> {binds}{vbttom10c20c10c11c00evaluator} = $Awfif::memes-> {bh}{"vbttom10c20c10c11c00evaluator1"};
# vbttom10c20c11c00bindtocode
    $Awfif::memes-> {binds}{vbttom10c20c11c00evaluator} = $Awfif::memes-> {bh}{"vbttom10c20c11c00evaluator1"};
# vbttom10c10bindtocode
    $Awfif::memes-> {binds}{vbttom10c10evaluator} = $Awfif::memes-> {bh}{"vbttom10c10evaluator1"};
# vbttom10c11bindtocode
    $Awfif::memes-> {binds}{vbttom10c11evaluator} = $Awfif::memes-> {bh}{"vbttom10c11evaluator1"};
# vbttom10c10c11bindtocode
    $Awfif::memes-> {binds}{vbttom10c10c11evaluator} = $Awfif::memes-> {bh}{"vbttom10c10c11evaluator1"};
# vbttom10c00bindtocode
    $Awfif::memes-> {binds}{vbttom10c00evaluator} = $Awfif::memes-> {bh}{"vbttom10c00evaluator1"};
# vbttom10c10c11c00bindtocode
    $Awfif::memes-> {binds}{vbttom10c10c11c00evaluator} = $Awfif::memes-> {bh}{"vbttom10c10c11c00evaluator1"};
# vbttom10c10c00bindtocode
    $Awfif::memes-> {binds}{vbttom10c10c00evaluator} = $Awfif::memes-> {bh}{"vbttom10c10c00evaluator1"};
# vbttom10c11c00bindtocode
    $Awfif::memes-> {binds}{vbttom10c11c00evaluator} = $Awfif::memes-> {bh}{"vbttom10c11c00evaluator1"};
# vbttom11ncbindtocode
    $Awfif::memes-> {binds}{vbttom11ncevaluator} = $Awfif::memes-> {bh}{"vbttom11ncevaluator1"};
# vbttom11c21bindtocode
    $Awfif::memes-> {binds}{vbttom11c21evaluator} = $Awfif::memes-> {bh}{"vbttom11c21evaluator1"};
# vbttom11c21c01bindtocode
    $Awfif::memes-> {binds}{vbttom11c21c01evaluator} = $Awfif::memes-> {bh}{"vbttom11c21c01evaluator1"};
# vbttom11c21c12bindtocode
    $Awfif::memes-> {binds}{vbttom11c21c12evaluator} = $Awfif::memes-> {bh}{"vbttom11c21c12evaluator1"};
# vbttom11c21c11bindtocode
    $Awfif::memes-> {binds}{vbttom11c21c11evaluator} = $Awfif::memes-> {bh}{"vbttom11c21c11evaluator1"};
# vbttom11c21c11c01bindtocode
    $Awfif::memes-> {binds}{vbttom11c21c11c01evaluator} = $Awfif::memes-> {bh}{"vbttom11c21c11c01evaluator1"};
# vbttom11c21c11c12bindtocode
    $Awfif::memes-> {binds}{vbttom11c21c11c12evaluator} = $Awfif::memes-> {bh}{"vbttom11c21c11c12evaluator1"};
# vbttom11c21c11c12c01bindtocode
    $Awfif::memes-> {binds}{vbttom11c21c11c12c01evaluator} = $Awfif::memes-> {bh}{"vbttom11c21c11c12c01evaluator1"};
# vbttom11c21c12c01bindtocode
    $Awfif::memes-> {binds}{vbttom11c21c12c01evaluator} = $Awfif::memes-> {bh}{"vbttom11c21c12c01evaluator1"};
# vbttom11c11bindtocode
    $Awfif::memes-> {binds}{vbttom11c11evaluator} = $Awfif::memes-> {bh}{"vbttom11c11evaluator1"};
# vbttom11c12bindtocode
    $Awfif::memes-> {binds}{vbttom11c12evaluator} = $Awfif::memes-> {bh}{"vbttom11c12evaluator1"};
# vbttom11c11c12bindtocode
    $Awfif::memes-> {binds}{vbttom11c11c12evaluator} = $Awfif::memes-> {bh}{"vbttom11c11c12evaluator1"};
# vbttom11c01bindtocode
    $Awfif::memes-> {binds}{vbttom11c01evaluator} = $Awfif::memes-> {bh}{"vbttom11c01evaluator1"};
# vbttom11c11c12c01bindtocode
    $Awfif::memes-> {binds}{vbttom11c11c12c01evaluator} = $Awfif::memes-> {bh}{"vbttom11c11c12c01evaluator1"};
# vbttom11c11c01bindtocode
    $Awfif::memes-> {binds}{vbttom11c11c01evaluator} = $Awfif::memes-> {bh}{"vbttom11c11c01evaluator1"};
# vbttom11c12c01bindtocode
    $Awfif::memes-> {binds}{vbttom11c12c01evaluator} = $Awfif::memes-> {bh}{"vbttom11c12c01evaluator1"};
# vbttom11c10bindtocode
    $Awfif::memes-> {binds}{vbttom11c10evaluator} = $Awfif::memes-> {bh}{"vbttom11c10evaluator1"};
# vbttom11c21c10bindtocode
    $Awfif::memes-> {binds}{vbttom11c21c10evaluator} = $Awfif::memes-> {bh}{"vbttom11c21c10evaluator1"};
# vbttom11c21c01c10bindtocode
    $Awfif::memes-> {binds}{vbttom11c21c01c10evaluator} = $Awfif::memes-> {bh}{"vbttom11c21c01c10evaluator1"};
# vbttom11c21c12c10bindtocode
    $Awfif::memes-> {binds}{vbttom11c21c12c10evaluator} = $Awfif::memes-> {bh}{"vbttom11c21c12c10evaluator1"};
# vbttom11c21c11c10bindtocode
    $Awfif::memes-> {binds}{vbttom11c21c11c10evaluator} = $Awfif::memes-> {bh}{"vbttom11c21c11c10evaluator1"};
# vbttom11c21c11c01c10bindtocode
    $Awfif::memes-> {binds}{vbttom11c21c11c01c10evaluator} = $Awfif::memes-> {bh}{"vbttom11c21c11c01c10evaluator1"};
# vbttom11c21c11c12c10bindtocode
    $Awfif::memes-> {binds}{vbttom11c21c11c12c10evaluator} = $Awfif::memes-> {bh}{"vbttom11c21c11c12c10evaluator1"};
# vbttom11c21c11c12c01c10bindtocode
    $Awfif::memes-> {binds}{vbttom11c21c11c12c01c10evaluator} = $Awfif::memes-> {bh}{"vbttom11c21c11c12c01c10evaluator1"};
# vbttom11c21c12c01c10bindtocode
    $Awfif::memes-> {binds}{vbttom11c21c12c01c10evaluator} = $Awfif::memes-> {bh}{"vbttom11c21c12c01c10evaluator1"};
# vbttom11c11c10bindtocode
    $Awfif::memes-> {binds}{vbttom11c11c10evaluator} = $Awfif::memes-> {bh}{"vbttom11c11c10evaluator1"};
# vbttom11c12c10bindtocode
    $Awfif::memes-> {binds}{vbttom11c12c10evaluator} = $Awfif::memes-> {bh}{"vbttom11c12c10evaluator1"};
# vbttom11c11c12c10bindtocode
    $Awfif::memes-> {binds}{vbttom11c11c12c10evaluator} = $Awfif::memes-> {bh}{"vbttom11c11c12c10evaluator1"};
# vbttom11c01c10bindtocode
    $Awfif::memes-> {binds}{vbttom11c01c10evaluator} = $Awfif::memes-> {bh}{"vbttom11c01c10evaluator1"};
# vbttom11c11c12c01c10bindtocode
    $Awfif::memes-> {binds}{vbttom11c11c12c01c10evaluator} = $Awfif::memes-> {bh}{"vbttom11c11c12c01c10evaluator1"};
# vbttom11c11c01c10bindtocode
    $Awfif::memes-> {binds}{vbttom11c11c01c10evaluator} = $Awfif::memes-> {bh}{"vbttom11c11c01c10evaluator1"};
# vbttom11c12c01c10bindtocode
    $Awfif::memes-> {binds}{vbttom11c12c01c10evaluator} = $Awfif::memes-> {bh}{"vbttom11c12c01c10evaluator1"};
# vbttoamsbindtocode
    $Awfif::memes-> {binds}{vbttoamsevaluator} = $Awfif::memes-> {bh}{"vbttoamsevaluator1"};
# vbttoamebindtocode
    $Awfif::memes-> {binds}{vbttoameevaluator} = $Awfif::memes-> {bh}{"vbttoameevaluator1"};
# vbttoamwbindtocode
    $Awfif::memes-> {binds}{vbttoamwevaluator} = $Awfif::memes-> {bh}{"vbttoamwevaluator1"};
# vbttoamrbindtocode
    $Awfif::memes-> {binds}{vbttoamrevaluator} = $Awfif::memes-> {bh}{"vbttoamrevaluator1"};
# vbttoapcbindtocode
    $Awfif::memes-> {binds}{vbttoapcevaluator} = $Awfif::memes-> {bh}{"vbttoapcevaluator1"};
# ivbttoamsbindtocode
    $Awfif::memes-> {binds}{"ivbttoamsevaluator"} = $Awfif::memes-> {bh}{"ivbttoamsevaluator1"};
# ivbttoamnbindtocode
    $Awfif::memes-> {binds}{"ivbttoamnevaluator"} = $Awfif::memes-> {bh}{"ivbttoamnevaluator1"};
# ivbttoamebindtocode
    $Awfif::memes-> {binds}{"ivbttoameevaluator"} = $Awfif::memes-> {bh}{"ivbttoameevaluator1"};
# ivbttoamwbindtocode
    $Awfif::memes-> {binds}{"ivbttoamwevaluator"} = $Awfif::memes-> {bh}{"ivbttoamwevaluator1"};
# ivbttoamrbindtocode
    $Awfif::memes-> {binds}{"ivbttoamrevaluator"} = $Awfif::memes-> {bh}{"ivbttoamrevaluator1"};
# ivbttoapcbindtocode
    $Awfif::memes-> {binds}{"ivbttoapcevaluator"} = $Awfif::memes-> {bh}{"ivbttoapcevaluator1"};
# ivbttom00ncbindtocode
    $Awfif::memes-> {binds}{"ivbttom00ncevaluator"} = $Awfif::memes-> {bh}{"ivbttom00ncevaluator1"};
# ivbttom0recbindtocode
    $Awfif::memes-> {binds}{"ivbttom0recevaluator"} = $Awfif::memes-> {bh}{"ivbttom0recevaluator1"};
# ivbttom00c10c00bindtocode
    $Awfif::memes-> {binds}{"ivbttom00c10c00evaluator"} = $Awfif::memes-> {bh}{"ivbttom00c10c00evaluator1"};
# ivbttom00c10c01bindtocode
    $Awfif::memes-> {binds}{"ivbttom00c10c01evaluator"} = $Awfif::memes-> {bh}{"ivbttom00c10c01evaluator1"};
# ivbttom00c00bindtocode
    $Awfif::memes-> {binds}{"ivbttom00c00evaluator"} = $Awfif::memes-> {bh}{"ivbttom00c00evaluator1"};
# ivbttom00c00c01bindtocode
    $Awfif::memes-> {binds}{"ivbttom00c00c01evaluator"} = $Awfif::memes-> {bh}{"ivbttom00c00c01evaluator1"};
# ivbttom00c01bindtocode
    $Awfif::memes-> {binds}{"ivbttom00c01evaluator"} = $Awfif::memes-> {bh}{"ivbttom00c01evaluator1"};
# ivbttom00c10bindtocode
    $Awfif::memes-> {binds}{"ivbttom00c10evaluator"} = $Awfif::memes-> {bh}{"ivbttom00c10evaluator1"};
# ivbttom00c10c01c00bindtocode
    $Awfif::memes-> {binds}{"ivbttom00c10c01c00evaluator"} = $Awfif::memes-> {bh}{"ivbttom00c10c01c00evaluator1"};
# vbttom00c10c01c00bindtocode
    $Awfif::memes-> {binds}{vbttom00c10c01c00evaluator} = $Awfif::memes-> {bh}{"vbttom00c10c01c00evaluator1"};
# ivbttom01ncbindtocode
    $Awfif::memes-> {binds}{"ivbttom01ncevaluator"} = $Awfif::memes-> {bh}{"ivbttom01ncevaluator1"};
# ivbttom01c00bindtocode
    $Awfif::memes-> {binds}{"ivbttom01c00evaluator"} = $Awfif::memes-> {bh}{"ivbttom01c00evaluator1"};
# ivbttom01c00c01bindtocode
    $Awfif::memes-> {binds}{"ivbttom01c00c01evaluator"} = $Awfif::memes-> {bh}{"ivbttom01c00c01evaluator1"};
# ivbttom01c00c01c02bindtocode
    $Awfif::memes-> {binds}{"ivbttom01c00c01c02evaluator"} = $Awfif::memes-> {bh}{"ivbttom01c00c01c02evaluator1"};
# ivbttom01c00c01c11bindtocode
    $Awfif::memes-> {binds}{"ivbttom01c00c01c11evaluator"} = $Awfif::memes-> {bh}{"ivbttom01c00c01c11evaluator1"};
# ivbttom01c00c01c11c02bindtocode
    $Awfif::memes-> {binds}{"ivbttom01c00c01c11c02evaluator"} = $Awfif::memes-> {bh}{"ivbttom01c00c01c11c02evaluator1"};
# ivbttom01c00c02bindtocode
    $Awfif::memes-> {binds}{"ivbttom01c00c02evaluator"} = $Awfif::memes-> {bh}{"ivbttom01c00c02evaluator1"};
# ivbttom01c00c11bindtocode
    $Awfif::memes-> {binds}{"ivbttom01c00c11evaluator"} = $Awfif::memes-> {bh}{"ivbttom01c00c11evaluator1"};
# ivbttom01c00c11c02bindtocode
    $Awfif::memes-> {binds}{"ivbttom01c00c11c02evaluator"} = $Awfif::memes-> {bh}{"ivbttom01c00c11c02evaluator1"};
# ivbttom01c01bindtocode
    $Awfif::memes-> {binds}{"ivbttom01c01evaluator"} = $Awfif::memes-> {bh}{"ivbttom01c01evaluator1"};
# ivbttom01c11bindtocode
    $Awfif::memes-> {binds}{"ivbttom01c11evaluator"} = $Awfif::memes-> {bh}{"ivbttom01c11evaluator1"};
# ivbttom01c01c11bindtocode
    $Awfif::memes-> {binds}{"ivbttom01c01c11evaluator"} = $Awfif::memes-> {bh}{"ivbttom01c01c11evaluator1"};
# ivbttom01c02bindtocode
    $Awfif::memes-> {binds}{"ivbttom01c02evaluator"} = $Awfif::memes-> {bh}{"ivbttom01c02evaluator1"};
# ivbttom01c01c11c02bindtocode
    $Awfif::memes-> {binds}{"ivbttom01c01c11c02evaluator"} = $Awfif::memes-> {bh}{"ivbttom01c01c11c02evaluator1"};
# ivbttom01c01c02bindtocode
    $Awfif::memes-> {binds}{"ivbttom01c01c02evaluator"} = $Awfif::memes-> {bh}{"ivbttom01c01c02evaluator1"};
# ivbttom01c11c02bindtocode
    $Awfif::memes-> {binds}{"ivbttom01c11c02evaluator"} = $Awfif::memes-> {bh}{"ivbttom01c11c02evaluator1"};
# ivbttom09ncbindtocode
    $Awfif::memes-> {binds}{"ivbttom09ncevaluator"} = $Awfif::memes-> {bh}{"ivbttom09ncevaluator1"};
# ivbttom09c19c09bindtocode
    $Awfif::memes-> {binds}{"ivbttom09c19c09evaluator"} = $Awfif::memes-> {bh}{"ivbttom09c19c09evaluator1"};
# ivbttom09c19c08bindtocode
    $Awfif::memes-> {binds}{"ivbttom09c19c08evaluator"} = $Awfif::memes-> {bh}{"ivbttom09c19c08evaluator1"};
# ivbttom09c09bindtocode
    $Awfif::memes-> {binds}{"ivbttom09c09evaluator"} = $Awfif::memes-> {bh}{"ivbttom09c09evaluator1"};
# ivbttom09c09c08bindtocode
    $Awfif::memes-> {binds}{"ivbttom09c09c08evaluator"} = $Awfif::memes-> {bh}{"ivbttom09c09c08evaluator1"};
# ivbttom09c08bindtocode
    $Awfif::memes-> {binds}{"ivbttom09c08evaluator"} = $Awfif::memes-> {bh}{"ivbttom09c08evaluator1"};
# ivbttom09c19bindtocode
    $Awfif::memes-> {binds}{"ivbttom09c19evaluator"} = $Awfif::memes-> {bh}{"ivbttom09c19evaluator1"};
# ivbttom09c19c08c09bindtocode
    $Awfif::memes-> {binds}{"ivbttom09c19c08c09evaluator"} = $Awfif::memes-> {bh}{"ivbttom09c19c08c09evaluator1"};
# vbttom09c19c08c09bindtocode
    $Awfif::memes-> {binds}{vbttom09c19c08c09evaluator} = $Awfif::memes-> {bh}{"vbttom09c19c08c09evaluator1"};
# ivbttom19ncbindtocode
    $Awfif::memes-> {binds}{"ivbttom19ncevaluator"} = $Awfif::memes-> {bh}{"ivbttom19ncevaluator1"};
# ivbttom19c09bindtocode
    $Awfif::memes-> {binds}{"ivbttom19c09evaluator"} = $Awfif::memes-> {bh}{"ivbttom19c09evaluator1"};
# ivbttom19c09c19bindtocode
    $Awfif::memes-> {binds}{"ivbttom19c09c19evaluator"} = $Awfif::memes-> {bh}{"ivbttom19c09c19evaluator1"};
# ivbttom19c09c19c29bindtocode
    $Awfif::memes-> {binds}{"ivbttom19c09c19c29evaluator"} = $Awfif::memes-> {bh}{"ivbttom19c09c19c29evaluator1"};
# ivbttom19c09c19c18bindtocode
    $Awfif::memes-> {binds}{"ivbttom19c09c19c18evaluator"} = $Awfif::memes-> {bh}{"ivbttom19c09c19c18evaluator1"};
# ivbttom19c09c19c18c29bindtocode
    $Awfif::memes-> {binds}{"ivbttom19c09c19c18c29evaluator"} = $Awfif::memes-> {bh}{"ivbttom19c09c19c18c29evaluator1"};
# ivbttom19c09c29bindtocode
    $Awfif::memes-> {binds}{"ivbttom19c09c29evaluator"} = $Awfif::memes-> {bh}{"ivbttom19c09c29evaluator1"};
# ivbttom19c09c18bindtocode
    $Awfif::memes-> {binds}{"ivbttom19c09c18evaluator"} = $Awfif::memes-> {bh}{"ivbttom19c09c18evaluator1"};
# ivbttom19c09c18c29bindtocode
    $Awfif::memes-> {binds}{"ivbttom19c09c18c29evaluator"} = $Awfif::memes-> {bh}{"ivbttom19c09c18c29evaluator1"};
# ivbttom19c19bindtocode
    $Awfif::memes-> {binds}{"ivbttom19c19evaluator"} = $Awfif::memes-> {bh}{"ivbttom19c19evaluator1"};
# ivbttom19c18bindtocode
    $Awfif::memes-> {binds}{"ivbttom19c18evaluator"} = $Awfif::memes-> {bh}{"ivbttom19c18evaluator1"};
# ivbttom19c19c18bindtocode
    $Awfif::memes-> {binds}{"ivbttom19c19c18evaluator"} = $Awfif::memes-> {bh}{"ivbttom19c19c18evaluator1"};
# ivbttom19c29bindtocode
    $Awfif::memes-> {binds}{"ivbttom19c29evaluator"} = $Awfif::memes-> {bh}{"ivbttom19c29evaluator1"};
# ivbttom19c19c18c29bindtocode
    $Awfif::memes-> {binds}{"ivbttom19c19c18c29evaluator"} = $Awfif::memes-> {bh}{"ivbttom19c19c18c29evaluator1"};
# ivbttom19c19c29bindtocode
    $Awfif::memes-> {binds}{"ivbttom19c19c29evaluator"} = $Awfif::memes-> {bh}{"ivbttom19c19c29evaluator1"};
# ivbttom19c18c29bindtocode
    $Awfif::memes-> {binds}{"ivbttom19c18c29evaluator"} = $Awfif::memes-> {bh}{"ivbttom19c18c29evaluator1"};
# ivbttom99ncbindtocode
    $Awfif::memes-> {binds}{"ivbttom99ncevaluator"} = $Awfif::memes-> {bh}{"ivbttom99ncevaluator1"};
# ivbttom99c89c99bindtocode
    $Awfif::memes-> {binds}{"ivbttom99c89c99evaluator"} = $Awfif::memes-> {bh}{"ivbttom99c89c99evaluator1"};
# ivbttom99c89c98bindtocode
    $Awfif::memes-> {binds}{"ivbttom99c89c98evaluator"} = $Awfif::memes-> {bh}{"ivbttom99c89c98evaluator1"};
# ivbttom99c99bindtocode
    $Awfif::memes-> {binds}{"ivbttom99c99evaluator"} = $Awfif::memes-> {bh}{"ivbttom99c99evaluator1"};
# ivbttom99c99c98bindtocode
    $Awfif::memes-> {binds}{"ivbttom99c99c98evaluator"} = $Awfif::memes-> {bh}{"ivbttom99c99c98evaluator1"};
# ivbttom99c98bindtocode
    $Awfif::memes-> {binds}{"ivbttom99c98evaluator"} = $Awfif::memes-> {bh}{"ivbttom99c98evaluator1"};
# ivbttom99c89bindtocode
    $Awfif::memes-> {binds}{"ivbttom99c89evaluator"} = $Awfif::memes-> {bh}{"ivbttom99c89evaluator1"};
# ivbttom99c89c98c99bindtocode
    $Awfif::memes-> {binds}{"ivbttom99c89c98c99evaluator"} = $Awfif::memes-> {bh}{"ivbttom99c89c98c99evaluator1"};
# vbttom99c89c98c99bindtocode
    $Awfif::memes-> {binds}{vbttom99c89c98c99evaluator} = $Awfif::memes-> {bh}{"vbttom99c89c98c99evaluator1"};
# ivbttom98ncbindtocode
    $Awfif::memes-> {binds}{"ivbttom98ncevaluator"} = $Awfif::memes-> {bh}{"ivbttom98ncevaluator1"};
# ivbttom98c99bindtocode
    $Awfif::memes-> {binds}{"ivbttom98c99evaluator"} = $Awfif::memes-> {bh}{"ivbttom98c99evaluator1"};
# ivbttom98c99c98bindtocode
    $Awfif::memes-> {binds}{"ivbttom98c99c98evaluator"} = $Awfif::memes-> {bh}{"ivbttom98c99c98evaluator1"};
# ivbttom98c99c98c97bindtocode
    $Awfif::memes-> {binds}{"ivbttom98c99c98c97evaluator"} = $Awfif::memes-> {bh}{"ivbttom98c99c98c97evaluator1"};
# ivbttom98c99c98c88bindtocode
    $Awfif::memes-> {binds}{"ivbttom98c99c98c88evaluator"} = $Awfif::memes-> {bh}{"ivbttom98c99c98c88evaluator1"};
# ivbttom98c99c98c88c97bindtocode
    $Awfif::memes-> {binds}{"ivbttom98c99c98c88c97evaluator"} = $Awfif::memes-> {bh}{"ivbttom98c99c98c88c97evaluator1"};
# ivbttom98c99c97bindtocode
    $Awfif::memes-> {binds}{"ivbttom98c99c97evaluator"} = $Awfif::memes-> {bh}{"ivbttom98c99c97evaluator1"};
# ivbttom98c99c88bindtocode
    $Awfif::memes-> {binds}{"ivbttom98c99c88evaluator"} = $Awfif::memes-> {bh}{"ivbttom98c99c88evaluator1"};
# ivbttom98c99c88c97bindtocode
    $Awfif::memes-> {binds}{"ivbttom98c99c88c97evaluator"} = $Awfif::memes-> {bh}{"ivbttom98c99c88c97evaluator1"};
# ivbttom98c98bindtocode
    $Awfif::memes-> {binds}{"ivbttom98c98evaluator"} = $Awfif::memes-> {bh}{"ivbttom98c98evaluator1"};
# ivbttom98c88bindtocode
    $Awfif::memes-> {binds}{"ivbttom98c88evaluator"} = $Awfif::memes-> {bh}{"ivbttom98c88evaluator1"};
# ivbttom98c98c88bindtocode
    $Awfif::memes-> {binds}{"ivbttom98c98c88evaluator"} = $Awfif::memes-> {bh}{"ivbttom98c98c88evaluator1"};
# ivbttom98c97bindtocode
    $Awfif::memes-> {binds}{"ivbttom98c97evaluator"} = $Awfif::memes-> {bh}{"ivbttom98c97evaluator1"};
# ivbttom98c98c88c97bindtocode
    $Awfif::memes-> {binds}{"ivbttom98c98c88c97evaluator"} = $Awfif::memes-> {bh}{"ivbttom98c98c88c97evaluator1"};
# ivbttom98c98c97bindtocode
    $Awfif::memes-> {binds}{"ivbttom98c98c97evaluator"} = $Awfif::memes-> {bh}{"ivbttom98c98c97evaluator1"};
# ivbttom98c88c97bindtocode
    $Awfif::memes-> {binds}{"ivbttom98c88c97evaluator"} = $Awfif::memes-> {bh}{"ivbttom98c88c97evaluator1"};
# ivbttom90ncbindtocode
    $Awfif::memes-> {binds}{"ivbttom90ncevaluator"} = $Awfif::memes-> {bh}{"ivbttom90ncevaluator1"};
# ivbttom90c80c90bindtocode
    $Awfif::memes-> {binds}{"ivbttom90c80c90evaluator"} = $Awfif::memes-> {bh}{"ivbttom90c80c90evaluator1"};
# ivbttom90c80c91bindtocode
    $Awfif::memes-> {binds}{"ivbttom90c80c91evaluator"} = $Awfif::memes-> {bh}{"ivbttom90c80c91evaluator1"};
# ivbttom90c90bindtocode
    $Awfif::memes-> {binds}{"ivbttom90c90evaluator"} = $Awfif::memes-> {bh}{"ivbttom90c90evaluator1"};
# ivbttom90c90c91bindtocode
    $Awfif::memes-> {binds}{"ivbttom90c90c91evaluator"} = $Awfif::memes-> {bh}{"ivbttom90c90c91evaluator1"};
# ivbttom90c91bindtocode
    $Awfif::memes-> {binds}{"ivbttom90c91evaluator"} = $Awfif::memes-> {bh}{"ivbttom90c91evaluator1"};
# ivbttom90c80bindtocode
    $Awfif::memes-> {binds}{"ivbttom90c80evaluator"} = $Awfif::memes-> {bh}{"ivbttom90c80evaluator1"};
# ivbttom90c80c91c90bindtocode
    $Awfif::memes-> {binds}{"ivbttom90c80c91c90evaluator"} = $Awfif::memes-> {bh}{"ivbttom90c80c91c90evaluator1"};
# vbttom90c80c91c90bindtocode
    $Awfif::memes-> {binds}{vbttom90c80c91c90evaluator} = $Awfif::memes-> {bh}{"vbttom90c80c91c90evaluator1"};
# ivbttom10ncbindtocode
    $Awfif::memes-> {binds}{"ivbttom10ncevaluator"} = $Awfif::memes-> {bh}{"ivbttom10ncevaluator1"};
# ivbttom10c20bindtocode
    $Awfif::memes-> {binds}{"ivbttom10c20evaluator"} = $Awfif::memes-> {bh}{"ivbttom10c20evaluator1"};
# ivbttom10c20c10bindtocode
    $Awfif::memes-> {binds}{"ivbttom10c20c10evaluator"} = $Awfif::memes-> {bh}{"ivbttom10c20c10evaluator1"};
# ivbttom10c20c10c00bindtocode
    $Awfif::memes-> {binds}{"ivbttom10c20c10c00evaluator"} = $Awfif::memes-> {bh}{"ivbttom10c20c10c00evaluator1"};
# ivbttom10c20c10c11bindtocode
    $Awfif::memes-> {binds}{"ivbttom10c20c10c11evaluator"} = $Awfif::memes-> {bh}{"ivbttom10c20c10c11evaluator1"};
# ivbttom10c20c10c11c00bindtocode
    $Awfif::memes-> {binds}{"ivbttom10c20c10c11c00evaluator"} = $Awfif::memes-> {bh}{"ivbttom10c20c10c11c00evaluator1"};
# ivbttom10c20c00bindtocode
    $Awfif::memes-> {binds}{"ivbttom10c20c00evaluator"} = $Awfif::memes-> {bh}{"ivbttom10c20c00evaluator1"};
# ivbttom10c20c11bindtocode
    $Awfif::memes-> {binds}{"ivbttom10c20c11evaluator"} = $Awfif::memes-> {bh}{"ivbttom10c20c11evaluator1"};
# ivbttom10c20c11c00bindtocode
    $Awfif::memes-> {binds}{"ivbttom10c20c11c00evaluator"} = $Awfif::memes-> {bh}{"ivbttom10c20c11c00evaluator1"};
# ivbttom10c10bindtocode
    $Awfif::memes-> {binds}{"ivbttom10c10evaluator"} = $Awfif::memes-> {bh}{"ivbttom10c10evaluator1"};
# ivbttom10c11bindtocode
    $Awfif::memes-> {binds}{"ivbttom10c11evaluator"} = $Awfif::memes-> {bh}{"ivbttom10c11evaluator1"};
# ivbttom10c10c11bindtocode
    $Awfif::memes-> {binds}{"ivbttom10c10c11evaluator"} = $Awfif::memes-> {bh}{"ivbttom10c10c11evaluator1"};
# ivbttom10c00bindtocode
    $Awfif::memes-> {binds}{"ivbttom10c00evaluator"} = $Awfif::memes-> {bh}{"ivbttom10c00evaluator1"};
# ivbttom10c10c11c00bindtocode
    $Awfif::memes-> {binds}{"ivbttom10c10c11c00evaluator"} = $Awfif::memes-> {bh}{"ivbttom10c10c11c00evaluator1"};
# ivbttom10c10c00bindtocode
    $Awfif::memes-> {binds}{"ivbttom10c10c00evaluator"} = $Awfif::memes-> {bh}{"ivbttom10c10c00evaluator1"};
# ivbttom10c11c00bindtocode
    $Awfif::memes-> {binds}{"ivbttom10c11c00evaluator"} = $Awfif::memes-> {bh}{"ivbttom10c11c00evaluator1"};
# ivbttom11ncbindtocode
    $Awfif::memes-> {binds}{"ivbttom11ncevaluator"} = $Awfif::memes-> {bh}{"ivbttom11ncevaluator1"};
# ivbttom11c21bindtocode
    $Awfif::memes-> {binds}{"ivbttom11c21evaluator"} = $Awfif::memes-> {bh}{"ivbttom11c21evaluator1"};
# ivbttom11c21c11bindtocode
    $Awfif::memes-> {binds}{"ivbttom11c21c11evaluator"} = $Awfif::memes-> {bh}{"ivbttom11c21c11evaluator1"};
# ivbttom11c21c11c01bindtocode
    $Awfif::memes-> {binds}{"ivbttom11c21c11c01evaluator"} = $Awfif::memes-> {bh}{"ivbttom11c21c11c01evaluator1"};
# ivbttom11c21c11c12bindtocode
    $Awfif::memes-> {binds}{"ivbttom11c21c11c12evaluator"} = $Awfif::memes-> {bh}{"ivbttom11c21c11c12evaluator1"};
# ivbttom11c21c11c12c01bindtocode
    $Awfif::memes-> {binds}{"ivbttom11c21c11c12c01evaluator"} = $Awfif::memes-> {bh}{"ivbttom11c21c11c12c01evaluator1"};
# ivbttom11c21c01bindtocode
    $Awfif::memes-> {binds}{"ivbttom11c21c01evaluator"} = $Awfif::memes-> {bh}{"ivbttom11c21c01evaluator1"};
# ivbttom11c21c12bindtocode
    $Awfif::memes-> {binds}{"ivbttom11c21c12evaluator"} = $Awfif::memes-> {bh}{"ivbttom11c21c12evaluator1"};
# ivbttom11c21c12c01bindtocode
    $Awfif::memes-> {binds}{"ivbttom11c21c12c01evaluator"} = $Awfif::memes-> {bh}{"ivbttom11c21c12c01evaluator1"};
# ivbttom11c11bindtocode
    $Awfif::memes-> {binds}{"ivbttom11c11evaluator"} = $Awfif::memes-> {bh}{"ivbttom11c11evaluator1"};
# ivbttom11c12bindtocode
    $Awfif::memes-> {binds}{"ivbttom11c12evaluator"} = $Awfif::memes-> {bh}{"ivbttom11c12evaluator1"};
# ivbttom11c11c12bindtocode
    $Awfif::memes-> {binds}{"ivbttom11c11c12evaluator"} = $Awfif::memes-> {bh}{"ivbttom11c11c12evaluator1"};
# ivbttom11c01bindtocode
    $Awfif::memes-> {binds}{"ivbttom11c01evaluator"} = $Awfif::memes-> {bh}{"ivbttom11c01evaluator1"};
# ivbttom11c11c12c01bindtocode
    $Awfif::memes-> {binds}{"ivbttom11c11c12c01evaluator"} = $Awfif::memes-> {bh}{"ivbttom11c11c12c01evaluator1"};
# ivbttom11c11c01bindtocode
    $Awfif::memes-> {binds}{"ivbttom11c11c01evaluator"} = $Awfif::memes-> {bh}{"ivbttom11c11c01evaluator1"};
# ivbttom11c12c01bindtocode
    $Awfif::memes-> {binds}{"ivbttom11c12c01evaluator"} = $Awfif::memes-> {bh}{"ivbttom11c12c01evaluator1"};
# ivbttom11c10bindtocode
    $Awfif::memes-> {binds}{"ivbttom11c10evaluator"} = $Awfif::memes-> {bh}{"ivbttom11c10evaluator1"};
# ivbttom11c21c10bindtocode
    $Awfif::memes-> {binds}{"ivbttom11c21c10evaluator"} = $Awfif::memes-> {bh}{"ivbttom11c21c10evaluator1"};
# ivbttom11c21c11c10bindtocode
    $Awfif::memes-> {binds}{"ivbttom11c21c11c10evaluator"} = $Awfif::memes-> {bh}{"ivbttom11c21c11c10evaluator1"};
# ivbttom11c21c11c01c10bindtocode
    $Awfif::memes-> {binds}{"ivbttom11c21c11c01c10evaluator"} = $Awfif::memes-> {bh}{"ivbttom11c21c11c01c10evaluator1"};
# ivbttom11c21c11c12c10bindtocode
    $Awfif::memes-> {binds}{"ivbttom11c21c11c12c10evaluator"} = $Awfif::memes-> {bh}{"ivbttom11c21c11c12c10evaluator1"};
# ivbttom11c21c11c12c01c10bindtocode
    $Awfif::memes-> {binds}{"ivbttom11c21c11c12c01c10evaluator"} = $Awfif::memes-> {bh}{"ivbttom11c21c11c12c01c10evaluator1"};
# ivbttom11c21c01c10bindtocode
    $Awfif::memes-> {binds}{"ivbttom11c21c01c10evaluator"} = $Awfif::memes-> {bh}{"ivbttom11c21c01c10evaluator1"};
# ivbttom11c21c12c10bindtocode
    $Awfif::memes-> {binds}{"ivbttom11c21c12c10evaluator"} = $Awfif::memes-> {bh}{"ivbttom11c21c12c10evaluator1"};
# ivbttom11c21c12c01c10bindtocode
    $Awfif::memes-> {binds}{"ivbttom11c21c12c01c10evaluator"} = $Awfif::memes-> {bh}{"ivbttom11c21c12c01c10evaluator1"};
# ivbttom11c11c10bindtocode
    $Awfif::memes-> {binds}{"ivbttom11c11c10evaluator"} = $Awfif::memes-> {bh}{"ivbttom11c11c10evaluator1"};
# ivbttom11c12c10bindtocode
    $Awfif::memes-> {binds}{"ivbttom11c12c10evaluator"} = $Awfif::memes-> {bh}{"ivbttom11c12c10evaluator1"};
# ivbttom11c11c12c10bindtocode
    $Awfif::memes-> {binds}{"ivbttom11c11c12c10evaluator"} = $Awfif::memes-> {bh}{"ivbttom11c11c12c10evaluator1"};
# ivbttom11c01c10bindtocode
    $Awfif::memes-> {binds}{"ivbttom11c01c10evaluator"} = $Awfif::memes-> {bh}{"ivbttom11c01c10evaluator1"};
# ivbttom11c11c12c01c10bindtocode
    $Awfif::memes-> {binds}{"ivbttom11c11c12c01c10evaluator"} = $Awfif::memes-> {bh}{"ivbttom11c11c12c01c10evaluator1"};
# ivbttom11c11c01c10bindtocode
    $Awfif::memes-> {binds}{"ivbttom11c11c01c10evaluator"} = $Awfif::memes-> {bh}{"ivbttom11c11c01c10evaluator1"};
# ivbttom11c12c01c10bindtocode
    $Awfif::memes-> {binds}{"ivbttom11c12c01c10evaluator"} = $Awfif::memes-> {bh}{"ivbttom11c12c01c10evaluator1"};
# vbttoamnbindtocode
    $Awfif::memes-> {binds}{vbttoamnevaluator} = $Awfif::memes-> {bh}{"vbttoamnevaluator1"};
# devibindtocode
    $Awfif::memes-> {binds}{devinhibitor} = $Awfif::memes-> {bh}{"devinhibitor1"};
# vbtdevibindtocode
    $Awfif::memes-> {binds}{vbtdevinhibitor} = $Awfif::memes-> {bh}{"vbtdevinhibitor1"};
# vbtdevisbindtocode
    $Awfif::memes-> {binds}{vbtdevinspector} = $Awfif::memes-> {bh}{"vbtdevinspector1"};
# devisbindtocode
    $Awfif::memes-> {binds}{devinspector} = $Awfif::memes-> {bh}{"devinspector1"};
    $Awfif::memes-> {binds}{dcnevaluator} = $Awfif::memes-> {bh}{"dcnevaluator1"};
    $Awfif::memes-> {binds}{growthevaluator} = $Awfif::memes-> {bh}{"growthevaluator1"};
# misbindtocode
    $Awfif::memes-> {binds}{misevaluator} = $Awfif::memes-> {bh}{"misevaluator1"};
# misibindtocode
    $Awfif::memes-> {binds}{misinspector} = $Awfif::memes-> {bh}{"misinspector1"};
# mdvbindtocode
    $Awfif::memes-> {binds}{mdvevaluator} = $Awfif::memes-> {bh}{"mdvevaluator1"};
# mdvibindtocode
    $Awfif::memes-> {binds}{mdvinspector} = $Awfif::memes-> {bh}{"mdvinspector1"};
    $Awfif::memes-> {binds}{mkwevaluator} = $Awfif::memes-> {bh}{"mkwevaluator1"};
# mkwibindtocode
    $Awfif::memes-> {binds}{mkwinspector} = $Awfif::memes-> {bh}{"mkwinspector1"};
# miforallebindtocode
    $Awfif::memes-> {binds}{miforallevaluator} = $Awfif::memes-> {bh}{"miforallevaluator1"};
# miforallibindtocode
    $Awfif::memes-> {binds}{miforallinspector} = $Awfif::memes-> {bh}{"miforallinspector1"};
# dassgebindtocode
    $Awfif::memes-> {binds}{dassgevaluator} = $Awfif::memes-> {bh}{"dassgevaluator1"};
# dassgibindtocode
    $Awfif::memes-> {binds}{dassginspector} = $Awfif::memes-> {bh}{"dassginspector1"};
# dascgebindtocode
    $Awfif::memes-> {binds}{dascgevaluator} = $Awfif::memes-> {bh}{"dascgevaluator1"};
# dascgibindtocode
    $Awfif::memes-> {binds}{dascginspector} = $Awfif::memes-> {bh}{"dascginspector1"};
# casesaebindtocode
    $Awfif::memes-> {binds}{casesaevaluator} = $Awfif::memes-> {bh}{"casesaevaluator1"};
# casesaibindtocode
    $Awfif::memes-> {binds}{casesainspector} = $Awfif::memes-> {bh}{"casesainspector1"};
    $Awfif::memes-> {binds}{drevaluator} = $Awfif::memes-> {bh}{"drevaluator1"};
# mstebindtocode
    $Awfif::memes-> {binds}{msalthrevaluator} = $Awfif::memes-> {bh}{"msalthrevaluator1"};
# mgpartebindtocode
    $Awfif::memes-> {binds}{mgpartevaluator} = $Awfif::memes-> {bh}{"mgpartevaluator1"};
# mrddrebindtocode
    $Awfif::memes-> {binds}{mresddrevaluator} = $Awfif::memes-> {bh}{"mresddrevaluator1"};
    $Awfif::memes-> {binds}{mresadrevaluator} = $Awfif::memes-> {bh}{"mresadrevaluator1"};
# vbtmressebindtocode
    $Awfif::memes-> {binds}{vbtmressevaluator} = $Awfif::memes-> {bh}{"vbtmressevaluator1"};
# vbtmresoebindtocode
    $Awfif::memes-> {binds}{vbtmresoevaluator} = $Awfif::memes-> {bh}{"vbtmresoevaluator1"};
# mcssubebindtocode
    $Awfif::memes-> {binds}{mcssubevaluator} = $Awfif::memes-> {bh}{"mcssubevaluator1"};
# mcsobebindtocode
    $Awfif::memes-> {binds}{mcsobevaluator} = $Awfif::memes-> {bh}{"mcsobevaluator1"};
# msormebindtocode
    $Awfif::memes-> {binds}{msormevaluator} = $Awfif::memes-> {bh}{"msormevaluator1"};
# vbtmsormebindtocode
    $Awfif::memes-> {binds}{vbtmsormevaluator} = $Awfif::memes-> {bh}{"vbtmsormevaluator1"};
# miterebindtocode
    $Awfif::memes-> {binds}{miterevaluator} = $Awfif::memes-> {bh}{"miterevaluator1"};
# mviintebindtocode
    $Awfif::memes-> {binds}{mviintevaluator} = $Awfif::memes-> {bh}{"mviintevaluator1"};
# mactsverbebindtocode
    $Awfif::memes-> {binds}{mactsverbevaluator} = $Awfif::memes-> {bh}{"mactsverbevaluator1"};
# mactcverbebindtocode
    $Awfif::memes-> {binds}{mactcverbevaluator} = $Awfif::memes-> {bh}{"mactcverbevaluator1"};
# vbtmactsverbebindtocode
    $Awfif::memes-> {binds}{vbtmactsverbevaluator} = $Awfif::memes-> {bh}{"vbtmactsverbevaluator1"};
# mmcrebindtocode
    $Awfif::memes-> {binds}{mmcrevaluator} = $Awfif::memes-> {bh}{"mmcrevaluator1"};
# mmctebindtocode
    $Awfif::memes-> {binds}{mmctevaluator} = $Awfif::memes-> {bh}{"mmctevaluator1"};
# mmcvebindtocode
    $Awfif::memes-> {binds}{mmcvevaluator} = $Awfif::memes-> {bh}{"mmcvevaluator1"};
# mcspebindtocode
    $Awfif::memes-> {binds}{mcspevaluator} = $Awfif::memes-> {bh}{"mcspevaluator1"};
# vbtmcspebindtocode
    $Awfif::memes-> {binds}{vbtmcspevaluator} = $Awfif::memes-> {bh}{"vbtmcspevaluator1"};
# mcopebindtocode
    $Awfif::memes-> {binds}{mcopevaluator} = $Awfif::memes-> {bh}{"mcopevaluator1"};
# vbtmcopebindtocode
    $Awfif::memes-> {binds}{vbtmcopevaluator} = $Awfif::memes-> {bh}{"vbtmcopevaluator1"};
# mcvpebindtocode
    $Awfif::memes-> {binds}{mcvpevaluator} = $Awfif::memes-> {bh}{"mcvpevaluator1"};
# vbtmcvpebindtocode
    $Awfif::memes-> {binds}{vbtmcvpevaluator} = $Awfif::memes-> {bh}{"vbtmcvpevaluator1"};
# mwstaebindtocode
    $Awfif::memes-> {binds}{mwstaevaluator} = $Awfif::memes-> {bh}{"mwstaevaluator1"};
# mwstdebindtocode
    $Awfif::memes-> {binds}{mwstdevaluator} = $Awfif::memes-> {bh}{"mwstdevaluator1"};
# slocebindtocode
    $Awfif::memes-> {binds}{slocevaluator} = $Awfif::memes-> {bh}{"slocevaluator1"};
    $Awfif::memes-> {binds}{slocbsmodeler} = $Awfif::memes-> {bh}{"slocbsmodeler1"};
# slistkwebindtocode
    $Awfif::memes-> {binds}{slistkwevaluator} = $Awfif::memes-> {bh}{"slistkwevaluator1"};
    $Awfif::memes-> {binds}{islistkwevaluator} = $Awfif::memes-> {bh}{"islistkwevaluator1"};
    $Awfif::memes-> {binds}{slistkwbsmodeler} = $Awfif::memes-> {bh}{"slistkwbsmodeler1"};
# endrcdkwebindtocode
    $Awfif::memes-> {binds}{endrcdkwevaluator} = $Awfif::memes-> {bh}{"endrcdkwevaluator1"};
    $Awfif::memes-> {binds}{iendrcdkwevaluator} = $Awfif::memes-> {bh}{"iendrcdkwevaluator1"};
    $Awfif::memes-> {binds}{endrcdkwbsmodeler} = $Awfif::memes-> {bh}{"endrcdkwbsmodeler1"};
# endlistkwebindtocode
    $Awfif::memes-> {binds}{endlistkwevaluator} = $Awfif::memes-> {bh}{"endlistkwevaluator1"};
    $Awfif::memes-> {binds}{iendlistkwevaluator} = $Awfif::memes-> {bh}{"iendlistkwevaluator1"};
    $Awfif::memes-> {binds}{endlistkwbsmodeler} = $Awfif::memes-> {bh}{"endlistkwbsmodeler1"};
# dcrdoslistebindtocode
    $Awfif::memes-> {binds}{dcrdoslistevaluator} = $Awfif::memes-> {bh}{"dcrdoslistevaluator1"};
    $Awfif::memes-> {binds}{idcrdoslistevaluator} = $Awfif::memes-> {bh}{"idcrdoslistevaluator1"};
    $Awfif::memes-> {binds}{dcrdoslistbsmodeler} = $Awfif::memes-> {bh}{"dcrdoslistbsmodeler1"};
# dcrdononrecebindtocode
    $Awfif::memes-> {binds}{dcrdononrecevaluator} = $Awfif::memes-> {bh}{"dcrdononrecevaluator1"};
    $Awfif::memes-> {binds}{idcrdononrecevaluator} = $Awfif::memes-> {bh}{"idcrdononrecevaluator1"};
    $Awfif::memes-> {binds}{dcrdononrecbsmodeler} = $Awfif::memes-> {bh}{"dcrdononrecbsmodeler1"};
# dcrdoncasedescebindtocode
    $Awfif::memes-> {binds}{dcrdoncasedescevaluator} = $Awfif::memes-> {bh}{"dcrdoncasedescevaluator1"};
    $Awfif::memes-> {binds}{idcrdoncasedescevaluator} = $Awfif::memes-> {bh}{"idcrdoncasedescevaluator1"};
    $Awfif::memes-> {binds}{dcrdoncasedescbsmodeler} = $Awfif::memes-> {bh}{"dcrdoncasedescbsmodeler1"};
# dcrdocasedescebindtocode
    $Awfif::memes-> {binds}{dcrdocasedescevaluator} = $Awfif::memes-> {bh}{"dcrdocasedescevaluator1"};
    $Awfif::memes-> {binds}{idcrdocasedescevaluator} = $Awfif::memes-> {bh}{"idcrdocasedescevaluator1"};
    $Awfif::memes-> {binds}{dcrdocasedescbsmodeler} = $Awfif::memes-> {bh}{"dcrdocasedescbsmodeler1"};
# dcrdogowithinebindtocode
    $Awfif::memes-> {binds}{dcrdogowithinevaluator} = $Awfif::memes-> {bh}{"dcrdogowithinevaluator1"};
    $Awfif::memes-> {binds}{idcrdogowithinevaluator} = $Awfif::memes-> {bh}{"idcrdogowithinevaluator1"};
    $Awfif::memes-> {binds}{dcrdogowithinbsmodeler} = $Awfif::memes-> {bh}{"dcrdogowithinbsmodeler1"};
# dcrdosrecordebindtocode
    $Awfif::memes-> {binds}{dcrdosrecordevaluator} = $Awfif::memes-> {bh}{"dcrdosrecordevaluator1"};
    $Awfif::memes-> {binds}{idcrdosrecordevaluator} = $Awfif::memes-> {bh}{"idcrdosrecordevaluator1"};
    $Awfif::memes-> {binds}{dcrdosrecordbsmodeler} = $Awfif::memes-> {bh}{"dcrdosrecordbsmodeler1"};
# seltstebindtocode
    $Awfif::memes-> {binds}{seltstevaluator} = $Awfif::memes-> {bh}{"seltstevaluator1"};
    $Awfif::memes-> {binds}{seltstbsmodeler} = $Awfif::memes-> {bh}{"seltstbsmodeler1"};
# ivalwebindtocode
    $Awfif::memes-> {binds}{ivalwevaluator} = $Awfif::memes-> {bh}{"ivalwevaluator1"};
    $Awfif::memes-> {binds}{iivalevaluator} = $Awfif::memes-> {bh}{"iivalevaluator1"};
    $Awfif::memes-> {binds}{ivalwbsmodeler} = $Awfif::memes-> {bh}{"ivalwbsmodeler1"};
# itargebindtocode
    $Awfif::memes-> {binds}{itargevaluator} = $Awfif::memes-> {bh}{"itargevaluator1"};
    $Awfif::memes-> {binds}{itargbsmodeler} = $Awfif::memes-> {bh}{"itargbsmodeler1"};
# acsaoebindtocode
    $Awfif::memes-> {binds}{acsaoevaluator} = $Awfif::memes-> {bh}{"acsaoevaluator1"};
    $Awfif::memes-> {binds}{iacsaoevaluator} = $Awfif::memes-> {bh}{"iacsaoevaluator1"};
    $Awfif::memes-> {binds}{acsaobsmodeler} = $Awfif::memes-> {bh}{"acsaobsmodeler1"};
# cbodyebindtocode
    $Awfif::memes-> {binds}{cbodyevaluator} = $Awfif::memes-> {bh}{"cbodyevaluator1"};
    $Awfif::memes-> {binds}{cbodybsmodeler} = $Awfif::memes-> {bh}{"cbodybsmodeler1"};
# icompdebindtocode
    $Awfif::memes-> {binds}{icompdevaluator} = $Awfif::memes-> {bh}{"icompdevaluator1"};
    $Awfif::memes-> {binds}{iicompdevaluator} = $Awfif::memes-> {bh}{"iicompdevaluator1"};
    $Awfif::memes-> {binds}{icompdbsmodeler} = $Awfif::memes-> {bh}{"icompdbsmodeler1"};
# msadobebindtocode
    $Awfif::memes-> {binds}{msadobevaluator} = $Awfif::memes-> {bh}{"msadobevaluator1"};
# dcrdoinitebindtocode
    $Awfif::memes-> {binds}{dcrdoinitevaluator} = $Awfif::memes-> {bh}{"dcrdoinitevaluator1"};
    $Awfif::memes-> {binds}{idcrdoinitevaluator} = $Awfif::memes-> {bh}{"idcrdoinitevaluator1"};
    $Awfif::memes-> {binds}{dcrdoinitbsmodeler} = $Awfif::memes-> {bh}{"dcrdoinitbsmodeler1"};
# crsmebindtocode
    $Awfif::memes-> {binds}{crsmevaluator} = $Awfif::memes-> {bh}{"crsmevaluator1"};
    $Awfif::memes-> {binds}{icrsmevaluator} = $Awfif::memes-> {bh}{"icrsmevaluator1"};
    $Awfif::memes-> {binds}{crsmbsmodeler} = $Awfif::memes-> {bh}{"crsmbsmodeler1"};
# crsmofebindtocode
    $Awfif::memes-> {binds}{crsmofevaluator} = $Awfif::memes-> {bh}{"crsmofevaluator1"};
    $Awfif::memes-> {binds}{crsmofbsmodeler} = $Awfif::memes-> {bh}{"crsmofbsmodeler1"};
# crsmoxebindtocode
    $Awfif::memes-> {binds}{crsmoxevaluator} = $Awfif::memes-> {bh}{"crsmoxevaluator1"};
    $Awfif::memes-> {binds}{crsmoxbsmodeler} = $Awfif::memes-> {bh}{"crsmoxbsmodeler1"};
# iicrsmoxebindtocode
    $Awfif::memes-> {binds}{iicrsmoxevaluator} = $Awfif::memes-> {bh}{"iicrsmoxevaluator1"};
# crsmoiebindtocode
    $Awfif::memes-> {binds}{crsmoievaluator} = $Awfif::memes-> {bh}{"crsmoievaluator1"};
    $Awfif::memes-> {binds}{crsmoibsmodeler} = $Awfif::memes-> {bh}{"crsmoibsmodeler1"};
# crsmoeiebindtocode
    $Awfif::memes-> {binds}{crsmoeievaluator} = $Awfif::memes-> {bh}{"crsmoeievaluator1"};
    $Awfif::memes-> {binds}{crsmoeibsmodeler} = $Awfif::memes-> {bh}{"crsmoeibsmodeler1"};
# crsmoeebindtocode
    $Awfif::memes-> {binds}{crsmoeevaluator} = $Awfif::memes-> {bh}{"crsmoeevaluator1"};
    $Awfif::memes-> {binds}{crsmoebsmodeler} = $Awfif::memes-> {bh}{"crsmoebsmodeler1"};
# crsmomebindtocode
    $Awfif::memes-> {binds}{crsmomevaluator} = $Awfif::memes-> {bh}{"crsmomevaluator1"};
    $Awfif::memes-> {binds}{crsmombsmodeler} = $Awfif::memes-> {bh}{"crsmombsmodeler1"};
# crsmomeebindtocode
    $Awfif::memes-> {binds}{crsmomeevaluator} = $Awfif::memes-> {bh}{"crsmomeevaluator1"};
    $Awfif::memes-> {binds}{crsmomebsmodeler} = $Awfif::memes-> {bh}{"crsmomebsmodeler1"};
# csresebindtocode
    $Awfif::memes-> {binds}{csresevaluator} = $Awfif::memes-> {bh}{"csresevaluator1"};
    $Awfif::memes-> {binds}{icsresevaluator} = $Awfif::memes-> {bh}{"icsresevaluator1"};
    $Awfif::memes-> {binds}{csresbsmodeler} = $Awfif::memes-> {bh}{"csresbsmodeler1"};
# bcsubpcebindtocode
    $Awfif::memes-> {binds}{bcsubpcevaluator} = $Awfif::memes-> {bh}{"bcsubpcevaluator1"};
    $Awfif::memes-> {binds}{ibcsubpcevaluator} = $Awfif::memes-> {bh}{"ibcsubpcevaluator1"};
    $Awfif::memes-> {binds}{bcsubpcbsmodeler} = $Awfif::memes-> {bh}{"bcsubpcbsmodeler1"};
# bcsubpsebindtocode
    $Awfif::memes-> {binds}{bcsubpsevaluator} = $Awfif::memes-> {bh}{"bcsubpsevaluator1"};
    $Awfif::memes-> {binds}{ibcsubpsevaluator} = $Awfif::memes-> {bh}{"ibcsubpsevaluator1"};
    $Awfif::memes-> {binds}{bcsubpsbsmodeler} = $Awfif::memes-> {bh}{"bcsubpsbsmodeler1"};
# unbindebindtocode
    $Awfif::memes-> {binds}{unbindevaluator} = $Awfif::memes-> {bh}{"unbindevaluator1"};
# initpdcaebindtocode
    $Awfif::memes-> {binds}{initpdcaevaluator} = $Awfif::memes-> {bh}{"initpdcaevaluator1"};
    $Awfif::memes-> {binds}{initpdcabsmodeler} = $Awfif::memes-> {bh}{"initpdcabsmodeler1"};
# initpdcascebindtocode
    $Awfif::memes-> {binds}{initpdcascevaluator} = $Awfif::memes-> {bh}{"initpdcascevaluator1"};
    $Awfif::memes-> {binds}{initpdcascbsmodeler} = $Awfif::memes-> {bh}{"initpdcascbsmodeler1"};
# invsupebindtocode
    $Awfif::memes-> {binds}{invsupevaluator} = $Awfif::memes-> {bh}{"invsupevaluator1"};
    $Awfif::memes-> {binds}{iinvsupevaluator} = $Awfif::memes-> {bh}{"iinvsupevaluator1"};
    $Awfif::memes-> {binds}{invsupbsmodeler} = $Awfif::memes-> {bh}{"invsupbsmodeler1"};
# invmodebindtocode
    $Awfif::memes-> {binds}{invmodevaluator} = $Awfif::memes-> {bh}{"invmodevaluator1"};
    $Awfif::memes-> {binds}{iinvmodevaluator} = $Awfif::memes-> {bh}{"iinvmodevaluator1"};
    $Awfif::memes-> {binds}{invmodbsmodeler} = $Awfif::memes-> {bh}{"invmodbsmodeler1"};
# dcyctpebindtocode
    $Awfif::memes-> {binds}{dcyctpevaluator} = $Awfif::memes-> {bh}{"dcyctpevaluator1"};
    $Awfif::memes-> {binds}{idcyctpevaluator} = $Awfif::memes-> {bh}{"idcyctpevaluator1"};
    $Awfif::memes-> {binds}{dcyctpbsmodeler} = $Awfif::memes-> {bh}{"dcyctpbsmodeler1"};
# dcycipebindtocode
    $Awfif::memes-> {binds}{dcycipevaluator} = $Awfif::memes-> {bh}{"dcycipevaluator1"};
    $Awfif::memes-> {binds}{idcycipevaluator} = $Awfif::memes-> {bh}{"idcycipevaluator1"};
    $Awfif::memes-> {binds}{dcycipbsmodeler} = $Awfif::memes-> {bh}{"dcycipbsmodeler1"};
# e2ftfebindtocode
    $Awfif::memes-> {binds}{e2ftfevaluator} = $Awfif::memes-> {bh}{"e2ftfevaluator1"};
    $Awfif::memes-> {binds}{ie2ftfevaluator} = $Awfif::memes-> {bh}{"ie2ftfevaluator1"};
    $Awfif::memes-> {binds}{e2ftfbsmodeler} = $Awfif::memes-> {bh}{"e2ftfbsmodeler1"};
# prbebindtocode
    $Awfif::memes-> {binds}{prbevaluator} = $Awfif::memes-> {bh}{"prbevaluator1"};
    $Awfif::memes-> {binds}{iprbevaluator} = $Awfif::memes-> {bh}{"iprbevaluator1"};
    $Awfif::memes-> {binds}{prbbsmodeler} = $Awfif::memes-> {bh}{"prbbsmodeler1"};
# ecycdopebindtocode
    $Awfif::memes-> {binds}{ecycdopevaluator} = $Awfif::memes-> {bh}{"ecycdopevaluator1"};
    $Awfif::memes-> {binds}{iecycdopevaluator} = $Awfif::memes-> {bh}{"iecycdopevaluator1"};
    $Awfif::memes-> {binds}{ecycdopbsmodeler} = $Awfif::memes-> {bh}{"ecycdopbsmodeler1"};
# acycchpebindtocode
    $Awfif::memes-> {binds}{acycchpevaluator} = $Awfif::memes-> {bh}{"acycchpevaluator1"};
    $Awfif::memes-> {binds}{iacycchpevaluator} = $Awfif::memes-> {bh}{"iacycchpevaluator1"};
    $Awfif::memes-> {binds}{acycchpbsmodeler} = $Awfif::memes-> {bh}{"acycchpbsmodeler1"};
# bcycacpebindtocode
    $Awfif::memes-> {binds}{bcycacpevaluator} = $Awfif::memes-> {bh}{"bcycacpevaluator1"};
    $Awfif::memes-> {binds}{ibcycacpevaluator} = $Awfif::memes-> {bh}{"ibcycacpevaluator1"};
    $Awfif::memes-> {binds}{bcycacpbsmodeler} = $Awfif::memes-> {bh}{"bcycacpbsmodeler1"};
# spdcaebindtocode
    $Awfif::memes-> {binds}{spdcaevaluator} = $Awfif::memes-> {bh}{"spdcaevaluator1"};
    $Awfif::memes-> {binds}{ispdcaevaluator} = $Awfif::memes-> {bh}{"ispdcaevaluator1"};
    $Awfif::memes-> {binds}{spdcabsmodeler} = $Awfif::memes-> {bh}{"spdcabsmodeler1"};
# spdcascebindtocode
    $Awfif::memes-> {binds}{spdcascevaluator} = $Awfif::memes-> {bh}{"spdcascevaluator1"};
    $Awfif::memes-> {binds}{spdcascbsmodeler} = $Awfif::memes-> {bh}{"spdcascbsmodeler1"};
# e2finhibbindtocode
    $Awfif::memes-> {binds}{e2finhibb} = $Awfif::memes-> {bh}{"e2finhibb1"};
# tfactorbindtocode
    $Awfif::memes-> {binds}{tfactorb} = $Awfif::memes-> {bh}{"tfactorb1"};
# receptorbindtocode
    $Awfif::memes-> {binds}{receptorb} = $Awfif::memes-> {bh}{"receptorb1"};
# receptorbibindtocode
    $Awfif::memes-> {binds}{receptorbi} = $Awfif::memes-> {bh}{"receptorbi1"};
# receptorhbindtocode
    $Awfif::memes-> {binds}{receptorh} = $Awfif::memes-> {bh}{"receptorh1"};
# warbindtocode
    $Awfif::memes-> {binds}{warb} = $Awfif::memes-> {bh}{"warb1"};
    $Awfif::memes-> {binds}{warasb} = $Awfif::memes-> {bh}{"warasb1"};
    $Awfif::memes-> {binds}{warmab} = $Awfif::memes-> {bh}{"warmab1"};
    $Awfif::memes-> {binds}{warmsb} = $Awfif::memes-> {bh}{"warmsb1"};
    $Awfif::memes-> {binds}{warmdob} = $Awfif::memes-> {bh}{"warmdob1"};
    $Awfif::memes-> {binds}{warhdob} = $Awfif::memes-> {bh}{"warhdob1"};
# vworldbindtocode
    $Awfif::memes-> {binds}{vworldb} = $Awfif::memes-> {bh}{"vworldb1"};
# vwxstartbindtocode
    $Awfif::memes-> {binds}{vwxstartb} = $Awfif::memes-> {bh}{"vwxstartb1"};
# vcansbindtocode
    $Awfif::memes-> {binds}{vcansb} = $Awfif::memes-> {bh}{"vcansb1"};
# selfbindtocode
    $Awfif::memes-> {binds}{self} = $Awfif::memes-> {bh}{"self1"};
# cassertebindtocode
    $Awfif::memes-> {binds}{cassertevaluator} = $Awfif::memes-> {bh}{"cassertevaluator1"};
    $Awfif::memes-> {binds}{icassertevaluator} = $Awfif::memes-> {bh}{"icassertevaluator1"};
    $Awfif::memes-> {binds}{cassertbsmodeler} = $Awfif::memes-> {bh}{"cassertbsmodeler1"};
# desrasstebindtocode
    $Awfif::memes-> {binds}{desrasstevaluator} = $Awfif::memes-> {bh}{"desrasstevaluator1"};
    $Awfif::memes-> {binds}{idesrasstevaluator} = $Awfif::memes-> {bh}{"idesrasstevaluator1"};
    $Awfif::memes-> {binds}{desrasstbsmodeler} = $Awfif::memes-> {bh}{"desrasstbsmodeler1"};
# dcrdowarsebindtocode
    $Awfif::memes-> {binds}{dcrdowarsevaluator} = $Awfif::memes-> {bh}{"dcrdowarsevaluator1"};
    $Awfif::memes-> {binds}{idcrdowarsevaluator} = $Awfif::memes-> {bh}{"idcrdowarsevaluator1"};
    $Awfif::memes-> {binds}{dcrdowarsbsmodeler} = $Awfif::memes-> {bh}{"dcrdowarsbsmodeler1"};
# uwarsebindtocode
    $Awfif::memes-> {binds}{uwarsevaluator} = $Awfif::memes-> {bh}{"uwarsevaluator1"};
    $Awfif::memes-> {binds}{iuwarsevaluator} = $Awfif::memes-> {bh}{"iuwarsevaluator1"};
    $Awfif::memes-> {binds}{uwarsbsmodeler} = $Awfif::memes-> {bh}{"uwarsbsmodeler1"};
# lbstreamebindtocode
    $Awfif::memes-> {binds}{lbstreamevaluator} = $Awfif::memes-> {bh}{"lbstreamevaluator1"};
    $Awfif::memes-> {binds}{ilbstreamevaluator} = $Awfif::memes-> {bh}{"ilbstreamevaluator1"};
    $Awfif::memes-> {binds}{lbstreambsmodeler} = $Awfif::memes-> {bh}{"lbstreambsmodeler1"};
# lbstreamcompebindtocode
    $Awfif::memes-> {binds}{lbstreamcompevaluator} = $Awfif::memes-> {bh}{"lbstreamcompevaluator1"};
# skipwsoebindtocode
    $Awfif::memes-> {binds}{skipwsoevaluator} = $Awfif::memes-> {bh}{"skipwsoevaluator1"};
    $Awfif::memes-> {binds}{iskipwsoevaluator} = $Awfif::memes-> {bh}{"iskipwsoevaluator1"};
    $Awfif::memes-> {binds}{skipwsobsmodeler} = $Awfif::memes-> {bh}{"skipwsobsmodeler1"};
# srcdkwebindtocode
    $Awfif::memes-> {binds}{srcdkwevaluator} = $Awfif::memes-> {bh}{"srcdkwevaluator1"};
    $Awfif::memes-> {binds}{isrcdkwevaluator} = $Awfif::memes-> {bh}{"isrcdkwevaluator1"};
    $Awfif::memes-> {binds}{srcdkwbsmodeler} = $Awfif::memes-> {bh}{"srcdkwbsmodeler1"};
# namestebindtocode
    $Awfif::memes-> {binds}{namestevaluator} = $Awfif::memes-> {bh}{"namestevaluator1"};
    $Awfif::memes-> {binds}{inamestevaluator} = $Awfif::memes-> {bh}{"inamestevaluator1"};
    $Awfif::memes-> {binds}{namestbsmodeler} = $Awfif::memes-> {bh}{"namestbsmodeler1"};
# schbbindtocode
    $Awfif::memes-> {binds}{schbindevaluator} = $Awfif::memes-> {bh}{"schbindevaluator1"};
    $Awfif::memes-> {binds}{schbindbsmodeler} = $Awfif::memes-> {bh}{"schbindbsmodeler1"};
# devscwldtocode
    $Awfif::memes-> {binds}{devscwldevaluator} = $Awfif::memes-> {bh}{"devscwldevaluator1"};
    $Awfif::memes-> {binds}{devscwldbsmodeler} = $Awfif::memes-> {bh}{"devscwldbsmodeler1"};
# devpcelltocode
    $Awfif::memes-> {binds}{devpcellevaluator} = $Awfif::memes-> {bh}{"devpcellevaluator1"};
    $Awfif::memes-> {binds}{devpcellbsmodeler} = $Awfif::memes-> {bh}{"devpcellbsmodeler1"};
# devscelltocode
    $Awfif::memes-> {binds}{devscellevaluator} = $Awfif::memes-> {bh}{"devscellevaluator1"};
    $Awfif::memes-> {binds}{devscellbsmodeler} = $Awfif::memes-> {bh}{"devscellbsmodeler1"};
# devbtwldtocode
    $Awfif::memes-> {binds}{devbtwldevaluator} = $Awfif::memes-> {bh}{"devbtwldevaluator1"};
    $Awfif::memes-> {binds}{devbtwldbsmodeler} = $Awfif::memes-> {bh}{"devbtwldbsmodeler1"};
# devbtcnstocode
    $Awfif::memes-> {binds}{devbtcnsevaluator} = $Awfif::memes-> {bh}{"devbtcnsevaluator1"};
    $Awfif::memes-> {binds}{devbtcnsbsmodeler} = $Awfif::memes-> {bh}{"devbtcnsbsmodeler1"};
# devsccnstocode
    $Awfif::memes-> {binds}{devsccnsevaluator} = $Awfif::memes-> {bh}{"devsccnsevaluator1"};
    $Awfif::memes-> {binds}{devsccnsbsmodeler} = $Awfif::memes-> {bh}{"devsccnsbsmodeler1"};
# stbbindtocode
    $Awfif::memes-> {binds}{stbindevaluator} = $Awfif::memes-> {bh}{"stbindevaluator1"};
    $Awfif::memes-> {binds}{stbindbsmodeler} = $Awfif::memes-> {bh}{"stbindbsmodeler1"};
# indslocbindtocode
    $Awfif::memes-> {binds}{indslocevaluator} = $Awfif::memes-> {bh}{"indslocevaluator1"};
    $Awfif::memes-> {binds}{indslocbsmodeler} = $Awfif::memes-> {bh}{"indslocbsmodeler1"};
# shslocbindtocode
    $Awfif::memes-> {binds}{shslocevaluator} = $Awfif::memes-> {bh}{"shslocevaluator1"};
    $Awfif::memes-> {binds}{shslocbsmodeler} = $Awfif::memes-> {bh}{"shslocbsmodeler1"};
# rchpairbindtocode
    $Awfif::memes-> {binds}{rchpairevaluator} = $Awfif::memes-> {bh}{"rchpairevaluator1"};
    $Awfif::memes-> {binds}{rchpairbsmodeler} = $Awfif::memes-> {bh}{"rchpairbsmodeler1"};
# ripkwmbindtocode
    $Awfif::memes-> {binds}{ripkwmevaluator} = $Awfif::memes-> {bh}{"ripkwmevaluator1"};
    $Awfif::memes-> {binds}{ripkwmbsmodeler} = $Awfif::memes-> {bh}{"ripkwmbsmodeler1"};
# rpkwmintbindtocode
    $Awfif::memes-> {binds}{rpkwmintevaluator} = $Awfif::memes-> {bh}{"rpkwmintevaluator1"};
    $Awfif::memes-> {binds}{rpkwmintbsmodeler} = $Awfif::memes-> {bh}{"rpkwmintbsmodeler1"};
# rchpintbindtocode
    $Awfif::memes-> {binds}{rchpintevaluator} = $Awfif::memes-> {bh}{"rchpintevaluator1"};
    $Awfif::memes-> {binds}{rchpintbsmodeler} = $Awfif::memes-> {bh}{"rchpintbsmodeler1"};
# pmmanibindtocode
    $Awfif::memes-> {binds}{pmmaninspector} = $Awfif::memes-> {bh}{"pmmaninspector1"};
#
    if ((!defined ($restoring)) or (!$restoring)){
# codeletinvbindings

    my ($ci2, $bit, $i2, @bool);
    $i2 = 0;
    $ci2 = $i2;
    $bit = 1;
    for my $act (@$csset) {
      $Awfif::memes-> {cseh}{$act} = $i2;
      $Awfif::memes-> {cseih}{$ci2} = $act;
      $Awfif::csehist-> {d}[$ci2] = Awfif::newlink ($Awfif::memes-> {csehih}, \$Awfif::csehist);
      $Awfif::memes-> {csehih} = $Awfif::csehist-> {d}[$i2];
      $Awfif::csehist-> {l} [$Awfif::memes-> {csehih}] [2] = $act;
      $Awfif::csehist-> {l} [$Awfif::memes-> {csehih}] [3] = 0;# the count of usage
# codeletboolmask
# this boolean code only works for the first 32 elements of the set since $bool[x] is a 32 bit number
# still all the referenced items are currently in that sub-set

      $bool[$i2] = $bit;
      $bit = $bit << 1;
      $i2++;
      $ci2 = $i2;
      } #for my
#setup the masks for boolean checks

    $Awfif::memes-> {usedesc} = $bool[$Awfif::memes->{cseh}{tdescscout}];
    $Awfif::memes-> {usedesc} |= $bool[$Awfif::memes->{cseh}{descscout}];
    $Awfif::memes-> {usedesc} |= $bool[$Awfif::memes->{cseh}{descevaluator}];
    $Awfif::memes-> {usedesc} |= $bool[$Awfif::memes->{cseh}{descbuilder}];
    $Awfif::memes-> {igdesc} = $Awfif::memes-> {usedesc} ^ -1;
    $Awfif::memes-> {userel} = $bool[$Awfif::memes->{cseh}{trelscout}];
    $Awfif::memes-> {userel} |= $bool[$Awfif::memes->{cseh}{relscout}];
    $Awfif::memes-> {userel} |= $bool[$Awfif::memes->{cseh}{relevaluator}];
    $Awfif::memes-> {userel} |= $bool[$Awfif::memes->{cseh}{relbuilder}];
    $Awfif::memes-> {igrel} = $Awfif::memes-> {userel} ^ -1;
#
# strbooleans
# setup strategy booleans

    my ($i2);
    $i2 = 0;
    $ci2 = $i2;
    $bit = 1;
    for my $act (@$strset) {
      $Awfif::memes-> {streh}{$act} = $i2;
      $Awfif::memes-> {streih}{$ci2} = $act;
      $Awfif::memes-> {backoffactive} {$act} = 0;
      $Awfif::memes-> {backoffactives} {$act} = 0;
      $Awfif::memes-> {strbool}[$i2] = $bit;
      $bit = $bit << 1;
      $i2++;
      $ci2 = $i2;
      } #for my

    $Awfif::memes-> {allbuwsstr} = $Awfif::memes-> {strbool} [ $Awfif::memes-> {streh} {budesc}];
    $Awfif::memes-> {allbuwsstr} |= $Awfif::memes-> {strbool} [ $Awfif::memes-> {streh} {bubond}];
    $Awfif::memes-> {allbuwsstr} |= $Awfif::memes-> {strbool} [ $Awfif::memes-> {streh} {bugroup}];
    $Awfif::memes-> {allbuwsstr} |= $Awfif::memes-> {strbool} [ $Awfif::memes-> {streh} {budevelopment}];
    $Awfif::memes-> {allbuwsstr} |= $Awfif::memes-> {strbool} [ $Awfif::memes-> {streh} {bustatement}];
#
    $Awfif::memes-> {alltdwsstr} = $Awfif::memes-> {strbool} [ $Awfif::memes-> {streh} {tddesc}];
    $Awfif::memes-> {alltdwsstr} |= $Awfif::memes-> {strbool} [ $Awfif::memes-> {streh} {tdbond}];
    $Awfif::memes-> {alltdwsstr} |= $Awfif::memes-> {strbool} [ $Awfif::memes-> {streh} {tdgroup}];
#
    $Awfif::memes-> {allwsstr} = $Awfif::memes-> {allbuwsstr};
    $Awfif::memes-> {allwsstr} |= $Awfif::memes-> {alltdwsstr};
#
# map the strategies into the seperate cachable areas
    $Awfif::cussnl[$Awfif::cache-> {h}{'tddescl'}] = 0;
    $Awfif::cussnl[$Awfif::cache-> {h}{'budescl'}] = 1;
    $Awfif::cussnl[$Awfif::cache-> {h}{'tddesc'}] = 0;
    $Awfif::cussnl[$Awfif::cache-> {h}{'budesc'}] = 1;
    $Awfif::cussnl[$Awfif::cache-> {h}{'tdbond'}] = 2;
    $Awfif::cussnl[$Awfif::cache-> {h}{'bubond'}] = 3;
    $Awfif::cussnl[$Awfif::cache-> {h}{'tdgroup'}] = 4;
    $Awfif::cussnl[$Awfif::cache-> {h}{'bugroup'}] = 5;
    $Awfif::cussnl[$Awfif::cache-> {h}{'budevelopment'}] = 6;
    $Awfif::cussnl[$Awfif::cache-> {h}{'bustatement'}] = 7;

    $Awfif::memes-> {groupsponsor} = $Awfif::memes-> {snnh} {wsi};
# setup the matchtree state
    $Awfif::memes-> {mtsnstate} = $Awfif::memes-> {snnh} {either};
    $Awfif::memes-> {mtsnlvl} = 0;
    $Awfif::memes-> {mtsnlc} [0] = 0;
#
#
# setup pseudo concept controls
    $Awfif::memes-> {npconc} = $Awfif::memes-> {snnh} {pcb} +1; # next pseudo concept
    $Awfif::memes-> {maxpconcs} = $Awfif::memes-> {snnh} {wsil} -1; # how many pseudo concepts can exist
#
# setup the depths, distances and links for each slipnet node
#
# adjacent
# $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnd}
# [$Awfif::memes-> {snnh} {adjacent}] = 20;
# $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc}
# [$Awfif::memes-> {snnh} {adjacent}][0] = 9;- give halo to char
# $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc}
# [$Awfif::memes-> {snnh} {adjacent}][1] = 8;#8
# $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
# [$Awfif::memes-> {snnh} {adjacent}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {bondcategory},$Awfif::memes-> {snnh} {adjacent},
# $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {adjacent}]);
# $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
# [$Awfif::memes-> {snnh} {adjacent}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {lateral},$Awfif::memes-> {snnh} {adjgroup},$Awfif::memes-> {snnh} {adjacent},
# $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {adjacent}]);
# $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
# [$Awfif::memes-> {snnh} {adjacent}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namescategory},$Awfif::memes-> {snnh} {adjacent},
# $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {adjacent}]);
# $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
# [$Awfif::memes-> {snnh} {adjacent}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {identity},$Awfif::memes-> {snnh} {char},$Awfif::memes-> {snnh} {adjacent},
# $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {adjacent}]);
# adjgroup

# $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnd}
# [$Awfif::memes-> {snnh} {adjgroup}] = 20;
# $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc}
# [$Awfif::memes-> {snnh} {adjgroup}][0] = 14;
# $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc}
# [$Awfif::memes-> {snnh} {adjgroup}][1] = 11;
# $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
# [$Awfif::memes-> {snnh} {adjgroup}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {groupcategory},$Awfif::memes-> {snnh} {adjgroup},
# $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {adjgroup}]);
# $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
# [$Awfif::memes-> {snnh} {adjgroup}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {lateral},$Awfif::memes-> {snnh} {testcategory},$Awfif::memes-> {snnh} {adjgroup},
# $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {adjgroup}]);
# $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
# [$Awfif::memes-> {snnh} {adjgroup}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {lateral},$Awfif::memes-> {snnh} {char},$Awfif::memes-> {snnh} {adjgroup},
# $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {adjgroup}]);
# all

    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnd}
      [$Awfif::memes-> {snnh} {all}] = 8;
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc}
      [$Awfif::memes-> {snnh} {all}][0] = 13;#13
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc}
      [$Awfif::memes-> {snnh} {all}][1] = 12;#5
#<!-- start tag inp -->
# miforallbindtosig
# setup the binding string for the single path signal to initiate a matchkword
    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {all}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {all}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$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} {for}, $Awfif::memes-> {snnh} {each});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {miforallevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
# miforallibindtosig
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {inspector}, $Awfif::memes-> {snnh} {miforallinspector}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
#<!-- end tag inp -->
#<!-- start tag vbt -->
# 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}]);
#<!-- end tag vbt -->
# and

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

    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnd}
      [$Awfif::memes-> {snnh} {assert}] = 1;
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc}
      [$Awfif::memes-> {snnh} {assert}][0] = 14;
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc}
      [$Awfif::memes-> {snnh} {assert}][1] = 18;
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {assert}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {testcategory},$Awfif::memes-> {snnh} {assert},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {assert}]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {assert}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {successor},$Awfif::memes-> {snnh} {statementcomplete},$Awfif::memes-> {snnh} {assert},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {assert}]);
# asssucpro
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {assert}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {successor},$Awfif::memes-> {snnh} {process},$Awfif::memes-> {snnh} {assert},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {assert}]);
# buffer

    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnd}
      [$Awfif::memes-> {snnh} {buffer}] = 1;
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc}
      [$Awfif::memes-> {snnh} {buffer}][0] = 14;
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc}
      [$Awfif::memes-> {snnh} {buffer}][1] = 18;
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {buffer}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {testcategory},$Awfif::memes-> {snnh} {buffer},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {buffer}]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {buffer}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {successor},$Awfif::memes-> {snnh} {statementcomplete},$Awfif::memes-> {snnh} {buffer},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {buffer}]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {buffer}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {successor},$Awfif::memes-> {snnh} {process},$Awfif::memes-> {snnh} {buffer},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {buffer}]);
#<!-- start tag aso -->
# development

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

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

    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnd}
      [$Awfif::memes-> {snnh} {hdo}] = 1;
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc}
      [$Awfif::memes-> {snnh} {hdo}][0] = 13;#13
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc}
      [$Awfif::memes-> {snnh} {hdo}][1] = 12;#5
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {hdo}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {namedcategory},$Awfif::memes-> {snnh} {hdo},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {hdo}]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {hdo}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$Awfif::memes-> {snnh} {testcategory},$Awfif::memes-> {snnh} {hdo},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {hdo}]);
#<!-- end tag aso -->
#<!-- start tag vbt -->
# 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}]);
#<!-- end tag vbt -->
#<!-- start tag scl -->
#
# liposome

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

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [1], 8, $Awfif::memes-> {currentwsbi});
# next want to setup the operon
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {mpsignal}, $pconc, 2, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc), $pconc,# ****
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {mergestreams}, $Awfif::memes-> {snnh} {sequence}, $Awfif::memes-> {snnh} {integration}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
#<!-- end tag aso -->
#<!-- start tag 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');
#<!-- end tag vbt -->
# testt01bindtomsiggv
# setup the binding string for the multi path signal to test transaction 01 - 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} {test}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {test}] [1], 8, $Awfif::memes-> {currentwsbi});
# next want to setup the signal
    $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} {test}, $Awfif::memes-> {snnh} {schema}, $Awfif::memes-> {snnh} {naught}, $Awfif::memes-> {snnh} {one}, $Awfif::memes-> {snnh} {signal}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
#<!-- start tag aso -->
# msaobindtomsiggv
# setup