Java StarLogo
1.1
`turtle`

to setup-turtle

  ifelse breed = whittler
  [
    setc cyan
  ]
  [
    setc pink ;; still looks red on my screen
  ]
  seth random 360
  jump random ( screen-height + screen-width )

end

to run-turtle

  ifelse breed = whittler
  [
    make-some-shavings
  ]
  [
    move-some-shavings
  ]

end

to make-some-shavings
  loop
  [
    check-shavings-supply
    ifelse sober [wiggle] [drunk-walk]
  ]
end

to check-shavings-supply
  if ( precision > ( random whittle-random-range ) )
  [
    ifelse ( 0 = ( count-pc yellow ) ) ;; do we see any shavings?
    [
      stamp yellow  ;; no, so drop a shaving
      settotal-shavings (total-shavings + 1)
      ifelse ( total-shavings mod 2 ) = 0  ;; every other shaving dropped
      [st setvisible true]                 ;; watch shavings _and_ ants
      [ht setvisible false]                ;; just watch shavings
      write-log                            ;; stats to output window
      if total-shavings > number
      [
        set-whittle-random-range
        st setvisible true
        die ;; we can never drop another shaving,
            ;; there are more shavings than ants,
            ;; there will always be a shaving visible,
      ]     ;; why go on living a futile existence?
    ]
    [
      setcheck-shavings-successes ( check-shavings-successes + 1 )
    ]
    setcheck-shavings-tries ( check-shavings-tries + 1 )
    set-whittle-random-range  ;; this is self adjusting with every shaving
  ]
  ifelse visible [st] [ht] ;; respond to external toggles as well as my own
end

to move-some-shavings
  loop  ;; let turtle color store a cheap state so we can simplify the
        ;; conceptual model
  [
    if color = pink    [ search-for-shaving ]  ;; not-carrying, on open area  : find a wood shaving and pick it up
    if color = green   [ find-a-new-pile    ]  ;; carrying, on open area      : find a pile of wood shavings
    if color = magenta [ find-empty-spot    ]  ;; carrying, on pile           : find an empty spot and put it down
    if color = blue    [ bragged-a-bit      ]  ;; ready to drop on open spot  : need to avoid collisions here!  Two drops same spot = lost chip!
    if color = brown   [ find-a-new-start   ]  ;; not carrying, on pile       : find an empty spot to restart search
    ;; check if I'm at the correct visibility
    ifelse visible [st] [ht]
  ]
end

to search-for-shaving  ;; I am color pink, the state of not carrying a shaving,
                       ;; and looking for a shaving

  ifelse pc = yellow   ;; if find a wood shaving...
  [
    stamp black     ;; remove wood shaving from patch
    setc green      ;; change color while carrying shaving on open area
    wait-a-bit

    ;; insisting on landing on an empty patch here instead of a simple
    ;; random teleport makes the application fail completely.  the ant
    ;; _must_ have a chance to jump into a pile [from which it just
    ;; stole a shaving, or another]; this is how the piles become round
    ;; instead of fractal.

    teleport  ;; go somewhere random to start my quest for a pile at which
              ;; to drop my shaving [this is kind of artificial; would a
              ;; single drunk-walk step work almost as well, just slower?]

    if pc = yellow
    [
      setc magenta ;; I landed on a pile, change color and state
      wait-a-bit
    ]
  ]
  [
    wiggle
  ]

end

to find-a-new-pile  ;; I am colored green, the state of carrying a shaving,
                    ;; and seeking a shaving next to which to drop it.

  ifelse pc = yellow ;; Did I just step on a shaving?
  [
    setc magenta   ;; Now carrying and on a pile, change color and state
    wait-a-bit
  ]
  [
    aim ;; still looking for a pile, keep color and state
  ]

end

to find-empty-spot   ;; I am colored magenta, the state of carrying a shaving
                     ;; and seeking an empty patch on which to drop it.

  ifelse pc = black  ;; Did I just step on an empty patch?
  [
    setc blue        ;; Tentative success, we are ready to show off.
    wait-a-bit       ;; Show off a bit; we just did our job
  ]
  [
    ifelse ( 199999 > random (200000 + density) ) ;; Have I been trying
                                                  ;; too long?

    ;; Break out of the middle of large piles "eventually",
    ;; so that they don't capture "all" the termites, leaving
    ;; the dark areas nearly uninhabited.

    ;; These odds have to be really lopsided, or the shaving
    ;; carriers and shaving seekers wandering in the dark are
    ;; almost in balance, and consumption of stray specks
    ;; seems to take "forever".  There is also a need to
    ;; correct for shaving density, because denser shavings leave
    ;; fewer dark places for burdened termites to alight
    ;; when they teleport.
    [
      drunk-walk ;; keep trying to find my way out unassisted
    ]
    [
      teleport      ;; bail
      wait-a-bit    ;; Be visible for a bit as a success example
                    ;; in case I land on an empty patch, or as a failure
                    ;; example in case I land on a shaving; this is
                    ;; the only visibility pause not always accompanied
                    ;; by a state change.

      if ( pc = black )
      [
        setc green ;; We landed on an empty spot alright,
        wait-a-bit ;; but we are still carrying a shaving, and we do not
		   ;; know that we are next to a pile, so we need to
		   ;; find a pile all over again.  Set color green and
		   ;; thus state back to carrying and seeking a pile.
      ]
    ]
  ]
end

to bragged-a-bit     ;; We may have lost our chance to drop our shaving
                     ;; in all our gloating, better check!

  ifelse patchcolor = black
  [
    stamp yellow     ;; Put down wood shaving in patch
    setc brown       ;; Set own color to brown, we are empty-mandibled;
                     ;; time to find a new start.
  ]
  [
    setc magenta     ;; Some rotter beat us to it, now we're on yellow
                     ;; and still carrying a shaving; change state
                     ;; appropriately!
  ]
  wait-a-bit

end

to find-a-new-start  ;; I am colored brown, the state of not carrying a
                     ;; shaving  and looking for an empty spot to begin
                     ;; my search for one to carry.
  teleport
  wait-a-bit         ;; Mourn a bit that I'm not helping the colony just
                     ;; now, for visibility to the user.
  if pc = black
  [
    setc pink   ;; Found an empty spot, ready to go back to search mode.
    wait-a-bit  ;; Show off my transition for a moment.
  ]
end

to aim          ;; Do a usually straighter form of wiggle.
  fd 1
  ifelse ( 999 > random 1000 )
  [
    rt random 50
    lt random 50
  ]
  [
    rt random 5
    lt random 5
  ]
end

to wiggle
  fd 1
  rt random 50
  lt random 50
end

to teleport
  seth random 360
  jump random (screen-height + screen-width)
end

to drunk-walk
  seth random 360
  fd 1
end

to precision
  output 10000
end

to set-whittle-random-range
  setwhittle-random-range (
                            precision
                            +
                            int
                            (
                              (
                                screen-height
                                *
                                screen-width
                                *
                                (
                                  (
                                    1
                                    +
                                    check-shavings-successes
                                  )
                                  / 
                                  (
                                    1
                                    +
                                    check-shavings-tries
                                    -
                                    check-shavings-successes
                                  )
                                )
                                *
                                precision
                              )
                              /
                              number
                            )
                          )
end

to wait-a-bit
  if pause [ wait 1 ]
end


to write-log
  print to-string [ total-shavings
                    " shavings exist, seen / gone / tallied "
                    check-shavings-successes
                    " / "
                    ( check-shavings-tries - check-shavings-successes )
                    " / "
                    check-shavings-tries 
                    " times, now averaging "
                    ( whittle-random-range / precision )
                    " turns per whittle try"
                  ]
end

`observer`

globals [ total-shavings
  whittle-random-range
  check-shavings-successes
  check-shavings-tries
  pause
  visible
  sober
]

breeds [
  ants
  whittler
]

to setup

  ca

  setpause true

  setvisible true

  setsober true

  settotal-shavings 0

  ask-patches  [ if ( random 100 ) < density [ setpc yellow ] ]

  create-turtles-and-do     number [ setbreed ants ]

  ;; only create a whittler, and do all the setup work involved,
  ;; if there can ever be a chance to whittle

  settotal-shavings           count-pc  yellow 

  if ( number > total-shavings )
  [
    create-turtles-and-do       1         [ setbreed whittler ]
    setcheck-shavings-successes 1
    setcheck-shavings-tries     1
    ask-whittler [ set-whittle-random-range ]
  ]

  ask-turtles [ setup-turtle ]

end

to toggle-visible
  ifelse visible
  [setvisible false]
  [setvisible true ]
end

to toggle-pause
  ifelse pause 
  [ setpause false ]
  [ setpause true ]
end


to toggle-sober
  ifelse sober 
  [ setsober false ]
  [ setsober true ]
end

to go
  ask-turtles [run-turtle]
end

`information`
;;;;;;;;;;;;;;;;
;; TWhatAC.slogo
;;;;;;;;;;;;;;;;

[Pronounced

  twaah tack
  
and not

  't what a sea  

just FYI]

This is a heavily revised version of the TERMiTES.slogo program that
comes as a demo with StarLogo for Java from MIT.

It is so heavily changed it needed a new name: TWhatAC, a barely
pronouncable acronym for "The Whittler and the Ant Colony".  The
TERMiTES program has a sneaky infinite loop state: what if you have
many more termites than chips, and the termites pick up all the chips
at once?  Then there is no pile left beside which to drop a chip, and
the demo loops forever.  I saw a great need for a program with a
producer of shavings (vice chips), to handle this case, and so appears
a second breed of turtle, the solitary whittler.

[ Of course, making this change worstened another even harder to find
infinite loop condition.  Finding it is left as a student exercise. ]

This one change turns out to change profoundly the entire behavior of
the demo, because now, for example, one can start with zero density or
very low density of shavings, and let the whittler carve sloppily away
to provide the ants' objects of attention.

As the total number of shavings in circulation increases, there is a
state at which the pile of shavings vanishes and reappears, and in
between writhes across the display area (in large patch, small
screen-height and screen width cases, at least) like something alive,
instead of standing still like a more respectable pile of termite-borne
chips would have done.

There is also a very delicate "edge-of-chaos"y balance being sought
between the whittler, who is very lazy and only drops a shaving when
there isn't one is sight, and the ants, who can only manage to play the
old hidden shavings trick for so long before one pile or several piles
start to appear, twinkling like stars.

To add to the confusion, I simplified the very difficult to understand
interaction between breeds of turtle and the functioning of the ask
turtles command.  This version uses no "stop" statements, does no
recursion, and only needs the ask-turtles command to kick off the
threads, not to keep them going over and over, which didn't work at all
well when the stopping of the ants interfered with the running of the
whittler, and vice versa.

This gets paid for by the added complexity of breeds, and by some
avoidable global variables I added just to control the rate at which
the quite expensive operation of counting patches colored yellow is
performed; with small patches and a large patch area, this is a real
necessity.

I also made the ant states, which were implicit by which of the three
main loops the ant was executing, explicit, and encoded them in the
color of the ant, which was both cheaper than a new variable, and gives
the added joy of letting the user understand better what each ant is
trying to accomplish.

For the teleporting cases, the ants at the speed of a modern machine
were effectively invisible, so I added some brief wait states to the
ants when they make certain transitions, to let the user notice that a
special situation has occurred.  This can look fairly clunky at the
beginning of a run, when all the ants wait in synch, but fairly soon it
randomizes to look smoother.

For providing even a little more confusion to the new user, and a great
test for tendencies to epilepsy, every time the whittler drops a
shaving, the ants' visibility state changes.

This is done to allow the user to see both how the ants march through
their states, and also how the shavings pile develops over time, since
a number of ants larger than the number of shavings pretty much obscure
the shavings piles otherwise.

If the initial number of shavings is larger than the number of ants,
there can never be a situation where the whittler can drop a shaving,
so the whittler part of the demo is turned off.

For very, very small numbers of ants, I've seen it happen with seven,
the ants may manage to each be carrying a shaving, allowing the
whittler to drop that one extra shaving that makes a whittler
superfluous, and the whittler promptly dies of embarrassment, disabling
the visibility shifts in the show turtle mode.

The weighting for the whittler's checks for shavings on the patchs is
very heavily influenced by success at finding none, so over time the
whittler tries less and less often to drop a shaving, which is just
fine, since it is harder and harder for the ants to pick them all up at
once.  If they do, though, they will remain carriers until the whittler
checks and drops another shaving, so no chance is lost by these longer
delays, just fewer expensive calls to count patch colors get made.

There is a lot of probability intuition to be gained by watching the
output window; starting from zero density, 250 ants on a 123 x 123
patch screen have an almost impossible time convincing the whittler to
produce 150 shavings.  This lack of overt cooperation is one example of
what makes this demo an emergent behavior demo, where simple rules
cause complex behavior.

All together, I think it is a lot more fun demo this way, and it verges
on becoming agent software a teeny bit as well.  Try it with big fat
patches and also with tiny ones in profusion, the behavior changes
modestly with size of arena as well as number of participants and
density of shavings.

Since I stole it myself, freeware, as before, of course; enjoy!

;;;;;;;;;;;
;; Controls
;;;;;;;;;;;

Slider Number of Ants allows control of the number of ants from 1 to
500; in non-whittler situations, the number of ants doesn't matter to
the task completion time nearly as much as one might expect; the lesser
number of ants just run faster with a bigger share of the processing
cycles.

Slider Shavings Density allows control of the average shavings density
in whole percents from 0 to 99.  Use very low or zero percents to
enable whittler mode.

Button setup is the standard StarLogo setup button, used to provide
values to state variable and set the "turtles" (ants and whittler) and
the shavings (patch colors) on the patch screen.

Button go starts the demo running.

Button "ants visible / invisible" changes the visibility of the ants
and the whittler.  In whittler mode, the whittler also has control of
the visibility, so do not be surprised to be engaged in a struggle for
power.  In non-whittler mode, as in any Logo program, hiding the
"turtles" makes the program run (much) faster.

Button "state change pause yes / no" toggles the pauses to show you
what is going on when the ants change state.  Without the pauses, on
modern hardware, things are moving too fast to comprehend; with them,
things are running too slow to bear.  The pauses work better late in
the demo, when shavings are consolidated in a few piles and the empty
patches are also consolidated, so that most of the ants are wandering
around rather than changing state frequently.

Button "whittler sober / drunk" is mostly just for fun.  It changes the
whittler motion from a headlong flight to a drunkard's walk.  The
latter is much easier to track by eye, but since the patch surface is
mathematically a torus, it makes little difference if the whittler
drops the only shaving on a patch close to the drop point of the last
one or far from it, so long as the ants have had a chance to randomize
their locations again.  All patches are "in the middle".

;;;;;;;;;;;
;; Concepts
;;;;;;;;;;;

How does the demo illustrate "emergent behavior"?

While there is a _lot_ of code added to avoid obnoxious behavior, there
is nothing that says "pile up all the shavings in a single pile and
make it round", just "pick up a shaving and set it in an empty patch
next to another shaving", yet the latter simple rule leads to the
former complex behavior; complex behavior _emerges_ from simple rules.

How does the demo illustrate different concepts of "round"?

On a torus, a round pile can be a round fat dot, a round ring around
the shorter dimension of the torus, a round ring around the longer
dimension of the torus, or a nearly full torus surrounding a round fat
empty space.  Depending on the density of shavings any one of these is
possible, though the odds against a band going with the longer
dimension are pretty huge.  When round looks like a dot, the shortest
border looks like a circle.  When round looks like a ring, the shortest
border looks like a pair of straight lines.

How does the demo illustrate a "super-saturated solution"?

Watch the ants in whittler mode; for a long time they will pick up
shavings dropped by the whittler with only a few short lived small
piles occasionally seeded by the dropped shaving.  Then, all at once,
the ants carrying the shavings seem to admit defeat, and drop not just
a shaving or two, but a whole, long lasting pile of shavings.  It
frequently takes longer to pick up such a pile of shavings than the
demo had run until it appeared.  The density of shavings carrying ants
has exceeded the capacity of the patch arena size and the shavings
seeking ants to keep the patch arena clear.

How does the demo illustrate "catastrophe theory"?

The same behavior viewed a different way.  For a long time, the ants
keep carrying more and more shavings, but suddenly, one dropped
shaving, seemingly no different than the rest, makes the demo behavior
"fall off a cliff", into a mode where a pile persists for a very long
time before the ants can struggle back to a state of carrying all the
shavings.  Then, a shaving or two more from the whittler, and over the
cliff to pile maintenance mode it goes again.

How does the demo illustrate a "self-adjusting control loop"?

The more often the whittler sees no shaving and so finds the
opportunity to drop a shaving, the more often the whittler looks for a
patch screen without a shaving.  The more often the whittler sees a
shaving and so drops no shaving, the less often the whittler looks for
a patch screen without a shaving.  As an end result, the less success
the whittler has finding an empty patch screen, the less often the
attempt is made, until a balance is struck, but the balance of
necessity is a moving one, as more and more shavings enter
circulation.

;;;;;;;;;;;;
;; Color key
;;;;;;;;;;;;

cyan    - the one and only whittler
pink    - ant without a shaving and looking for a shaving to pick up
green   - ant with a shaving and looking for a shaving next to which to
          drop it
magenta - ant with a shaving and looking for an empty spot to drop it
blue    - ant with a shaving that just found an empty spot on which to
          drop it
brown   - ant that just dropped a shaving, looking for an empty spot on
          which to start searching for another shaving

Ants standing still have usually just changed state.  If state change pauses
are turned off, blue and brown ants move too fast to be seen.

Kent Paul Dolan
xanthian@well.com
http://www.well.com/user/xanthian/
http://www.well.com/user/xanthian/public/code/StarLogo/TWhatAC/twhatac.slogo

For more information about the original project, see:
http://el.www.media.mit.edu/people/starlogo/projects/termite.html


`interface`

SLSlider
top-left 5 5
width-height 600 25
name "number of ants"
variable "number"
min-value 1
max-value 500
current-value 144
slider-number 0
show-name? true

SLSlider
top-left 35 5
width-height 600 25
name "density of shavings"
variable "density"
min-value 0
max-value 99
current-value 0
slider-number 1
show-name? true

SLButton
turtle-or-observer? observer
top-left 65 5
width-height 150 45
name "button1"
line-to-run "setup"
forever? false
button-number 2
show-name? false

SLButton
turtle-or-observer? observer
top-left 115 5
width-height 150 45
name "button2"
line-to-run "go"
forever? true
button-number 3
show-name? false

SLButton
turtle-or-observer? observer
top-left 165 5
width-height 150 45
name "state change pause yes / no"
line-to-run "toggle-pause"
forever? false
button-number 4
show-name? true

SLButton
turtle-or-observer? observer
top-left 215 5
width-height 150 45
name "ants visible / invisible"
line-to-run "toggle-visible"
forever? false
button-number 5
show-name? true

SLButton
turtle-or-observer? observer
top-left 265 5
width-height 150 45
name "whittler sober / drunk"
line-to-run "toggle-sober"
forever? false
button-number 6
show-name? true

SLCanvas
top-left 65 160

`settings`
patch-size 9
num-shapes 256
screen-half-width 24
screen-half-height 15
interface-window-xcor 11
interface-window-ycor 3
interface-window-size 610 362
output-window-xcor 12
output-window-ycor 3
output-window-width 781
output-window-height 142
info-window-xcor 12
info-window-ycor 2
info-window-width 617
info-window-height 420
control-center-xcor 638
control-center-ycor 3
control-center-width 298
control-center-height 419
turtle-command-center-height 138
observer-command-center-height 138
plot-window-xcor 0
plot-window-ycor 0
plot-window-width 508
plot-window-height 372

`string table`
H4sIAAAAAAAAAGNgYGAAABzfRCEEAAAAAAAABA==

`symbol table`
H4sIAAAAAAAAAGNgYGAAABzfRCEEAAAAAAAABA==

`double table`
H4sIAAAAAAAAAGNgYGAAABzfRCEEAAAAAAAABA==

`list table`
H4sIAAAAAAAAAGNgYGAAABzfRCEEAAAAAAAABA==

`observer world`
H4sIAAAAAAAAAG1NMQ7CMAx0gTQDEmLowNgZKX/gKU2D1USEpIrd8H2SDB0Qlk4+
+84+uE5xJkwZ00isGacH7HWH3mNY2BY+glx95BVDk87NvKunAgkXjqy9IquzCws1
4/CxjtmjSjo847u2Bcu+g5uxaF67W9FmDBJhvTvA8KNyck05glj1RthCZXbkZl8H
AYLijKnQvr7vWsZ/fAF077Gg9QAAAAAAAPU=

`patch world`
H4sIAAAAAAAAAH3Uywrr5hmGUbWEVlBKNfBAAw2EMcYYY3w+21Kyj5eREEIzCMmm
3YN25kvuJTQHPjfQT0sDW/bS82v2Fn/9+tM3n7/9vv3n528+f/d1X7yu98UX//r2
p3/8ev/HT9/+/FkVf/rhux///vn7n++b4s+ffvjp86fvfvz5R1188e/fHi2Lv/x6
0O+e+4WL4m+/HNP957ej4/t31x/izamVsAo2gtWwBtbCxrAJbAqbweawBWwJW8HW
sA1sC9vB9rAD7Ag7wc6wC+wKu8HusAesg/Wy57B9ie5LdF+h+wrdG3Rv0L1F9xbd
O3Tv0L1H9x7dB3Qf0H1E93G4i//6/6P/bWtqJayCjWA1rIG1sDFsApvCZrA5bAFb
wlawNWwD28J2sD3sADvCTrAz7AK7wm6wO+wB62C97DlsX6L7Et1X6L5C9wbdG3Rv
0b1F9w7dO3Tv0b1H9wHdB3Qf0X0c7l7bWiZdASthFWwEq2ENrIWNYRPYFDaDzWEL
2BK2gq1hG9gWtoPtYQfYEXaCnWEX2BV2g91hD1gH62XPYYttTQ1dbGtq6GJbU0MX
25oautjW1NDFtqaGLrY1NXSxrakNd69trZKugJWwCjaC1bAG1sLGsAlsCpvB5rAF
bAlbwdawDWwL28H2sAPsCDvBzrAL7Aq7we6wB6yD9bLnsMW2poYutjU1dLGtqaGL
bU0NXWxrauhiW1NDF9uaGrrY1tSGu9e2jpKugJWwCjaC1bAG1sLGsAlsCpvB5rAF
bAlbwdawDWwL28H2sAPsCDvBzrAL7Aq7we6wB6yD9bLnsMW2poYutjU1dLGtqaGL
bU0NXWxrauhiW1NDF9uaGrrY1tSGu9e21klXwEpYBRvBalgDa2Fj2AQ2hc1gc9gC
toStYGvYBraF7WB72AF2hJ1gZ9gFdoXdYHfYA9bBetlz2GJbU0MX25oautjW1NDF
tqaGLrY1NXSxramhi21NDV1sa2rD3Wtbm6QrYCWsgo1gNayBtbAxbAKbwmawOWwB
W8JWsDVsA9vCdrA97AA7wk6wM+wCu8JusDvsAetgvew5bLGtqaGLbU0NXWxrauhi
W1NDF9uaGrrY1tTQxbamhi62NbXh7rWtbdIVsBJWwUawGtbAWtgYNoFNYTPYHLaA
LWEr2Bq2gW1hO9gedoAdYSfYGXaBXWE32B32gHWwXvYcttjW1NDFtqaGLrY1NXSx
ramhi21NDV1sa2roYltTQxfbmtpw99rWcdIVsBJWwUawGtbAWtgYNoFNYTPYHLaA
LWEr2Bq2gW1hO9gedoAdYSfYGXaBXWE32B32gHWwXvYcttjW1NDFtqaGLrY1NXSx
ramhi21NDV1sa2roYltTQxfbmtpw99rWSdIVsBJWwUawGtbAWtgYNoFNYTPYHLaA
LWEr2Bq2gW1hO9gedoAdYSfYGXaBXWE32B32gHWwXvYcttjW1NDFtqaGLrY1NXSx
ramhi21NDV1sa2roYltTQxfbmtpw99rWadIVsBJWwUawGtbAWtgYNoFNYTPYHLaA
LWEr2Bq2gW1hO9gedoAdYSfYGXaBXWE32B32gHWwXvYcttjW1NDFtqaGLrY1NXSx
ramhi21NDV1sa2roYltTQxfbmtpw99rWWdIVsBJWwUawGtbAWtgYNoFNYTPYHLaA
LWEr2Bq2gW1hO9gedoAdYSfYGXaBXWE32B32gHWwXvYcttjW1NDFtqaGLrY1NXSx
ramhi21NDV1sa2roYltTQxfbmtpw99rWedIVsBJWwUawGtbAWtgYNoFNYTPYHLaA
LWEr2Bq2gW1hO9gedoAdYSfYGXaBXWE32B32gHWwXvYcttjW1NDFtqaGLrY1NXSx
ramhi21NDV1sa2roYltTQxfbmtpw99rWRdIVsBJWwUawGtbAWtgYNoFNYTPYHLaA
LWEr2Bq2gW1hO9gedoAdYSfYGXaBXWE32B32gHWwXvYcttjW1NDFtqaGLrY1NXSx
ramhi21NDV1sa2roYltTQxfbmtpw99rWZdIVsBJWwUawGtbAWtgYNoFNYTPYHLaA
LWEr2Bq2gW1hO9gedoAdYSfYGXaBXWE32B32gHWwXvYcttjW1NDFtqaGLrY1NXSx
ramhi21NDV1sa2roYltTQxfbmtpw99rWVdIVsBJWwUawGtbAWtgYNoFNYTPYHLaA
LWEr2Bq2gW1hO9gedoAdYSfYGXaBXWE32B32gHWwXvYcttjW1NDFtqaGLrY1NXSx
ramhi21NDV1sa2roYltTQxfbmtpw99rWddIVsBJWwUawGtbAWtgYNoFNYTPYHLaA
LWEr2Bq2gW1hO9gedoAdYSfYGXaBXWE32B32gHWwXvYcttjW1NDFtqaGLrY1NXSx
ramhi21NDV1sa2roYltTQxfbmtpw99rWTdIVsBJWwUawGtbAWtgYNoFNYTPYHLaA
LWEr2Bq2gW1hO9gedoAdYSfYGXaBXWE32B32gHWwXvYcttjW1NDFtqaGLrY1NXSx
ramhi21NDV1sa2roYltTQxfbmtpw99rWbdIVsBJWwUawGtbAWtgYNoFNYTPYHLaA
LWEr2Bq2gW1hO9gedoAdYSfYGXaBXWE32B32gHWwXvYcttjW1NDFtqaGLrY1NXSx
ramhi21NDV1sa2roYltTQxfbmtpw99rWXdIVsBJWwUawGtbAWtgYNoFNYTPYHLaA
LWEr2Bq2gW1hO9gedoAdYSfYGXaBXWE32B32gHWwXvYcttjW1NDFtqaGLrY1NXSx
ramhi21NDV1sa2roYltTQxfbmtpw99rWfdIVsBJWwUawGtbAWtgYNoFNYTPYHLaA
LWEr2Bq2gW1hO9gedoAdYSfYGXaBXWE32B32gHWwXvYcttjW1NDFtqaGLrY1NXSx
ramhi21NDV1sa2roYltTQxfbmtpw99rWQ9IVsBJWwUawGtbAWtgYNoFNYTPYHLaA
LWEr2Bq2gW1hO9gedoAdYSfYGXaBXWE32B32gHWwXvYcttjW1NDFtqaGLrY1NXSx
ramhi21NDV1sa2roYltTQxfbmtpw99rWY9IVsBJWwUawGtbAWtgYNoFNYTPYHLaA
LWEr2Bq2gW1hO9gedoAdYSfYGXaBXWE32B32gHWwXvYcttjW1NDFtqaGLrY1NXSx
ramhi21NDV1sa2roYltTQxfbmtpw99rWU9IVsBJWwUawGtbAWtgYNoFNYTPYHLaA
LWEr2Bq2gW1hO9gedoAdYSfYGXaBXWE32B32gHWwXvYcttjW1NDFtqaGLrY1NXSx
ramhi21NDV1sa2roYltTQxfbmtpw99rWc9IVsBJWwUawGtbAWtgYNoFNYTPYHLaA
LWEr2Bq2gW1hO9gedoAdYSfYGXaBXWE32B32gHWwXvYcttjW1NDFtqaGLrY1NXSx
ramhi21NDV1sa2roYltTQxfbmtpw99rWS9IVsBJWwUawGtbAWtgYNoFNYTPYHLaA
LWEr2Bq2gW1hO9gedoAdYSfYGXaBXWE32B32gHWwXvYcttjW1NDFtqaGLrY1NXSx
ramhi21NDV1sa2roYltTQxfbmtpw99rWa9IVsBJWwUawGtbAWtgYNoFNYTPYHLaA
LWEr2Bq2gW1hO9gedoAdYSfYGXaBXWE32B32gHWwXvYcttjW1NDFtqaGLrY1NXSx
ramhi21NDV1sa2roYltTQxfbmtpw99rWW9IVsBJWwUawGtbAWtgYNoFNYTPYHLaA
LWEr2Bq2gW1hO9gedoAdYSfYGXaBXWE32B32gHWwXvYcttjW1NDFtqaGLrY1NXSx
ramhi21NDV1sa2roYltTQxfbmtpw99rWe9IVsBJWwUawGtbAWtgYNoFNYTPYHLaA
LWEr2Bq2gW1hO9gedoAdYSfYGXaBXWE32B32gHWwXvYcttjW1NDFtqaGLrY1NXSx
ramhi21NDV1sa2roYltTQxfbmtpw99rWR9IVsBJWwUawGtbAWtgYNoFNYTPYHLaA
LWEr2Bq2gW1hO9gedoAdYSfYGXaBXWE32B32gHWwXvYcttjW1NDFtqaGLrY1NXSx
ramhi21NDV1sa2roYltTQxfbmtpw99rWLukKWAmrYCNYDWtgLWwMm8CmsBlsDlvA
lrAVbA3bwLawHWwPO8COsBPsDLvArrAb7A57wDpYL3sOW2xrauhiW1NDF9uaGrrY
1tTQxbamhi62NTV0sa2poYttTW24+y8ziYzpkaYAAAAAppE=

`turtle world`
H4sIAAAAAAAAAE2OOw7CMBBEh+B8JBAVJQVFKgoK4AAcJSZZxZEs24oXBU7BkWET
IsRWb6SZ2cGm4nvPlvaRNVN1xe9eyCy5lo3wBemtJ2oES+TBeg7kRByR1t76XnAH
9awnWmM1lf2lC7E3fnBB1AlpNDqQ4AHq8c0oLAfjp79ZNLPzjNyQbjrXitjOsxIo
7TgKLVAMpmMZPzYkb7nR8AGBdgya0wAAAAAAANM=