Workspace

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

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.

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.

This page introduces the programs that the Adaptive Web Framework (AWF) develops and uses to deploy Rob's Strategy Studio (RSS). The programs are structured to obey complex adaptive system (CAS) principles. That allows AWF to experiment and examine the effects. A production program generates the web pages. A testing system tests the production program. It uses a framework to support the test programs. This is AWF's agent programming framework as described in the agent-based programming presentation. An example of the other AWF agent-based programs that are also described in the frame is the virtual robot. Finally a strength, weaknesses, opportunities and threats assessment is presented. Perl frame
This page describes the Adaptive Web framework (AWF) test system and the agent programming framework (Smiley) that supports its operation. Example test system statements are included. To begin a test a test statement is loaded into Smiley while Smiley executes on the Perl interpreter. Part of Smiley's Perl code focused on setting up the infrastructure is included bellow. The setup includes: Loading the 'Meta file' specification, Initializing the Slipnet, and Workspaces and loading them So that the Coderack can be called. The Coderack, which is the focus of a separate page of the Perl frame then schedules and runs the codelets that are invoked by the test statement structures. Test framework
This page introduces the many ways a complex modeling and coordination activity can be implemented using agent-based programming (see presentation). It describes how salient schematic alternative strings can be used to model a situation and make a decision under evolved control. It also introduces bottom up model codelets and complex techniques that are covered more fully on other pages. Constraints on the modeling process including requirements for timeliness, parallelism, synchronization and emergence of new models are discussed. Once a schematic sequence is selected by a group codelet or any additional type of modeling codelet the codelet will initiate an iterative cycle of detect, signal, match, deploy. This allows the actions of a schematically selected sequence of model codelets to aggregate into a focused agent. A series of example signals sent by complex modeling codelets along with their associated operons and subgroup schematic sequences are included. The signals are sent by the: merge streams spdca builder - The initiator of merge streams's pdca cycle (see schematic pdca). merge streams dcycip builder - The initiator of the planning phase of the merge streams's pdca cycle. merge streams cassert builder - The initiator of the mergestreams's case resolved assert true conditional cascade. It is a structurally enhanced codelet which activates at the end of the 'do' phase and signals the nucleus. merge streams indsloc builder - The start locator codelet finds the application schemata's start operon merge streams shsloc builder - A start locator codelet that finds an alternative start operon in the application schematic operon merge streams rchpair builder - A receptor that detects and relays an application signal pdca ecycdop builder - A cyclin simulation codelet which signals entry to the 'do' phase of the pdca. pdca acycchp builder - A cyclin simulation codelet which signals entry to the 'check' phase of the pdca. pdca bcycacp builder - A cyclin simulation codelet which signals entry to the 'act' phase of the pdca. And the Slipnet configuration which activates the schematic subgroup sequence <mergestreams> <for> <case> <resolved> <assert> <true> is included. Schematic modeling
This page looks at how Smiley processes the statement, such as a test request, to ensure that each part of the statement is composed of groups. Smiley does this through the operation of a part codelet which indirectly sponsors the modeling of the parts of the statement. The modeling itself is performed by model codelets. The part codelet synchronizes with the completion of the modeling. The part evaluator's signal along with the associated operons and subgroup schematic sequences are included. The group models' Slipnet associations are included. The codelets and supporting functions are included. Schematic whole part
This page looks at how Smiley processes the statement, such as a test request, to ensure that each part of the statement is valid. Smiley does this through the operation of a part codelet which indirectly sponsors the modeling of the parts of the statement. The modeling itself is performed by model codelets. The part codelet synchronizes with the completion of the modeling. The part evaluator's signal along with the associated operons and subgroup schematic sequences are included. The group models' Slipnet associations are included. The codelets and supporting functions are included. Part validity
This page looks at how Smiley processes the statement, such as a test request, to ensure that each part of the statement is constrained. Smiley does this through the operation of a part codelet which indirectly sponsors the modeling of the parts of the statement. The modeling itself is performed by model codelets. The part codelet synchronizes with the completion of the modeling. The part evaluator's signal along with the associated operons and subgroup schematic sequences are included. The group models' Slipnet associations are included. The codelets and supporting functions are included. Part constraints
This page looks at how Smiley processes the statement, such as a test request, to ensure that each part of the statement is integral. Smiley does this through the operation of a part codelet which initiates a program to assess the integrity of the parts. The modeling itself is performed by model codelets. The group models' Slipnet associations are included. The codelets and supporting functions are included. Part integrity
This page looks at how Smiley processes the statement, such as a test request, to ensure that the statement contains all required parts. Smiley does this through the operation of a statement codelet which indirectly sponsors the modeling of the whole statement. The modeling itself is performed by model codelets. The group models' Slipnet associations are included. The codelets and supporting functions are included. Syntactically whole statement
This page looks at Smiley's statement codelet. What the codelet's goals are. The three aspects of its operations are described. The indirect nature of its support for the applications programs and Shewhart cycles are illustrated. It describes how the application codelets are inhibited from action until the Statement codelet concludes the application's assertion or implementation statement is viable. An application assertion statement is described and the schematic string included. The statement codelet Perl and its support infrastructure are included. Statement operation
This page describes the need for stated assumptions to support the setup and development of a Smiley agent-based application. As an example it discusses the use of assumptions about connecting external files to the agents. The Smiley codelets which process files and integrate them with the application agents using assumptions are introduced. The Slipnet associations relating the Workspace schematic strings to group completion scheduled codelets are included. The codelets and supporting functions are included. Schematic assumptions
This page discusses how Smiley can support the start of the development phase of an agent-based application. Startup is an artificial operation not found in living systems. But Smiley must do it and so we discuss an example of starting the development phase. With the Smiley infrastructure and the application integrated the application's development phase is reviewed. The association of structural Workspaces for state representation is discussed. The aggregation of schematic associations of codelets defines a development agent. At the application level it processes the application's schematic strings. The schematic nature of the data processed by the test application suggests the use of an indirect integration framework. This supports the binding of codelets to the schematic data and detecting and responding to the control operons. An application polymerase complex emerges. The codelets and supporting functions are included. Schematic development
This page describes the specialized codelets that provide life-cycle and checkpoint capabilities for Smiley applications. The codelets implement a Shewhart cycle. The structural schematic nature of the cycle is described. Transcription factor codelets operate the phase change controls. How inhibitory agents are integrated into the cycle is described. An application agent with management and operational roles emerges. The codelets and supporting functions are included. Schematic PDCA
This page describes a schematic system about abstracted 'animal' and 'plant' cells competing in a small world. The schematic cell was designed to focus in on the nature of mutation and the adjacent possible. THE IMPLEMENTATION IS INCOMPLETE AND ONGOING. The codelets and infrastructure are included. Schematic cell
This page describes a schematic system about abstracted neurons operating in a circuit. The neuronal system was designed to focus in on the cellular nature of a schematically defined neuron. The goals include: Development of a system of cells, their differentiation and deployment into a neuron network. Abstract receptor operation must support interactions of a network of neurons and attached cells. THE IMPLEMENTATION IS INCOMPLETE AND ONGOING. The codelets and infrastructure are included. Schematic innate neuron
This page discusses a complex adaptive system (CAS) implementation of a genetic algorithm (GA), Melanie Mitchell's robot-janitor built as a set of Copycat codelets integrated using agent-based programming. The improvement in the operation of the robots over succeeding generations of applying the GA is graphed. The CAS that generated, and operated the robot is reviewed, including the implementation details and codelet operational program flow, and the challenges and limitations of this implementation. The schematic strings which make up the robot's genotype, as well as the signals which are sent to the nucleus of the robot's agents so that the agents can deploy the appropriate response strings (which activate codelets) are listed. The Slipnet configuration required by the system to associate the schematic strings with programmatic forces (codelets) is also listed. The codelets and supporting perl are also listed. In the conclusion the limitations of the robot-janitor abstraction in studying emergence and creative evolution are discussed and alternative experimental frameworks are proposed. One such, the schematic cell is the subject of a separate page in this web frame. Virtual robot
This page discusses how a Smiley based application the event processor test program's operational phase is structured. The goals of the event processor test application are described. The implementation strategy is outlined. Synchronization of Smiley setup completion and operation phase initiation is discussed. The association of structural Workspaces for state representation is discussed. An application specific codelet merge streams assert responds to the nature of the assertion. It does not have an emergent structure. Instead it reflects software engineering practice. It includes: Merge stream case specific Modeling with sub-programs Resolving of case Non case assertion The operation is setup, inhibited, initiated, and managed by iterative phase check-pointing provided by Smiley codelets. Schematic synchronization of parallel codelet cascades is performed structurally. The assert merge operon cascade is included. The Slipnet concept network for merge streams is included. The codelets and supporting functions are included. Schematic assert merge
This page describes the inhibitor framework provided by the adaptive web framework's (AWF) Smiley agent programming infrastructure. Two mechanisms are provided: Uncompetitive inhibition of group completion. Uncompetitive inhibition of transcription factors. In both cases the inhibitors provide a restriction process. The Slipnet inhibitor descriptions are included. The codelets and supporting infrastructure are included. Codelet restriction
This page discusses how the adaptive web framework (AWF) Smiley supports agent-based application's leverage of infrastucture amplification. A number of Smiley's amplification strategies are reviewed: Locality Enzyme like catalysis Efficient routing through the Slipnet Independence and equivalence of transactional codelets Structurally enhanced state based amplification The architecture of Smiley's grab amplification is discussed. This includes: Sub program grab amplification Deployment infrastructure cooperation in grab amplification Generalizing the grab architecture The mechanisms Smiley uses to limit the impact of amplification, such as crowding out and processor starvation, on other codelets operations are discussed. The codelets and infrastructure are included. Infrastructure amplifier
This page describes the 'merge streams' application's codelet implementation of a 'case' architecture based on the adaptive web framework's (AWF) Smiley histone infrastructure. The application scenario for processing case statements is described. It involves a schematic binder complex for resolving the case statements. A case tagged application schemata. The Smiley infrastructure that supports the case architecture is reviewed. The Workspace schematic strings that implement the operon supporting histone like case control are included. The Slipnet concept network for the 'merge streams' application's histone like case control is included. The codelets and supporting functions are included. Schematic case
This page describes the adaptive web framework (AWF) Smiley agent progamming infrastructure's codelet based Copycat grouping operation. The requirements needed for a group to complete are described. The association of group completion with a Slipnet defined operon is described. Either actions or signals result from the association. How a generated signal is transported to the nucleus of the cell and matched with an operon is described. A match with an operon can result in deployment of a schematic string to the original Workspace. But eventually the deployed string will be destroyed. Smiley infrastructure amplification of the group completion operation is introduced. This includes facilities to inhibit crowding out of offspring. A test file awfart04 is included. The group codelet and supporting functions are included. Group complete
This page describes the Smiley infrastructure and codelets that instantiate the epiphenomena defined in the Meta file and Slipnet. Infrastructure sensors are introduced. The role of phenomena in shaping the environment is discussed. The focusing of forces by phenomena in Smiley is discussed. The Meta file association of case keywords with phenomena is included. The codelets and supporting functions are included. Phenomena
This page describes the Copycat Slipnet. The goal of the Slipnet is reviewed. Smiley's specialized use of the Slipnet is introduced. The initial Slipnet network used by the 'Merge Streams' and 'Virtual Robot' agent-based applications is setup in initchemistry and is included. The Slipnet infrastructure and initialization functions are included. Slipnet
Workspace
This page describes the Copycat Coderack. The details of the codelet architecture are described. The specialized use of the Coderack by the adaptive web framework's (AWF) Smiley is discussed. The codelet scheduling mechanism is discussed. A variety of Smiley extensions to the Coderack are reviewed. The Coderack infrastructure functions are included. Coderack
This page discusses how Smiley provides signalling to its agent-based applications. Alternative strategies for initiating the signalling are reviewed. The codelets and supporting functions are included. Schematic signals
This page discusses how Smiley provides deployment guarantees to its agent-based applications. Smiley's transaction services are reviewed. The complex interactions of codelets participating in a deployment cascade are discussed including: The implementation of schematic switches. The cooperative use of goal suppression. Evaluator codelets promotion of other siblings. Challenges of initiation of a cascade are discussed. Tools to associate transaction protection to an operon deployed codelet are described. Special support for sub-program codelets is described. Completion of transactional sub-programs presents special challenges. Priority and synchronization support includes: Delaying the operaton of the cascade sponsor. Delaying the notgcompleting cascade participant. Waiting for completion of parallel operations with the wait and relay service. The need to sustain resource pools is reviewed. The use of signals to coordinate siblings is described. The structural binding operon for the wait and relay service is included. The codelets and supporting functions are included. Schematic cascades
This page describes the Smiley infrastructure that supports the associative binding of schematic strings to codelets defined in the Meta file and Slipnet. The infrastructure supporting the associations is introduced. The role of Jeff Hawkins neocortical attributes is discussed. Relevant Slipnet configurations are included. The codelets and supporting functions are included. Associative labels
This page describes the Smiley data structures. Key structures are described each of which is based on a list structure represented with an array and add and free subroutines. Data structures

Primary Navigation

In this page we:

Introduce some current problems of complexity for humanity
Explain how to use the site.

There are two main starting points:

The example systems frame and
The presentation frame.
And then there is how we use the site.

The site uses lots of click through. That's so that you can see the underlying principles that are contributing to the system being discussed. We hope that as you internalize and reflect on the principles the system should appear in a new light. At this site clicking is good!

Opportunities

This page introduces the complex adaptive system (CAS) theory frame. The theory provides an organizing framework that is used by 'life.' It can illuminate and clarify complex situations and be applied flexibly. It can be used to evaluate and rank models that claim to describe our perceived reality. It catalogs the laws and strategies which underpin the operation of systems that are based on the interaction of emergent agents. It highlights the constraints that shape CAS and so predicts their form. A proposal that does not conform is wrong.

John Holland's framework for representing complexity is outlined. Links to other key aspects of CAS theory discussed at the site are presented.

Theory

We are products of complexity, but our evolution has focused our understanding on the situation of hunter gatherers on the African savanna. As humanity has become more powerful we can significantly impact the systems we depend on. But we struggle to comprehend them. So this web frame explores significant real world complex adaptive systems (CAS):

Assumptions of randomness & equilibrium allowed the wealthy & powerful to expand the size and leverage of stock markets, by placing at risk the insurance and retirement savings of the working class. The assumptions are wrong but remain entrenched.
The US nation was built from two divergent political views of: Jefferson and Hamilton. It also reflects the development of competing ancient ideas of Epicurus and Cyril. But the collapse of Bretton Woods forced Wall Street into a position of power, while the middle and working class were abandoned by the elites. Housing financed with cash from oil and derivative transactions helped hide the shift.
Most US health care is still operating the way cars built in the 1940s did. Geisinger is an example of better solution. But transforming the whole network is a challenge. And public health investment has proved far more beneficial.
Helping our children learn to be effective adults is part of our humanity, but we have created a robust but deeply flawed education system. Better alternatives have emerged.
Spoken language, reading and writing emerged allowing our good ideas to become a second genetic material.
The emergence of the global economy in the 1600s and its subsequent development;

It explains how the examples relate to each other, why we all have trouble effectively comprehending these systems and explains how our inexperience with CAS can lead to catastrophe. It outlines the items we see as key to the system and why.

Examples

This page presents a search result list covering each linked region of rob's strategy studio.

Search

Rob's Strategy Studio aims to celebrate and illuminate complex adaptive systems (CAS) just as an art studio does art.

By way of introduction it notes the complex interactions that led to the partnership that discovered the DNA double helix and genetic code.

The page introduces the RSS vision 'I act, therefore I think' approach and the RSS mission.

It describes how many key aspects of the world are CAS including businesses.

Finally the page explains each of the framed pictures displayed at the studio including the other aspects explored in this vision frame.

Vision

This page introduces the programs that the Adaptive Web Framework (AWF) develops and uses to deploy Rob's Strategy Studio (RSS).
The programs are structured to obey complex adaptive system (CAS) principles. That allows AWF to experiment and examine the effects.
A production program generates the web pages.
A testing system tests the production program. It uses a framework to support the test programs. This is AWF's agent programming framework as described in the agent-based programming presentation.
An example of the other AWF agent-based programs that are also described in the frame is the virtual robot.
Finally a strength, weaknesses, opportunities and threats assessment is presented.

Perl

This page introduces a series of asymmetries which encourage different strategic approaches.
The differences found in business, sexual selection, gamete structure, as well as in chess encourage escalations in the interactions.
And yet the systems including these asymmetries can be quite stable.

Asymmetries

This web frame includes a set of presentations about complex adaptive systems (CAS)

Presentations

Perceptual infrastructure for Copycat

Summary

This page describes the

This page discusses the interdependence of perception and representation in a complex adaptive system (CAS). Hofstadter and Mitchell's research with Copycat is reviewed. The bridging of a node from a network of 'well known' percepts to a new representational instance is discussed as it occurs in biochemistry, in consciousness and abstractly.

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 a collection of: happenings, occurrences and processes; including emergent entities, as required by relativity, explains Rovelli. But natural selection has improved our fitness by representing this perception, in our minds, as an unchanging thing, as explained by Pinker. Dehaene explains the object modeling and construction process within the unconscious and conscious brain. Mathematicians view anything that can be defined and used in deductive reasoning and mathematical proofs as an object. These mathematical objects can be values of variables, allowing them to be used in formulas.
is included.
The Workspace infrastructure functions are included.

Introduction

Smiley, an

This page describes the Adaptive Web framework (AWF) test system and the agent programming framework (Smiley) that supports its operation.
Example test system statements are included. To begin a test a test statement is loaded into Smiley while Smiley executes on the Perl interpreter.
Part of Smiley's Perl code focused on setting up the infrastructure is included bellow.
The setup includes:

Loading the 'Meta file' specification,
Initializing the Slipnet, and Workspaces and loading them
So that the Coderack can be called.

The Coderack, which is the focus of a separate page of the Perl frame then schedules and runs the codelets that are invoked by the test statement structures.

agent programming framework, needs a mechanism to define and adapt its physical environment. To do this we 'repurposed' Copycat's solution the Workspace.

Copycat, Douglas Hofstadter & Melanie Mitchell's implementation of a

perception & representation architecture, integrates a conceptual model with its local perceptions of its situation. The perceptual situation is maintained in the Workspace.

Smiley's specialized use of the Workspace

In the adaptive web framework (AWF)'s implementation of the architecture (the AWF test infrastructure) the Workspace is initially loaded with a specification statement and nuclear

Plans emerge in complex adaptive systems (CAS) to provide the instructions that agents use to perform actions. The component architecture and structure of the plans is reviewed.

memes based on the

This page describes the Copycat Slipnet.
The goal of the Slipnet is reviewed.
Smiley's specialized use of the Slipnet is introduced.
The initial Slipnet network used by the 'Merge Streams' and 'Virtual Robot' agent-based applications is setup in initchemistry and is included.
The Slipnet infrastructure and initialization functions are included.

Slipnet's relations and the physical rules defined in the Meta file is loaded by the adaptive web framework's (AWF) Smiley. It defines the application system's basic rules, its keywords and their properties and the form of the assertion or implementation statement the application uses.
. The Workspace is essentially a chemical, molecules obtain chemical properties from the atoms from which they are composed and from the environment in which they exist. Being relatively small they are subject to phenomena which move them about, inducing collisions and possibly reactions with other molecules. AWF's Smiley simulates a chemical environment including associating the 'molecule' like strings with codelet based forces that allow the strings to react based on their component parts, sequence etc.

The complex adaptive system (CAS) nature of a value delivery system is first introduced. It's a network of agents acting as relays.

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

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

Finally an example of aligning a VDS is presented.

environment into which

Plans emerge in complex adaptive systems (CAS) to provide the instructions that agents use to perform actions. The component architecture and structure of the plans is reviewed.

schematic structures such as additional memes can

This page discusses the mechanisms and effects of emergence underpinning any complex adaptive system (CAS). Physical forces and constraints follow the rules of complexity. They generate phenomena and support the indirect emergence of epiphenomena. Flows of epiphenomena interact in events which support the emergence of equilibrium and autonomous entities. Autonomous entities enable evolution to operate broadening the adjacent possible. Key research is reviewed.

emerge. Each Workspace object is a collection of: happenings, occurrences and processes; including emergent entities, as required by relativity, explains Rovelli. But natural selection has improved our fitness by representing this perception, in our minds, as an unchanging thing, as explained by Pinker. Dehaene explains the object modeling and construction process within the unconscious and conscious brain. Mathematicians view anything that can be defined and used in deductive reasoning and mathematical proofs as an object. These mathematical objects can be values of variables, allowing them to be used in formulas.
, like a carbon atom, is a building block, able, due to its list structure and functions (addwsoli), to integrate into backbone and side chains. This enables the rich representation environment where descriptions can be supported.

Text including XML style keywords can be imported and converted into Workspace structures

Any text string can be loaded into the Workspace using the convbws function. As it processes each character of the text string convbws decides if it is part of a keyword defined in the Meta file. If it is then the keyword will be added to the Workspace rather than the discrete characters. Similarly if convbws is told via 'meta commands' embedded in the text string that this part of the string is grouped then if convbws identifies the Workspace object is a collection of: happenings, occurrences and processes; including emergent entities, as required by relativity, explains Rovelli. But natural selection has improved our fitness by representing this perception, in our minds, as an unchanging thing, as explained by Pinker. Dehaene explains the object modeling and construction process within the unconscious and conscious brain. Mathematicians view anything that can be defined and used in deductive reasoning and mathematical proofs as an object. These mathematical objects can be values of variables, allowing them to be used in formulas.
as being part of a sequence configured in the Slipnet the Workspace group will be associated with this Slipnet configuration.

Workspace objects include a keyword attribute. Using a chemical analogy this is the 'atomic' core of the Workspace object. Each keyword can have physical

This page describes the Smiley infrastructure and codelets that instantiate the epiphenomena defined in the Meta file and Slipnet.
Infrastructure sensors are introduced.
The role of phenomena in shaping the environment is discussed.
The focusing of forces by phenomena in Smiley is discussed.
The Meta file association of case keywords with phenomena is included.
The codelets and supporting functions are included.

phenomena associated with it.

The Workspace objects become the focus of attention of

Plans are interpreted and implemented by agents. This page discusses the properties of agents in a complex adaptive system (CAS).
It then presents examples of agents in different CAS. The examples include a computer program where modeling and actions are performed by software agents. These software agents are aggregates.
The participation of agents in flows is introduced and some implications of this are outlined.

agents which are aggregates of codelets operating on execution infrastructure called the

This page describes the Copycat Coderack.
The details of the codelet architecture are described.
The specialized use of the Coderack by the adaptive web framework's (AWF) Smiley is discussed.
The codelet scheduling mechanism is discussed.
A variety of Smiley extensions to the Coderack are reviewed.
The Coderack infrastructure functions are included.

Coderack. Each time an agent identifies a perception about an object or group of objects it deploys a Workspace object

This page discusses the tagging of signals in a complex adaptive system (CAS). Tagged signals can be used to control filtering of an event stream. Examples of CAS filters are reviewed.

tag.

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

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

Schematic structures can become deployed in any Workspace.

Smiley telomeric schematic structures

Telomeric seal the ends of a chromosome. During each replication of the chromosome the telomeres shrink slightly. Over time they act as an indication of the total age of the organism and contribute to the death from 'old age' of some organisms. Stem cells are protected from this chromosomal aging by telomerases. But differentiated cells are expected to die and do not express telomerase. In the adaptive web framework's (AWF) Smiley telomeric infrastructure counts down the age of telomeric schematic strings. The analogy with a real telomere is weak and has no operational equivalence! schematic structures have the additional property that they are monitored, aged and can be destroyed, by destruction codelets (s, e, b), once their density reaches a threshold and their associated telomeric count drops below an ageing threshold. A special independent and equivalent form of telomeric schemata can represent multiple codelets, is

This page describes the Smiley infrastructure that supports the associative binding of schematic strings to codelets defined in the Meta file and Slipnet.
The infrastructure supporting the associations is introduced.
The role of Jeff Hawkins neocortical attributes is discussed.
Relevant Slipnet configurations are included.
The codelets and supporting functions are included.

associated with jhls references, and is protected from destruction.

Workspace object state

#	Keywords are chained together by their list heads;  The end of the list is a sentinel

#	The head of an active list entry will be the list index of the next entry in the list

#	With the hash the list can be entered at one sentinel.

#	The head is setup for an easy add of a new element

#	memes->{wsobjectl} => wsol->{l}

#	wsol-> {l} [$i][0] is backward link

#	wsol-> {l} [$i][1] is forward link

#	wsol-> {l} [$i][2] is index of first perception descriptor

#	wsol-> {l} [$i][3] is number of descriptors

#	wsol-> {l} [$i][4] is the keyword in first element

#	wsol-> {l} [$i][5] is the instantaneous mean activation (5+6 = salience)

#	wsol-> {l} [$i][6] is the instantaneous unhappiness

#	wsol-> {l} [$i][7] is the instantaneous strength

#	wsol-> {l} [$i][8] is the head log items index or 0 if none

#	wsol-> {l} [$i][9] is the access count element items index or 0 if none

#	wsol-> {l} [$i][10] is the log usage count: log will write if value is > 0

#	wsol-> {l} [$i][11] is the wsbasetype if setup

#	wsol-> {l} [$i][12] is the wsbaseind if setup

# gccache

#	wsol-> {l} [$i][13] is the completed wsgroups sponsor if setup

#	wsol-> {l} [$i][14] is previous logical workspace object

#	wsol-> {l} [$i][15] points to the base and offset of the workspace in wsbl

#	wsol-> {l} [$i][16] is the next logical workspace object

#	wsol-> {l} [$i][17] is [0] the keyword backward links wsi

#	wsol-> {l} [$i][18] is [1] the keyword forward links wsi

#	wsol-> {l} [$i][19] is primary keyword position in metafile

#	wsol-> {l} [$i][20] is primary keyword wsi

#	wsol-> {l} [$i][21] is count of begins that wso is within scope

#	wsol-> {l} [$i][22] is count of starts that wso is within scope

# wsolfbv

#	wsol-> {l} [$i][23] is itstrengths value

#	wsol-> {l} [$i][26] is link address of 'single' group descriptor (fgrpd)

# tdgroupdcache

#	wsol-> {l} [$i][25] is cache value for tdgroup1

#	wsol-> {l} [$i][27] is cache value for tdbond1

#	wsol-> {l} [$i][28] is cache value for bugroup1

#	wsol-> {l} [$i][29] is isterminated cache if present

#	wsol-> {l} [$i][30] is bindtoinspector cache if present

#	wsol-> {l} [$i][31] is bustatement cache if present

#	wsol-> {l} [$i][32] is namespace (operon|stbinding) relative jhlsoi set in deploymd & groupbuilder when deploys completed group and matches jhlabels

#	wsol-> {l} [$i][33] is histone binding ptr if present and non-zero

#	wsol-> {l} [$i][34] is jhlsi for groupcomplete sponsor wso

#	wsol-> {fbs} [$i][23 - 23] 't==2' is record of descriptor update (strength)

#	wsol-> {fbs} [$i][24 - 23] 't==2' is record of descriptor update (unhappiness)

#	wsol-> {fbs} [$i][25 - 23] 't==2' is record of descriptor update (tdgroup1)

#	wsol-> {fbs} [$i][27 - 23] 't==2' is record of descriptor update (tdbond1:strocc)

#	wsol-> {fbs} [$i][28 - 23] 't==2' is record of descriptor update (bugroup1)

Functions

acyclino1
addwsoli
bcyclino1
binderc1
binderc101
binderc111
binderc131
binderc161
binderc191
binderc41
binderc71
binderc91
bindercml1
bindercs1
bindercs21
bindercst1
binderp11
binderrc1
canrejfwso
casopai1
casoppi1
cassuboppi1
checkwsbf
checkwsmd
comparest1
comparestb1
comparesti1
convbws
counttelst1
dcyclino1
destructionbuilder1
destructionevaluator1
destructionscout1
developmentb1
developmenti1
developmentlabel1
devscon1
e2finhibb1
ecyclino1
flagkws
freewso
goalscon1
goalsupp1
greatergwso
greaterwso
hdob1
hdoi1
hdoscon1
iaddsg
ibindervc1
igoalscon1
iinitiators1
imemb1
inewaws
inewstws
isetupws
istelwso
labinv1
labload
mergestreamsb1
mergestreamsi1
msadoboppi1
msiopscon1
mstracasetestpi1
mstranoctestpi1
mstrarescinitpi1
mstraresctestpi1
newwsolink
partlabel1
pcellb1
pdcab1
pdcasappi1
receptorb1
receptorbi1
receptorh1
relinkwsobwsft
screplicate1
self1
setfwst
setwsbf
setwsmd
statementlabel1
statementpdcal1
stripichar
subpc1
telhasiecache
telisie
teltail
tfactorb1
toofewwso
vbtb1
vbtdevscon1
vbti1
vbtiopscon1
vcansb1
vworldb1
vwxstartb1
warasb1
warb1
warhdob1
warmab1
warmdob1
warmsb1
writeiecok

sub convbws {

	my($myli, $buffer, $kwp, $kwpr, $kwmi, $kwmir, $sponsor, $insymbol, $inmsymbol, $started, $end, $depstag, $depttag, $dephtag, $wsi, $namespace, $strscope, $actbt, $setwsclinv)=@_;

	my ($char, $schar, $kws, $kwl, $kwind, $kwai, $ptstoptf, $ptstarttf, $ptrecordtf, $linki, $cwsbi, $akwai, $ptmrf, $ptmbf, $ptmgf, $ptmhf, $ptmtf, $ptwindtf, $ptunwindtf, $newmemetics, $removekwcc, $wascomp, $wascbp, $wascsp,

	$sec, $min, $hour, $mday, $mon, $year, $wday, $yday, $isdat, $convst, $convet, $convwst, $convwet, $convcst, $convcet, $convcbst, $convcbet, $convost, $convoet);

#	characterise each character, or token in a buffer and make a wso

#	updated for merged workspaces

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

		print ("convbws kwp $$kwp kwpr $kwpr kwmi $kwmi kwmir $kwmir wsi $wsi ");

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

		use Time::HiRes 'time';

		($sec, $min, $hour, $mday, $mon, $year, $wday, $yday, $isdat) = localtime(time);

};

	$convst = time ();

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

# convflip

#	while ( $$buffer =~/<(\/)*(rhl)+(t)*(case)*([^>]+)?>+?/i) {

	while ( $$buffer =~/<(\/|#)*(rhl)+(t)*(case)*([^>]+)?>+?/i) {

		my ($a, $b);

		$a = $1.$2.$3.$4.$5;

		$b = $1.$5.$2.$3.$4;

		$$buffer =~ s/\Q<$a/<$b/;

		} # flip complete

	$convcet = time ();

	$Awfif::memes-> {time} [$Awfif::memes-> {spctime}] [$Awfif::memes-> {ch}{$Awfif::codelet-> {l} [$myli] [2]}] [$Awfif::memes-> {convfsum}] = $Awfif::memes-> {time} [$Awfif::memes-> {spctime}] [$Awfif::memes-> {ch}{$Awfif::codelet-> {l} [$myli] [2]}] [$Awfif::memes-> {convfsum}] + $convcet - $convst;

	$char = unpack ('a', $$buffer); #prime char

	$removekwcc = '';

	if (!$$setwsclinv) {

		&wsclinv (0, $wsi, $strscope);#	force the bottom-up workspace caches to reset

		$$setwsclinv = 't';

};#

	$Awfif::memes-> {cativationchange} [$wsi] = 't';

	while ($char ne '') {#not end of record

		if ($Awfif::memes-> {comprocessing} == 1) {#remember if comprocessing so can clear the char if stop

			$wascomp = 't';

			}#if

		else {

			$wascomp = '';

			};#else

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

			$wascbp = 't';

			}#if

		else {

			$wascbp = '';

			};#else

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

			$wascsp = 't';

			}#if

		else {

			$wascsp = '';

			};#else

#		work in the new workspace

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

		if (($char eq '<')

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

			$convcst = time ();

			$removekwcc = 't';

			$$buffer =~ s/\Q$kws//i;

# convbwscb

			if ($Awfif::memes-> {cbprocessing} == 1) {#special processing on anything except </rhlbmsge>

				$$buffer =~ s/\Q>//i;

				$char = '(';

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

#				describe the fact that this paren really substitutes for a meta tag

				$Awfif::wsol-> {l} [awsoadr ($Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}])][2]

					= setupdesc (	$Awfif::memes-> {snnh} {start},

						($Awfif::memes-> {snnh} {mcharbuffer}), #its an end edge

						$Awfif::memes-> {snnh} {mattrib},

						$Awfif::wsol-> {l} [awsoadr ($Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}])][2],

						awsoadr ($Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}]));

				$char = '';

				}#if

			elsif ($Awfif::memes-> {csprocessing} == 1) {#special processing on anything except </tmbinding>

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

					$Awfif::memes-> {catchstring} [ ++ $Awfif::memes-> {catchstring} [0] ] = $4;

					$$buffer =~ s/\Q$1$2$3$4$5$6$7//i;

#					$Awfif::memes-> {csprocessing} = 0;#so that deploymd processes the end keyword

					};#if

				$char = '';

				}#elsif

# convbwscoms

			elsif ($Awfif::memes-> {comprocessing} == 0) {# otherwise stop processing anything except </comm

				if (!$newmemetics) {

					no strict 'refs';

					if (@$inmsymbol != 0) {

						my (@dumstarted, $dumend);

						$dumstarted[0] = -1;

						$dumstarted[1] = '';#initial phase

						$dumend = 0;

						&deploymd ($myli, \@$inmsymbol, $wsi, 0, \@dumstarted, \$dumend, \$$depstag, \$$depttag, \$$dephtag, $newmemetics, $namespace, $strscope, $actbt);

						};#deploy start edge if appropriate

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

					no strict 'refs';

					if (@$inmsymbol != 0) {

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

						}#deploy descriptors for meta tags

					else {#clear end

						$$end = '';

};

					if ((Awfif::wsbasetype( $Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}]) > 0)

					&& ((defined ($actbt)) && ($actbt)) #only activate if caller requires it

#					&& (($actbt ne '') && ($actbt))

					&& ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[Awfif::wsbasetype( $Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}])] > 0) ){#activate the base type

						&setinhib (wsbasetype( $Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}]),0);

						&Awfif::actnodes (wsbasetype($Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}]), $Awfif::memes-> {convfrom}, $strscope);

						};#found basetype

					};#not a new meta keyword

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

				if (

				($ptmgf) &&

				($ptstarttf)) {

					my ($wsbi);

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

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

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

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

					$linki = addmkw ($sponsor);

					$Awfif::mkwl-> {l} [$linki][3] = $Awfif::wsol-> {l}[$akwai][4];

					$$depstag = 't';

					}#memetic start

# convbwstel1

				elsif (

					($ptmtf) &&

					($ptstarttf)) {#Telomeric memetic

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

					$linki = addmkw ($sponsor);

					$Awfif::mkwl-> {l} [$linki][3] = $Awfif::wsol-> {l}[$akwai][4];

					$$depttag = -1;

					}#telomeric memetic start

# convbwshis1

				elsif (

					($ptmhf) &&

					($ptstarttf)) {#histome memetic

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

					$linki = addmkw ($sponsor);

					$Awfif::mkwl-> {l} [$linki][3] = $Awfif::wsol-> {l}[$akwai][4];

					$$dephtag = -(addhistone ($sponsor));

					}#histome memetic start

				elsif (

#					($ptrecordtf) &&

					($ptstarttf)) {

					$$insymbol = 't';

					$linki = addkw ($sponsor);

					$Awfif::kwl-> {l} [$linki][3] = $Awfif::wsol-> {l}[$akwai][4];

					if ($ptwindtf) {# need to mark the head of the kwl

						$Awfif::kwl-> {w} [$Awfif::kwl-> {h}] = 't';

						};#if wind

				elsif (

#					($ptrecordtf) &&

					($ptstoptf)) {

					my ($kw, $scomp);

					$kw = $Awfif::wsol-> {l}[$akwai][4];

					$kw =~ s/\Q\///i;

					$scomp = '';

# convbwstel2

# convbwshis2

					if (($ptmbf) or ($ptmgf) or ($ptmrf) or ($ptmtf) or ($ptmhf)) {#memetic

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

					else {

						$linki = $Awfif::kwl-> {h};

};

					while ((!$scomp) && ($linki != 0)) {

# convbwstel3

# convbwshis3

						if (($ptmbf) or ($ptmgf) or ($ptmrf) or ($ptmtf) or ($ptmhf)) {

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

								$scomp = 't';

								&freemkw ($linki);

# seems to create problems removed 1 sep 07							if ($Awfif::mkwl-> {tlistl} == $Awfif::mkwl-> {flistl}) {

								pop (@$inmsymbol);

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

								if ($newmemetics) {

# convbwshis4

									my (@hainmsymbol);

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

									$$end = '';

									@hainmsymbol = remstkw ($myli, \@$inmsymbol);

									if (@hainmsymbol != 0) {

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

										}#deploy descriptors for meta tags

									};# if

# seems to create problems removed 1 sep 07							};#if

								}#if

							$linki = $Awfif::mkwl-> {l} [$linki] [0];

						else {

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

								$scomp = 't';

								&freekw ($linki);

								if ($Awfif::kwl-> {tlistl} == $Awfif::kwl-> {flistl}) {

									$$insymbol = '';

};

								}#if

							$linki = $Awfif::kwl-> {l} [$linki] [0];

							};#non memetic

						};#while entries in active list and not found match

					if ($ptunwindtf) {# need to remove entries from the head of kwl until match

						my ($linki);

						$linki = $Awfif::kwl-> {h};

						while ($linki != 0) {

							$linki = unwindkw ($linki);

							};# while wind

						};#if wind

					};#if

#				restore current default workspace base

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

				}# not in comment mode

			$convcet = time ();

			$Awfif::memes-> {time} [$Awfif::memes-> {spctime}] [$Awfif::memes-> {ch}{$Awfif::codelet-> {l} [$myli] [2]}] [$Awfif::memes-> {convcsum}] = $Awfif::memes-> {time} [$Awfif::memes-> {spctime}] [$Awfif::memes-> {ch}{$Awfif::codelet-> {l} [$myli] [2]}] [$Awfif::memes-> {convcsum}] + $convcet - $convcst;

			}# possible keyword

		elsif (($Awfif::memes-> {cbprocessing} == 1)

			) {#

			$convcbst = time ();

			no strict 'refs';

			if (@$inmsymbol != 0) {

				my (@dumstarted, $dumend);

				$dumstarted[0] = -1;

				$dumstarted[1] = '';

				$dumend = 0;

				&deploymd ($myli, \@$inmsymbol, $wsi, 0, \@dumstarted, \$dumend, \$$depstag, \$$depttag, \$$dephtag, $newmemetics, $namespace, $strscope, $actbt);

				}#deploy start edge if appropriate

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

			no strict 'refs';

			if (@$inmsymbol != 0) {

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

				}#deploy descriptors for meta tags

			else {#clear end

				$$end = '';

};

			if (($char ne '<')

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

){

				$$buffer =~ s/\Q$char//i;

				};#if

			$char = '';

			$convcbet = time ();

			$Awfif::memes-> {time} [$Awfif::memes-> {spctime}] [$Awfif::memes-> {ch}{$Awfif::codelet-> {l} [$myli] [2]}] [$Awfif::memes-> {convcbsum}] = $Awfif::memes-> {time} [$Awfif::memes-> {spctime}] [$Awfif::memes-> {ch}{$Awfif::codelet-> {l} [$myli] [2]}] [$Awfif::memes-> {convcbsum}] + $convcbet - $convcbst;

		elsif ($Awfif::memes-> {csprocessing} == 1) {#special processing on anything except </tmbinding>

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

				$Awfif::memes-> {catchstring} [ ++ $Awfif::memes-> {catchstring} [0] ] = $4;

				$$buffer =~ s/\Q$1$2$3$4$5$6$7//i;

#				$Awfif::memes-> {csprocessing} = 0;

				}#if

			else {

				$$buffer =~ s/\Q$char//i;

				};#else

			$char = '';

		elsif (($char eq '<')

		&& ($wascsp)

		) {#keyword has already processed the buffer

			$char = '';

			$wascsp = '';

		elsif (($char eq '<')

		&& ($wascomp)

		) {#keyword has already processed the buffer

			$char = '';

			$wascomp = '';

		elsif (($char eq '<')

		&& ($Awfif::memes-> {cbprocessing} != 1)

		&& ($wascbp)

		) {#keyword has already processed the buffer

			$char = ')';

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

#			describe the fact that this paren really substitutes for a meta tag

			$Awfif::wsol-> {l} [awsoadr ($Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}])][2]

				= setupdesc (	$Awfif::memes-> {snnh} {stop},

					($Awfif::memes-> {snnh} {mcharbuffer}), #its an end edge

					$Awfif::memes-> {snnh} {mattrib},

					$Awfif::wsol-> {l} [awsoadr ($Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}])][2],

					awsoadr ($Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}]));

#			get rid of the closing chevron left over from the stop charbuffer keyword

			$char = '>';

			$$buffer =~ s/\Q$char//i;

			$char = '';

			$wascbp = '';

		elsif ($char eq "\n") {

			$$buffer =~ s/\Q$char//i;

		elsif (($Awfif::memes-> {comprocessing} == 1)

			) {#keyword has already processed the buffer

#old use		$convcst = time ();

			$$buffer =~ s/\Q$char//i;

			$char = '';

#old use		$convcet = time ();

#old use		$Awfif::memes-> {time} [$Awfif::memes-> {spctime}] [$Awfif::memes-> {ch}{$Awfif::codelet-> {l} [$myli] [2]}] [$Awfif::memes-> {convcsum}] = $Awfif::memes-> {time} [$Awfif::memes-> {spctime}] [$Awfif::memes-> {ch}{$Awfif::codelet-> {l} [$myli] [2]}] [$Awfif::memes-> {convcsum}] + $convcet - $convcst;

		elsif (($char eq '>')

		&& ( ($removekwcc) or ($wascomp) )

			) {#keyword has already processed the buffer

			$$buffer =~ s/\Q$char//i;

			$char = '';

			$removekwcc = '';

			$wascomp = '';

		elsif (($schar = ''.$char) ne ' ') {#hopefully force a number to be treated as a character rather than => else

			$convost = time ();

			if ($$insymbol) {

				my ($convoast, $convoaet);

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

				$convoast = time ();

				if ((Awfif::wsbasetype ( trwsoadr ($Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}], -1)) > 0)

				&& ((defined ($actbt)) && ($actbt)) #only activate if caller requires it

#				&& (($actbt ne '') && ($actbt))

				&& (Awfif::wsbasetype ( trwsoadr ($Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}],-1)) ==

					$Awfif::workspace-> {l} [$Awfif::wsol-> {l} [ awsoadr ( trwsoadr ($Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}],-1))] [2]][2])

				&& ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl} [wsbasetype ( trwsoadr ($Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}], -1))] > 0) ) {#activate the base type

					&Awfif::actnodes ($Awfif::workspace-> {l}[$Awfif::wsol-> {l}[ awsoadr ( trwsoadr ($Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}], -1))][2]][2], $Awfif::memes-> {descato}, $strscope);

					};#found basetype

				$convoaet = time ();

				$Awfif::memes-> {time} [$Awfif::memes-> {spctime}] [$Awfif::memes-> {ch}{$Awfif::codelet-> {l} [$myli] [2]}] [$Awfif::memes-> {convoasum}] = $Awfif::memes-> {time} [$Awfif::memes-> {spctime}] [$Awfif::memes-> {ch}{$Awfif::codelet-> {l} [$myli] [2]}] [$Awfif::memes-> {convoasum}] + $convoaet - $convoast;

				no strict 'refs';

				if (@$inmsymbol != 0) {

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

					};#deploy descriptors for meta tags

			else {

				$convwst = time ();

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

				$convwet = time ();

				$Awfif::memes-> {time} [$Awfif::memes-> {spctime}] [$Awfif::memes-> {ch}{$Awfif::codelet-> {l} [$myli] [2]}] [$Awfif::memes-> {convwsum}] = $Awfif::memes-> {time} [$Awfif::memes-> {spctime}] [$Awfif::memes-> {ch}{$Awfif::codelet-> {l} [$myli] [2]}] [$Awfif::memes-> {convwsum}] + $convwet - $convwst;

				};#if

			if (($char ne '<')

			or (unpack ('a', $$buffer) eq '<')

			) {#the keyword processor will have removed the < from the buffer even if it decides this isn't a keyword.

				$$buffer =~ s/\Q$char//i;

				};#if

			$char = '';

#			go back to current work space

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

			$convoet = time ();

			$Awfif::memes-> {time} [$Awfif::memes-> {spctime}] [$Awfif::memes-> {ch}{$Awfif::codelet-> {l} [$myli] [2]}] [$Awfif::memes-> {convosum}] = $Awfif::memes-> {time} [$Awfif::memes-> {spctime}] [$Awfif::memes-> {ch}{$Awfif::codelet-> {l} [$myli] [2]}] [$Awfif::memes-> {convosum}] + $convoet - $convost;

			}# else make char

		else {#its going to be classed as white space

			$convwst = time ();

			if ($$insymbol) {

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

				if ((Awfif::wsbasetype( trwsoadr ($Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}], -1)) > 0)

				&& ((defined ($actbt)) && ($actbt)) #only activate if caller requires it

				&& (Awfif::wsbasetype ( trwsoadr ($Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}], -1)) ==

					$Awfif::workspace-> {l} [$Awfif::wsol-> {l}[ awsoadr( trwsoadr ($Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}], -1))] [2]] [2])

				&& ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl} [ Awfif::wsbasetype ( trwsoadr ($Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}], -1))] > 0) ){#activate the base type

					&Awfif::actnodes ($Awfif::workspace-> {l}[$Awfif::wsol-> {l}[ awsoadr( trwsoadr ($Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}], -1))][2]][2], $Awfif::memes-> {descato}, $strscope);

				};#found basetype

				no strict 'refs';

				if (@$inmsymbol != 0) {

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

					};#deploy descriptors for meta tags

			else {

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

				};#if

			$$buffer =~ s/\Q$char//i;

#			go back to current work space

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

			$convwet = time ();

			$Awfif::memes-> {time} [$Awfif::memes-> {spctime}] [$Awfif::memes-> {ch}{$Awfif::codelet-> {l} [$myli] [2]}] [$Awfif::memes-> {convwsum}] = $Awfif::memes-> {time} [$Awfif::memes-> {spctime}] [$Awfif::memes-> {ch}{$Awfif::codelet-> {l} [$myli] [2]}] [$Awfif::memes-> {convwsum}] + $convwet - $convwst;

};

		$char = unpack ('a', $$buffer); #prime char

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

			print ("convbws char($char) ");

			};# trace

		};# while to process each char in the record

	$convet = time ();

	$Awfif::memes-> {time} [$Awfif::memes-> {spctime}] [$Awfif::memes-> {ch}{$Awfif::codelet-> {l} [$myli] [2]}] [$Awfif::memes-> {convbsum}] = $Awfif::memes-> {time} [$Awfif::memes-> {spctime}] [$Awfif::memes-> {ch}{$Awfif::codelet-> {l} [$myli] [2]}] [$Awfif::memes-> {convbsum}] + $convet - $convst;

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

		print ("convbwsx\n");

		};# trace

	} # end of convbws

sub flagkws {

	my ($kwai, $ptstoptf, $ptstarttf, $ptrecordtf, $ptmrf, $ptmbf, $ptmgf, $ptmtf, $ptwindtf, $ptunwindtf, $ptmhf)=@_;

	my ($i, $akwai, $cwsbi);

#	flag the keywords matched in the workspace

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

		print ("flagkws kwai $kwai ");

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

	$$ptstoptf = '';

	$$ptstarttf = '';

	$$ptrecordtf = '';

	$$ptmrf = '';

	$$ptmbf = '';

	$$ptmgf = '';

	$$ptmtf = '';

	$$ptmhf = '';

	$$ptunwindtf = '';

	$$ptwindtf = '';

#	work with the meta keyword workspace

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

	$akwai = awsoadr ($kwai);

	for ($i = $Awfif::wsol-> {l}[$akwai][2];$i < ($Awfif::wsol-> {l}[$akwai][2] + $Awfif::wsol-> {l}[$akwai][3]); $i++) {

		if ($Awfif::memes-> {keywordl}[$i] eq 'ptstartt') {

			$$ptstarttf = 't';

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

			$$ptstoptf = 't';

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

			$$ptrecordtf = 't';

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

			$$ptwindtf = 't';

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

			$$ptunwindtf = 't';

};

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

			$$ptmgf = 't';

};

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

			$$ptmbf = 't';

};

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

			$$ptmrf = 't';

};

# flagkwstel

		if (($Awfif::memes-> {keywordl}[$i] eq 'pttelomerestt') or ($Awfif::memes-> {keywordl}[$i] eq 'pttelomerespt')) {

			$$ptmtf = 't';

};

# flagkwshis

		if ($Awfif::memes-> {keywordl}[$i] eq 'ptmhistt' ) {

			$$ptmhf = 't';

};

		};#for tokens keywords

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

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

		print ("flagkwsx ptstoptf ($$ptstoptf) ptstarttf ($$ptstarttf) ptrecordtf ($$ptrecordtf) ptmrf ($$ptmrf) ptmbf ($$ptmbf) ptmgf ($$ptmgf) ptmtf ($$ptmtf) ptwindtf ($$ptwindtf) ptunwindtf ($$ptunwindtf) ret $akwai\n");

		};# trace

	return $akwai

	} # end of flagkws

sub addwsoli {

	my ($list) = @_;

#	setup the structures to support linked buffers

	my ($pflink, $plink, $nslinkh, $aahead, $newhead, $headsentl);

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

		print ("addwsoli ");

};

	if ( ($Awfif::memes-> {chckadd})

	&& (($$list-> {f} < 0)

	or ($$list-> {t} <0)

	or ($$list-> {f} >= $$list-> {p})

	or ($$list-> {t} >= $$list-> {p})

	or (($$list-> {f} != 0)

	&& ($Awfif::wsol-> {l}[$$list-> {f}][ $Awfif::memes-> {wsowsi}] != 0) ) #*** submacrok ***#

	or (($$list-> {t} != 0)

	&& ($Awfif::wsol-> {l}[$$list-> {t}][ $Awfif::memes-> {wsowsi}] != 0) ) #*** submacrok ***#

	) {&break()};

#	setup the links data

#	the head and tail of this virtual workspace are managed here

	$newhead = '';

#	if the tail is 0 then set it to 1 and initialise the head to 1

	if ($Awfif::wsbl-> {newhead}[$Awfif::memes-> {currentwsbi}]) {

		$aahead = 0;

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

		$newhead = 't';

	else {

		$aahead = awsoadrd ($Awfif::wsbl-> {wsoh}[$Awfif::memes->{currentwsbi}]);

};

#	create an active descriptor

	$pflink = $$list-> {f};

	if (($pflink != 0 )

	&& (($newhead) or ($pflink != $Awfif::wsbl-> {l} [$Awfif::memes-> {currentwsbi}][2]) or (canrejfwso (\$pflink, \$$list)))

){

#		can reclaim one from the inactive list

#		The inactive list can use absolute addressing

		if ($Awfif::wsol-> {l}[$pflink][ $Awfif::memes-> {wsowsi}] != 0) #*** submacrok ***#

		{&break()};

		$$list-> {flistl}--;

		$plink = $Awfif::wsol-> {l}[$pflink][ $Awfif::memes-> {wsoprev}]; #*** submacrok ***#

		if ($plink != 0) {

			$Awfif::wsol-> {l}[$plink][ $Awfif::memes-> {wsonext}] =  0; #*** submacrok ***#

			$$list-> {f} = $plink;

			} # if

		else {#zero the free head ptr

			$$list-> {f} = 0;

			$$list-> {t} = 0;

};

		$headsentl = $Awfif::wsol-> {l}[awsoadrd ($Awfif::wsbl-> {wsoh}[$Awfif::memes-> {currentwsbi}])][ $Awfif::memes-> {wsonext}]; #*** submacrok ***#

#		if this is a new head and the ws uses arch sentinals need to setup ws base and offset

		if (($newhead) && ($Awfif::wsbl-> {wsas}[$Awfif::memes->{currentwsbi}])) {#create sentinals

#			the base + 1 must be the real address of the first item since that is the tail

			$Awfif::wsbl-> {l}[$Awfif::memes->{currentwsbi}][2] = $pflink-1;#base

			$Awfif::wsbl-> {l}[$Awfif::memes->{currentwsbi}][3] = 0;#offset

			$Awfif::wsbl-> {ofssum} [$Awfif::memes->{currentwsbi}] = 0;

			};#setup the ws base and offset

#		The control data structures can use absolute addressing still

		if ((!$Awfif::wsbl-> {wsas}[$Awfif::memes-> {currentwsbi}]) or ($newhead) or ($Awfif::wsbl-> {wsss}[$Awfif::memes-> {currentwsbi}])) {# don't move the head if this is a sentinal

			$Awfif::wsbl-> {wsoh}[$Awfif::memes->{currentwsbi}] = grwsoadr ($pflink);

};

#		the wsol head should have a sentinal in its 16 if architected sentinals in use so must remember this rel address as we restructure this

		if (!$newhead) {

			$Awfif::wsol-> {l}[$aahead][ $Awfif::memes-> {wsonext}] =  grwsoadr ($pflink); #*** submacrok ***#

#			setup the relative environment

			$Awfif::wsol-> {l}[$pflink][ $Awfif::memes-> {wsoprev}] =  grwsoadr ($aahead); #*** submacrok ***#

			if (($Awfif::wsbl-> {wsas}[$Awfif::memes->{currentwsbi}]) && ($Awfif::wsbl-> {wsss}[$Awfif::memes-> {currentwsbi}])) {#head sentinal needs setting up

				$Awfif::wsol-> {l}[$pflink][ $Awfif::memes-> {wsonext}] =  $headsentl; #*** submacrok ***#

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

			else {

				$Awfif::wsol-> {l}[$pflink][ $Awfif::memes-> {wsonext}] =  0; #*** submacrok ***#

				};#else

			};#if

		$nslinkh = $pflink;

		}# found free links

	else {

#		if there weren't any then get a newone

#		if this is a new head and the ws uses arch sentinals need to setup ws base and offset

		$aahead = newwsolink ($aahead, \$$list);

		$$list-> {tlistl}++;

		$nslinkh = $aahead;

		if ((!$Awfif::wsbl-> {wsas}[$Awfif::memes-> {currentwsbi}]) or ($newhead) or ($Awfif::wsbl-> {wsss}[$Awfif::memes-> {currentwsbi}])) {# don't move the head if this is a sentinal

#			The head is really a relative index of the head of this workspace.

			$Awfif::wsbl-> {wsoh}[$Awfif::memes-> {currentwsbi}] = grwsoadr ($nslinkh);

};

		}; #else

#	now have a descriptor but it may need sentinals (flagged by $newhead with {wsas})

	if (($newhead) && ($Awfif::wsbl-> {wsas}[$Awfif::memes->{currentwsbi}])) {#create sentinals

		my ($headsi, $aheadsi, $tailsi, $atailsi, $ahdptr);

#		tail sentinal

		$tailsi = addwsoli (\$Awfif::wsol);

		$atailsi = awsoadrd ($tailsi);

#		fix up the pointers

		$Awfif::wsol-> {l}[$atailsi][ $Awfif::memes-> {wsowsi}] =  $Awfif::memes-> {currentwsbi}; #*** submacrok ***#

		$Awfif::wsol-> {l}[$atailsi][ $Awfif::memes-> {wsoprev}] =  0; #*** submacrok ***#

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

#		head sentinal

		$headsi = addwsoli (\$Awfif::wsol);

		$aheadsi = awsoadrd ($headsi);

#		fix up the pointers

		$Awfif::wsol-> {l}[$aheadsi][ $Awfif::memes-> {wsowsi}] =  $Awfif::memes-> {currentwsbi}; #*** submacrok ***#

		$Awfif::wsol-> {l}[$aheadsi][ $Awfif::memes-> {wsonext}] =  0; #*** submacrok ***#

		$Awfif::wsol-> {l}[$aheadsi][ $Awfif::memes-> {wsoprev}] =  $Awfif::wsbl-> {wsoh} [$Awfif::memes-> {currentwsbi}]; #*** submacrok ***#

#		and the head's pointers

		$ahdptr = awsoadrd ($Awfif::wsbl-> {wsoh} [$Awfif::memes-> {currentwsbi}]);

		$Awfif::wsol-> {l}[$ahdptr][ $Awfif::memes-> {wsowsi}] =  $Awfif::memes-> {currentwsbi}; #*** submacrok ***#

		$Awfif::wsol-> {l}[$ahdptr][ $Awfif::memes-> {wsonext}] =  $headsi; #*** submacrok ***#

		$Awfif::wsol-> {l}[$ahdptr][ $Awfif::memes-> {wsoprev}] =  $tailsi; #*** submacrok ***#

		$Awfif::wsbl-> {wsss}[$Awfif::memes-> {currentwsbi}] = 't';

# addwsolitelhd

#		add the telomeric root to the tail sentinal of the workspace

		&deptelhd ($Awfif::memes-> {currentwsbi});

		};#if should create the sentinals

#	switch to relative addressing

	$nslinkh = grwsoadr ($nslinkh);

#	The head is really a relative index of the head of this workspace.

	if ( ($Awfif::memes-> {chckadd})

	&& (($$list-> {f} < 0)

	or ($$list-> {t} <0)

	or ($$list-> {f} >= $$list-> {p})

	or ($$list-> {t} >= $$list-> {p})

	or (($$list-> {f} != 0)

	&& ($Awfif::wsol-> {l}[$$list-> {f}][ $Awfif::memes-> {wsowsi}] != 0) ) #*** submacrok ***#

	or (($$list-> {t} != 0)

	&& ($Awfif::wsol-> {l}[$$list-> {t}][ $Awfif::memes-> {wsowsi}] != 0) ) #*** submacrok ***#

	) {&break()};

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

		print ("addwsolix ret $nslinkh\n");

};

	return $nslinkh

	}# addwsolix

sub canrejfwso {# The caller can't accept this free chain wso move it from head if can or

	my ($pflink, $list) = @_;

	my ($result);

	$result = '';

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

	if ($$pflink == $$list-> {t}) {#can't reject this item its the only one

#		setup the first list element

		$$pflink = 0;

	else {#can reject this item

		my ($of, $ot, $ofws14, $ofws16, $nfws14, $nfws16);

#		by moving it to the tail of the free list

#		and returning the new head of the free list

		$result = 't';

		$of = $$list-> {f};

		$ot = $$list-> {t};

		$ofws14 = $Awfif::wsol-> {l}[$$list-> {f}][ $Awfif::memes-> {wsoprev}]; #*** submacrok ***#

		$ofws16 = $Awfif::wsol-> {l}[$$list-> {f}][ $Awfif::memes-> {wsonext}]; #*** submacrok ***#

		$nfws14 = checkwsmd (

			$Awfif::wsol-> {l}[$$list-> {f}][ $Awfif::memes-> {wsoprev}] #*** submacrok ***#

			,$Awfif::memes-> {wsoprev});

		$nfws16 = checkwsmd (

			$Awfif::wsol-> {l}[$$list-> {f}][ $Awfif::memes-> {wsoprev}]   #*** submacrok ***#

			,$Awfif::memes-> {wsonext});

		$$pflink = $Awfif::wsol-> {l}[$$list-> {f}][ $Awfif::memes-> {wsoprev}]; #*** submacrok ***#

		$$list-> {t} = $of;

#		make {f} point to new pflink

		$$list-> {f} = $$pflink;

#		tail the rejected item

		$Awfif::wsol-> {l}[$$list-> {f}][ $Awfif::memes-> {wsonext}] =  0; #*** submacrok ***#

		$Awfif::wsol-> {l}[$of][ $Awfif::memes-> {wsoprev}] =  0; #*** submacrok ***#

		$Awfif::wsol-> {l}[$of][ $Awfif::memes-> {wsonext}] =  $ot; #*** submacrok ***#

		$Awfif::wsol-> {l}[$ot][ $Awfif::memes-> {wsoprev}] =  $of; #*** submacrok ***#

		};#else

	if (($$list-> {f} < 0)

	or ($$list-> {t} <0)

	or ($$list-> {f} >= $$list-> {p})

	or ($$list-> {t} >= $$list-> {p})

	or (($$list-> {f} != 0)

	&& ($Awfif::wsol-> {l}[$$list-> {f}][ $Awfif::memes-> {wsowsi}] != 0) ) #*** submacrok ***#

	or (($$list-> {t} != 0)

	&& ($Awfif::wsol-> {l}[$$list-> {t}][ $Awfif::memes-> {wsowsi}] != 0) ) #*** submacrok ***#

	) {&break()};

	return $result;

	} # canrejfwso

sub newwsolink {# This knows the wsobjectl is an array and so free list is absolute addressed

	my ($froml, $larrayref) = @_;# currently assumes froml is a relative head address or 0

	my ($link, $headsentl);

	no strict 'refs';

	if ($froml == 0) {#start new set of links

#		setup the first list element

		$Awfif::wsol-> {l}[$$larrayref-> {p}][ $Awfif::memes-> {wsoprev}] =  0; #*** submacrok ***#

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

#		note the head

		$link = $$larrayref-> {p};

		if (($Awfif::wsbl-> {wsas}[$Awfif::memes->{currentwsbi}])) {#base and offset need setting up

			$Awfif::wsbl-> {l}[$Awfif::memes->{currentwsbi}][2] = $link-1;#base

			$Awfif::wsbl-> {l}[$Awfif::memes->{currentwsbi}][3] = 0;#offset

			};#setup the ws base and offset

	else {#add a link to this set

		$headsentl = $Awfif::wsol-> {l}[$froml][ $Awfif::memes-> {wsonext}]; #*** submacrok ***#

		$Awfif::wsol-> {l}[$froml][ $Awfif::memes-> {wsonext}] =  grwsoadr ($$larrayref-> {p}); #*** submacrok ***#

#		setup the relative environment

		$Awfif::wsol-> {l}[$$larrayref-> {p}][ $Awfif::memes-> {wsoprev}] =  grwsoadr($froml); #*** submacrok ***#

		if (($Awfif::wsbl-> {wsas}[$Awfif::memes->{currentwsbi}]) && ($Awfif::wsbl-> {wsss}[$Awfif::memes-> {currentwsbi}])) {#head sentinal needs setting up

			my ($ahs);

			$ahs = awsoadrd ($headsentl);

			$Awfif::wsol-> {l}[$$larrayref-> {p}][ $Awfif::memes-> {wsonext}] =  $headsentl; #*** submacrok ***#

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

		else {

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

			};#else

#		note the head

		$link = $$larrayref-> {p};

};

	$$larrayref-> {p}++;

	return $link;

	} # newwsolink

#	freewso has a bad block structure layout

sub freewso {# This moves a wso to the free list of $Awfif::wsol

	my ($wso) = @_;#

	my ($awso, $previous, $next, $fprevious, $fnext, $fpws, $fnws, $cwsbi, $zombie, $kws, $rgsponsor);

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

	or ($Awfif::wsol-> {t} <0)

	or ($Awfif::wsol-> {f} >= $Awfif::wsol-> {p})

	or ($Awfif::wsol-> {t} >= $Awfif::wsol-> {p})

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

	&& ($Awfif::wsol-> {l}[$Awfif::wsol-> {f}][ $Awfif::memes-> {wsowsi}] != 0) ) #*** submacrok ***#

	or (($Awfif::wsol-> {t} != 0)

	&& ($Awfif::wsol-> {l}[$Awfif::wsol-> {t}][ $Awfif::memes-> {wsowsi}] != 0) ) #*** submacrok ***#

	) {&break()};

	$next = 0;

	$zombie = '';

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

	$awso = awsoadr ($wso);

	if ($Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsowsi}] != $cwsbi) { #*** submacrok ***#

		&break ();

};

	$kws = getwsost4 ($wso);

#	free the wso descriptors

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

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

		};#while

	while ($Awfif::wsol-> {l} [$awso] [8] != 0) {

		$Awfif::wsol-> {l} [$awso] [8] = freedesc ($Awfif::wsol-> {l} [$awso] [8]);

		};#while

#	set wsol [2], [8], [10], [13] descriptor data to 0

	$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsologucount}] =  0; #*** submacrok ***#

	$rgsponsor = $Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsogcsponsor}]; #*** submacrok ***#

	if ($rgsponsor != 0) {

		my ($ngcsponsor);

		$ngcsponsor =

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

		if (($Awfif::memes-> {freewsongcspbreak}) && ($ngcsponsor != 0) && ($Awfif::memes-> {currentwsbi} == 3)) {&break ()};

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

			};#if

#		remember the wso details

		$Awfif::wsol->{flistl}++;

		$previous = $Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsoprev}]; #*** submacrok ***##follow from the head back through previous

		$next = $Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsonext}]; #*** submacrok ***#

		$fprevious = $Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsobkwl}]; #*** submacrok ***#

		$fnext = $Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsofkwl}]; #*** submacrok ***#

		$fpws = $Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsobws}]; #*** submacrok ***#

		$fnws = $Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsofws}]; #*** submacrok ***#

# freewsocc

#		clear out the cached details

		$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsobastype}] =  undef(); #*** submacrok ***#

		$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsobasind}] =  undef(); #*** submacrok ***#

		$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsopkpos}] =  undef(); #*** submacrok ***#

# freewsobf

		$Awfif::wsol-> {fbs} [$awso] = undef ();

#		if this wso is the master of a keyword this info must be moved to the next in chain

		if ($Awfif::wsol-> {l} [$awso][4] ne '') {

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

				$Awfif::wsol-> {l} [$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsofkwl}]][4] = $Awfif::wsol-> {l} [$awso][4]; #*** submacrok ***#

			else {

				$zombie = 't';

};

			};#if

#		or if there is none this wso must remain as a zombie linked into the keyword list

#		not sure how to do that correctly or if it can occur

#		purge the contents of the wso

		$Awfif::wsol-> {l} [$awso] = ();

		$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsobkwl}] =  0; #*** submacrok ***#

		$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsofkwl}] =  0; #*** submacrok ***#

		$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsobasind}] =  0; #*** submacrok ***#

		$rgsponsor = $Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsogcsponsor}]; #*** submacrok ***#

		if ($rgsponsor != 0) {

			my ($ngcsponsor);

			$ngcsponsor =

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

			if (($Awfif::memes-> {freewsongcspbreak}) && ($ngcsponsor != 0) && ($Awfif::memes-> {currentwsbi} == 3)) {&break ()};

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

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

			};#if

		$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsogcsponsor}] =  0; #*** submacrok ***#

		$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsogcsponsored}] =  0; #*** submacrok ***#

		$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsoprev}] =  0; #*** submacrok ***#

		$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsowsi}] =  0; #*** submacrok ***#

		$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsonext}] =  0; #*** submacrok ***#

		$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsobws}] =  0; #*** submacrok ***#

		$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsofws}] =  0; #*** submacrok ***#

		$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsoitstr}] =  0; #*** submacrok ***#

		$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsotdg}] =  0; #*** submacrok ***#

		$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsofgrp}] =  0; #*** submacrok ***#

		$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsotdb}] =  0; #*** submacrok ***#

		$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsobug}] =  0; #*** submacrok ***#

		$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsoisterm}] =  0; #*** submacrok ***#

		$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsobti}] =  0; #*** submacrok ***#

		$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsobus}] =  0; #*** submacrok ***#

		$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsogcjhlsi}] =  0; #*** submacrok ***#

		$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsohistbp}] =  0; #*** submacrok ***#

		$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsogcspjhlsi}] =  0; #*** submacrok ***#

		$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsocstarts}] =  0; #*** submacrok ***#

		$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsocbegins}] =  0; #*** submacrok ***#

		$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsopkwsi}] =  0; #*** submacrok ***#

		$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsosyncl}] =  0; #*** submacrok ***#

		$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsosponsorgs}] =  0; #*** submacrok ***#

		$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsosponsort}] =  0; #*** submacrok ***#

		$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsosubpid}] =  0; #*** submacrok ***#

		$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsogstart}] =  0; #*** submacrok ***#

		$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsogend}] =  0; #*** submacrok ***#

#		link the wso into the free list

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

#			empty free list

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

				$Awfif::wsol-> {f} = $awso;

				$Awfif::wsol-> {t} = $awso;

				$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsoprev}] =  0; #*** submacrok ***#

				$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsonext}] =  0; #*** submacrok ***#

				}# 0

			else {#just one element in the free list - adding new element to be head

				$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsoprev}] =  $Awfif::wsol-> {f}; #*** submacrok ***#

				$Awfif::wsol-> {f} = $awso;

				$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsonext}] =  0; #*** submacrok ***#

				$Awfif::wsol-> {l}[$Awfif::wsol-> {t}][ $Awfif::memes-> {wsonext}] =  $awso; #*** submacrok ***#

				};#else

			}#if

		else {#add at the free head

			$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsoprev}] =  $Awfif::wsol-> {f}; #*** submacrok ***#

			$Awfif::wsol-> {l}[$Awfif::wsol-> {f}][ $Awfif::memes-> {wsonext}] =  $awso; #*** submacrok ***#

			$Awfif::wsol-> {f} = $awso;

			$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsonext}] =  0; #*** submacrok ***#

			};#else

#		link the workspace together - this assumption will not work for deleting the final wso

		$Awfif::wsol-> {l}[awsoadr ($previous)][ $Awfif::memes-> {wsonext}] =  $next; #*** submacrok ***#

# freewswinu

#		if the wso is in the workspace window then move the window to the previous

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

			$Awfif::wsbl-> {winkwp} [$cwsbi] = $previous;

			};#if

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

			$Awfif::wsbl-> {winkwpr} [$cwsbi] = $previous;

			};#if

		$Awfif::wsol-> {l}[awsoadr ($next)][ $Awfif::memes-> {wsoprev}] =  $previous; #*** submacrok ***#

#		link the function list together

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

		$Awfif::wsol-> {l}[awsoadr ($fprevious)][ $Awfif::memes-> {wsofkwl}] =  $fnext; #*** submacrok ***#

		$Awfif::wsol-> {l}[awsoadr ($fprevious)][ $Awfif::memes-> {wsofws}] =  $fnws; #*** submacrok ***#

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

		$Awfif::wsol-> {l}[awsoadr (awsoadr ($fnext))][ $Awfif::memes-> {wsobkwl}] =  $fprevious; #*** submacrok ***#

		$Awfif::wsol-> {l}[awsoadr ($fnext)][ $Awfif::memes-> {wsobws}] =  $fpws; #*** submacrok ***#

#		correct the hash pointers if the deleted wso was addressed by the hash

		if (($Awfif::memes-> {keywordwsih}-> {$kws} == $cwsbi)

		&& ($Awfif::memes-> {keywordh}-> {$kws} == $wso)

){

			$Awfif::memes-> {keywordh}-> {$kws} = $fprevious;

			$Awfif::memes-> {keywordwsih}-> {$kws} = $fpws;

};

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

		or ($Awfif::wsol-> {t} <0)

		or ($Awfif::wsol-> {f} >= $Awfif::wsol-> {p})

		or ($Awfif::wsol-> {t} >= $Awfif::wsol-> {p})

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

		&& ($Awfif::wsol-> {l}[$Awfif::wsol-> {f}][ $Awfif::memes-> {wsowsi}] != 0) ) #*** submacrok ***#

		or (($Awfif::wsol-> {t} != 0)

		&& ($Awfif::wsol-> {l}[$Awfif::wsol-> {t}][ $Awfif::memes-> {wsowsi}] != 0) ) #*** submacrok ***#

		) {&break()};

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

	return $next;

	} # freewso

sub toofewwso {# This checks the wso list has at least count members from s to e or 0

	my ($wsoe, $wsos, $mint) = @_;

	my ($result, $rlink, $count);

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

		print ("toofewwso wsoe $wsoe wsos $wsos mint $mint ");

};

	$result = 't';

	$rlink = $wsos;

	$count = $mint;

	while (($rlink != $wsoe) && (awsoadr($rlink) != 0) && (($count--) != 0) && (($rlink = trwsoadr ($rlink, 1)) != 0)) {

		if ((wsbasetype ($rlink) == $Awfif::memes-> {snnh}{ichar})

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

			$count++;

			};#if

		if ($count <= 0) {

			$result = '';

			};#if

};

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

		print ("toofewwsox ret ($result)\n");

};

	return $result;

	} # toofewwso

sub greaterwso {# This returns true if wso2 follows in list after wso1

	my ($wso2, $wso1) = @_;

	my ($result, $rlink);

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

		print ("greaterwso wso2 $wso2 wso1 $wso1 ");

};

	$result = '';

	$rlink = $wso1;

	if (trwsoadr ($rlink, -1) != $wso2) {#if wso2 is pred of wso1 then just return false

		while (($rlink != $wso2) && (awsoadr($rlink) != 0) && (($rlink = trwsoadr ($rlink, 1)) != 0)) {

			if ($rlink == $wso2) {

				$result = 't';

				};# if

			};#while

		};#if

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

		print ("greatergwsox ret ($result)\n");

};

	return $result;

	} # greaterwso

sub greatergwso {# This returns true if wso2 follows in list after wso1

	my ($wso2, $wso1) = @_;

	my ($result, $rlink);

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

		print ("greatergwso wso2 $wso2 wso1 $wso1 ");

};

	$result = '';

	$rlink = $wso1;

	if ($wso1 == $Awfif::wsbl->{wsft}[$Awfif::memes-> {currentwsbi}]) {

		$result = 't';#for a group assume that wso2 must be above the fast tail

		}#if

	elsif ($wso2 == $Awfif::wsbl->{wsoh}[$Awfif::memes-> {currentwsbi}]) {

		$result = 't';

		}#elsif

	elsif ($wso2 == $Awfif::wsbl->{wsft}[$Awfif::memes-> {currentwsbi}]) {

		$result = '';#for a group assume that wso2 must be above the fast tail

		}#if

	elsif ($wso1 == $Awfif::wsbl->{wsoh}[$Awfif::memes-> {currentwsbi}]) {

		$result = '';

		}#elsif

	elsif (trwsoadr ($rlink, -1) != $wso2) {#if wso2 is pred of wso1 then just return false

		while (($rlink != $wso2) && (awsoadr($rlink) != 0) && (wsbasetype ($rlink) != $Awfif::memes->{snnh}{ichar}) && (($rlink = trwsoadr ($rlink, 1)) != 0)) {

			if ($rlink == $wso2) {

				$result = 't';

				};# if

			};#while

		};#if

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

		print ("greatergwsox ret ($result)\n");

};

	return $result;

	} # greatergwso

sub setfwst {# This sets the fast workspace tail

	my ($wsoe, $wsos, $ws) = @_;

	my ($result, $rlink, $found, $cwsbi);

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

		print ("setfwst wsoe $wsoe wsos $wsos");

};

	$result = $wsos;

	$found = '';

	$rlink = $wsos;

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

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

	while ((!($found)) && ($rlink != $wsoe) && (awsoadr($rlink) != 0) ) {

		if ((wsbasetype ($rlink) == $Awfif::memes-> {snnh}{ichar})

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

			$found = '';

			}#if

		else {

			$found = 't';

			$result = $rlink;

			};#else

		if (($rlink = trwsoadr ($rlink, 1)) == 0) {

			$found = 't';

			};#if

		};#while

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

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

		print ("setfwstx ret ($result)\n");

};

	return $result;

	} # setfwst

sub stripichar {# This consolidates all the white space and ichar blocks of more than two items - leaving two actively in place

	my ($wsoe, $ws) = @_;

	my ($result, $rlink, $orlink, $count, $cwsbi, $succeeded);

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

		print ("stripichar wsoe $wsoe ws $ws ");

};

	$succeeded = 't';

	$count = 0;

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

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

	$rlink = trwsoadr ($Awfif::wsbl-> {wsft}[$ws], 1);

	while ( ($rlink != $wsoe) && (awsoadr($rlink) != 0) && ($succeeded) ){

		if (((wsbasetype ($rlink) == $Awfif::memes-> {snnh}{ichar}) )

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

			if ($count <= 3 ) {

				$count++;

				$rlink = trwsoadr ($rlink, 1);

				};#if

			if ($count > 3) {

				$orlink = $rlink;

				$rlink = trwsoadr ($rlink, 1);

				$succeeded = relinkwsobwsft ($orlink);

				};#if

			}#if have some enough to relink

		else {

			$count = 0;

			$rlink = trwsoadr ($rlink, 1);

			};#else

};

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

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

		print ("stripicharx ret ($result)\n");

};

	return $result;

	} # stripichar

sub relinkwsobwsft {# This relinks a wso so that it is logically in the set prior to the fast tail wsft

	my ($wso) = @_;

	my ($awso, $previous, $next, $cwsbi, $result);

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

		print ("relinkwsobwsft wso $wso");

};

	$result = '';

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

	$awso = awsoadr ($wso);

#	remember the wso details

	$previous = $Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsoprev}];#*** submacrok ***##follow from the head back through previous

	$next = $Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsonext}];#*** submacrok ***#

#	link the wso into the pre wsft list

	if ( ($Awfif::wsbl-> {wsft}[$cwsbi] ne '')

	&& ($Awfif::wsbl-> {wsft}[$cwsbi] != $Awfif::wsbl-> {wsot}[$cwsbi])

) {

#		relink the wso

		$result = 't';

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

			$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsohistbp}] =  0;#*** submacrok ***#

};

		&setwsmd ($awso, $Awfif::memes-> {wsoprev},

			$Awfif::wsol-> {l}[awsoadr ($Awfif::wsbl-> {wsft}[$cwsbi])][ $Awfif::memes-> {wsoprev}]#*** submacrok ***#

);

		$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsonext}] =  $Awfif::wsbl-> {wsft}[$cwsbi];#*** submacrok ***#

#		link the two associates together

		$Awfif::wsol-> {l}[awsoadr ($next)][ $Awfif::memes-> {wsoprev}] =  $previous;#*** submacrok ***#

		$Awfif::wsol-> {l}[awsoadr ($previous)][ $Awfif::memes-> {wsonext}] =  $next;#*** submacrok ***#

#		link the two new associates to the wso

		&setwsmd ( awsoadr (

			$Awfif::wsol-> {l}[awsoadr($Awfif::wsbl-> {wsft}[$cwsbi])][$Awfif::memes-> {wsoprev} ]#*** submacrok ***#

			), $Awfif::memes-> {wsonext}, $wso);

		$Awfif::wsol-> {l}[ awsoadr ($Awfif::wsbl-> {wsft}[$cwsbi])][ $Awfif::memes-> {wsoprev}] =  $wso;#*** submacrok ***#

		};#if

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

		print ("relinkwsobwsftx ret ($result)\n");

};

	return $result

	} # relinkwsobwsft

sub checkwsbf {# This supports the addressing of a two bit flag in the wso bit vector

	my ($awso, $index) = @_;

	my ($result);

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

#		print ("checkwsbf awso $awso index $index ");

#		};

	if ($Awfif::memes-> {usewsobfdirect}) {

		$result = $Awfif::wsolfbs [$awso] [$index - $Awfif::memes-> {flagsoffset}];

		}#if

	else {

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

		};#else

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

#		print ("checkwsbfx ret ($result)\n");

#		};

	return $result

	} # checkwsbf

sub setwsbf {# This supports the addressing and setting of a two bit flag in the wso bit vector

	my ($awso, $index, $value) = @_;

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

#		print ("setwsbf awso $awso index $index value $value ");

#		};

	if ($Awfif::memes-> {usewsobfdirect}) {

		$Awfif::wsolfbs [$awso] [$index - $Awfif::memes-> {flagsoffset}] = $value;

		}#if

	else {

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

		};#else

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

#		print ("setwsbfx \n");

#		};

	} # setwsbf

#<!-- start tag uts -->

sub checkwsmd { #*** ndefmacro ***#

	my ($awso, $index) = @_; #*** pdefmacro ***#

	my ($result);

# This supports the addressing of mapped data in the wso vector storage

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

		print ("checkwsmd awso $awso index $index ");

};

	if ($Awfif::memes-> {usewsodirect}) {

		$result = $Awfif::wsol-> {l}[$awso][$index]; #*** repdefmacro ***#

		}#if

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

	or ($index == $Awfif::memes-> {wsofkwl})

	or ($index == $Awfif::memes-> {wsobasind})

	or ($index == $Awfif::memes-> {wsogcsponsor})

	or ($index == $Awfif::memes-> {wsogcsponsored})

	or ($index == $Awfif::memes-> {wsotdb})

	or ($index == $Awfif::memes-> {wsobug})

	or ($index == $Awfif::memes-> {wsoisterm})

	or ($index == $Awfif::memes-> {wsobti})

	or ($index == $Awfif::memes-> {wsobus})

	or ($index == $Awfif::memes-> {wsoitstr})

	or ($index == $Awfif::memes-> {wsotdg})

	or ($index == $Awfif::memes-> {wsogstart})

	or ($index == $Awfif::memes-> {wsogend})

){

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

		}#elsif

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

	or ($index == $Awfif::memes-> {wsobws})

	or ($index == $Awfif::memes-> {wsofws})

	or ($index == $Awfif::memes-> {wsobastype})

	or ($index == $Awfif::memes-> {wsogcspjhlsi})

	or ($index == $Awfif::memes-> {wsogcjhlsi})

	or ($index == $Awfif::memes-> {wsopkwsi})

	or ($index == $Awfif::memes-> {wsocbegins})

	or ($index == $Awfif::memes-> {wsocstarts})

	or ($index == $Awfif::memes-> {wsopkpos})

	or ($index == $Awfif::memes-> {wsologucount})

	or ($index == $Awfif::memes-> {wsosubpid})

	or ($index == $Awfif::memes-> {wsosponsorgs})

	or ($index == $Awfif::memes-> {wsosponsort})

){

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

		}#elsif

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

	or ($index == $Awfif::memes-> {wsologaei})

){

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

		}#elsif

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

){

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

		};#elsif

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

		print ("checkwsmdx ret ($result)\n");

};

	return $result #*** rdefmacro ***#

	} # checkwsmd

#<!-- end tag uts -->

sub setwsmd {# This supports the addressing and setting of a mapped data in the wso vector storage #*** ndefmacro ***#

	my ($awso, $index, $value) = @_; #*** pdefmacro ***#

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

		print ("setwsmd awso $awso index $index value $value ");

};

	if ($Awfif::memes-> {usewsodirect}) {

		$Awfif::wsol-> {l}[$awso][$index] = $value; #*** repdefmacro ***#

		}#if

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

	or ($index == $Awfif::memes-> {wsofkwl})

	or ($index == $Awfif::memes-> {wsobasind})

	or ($index == $Awfif::memes-> {wsogcsponsor})

	or ($index == $Awfif::memes-> {wsogcsponsored})

	or ($index == $Awfif::memes-> {wsoprev})

	or ($index == $Awfif::memes-> {wsonext})

	or ($index == $Awfif::memes-> {wsotdb})

	or ($index == $Awfif::memes-> {wsobug})

	or ($index == $Awfif::memes-> {wsoisterm})

	or ($index == $Awfif::memes-> {wsobti})

	or ($index == $Awfif::memes-> {wsobus})

	or ($index == $Awfif::memes-> {wsoitstr})

	or ($index == $Awfif::memes-> {wsotdg})

	or ($index == $Awfif::memes-> {wsogstart})

	or ($index == $Awfif::memes-> {wsogend})

){

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

		}#if

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

	or ($index == $Awfif::memes-> {wsobws})

	or ($index == $Awfif::memes-> {wsofws})

	or ($index == $Awfif::memes-> {wsobastype})

	or ($index == $Awfif::memes-> {wsogcspjhlsi})

	or ($index == $Awfif::memes-> {wsogcjhlsi})

	or ($index == $Awfif::memes-> {wsopkwsi})

	or ($index == $Awfif::memes-> {wsocbegins})

	or ($index == $Awfif::memes-> {wsocstarts})

	or ($index == $Awfif::memes-> {wsopkpos})

	or ($index == $Awfif::memes-> {wsologucount})

	or ($index == $Awfif::memes-> {wsosubpid})

	or ($index == $Awfif::memes-> {wsosponsorgs})

	or ($index == $Awfif::memes-> {wsosponsort})

){

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

		}#elsif

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

	or ($index == $Awfif::memes-> {wsologaei})

){

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

		}#elsif

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

){

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

		};#elsif

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

		print ("setwsmdx \n");

};

	} # setwsmd

sub inewstws {

	my ($myli, $buffers, $grkwp, $grkwpr, $sponsor, $makesubprogram) = @_;

#	create a new structural workspace

	return isetupws ($myli, $buffers, $grkwp, $grkwpr, $sponsor, $makesubprogram);

	}#inewstws

#<!-- start tag scl -->

sub inewaws {

	my ($myli, $buffers, $grkwp, $grkwpr, $sponsor, $makesubprogram) = @_;

#	create a new active workspace

	return isetupws ($myli, $buffers, $grkwp, $grkwpr, $sponsor, $makesubprogram, undef (), 't');

	}#iaddsg

sub iaddsg {

	my ($myli, $buffers, $grkwp, $grkwpr, $sponsor, $usews) = @_;

#	add a group to a structural workspace

	return isetupws ($myli, $buffers, $grkwp, $grkwpr, $sponsor, undef (), $usews);

	}#iaddsg

sub isetupws {

	my ($myli, $buffers, $grkwp, $grkwpr, $sponsor, $makesubprogram, $usews, $makeactive) = @_;

#	create a new structural workspace

	my ($tws, $buffer, $active, $depstag, $depttag, $dephtag, $insymbol, @inmsymbol, @started, $end, $cwsbi, $setwsclinv, $binding);

#	checked for merged workspaces

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

		print ("isetupws buffers($$buffers) grkwp $$grkwp grkwpr $grkwpr sponsor $sponsor ");

		if (defined ($makesubprogram)) {

			print ("makesubprogram $makesubprogram ");

			};#if

		if (defined ($usews)) {

			print ("usews $usews ");

			};#if

		if (defined ($makeactive)) {

			print ("makeactive $makeactive ");

			};#if

};

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

	if (defined ($makesubprogram)) {

		$binding = $makesubprogram;

		}#if

	else {

		$binding = $Awfif::memes-> {snnh} {stbinding};

		};#else

	if (!defined ($usews)) {

		$tws = setupws ();

		}#if

	else {

		$tws = $usews;

		};#else

	if ((defined ($makeactive)) && ($makeactive)) {

		$active = $makeactive;

		$buffer = $$buffers;

		}#if

	else {

		$active = '';

		$buffer = '(<rhlmspg>';

		$buffer = $buffer . $$buffers;

		$buffer = $buffer . '</rhlmspg>)';

		};#else

	$Awfif::wsbl-> {wsactive}[$tws] = $active;#default the workspace to being processed by the coderack structural workspaces may be inactive

	$depstag = '';

	$depttag = 0;

	$dephtag = 0;

	$insymbol = '';

	@inmsymbol = ();

	$started[0] = 0;

	$started[1] = 't';

	$setwsclinv = '';

	&convbws ($myli, \$buffer, \$$grkwp, $grkwpr, $Awfif::memes-> {kwmi}, $Awfif::memes-> {kwmir}, $sponsor, \$insymbol, \@inmsymbol, \@started, \$end, \$depstag, \$depttag, \$dephtag, $tws, $binding,

		$Awfif::memes-> {strbool}[$Awfif::memes-> {streh} {budesc}],

		'', #dont energize the base types

		\$setwsclinv

);

	$Awfif::wsbl-> {wsft} [$tws] = setfwst ($Awfif::wsbl-> {wsbloh} [$tws], $Awfif::wsbl-> {wsot}[$tws], $tws);

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

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

		print ("isetupwsx ret $tws\n");

};

	return $tws;

	}#isetupws

#<!-- end tag scl -->

#<!-- start tag vbt -->

#<!-- start tag aso -->

#<!-- start tag sca -->

sub igoalscon1 {# setup the goal suppressor for general cascade participant

	my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static, $strategy)=@_;

	my ($labcount);

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

		print ("igoalscon1 myli $myli sti($sti) kwp($$kwp) kwpr($kwpr) sactset($$sactset[0]) ");

};

#	updated for merged workspaces

	$labcount = 0;

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

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

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

	if (defined ($$static)) {

		$$static = '';#can't depend on this being the same every return - don't cache

		};#if

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

		print ("igoalsconx ret ($labcount)\n");

		};#if

	return $labcount

	}# igoalscon1

#<!-- end tag sca -->

#<!-- end tag vbt -->

#<!-- end tag aso -->

sub goalscon1 {# setup the goal suppressor for general cascade participant

	my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

	return (igoalscon1 ($myli, $sti, \@$lab, $kwp, $kwpr, \@$sactset, \$$static, getwsost4 ($Awfif::codelet-> {l} [$myli][21])));

	}# goalscon1

sub devscon1 {# setup the goal suppressor for dev codelet

	my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

	return (igoalscon1 ($myli, $sti, \@$lab, $kwp, $kwpr, \@$sactset, \$$static, 'development'));

	}# devscon1

#<!-- start tag vbt -->

sub vbtdevscon1 {# setup the goal suppressor for vbtdev codelet

	my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

	return (igoalscon1 ($myli, $sti, \@$lab, $kwp, $kwpr, \@$sactset, \$$static, 'development'));

	}# vbtdevscon1

sub vbtiopscon1 {# setup the goal suppressor for vbtiop codelet

	my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

	return (igoalscon1 ($myli, $sti, \@$lab, $kwp, $kwpr, \@$sactset, \$$static, 'vbt'));

	}# vbtiopscon1

#<!-- end tag vbt -->

#<!-- start tag aso -->

sub msiopscon1 {# setup the goal suppressor for msiop codelet

	my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

	return (igoalscon1 ($myli, $sti, \@$lab, $kwp, $kwpr, \@$sactset, \$$static, 'mergestreams'));

	}# msiopscon1

#<!-- start tag sca -->

sub hdoscon1 {# setup the goal suppressor for msiop codelet

	my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

	return (igoalscon1 ($myli, $sti, \@$lab, $kwp, $kwpr, \@$sactset, \$$static, 'hdo'));

	}# hdoscon1

#<!-- end tag sca -->

#<!-- end tag aso -->

##################### end strategy routines ################ ################## #########

##################### label strategy routines ################ ################## #########

#<!-- start tag ssc -->

sub statementlabel1 {# setup the labels for statement

	my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

	my ($labcount);

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

		print ("statementlabel myli $myli sti $sti kwp $kwp kwpr $kwpr sactset $$sactset[0] ");

};

#	updated for merged workspaces

	$labcount = 0;

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

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

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

	$labcount = labload (\@$lab, $labcount, wsbasetype ($sti));

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

	if (defined ($$static)) {

		$$static = '';#can't depend on this being the same every return - don't cache

		};#if

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

		print ("statementlabelx ret ($labcount)\n");

};

	return $labcount

	}# statementlabel

#<!-- start tag swp -->

sub partlabel1 {# setup the labels for part

	my($myli, $parti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

	my ($labcount);

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

		print ("partlabel myli $myli parti $parti kwp $kwp kwpr $kwpr sactset $$sactset[0] ");

};

#	updated for merged workspaces

	$labcount = 0;

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

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

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

	$labcount = labload (\@$lab, $labcount, wsbasetype ($parti));

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

	if (defined ($$static)) {

		$$static = '';#can't depend on this being the same every return - don't cache

		};#if

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

		print ("partlabelx ret ($labcount)\n");

};

	return $labcount

	}# partlabel

#<!-- end tag ssc -->

#<!-- end tag swp -->

#<!-- start tag scs -->

#<!-- start tag sca -->

sub statementpdcal1 {# setup the labels for statement

	my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

	my ($labcount, $concept, $drefi, $cwsbi);

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

		print ("statementpdcal myli $myli sti $sti kwp $kwp kwpr $kwpr sactset $$sactset[0] ");

};

#	updated for merged workspaces

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

	$Awfif::memes-> {currentwsbi} = $Awfif::codelet-> {l}[$myli] [20];

	$labcount = 0;

	&findcounter ($Awfif::wsol-> {l} [awsoadr ($sti)][2], ($Awfif::memes-> {snnh}{pdcaprogram}), \$drefi);

	if ($drefi != 0) {

		$concept = ($Awfif::workspace-> {l} [$drefi] [2] - $Awfif::memes-> {snnh}{wsi});

		};#if

	if (($drefi != 0) && ($concept != 0)) {

		$labcount = labload (\@$lab, $labcount, $concept);

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

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

		};#if

	if (defined ($$static)) {

		$$static = '';#can't depend on this being the same every return - don't cache

		};#if

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

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

		print ("statementpdcalx ret ($labcount)\n");

};

	return $labcount

	}# statementpdcal

#<!-- end tag sca -->

#<!-- start tag scl -->

sub screplicate1 {# setup the labels for statement

	my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

	my ($labcount, $concept, $drefi, $cwsbi);

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

		print ("screplicate myli $myli sti $sti kwp $kwp kwpr $kwpr sactset $$sactset[0] ");

};

#	updated for merged workspaces

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

	$Awfif::memes-> {currentwsbi} = $Awfif::codelet-> {l}[$myli] [20];

	$labcount = 0;

	&findcounter ($Awfif::wsol-> {l} [awsoadr ($sti)][2], ($Awfif::memes-> {snnh}{pdcaprogram}), \$drefi);

	if ($drefi != 0) {

		$concept = ($Awfif::workspace-> {l} [$drefi] [2] - $Awfif::memes-> {snnh}{wsi});

		};#if

	if (($drefi != 0) && ($concept != 0)) {

		$labcount = labload (\@$lab, $labcount, $concept);

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

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

		};#if

	if (defined ($$static)) {

		$$static = '';#can't depend on this being the same every return - don't cache

		};#if

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

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

		print ("screplicatex ret ($labcount)\n");

};

	return $labcount

	}# screplicate

#<!-- end tag scl -->

#<!-- start tag ssc -->

sub developmentlabel1 {# setup the labels for development

	my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

	my ($labcount);

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

		print ("developmentlabel myli $myli sti $sti kwp $kwp kwpr $kwpr sactset $$sactset[0] ");

};

#	updated for merged workspaces

	$labcount = 0;

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

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

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

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

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

	if (defined ($$static)) {

		$$static = 't';#can depend on this being the same every return - can cache

		};#if

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

		print ("developmentlabelx ret ($labcount)\n");

};

	return $labcount

	}# developmentlabel

#<!-- end tag ssc -->

sub developmentb1 {# setup the binding for development binder

	my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

	my ($labcount);

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

		print ("developmentb1 myli $myli sti $sti kwp $kwp kwpr $kwpr sactset $$sactset[0] ");

};

#	updated for merged workspaces

	$labcount = 0;

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

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

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

	if (defined ($$static)) {

		$$static = 't';#can depend on this being the same every return - can cache

		};#if

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

		print ("developmentbx ret ($labcount)\n");

};

	return $labcount

	}# developmentb

#<!-- start tag vbt -->

#<!-- start tag dli -->

sub developmenti1 {# setup the labels for development initiator signaling

	my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

	return (iinitiators1 ($myli, $sti, \@$lab, $kwp, $kwpr, \@$sactset, \$$static, 'development'));

	}# developmenti1

sub binderp11 {# setup the labels for binder base context

	my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

	my ($labcount);

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

		print ("binderp11 myli $myli sti $sti ");

		if (defined ($kwp)) {

			print ("kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");

			};#if

};

#	updated for merged workspaces

	$labcount = 0;

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

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

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

		};#if

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

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

	if (defined ($$static)) {

		$$static = '';#can't depend on this being the same every return - don't cache

		};#if

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

		print ("binderp11x ret ($labcount)\n");

};

	return $labcount

	}# binderp11

sub binderc1 {# setup the labels for binder indirect context

	my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

	my ($labcount, $i, $cwsbi, $conforms, $ssloc, $shistone, $ri);

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

		print ("binderc1 myli $myli sti $sti ");

		if (defined ($kwp)) {

			print ("kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");

			};#if

};

#	updated for merged workspaces

	$labcount = 0;

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

	$Awfif::memes-> {currentwsbi} = $Awfif::codelet-> {l} [$myli] [20];

	for ($i = trwsoadr($Awfif::codelet-> {l} [$myli][21],2);

	( (!($shistone = chmdefis ($myli, trwsoadr ($i,-1), $Awfif::memes-> {snnh}{histone}, \$conforms)))

	&& ($i != trwsoadr ($Awfif::codelet-> {l} [$myli][22],-2) )

	&& ($ri = $i)

	&& (!($ssloc = chmdefis ($myli, trwsoadr ($i,2), $Awfif::memes-> {snnh}{sloc}, \$conforms))));

	$i = trwsoadr ($i,1)) {

		$labcount = labload (\@$lab, $labcount, wsbasetype ($i));

		};#for

	if ($shistone) {#already done it

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

		}#if

	elsif ($ssloc) {

		$labcount = labload (\@$lab, $labcount, wsbasetype ($ri));

		}#elsif

	else {

		$labcount = labload (\@$lab, $labcount, wsbasetype (trwsoadr ($Awfif::codelet-> {l} [$myli][22],-2)));

		};#else

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

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

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

	if (defined ($$static)) {

		$$static = '';#can't depend on this being the same every return - don't cache

		};#if

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

		print ("binderc1x ret ($labcount)\n");

};

	return $labcount

	}# binderc1

#<!-- start tag aso -->

sub ibindervc1 {# setup the labels for app complex indirect context (with variable end)

	my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static, $tback, $ihforward)=@_;

	my ($labcount, $i, $initi, $hforward, $cwsbi);

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

		print ("bindercs1 myli $myli sti $sti ");

		if (defined ($ihforward)) {

			print ("ihforward($ihforward) ");

			};#if

		if (defined ($kwp)) {

			print ("kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");

			};#if

};

#	updated for merged workspaces

	$labcount = 0;

	if (defined ($ihforward)) {

		$hforward = $ihforward;

		}#if

	else {

		$hforward = 2;

		};#else

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

	$Awfif::memes-> {currentwsbi} = $Awfif::codelet-> {l} [$myli] [20];

	for ($i = ($initi = trwsoadr($Awfif::codelet-> {l} [$myli][21], $hforward));

	$i != trwsoadr ($Awfif::codelet-> {l} [$myli][22], - $tback, $initi);

	$i = trwsoadr ($i,1)) {

		$labcount = labload (\@$lab, $labcount, wsbasetype ($i));

		};#for

	$labcount = labload (\@$lab, $labcount, wsbasetype (trwsoadr ($Awfif::codelet-> {l} [$myli][22], - $tback)));

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

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

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

	if (defined ($$static)) {

		$$static = '';#can't depend on this being the same every return - don't cache

		};#if

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

		print ("bindervc1x ret ($labcount)\n");

};

	return $labcount

	}# ibindervc1

#<!-- end tag aso -->

#<!-- end tag vbt -->

sub bindercs1 {# setup the labels for semantic binder complex indirect context

	my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

	return (ibindervc1 ($myli, $sti, \@$lab, $kwp, $kwpr, \@$sactset, \$$static, 3));

	}# bindercs1

#<!-- start tag vbt -->

sub binderc41 {# setup the labels for vbttom00nc binder complex indirect context

	my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

	return (ibindervc1 ($myli, $sti, \@$lab, $kwp, $kwpr, \@$sactset, \$$static, 4));

	}# binderc41

sub binderc71 {# setup the labels for vbttom00c10 binder complex indirect context

	my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

	return (ibindervc1 ($myli, $sti, \@$lab, $kwp, $kwpr, \@$sactset, \$$static, 7));

	}# binderc71

sub binderc91 {# setup the labels for vbttom00c10c01 binder complex indirect context

	my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

	return (ibindervc1 ($myli, $sti, \@$lab, $kwp, $kwpr, \@$sactset, \$$static, 9));

	}# binderc91

sub binderc101 {# setup the labels for vbttom00c10c00 binder complex indirect context

	my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

	return (ibindervc1 ($myli, $sti, \@$lab, $kwp, $kwpr, \@$sactset, \$$static, 10));

	}# binderc111

sub binderc111 {# setup the labels for vbttom00c10c01c00 binder complex indirect context

	my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

	return (ibindervc1 ($myli, $sti, \@$lab, $kwp, $kwpr, \@$sactset, \$$static, 11));

	}# binderc111

sub binderc131 {# setup the labels for vbttom01c00c11c02 binder complex indirect context

	my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

	return (ibindervc1 ($myli, $sti, \@$lab, $kwp, $kwpr, \@$sactset, \$$static, 13));

	}# binderc131

sub binderc161 {# setup the labels for vbttom01c00c01c11c02 binder complex indirect context

	my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

	return (ibindervc1 ($myli, $sti, \@$lab, $kwp, $kwpr, \@$sactset, \$$static, 16));

	}# binderc161

sub binderc191 {# setup the labels for vbttom11c21c11c12c01c10 binder complex indirect context

	my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

	return (ibindervc1 ($myli, $sti, \@$lab, $kwp, $kwpr, \@$sactset, \$$static, 19));

	}# binderc191

#<!-- end tag vbt -->

sub bindercs21 {# setup the labels for semantic binder complex indirect context

	my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

	return (ibindervc1 ($myli, $sti, \@$lab, $kwp, $kwpr, \@$sactset, \$$static, 4));

	}# bindercs21

#<!-- start tag aso -->

#<!-- start tag sir -->

sub bindercst1 {# setup the labels for binder indirect context

	my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

	my ($labcount, $i, $cwsbi, $conforms, $ssloc, $shistone, $ri);

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

		print ("bindercst1 myli $myli sti $sti ");

		if (defined ($kwp)) {

			print ("kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");

			};#if

};

#	updated for merged workspaces

	$labcount = 0;

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

	$Awfif::memes-> {currentwsbi} = $Awfif::codelet-> {l} [$myli] [20];

	for ($i = trwsoadr($Awfif::codelet-> {l} [$myli][21],2);

	( (!($shistone = chmdefis ($myli, trwsoadr ($i,-1), $Awfif::memes-> {snnh}{histone}, \$conforms)))

	&& ($i != trwsoadr ($Awfif::codelet-> {l} [$myli][22],-2) )

	&& ($ri = $i)

	&& (!($ssloc = chmdefis ($myli, trwsoadr ($i,2), $Awfif::memes-> {snnh}{sloc}, \$conforms))));

	$i = trwsoadr ($i,1)) {

		$labcount = labload (\@$lab, $labcount, wsbasetype ($i));

		};#for

	if ($shistone) {#already done it

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

		}#if

	elsif ($ssloc) {

		$labcount = labload (\@$lab, $labcount, wsbasetype ($ri));

		}#elsif

	else {

		$labcount = labload (\@$lab, $labcount, wsbasetype (trwsoadr ($Awfif::codelet-> {l} [$myli][22],-2)));

		};#else

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

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

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

	if (defined ($$static)) {

		$$static = '';#can't depend on this being the same every return - don't cache

		};#if

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

		print ("bindercst1x ret ($labcount)\n");

};

	return $labcount

	}# bindercst1

#<!-- end tag sir -->

#<!-- end tag aso -->

#<!-- start tag vbt -->

sub casoppi1 {# setup the labels for development integration

	my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

	my ($labcount, $i, $cwsbi);

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

		print ("casoppi1 myli $myli sti $sti ");

		if (defined ($kwp)) {

			print ("kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");

			};#if

};

#	updated for merged workspaces

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

	$labcount = 0;

	$Awfif::memes-> {currentwsbi} = $Awfif::codelet-> {l} [$myli] [20];

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

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

	for ($i = trwsoadr ($Awfif::codelet-> {l} [$myli][21], 4);

	$i != $Awfif::codelet-> {l} [$myli][22];

	$i = trwsoadr ($i,1)) {

		$labcount = labload (\@$lab, $labcount, wsbasetype ($i));

		};#for

	$labcount = labload (\@$lab, $labcount, wsbasetype ($Awfif::codelet-> {l} [$myli][22]));

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

	if (defined ($$static)) {

		$$static = '';#can't depend on this being the same every return - don't cache

		};#if

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

		print ("casoppi1x ret ($labcount)\n");

};

	return $labcount

	}# casoppi1

#<!-- end tag vbt -->

#<!-- end tag dli -->

sub cassuboppi1 {# setup the labels for subprogram integration

	my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

	my ($labcount, $i, $cwsbi);

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

		print ("casoppi1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");

};

#	updated for merged workspaces

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

	$labcount = 0;

	$Awfif::memes-> {currentwsbi} = $Awfif::codelet-> {l} [$myli] [20];

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

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

	for ($i = trwsoadr ($Awfif::codelet-> {l} [$myli][21], 4);

	$i != $Awfif::codelet-> {l} [$myli][22];

	$i = trwsoadr ($i,1)) {

		$labcount = labload (\@$lab, $labcount, wsbasetype ($i));

		};#for

	$labcount = labload (\@$lab, $labcount, wsbasetype ($Awfif::codelet-> {l} [$myli][22]));

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

	if (defined ($$static)) {

		$$static = '';#can't depend on this being the same every return - don't cache

		};#if

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

		print ("casoppi1x ret ($labcount)\n");

};

	return $labcount

	}# cassuboppi1

#<!-- start tag aso -->

sub casopai1 {# setup the labels for development integration

	my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

	my ($labcount, $i, $cwsbi);

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

		print ("casopai1 myli $myli sti $sti ");

		if (defined ($kwp)) {

			print ("kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");

			};#if

};

#	updated for merged workspaces

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

	$labcount = 0;

	$Awfif::memes-> {currentwsbi} = $Awfif::codelet-> {l} [$myli] [20];

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

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

	for ($i = trwsoadr ($Awfif::codelet-> {l} [$myli][21], 2);

	$i != $Awfif::codelet-> {l} [$myli][22];

	$i = trwsoadr ($i,1)) {

		$labcount = labload (\@$lab, $labcount, wsbasetype ($i));

		};#for

	$labcount = labload (\@$lab, $labcount, wsbasetype ($Awfif::codelet-> {l} [$myli][22]));

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

	if (defined ($$static)) {

		$$static = '';#can't depend on this being the same every return - don't cache

		};#if

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

		print ("casopai1x ret ($labcount)\n");

};

	return $labcount

	}# casopai1

#<!-- end tag aso -->

sub goalsupp1 {# setup the binding for goal suppressor

	my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

	my ($labcount);

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

		print ("goalsupp1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");

};

#	updated for merged workspaces

	$labcount = 0;

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

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

	if (defined ($$static)) {

		$$static = 't';#can depend on this being the same every return - cache

		};#if

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

		print ("goalsuppx ret ($labcount)\n");

};

	return $labcount

	}# goalsupp

#<!-- end tag cr -->

#<!-- start tag aso -->

sub mergestreamsb1 {# setup the binding for mergestreams binder

	my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

	my ($labcount);

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

		print ("mergestreamsb1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");

};

#	updated for merged workspaces

	$labcount = 0;

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

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

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

	if (defined ($$static)) {

		$$static = 't';#can depend on this being the same every return - can cache

		};#if

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

		print ("mergestreamsbx ret ($labcount)\n");

};

	return $labcount

	}# mergestreamsb

#<!-- end tag aso -->

#<!-- start tag vbt -->

sub vbtb1 {# setup the binding for vbt binder

	my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

	my ($labcount);

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

		print ("vbtb1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");

};

#	updated for merged workspaces

	$labcount = 0;

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

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

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

	if (defined ($$static)) {

		$$static = 't';#can depend on this being the same every return - can cache

		};#if

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

		print ("vbtbx ret ($labcount)\n");

};

	return $labcount

	}# vbtb

#<!-- start tag sca -->

#<!-- start tag dli -->

#<!-- start tag aso -->

sub iinitiators1 {# setup the labels for complex initiator signaling

	my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static, $strategy)=@_;

	my ($labcount, $i);

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

		print ("iinitiators1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");

};

#	updated for merged workspaces

	$labcount = 0;

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

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

	for ($i = $Awfif::codelet-> {l} [$myli][21]; $i != $Awfif::codelet-> {l} [$myli][22];$i = trwsoadr ($i,1)) {

		$labcount = labload (\@$lab, $labcount, wsbasetype ($i));

		};#for

	$labcount = labload (\@$lab, $labcount, wsbasetype ($Awfif::codelet-> {l} [$myli][22]));

	$labcount = labload (\@$lab, $labcount, wsbasetype ($sti));

	if (defined ($$static)) {

		$$static = '';#can't depend on this being the same every return - don't cache

		};#if

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

		print ("iinitiators1x ret ($labcount)\n");

};

	return $labcount

	}# iinitiators1

#<!-- end tag sca -->

#<!-- end tag dli -->

#<!-- end tag vbt -->

sub mergestreamsi1 {# setup the labels for mergestreams assert case resolution

	my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

	return (iinitiators1 ($myli, $sti, \@$lab, $kwp, $kwpr, \@$sactset, \$$static, 'mergestreams'));

	}# mergestreamsi1

#<!-- start tag vbt -->

sub vbti1 {# setup the labels for vbt initiator signaling

	my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

	return (iinitiators1 ($myli, $sti, \@$lab, $kwp, $kwpr, \@$sactset, \$$static, 'vbt'));

	}# vbti1

#<!-- end tag vbt -->

sub mstracasetestpi1 {# setup the labels for mergestreams case test resolution

	my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

	my ($labcount);

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

		print ("mstracasetestpi1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");

};

#	updated for merged workspaces

	$labcount = 0;

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

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

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

	$labcount = labload (\@$lab, $labcount, wsbasetype ($sti));

	if (defined ($$static)) {

		$$static = '';#can't depend on this being the same every return - don't cache

		};#if

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

		print ("mstracasetestpi1x ret ($labcount)\n");

};

	return $labcount

	}# mstracasetestpi1

sub mstraresctestpi1 {# setup the labels for mergestreams case test resolution

	my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

	my ($labcount);

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

		print ("mstraresctestpi1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");

};

#	updated for merged workspaces

	$labcount = 0;

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

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

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

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

	$labcount = labload (\@$lab, $labcount, wsbasetype ($sti));

	if (defined ($$static)) {

		$$static = '';#can't depend on this being the same every return - don't cache

		};#if

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

		print ("mstraresctestpi1x ret ($labcount)\n");

};

	return $labcount

	}# mstraresctestpi1

sub mstranoctestpi1 {# setup the labels for mergestreams case test resolution

	my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

	my ($labcount);

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

		print ("mstranoctestpi1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");

};

#	updated for merged workspaces

	$labcount = 0;

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

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

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

	$labcount = labload (\@$lab, $labcount, wsbasetype ($sti));

	if (defined ($$static)) {

		$$static = '';#can't depend on this being the same every return - don't cache

		};#if

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

		print ("mstranoctestpi1x ret ($labcount)\n");

};

	return $labcount

	}# mstranoctestpi1

sub mstrarescinitpi1 {# setup the labels for initialisation of mergestreams case test resolution

	my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

	my ($labcount);

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

		print ("mstrarescinitpi1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");

};

#	updated for merged workspaces

	$labcount = 0;

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

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

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

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

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

	$labcount = labload (\@$lab, $labcount, wsbasetype ($sti));

	if (defined ($$static)) {

		$$static = '';#can't depend on this being the same every return - don't cache

		};#if

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

		print ("mstrarescinitpi1x ret ($labcount)\n");

};

	return $labcount

	}# mstrarescinitpi1

#<!-- start tag scs -->

sub pdcasappi1 {# setup the labels for initpdca signalling of application

	my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

	my ($labcount, $i);

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

		print ("pdcasappi1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");

};

#	updated for merged workspaces

	$labcount = 0;

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

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

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

	for ($i = trwsoadr ($Awfif::codelet-> {l} [$myli][21], 2); $i != trwsoadr ($Awfif::codelet-> {l} [$myli][22],-2);$i = trwsoadr ($i,1)) {

		$labcount = labload (\@$lab, $labcount, wsbasetype ($i));

		};#for

	$labcount = labload (\@$lab, $labcount, wsbasetype (trwsoadr ($Awfif::codelet-> {l} [$myli][22],-2)));

	$labcount = labload (\@$lab, $labcount, wsbasetype ($Awfif::codelet-> {l} [$myli][22]));

	if (defined ($$static)) {

		$$static = '';#can't depend on this being the same every return - don't cache

		};#if

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

		my ($pr);

		for ($i = 1; $i <= $labcount; $i++) {

			$pr = '<' . $Awfif::memes-> {snnih} {$$lab[$i]} . '>';

			print ("$pr");

			};#for

		print ("pdcasappi1x ret ($labcount)\n");

};

	return $labcount

	}# pdcasappi1

sub pdcab1 {# setup the binding for Shewhart binder

	my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

	my ($labcount);

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

		print ("pdcab1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");

};

#	updated for merged workspaces

	$labcount = 0;

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

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

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

	if (defined ($$static)) {

		$$static = 't';#can depend on this being the same every return - can cache

		};#if

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

		print ("pdcabx ret ($labcount)\n");

};

	return $labcount

	}# pdcab

sub e2finhibb1 {# setup the binding for e2finhib binder

	my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

	my ($labcount);

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

		print ("e2finhibb1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");

};

#	updated for merged workspaces

	$labcount = 0;

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

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

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

	if (defined ($$static)) {

		$$static = 't';#can depend on this being the same every return - can cache

		};#if

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

		print ("e2finhibbx ret ($labcount)\n");

};

	return $labcount

	}# e2finhibb

#<!-- end tag scs -->

sub comparest1 {# setup the labels for comparison of source and target

	my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

	my ($labcount);

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

		print ("comparest1 myli $myli sti $sti ");

		if (defined ($kwp)) {

			print ("kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");

			};#if

};

#	updated for merged workspaces

	$labcount = 0;

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

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

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

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

	$labcount = labload (\@$lab, $labcount, wsbasetype ($Awfif::codelet-> {l} [$myli][22]));

	if (defined ($$static)) {

		$$static = '';#can't depend on this being the same every return - don't cache

		};#if

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

		print ("comparest1x ret ($labcount)\n");

};

	return $labcount

	}# comparest1

#	self1 does not appear to be used

sub self1 {# setup the labels for self analysis

	my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

	my ($labcount, $i);

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

		print ("self1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");

};

#	updated for merged workspaces

	$labcount = 0;

	for ($i = $Awfif::codelet-> {l} [$myli][21]; $i != $Awfif::codelet-> {l} [$myli][22];$i = trwsoadr ($i,1)) {

		$labcount = labload (\@$lab, $labcount, wsbasetype ($i));

		};#for

	$labcount = labload (\@$lab, $labcount, wsbasetype ($Awfif::codelet-> {l} [$myli][22]));

	if (defined ($$static)) {

		$$static = '';#can't depend on this being the same every return - don't cache

		};#if

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

		my ($pr);

		for ($i = 1; $i <= $labcount; $i++) {

			$pr = '<' . $Awfif::memes-> {snnih} {$$lab[$i]} . '>';

			print ("$pr");

			};#for

		print ("selfx ret ($labcount)\n");

};

	return $labcount

	}# self1

#<!-- start tag scs -->

sub ecyclino1 {# setup the labels for e cyclin signalling

	my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

	my ($labcount, $i);

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

		print ("ecyclino1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");

};

#	updated for merged workspaces

	$labcount = 0;

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

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

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

	if (defined ($$static)) {

		$$static = '';#can't depend on this being the same every return - don't cache

		};#if

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

		my ($pr);

		for ($i = 1; $i <= $labcount; $i++) {

			$pr = '<' . $Awfif::memes-> {snnih} {$$lab[$i]} . '>';

			print ("$pr");

			};#for

		print ("ecyclino1x ret ($labcount)\n");

};

	return $labcount

	}# ecyclino1

sub acyclino1 {# setup the labels for a cyclin signalling

	my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

	my ($labcount, $i);

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

		print ("acyclino1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");

};

#	updated for merged workspaces

	$labcount = 0;

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

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

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

	if (defined ($$static)) {

		$$static = '';#can't depend on this being the same every return - don't cache

		};#if

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

		my ($pr);

		for ($i = 1; $i <= $labcount; $i++) {

			$pr = '<' . $Awfif::memes-> {snnih} {$$lab[$i]} . '>';

			print ("$pr");

			};#for

		print ("acyclino1x ret ($labcount)\n");

};

	return $labcount

	}# acyclino1

sub bcyclino1 {# setup the labels for b cyclin signalling

	my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

	my ($labcount, $i);

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

		print ("bcyclino1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");

};

#	updated for merged workspaces

	$labcount = 0;

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

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

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

	if (defined ($$static)) {

		$$static = '';#can't depend on this being the same every return - don't cache

		};#if

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

		my ($pr);

		for ($i = 1; $i <= $labcount; $i++) {

			$pr = '<' . $Awfif::memes-> {snnih} {$$lab[$i]} . '>';

			print ("$pr");

			};#for

		print ("bcyclino1x ret ($labcount)\n");

};

	return $labcount

	}# bcyclino1

sub dcyclino1 {# setup the labels for d cyclin signalling

	my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

	my ($labcount, $i);

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

		print ("dcyclino1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");

};

#	updated for merged workspaces

	$labcount = 0;

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

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

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

	if (defined ($$static)) {

		$$static = '';#can't depend on this being the same every return - don't cache

		};#if

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

		my ($pr);

		for ($i = 1; $i <= $labcount; $i++) {

			$pr = '<' . $Awfif::memes-> {snnih} {$$lab[$i]} . '>';

			print ("$pr");

			};#for

		print ("dcyclino1x ret ($labcount)\n");

};

	return $labcount

	}# dcyclino1

sub imemb1 {# setup the binding for internal membrane binder

	my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

	my ($labcount);

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

		print ("imemeb1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");

};

#	updated for merged workspaces

	$labcount = 0;

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

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

	if (defined ($$static)) {

		$$static = '';#can't depend on this being the same every return - don't cache

		};#if

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

		print ("imembx ret ($labcount)\n");

};

	return $labcount

	}# imemb

sub tfactorb1 {# setup the binding for tfactor binder

	my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

	my ($labcount);

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

		print ("tfactorb myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");

};

#	updated for merged workspaces

	$labcount = 0;

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

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

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

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

	if (defined ($$static)) {

		$$static = 't';#can depend on this being the same every return - can cache

		};#if

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

		print ("tfactorbx ret ($labcount)\n");

};

	return $labcount

	}# tfactorb

#<!-- end tag scs -->

#<!-- end tag aso -->

#<!-- start tag sir -->

sub receptorb1 {# setup the binding for resolved assert receptor buffer binder

	my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

	my ($labcount, $cwsbi, $i);

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

		print ("receptorb myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");

};

#	updated for merged workspaces

	$labcount = 0;

#	updated for merged workspaces

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

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

	$Awfif::memes-> {currentwsbi} = $Awfif::codelet-> {l} [$myli] [20];

	for ($i = trwsoadr ($Awfif::codelet-> {l} [$myli][21], 4);

	$i != $Awfif::codelet-> {l} [$myli][22];

	$i = trwsoadr ($i,1)) {

		$labcount = labload (\@$lab, $labcount, wsbasetype ($i));

		};#for

	$labcount = labload (\@$lab, $labcount, wsbasetype ($Awfif::codelet-> {l} [$myli][22]));

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

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

	if (defined ($$static)) {

		$$static = '';#can not depend on this being the same every return - can't cache

		};#if

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

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

		print ("receptorbx ret ($labcount)\n");

};

	return $labcount

	}# receptorb

sub receptorbi1 {# setup the binding for resolved assert receptor buffer binder

	my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

	my ($labcount, $cwsbi, $i);

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

		print ("receptorbi myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");

};

#	updated for merged workspaces

	$labcount = 0;

#	updated for merged workspaces

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

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

	$Awfif::memes-> {currentwsbi} = $Awfif::codelet-> {l} [$myli] [20];

	for ($i = trwsoadr ($Awfif::codelet-> {l} [$myli][21], 5);

	$i != $Awfif::codelet-> {l} [$myli][22];

	$i = trwsoadr ($i,1)) {

		$labcount = labload (\@$lab, $labcount, wsbasetype ($i));

		};#for

	$labcount = labload (\@$lab, $labcount, wsbasetype ($Awfif::codelet-> {l} [$myli][22]));

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

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

	if (defined ($$static)) {

		$$static = '';#can not depend on this being the same every return - can't cache

		};#if

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

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

		print ("receptorbix ret ($labcount)\n");

};

	return $labcount

	}# receptorbi

sub receptorh1 {# setup the binding for receptor hierarchy signal schematic workspace binder

	my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

	my ($labcount);

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

		print ("receptorh1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");

};

#	updated for merged workspaces

	$labcount = 0;

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

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

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

	if (defined ($$static)) {

		$$static = 't';#can depend on this being the same every return - can cache

		};#if

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

		print ("receptorhx ret ($labcount)\n");

};

	return $labcount

	}# receptorh

#<!-- end tag sir -->

#<!-- start tag cr -resweb -->

sub subpc1 {# setup the labels for subprogram indirect context

	my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

	my ($labcount, $i, $cwsbi);

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

		print ("subpc1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");

};

#	updated for merged workspaces

	$labcount = 0;

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

	$Awfif::memes-> {currentwsbi} = $Awfif::codelet-> {l} [$myli] [20];

	for ($i = trwsoadr($Awfif::codelet-> {l} [$myli][21],2);

	$i != trwsoadr ($Awfif::codelet-> {l} [$myli][22],-2);

	$i = trwsoadr ($i,1)) {

		$labcount = labload (\@$lab, $labcount, wsbasetype ($i));

		};#for

	$labcount = labload (\@$lab, $labcount, wsbasetype (trwsoadr ($Awfif::codelet-> {l} [$myli][22],-2)));

	if ($Awfif::codelet-> {l} [$myli] [36] == 0) {

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

		};#else

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

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

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

	if (defined ($$static)) {

		$$static = '';#can't depend on this being the same every return - don't cache

		};#if

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

		print ("subpc1x ret ($labcount)\n");

};

	return $labcount

	}# subpc1

#<!-- start tag sca -->

sub hdob1 {# setup the binding for hdo binder

	my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

	my ($labcount);

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

		print ("hdob1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");

};

#	updated for merged workspaces

	$labcount = 0;

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

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

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

	if (defined ($$static)) {

		$$static = 't';#can depend on this being the same every return - can cache

		};#if

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

		print ("hdobx ret ($labcount)\n");

};

	return $labcount

	}# hdob

#	hdoi1 does not appear to be used

sub hdoi1 {# setup the labels for hdo initiator signaling

	my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

	return (iinitiators1 ($myli, $sti, \@$lab, $kwp, $kwpr, \@$sactset, \$$static, 'hdo'));

	}# hdoi1

#<!-- start tag aso -->

sub msadoboppi1 {# setup the labels for hdo integration

	my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

	my ($labcount, $i, $cwsbi);

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

		print ("msadoboppi1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");

};

#	updated for merged workspaces

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

	$labcount = 0;

	$Awfif::memes-> {currentwsbi} = $Awfif::codelet-> {l} [$myli] [20];

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

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

	for ($i = trwsoadr ($Awfif::codelet-> {l} [$myli][21], 4);

	$i != $Awfif::codelet-> {l} [$myli][22];

	$i = trwsoadr ($i,1)) {

		$labcount = labload (\@$lab, $labcount, wsbasetype ($i));

		};#for

	$labcount = labload (\@$lab, $labcount, wsbasetype ($Awfif::codelet-> {l} [$myli][22]));

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

	if (defined ($$static)) {

		$$static = '';#can't depend on this being the same every return - don't cache

		};#if

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

		print ("msadoboppi1x ret ($labcount)\n");

};

	return $labcount

	}# msadoboppi1

sub binderrc1 {# setup the labels for binder 4 to -1

	my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

	return (ibindervc1 ($myli, $sti, \@$lab, $kwp, $kwpr, \@$sactset, \$$static, 1, 4));

	}# binderrc1

sub bindercml1 {# setup the labels for binder 2 to -1

	my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

	return (ibindervc1 ($myli, $sti, \@$lab, $kwp, $kwpr, \@$sactset, \$$static, 1));

	}# bindercml1

#<!-- end tag aso -->

#<!-- end tag sca -->

#<!-- start tag vbt -->

sub vworldb1 {# setup the binding for vbot world workspace

	my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

	my ($labcount);

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

		print ("vworldb1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");

};

#	updated for merged workspaces

	$labcount = 0;

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

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

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

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

	if (defined ($$static)) {

		$$static = 't';#can depend on this being the same every return - can cache

		};#if

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

		print ("vworldbx ret ($labcount)\n");

};

	return $labcount

	}# vworldb

sub vwxstartb1 {# setup the binding for vbot world start workspace

	my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

	my ($labcount);

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

		print ("vwxstartb1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");

};

#	updated for merged workspaces

	$labcount = 0;

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

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

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

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

	if (defined ($$static)) {

		$$static = 't';#can depend on this being the same every return - can cache

		};#if

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

		print ("vwxstartbx ret ($labcount)\n");

};

	return $labcount

	}# vwxstartb

sub vcansb1 {# setup the binding for vbot can workspace

	my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

	my ($labcount);

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

		print ("vcansb1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");

};

#	updated for merged workspaces

	$labcount = 0;

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

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

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

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

	if (defined ($$static)) {

		$$static = 't';#can depend on this being the same every return - can cache

		};#if

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

		print ("vcansbx ret ($labcount)\n");

};

	return $labcount

	}# vcansb

#<!-- end tag vbt -->

#<!-- start tag scl -->

sub pcellb1 {# setup the binding for pcell structural workspace

	my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

	my ($labcount);

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

		print ("pcellb1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");

};

#	updated for merged workspaces

	$labcount = 0;

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

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

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

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

	if (defined ($$static)) {

		$$static = 't';#can depend on this being the same every return - can cache

		};#if

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

		print ("pcellbx ret ($labcount)\n");

};

	return $labcount

	}# pcellb

#<!-- end tag scl -->

#<!-- start tag scc -->

#<!-- start tag aso -->

sub warb1 {# setup the binding for wait and relay workspace

	my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

	my ($labcount);

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

		print ("warb1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");

};

#	updated for merged workspaces

	$labcount = 0;

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

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

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

	if (defined ($$static)) {

		$$static = 't';#can depend on this being the same every return - can cache

		};#if

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

		print ("warbx ret ($labcount)\n");

};

	return $labcount

	}# warb

sub warasb1 {# setup the association for wait and relay operons

	my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

	my ($labcount);

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

		print ("warasb1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");

};

#	updated for merged workspaces

	$labcount = 0;

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

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

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

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

	if (defined ($$static)) {

		$$static = 't';#can depend on this being the same every return - can cache

		};#if

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

		print ("warasbx ret ($labcount)\n");

};

	return $labcount

	}# warasb

sub warmab1 {# match a wait and relay operon

	my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

	my ($labcount, $lbuffer, $content);

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

		print ("warmab1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");

};

#	updated for merged workspaces

	$labcount = 0;

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

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

#	now must find each <keyword> in $st1 snnh it into its index and labload it

	$lbuffer = $sti;

	while ($lbuffer =~ /<([\w]*)>/){

		$content = $1;

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

		$lbuffer =~ s/\Q<$1>/ /;

		};#while

	if (defined ($$static)) {

		$$static = 't';#can depend on this being the same every return - can cache

		};#if

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

		print ("warmabx ret ($labcount)\n");

};

	return $labcount

	}# warmab

sub warmdob1 {# setup the association of do mergestreams with wait and relay operons

	my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

	my ($labcount);

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

		print ("warmdob1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");

};

#	updated for merged workspaces

	$labcount = 0;

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

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

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

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

	if (defined ($$static)) {

		$$static = 't';#can depend on this being the same every return - can cache

		};#if

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

		print ("warmdobx ret ($labcount)\n");

};

	return $labcount

	}# warmdob

sub warhdob1 {# setup the association of histone do with wait and relay operons

	my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

	my ($labcount);

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

		print ("warhdob1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");

};

#	updated for merged workspaces

	$labcount = 0;

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

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

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

	if (defined ($$static)) {

		$$static = 't';#can depend on this being the same every return - can cache

		};#if

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

		print ("warhdobx ret ($labcount)\n");

};

	return $labcount

	}# warhdob

sub warmsb1 {# setup the association of mergestreams stream with wait and relay operons

	my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

	my ($labcount);

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

		print ("warmsb1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");

};

#	updated for merged workspaces

	$labcount = 0;

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

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

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

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

	if (defined ($$static)) {

		$$static = 't';#can depend on this being the same every return - can cache

		};#if

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

		print ("warmsbx ret ($labcount)\n");

};

	return $labcount

	}# warmsb

sub comparestb1 {# setup the binding for compare source target binder

	my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

	my ($labcount);

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

		print ("comparestb1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");

};

#	updated for merged workspaces

	$labcount = 0;

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

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

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

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

	if (defined ($$static)) {

		$$static = 't';#can depend on this being the same every return - can cache

		};#if

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

		print ("comparestbx ret ($labcount)\n");

};

	return $labcount

	}# comparestb

sub comparesti1 {# setup the labels for compare source target

	my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;

	my ($labcount, $i);

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

		print ("comparesti1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");

};

#	updated for merged workspaces

	$labcount = 0;

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

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

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

	for ($i = $Awfif::codelet-> {l} [$myli][21]; $i != $Awfif::codelet-> {l} [$myli][22];$i = trwsoadr ($i,1)) {

		$labcount = labload (\@$lab, $labcount, wsbasetype ($i));

		};#for

	$labcount = labload (\@$lab, $labcount, wsbasetype ($Awfif::codelet-> {l} [$myli][22]));

	$labcount = labload (\@$lab, $labcount, wsbasetype ($sti));

	if (defined ($$static)) {

		$$static = '';#can't depend on this being the same every return - don't cache

		};#if

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

		print ("comparesti1x ret ($labcount)\n");

};

	return $labcount

	}# comparesti1

#<!-- end tag aso -->

#<!-- end tag scc -->

sub labinv1 {

	my ($myli, $as, $ae, $ael, $sponsor, $lomatchs, $lola, $loconcs, $lostrts, $loends, $logb, $loge, $filstrategy) = @_;

	my ($i, $i2, $label, $type, $ltype, $sigcount, $aer);

#	inversion of group builder complete's label space code

#	checked for merged workspaces

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

		print ("labinv1 myli $myli as $as ae $ae ");

		if ($myli > 0) {

			&itcpoutput ($myli);

};

};

	$label = '';

	$ltype = '';

	$i2 = 0;

	$aer = '';

# labinv1nsu1

	$i = trwsoadr ($as, 1);

	while ((($ael && !$aer) or (!$ael && ($i != $ae))) && ( awsoadr ($i) != 0)) {

		my($kwai, $akwai, $kws, $kwl, $slab);

		if ($ael && ($i == $ae)) {

			$aer = 't';

			};#if

#		sponsor is now stable can mark its position in group members wso

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

			if ((defined ($Awfif::wsol-> {l} [awsoadr ($i)] [ $Awfif::memes-> {wsogstart} ]))

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

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

){

				&break ();

				};#if

			my ($ngcsponsor);

			$ngcsponsor =

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

			if (($ngcsponsor != 0) && ($ngcsponsor != $sponsor)) {&break ()};

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

			$Awfif::wsol-> {l}[awsoadr ($i)][ $Awfif::memes-> {wsogcsponsored}] =  $sponsor;#*** submacrok ***#

			};#update sponsor if specified

		$type = ' ' . wsbasetype ($i);

		$slab = getwsost4 ($i);

		if ((($type == $Awfif::memes-> {snnh} {mkeywords}) or ($type == $Awfif::memes-> {snnh} {mkeyworde}))  && (mkwlabel (\$slab, \$kwai, \$akwai, \$kws, \$kwl)) && (!ismemetic ($akwai))) {

# labinv1m1

			my ($sparam, $param, $param2);

			$sparam = jhlmappl ($kws);

			if ($sparam =~ /,/) {

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

					$param = $1;

					$param2 = $2;

					$sparam =~ s/$param$param2//;

					$type = ' '.$param;

					$label = $label.$type;

					$$lostrts[$i2++] = $i;

					};#while

				};#if

			$ltype = '';#no repeats on mkeyword

		else {

			if ($type eq ' '.wsbasetype ( trwsoadr ($i, 1))) {#note repeat

				$type = '_' . wsbasetype ($i);

				};#repeat

			if ($ltype ne $type) {# ignore repeats

				$label = $label.$type;

				$$lostrts[$i2++] = $i;

				};#build direct label

			$ltype = $type;

			};#else

		$i = trwsoadr ($i, 1);

		};#for

#	apply the linking function of group completion

#	if the groups labels result in a match with a signal then raise the signal

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

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

		print ("labinv1x ret $sigcount\n");

};

	return $sigcount

	}# labinv1

sub labload {

	my ($lab, $labcount, $concept) = @_;

	my ($count);

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

		my ($pr);

		$pr = $Awfif::memes-> {snnih}{$concept};

		print ("labload labcount $labcount concept $pr($concept) ");

};

	$count = $labcount + 1;

	$$lab [$count] = $concept;

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

		print ("labloadx ret $count\n");

};

	return $count

	}# labload

sub destructionscout1 {

	my ($myli, $kwp, $kwpr, $sactset) = @_;#The ignored parameters are required by the codelet calling architecture

	my ($cdn, $cdnx, $descid);

#	checked for merged workspaces

	$cdn = clogstat (\$cdnx);

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

		print ("$cdn myli $myli ");

		&itcpoutput ($myli);

};

#	destruction codelets must use the full workspace

#	see if this workspace has any telomeric structures to evaluate

	if ((($descid = findtelhd ($Awfif::memes-> {currentwsbi}))>0)

	&& (($Awfif::workspace-> {l} [$descid] [2] - $Awfif::memes-> {snnh} {wsi}) > 0)

) {

#		if the telomeric list has entries call in an evaluator

		$Awfif::clp = ();

		$Awfif::clp-> {log} = $Awfif::codelet-> {l} [$myli][13];

		$Awfif::clp-> {urgency} = $Awfif::memes-> {parteu};

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

			$Awfif::clp-> {wsi} = $Awfif::codelet-> {l}[$myli][19];

			}#wsi set

		else {

			$Awfif::clp-> {wsi} = $Awfif::memes-> {currentwsbi};

};

		$Awfif::clp-> {strategy} = "destructionevaluator";

		&cdsubmitcodelet ($myli, \$Awfif::clp);

		};# got a telomere

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

		print ("$cdnx\n");

};

	&clogstatx ();

	}# destructionscout1

sub destructionevaluator1 {

	my ($myli, $kwp, $kwpr, $sactset) = @_;#The ignored parameters are required by the codelet calling architecture

	my ($count, $telcount,

	$cdn, $cdnx);

#	checked for merged workspaces

	$cdn = clogstat (\$cdnx);

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

		print ("$cdn myli $myli ");

		&itcpoutput ($myli);

};

#	see if this workspace has any telomeric structures to evaluate

	$count = 0;

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

	if ($count > $Awfif::memes-> {telcountth}) {

		$Awfif::clp = ();

		$Awfif::clp-> {log} = $Awfif::codelet-> {l} [$myli][13];

		$Awfif::clp-> {urgency} = ($Awfif::codelet-> {l} [$myli][3] * $Awfif::memes-> {blaunchm});

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

			$Awfif::clp-> {wsi} = $Awfif::codelet-> {l}[$myli][19];

			}#wsi set

		else {

			$Awfif::clp-> {wsi} = $Awfif::memes-> {currentwsbi};

};

		$Awfif::clp-> {strategy} = "destructionbuilder";

		&cdsubmitcodelet ($myli, \$Awfif::clp);

		};#if

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

		print ("$cdnx\n");

};

	&clogstatx ();

	}# destructionevaluator1

sub counttelst1 {

	my ($ws, $telcount) = @_;

	my ($ni, $descid, $count);

#	checked for merged workspaces

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

#		print ("counttelst1 ws $ws ");

#		};

#	see if this workspace has any telomeric structures to evaluate

	$count = 0;

	$$telcount = 0;

	if ((($descid = findtelhd ($ws))>0)

	&& (($ni = ($Awfif::workspace-> {l} [$descid] [2] - $Awfif::memes-> {snnh} {wsi})) > 0)

) {

		while ($ni != 0) {

			&istelwso (\$ni, \$count, \$$telcount);

# countteljhlsu1

			};#while

		};#got telomeric structures to evaluate

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

#		print ("counttelst1x telcount $$telcount ret ($count)\n");

#		};

	return $count

	}# counttelst1

sub istelwso {

	my ($ni, $count, $telcount) = @_;

	my ($descid, $found, $life, $jhlsoi, $ini);

#	see if this wso is telomeric and measure it

	$found = '';

	$ini = $$ni;

	if ($$ni != 0) {

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

			print ("istelwso ni $$ni count $$count telcount $$telcount \n");

			&itwsoutput ( trwsoadr ($$ni,1), $$ni);

			};#if trace

		$descid = $Awfif::wsol-> {l} [awsoadr ($$ni)] [2];

		$$ni = 0;

		while (($descid != 0)) {#search ni for telomeric descriptors

			if (($Awfif::workspace-> {l} [$descid] [3] == $Awfif::memes-> {snnh} {value}) && ($Awfif::workspace-> {l} [$descid] [4] == $Awfif::memes-> {snnh} {telomere})) {

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

				if ($life < $Awfif::memes-> {tellifeth} ) {

					$$count++;

					};#if

				}# found a count

			if (($Awfif::workspace-> {l} [$descid] [3] == $Awfif::memes-> {snnh} {lhead}) && ($Awfif::workspace-> {l} [$descid] [4] == $Awfif::memes-> {snnh} {telomere})) {

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

				$$telcount ++;

				$found = 't';

				};# found a head

# isteljhlsu1

			if (

			($Awfif::workspace-> {l} [$descid] [3] == $Awfif::memes-> {snnh} {jhlsoi})

			&& ($Awfif::workspace-> {l} [$descid] [4] == $Awfif::memes-> {snnh} {telomere})

			&& (($Awfif::jhls-> {l} [($jhlsoi = ($Awfif::workspace-> {l} [$descid] [2] - $Awfif::memes-> {snnh} {wsi}))] [14] [2]) <= 1)

) {

				$$count--;

				};# telomere is last link to sponsor gc

# isteldoku1

			if (

			($Awfif::workspace-> {l} [$descid] [3] == $Awfif::memes-> {snnh} {destroyok})

			&& ($Awfif::workspace-> {l} [$descid] [4] == $Awfif::memes-> {snnh} {telomere})

			&& (($Awfif::jhls-> {l} [($jhlsoi = ($Awfif::workspace-> {l} [$descid] [2] - $Awfif::memes-> {snnh} {wsi}))] [14] [2]) <= 1)

			&& (!telisie ($ini))

) {

				$$count++;

				};# telomere is allowed to be destroyed

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

			};#while

		};#if

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

		print ("istelwsox nextni $$ni destcount $$count telcount $$telcount ret ($found)\n");

};

	return $found

	}# istelwso

sub writeiecok {

	my ($sponsor) = @_;

	my ($iedesc, $found, $jhlsi);

#	see if conditions exist to write to the independent & equivalent cache

	$found = '';

	if ($sponsor != 0) {

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

			print ("writeiecok sponsor $sponsor \n");

			&itwsoutput ( trwsoadr ($sponsor,1), $sponsor);

			};#if trace

		if ( (($iedesc = findtdesc ($Awfif::wsol-> {l} [ awsoadr ($sponsor)] [2], $Awfif::memes-> {snnh} {indequiv})) == 0  )	#groupbuilder has not previously written the cache details

		&& (($iedesc = findtdesc ($Awfif::wsol-> {l} [ awsoadr( trwsoadr($sponsor, -1))] [2], $Awfif::memes-> {snnh} {mindequiv})) != 0  )	#groupbuilder has not previously written the cache details

		&& (($jhlsi = ($Awfif::workspace-> {l} [$iedesc][2] - $Awfif::memes-> {snnh} {wsi})) != 0)

		&& ($Awfif::jhls-> {l} [$jhlsi][15] [0])

){

			$found = 't';

			};#if conditions ok

		};#if

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

		print ("writeiecokx ret ($found)\n");

};

	return $found

	}# writeiecok

sub telhasiecache {

	my ($ni) = @_;

	my ($iedesc, $found, $jhlsi);

#	see if telomere has an ie cache

	$found = '';

	if ($ni != 0) {

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

			print ("telhasiecache ni $ni \n");

			&itwsoutput ( trwsoadr ($ni,1), $ni);

			};#if trace

		if ( (($iedesc = findtdesc ($Awfif::wsol-> {l} [ awsoadr ($ni)] [2], $Awfif::memes-> {snnh} {mindequiv})) != 0  )	#groupbuilder has not previously written the cache details

		&& (($jhlsi = ($Awfif::workspace-> {l} [$iedesc][2] - $Awfif::memes-> {snnh} {wsi})) != 0)

		&& ($Awfif::jhls-> {l} [$jhlsi][15][2] > 0)

		&& ($Awfif::jhls-> {l} [$Awfif::jhls-> {l} [$jhlsi][15][2]][15][1])

){

			$found = 't';

			};#if conditions ok

		};#if

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

		print ("telhasiecachex ret ($found)\n");

};

	return $found

	}# telhasiecache

sub telisie {

	my ($ni) = @_;

	my ($iedesc, $found, $jhlsi);

#	see if this telomere is an i.e. master

	$found = '';

	if ($ni != 0) {

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

			print ("telisie ni $ni \n");

			&itwsoutput ( trwsoadr ($ni,1), $ni);

			};#if trace

		if ( (($iedesc = findtdesc ($Awfif::wsol-> {l} [ awsoadr ($ni)] [2], $Awfif::memes-> {snnh} {mindequiv})) != 0  )	#groupbuilder has not previously written the cache details

		&& (($jhlsi = ($Awfif::workspace-> {l} [$iedesc][2] - $Awfif::memes-> {snnh} {wsi})) != 0)

		&& ($Awfif::jhls-> {l} [$jhlsi][15][3] > 0)

){

			$found = 't';

			};#if conditions ok

		};#if

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

		print ("telisiex ret ($found)\n");

};

	return $found

	}# telisie

sub teltail {

	my ($wso) = @_;

	my ($descid, $found, $result);

#	given a telomere head wso find the tail reference

	$found = '';

	$result = 0;

	if ($wso != 0) {

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

			print ("teltail wso $wso \n");

			&itwsoutput ( $wso);

			};#if trace

		$descid = $Awfif::wsol-> {l} [awsoadr ($wso)] [2];

		while (($descid != 0) && (!$found)) {#search ni for telomeric descriptors

			if (

			($Awfif::workspace-> {l} [$descid] [3] == $Awfif::memes-> {snnh} {ltail})

			&& ($Awfif::workspace-> {l} [$descid] [4] == $Awfif::memes-> {snnh} {telomere})

			&& (($result = ($Awfif::workspace-> {l} [$descid] [2] - $Awfif::memes-> {snnh} {wsi})) != 0)

) {

				$found = 't';

				};# telomere is allowed to be destroyed

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

			};#while

		};#if

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

		print ("teltailx ret ($result)\n");

};

	return $result

	}# teltail

sub destructionbuilder1 {

	my ($myli, $kwp, $kwpr, $sactset) = @_;#The ignored parameters are required by the codelet calling architecture

	my ($ni, $descid, $found, $life, $count, $presentni, $lastni, $notdeleting, $cwsbi, $cdn, $cdnx);

#	checked for merged workspaces

	$cdn = clogstat (\$cdnx);

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

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

		print ("$cdn myli $myli ");

		&itcpoutput ($myli);

};

#	see if this workspace has any telomeric structures to destroy

	$count = 0;

	$presentni = 0;

	$notdeleting = 't';

	if ((($descid = findtelhd ($Awfif::memes-> {currentwsbi}))>0)

	&& (($ni = ($Awfif::workspace-> {l} [$descid] [2] - $Awfif::memes-> {snnh} {wsi})) > 0)

) {

		while ($ni != 0) {

			$descid = $Awfif::wsol-> {l} [awsoadr ($ni)] [2];

			$found = '';

			if ($notdeleting) {

				$lastni = $presentni;

				$presentni = $ni;

				};#if

			$ni = 0;

			while (($descid != 0)) {#search ni for telomeric descriptors

				if (($Awfif::workspace-> {l} [$descid] [3] == $Awfif::memes-> {snnh} {value}) && ($Awfif::workspace-> {l} [$descid] [4] == $Awfif::memes-> {snnh} {telomere})) {

# destructionbtellu1

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

					if ($life < $Awfif::memes-> {tellifeth} ) {

						$count++;

						$found = 't';

						};#if

					}# found a count

				if (($Awfif::workspace-> {l} [$descid] [3] == $Awfif::memes-> {snnh} {lhead}) && ($Awfif::workspace-> {l} [$descid] [4] == $Awfif::memes-> {snnh} {telomere})) {

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

					};# found a head

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

				};#while

# destructionbteldu1

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

				my ($nextni, $skipdel);

				$notdeleting = '';

				$skipdel = '';

				if (($nextni = freetelstr ($ni, $presentni, \$skipdel)) == 0) {

					$ni = 0;

					}#if

				elsif ($skipdel) {

#					ni will be the next item to look at

					}# elsif

				else {

					$ni = $presentni;

					};#else

				};#if

			};#while ni != 0

		};#got telomeric structures to destroy

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

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

		print ("$cdnx\n");

};

	&clogstatx ();

	}# destructionbuilder1

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