Saunders Mac Lane - Mathematics Form and Function

xholonWorkbook.xml

<?xml version="1.0" encoding="UTF-8"?>
<!--Xholon Workbook http://www.primordion.com/Xholon/gwt/ MIT License, Copyright (C) Ken Webb, Fri Dec 13 2019 16:32:10 GMT-0500 (Eastern Standard Time)-->
<XholonWorkbook>

<Notes><![CDATA[
Xholon
------
Title: Saunders Mac Lane - Mathematics Form and Function
Description: 
Url: http://www.primordion.com/Xholon/gwt/
InternalName: fddceec2929ecb57236d86a9ceb7211b
Keywords: 

My Notes
--------
December 4, 2019

Saunders Mac Lane, co-inventor of Category Theory, also wrote a philosophy of mathematics book called Mathematics, Form and Function.
He writes very well, and obviously knows his Math very well.
This book offers a lot of ideas and intuitions that I can use.

See also:
- xholon/lib/xhmath/modules/parser.js
- xholon/lib/xhmath/README_XholonMathNotation.txt
- my notebook

To get access to xhmath JavaScript library:
http://127.0.0.1:8888/XholonXhmath.html?app=Saunders+Mac+Lane+-+Mathematics+Form+and+Function&src=lstr&gui=clsc

**Introduction**

**page 2**
relation of the formal to the factual

**Chapter 1 - Origins of Formal Structure**

**page 6**
Mathematics, at the beginning, is sometimes described as the science of Number and Space - better, of Number, Time, Space, and Motion.
The need for such a science arises with the most primitive human activities.
These activities presently involve counting, timing, measuring, and moving, using numbers, intervals, distances, and shapes.
the natural numbers arise from counting, with notation which provides to every number the next one - its successor
the development of the formal from the factual
we start again from number, time, space, and motion, and build up directly some of the general concepts of modern Mathematics.
Thus counting leads to cardinal and ordinal numbers and to infinite sets and transformations.
The analysis of time leads to the notion of an ordered set and a complete ordered set; these concepts fit also with geometrical measurement.
The study of motion (in space) and of the composition of two motions suggests the motion of a transformation group.

**page 7**
Comparison of this notion of composition with the arithmetic operations of addition and multiplication leads by further abstraction to the concept of a group.
On the other hand, motion involves continuity, and the formal analysis of continuity
gives rise to a simple axiomatic description of space as a metric space or, more intrinsically, as a topological space.
Thus this chapter introduces the idea of the formal in terms of certain basic structures:
 Set, transformation, group, order, and topology.

**1. The Natural Numbers**
From these activities, several Mathematical concepts arise together
  set number label list
KSW in this workbook I will implement an app based on a careful reading of this section of the book, paying particular attention to the above 4 concepts that "arise together"
Sets (informal)
 - At this point the word "set" simply means a co9llection of things
 - At this stage, the word "collection" is appropriate, because all that matters about a set (or collection) is that it is determined by specifying its elements
In these terms, one can give semi-formal descriptions of the (at first) highly informal operations of listing, labeling, counting and comparing.
To "list" a collection such as {A,B,C} means to attach in regular order a numeral to each object in the collection
 - one usually begins with the numeral 1 and proceeds in order, say, as {A₁,B₂,C₃}.
 - KSW could use JS Array, a linked list or graph, a subscript (as done in the book)
 - numerals will be adequate for this process in all cases only if there is always a next numeral
  - the idea that every natural number n has an immediate successor s(n) = n + 1
To "label" means to attach the same numerals to the objects of the collection, but irrespective of their order, as in {A₂,B₃,C₁}
To "count" a collection means to determine how many numerals (or which numerals) are needed to label all the objects in the collection.
 - the numerals needed do not depend on the order in which the objects of the collections are counted
Comparing two collections, such as {A,B,C} and {U,V,W} means matching each object of the first collection with some object of the second, until both are exhausted
In this context, one says that the collection {A,B,C} has the cardinal number 3, in symbols
 #{A,B,C} = 3
this means that there is a one-to-one correspondence f
 f:1 |-> A, 2 |-> B, 3 |-> C
KSW in a Xholon app, the typical first thing to is to collect things from wherever:
 - ex: collect objects or concepts from a news or science articles

**2. Infinite Sets**

**3. Permutations**
A finite set, counted in any order, leads to the same (finite) cardinal number. The count is not changed by "permuting" the things counted.
But one may also count how many permutations there are.

**4. Time and Order**
The passage of time suggests the ideas "before" and "after"
(1) transitive law
binary relation <
(2) law of trichotomy
time is contnuous and obeys the two laws
so also do the natural numbers which are a discrete set
There are numerous other examples of these two formal laws.

**5. Space and Motion**
Space can be regarded as something extended or as a receptable for objects or as a background for ideal "figures".
These aspects are all closely tied to the motion through space, while motion provides the notion of measuring distance through space.
Space and motion crop up together everywhere, from physics to physical exercise.
KSW by "space" I think he means 2D and 3D space laid out in a grid with x,y,z coordinants
KSW Xholon offers various spaces and ways of moving through these spaces, especially grids
 - I could draw a 2D map of the Mud Lake area using a Xholon grid, and show the locations and collectables on it
 - superimpose the location graph (the ports between locations and segments
 - show the Avatar in real time moving through the grid
 - use d3cp (circles within circles) to show the Avatar's current local view
 - this is what I've done in the Island Game, with its global grid-based view and its local d3cp view
KSW I can also show the 2D space using Leaflet, as a map, where each location has a specific latitude and longitude
 - see my BGCO examples
KSW then he talks about figures (ex: triangle), rigid motions, translation, rotation, reflection, composite motions
 - for now, I don't need these concepts

**6. Symmetry**

**7. Transformation Groups**

**8. Groups**
general notion of an algebraic structure:
 A set X with nullary, unary, binary, ternary ... operations satisfying as axioms a variety of identities between composite operations.
"many-sorted" universal algebra
 - KSW see https://en.wikipedia.org/wiki/Many-sorted_logic

**9. Boolean Algebra**
Another example of an algebra is provided by the operations such as the intersection and the union of subsets S and T of a given set X.
"if and only if"
"and" "or" "if then"
Venn diagrams
KSW do Venn diagrams correspond with the Xholon bplex concept?
 - set X = {a,b,c,d,e,f,g,h,i,j,k,l}
 - bplex/set S = {a,b,c,d,e}
 - bplex/set T = {a,c,e,g,i,k}
complement (not)
These various operations ∩, ∪, ⇒, ¬ satisfy certain algebraic identities which can all be deduced from a suitable list of axioms, the axioms for Boolean Algebra.
Boolean algebra provides a Mathematical way of representing properties, in that each property H of elements of a set X determines a subset of X;
 namely, the subset S consisting of all those elements which have the property
This subset is sometimes called the extension of the property H
"extensionality" axiom for sets
 a set is completely determined just by specifying its elements
inclusion relation
ordered set
partially ordered, poset
many orders are just partial orders and not toal orders (not linear)
lattice
both these Boolean operations [union and intersection] can be described directly in terms of inclusion, without any use of membership
join
meet
KSW I can use much of the material in section 9 in my Mud Lake app

**10. Calculus, Continuity, and Topology**
sets-with-structure

**11. Human Activity and Ideas**

**Table 1.1**
Activity   Idea                 Formulation
--------   ----                 -----------
Collecting Collection           Set (of elements)
Counting   Next                 Successor; order, Ordinal number
Comparing  Enumeration          Bijection, Cardinal number
Computing  Combination (of nos) Rules for addition, Rules for multiplication, Abelian group
...
see also ref 2

**12. Mathematical Activities**

**13. Axiomatic Structure**

**Chapter 2 - From Whole Numbers to Rational Numbers**

**1. Properties of Natural Numbers**

**Chapter 3 - **

**Chapter 4 - **

**Chapter 5 - Functions, Transformations, and Groups**

**3. What is a Function?**

**4. Functions as Sets of Pairs**

**page 129**
Definition.
A function f on the set X to the set Y is a set S ⊂ X × Y of
ordered pairs which to each x ∈ X contains exactly one ordered pair
<x,y> with first component x. The second component of this pair is the
value of the function f at the argument x, written f(x). We call X the
domain and Y the codomain of the function f.


KSW 1
-----
Activity - find 10 small interesting things in the woods and return with a picture (photo, drawing, etc.) of each, as well as a picture of yourself (the Avatar)
- the pictures will be in a specific order within your camera or phone
 - this corresponds to the fact that the ten things are collected in time, one after the other and not all at the same time
- or return with the actual things in your backpack; this is a collection, definitely unordered,
  unless you label them with a number or put them into a collection box with 10 sections, or into an egg carton, or take a video during collection, or ...
- typical things to collect include:
  - small rocks that differ from each other in color, size, texture, etc.
  - leaves, needles, nuts, berries, bark, and other plant parts
  - a bit of mud, some snow or ice, some water
- follow a path through the woods (ex: Mud Lake)
 - the Mud Lake path is divided into segments labeled using pairs of marked places: (A,B) (B,C) etc.
 - include a map, and photos of the signs that mark the places
- it's obvious that the whole activity involves many aspects, none of which are necessarily fundamental
 - because of the nature of time, I must collect the things in a given order (I could generate a list of items, ordered by the time of collection of each item)
  - if I collect actual physical things and drop them into my backpack, then an ordered collection process becomes a set
  - so I can't really say which is more fundamental: set or list (or number or label)
  - in a real-world activity, these all "arise together"
- if I come home with 10 items in my backpack, and dump them on the floor in front of Andrea, then she will be presented with a true unordered collection/set
- collecting the 10 items is only the starting point
 - there are numerous ways to organize them, for example into subsets and classes (ex: stones,nuts,berries OR living,unliving OR red,green,blue)
- I might want to label each collected item, for example:
 - smoothpinkrock, jaggedgreyrock, pineneedle, greenleaf, brownleaf, blueberry, blackberry, acorn, pinecone, birchbark
 - OR A,B,C,D,E,F,G,H,I,J
 - OR x0,x1,x2,x3,x4,x5,x6,x7,x8,x9
 - OR goofy,mickey,daisy,minnie,pluto,dumbo,bozo,huey,dewey,louie
 - OR 1,2,3,4,5,6,7,8,9,10  OR 0,1,2,3,4,5,6,7,8,9

Math Videos and Lectures
------------------------
- compare drawing examples on the blackboard, with formal math, and with the KSW 1 activity
 - drawing on the blackboard also involves all of these things "together"
 - if you draw ("conjure up" KSW) a set of points or shapes on the blackboard, each is drawn at a time relatively before or after each other point or shape
  - if I record exactly when each point is drawn (such as by stepping through the video), then for each pair of points x and y, I can definitively say whether (x < y) or (y < x)
   - Math order, preorder, total order, poset

My thoughts and conclusions
-----------
- I can use Mac Lane's book and my examples to answer some of my basic Math questions
- don't worry about what is a set and what is a list and how they differ from each other
- Mac Lane: "the development of the formal from the factual" "relation of the formal to the factual"
- Math always involves an element of time
- the Mud Lake treasure/scavenger hunt is more of a collage than a process
 - the "facts" can present themselves in different ways and orderings
 - it's open-ended, but Math still pops up in various ways
- Mac Lane makes these Math ideas more usable, by presenting them in an informal but meaningful way
 - I can use his descriptions to help me decise how to use the Math ideas
- this makes it easier to use Math less formally, and to realize that the order of construction is not too important
- I'm basically just trying to work with the ideas, using them as tools/insights
- Mac Lane chapter 1 contains things that I might do; guidelines, heuristics, a checklist
 - it provides a rigorous checklist of things to think about
 - as the app designer and implementer, I can decide which ideas to use
 - to keep it rigorous, I should explain why I use or don't use some concept
  - for example: why do I use or not use labels and numbers as Mac Lane describes them
  - my labels are strings such as "A" or "smoothpinkrock"
  - I use numbers as node IDs, but these function more as labels; they are not a simple sequence of the natural numbers starting with 0
 - Mac Lane gives me a set of informal design heuristics, which are good concepts because they are backed by rigorous formal Math concepts
  - the heuristics tell me that I should consider using various aspects of set, number, label, list
   - human activities: listing, labeling, counting and comparing
  - I could use these instead of starting with more typical Object Oriented concepts such as classes (although I do use classes)
  - these provide questions for me to ask about my app
   - does it matter whether items in a collection are ordered or not?
   - do I need to count the items?
   - how should I label them, and why do I need to label them (as a formal exercise, or to give them meaning for a human observer)?
 - the Math helps to keep fundamental concepts separate from each other
 - note that links are ordered as a list (not a set); each link has a number >= 0, that corresponds to a numeric key on the keyboard

Graphviz
--------
/*
Automatically generated by Xholon version 0.9.1, using org.primordion.ef.Xholon2Graphviz.java
Wed Dec 04 17:38:22 GMT-500 2019 1575499102224
model: Saunders Mac Lane - Mathematics Form and Function
www.primordion.com/Xholon

To view this file, use Graphviz dot|fdp|neato|twopi|circo|sfdp from http://www.graphviz.org/
For example, to generate an SVG file:
  dot -Tsvg -O Habitat_47_1575499102224.gv
Alternatively try one of these:
  dot -Tsvg -O Habitat_47_1575499102224.gv
  dot -Tsvg -O -Grankdir=LR Habitat_47_1575499102224.gv
  fdp -Tsvg -O Habitat_47_1575499102224.gv
  neato -Tsvg -O Habitat_47_1575499102224.gv
  circo -Tsvg -O Habitat_47_1575499102224.gv
Or use one of: -Tgif -Tjpg -Tpdf -Tpng -Txdot -Txlib
See also: http://www.webgraphviz.com/
See also: http://rise4fun.com/agl/

To repeat this Xholon export:
 $wnd.xh.xport("Graphviz", $wnd.xh.root().parent().xpath("Chameleon/PhysicalSystem/City/Habitat"), '{"gvFileExt":".gv","gvGraph":"digraph","layout":"dot","edgeOp":"->","gvCluster":"","shouldShowStateMachineEntities":false,"filter":"--Behavior,Script","nameTemplateNodeId":"^^^^i^","nameTemplateNodeLabel":"R^^^^^","shouldQuoteLabels":true,"shouldShowLinks":true,"shouldShowLinkLabels":true,"shouldSpecifyLayout":false,"maxLabelLen":-1,"shouldColor":true,"defaultNodeColor":"#5f5f8e","bgGraphColor":"white","shouldSpecifyShape":true,"shape":"ellipse","shouldSpecifySize":true,"size":"20","shouldSpecifyFontname":true,"fontname":"\"Courier New\"","shouldSpecifyArrowhead":true,"arrowhead":"vee","shouldSpecifyStylesheet":true,"stylesheet":"Xholon.css","shouldSpecifyRankdir":true,"rankdir":"LR","shouldDisplayGraph":true,"outputFormat":"svg"}');
*/
digraph 47 {
 graph [label="Mud Lake",id="Habitat",stylesheet="Xholon.css",rankdir=LR,size=20,fontname="Courier New",bgcolor=white]
 node [style=filled,fillcolor="#5f5f8e",shape=ellipse,fontname="Courier New"]
 edge [arrowhead=vee]
 48 [label="A" id="Habitat/MarkedLocation[@roleName='A']"]
  48 -> 52 [label="trail"];
  48 -> 72 [label="trail"];
  48 -> 77 [label="trail"];
 52 [label="B" id="Habitat/MarkedLocation[@roleName='B']"]
  52 -> 48 [label="trail"];
  52 -> 56 [label="trail"];
  52 -> 80 [label="trail"];
 56 [label="C" id="Habitat/MarkedLocation[@roleName='C']"]
  56 -> 52 [label="trail"];
  56 -> 60 [label="trail"];
  56 -> 82 [label="trail"];
 60 [label="D" id="Habitat/MarkedLocation[@roleName='D']"]
  60 -> 56 [label="trail"];
  60 -> 64 [label="trail"];
  60 -> 74 [label="trail"];
 64 [label="E" id="Habitat/MarkedLocation[@roleName='E']"]
  64 -> 60 [label="trail"];
  64 -> 74 [label="trail"];
  64 -> 68 [label="untrail"];
 68 [label="F" id="Habitat/UnmarkedLocation"]
  68 -> 64 [label="untrail"];
  68 -> 77 [label="untrail"];
  68 -> 84 [label="untrail"];
 72 [label="G" id="Habitat/Lookout[@roleName='G']"]
  72 -> 48 [label="trail"];
 74 [label="H" id="Habitat/Lookout[@roleName='H']"]
  74 -> 60 [label="trail"];
  74 -> 64 [label="trail"];
 77 [label="I" id="Habitat/Building"]
  77 -> 48 [label="trail"];
  77 -> 68 [label="untrail"];
 80 [label="J" id="Habitat/Entrance[@roleName='J']"]
  80 -> 52 [label="trail"];
 82 [label="K" id="Habitat/Entrance[@roleName='K']"]
  82 -> 56 [label="trail"];
 84 [label="L" id="Habitat/Entrance[@roleName='L']"]
  84 -> 68 [label="untrail"];
}

December 5
----------
- the Avatar can now collect items from the trails around Mud Lake, bring them home in a backpack, and dump the items on the floor as an unordered collection (set)
- TODO do things with this collection
 - count the number of items in the collection; the count is the same no matter the order of the collection
  - if I shuffle the collection each time step, and then count the number of items, the resulting cardinal number will always be the same
 - generate the set of permutations, and count how many there are
 - organize the set into various lists, ordered by different attributes (ex: alphabetical order, Xholon ID, size or weight of the item (ex: feather <= rock))
 - create subsets (ex: a subset containing all items with "rock" as part of their label (Xholon roleName)
  - it would be arbitrary to create two subsets called "heavy" and "light"
   - rocks would go in the heavy subset, and feathers in the light subset
   - the union of heavy and light would be the entire original set
 - to create lists or subsets, use JavaScript arrays, or use Xholon bplexes (linked lists or cycles)
 - I could organize the species/genus/etc of plant specimens (and any animals?) using the approach in Fong and Spivak "tree of life"); a preorder/poset and a monotone map
 - the Avatar could bring along a list of things to find, making this a scavenger hunt
  - it could look for things in order, or whenever it happens to find something
  - if the list is in the form of a list of set of Xholon nodes, then it could simply do a mapping from its list to the actual items (like taking a photo of each)
   - ex list: {rock, fern, feather} -> these three items at Mud Lake
    - set of String -> set of IXholon nodes
 - there are all sorts of informal things I can do
  - and then tie the facts back to the formal Math, Category Theory concepts

December 6
----------
- TODO put "standard" formal or semi-formal Math notation wherever it makes sense
 - this is another way that the conventions of Math can be helpful
 - Math sets vs types, Xholon CSH vs IH
 - make it clear how I can parse these objects and structures to become part of the Xholon app
 - keep in mind that Math notation is just a bunch of conventions for expressing Math concepts
- in Xholon, by default, an app developer uses XML to specify structure
 - I can include the Math notation as text, as comments, or as processing instructions
  - unless the text is inside an <Attribute_String/> or other XML node that processes its text, then the text is ignored
  - anything within an XML comment is ignored, for example: <!-- I am ignored -->
  - text within an XML processing instruction (PI) could be parsed, if code is available to do that  ex: <?PITarget PIContent?>
  - XSLT  ex: <?xml-stylesheet type="text/xsl" href="style.xsl"?>
- there are at least two things I want to demonstrate by pairing Math notation with Xholon XML
 - 1. in some cases, it's more practical (less effort) to use Math notation coupled with a parser
  - XML can be quite verbose
 - 2. I want to show how well aligned Xholon is with concepts from Math, as evidenced by the ease of transforming/mapping between the two formats
- Xholon is
 - various structures
  - equipped with a set of behaviors
 - one goal of Xholon is to use more and more Structure, while using less and less Behavior

December 7
----------
Counting the Collection of items
- one way to count collected items once the Avatar returns home, is to associate each item with a next number node
 - an item could be placed inside each number node, or
 - each item could point to (have an arrow to, be paired with) a different number node
  items = {a,b,c,d,e,f,g,h}
  numbers = {1,2,3,4,5,6,7,8,9,10.11.12.13,...}
  mapping = {(a,1), (b,2), (c,3), ..., (h,8)}
  Therefore there are 8 items
  The mapping could be implemented in several different ways
  It doesn't matter what order the items are in; the count will always be the same

December 11
-----------

Standard Names
--------------
- create a list of standard names to use in pSiblings01; currently I have the following sets:
 - nodes roles roleMapping typeMapping ports portMapping
 - ex: nodes = {Un,Two,Drei}
 - I could have any number of standard names
- maybe create a special Xholon workbook with named sections, where a user could write items from top to bottom (newline-separated) or left to right (comma-separated)

Math Tools
----------
- collections, sets
- pointed sets
- sets equipped with extra structure
- orders, lists
- products
- subsets of products, maps, pairs
- functions
- graphs

Process
-------
- always starts with collecting things

December 12
-----------
see ref 9, page 1

N nodes
R roles
T types
P ports
N×N 

N -roleMapping-> R
 \
|  \
|    v
|    N×N
v       \
           \
              v
T                P


References
----------
(1) Mac Lane, Saunders, 1986, Mathematics Form and Function
    book

(2) https://en.wikipedia.org/wiki/Mathematics,_Form_and_Function
    Mathematics, Form and Function is a survey of the whole of mathematics,
    including its origins and deep structure,
    by the American mathematician Saunders Mac Lane.
    
    Mathematics and human activities
    Throughout his book, and especially in chapter I.11, Mac Lane informally discusses how mathematics is grounded in more ordinary concrete and abstract human activities.
    The following table is adapted from one given on p. 35 of Mac Lane (1986). The rows are very roughly ordered from most to least fundamental.
    For a bullet list that can be compared and contrasted with this table, see section 3 of Where Mathematics Comes From.

(3) Lakoff and Nunez book
    Where Mathematics Comes From

(4) https://en.wikipedia.org/wiki/Where_Mathematics_Comes_From
    Where Mathematics Comes From: How the Embodied Mind Brings Mathematics into Being (hereinafter WMCF) is a book by George Lakoff, a cognitive linguist, and Rafael E. Núñez, a psychologist.
    Published in 2000, WMCF seeks to found a cognitive science of mathematics, a theory of embodied mathematics based on conceptual metaphor. 

(5) https://en.wikipedia.org/wiki/Philosophy_of_mathematics
    The philosophy of mathematics is the branch of philosophy that studies the assumptions, foundations, and implications of mathematics.
    It aims to understand the nature and methods of mathematics, and finding out the place of mathematics in people's lives.
    The logical and structural nature of mathematics itself makes this study both broad and unique among its philosophical counterparts. 

(6) https://en.wikipedia.org/wiki/Mathematical_universe_hypothesis
    Max Tegmark
    In physics and cosmology, the mathematical universe hypothesis (MUH), also known as the ultimate ensemble theory, is a speculative "theory of everything" (TOE) proposed by cosmologist Max Tegmark.
    Tegmark's MUH is: Our external physical reality is a mathematical structure.
    That is, the physical universe is not merely described by mathematics, but is mathematics (specifically, a mathematical structure).
    Mathematical existence equals physical existence, and all structures that exist mathematically exist physically as well.
    Observers, including humans, are "self-aware substructures (SASs)".
    In any mathematical structure complex enough to contain such substructures, they "will subjectively perceive themselves as existing in a physically 'real' world".

(7) http://ncc-ccn.gc.ca/places/mud-lake
    Mud Lake is one of the most ecologically important natural habitats in the urban part of Canada’s Capital Region.

(8) https://www.tripadvisor.ca/Attraction_Review-g155004-d15073290-Reviews-Mud_Lake-Ottawa_Ontario.html
    has 10+ photos - places, birds, bugs, etc.

(9) Mac Lane, Saunders, 1998, Categories for the Working Mathematician, Second Edition
    book

(10) https://en.wikipedia.org/wiki/Categories_for_the_Working_Mathematician
    Categories for the Working Mathematician (CWM) is a textbook in category theory written by American mathematician Saunders Mac Lane, who cofounded the subject together with Samuel Eilenberg.
    It was first published in 1971, and is based on his lectures on the subject given at the University of Chicago, the Australian National University, Bowdoin College, and Tulane University.
    It is widely regarded as the premier introduction to the subject.

]]></Notes> 

<_-.XholonClass>
  <PhysicalSystem/>
  
  <City/>
  <Habitat/>
  <House/>
  
  <!--
# a pointed/rooted set of types; the first element in the set, Location, is, by my convention (by my calling it so), the superClass
locations = {Location, MarkedLocation, UnmarkedLocation, Lookout, Building, Entrance}
# OR
<Location xhmath="pSet01">{MarkedLocation, UnmarkedLocation, Lookout, Building, Entrance}</Location>
# OR
locations = ({Location, MarkedLocation, UnmarkedLocation, Lookout, Building, Entrance}, Location)
# OR
<xhmath xhmath="pSetPointed01">({Location, MarkedLocation, UnmarkedLocation, Lookout, Building, Entrance}, Location)</xhmath>
-->
  <Location>
    <MarkedLocation/>
    <UnmarkedLocation/>
    <Lookout/>
    <Building/>
    <Entrance/>
  </Location>
  
  <!-- there is a trail segment between each pair of connected locations; collectables are scattered along each segment -->
  <Segment/>
  
  <Collectable/>
  <Collectables superClass="Attribute_String"/>
  
  <Collection>
    <Backpack/>
  </Collection>
  
  <?xhmath.pSetPointed01 ({Planet,Mercury,Venus,Earth,Mars}, Planet)?>
  
  <Testing/>
  <Category/>
  
</_-.XholonClass>

<xholonClassDetails>
  <MarkedLocation xhType="XhtypePureActiveObject"/>
  
  # a set of colors; each type has 0 or 1 color; I need to specify a mapping from type to color
  colors = {white, yellow, #5f5f8e, #8e5f5f, #5f8e5f, orange, green, red}
  # a set of pairs that specify the mapping from types to colors
  colormapping = { (City,white), (Habitat,white), (House,yellow), (MarkedLocation,#5f5f8e), ..., (Entrance,green) }
  # note that specifying two sets and then a mapping between the two sets, could be cumbersome; or maybe I'm just not used to it
  # my purpose here is to highlight that Xholon and Math notation can both do the same thing
  # in Xholon terms, Color is a child of City; it becomes an attribute; so in some ways, and attribute is a child of a node; but there's also an arrow from City to Color and/or vice versa
  
  <City><Color>white</Color></City>
  <Habitat><Color>white</Color></Habitat>
  <House><Color>yellow</Color></House>
  
  <MarkedLocation><Color>#5f5f8e</Color></MarkedLocation>
  <UnmarkedLocation><Color>#8e5f5f</Color></UnmarkedLocation>
  <Lookout><Color>#5f8e5f</Color></Lookout>
  <Building><Color>orange</Color></Building>
  <Entrance><Color>green</Color></Entrance>

  <Avatar><Color>red</Color></Avatar>
</xholonClassDetails>

<PhysicalSystem>
  
  # the following assumes that the XholonClass names already exist in the IH
  ({A,B,C,D,E,F,G,H,I,J,K,L}, {(A,MarkedLocation), (B,MarkedLocation), ..., (G,Lookout), ..., (L,Entrance)})
  # OR
  roleNames = {A,B,C,D,E,F,G,H,I,J,K,L}
  # a mapping from roleNames to XholonClass names
  rn2ihMapping = {(A,MarkedLocation), (B,MarkedLocation), ..., (G,Lookout), ..., (L,Entrance)}
  
  # ports
  ports.trail = {(A,B),(B,A),(B,C),(B,J),(C,D), ...}
  ports.untrail = {(E,F), ...}
  
  # SetPorts01 ports as a set of triples/tuples
  {(A,B,trail), (A,G,trail), ..., (E,D,trail), (E,H,trail), (E,F,untrail), ...}
  
  # SetPorts02 ports as a set of structures/tuples/pairs, where each pair contains a set of pairs (a subset of Location x Location) and a label (the port name, or the function name)
  # Set of pairs equipped with a label, where the label is the name of the link/function ex: trail, untrail, port, parent, type, etc.
  # by convention the set always comes first in this type of structure
  {
    (
      {(A,B), (A,G), (A,I), (B,A), (B,C), (B,J), ...},
      trail
    ),
    (
      {(E,F), (F,E), ...},
      untrail
    )
  }
  
  # function, morphism, arrow
  trail(A) --> B
  A --trail-> B
  
  # JavaScript
  A.trail[0] = B;
  A.trail[1] = G;
  A.trail[2] = I;
  E.trail[0] = D;
  E.untrail[0] = F;
  
  # JavaScript
  (function(a, b) {console.log(a + b)}) (2,5)
  
  # JavaScript
  (function(str, portName) {
    window.habitat = {};
    const arr = str.split(",");
    arr.forEach(function(item) {
      habitat[item] = {};
      habitat[item][portName] = [];
    });
    console.log(habitat);
    habitat.A.trail.push(habitat.B);
    habitat.A.trail.push(habitat.G);
    habitat.A.trail.push(habitat.I);
    habitat.E.trail.push(habitat.D);
    //E.untrail[0] = F;
  }
  )("A,B,C,D,E,F,G,H,I", "trail")
  
  # JSON
[
  [
    ["A,B", "A,G", "A,I", "B,A", "B,C", "B,J"],
    "trail"
  ],
  [
    ["E,F", "F,E"],
    "untrail"
  ]
]

const json = '[[["A,B","A,G","A,I","B,A","B,C","B,J"],"trail"],[["E,F","F,E"],"untrail"]]';
const jso = JSON.parse(json);
  
  # SetPorts03 ports as a simple set of pairs; the label "port" is assumed, and the index auto-increments (ex: port[0] port[1] ...)
  {(Aaa,Bbb),(Aaa,Ccc), (Ddd,Eee), ...}
  
  <!--<City roleName="Ottawa">
    <Habitat roleName="Mud Lake">
      <MarkedLocation roleName="A">
        <port name="trail" index="0" connector="../MarkedLocation[@roleName='B']"/>
        <port name="trail" index="1" connector="../Lookout[@roleName='G']"/>
        <port name="trail" index="2" connector="../Building[@roleName='I']"/>
      </MarkedLocation>
      <MarkedLocation roleName="B">
        <port name="trail" index="0" connector="../MarkedLocation[@roleName='A']"/>
        <port name="trail" index="1" connector="../MarkedLocation[@roleName='C']"/>
        <port name="trail" index="2" connector="../Entrance[@roleName='J']"/>
      </MarkedLocation>
      <MarkedLocation roleName="C">
        <port name="trail" index="0" connector="../MarkedLocation[@roleName='B']"/>
        <port name="trail" index="1" connector="../MarkedLocation[@roleName='D']"/>
        <port name="trail" index="2" connector="../Entrance[@roleName='K']"/>
      </MarkedLocation>
      <MarkedLocation roleName="D">
        <port name="trail" index="0" connector="../MarkedLocation[@roleName='C']"/>
        <port name="trail" index="1" connector="../MarkedLocation[@roleName='E']"/>
        <port name="trail" index="2" connector="../Lookout[@roleName='H']"/>
      </MarkedLocation>
      <MarkedLocation roleName="E">
        <port name="trail" index="0" connector="../MarkedLocation[@roleName='D']"/>
        <port name="trail" index="1" connector="../Lookout[@roleName='H']"/>
        <port name="untrail" index="0" connector="../UnmarkedLocation[@roleName='F']"/>
      </MarkedLocation>
      <UnmarkedLocation roleName="F">
        <port name="untrail" index="0" connector="../MarkedLocation[@roleName='E']"/>
        <port name="untrail" index="1" connector="../Building[@roleName='I']"/>
        <port name="untrail" index="2" connector="../Entrance[@roleName='L']"/>
      </UnmarkedLocation>
      <Lookout roleName="G">
        <port name="trail" index="0" connector="../MarkedLocation[@roleName='A']"/>
      </Lookout>
      <Lookout roleName="H">
        <port name="trail" index="0" connector="../MarkedLocation[@roleName='D']"/>
        <port name="trail" index="1" connector="../MarkedLocation[@roleName='E']"/>
      </Lookout>
      <Building roleName="I">
        <port name="trail" index="0" connector="../MarkedLocation[@roleName='A']"/>
        <port name="untrail" index="0" connector="../UnmarkedLocation[@roleName='F']"/>
      </Building>
      <Entrance roleName="J">
        <port name="trail" index="0" connector="../MarkedLocation[@roleName='B']"/>
      </Entrance>
      <Entrance roleName="K">
        <port name="trail" index="0" connector="../MarkedLocation[@roleName='C']"/>
      </Entrance>
      <Entrance roleName="L">
        <port name="untrail" index="0" connector="../UnmarkedLocation[@roleName='F']"/>
      </Entrance>
    </Habitat>
    <House roleName="Home"/>
  </City>-->
  
  <!--<City roleName="Ottawa">
    <Habitat roleName="Mud Lake">
      <MarkedLocation roleName="A">
        <port name="trail" index="0" connector="../Location[@roleName='B']"/>
        <port name="trail" index="1" connector="../Location[@roleName='G']"/>
        <port name="trail" index="2" connector="../Location[@roleName='I']"/>
      </MarkedLocation>
      <MarkedLocation roleName="B">
        <port name="trail" index="0" connector="../Location[@roleName='A']"/>
        <port name="trail" index="1" connector="../Location[@roleName='C']"/>
        <port name="trail" index="2" connector="../Location[@roleName='J']"/>
      </MarkedLocation>
      <MarkedLocation roleName="C">
        <port name="trail" index="0" connector="../Location[@roleName='B']"/>
        <port name="trail" index="1" connector="../Location[@roleName='D']"/>
        <port name="trail" index="2" connector="../Location[@roleName='K']"/>
      </MarkedLocation>
      <MarkedLocation roleName="D">
        <port name="trail" index="0" connector="../Location[@roleName='C']"/>
        <port name="trail" index="1" connector="../Location[@roleName='E']"/>
        <port name="trail" index="2" connector="../Location[@roleName='H']"/>
      </MarkedLocation>
      <MarkedLocation roleName="E">
        <port name="trail" index="0" connector="../Location[@roleName='D']"/>
        <port name="trail" index="1" connector="../Location[@roleName='H']"/>
        <port name="untrail" index="0" connector="../Location[@roleName='F']"/>
      </MarkedLocation>
      <UnmarkedLocation roleName="F">
        <port name="untrail" index="0" connector="../Location[@roleName='E']"/>
        <port name="untrail" index="1" connector="../Location[@roleName='I']"/>
        <port name="untrail" index="2" connector="../Location[@roleName='L']"/>
      </UnmarkedLocation>
      <Lookout roleName="G">
        <port name="trail" index="0" connector="../Location[@roleName='A']"/>
      </Lookout>
      <Lookout roleName="H">
        <port name="trail" index="0" connector="../Location[@roleName='D']"/>
        <port name="trail" index="1" connector="../Location[@roleName='E']"/>
      </Lookout>
      <Building roleName="I">
        <port name="trail" index="0" connector="../Location[@roleName='A']"/>
        <port name="untrail" index="0" connector="../Location[@roleName='F']"/>
      </Building>
      <Entrance roleName="J">
        <port name="trail" index="0" connector="../Location[@roleName='B']"/>
      </Entrance>
      <Entrance roleName="K">
        <port name="trail" index="0" connector="../Location[@roleName='C']"/>
      </Entrance>
      <Entrance roleName="L">
        <port name="untrail" index="0" connector="../Location[@roleName='F']"/>
      </Entrance>
    </Habitat>
    <House roleName="Home"/>
  </City>-->
  
  <City roleName="Ottawa">
    <Habitat roleName="Mud Lake">
      <MarkedLocation roleName="A">
        <port name="trail" index="0" connector="../*[@roleName='B']"/>
        <port name="trail" index="1" connector="../*[@roleName='G']"/>
        <port name="trail" index="2" connector="../*[@roleName='I']"/>
      </MarkedLocation>
      <MarkedLocation roleName="B">
        <port name="trail" index="0" connector="../*[@roleName='A']"/>
        <port name="trail" index="1" connector="../*[@roleName='C']"/>
        <port name="trail" index="2" connector="../*[@roleName='J']"/>
      </MarkedLocation>
      <MarkedLocation roleName="C">
        <port name="trail" index="0" connector="../*[@roleName='B']"/>
        <port name="trail" index="1" connector="../*[@roleName='D']"/>
        <port name="trail" index="2" connector="../*[@roleName='K']"/>
      </MarkedLocation>
      <MarkedLocation roleName="D">
        <port name="trail" index="0" connector="../*[@roleName='C']"/>
        <port name="trail" index="1" connector="../*[@roleName='E']"/>
        <port name="trail" index="2" connector="../*[@roleName='H']"/>
      </MarkedLocation>
      <MarkedLocation roleName="E">
        <port name="trail" index="0" connector="../*[@roleName='D']"/>
        <port name="trail" index="1" connector="../*[@roleName='H']"/>
        <port name="untrail" index="0" connector="../*[@roleName='F']"/>
      </MarkedLocation>
      <UnmarkedLocation roleName="F">
        <port name="untrail" index="0" connector="../*[@roleName='E']"/>
        <port name="untrail" index="1" connector="../*[@roleName='I']"/>
        <port name="untrail" index="2" connector="../*[@roleName='L']"/>
      </UnmarkedLocation>
      <Lookout roleName="G">
        <port name="trail" index="0" connector="../*[@roleName='A']"/>
      </Lookout>
      <Lookout roleName="H">
        <port name="trail" index="0" connector="../*[@roleName='D']"/>
        <port name="trail" index="1" connector="../*[@roleName='E']"/>
      </Lookout>
      <Building roleName="I">
        <port name="trail" index="0" connector="../*[@roleName='A']"/>
        <port name="untrail" index="0" connector="../*[@roleName='F']"/>
      </Building>
      <Entrance roleName="J">
        <port name="trail" index="0" connector="../*[@roleName='B']"/>
      </Entrance>
      <Entrance roleName="K">
        <port name="trail" index="0" connector="../*[@roleName='C']"/>
      </Entrance>
      <Entrance roleName="L">
        <port name="untrail" index="0" connector="../*[@roleName='F']"/>
      </Entrance>
    </Habitat>
    <House roleName="Home"/>
  </City>
  
  <Collectables>
    <!-- write behavior (Collectablesbehavior and Habitatbehavior) to place the following set of items randomly along the links between the Location nodes -->
    {smoothpinkrock, jaggedgreyrock, pineneedle3, greenleaf, brownleaf, blueberry, blackberry, acorn, pinecone, birchbark, blackrock, ice, mud, stick, thorn, smallseed, seeds, feather, horsetail, fern, snow, bug, moss, lichen, smoothgreyrock, jaggedgreenrock, pineneedle2, yellowleaf, orangeleaf, redberry, yellowberry, chestnut, fircone, bluerock, slush, muck, knot, thistle, bigseed, tinyfeather, ginkoleaf}
  </Collectables>
  
  <!-- testing; for now these PI and XSLT statements are ignored -->
  <?PITarget PIContent?>
  <?xml-stylesheet type="text/xsl" href="style.xsl"?>
  <?xml-stylesheet type="text/css" href="style.css"?>
  
  <Testing roleName="test01">
    <?xhmath.pSet01 {One, Two, Three, Four, Five}?>
  </Testing>
  
  <?xhmath.pSetPointed01 ({Planets,Mercury,Venus,Earth,Mars}, Planets)?>
  <?xhmath.pSetPointed02 ({Planet,Jupiter,Saturn,Uranus,Neptune}, Planet)?>
  <?xhmath.pPorts02 {({(A,B),(A,G),(A,I),(B,A),(B,C),(B,J)},trail),({(E,F),(F,E)},untrail)}?>
  
  <Testing roleName="test02"><?xhmath.pSiblings01
# process all of this stuff together
nodes = {0,1,2,3,4,5,6,7,8,9,10,11} # {0,1,2,3,4,5,6,7,8,9,10,11} # or use shorthand {0,…,11} or {0,...,11}; these are JavaScript Array indexes
roles = {A,B,C,D,E,F,G,H,I,J,K,L}
# assume that types are already defined
roleMapping = {(0,A), (1,B), (2,C), (3,D), (4,E), (5,F), (6,G), (7,H), (8,I), (9,J), (10,K), (11,L)} # {(0,A), ..., (11,L)}
typeMapping = {(0,MarkedLocation), (1,MarkedLocation), (2,MarkedLocation), (3,MarkedLocation), (4,MarkedLocation), (5,UnmarkedLocation), (6,Lookout), (7,Lookout), (8,Building), (9,Entrance), (10,Entrance), (11,Entrance)}
ports = {trail,untrail}
portMapping = {({(A,B),(A,G),(A,I),(B,A),(B,C),(B,J),(C,B),(C,D),(C,K),(D,C),(D,E),(D,H),(E,D),(E,H),(G,A),(H,D),(H,E),(I,A),(J,B),(K,C)},trail),({(E,F),(F,E),(F,I),(F,L),(I,F),(L,F)},untrail)} # using roleNames rather than id
  ?></Testing>
  result (JSON):
  [
  {"roleName":"A","xhc":"MarkedLocation","trail":["B","G","I"],"untrail":[]},
  {"roleName":"B","xhc":"MarkedLocation","trail":["A","C","J"],"untrail":[]},
  {"roleName":"C","xhc":"MarkedLocation","trail":["B","D","K"],"untrail":[]},
  {"roleName":"D","xhc":"MarkedLocation","trail":["C","E","H"],"untrail":[]},
  {"roleName":"E","xhc":"MarkedLocation","trail":["D","H"],"untrail":["F"]},
  {"roleName":"F","xhc":"UnmarkedLocation","trail":[],"untrail":["E","I","L"]},
  {"roleName":"G","xhc":"Lookout","trail":["A"],"untrail":[]},
  {"roleName":"H","xhc":"Lookout","trail":["D","E"],"untrail":[]},
  {"roleName":"I","xhc":"Building","trail":["A"],"untrail":["F"]},
  {"roleName":"J","xhc":"Entrance","trail":["B"],"untrail":[]},
  {"roleName":"K","xhc":"Entrance","trail":["C)"],"untrail":[]},
  {"roleName":"L","xhc":"Entrance","trail":[],"untrail":["F"]}
  ]
  
  because these are all defined to be mathematical sets, then the order of the elements in each set should not matter
  <Testing roleName="test03"><?xhmath.pSiblings01
nodes = {3,0,1,2,4,5,11,6,7,10,8,9}
roles = {B,L,A,D,G,E,C,H,I,J,K,F}
roleMapping = {(1,B), (2,C), (3,D), (4,E), (5,F), (0,A), (6,G), (7,H), (8,I), (9,J), (10,K), (11,L)}
typeMapping = {(0,MarkedLocation), (1,MarkedLocation), (2,MarkedLocation), (3,MarkedLocation), (5,UnmarkedLocation), (6,Lookout), (7,Lookout), (8,Building), (4,MarkedLocation), (9,Entrance), (10,Entrance), (11,Entrance)}
ports = {untrail,trail}
portMapping = {({(A,B),(A,I),(B,A),(B,C),(B,J),(C,B),(C,D),(A,G),(C,K),(D,C),(D,E),(D,H),(E,D),(E,H),(G,A),(H,D),(H,E),(I,A),(J,B),(K,C)},trail),({(F,E),(F,I),(F,L),(E,F),(I,F),(L,F)},untrail)}
  ?></Testing>
  the result is exactly the same as before, except for the order of the ports for each location
  the reulting Graphviz graph looks almost exactly the same as before
  
  <Category roleName="cat01"><?xhmath.pSiblings01
# TODO improve this
types = {Set}
nodes = {0,1,2,3}
roles = {nodes,roles,types,ports}
roleMapping = {(0,nodes), (1,roles), (2,types), (3,ports)}
typeMapping = {(0,Set), (1,Set), (2,Set), (3,Set)}
ports = {roleMapping,typeMapping,portMapping}
nodesXnodes = {nodes,nodes}
portMapping = {({(nodes,roles)},roleMapping), ({(nodes,types)},typeMapping), ({(nodes,ports)},portMapping)}
# Xholon node decorations
colors = {red,orange,yellow,green,blue,purple}
colorMapping = {(0,red), (1,purple), (2,green), (3,blue)}
opacities = {0.9}
opacityMapping = {(0,0.9), (1,0.9), (2,0.9), (3,0.9)}
annos = {}
annoMapping={(0,I am redish.),(1,You are purplish.),(2,He is greenish.),(3,She is bluish.)}
  ?></Category>
  
  <Testing roleName="test04"><?xhmath.pSiblings01
nodes = {*,*,*} # the only significant thing here is the number of items in the set; the actual element values are ignored
roles = {un,deux,trois}
roleMapping = {(0,un), (1,deux), (2,trois)}
typeMapping = {(0,Mars), (1,Mars), (2,Mars)}
ports = {moi} # an identity arrow
portMapping = {({(un,un),(deux,deux),(trois,trois)},moi)} # self mapping; in Dev Tools, I can keep recursively clicking on "moi" arbitrarily many times (follow the arrow forever)
  ?></Testing>
  
  <Testing roleName="test05"><?xhmath.pSiblings01
# a complete mapping; each node is linked to every other node
nodes = {*,*,*}
roles = {un,deux,trois}
roleMapping = {(0,un), (1,deux), (2,trois)}
typeMapping = {(0,Mars), (1,Mars), (2,Mars)}
ports = {arrow}
portMapping = {({(un,un),(un,deux),(un,trois),(deux,un),(deux,deux),(deux,trois),(trois,un),(trois,deux),(trois,trois)},arrow)}
  ?></Testing>
  
  <Testing roleName="test06"><?xhmath.pSiblings01
# multiple nodes lines
nodes = {3,0,1,2,4,5,11,6,7,10,8,9}
nodes = {*,*,*}
roles = {B,L,A,D,G,E,C,H,I,J,K,F}
roleMapping = {(1,B), (2,C), (3,D), (4,E), (5,F), (0,A), (6,G), (7,H), (8,I), (9,J), (10,K), (11,L)}
typeMapping = {(0,MarkedLocation), (1,MarkedLocation), (2,MarkedLocation), (3,MarkedLocation), (5,UnmarkedLocation), (6,Lookout), (7,Lookout), (8,Building), (4,MarkedLocation), (9,Entrance), (10,Entrance), (11,Entrance)}
ports = {untrail,trail}
portMapping = {({(A,B),(A,I),(B,A),(B,C),(B,J),(C,B),(C,D),(A,G),(C,K),(D,C),(D,E),(D,H),(E,D),(E,H),(G,A),(H,D),(H,E),(I,A),(J,B),(K,C)},trail),({(F,E),(F,I),(F,L),(E,F),(I,F),(L,F)},untrail)}
  ?></Testing>
  
  <Testing roleName="json 1"><?xhmath.pJson01
[{"roleName":"un","xhc":"Venus","ports":{"arrow":["un","deux","trois"]}},{"roleName":"deux","xhc":"Earth","ports":{"arrow":["un","deux","trois"]}},{"roleName":"trois","xhc":"Mars","ports":{"arrow":["un","deux","trois"]}}]
  ?></Testing>
  
  <Testing roleName="test07">
    <script>
let count = 0;
let node = this.next();
while (node) {
  count++;
  node = node.next();
}
console.log(this.parent().name() + " has " + count + " child nodes.");
    </script>
    <?xhmath.pSiblings01
nodes = {0,…,99}
roles = {A,B,C,D,E,F,G,H,I,J,K,L}
roleMapping = {(0,A), (1,B), (2,C), (3,D), (4,E), (5,F), (6,G), (7,H), (8,I), (9,J), (10,K), (11,L)}
nodes = {1,2,3,4,5,6,7}
roles = {P,Q,R}
roleMapping = {(20,P), (21,Q), (22,R)}
typeMapping = {(0,MarkedLocation), (1,MarkedLocation), (2,MarkedLocation), (3,MarkedLocation), (4,MarkedLocation), (5,UnmarkedLocation), (6,Lookout), (7,Lookout), (8,Building), (9,Entrance), (10,Entrance), (11,Entrance)}
ports = {trail,untrail}
portMapping = {({(A,B),(A,G),(A,I),(B,A),(B,C),(B,J),(C,B),(C,D),(C,K),(D,C),(D,E),(D,H),(E,D),(E,H),(G,A),(H,D),(H,E),(I,A),(J,B),(K,C)},trail),({(E,F),(F,E),(F,I),(F,L),(I,F),(L,F)},untrail)}
  ?>
  </Testing>
  
  <Animate selection="#xhgraph" xpath="PhysicalSystem/City" duration="0.5" cssStyle=".d3cpnode circle {stroke-width: 0px;} .d3cpleaf circle {stroke-width: 0px;} .City:not(.d3cpdummy) circle {stroke: #98FB98; stroke-width: 0.5px;} .Habitat:not(.d3cpdummy) circle {stroke: #FB98FB; stroke-width: 0.5px;}" tweenScript="xhSvgTween" efParams="{&quot;selection&quot;:&quot;#xhgraph&quot;,  &quot;sort&quot;:&quot;disable&quot;,  &quot;width&quot;:600,  &quot;height&quot;:600,  &quot;mode&quot;:&quot;tween&quot;,  &quot;labelContainers&quot;:true,  &quot;includeClass&quot;:true}"/>
  
</PhysicalSystem>

<PhysicalSystembehavior implName="org.primordion.xholon.base.Behavior_gwtjs"><![CDATA[
  // commands for built-in Avatar, formatted as a JSON string
  // this is a mapping from a set of keyboard keys (ex: "w") and meta commands (ex: "SHIFT") to a set of Avatar commands (ex: "who;where")
  const akm = `{
"SHIFT":"true",
"NOSCROLL":"true",
"0":"go link0",
"1":"go link1",
"2":"go link2",
"3":"go link3",
"4":"go link4",
"5":"go link5",
"6":"go link6",
"7":"go link7",
"8":"go link8",
"9":"go link9",
"b":"take backpack",
"B":"drop backpack",
"d":"if xpath(Avatar/ancestor::House) drop backpack;if xpath(Avatar/ancestor::House) enter backpack;if xpath(Avatar/ancestor::Backpack) take;if xpath(Avatar/ancestor::Backpack) exit;if xpath(Avatar/ancestor::House) drop;",
"h":"if xpath(Avatar/ancestor::Location) go xpath(../../House)",
"i":"inventory",
"l":"look",
"p":"pause",
"r":"start",
"s":"step",
" ":"step",
"t":"take *coll;put *coll in xpath(Avatar/Backpack)",
"T":"takeclone *coll;put *coll in xpath(Avatar/Backpack)",
"w":"who;where",
"?":"help keymap"
}`;
  $wnd.xh.avatarKeyMap(akm);
]]></PhysicalSystembehavior>

<PhysicalSystembehavior implName="org.primordion.xholon.base.Behavior_gwtjs"><![CDATA[
var me, beh = {
postConfigure: function() {
  me = this.cnode.parent();
  this.cnode.remove();
  var ava = $wnd.xh.avatar();
  // move Avatar to starting point, and make it visible
  ava.action("become this role Ken;enter;enter;enter;enter L;appear;build Backpack;take backpack;");
}
}
//# sourceURL=PhysicalSystembehavior.js
]]></PhysicalSystembehavior>

<Collectablesbehavior implName="org.primordion.xholon.base.Behavior_gwtjs"><![CDATA[
const enabled = true;
var me, beh = {
postConfigure: function() {
  me = this.cnode.parent();
  this.cnode.remove();
  if (!enabled) {return;}
  const str = me.text().trim();
  if ($wnd.xh.xhmath) {
    const xmlStr = $wnd.xh.xhmath.pSetPointed02("({Collectable, " + str.substring(1)  + ", Collectable)");
    //me.println(xmlStr);
    me.append(xmlStr);
  }
  else {
    const arr = str.substring(1, str.length-1).split(",");
    let xmlStr = "<" + "_-.stuff>\n";
    for (var i = 0; i < arr.length; i++) {
      let item = arr[i].trim();
      xmlStr += '<' + 'Collectable roleName="' + item + '"/>\n';
    }
    xmlStr += "</" + "_-.stuff>\n";
    //me.println(xmlStr);
    me.append(xmlStr);
  }
}
}
//# sourceURL=Collectablesbehavior.js
]]></Collectablesbehavior>

<Habitatbehavior implName="org.primordion.xholon.base.Behavior_gwtjs"><![CDATA[
const enabled = true;
var me, beh = {
postConfigure: function() {
  me = this.cnode.parent();
  this.cnode.remove();
  if (!enabled) {return;}
  // add a single segment between each pair of connected locations
  var clctbls = me.parent().next();
  var loctn = me.first();
  while (loctn) {
    var links = loctn.links(false,true);
    //$wnd.console.log(links);
    for (var i = 0; i < links.length; i++) {
      var link = links[i];
      me.append("<" + "Segment/>");
      var segment = me.last().remove();
      segment[link.fieldName] = link.reffedNode;
      loctn[link.fieldName][link.fieldNameIndex] = segment;
      segment.role(loctn.role() + "_" + link.reffedNode.role());
      // place a collectable inside the segment, if one is available
      while (Math.random() > 0.5) {
        var clctbl = clctbls.first();
        if (clctbl) {
          segment.append(clctbl.remove());
        }
      }
    }
    loctn = loctn.next();
  }
}
}
//# sourceURL=Habitatbehavior.js
]]></Habitatbehavior>

<SvgClient><Attribute_String roleName="svgUri"><![CDATA[data:image/svg+xml,
<!--<svg width="100" height="50" xmlns="http://www.w3.org/2000/svg">
  <g>
    <title>City</title>
    <rect id="PhysicalSystem/City" fill="#98FB98" height="50" width="50" x="25" y="0"/>
    <g>
      <title>Habitat</title>
      <rect id="PhysicalSystem/City/Habitat" fill="#6AB06A" height="50" width="10" x="80" y="0"/>
    </g>
  </g>
</svg>-->

<!-- Graphviz -->
<svg width="888pt" height="278pt"
 viewBox="0.00 0.00 888.00 277.60" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
<g id="Habitat" class="graph" transform="scale(1 1) rotate(0) translate(4 273.6)">
<title>47</title>
<polygon fill="white" stroke="none" points="-4,4 -4,-273.6 884,-273.6 884,4 -4,4"/>
<text text-anchor="middle" x="440" y="-8.2" font-family="Courier New" font-size="14.00">Mud Lake</text>
<!-- 48 -->
<g id="Habitat/MarkedLocation[@roleName=&#39;A&#39;]" class="node"><title>48</title>
<ellipse fill="#5f5f8e" stroke="black" cx="27" cy="-117.8" rx="27" ry="18"/>
<text text-anchor="middle" x="27" y="-113.6" font-family="Courier New" font-size="14.00">A</text>
</g>
<!-- 52 -->
<g id="Habitat/MarkedLocation[@roleName=&#39;B&#39;]" class="node"><title>52</title>
<ellipse fill="#5f5f8e" stroke="black" cx="141" cy="-215.8" rx="27" ry="18"/>
<text text-anchor="middle" x="141" y="-211.6" font-family="Courier New" font-size="14.00">B</text>
</g>
<!-- 48&#45;&gt;52 -->
<g id="Habitat_edge1" class="edge"><title>48&#45;&gt;52</title>
<path fill="none" stroke="black" d="M33.4654,-135.287C39.9005,-153.055 52.2831,-180.127 72,-195.8 81.2191,-203.128 93.0487,-207.772 104.249,-210.715"/>
<polygon fill="black" stroke="black" points="114.264,-212.968 103.52,-215.164 109.386,-211.87 104.508,-210.773 104.508,-210.773 104.508,-210.773 109.386,-211.87 105.495,-206.383 114.264,-212.968 114.264,-212.968"/>
<text text-anchor="middle" x="84" y="-213" font-family="Times,serif" font-size="14.00">trail</text>
</g>
<!-- 72 -->
<g id="Habitat/Lookout[@roleName=&#39;G&#39;]" class="node"><title>72</title>
<ellipse fill="#5f8e5f" stroke="black" cx="141" cy="-123.8" rx="27" ry="18"/>
<text text-anchor="middle" x="141" y="-119.6" font-family="Courier New" font-size="14.00">G</text>
</g>
<!-- 48&#45;&gt;72 -->
<g id="Habitat_edge2" class="edge"><title>48&#45;&gt;72</title>
<path fill="none" stroke="black" d="M53.9766,-119.192C68.7132,-119.981 87.388,-120.982 103.569,-121.848"/>
<polygon fill="black" stroke="black" points="113.776,-122.395 103.55,-126.354 108.783,-122.128 103.791,-121.86 103.791,-121.86 103.791,-121.86 108.783,-122.128 104.031,-117.367 113.776,-122.395 113.776,-122.395"/>
<text text-anchor="middle" x="84" y="-126" font-family="Times,serif" font-size="14.00">trail</text>
</g>
<!-- 77 -->
<g id="Habitat/Building" class="node"><title>77</title>
<ellipse fill="orange" stroke="black" cx="853" cy="-80.8" rx="27" ry="18"/>
<text text-anchor="middle" x="853" y="-76.6" font-family="Courier New" font-size="14.00">I</text>
</g>
<!-- 48&#45;&gt;77 -->
<g id="Habitat_edge3" class="edge"><title>48&#45;&gt;77</title>
<path fill="none" stroke="black" d="M44.6767,-104.151C65.6001,-88.4477 103.215,-64.8 140,-64.8 140,-64.8 140,-64.8 726,-64.8 756.871,-64.8 791.66,-69.5852 816.849,-73.9217"/>
<polygon fill="black" stroke="black" points="827.017,-75.7375 816.382,-78.4094 822.095,-74.8585 817.173,-73.9795 817.173,-73.9795 817.173,-73.9795 822.095,-74.8585 817.964,-69.5495 827.017,-75.7375 827.017,-75.7375"/>
<text text-anchor="middle" x="426" y="-69" font-family="Times,serif" font-size="14.00">trail</text>
</g>
<!-- 52&#45;&gt;48 -->
<g id="Habitat_edge4" class="edge"><title>52&#45;&gt;48</title>
<path fill="none" stroke="black" d="M124.691,-201.265C116.307,-193.392 105.682,-183.552 96,-175 81.868,-162.517 65.7295,-148.915 52.7221,-138.108"/>
<polygon fill="black" stroke="black" points="44.679,-131.45 55.2516,-134.36 48.5305,-134.638 52.382,-137.826 52.382,-137.826 52.382,-137.826 48.5305,-134.638 49.5125,-141.293 44.679,-131.45 44.679,-131.45"/>
<text text-anchor="middle" x="84" y="-180" font-family="Times,serif" font-size="14.00">trail</text>
</g>
<!-- 56 -->
<g id="Habitat/MarkedLocation[@roleName=&#39;C&#39;]" class="node"><title>56</title>
<ellipse fill="#5f5f8e" stroke="black" cx="255" cy="-170.8" rx="27" ry="18"/>
<text text-anchor="middle" x="255" y="-166.6" font-family="Courier New" font-size="14.00">C</text>
</g>
<!-- 52&#45;&gt;56 -->
<g id="Habitat_edge5" class="edge"><title>52&#45;&gt;56</title>
<path fill="none" stroke="black" d="M164.396,-206.802C180.846,-200.192 203.435,-191.116 221.816,-183.731"/>
<polygon fill="black" stroke="black" points="231.259,-179.937 223.658,-187.841 226.62,-181.801 221.98,-183.665 221.98,-183.665 221.98,-183.665 226.62,-181.801 220.302,-179.49 231.259,-179.937 231.259,-179.937"/>
<text text-anchor="middle" x="198" y="-202" font-family="Times,serif" font-size="14.00">trail</text>
</g>
<!-- 80 -->
<g id="Habitat/Entrance[@roleName=&#39;J&#39;]" class="node"><title>80</title>
<ellipse fill="green" stroke="black" cx="255" cy="-239.8" rx="27" ry="18"/>
<text text-anchor="middle" x="255" y="-235.6" font-family="Courier New" font-size="14.00">J</text>
</g>
<!-- 52&#45;&gt;80 -->
<g id="Habitat_edge6" class="edge"><title>52&#45;&gt;80</title>
<path fill="none" stroke="black" d="M155.917,-230.937C163.893,-238.473 174.573,-246.81 186,-250.8 197.352,-254.764 210.277,-253.918 221.787,-251.428"/>
<polygon fill="black" stroke="black" points="231.464,-248.896 222.928,-255.781 226.626,-250.162 221.789,-251.427 221.789,-251.427 221.789,-251.427 226.626,-250.162 220.65,-247.074 231.464,-248.896 231.464,-248.896"/>
<text text-anchor="middle" x="198" y="-257" font-family="Times,serif" font-size="14.00">trail</text>
</g>
<!-- 72&#45;&gt;48 -->
<g id="Habitat_edge19" class="edge"><title>72&#45;&gt;48</title>
<path fill="none" stroke="black" d="M121.576,-111.189C114.002,-106.728 104.924,-102.259 96,-100 83.5228,-96.8417 69.7847,-99.307 57.9423,-103.298"/>
<polygon fill="black" stroke="black" points="48.5099,-106.92 56.2324,-99.1345 53.1777,-105.128 57.8454,-103.335 57.8454,-103.335 57.8454,-103.335 53.1777,-105.128 59.4585,-107.536 48.5099,-106.92 48.5099,-106.92"/>
<text text-anchor="middle" x="84" y="-105" font-family="Times,serif" font-size="14.00">trail</text>
</g>
<!-- 77&#45;&gt;48 -->
<g id="Habitat_edge22" class="edge"><title>77&#45;&gt;48</title>
<path fill="none" stroke="black" d="M834.722,-67.5288C811.39,-50.9688 767.892,-24.8 726,-24.8 140,-24.8 140,-24.8 140,-24.8 97.3531,-24.8 62.267,-65.2045 43.3028,-92.7496"/>
<polygon fill="black" stroke="black" points="37.7229,-101.173 39.4937,-90.3515 40.4841,-97.005 43.2453,-92.8365 43.2453,-92.8365 43.2453,-92.8365 40.4841,-97.005 46.9969,-95.3216 37.7229,-101.173 37.7229,-101.173"/>
<text text-anchor="middle" x="426" y="-29" font-family="Times,serif" font-size="14.00">trail</text>
</g>
<!-- 68 -->
<g id="Habitat/UnmarkedLocation" class="node"><title>68</title>
<ellipse fill="#8e5f5f" stroke="black" cx="725" cy="-153.8" rx="27" ry="18"/>
<text text-anchor="middle" x="725" y="-149.6" font-family="Courier New" font-size="14.00">F</text>
</g>
<!-- 77&#45;&gt;68 -->
<g id="Habitat_edge23" class="edge"><title>77&#45;&gt;68</title>
<path fill="none" stroke="black" d="M825.881,-80.466C808.848,-81.365 786.752,-84.7308 770,-95 757.093,-102.912 746.694,-116.133 739.252,-128.037"/>
<polygon fill="black" stroke="black" points="734.146,-136.774 735.307,-125.87 736.669,-132.457 739.192,-128.14 739.192,-128.14 739.192,-128.14 736.669,-132.457 743.077,-130.411 734.146,-136.774 734.146,-136.774"/>
<text text-anchor="middle" x="789" y="-100" font-family="Times,serif" font-size="14.00">untrail</text>
</g>
<!-- 56&#45;&gt;52 -->
<g id="Habitat_edge7" class="edge"><title>56&#45;&gt;52</title>
<path fill="none" stroke="black" d="M229.128,-165.222C215.815,-163.429 199.441,-163.188 186,-169 175.295,-173.629 165.994,-182.286 158.735,-190.907"/>
<polygon fill="black" stroke="black" points="152.423,-199.03 155.006,-188.372 155.491,-195.082 158.56,-191.134 158.56,-191.134 158.56,-191.134 155.491,-195.082 162.113,-193.895 152.423,-199.03 152.423,-199.03"/>
<text text-anchor="middle" x="198" y="-174" font-family="Times,serif" font-size="14.00">trail</text>
</g>
<!-- 60 -->
<g id="Habitat/MarkedLocation[@roleName=&#39;D&#39;]" class="node"><title>60</title>
<ellipse fill="#5f5f8e" stroke="black" cx="369" cy="-151.8" rx="27" ry="18"/>
<text text-anchor="middle" x="369" y="-147.6" font-family="Courier New" font-size="14.00">D</text>
</g>
<!-- 56&#45;&gt;60 -->
<g id="Habitat_edge8" class="edge"><title>56&#45;&gt;60</title>
<path fill="none" stroke="black" d="M281.415,-166.489C296.594,-163.914 316.097,-160.605 332.75,-157.78"/>
<polygon fill="black" stroke="black" points="342.686,-156.094 333.58,-162.204 337.756,-156.931 332.827,-157.767 332.827,-157.767 332.827,-157.767 337.756,-156.931 332.074,-153.33 342.686,-156.094 342.686,-156.094"/>
<text text-anchor="middle" x="312" y="-168" font-family="Times,serif" font-size="14.00">trail</text>
</g>
<!-- 82 -->
<g id="Habitat/Entrance[@roleName=&#39;K&#39;]" class="node"><title>82</title>
<ellipse fill="green" stroke="black" cx="369" cy="-216.8" rx="27" ry="18"/>
<text text-anchor="middle" x="369" y="-212.6" font-family="Courier New" font-size="14.00">K</text>
</g>
<!-- 56&#45;&gt;82 -->
<g id="Habitat_edge9" class="edge"><title>56&#45;&gt;82</title>
<path fill="none" stroke="black" d="M266.322,-187.261C276.267,-202.49 291.08,-223.417 300,-227.8 311.236,-233.321 324.654,-232.487 336.591,-229.572"/>
<polygon fill="black" stroke="black" points="346.188,-226.729 337.879,-233.884 341.394,-228.149 336.6,-229.57 336.6,-229.57 336.6,-229.57 341.394,-228.149 335.322,-225.255 346.188,-226.729 346.188,-226.729"/>
<text text-anchor="middle" x="312" y="-236" font-family="Times,serif" font-size="14.00">trail</text>
</g>
<!-- 80&#45;&gt;52 -->
<g id="Habitat_edge24" class="edge"><title>80&#45;&gt;52</title>
<path fill="none" stroke="black" d="M228.883,-234.145C222.712,-232.773 216.12,-231.32 210,-230 199.39,-227.711 187.836,-225.276 177.312,-223.081"/>
<polygon fill="black" stroke="black" points="167.206,-220.98 177.912,-218.61 172.101,-221.998 176.996,-223.016 176.996,-223.016 176.996,-223.016 172.101,-221.998 176.081,-227.421 167.206,-220.98 167.206,-220.98"/>
<text text-anchor="middle" x="198" y="-234" font-family="Times,serif" font-size="14.00">trail</text>
</g>
<!-- 60&#45;&gt;56 -->
<g id="Habitat_edge10" class="edge"><title>60&#45;&gt;56</title>
<path fill="none" stroke="black" d="M345.904,-142.16C332.428,-137.621 314.973,-134.156 300,-139 292.725,-141.354 285.642,-145.409 279.361,-149.851"/>
<polygon fill="black" stroke="black" points="271.348,-156.025 276.523,-146.357 275.309,-152.973 279.27,-149.921 279.27,-149.921 279.27,-149.921 275.309,-152.973 282.016,-153.486 271.348,-156.025 271.348,-156.025"/>
<text text-anchor="middle" x="312" y="-144" font-family="Times,serif" font-size="14.00">trail</text>
</g>
<!-- 64 -->
<g id="Habitat/MarkedLocation[@roleName=&#39;E&#39;]" class="node"><title>64</title>
<ellipse fill="#5f5f8e" stroke="black" cx="597" cy="-162.8" rx="27" ry="18"/>
<text text-anchor="middle" x="597" y="-158.6" font-family="Courier New" font-size="14.00">E</text>
</g>
<!-- 60&#45;&gt;64 -->
<g id="Habitat_edge11" class="edge"><title>60&#45;&gt;64</title>
<path fill="none" stroke="black" d="M392.31,-142.252C419.94,-131.644 468.446,-116.998 510,-125 530.081,-128.867 551.123,-138.015 567.366,-146.342"/>
<polygon fill="black" stroke="black" points="576.332,-151.104 565.39,-150.388 571.917,-148.759 567.501,-146.413 567.501,-146.413 567.501,-146.413 571.917,-148.759 569.612,-142.439 576.332,-151.104 576.332,-151.104"/>
<text text-anchor="middle" x="483" y="-130" font-family="Times,serif" font-size="14.00">trail</text>
</g>
<!-- 74 -->
<g id="Habitat/Lookout[@roleName=&#39;H&#39;]" class="node"><title>74</title>
<ellipse fill="#5f8e5f" stroke="black" cx="483" cy="-168.8" rx="27" ry="18"/>
<text text-anchor="middle" x="483" y="-164.6" font-family="Courier New" font-size="14.00">H</text>
</g>
<!-- 60&#45;&gt;74 -->
<g id="Habitat_edge12" class="edge"><title>60&#45;&gt;74</title>
<path fill="none" stroke="black" d="M395.731,-149.052C408.546,-148.3 424.209,-148.316 438,-151 442.277,-151.832 446.664,-153.08 450.933,-154.536"/>
<polygon fill="black" stroke="black" points="460.575,-158.215 449.627,-158.854 455.903,-156.433 451.232,-154.65 451.232,-154.65 451.232,-154.65 455.903,-156.433 452.836,-150.446 460.575,-158.215 460.575,-158.215"/>
<text text-anchor="middle" x="426" y="-156" font-family="Times,serif" font-size="14.00">trail</text>
</g>
<!-- 82&#45;&gt;56 -->
<g id="Habitat_edge25" class="edge"><title>82&#45;&gt;56</title>
<path fill="none" stroke="black" d="M345.643,-207.618C329.095,-200.821 306.318,-191.466 287.865,-183.887"/>
<polygon fill="black" stroke="black" points="278.396,-179.998 289.356,-179.635 283.021,-181.898 287.646,-183.797 287.646,-183.797 287.646,-183.797 283.021,-181.898 285.936,-187.96 278.396,-179.998 278.396,-179.998"/>
<text text-anchor="middle" x="312" y="-203" font-family="Times,serif" font-size="14.00">trail</text>
</g>
<!-- 64&#45;&gt;60 -->
<g id="Habitat_edge13" class="edge"><title>64&#45;&gt;60</title>
<path fill="none" stroke="black" d="M577.913,-175.533C570.241,-180.379 561.004,-185.519 552,-188.8 511.805,-203.446 498.705,-198.333 456,-195.8 437.235,-194.687 431.15,-198.497 414,-190.8 405.432,-186.955 397.34,-180.836 390.488,-174.575"/>
<polygon fill="black" stroke="black" points="383.06,-167.288 393.349,-171.079 386.629,-170.789 390.198,-174.291 390.198,-174.291 390.198,-174.291 386.629,-170.789 387.046,-177.503 383.06,-167.288 383.06,-167.288"/>
<text text-anchor="middle" x="483" y="-203" font-family="Times,serif" font-size="14.00">trail</text>
</g>
<!-- 64&#45;&gt;74 -->
<g id="Habitat_edge14" class="edge"><title>64&#45;&gt;74</title>
<path fill="none" stroke="black" d="M570.445,-166.135C564.407,-166.803 557.984,-167.417 552,-167.8 541.768,-168.455 530.654,-168.781 520.433,-168.925"/>
<polygon fill="black" stroke="black" points="510.179,-169.016 520.139,-164.427 515.179,-168.972 520.179,-168.927 520.179,-168.927 520.179,-168.927 515.179,-168.972 520.219,-173.427 510.179,-169.016 510.179,-169.016"/>
<text text-anchor="middle" x="540" y="-173" font-family="Times,serif" font-size="14.00">trail</text>
</g>
<!-- 64&#45;&gt;68 -->
<g id="Habitat_edge15" class="edge"><title>64&#45;&gt;68</title>
<path fill="none" stroke="black" d="M624.107,-160.935C642.522,-159.62 667.43,-157.841 687.767,-156.388"/>
<polygon fill="black" stroke="black" points="697.926,-155.662 688.272,-160.864 692.939,-156.019 687.952,-156.375 687.952,-156.375 687.952,-156.375 692.939,-156.019 687.631,-151.886 697.926,-155.662 697.926,-155.662"/>
<text text-anchor="middle" x="661" y="-164" font-family="Times,serif" font-size="14.00">untrail</text>
</g>
<!-- 74&#45;&gt;60 -->
<g id="Habitat_edge20" class="edge"><title>74&#45;&gt;60</title>
<path fill="none" stroke="black" d="M455.969,-170.437C443.221,-170.727 427.703,-170.318 414,-167.8 409.978,-167.061 405.837,-165.994 401.78,-164.757"/>
<polygon fill="black" stroke="black" points="391.981,-161.422 402.898,-160.385 396.715,-163.033 401.448,-164.644 401.448,-164.644 401.448,-164.644 396.715,-163.033 399.998,-168.904 391.981,-161.422 391.981,-161.422"/>
<text text-anchor="middle" x="426" y="-175" font-family="Times,serif" font-size="14.00">trail</text>
</g>
<!-- 74&#45;&gt;64 -->
<g id="Habitat_edge21" class="edge"><title>74&#45;&gt;64</title>
<path fill="none" stroke="black" d="M503.419,-156.777C510.829,-152.846 519.533,-148.982 528,-147 540.048,-144.179 553.301,-146.121 564.883,-149.476"/>
<polygon fill="black" stroke="black" points="574.557,-152.703 563.647,-153.807 569.814,-151.121 565.071,-149.538 565.071,-149.538 565.071,-149.538 569.814,-151.121 566.495,-145.27 574.557,-152.703 574.557,-152.703"/>
<text text-anchor="middle" x="540" y="-152" font-family="Times,serif" font-size="14.00">trail</text>
</g>
<!-- 68&#45;&gt;77 -->
<g id="Habitat_edge17" class="edge"><title>68&#45;&gt;77</title>
<path fill="none" stroke="black" d="M748.665,-145.013C765.558,-138.06 788.906,-127.584 808,-115.8 814.738,-111.641 821.625,-106.603 827.888,-101.661"/>
<polygon fill="black" stroke="black" points="835.972,-95.0731 831.063,-104.879 832.096,-98.232 828.22,-101.391 828.22,-101.391 828.22,-101.391 832.096,-98.232 825.377,-97.9028 835.972,-95.0731 835.972,-95.0731"/>
<text text-anchor="middle" x="789" y="-140" font-family="Times,serif" font-size="14.00">untrail</text>
</g>
<!-- 68&#45;&gt;64 -->
<g id="Habitat_edge16" class="edge"><title>68&#45;&gt;64</title>
<path fill="none" stroke="black" d="M702.521,-143.806C695.499,-141.029 687.559,-138.394 680,-137 663.391,-133.937 658.299,-132.574 642,-137 636.087,-138.606 630.157,-141.228 624.65,-144.2"/>
<polygon fill="black" stroke="black" points="615.86,-149.414 622.165,-140.442 620.16,-146.863 624.461,-144.312 624.461,-144.312 624.461,-144.312 620.16,-146.863 626.757,-148.182 615.86,-149.414 615.86,-149.414"/>
<text text-anchor="middle" x="661" y="-142" font-family="Times,serif" font-size="14.00">untrail</text>
</g>
<!-- 84 -->
<g id="Habitat/Entrance[@roleName=&#39;L&#39;]" class="node"><title>84</title>
<ellipse fill="green" stroke="black" cx="853" cy="-197.8" rx="27" ry="18"/>
<text text-anchor="middle" x="853" y="-193.6" font-family="Courier New" font-size="14.00">L</text>
</g>
<!-- 68&#45;&gt;84 -->
<g id="Habitat_edge18" class="edge"><title>68&#45;&gt;84</title>
<path fill="none" stroke="black" d="M737.907,-170.056C745.829,-179.459 757.124,-190.458 770,-195.8 784.395,-201.772 801.467,-203.004 816.298,-202.456"/>
<polygon fill="black" stroke="black" points="826.63,-201.786 816.943,-206.924 821.641,-202.11 816.651,-202.433 816.651,-202.433 816.651,-202.433 821.641,-202.11 816.36,-197.943 826.63,-201.786 826.63,-201.786"/>
<text text-anchor="middle" x="789" y="-207" font-family="Times,serif" font-size="14.00">untrail</text>
</g>
<!-- 84&#45;&gt;68 -->
<g id="Habitat_edge26" class="edge"><title>84&#45;&gt;68</title>
<path fill="none" stroke="black" d="M831.848,-186.145C824.507,-182.227 816.035,-178.075 808,-175 792.937,-169.235 775.728,-164.518 760.978,-161.01"/>
<polygon fill="black" stroke="black" points="751.215,-158.776 761.967,-156.62 756.089,-159.891 760.963,-161.006 760.963,-161.006 760.963,-161.006 756.089,-159.891 759.959,-165.393 751.215,-158.776 751.215,-158.776"/>
<text text-anchor="middle" x="789" y="-180" font-family="Times,serif" font-size="14.00">untrail</text>
</g>
</g>
</svg>

<svg width="888pt" height="298pt"
 viewBox="0.00 0.00 888.00 297.60" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
<g id="Testing" class="graph" transform="scale(1 1) rotate(0) translate(4 293.6)">
<title>132</title>
<polygon fill="white" stroke="none" points="-4,4 -4,-293.6 884,-293.6 884,4 -4,4"/>
<text text-anchor="middle" x="440" y="-8.2" font-family="Courier New" font-size="14.00">test03</text>
<!-- 133 -->
<g id="Testing/MarkedLocation[@roleName=&#39;A&#39;]" class="node"><title>133</title>
<ellipse fill="#5f5f8e" stroke="black" cx="27" cy="-113.8" rx="27" ry="18"/>
<text text-anchor="middle" x="27" y="-109.6" font-family="Courier New" font-size="14.00">A</text>
</g>
<!-- 137 -->
<g id="Testing/MarkedLocation[@roleName=&#39;B&#39;]" class="node"><title>137</title>
<ellipse fill="#5f5f8e" stroke="black" cx="141" cy="-202.8" rx="27" ry="18"/>
<text text-anchor="middle" x="141" y="-198.6" font-family="Courier New" font-size="14.00">B</text>
</g>
<!-- 133&#45;&gt;137 -->
<g id="Testing_edge1" class="edge"><title>133&#45;&gt;137</title>
<path fill="none" stroke="black" d="M35.2719,-131.046C42.4958,-146.201 54.9564,-167.808 72,-180.8 81.444,-187.999 93.3303,-192.89 104.513,-196.193"/>
<polygon fill="black" stroke="black" points="114.495,-198.8 103.682,-200.626 109.657,-197.536 104.819,-196.273 104.819,-196.273 104.819,-196.273 109.657,-197.536 105.957,-191.919 114.495,-198.8 114.495,-198.8"/>
<text text-anchor="middle" x="84" y="-197" font-family="Times,serif" font-size="14.00">trail</text>
</g>
<!-- 162 -->
<g id="Testing/Building" class="node"><title>162</title>
<ellipse fill="orange" stroke="black" cx="853" cy="-145.8" rx="27" ry="18"/>
<text text-anchor="middle" x="853" y="-141.6" font-family="Courier New" font-size="14.00">I</text>
</g>
<!-- 133&#45;&gt;162 -->
<g id="Testing_edge2" class="edge"><title>133&#45;&gt;162</title>
<path fill="none" stroke="black" d="M52.7661,-119.396C75.3655,-124.01 109.752,-129.8 140,-129.8 140,-129.8 140,-129.8 726,-129.8 756.871,-129.8 791.66,-134.585 816.849,-138.922"/>
<polygon fill="black" stroke="black" points="827.017,-140.738 816.382,-143.409 822.095,-139.858 817.173,-138.979 817.173,-138.979 817.173,-138.979 822.095,-139.858 817.964,-134.55 827.017,-140.738 827.017,-140.738"/>
<text text-anchor="middle" x="426" y="-134" font-family="Times,serif" font-size="14.00">trail</text>
</g>
<!-- 157 -->
<g id="Testing/Lookout[@roleName=&#39;G&#39;]" class="node"><title>157</title>
<ellipse fill="#5f8e5f" stroke="black" cx="141" cy="-76.8" rx="27" ry="18"/>
<text text-anchor="middle" x="141" y="-72.6" font-family="Courier New" font-size="14.00">G</text>
</g>
<!-- 133&#45;&gt;157 -->
<g id="Testing_edge3" class="edge"><title>133&#45;&gt;157</title>
<path fill="none" stroke="black" d="M51.7356,-105.773C58.2964,-103.566 65.4208,-101.18 72,-99 83.2817,-95.2611 95.6318,-91.2151 106.675,-87.6142"/>
<polygon fill="black" stroke="black" points="116.381,-84.4539 108.265,-91.8289 111.626,-86.002 106.872,-87.5501 106.872,-87.5501 106.872,-87.5501 111.626,-86.002 105.479,-83.2712 116.381,-84.4539 116.381,-84.4539"/>
<text text-anchor="middle" x="84" y="-104" font-family="Times,serif" font-size="14.00">trail</text>
</g>
<!-- 137&#45;&gt;133 -->
<g id="Testing_edge4" class="edge"><title>137&#45;&gt;133</title>
<path fill="none" stroke="black" d="M125.534,-187.464C117.227,-178.987 106.406,-168.487 96,-160 83.4508,-149.765 68.668,-139.527 56.0965,-131.3"/>
<polygon fill="black" stroke="black" points="47.397,-125.693 58.2403,-127.328 51.5997,-128.402 55.8025,-131.11 55.8025,-131.11 55.8025,-131.11 51.5997,-128.402 53.3646,-134.893 47.397,-125.693 47.397,-125.693"/>
<text text-anchor="middle" x="84" y="-165" font-family="Times,serif" font-size="14.00">trail</text>
</g>
<!-- 141 -->
<g id="Testing/MarkedLocation[@roleName=&#39;C&#39;]" class="node"><title>141</title>
<ellipse fill="#5f5f8e" stroke="black" cx="255" cy="-202.8" rx="27" ry="18"/>
<text text-anchor="middle" x="255" y="-198.6" font-family="Courier New" font-size="14.00">C</text>
</g>
<!-- 137&#45;&gt;141 -->
<g id="Testing_edge5" class="edge"><title>137&#45;&gt;141</title>
<path fill="none" stroke="black" d="M168.259,-202.8C183.004,-202.8 201.623,-202.8 217.741,-202.8"/>
<polygon fill="black" stroke="black" points="227.905,-202.8 217.906,-207.3 222.905,-202.8 217.905,-202.8 217.905,-202.8 217.905,-202.8 222.905,-202.8 217.905,-198.3 227.905,-202.8 227.905,-202.8"/>
<text text-anchor="middle" x="198" y="-207" font-family="Times,serif" font-size="14.00">trail</text>
</g>
<!-- 165 -->
<g id="Testing/Entrance[@roleName=&#39;J&#39;]" class="node"><title>165</title>
<ellipse fill="green" stroke="black" cx="255" cy="-269.8" rx="27" ry="18"/>
<text text-anchor="middle" x="255" y="-265.6" font-family="Courier New" font-size="14.00">J</text>
</g>
<!-- 137&#45;&gt;165 -->
<g id="Testing_edge6" class="edge"><title>137&#45;&gt;165</title>
<path fill="none" stroke="black" d="M150.102,-219.766C157.486,-233.238 169.72,-251.333 186,-260.8 195.518,-266.334 207.03,-269.045 217.854,-270.25"/>
<polygon fill="black" stroke="black" points="227.934,-270.987 217.633,-274.746 222.948,-270.622 217.961,-270.258 217.961,-270.258 217.961,-270.258 222.948,-270.622 218.289,-265.77 227.934,-270.987 227.934,-270.987"/>
<text text-anchor="middle" x="198" y="-273" font-family="Times,serif" font-size="14.00">trail</text>
</g>
<!-- 162&#45;&gt;133 -->
<g id="Testing_edge23" class="edge"><title>162&#45;&gt;133</title>
<path fill="none" stroke="black" d="M844.149,-128.72C827.507,-95.3666 785.292,-24.8 726,-24.8 140,-24.8 140,-24.8 140,-24.8 98.7197,-24.8 63.8303,-62.3171 44.4344,-88.6345"/>
<polygon fill="black" stroke="black" points="38.4637,-97.0598 40.5741,-86.2989 41.3547,-92.9803 44.2457,-88.9008 44.2457,-88.9008 44.2457,-88.9008 41.3547,-92.9803 47.9172,-91.5026 38.4637,-97.0598 38.4637,-97.0598"/>
<text text-anchor="middle" x="426" y="-29" font-family="Times,serif" font-size="14.00">trail</text>
</g>
<!-- 153 -->
<g id="Testing/UnmarkedLocation" class="node"><title>153</title>
<ellipse fill="#8e5f5f" stroke="black" cx="725" cy="-219.8" rx="27" ry="18"/>
<text text-anchor="middle" x="725" y="-215.6" font-family="Courier New" font-size="14.00">F</text>
</g>
<!-- 162&#45;&gt;153 -->
<g id="Testing_edge22" class="edge"><title>162&#45;&gt;153</title>
<path fill="none" stroke="black" d="M825.854,-145.421C808.809,-146.302 786.711,-149.663 770,-160 756.897,-168.105 746.438,-181.678 739.01,-193.847"/>
<polygon fill="black" stroke="black" points="733.927,-202.764 734.969,-191.848 736.403,-198.42 738.879,-194.076 738.879,-194.076 738.879,-194.076 736.403,-198.42 742.788,-196.305 733.927,-202.764 733.927,-202.764"/>
<text text-anchor="middle" x="789" y="-165" font-family="Times,serif" font-size="14.00">untrail</text>
</g>
<!-- 157&#45;&gt;133 -->
<g id="Testing_edge19" class="edge"><title>157&#45;&gt;133</title>
<path fill="none" stroke="black" d="M116.222,-69.5528C102.786,-66.721 85.9415,-65.3378 72,-71 62.2839,-74.9461 53.5359,-82.1827 46.4475,-89.597"/>
<polygon fill="black" stroke="black" points="39.4399,-97.5647 42.665,-87.0838 42.742,-93.8102 46.0441,-90.0557 46.0441,-90.0557 46.0441,-90.0557 42.742,-93.8102 49.4231,-93.0276 39.4399,-97.5647 39.4399,-97.5647"/>
<text text-anchor="middle" x="84" y="-76" font-family="Times,serif" font-size="14.00">trail</text>
</g>
<!-- 141&#45;&gt;137 -->
<g id="Testing_edge7" class="edge"><title>141&#45;&gt;137</title>
<path fill="none" stroke="black" d="M234.081,-191.103C226.762,-187.429 218.244,-183.85 210,-182 199.592,-179.664 196.408,-179.664 186,-182 181.105,-183.099 176.114,-184.807 171.334,-186.782"/>
<polygon fill="black" stroke="black" points="161.919,-191.103 169.131,-182.842 166.464,-189.018 171.008,-186.932 171.008,-186.932 171.008,-186.932 166.464,-189.018 172.885,-191.022 161.919,-191.103 161.919,-191.103"/>
<text text-anchor="middle" x="198" y="-187" font-family="Times,serif" font-size="14.00">trail</text>
</g>
<!-- 145 -->
<g id="Testing/MarkedLocation[@roleName=&#39;D&#39;]" class="node"><title>145</title>
<ellipse fill="#5f5f8e" stroke="black" cx="369" cy="-239.8" rx="27" ry="18"/>
<text text-anchor="middle" x="369" y="-235.6" font-family="Courier New" font-size="14.00">D</text>
</g>
<!-- 141&#45;&gt;145 -->
<g id="Testing_edge8" class="edge"><title>141&#45;&gt;145</title>
<path fill="none" stroke="black" d="M281.64,-206.456C294.572,-208.723 310.366,-212.147 324,-217 329.038,-218.793 334.223,-221.06 339.188,-223.464"/>
<polygon fill="black" stroke="black" points="348.364,-228.169 337.413,-227.611 343.915,-225.888 339.466,-223.607 339.466,-223.607 339.466,-223.607 343.915,-225.888 341.519,-219.602 348.364,-228.169 348.364,-228.169"/>
<text text-anchor="middle" x="312" y="-221" font-family="Times,serif" font-size="14.00">trail</text>
</g>
<!-- 167 -->
<g id="Testing/Entrance[@roleName=&#39;K&#39;]" class="node"><title>167</title>
<ellipse fill="green" stroke="black" cx="369" cy="-175.8" rx="27" ry="18"/>
<text text-anchor="middle" x="369" y="-171.6" font-family="Courier New" font-size="14.00">K</text>
</g>
<!-- 141&#45;&gt;167 -->
<g id="Testing_edge9" class="edge"><title>141&#45;&gt;167</title>
<path fill="none" stroke="black" d="M273.883,-189.496C281.523,-184.584 290.793,-179.588 300,-177 310.145,-174.149 321.481,-173.14 331.945,-173.035"/>
<polygon fill="black" stroke="black" points="342.042,-173.197 331.971,-177.536 337.042,-173.117 332.043,-173.036 332.043,-173.036 332.043,-173.036 337.042,-173.117 332.115,-168.537 342.042,-173.197 342.042,-173.197"/>
<text text-anchor="middle" x="312" y="-182" font-family="Times,serif" font-size="14.00">trail</text>
</g>
<!-- 165&#45;&gt;137 -->
<g id="Testing_edge24" class="edge"><title>165&#45;&gt;137</title>
<path fill="none" stroke="black" d="M235.843,-256.936C228.005,-251.532 218.663,-245.287 210,-240 197.764,-232.533 183.937,-224.839 171.962,-218.4"/>
<polygon fill="black" stroke="black" points="162.821,-213.533 173.763,-214.26 167.234,-215.883 171.648,-218.233 171.648,-218.233 171.648,-218.233 167.234,-215.883 169.533,-222.205 162.821,-213.533 162.821,-213.533"/>
<text text-anchor="middle" x="198" y="-244" font-family="Times,serif" font-size="14.00">trail</text>
</g>
<!-- 145&#45;&gt;141 -->
<g id="Testing_edge10" class="edge"><title>145&#45;&gt;141</title>
<path fill="none" stroke="black" d="M341.799,-240.649C328.868,-240.285 313.244,-238.648 300,-233.8 293.161,-231.297 286.408,-227.444 280.322,-223.296"/>
<polygon fill="black" stroke="black" points="271.952,-217.13 282.672,-219.438 275.978,-220.096 280.003,-223.061 280.003,-223.061 280.003,-223.061 275.978,-220.096 277.334,-226.684 271.952,-217.13 271.952,-217.13"/>
<text text-anchor="middle" x="312" y="-243" font-family="Times,serif" font-size="14.00">trail</text>
</g>
<!-- 149 -->
<g id="Testing/MarkedLocation[@roleName=&#39;E&#39;]" class="node"><title>149</title>
<ellipse fill="#5f5f8e" stroke="black" cx="597" cy="-232.8" rx="27" ry="18"/>
<text text-anchor="middle" x="597" y="-228.6" font-family="Courier New" font-size="14.00">E</text>
</g>
<!-- 145&#45;&gt;149 -->
<g id="Testing_edge11" class="edge"><title>145&#45;&gt;149</title>
<path fill="none" stroke="black" d="M389.291,-227.902C406.177,-218.229 431.739,-205.342 456,-200 479.439,-194.839 486.387,-195.705 510,-200 529.622,-203.569 533.365,-208.695 552,-215.8 555.766,-217.236 559.711,-218.748 563.626,-220.254"/>
<polygon fill="black" stroke="black" points="573.178,-223.938 562.229,-224.538 568.513,-222.139 563.848,-220.34 563.848,-220.34 563.848,-220.34 568.513,-222.139 565.467,-216.141 573.178,-223.938 573.178,-223.938"/>
<text text-anchor="middle" x="483" y="-205" font-family="Times,serif" font-size="14.00">trail</text>
</g>
<!-- 159 -->
<g id="Testing/Lookout[@roleName=&#39;H&#39;]" class="node"><title>159</title>
<ellipse fill="#5f8e5f" stroke="black" cx="483" cy="-243.8" rx="27" ry="18"/>
<text text-anchor="middle" x="483" y="-239.6" font-family="Courier New" font-size="14.00">H</text>
</g>
<!-- 145&#45;&gt;159 -->
<g id="Testing_edge12" class="edge"><title>145&#45;&gt;159</title>
<path fill="none" stroke="black" d="M392.649,-230.691C405.865,-226.505 422.865,-223.055 438,-226 442.277,-226.832 446.664,-228.08 450.933,-229.536"/>
<polygon fill="black" stroke="black" points="460.575,-233.215 449.627,-233.854 455.903,-231.433 451.232,-229.65 451.232,-229.65 451.232,-229.65 455.903,-231.433 452.836,-225.446 460.575,-233.215 460.575,-233.215"/>
<text text-anchor="middle" x="426" y="-230" font-family="Times,serif" font-size="14.00">trail</text>
</g>
<!-- 149&#45;&gt;145 -->
<g id="Testing_edge14" class="edge"><title>149&#45;&gt;145</title>
<path fill="none" stroke="black" d="M579.912,-246.781C572.002,-252.934 562.028,-259.684 552,-263.8 534.493,-270.985 528.86,-269.239 510,-270.8 467.331,-274.331 454.435,-276.874 414,-262.8 408.94,-261.039 403.743,-258.777 398.775,-256.362"/>
<polygon fill="black" stroke="black" points="389.597,-251.618 400.546,-252.212 394.038,-253.914 398.48,-256.209 398.48,-256.209 398.48,-256.209 394.038,-253.914 396.414,-260.207 389.597,-251.618 389.597,-251.618"/>
<text text-anchor="middle" x="483" y="-277" font-family="Times,serif" font-size="14.00">trail</text>
</g>
<!-- 149&#45;&gt;159 -->
<g id="Testing_edge15" class="edge"><title>149&#45;&gt;159</title>
<path fill="none" stroke="black" d="M571.491,-239.322C565.185,-240.737 558.378,-242.037 552,-242.8 541.82,-244.018 530.722,-244.525 520.501,-244.663"/>
<polygon fill="black" stroke="black" points="510.241,-244.687 520.23,-240.163 515.241,-244.675 520.241,-244.663 520.241,-244.663 520.241,-244.663 515.241,-244.675 520.252,-249.163 510.241,-244.687 510.241,-244.687"/>
<text text-anchor="middle" x="540" y="-248" font-family="Times,serif" font-size="14.00">trail</text>
</g>
<!-- 149&#45;&gt;153 -->
<g id="Testing_edge13" class="edge"><title>149&#45;&gt;153</title>
<path fill="none" stroke="black" d="M623.802,-230.138C642.318,-228.228 667.512,-225.628 688.005,-223.514"/>
<polygon fill="black" stroke="black" points="698.232,-222.459 688.747,-227.961 693.259,-222.972 688.285,-223.485 688.285,-223.485 688.285,-223.485 693.259,-222.972 687.823,-219.009 698.232,-222.459 698.232,-222.459"/>
<text text-anchor="middle" x="661" y="-232" font-family="Times,serif" font-size="14.00">untrail</text>
</g>
<!-- 159&#45;&gt;145 -->
<g id="Testing_edge20" class="edge"><title>159&#45;&gt;145</title>
<path fill="none" stroke="black" d="M455.835,-243.741C443.192,-243.63 427.802,-243.372 414,-242.8 411.456,-242.695 408.831,-242.566 406.189,-242.422"/>
<polygon fill="black" stroke="black" points="396.046,-241.807 406.3,-237.921 401.036,-242.11 406.027,-242.412 406.027,-242.412 406.027,-242.412 401.036,-242.11 405.755,-246.904 396.046,-241.807 396.046,-241.807"/>
<text text-anchor="middle" x="426" y="-247" font-family="Times,serif" font-size="14.00">trail</text>
</g>
<!-- 159&#45;&gt;149 -->
<g id="Testing_edge21" class="edge"><title>159&#45;&gt;149</title>
<path fill="none" stroke="black" d="M503.419,-231.777C510.829,-227.846 519.533,-223.982 528,-222 539.317,-219.35 551.847,-220.271 563.036,-222.433"/>
<polygon fill="black" stroke="black" points="572.861,-224.7 562.106,-226.837 567.989,-223.576 563.117,-222.452 563.117,-222.452 563.117,-222.452 567.989,-223.576 564.129,-218.067 572.861,-224.7 572.861,-224.7"/>
<text text-anchor="middle" x="540" y="-226" font-family="Times,serif" font-size="14.00">trail</text>
</g>
<!-- 153&#45;&gt;162 -->
<g id="Testing_edge17" class="edge"><title>153&#45;&gt;162</title>
<path fill="none" stroke="black" d="M748.648,-210.688C765.531,-203.506 788.876,-192.735 808,-180.8 814.718,-176.608 821.596,-171.557 827.859,-166.614"/>
<polygon fill="black" stroke="black" points="835.945,-160.03 831.032,-169.834 832.068,-163.187 828.191,-166.344 828.191,-166.344 828.191,-166.344 832.068,-163.187 825.349,-162.855 835.945,-160.03 835.945,-160.03"/>
<text text-anchor="middle" x="789" y="-205" font-family="Times,serif" font-size="14.00">untrail</text>
</g>
<!-- 153&#45;&gt;149 -->
<g id="Testing_edge16" class="edge"><title>153&#45;&gt;149</title>
<path fill="none" stroke="black" d="M702.482,-209.578C685.776,-203.031 662.145,-196.82 642,-203 635.126,-205.109 628.359,-208.696 622.271,-212.665"/>
<polygon fill="black" stroke="black" points="613.905,-218.627 619.437,-209.159 617.977,-215.725 622.049,-212.824 622.049,-212.824 622.049,-212.824 617.977,-215.725 624.66,-216.488 613.905,-218.627 613.905,-218.627"/>
<text text-anchor="middle" x="661" y="-207" font-family="Times,serif" font-size="14.00">untrail</text>
</g>
<!-- 169 -->
<g id="Testing/Entrance[@roleName=&#39;L&#39;]" class="node"><title>169</title>
<ellipse fill="green" stroke="black" cx="853" cy="-262.8" rx="27" ry="18"/>
<text text-anchor="middle" x="853" y="-258.6" font-family="Courier New" font-size="14.00">L</text>
</g>
<!-- 153&#45;&gt;169 -->
<g id="Testing_edge18" class="edge"><title>153&#45;&gt;169</title>
<path fill="none" stroke="black" d="M737.987,-235.676C745.939,-244.857 757.238,-255.595 770,-260.8 784.324,-266.642 801.257,-267.886 816.006,-267.383"/>
<polygon fill="black" stroke="black" points="826.29,-266.748 816.587,-271.855 821.3,-267.056 816.309,-267.364 816.309,-267.364 816.309,-267.364 821.3,-267.056 816.032,-262.872 826.29,-266.748 826.29,-266.748"/>
<text text-anchor="middle" x="789" y="-271" font-family="Times,serif" font-size="14.00">untrail</text>
</g>
<!-- 169&#45;&gt;153 -->
<g id="Testing_edge25" class="edge"><title>169&#45;&gt;153</title>
<path fill="none" stroke="black" d="M831.867,-251.094C824.528,-247.171 816.053,-243.029 808,-240 793.093,-234.392 776.071,-229.906 761.414,-226.6"/>
<polygon fill="black" stroke="black" points="751.224,-224.402 761.948,-222.111 756.111,-225.456 760.999,-226.51 760.999,-226.51 760.999,-226.51 756.111,-225.456 760.05,-230.909 751.224,-224.402 751.224,-224.402"/>
<text text-anchor="middle" x="789" y="-244" font-family="Times,serif" font-size="14.00">untrail</text>
</g>
</g>
</svg>
]]></Attribute_String><Attribute_String roleName="setup">${MODELNAME_DEFAULT},${SVGURI_DEFAULT}</Attribute_String></SvgClient>

</XholonWorkbook>