Workspace
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
This page introduces the programs that the Adaptive Web Framework (AWF) develops and uses to deploy Rob's Strategy Studio (RSS). 
The programs are structured to obey complex adaptive system (CAS) principles.  That allows AWF to experiment and examine the effects. 
A production program generates the web pages. 
A testing system tests the production program.  It uses a framework to support the test programs.  This is AWF's agent programming framework as described in the agent-based programming presentation. 
An example of the other AWF agent-based programs that are also described in the frame is the virtual robot. 
Finally a strength, weaknesses, opportunities and threats assessment is presented. 
Perl frame
This page describes the Adaptive Web framework (AWF) test system and the agent programming framework (Smiley) that supports its operation. 
Example test system statements are included.  To begin a test a test statement is loaded into Smiley while Smiley executes on the Perl interpreter. 
Part of Smiley's Perl code focused on setting up the infrastructure is included bellow. 
The setup includes:
  • Loading the 'Meta file' specification,
  • Initializing the Slipnet, and Workspaces and loading them
  • So that the Coderack can be called. 
The Coderack, which is the focus of a separate page of the Perl frame then schedules and runs the codelets that are invoked by the test statement structures. 
Test framework
This page introduces the many ways a complex modeling and coordination activity can be implemented using agent-based programming (see presentation). 

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

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

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

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

A series of example signals sent by complex modeling codelets along with their associated operons and subgroup schematic sequences are included.  The signals are sent by the:
  • merge streams spdca builder - The initiator of merge streams's pdca cycle (see schematic pdca).
  • merge streams dcycip builder - The initiator of the planning phase of the merge streams's pdca cycle. 
  • merge streams cassert builder - The initiator of the mergestreams's case resolved assert true conditional cascade.  It is a structurally enhanced codelet which activates at the end of the 'do' phase and signals the nucleus. 
  • merge streams indsloc builder - The start locator codelet finds the application schemata's start operon
  • merge streams shsloc builder - A start locator codelet that finds an alternative start operon in the application schematic operon
  • merge streams rchpair builder - A receptor that detects and relays an application signal
  • pdca ecycdop builder - A cyclin simulation codelet which signals entry to the 'do' phase of the pdca. 
  • pdca acycchp builder - A cyclin simulation codelet which signals entry to the 'check' phase of the pdca. 
  • pdca bcycacp builder - A cyclin simulation codelet which signals entry to the 'act' phase of the pdca. 
And the Slipnet configuration which activates the schematic subgroup sequence <mergestreams> <for> <case> <resolved> <assert> <true> is included. 
Schematic modeling
This page looks at how Smiley processes the statement, such as a test request, to ensure that each part of the statement is composed of groups. 
Smiley does this through the operation of a part codelet which indirectly sponsors the modeling of the parts of the statement. 
The modeling itself is performed by model codelets. 
The part codelet synchronizes with the completion of the modeling. 
The part evaluator's signal along with the associated operons and subgroup schematic sequences are included. 
The group models' Slipnet associations are included. 
The codelets and supporting functions are included. 
Schematic whole part
This page looks at how Smiley processes the statement, such as a test request, to ensure that each part of the statement is valid. 
Smiley does this through the operation of a part codelet which indirectly sponsors the modeling of the parts of the statement. 
The modeling itself is performed by model codelets. 
The part codelet synchronizes with the completion of the modeling. 
The part evaluator's signal along with the associated operons and subgroup schematic sequences are included. 
The group models' Slipnet associations are included. 
The codelets and supporting functions are included. 
Part validity
This page looks at how Smiley processes the statement, such as a test request, to ensure that each part of the statement is constrained. 
Smiley does this through the operation of a part codelet which indirectly sponsors the modeling of the parts of the statement. 
The modeling itself is performed by model codelets. 
The part codelet synchronizes with the completion of the modeling. 
The part evaluator's signal along with the associated operons and subgroup schematic sequences are included. 
The group models' Slipnet associations are included. 
The codelets and supporting functions are included. 
Part constraints
This page looks at how Smiley processes the statement, such as a test request, to ensure that each part of the statement is integral. 
Smiley does this through the operation of a part codelet which initiates a program to assess the integrity of the parts. 
The modeling itself is performed by model codelets. 
The group models' Slipnet associations are included. 
The codelets and supporting functions are included. 
Part integrity
This page looks at how Smiley processes the statement, such as a test request, to ensure that the statement contains all required parts. 
Smiley does this through the operation of a statement codelet which indirectly sponsors the modeling of the whole statement. 
The modeling itself is performed by model codelets. 
The group models' Slipnet associations are included. 
The codelets and supporting functions are included. 
Syntactically whole statement
This page looks at Smiley's statement codelet. 
What the codelet's goals are. 
The three aspects of its operations are described. 
The indirect nature of its support for the applications programs and Shewhart cycles are illustrated. 
It describes how the application codelets are inhibited from action until the Statement codelet concludes the application's assertion or implementation statement is viable.  An application assertion statement is described and the schematic string included. 
The statement codelet Perl and its support infrastructure are included. 
Statement operation
This page describes the need for stated assumptions to support the setup and development of a Smiley agent-based application. 
As an example it discusses the use of assumptions about connecting external files to the agents. 
The Smiley codelets which process files and integrate them with the application agents using assumptions are introduced. 
The Slipnet associations relating the Workspace schematic strings to group completion scheduled codelets are included. 
The codelets and supporting functions are included. 
Schematic assumptions
This page discusses how Smiley can support the start of the development phase of an agent-based application. 
Startup is an artificial operation not found in living systems.  But Smiley must do it and so we discuss an example of starting the development phase. 
With the Smiley infrastructure and the application integrated the application's development phase is reviewed.
The association of structural Workspaces for state representation is discussed. 
The aggregation of schematic associations of codelets defines a development agent.  At the application level it processes the application's schematic strings. 
The schematic nature of the data processed by the test application suggests the use of an indirect integration framework.  This supports the binding of codelets to the schematic data and detecting and responding to the control operons. 
An application polymerase complex emerges. 
The codelets and supporting functions are included. 
Schematic development
This page describes the specialized codelets that provide life-cycle and checkpoint capabilities for Smiley applications. 
The codelets implement a Shewhart cycle. 
The structural schematic nature of the cycle is described. 
Transcription factor codelets operate the phase change controls. 
How inhibitory agents are integrated into the cycle is described. 
An application agent with management and operational roles emerges. 
The codelets and supporting functions are included. 
Schematic PDCA
This page describes a schematic system about abstracted 'animal' and 'plant' cells competing in a small world. 
The schematic cell was designed to focus in on the nature of mutation and the adjacent possible. 
THE IMPLEMENTATION IS INCOMPLETE AND ONGOING. 
The codelets and infrastructure are included. 
Schematic cell
This page describes a schematic system about abstracted neurons operating in a circuit. 
The neuronal system was designed to focus in on the cellular nature of a schematically defined neuron. 
The goals include:
  • Development of a system of cells, their differentiation and deployment into a neuron network. 
  • Abstract receptor operation must support interactions of a network of neurons and attached cells. 
THE IMPLEMENTATION IS INCOMPLETE AND ONGOING. 
The codelets and infrastructure are included. 
Schematic innate neuron
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
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. 
Schematic assert merge
This page describes the inhibitor framework provided by the adaptive web framework's (AWF) Smiley agent programming infrastructure. 
Two mechanisms are provided:
  1. Uncompetitive inhibition of group completion. 
  2. Uncompetitive inhibition of transcription factors.  
In both cases the inhibitors provide a restriction process. 
The Slipnet inhibitor descriptions are included. 
The codelets and supporting infrastructure are included. 
Codelet restriction
This page discusses how the adaptive web framework (AWF) Smiley supports agent-based application's leverage of infrastucture amplification. 
A number of Smiley's amplification strategies are reviewed:
  • Locality
  • Enzyme like catalysis
  • Efficient routing through the Slipnet 
  • Independence and equivalence of transactional codelets 
  • Structurally enhanced state based amplification
The architecture of Smiley's grab amplification is discussed.  This includes:
  • Sub program grab amplification
  • Deployment infrastructure cooperation in grab amplification
  • Generalizing the grab architecture 
The mechanisms Smiley uses to limit the impact of amplification, such as crowding out and processor starvation, on other codelets operations are discussed. 
The codelets and infrastructure are included. 
Infrastructure amplifier
This page describes the 'merge streams' application's codelet implementation of a 'case' architecture based on the adaptive web framework's (AWF) Smiley histone infrastructure. 
The application scenario for processing case statements is described. 
It involves a schematic binder complex for resolving the case statements. 
A case tagged application schemata. 
The Smiley infrastructure that supports the case architecture is reviewed. 
The Workspace schematic strings that implement the operon supporting histone like case control are included. 
The Slipnet concept network for the 'merge streams' application's histone like case control is included. 
The codelets and supporting functions are included. 
Schematic case
This page describes the adaptive web framework (AWF) Smiley agent progamming infrastructure's codelet based Copycat grouping operation. 
The requirements needed for a group to complete are described. 
The association of group completion with a Slipnet defined operon is described.  Either actions or signals result from the association. 
How a generated signal is transported to the nucleus of the cell and matched with an operon is described. 
A match with an operon can result in deployment of a schematic string to the original Workspace.  But eventually the deployed string will be destroyed. 
Smiley infrastructure amplification of the group completion operation is introduced.  This includes facilities to inhibit crowding out of offspring. 
A test file awfart04 is included. 
The group codelet and supporting functions are included. 
Group complete
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
This page describes the Copycat Slipnet. 
The goal of the Slipnet is reviewed. 
Smiley's specialized use of the Slipnet is introduced. 
The initial Slipnet network used by the 'Merge Streams' and 'Virtual Robot' agent-based applications is setup in initchemistry and is included. 
The Slipnet infrastructure and initialization functions are included. 
Slipnet
Workspace
This page describes the Copycat Coderack. 
The details of the codelet architecture are described. 
The specialized use of the Coderack by the adaptive web framework's (AWF) Smiley is discussed. 
The codelet scheduling mechanism is discussed. 
A variety of Smiley extensions to the Coderack are reviewed. 
The Coderack infrastructure functions are included. 
Coderack
This page discusses how Smiley provides signalling to its agent-based applications. 
Alternative strategies for initiating the signalling are reviewed. 
The codelets and supporting functions are included.
Schematic signals
This page discusses how Smiley provides deployment guarantees to its agent-based applications. 
Smiley's transaction services are reviewed. 
The complex interactions of codelets participating in a deployment cascade are discussed including: 
  • The implementation of schematic switches. 
  • The cooperative use of goal suppression.  
  • Evaluator codelets promotion of other siblings. 
Challenges of initiation of a cascade are discussed. 
Tools to associate transaction protection to an operon deployed codelet are described. 
Special support for sub-program codelets is described.  Completion of transactional sub-programs presents special challenges. 
Priority and synchronization support includes:
  • Delaying the operaton of the cascade sponsor. 
  • Delaying the notgcompleting cascade participant. 
  • Waiting for completion of parallel operations with the wait and relay service.  
The need to sustain resource pools is reviewed. 
The use of signals to coordinate siblings is described. 
The structural binding operon for the wait and relay service is included. 
The codelets and supporting functions are included.
Schematic cascades
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. 
Associative labels
This page describes the Smiley data structures.   
Key structures are described each of which is based on a list structure represented with an array and add and free subroutines. 
Data structures
Primary Navigation

Perceptual 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 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. 
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 its physical environment.  To do this we 'repurposed' Copycat's solution the Workspace. 

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 perceptual situation is maintained in the Workspace. 
Smiley's specialized use of the Workspace
In the adaptive web framework (AWF)'s implementation of the architecture (the AWF test infrastructure) the Workspace is initially loaded with a specification statement and nuclear
Plans emerge in complex adaptive systems (CAS) to provide the instructions that agents use to perform actions.  The component architecture and structure of the plans is reviewed. 
memes based on the
This page describes the Copycat Slipnet. 
The goal of the Slipnet is reviewed. 
Smiley's specialized use of the Slipnet is introduced. 
The initial Slipnet network used by the 'Merge Streams' and 'Virtual Robot' agent-based applications is setup in initchemistry and is included. 
The Slipnet infrastructure and initialization functions are included. 
Slipnet's relations and the physical rules defined 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 Workspace is essentially a chemical, molecules obtain chemical properties from the atoms from which they are composed and from the environment in which they exist.  Being relatively small they are subject to phenomena which move them about, inducing collisions and possibly reactions with other molecules.  AWF's Smiley simulates a chemical environment including associating the 'molecule' like strings  with codelet based forces that allow the strings to react based on their component parts, sequence etc.  
The complex adaptive system (CAS) nature of a value delivery system is first introduced.  It's a network of agents acting as relays. 

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

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

Finally an example of aligning a VDS is presented. 
environment into which
Plans emerge in complex adaptive systems (CAS) to provide the instructions that agents use to perform actions.  The component architecture and structure of the plans is reviewed. 
schematic structures such as additional memes can
This page discusses the mechanisms and effects of emergence underpinning any complex adaptive system (CAS).  Key research is reviewed. 
emerge.  Each Workspace object, like a carbon atom, is a building block, able, due to its list structure and functions (addwsoli), to integrate into backbone and side chains.  This enables the rich representation environment where descriptions can be supported. 
Text including XML style keywords can be imported and converted into Workspace structures
Any text string can be loaded into the Workspace using the convbws function.  As it processes each character of the text string convbws decides if it is part of a keyword defined in the Meta file.  If it is then the keyword will be added to the Workspace rather than the discrete characters.  Similarly if convbws is told via 'meta commands' embedded in the text string that this part of the string is grouped then if convbws identifies the Workspace object as being part of a sequence configured in the Slipnet the Workspace group will be associated with this Slipnet configuration. 

Workspace objects include a keyword attribute.  Using a chemical analogy this is the 'atomic' core of the Workspace object.  Each keyword can have physical
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 associated with it. 

The Workspace objects become the focus of attention of
Plans are interpreted and implemented by agents.  This page discusses the properties of agents in a complex adaptive system (CAS). 
It then presents examples of agents in different CAS.  The examples include a computer program where modeling and actions are performed by software agents.  These software agents are aggregates. 
The participation of agents in flows is introduced and some implications of this are outlined. 
agents which are aggregates of codelets operating on execution infrastructure called the
This page describes the Copycat Coderack. 
The details of the codelet architecture are described. 
The specialized use of the Coderack by the adaptive web framework's (AWF) Smiley is discussed. 
The codelet scheduling mechanism is discussed. 
A variety of Smiley extensions to the Coderack are reviewed. 
The Coderack infrastructure functions are included. 
Coderack.  Each time an agent identifies a perception about an object or group of objects it deploys a Workspace object
This page discusses the tagging of signals in a complex adaptive system (CAS).  Tagged signals can be used to control filtering of an event stream.  Examples of CAS filters are reviewed. 
tag. 

The Workspace objects various attributes are mapped to parts of a procedurally addressed bit vector. 

The percepts (tags) are descriptors that are associated with the particular situation.

Schematic structures can become deployed in any Workspace. 
Smiley telomeric schematic structures
Telomeric seal the ends of a chromosome.  During each replication of the chromosome the telomeres shrink slightly.  Over time they act as an indication of the total age of the organism and contribute to the death from 'old age' of some organisms.  Stem cells are protected from this chromosomal aging by telomerases.  But differentiated cells are expected to die and do not express telomerase.  In the adaptive web framework's (AWF) Smiley telomeric infrastructure counts down the age of telomeric schematic strings.  The analogy with a real telomere is weak and has no operational equivalence! 
schematic structures have the additional property that they are monitored, aged and can be destroyed, by destruction codelets (s, e, b), once their density reaches a threshold and their associated telomeric count drops below an ageing threshold.  A special independent and equivalent form of telomeric schemata can represent multiple codelets, is
This page describes the Smiley infrastructure that supports the associative binding of schematic strings to codelets defined in the Meta file and Slipnet. 
The infrastructure supporting the associations is introduced. 
The role of Jeff Hawkins neocortical attributes is discussed. 
Relevant Slipnet configurations are included. 
The codelets and supporting functions are included. 
associated with jhls references, and is protected from destruction. 
Workspace object state

 
# Keywords are chained together by their list heads; The end of the list is a sentinel
# The head of an active list entry will be the list index of the next entry in the list
# With the hash the list can be entered at one sentinel.
# The head is setup for an easy add of a new element
# memes->{wsobjectl} => wsol->{l}
# wsol-> {l} [$i][0] is backward link
# wsol-> {l} [$i][1] is forward link
# wsol-> {l} [$i][2] is index of first perception descriptor
# wsol-> {l} [$i][3] is number of descriptors
# wsol-> {l} [$i][4] is the keyword in first element
# wsol-> {l} [$i][5] is the instantaneous mean activation (5+6 = salience)
# wsol-> {l} [$i][6] is the instantaneous unhappiness
# wsol-> {l} [$i][7] is the instantaneous strength
# wsol-> {l} [$i][8] is the head log items index or 0 if none
# wsol-> {l} [$i][9] is the access count element items index or 0 if none
# wsol-> {l} [$i][10] is the log usage count: log will write if value is > 0
# wsol-> {l} [$i][11] is the wsbasetype if setup
# wsol-> {l} [$i][12] is the wsbaseind if setup
# gccache
# wsol-> {l} [$i][13] is the completed wsgroups sponsor if setup
# wsol-> {l} [$i][14] is previous logical workspace object
# wsol-> {l} [$i][15] points to the base and offset of the workspace in wsbl
# wsol-> {l} [$i][16] is the next logical workspace object
# wsol-> {l} [$i][17] is [0] the keyword backward links wsi
# wsol-> {l} [$i][18] is [1] the keyword forward links wsi
# wsol-> {l} [$i][19] is primary keyword position in metafile
# wsol-> {l} [$i][20] is primary keyword wsi
# wsol-> {l} [$i][21] is count of begins that wso is within scope
# wsol-> {l} [$i][22] is count of starts that wso is within scope
# wsolfbv
# wsol-> {l} [$i][23] is itstrengths value
# wsol-> {l} [$i][26] is link address of 'single' group descriptor (fgrpd)
# tdgroupdcache
# wsol-> {l} [$i][25] is cache value for tdgroup1
# wsol-> {l} [$i][27] is cache value for tdbond1
# wsol-> {l} [$i][28] is cache value for bugroup1
# wsol-> {l} [$i][29] is isterminated cache if present
# wsol-> {l} [$i][30] is bindtoinspector cache if present
# wsol-> {l} [$i][31] is bustatement cache if present
# wsol-> {l} [$i][32] is namespace (operon|stbinding) relative jhlsoi set in deploymd & groupbuilder when deploys completed group and matches jhlabels
# wsol-> {l} [$i][33] is histone binding ptr if present and non-zero
# wsol-> {l} [$i][34] is jhlsi for groupcomplete sponsor wso
#
# wsol-> {fbs} [$i][23 - 23] 't==2' is record of descriptor update (strength)
# wsol-> {fbs} [$i][24 - 23] 't==2' is record of descriptor update (unhappiness)
# wsol-> {fbs} [$i][25 - 23] 't==2' is record of descriptor update (tdgroup1)
# wsol-> {fbs} [$i][27 - 23] 't==2' is record of descriptor update (tdbond1:strocc)
# wsol-> {fbs} [$i][28 - 23] 't==2' is record of descriptor update (bugroup1)
#
#
#

Functions

#
sub convbws {
    my($myli, $buffer, $kwp, $kwpr, $kwmi, $kwmir, $sponsor, $insymbol, $inmsymbol, $started, $end, $depstag, $depttag, $dephtag, $wsi, $namespace, $strscope, $actbt, $setwsclinv)=@_;
    my ($char, $schar, $kws, $kwl, $kwind, $kwai, $ptstoptf, $ptstarttf, $ptrecordtf, $linki, $cwsbi, $akwai, $ptmrf, $ptmbf, $ptmgf, $ptmhf, $ptmtf, $ptwindtf, $ptunwindtf, $newmemetics, $removekwcc, $wascomp, $wascbp, $wascsp,
    $sec, $min, $hour, $mday, $mon, $year, $wday, $yday, $isdat, $convst, $convet, $convwst, $convwet, $convcst, $convcet, $convcbst, $convcbet, $convost, $convoet);
# characterise each character, or token in a buffer and make a wso
#
# updated for merged workspaces

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("convbws kwp $$kwp kwpr $kwpr kwmi $kwmi kwmir $kwmir wsi $wsi ");
      }
    if ($Awfif::memes-> {trace} == $Awfif::memes-> {tracehrtime}) {
      use Time::HiRes 'time';
      ($sec, $min, $hour, $mday, $mon, $year, $wday, $yday, $isdat) = localtime(time);
      };
    $convst = time ();
    $cwsbi = $Awfif::memes-> {currentwsbi};
# convflip
# while ( $$buffer =~/<(\/)*(rhl)+(t)*(case)*([^>]+)?>+?/i) {
    while ( $$buffer =~/<(\/|#)*(rhl)+(t)*(case)*([^>]+)?>+?/i) {

      my ($a, $b);
      $a = $1.$2.$3.$4.$5;
      $b = $1.$5.$2.$3.$4;
      $$buffer =~ s/\Q<$a/<$b/;
      } # flip complete
    $convcet = time ();
    $Awfif::memes-> {time} [$Awfif::memes-> {spctime}] [$Awfif::memes-> {ch}{$Awfif::codelet-> {l} [$myli] [2]}] [$Awfif::memes-> {convfsum}] = $Awfif::memes-> {time} [$Awfif::memes-> {spctime}] [$Awfif::memes-> {ch}{$Awfif::codelet-> {l} [$myli] [2]}] [$Awfif::memes-> {convfsum}] + $convcet - $convst;
    $char = unpack ('a', $$buffer); #prime char
    $removekwcc = '';
    if (!$$setwsclinv) {

      &wsclinv (0, $wsi, $strscope);# force the bottom-up workspace caches to reset
      $$setwsclinv = 't';
      };#
    $Awfif::memes-> {cativationchange} [$wsi] = 't';
    while ($char ne '') {#not end of record
      if ($Awfif::memes-> {comprocessing} == 1) {#remember if comprocessing so can clear the char if stop

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

        $wascomp = '';
        };#else
      if ($Awfif::memes-> {cbprocessing} == 1) {#remember if cbprocessing so can record the stop

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

        $wascbp = '';
        };#else
      if ($Awfif::memes-> {csprocessing} == 1) {#remember if catch string processing so can record the stop

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

        $wascsp = '';
        };#else
# work in the new workspace

      $Awfif::memes-> {currentwsbi} = $wsi;
      if (($char eq '<')
      && ( keywmatch ($myli, \$$buffer, \$kws, \$kwind, \$kwl, $kwmi, $kwmir, \$Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}], $Awfif::wsbl-> {wsot} [$Awfif::memes-> {currentwsbi}], \$kwai, $wsi, \@$started, \$$end, \$newmemetics, \$Awfif::memes-> {comprocessing}, \$Awfif::memes-> {cbprocessing}, \$Awfif::memes-> {csprocessing}))) {#its a keyword token

        $convcst = time ();
        $removekwcc = 't';
        $$buffer =~ s/\Q$kws//i;
# convbwscb
        if ($Awfif::memes-> {cbprocessing} == 1) {#special processing on anything except </rhlbmsge>

          $$buffer =~ s/\Q>//i;
          $char = '(';
          &newwso ($myli, \$char, 1, $Awfif::memes->{snnh}{ichar}, \$Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}], $Awfif::wsbl-> {wsot} [$Awfif::memes-> {currentwsbi}]);# make it into a char based wso
# describe the fact that this paren really substitutes for a meta tag
          $Awfif::wsol-> {l} [awsoadr ($Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}])][2]
            = setupdesc ( $Awfif::memes-> {snnh} {start},
              ($Awfif::memes-> {snnh} {mcharbuffer}), #its an end edge
              $Awfif::memes-> {snnh} {mattrib},
              $Awfif::wsol-> {l} [awsoadr ($Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}])][2],
              awsoadr ($Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}]));
          $char = '';
          }#if
        elsif ($Awfif::memes-> {csprocessing} == 1) {#special processing on anything except </tmbinding>

          if ($$buffer =~ /(\s)*(['"])+(\s)*(\w+)*(\s)*(['"])+(\s)*/i){

            $Awfif::memes-> {catchstring} [ ++ $Awfif::memes-> {catchstring} [0] ] = $4;
            $$buffer =~ s/\Q$1$2$3$4$5$6$7//i;
# $Awfif::memes-> {csprocessing} = 0;#so that deploymd processes the end keyword
            };#if
          $char = '';
          }#elsif
# convbwscoms
        elsif ($Awfif::memes-> {comprocessing} == 0) {# otherwise stop processing anything except </comm

          if (!$newmemetics) {

            no strict 'refs';
            if (@$inmsymbol != 0) {

              my (@dumstarted, $dumend);
              $dumstarted[0] = -1;
              $dumstarted[1] = '';#initial phase
              $dumend = 0;
              &deploymd ($myli, \@$inmsymbol, $wsi, 0, \@dumstarted, \$dumend, \$$depstag, \$$depttag, \$$dephtag, $newmemetics, $namespace, $strscope, $actbt);
              };#deploy start edge if appropriate
            &newwso ($myli, \$kws, $kwl, $kwind, \$Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}], $Awfif::wsbl-> {wsot} [$Awfif::memes-> {currentwsbi}]);# make it into a char based wso

            no strict 'refs';
            if (@$inmsymbol != 0) {

              &deploymd ($myli, \@$inmsymbol, $wsi, $Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}], \@$started, \$$end, \$$depstag, \$$depttag, \$$dephtag, $newmemetics, $namespace, $strscope, $actbt);
              }#deploy descriptors for meta tags
            else {#clear end

              $$end = '';
              };
            if ((Awfif::wsbasetype( $Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}]) > 0)
            && ((defined ($actbt)) && ($actbt)) #only activate if caller requires it
# && (($actbt ne '') && ($actbt))
            && ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[Awfif::wsbasetype( $Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}])] > 0) ){#activate the base type

              &setinhib (wsbasetype( $Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}]),0);
              &Awfif::actnodes (wsbasetype($Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}]), $Awfif::memes-> {convfrom}, $strscope);
              };#found basetype
            };#not a new meta keyword

          $akwai = flagkws ($kwai, \$ptstoptf, \$ptstarttf, \$ptrecordtf, \$ptmrf, \$ptmbf, \$ptmgf, \$ptmtf, \$ptwindtf, \$ptunwindtf, \$ptmhf);
          if (
          ($ptmgf) &&
          ($ptstarttf)) {

            my ($wsbi);
            $wsbi = $Awfif::memes-> {currentwsbi};
            $Awfif::memes-> {currentwsbi} = $wsi;
            push (@$inmsymbol, $Awfif::wsol-> {l}[$akwai][4]);
            $Awfif::memes-> {currentwsbi} = $wsbi;
            $linki = addmkw ($sponsor);
            $Awfif::mkwl-> {l} [$linki][3] = $Awfif::wsol-> {l}[$akwai][4];
            $$depstag = 't';
            }#memetic start
# convbwstel1
          elsif (
            ($ptmtf) &&
            ($ptstarttf)) {#Telomeric memetic

            push (@$inmsymbol, $Awfif::wsol-> {l}[$akwai][4]);
            $linki = addmkw ($sponsor);
            $Awfif::mkwl-> {l} [$linki][3] = $Awfif::wsol-> {l}[$akwai][4];
            $$depttag = -1;
            }#telomeric memetic start
# convbwshis1
          elsif (
            ($ptmhf) &&
            ($ptstarttf)) {#histome memetic

            push (@$inmsymbol, $Awfif::wsol-> {l}[$akwai][4]);
            $linki = addmkw ($sponsor);
            $Awfif::mkwl-> {l} [$linki][3] = $Awfif::wsol-> {l}[$akwai][4];
            $$dephtag = -(addhistone ($sponsor));
            }#histome memetic start
          elsif (
# ($ptrecordtf) &&
            ($ptstarttf)) {

            $$insymbol = 't';
            $linki = addkw ($sponsor);
            $Awfif::kwl-> {l} [$linki][3] = $Awfif::wsol-> {l}[$akwai][4];
            if ($ptwindtf) {# need to mark the head of the kwl

              $Awfif::kwl-> {w} [$Awfif::kwl-> {h}] = 't';
              };#if wind
            }
          elsif (
# ($ptrecordtf) &&
            ($ptstoptf)) {

            my ($kw, $scomp);
            $kw = $Awfif::wsol-> {l}[$akwai][4];
            $kw =~ s/\Q\///i;
            $scomp = '';
# convbwstel2
# convbwshis2
            if (($ptmbf) or ($ptmgf) or ($ptmrf) or ($ptmtf) or ($ptmhf)) {#memetic

              $linki = $Awfif::mkwl-> {h};
              }
            else {

              $linki = $Awfif::kwl-> {h};
              };
            while ((!$scomp) && ($linki != 0)) {
# convbwstel3
# convbwshis3
              if (($ptmbf) or ($ptmgf) or ($ptmrf) or ($ptmtf) or ($ptmhf)) {

                if ($kw eq $Awfif::mkwl-> {l} [$linki][3]) {

                  $scomp = 't';
                  &freemkw ($linki);
# seems to create problems removed 1 sep 07 if ($Awfif::mkwl-> {tlistl} == $Awfif::mkwl-> {flistl}) {

                  pop (@$inmsymbol);
                  push (@$inmsymbol, $Awfif::wsol-> {l}[$akwai][4]);
                  if ($newmemetics) {
# convbwshis4

                    my (@hainmsymbol);
                    &deploymd ($myli, \@$inmsymbol, $wsi, $Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}], \@$started, \$$end, \$$depstag, \$$depttag, \$$dephtag, $newmemetics, $namespace, $strscope, $actbt);
                    $$end = '';

                    @hainmsymbol = remstkw ($myli, \@$inmsymbol);
                    if (@hainmsymbol != 0) {

                      &deploymd ($myli, \@hainmsymbol, $wsi, $Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}], \@$started, \$$end, \$$depstag, \$$depttag, \$$dephtag, $newmemetics, $namespace, $strscope, $actbt);
                      }#deploy descriptors for meta tags
                    };# if
# seems to create problems removed 1 sep 07 };#if
                  }#if
                $linki = $Awfif::mkwl-> {l} [$linki] [0];
                }
              else {
                if ($kw eq $Awfif::kwl-> {l} [$linki][3]) {

                  $scomp = 't';
                  &freekw ($linki);
                  if ($Awfif::kwl-> {tlistl} == $Awfif::kwl-> {flistl}) {

                    $$insymbol = '';
                    };
                  }#if
                $linki = $Awfif::kwl-> {l} [$linki] [0];
                };#non memetic
              };#while entries in active list and not found match
            if ($ptunwindtf) {# need to remove entries from the head of kwl until match
              my ($linki);

              $linki = $Awfif::kwl-> {h};
              while ($linki != 0) {

                $linki = unwindkw ($linki);
                };# while wind
              };#if wind
            };#if
# restore current default workspace base

          $Awfif::memes-> {currentwsbi} = $cwsbi;
          }# not in comment mode
        $convcet = time ();
        $Awfif::memes-> {time} [$Awfif::memes-> {spctime}] [$Awfif::memes-> {ch}{$Awfif::codelet-> {l} [$myli] [2]}] [$Awfif::memes-> {convcsum}] = $Awfif::memes-> {time} [$Awfif::memes-> {spctime}] [$Awfif::memes-> {ch}{$Awfif::codelet-> {l} [$myli] [2]}] [$Awfif::memes-> {convcsum}] + $convcet - $convcst;
        }# possible keyword
      elsif (($Awfif::memes-> {cbprocessing} == 1)
        ) {#

        $convcbst = time ();
        no strict 'refs';
        if (@$inmsymbol != 0) {

          my (@dumstarted, $dumend);
          $dumstarted[0] = -1;
          $dumstarted[1] = '';
          $dumend = 0;
          &deploymd ($myli, \@$inmsymbol, $wsi, 0, \@dumstarted, \$dumend, \$$depstag, \$$depttag, \$$dephtag, $newmemetics, $namespace, $strscope, $actbt);
          }#deploy start edge if appropriate
        &newwso ($myli, \$char, 1, $Awfif::memes->{snnh}{char}, \$Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}], $Awfif::wsbl-> {wsblot} [$Awfif::memes-> {currentwsbi}]);# make it into a char based wso

        no strict 'refs';
        if (@$inmsymbol != 0) {

          &deploymd ($myli, \@$inmsymbol, $wsi, $Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}], \@$started, \$$end, \$$depstag, \$$depttag, \$$dephtag, $newmemetics, $namespace, $strscope, $actbt);
          }#deploy descriptors for meta tags
        else {#clear end

          $$end = '';
          };

        if (($char ne '<')
        or ($char eq unpack ('a', $$buffer))# turns out that two open chevrons does not occur often in the char buffer datastream
        ){

          $$buffer =~ s/\Q$char//i;
          };#if
        $char = '';
        $convcbet = time ();
        $Awfif::memes-> {time} [$Awfif::memes-> {spctime}] [$Awfif::memes-> {ch}{$Awfif::codelet-> {l} [$myli] [2]}] [$Awfif::memes-> {convcbsum}] = $Awfif::memes-> {time} [$Awfif::memes-> {spctime}] [$Awfif::memes-> {ch}{$Awfif::codelet-> {l} [$myli] [2]}] [$Awfif::memes-> {convcbsum}] + $convcbet - $convcbst;
        }
      elsif ($Awfif::memes-> {csprocessing} == 1) {#special processing on anything except </tmbinding>

        if ($$buffer =~ /(\s)*(['"])+(\s)*(\w+)*(\s)*(['"])+(\s)*/i){

          $Awfif::memes-> {catchstring} [ ++ $Awfif::memes-> {catchstring} [0] ] = $4;
          $$buffer =~ s/\Q$1$2$3$4$5$6$7//i;
# $Awfif::memes-> {csprocessing} = 0;
          }#if
        else {

          $$buffer =~ s/\Q$char//i;
          };#else
        $char = '';
        }
      elsif (($char eq '<')
      && ($wascsp)
      ) {#keyword has already processed the buffer

        $char = '';
        $wascsp = '';
        }
      elsif (($char eq '<')
      && ($wascomp)
      ) {#keyword has already processed the buffer

        $char = '';
        $wascomp = '';
        }
      elsif (($char eq '<')
      && ($Awfif::memes-> {cbprocessing} != 1)
      && ($wascbp)
      ) {#keyword has already processed the buffer

        $char = ')';
        &newwso ($myli, \$char, 1, $Awfif::memes->{snnh}{ichar}, \$Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}], $Awfif::wsbl-> {wsot} [$Awfif::memes-> {currentwsbi}]);# make it into a char based wso
# describe the fact that this paren really substitutes for a meta tag
        $Awfif::wsol-> {l} [awsoadr ($Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}])][2]
          = setupdesc ( $Awfif::memes-> {snnh} {stop},
            ($Awfif::memes-> {snnh} {mcharbuffer}), #its an end edge
            $Awfif::memes-> {snnh} {mattrib},
            $Awfif::wsol-> {l} [awsoadr ($Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}])][2],
            awsoadr ($Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}]));
# get rid of the closing chevron left over from the stop charbuffer keyword
        $char = '>';
        $$buffer =~ s/\Q$char//i;
        $char = '';
        $wascbp = '';
        }
      elsif ($char eq "\n") {

        $$buffer =~ s/\Q$char//i;
        }
      elsif (($Awfif::memes-> {comprocessing} == 1)
        ) {#keyword has already processed the buffer

#old use $convcst = time ();
        $$buffer =~ s/\Q$char//i;
        $char = '';
#old use $convcet = time ();
#old use $Awfif::memes-> {time} [$Awfif::memes-> {spctime}] [$Awfif::memes-> {ch}{$Awfif::codelet-> {l} [$myli] [2]}] [$Awfif::memes-> {convcsum}] = $Awfif::memes-> {time} [$Awfif::memes-> {spctime}] [$Awfif::memes-> {ch}{$Awfif::codelet-> {l} [$myli] [2]}] [$Awfif::memes-> {convcsum}] + $convcet - $convcst;
        }
      elsif (($char eq '>')
      && ( ($removekwcc) or ($wascomp) )
        ) {#keyword has already processed the buffer

        $$buffer =~ s/\Q$char//i;
        $char = '';
        $removekwcc = '';
        $wascomp = '';
        }
      elsif (($schar = ''.$char) ne ' ') {#hopefully force a number to be treated as a character rather than => else

        $convost = time ();
        if ($$insymbol) {

          my ($convoast, $convoaet);
          &newwso ($myli, \$char, 1, $Awfif::memes->{snnh}{char}, \$Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}], $Awfif::wsbl-> {wsblot} [$Awfif::memes-> {currentwsbi}]);# make it into a char based wso
          $convoast = time ();
          if ((Awfif::wsbasetype ( trwsoadr ($Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}], -1)) > 0)
          && ((defined ($actbt)) && ($actbt)) #only activate if caller requires it
# && (($actbt ne '') && ($actbt))
          && (Awfif::wsbasetype ( trwsoadr ($Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}],-1)) ==
            $Awfif::workspace-> {l} [$Awfif::wsol-> {l} [ awsoadr ( trwsoadr ($Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}],-1))] [2]][2])
          && ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl} [wsbasetype ( trwsoadr ($Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}], -1))] > 0) ) {#activate the base type

            &Awfif::actnodes ($Awfif::workspace-> {l}[$Awfif::wsol-> {l}[ awsoadr ( trwsoadr ($Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}], -1))][2]][2], $Awfif::memes-> {descato}, $strscope);
            };#found basetype
          $convoaet = time ();
          $Awfif::memes-> {time} [$Awfif::memes-> {spctime}] [$Awfif::memes-> {ch}{$Awfif::codelet-> {l} [$myli] [2]}] [$Awfif::memes-> {convoasum}] = $Awfif::memes-> {time} [$Awfif::memes-> {spctime}] [$Awfif::memes-> {ch}{$Awfif::codelet-> {l} [$myli] [2]}] [$Awfif::memes-> {convoasum}] + $convoaet - $convoast;

          no strict 'refs';
          if (@$inmsymbol != 0) {

            &deploymd ($myli, \@$inmsymbol, $wsi, $Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}], \@$started, \$$end, \$$depstag, \$$depttag, \$$dephtag, $newmemetics, $namespace, $strscope, $actbt);
            };#deploy descriptors for meta tags
          }
        else {

          $convwst = time ();
          &newwso ($myli, \$char, 1, $Awfif::memes->{snnh}{ichar}, \$Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}], $Awfif::wsbl-> {wsot} [$Awfif::memes-> {currentwsbi}]);# make it into a char based wso
          $convwet = time ();
          $Awfif::memes-> {time} [$Awfif::memes-> {spctime}] [$Awfif::memes-> {ch}{$Awfif::codelet-> {l} [$myli] [2]}] [$Awfif::memes-> {convwsum}] = $Awfif::memes-> {time} [$Awfif::memes-> {spctime}] [$Awfif::memes-> {ch}{$Awfif::codelet-> {l} [$myli] [2]}] [$Awfif::memes-> {convwsum}] + $convwet - $convwst;
          };#if
        if (($char ne '<')
        or (unpack ('a', $$buffer) eq '<')
        ) {#the keyword processor will have removed the < from the buffer even if it decides this isn't a keyword.

          $$buffer =~ s/\Q$char//i;
          };#if
        $char = '';
# go back to current work space
        $Awfif::memes-> {currentwsbi} = $cwsbi;
        $convoet = time ();
        $Awfif::memes-> {time} [$Awfif::memes-> {spctime}] [$Awfif::memes-> {ch}{$Awfif::codelet-> {l} [$myli] [2]}] [$Awfif::memes-> {convosum}] = $Awfif::memes-> {time} [$Awfif::memes-> {spctime}] [$Awfif::memes-> {ch}{$Awfif::codelet-> {l} [$myli] [2]}] [$Awfif::memes-> {convosum}] + $convoet - $convost;
        }# else make char
      else {#its going to be classed as white space

        $convwst = time ();
        if ($$insymbol) {

          &newwso ($myli, \$char, 1, $Awfif::memes->{snnh}{char}, \$Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}], $Awfif::wsbl-> {wsot} [$Awfif::memes-> {currentwsbi}]);# make it into a char based wso
          if ((Awfif::wsbasetype( trwsoadr ($Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}], -1)) > 0)
          && ((defined ($actbt)) && ($actbt)) #only activate if caller requires it
          && (Awfif::wsbasetype ( trwsoadr ($Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}], -1)) ==
            $Awfif::workspace-> {l} [$Awfif::wsol-> {l}[ awsoadr( trwsoadr ($Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}], -1))] [2]] [2])
          && ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl} [ Awfif::wsbasetype ( trwsoadr ($Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}], -1))] > 0) ){#activate the base type

            &Awfif::actnodes ($Awfif::workspace-> {l}[$Awfif::wsol-> {l}[ awsoadr( trwsoadr ($Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}], -1))][2]][2], $Awfif::memes-> {descato}, $strscope);
          };#found basetype
          no strict 'refs';
          if (@$inmsymbol != 0) {

            &deploymd ($myli, \@$inmsymbol, $wsi, $Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}], \@$started, \$$end, \$$depstag, \$$depttag, \$$dephtag, $newmemetics, $namespace, $strscope, $actbt);
            };#deploy descriptors for meta tags
          }
        else {

          &newwso ($myli, \$char, 1, $Awfif::memes->{snnh}{whitespace}, \$Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}], $Awfif::wsbl-> {wsot} [$Awfif::memes-> {currentwsbi}]);# make it into a whitespace based wso
          };#if

        $$buffer =~ s/\Q$char//i;
# go back to current work space
        $Awfif::memes-> {currentwsbi} = $cwsbi;
        $convwet = time ();
        $Awfif::memes-> {time} [$Awfif::memes-> {spctime}] [$Awfif::memes-> {ch}{$Awfif::codelet-> {l} [$myli] [2]}] [$Awfif::memes-> {convwsum}] = $Awfif::memes-> {time} [$Awfif::memes-> {spctime}] [$Awfif::memes-> {ch}{$Awfif::codelet-> {l} [$myli] [2]}] [$Awfif::memes-> {convwsum}] + $convwet - $convwst;
        };

      $char = unpack ('a', $$buffer); #prime char
      if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {

        print ("convbws char($char) ");
        };# trace
      };# while to process each char in the record
    $convet = time ();
    $Awfif::memes-> {time} [$Awfif::memes-> {spctime}] [$Awfif::memes-> {ch}{$Awfif::codelet-> {l} [$myli] [2]}] [$Awfif::memes-> {convbsum}] = $Awfif::memes-> {time} [$Awfif::memes-> {spctime}] [$Awfif::memes-> {ch}{$Awfif::codelet-> {l} [$myli] [2]}] [$Awfif::memes-> {convbsum}] + $convet - $convst;

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("convbwsx\n");
      };# trace
    } # end of convbws
#
sub flagkws {
    my ($kwai, $ptstoptf, $ptstarttf, $ptrecordtf, $ptmrf, $ptmbf, $ptmgf, $ptmtf, $ptwindtf, $ptunwindtf, $ptmhf)=@_;
    my ($i, $akwai, $cwsbi);
# flag the keywords matched in the workspace

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("flagkws kwai $kwai ");
      }
    $cwsbi = $Awfif::memes-> {currentwsbi};
    $$ptstoptf = '';
    $$ptstarttf = '';
    $$ptrecordtf = '';
    $$ptmrf = '';
    $$ptmbf = '';
    $$ptmgf = '';
    $$ptmtf = '';
    $$ptmhf = '';
    $$ptunwindtf = '';
    $$ptwindtf = '';
# work with the meta keyword workspace
    $Awfif::memes-> {currentwsbi} = $Awfif::memes-> {kwwsbi};
    $akwai = awsoadr ($kwai);

    for ($i = $Awfif::wsol-> {l}[$akwai][2];$i < ($Awfif::wsol-> {l}[$akwai][2] + $Awfif::wsol-> {l}[$akwai][3]); $i++) {
      if ($Awfif::memes-> {keywordl}[$i] eq 'ptstartt') {

        $$ptstarttf = 't';
        }
      elsif ($Awfif::memes-> {keywordl}[$i] eq 'ptstopt') {

        $$ptstoptf = 't';
        }
      elsif ($Awfif::memes-> {keywordl}[$i] eq 'ptrecordt') {

        $$ptrecordtf = 't';
        }
      elsif ($Awfif::memes-> {keywordl}[$i] eq 'ptwindt') {

        $$ptwindtf = 't';
        }
      elsif ($Awfif::memes-> {keywordl}[$i] eq 'ptunwindt') {

        $$ptunwindtf = 't';
        };
      if ($Awfif::memes-> {keywordl}[$i] eq 'ptmsgroupt') {

        $$ptmgf = 't';
        };
      if ($Awfif::memes-> {keywordl}[$i] eq 'ptmsbondt') {

        $$ptmbf = 't';
        };
      if ($Awfif::memes-> {keywordl}[$i] eq 'ptmsrelt') {

        $$ptmrf = 't';
        };
# flagkwstel
      if (($Awfif::memes-> {keywordl}[$i] eq 'pttelomerestt') or ($Awfif::memes-> {keywordl}[$i] eq 'pttelomerespt')) {

        $$ptmtf = 't';
        };
# flagkwshis
      if ($Awfif::memes-> {keywordl}[$i] eq 'ptmhistt' ) {

        $$ptmhf = 't';
        };
      };#for tokens keywords
    $Awfif::memes-> {currentwsbi} = $cwsbi;

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("flagkwsx ptstoptf ($$ptstoptf) ptstarttf ($$ptstarttf) ptrecordtf ($$ptrecordtf) ptmrf ($$ptmrf) ptmbf ($$ptmbf) ptmgf ($$ptmgf) ptmtf ($$ptmtf) ptwindtf ($$ptwindtf) ptunwindtf ($$ptunwindtf) ret $akwai\n");
      };# trace
    return $akwai
    } # end of flagkws
#
#
sub addwsoli {
    my ($list) = @_;
# setup the structures to support linked buffers
    my ($pflink, $plink, $nslinkh, $aahead, $newhead, $headsentl);

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("addwsoli ");
      };
    if ( ($Awfif::memes-> {chckadd})
    && (($$list-> {f} < 0)
    or ($$list-> {t} <0)
    or ($$list-> {f} >= $$list-> {p})
    or ($$list-> {t} >= $$list-> {p})
    or (($$list-> {f} != 0)
    && ($Awfif::wsol-> {l}[$$list-> {f}][ $Awfif::memes-> {wsowsi}] != 0) ) #*** submacrok ***#
    or (($$list-> {t} != 0)
    && ($Awfif::wsol-> {l}[$$list-> {t}][ $Awfif::memes-> {wsowsi}] != 0) ) #*** submacrok ***#
    )
    ) {&break()};
# setup the links data
# the head and tail of this virtual workspace are managed here
    $newhead = '';
# if the tail is 0 then set it to 1 and initialise the head to 1
    if ($Awfif::wsbl-> {newhead}[$Awfif::memes-> {currentwsbi}]) {

      $aahead = 0;
      $Awfif::wsbl-> {newhead}[$Awfif::memes-> {currentwsbi}] = '';
      $newhead = 't';
      }
    else {

      $aahead = awsoadrd ($Awfif::wsbl-> {wsoh}[$Awfif::memes->{currentwsbi}]);
      };
# create an active descriptor
    $pflink = $$list-> {f};
    if (($pflink != 0 )
    && (($newhead) or ($pflink != $Awfif::wsbl-> {l} [$Awfif::memes-> {currentwsbi}][2]) or (canrejfwso (\$pflink, \$$list)))
    ){
# can reclaim one from the inactive list
# The inactive list can use absolute addressing

      if ($Awfif::wsol-> {l}[$pflink][ $Awfif::memes-> {wsowsi}] != 0) #*** submacrok ***#
      {&break()};
      $$list-> {flistl}--;
      $plink = $Awfif::wsol-> {l}[$pflink][ $Awfif::memes-> {wsoprev}]; #*** submacrok ***#
      if ($plink != 0) {

        $Awfif::wsol-> {l}[$plink][ $Awfif::memes-> {wsonext}] = 0; #*** submacrok ***#
        $$list-> {f} = $plink;
        } # if
      else {#zero the free head ptr

        $$list-> {f} = 0;
        $$list-> {t} = 0;
        };
      $headsentl = $Awfif::wsol-> {l}[awsoadrd ($Awfif::wsbl-> {wsoh}[$Awfif::memes-> {currentwsbi}])][ $Awfif::memes-> {wsonext}]; #*** submacrok ***#
# if this is a new head and the ws uses arch sentinals need to setup ws base and offset
      if (($newhead) && ($Awfif::wsbl-> {wsas}[$Awfif::memes->{currentwsbi}])) {#create sentinals
# the base + 1 must be the real address of the first item since that is the tail

        $Awfif::wsbl-> {l}[$Awfif::memes->{currentwsbi}][2] = $pflink-1;#base
        $Awfif::wsbl-> {l}[$Awfif::memes->{currentwsbi}][3] = 0;#offset
        $Awfif::wsbl-> {ofssum} [$Awfif::memes->{currentwsbi}] = 0;
        };#setup the ws base and offset
# The control data structures can use absolute addressing still
      if ((!$Awfif::wsbl-> {wsas}[$Awfif::memes-> {currentwsbi}]) or ($newhead) or ($Awfif::wsbl-> {wsss}[$Awfif::memes-> {currentwsbi}])) {# don't move the head if this is a sentinal

        $Awfif::wsbl-> {wsoh}[$Awfif::memes->{currentwsbi}] = grwsoadr ($pflink);
        };
# the wsol head should have a sentinal in its 16 if architected sentinals in use so must remember this rel address as we restructure this

      if (!$newhead) {
        $Awfif::wsol-> {l}[$aahead][ $Awfif::memes-> {wsonext}] = grwsoadr ($pflink); #*** submacrok ***#
# setup the relative environment
        $Awfif::wsol-> {l}[$pflink][ $Awfif::memes-> {wsoprev}] = grwsoadr ($aahead); #*** submacrok ***#
        if (($Awfif::wsbl-> {wsas}[$Awfif::memes->{currentwsbi}]) && ($Awfif::wsbl-> {wsss}[$Awfif::memes-> {currentwsbi}])) {#head sentinal needs setting up

          $Awfif::wsol-> {l}[$pflink][ $Awfif::memes-> {wsonext}] = $headsentl; #*** submacrok ***#
          $Awfif::wsol-> {l}[awsoadrd ($headsentl)][ $Awfif::memes-> {wsoprev}] = grwsoadr ($pflink); #*** submacrok ***# #another problem for macro dep
          }
        else {

          $Awfif::wsol-> {l}[$pflink][ $Awfif::memes-> {wsonext}] = 0; #*** submacrok ***#
          };#else
        };#if
      $nslinkh = $pflink;
      }# found free links
    else {
# if there weren't any then get a newone
# if this is a new head and the ws uses arch sentinals need to setup ws base and offset

      $aahead = newwsolink ($aahead, \$$list);
      $$list-> {tlistl}++;
      $nslinkh = $aahead;
      if ((!$Awfif::wsbl-> {wsas}[$Awfif::memes-> {currentwsbi}]) or ($newhead) or ($Awfif::wsbl-> {wsss}[$Awfif::memes-> {currentwsbi}])) {# don't move the head if this is a sentinal
# The head is really a relative index of the head of this workspace.

        $Awfif::wsbl-> {wsoh}[$Awfif::memes-> {currentwsbi}] = grwsoadr ($nslinkh);
        };
      }; #else
# now have a descriptor but it may need sentinals (flagged by $newhead with {wsas})
    if (($newhead) && ($Awfif::wsbl-> {wsas}[$Awfif::memes->{currentwsbi}])) {#create sentinals

      my ($headsi, $aheadsi, $tailsi, $atailsi, $ahdptr);
# tail sentinal

      $tailsi = addwsoli (\$Awfif::wsol);
      $atailsi = awsoadrd ($tailsi);
# fix up the pointers

      $Awfif::wsol-> {l}[$atailsi][ $Awfif::memes-> {wsowsi}] = $Awfif::memes-> {currentwsbi}; #*** submacrok ***#
      $Awfif::wsol-> {l}[$atailsi][ $Awfif::memes-> {wsoprev}] = 0; #*** submacrok ***#
      $Awfif::wsol-> {l}[$atailsi][ $Awfif::memes-> {wsonext}] = $Awfif::wsbl-> {wsoh} [$Awfif::memes-> {currentwsbi}]; #*** submacrok ***#
# head sentinal

      $headsi = addwsoli (\$Awfif::wsol);
      $aheadsi = awsoadrd ($headsi);
# fix up the pointers

      $Awfif::wsol-> {l}[$aheadsi][ $Awfif::memes-> {wsowsi}] = $Awfif::memes-> {currentwsbi}; #*** submacrok ***#
      $Awfif::wsol-> {l}[$aheadsi][ $Awfif::memes-> {wsonext}] = 0; #*** submacrok ***#
      $Awfif::wsol-> {l}[$aheadsi][ $Awfif::memes-> {wsoprev}] = $Awfif::wsbl-> {wsoh} [$Awfif::memes-> {currentwsbi}]; #*** submacrok ***#
# and the head's pointers

      $ahdptr = awsoadrd ($Awfif::wsbl-> {wsoh} [$Awfif::memes-> {currentwsbi}]);
      $Awfif::wsol-> {l}[$ahdptr][ $Awfif::memes-> {wsowsi}] = $Awfif::memes-> {currentwsbi}; #*** submacrok ***#
      $Awfif::wsol-> {l}[$ahdptr][ $Awfif::memes-> {wsonext}] = $headsi; #*** submacrok ***#
      $Awfif::wsol-> {l}[$ahdptr][ $Awfif::memes-> {wsoprev}] = $tailsi; #*** submacrok ***#
      $Awfif::wsbl-> {wsss}[$Awfif::memes-> {currentwsbi}] = 't';
# addwsolitelhd
# add the telomeric root to the tail sentinal of the workspace

      &deptelhd ($Awfif::memes-> {currentwsbi});
      };#if should create the sentinals
# switch to relative addressing

    $nslinkh = grwsoadr ($nslinkh);
# The head is really a relative index of the head of this workspace.

    if ( ($Awfif::memes-> {chckadd})
    && (($$list-> {f} < 0)
    or ($$list-> {t} <0)
    or ($$list-> {f} >= $$list-> {p})
    or ($$list-> {t} >= $$list-> {p})
    or (($$list-> {f} != 0)
    && ($Awfif::wsol-> {l}[$$list-> {f}][ $Awfif::memes-> {wsowsi}] != 0) ) #*** submacrok ***#
    or (($$list-> {t} != 0)
    && ($Awfif::wsol-> {l}[$$list-> {t}][ $Awfif::memes-> {wsowsi}] != 0) ) #*** submacrok ***#
    )
    ) {&break()};

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

    return $nslinkh
    }# addwsolix
#
sub canrejfwso {# The caller can't accept this free chain wso move it from head if can or
    my ($pflink, $list) = @_;

    my ($result);
    $result = '';
    if (checkwsmd ($$pflink, $Awfif::memes-> {wsowsi}) != 0) {&break()};

    if ($$pflink == $$list-> {t}) {#can't reject this item its the only one
# setup the first list element
      $$pflink = 0;
      }
    else {#can reject this item
      my ($of, $ot, $ofws14, $ofws16, $nfws14, $nfws16);
# by moving it to the tail of the free list
# and returning the new head of the free list

      $result = 't';
      $of = $$list-> {f};
      $ot = $$list-> {t};
      $ofws14 = $Awfif::wsol-> {l}[$$list-> {f}][ $Awfif::memes-> {wsoprev}]; #*** submacrok ***#
      $ofws16 = $Awfif::wsol-> {l}[$$list-> {f}][ $Awfif::memes-> {wsonext}]; #*** submacrok ***#
      $nfws14 = checkwsmd (
        $Awfif::wsol-> {l}[$$list-> {f}][ $Awfif::memes-> {wsoprev}] #*** submacrok ***#
        ,$Awfif::memes-> {wsoprev});
      $nfws16 = checkwsmd (
        $Awfif::wsol-> {l}[$$list-> {f}][ $Awfif::memes-> {wsoprev}] #*** submacrok ***#
        ,$Awfif::memes-> {wsonext});
      $$pflink = $Awfif::wsol-> {l}[$$list-> {f}][ $Awfif::memes-> {wsoprev}]; #*** submacrok ***#
      $$list-> {t} = $of;
# make {f} point to new pflink

      $$list-> {f} = $$pflink;
# tail the rejected item

      $Awfif::wsol-> {l}[$$list-> {f}][ $Awfif::memes-> {wsonext}] = 0; #*** submacrok ***#
      $Awfif::wsol-> {l}[$of][ $Awfif::memes-> {wsoprev}] = 0; #*** submacrok ***#
      $Awfif::wsol-> {l}[$of][ $Awfif::memes-> {wsonext}] = $ot; #*** submacrok ***#
      $Awfif::wsol-> {l}[$ot][ $Awfif::memes-> {wsoprev}] = $of; #*** submacrok ***#
      };#else
    if (($$list-> {f} < 0)
    or ($$list-> {t} <0)
    or ($$list-> {f} >= $$list-> {p})
    or ($$list-> {t} >= $$list-> {p})
    or (($$list-> {f} != 0)
    && ($Awfif::wsol-> {l}[$$list-> {f}][ $Awfif::memes-> {wsowsi}] != 0) ) #*** submacrok ***#
    or (($$list-> {t} != 0)
    && ($Awfif::wsol-> {l}[$$list-> {t}][ $Awfif::memes-> {wsowsi}] != 0) ) #*** submacrok ***#
    ) {&break()};

    return $result;
    } # canrejfwso
#
sub newwsolink {# This knows the wsobjectl is an array and so free list is absolute addressed
    my ($froml, $larrayref) = @_;# currently assumes froml is a relative head address or 0

    my ($link, $headsentl);
    no strict 'refs';

    if ($froml == 0) {#start new set of links
# setup the first list element
      $Awfif::wsol-> {l}[$$larrayref-> {p}][ $Awfif::memes-> {wsoprev}] = 0; #*** submacrok ***#
      $Awfif::wsol-> {l}[$$larrayref-> {p}][ $Awfif::memes-> {wsonext}] = 0; #*** submacrok ***#
# note the head
      $link = $$larrayref-> {p};
      if (($Awfif::wsbl-> {wsas}[$Awfif::memes->{currentwsbi}])) {#base and offset need setting up

        $Awfif::wsbl-> {l}[$Awfif::memes->{currentwsbi}][2] = $link-1;#base
        $Awfif::wsbl-> {l}[$Awfif::memes->{currentwsbi}][3] = 0;#offset
        };#setup the ws base and offset
      }
    else {#add a link to this set

      $headsentl = $Awfif::wsol-> {l}[$froml][ $Awfif::memes-> {wsonext}]; #*** submacrok ***#
      $Awfif::wsol-> {l}[$froml][ $Awfif::memes-> {wsonext}] = grwsoadr ($$larrayref-> {p}); #*** submacrok ***#
# setup the relative environment
      $Awfif::wsol-> {l}[$$larrayref-> {p}][ $Awfif::memes-> {wsoprev}] = grwsoadr($froml); #*** submacrok ***#
      if (($Awfif::wsbl-> {wsas}[$Awfif::memes->{currentwsbi}]) && ($Awfif::wsbl-> {wsss}[$Awfif::memes-> {currentwsbi}])) {#head sentinal needs setting up

        my ($ahs);
        $ahs = awsoadrd ($headsentl);
        $Awfif::wsol-> {l}[$$larrayref-> {p}][ $Awfif::memes-> {wsonext}] = $headsentl; #*** submacrok ***#
        $Awfif::wsol-> {l}[$ahs][ $Awfif::memes-> {wsoprev}] = grwsoadr ($$larrayref-> {p}); #*** submacrok ***#
        }
      else {

        $Awfif::wsol-> {l}[$$larrayref-> {p}][ $Awfif::memes-> {wsonext}] = 0; #*** submacrok ***#
        };#else
# note the head

      $link = $$larrayref-> {p};
      };
    $$larrayref-> {p}++;
    return $link;
    } # newwsolink
#
# freewso has a bad block structure layout
sub freewso {# This moves a wso to the free list of $Awfif::wsol
    my ($wso) = @_;#

    my ($awso, $previous, $next, $fprevious, $fnext, $fpws, $fnws, $cwsbi, $zombie, $kws, $rgsponsor);
    if (($Awfif::wsol-> {f} < 0)
    or ($Awfif::wsol-> {t} <0)
    or ($Awfif::wsol-> {f} >= $Awfif::wsol-> {p})
    or ($Awfif::wsol-> {t} >= $Awfif::wsol-> {p})
    or (($Awfif::wsol-> {f} != 0)
    && ($Awfif::wsol-> {l}[$Awfif::wsol-> {f}][ $Awfif::memes-> {wsowsi}] != 0) ) #*** submacrok ***#
    or (($Awfif::wsol-> {t} != 0)
    && ($Awfif::wsol-> {l}[$Awfif::wsol-> {t}][ $Awfif::memes-> {wsowsi}] != 0) ) #*** submacrok ***#
    ) {&break()};
    $next = 0;
    $zombie = '';
    $cwsbi = $Awfif::memes-> {currentwsbi};
    $awso = awsoadr ($wso);
    if ($Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsowsi}] != $cwsbi) { #*** submacrok ***#
      &break ();
      };
    $kws = getwsost4 ($wso);
# free the wso descriptors

    while ($Awfif::wsol-> {l} [$awso] [2] != 0) {
      $Awfif::wsol-> {l} [$awso] [2] = freedesc ($Awfif::wsol-> {l} [$awso] [2]);
      };#while

    while ($Awfif::wsol-> {l} [$awso] [8] != 0) {
      $Awfif::wsol-> {l} [$awso] [8] = freedesc ($Awfif::wsol-> {l} [$awso] [8]);
      };#while
# set wsol [2], [8], [10], [13] descriptor data to 0

    $Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsologucount}] = 0; #*** submacrok ***#
    $rgsponsor = $Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsogcsponsor}]; #*** submacrok ***#
    if ($rgsponsor != 0) {

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

      if (($Awfif::memes-> {freewsongcspbreak}) && ($ngcsponsor != 0) && ($Awfif::memes-> {currentwsbi} == 3)) {&break ()};
        $Awfif::wsol-> {l}[awsoadr ($rgsponsor)][ $Awfif::memes-> {wsogcsponsor}] = 0; #*** submacrok ***#
        };#if
# remember the wso details

      $Awfif::wsol->{flistl}++;
      $previous = $Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsoprev}]; #*** submacrok ***##follow from the head back through previous
      $next = $Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsonext}]; #*** submacrok ***#
      $fprevious = $Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsobkwl}]; #*** submacrok ***#
      $fnext = $Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsofkwl}]; #*** submacrok ***#
      $fpws = $Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsobws}]; #*** submacrok ***#
      $fnws = $Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsofws}]; #*** submacrok ***#
# freewsocc
# clear out the cached details
      $Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsobastype}] = undef(); #*** submacrok ***#
      $Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsobasind}] = undef(); #*** submacrok ***#
      $Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsopkpos}] = undef(); #*** submacrok ***#
# freewsobf

      $Awfif::wsol-> {fbs} [$awso] = undef ();
# if this wso is the master of a keyword this info must be moved to the next in chain
      if ($Awfif::wsol-> {l} [$awso][4] ne '') {

        if ($Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsofkwl}] != 0) { #*** submacrok ***#
          $Awfif::wsol-> {l} [$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsofkwl}]][4] = $Awfif::wsol-> {l} [$awso][4]; #*** submacrok ***#
          }
        else {
          $zombie = 't';
          };
        };#if
# or if there is none this wso must remain as a zombie linked into the keyword list
# not sure how to do that correctly or if it can occur
# purge the contents of the wso

      $Awfif::wsol-> {l} [$awso] = ();
      $Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsobkwl}] = 0; #*** submacrok ***#
      $Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsofkwl}] = 0; #*** submacrok ***#
      $Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsobasind}] = 0; #*** submacrok ***#
      $rgsponsor = $Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsogcsponsor}]; #*** submacrok ***#
      if ($rgsponsor != 0) {

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

        if (($Awfif::memes-> {freewsongcspbreak}) && ($ngcsponsor != 0) && ($Awfif::memes-> {currentwsbi} == 3)) {&break ()};
        $Awfif::wsol-> {l}[awsoadr ($rgsponsor)][ $Awfif::memes-> {wsogcsponsor}] = 0; #*** submacrok ***#
        $Awfif::wsol-> {l}[awsoadr ($rgsponsor)][ $Awfif::memes-> {wsogcsponsored}] = 0; #*** submacrok ***#
        };#if
      $Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsogcsponsor}] = 0; #*** submacrok ***#
      $Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsogcsponsored}] = 0; #*** submacrok ***#
      $Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsoprev}] = 0; #*** submacrok ***#
      $Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsowsi}] = 0; #*** submacrok ***#
      $Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsonext}] = 0; #*** submacrok ***#
      $Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsobws}] = 0; #*** submacrok ***#
      $Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsofws}] = 0; #*** submacrok ***#
      $Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsoitstr}] = 0; #*** submacrok ***#
      $Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsotdg}] = 0; #*** submacrok ***#
      $Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsofgrp}] = 0; #*** submacrok ***#
      $Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsotdb}] = 0; #*** submacrok ***#
      $Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsobug}] = 0; #*** submacrok ***#
      $Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsoisterm}] = 0; #*** submacrok ***#
      $Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsobti}] = 0; #*** submacrok ***#
      $Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsobus}] = 0; #*** submacrok ***#
      $Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsogcjhlsi}] = 0; #*** submacrok ***#
      $Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsohistbp}] = 0; #*** submacrok ***#
      $Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsogcspjhlsi}] = 0; #*** submacrok ***#
      $Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsocstarts}] = 0; #*** submacrok ***#
      $Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsocbegins}] = 0; #*** submacrok ***#
      $Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsopkwsi}] = 0; #*** submacrok ***#
      $Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsosyncl}] = 0; #*** submacrok ***#
      $Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsosponsorgs}] = 0; #*** submacrok ***#
      $Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsosponsort}] = 0; #*** submacrok ***#
      $Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsosubpid}] = 0; #*** submacrok ***#
      $Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsogstart}] = 0; #*** submacrok ***#
      $Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsogend}] = 0; #*** submacrok ***#
# link the wso into the free list
      if ($Awfif::wsol-> {f} == $Awfif::wsol-> {t}) {
# empty free list

        if ($Awfif::wsol-> {f} == 0) {

          $Awfif::wsol-> {f} = $awso;
          $Awfif::wsol-> {t} = $awso;
          $Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsoprev}] = 0; #*** submacrok ***#
          $Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsonext}] = 0; #*** submacrok ***#
          }# 0
        else {#just one element in the free list - adding new element to be head

          $Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsoprev}] = $Awfif::wsol-> {f}; #*** submacrok ***#
          $Awfif::wsol-> {f} = $awso;
          $Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsonext}] = 0; #*** submacrok ***#
          $Awfif::wsol-> {l}[$Awfif::wsol-> {t}][ $Awfif::memes-> {wsonext}] = $awso; #*** submacrok ***#
          };#else
        }#if
      else {#add at the free head

        $Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsoprev}] = $Awfif::wsol-> {f}; #*** submacrok ***#
        $Awfif::wsol-> {l}[$Awfif::wsol-> {f}][ $Awfif::memes-> {wsonext}] = $awso; #*** submacrok ***#
        $Awfif::wsol-> {f} = $awso;
        $Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsonext}] = 0; #*** submacrok ***#
        };#else
# link the workspace together - this assumption will not work for deleting the final wso

      $Awfif::wsol-> {l}[awsoadr ($previous)][ $Awfif::memes-> {wsonext}] = $next; #*** submacrok ***#
# freewswinu
# if the wso is in the workspace window then move the window to the previous
      if ($Awfif::wsbl-> {winkwp} [$cwsbi] == $wso) {

        $Awfif::wsbl-> {winkwp} [$cwsbi] = $previous;
        };#if
      if ($Awfif::wsbl-> {winkwpr} [$cwsbi] == $wso) {

        $Awfif::wsbl-> {winkwpr} [$cwsbi] = $previous;
        };#if
      $Awfif::wsol-> {l}[awsoadr ($next)][ $Awfif::memes-> {wsoprev}] = $previous; #*** submacrok ***#
# link the function list together
      $Awfif::memes-> {currentwsbi} = $fpws;
      $Awfif::wsol-> {l}[awsoadr ($fprevious)][ $Awfif::memes-> {wsofkwl}] = $fnext; #*** submacrok ***#
      $Awfif::wsol-> {l}[awsoadr ($fprevious)][ $Awfif::memes-> {wsofws}] = $fnws; #*** submacrok ***#
      $Awfif::memes-> {currentwsbi} = $fnws;
      $Awfif::wsol-> {l}[awsoadr (awsoadr ($fnext))][ $Awfif::memes-> {wsobkwl}] = $fprevious; #*** submacrok ***#
      $Awfif::wsol-> {l}[awsoadr ($fnext)][ $Awfif::memes-> {wsobws}] = $fpws; #*** submacrok ***#
#
# correct the hash pointers if the deleted wso was addressed by the hash
      if (($Awfif::memes-> {keywordwsih}-> {$kws} == $cwsbi)
      && ($Awfif::memes-> {keywordh}-> {$kws} == $wso)
      ){

        $Awfif::memes-> {keywordh}-> {$kws} = $fprevious;
        $Awfif::memes-> {keywordwsih}-> {$kws} = $fpws;
        };
      if (($Awfif::wsol-> {f} < 0)
      or ($Awfif::wsol-> {t} <0)
      or ($Awfif::wsol-> {f} >= $Awfif::wsol-> {p})
      or ($Awfif::wsol-> {t} >= $Awfif::wsol-> {p})
      or (($Awfif::wsol-> {f} != 0)
      && ($Awfif::wsol-> {l}[$Awfif::wsol-> {f}][ $Awfif::memes-> {wsowsi}] != 0) ) #*** submacrok ***#
      or (($Awfif::wsol-> {t} != 0)
      && ($Awfif::wsol-> {l}[$Awfif::wsol-> {t}][ $Awfif::memes-> {wsowsi}] != 0) ) #*** submacrok ***#
      ) {&break()};

      $Awfif::memes-> {currentwsbi} = $cwsbi;
    return $next;
    } # freewso
#
sub toofewwso {# This checks the wso list has at least count members from s to e or 0
    my ($wsoe, $wsos, $mint) = @_;
    my ($result, $rlink, $count);

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("toofewwso wsoe $wsoe wsos $wsos mint $mint ");
      };

    $result = 't';
    $rlink = $wsos;
    $count = $mint;
    while (($rlink != $wsoe) && (awsoadr($rlink) != 0) && (($count--) != 0) && (($rlink = trwsoadr ($rlink, 1)) != 0)) {
      if ((wsbasetype ($rlink) == $Awfif::memes-> {snnh}{ichar})
      or (wsbasetype ($rlink) == $Awfif::memes-> {snnh}{whitespace})) {# not valid inc count
        $count++;
        };#if
      if ($count <= 0) {
        $result = '';
        };#if
      };

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("toofewwsox ret ($result)\n");
      };
    return $result;
    } # toofewwso
#
sub greaterwso {# This returns true if wso2 follows in list after wso1
    my ($wso2, $wso1) = @_;
    my ($result, $rlink);

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

    $result = '';
    $rlink = $wso1;
    if (trwsoadr ($rlink, -1) != $wso2) {#if wso2 is pred of wso1 then just return false
      while (($rlink != $wso2) && (awsoadr($rlink) != 0) && (($rlink = trwsoadr ($rlink, 1)) != 0)) {
        if ($rlink == $wso2) {
          $result = 't';
          };# if
        };#while
      };#if

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("greatergwsox ret ($result)\n");
      };
    return $result;
    } # greaterwso
#
sub greatergwso {# This returns true if wso2 follows in list after wso1
    my ($wso2, $wso1) = @_;
    my ($result, $rlink);

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

    $result = '';
    $rlink = $wso1;
    if ($wso1 == $Awfif::wsbl->{wsft}[$Awfif::memes-> {currentwsbi}]) {
      $result = 't';#for a group assume that wso2 must be above the fast tail
      }#if
    elsif ($wso2 == $Awfif::wsbl->{wsoh}[$Awfif::memes-> {currentwsbi}]) {
      $result = 't';
      }#elsif
    elsif ($wso2 == $Awfif::wsbl->{wsft}[$Awfif::memes-> {currentwsbi}]) {
      $result = '';#for a group assume that wso2 must be above the fast tail
      }#if
    elsif ($wso1 == $Awfif::wsbl->{wsoh}[$Awfif::memes-> {currentwsbi}]) {
      $result = '';
      }#elsif
    elsif (trwsoadr ($rlink, -1) != $wso2) {#if wso2 is pred of wso1 then just return false
      while (($rlink != $wso2) && (awsoadr($rlink) != 0) && (wsbasetype ($rlink) != $Awfif::memes->{snnh}{ichar}) && (($rlink = trwsoadr ($rlink, 1)) != 0)) {
        if ($rlink == $wso2) {
          $result = 't';
          };# if
        };#while
      };#if

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("greatergwsox ret ($result)\n");
      };
    return $result;
    } # greatergwso
#
sub setfwst {# This sets the fast workspace tail
    my ($wsoe, $wsos, $ws) = @_;
    my ($result, $rlink, $found, $cwsbi);

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

    $result = $wsos;
    $found = '';
    $rlink = $wsos;
    $cwsbi = $Awfif::memes-> {currentwsbi};
    $Awfif::memes-> {currentwsbi} = $ws;
    while ((!($found)) && ($rlink != $wsoe) && (awsoadr($rlink) != 0) ) {
      if ((wsbasetype ($rlink) == $Awfif::memes-> {snnh}{ichar})
      or (wsbasetype ($rlink) == $Awfif::memes-> {snnh}{whitespace})) {# not valid inc count
        $found = '';
        }#if
      else {
        $found = 't';
        $result = $rlink;
        };#else
      if (($rlink = trwsoadr ($rlink, 1)) == 0) {
        $found = 't';
        };#if
      };#while
    $Awfif::memes-> {currentwsbi} = $cwsbi;

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("setfwstx ret ($result)\n");
      };
    return $result;
    } # setfwst
#
sub stripichar {# This consolidates all the white space and ichar blocks of more than two items - leaving two actively in place
    my ($wsoe, $ws) = @_;
    my ($result, $rlink, $orlink, $count, $cwsbi, $succeeded);

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

    $succeeded = 't';
    $count = 0;
    $cwsbi = $Awfif::memes-> {currentwsbi};
    $Awfif::memes-> {currentwsbi} = $ws;
    $rlink = trwsoadr ($Awfif::wsbl-> {wsft}[$ws], 1);
    while ( ($rlink != $wsoe) && (awsoadr($rlink) != 0) && ($succeeded) ){

      if (((wsbasetype ($rlink) == $Awfif::memes-> {snnh}{ichar}) )
      or ((wsbasetype ($rlink) == $Awfif::memes-> {snnh}{whitespace}) ) ) {# not valid inc count

        if ($count <= 3 ) {

          $count++;
          $rlink = trwsoadr ($rlink, 1);
          };#if

        if ($count > 3) {

          $orlink = $rlink;
          $rlink = trwsoadr ($rlink, 1);
          $succeeded = relinkwsobwsft ($orlink);
          };#if
        }#if have some enough to relink
      else {

        $count = 0;
        $rlink = trwsoadr ($rlink, 1);
        };#else
      };

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

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("stripicharx ret ($result)\n");
      };
    return $result;
    } # stripichar
#
sub relinkwsobwsft {# This relinks a wso so that it is logically in the set prior to the fast tail wsft
    my ($wso) = @_;
    my ($awso, $previous, $next, $cwsbi, $result);

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

    $result = '';
    $cwsbi = $Awfif::memes-> {currentwsbi};
    $awso = awsoadr ($wso);
# remember the wso details

    $previous = $Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsoprev}];#*** submacrok ***##follow from the head back through previous
    $next = $Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsonext}];#*** submacrok ***#
# link the wso into the pre wsft list
    if ( ($Awfif::wsbl-> {wsft}[$cwsbi] ne '')
    && ($Awfif::wsbl-> {wsft}[$cwsbi] != $Awfif::wsbl-> {wsot}[$cwsbi])
    ) {
# relink the wso

      $result = 't';
      if ($Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsohistbp}] != 0) {#*** submacrok ***#
        $Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsohistbp}] = 0;#*** submacrok ***#
        };
      &setwsmd ($awso, $Awfif::memes-> {wsoprev},
        $Awfif::wsol-> {l}[awsoadr ($Awfif::wsbl-> {wsft}[$cwsbi])][ $Awfif::memes-> {wsoprev}]#*** submacrok ***#
          );
      $Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsonext}] = $Awfif::wsbl-> {wsft}[$cwsbi];#*** submacrok ***#
# link the two associates together
      $Awfif::wsol-> {l}[awsoadr ($next)][ $Awfif::memes-> {wsoprev}] = $previous;#*** submacrok ***#
      $Awfif::wsol-> {l}[awsoadr ($previous)][ $Awfif::memes-> {wsonext}] = $next;#*** submacrok ***#
# link the two new associates to the wso
      &setwsmd ( awsoadr (
        $Awfif::wsol-> {l}[awsoadr($Awfif::wsbl-> {wsft}[$cwsbi])][$Awfif::memes-> {wsoprev} ]#*** submacrok ***#
        ), $Awfif::memes-> {wsonext}, $wso);
      $Awfif::wsol-> {l}[ awsoadr ($Awfif::wsbl-> {wsft}[$cwsbi])][ $Awfif::memes-> {wsoprev}] = $wso;#*** submacrok ***#
      };#if

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("relinkwsobwsftx ret ($result)\n");
      };
    return $result
    } # relinkwsobwsft
#
sub checkwsbf {# This supports the addressing of a two bit flag in the wso bit vector
    my ($awso, $index) = @_;
    my ($result);

# if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
# print ("checkwsbf awso $awso index $index ");
# };

    if ($Awfif::memes-> {usewsobfdirect}) {
      $result = $Awfif::wsolfbs [$awso] [$index - $Awfif::memes-> {flagsoffset}];
      }#if
    else {

      $result = vec ($Awfif::wsolfbs [$awso * $Awfif::memes-> {maxfbs}], ($index - $Awfif::memes-> {flagsoffset}), 2);
      };#else

# if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
# print ("checkwsbfx ret ($result)\n");
# };
    return $result
    } # checkwsbf
#
sub setwsbf {# This supports the addressing and setting of a two bit flag in the wso bit vector
    my ($awso, $index, $value) = @_;

# if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
# print ("setwsbf awso $awso index $index value $value ");
# };

    if ($Awfif::memes-> {usewsobfdirect}) {
      $Awfif::wsolfbs [$awso] [$index - $Awfif::memes-> {flagsoffset}] = $value;
      }#if
    else {
      vec ($Awfif::wsolfbs [$awso * $Awfif::memes-> {maxfbs}], ($index - $Awfif::memes-> {flagsoffset}), 2) = $value;
      };#else

# if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
# print ("setwsbfx \n");
# };
    } # setwsbf
#<!-- start tag uts -->
#
sub checkwsmd { #*** ndefmacro ***#
    my ($awso, $index) = @_; #*** pdefmacro ***#
    my ($result);
# This supports the addressing of mapped data in the wso vector storage

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("checkwsmd awso $awso index $index ");
      };
    if ($Awfif::memes-> {usewsodirect}) {

      $result = $Awfif::wsol-> {l}[$awso][$index]; #*** repdefmacro ***#
      }#if
    elsif (($index == $Awfif::memes-> {wsobkwl})
    or ($index == $Awfif::memes-> {wsofkwl})
    or ($index == $Awfif::memes-> {wsobasind})
    or ($index == $Awfif::memes-> {wsogcsponsor})
    or ($index == $Awfif::memes-> {wsogcsponsored})
    or ($index == $Awfif::memes-> {wsotdb})
    or ($index == $Awfif::memes-> {wsobug})
    or ($index == $Awfif::memes-> {wsoisterm})
    or ($index == $Awfif::memes-> {wsobti})
    or ($index == $Awfif::memes-> {wsobus})
    or ($index == $Awfif::memes-> {wsoitstr})
    or ($index == $Awfif::memes-> {wsotdg})
    or ($index == $Awfif::memes-> {wsogstart})
    or ($index == $Awfif::memes-> {wsogend})
    ){

      $result = unpack ("l", pack ("L", vec ($Awfif::wsoli32s, (($awso * $Awfif::memes-> {maxm32}) + $Awfif::m32[$index]), 32)));
      }#elsif

    elsif (($index == $Awfif::memes-> {wsowsi})
    or ($index == $Awfif::memes-> {wsobws})
    or ($index == $Awfif::memes-> {wsofws})
    or ($index == $Awfif::memes-> {wsobastype})
    or ($index == $Awfif::memes-> {wsogcspjhlsi})
    or ($index == $Awfif::memes-> {wsogcjhlsi})
    or ($index == $Awfif::memes-> {wsopkwsi})
    or ($index == $Awfif::memes-> {wsocbegins})
    or ($index == $Awfif::memes-> {wsocstarts})
    or ($index == $Awfif::memes-> {wsopkpos})
    or ($index == $Awfif::memes-> {wsologucount})
    or ($index == $Awfif::memes-> {wsosubpid})
    or ($index == $Awfif::memes-> {wsosponsorgs})
    or ($index == $Awfif::memes-> {wsosponsort})
    ){

      $result = vec ($Awfif::wsoli16s, (($awso * $Awfif::memes-> {maxm16}) + $Awfif::m16[$index]), 16);
      }#elsif
    elsif (($index == $Awfif::memes-> {wsofgrp})
    or ($index == $Awfif::memes-> {wsologaei})
    ){

      $result = vec ($Awfif::wsolu32s, (($awso * $Awfif::memes-> {maxmu32}) + $Awfif::mu32[$index]), 32);

      }#elsif
    elsif (($index == $Awfif::memes-> {wsohistbp})
    ){

      $result = $Awfif::wsol-> {l} [$awso][9];
      };#elsif

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("checkwsmdx ret ($result)\n");
      };
    return $result #*** rdefmacro ***#
    } # checkwsmd
#<!-- end tag uts -->
#
sub setwsmd {# This supports the addressing and setting of a mapped data in the wso vector storage #*** ndefmacro ***#
    my ($awso, $index, $value) = @_; #*** pdefmacro ***#

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("setwsmd awso $awso index $index value $value ");
      };
    if ($Awfif::memes-> {usewsodirect}) {

      $Awfif::wsol-> {l}[$awso][$index] = $value; #*** repdefmacro ***#
      }#if
    elsif (($index == $Awfif::memes-> {wsobkwl})
    or ($index == $Awfif::memes-> {wsofkwl})
    or ($index == $Awfif::memes-> {wsobasind})
    or ($index == $Awfif::memes-> {wsogcsponsor})
    or ($index == $Awfif::memes-> {wsogcsponsored})
    or ($index == $Awfif::memes-> {wsoprev})
    or ($index == $Awfif::memes-> {wsonext})
    or ($index == $Awfif::memes-> {wsotdb})
    or ($index == $Awfif::memes-> {wsobug})
    or ($index == $Awfif::memes-> {wsoisterm})
    or ($index == $Awfif::memes-> {wsobti})
    or ($index == $Awfif::memes-> {wsobus})
    or ($index == $Awfif::memes-> {wsoitstr})
    or ($index == $Awfif::memes-> {wsotdg})
    or ($index == $Awfif::memes-> {wsogstart})
    or ($index == $Awfif::memes-> {wsogend})
    ){

      vec ($Awfif::wsoli32s , (($awso * $Awfif::memes-> {maxm32}) + $Awfif::m32[$index]), 32) = $value;
      }#if

    elsif (($index == $Awfif::memes-> {wsowsi})
    or ($index == $Awfif::memes-> {wsobws})
    or ($index == $Awfif::memes-> {wsofws})
    or ($index == $Awfif::memes-> {wsobastype})
    or ($index == $Awfif::memes-> {wsogcspjhlsi})
    or ($index == $Awfif::memes-> {wsogcjhlsi})
    or ($index == $Awfif::memes-> {wsopkwsi})
    or ($index == $Awfif::memes-> {wsocbegins})
    or ($index == $Awfif::memes-> {wsocstarts})
    or ($index == $Awfif::memes-> {wsopkpos})
    or ($index == $Awfif::memes-> {wsologucount})
    or ($index == $Awfif::memes-> {wsosubpid})
    or ($index == $Awfif::memes-> {wsosponsorgs})
    or ($index == $Awfif::memes-> {wsosponsort})
    ){

      vec ($Awfif::wsoli16s , (($awso * $Awfif::memes-> {maxm16}) + $Awfif::m16[$index]), 16) = $value;
      }#elsif
    elsif (($index == $Awfif::memes-> {wsofgrp})
    or ($index == $Awfif::memes-> {wsologaei})
    ){

      vec ($Awfif::wsolu32s, (($awso * $Awfif::memes-> {maxmu32}) + $Awfif::mu32[$index]), 32) = $value;
      }#elsif
    elsif (($index == $Awfif::memes-> {wsohistbp})
    ){

      $Awfif::wsol-> {l} [$awso][9] = $value;
      };#elsif

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("setwsmdx \n");
      };
    } # setwsmd
#
#
sub inewstws {
    my ($myli, $buffers, $grkwp, $grkwpr, $sponsor, $makesubprogram) = @_;
#
# create a new structural workspace
    return isetupws ($myli, $buffers, $grkwp, $grkwpr, $sponsor, $makesubprogram);
    }#inewstws
#<!-- start tag scl -->
#
sub inewaws {
    my ($myli, $buffers, $grkwp, $grkwpr, $sponsor, $makesubprogram) = @_;
#
# create a new active workspace
#
    return isetupws ($myli, $buffers, $grkwp, $grkwpr, $sponsor, $makesubprogram, undef (), 't');
    }#iaddsg
#
sub iaddsg {
    my ($myli, $buffers, $grkwp, $grkwpr, $sponsor, $usews) = @_;
#
# add a group to a structural workspace
#
    return isetupws ($myli, $buffers, $grkwp, $grkwpr, $sponsor, undef (), $usews);
    }#iaddsg
#
sub isetupws {
    my ($myli, $buffers, $grkwp, $grkwpr, $sponsor, $makesubprogram, $usews, $makeactive) = @_;
#
# create a new structural workspace
    my ($tws, $buffer, $active, $depstag, $depttag, $dephtag, $insymbol, @inmsymbol, @started, $end, $cwsbi, $setwsclinv, $binding);
#
# checked for merged workspaces

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("isetupws buffers($$buffers) grkwp $$grkwp grkwpr $grkwpr sponsor $sponsor ");
      if (defined ($makesubprogram)) {
        print ("makesubprogram $makesubprogram ");
        };#if
      if (defined ($usews)) {
        print ("usews $usews ");
        };#if
      if (defined ($makeactive)) {
        print ("makeactive $makeactive ");
        };#if
      };
    $cwsbi = $Awfif::memes-> {currentwsbi};

    if (defined ($makesubprogram)) {

      $binding = $makesubprogram;
      }#if
    else {

      $binding = $Awfif::memes-> {snnh} {stbinding};
      };#else
    if (!defined ($usews)) {

      $tws = setupws ();
      }#if
    else {

      $tws = $usews;
      };#else
    if ((defined ($makeactive)) && ($makeactive)) {

      $active = $makeactive;
      $buffer = $$buffers;
      }#if
    else {

      $active = '';
      $buffer = '(<rhlmspg>';
      $buffer = $buffer . $$buffers;
      $buffer = $buffer . '</rhlmspg>)';
      };#else
    $Awfif::wsbl-> {wsactive}[$tws] = $active;#default the workspace to being processed by the coderack structural workspaces may be inactive

    $depstag = '';
    $depttag = 0;
    $dephtag = 0;
    $insymbol = '';
    @inmsymbol = ();
    $started[0] = 0;
    $started[1] = 't';
    $setwsclinv = '';

    &convbws ($myli, \$buffer, \$$grkwp, $grkwpr, $Awfif::memes-> {kwmi}, $Awfif::memes-> {kwmir}, $sponsor, \$insymbol, \@inmsymbol, \@started, \$end, \$depstag, \$depttag, \$dephtag, $tws, $binding,
      $Awfif::memes-> {strbool}[$Awfif::memes-> {streh} {budesc}],
      '', #dont energize the base types
      \$setwsclinv
      );
    $Awfif::wsbl-> {wsft} [$tws] = setfwst ($Awfif::wsbl-> {wsbloh} [$tws], $Awfif::wsbl-> {wsot}[$tws], $tws);

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

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("isetupwsx ret $tws\n");
      };
    return $tws;
    }#isetupws
#
#<!-- end tag scl -->
#<!-- start tag vbt -->
#<!-- start tag aso -->
#<!-- start tag sca -->
#
sub igoalscon1 {# setup the goal suppressor for general cascade participant
    my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static, $strategy)=@_;
    my ($labcount);

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("igoalscon1 myli $myli sti($sti) kwp($$kwp) kwpr($kwpr) sactset($$sactset[0]) ");
      };
# updated for merged workspaces

    $labcount = 0;

    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {$strategy});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {selector});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {schema});

    if (defined ($$static)) {
      $$static = '';#can't depend on this being the same every return - don't cache
      };#if

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("igoalsconx ret ($labcount)\n");
      };#if
    return $labcount
    }# igoalscon1
#
#<!-- end tag sca -->
#<!-- end tag vbt -->
#<!-- end tag aso -->
#
sub goalscon1 {# setup the goal suppressor for general cascade participant
    my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

    return (igoalscon1 ($myli, $sti, \@$lab, $kwp, $kwpr, \@$sactset, \$$static, getwsost4 ($Awfif::codelet-> {l} [$myli][21])));
    }# goalscon1
#
sub devscon1 {# setup the goal suppressor for dev codelet
    my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

    return (igoalscon1 ($myli, $sti, \@$lab, $kwp, $kwpr, \@$sactset, \$$static, 'development'));
    }# devscon1
#
#<!-- start tag vbt -->
#
sub vbtdevscon1 {# setup the goal suppressor for vbtdev codelet
    my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
    return (igoalscon1 ($myli, $sti, \@$lab, $kwp, $kwpr, \@$sactset, \$$static, 'development'));
    }# vbtdevscon1
#
sub vbtiopscon1 {# setup the goal suppressor for vbtiop codelet
    my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
    return (igoalscon1 ($myli, $sti, \@$lab, $kwp, $kwpr, \@$sactset, \$$static, 'vbt'));
    }# vbtiopscon1
#<!-- end tag vbt -->
#<!-- start tag aso -->
#
sub msiopscon1 {# setup the goal suppressor for msiop codelet
    my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
    return (igoalscon1 ($myli, $sti, \@$lab, $kwp, $kwpr, \@$sactset, \$$static, 'mergestreams'));
    }# msiopscon1
#<!-- start tag sca -->
#
sub hdoscon1 {# setup the goal suppressor for msiop codelet
    my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
    return (igoalscon1 ($myli, $sti, \@$lab, $kwp, $kwpr, \@$sactset, \$$static, 'hdo'));
    }# hdoscon1
#<!-- end tag sca -->
#<!-- end tag aso -->
#
##################### end strategy routines ################ ################## #########
#
##################### label strategy routines ################ ################## #########
#<!-- start tag ssc -->
#
sub statementlabel1 {# setup the labels for statement
    my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
    my ($labcount);

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("statementlabel myli $myli sti $sti kwp $kwp kwpr $kwpr sactset $$sactset[0] ");
      };
# updated for merged workspaces

    $labcount = 0;

    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {model});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {schema});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {statementcategory});
    $labcount = labload (\@$lab, $labcount, wsbasetype ($sti));
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {statementcomplete});

    if (defined ($$static)) {
      $$static = '';#can't depend on this being the same every return - don't cache
      };#if

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("statementlabelx ret ($labcount)\n");
      };
    return $labcount
    }# statementlabel
#
#<!-- start tag swp -->
#
sub partlabel1 {# setup the labels for part
    my($myli, $parti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
    my ($labcount);

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("partlabel myli $myli parti $parti kwp $kwp kwpr $kwpr sactset $$sactset[0] ");
      };
# updated for merged workspaces

    $labcount = 0;

    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {model});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {schema});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {partscategory});
    $labcount = labload (\@$lab, $labcount, wsbasetype ($parti));
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {groupcomplete});

    if (defined ($$static)) {
      $$static = '';#can't depend on this being the same every return - don't cache
      };#if

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("partlabelx ret ($labcount)\n");
      };
    return $labcount
    }# partlabel
#
#<!-- end tag ssc -->
#<!-- end tag swp -->
#<!-- start tag scs -->
#<!-- start tag sca -->
#
sub statementpdcal1 {# setup the labels for statement
    my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
    my ($labcount, $concept, $drefi, $cwsbi);

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("statementpdcal myli $myli sti $sti kwp $kwp kwpr $kwpr sactset $$sactset[0] ");
      };
# updated for merged workspaces

    $cwsbi = $Awfif::memes-> {currentwsbi};
    $Awfif::memes-> {currentwsbi} = $Awfif::codelet-> {l}[$myli] [20];
    $labcount = 0;
    &findcounter ($Awfif::wsol-> {l} [awsoadr ($sti)][2], ($Awfif::memes-> {snnh}{pdcaprogram}), \$drefi);
    if ($drefi != 0) {
      $concept = ($Awfif::workspace-> {l} [$drefi] [2] - $Awfif::memes-> {snnh}{wsi});
      };#if
    if (($drefi != 0) && ($concept != 0)) {


      $labcount = labload (\@$lab, $labcount, $concept);
      $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {program});
      $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {initiate});
      };#if

    if (defined ($$static)) {
      $$static = '';#can't depend on this being the same every return - don't cache
      };#if

    $Awfif::memes-> {currentwsbi} = $cwsbi;
    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("statementpdcalx ret ($labcount)\n");
      };
    return $labcount
    }# statementpdcal
#
#<!-- end tag sca -->
#<!-- start tag scl -->
#
sub screplicate1 {# setup the labels for statement
    my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
    my ($labcount, $concept, $drefi, $cwsbi);

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("screplicate myli $myli sti $sti kwp $kwp kwpr $kwpr sactset $$sactset[0] ");
      };
# updated for merged workspaces

    $cwsbi = $Awfif::memes-> {currentwsbi};
    $Awfif::memes-> {currentwsbi} = $Awfif::codelet-> {l}[$myli] [20];
    $labcount = 0;
    &findcounter ($Awfif::wsol-> {l} [awsoadr ($sti)][2], ($Awfif::memes-> {snnh}{pdcaprogram}), \$drefi);
    if ($drefi != 0) {
      $concept = ($Awfif::workspace-> {l} [$drefi] [2] - $Awfif::memes-> {snnh}{wsi});
      };#if
    if (($drefi != 0) && ($concept != 0)) {


      $labcount = labload (\@$lab, $labcount, $concept);
      $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {replication});
      $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {initiate});
      };#if

    if (defined ($$static)) {
      $$static = '';#can't depend on this being the same every return - don't cache
      };#if

    $Awfif::memes-> {currentwsbi} = $cwsbi;
    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("screplicatex ret ($labcount)\n");
      };
    return $labcount
    }# screplicate
#
#<!-- end tag scl -->
#<!-- start tag ssc -->
#
sub developmentlabel1 {# setup the labels for development
    my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
    my ($labcount);

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("developmentlabel myli $myli sti $sti kwp $kwp kwpr $kwpr sactset $$sactset[0] ");
      };
# updated for merged workspaces

    $labcount = 0;

    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {model});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {schema});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {devcategory});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {development});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {statementcomplete});

    if (defined ($$static)) {
      $$static = 't';#can depend on this being the same every return - can cache
      };#if

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("developmentlabelx ret ($labcount)\n");
      };
    return $labcount
    }# developmentlabel
#
#<!-- end tag ssc -->
#
sub developmentb1 {# setup the binding for development binder
    my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
    my ($labcount);

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("developmentb1 myli $myli sti $sti kwp $kwp kwpr $kwpr sactset $$sactset[0] ");
      };
# updated for merged workspaces

    $labcount = 0;

    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {development});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {sequence});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {integration});

    if (defined ($$static)) {
      $$static = 't';#can depend on this being the same every return - can cache
      };#if

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("developmentbx ret ($labcount)\n");
      };
    return $labcount
    }# developmentb
#
#<!-- start tag vbt -->
#<!-- start tag dli -->
#
sub developmenti1 {# setup the labels for development initiator signaling
    my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

    return (iinitiators1 ($myli, $sti, \@$lab, $kwp, $kwpr, \@$sactset, \$$static, 'development'));
    }# developmenti1
#
sub binderp11 {# setup the labels for binder base context
    my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
    my ($labcount);

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("binderp11 myli $myli sti $sti ");
      if (defined ($kwp)) {
        print ("kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
        };#if
      };
# updated for merged workspaces

    $labcount = 0;

    $labcount = labload (\@$lab, $labcount, wsbasetype ($Awfif::codelet-> {l} [$myli][21]));
    if ((defined ($Awfif::codelet-> {l} [$myli] [36])) && ($Awfif::codelet-> {l} [$myli] [36] > 0) ){

      $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {subprogram});
      };#if
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {sequence});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {integration});

    if (defined ($$static)) {
      $$static = '';#can't depend on this being the same every return - don't cache
      };#if

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("binderp11x ret ($labcount)\n");
      };
    return $labcount
    }# binderp11
#
sub binderc1 {# setup the labels for binder indirect context
    my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
    my ($labcount, $i, $cwsbi, $conforms, $ssloc, $shistone, $ri);

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("binderc1 myli $myli sti $sti ");
      if (defined ($kwp)) {
        print ("kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
        };#if
      };
# updated for merged workspaces

    $labcount = 0;

    $cwsbi = $Awfif::memes-> {currentwsbi};
    $Awfif::memes-> {currentwsbi} = $Awfif::codelet-> {l} [$myli] [20];
    for ($i = trwsoadr($Awfif::codelet-> {l} [$myli][21],2);
    ( (!($shistone = chmdefis ($myli, trwsoadr ($i,-1), $Awfif::memes-> {snnh}{histone}, \$conforms)))
    && ($i != trwsoadr ($Awfif::codelet-> {l} [$myli][22],-2) )
    && ($ri = $i)
    && (!($ssloc = chmdefis ($myli, trwsoadr ($i,2), $Awfif::memes-> {snnh}{sloc}, \$conforms))));
    $i = trwsoadr ($i,1)) {

      $labcount = labload (\@$lab, $labcount, wsbasetype ($i));
      };#for
    if ($shistone) {#already done it

      if ($Awfif::memes-> {binderchis}) {&break()};
      }#if
    elsif ($ssloc) {

      $labcount = labload (\@$lab, $labcount, wsbasetype ($ri));
      }#elsif
    else {

      $labcount = labload (\@$lab, $labcount, wsbasetype (trwsoadr ($Awfif::codelet-> {l} [$myli][22],-2)));
      };#else
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {sequence});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {integration});
    $Awfif::memes-> {currentwsbi} = $cwsbi;

    if (defined ($$static)) {
      $$static = '';#can't depend on this being the same every return - don't cache
      };#if

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("binderc1x ret ($labcount)\n");
      };
    return $labcount
    }# binderc1
#
#<!-- start tag aso -->
#
sub ibindervc1 {# setup the labels for app complex indirect context (with variable end)
    my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static, $tback, $ihforward)=@_;
    my ($labcount, $i, $initi, $hforward, $cwsbi);

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("bindercs1 myli $myli sti $sti ");
      if (defined ($ihforward)) {
        print ("ihforward($ihforward) ");
        };#if
      if (defined ($kwp)) {
        print ("kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
        };#if
      };
# updated for merged workspaces

    $labcount = 0;
    if (defined ($ihforward)) {

      $hforward = $ihforward;
      }#if
    else {

      $hforward = 2;
      };#else

    $cwsbi = $Awfif::memes-> {currentwsbi};
    $Awfif::memes-> {currentwsbi} = $Awfif::codelet-> {l} [$myli] [20];
    for ($i = ($initi = trwsoadr($Awfif::codelet-> {l} [$myli][21], $hforward));
    $i != trwsoadr ($Awfif::codelet-> {l} [$myli][22], - $tback, $initi);
    $i = trwsoadr ($i,1)) {

      $labcount = labload (\@$lab, $labcount, wsbasetype ($i));
      };#for
    $labcount = labload (\@$lab, $labcount, wsbasetype (trwsoadr ($Awfif::codelet-> {l} [$myli][22], - $tback)));
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {sequence});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {integration});
    $Awfif::memes-> {currentwsbi} = $cwsbi;

    if (defined ($$static)) {
      $$static = '';#can't depend on this being the same every return - don't cache
      };#if

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("bindervc1x ret ($labcount)\n");
      };
    return $labcount
    }# ibindervc1
#
#<!-- end tag aso -->
#<!-- end tag vbt -->
#
sub bindercs1 {# setup the labels for semantic binder complex indirect context
    my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

    return (ibindervc1 ($myli, $sti, \@$lab, $kwp, $kwpr, \@$sactset, \$$static, 3));
    }# bindercs1
#
#<!-- start tag vbt -->
#
sub binderc41 {# setup the labels for vbttom00nc binder complex indirect context
    my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

    return (ibindervc1 ($myli, $sti, \@$lab, $kwp, $kwpr, \@$sactset, \$$static, 4));
    }# binderc41
#
sub binderc71 {# setup the labels for vbttom00c10 binder complex indirect context
    my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

    return (ibindervc1 ($myli, $sti, \@$lab, $kwp, $kwpr, \@$sactset, \$$static, 7));
    }# binderc71
#
sub binderc91 {# setup the labels for vbttom00c10c01 binder complex indirect context
    my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

    return (ibindervc1 ($myli, $sti, \@$lab, $kwp, $kwpr, \@$sactset, \$$static, 9));
    }# binderc91
#
sub binderc101 {# setup the labels for vbttom00c10c00 binder complex indirect context
    my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

    return (ibindervc1 ($myli, $sti, \@$lab, $kwp, $kwpr, \@$sactset, \$$static, 10));
    }# binderc111
#
sub binderc111 {# setup the labels for vbttom00c10c01c00 binder complex indirect context
    my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

    return (ibindervc1 ($myli, $sti, \@$lab, $kwp, $kwpr, \@$sactset, \$$static, 11));
    }# binderc111
#
sub binderc131 {# setup the labels for vbttom01c00c11c02 binder complex indirect context
    my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

    return (ibindervc1 ($myli, $sti, \@$lab, $kwp, $kwpr, \@$sactset, \$$static, 13));
    }# binderc131
#
sub binderc161 {# setup the labels for vbttom01c00c01c11c02 binder complex indirect context
    my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

    return (ibindervc1 ($myli, $sti, \@$lab, $kwp, $kwpr, \@$sactset, \$$static, 16));
    }# binderc161
#
sub binderc191 {# setup the labels for vbttom11c21c11c12c01c10 binder complex indirect context
    my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

    return (ibindervc1 ($myli, $sti, \@$lab, $kwp, $kwpr, \@$sactset, \$$static, 19));
    }# binderc191
#<!-- end tag vbt -->
#
#
sub bindercs21 {# setup the labels for semantic binder complex indirect context
    my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

    return (ibindervc1 ($myli, $sti, \@$lab, $kwp, $kwpr, \@$sactset, \$$static, 4));
    }# bindercs21
#
#<!-- start tag aso -->
#<!-- start tag sir -->
#
sub bindercst1 {# setup the labels for binder indirect context
    my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
    my ($labcount, $i, $cwsbi, $conforms, $ssloc, $shistone, $ri);

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("bindercst1 myli $myli sti $sti ");
      if (defined ($kwp)) {
        print ("kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
        };#if
      };
# updated for merged workspaces

    $labcount = 0;

    $cwsbi = $Awfif::memes-> {currentwsbi};
    $Awfif::memes-> {currentwsbi} = $Awfif::codelet-> {l} [$myli] [20];
    for ($i = trwsoadr($Awfif::codelet-> {l} [$myli][21],2);
    ( (!($shistone = chmdefis ($myli, trwsoadr ($i,-1), $Awfif::memes-> {snnh}{histone}, \$conforms)))
    && ($i != trwsoadr ($Awfif::codelet-> {l} [$myli][22],-2) )
    && ($ri = $i)
    && (!($ssloc = chmdefis ($myli, trwsoadr ($i,2), $Awfif::memes-> {snnh}{sloc}, \$conforms))));
    $i = trwsoadr ($i,1)) {

      $labcount = labload (\@$lab, $labcount, wsbasetype ($i));
      };#for
    if ($shistone) {#already done it

      if ($Awfif::memes-> {binderchis}) {&break()};
      }#if
    elsif ($ssloc) {

      $labcount = labload (\@$lab, $labcount, wsbasetype ($ri));
      }#elsif
    else {

      $labcount = labload (\@$lab, $labcount, wsbasetype (trwsoadr ($Awfif::codelet-> {l} [$myli][22],-2)));
      };#else
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {sequence});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {integration});
    $Awfif::memes-> {currentwsbi} = $cwsbi;

    if (defined ($$static)) {
      $$static = '';#can't depend on this being the same every return - don't cache
      };#if

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("bindercst1x ret ($labcount)\n");
      };
    return $labcount
    }# bindercst1
#
#<!-- end tag sir -->
#<!-- end tag aso -->
#<!-- start tag vbt -->
#
sub casoppi1 {# setup the labels for development integration
    my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
    my ($labcount, $i, $cwsbi);

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("casoppi1 myli $myli sti $sti ");
      if (defined ($kwp)) {
        print ("kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
        };#if
      };
# updated for merged workspaces
    $cwsbi = $Awfif::memes-> {currentwsbi};

    $labcount = 0;

    $Awfif::memes-> {currentwsbi} = $Awfif::codelet-> {l} [$myli] [20];
    $labcount = labload (\@$lab, $labcount, wsbasetype ($Awfif::codelet-> {l} [$myli][21]));
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {schema});
    for ($i = trwsoadr ($Awfif::codelet-> {l} [$myli][21], 4);
    $i != $Awfif::codelet-> {l} [$myli][22];
    $i = trwsoadr ($i,1)) {
      $labcount = labload (\@$lab, $labcount, wsbasetype ($i));
      };#for
    $labcount = labload (\@$lab, $labcount, wsbasetype ($Awfif::codelet-> {l} [$myli][22]));
    $Awfif::memes-> {currentwsbi} = $cwsbi;

    if (defined ($$static)) {
      $$static = '';#can't depend on this being the same every return - don't cache
      };#if

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("casoppi1x ret ($labcount)\n");
      };
    return $labcount
    }# casoppi1
#
#<!-- end tag vbt -->
#<!-- end tag dli -->
#
sub cassuboppi1 {# setup the labels for subprogram integration
    my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
    my ($labcount, $i, $cwsbi);

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("casoppi1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
      };
# updated for merged workspaces
    $cwsbi = $Awfif::memes-> {currentwsbi};

    $labcount = 0;

    $Awfif::memes-> {currentwsbi} = $Awfif::codelet-> {l} [$myli] [20];
    $labcount = labload (\@$lab, $labcount, wsbasetype ($Awfif::codelet-> {l} [$myli][21]));
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {schema});
    for ($i = trwsoadr ($Awfif::codelet-> {l} [$myli][21], 4);
    $i != $Awfif::codelet-> {l} [$myli][22];
    $i = trwsoadr ($i,1)) {
      $labcount = labload (\@$lab, $labcount, wsbasetype ($i));
      };#for
    $labcount = labload (\@$lab, $labcount, wsbasetype ($Awfif::codelet-> {l} [$myli][22]));
    $Awfif::memes-> {currentwsbi} = $cwsbi;

    if (defined ($$static)) {
      $$static = '';#can't depend on this being the same every return - don't cache
      };#if

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("casoppi1x ret ($labcount)\n");
      };
    return $labcount
    }# cassuboppi1
#
#<!-- start tag aso -->
#
sub casopai1 {# setup the labels for development integration
    my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
    my ($labcount, $i, $cwsbi);

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("casopai1 myli $myli sti $sti ");
      if (defined ($kwp)) {
        print ("kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
        };#if
      };
# updated for merged workspaces
    $cwsbi = $Awfif::memes-> {currentwsbi};

    $labcount = 0;

    $Awfif::memes-> {currentwsbi} = $Awfif::codelet-> {l} [$myli] [20];
    $labcount = labload (\@$lab, $labcount, wsbasetype ($Awfif::codelet-> {l} [$myli][21]));
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {schema});
    for ($i = trwsoadr ($Awfif::codelet-> {l} [$myli][21], 2);
    $i != $Awfif::codelet-> {l} [$myli][22];
    $i = trwsoadr ($i,1)) {
      $labcount = labload (\@$lab, $labcount, wsbasetype ($i));
      };#for
    $labcount = labload (\@$lab, $labcount, wsbasetype ($Awfif::codelet-> {l} [$myli][22]));
    $Awfif::memes-> {currentwsbi} = $cwsbi;

    if (defined ($$static)) {
      $$static = '';#can't depend on this being the same every return - don't cache
      };#if

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("casopai1x ret ($labcount)\n");
      };
    return $labcount
    }# casopai1
#
#<!-- end tag aso -->
#
sub goalsupp1 {# setup the binding for goal suppressor
    my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
    my ($labcount);

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("goalsupp1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
      };
# updated for merged workspaces

    $labcount = 0;

    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {schema});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {partconstrained});

    if (defined ($$static)) {
      $$static = 't';#can depend on this being the same every return - cache
      };#if

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("goalsuppx ret ($labcount)\n");
      };
    return $labcount
    }# goalsupp
#<!-- end tag cr -->
#<!-- start tag aso -->
#
sub mergestreamsb1 {# setup the binding for mergestreams binder
    my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
    my ($labcount);

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("mergestreamsb1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
      };
# updated for merged workspaces

    $labcount = 0;

    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {mergestreams});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {sequence});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {integration});

    if (defined ($$static)) {
      $$static = 't';#can depend on this being the same every return - can cache
      };#if

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("mergestreamsbx ret ($labcount)\n");
      };
    return $labcount
    }# mergestreamsb
#<!-- end tag aso -->
#<!-- start tag vbt -->
#
sub vbtb1 {# setup the binding for vbt binder
    my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
    my ($labcount);

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("vbtb1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
      };
# updated for merged workspaces

    $labcount = 0;

    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {vbot});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {sequence});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {integration});

    if (defined ($$static)) {
      $$static = 't';#can depend on this being the same every return - can cache
      };#if

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("vbtbx ret ($labcount)\n");
      };
    return $labcount
    }# vbtb
#<!-- start tag sca -->
#<!-- start tag dli -->
#<!-- start tag aso -->
#
sub iinitiators1 {# setup the labels for complex initiator signaling
    my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static, $strategy)=@_;
    my ($labcount, $i);

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("iinitiators1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
      };
# updated for merged workspaces

    $labcount = 0;

    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {$strategy});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {schema});
    for ($i = $Awfif::codelet-> {l} [$myli][21]; $i != $Awfif::codelet-> {l} [$myli][22];$i = trwsoadr ($i,1)) {
      $labcount = labload (\@$lab, $labcount, wsbasetype ($i));
      };#for
    $labcount = labload (\@$lab, $labcount, wsbasetype ($Awfif::codelet-> {l} [$myli][22]));
    $labcount = labload (\@$lab, $labcount, wsbasetype ($sti));

    if (defined ($$static)) {
      $$static = '';#can't depend on this being the same every return - don't cache
      };#if

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("iinitiators1x ret ($labcount)\n");
      };
    return $labcount
    }# iinitiators1
#
#<!-- end tag sca -->
#<!-- end tag dli -->
#<!-- end tag vbt -->
#
sub mergestreamsi1 {# setup the labels for mergestreams assert case resolution
    my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

    return (iinitiators1 ($myli, $sti, \@$lab, $kwp, $kwpr, \@$sactset, \$$static, 'mergestreams'));
    }# mergestreamsi1
#
#<!-- start tag vbt -->
#
sub vbti1 {# setup the labels for vbt initiator signaling
    my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

    return (iinitiators1 ($myli, $sti, \@$lab, $kwp, $kwpr, \@$sactset, \$$static, 'vbt'));
    }# vbti1
#
#<!-- end tag vbt -->
#
sub mstracasetestpi1 {# setup the labels for mergestreams case test resolution
    my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
    my ($labcount);

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("mstracasetestpi1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
      };
# updated for merged workspaces

    $labcount = 0;

    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {mergestreams});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {schema});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {case});
    $labcount = labload (\@$lab, $labcount, wsbasetype ($sti));

    if (defined ($$static)) {
      $$static = '';#can't depend on this being the same every return - don't cache
      };#if

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("mstracasetestpi1x ret ($labcount)\n");
      };
    return $labcount
    }# mstracasetestpi1
#
sub mstraresctestpi1 {# setup the labels for mergestreams case test resolution
    my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
    my ($labcount);

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("mstraresctestpi1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
      };
# updated for merged workspaces

    $labcount = 0;

    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {mergestreams});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {schema});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {deploy});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {case});
    $labcount = labload (\@$lab, $labcount, wsbasetype ($sti));

    if (defined ($$static)) {
      $$static = '';#can't depend on this being the same every return - don't cache
      };#if

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("mstraresctestpi1x ret ($labcount)\n");
      };
    return $labcount
    }# mstraresctestpi1
#
sub mstranoctestpi1 {# setup the labels for mergestreams case test resolution
    my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
    my ($labcount);

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("mstranoctestpi1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
      };
# updated for merged workspaces

    $labcount = 0;

    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {mergestreams});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {schema});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {statementcomplete});
    $labcount = labload (\@$lab, $labcount, wsbasetype ($sti));

    if (defined ($$static)) {
      $$static = '';#can't depend on this being the same every return - don't cache
      };#if

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("mstranoctestpi1x ret ($labcount)\n");
      };
    return $labcount
    }# mstranoctestpi1
#
sub mstrarescinitpi1 {# setup the labels for initialisation of mergestreams case test resolution
    my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
    my ($labcount);

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("mstrarescinitpi1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
      };
# updated for merged workspaces

    $labcount = 0;

    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {mergestreams});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {schema});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {initialise});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {deploy});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {case});
    $labcount = labload (\@$lab, $labcount, wsbasetype ($sti));

    if (defined ($$static)) {
      $$static = '';#can't depend on this being the same every return - don't cache
      };#if

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("mstrarescinitpi1x ret ($labcount)\n");
      };
    return $labcount
    }# mstrarescinitpi1
#<!-- start tag scs -->
#
sub pdcasappi1 {# setup the labels for initpdca signalling of application
    my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
    my ($labcount, $i);

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("pdcasappi1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
      };
# updated for merged workspaces

    $labcount = 0;

    $labcount = labload (\@$lab, $labcount, wsbasetype ($Awfif::codelet-> {l} [$myli][21]));
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {schema});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {deploy});
    for ($i = trwsoadr ($Awfif::codelet-> {l} [$myli][21], 2); $i != trwsoadr ($Awfif::codelet-> {l} [$myli][22],-2);$i = trwsoadr ($i,1)) {
      $labcount = labload (\@$lab, $labcount, wsbasetype ($i));
      };#for
    $labcount = labload (\@$lab, $labcount, wsbasetype (trwsoadr ($Awfif::codelet-> {l} [$myli][22],-2)));
    $labcount = labload (\@$lab, $labcount, wsbasetype ($Awfif::codelet-> {l} [$myli][22]));

    if (defined ($$static)) {
      $$static = '';#can't depend on this being the same every return - don't cache
      };#if

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      my ($pr);
      for ($i = 1; $i <= $labcount; $i++) {
        $pr = '<' . $Awfif::memes-> {snnih} {$$lab[$i]} . '>';
        print ("$pr");
        };#for
      print ("pdcasappi1x ret ($labcount)\n");
      };
    return $labcount
    }# pdcasappi1
#
sub pdcab1 {# setup the binding for Shewhart binder
    my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
    my ($labcount);

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("pdcab1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
      };
# updated for merged workspaces

    $labcount = 0;

    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {pdca});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {sequence});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {integration});

    if (defined ($$static)) {
      $$static = 't';#can depend on this being the same every return - can cache
      };#if

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("pdcabx ret ($labcount)\n");
      };
    return $labcount
    }# pdcab
#
sub e2finhibb1 {# setup the binding for e2finhib binder
    my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
    my ($labcount);

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("e2finhibb1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
      };
# updated for merged workspaces

    $labcount = 0;

    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {inhibitor});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {sequence});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {integration});

    if (defined ($$static)) {
      $$static = 't';#can depend on this being the same every return - can cache
      };#if

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("e2finhibbx ret ($labcount)\n");
      };
    return $labcount
    }# e2finhibb
#
#<!-- end tag scs -->
#
sub comparest1 {# setup the labels for comparison of source and target
    my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
    my ($labcount);

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("comparest1 myli $myli sti $sti ");
      if (defined ($kwp)) {
        print ("kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
        };#if
      };
# updated for merged workspaces

    $labcount = 0;

    $labcount = labload (\@$lab, $labcount, wsbasetype ($Awfif::codelet-> {l} [$myli][21]));
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {source});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {target});
    $labcount = labload (\@$lab, $labcount, wsbasetype (trwsoadr ($Awfif::codelet-> {l} [$myli][22], -1)));
    $labcount = labload (\@$lab, $labcount, wsbasetype ($Awfif::codelet-> {l} [$myli][22]));

    if (defined ($$static)) {
      $$static = '';#can't depend on this being the same every return - don't cache
      };#if

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("comparest1x ret ($labcount)\n");
      };
    return $labcount
    }# comparest1
# self1 does not appear to be used
sub self1 {# setup the labels for self analysis
    my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
    my ($labcount, $i);

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("self1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
      };
# updated for merged workspaces

    $labcount = 0;

    for ($i = $Awfif::codelet-> {l} [$myli][21]; $i != $Awfif::codelet-> {l} [$myli][22];$i = trwsoadr ($i,1)) {
      $labcount = labload (\@$lab, $labcount, wsbasetype ($i));
      };#for
    $labcount = labload (\@$lab, $labcount, wsbasetype ($Awfif::codelet-> {l} [$myli][22]));

    if (defined ($$static)) {
      $$static = '';#can't depend on this being the same every return - don't cache
      };#if

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      my ($pr);
      for ($i = 1; $i <= $labcount; $i++) {
        $pr = '<' . $Awfif::memes-> {snnih} {$$lab[$i]} . '>';
        print ("$pr");
        };#for
      print ("selfx ret ($labcount)\n");
      };
    return $labcount
    }# self1
#
#<!-- start tag scs -->
#
sub ecyclino1 {# setup the labels for e cyclin signalling
    my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
    my ($labcount, $i);

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("ecyclino1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
      };
# updated for merged workspaces

    $labcount = 0;

    $labcount = labload (\@$lab, $labcount, wsbasetype ($Awfif::codelet-> {l} [$myli][21]));
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {program});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {do});

    if (defined ($$static)) {
      $$static = '';#can't depend on this being the same every return - don't cache
      };#if

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      my ($pr);
      for ($i = 1; $i <= $labcount; $i++) {
        $pr = '<' . $Awfif::memes-> {snnih} {$$lab[$i]} . '>';
        print ("$pr");
        };#for
      print ("ecyclino1x ret ($labcount)\n");
      };
    return $labcount
    }# ecyclino1
#
sub acyclino1 {# setup the labels for a cyclin signalling
    my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
    my ($labcount, $i);

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("acyclino1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
      };
# updated for merged workspaces

    $labcount = 0;

    $labcount = labload (\@$lab, $labcount, wsbasetype ($Awfif::codelet-> {l} [$myli][21]));
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {program});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {check});

    if (defined ($$static)) {
      $$static = '';#can't depend on this being the same every return - don't cache
      };#if

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      my ($pr);
      for ($i = 1; $i <= $labcount; $i++) {
        $pr = '<' . $Awfif::memes-> {snnih} {$$lab[$i]} . '>';
        print ("$pr");
        };#for
      print ("acyclino1x ret ($labcount)\n");
      };
    return $labcount
    }# acyclino1
#
sub bcyclino1 {# setup the labels for b cyclin signalling
    my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
    my ($labcount, $i);

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("bcyclino1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
      };
# updated for merged workspaces

    $labcount = 0;

    $labcount = labload (\@$lab, $labcount, wsbasetype ($Awfif::codelet-> {l} [$myli][21]));
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {program});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {act});

    if (defined ($$static)) {
      $$static = '';#can't depend on this being the same every return - don't cache
      };#if

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      my ($pr);
      for ($i = 1; $i <= $labcount; $i++) {
        $pr = '<' . $Awfif::memes-> {snnih} {$$lab[$i]} . '>';
        print ("$pr");
        };#for
      print ("bcyclino1x ret ($labcount)\n");
      };
    return $labcount
    }# bcyclino1
#
sub dcyclino1 {# setup the labels for d cyclin signalling
    my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
    my ($labcount, $i);

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("dcyclino1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
      };
# updated for merged workspaces

    $labcount = 0;

    $labcount = labload (\@$lab, $labcount, wsbasetype ($Awfif::codelet-> {l} [$myli][21]));
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {program});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {initiate});

    if (defined ($$static)) {
      $$static = '';#can't depend on this being the same every return - don't cache
      };#if

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      my ($pr);
      for ($i = 1; $i <= $labcount; $i++) {
        $pr = '<' . $Awfif::memes-> {snnih} {$$lab[$i]} . '>';
        print ("$pr");
        };#for
      print ("dcyclino1x ret ($labcount)\n");
      };
    return $labcount
    }# dcyclino1
#
sub imemb1 {# setup the binding for internal membrane binder
    my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
    my ($labcount);

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("imemeb1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
      };
# updated for merged workspaces

    $labcount = 0;

    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {membrane});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {internal});

    if (defined ($$static)) {
      $$static = '';#can't depend on this being the same every return - don't cache
      };#if

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("imembx ret ($labcount)\n");
      };
    return $labcount
    }# imemb
#
sub tfactorb1 {# setup the binding for tfactor binder
    my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
    my ($labcount);

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("tfactorb myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
      };
# updated for merged workspaces

    $labcount = 0;

    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {transcription});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {factor});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {sequence});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {integration});

    if (defined ($$static)) {
      $$static = 't';#can depend on this being the same every return - can cache
      };#if

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("tfactorbx ret ($labcount)\n");
      };
    return $labcount
    }# tfactorb
#<!-- end tag scs -->
#<!-- end tag aso -->
#<!-- start tag sir -->
#
sub receptorb1 {# setup the binding for resolved assert receptor buffer binder
    my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
    my ($labcount, $cwsbi, $i);

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("receptorb myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
      };
# updated for merged workspaces

    $labcount = 0;
# updated for merged workspaces
    $cwsbi = $Awfif::memes-> {currentwsbi};

    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {signal});
    $Awfif::memes-> {currentwsbi} = $Awfif::codelet-> {l} [$myli] [20];
    for ($i = trwsoadr ($Awfif::codelet-> {l} [$myli][21], 4);
    $i != $Awfif::codelet-> {l} [$myli][22];
    $i = trwsoadr ($i,1)) {
      $labcount = labload (\@$lab, $labcount, wsbasetype ($i));
      };#for
    $labcount = labload (\@$lab, $labcount, wsbasetype ($Awfif::codelet-> {l} [$myli][22]));
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {sequence});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {integration});

    if (defined ($$static)) {
      $$static = '';#can not depend on this being the same every return - can't cache
      };#if
    $Awfif::memes-> {currentwsbi} = $cwsbi;

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("receptorbx ret ($labcount)\n");
      };
    return $labcount
    }# receptorb
#
sub receptorbi1 {# setup the binding for resolved assert receptor buffer binder
    my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
    my ($labcount, $cwsbi, $i);

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("receptorbi myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
      };
# updated for merged workspaces

    $labcount = 0;
# updated for merged workspaces
    $cwsbi = $Awfif::memes-> {currentwsbi};

    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {signal});
    $Awfif::memes-> {currentwsbi} = $Awfif::codelet-> {l} [$myli] [20];
    for ($i = trwsoadr ($Awfif::codelet-> {l} [$myli][21], 5);
    $i != $Awfif::codelet-> {l} [$myli][22];
    $i = trwsoadr ($i,1)) {
      $labcount = labload (\@$lab, $labcount, wsbasetype ($i));
      };#for
    $labcount = labload (\@$lab, $labcount, wsbasetype ($Awfif::codelet-> {l} [$myli][22]));
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {sequence});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {integration});

    if (defined ($$static)) {
      $$static = '';#can not depend on this being the same every return - can't cache
      };#if
    $Awfif::memes-> {currentwsbi} = $cwsbi;

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("receptorbix ret ($labcount)\n");
      };
    return $labcount
    }# receptorbi
#
sub receptorh1 {# setup the binding for receptor hierarchy signal schematic workspace binder
    my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
    my ($labcount);

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("receptorh1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
      };
# updated for merged workspaces

    $labcount = 0;

    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {signal});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {schema});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {integration});

    if (defined ($$static)) {
      $$static = 't';#can depend on this being the same every return - can cache
      };#if

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("receptorhx ret ($labcount)\n");
      };
    return $labcount
    }# receptorh
#<!-- end tag sir -->
#<!-- start tag cr -resweb -->
#
sub subpc1 {# setup the labels for subprogram indirect context
    my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
    my ($labcount, $i, $cwsbi);

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("subpc1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
      };
# updated for merged workspaces

    $labcount = 0;

    $cwsbi = $Awfif::memes-> {currentwsbi};
    $Awfif::memes-> {currentwsbi} = $Awfif::codelet-> {l} [$myli] [20];
    for ($i = trwsoadr($Awfif::codelet-> {l} [$myli][21],2);
    $i != trwsoadr ($Awfif::codelet-> {l} [$myli][22],-2);
    $i = trwsoadr ($i,1)) {
      $labcount = labload (\@$lab, $labcount, wsbasetype ($i));
      };#for
    $labcount = labload (\@$lab, $labcount, wsbasetype (trwsoadr ($Awfif::codelet-> {l} [$myli][22],-2)));
    if ($Awfif::codelet-> {l} [$myli] [36] == 0) {

      $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {subprogram});
      };#else
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {sequence});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {integration});
    $Awfif::memes-> {currentwsbi} = $cwsbi;

    if (defined ($$static)) {
      $$static = '';#can't depend on this being the same every return - don't cache
      };#if

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("subpc1x ret ($labcount)\n");
      };
    return $labcount
    }# subpc1
#<!-- start tag sca -->
#
sub hdob1 {# setup the binding for hdo binder
    my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
    my ($labcount);

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("hdob1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
      };
# updated for merged workspaces

    $labcount = 0;

    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {hdo});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {sequence});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {integration});

    if (defined ($$static)) {
      $$static = 't';#can depend on this being the same every return - can cache
      };#if

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("hdobx ret ($labcount)\n");
      };
    return $labcount
    }# hdob
# hdoi1 does not appear to be used
sub hdoi1 {# setup the labels for hdo initiator signaling
    my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

    return (iinitiators1 ($myli, $sti, \@$lab, $kwp, $kwpr, \@$sactset, \$$static, 'hdo'));
    }# hdoi1
#
#<!-- start tag aso -->
#
sub msadoboppi1 {# setup the labels for hdo integration
    my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
    my ($labcount, $i, $cwsbi);

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("msadoboppi1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
      };
# updated for merged workspaces
    $cwsbi = $Awfif::memes-> {currentwsbi};

    $labcount = 0;

    $Awfif::memes-> {currentwsbi} = $Awfif::codelet-> {l} [$myli] [20];
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {hdo});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {schema});
    for ($i = trwsoadr ($Awfif::codelet-> {l} [$myli][21], 4);
    $i != $Awfif::codelet-> {l} [$myli][22];
    $i = trwsoadr ($i,1)) {
      $labcount = labload (\@$lab, $labcount, wsbasetype ($i));
      };#for
    $labcount = labload (\@$lab, $labcount, wsbasetype ($Awfif::codelet-> {l} [$myli][22]));
    $Awfif::memes-> {currentwsbi} = $cwsbi;

    if (defined ($$static)) {
      $$static = '';#can't depend on this being the same every return - don't cache
      };#if

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("msadoboppi1x ret ($labcount)\n");
      };
    return $labcount
    }# msadoboppi1
#
sub binderrc1 {# setup the labels for binder 4 to -1
    my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

    return (ibindervc1 ($myli, $sti, \@$lab, $kwp, $kwpr, \@$sactset, \$$static, 1, 4));
    }# binderrc1
#
sub bindercml1 {# setup the labels for binder 2 to -1
    my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

    return (ibindervc1 ($myli, $sti, \@$lab, $kwp, $kwpr, \@$sactset, \$$static, 1));
    }# bindercml1
#
#<!-- end tag aso -->
#<!-- end tag sca -->
#<!-- start tag vbt -->
#
sub vworldb1 {# setup the binding for vbot world workspace
    my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
    my ($labcount);

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("vworldb1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
      };
# updated for merged workspaces

    $labcount = 0;

    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {square});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {naught});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {schema});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {integration});

    if (defined ($$static)) {
      $$static = 't';#can depend on this being the same every return - can cache
      };#if

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("vworldbx ret ($labcount)\n");
      };
    return $labcount
    }# vworldb
#
sub vwxstartb1 {# setup the binding for vbot world start workspace
    my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
    my ($labcount);

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("vwxstartb1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
      };
# updated for merged workspaces

    $labcount = 0;

    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {wall});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {naught});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {one});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {two});

    if (defined ($$static)) {
      $$static = 't';#can depend on this being the same every return - can cache
      };#if

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("vwxstartbx ret ($labcount)\n");
      };
    return $labcount
    }# vwxstartb
#
sub vcansb1 {# setup the binding for vbot can workspace
    my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
    my ($labcount);

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("vcansb1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
      };
# updated for merged workspaces

    $labcount = 0;

    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {cans});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {naught});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {schema});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {integration});

    if (defined ($$static)) {
      $$static = 't';#can depend on this being the same every return - can cache
      };#if

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("vcansbx ret ($labcount)\n");
      };
    return $labcount
    }# vcansb
#
#<!-- end tag vbt -->
#<!-- start tag scl -->
#
sub pcellb1 {# setup the binding for pcell structural workspace
    my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
    my ($labcount);

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("pcellb1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
      };
# updated for merged workspaces

    $labcount = 0;

    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {cans});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {naught});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {schema});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {integration});

    if (defined ($$static)) {
      $$static = 't';#can depend on this being the same every return - can cache
      };#if

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("pcellbx ret ($labcount)\n");
      };
    return $labcount
    }# pcellb
#
#<!-- end tag scl -->
#<!-- start tag scc -->
#<!-- start tag aso -->
#
sub warb1 {# setup the binding for wait and relay workspace
    my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
    my ($labcount);

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("warb1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
      };
# updated for merged workspaces

    $labcount = 0;

    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {waitarelay});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {schema});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {integration});

    if (defined ($$static)) {
      $$static = 't';#can depend on this being the same every return - can cache
      };#if

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("warbx ret ($labcount)\n");
      };
    return $labcount
    }# warb
#
sub warasb1 {# setup the association for wait and relay operons
    my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
    my ($labcount);

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("warasb1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
      };
# updated for merged workspaces

    $labcount = 0;

    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {waitarelay});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {schema});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {qmark});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {qmark});

    if (defined ($$static)) {
      $$static = 't';#can depend on this being the same every return - can cache
      };#if

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("warasbx ret ($labcount)\n");
      };
    return $labcount
    }# warasb
#
sub warmab1 {# match a wait and relay operon
    my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
    my ($labcount, $lbuffer, $content);

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("warmab1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
      };
# updated for merged workspaces

    $labcount = 0;

    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {waitarelay});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {schema});
# now must find each <keyword> in $st1 snnh it into its index and labload it
    $lbuffer = $sti;
    while ($lbuffer =~ /<([\w]*)>/){

      $content = $1;
      $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {$content});
      $lbuffer =~ s/\Q<$1>/ /;
      };#while

    if (defined ($$static)) {
      $$static = 't';#can depend on this being the same every return - can cache
      };#if

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("warmabx ret ($labcount)\n");
      };
    return $labcount
    }# warmab
#
sub warmdob1 {# setup the association of do mergestreams with wait and relay operons
    my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
    my ($labcount);

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("warmdob1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
      };
# updated for merged workspaces

    $labcount = 0;

    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {waitarelay});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {schema});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {do});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {mergestreams});

    if (defined ($$static)) {
      $$static = 't';#can depend on this being the same every return - can cache
      };#if

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("warmdobx ret ($labcount)\n");
      };
    return $labcount
    }# warmdob
#
sub warhdob1 {# setup the association of histone do with wait and relay operons
    my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
    my ($labcount);

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("warhdob1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
      };
# updated for merged workspaces

    $labcount = 0;

    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {waitarelay});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {schema});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {hdo});

    if (defined ($$static)) {
      $$static = 't';#can depend on this being the same every return - can cache
      };#if

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("warhdobx ret ($labcount)\n");
      };
    return $labcount
    }# warhdob
#
sub warmsb1 {# setup the association of mergestreams stream with wait and relay operons
    my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
    my ($labcount);

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("warmsb1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
      };
# updated for merged workspaces

    $labcount = 0;

    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {waitarelay});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {schema});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {mergestreams});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {stream});

    if (defined ($$static)) {
      $$static = 't';#can depend on this being the same every return - can cache
      };#if

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("warmsbx ret ($labcount)\n");
      };
    return $labcount
    }# warmsb
#
sub comparestb1 {# setup the binding for compare source target binder
    my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
    my ($labcount);

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("comparestb1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
      };
# updated for merged workspaces

    $labcount = 0;

    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {source});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {target});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {sequence});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {integration});

    if (defined ($$static)) {
      $$static = 't';#can depend on this being the same every return - can cache
      };#if

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("comparestbx ret ($labcount)\n");
      };
    return $labcount
    }# comparestb
#
sub comparesti1 {# setup the labels for compare source target
    my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
    my ($labcount, $i);

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("comparesti1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
      };
# updated for merged workspaces

    $labcount = 0;

    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {source});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {target});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {schema});
    for ($i = $Awfif::codelet-> {l} [$myli][21]; $i != $Awfif::codelet-> {l} [$myli][22];$i = trwsoadr ($i,1)) {
      $labcount = labload (\@$lab, $labcount, wsbasetype ($i));
      };#for
    $labcount = labload (\@$lab, $labcount, wsbasetype ($Awfif::codelet-> {l} [$myli][22]));
    $labcount = labload (\@$lab, $labcount, wsbasetype ($sti));

    if (defined ($$static)) {
      $$static = '';#can't depend on this being the same every return - don't cache
      };#if

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("comparesti1x ret ($labcount)\n");
      };
    return $labcount
    }# comparesti1
#
#<!-- end tag aso -->
#<!-- end tag scc -->
#
sub labinv1 {
    my ($myli, $as, $ae, $ael, $sponsor, $lomatchs, $lola, $loconcs, $lostrts, $loends, $logb, $loge, $filstrategy) = @_;
    my ($i, $i2, $label, $type, $ltype, $sigcount, $aer);
# inversion of group builder complete's label space code
#
# checked for merged workspaces

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("labinv1 myli $myli as $as ae $ae ");
      if ($myli > 0) {
        &itcpoutput ($myli);
        };
      };

    $label = '';
    $ltype = '';
    $i2 = 0;
    $aer = '';
# labinv1nsu1

    $i = trwsoadr ($as, 1);
    while ((($ael && !$aer) or (!$ael && ($i != $ae))) && ( awsoadr ($i) != 0)) {
      my($kwai, $akwai, $kws, $kwl, $slab);
      if ($ael && ($i == $ae)) {

        $aer = 't';
        };#if
# sponsor is now stable can mark its position in group members wso

      if ($sponsor ne '') {# if use defined here no work gets done???

        if ((defined ($Awfif::wsol-> {l} [awsoadr ($i)] [ $Awfif::memes-> {wsogstart} ]))
        && ($Awfif::wsol-> {l} [awsoadr ($i)] [ $Awfif::memes-> {wsogstart} ] != 0)
        && ($Awfif::wsol-> {l} [awsoadr ($i)] [ $Awfif::memes-> {wsogstart} ] != $sponsor)
        ){

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

        if (($ngcsponsor != 0) && ($ngcsponsor != $sponsor)) {&break ()};
        $Awfif::wsol-> {l}[awsoadr ($i)][ $Awfif::memes-> {wsogcsponsor}] = $sponsor;#*** submacrok ***#
        $Awfif::wsol-> {l}[awsoadr ($i)][ $Awfif::memes-> {wsogcsponsored}] = $sponsor;#*** submacrok ***#
        };#update sponsor if specified

      $type = ' ' . wsbasetype ($i);
      $slab = getwsost4 ($i);
      if ((($type == $Awfif::memes-> {snnh} {mkeywords}) or ($type == $Awfif::memes-> {snnh} {mkeyworde})) && (mkwlabel (\$slab, \$kwai, \$akwai, \$kws, \$kwl)) && (!ismemetic ($akwai))) {
# labinv1m1
        my ($sparam, $param, $param2);
        $sparam = jhlmappl ($kws);

        if ($sparam =~ /,/) {
          while ($sparam =~ /(\d+)+(,)*/i) {

            $param = $1;
            $param2 = $2;
            $sparam =~ s/$param$param2//;
            $type = ' '.$param;
            $label = $label.$type;
            $$lostrts[$i2++] = $i;
            };#while
          };#if
        $ltype = '';#no repeats on mkeyword
        }
      else {
        if ($type eq ' '.wsbasetype ( trwsoadr ($i, 1))) {#note repeat

          $type = '_' . wsbasetype ($i);
          };#repeat
        if ($ltype ne $type) {# ignore repeats

          $label = $label.$type;
          $$lostrts[$i2++] = $i;
          };#build direct label
        $ltype = $type;
        };#else
      $i = trwsoadr ($i, 1);
      };#for
# apply the linking function of group completion
# if the groups labels result in a match with a signal then raise the signal
#

    $sigcount = msublabel1 ($myli, \$label, \@$lomatchs, \@$lola, \@$loconcs, \@$lostrts, \@$loends, \@$logb, \@$loge, $filstrategy);

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("labinv1x ret $sigcount\n");
      };
    return $sigcount
    }# labinv1
#
sub labload {
    my ($lab, $labcount, $concept) = @_;
    my ($count);

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

    $count = $labcount + 1;
    $$lab [$count] = $concept;

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("labloadx ret $count\n");
      };
    return $count
    }# labload
#
#
sub destructionscout1 {
    my ($myli, $kwp, $kwpr, $sactset) = @_;#The ignored parameters are required by the codelet calling architecture
    my ($cdn, $cdnx, $descid);
#
# checked for merged workspaces

    $cdn = clogstat (\$cdnx);
    if (($Awfif::memes-> {telomeretrace} > $Awfif::memes-> {traceentry}) && ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry})) {
      print ("$cdn myli $myli ");
      &itcpoutput ($myli);
      };
# destruction codelets must use the full workspace

# see if this workspace has any telomeric structures to evaluate

    if ((($descid = findtelhd ($Awfif::memes-> {currentwsbi}))>0)
    && (($Awfif::workspace-> {l} [$descid] [2] - $Awfif::memes-> {snnh} {wsi}) > 0)
    ) {
# if the telomeric list has entries call in an evaluator

      $Awfif::clp = ();
      $Awfif::clp-> {log} = $Awfif::codelet-> {l} [$myli][13];
      $Awfif::clp-> {urgency} = $Awfif::memes-> {parteu};
      if (defined ($Awfif::codelet-> {l}[$myli][19])) {
        $Awfif::clp-> {wsi} = $Awfif::codelet-> {l}[$myli][19];
        }#wsi set
      else {
        $Awfif::clp-> {wsi} = $Awfif::memes-> {currentwsbi};
        };
      $Awfif::clp-> {strategy} = "destructionevaluator";
      &cdsubmitcodelet ($myli, \$Awfif::clp);
      };# got a telomere

    if (($Awfif::memes-> {telomeretrace} > $Awfif::memes-> {traceentry}) && ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry})) {
      print ("$cdnx\n");
      };
    &clogstatx ();
    }# destructionscout1
#
sub destructionevaluator1 {
    my ($myli, $kwp, $kwpr, $sactset) = @_;#The ignored parameters are required by the codelet calling architecture
    my ($count, $telcount,
    $cdn, $cdnx);
#
# checked for merged workspaces

    $cdn = clogstat (\$cdnx);
    if (($Awfif::memes-> {telomeretrace} > $Awfif::memes-> {traceentry}) && ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry})) {
      print ("$cdn myli $myli ");
      &itcpoutput ($myli);
      };
# see if this workspace has any telomeric structures to evaluate

    $count = 0;
    $count = counttelst1 ($Awfif::memes-> {currentwsbi}, \$telcount);

    if ($count > $Awfif::memes-> {telcountth}) {
      $Awfif::clp = ();
      $Awfif::clp-> {log} = $Awfif::codelet-> {l} [$myli][13];
      $Awfif::clp-> {urgency} = ($Awfif::codelet-> {l} [$myli][3] * $Awfif::memes-> {blaunchm});
      if (defined ($Awfif::codelet-> {l}[$myli][19])) {
        $Awfif::clp-> {wsi} = $Awfif::codelet-> {l}[$myli][19];
        }#wsi set
      else {
        $Awfif::clp-> {wsi} = $Awfif::memes-> {currentwsbi};
        };
      $Awfif::clp-> {strategy} = "destructionbuilder";
      &cdsubmitcodelet ($myli, \$Awfif::clp);
      };#if

    if (($Awfif::memes-> {telomeretrace} > $Awfif::memes-> {traceentry}) && ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry})) {
      print ("$cdnx\n");
      };
    &clogstatx ();
    }# destructionevaluator1
#
sub counttelst1 {
    my ($ws, $telcount) = @_;
    my ($ni, $descid, $count);
#
# checked for merged workspaces

# if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
# print ("counttelst1 ws $ws ");
# };
# see if this workspace has any telomeric structures to evaluate

    $count = 0;
    $$telcount = 0;
    if ((($descid = findtelhd ($ws))>0)
    && (($ni = ($Awfif::workspace-> {l} [$descid] [2] - $Awfif::memes-> {snnh} {wsi})) > 0)
    ) {

      while ($ni != 0) {
        &istelwso (\$ni, \$count, \$$telcount);
# countteljhlsu1
        };#while

      };#got telomeric structures to evaluate
# if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
# print ("counttelst1x telcount $$telcount ret ($count)\n");
# };

    return $count
    }# counttelst1
#
sub istelwso {
    my ($ni, $count, $telcount) = @_;
    my ($descid, $found, $life, $jhlsoi, $ini);
#
# see if this wso is telomeric and measure it

    $found = '';
    $ini = $$ni;

    if ($$ni != 0) {
      if ($Awfif::memes-> {telomeretrace} > $Awfif::memes-> {traceentry}) {

        print ("istelwso ni $$ni count $$count telcount $$telcount \n");
        &itwsoutput ( trwsoadr ($$ni,1), $$ni);
        };#if trace
      $descid = $Awfif::wsol-> {l} [awsoadr ($$ni)] [2];
      $$ni = 0;

      while (($descid != 0)) {#search ni for telomeric descriptors
        if (($Awfif::workspace-> {l} [$descid] [3] == $Awfif::memes-> {snnh} {value}) && ($Awfif::workspace-> {l} [$descid] [4] == $Awfif::memes-> {snnh} {telomere})) {

          $life = ($Awfif::workspace-> {l} [$descid] [2] - $Awfif::memes-> {snnh} {wsi});
          if ($life < $Awfif::memes-> {tellifeth} ) {

            $$count++;
            };#if
          }# found a count
        if (($Awfif::workspace-> {l} [$descid] [3] == $Awfif::memes-> {snnh} {lhead}) && ($Awfif::workspace-> {l} [$descid] [4] == $Awfif::memes-> {snnh} {telomere})) {

          $$ni = ($Awfif::workspace-> {l} [$descid] [2] - $Awfif::memes-> {snnh} {wsi});
          $$telcount ++;
          $found = 't';
          };# found a head
# isteljhlsu1
        if (
        ($Awfif::workspace-> {l} [$descid] [3] == $Awfif::memes-> {snnh} {jhlsoi})
        && ($Awfif::workspace-> {l} [$descid] [4] == $Awfif::memes-> {snnh} {telomere})
        && (($Awfif::jhls-> {l} [($jhlsoi = ($Awfif::workspace-> {l} [$descid] [2] - $Awfif::memes-> {snnh} {wsi}))] [14] [2]) <= 1)
        ) {

          $$count--;
          };# telomere is last link to sponsor gc
# isteldoku1
        if (
        ($Awfif::workspace-> {l} [$descid] [3] == $Awfif::memes-> {snnh} {destroyok})
        && ($Awfif::workspace-> {l} [$descid] [4] == $Awfif::memes-> {snnh} {telomere})
        && (($Awfif::jhls-> {l} [($jhlsoi = ($Awfif::workspace-> {l} [$descid] [2] - $Awfif::memes-> {snnh} {wsi}))] [14] [2]) <= 1)
        && (!telisie ($ini))
        ) {

          $$count++;
          };# telomere is allowed to be destroyed

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

    if ($Awfif::memes-> {telomeretrace} > $Awfif::memes-> {traceentry}) {
      print ("istelwsox nextni $$ni destcount $$count telcount $$telcount ret ($found)\n");
      };

    return $found
    }# istelwso
#
sub writeiecok {
    my ($sponsor) = @_;
    my ($iedesc, $found, $jhlsi);
#
# see if conditions exist to write to the independent & equivalent cache

    $found = '';

    if ($sponsor != 0) {
      if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {

        print ("writeiecok sponsor $sponsor \n");
        &itwsoutput ( trwsoadr ($sponsor,1), $sponsor);
        };#if trace
      if ( (($iedesc = findtdesc ($Awfif::wsol-> {l} [ awsoadr ($sponsor)] [2], $Awfif::memes-> {snnh} {indequiv})) == 0 ) #groupbuilder has not previously written the cache details
      && (($iedesc = findtdesc ($Awfif::wsol-> {l} [ awsoadr( trwsoadr($sponsor, -1))] [2], $Awfif::memes-> {snnh} {mindequiv})) != 0 ) #groupbuilder has not previously written the cache details
      && (($jhlsi = ($Awfif::workspace-> {l} [$iedesc][2] - $Awfif::memes-> {snnh} {wsi})) != 0)
      && ($Awfif::jhls-> {l} [$jhlsi][15] [0])
      ){
        $found = 't';
        };#if conditions ok
      };#if

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

    return $found
    }# writeiecok
#
sub telhasiecache {
    my ($ni) = @_;
    my ($iedesc, $found, $jhlsi);
#
# see if telomere has an ie cache

    $found = '';

    if ($ni != 0) {
      if ($Awfif::memes-> {telomeretrace} > $Awfif::memes-> {traceentry}) {

        print ("telhasiecache ni $ni \n");
        &itwsoutput ( trwsoadr ($ni,1), $ni);
        };#if trace
      if ( (($iedesc = findtdesc ($Awfif::wsol-> {l} [ awsoadr ($ni)] [2], $Awfif::memes-> {snnh} {mindequiv})) != 0 ) #groupbuilder has not previously written the cache details
      && (($jhlsi = ($Awfif::workspace-> {l} [$iedesc][2] - $Awfif::memes-> {snnh} {wsi})) != 0)
      && ($Awfif::jhls-> {l} [$jhlsi][15][2] > 0)
      && ($Awfif::jhls-> {l} [$Awfif::jhls-> {l} [$jhlsi][15][2]][15][1])
      ){
        $found = 't';
        };#if conditions ok
      };#if

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

    return $found
    }# telhasiecache
#
sub telisie {
    my ($ni) = @_;
    my ($iedesc, $found, $jhlsi);
#
# see if this telomere is an i.e. master

    $found = '';

    if ($ni != 0) {
      if ($Awfif::memes-> {telomeretrace} > $Awfif::memes-> {traceentry}) {

        print ("telisie ni $ni \n");
        &itwsoutput ( trwsoadr ($ni,1), $ni);
        };#if trace
      if ( (($iedesc = findtdesc ($Awfif::wsol-> {l} [ awsoadr ($ni)] [2], $Awfif::memes-> {snnh} {mindequiv})) != 0 ) #groupbuilder has not previously written the cache details
      && (($jhlsi = ($Awfif::workspace-> {l} [$iedesc][2] - $Awfif::memes-> {snnh} {wsi})) != 0)
      && ($Awfif::jhls-> {l} [$jhlsi][15][3] > 0)
      ){
        $found = 't';
        };#if conditions ok
      };#if

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

    return $found
    }# telisie
#
sub teltail {
    my ($wso) = @_;
    my ($descid, $found, $result);
#
# given a telomere head wso find the tail reference

    $found = '';
    $result = 0;

    if ($wso != 0) {
      if ($Awfif::memes-> {telomeretrace} > $Awfif::memes-> {traceentry}) {

        print ("teltail wso $wso \n");
        &itwsoutput ( $wso);
        };#if trace
      $descid = $Awfif::wsol-> {l} [awsoadr ($wso)] [2];

      while (($descid != 0) && (!$found)) {#search ni for telomeric descriptors
        if (
        ($Awfif::workspace-> {l} [$descid] [3] == $Awfif::memes-> {snnh} {ltail})
        && ($Awfif::workspace-> {l} [$descid] [4] == $Awfif::memes-> {snnh} {telomere})
        && (($result = ($Awfif::workspace-> {l} [$descid] [2] - $Awfif::memes-> {snnh} {wsi})) != 0)
        ) {

          $found = 't';
          };# telomere is allowed to be destroyed

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

    if ($Awfif::memes-> {telomeretrace} > $Awfif::memes-> {traceentry}) {
      print ("teltailx ret ($result)\n");
      };

    return $result
    }# teltail
#
#
sub destructionbuilder1 {
    my ($myli, $kwp, $kwpr, $sactset) = @_;#The ignored parameters are required by the codelet calling architecture
    my ($ni, $descid, $found, $life, $count, $presentni, $lastni, $notdeleting, $cwsbi, $cdn, $cdnx);
#
# checked for merged workspaces

    $cdn = clogstat (\$cdnx);
    $cwsbi = $Awfif::memes-> {currentwsbi};
    if (($Awfif::memes-> {telomeretrace} > $Awfif::memes-> {traceentry}) && ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry})) {
      print ("$cdn myli $myli ");
      &itcpoutput ($myli);
      };
# see if this workspace has any telomeric structures to destroy

    $count = 0;
    $presentni = 0;
    $notdeleting = 't';
    if ((($descid = findtelhd ($Awfif::memes-> {currentwsbi}))>0)
    && (($ni = ($Awfif::workspace-> {l} [$descid] [2] - $Awfif::memes-> {snnh} {wsi})) > 0)
    ) {
      while ($ni != 0) {
        $descid = $Awfif::wsol-> {l} [awsoadr ($ni)] [2];
        $found = '';
        if ($notdeleting) {
          $lastni = $presentni;
          $presentni = $ni;
          };#if
        $ni = 0;
        while (($descid != 0)) {#search ni for telomeric descriptors
          if (($Awfif::workspace-> {l} [$descid] [3] == $Awfif::memes-> {snnh} {value}) && ($Awfif::workspace-> {l} [$descid] [4] == $Awfif::memes-> {snnh} {telomere})) {
# destructionbtellu1
            $life = ($Awfif::workspace-> {l} [$descid] [2] - $Awfif::memes-> {snnh} {wsi});
            if ($life < $Awfif::memes-> {tellifeth} ) {
              $count++;
              $found = 't';
              };#if
            }# found a count
          if (($Awfif::workspace-> {l} [$descid] [3] == $Awfif::memes-> {snnh} {lhead}) && ($Awfif::workspace-> {l} [$descid] [4] == $Awfif::memes-> {snnh} {telomere})) {
            $ni = ($Awfif::workspace-> {l} [$descid] [2] - $Awfif::memes-> {snnh} {wsi});
            };# found a head
          $descid = $Awfif::workspace-> {l} [$descid] [0];
          };#while
# destructionbteldu1

        if (($count > $Awfif::memes-> {telcountth}) && ($found) && ($ni != 0)) {# delete those older than count
          my ($nextni, $skipdel);

          $notdeleting = '';
          $skipdel = '';
          if (($nextni = freetelstr ($ni, $presentni, \$skipdel)) == 0) {
            $ni = 0;
            }#if
          elsif ($skipdel) {
# ni will be the next item to look at
            }# elsif
          else {
            $ni = $presentni;
            };#else
          };#if
        };#while ni != 0
      };#got telomeric structures to destroy

    $Awfif::memes-> {currentwsbi} = $cwsbi;
    if (($Awfif::memes-> {telomeretrace} > $Awfif::memes-> {traceentry}) && ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry})) {
      print ("$cdnx\n");
      };
    &clogstatx ();
    }# destructionbuilder1
#
Market Centric Workshops
The Physics - Politics, Economics & Evolutionary Psychology
Politics, Economics & Evolutionary Psychology

Business Physics
Nature and nurture drive the business eco-system
Human nature
Emerging structure and dynamic forces of adaptation
integrating quality appropriate for each market
 
This page looks at schematic structures and their uses.  It discusses a number of examples:
  • Schematic ideas are recombined in creativity. 
  • Similarly designers take ideas and rules about materials and components and combine them. 
  • Schematic Recipes help to standardize operations. 
  • Modular components are combined into strategies for use in business plans and business models. 

As a working example it presents part of the contents and schematic details from the Adaptive Web Framework (AWF)'s operational plan. 

Finally it includes a section presenting our formal representation of schematic goals. 
Each goal has a series of associated complex adaptive system (CAS) strategy strings. 
These goals plus strings are detailed for various chess and business examples. 
Strategy | Design |
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. 
Program Management | Home
Profiles | Papers | Glossary | E-mail us

Copyright ©2012, 2013, 2014, 2015, 2016, 2017 •  Rob Lingley