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

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

Schematic codelets provide a Shewhart cycle

Summary
This page describes the specialized codelets that provide life-cycle and checkpoint capabilities for
This page describes the Adaptive Web framework (AWF) test system and the agent programming framework (Smiley) that supports its operation. 
Example test system statements are included.  To begin a test a test statement is loaded into Smiley while Smiley executes on the Perl interpreter. 
Part of Smiley's Perl code focused on setting up the infrastructure is included bellow. 
The setup includes:
  • Loading the 'Meta file' specification,
  • Initializing the Slipnet, and Workspaces and loading them
  • So that the Coderack can be called. 
The Coderack, which is the focus of a separate page of the Perl frame then schedules and runs the codelets that are invoked by the test statement structures. 
Smiley
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
Introduction
The adaptive web framework's (AWF)
This page describes the Adaptive Web framework (AWF) test system and the agent programming framework (Smiley) that supports its operation. 
Example test system statements are included.  To begin a test a test statement is loaded into Smiley while Smiley executes on the Perl interpreter. 
Part of Smiley's Perl code focused on setting up the infrastructure is included bellow. 
The setup includes:
  • Loading the 'Meta file' specification,
  • Initializing the Slipnet, and Workspaces and loading them
  • So that the Coderack can be called. 
The Coderack, which is the focus of a separate page of the Perl frame then schedules and runs the codelets that are invoked by the test statement structures. 
Smiley
supports application
Plans are interpreted and implemented by agents.  This page discusses the properties of agents in a complex adaptive system (CAS). 
It then presents examples of agents in different CAS.  The examples include a computer program where modeling and actions are performed by software agents.  These software agents are aggregates. 
The participation of agents in flows is introduced and some implications of this are outlined. 
agent
coordination and control by providing a eukaryotic, a relatively large multi-component cell type from which yeast and multi-celled plants and animals, including humans, is constructed.  It contains modules including a nucleus and production functions such as mitochondria.   cell-cycle, a key control mechanism in eukaryotic cells ensures that the cell can replicate when required.  The process is complicated but is logically equivalent to a Shewhart cycle with four phases: (1) general operation using the DNA as the plan, (2) generation of copies of genetic material, (3) checking that the copies were robust, (4) separation of the cell into two.  The details of the cell-cycle are described by Helmreich.  In AWF the eukaryotic cell-cycle has been abstracted in a codelet based implementation. 
like codelet cascade.  The cascade can be used to institute check pointed phases within the application's operation.  The result is strikingly similar to the operation of a product team's quality and life-cycle activities. 
The effect of the cascade is to implement a Shewhart cycle
A
Walter Shewhart's iterative development process is found in many complex adaptive systems (CAS).  The mechanism is reviewed and its value in coping with random events is explained. 
Shewhart (PDCA) cycle
is created by a circular cascade modeled on the operation of cyclins, four enzymes A, B, C, D which cooperate to enforce the four phases of the eukaryotic cell cycle. 
in eukaryotic cells:
The cycle state representation is supported by structural schematic tags
The iterative cycle uses
This page discusses the tagging of signals in a complex adaptive system (CAS).  Tagged signals can be used to control filtering of an event stream.  Examples of CAS filters are reviewed. 
structural schematic tags
:

Transcription factor integration
The <transcription> <factor> <sequence> <integration> tag allows the transcription machinery nuclabm codelet (builder) to interact (via ctficomp) with associated transcription factors are enzymes which associate with a transcription complex to bind to the DNA and control its transcription and hence translation into proteins.  The regulation of DNA transcription and protein synthesis are reviewed by Tsonis.  Transcription factors allow environmental state to become reflected in the control of DNA transcription.  Transcription factors can regulate multiple genes, allowing network effects & multiple transcription factors can regulate a gene allowing sophisticated control processes.  In AWF the transcription, translation and deployment infrastructure of the eukaryotic cell has been abstracted in a codelet based implementation. 
, such as e2ftf and pRB.  The associations are deployed in the
This page describes the Copycat Slipnet. 
The goal of the Slipnet is reviewed. 
Smiley's specialized use of the Slipnet is introduced. 
The initial Slipnet network used by the 'Merge Streams' and 'Virtual Robot' agent-based applications is setup in initchemistry and is included. 
The Slipnet infrastructure and initialization functions are included. 
Slipnet
with the assistance of addjhltrf. 

Inhibitor integration
The <inhibitor> <sequence> <integration> tag allows the Smiley inhibitor, in an enzyme catalyzed reaction an inhibitor can stop the reaction.  It may be competitive, uncompetitive or noncompetitive.  Competitive inhibitors compete with the substrate for access to the active site.  Uncompetitive inhibitors react only with the enzyme-substrate complex creating an inhibited complex.  Noncompetitive inhibitors combine with the enzyme away from the active site and change the shape of the enzyme and its active site.  The adaptive web framework's (AWF) Smiley inhibitors are uncompetitive.  But the inhibition can be removed (reversed) by deploying descriptors. 
'machinery' prb, in the eukaryote cell cycle pRB is a transcription factor the retinoblastoma suppressor protein.  It binds E2F1 until it is phosphorylated by cyclin D1 when E2F1 is released initiating transcription of genes.  In the adaptive web framework's Smiley a pRB like codelet inhibits e2ftf until application codelets indicate that a cell-cycle like phase change can occur. 
, and p53 is a tumor suppressor which improves the specificity of transcription's DNA binding and promotes the transcriptional activity of E2F.  P53's activity is controlled by phosphorylation by cyclin Cdk complexes allowing indirect control of the cell cycle.  Among the many genes controlled by p53 are cyclin genes, genes for an inhibitor of cyclin-dependent kinases (Cdk), and the bax gene, which promotes apoptosis.  p53 can thus promote cell proliferation.  It can drive cells into apoptosis.  But it can also stop cell proliferation by arresting the cell cycle.  Normally there is a dynamic balance between proliferation of cells and their death.  In cancer proliferation may become unregulated due to oncogenic mutations or over expression of key regulatory signalling G proteins such as Ras.  Mutations of the p53 suppressor gene are the most frequent suppressor gene mutations in human cancers.  Elephants like humans, have a relatively low buildup of cancer with age.  Elephant's cells have twenty copies of p53 gene pairs which ensure cells with damaged DNA go into apoptosis blocking cancer onset. 
to interact with the application codelets, transcription factors are enzymes which associate with a transcription complex to bind to the DNA and control its transcription and hence translation into proteins.  The regulation of DNA transcription and protein synthesis are reviewed by Tsonis.  Transcription factors allow environmental state to become reflected in the control of DNA transcription.  Transcription factors can regulate multiple genes, allowing network effects & multiple transcription factors can regulate a gene allowing sophisticated control processes.  In AWF the transcription, translation and deployment infrastructure of the eukaryotic cell has been abstracted in a codelet based implementation. 
and
Walter Shewhart's iterative development process is found in many complex adaptive systems (CAS).  The mechanism is reviewed and its value in coping with random events is explained. 
Shewhart cycle
codelets, within the context of the
This page discusses how a Smiley based application the event processor test program's operational phase is structured. 
The goals of the event processor test application are described. 
The implementation strategy is outlined. 
Synchronization of Smiley setup completion and operation phase initiation is discussed. 
The association of structural Workspaces for state representation is discussed. 
An application specific codelet merge streams assert responds to the nature of the assertion.  It does not have an emergent structure.  Instead it reflects software engineering practice.  It includes:
  • Merge stream case specific
    • Modeling with sub-programs
    • Resolving of case
  • Non case assertion
The operation is setup, inhibited, initiated, and managed by iterative phase check-pointing provided by Smiley codelets. 
Schematic synchronization of parallel codelet cascades is performed structurally. 
The assert merge operon cascade is included. 
The Slipnet concept network for merge streams is included. 
The codelets and supporting functions are included. 
merge streams
program. 

As part of the planning phase an application codelet describes that the application's planning iteration has completed with the descriptor {model}-({complete})-> {investigation}.  Upon discovering this description the inhibitor machinery prb releases its inhibition of the transcription factor e2ftf, by writing a {inhibition}-({complete})->{prbevaluator} counter to the inhibitor tagged Workspace object (WSO), allowing the Shewhart cycle to advance.  As long as no 'e'prbi descriptor such as {pdcaprogram}-({complete})->{ecyclin}, is present the first ecycdop builder will remove the {inhibition}-({complete})->{prbevaluator} descriptor setting up the PDCA cycle's next planning phase check point, and deploys the 'e'prbi descriptor, inhibiting further current phase state changes by ecyclins. 

However after the transition to the 'Do' phase, when ecyclins are active, which they indicate by describing {pdcaprogram}-({complete})->{ecyclin}, the prb codelet will not respond to the icompd descriptor. 
The PDCA operon
The blending of Shewhart cycle schemata and application binder complex schemata creates a sophisticated
Plans are interpreted and implemented by agents.  This page discusses the properties of agents in a complex adaptive system (CAS). 
It then presents examples of agents in different CAS.  The examples include a computer program where modeling and actions are performed by software agents.  These software agents are aggregates. 
The participation of agents in flows is introduced and some implications of this are outlined. 
agent
with discrete management and operational roles. 

The codelet builder dcycipbuilder promotes exit from the planning phase.



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


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

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


#<!-- start tag aso -->


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

 


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



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

 


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


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

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





#<!-- start tag smo -->


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

 


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



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

 


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



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

 


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

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



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

 


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




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

 


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



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

 


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

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

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

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



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

 


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



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

 


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



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

 


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



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

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


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

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

#<!-- start tag smo -->

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

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

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

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

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

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

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

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

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

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

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

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

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

#<!-- end tag smo -->
#
    my ($pconc, $jhlsid);
# msciobindtomsiggv
# setup the binding string for the multi path signal to control merge streams program initiation - statement codelets launch nuclabmcodelets which ignore the concept as long as it had an evaluator

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

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

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

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

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

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

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

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

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [1], 8, $Awfif::memes-> {currentwsbi});
# next want to setup the operon
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {mpsignal}, $pconc, 2, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc), $pconc,# ****
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {mergestreams}, $Awfif::memes-> {snnh} {program}, $Awfif::memes-> {snnh} {terminate}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
# msacribindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {mergestreams}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {case}, $Awfif::memes-> {snnh} {resolved}, $Awfif::memes-> {snnh} {assert}, $Awfif::memes-> {snnh} {initialise}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {initpdcaevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
# msacrscibindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {pcell}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {pcell}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {pcell}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {case}, $Awfif::memes-> {snnh} {resolved}, $Awfif::memes-> {snnh} {assert}, $Awfif::memes-> {snnh} {initialise}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {initpdcascevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
# mstpdcabindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {mergestreams}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {program}, $Awfif::memes-> {snnh} {terminate}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {dcyctpevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
# msipdcabindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {mergestreams}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {program}, $Awfif::memes-> {snnh} {initiate}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {dcycipevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
# msspdcabindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {mergestreams}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {statementcomplete}, $Awfif::memes-> {snnh} {program}, $Awfif::memes-> {snnh} {initiate}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {spdcaevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
# msspdcascbindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {pcell}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {pcell}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {pcell}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {statementcomplete}, $Awfif::memes-> {snnh} {replication}, $Awfif::memes-> {snnh} {initiate}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {spdcascevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
# mse2ftfbindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {mergestreams}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {program}, $Awfif::memes-> {snnh} {transcription}, $Awfif::memes-> {snnh} {factor}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {e2ftfevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
# msprbbindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {mergestreams}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {program}, $Awfif::memes-> {snnh} {pdca}, $Awfif::memes-> {snnh} {change}, $Awfif::memes-> {snnh} {inhibitor}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {prbevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
# msdopdcabindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {mergestreams}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {program}, $Awfif::memes-> {snnh} {do}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {ecycdopevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
# mscheckpdcabindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {mergestreams}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {program}, $Awfif::memes-> {snnh} {check}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {acycchpevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
# msactpdcabindtobis
# setup the binding string for the binder

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {mergestreams}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {program}, $Awfif::memes-> {snnh} {act}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {bcycacpevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
#<!-- start tag inh -->
# msecycbindtotf

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [1], 8, $Awfif::memes-> {currentwsbi});
    &Awfif::addjhltrf ($pconc, $Awfif::memes-> {snnh} {mergestreams}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {program}, $Awfif::memes-> {snnh} {do}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {factor}, $Awfif::memes-> {snnh} {e2ftfevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
# msbcycbindtotf

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [1], 8, $Awfif::memes-> {currentwsbi});
    &Awfif::addjhltrf ($pconc, $Awfif::memes-> {snnh} {mergestreams}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {program}, $Awfif::memes-> {snnh} {act}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {factor}, $Awfif::memes-> {snnh} {e2ftfevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
#<!-- end tag inh -->
#<!-- start tag inh -->
# mscassertbindtotf

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [1], 8, $Awfif::memes-> {currentwsbi});
    &Awfif::addjhltrf ($pconc, $Awfif::memes-> {snnh} {mergestreams}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {case}, $Awfif::memes-> {snnh} {resolved}, $Awfif::memes-> {snnh} {assert}, $Awfif::memes-> {snnh} {true}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {factor}, $Awfif::memes-> {snnh} {e2ftfevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
#<!-- end tag inh -->

Functions

#
sub chstoff1 {# find the transactional state of f1 signalled codelets
    my($myli, $sponsor, $kwp, $kwpr, $sactset, $f1transid, $f1trmgrid, $transtatus, $transid, $stransmgrid, $samesubpid, $reportcaspart, $istrategy)=@_;
    my ($usetrans, $cwsbi, $asponsor, $strategy);

no strict 'refs';
    if (
    (defined ($Awfif::memes-> {chstoff1d}))
    && ($Awfif::memes-> {chstoff1d})
    ){#

      &break ();
      };#if
    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      my ($pr);
      print ("chstoff1 ");
      $pr = $Awfif::codelet-> {l} [$myli] [2];
      print ("myli $myli caller($pr) ");
      };#if

    $cwsbi = $Awfif::memes-> {currentwsbi};
    $Awfif::memes-> {currentwsbi} = $Awfif::codelet-> {l} [$myli] [20];
    $asponsor = awsoadr ($sponsor);
# chstoff1strategy1

    if (defined ($istrategy) ){

      $strategy = $istrategy;
      }#if
    else {

      $strategy = 'bindercs';
      };#else
    if ($Awfif::codelet-> {l} [$myli] [36] == 0) {#sustain the signalled codelets if necessary

      $$f1transid = 0;#must define this for it to be set and returned
      $$f1trmgrid = mapnonsubtotmgrid ($asponsor, $Awfif::memes-> {snnh} {stran}, 0, \$$f1transid);
# need to handle sameas transaction procedure pairs
      if (($$f1trmgrid > 0)
      && (!tralcomp ($myli, $$f1transid))
      ){

        $$transtatus = 0;#find out the status of the transaction

        $usetrans = $$f1transid;
        $$transid = $$f1transid;
        $$stransmgrid = $$f1trmgrid;
        &transalloc ($myli, $Awfif::memes-> {snnh} {cassponsor}, undef(), $$transid, \$$transtatus);
        if (($$transtatus == $Awfif::memes-> {completed})
        && ($Awfif::tral-> {w} [$$f1transid] [1] == $Awfif::memes-> {terminated})
        ) {#terminated transaction

          $usetrans = 0;
          };#if
        }#if
      elsif (($$f1trmgrid > 0)
      && (tralcomp ($myli, $$f1transid))
      ){#the transaction has completed
# free the transaction resources

        $$transtatus = 0;#find out the status of the transaction
        if ((defined ($Awfif::codelet-> {l} [$myli] [35])) && ($Awfif::codelet-> {l} [$myli] [35] != 0) ) {

          if ( (defined ($Awfif::memes-> {chstoff1subpsptrbreak}))
          && ($Awfif::memes-> {chstoff1subpsptrbreak} == $Awfif::codelet-> {l} [$myli] [36])
          ){

            &break();
            };#if
          $$reportcaspart = 't';
          };#if
# reset the transaction info so that proceed with new trasaction

        $$transid = undef();
        $$f1transid = undef();
        $$f1trmgrid = undef();
        $usetrans = 0;
        $$transtatus = $Awfif::memes-> {snnh} {transid};
        }#elsif
      else {#no outstanding signalled codelets to support

        $usetrans = $$f1transid;
        $$transid = undef();
        $$stransmgrid = $$f1trmgrid;
        };#else
      }#if
    else {

      $$transtatus = 0;#find out the status of the transaction
      $usetrans = gettransstate ($myli, $sponsor, $asponsor, $strategy, \$$stransmgrid, \$$transid, \$$transtatus, $$kwp, $kwpr, \@$sactset);
      if (defined ($$transid)) {#remember that found an active transaction
        $$samesubpid = 't';
        };#if
      };#else

    $Awfif::memes-> {currentwsbi} = $cwsbi;
    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      my ($pr);
      if ($Awfif::memes-> {snnih} {$$transtatus} > 0) {
        $pr = $Awfif::memes-> {snnih} {$$transtatus};
        };#if
      print ("chstoff1x f1transid($$f1transid) f1trmgrid($$f1trmgrid) transtatus($pr($$transtatus)) transid($$transid) stransmgrid($$stransmgrid) samesubpid($$samesubpid) reportcaspart($$reportcaspart) ret $usetrans\n");
      };
    return $usetrans
    }# chstoff1
#
#<!-- start tag sss -->
#
sub resstoff1 {# find the transactional state of f1 signalled codelets
    my($myli, $sponsor, $kwp, $kwpr, $sactset, $strategy, $iusetrans, $f1transid, $f1trmgrid, $transtatus, $transid, $stransmgrid, $samesubpid, $reportcaspart, $jhlabeli, $jhlabeloi, $buildoffurg)=@_;
    my ($usetrans, $jhlabeliav, $mswso, $giveup, $cwsbi, $asponsor);

no strict 'refs';
    if (
    (defined ($Awfif::memes-> {resstoffd}))
    && ($Awfif::memes-> {resstoffd})
    ){#

      &break ();
      };#if
    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      my ($pr);
      print ("resstoff1 ");
      $pr = $Awfif::codelet-> {l} [$myli] [2];
      print ("myli $myli caller($pr) sponsor($sponsor) strategy($strategy) iusetrans($iusetrans) f1transid($$f1transid) f1trmgrid($$f1trmgrid) ");
      if ($Awfif::memes-> {snnih} {$$transtatus} > 0) {
        $pr = $Awfif::memes-> {snnih} {$$transtatus};
        };#if
      print ("transtatus($pr($$transtatus)) transid($$transid) stransmgrid($$stransmgrid) samesubpid($$samesubpid) reportcaspart($$reportcaspart) jhlabeli($$jhlabeli) jhlabeloi($$jhlabeloi) ");
      };#if

    $cwsbi = $Awfif::memes-> {currentwsbi};
    $Awfif::memes-> {currentwsbi} = $Awfif::codelet-> {l} [$myli] [20];
    $asponsor = awsoadr ($sponsor);
    $usetrans = $iusetrans;

    if (($$f1trmgrid > 0)
    && (!tralcomp ($myli, $$f1transid))
    ){

      my ($subpid, $casst);#need to support cascade with signal to nucleus
      if ($Awfif::codelet-> {l} [$myli] [36] > 0) {

        $subpid = $Awfif::codelet-> {l} [$myli] [36];
        $$jhlabeli = 0;
        $$jhlabeloi = 0;
        $casst = 'cassuboppi';
        }#if
      else {

        $casst = $strategy;
        $reportcaspart = '';#may have found the sub-transaction is complete but gaps still need the cascade sponsors support
        };#else

      $jhlabeliav = 't';
      $Awfif::memes-> {currentwsbi} = $Awfif::codelet-> {l} [$myli] [20];
      &ilaunchnc ($myli, $mswso, $casst, $Awfif::memes-> {snnh} {cascompsopp}, \$giveup, $kwp, $kwpr, \@$sactset,
        '32,37', #mask out codelet-> {l} [32] i.e. {tfree}
        $usetrans,
        \$$transid,
        \$$transtatus,
        $subpid, #signal sub-program
        \$$jhlabeli,
        \$$jhlabeloi,
        undef (), #newli
        undef (), #hiurg
        undef (), #usepooling
        $buildoffurg #buildoffurg
        );
      }#if
    else {

      &transmgr ($myli, $myli, $Awfif::memes-> {snnh} {update}, $Awfif::memes-> {snnh} {assoctran}, $asponsor, $Awfif::memes-> {snnh} {stran}, 0, 0, $$stransmgrid);
      if ($Awfif::codelet-> {l} [$myli] [36] != 0) {

        &transmgr ($myli, $myli, $Awfif::memes-> {snnh} {remove}, $Awfif::memes-> {snnh} {assocf1}, undef(), $Awfif::memes-> {snnh} {rtran}, undef(), $Awfif::codelet-> {l} [$myli] [36], $$stransmgrid);
        };#if
      };#else
    if ($reportcaspart) {#

      &transalloc ($myli, $Awfif::memes-> {snnh} {casparticipant}, undef(), $Awfif::codelet-> {l} [$myli] [35], \$$transtatus);
      };

    $Awfif::memes-> {currentwsbi} = $cwsbi;
    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      my ($pr);
      if ($Awfif::memes-> {snnih} {$$transtatus} > 0) {
        $pr = $Awfif::memes-> {snnih} {$$transtatus};
        };#if
      print ("resstoff1x f1transid($$f1transid) f1trmgrid($$f1trmgrid) transtatus($pr($$transtatus)) transid($$transid) stransmgrid($$stransmgrid) samesubpid($$samesubpid) reportcaspart($$reportcaspart) jhlabeli($$jhlabeli) jhlabeloi($$jhlabeloi) ret $usetrans\n");
      };
    return $usetrans
    }# resstoff1
#
#<!-- end tag sss -->
#<!-- start tag scl -->
#
sub statementpdca {#
    my($myli, $sti, $kwp, $kwpr, $sactset, $iststrategy)=@_;
    my ($finished, $giveup, $ststrategy);

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("statementpdca myli $myli ");
      };
# updated for merged workspaces
# statementpdca is called within statement codelet
# it uses statement/part model launcher to check if the plan associated with cascade statementpdcal is modelled and described as model-(assert|implement)->plan or stopped,

    if (!defined ($iststrategy) ){

      $ststrategy = 'statementpdcal';
      } #if
    else {

      $ststrategy = $iststrategy;
      };#else

    $finished = ilaunchmodel ($myli, $sti, $ststrategy, $Awfif::memes-> {snnh} {plan}, \$giveup, $kwp, $kwpr, \@$sactset);

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("statementpdcax giveup $giveup ret ($finished)\n");
      };
    return $finished
    }# statementpdca
#
#<!-- end tag scl -->
#<!-- 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
#
#
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
#
sub initpdcaevaluator1 {
    my ($myli, $kwp, $kwpr, $sactset) = @_;#The ignored parameters are required by the codelet calling architecture

    &iinitpdcaevaluator1 ($myli, \$$kwp, $kwpr, \@$sactset, 'initpdcabuilder');
    }# initpdcaevaluator1
#
#
sub iinitpdcaevaluator1 {
    my ($myli, $kwp, $kwpr, $sactset, $strategy, $nostream) = @_;
    my ($sponsor, $signal, $schema, $spi, $swstype, $noswstype, $abdwso, $cwsbi,
    $grkwp, $grkwpr, $cdn, $cdnx);
#
# checked for merged workspaces

# init pdca codelet responds to its signal by initiating the planning phase of the merge stream application
    $cwsbi = $Awfif::memes-> {currentwsbi};
    $noswstype = 't';
    if (getcontext ($myli, \$sponsor, \$signal, \$schema, \$swstype, \$grkwp, \$grkwpr, $noswstype, \$cdn, \$cdnx, 4)) {
      my ($stwso, $astwso, $twso, $asponsor);
      $twso = trwsoadr (fgrpend ($sponsor), 1);
      $asponsor = awsoadr ($sponsor);

# Find the statement wso and obtain any stream descriptions - These should include important streams for development
      $stwso = getmystatement ($myli, $sponsor, $grkwp, $grkwpr);
      $astwso = awsoadr ($stwso);
# if the statement does not have stream descriptions for the builder to work on give up
      if ( (findtdesc ($Awfif::wsol-> {l} [ $astwso] [2], $Awfif::memes-> {snnh} {stream}) != 0)
      or ( (defined ($nostream)) && ($nostream) )
# the builder will need to deal with istream structures too but no point if there is no direct stream they would be described in
# Otherwise need to setup the builder so that it sees the key context wso immediately after the operon starts
      ){#launch builder

        $Awfif::clp = ();
        $Awfif::clp-> {log} = $Awfif::codelet-> {l} [$myli][13];
# initpdcaevalubo1
        if (ifindupri ($myli, $sponsor)
# initpdcaevalubo2
        && (getabdwso ($myli, $sponsor, 'binderp1', \$abdwso))
        && (!findbond ($Awfif::wsol-> {l} [ $abdwso][2], $Awfif::memes-> {snnh} {casbound}, $Awfif::memes-> {snnh} {mergestreams}, $Awfif::memes-> {snnh} {model}))
        ){#

          $Awfif::clp-> {urgency} = ($Awfif::codelet-> {l} [$myli][3] / $Awfif::memes-> {pappbu});
# initpdcaevalubo3
          &dropsalience ($myli, $sponsor);
          }#if
        else {
          $Awfif::clp-> {urgency} = ($Awfif::codelet-> {l} [$myli][3] * $Awfif::memes-> {blaunchm});
          };#else
        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} = $strategy;
        $Awfif::clp-> {action}-> {sponsor} = $sponsor;
        $Awfif::clp-> {action}-> {signal} = $Awfif::codelet-> {l} [$myli][16];
        $Awfif::clp-> {action}-> {schema} = $Awfif::codelet-> {l} [$myli][18];
        $Awfif::clp-> {action}-> {ref} = $spi;
        $Awfif::clp-> {action}-> {sws} = $Awfif::codelet-> {l} [$myli] [20];
        $Awfif::clp-> {action}-> {wss} = $Awfif::codelet-> {l} [$myli][21];
        $Awfif::clp-> {action}-> {wse} = $Awfif::codelet-> {l} [$myli][22]-1;
        $Awfif::clp-> {action}-> {wsoname} = 0;
        &groupsinv1 ($myli, undef(), undef(), undef(), undef(),undef(), $strategy, $$kwp, $kwpr, \@$sactset);
        }
      else {#report error no direct stream found

        my ($awss);
        $awss = awsoadr ($Awfif::codelet-> {l} [$myli][21]);
        $Awfif::wsol-> {l} [$awss][2]
        = setupdesc ( $Awfif::memes-> {snnh} {asopcsp},
            ($Awfif::memes-> {snnh} {wsi} + $Awfif::memes-> {snnh} {error}),
            $Awfif::memes-> {snnh} {initpdcaevaluator},
            $Awfif::wsol-> {l} [$awss] [2],
            $awss);
        };
      };#got buffer
    $Awfif::memes-> {currentwsbi} = $cwsbi;

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("$cdnx\n");
      };
    &clogstatx ();
    }# iinitpdcaevaluator1
#
#<!-- end tag scl -->
#<!-- start tag scs -->
#
sub initpdcabsmodeler1 {
    my ($myli, $kwp, $kwpr, $sactset, $and) = @_;
    my ($salience);
    if ((defined ($kwp))
    && ($kwp == 1)
    ) {
      print ("myli $myli kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) \n");
      };#if

    $salience = $Awfif::memes-> {bnotsalient};
    $$and = 't';
    return $salience
    }# initpdcabsmodeler1
#
#
sub initpdcabuilder1 {
    my ($myli, $kwp, $kwpr, $sactset) = @_;#The ignored parameters are required by the codelet calling architecture

#
#
sub iinitpdcabuilder1 {
    my ($myli, $kwp, $kwpr, $sactset, $deprelative) = @_;
    my ($sponsor, $sponsortype, $signal, $schema, $found, $bcount, $swstype, $noswstype, $cwsbi, $bdwso, $abdwso, $bcexists, $tws,
    $grkwp, $grkwpr, $cdn, $cdnx);
#
# initiate the Shewhart cycle that will include both operation and control codelets

# look for assert binder's workspace

    $cwsbi = $Awfif::memes-> {currentwsbi};
    $found = '';
    $bcount = 0;
    $noswstype = 't';
    $bcexists = '';

# now check the workspace for salient workspace type with model status descriptor
    if (getcontext ($myli, \$sponsor, \$signal, \$schema, \$swstype, \$grkwp, \$grkwpr, $noswstype, \$cdn, \$cdnx, 4)) {
      my ($stwso, $astwso, $giveup);

      $sponsortype = wsbasetype ($sponsor);
# Find the statement wso and obtain the statement's wso type
      $stwso = igetmynowner ($myli, $sponsor, 'bustatement', $grkwp, $grkwpr);
      $astwso = awsoadr ($stwso);

      my ($sigcount, @lomatchs, @lola, @loconcs, @lostrts, @loends, @logb, @loge);
      if ( (!defined ($deprelative)) or (!$deprelative) ){

        $bcount = ifindb ($myli, $stwso, 'pdcab', \$sigcount, \@lomatchs, \@lola, \@loconcs, \@lostrts, \@loends, \@logb, \@loge, $$kwp, $kwpr, \@$sactset, undef(), undef(), undef(), 't');
        if ($bcount <= 0) {#create the pdca binder structure
# initpdcabuildercstb

          my ($buffer);
          $buffer = '';
          $buffer = $buffer . '<pdca><sequence><integration>' . '<transcription><factor><sequence><integration>' . '<inhibitor><sequence><integration>';
          &inewstws ($myli, \$buffer, \$grkwp, $grkwpr, $sponsor);
          };#if

        if ( ifindb ($myli, $stwso, 'pdcab', \$sigcount, \@lomatchs, \@lola, \@loconcs, \@lostrts, \@loends, \@logb, \@loge, $$kwp, $kwpr, \@$sactset) == 1) {

          $bcexists = 't';
          $bdwso = getfbws ($myli, $sigcount, \@lomatchs, \@lola, \$tws);

          };# if find then update binder ws
        }#if deploy absolute
      else {#deploy relative

        my ($pdcawso, $pws, $imemwso);
        $bcount = ifindb ($myli, $stwso, 'imemb', \$sigcount, \@lomatchs, \@lola, \@loconcs, \@lostrts, \@loends, \@logb, \@loge, $$kwp, $kwpr, \@$sactset);
        $imemwso = getfbws ($myli, $sigcount, \@lomatchs, \@lola, \$pws);
# find the pdca binding and issue the control signal
        if ($bcount == 1) {

          $bcount = ifindb ($myli, $stwso, 'pdcab', \$sigcount, \@lomatchs, \@lola, \@loconcs, \@lostrts, \@loends, \@logb, \@loge, $$kwp, $kwpr, \@$sactset, $pws);
          $pdcawso = getstsbws ($myli, $sigcount, \@lomatchs, \@lola, $pws);
          if (($bcount <= 0) ){#add relative pdca area
# initpdcabuilderrcst1

            my ($buffer);
            $buffer = '';
            $buffer = $buffer . '<pdca><sequence><integration>' . '<transcription><factor><sequence><integration>' . '<inhibitor><sequence><integration>';
            &iaddsg ($myli, \$buffer, \$$kwp, $kwpr, $sponsor, $pws);
            };#if
          };#if
        };#else
# initpdcabuilderswdevi
# The builder [mps] signals the nucleus

      $Awfif::memes-> {currentwsbi} = $cwsbi;
      &ilaunchnc ($myli, $stwso, 'pdcasappi', $Awfif::memes-> {snnh} {pdcawhole}, \$giveup, $grkwp, $grkwpr, \@$sactset,
        '32,37', #mask out codelet-> {l} [32] i.e. {tfree}
        undef (), #usetrans
        undef (), #transid
        undef (), #transtatus
        undef (), #subprogram
        undef (), #jhlabeli
        undef (), #jhlabeloi
        undef (), #newli
        undef (), #hiurg
        undef (), #usepooling
        ( (ifindupri ($myli, $sponsor)) && (!(hdescexists ($myli, $tws, $bdwso, $Awfif::memes-> {snnh} {casinit}, $sponsortype))) )#buildoffurg
        );
# need to continue stimulating the pdca activity until signal recipient+sponsor describes taking control
# The description will be deployed into the binder's context structural workspace

      $Awfif::memes-> {currentwsbi} = $tws;
      $abdwso = awsoadr ($bdwso);
      if (
      ($bcexists)
      && (!findbond ($Awfif::wsol-> {l} [ $abdwso][2], $Awfif::memes-> {snnh} {dcyclin}, $Awfif::memes-> {snnh} {operation}, $Awfif::memes-> {snnh} {model})) ){

        my ($sgdi, $gsponsor, $concept, $drefi);
# initpdcabuildertfu
# can't free until loose sponsorship
see statement builder & devbuilder
        $Awfif::memes-> {currentwsbi} = $cwsbi;
        &cascadesponsor ($myli, $sponsor, $Awfif::memes-> {snnh}{cassponsor});
        &fgrpd ($myli, $sponsor, \$sgdi, $Awfif::memes->{snnh}{groupcategory});
        $gsponsor = fgrpsponsor ($sponsor, $Awfif::workspace-> {l} [$sgdi] [3], $Awfif::memes-> {snnh} {groupcategory});
        $Awfif::memes-> {currentwsbi} = $Awfif::codelet-> {l} [$myli] [20];
        ¬gcompleted ($myli, $gsponsor, undef(), 't');
        &findcounter ($Awfif::wsol-> {l} [$astwso][2], ($Awfif::memes-> {snnh}{pdcaprogram}), \$drefi);
        if ($drefi != 0) {
          $concept = ($Awfif::workspace-> {l} [$drefi] [2] - $Awfif::memes-> {snnh}{wsi});
          };#if
        if (($drefi == 0) or ($concept == 0)) {

          $Awfif::wsol-> {l} [$astwso] [2]
          = inccounter ( $Awfif::memes-> {snnh} {initiate}, #shouldn't this be the string since this should be an application pseudo concept
              ($Awfif::memes-> {snnh} {wsi} + wsbasetype ($Awfif::codelet-> {l} [$myli][21])),
              $Awfif::memes-> {snnh} {pdcaprogram},
              $Awfif::wsol-> {l} [$astwso] [2],
              $astwso);
          };#if
        }#re stimulate dev activity
      else {
# must free once loose sponsorship

        &cascadesponsor ($myli, $sponsor, $Awfif::memes-> {snnh}{wascassponsor});
        };#else
      };#got target wso
    $Awfif::memes-> {currentwsbi} = $cwsbi;

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("$cdnx\n");
      };
    &clogstatx ();
    }# iinitpdcabuilder1
#
#<!-- end tag scl -->
#
sub dcyctpevaluator1 {
    my ($myli, $kwp, $kwpr, $sactset) = @_;#The ignored parameters are required by the codelet calling architecture
# cyclins operate a Shewhart cycle in the eucaryotic cell. The dcyclin is supported in awf by a model deployed by dcyctp codelet

    &icsevaluator1 ($myli, \&Awfif::idcyctpevaluator1, 'dcyctpbuilder', $kwp, $kwpr, \@$sactset);
    }# dcyctpevaluator1
#
sub idcyctpevaluator1 {
    my ($myli, $sponsor, $signal, $schema, $swstype, $kwp, $kwpr, $sactset, $noswstype, $fbinderc) = @_;#bsmodeler requires the ignored parameters for its general interface
    my ($dolaunch, $bcount, $pdcawso, $pws, $stwso, $astwso, $twso, $asponsor, $cwsbi,
    $grkwp, $grkwpr);
#
# checked for merged workspaces

    $cwsbi = $Awfif::memes-> {currentwsbi};
    $dolaunch = '';
    $twso = trwsoadr (fgrpend ($sponsor), 1);
    $asponsor = awsoadr ($sponsor);

    $stwso = getmystatement ($myli, $sponsor, $grkwp, $grkwpr);
    $astwso = awsoadr ($stwso);
    my ($sigcount, @lomatchs, @lola, @loconcs, @lostrts, @loends, @logb, @loge, $e2fwso);
    $$fbinderc = ifindb ($myli, $stwso, 'pdcab', \$sigcount, \@lomatchs, \@lola, \@loconcs, \@lostrts, \@loends, \@logb, \@loge, $kwp, $kwpr, \@$sactset);
    $pdcawso = getfbws ($myli, $sigcount, \@lomatchs, \@lola, \$pws);
# find the inhibitor binding
    if ($$fbinderc == 1) {

      $bcount = ifindb ($myli, $stwso, 'e2finhibb', \$sigcount, \@lomatchs, \@lola, \@loconcs, \@lostrts, \@loends, \@logb, \@loge, $kwp, $kwpr, \@$sactset, $pws);
      $e2fwso = getstsbws ($myli, $sigcount, \@lomatchs, \@lola, $pws);
      if (($bcount == 1) #call in the builder
      ){#launch builder
        $dolaunch = 't';
        };#if
      };#if
    $Awfif::memes-> {currentwsbi} = $cwsbi;

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("idcyctpevaluatorx ret ($dolaunch)\n");
      };
    return $dolaunch
    }# idcyctpevaluator1
#
sub dcyctpbsmodeler1 {
    my ($myli, $kwp, $kwpr, $sactset, $and) = @_;
    my ($salience);
# cyclins operate a Shewhart cycle in the eucaryotic cell. The dcyclin is supported in awf by a model deployed by dcyctp codelet

    $salience = ievalbsmodeler1 ($myli, \$$kwp, $kwpr, \@$sactset, \$$and, 'idcyctpevaluator');
    $$and = 't';
    return $salience
    }# dcyctpbsmodeler1
#
sub dcyctpbuilder1 {
    my ($myli, $kwp, $kwpr, $sactset) = @_;#The ignored parameters are required by the codelet calling architecture
    my ($sponsor, $signal, $schema, $found, $bcount, $swstype, $noswstype, $cwsbi, $bcexists, $pdcawso, $pws,
# cyclins operate a Shewhart cycle in the eucaryotic cell. The dcyclin is supported in awf by a model deployed by dcyctp codelet
    $grkwp, $grkwpr, $cdn, $cdnx);
#
# checked for merged workspaces

# look for assert binder's workspace

    $cwsbi = $Awfif::memes-> {currentwsbi};
    $found = '';
    $bcount = 0;
    $noswstype = 't';
    $bcexists = '';

# now check the workspace for salient workspace type with model status descriptor
    if (getcontext ($myli, \$sponsor, \$signal, \$schema, \$swstype, \$grkwp, \$grkwpr, $noswstype, \$cdn, \$cdnx, 3)) {
      my ($stwso, $astwso);

# Find the statement wso and obtain the statement's wso type
      $stwso = igetmynowner ($myli, $sponsor, 'bustatement', $grkwp, $grkwpr);
      $astwso = awsoadr ($stwso);

      my ($sigcount, @lomatchs, @lola, @loconcs, @lostrts, @loends, @logb, @loge, $e2fwso);
      $bcount = ifindb ($myli, $stwso, 'pdcab', \$sigcount, \@lomatchs, \@lola, \@loconcs, \@lostrts, \@loends, \@logb, \@loge, $$kwp, $kwpr, \@$sactset);
      $pdcawso = getfbws ($myli, $sigcount, \@lomatchs, \@lola, \$pws);
# find the inhibitor binding and write the prediction of must have models
      if ($bcount == 1) {

        $bcount = ifindb ($myli, $stwso, 'e2finhibb', \$sigcount, \@lomatchs, \@lola, \@loconcs, \@lostrts, \@loends, \@logb, \@loge, $$kwp, $kwpr, \@$sactset, $pws);
        $e2fwso = getstsbws ($myli, $sigcount, \@lomatchs, \@lola, $pws);
        if ($bcount == 1) {#write prediction

          my ($ae2fwso);
          $Awfif::memes-> {currentwsbi} = $pws;
          $ae2fwso = awsoadr ($e2fwso);
          $Awfif::wsol-> {l} [$ae2fwso][2]
          = setupdesc ( $Awfif::memes-> {snnh} {atp},
              ($Awfif::memes-> {snnh} {wsi} + $Awfif::memes-> {fatp}), #lets start with one
              $Awfif::memes-> {snnh} {model},
              $Awfif::wsol-> {l} [$ae2fwso] [2],
              $ae2fwso);
          $Awfif::wsol-> {l} [$ae2fwso][2]
          = setupdesc ( $Awfif::memes-> {snnh} {deltaatp},
              ($Awfif::memes-> {snnh} {wsi} + 50), #model of benefit of activity
              $Awfif::memes-> {snnh} {model},
              $Awfif::wsol-> {l} [$ae2fwso] [2],
              $ae2fwso);
          $Awfif::wsol-> {l} [$ae2fwso][2]
          = setupdesc ( $Awfif::memes-> {snnh} {costatp},
              ($Awfif::memes-> {snnh} {wsi} + 10), #model of cost of activity
              $Awfif::memes-> {snnh} {model},
              $Awfif::wsol-> {l} [$ae2fwso] [2],
              $ae2fwso);
          $Awfif::wsol-> {l} [$ae2fwso][2]
          = setupdesc ( $Awfif::memes-> {snnh} {schema},
              ($Awfif::jhls-> {l} [$Awfif::codelet-> {l} [$myli] [23] ] [6]), #pseudo concept
              $Awfif::memes-> {snnh} {model},
              $Awfif::wsol-> {l} [$ae2fwso] [2],
              $ae2fwso);
          };#if
        };#if
      };#got target wso

    $Awfif::memes-> {currentwsbi} = $cwsbi;
    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("$cdnx\n");
      };
    &clogstatx ();
    }# dcyctpbuilder1
#
sub dcycipevaluator1 {
    my ($myli, $kwp, $kwpr, $sactset) = @_;#The ignored parameters are required by the codelet calling architecture
# cyclins operate a Shewhart cycle in the eucaryotic cell. The dcyclin signals entry to a new planning phase

    &icsevaluator1 ($myli, \&Awfif::idcycipevaluator1, 'dcycipbuilder', $kwp, $kwpr, \@$sactset);
    }# dcycipevaluator1
#
sub idcycipevaluator1 {
    my ($myli, $sponsor, $signal, $schema, $swstype, $kwp, $kwpr, $sactset, $noswstype, $fbinderc) = @_;#bsmodeler requires the ignored parameters for its general interface
    my ($dolaunch, $bcount, $pdcawso, $pws, $stwso, $astwso, $twso, $asponsor, $cwsbi,
    $grkwp, $grkwpr);
# cyclins operate a Shewhart cycle in the eucaryotic cell. The dcyclin signals entry to a new planning phase
#
# checked for merged workspaces

    $cwsbi = $Awfif::memes-> {currentwsbi};
    $dolaunch = '';
    $twso = trwsoadr (fgrpend ($sponsor), 1);
    $asponsor = awsoadr ($sponsor);

    $stwso = getmystatement ($myli, $sponsor, $grkwp, $grkwpr);
    $astwso = awsoadr ($stwso);
    my ($sigcount, @lomatchs, @lola, @loconcs, @lostrts, @loends, @logb, @loge, $e2fwso);
    $$fbinderc = ifindb ($myli, $stwso, 'pdcab', \$sigcount, \@lomatchs, \@lola, \@loconcs, \@lostrts, \@loends, \@logb, \@loge, $kwp, $kwpr, \@$sactset);
    $pdcawso = getfbws ($myli, $sigcount, \@lomatchs, \@lola, \$pws);
# find the inhibitor binding
    if ($$fbinderc == 1) {

      $bcount = ifindb ($myli, $stwso, 'e2finhibb', \$sigcount, \@lomatchs, \@lola, \@loconcs, \@lostrts, \@loends, \@logb, \@loge, $kwp, $kwpr, \@$sactset, $pws);
      $e2fwso = getstsbws ($myli, $sigcount, \@lomatchs, \@lola, $pws);
      if (($bcount == 1) #call in the builder
      ){#launch builder
        $dolaunch = 't';
        };#if
      };#if
    $Awfif::memes-> {currentwsbi} = $cwsbi;

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("idcycipevaluatorx ret ($dolaunch)\n");
      };
    return $dolaunch
    }# idcycipevaluator1
#
sub dcycipbsmodeler1 {
    my ($myli, $kwp, $kwpr, $sactset, $and) = @_;
    my ($salience);
# cyclins operate a Shewhart cycle in the eucaryotic cell. The dcyclin signals entry to a new planning phase

    $salience = ievalbsmodeler1 ($myli, \$$kwp, $kwpr, \@$sactset, \$$and, 'idcycipevaluator');
    $$and = 't';
    return $salience
    }# dcycipbsmodeler1
#
sub dcycipbuilder1 {
    my ($myli, $kwp, $kwpr, $sactset) = @_;#The ignored parameters are required by the codelet calling architecture
    my ($sponsor, $signal, $schema, $found, $bcount, $swstype, $noswstype, $cwsbi, $bcexists, $pdcawso, $pws,
    $grkwp, $grkwpr, $cdn, $cdnx);
      my ($usetrans, $f1transid, $f1trmgrid, $transtatus, $transid, $stransmgrid, $samesubpid, $reportcaspart, $jhlabeli, $jhlabeloi);
# cyclins operate a Shewhart cycle in the eucaryotic cell. The dcyclin signals entry to a new planning phase
#
# checked for merged workspaces

# look for assert binder's workspace

    $cwsbi = $Awfif::memes-> {currentwsbi};
    $found = '';
    $bcount = 0;
    $noswstype = 't';
    $bcexists = '';

# now check the workspace for salient workspace type with model status descriptor
    if (getcontext ($myli, \$sponsor, \$signal, \$schema, \$swstype, \$grkwp, \$grkwpr, $noswstype, \$cdn, \$cdnx, 3)) {
      my ($stwso, $astwso);

# Find the statement wso and obtain the statement's wso type
      $stwso = igetmynowner ($myli, $sponsor, 'bustatement', $grkwp, $grkwpr);
      $astwso = awsoadr ($stwso);
      $usetrans = chstoff1 ($myli, $sponsor, $kwp, $kwpr, \@$sactset, \$f1transid, \$f1trmgrid, \$transtatus, \$transid, \$stransmgrid, \$samesubpid, \$reportcaspart);

      my ($sigcount, @lomatchs, @lola, @loconcs, @lostrts, @loends, @logb, @loge, $e2fwso);
      $bcount = ifindb ($myli, $stwso, 'pdcab', \$sigcount, \@lomatchs, \@lola, \@loconcs, \@lostrts, \@loends, \@logb, \@loge, $$kwp, $kwpr, \@$sactset);
      $pdcawso = getfbws ($myli, $sigcount, \@lomatchs, \@lola, \$pws);
# find the inhibitor binding and check if there is an a cyclin generated inhibitor
      if ($bcount == 1) {

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

          my ($ae2fwso, $aid, $counteri, $giveup);
          $Awfif::memes-> {currentwsbi} = $pws;
          $ae2fwso = awsoadr ($e2fwso);
# if no inhibitor is found then signal the e-cyclin
          if ( (!($aid = findcounter ($Awfif::wsol-> {l} [$ae2fwso][2], ($Awfif::memes-> {snnh} {inhibitor}), \$counteri, $Awfif::memes-> {snnh} {acyclin})))
          ){#no inhibitor so signal the e-cyclin

            if ( (!(findcounter ($Awfif::wsol-> {l} [$ae2fwso][2], ($Awfif::memes-> {snnh} {inhibitor}), \$counteri, $Awfif::memes-> {snnh} {dcyclin})))
            ){

              $Awfif::wsol-> {l} [$ae2fwso][2]
              = inccounter ( 0,
                  ($Awfif::memes-> {snnh} {wsi} + $Awfif::memes-> {snnh} {dcyclin}), #lets start with one
                  $Awfif::memes-> {snnh} {inhibitor},
                  $Awfif::wsol-> {l} [$ae2fwso] [2],
                  $ae2fwso,
                  undef (),
                  0,
                  $Awfif::memes-> {snnh} {dcyclin});
              };#if
            $Awfif::memes-> {currentwsbi} = $Awfif::codelet-> {l} [$myli] [20];
            &ilaunchnc ($myli, $stwso, 'ecyclino', $Awfif::memes-> {snnh} {dcyclin}, \$giveup, $grkwp, $grkwpr, \@$sactset,
              '32,37', #mask out codelet-> {l} [32] i.e. {tfree}
              $usetrans,
              \$transid,
              \$transtatus,
              $Awfif::codelet-> {l} [$myli][36],
              \$jhlabeli,
              \$jhlabeloi
              );
            };#if no inhibitor
          };#if
        };#if
      };#got target wso

    $Awfif::memes-> {currentwsbi} = $cwsbi;
    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("$cdnx\n");
      };
    &clogstatx ();
    }# dcycipbuilder1
#
sub ecycdopevaluator1 {
    my ($myli, $kwp, $kwpr, $sactset) = @_;#The ignored parameters are required by the codelet calling architecture
# cyclins operate a Shewhart cycle in the eucaryotic cell. The ecyclin signals entry to a do phase

    &icsevaluator1 ($myli, \&Awfif::iecycdopevaluator1, 'ecycdopbuilder', $kwp, $kwpr, \@$sactset);
    }# ecycdopevaluator1
#
sub iecycdopevaluator1 {
    my ($myli, $sponsor, $signal, $schema, $swstype, $kwp, $kwpr, $sactset, $noswstype, $fbinderc) = @_;#bsmodeler requires the ignored parameters for its general interface
    my ($dolaunch, $bcount, $pdcawso, $pws, $stwso, $astwso, $twso, $asponsor, $cwsbi,
    $grkwp, $grkwpr);
#
# cyclins operate a Shewhart cycle in the eucaryotic cell. The ecyclin signals entry to a do phase
# checked for merged workspaces

    $cwsbi = $Awfif::memes-> {currentwsbi};
    $dolaunch = '';
    $twso = trwsoadr (fgrpend ($sponsor), 1);
    $asponsor = awsoadr ($sponsor);

    $stwso = getmystatement ($myli, $sponsor, $grkwp, $grkwpr);
    $astwso = awsoadr ($stwso);
    my ($sigcount, @lomatchs, @lola, @loconcs, @lostrts, @loends, @logb, @loge, $e2fwso);
    $$fbinderc = ifindb ($myli, $stwso, 'pdcab', \$sigcount, \@lomatchs, \@lola, \@loconcs, \@lostrts, \@loends, \@logb, \@loge, $kwp, $kwpr, \@$sactset);
    $pdcawso = getfbws ($myli, $sigcount, \@lomatchs, \@lola, \$pws);
# find the inhibitor binding
    if ($$fbinderc == 1) {

      $bcount = ifindb ($myli, $stwso, 'e2finhibb', \$sigcount, \@lomatchs, \@lola, \@loconcs, \@lostrts, \@loends, \@logb, \@loge, $kwp, $kwpr, \@$sactset, $pws);
      $e2fwso = getstsbws ($myli, $sigcount, \@lomatchs, \@lola, $pws);
      if (($bcount == 1) #call in the builder
      ){#launch builder
        $dolaunch = 't';
        };#if
      };#if
    $Awfif::memes-> {currentwsbi} = $cwsbi;

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("iecycdopevaluatorx ret ($dolaunch)\n");
      };
    return $dolaunch
    }# iecycdopevaluator1
#
sub ecycdopbsmodeler1 {
    my ($myli, $kwp, $kwpr, $sactset, $and) = @_;
    my ($salience);
# cyclins operate a Shewhart cycle in the eucaryotic cell. The ecyclin signals entry to a do phase

    $salience = ievalbsmodeler1 ($myli, \$$kwp, $kwpr, \@$sactset, \$$and, 'iecycdopevaluator');
    $$and = 't';
    return $salience
    }# ecycdopbsmodeler1
#
sub ecycdopbuilder1 {
    my ($myli, $kwp, $kwpr, $sactset) = @_;#The ignored parameters are required by the codelet calling architecture
    my ($sponsor, $asponsor, $signal, $schema, $found, $bcount, $swstype, $noswstype, $cwsbi, $bcexists, $pdcawso, $pws,
    $grkwp, $grkwpr, $cdn, $cdnx);
#
# cyclins operate a Shewhart cycle in the eucaryotic cell. The ecyclin signals entry to a do phase
# checked for merged workspaces

    $cwsbi = $Awfif::memes-> {currentwsbi};
    $found = '';
    $bcount = 0;
    $noswstype = 't';
    $bcexists = '';

    if (getcontext ($myli, \$sponsor, \$signal, \$schema, \$swstype, \$grkwp, \$grkwpr, $noswstype, \$cdn, \$cdnx, 3)) {
      my ($stwso, $astwso, $giveup);
      my ($atelhwso, $usetrans, $f1transid, $f1trmgrid, $transtatus, $transid, $stransmgrid, $samesubpid, $reportcaspart, $jhlabeli, $jhlabeloi);

      $Awfif::memes-> {currentwsbi} = $Awfif::codelet-> {l} [$myli] [20];
      $atelhwso = awsoadr (trwsoadr ($sponsor,-1));
      $asponsor = awsoadr ($sponsor);
# Find the statement wso and obtain the statement's wso type
      $stwso = igetmynowner ($myli, $sponsor, 'bustatement', $grkwp, $grkwpr);
      $astwso = awsoadr ($stwso);
      $usetrans = chstoff1 ($myli, $sponsor, $kwp, $kwpr, \@$sactset, \$f1transid, \$f1trmgrid, \$transtatus, \$transid, \$stransmgrid, \$samesubpid, \$reportcaspart);

      my ($sigcount, @lomatchs, @lola, @loconcs, @lostrts, @loends, @logb, @loge, $e2fwso, $e2ftwso);
      $bcount = ifindb ($myli, $stwso, 'pdcab', \$sigcount, \@lomatchs, \@lola, \@loconcs, \@lostrts, \@loends, \@logb, \@loge, $$kwp, $kwpr, \@$sactset);
      $pdcawso = getfbws ($myli, $sigcount, \@lomatchs, \@lola, \$pws);
# find the inhibitor binding
      if ($bcount == 1) {

        my ($ae2fwso, $ae2ftwso, $counteri, $factor, $codeletdef);
        $bcount = ifindb ($myli, $stwso, 'e2finhibb', \$sigcount, \@lomatchs, \@lola, \@loconcs, \@lostrts, \@loends, \@logb, \@loge, $$kwp, $kwpr, \@$sactset, $pws);
        $e2fwso = getstsbws ($myli, $sigcount, \@lomatchs, \@lola, $pws);
        &ictficomp ($myli, $Awfif::codelet-> {l} [$myli] [23], $kwp, $kwpr, \@$sactset, \$found, \$factor, \$e2ftwso, \$pws);
        $Awfif::memes-> {currentwsbi} = $pws;
        $ae2fwso = awsoadr ($e2fwso);
        $ae2ftwso = awsoadr ($e2ftwso);
        if (($bcount == 1)
        && ((!findcounter ($Awfif::wsol-> {l} [$ae2fwso][2], ($Awfif::memes-> {snnh} {pdcaprogram}), \$counteri, $Awfif::memes-> {snnh} {ecyclin})))
        && ((!findcounter ($Awfif::wsol-> {l} [$ae2fwso][2], ($Awfif::memes-> {snnh} {cwaitondesc}), \$counteri, $Awfif::memes-> {snnh} {ecyclin})))
        ){#Transition the cycle phase

# remove the prb inhibitor descriptor
          &maskcounter ($Awfif::memes-> {snnh} {inhibition}, $ae2fwso, $Awfif::memes-> {snnh} {prbevaluator});
# remove a cyclin codelet inhibition (dcyclin inhibitor counter written by d cyclin codelet)
          &maskcounter ($Awfif::memes-> {snnh} {inhibitor}, $ae2fwso, $Awfif::memes-> {snnh} {dcyclin});
# remove b cyclin prbi

          &maskcounter ($Awfif::memes-> {snnh} {pdcaprogam}, $ae2fwso, $Awfif::memes-> {snnh} {bcyclin});
# get any transcription factor wso descriptor and remove it if present
          &masktfdesc ($myli, $Awfif::codelet-> {l} [$myli] [23], $kwp, $kwpr, \@$sactset, \$ae2ftwso, \$factor);
# deploy the e descriptor which will be removed later in the cycle by a b cyclin

          $Awfif::wsol-> {l} [$ae2fwso][2]
          = inccounter ( $Awfif::memes-> {snnh} {complete},
              ($Awfif::memes-> {snnh} {wsi} + $Awfif::memes-> {snnh} {ecyclin}), #lets start with one
              $Awfif::memes-> {snnh} {pdcaprogram},
              $Awfif::wsol-> {l} [$ae2fwso] [2],
              $ae2fwso,
              undef (),
              $Awfif::memes-> {snnh} {complete},
              $Awfif::memes-> {snnh} {ecyclin});
# ecycbwe2fu1
# while there is no e2fdescriptor wait for one
          if (!(findcounter ($Awfif::wsol-> {l} [$ae2ftwso][2], $Awfif::memes-> {snnh} {tfactor}, \$counteri, $Awfif::memes-> {snnh} {$factor}))
          ){#wait

            &waitondesc ($myli, $ae2ftwso, ($Awfif::memes-> {snnh} {$factor} + $Awfif::memes-> {snnh} {wsi}), $Awfif::memes-> {snnh} {complete}, $Awfif::memes-> {snnh} {tfactor}, undef(), undef(), undef(), undef(), \$codeletdef);
# record the waited codelets existance
            $Awfif::wsol-> {l} [$ae2fwso][2]
            = inccounter ( $Awfif::memes-> {snnh} {ecyclin},
                ($Awfif::memes-> {snnh} {wsi} + $codeletdef), #lets start with one
                $Awfif::memes-> {snnh} {cwaitondesc},
                $Awfif::wsol-> {l} [$ae2fwso] [2],
                $ae2fwso,
                undef (),
                $Awfif::memes-> {snnh} {ecyclin},
                $Awfif::memes-> {snnh} {$codeletdef});
# remove any transaction sponsorship
            if ($Awfif::codelet-> {l} [$myli] [35] > 0) {#

              &transalloc ($myli, $Awfif::memes-> {snnh} {casparticipant}, undef(), $Awfif::codelet-> {l} [$myli] [35], \$$transtatus);
              };#if
            }
          else {#proceed
            $Awfif::memes-> {currentwsbi} = $Awfif::codelet-> {l} [$myli][20];

            $transtatus = 0;#must be defined to be set in ilaunchnc
            &ilaunchnc ($myli, $stwso, 'acyclino', $Awfif::memes-> {snnh} {ecyclin}, \$giveup, $grkwp, $grkwpr, \@$sactset,
              '32,37', #mask out codelet-> {l} [32] i.e. {tfree}
              $usetrans,
              \$transid,
              \$transtatus,
              $Awfif::codelet-> {l} [$myli][36],
              \$jhlabeli,
              \$jhlabeloi
              );
            &transmgr ($myli, $myli, $Awfif::memes-> {snnh} {update}, $Awfif::memes-> {snnh} {assoctran}, $asponsor, $Awfif::memes-> {snnh} {stran}, $transid, $Awfif::codelet-> {l} [$myli] [36], $stransmgrid);
            if ($Awfif::codelet-> {l} [$myli] [36] != 0) {

              &transmgr ($myli, $myli, $Awfif::memes-> {snnh} {add}, $Awfif::memes-> {snnh} {assocf1}, $atelhwso, $Awfif::memes-> {snnh} {rtran}, undef(), $Awfif::codelet-> {l} [$myli] [36], $Awfif::codelet-> {l} [$myli] [37], $Awfif::codelet-> {l} [$myli] [36]);
              };#if
            };#else proceed
          }#if
        elsif (($bcount == 1)
        &&(findcounter ($Awfif::wsol-> {l} [$ae2ftwso][2], $Awfif::memes-> {snnh} {tfactor}, \$counteri, $Awfif::memes-> {snnh} {$factor}))
        ){#waitondesc completed
          $Awfif::memes-> {currentwsbi} = $Awfif::codelet-> {l} [$myli][20];

          &maskcounter ($Awfif::memes-> {snnh} {cwaitondesc}, $ae2fwso, $Awfif::memes-> {snnh} {ecyclin});
          $transtatus = 0;#must be defined to be set in ilaunchnc
          &ilaunchnc ($myli, $stwso, 'acyclino', $Awfif::memes-> {snnh} {ecyclin}, \$giveup, $grkwp, $grkwpr, \@$sactset,
            '32,37', #mask out codelet-> {l} [32] i.e. {tfree}
            $usetrans,
            \$transid,
            \$transtatus,
            $Awfif::codelet-> {l} [$myli][36],
            \$jhlabeli,
            \$jhlabeloi
            );
          &transmgr ($myli, $myli, $Awfif::memes-> {snnh} {update}, $Awfif::memes-> {snnh} {assoctran}, $asponsor, $Awfif::memes-> {snnh} {stran}, $transid, $Awfif::codelet-> {l} [$myli] [36], $stransmgrid);
          if ($Awfif::codelet-> {l} [$myli] [36] != 0) {

            &transmgr ($myli, $myli, $Awfif::memes-> {snnh} {add}, $Awfif::memes-> {snnh} {assocf1}, $atelhwso, $Awfif::memes-> {snnh} {rtran}, undef(), $Awfif::codelet-> {l} [$myli] [36], $Awfif::codelet-> {l} [$myli] [37], $Awfif::codelet-> {l} [$myli] [36]);
            };#if
          }#elsif
        elsif ($usetrans > 0) {

          $usetrans = resstoff1 ($myli, $sponsor, $kwp, $kwpr, \@$sactset, 'acyclino', $usetrans, \$f1transid, \$f1trmgrid, \$transtatus, \$transid, \$stransmgrid, \$samesubpid, \$reportcaspart, \$jhlabeli, $jhlabeloi);
          };#elsif
# ecycbngcu1
        if (($transtatus == $Awfif::memes-> {snnh} {incomplete})
        ){

          my ($sgdi, $gsponsor);
          $Awfif::memes-> {currentwsbi} = $Awfif::codelet-> {l} [$myli] [20];
          &fgrpd ($myli, $sponsor, \$sgdi, $Awfif::memes->{snnh}{groupcategory});
          $gsponsor = fgrpsponsor ($sponsor, $Awfif::workspace-> {l} [$sgdi] [3], $Awfif::memes-> {snnh} {groupcategory});
          ¬gcompleted ($myli, $gsponsor, undef(), 't', undef (), undef(),);
          };#if
        };#if
      };#got target wso

    $Awfif::memes-> {currentwsbi} = $cwsbi;
    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("$cdnx\n");
      };
    &clogstatx ();
    }# ecycdopbuilder1
#
sub acycchpevaluator1 {
    my ($myli, $kwp, $kwpr, $sactset) = @_;#The ignored parameters are required by the codelet calling architecture
# cyclins operate a Shewhart cycle in the eucaryotic cell. The acyclin signals entry to a check phase

    &icsevaluator1 ($myli, \&Awfif::iacycchpevaluator1, 'acycchpbuilder', $kwp, $kwpr, \@$sactset);
    }# acycchevaluator1
#
sub iacycchpevaluator1 {
    my ($myli, $sponsor, $signal, $schema, $swstype, $kwp, $kwpr, $sactset, $noswstype, $fbinderc) = @_;#bsmodeler requires the ignored parameters for its general interface
    my ($dolaunch, $bcount, $pdcawso, $pws, $stwso, $astwso, $twso, $asponsor, $cwsbi,
    $grkwp, $grkwpr);
#
# cyclins operate a Shewhart cycle in the eucaryotic cell. The acyclin signals entry to a check phase
# checked for merged workspaces

    $cwsbi = $Awfif::memes-> {currentwsbi};
    $dolaunch = '';
    $twso = trwsoadr (fgrpend ($sponsor), 1);
    $asponsor = awsoadr ($sponsor);

    $stwso = getmystatement ($myli, $sponsor, $grkwp, $grkwpr);
    $astwso = awsoadr ($stwso);
    my ($sigcount, @lomatchs, @lola, @loconcs, @lostrts, @loends, @logb, @loge, $e2fwso);
    $$fbinderc = ifindb ($myli, $stwso, 'pdcab', \$sigcount, \@lomatchs, \@lola, \@loconcs, \@lostrts, \@loends, \@logb, \@loge, $kwp, $kwpr, \@$sactset);
    $pdcawso = getfbws ($myli, $sigcount, \@lomatchs, \@lola, \$pws);
# find the inhibitor binding
    if ($$fbinderc == 1) {

      $bcount = ifindb ($myli, $stwso, 'e2finhibb', \$sigcount, \@lomatchs, \@lola, \@loconcs, \@lostrts, \@loends, \@logb, \@loge, $kwp, $kwpr, \@$sactset, $pws);
      $e2fwso = getstsbws ($myli, $sigcount, \@lomatchs, \@lola, $pws);
      if (($bcount == 1) #call in the builder
      ){#launch builder
        $dolaunch = 't';
        };#if
      };#if
    $Awfif::memes-> {currentwsbi} = $cwsbi;

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("iacycchpevaluatorx ret ($dolaunch)\n");
      };
    return $dolaunch
    }# iacycchpevaluator1
#
sub acycchpbsmodeler1 {
    my ($myli, $kwp, $kwpr, $sactset, $and) = @_;
    my ($salience);
# cyclins operate a Shewhart cycle in the eucaryotic cell. The acyclin signals entry to a check phase

    $salience = ievalbsmodeler1 ($myli, \$$kwp, $kwpr, \@$sactset, \$$and, 'iacycchpevaluator');
    $$and = 't';
    return $salience
    }# acycchpbsmodeler1
#
sub acycchpbuilder1 {
    my ($myli, $kwp, $kwpr, $sactset) = @_;#The ignored parameters are required by the codelet calling architecture
    my ($sponsor, $asponsor, $signal, $schema, $found, $bcount, $swstype, $noswstype, $cwsbi, $bcexists, $pdcawso, $pws,
    $grkwp, $grkwpr, $cdn, $cdnx);
#
# cyclins operate a Shewhart cycle in the eucaryotic cell. The acyclin signals entry to a check phase
# checked for merged workspaces

# look for assert binder's workspace

    $cwsbi = $Awfif::memes-> {currentwsbi};
    $found = '';
    $bcount = 0;
    $noswstype = 't';
    $bcexists = '';

    if (getcontext ($myli, \$sponsor, \$signal, \$schema, \$swstype, \$grkwp, \$grkwpr, $noswstype, \$cdn, \$cdnx, 3)) {
      my ($stwso, $astwso);
      my ($atelhwso, $usetrans, $f1transid, $f1trmgrid, $transtatus, $transid, $stransmgrid, $samesubpid, $reportcaspart, $jhlabeli, $jhlabeloi);

      $Awfif::memes-> {currentwsbi} = $Awfif::codelet-> {l} [$myli] [20];
      $atelhwso = awsoadr (trwsoadr ($sponsor,-1));
      $asponsor = awsoadr ($sponsor);
# Find the statement wso and obtain the statement's wso type
      $stwso = igetmynowner ($myli, $sponsor, 'bustatement', $grkwp, $grkwpr);
      $astwso = awsoadr ($stwso);
      $usetrans = chstoff1 ($myli, $sponsor, $kwp, $kwpr, \@$sactset, \$f1transid, \$f1trmgrid, \$transtatus, \$transid, \$stransmgrid, \$samesubpid, \$reportcaspart);

      my ($sigcount, @lomatchs, @lola, @loconcs, @lostrts, @loends, @logb, @loge, $e2fwso);
      $bcount = ifindb ($myli, $stwso, 'pdcab', \$sigcount, \@lomatchs, \@lola, \@loconcs, \@lostrts, \@loends, \@logb, \@loge, $$kwp, $kwpr, \@$sactset);
      $pdcawso = getfbws ($myli, $sigcount, \@lomatchs, \@lola, \$pws);
# find the inhibitor binding and check if there is a d or a cyclin generated inhibitor - if so don't run
      if ($bcount == 1) {

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

          my ($ae2fwso, $aid, $counteri, $giveup);
# acycbwe2fu1
# if there is no e2fdescriptor then wait for one
          $Awfif::memes-> {currentwsbi} = $pws;
          $ae2fwso = awsoadr ($e2fwso);
# if no inhibitor is found then signal the b-cyclin
          if ( (!($aid = findcounter ($Awfif::wsol-> {l} [$ae2fwso][2], ($Awfif::memes-> {snnh} {inhibitor}), \$counteri, $Awfif::memes-> {snnh} {dcyclin})))
          ){#no inhibitor so lock out the d cyclin and signal the b-cyclin
            if ( (!(findcounter ($Awfif::wsol-> {l} [$ae2fwso][2], ($Awfif::memes-> {snnh} {inhibitor}), \$counteri, $Awfif::memes-> {snnh} {acyclin})))
            ){
              $Awfif::wsol-> {l} [$ae2fwso][2]
              = inccounter ( 0,
                  ($Awfif::memes-> {snnh} {wsi} + $Awfif::memes-> {snnh} {acyclin}), #lets start with one
                  $Awfif::memes-> {snnh} {inhibitor},
                  $Awfif::wsol-> {l} [$ae2fwso] [2],
                  $ae2fwso,
                  undef (),
                  0,
                  $Awfif::memes-> {snnh} {acyclin});
              };#if

            $Awfif::memes-> {currentwsbi} = $Awfif::codelet-> {l} [$myli] [20];
            $transtatus = 0;#must be defined to be set in ilaunchnc
            &ilaunchnc ($myli, $stwso, 'bcyclino', $Awfif::memes-> {snnh} {dcyclin}, \$giveup, $grkwp, $grkwpr, \@$sactset,
              '32,37', #mask out codelet-> {l} [32] i.e. {tfree}
              $usetrans,
              \$transid,
              \$transtatus,
              $Awfif::codelet-> {l} [$myli][36],
              \$jhlabeli,
              \$jhlabeloi
              );
            &transmgr ($myli, $myli, $Awfif::memes-> {snnh} {update}, $Awfif::memes-> {snnh} {assoctran}, $asponsor, $Awfif::memes-> {snnh} {stran}, $transid, $Awfif::codelet-> {l} [$myli] [36], $stransmgrid);
            if ($Awfif::codelet-> {l} [$myli] [36] != 0) {

              &transmgr ($myli, $myli, $Awfif::memes-> {snnh} {add}, $Awfif::memes-> {snnh} {assocf1}, $atelhwso, $Awfif::memes-> {snnh} {rtran}, undef(), $Awfif::codelet-> {l} [$myli] [36], $Awfif::codelet-> {l} [$myli] [37], $Awfif::codelet-> {l} [$myli] [36]);
              };#if
            }#if no inhibitor
          elsif ($usetrans > 0) {

            $usetrans = resstoff1 ($myli, $sponsor, $kwp, $kwpr, \@$sactset, 'acyclino', $usetrans, \$f1transid, \$f1trmgrid, \$transtatus, \$transid, \$stransmgrid, \$samesubpid, \$reportcaspart, \$jhlabeli, $jhlabeloi);
            };
# acycbngcu1
          if (($transtatus == $Awfif::memes-> {snnh} {incomplete})
          ){

            my ($sgdi, $gsponsor);
            $Awfif::memes-> {currentwsbi} = $Awfif::codelet-> {l} [$myli] [20];
            &fgrpd ($myli, $sponsor, \$sgdi, $Awfif::memes->{snnh}{groupcategory});
            $gsponsor = fgrpsponsor ($sponsor, $Awfif::workspace-> {l} [$sgdi] [3], $Awfif::memes-> {snnh} {groupcategory});
            ¬gcompleted ($myli, $gsponsor, undef(), 't', undef (), undef(),);
            };#if
          };#if
        };#if
      };#got target wso

    $Awfif::memes-> {currentwsbi} = $cwsbi;
    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("$cdnx\n");
      };
    &clogstatx ();
    }# acycchpbuilder1
#
sub bcycacpevaluator1 {
    my ($myli, $kwp, $kwpr, $sactset) = @_;#The ignored parameters are required by the codelet calling architecture
# cyclins operate a Shewhart cycle in the eucaryotic cell. The bcyclin signals entry to an act phase

    &icsevaluator1 ($myli, \&Awfif::ibcycacpevaluator1, 'bcycacpbuilder', $kwp, $kwpr, \@$sactset);
    }# bcycacevaluator1
#
sub ibcycacpevaluator1 {
    my ($myli, $sponsor, $signal, $schema, $swstype, $kwp, $kwpr, $sactset, $noswstype, $fbinderc) = @_;#bsmodeler requires the ignored parameters for its general interface
    my ($dolaunch, $bcount, $pdcawso, $pws, $stwso, $astwso, $twso, $asponsor, $cwsbi,
    $grkwp, $grkwpr);
#
# cyclins operate a Shewhart cycle in the eucaryotic cell. The bcyclin signals entry to an act phase
# checked for merged workspaces

    $cwsbi = $Awfif::memes-> {currentwsbi};
    $dolaunch = '';
    $twso = trwsoadr (fgrpend ($sponsor), 1);
    $asponsor = awsoadr ($sponsor);

    $stwso = getmystatement ($myli, $sponsor, $grkwp, $grkwpr);
    $astwso = awsoadr ($stwso);
    my ($sigcount, @lomatchs, @lola, @loconcs, @lostrts, @loends, @logb, @loge, $e2fwso);
    $$fbinderc = ifindb ($myli, $stwso, 'pdcab', \$sigcount, \@lomatchs, \@lola, \@loconcs, \@lostrts, \@loends, \@logb, \@loge, $kwp, $kwpr, \@$sactset);
    $pdcawso = getfbws ($myli, $sigcount, \@lomatchs, \@lola, \$pws);
# find the inhibitor binding
    if ($$fbinderc == 1) {

      $bcount = ifindb ($myli, $stwso, 'e2finhibb', \$sigcount, \@lomatchs, \@lola, \@loconcs, \@lostrts, \@loends, \@logb, \@loge, $kwp, $kwpr, \@$sactset, $pws);
      $e2fwso = getstsbws ($myli, $sigcount, \@lomatchs, \@lola, $pws);
      if (($bcount == 1) #call in the builder
      ){#launch builder
        $dolaunch = 't';
        };#if
      };#if
    $Awfif::memes-> {currentwsbi} = $cwsbi;

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("ibcycacpevaluatorx ret ($dolaunch)\n");
      };
    return $dolaunch
    }# ibcycacpevaluator1
#
sub bcycacpbsmodeler1 {
    my ($myli, $kwp, $kwpr, $sactset, $and) = @_;
    my ($salience);
# cyclins operate a Shewhart cycle in the eucaryotic cell. The bcyclin signals entry to an act phase

    $salience = ievalbsmodeler1 ($myli, \$$kwp, $kwpr, \@$sactset, \$$and, 'ibcycacpevaluator');
    $$and = 't';
    return $salience
    }# bcycacpbsmodeler1
#
sub bcycacpbuilder1 {
    my ($myli, $kwp, $kwpr, $sactset) = @_;#The ignored parameters are required by the codelet calling architecture
    my ($sponsor, $asponsor, $signal, $schema, $found, $bcount, $swstype, $noswstype, $cwsbi, $bcexists, $pdcawso, $pws,
    $grkwp, $grkwpr, $cdn, $cdnx);
#
# cyclins operate a Shewhart cycle in the eucaryotic cell. The bcyclin signals entry to an act phase
# checked for merged workspaces

# look for assert binder's workspace

    $cwsbi = $Awfif::memes-> {currentwsbi};
    $found = '';
    $bcount = 0;
    $noswstype = 't';
    $bcexists = '';

    if (getcontext ($myli, \$sponsor, \$signal, \$schema, \$swstype, \$grkwp, \$grkwpr, $noswstype, \$cdn, \$cdnx, 3)) {
      my ($stwso, $astwso);
      my ($atelhwso, $usetrans, $f1transid, $f1trmgrid, $transtatus, $transid, $stransmgrid, $samesubpid, $reportcaspart, $jhlabeli, $jhlabeloi);

      $Awfif::memes-> {currentwsbi} = $Awfif::codelet-> {l} [$myli] [20];
      $atelhwso = awsoadr (trwsoadr ($sponsor,-1));
      $asponsor = awsoadr ($sponsor);
# Find the statement wso and obtain the statement's wso type
      $stwso = igetmynowner ($myli, $sponsor, 'bustatement', $grkwp, $grkwpr);
      $astwso = awsoadr ($stwso);
      $usetrans = chstoff1 ($myli, $sponsor, $kwp, $kwpr, \@$sactset, \$f1transid, \$f1trmgrid, \$transtatus, \$transid, \$stransmgrid, \$samesubpid, \$reportcaspart);

      my ($sigcount, @lomatchs, @lola, @loconcs, @lostrts, @loends, @logb, @loge, $e2fwso);
      $bcount = ifindb ($myli, $stwso, 'pdcab', \$sigcount, \@lomatchs, \@lola, \@loconcs, \@lostrts, \@loends, \@logb, \@loge, $$kwp, $kwpr, \@$sactset);
      $pdcawso = getfbws ($myli, $sigcount, \@lomatchs, \@lola, \$pws);
# find the inhibitor binding and check if there is an a cyclin generated inhibitor
      if ($bcount == 1) {

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

          my ($ae2fwso, $aid, $counteri, $giveup);
          $Awfif::memes-> {currentwsbi} = $pws;
          $ae2fwso = awsoadr ($e2fwso);
# if no inhibitor is found then signal the d-cyclin
          if ( (!($aid = findcounter ($Awfif::wsol-> {l} [$ae2fwso][2], ($Awfif::memes-> {snnh} {inhibitor}), \$counteri, $Awfif::memes-> {snnh} {bcyclin})))
          ){#transition the cycle phase
# remove the prb inhibitor descriptor

            &maskcounter ($Awfif::memes-> {snnh} {inhibition}, $ae2fwso, $Awfif::memes-> {snnh} {prbevaluator});
# remove e cyclin prbi
            &maskcounter ($Awfif::memes-> {snnh} {pdcaprogam}, $ae2fwso, $Awfif::memes-> {snnh} {ecyclin});
# remove d cyclin codelet inhibition (acyclin inhibitor counter written by the acyclin codelet)
            &maskcounter ($Awfif::memes-> {snnh} {inhibitor}, $ae2fwso, $Awfif::memes-> {snnh} {acyclin});
# get any transcription factor wso descriptor and remove it if present
            &masktfdesc ($myli, $Awfif::codelet-> {l} [$myli] [23], $kwp, $kwpr, \@$sactset);
# deploy the b descriptor which will be removed later in the cycle by an e cyclin

            $Awfif::wsol-> {l} [$ae2fwso][2]
            = inccounter ( $Awfif::memes-> {snnh} {complete},
                ($Awfif::memes-> {snnh} {wsi} + $Awfif::memes-> {snnh} {bcyclin}), #lets start with one
                $Awfif::memes-> {snnh} {pdcaprogram},
                $Awfif::wsol-> {l} [$ae2fwso] [2],
                $ae2fwso,
                undef (),
                $Awfif::memes-> {snnh} {complete},
                $Awfif::memes-> {snnh} {bcyclin});

            $Awfif::memes-> {currentwsbi} = $Awfif::codelet-> {l} [$myli][20];
            $transtatus = 0;#must be defined to be set in ilaunchnc
            &ilaunchnc ($myli, $stwso, 'dcyclino', $Awfif::memes-> {snnh} {bcyclin}, \$giveup, $grkwp, $grkwpr, \@$sactset,
              '32,37', #mask out codelet-> {l} [32] i.e. {tfree}
              $usetrans,
              \$transid,
              \$transtatus,
              $Awfif::codelet-> {l} [$myli][36],
              \$jhlabeli,
              \$jhlabeloi
              );
            &transmgr ($myli, $myli, $Awfif::memes-> {snnh} {update}, $Awfif::memes-> {snnh} {assoctran}, $asponsor, $Awfif::memes-> {snnh} {stran}, $transid, $Awfif::codelet-> {l} [$myli] [36], $stransmgrid);
            if ($Awfif::codelet-> {l} [$myli] [36] != 0) {

              &transmgr ($myli, $myli, $Awfif::memes-> {snnh} {add}, $Awfif::memes-> {snnh} {assocf1}, $atelhwso, $Awfif::memes-> {snnh} {rtran}, undef(), $Awfif::codelet-> {l} [$myli] [36], $Awfif::codelet-> {l} [$myli] [37], $Awfif::codelet-> {l} [$myli] [36]);
              };#if
            }#if no inhibitor
          elsif ($usetrans > 0) {

            $usetrans = resstoff1 ($myli, $sponsor, $kwp, $kwpr, \@$sactset, 'dcyclino', $usetrans, \$f1transid, \$f1trmgrid, \$transtatus, \$transid, \$stransmgrid, \$samesubpid, \$reportcaspart, \$jhlabeli, $jhlabeloi);
            };#elsif
# bcycbngcu1
          if (($transtatus == $Awfif::memes-> {snnh} {incomplete})
          ){

            my ($sgdi, $gsponsor);
            $Awfif::memes-> {currentwsbi} = $Awfif::codelet-> {l} [$myli] [20];
            &fgrpd ($myli, $sponsor, \$sgdi, $Awfif::memes->{snnh}{groupcategory});
            $gsponsor = fgrpsponsor ($sponsor, $Awfif::workspace-> {l} [$sgdi] [3], $Awfif::memes-> {snnh} {groupcategory});
            ¬gcompleted ($myli, $gsponsor, undef(), 't', undef (), undef(),);
            };#if
          };#if
        };#if
      };#got target wso

    $Awfif::memes-> {currentwsbi} = $cwsbi;
    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("$cdnx\n");
      };
    &clogstatx ();
    }# bcycacpbuilder1
#
sub spdcaevaluator1 {
    my ($myli, $kwp, $kwpr, $sactset) = @_;#The ignored parameters are required by the codelet calling architecture
# cyclins operate a Shewhart cycle in the eucaryotic cell. The spdca codelet signals initiation of a similar PDCA cycle controlled by Awf cyclin codelets

    &icsevaluator1 ($myli, \&Awfif::ispdcaevaluator1, 'spdcabuilder', $kwp, $kwpr, \@$sactset);
    }# spdcaevaluator1
#
#<!-- start tag scl -->
#
sub ispdcaevaluator1 {
    my ($myli, $sponsor, $signal, $schema, $swstype, $kwp, $kwpr, $sactset, $noswstype, $fbinderc) = @_;#bsmodeler requires the ignored parameters for its general interface
    my ($dolaunch, $bcount, $pdcawso, $pws, $stwso, $astwso, $twso, $asponsor, $cwsbi,
    $grkwp, $grkwpr);
#
# cyclins operate a Shewhart cycle in the eucaryotic cell. The spdca codelet signals initiation of a similar PDCA cycle controlled by Awf cyclin codelets
# checked for merged workspaces

    $cwsbi = $Awfif::memes-> {currentwsbi};
    $dolaunch = '';
    $twso = trwsoadr (fgrpend ($sponsor), 1);
    $asponsor = awsoadr ($sponsor);

    $stwso = getmystatement ($myli, $sponsor, $grkwp, $grkwpr);
    $astwso = awsoadr ($stwso);
    my ($sigcount, @lomatchs, @lola, @loconcs, @lostrts, @loends, @logb, @loge, $e2fwso);
    $$fbinderc = ifindb ($myli, $stwso, 'pdcab', \$sigcount, \@lomatchs, \@lola, \@loconcs, \@lostrts, \@loends, \@logb, \@loge, $kwp, $kwpr, \@$sactset);
    $pdcawso = getfbws ($myli, $sigcount, \@lomatchs, \@lola, \$pws);
# find the inhibitor binding
    if ($$fbinderc == 1) {

      $bcount = ifindb ($myli, $stwso, 'e2finhibb', \$sigcount, \@lomatchs, \@lola, \@loconcs, \@lostrts, \@loends, \@logb, \@loge, $kwp, $kwpr, \@$sactset, $pws);
      $e2fwso = getstsbws ($myli, $sigcount, \@lomatchs, \@lola, $pws);
      if ( ($bcount == 1) #call in the builder
      ){#launch builder
        $dolaunch = 't';
        };#if
      };#if
    $Awfif::memes-> {currentwsbi} = $cwsbi;

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("ispdcaevaluatorx ret ($dolaunch)\n");
      };
    return $dolaunch
    }# ispdcaevaluator1
#
#
sub spdcabsmodeler1 {
    my ($myli, $kwp, $kwpr, $sactset, $and) = @_;
    my ($salience);
# cyclins operate a Shewhart cycle in the eucaryotic cell. The spdca codelet signals initiation of a similar PDCA cycle controlled by Awf cyclin codelets

    $salience = ievalbsmodeler1 ($myli, \$$kwp, $kwpr, \@$sactset, \$$and, 'ispdcaevaluator');
    $$and = 't';
    return $salience
    }# spdcabsmodeler1
#
#
sub spdcabuilder1 {
    my ($myli, $kwp, $kwpr, $sactset) = @_;#The ignored parameters are required by the codelet calling architecture
# cyclins operate a Shewhart cycle in the eucaryotic cell. The spdca codelet signals initiation of a similar PDCA cycle controlled by Awf cyclin codelets

    &ispdcabuilder1 ($myli, \$$kwp, $kwpr, \@$sactset);
    }# spdcabuilder1
#
#<!-- start tag scl -->
#
sub ispdcabuilder1 {
    my ($myli, $kwp, $kwpr, $sactset, $ststrategy) = @_;
    my ($sponsor, $signal, $schema, $found, $bcount, $swstype, $noswstype, $cwsbi, $bcexists, $pdcawso, $pws,
    $grkwp, $grkwpr, $cdn, $cdnx);
#
# cyclins operate a Shewhart cycle in the eucaryotic cell. The spdca codelet signals initiation of a similar PDCA cycle controlled by Awf cyclin codelets
# It is based on an inversion of the statementpdca code from the statement codelet
# checked for merged workspaces

# look for assert binder's workspace

    $cwsbi = $Awfif::memes-> {currentwsbi};
    $found = '';
    $bcount = 0;
    $noswstype = 't';
    $bcexists = '';

    if (getcontext ($myli, \$sponsor, \$signal, \$schema, \$swstype, \$grkwp, \$grkwpr, $noswstype, \$cdn, \$cdnx, 4)) {
      my ($stwso, $astwso, $statementcomplete);

# Find the statement wso and obtain the statement's wso type
      $stwso = igetmynowner ($myli, $sponsor, 'bustatement', $grkwp, $grkwpr);
      $astwso = awsoadr ($stwso);

      my ($sigcount, @lomatchs, @lola, @loconcs, @lostrts, @loends, @logb, @loge, $e2fwso);
      $bcount = ifindb ($myli, $stwso, 'pdcab', \$sigcount, \@lomatchs, \@lola, \@loconcs, \@lostrts, \@loends, \@logb, \@loge, $$kwp, $kwpr, \@$sactset);
      $pdcawso = getfbws ($myli, $sigcount, \@lomatchs, \@lola, \$pws);
# find the inhibitor binding and issue the control signal
      if ($bcount == 1) {

        $bcount = ifindb ($myli, $stwso, 'e2finhibb', \$sigcount, \@lomatchs, \@lola, \@loconcs, \@lostrts, \@loends, \@logb, \@loge, $$kwp, $kwpr, \@$sactset, $pws);
        $e2fwso = getstsbws ($myli, $sigcount, \@lomatchs, \@lola, $pws);
        if (($bcount == 1)

        && (statementpdca ($myli, $stwso, $grkwp, $grkwpr, \@$sactset, $ststrategy)) ){

          $statementcomplete = 't';
          $Awfif::wsol-> {l} [$astwso][2]
            = setupdesc ( (wsbasetype ($stwso)),
            ($Awfif::memes-> {snnh} {wsi} + $Awfif::memes-> {snnh} {valid}), #to match findbond
            $Awfif::memes-> {snnh} {model},
            $Awfif::wsol-> {l} [$astwso][2],
            $astwso);
          &invcaches (wsbasetype ($stwso));
          };#if manage PDCA


        if ($statementcomplete) {#deploy the statement descriptor

          $Awfif::wsol-> {l} [$astwso][2]
              = setupdesc ( (wsbasetype ($stwso)),
                ($Awfif::memes-> {snnh} {wsi} + $stwso),
                $Awfif::memes-> {snnh}{partscategory},
                $Awfif::wsol-> {l} [$astwso][2],
                $astwso);
          $Awfif::memes-> {fatp} = $Awfif::memes-> {fatp} + $Awfif::memes-> {batp};
# send activation to the involved Slipnet nodes
          &actnodes ( $Awfif::memes-> {snnh}{partscategory}, $Awfif::memes-> {openatype});
          &actnodes ( $Awfif::memes-> {snnh} {wsi}, $Awfif::memes-> {openato});
          &invcaches (wsbasetype ($stwso));
          };#statement complete
        };#if
      };#got target wso

    $Awfif::memes-> {currentwsbi} = $cwsbi;
    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("$cdnx\n");
      };
    &clogstatx ();
    }# ispdcabuilder1
#
#<!-- end tag scl -->
#<!-- end tag cr -->
#<!-- start tag inh -->
#
#
sub e2ftfevaluator1 {
    my ($myli, $kwp, $kwpr, $sactset) = @_;#The ignored parameters are required by the codelet calling architecture
# cyclins operate a Shewhart cycle in the eucaryotic cell. The e2ftf codelet is a transcription factor regulating the expression of cyclin genes

    &icsevaluator1 ($myli, \&Awfif::ie2ftfevaluator1, 'e2ftfbuilder', $kwp, $kwpr, \@$sactset);
    }# e2ftfevaluator1
#
sub ie2ftfevaluator1 {
    my ($myli, $sponsor, $signal, $schema, $swstype, $kwp, $kwpr, $sactset, $noswstype, $fbinderc) = @_;#bsmodeler requires the ignored parameters for its general interface
    my ($dolaunch, $bcount, $pdcawso, $pws, $stwso, $astwso, $twso, $asponsor, $cwsbi,
    $grkwp, $grkwpr);
#
# cyclins operate a Shewhart cycle in the eucaryotic cell. The e2ftf codelet is a transcription factor regulating the expression of cyclin genes
# checked for merged workspaces

    $dolaunch = '';
    $cwsbi = $Awfif::memes-> {currentwsbi};
    $twso = trwsoadr (fgrpend ($sponsor), 1);
    $asponsor = awsoadr ($sponsor);

    $stwso = getmystatement ($myli, $sponsor, $grkwp, $grkwpr);
    $astwso = awsoadr ($stwso);
    my ($sigcount, @lomatchs, @lola, @loconcs, @lostrts, @loends, @logb, @loge, $e2fwso);
    $$fbinderc = ifindb ($myli, $stwso, 'pdcab', \$sigcount, \@lomatchs, \@lola, \@loconcs, \@lostrts, \@loends, \@logb, \@loge, $kwp, $kwpr, \@$sactset);
    $pdcawso = getfbws ($myli, $sigcount, \@lomatchs, \@lola, \$pws);

# find the inhibitor binding
    if ($$fbinderc == 1) {

      $bcount = ifindb ($myli, $stwso, 'e2finhibb', \$sigcount, \@lomatchs, \@lola, \@loconcs, \@lostrts, \@loends, \@logb, \@loge, $kwp, $kwpr, \@$sactset, $pws);
      $e2fwso = getstsbws ($myli, $sigcount, \@lomatchs, \@lola, $pws);
      if (($bcount == 1) #call in the builder
      ){#launch builder
        $dolaunch = 't';
        };#if
      };#if
    $Awfif::memes-> {currentwsbi} = $cwsbi;

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("ie2ftfevaluatorx ret ($dolaunch)\n");
      };
    return $dolaunch
    }# ie2ftfevaluator1
#
sub e2ftfbsmodeler1 {
    my ($myli, $kwp, $kwpr, $sactset, $and) = @_;
    my ($salience);
# cyclins operate a Shewhart cycle in the eucaryotic cell. The e2ftf codelet is a transcription factor regulating the expression of cyclin genes

    $salience = ievalbsmodeler1 ($myli, \$$kwp, $kwpr, \@$sactset, \$$and, 'ie2ftfevaluator');
    $$and = 't';
    return $salience
    }# e2ftfbsmodeler1
#
sub e2ftfbuilder1 {
    my ($myli, $kwp, $kwpr, $sactset) = @_;#The ignored parameters are required by the codelet calling architecture
    my ($sponsor, $signal, $schema, $found, $bcount, $swstype, $noswstype, $cwsbi, $bcexists, $pdcawso, $pws, $iwso, $counteri, $tfwso,
    $grkwp, $grkwpr, $cdn, $cdnx);
#
# cyclins operate a Shewhart cycle in the eucaryotic cell. The e2ftf codelet is a transcription factor regulating the expression of cyclin genes
# checked for merged workspaces

# look for assert binder's workspace

    $cwsbi = $Awfif::memes-> {currentwsbi};
    $found = '';
    $bcount = 0;
    $noswstype = 't';
    $bcexists = '';

# now check the workspace for salient workspace type with model status descriptor
    if (getcontext ($myli, \$sponsor, \$signal, \$schema, \$swstype, \$grkwp, \$grkwpr, $noswstype, \$cdn, \$cdnx, 3)) {
      my ($stwso, $astwso);

# Find the statement wso and obtain the statement's wso type
      $stwso = igetmynowner ($myli, $sponsor, 'bustatement', $grkwp, $grkwpr);
      $astwso = awsoadr ($stwso);

      my ($sigcount, @lomatchs, @lola, @loconcs, @lostrts, @loends, @logb, @loge);
      $bcount = ifindb ($myli, $stwso, 'pdcab', \$sigcount, \@lomatchs, \@lola, \@loconcs, \@lostrts, \@loends, \@logb, \@loge, $$kwp, $kwpr, \@$sactset);
      $pdcawso = getfbws ($myli, $sigcount, \@lomatchs, \@lola, \$pws);
# find the inhibitor binding
      if ($bcount == 1) {

        my ($aiwso);
        $bcount = ifindb ($myli, $stwso, 'e2finhibb', \$sigcount, \@lomatchs, \@lola, \@loconcs, \@lostrts, \@loends, \@logb, \@loge, $$kwp, $kwpr, \@$sactset, $pws);
        $iwso = getstsbws ($myli, $sigcount, \@lomatchs, \@lola, $pws);
        $Awfif::memes-> {currentwsbi} = $pws;
        $aiwso = awsoadr ($iwso);
        if ( ($bcount == 1)
        && ((findcounter ($Awfif::wsol-> {l} [$aiwso][2], ($Awfif::memes-> {snnh} {inhibition}), \$counteri, $Awfif::memes-> {snnh} {prbevaluator})))
        && ((!findcounter ($Awfif::wsol-> {l} [$aiwso][2], ($Awfif::memes-> {snnh} {pdcaprogram}), \$counteri, $Awfif::memes-> {snnh} {ecyclin})))
        && ((!findcounter ($Awfif::wsol-> {l} [$aiwso][2], ($Awfif::memes-> {snnh} {pdcaprogram}), \$counteri, $Awfif::memes-> {snnh} {bcyclin})))
        ){#found descriptor

          $bcount = ifindb ($myli, $stwso, 'tfactorb', \$sigcount, \@lomatchs, \@lola, \@loconcs, \@lostrts, \@loends, \@logb, \@loge, $$kwp, $kwpr, \@$sactset, $pws);
          $tfwso = getstsbws ($myli, $sigcount, \@lomatchs, \@lola, $pws);
          if ($bcount == 1) {#write prediction

            my ($atfwso);
            $Awfif::memes-> {currentwsbi} = $pws;
            $atfwso = awsoadr ($tfwso);
            if ( ((!findcounter ($Awfif::wsol-> {l} [$atfwso][2], ($Awfif::memes-> {snnh} {tfactor}), \$counteri, $Awfif::memes-> {snnh} {e2fevaluator}, $Awfif::memes-> {snnh} {complete})))
              ){

              $Awfif::wsol-> {l} [$atfwso][2]
              = inccounter ( $Awfif::memes-> {snnh} {complete},
                  ($Awfif::memes-> {snnh} {wsi} + $Awfif::memes-> {snnh} {e2ftfevaluator}), #lets start with one
                  $Awfif::memes-> {snnh} {tfactor},
                  $Awfif::wsol-> {l} [$atfwso] [2],
                  $atfwso,
                  't',#this descriptor will launch waiting codelets
                  $Awfif::memes-> {snnh} {complete},
                  ($Awfif::memes-> {snnh} {e2ftfevaluator})
                  );
              };#if
            };#if
          };#if
        };#if
      };#got target wso

    $Awfif::memes-> {currentwsbi} = $cwsbi;
    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("$cdnx\n");
      };
    &clogstatx ();
    }# e2ftfbuilder1
#
#<!-- end tag inh -->
#
sub prbevaluator1 {
    my ($myli, $kwp, $kwpr, $sactset) = @_;#The ignored parameters are required by the codelet calling architecture
# cyclins operate a Shewhart cycle in the eucaryotic cell. The pRB codelet is a transcription factor regulating the expression of cyclin genes

    &icsevaluator1 ($myli, \&Awfif::iprbevaluator1, 'prbbuilder', $kwp, $kwpr, \@$sactset);
    }# prbevaluator1
#
sub iprbevaluator1 {
    my ($myli, $sponsor, $signal, $schema, $swstype, $kwp, $kwpr, $sactset, $noswstype, $fbinderc) = @_;#bsmodeler requires the ignored parameters for its general interface
    my ($dolaunch, $bcount, $pdcawso, $pws, $stwso, $astwso, $twso, $asponsor, $cwsbi,
    $grkwp, $grkwpr);
#
# cyclins operate a Shewhart cycle in the eucaryotic cell. The pRB codelet is a transcription factor regulating the expression of cyclin genes
# checked for merged workspaces

    $cwsbi = $Awfif::memes-> {currentwsbi};
    $dolaunch = '';
    $twso = trwsoadr (fgrpend ($sponsor), 1);
    $asponsor = awsoadr ($sponsor);

    $stwso = getmystatement ($myli, $sponsor, $grkwp, $grkwpr);
    $astwso = awsoadr ($stwso);
    my ($sigcount, @lomatchs, @lola, @loconcs, @lostrts, @loends, @logb, @loge, $e2fwso);
    $$fbinderc = ifindb ($myli, $stwso, 'pdcab', \$sigcount, \@lomatchs, \@lola, \@loconcs, \@lostrts, \@loends, \@logb, \@loge, $kwp, $kwpr, \@$sactset);
    $pdcawso = getfbws ($myli, $sigcount, \@lomatchs, \@lola, \$pws);
# find the inhibitor binding
    if ($$fbinderc == 1) {

      $bcount = ifindb ($myli, $stwso, 'e2finhibb', \$sigcount, \@lomatchs, \@lola, \@loconcs, \@lostrts, \@loends, \@logb, \@loge, $kwp, $kwpr, \@$sactset, $pws);
      $e2fwso = getstsbws ($myli, $sigcount, \@lomatchs, \@lola, $pws);
      if (($bcount == 1) #call in the builder
      ){#launch builder
        $dolaunch = 't';
        };#if
      };#if
    $Awfif::memes-> {currentwsbi} = $cwsbi;

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("iprbevaluatorx ret ($dolaunch)\n");
      };
    return $dolaunch
    }# iprbevaluator1
#
sub prbbsmodeler1 {
    my ($myli, $kwp, $kwpr, $sactset, $and) = @_;
    my ($salience);
# cyclins operate a Shewhart cycle in the eucaryotic cell. The pRB codelet is a transcription factor regulating the expression of cyclin genes

    $salience = ievalbsmodeler1 ($myli, \$$kwp, $kwpr, \@$sactset, \$$and, 'iprbevaluator');
    $$and = 't';
    return $salience
    }# prbbsmodeler1
#
sub prbbuilder1 {
    my ($myli, $kwp, $kwpr, $sactset) = @_;#The ignored parameters are required by the codelet calling architecture
    my ($sponsor, $asponsor, $signal, $schema, $found, $bcount, $swstype, $noswstype, $cwsbi, $bcexists, $pdcawso, $pws, $iwso, $counteri, $codeletdef,
    $grkwp, $grkwpr, $cdn, $cdnx);
#
# cyclins operate a Shewhart cycle in the eucaryotic cell. The pRB codelet is a transcription factor regulating the expression of cyclin genes
# checked for merged workspaces

# look for assert binder's workspace

    $cwsbi = $Awfif::memes-> {currentwsbi};
    $found = '';
    $bcount = 0;
    $noswstype = 't';
    $bcexists = '';
# now check the workspace for salient workspace type with model status descriptor

    if (getcontext ($myli, \$sponsor, \$signal, \$schema, \$swstype, \$grkwp, \$grkwpr, $noswstype, \$cdn, \$cdnx, 3)) {

      my ($stwso, $astwso);
# Find the statement wso and obtain the statement's wso type
      $Awfif::memes-> {currentwsbi} = $Awfif::codelet-> {l} [$myli] [20];
      $stwso = igetmynowner ($myli, $sponsor, 'bustatement', $grkwp, $grkwpr);
      $astwso = awsoadr ($stwso);
      $asponsor = awsoadr ($sponsor);

      my ($sigcount, @lomatchs, @lola, @loconcs, @lostrts, @loends, @logb, @loge);
      $bcount = ifindb ($myli, $stwso, 'pdcab', \$sigcount, \@lomatchs, \@lola, \@loconcs, \@lostrts, \@loends, \@logb, \@loge, $$kwp, $kwpr, \@$sactset);
      $pdcawso = getfbws ($myli, $sigcount, \@lomatchs, \@lola, \$pws);
# find the inhibitor binding
      if ($bcount == 1) {

        my ($aiwso, $scount);
        $bcount = ifindb ($myli, $stwso, 'e2finhibb', \$sigcount, \@lomatchs, \@lola, \@loconcs, \@lostrts, \@loends, \@logb, \@loge, $$kwp, $kwpr, \@$sactset, $pws);
        $iwso = getstsbws ($myli, $sigcount, \@lomatchs, \@lola, $pws);
        $Awfif::memes-> {currentwsbi} = $pws;
        $aiwso = awsoadr ($iwso);
# now am looking for a descriptor from the investigation supervisor {supervisor} {investigation} {#} saying how many investigation codelets are required
# and then atleast that number of descriptors from the investigators

        if ( ($bcount == 1)
        && ((findcounter ($Awfif::wsol-> {l} [$aiwso][2], ($Awfif::memes-> {snnh} {supervisor}), \$counteri, $Awfif::memes-> {snnh} {investigation}, $Awfif::memes-> {snnh} {count})))
        && (($scount = ($Awfif::workspace-> {l} [$counteri] [9] - $Awfif::memes-> {snnh} {wsi})) > 0)
# prbbicfu1
        && ((findcounter ($Awfif::wsol-> {l} [$aiwso][2], ($Awfif::memes-> {snnh} {model}), \$counteri, $Awfif::memes-> {snnh} {investigation}, $Awfif::memes-> {snnh} {complete})))
        && ((!findcounter ($Awfif::wsol-> {l} [$aiwso][2], ($Awfif::memes-> {snnh} {pdcaprogram}), \$counteri, $Awfif::memes-> {snnh} {ecyclin})))
        && (countdset ($Awfif::memes-> {snnh} {model}, $scount, $aiwso))
        ){#found descriptor

# if these are present and there is no {pdacprogram} {complete} {ecyclin} then write description {inhibition} {complete} {prbevaluator}

          $Awfif::memes-> {currentwsbi} = $pws;
          if ( ((!findcounter ($Awfif::wsol-> {l} [$aiwso][2], ($Awfif::memes-> {snnh} {inhibition}), \$counteri, $Awfif::memes-> {snnh} {prbevaluator}, $Awfif::memes-> {snnh} {complete})))
            ){
            $Awfif::wsol-> {l} [$aiwso][2]
            = inccounter ( $Awfif::memes-> {snnh} {complete},
                ($Awfif::memes-> {snnh} {wsi} + $Awfif::memes-> {snnh} {prbevaluator}), #
                $Awfif::memes-> {snnh} {inhibition},
                $Awfif::wsol-> {l} [$aiwso] [2],
                $aiwso,
                undef(),
                $Awfif::memes-> {snnh} {complete},
                ($Awfif::memes-> {snnh} {prbevaluator})
                );
            };#if
          }#if
        elsif ( ($bcount == 1)
        && ((findcounter ($Awfif::wsol-> {l} [$aiwso][2], ($Awfif::memes-> {snnh} {supervisor}), \$counteri, $Awfif::memes-> {snnh} {investigation})))
        && ((findcounter ($Awfif::wsol-> {l} [$aiwso][2], ($Awfif::memes-> {snnh} {model}), \$counteri, $Awfif::memes-> {snnh} {investigation}, $Awfif::memes-> {snnh} {complete})))
        && ((findcounter ($Awfif::wsol-> {l} [$aiwso][2], ($Awfif::memes-> {snnh} {pdcaprogram}), \$counteri, $Awfif::memes-> {snnh} {ecyclin})))
        && (countdset ($Awfif::memes-> {snnh} {model}, $scount, $aiwso))
        ){#found descriptor
# if there is also a {pdcaprogram} {complete} {ecyclin} then delete the {supervisor} {investigation} {#} descriptor

          &maskcounter ($Awfif::memes-> {snnh} {supervisor}, $aiwso, $Awfif::memes-> {snnh} {investigation}, $Awfif::memes-> {snnh} {count});
# && look for check {supervisor} {check} {#} and {check} descriptors
          if ( ((findcounter ($Awfif::wsol-> {l} [$aiwso][2], ($Awfif::memes-> {snnh} {supervisor}), \$counteri, $Awfif::memes-> {snnh} {check})))
# if these are present then write description {inhibition} {complete} {prbevaluator}
          ){#found descriptor

            $Awfif::memes-> {currentwsbi} = $pws;
            if ( ((!findcounter ($Awfif::wsol-> {l} [$aiwso][2], ($Awfif::memes-> {snnh} {inhibition}), \$counteri, $Awfif::memes-> {snnh} {prbevaluator}, $Awfif::memes-> {snnh} {complete})))
              ){

              $Awfif::wsol-> {l} [$aiwso][2]
              = inccounter ( $Awfif::memes-> {snnh} {complete},
                  ($Awfif::memes-> {snnh} {wsi} + $Awfif::memes-> {snnh} {prbevaluator}), #
                  $Awfif::memes-> {snnh} {inhibition},
                  $Awfif::wsol-> {l} [$aiwso] [2],
                  $aiwso,
                  undef(),
                  $Awfif::memes-> {snnh} {complete},
                  ($Awfif::memes-> {snnh} {prbevaluator})
                  );
              };#if
            };#if
          }#elsif
        else {

          if ( (findtdesc ($Awfif::wsol-> {l} [$asponsor][2], ($Awfif::memes-> {snnh} {inhibition}), $Awfif::memes-> {snnh} {complete}, ($Awfif::memes-> {snnh} {prbevaluator} + $Awfif::memes-> {snnh} {wsi})) == 0)
          ){

            &waitondesc ($myli, $aiwso, ($Awfif::memes-> {snnh}{investigation} + $Awfif::memes-> {snnh} {wsi}), $Awfif::memes-> {snnh} {complete}, $Awfif::memes-> {snnh} {model}, undef(), undef(), undef(), undef(), \$codeletdef);
            $Awfif::wsol-> {l} [$asponsor][2]
            = setupdesc ( $Awfif::memes-> {snnh} {complete},
                ($Awfif::memes-> {snnh} {wsi} + $Awfif::memes-> {snnh} {prbevaluator}), #
                $Awfif::memes-> {snnh} {inhibition},
                $Awfif::wsol-> {l} [$asponsor] [2],
                $asponsor);
            };#if
          };#else wait for the cascade completion descriptor
        };#if bcount
      };#got target wso

    $Awfif::memes-> {currentwsbi} = $cwsbi;
    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("$cdnx\n");
      };
    &clogstatx ();
    }# prbbuilder1
#
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