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

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

Data structures

Summary
This page describes the
This page describes the Adaptive Web framework (AWF) test system and the agent programming framework (Smiley) that supports its operation. 
Example test system statements are included.  To begin a test a test statement is loaded into Smiley while Smiley executes on the Perl interpreter. 
Part of Smiley's Perl code focused on setting up the infrastructure is included bellow. 
The setup includes:
  • Loading the 'Meta file' specification,
  • Initializing the Slipnet, and Workspaces and loading them
  • So that the Coderack can be called. 
The Coderack, which is the focus of a separate page of the Perl frame then schedules and runs the codelets that are invoked by the test statement structures. 
Smiley
data structures.   
Key structures are described each of which is based on a list structure represented with an array and add and free subroutines. 
Introduction
A number of data structures are used widely within the adaptive web framework (AWF) infrastructure. 

Files are slurped and some of the arrays are stored globally in $Awfif::files

The standard structure of lists is illustrated by the parallel normalization list data structure. 

my (#file-private lexicals start
#our (#this would make these non exported package globals
%norml, @normll, $normlp, @normlh, @normlt, $normlf, $fnorml, $tnorml, @minnorml, @maxnorml
);#our non exported Awfif package private lexicals end
%norml = { #parallel normalization result list
    h => [@normlh],
    t => [@normlt],
    f => $normlf, #free pointer
    flistl => $fnorml, #count of free norm links
    tlistl => $tnorml,
    l => [@normll], #info about the named normalisation item
# 2 is the tinstance value generated randomly
# 3 is the next item by tlist value
# 4 is the i that has been generated by normalization
    min => [@minnorml],
    max => [@maxnorml],
    p => $normlp
    };


The Workspace descriptor structure - called $Awfif::workspace to reflect its association with the
This page describes the Copycat Workspace. 
The specialized use of the Workspace by the adaptive web framework's (AWF) Smiley is discussed. 
How text and XML are imported into the Smiley Workspace is described. 
Telomeric aging of schematic structures is introduced. 
The internal data structure used to represent the state of each workspace object is included. 
The Workspace infrastructure functions are included. 
Workspace
as opposed to 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
, is conventionally structured by:
The frame list structure $Awfif::framel, allowing for the representation of a stack frame of Workspaces, is conventionally structured by msadobbuilder (setupframe, addframe), dcrdoinitbuilder(1, 2), dcrdoslistbuilder, dcrdogowithinbuilder (addframe & freeframe) and dcrdocasedescbuilder.  A frame descriptor such as {wsframe} is used to maintain the head index in frame descriptor-> {l}[3] and the frame depth in frame descriptor-> {l} [2]. 

The histone, in the eukaryotic cell are enzymes which bind to the DNA polymers supporting them and controlling their interactions with other enzymes.  In particular sets of DNA operons can be enabled or disabled by histone induced changes in the DNA polymers shape.  In AWF the histone control of DNA has been abstracted in a codelet based implementation of operon controlled programmed case control. 
list structure $Awfif::histonel is conventionally structured by addhistone & deploymd.  A Workspace list element is associated with, and hence affected by, a histone if it has $Awfif::wsol-> {l} [absolute element index] [$Awfif::memes-> {wsohistbp}] set to a $Awfif::histonel element index.  The $Awfif::histonel element identifies the end of the histone associated schematic structure & the histone's state. 

The crowding out list structure $Awfif::costatel, structured by cletcostate includes the hash costate->{hash} which associates the codelet name with an element of the list {l}. 

The codelet parameter structure $Awfif::clp includes the clp->{action} data structure conventionally structured by unpackclp.

The sub-program list $Awfif::subpl is conventionally structured by addsubp.  addsubp manages the list and its head, so it must use addhli and freehli, rather than addli and freeli, to allocate and deallocate the list elements of {l}: The list elements of {q}:
  • Item [0] is structured by freecodelet and bcsubpcbuilder, and referenced by bcsubpsbuilder;
  • Item [1] is structured by freecodelet;
  • Item [2] is structured by notwaitonelkd;
  • Item [3] is structured by bcsubpsbuilder,
The list elements of {w} are structured by bcsubpsbuilder(1, 2)and referenced by crsmbuilder, icrsmoxbuilder, bcsubpsbuilder, applycodelet &  tmgiegcsalience;

The pooled codelet list $Awfif::poolcl is conventionally structured by addpoolc.  Head references are managed by pooling initiators such as ivalbuilder, bcsubpsbuilder and crsmbuilder

The vector cache list $Awfif::veccol is described in cache amplification. 

The transaction list $Awfif::tral is conventionally structured by addtra, and waitonstrancomp.  $Awfif::tral-> {r} and {c} are associated by subptrachanged.  $Awfif::tral-> {sameas} is associated by assandmaptran. 

The transaction back reference list $Awfif::sametl is conventionally structured by addsamet.  The back reference lists are associated through the transid via the head and tail references $Awfif::tral-> {sameash} and {sameast}.  When a transaction resolves to a procedure in igetcontext or changes state it can refer to its back reference list via the head or tail indexed by its transaction id. 

The transaction is an operation which guarantees to complete a defined set of activities or return to the initial state.  For a fee the postal service will ensure that a parcel is delivered to its recipient or will return the parcel to the sender.  To provide the service it may have to undo the act of trying to deliver the parcel with a compensating action.  Since the parcel could be lost or destroyed the service may have to return an equivalent value to the sender. 
manager list $Awfif::tmassl is conventionally structured by addtmass, firsttmgr, assprocwtmass and gettmgr.  It is connected to the 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! 
schemata by {pindequiv} descriptor which references the parent's jhls entry where slice [19] is the head of an $Awfif::amoffl list which is conventionally structured by addamoff, nsdepbuilder/addamoffmatch & idorolein for use by applycodelet. 

The cascade sponsor list $Awfif::cswsol which associates telomeric WSO with cascadesponsor codelets is conventionally structured by addcswso and notcsponsor.  cascadesponsor manages the list and its head, so it must use addhli and freehli, rather than addli and freeli, to allocate and deallocate the list elements. 

The subpscdef list $Awfif::subpscdefl which links deferred bcsubps codelets is conventionally structured by addsubpscdef. 

The wfcdef list $Awfif::wfcdefl links vbot waitfor descriptor events.  It is conventionally structured by addwfcdef, freewfcdef with waitondesc, waitforme and iwfccount.  It is supported by a chain hash $Awfif::wfchchainl which is structured by addwfchchain and freewfchchain. 

The synchronize on event list $Awfif::syncl and its synchronized codelet list $Awfif::synccodl are conventionally structured by waitondesc and waitonstrancomp.  waitondesc records the head of the sublist in the WSO ($Awfif::wsol-> {l} [$awso]  [$Awfif::memes-> {wsosyncl}]) where the descriptor will be deployed. 
For example endlistkwbuilder synchronizes with the deployment of ({subpref})-({completed})-> #sub by bcsubpcbuilder. 
bcsubpcbuilder synchronizes on the sub-transaction completion before it carries out the descriptor deployment.  waitonstrancomp clones its caller's codelet wrapping the codeletid in a synccodl list element.  It records the $Awfif::synccodl reference in the 0 element of the $Awfif::tral-> {w} slice for the sub-transaction.  Transalloc {casparticipant} uses the Awfif::tral/synccodl to activate the deferred codelets. 

The codelet feedback list $Awfif::fbl links codelets of the same name into hash chains.  It is conventionally structured by addfb, freefb, submitcodelet, freecodelet and addfeedback. 

# exporter

BEGIN {#This is executed as soon as possible by Perl
    use Exporter qw (import);
    our ($VERSION, @ISA, @EXPORT, @EXPORT_OK,
# %EXPORT_TAGS
    );
    $VERSION = 1.02;
    @ISA = qw();
# @ISA = qw(Exporter);
    @EXPORT = qw ();
# exported package globals go here
# optionally exported functions
    @EXPORT_OK = qw( bindversion pbsfs pbscore ithrefcheck jcontains rlocalityis slocalityis getstring findsitem
        findbsitem gettlistrec getlistcontrol initsymbols applyecasecontrol expandfile
# expandtarget includesource subntlistd subntlistvlb
# subntlistv1 subntlistv2
        matchstring1 matchstring1a matchstring2
        matchstring2a matchstring3 matchstring3a
        setuserprof submitcodelet
        bondscout1
        coderack);
# %EXPORT_TAGS = ();
    }

# exported package globals go here
# our $ Var1;
# non-exported package globals go here
#<!-- start tag lr -->
#<!-- start tag paral -->
my (#file-private lexicals start
#our (#this would make these non exported package globals
#<!-- end tag paral -->
#<!-- end tag lr -->
%binds, %bh, %usesymb, $inbvk, $inbvr, $invasn, @j, @j2, @prepsf, @prepsfc,
# %linked,
%cache, %pcache, %clp, %wslocality,
%memes, %mapped, @scalers,
%keywordh, %keywordwsih, @keywordl, %snnh, %snnih, %snna, %snnac, %snnacla, %snnaf, %snnafm, @snnl, @snnc, @snnd, $snep, @snmsnn,
@snehil, $snehip, $snehih, @wsohil, $wsohip, $wsohih, @csehil, $csehip, $csehih, @csehid,
%cseh, %cseih, %workspace,
@wsodesl, $wsodesp, $wsodesh, $wsodest, $wsodesf, $fwsodes, $twsodes,
@breakcodelet, @breakthwso, @breaksubp, @breakthsubp,
#<!-- start tag lr -->
# part of the Awfif non-exported package globals for the list regressions tests
#
# lrpackagedata
#
%lrst, $lrj,
#
#<!-- end tag lr -->
$jhldesp, $attribdesp,
# tkxdata
%tkx, $tkxbyteswritten, $tkxcount, $tkxnl, $tkxpid, $tkxread, $tkxt, %tkxtinfo, $tkxwrite,
# **** memetic variables
$loopcheck, $loopth, $failatpr, $traceadentry, $telomeretrace, $tracedpcache, $tracevcentry,
$traceclogentry, $tracehrtime,
$ratcoth, $abscoth, $tracetime, $nomcrsmgrab, $ssiasslncusetmass, $tellifeth,
$telcountth, $inhuramp, $usewcf1d, $usetdfmod, $tdfsampth, $tdfsampds, $tdfsampacc,
$mainco, $maininc, $freeampth, $maxusefree, $bcsubpsindex, $ivalwindex, $crsmindex, $totup,
$bugsmax, $killth, $ampramp, $waitamp, $convfrom, $groupatype, $groupato, $groupafrom,
$bumscu, $tdgsramp, $geramp, $gerhiamp, $budestscu, $pappbu, $parteu, $evlaunchm, $evlaunchhim,
$blaunchm, $ilaunchm, $icompdlaunchm, $manthreshold, $pstment, $pactive, $psubprogram,
$acodelets, $mincodelets, $breakmyli, $bmbcindex, $drwait, $crfocuswin, $grcompaward,
$salthr, $mmratio, $dmratio, $verbsrcws, $verbtaws, $clogbplist, $clogeplist, $clogs,
$comprocessing, $cbprocessing, $maxnormitems, $cpcountth, $maxtdgloop, $itswsallc,
$wsoname, $buildfbth, $delayselcount, $delayamp, $tgnth, $doprsib, $chckadd,
$checktransidnz, $checksubpidnz, $tral, $applycmin, $iapplycth, $applycth, $iapplyramp,
$applyramp, $applycount, $applyactive, $applyspigdiv, $newdep, $bnotsalient, $bsalient,
$submult, $submitted, $casetrmcws, $casetrmbcwso, $subptrachcount, $acaseoutputps,
$subprefctr, $allowspigrabmax, $veccah, $veccab, $usewsodirect, $usewsobfdirect,
$codeletdef, $jhldesf, $attribdesf, $attribdesh, $allwsstr, $npconc, $maxpconcs,
$smlscstate, $srfsmcstate, $trfsmcstate, $nfsmcstate, $stbbpersist, $fjhls8,
$storetheds, $storestop, $memnwsi, $usedivtags,
@crsmesubpspbreak, @cruna, @breaksalwso, @leavein, @strbool, @dcodeletc, @ieowner,
%ch, %cseh, %cseih, %streh, %streih, %starttime, %gdeltachange,
#
$codeleth, $codeletw, $codelett, $codeletf, $codeletp, @clnkl, $clnkp, %clnk, $clnkf, $clnkt, $clnkh, $fclnk, $clnkflistl,
%slipnet, %cacheh, @cachel, @pcachel, @pcachep, @pcachea, @pcachet,
%codelet, %slehist, %wsohist, %csehist, $minnorm, $minowidth, $maxoper, $maxact, %jhls, %attribs,
@temp, @codelett, $tcodelets, $tcodeletmax, $fcodelets, $jhldesf, $attribdesf, $attribdesh,
$structamp, $strbcont, $strnbcont, $depththamp, $depthamp, $depthslp,
$actamp, $actth, $actramp , $actmax, $actdamper, @activationchange, $ndecay, $ntact,
$crwait, $crkwp, $crkwpr,
$iphase, $iphasecomp, $peaksal,
$relatype, $relato, $relafrom, $descatype, $descato, $descafrom, $bondatype, $bondato, $bondafrom, $openatype, $openato, $openafrom, $uhmax, $uhth, $shout, $cpmax, $halomax,
$trace, $traceentry, $log, $logentry, $clplog, $clprework, $clpwsi, $clpdelayselect, $mrework, $lsbase, $lsnbase, $lebase, $lbbase, $tracetemp, $tracetree, $tracefull, $traceurg, $tracephase, $tracescache, $tscacheth, $tracemcache, $tmcacheth, $tracewscache, $twscacheth,
@time,
$cquote,
$fatigue, $fatp, $gatp, $batp, $datp, $ldsignal, $ldmcycle, $ldlcycle, $ldlcyclemax, $ldmcyclemax, @ldbuffer, $ldav, $ldoav, $lderr, $rtemp, $destthreshold, $descthreshold, $bondthreshold, $groupsponsor,
$critical, $coordmax, $coordamp,
$slipth, $relbar, $bondbar, $bondrwd, $bondamp, $desbar, $desrwd, $relrwd, $relamp,
#
$kwmi, $kwmir,
$clpurgency, $clpstrategy, %action, %bond, %group, %relation, $ni, $nidl, $nsnn, $pi, $pidl, $psnn, $gmodel, $gsponsor,
$category, $asignal, $aschema, $atfree, $atransid, $atransmgrid, $asubpi, $ausepooling,
%descriptor, $property, $buscu, $budescu, $acteu, $tdbsurg, $tddsurg, $tdgsurg, $propsnnode, $propsponsor, $mtsnstate, $mtsnlvl, @mtsnlc,
# lexblockdata
%lexblock, @lexblockd, $lexblockp, $lexblockc, @lexblockl, $lexblockh, $lexblockt, $lexblockf, $flexblock, $tlexblock,
# pagesdata
%pages, $pagesactive, $pagescurrent, $pageswanted, $pagesmax, $pagesext, $pagescompleted, $pagestarget, %pageshnames, $pagespscomp, %pageshdupnames, $pageslinecount, $pagesminlinecount, $pagesinhead, $pagespartref, $pagestotal, %pageshname, %pagespnamemap, %pagespnamemapf, $pagespath, @pagestagname, $pagescomment, $pagesalertincname, %pagesinames, $pageshrpage, $pagespend, @pagescontents, $pagescontentspage, %pagesfullhnames, %pagesfullinames, @pagescontentsdone,
# indlinedata
%indline, $indlineaccess, @indlineincstream, @indlineinincstream, @indlinerest,
#
%metasymbset, %symbolsets, $lbistringf, %imetasymbset,
@lbcnames, $lbcneeds, @lbcnamee, %lbcname, @lbcnamefsc, %lbch, @inlbcf, $lblinec, @lbcforie,
@lbcforiname, $lbcforicount, @lbcfname, $lbcificount, @lbcifiname, @lbcifselv,
$inlbt, $lbi, $lbi2, @lbis, @lbat, @lbar, @lbhref, @lbhreft,
@lbt, @lbsp, @lbdn, @lbb, @lbet, @lbst, @lbfs, @lbelas, @lbelac, @lbelae,
%lbrec, %lbtypesh, %lbih, %lblname, $lbcifrindex, @lbcifrsindex, @lbcifrdsindex,
@lbcifarsindex, @lbcifsync, @lbcifsynci, @lbcifsyncc, @lbcifsyncf, $lbcifsyncb, @lbcifnamee,
@lbcifnames, $lbcifselindex,
$lbcifrinstance, %lbcifrneeds, $lbcifdinstance, @lbcifrdf, @lbcifrdt, @lbcifused, @lbcifbasign, @lbcfused,
@lbcifrdfq, @lbcifrdtq,
$lbboth, $lbbsharing, @lbciffor, $lbji, @lbjb,
$lbri, $olbname, $lbneeds, $inonlb, @lblnames, @lblnamee,
@inlbl, @inlbiname, @inlbname, @inlblname, @inlbfs, @inlbst, @inlbet, @inlbr, @inlbdn, @inlbhref,
@inlbelas, @inlbelac, @inlbelae,
@inlbsp, @inlbb, @inlbis, @inlbat, @lbtypes, @lbname, @lbdnt, @lbitype, $inslbl,
%lbstruct, %lbht, @lbhtk, @inlbht, @inlbhtk, %lbhtki, %lbhtkig, %lbhtkio, @lbhtksc,
@lbcsv, @inlbcs, %lbistrt, @lbhtc,
#
%lbsymbset, $lb2istringf,
@lb2cnames, $lb2cneeds, @lb2cnamee, %lb2cname, @lb2cnamefsc, %lb2ch, @inlb2cf, $lb2linec, @lb2cforie,
@lb2cforiname, $lb2cforicount, @lb2cfname, $lb2cificount, @lb2cifiname, @lb2cifselv,
$inlb2t, $lb2i, $lb2i2, @lb2is, @lb2at, @lb2ar, @lb2href, @lb2hreft,
@lb2t, @lb2sp, @lb2dn, @lb2b, @lb2et, @lb2st, @lb2fs, @lb2elas, @lb2elac, @lb2elae,
%lb2rec, %lb2typesh, %lb2ih, %lb2lname, $lb2cifrindex, @lb2cifrsindex, @lb2cifrdsindex,
@lb2cifarsindex, @lb2cifsync, @lb2cifsynci, @lb2cifsyncc, @lb2cifsyncf, $lb2cifsyncb,
@lb2cifnamee, @lb2cifnames,
$lb2cifselindex, $lb2cifrinstance, %lb2cifrneeds, $lb2cifdinstance, @lb2cifrdf, @lb2cifrdt, @lb2cifused, @lb2cifbasign,
@lb2cfused, @lb2cifrdfq, @lb2cifrdtq,
$lb2both, $lb2bsharing, @lb2ciffor, $lb2ji, @lb2jb,
$lb2ri, $olb2name, $lb2needs, $inonlb2, @lb2lnames, @lb2lnamee,
@inlb2l, @inlb2iname, @inlb2name, @inlb2lname, @inlb2fs, @inlb2st, @inlb2et, @inlb2r, @inlb2dn, @inlb2href,
@inlb2sp, @inlb2b, @inlb2is, @inlb2at, @lb2types, @lb2name, @lb2dnt, @lb2itype, $inslb2l, @inlb2elas, @inlb2elac, @inlb2elae,
%lb2struct, %lb2ht, @lb2htk, @inlb2ht, @inlb2htk, %lb2htki, %lb2htkig, %lb2htkio, @lb2htksc,
@lb2csv, @inlb2cs, %lb2istrt, @lb2htc,
#
# %findb,
%backoffactive, %backoffactives, %sortingha,
%csymbset, $cistringf,
@ccnames, $ccneeds, @ccnamee, %ccname, @ccnamefsc, %cch, @inccf, $clinec, @ccforie,
@ccforiname, $ccforicount, @ccfname, $ccificount, @ccifiname, @ccifselv,
$inct,
$ci, $ci2, @cis, @cat, @car, @chref, @chreft,
@ct, @csp, @cdn, @cb, @cet, @cst, @cfs, @celas, @celac, @celae,
$ccifrindex, @ccifrsindex, @ccifrdsindex,
@ccifarsindex, @ccifsync, @ccifsynci, @ccifsyncc, @ccifsyncf, $ccifsyncb, @ccifnamee, @ccifnames, $ccifselindex,
$ccifrinstance, %ccifrneeds, $ccifdinstance, @ccifrdf, @ccifrdt, @ccifused, @cccifbasign, @ccfused, @ccifrdfq, @ccifrdtq,
$cboth, $cbsharing, @cciffor, $cji, @cjb,
%crec, %ctypesh, %cih, %clname,
$cri, $ocname, $cneeds, $inonc, @clnames, @clnamee,
@incl, @inciname, @incname, @inclname, @incfs, @incst, @incet, @incr, @incdn, @inchref,
@incsp, @incb, @incis, @incat, @ctypes, @cname, @cdnt, @citype, $inscl, @incelas, @incelac, @incelae,
%cstruct, %cht, @chtk, @incht, @inchtk, %chtki, %chtkig, %chtkio, @chtksc, @ccsv, @inccs,
%cistrt, @chtc,
#
%logosymbset, $logoistringf,
@logocnames, $logocneeds, @logocnamee, %logocname, @logocnamefsc, %logoch, @inlogocf, $logolinec, @logocforie,
@logocforiname, $logocforicount, @logocfname, $logocificount, @logocifiname, @logocifselv,
%logorec, $logori, @inlogol, $logocifrindex, @logocifrsindex, @logocifrdsindex,
@logocifarsindex, @logocifsync, @logocifsynci, @logocifsyncc, @logocifsyncf, $logocifsyncb, @logocifnamee,
@logocifnames, $logocifselindex,
$logocifrinstance, %logocifrneeds, $logocifdinstance, @logocifrdf, @logocifrdt, @logocifused, @logocifbasign,
@logocfused, @logocifrdfq, @logocifrdtq, $logoboth, $logobsharing,
@logociffor, $logoji, @logojb,
@logotypes, $logoi, %logotypesh, %logoih, @logoitype, @logoname, @logofs, @logost, @logoet, @logois, @logoat, %logoht, @logohtk,
@logoelas, @logoelac, @logoelae,
@logob, @logosp, @logodn, @logohref, @inlogor, @inlogoelas, @inlogoelac, @inlogoelae, @inlogoht, @inlogohtk, %logohtki, %logohtkig, %logohtkio, @logohtksc,
@inloname, $logoneeds, @inlolname, @inloiname, @inlofs, @inlost, @inloet, @inlob, @inlosp, @inlohref, @logohreft, @inlodn, @logodnt,
@inloat, @inlois, @logot, $inonlogo, %logolname, @logolnames, @logolnamee,
@logocsv, @inlocs, %logoistrt, @logohtc,
# dvardata
%dvarh, %ddvarh,
%logostruct,
# filesdata
%files,
@pbscfilea, @clfilea, @icbfilea,
# urldata
%url,
# ithrefdata
@ithreflinks, %ithreflinksh, %ithrefrefsh, %ithrefnamesh, @ithrefvisited,
# jhlabeldata
%jhlabel, $jhlp, %jhlg, %jhip,
# kwjhldata
%kwjhlabel, $kwjhlp, %kwjhlg, %kwjhip, %kwjhl,
#keywordlist
%kwl, @kwli, @kwll, @kwlw, $kwlp, $kwlh, $kwlt, $kwlf, $fkwl, $tkwl,
#memetic keyword list
%mkwl, @mkwli, @mkwll, $mkwlp, $mkwlh, $mkwlt, $mkwlf, $mfkwl, $mtkwl,
#transaction allocator list
%tral, @trali, @trall, @tralw, @tralwt, $tralp, $tralh, $tralt, $tralf, $ftral, $ttral, @tralc,
@tralsameas, @tralsameash, @tralsameast, @tralsameasaadd, @tralr,
#transaction manager association list
%tmassl, @tmassls, @tmasslr, @tmassll, @tmasslsalience, @tmasslsubmitted, $tmasslp, $tmasslh, $tmasslt, $tmasslf, $ftmassl, $ttmassl,
%tmasslwsoh, %tmasslwsot, %tmasslfirst, %tmasslproc,
#starttime
$sttsec, $sttmin, $stthour, $sttmday, $sttmon, $sttyear, $sttwday, $sttyday, $sttisdat,
#histonelist
%histonel, @histonell, $histonelp, $histonelh, $histonelt, $histonelf, $fhistonel, $thistonel,
# frameldata
%framel, @framell, $framelp, $framelh, $framelt, $framelf, $fframel, $tframel,
#ifbhc list
%ifbhcl, @ifbhcll, $ifbhclp, $ifbhclh, $ifbhclt, $ifbhclf, $fifbhcl, $tifbhcl, %ifbhclhc,
%ifbhclastwso, %ifbhclnuclear, %ifbhclexternal,
#ilabhc list
%ilabhcl, @ilabhcll, $ilabhclp, $ilabhclh, $ilabhclt, $ilabhclf, $filabhcl, $tilabhcl, %ilabhclhc,
%ilabhclastwso, %ilabhclnuclear, %ilabhclexternal,
#bindtoinsp cache
%bicl, @bicll, @biclrec, $biclcp, $biclp, $biclh, $biclt, $biclf, $fbicl, $tbicl,
#workspace base
# wsbldata
%wsbl, %wsblstatement, @sgmfile, @wsbll, @wsblactive, @wsblwinkwp, @wsblwinkwpr, @wsblrelorabs,
$wsblp, $wsblh, $wsblt, $wsblf, $fwsbl, $twsbl,
@wsblhih, @wsbloh, @wsblot, @wsbloto, @wsblft, @wsblasentinal, @wsblnh, @wsblofssum,
@wswsbloh, @wswsblot, @wsblssentinal,
%wsol, @wsobjectl, $wsolp, $wsolh, $wsolt, $wsolf, $fwsol, $twsol, @wsolni,
%wsblgetmys,
#
# cletassocdata
%clet, %cletassoc, %cletassocsa,
# subpldata
%subpl, @subpll, @subplw, @subplq, $subplp, $subplh, $subplt, $subplf, $fsubpl, $tsubpl,
# costateldata
%costatel, @costatell, $costatelp, $costatelh, $costatelt, $costatelf, $fcostatel, $tcostatel, %costatelhash,
# sametldata
%sametl, @sametll, $sametlp, $sametlh, $sametlt, $sametlf, $fsametl, $tsametl,
# vbotgadata
#@vbotgascmap,
%vbotga, @vbotgascmap0, @vbotgascmapc, @vbotgascmapn, @vbotgafitness, @vbotgaparent, @vbotgaparent2,
%vbotscmaph, %vbotha, @vbotgens, %vbotscmapehi, $vbotgagen,
# **** vbot memes
@canxl, @canyl,
# amoffldata
%amoffl, @amoffll, $amofflp, $amofflh, $amofflt, $amofflf, $famoffl, $tamoffl,
# poolcldata
%poolcl, @poolcll, $poolclp, $poolclh, $poolclt, $poolclf, $fpoolcl, $tpoolcl,
# syncldata
%syncl, @syncll, $synclp, $synclh, $synclt, $synclf, $fsyncl, $tsyncl,
# synccodldata
%synccodl, @synccodll, $synccodlp, $synccodlh, $synccodlt, $synccodlf, $fsynccodl, $tsynccodl,
# cswsoldata
%cswsol, @cswsoll, $cswsolp, $cswsolh, $cswsolt, $cswsolf, $fcswsol, $tcswsol,
# vfhistdata
%vfhist, @vfl, $vfp, $tvf, $vfh, $vft, @vfhistmean,
# subpscdefldata
%subpscdefl, @subpscdefll, $subpscdeflp, $subpscdeflh, $subpscdeflt, $subpscdeflf, $fsubpscdefl, $tsubpscdefl,
# wfcdefldata
%wfcdefl, @wfcdefll, $wfcdeflp, $wfcdeflh, $wfcdeflt, $wfcdeflf, $fwfcdefl, $twfcdefl, %wfcdeflhash, %wfcdeflhashb, %wfcdefloperon,
# wfchchainldata
%wfchchainl, @wfchchainll, $wfchchainlp, $wfchchainlh, $wfchchainlt, $wfchchainlf, $fwfchchainl, $twfchchainl, %wfchchainlhashname,
# jhlchldata
%jhlchl, @jhlchll, $jhlchlp, $jhlchlh, $jhlchlt, $jhlchlf, $fjhlchl, $tjhlchl, %jhlchlchash, %jhlchlpchash, %jhlchlchasht, %jhlchlpchasht, %jhlchljhclmax, %jhlchljhclmin, %jhlchljhpclmax, %jhlchljhpclmin,
# fbldata
%fbl, @fbll, $fblp, $fblh, $fblt, $fblf, $ffbl, $tfbl, %fblhc, %fblhcc,
# searchldata
%searchl, @searchll, $searchlp, $searchlh, $searchlt, $searchlf, $fsearchl, $tsearchl,
# dipextldata
%dipextl, @dipextll, $dipextlp, $dipextlh, $dipextlt, $dipextlf, $fdipextl, $tdipextl,
#<!-- start tag ca -->
# vectorcache
#vector cache support
%veccol, @veccoll, $veccolp, $veccolh, $veccolt, $veccolf, $fveccol, $tveccol, @veccolsh, $veccolstate, %veccolstrategy, %veccolindex, @veccolststate,
%veccolisset, %cvparmmap, %cvparmtype, %cvindexmap,
#<!-- end tag ca -->
%hnamel, @hnamell, $hnamelp, $hnamelh, $hnamelt, $hnamelf, $fhnamel, $thnamel,
%itswsall, @itswsalll, $itswsallp, $itswsallh, $itswsallt, $itswsallf, $fitswsall, $titswsall,
#<!-- otart tag inh -->
%inhibl, @inhibll, $inhiblp, $inhiblh, $inhiblt, $inhiblf, $finhibl, $tinhibl,
#<!-- ond tag inh -->
%trfl, @trfll, $trflp, $trflh, $trflt, $trflf, $ftrfl, $ttrfl,
%harray, @hatce,
#<!-- start tag paral -->
%norml, @normll, $normlp, @normlh, @normlt, $normlf, $fnorml, $tnorml, @minnorml, @maxnorml
#<!-- end tag paral -->
,$currentwsbi, $kwwsbi,
#scratchpad
%aspl, @aspli, @aspll, @asplws, @asplnws, $asplp, $asplh, $asplt, $asplf, $faspl, $taspl, $asws, $awsoname, $awss, $awse, $awsgs, $awsge, $ajhlabeli, $asgjhlsi, $apmman,
@asplb1, @asplb2, @asplb3, @asplb4, @asplb5, @asplb6, @asplb7, @asplb8, @asplb9, @asplb10,
%wontgroupc, $wgccaller, @wgcl, @wgci, $wgcp, $wgch, $wgct, $wgcf, $fwgc, $twgc,
#
%kwbracketd, $kwbbmec, $kwbibmec, $kwbsmsc, $kwbincb, $kwbincs,
%inhib, $inhiblinkp, @inhiblclpa, @trflclpa,
#memes referenced storage
@sactset,
#
%snw,#slipnet memetic hash used to reference the
#
$usedesc, $userel, $igdesc, $igrel,
#
#@params,
$tstring, @wsm, $actweight, $actfocus,
@rlocalityl, @rlocalitylc, %rlocalityh,
%genetic, $pstream, @cc
#<!-- start tag lr -->
#<!-- start tag paral -->
);#our non exported Awfif package private lexicals end
#<!-- end tag paral -->
#<!-- end tag lr -->
# initialize package globals, first exported ones
# $Var1 = '';
# Hashit = ();
# then the others (which are still accessible as $Awfif::stuff)
# version bootstaps must be in place.
#%linked = {};
%metasymbset = {};
%lbsymbset = {};
%logosymbset = {};
#@params = ();
#$usesymb {"<rhlpversrec>"}= "T";
$tstring = "0";
#@j = ();
$invasn = "0";
$inbvr = "0";
$inbvk = "0";
#
#
#$binds{"lbvproc"} = *lblistsv1{CODE};

%harray = {
    tce => [@hatce],
    dvar => {%dvarh},
    ddvar => {%ddvarh}
    };
# tkx
%tkx = {
    byteswritten => $tkxbyteswritten,
    count => $tkxcount,
    nl => $tkxnl,
    pid => $tkxpid,
    read => $tkxread,
    t => $tkxt,
    tinfo => {%tkxtinfo},
    write => $tkxwrite
    };
#<!-- start tag lr -->
# part of the Awfif non-exported package globals for the list regressions tests
#
#
%lrst = {
    j => $lrj
    };
#
#<!-- end tag lr -->
# clet
%clet = { #codelet associations
    assoc => {%cletassoc},
    assocsa => {%cletassocsa}
    };
# wsbl
%wsbl = { #workspace base and offset links
    statement => {%wsblstatement},
    sgmfile => [@sgmfile], #the nuclear sub group schemata
    h => $wsblh,
    t => $wsblt,
    f => $wsblf, #free pointer
    flistl => $fwsbl, #count of free cache links
    getmys => {%wsblgetmys},
    tlistl => $twsbl,
    l => [@wsbll],
    relorabs => [@wsblrelorabs],
    winkwp => [@wsblwinkwp],
    winkwpr => [@wsblwinkwpr],
    wsactive => [@wsblactive],#indicates if the workspace is actively processed by the coderack
    wsoh => [@wsbloh], #array of heads of workspaces
    wsot => [@wsblot], #array of tails of workspaces
    wsoto => [@wsbloto], #array of tail offsets
    wsft => [@wsblft], #array of fast tails - past first ichar & ws
    wsbloh => [@wswsbloh], #group modelled ws heads setup in newwso & used in group codelets
    wsblot => [@wswsblot], #group modelled ws tails used in group codelets
    wsohih => [@wsblhih], #array of heads of wso history for each ws
    wsas => [@wsblasentinal], #array recording use of architected sentinals
    wsss => [@wsblssentinal], #
    newhead => [@wsblnh],
    ofssum => [@wsblofssum], #static sum of offset and tail updates
    p => $wsblp
    };
%wsol = { #workspace control structure
    h => $wsolh,
    t => $wsolt,
    f => $wsolf, #free pointer
    flistl => $fwsol, #count of free cache links
    tlistl => $twsol,
    l => [@wsobjectl],
# wsolfbv
# wsoli16
# wsoli32
# removed
    ni => [@wsolni],
    p => $wsolp
    };
%vbotha = {
    gens => [@vbotgens],
    scmapehi => {%vbotscmapehi}
    };
# crstarttime
%starttime = {
    sec => $sttsec,
    min => $sttmin,
    hour => $stthour,
    mday => $sttmday,
    mon => $sttmon,
    year => $sttyear,
    wday => $sttwday,
    yday => $sttyday,
    isdat => $sttisdat
    };
# workspace
%workspace = {
    h => $wsodesh,
    t => $wsodest,
    f => $wsodesf, #free pointer
    flistl => $fwsodes, #count of free hname cache links
    tlistl => $twsodes,
    l => [@wsodesl], #wsobject descriptors as links
# 2 is too - in mdesc architecture it is data reference - dropsalience descriptorlink assumes it is a control ws relative indirect descriptor id (+ $Awfif::memes-> {snnh} {wsi}) so it will address a different ws and hence wso in each sub-program; - cascadesponsor assumes the [2] is the direct sponsor reference id for {cassponsor} descriptors.
# 3 is type - in mdesc descriptorlink architecture it is maskable by adding 1;
# 4 is from - in counter architecture it is maskable by adding 1; Transcounters also use 11 for transactional state. Descriptor links have the value #Awfif::memes-> {snnh} {descriptorlink}. Mdesc cassponsor is maskable as wascassponsor.
# 5 used in strength calc
# 9 is the counter value in counter architecture
# 10 is the stname etc string
# 11 is used in transactional counter architecture to represent presence if +ve or roled out -ve; The value is the transaction manager id
# 12 is used to represent cassrelay property within cassponsor descriptor
    p => $wsodesp #base for adding new array items
    };
# wontgroupcu3
%wontgroupc = {
    h => $wgch,
    t => $wgct,
    f => $wgcf, #free pointer
    flistl => $fwgc, #count of free cache links
    tlistl => $twgc,
    l => [@wgcl],
    i => [@wgci],
    p => $wgcp,
    caller => $wgccaller #start indicates initialise, stop indicates end use, wsi + $myli indicates in use;
    };
# bicl
%bicl = {
    h => $biclh,
    t => $biclt,
    f => $biclf, #free pointer
    flistl => $fbicl, #count of free cache links
    tlistl => $tbicl,
    l => [@bicll],
    rec => [@biclrec],
    cp => $biclcp,
    p => $biclp
    };
# parallelnorml
#<!-- start tag paral -->
%norml = { #parallel normalization result list
    h => [@normlh],
    t => [@normlt],
    f => $normlf, #free pointer
    flistl => $fnorml, #count of free norm links
    tlistl => $tnorml,
    l => [@normll], #info about the named normalisation item
# 2 is the tinstance value generated randomly
# 3 is the next item by tlist value
# 4 is the i that has been generated by normalization
    min => [@minnorml],
    max => [@maxnorml],
    p => $normlp
    };
#<!-- end tag paral -->
# ifbhcl
%ifbhcl = {
    h => $ifbhclh,
    t => $ifbhclt,
    f => $ifbhclf, #free pointer
    flistl => $fifbhcl, #count of free cache links
    tlistl => $tifbhcl,
    hc => {%ifbhclhc},
    astwso => {%ifbhclastwso},
    nuclear => {%ifbhclnuclear},
    external => {%ifbhclexternal},
    l => [@ifbhcll],
    p => $ifbhclp
    };
# ilabhcl
%ilabhcl = {
    h => $ilabhclh,
    t => $ilabhclt,
    f => $ilabhclf, #free pointer
    flistl => $filabhcl, #count of free cache links
    tlistl => $tilabhcl,
    hc => {%ilabhclhc},
    astwso => {%ilabhclastwso},
    nuclear => {%ilabhclnuclear},
    external => {%ilabhclexternal},
    l => [@ilabhcll],
    p => $ilabhclp
    };
# framel
%framel = {
    h => $framelh,
    t => $framelt,
    f => $framelf, #free pointer
    flistl => $fframel, #count of free cache links
    tlistl => $tframel,
    l => [@framell],
    p => $framelp
    };
# fbl
%fbl = {
    h => $fblh,
    t => $fblt,
    f => $fblf, #free pointer
    flistl => $ffbl, #count of free cache links
    tlistl => $tfbl,
    l => [@fbll],
    hc => {%fblhc}, #hash chain head
    hcc => {%fblhcc}, #hash chain count
    p => $fblp
    };
# subpl
%subpl = {
    h => $subplh,
    t => $subplt,
    f => $subplf, #free pointer
    flistl => $fsubpl, #count of free cache links
    tlistl => $tsubpl,
    l => [@subpll],
    q => [@subplq],
    w => [@subplw], #array with index true if waiting
    p => $subplp
    };
# costatel
%costatel = {
    h => $costatelh,
    t => $costatelt,
    f => $costatelf, #free pointer
    flistl => $fcostatel, #count of free cache links
    tlistl => $tcostatel,
    l => [@costatell],
    hash => {%costatelhash},
    p => $costatelp
    };
# amoffl
%amoffl = {
    h => $amofflh,
    t => $amofflt,
    f => $amofflf, #free pointer
    flistl => $famoffl, #count of free cache links
    tlistl => $tamoffl,
    l => [@amoffll],
    p => $amofflp
    };
# poolcl
%poolcl = {
    h => $poolclh,
    t => $poolclt,
    f => $poolclf, #free pointer
    flistl => $fpoolcl, #count of free cache links
    tlistl => $tpoolcl,
    l => [@poolcll],
    p => $poolclp
    };
# syncl
%syncl = {
    h => $synclh,
    t => $synclt,
    f => $synclf, #free pointer
    flistl => $fsyncl, #count of free cache links
    tlistl => $tsyncl,
    l => [@syncll],
    p => $synclp
    };
# synccodl
%synccodl = {
    h => $synccodlh,
    t => $synccodlt,
    f => $synccodlf, #free pointer
    flistl => $fsynccodl, #count of free cache links
    tlistl => $tsynccodl,
    l => [@synccodll],
    p => $synccodlp
    };
# cswsol
%cswsol = {
    h => $cswsolh,
    t => $cswsolt,
    f => $cswsolf, #free pointer
    flistl => $fcswsol, #count of free cache links
    tlistl => $tcswsol,
    l => [@cswsoll],
    p => $cswsolp
    };
# subpscdefl
%subpscdefl = {
    h => $subpscdeflh,
    t => $subpscdeflt,
    f => $subpscdeflf, #free pointer
    flistl => $fsubpscdefl, #count of free cache links
    tlistl => $tsubpscdefl,
    l => [@subpscdefll],
    p => $subpscdeflp
    };
# wfcdefl
%wfcdefl = {
    h => $wfcdeflh,
    t => $wfcdeflt,
    f => $wfcdeflf, #free pointer
    flistl => $fwfcdefl, #count of free cache links
    tlistl => $twfcdefl,
    l => [@wfcdefll],
    hash => {%wfcdeflhash},
    hashb => {%wfcdeflhashb}, #
    operon => {%wfcdefloperon}, #hashes the operon char string to the evaluator name
    p => $wfcdeflp
    };
# wfchchainl
%wfchchainl = {
    h => $wfchchainlh,
    t => $wfchchainlt,
    f => $wfchchainlf, #free pointer
    flistl => $fwfchchainl, #count of free cache links
    tlistl => $twfchchainl,
    l => [@wfchchainll],
    hashname => {%wfchchainlhashname},
    p => $wfchchainlp
    };
# jhlchl
%jhlchl = {
    h => $jhlchlh,
    t => $jhlchlt,
    f => $jhlchlf, #free pointer
    flistl => $fjhlchl, #count of free cache links
    tlistl => $tjhlchl,
    l => [@jhlchll], #hash chain links too jhls id
    chash => {%jhlchlchash},#concept hash head
    chasht => {%jhlchlchasht},#concept hash tail
    pchash => {%jhlchlpchash},#pseudo concept hash head
    pchasht => {%jhlchlpchasht},#pseudo concept hash tail
    jhclmax => {%jhlchljhclmax},#concept list max
    jhclmin => {%jhlchljhclmin},#concept list min
    jhpclmax => {%jhlchljhpclmax},#pseudo concept list max
    jhpclmin => {%jhlchljhpclmin},#pseudo concept list min
    p => $jhlchlp
    };
#<!-- start tag ca -->
# veccol
%veccol = {
    cvindexmap => {%cvindexmap},
    cvparmmap => {%cvparmmap},
    cvparmtype => {%cvparmtype},
    head => [@veccolsh], #head of each awso sub list
    index => {%veccolindex},
    isset => {%veccolisset},
    strategy => {%veccolstrategy},
    ststate => [@veccolststate],
    vcstate => $veccolstate,
    h => $veccolh,
    t => $veccolt,
    f => $veccolf, #free pointer
    flistl => $fveccol, #count of free vector cache links
    tlistl => $tveccol,
    l => [@veccoll],
    p => $veccolp
    };
#<!-- end tag ca -->
# searchl
%searchl = {
    h => $searchlh,
    t => $searchlt,
    f => $searchlf, #free pointer
    flistl => $fsearchl, #count of free cache links
    tlistl => $tsearchl,
    l => [@searchll],
    p => $searchlp
    };
# dipextl
%dipextl = {
    h => $dipextlh,
    t => $dipextlt,
    f => $dipextlf, #free pointer
    flistl => $fdipextl, #count of free cache links
    tlistl => $tdipextl,
    l => [@dipextll],
    p => $dipextlp
    };
# histonel
%histonel = {
    h => $histonelh,
    t => $histonelt,
    f => $histonelf, #free pointer
    flistl => $fhistonel, #count of free cache links
    tlistl => $thistonel,
    l => [@histonell],
    p => $histonelp
    };
%hnamel = {
    h => $hnamelh,
    t => $hnamelt,
    f => $hnamelf, #free pointer
    flistl => $fhnamel, #count of free hname cache links
    tlistl => $thnamel,
    l => [@hnamell], #info about the named wso
# 3 is the verb status -ve is
# 4 is name +ve or ref -ve
# 5 is the wso r adr
# 6 is the wso bi
    p => $hnamelp
    };
%itswsall = {
    h => $itswsallh,
    t => $itswsallt,
    f => $itswsallf, #free pointer
    flistl => $fitswsall, #count of free hname cache links
    tlistl => $titswsall,
    l => [@itswsalll],#info about the named wso
# 2 is the awso ind
# 3 is loadcache state (0 is must be reloaded, 1 each wso must be checked for load status (see 6), 2 is cache is valid
# 4 is $i2 value from the cache if its valid
# 5 is $tinstances from the cache if its valid
# 6 is this wso cache state
# 7 is this wso cache change if 6 is true
# 8 is the norml isation cache change if this wso was in the cache
# 9 is the change returned by the strategy routine.
    p => $itswsallp
    };
#<!-- otart tag inh -->
%inhibl = {
    h => $inhiblh,
    t => $inhiblt,
    f => $inhiblf, #free pointer
    flistl => $finhibl, #count of free inhibitor links
    tlistl => $tinhibl,
    l => [@inhibll], #info about each inhibitor
    clpa => [@inhiblclpa],#clp recorded as an array slice
    p => $inhiblp
    };
#<!-- ond tag inh -->
%trfl = {
    h => $trflh,
    t => $trflt,
    f => $trflf, #free pointer
    flistl => $ftrfl, #count of free trf links
    tlistl => $ttrfl,
    l => [@trfll], #info about each trf
    clpa => [@trflclpa],#clp recorded as an array slice
    p => $trflp
    };
%kwbracketd = { #supports keyword begin end bracket depth assessment
    bmec => $kwbbmec, #count of begin - end
    ibmec => $kwbibmec, #count of include begin - end
    smsc => $kwbsmsc, #count of start - stop
    incb => $kwbincb, #flag
    incs => $kwbincs #flag
    };
# tral
%tral = {
    c => [@tralc],
    h => $tralh,
    t => $tralt,
    f => $tralf, #free pointer
    flistl => $ftral, #count of free cache links
    tlistl => $ttral,
    i => [@trali],
    l => [@trall],
    r => [@tralr],
    sameas => [@tralsameas],
    sameasaadd => [@tralsameasaadd],
    sameash => [@tralsameash],
    sameast => [@tralsameast],
    w => [@tralw],
    wt => [@tralwt],
    p => $tralp
    };
# tmassl
%tmassl = {
    h => $tmasslh,
    t => $tmasslt,
    f => $tmasslf, #free pointer
    flistl => $ftmassl, #count of free cache links
    tlistl => $ttmassl,
    r => [@tmasslr],
    s => [@tmassls],
    l => [@tmassll],
    wsoh => {%tmasslwsoh},
    wsot => {%tmasslwsot},
    first => {%tmasslfirst},
    salience => [@tmasslsalience],
    submitted => [@tmasslsubmitted],
    proc => {%tmasslproc},
    p => $tmasslp
    };
%kwl = {
    h => $kwlh,
    t => $kwlt,
    f => $kwlf, #free pointer
    flistl => $fkwl, #count of free cache links
    tlistl => $tkwl,
    i => [@kwli],
    l => [@kwll],
    w => [@kwlw],
    p => $kwlp
    };
%mkwl = {
    h => $mkwlh,
    t => $mkwlt,
    f => $mkwlf, #free pointer
    flistl => $mfkwl, #count of free cache links
    tlistl => $mtkwl,
    i => [@mkwli],
    l => [@mkwll],
    p => $mkwlp
    };
%aspl = {
    h => $asplh,
    t => $asplt,
    f => $asplf, #free pointer
    flistl => $faspl, #count of free cache links
    tlistl => $taspl,
    i => [@aspli],
    l => [@aspll],
    ws => [@asplws], #this will be the wsbl for this buffer
    nws => [@asplnws],
    p => $asplp
    };
$Awfif::aspl-> {l}[1][2] = \@asplb1;
$Awfif::aspl-> {l}[2][2] = \@asplb2;
$Awfif::aspl-> {l}[3][2] = \@asplb3;
$Awfif::aspl-> {l}[4][2] = \@asplb4;
$Awfif::aspl-> {l}[5][2] = \@asplb5;
$Awfif::aspl-> {l}[6][2] = \@asplb6;
$Awfif::aspl-> {l}[7][2] = \@asplb7;
$Awfif::aspl-> {l}[8][2] = \@asplb8;
$Awfif::aspl-> {l}[9][2] = \@asplb9;
$Awfif::aspl-> {l}[10][2] = \@asplb10;
$Awfif::aspl-> {i}[1] = 0;
$Awfif::aspl-> {i}[2] = 0;
$Awfif::aspl-> {i}[3] = 0;
$Awfif::aspl-> {i}[4] = 0;
$Awfif::aspl-> {i}[5] = 0;
$Awfif::aspl-> {i}[6] = 0;
$Awfif::aspl-> {i}[7] = 0;
$Awfif::aspl-> {i}[8] = 0;
$Awfif::aspl-> {i}[9] = 0;
$Awfif::aspl-> {i}[10] = 0;
# clpaction
%action = {
    schema => $aschema,
    signal => $asignal,
    sponsor => $gsponsor, #be aware using same space as group
    ref => $ni, #ditto
# pssgwsu2
    ssgws => $nidl, #ditto
    ssgoid => $nsnn, #ditto
    jhlabeli => $ajhlabeli,
    sgjhlsi => $asgjhlsi, #subgroup jhlsi if set
    pmman => $apmman,
    tfree => $atfree,
    subpi => $asubpi,
# transidu
    transid => $atransid,
    transmgrid => $atransmgrid,
    usepooling => $ausepooling,
    wss => $awss,
    wsoname => $awsoname,
    wse => $awse,
    wsgs => $awsgs,
    wsge => $awsge,
    sws => $asws
    }; #action
%bond = {
    category => $category,
    ni => $ni,
    nidl => $nidl,
    nsnn => $nsnn,
    pi => $pi,
    pidl => $pidl,
    psnn => $psnn
    }; #bond
%descriptor = {
    ni => $ni,
    property => $property,
    snnode => $propsnnode,
    sponsor => $propsponsor
    }; #descriptor
%group = {
    sponsor => $gsponsor,
    model => $gmodel
    }; #group
%inhib = {
    ilinkp => $inhiblinkp
    }; #group
# kwjhl
%kwjhl = {
    jhip => {%kwjhip},
    jhlabel => {%kwjhlabel},
    jhlp => $kwjhlp,
    jhlg => {%kwjhlg}
    };# kwjhl
%relation = { #exclusive with bond across the clp interface
    category => $category,
    ni => $ni,
    nidl => $nidl,
    nsnn => $nsnn,
    pi => $pi,
    pidl => $pidl,
    psnn => $psnn,
    sponsor => $propsponsor
    }; #relation
# sametl
%sametl = {
    h => $sametlh,
    t => $sametlt,
    f => $sametlf, #free pointer
    flistl => $fsametl, #count of free links
    tlistl => $tsametl,
    l => [@sametll],
    p => $sametlp
    };
# vbotgas
%vbotga = {
    gen => $vbotgagen, #generation to work on
    scmap0 => [@vbotgascmap0],
    scmapc => [@vbotgascmapc],
    scmapn => [@vbotgascmapn],
    scmaph => {%vbotscmaph},
    parent => [@vbotgaparent],
    parent2 => [@vbotgaparent2],
    fitness => [@vbotgafitness]
    };
%ithreflinksh = {
    links => [@ithreflinks]
    };
#
#
# url
%url = {
    links => {%ithreflinksh}, #files referenced in html links
    names => {%ithrefnamesh}, #html names found in visited files
    refs => {%ithrefrefsh}, #names referenced in html links
    visited => [@ithrefvisited] #files that have been visited
    };
#
#
# clp
%clp = {
    action => {%action},
    bond => {%bond},
    delayselect => $clpdelayselect,
    descriptor => {%descriptor},
    group => {%group},
    inhib => {%inhib},
    relation => {%relation},
    urgency => $clpurgency,
    log => $clplog,
    rework => $clprework,
    strategy => $clpstrategy,
    wsi => $clpwsi
    };# clp

%snw = {#slipnet per workspace
    snna => {%snna}, #slipnet node activation level
    snnac => {%snnac}, #activation in critical state
    snnacla => {%snnacla}, #count of codelets that can be activated while critical
    snnaf => {%snnaf}, #activation in fatigue
    snnafm => {%snnafm}, #fatigue max
    snnc => [@snnc], #slipnet node coordinates
    snnd => [@snnd], #slipnet node depths
    msnn => [@snmsnn], #cache of true category by act matches
    snnl => [@snnl], #slipnet node attributes
    };# snw
# mapped
%mapped = {
    scalers => [@scalers],
    };#mapped
#
#
# memes
%memes = {
# Awfpbs
    j => [@j], #pbs i
    j2 => [@j2], #pbs
    cc => [@cc], #pbs c
    usesymb => {%usesymb}, #pbs c
    cquote => $cquote, #pbs C
    invasn => $invasn, #pbs c
    inbvr => $inbvr, #pbs c
    inbvk => $inbvk, #pbs c
    minowidth => $minowidth, #pbs c
    genetic => {%genetic}, #pbs i c
    prepsf => [@prepsf], #pbs c
    prepsfc => [@prepsfc], #pbs
    rlocalityh => {%rlocalityh},#pbs CC
    rlocalityl => [@rlocalityl],#pbs CCC
# rlocalitylh #pbs CC
    rlocalitylc => [@rlocalitylc],#pbs c
    tstring => $tstring, #pbs c
    usedivtags => $usedivtags, #pbs i c
#
#
# Awfcts
    abscoth => $abscoth,
    acaseoutputps => $acaseoutputps,
    acodelets => $acodelets,
    actamp => $actamp, #amplifier for activation
    activationchange=> [@activationchange],
    actth => $actth, #activation threshold
    actramp => $actramp, #power amplification of activation
    actmax => $actmax,
    actdamper => $actdamper,
    acteu => $acteu,
    actfocus => $actfocus, #acceleration spreading
    actweight => $actweight, #acceleration weighting
#
#
# addcltag #pbs
# addcltext #pbs
# addgltext #pbs c
# addgltag #pbs c
# addsumtext #pbs c
#
#
    allowspigrabmax => $allowspigrabmax,
    allwsstr => $allwsstr,
    ampramp => $ampramp,
    applyactive => $applyactive,
    applycmin => $applycmin,
    applycth => $applycth,
    applycount => $applycount,
    applyspigdiv => $applyspigdiv,
    applyramp => $applyramp,
    attribdesf => $attribdesf,
    attribdesh => $attribdesh,
    backoffactive => {%backoffactive},
    backoffactives => {%backoffactives},
    batp => $batp,
#
#
    binds => {%binds}, #pbs c
    bh => {%bh}, #pbs c
    blaunchm => $blaunchm,
# bmap #pbs c
#
#
    bnotsalient => $bnotsalient,
    bsalient => $bsalient,
    buildfbth => $buildfbth,
    breakcodelet => [@breakcodelet],
    breaksubp => [@breaksubp],
    breaksalwso => [@breaksalwso],
#
#
# breaksalwsoc #pbs
#
#
    breakthwso => [@breakthwso],
    breakthsubp => [@breakthsubp],
    breakmyli => $breakmyli,
    bmbcindex => $bmbcindex,
    bondafrom => $bondafrom,
    bondato => $bondato,
    bondatype => $bondatype,
    bondamp => $bondamp,
    bondbar => $bondbar,
    bondrwd => $bondrwd,
# booleans
    budestscu => $budestscu,
    bugsmax => $bugsmax,
# canx $pbs
# cany $pbs
    usedesc => $usedesc,
    icompdlaunchm => $icompdlaunchm,
    igdesc => $igdesc,
    userel => $userel,
    igrel => $igrel,
#
#
# imergeijsb #pbs c
#
#
    bcsubpsindex => $bcsubpsindex,
    ivalwindex => $ivalwindex,
    totup => $totup,
    bumscu => $bumscu,
    buscu => $buscu,
    budescu => $budescu,
    bondthreshold => $bondthreshold,
    descthreshold => $descthreshold,
    destthreshold => $destthreshold,
    tdbsurg => $tdbsurg,
    tddsurg => $tddsurg,
    tdgsurg => $tdgsurg,
    canx => [@canxl],
    canx => [@canyl],
#
#
# capjsb #pbs i c
# captureid #pbs
# capturestljsb #pbs i c
#
#
    casetrmbcwso => $casetrmbcwso,
    casetrmcws => $casetrmcws,
    cseh => {%cseh},
    cseih => {%cseih},
    ch => {%ch},
    chckadd => $chckadd,
    checksubpidnz => $checksubpidnz,
    checktransidnz => $checktransidnz,
    convfrom => $convfrom,
    coordmax => $coordmax,
    coordamp => $coordamp,
#
#
# clfile #pbs
#
#
    clogbplist => $clogbplist,
    clogeplist => $clogeplist,
    clogs => $clogs,
#
#
# cltext #pbs
#
#
    cbprocessing => $cbprocessing,
    comprocessing => $comprocessing,
    cpcountth => $cpcountth,
    crfocuswin => $crfocuswin,
    crsmindex => $crsmindex,
    critical => $critical,
    crsmesubpspbreak => [@crsmesubpspbreak],
    cruna => [@cruna],
    crwait => $crwait,
    csehih => $csehih, #point to the head (mru item) for codelet strategies
    cpmax => $cpmax, #maximum parameter index
    currentwsbi => $currentwsbi,
    dcodeletc => [@dcodeletc],
    delayamp => $delayamp,
    delayselcount => $delayselcount,
    depthamp => $depthamp,
    depthslp => $depthslp,
    depththamp => $depththamp,
    desbar => $desbar,
    desrwd => $desrwd,
    descafrom => $descafrom,
    descato => $descato,
    descatype => $descatype,
    datp => $datp,
    dmratio => $dmratio,
    doprsib => $doprsib,
    drwait => $drwait,
#
#
# dweb #pbs
#
#
    evlaunchhim => $evlaunchhim,
    evlaunchm => $evlaunchm,
    fatigue => $fatigue,
    fatp => $fatp,
    failatpr => $failatpr,
    fcodelets => $fcodelets,
#
#
# fixfhrjsb #pbs i
# fixhrefsgutsb #pbs i
# fixnameid #pbs i c
#
#
    fjhls8 => $fjhls8,
    freeampth => $freeampth,
    gatp => $gatp,
    gdelatchange => {%gdeltachange},
#
#
# gennameljsb #pbs i c
#
#
    geramp => $geramp,
    gerhiamp => $gerhiamp,
#
#
# getresponsejsb #pbs i
# glfile #pbs c
# gltext #pbs CCC
# gotfilters #pbs c
#
#
    grcompaward => $grcompaward,
    groupafrom => $groupafrom,
    groupato => $groupato,
    groupatype => $groupatype,
    groupsponsor => $groupsponsor,
    ha => {%sortingha},
    halomax => $halomax,
#
#
# help #pbs
# hrefcheckb #pbs i
#
#
    iapplycth => $iapplycth,
    iapplyramp => $iapplyramp,
    ieowner => [@ieowner],
#
#
# imergeijsb #pbs i
#
#
    itswsallc => $itswsallc,
    ilaunchm => $ilaunchm,
#
#
# includesbreak #pbs
# invasn #pbs c
#
#
    jhldesf => $jhldesf,
    killth => $killth,
#
#
# klink #pbs c
# kmap #pbs
#
#
    kwmi => $kwmi,
    kwmir => $kwmir,
    kwwsbi => $kwwsbi, #meta file keyword workspace
    kwp => $crkwp,
    kwpr => $crkwpr,
    keywordh => {%keywordh}, #given keyword as hash finds attrib start index
    keywordl => [@keywordl], #keyword attribs
    keywordwsih => {%keywordwsih}, #adds a wsi for the keyword associated by the hash
#
#
# lablist #pbs c
# labpr #pbs c
#
#
    ldav => $ldav,
    ldoav => $ldoav,
    lderr => $lderr,
    ldbuffer => [@ldbuffer],
    ldlcycle => $ldlcycle,
    ldlcyclemax => $ldlcyclemax,
    ldmcycle => $ldmcycle,
    ldmcyclemax => $ldmcyclemax,
    ldsignal => $ldsignal,
    leavein => [@leavein],
    loopcheck => $loopcheck,
    loopth => $loopth,
    inhuramp => $inhuramp,
    iphase => $iphase,
    iphasecomp => $iphasecomp,
#
#
# mainproc #pbs i c
# mapf #pbs CC
#
#
    mincodelets => $mincodelets,
    minnorm => $minnorm,
#
#
# minowidth #pbs i
#
#
    mrework => $mrework,
    mainco => $mainco,
    maininc => $maininc,
    manthreshold => $manthreshold,
    maxact => $maxact,
    maxnormitems => $maxnormitems,
    maxoper => $maxoper,
    maxpconcs => $maxpconcs,
    maxtdgloop => $maxtdgloop,
    maxusefree => $maxusefree,
    mmratio => $mmratio,
    mtsnlc => [@mtsnlc], #holds the trip link branch to check for circular paths
    mtsnlvl => $mtsnlvl, #holds the depth of matchtree descent
    mtsnstate => $mtsnstate, #holds the state of matchtree descent
#
#
# namedvar #pbs i c
# namelist #pbs c
#
#
    nfsmcstate => $nfsmcstate,
    ndecay => $ndecay,
    newdep => $newdep,
    nomcrsmgrab => $nomcrsmgrab,
    npconc => $npconc,
    ntact => $ntact,
    nwsi => $memnwsi,
    openafrom => $openafrom,
    openato => $openato,
    openatype => $openatype,
    pactive => $pactive,
#
#
# pscanijsb #pbs i
# pscanilcb #pbs i
#
#
    pstment => $pstment,
    psubprogram => $psubprogram,
    pappbu => $pappbu,
    parteu => $parteu,
#
#
    pstream => $pstream, #pbs i
#
#
    peaksal => $peaksal,
#
#
# prepsf #pbs c
# prepsfc #pbs
# purge #pbs i CCC
# purgeln #pbs c
#
#
# jhlabel
    jhip => {%jhip},
    jhlabel => {%jhlabel},
    jhlp => $jhlp,
    jhlg => {%jhlg},
    lbbase => $lbbase,
    lebase => $lebase,
    lsbase => $lsbase,
    lsnbase => $lsnbase,
    log => $log,
    logentry => $logentry,
    ratcoth => $ratcoth,
    relafrom => $relafrom,
    relato => $relato,
    relatype => $relatype,
    relamp => $relamp,
    relbar => $relbar,
    relrwd => $relrwd,
#
#
# removesthrefsstringsb #pbs i
# rfbufferb #pbs i c
#
#
    rtemp => $rtemp,
    salthr => $salthr,
#
#
# seqchdfile #pbs C
#
#
    srfsmcstate => $srfsmcstate,
    smlscstate => $smlscstate,
    ssiasslncusetmass => $ssiasslncusetmass,
    stbbpersist => $stbbpersist,
    storestop => $storestop, #instructs the coderack to terminate assuming resume will occur later - don't store this variable
    storetheds => $storetheds, #instructs the coderack to store off the data store - don' store this variable
    structamp => $structamp,
    strbcont => $strbcont,
    strnbcont => $strnbcont,
    strbool => [@strbool],
    streh => {%streh},
    streih => {%streih},
    submitted => $submitted,
    submult => $submult,
    subprefctr => $subprefctr,
    subptrachcount => $subptrachcount,
    sactset => [@sactset],
    shout => $shout, #state of shouting
    slipth => $slipth,
    snnh => {%snnh}, #slipnet node name index
    snnih => {%snnih}, #inverse
    snw => {%snw},
    snehih => $snehih, #point to the head (mru item)
#
#
# sumfile #pbs C
# sumtag #pbs
# sumtext #pbs CC
# tagnamebreak #pbs i
#
#
    temp => [@temp],
    tcodelets => $tcodelets,
    tcodeletmax => $tcodeletmax,
    tdfsampacc => $tdfsampacc,
    tdfsampds => $tdfsampds,
    tdfsampth => $tdfsampth,
    tdgsramp => $tdgsramp,
    time => [@time],
    telomeretrace => $telomeretrace,
    tellifeth => $tellifeth,
    telcountth => $telcountth,
    tgnth => $tgnth,
    trace => $trace,
    traceentry => $traceentry,
    traceadentry => $traceadentry,
    traceclogentry => $traceclogentry,
    tracetemp => $tracetemp,
    traceurg => $traceurg,
    tracefull => $tracefull,
    tracephase => $tracephase,
    tracetree => $tracetree,
    tracetime => $tracetime,
    tracedpcache => $tracedpcache,
    tracehrtime => $tracehrtime,
    tracemcache => $tracemcache,
    tracescache => $tracescache,
    tracevcentry => $tracevcentry,
    tracewscache => $tracewscache,
    tral => $tral,
    trfsmcstate => $trfsmcstate,
    tscacheth => $tscacheth,
    tmcacheth => $tmcacheth,
    twscacheth => $twscacheth,
    uhmax => $uhmax, #maximum contribution of unhappiness
    uhth => $uhth, #treshold of shouting
#
#
# usecatchintuls #pbs i c
# usecatchintulss #pbs
# usesymb #pbs i C
#
#
    usetdfmod => $usetdfmod,
    usewcf1d => $usewcf1d,
    usewsobfdirect => $usewsobfdirect,
    usewsodirect => $usewsodirect,
    verbsrcws => $verbsrcws,
    verbtaws => $verbtaws,
    veccab => $veccab,
    veccah => $veccah,
    waitamp => $waitamp,
    wsm => [@wsm], #cache for ws to sn connects
    wsohih => $wsohih, #point to the head (mru item)
    wsoname => $wsoname,
    wslocality => {%wslocality}, #deliniates the start and end of locality
    codeletdef => $codeletdef,
    codeleth => $codeleth, #points to the head of the list of codelets
    codeletw => $codeletw, #points to the head of the wait queue
    codelett => $codelett, #points to the tail of the list of active codelets
    codeletf => $codeletf #points to head of free list of codelets
#
#

    };
#
#
%slipnet = {
    l => [@snel], #slipnet descriptors as links
    p => $snep #base for adding new array items
    };
%slehist = {
    l => [@snehil],
    p => $snehip
    };
%wsohist = {
    l => [@wsohil],
    p => $wsohip
    };
# jhls
%jhls = {
    l => [@jhldesl], #jhlabel structure descriptors as links
    p => $jhldesp #base for adding new array items
    };
%attribs = {
    l => [@attribdesl],#jhlabel structure descriptors as links
    p => $attribdesp #base for adding new array items
    };
%codelet = {
    l => [@codeletl], #codelet list
    t => [@codelett], #codelet type (active, deferred, waiting, free)
    p => $codeletp #base for adding new array items
    };
%csehist = {
    cseh => {%cseh}, #codelet strategy hash name index
    cseih => {%cseih}, #inverse
    d => [@csehid],
    l => [@csehil],
    p => $csehip
    };
# vfhist
%vfhist = {
    h => $vfh, #vbot fitness list head
    t => $vft, #vbot fitness list tail
    tvf => $tvf, #count of elements in active list
    l => [@vfl],
    mean => [@vfhistmean], #mean for each generation
    p => $vfp
    };
%cache = {
    h => {%cacheh},
    l => [@cachel]
    };# cache
%pcache = {
    l => [@pcachel], #part cache list
    t => [@pcachet], #part cache terminal state
    accessed => [@pcachea], #has this ws pcache been accessed at all
    p => [@pcachep] #base for adding new array items within each ws
    };
%clnk = {
    l => [@clnkl], #
    p => $clnkp, #base for adding new array items
    h => $clnkh,
    t => $clnkt,
    f => $clnkf, #free pointer
    flistl => $clnkflistl,
    fclnk => $fclnk #count of free cache links
    };
#
#
# lexblock
%lexblock = {
    c => $lexblockc, #current value of lexblock
    d => [@lexblockd],element is the current active d
    h => $lexblockh,
    t => $lexblockt,
    f => $lexblockf, #free pointer
    flistl => $flexblock, #count of free lexblockelement links
    tlistl => $tlexblock,
    l => [@lexblockl],
    p => $lexblockp #base for adding new elements
    };
# files
%files = {
    clfile => [@clfilea], #capturelist @file array
    icbfile => [@icbfilea], #include[s]block @file array
    pbscfile => [@pbscfilea] #pbscore @file array
    };
# pages
%pages = {
    active => $pagesactive,
    alertincname => $pagesalertincname,
    comment => $pagescomment,
    completed => $pagescompleted,#controls output of end record of page
    contents => [@pagescontents], #keeps a list of the first line of text of each page of a presentation
    contentsdone => [@pagescontentsdone], #notes when the contents have been fully loaded for a page
    contentspage => $pagescontentspage, #page in presentation where contents are listed
    current => $pagescurrent,#currently reached page in presentation stream
    dupnames => {%pageshdupnames},
    ext => $pagesext,#the file name extension to be appended to the output file name
    fullinames => {%pagesfullinames},#inames record included .pres.names
    fullnames => {%pagesfullhnames},#links names to presentation pages
    hname => {%pageshname}, #hnames within a paged structure are mapped to the page where they are deployed
    hrpage => $pageshrpage, #current page being referenced in href
    inames => {%pagesinames},#inames record included .pres.names
    inhead => $pagesinhead,#indicates that am in a presentation html head
    linecount => $pageslinecount,
    max => $pagesmax, #the max number of pages in the presentation stream
    minlinecount => $pagesminlinecount,
    names => {%pageshnames},#links names to presentation pages
    partref => $pagespartref,#the reference text is partly specified
    path => $pagespath,
    pend => $pagespend, #the page in the presentation where the first end of presentation was encountered
    pnamemap => {%pagespnamemap},
    pnamemapf => {%pagespnamemapf},
    pscomp => $pagespscomp,#prescan completed
    tagname => [@pagestagname],#array of tags for infinite recursion checks
    target => $pagestarget,
    total => $pagestotal,
    wanted => $pageswanted #the page that should be displayed in this iteration of mergeistream
    };
# indline
%indline = {
    access => $indlineaccess,
    incstream => [@indlineincstream],
    inincstream => [@indlineinincstream],
    rest => [@indlinerest]
    };
#
%lbstruct = {
    inat => [@inlbat],
    inb => [@inlbb],
    incf => [@inlbcf],
    incs => [@inlbcs],
    indn => [@inlbdn],
    inet => [@inlbet],
    infs => [@inlbfs],
    inhref => [@inlbhref],
    inht => [@inlbht],
    inhtk => [@inlbhtk],
    inelas => [@inlbelas],
    inelac => [@inlbelac],
    inelae => [@inlbelae],
    ininame => [@inlbiname],
    inis => [@inlbis],
    inl => [@inlbl],
    inlname => [@inlblname],
    inname => [@inlbname],
    inr => [@inlbr],
    insl => $inslbl,
    insp => [@inlbsp],
    inst => [@inlbst],
    inon => $inonlb,
    int => $inlbt,
    ar => [@lbar],
    at => [@lbat],
    b => [@lbb],
    both => $lbboth,
    bsharing => $lbbsharing,
    cfname => [@lbcfname],
    cforicount => $lbcforicount,
    cforie => [@lbcforie],
    cforiname => [@lbcforiname],
    cifdinstance => $lbcifdinstance,
    ciffor => [@lbciffor],
    cificount => $lbcificount,
    cifiname => [@lbcifiname],
    cifrdf => [@lbcifrdf],
    cifrdt => [@lbcifrdt],
    cifrdfq => [@lbcifrdfq],
    cifrdtq => [@lbcifrdtq],
    cifrindex => $lbcifrindex,
    cifarsindex => [@lbcifarsindex],
    cifsync => [@lbcifsync],
    cifsyncb => $lbcifsyncb,
    cifsyncc => [@lbcifsyncc],
    cifsyncf => [@lbcifsyncf],
    cifsynci => [@lbcifsynci],
    cifrsindex => [@lbcifrsindex],
    cifrdsindex => [@lbcifrdsindex],
    cifrinstance => $lbcifrinstance,
    cifnamee => [@lbcifnamee],
    cifnames => [@lbcifnames],
    cifrneeds => {%lbcifrneeds},
    cifselv => [@lbcifselv],
    cifselindex => $lbcifselindex,
    cifused => [@lbcifused],
    cifbasign => [@lbcifbasign],
    cfused => [@lbcfused],
    cnames => [@lbcnames],
    cneeds => $lbcneeds,
    cnamee => [@lbcnamee],
    cname => {%lbcname},
    cnamefsc => {@lbcnamefsc},
    ch => {%lbch},
    csv => [@lbcsv],
    dn => [@lbdn],
    dnt => [@lbdnt],
    et => [@lbet],
    fs => [@lbfs],
    href => [@lbhref],
    hreft => [@lbhreft],
    ht => {%lbht},
    htc => [@lbhtc],
    htk => [@lbhtk],
    htki => {%lbhtki},
    htkig => {%lbhtkig},
    htkio => {%lbhtkio},
    htksc => [@lbhtksc],
    elas => [@lbelas],
    elac => [@lbelac],
    elae => [@lbelae],
    i => $lbi,
    i2 => $lbi2,
    ih => {%lbih},
    is => [@lbis],
    istringf => $lbistringf,
    istrt => {%lbistrt},
    itype => [@lbitype],
    jb => [@lbjb],
    ji => $lbji,
    linec => $lblinec,
    lname => {%lblname},
    lnamee => [@lblnamee],
    lnames => [@lblnames],
    name => [@lbname],
    needs => $lbneeds,
    rec => {%lbrec},
    ri => $lbri,
    sp => [@lbsp],
    st => [@lbst],
    t => [@lbt],
    types => [@lbtypes],
    typesh => {%lbtypesh},
    bname => $olbname
    };
%lb2struct = {
    inat => [@inlb2at],
    inb => [@inlb2b],
    incf => [@inlb2cf],
    incs => [@inlb2cs],
    indn => [@inlb2dn],
    inet => [@inlb2et],
    infs => [@inlb2fs],
    inhref => [@inlb2href],
    inht => [@inlb2ht],
    inhtk => [@inlb2htk],
    inelas => [@inlb2elas],
    inelac => [@inlb2elac],
    inelae => [@inlb2elae],
    ininame => [@inlb2iname],
    inis => [@inlb2is],
    inl => [@inlb2l],
    inlname => [@inlb2lname],
    inname => [@inlb2name],
    inr => [@inlb2r],
    insl => $inslb2l,
    insp => [@inlb2sp],
    inst => [@inlb2st],
    inon => $inonlb2,
    int => $inlb2t,
    ar => [@lb2ar],
    at => [@lb2at],
    b => [@lb2b],
    both => $lb2both,
    bsharing => $lb2bsharing,
    cfname => [@lb2cfname],
    cforicount => $lb2cforicount,
    cforiname => [@lb2cforiname],
    cforie => [@lb2cforie],
    cifdinstance => $lb2cifdinstance,
    ciffor => [@lb2ciffor],
    cificount => $lb2cificount,
    cifiname => [@lb2cifiname],
    cifnamee => [@lb2cifnamee],
    cifnames => [@lb2cifnames],
    cifrdf => [@lb2cifrdf],
    cifrdt => [@lb2cifrdt],
    cifrdfq => [@lb2cifrdfq],
    cifrdtq => [@lb2cifrdtq],
    cifrindex => $lb2cifrindex,
    cifarsindex => [@lb2cifarsindex],
    cifsync => [@lb2cifsync],
    cifsyncb => $lb2cifsyncb,
    cifsyncc => [@lb2cifsyncc],
    cifsyncf => [@lb2cifsyncf],
    cifsynci => [@lb2cifsynci],
    cifrsindex => [@lb2cifrsindex],
    cifrdsindex => [@lb2cifrdsindex],
    cifrinstance => $lb2cifrinstance,
    cifrneeds => {%lb2cifrneeds},
    cifselv => [@lb2cifselv],
    cifselindex => $lb2cifselindex,
    cifused => [@lb2cifused],
    cifbasign => [@lb2cifbasign],
    cfused => [@lb2cfused],
    cnames => [@lb2cnames],
    cneeds => $lb2cneeds,
    cnamee => [@lb2cnamee],
    cname => {%lb2cname},
    cnamefsc => {@lb2cnamefsc},
    ch => {%lb2ch},
    csv => [@lb2csv],
    dn => [@lb2dn],
    dnt => [@lb2dnt],
    et => [@lb2et],
    fs => [@lb2fs],
    href => [@lb2href],
    hreft => [@lb2hreft],
    ht => {%lb2ht},
    htc => [@lb2htc],
    htk => [@lb2htk],
    htki => {%lb2htki},
    htkig => {%lb2htkig},
    htkio => {%lb2htkio},
    htksc => [@lb2htksc],
    elas => [@lb2elas],
    elac => [@lb2elac],
    elae => [@lb2elae],
    i => $lb2i,
    i2 => $lb2i2,
    ih => {%lb2ih},
    is => [@lb2is],
    istringf => $lb2istringf,
    istrt => {%lb2istrt},
    itype => [@lb2itype],
    jb => [@lb2jb],
    ji => $lb2ji,
    linec => $lb2linec,
    lname => {%lb2lname},
    lnamee => [@lb2lnamee],
    lnames => [@lb2lnames],
    name => [@lb2name],
    needs => $lb2needs,
    rec => {%lb2rec},
    ri => $lb2ri,
    sp => [@lb2sp],
    st => [@lb2st],
    t => [@lb2t],
    types => [@lb2types],
    typesh => {%lb2typesh},
    bname => $olb2name
    };
%cstruct = {
    inat => [@incat],
    inb => [@incb],
    incf => [@inccf],
    incs => [@inccs],
    indn => [@incdn],
    inet => [@incet],
    infs => [@incfs],
    inhref => [@inchref],
    inht => [@incht],
    inhtk => [@inchtk],
    inelas => [@incelas],
    inelac => [@incelac],
    inelae => [@incelae],
    ininame => [@inciname],
    inis => [@incis],
    inl => [@incl],
    inlname => [@inclname],
    inname => [@incname],
    inr => [@incr],
    insl => $inscl,
    insp => [@incsp],
    inst => [@incst],
    inon => $inonc,
    int => $inct,
    ar => [@car],
    at => [@cat],
    b => [@cb],
    both => $cboth,
    bsharing => $cbsharing,
    cfname => [@ccfname],
    cforicount => $ccforicount,
    cforiname => [@ccforiname],
    cforie => [@ccforie],
    cifdinstance => $ccifdinstance,
    ciffor => [@cciffor],
    cificount => $ccificount,
    cifiname => [@ccifiname],
    cifrdf => [@ccifrdf],
    cifrdt => [@ccifrdt],
    cifrdfq => [@ccifrdfq],
    cifrdtq => [@ccifrdtq],
    cifrindex => $ccifrindex,
    cifarsindex => [@ccifarsindex],
    cifsync => [@ccifsync],
    cifsyncb => $ccifsyncb,
    cifsyncc => [@ccifsyncc],
    cifsyncf => [@ccifsyncf],
    cifsynci => [@ccifsynci],
    cifrsindex => [@ccifrsindex], #subindex for if selector store enables multiple alternatives
    cifrdsindex => [@ccifrdsindex], #subindex for if data store enables multiple alternatives
    cifrinstance => $ccifrinstance,
    cifnamee => [@ccifnamee],
    cifnames => [@ccifnames],
    cifrneeds => {%ccifrneeds},
    cifselv => [@ccifselv],
    cifselindex => $ccifselindex,
    cifused => [@ccifused],
    cifbasign => [@cccifbasign],
    cfused => [@ccfused],
    cnames => [@ccnames],
    cneeds => $ccneeds,
    cnamee => [@ccnamee],
    cname => {%ccname},
    cnamefsc => {@ccnamefsc},
    ch => {%cch},
    csv => [@ccsv],
    dn => [@cdn],
    dnt => [@cdnt],
    et => [@cet],
    fs => [@cfs],
    href => [@chref],
    hreft => [@chreft],
    ht => {%cht},
    htc => [@chtc],
    htk => [@chtk],
    htki => {%chtki},
    htkig => {%chtkig},
    htkio => {%chtkio},
    htksc => [@chtksc],
    elas => [@celas],
    elac => [@celac],
    elae => [@celae],
    i => $ci,
    i2 => $ci2,
    ih => {%cih},
    is => [@cis],
    istringf => $cistringf,
    istrt => {%cistrt},
    itype => [@citype],
    jb => [@cjb],
    ji => $cji,
    linec => $clinec,
    lname => {%clname},
    lnamee => [@clnamee],
    lnames => [@clnames],
    name => [@cname],
    needs => $cneeds,
    rec => {%crec},
    ri => $cri,
    sp => [@csp],
    st => [@cst],
    t => [@ct],
    types => [@ctypes],
    typesh => {%ctypesh},
    bname => $ocname
    };

%logostruct = {
    inat => [@inloat],
    inb => [@inlob],
    incf => [@inlogocf],
    incs => [@inlocs],
    indn => [@inlodn],
    inet => [@inloet],
    infs => [@inlofs],
    inhref => [@inlohref],
    inht => [@inlogoht],
    inhtk => [@inlogohtk],
    inelas => [@inlogoelas],
    inelac => [@inlogoelac],
    inelae => [@inlogoelae],
    ininame => [@inloiname],
    inis => [@inlois],
    inl => [@inlogol],
    inlname => [@inlolname],
    inname => [@inloname],
    inr => [@inlogor],
    insp => [@inlosp],
    inst => [@inlost],
    inon => $inonlogo,
    at => [@logoat],
    b => [@logob],
    both => $logoboth,
    bsharing => $logobsharing,
    cfname => [@logocfname],
    cforicount => $logocforicount,
    cforiname => [@logocforiname],
    cforie => [@logocforie],
    cifdinstance => $logocifdinstance,
    ciffor => [@logociffor],
    cificount => $logocificount,
    cifiname => [@logocifiname],
    cifrdf => [@logocifrdf],
    cifrdt => [@logocifrdt],
    cifrdfq => [@logocifrdfq],
    cifrdtq => [@logocifrdtq],
    cifrindex => $logocifrindex,
    cifarsindex => [@logocifarsindex],
    cifsync => [@logocifsync],
    cifsyncb => $logocifsyncb,
    cifsyncc => [@logocifsyncc],
    cifsyncf => [@logocifsyncf],
    cifsynci => [@logocifsynci],
    cifrsindex => [@logocifrsindex],
    cifrdsindex => [@logocifrdsindex],
    cifrinstance => $logocifrinstance,
    cifnamee => [@logocifnamee],
    cifnames => [@logocifnames],
    cifrneeds => {%logocifrneeds},
    cifselv => [@logocifselv],
    cifselindex => $logocifselindex,
    cifused => [@logocifused],
    cifbasign => [@logocifbasign],
    cfused => [@logocfused],
    cnames => [@logocnames],
    cneeds => $logocneeds,
    cnamee => [@logocnamee],
    cname => {%logocname},
    cnamefsc => {@logocnamefsc},
    ch => {%logoch},
    csv => [@logocsv],
    dn => [@logodn],
    dnt => [@logodnt],
    et => [@logoet],
    fs => [@logofs],
    href => [@logohref],
    hreft => [@logohreft],
    ht => {%logoht},
    htc => [@logohtc],
    htk => [@logohtk],
    htki => {%logohtki},
    htkig => {%logohtkig},
    htkio => {%logohtkio},
    htksc => [@logohtksc],
    elas => [@logoelas],
    elac => [@logoelac],
    elae => [@logoelae],
    i => $logoi,
    ih => {%logoih},
    is => [@logois],
    istringf => $logoistringf,
    istrt => {%logoistrt},
    itype => [@logoitype],
    jb => [@logojb],
    ji => $logoji,
    linec => $logolinec,
    lname => {%logolname},
    lnamee => [@logolnamee],
    lnames => [@logolnames],
    name => [@logoname],
    needs => $logoneeds,
    rec => {%logorec},
    ri => $logori,
    sp => [@logosp],
    st => [@logost],
    t => [@logot],
    types => [@logotypes],
    typesh => {%logotypesh}
    };
%symbolsets = {
    meta => {%metasymbset},
    imeta => {%imetasymbset},
    lb2 => {%lbsymbset},
    logo => {%logosymbset},
    case => {%csymbset}
    };
# all file-scoped lexicals must be created before the functions below that use them.
Market Centric Workshops
The Physics - Politics, Economics & Evolutionary Psychology
Politics, Economics & Evolutionary Psychology

Business Physics
Nature and nurture drive the business eco-system
Human nature
Emerging structure and dynamic forces of adaptation


integrating quality appropriate for each market
 
This page looks at schematic structures and their uses.  It discusses a number of examples:
  • Schematic ideas are recombined in creativity. 
  • Similarly designers take ideas and rules about materials and components and combine them. 
  • Schematic Recipes help to standardize operations. 
  • Modular components are combined into strategies for use in business plans and business models. 

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

Finally it includes a section presenting our formal representation of schematic goals. 
Each goal has a series of associated complex adaptive system (CAS) strategy strings. 
These goals plus strings are detailed for various chess and business examples. 
Strategy
| Design |
This page uses an example to illustrate how:
  • A business can gain focus from targeting key customers,
  • Business planning activities performed by the whole organization can build awareness, empowerment and coherence. 
  • A program approach can ensure strategic alignment. 
Program Management
| Home

Profiles | Papers | Glossary | E-mail us