There are three ways to enter a pattern:

1) Type it in the pattern entry field at the bottom of the juggler.
2) Use the up-arrow key in the pattern entry field to get a previous pattern.
3) Alternately, get the previous pattern from the History menu
   (which can be torn off).

When a pattern is entered, [MA][GNU]S will look for the shortest
transition to that pattern on the fly (which may involve throwing in
or throwing away balls and/or switching between synchronous and
asynchronous juggling).
-------------------------------------------------------------------------
Patterns are entered in a slightly expanded form of Siteswap
notation. If you are unfamiliar with Siteswap, check out the faq at
http://www.juggling.org/help/siteswap/faq.html. 

The following is the complete description of what the juggler
will accept as a pattern.

The basic unit in a pattern string is the _multiplex throw_, which is
either just an individual throw or a collection of invididual throws
collected between brackets [].

An _individual throw_ is a number, followed by a (possibly empty) list
of throw modifiers a-z.  If a space appears anywhere in the pattern
and there are no capital letters, consecutive digits are read as a
single decimal number. Otherwise the numbers are read in as digits 0-9
and letters A-Z (interpreted as 10-35). 

There are two kinds of patterns: synchronous and asynchronous.
An asynchronous pattern is simply a list of multiplex throws;
a synchronous pattern is a list of pairs of multiplex throws,
where each individual throw is an even number.

The pattern parser searches the pattern for parentheses and commas;
if it finds even one, it decides the pattern is synchronous, and
will then only complain if it has an odd number of multiplex throws,
or if any of the individual throws are odd.

If there are no parentheses or commas, the pattern parser will only
complain if it finds characters other than {space, 0-9, A-Z, a-z},
if the multiplexing brackets [] are badly matched, or if the
throw modifier "x" is used (since it's only supposed to be in
synchronous patterns).

Examples:

- The pattern "A1612" and "10 1 6 1 2" are interpreted as the same
  asynchronous pattern.

- The string "(6,3)" is not a well-formed pattern, because it wants
  to be synchronous, but has an odd throw.

- It's not good form to write "(4,6,4)(6,4,6)", but the pattern parser
  will interpret it as "(4,6)(4,6)(4,6)" and not raise a ruckus.

Remember that patterns specify a series of throws to be performed over
and over.  So if you really want to see fifteen balls juggled in a
cascade, but despair because the string "15" is interpreted as
one:five since it has no embedded spaces, you can be tricky and get
the desired effect with "15 15".

Throw modifiers

 b - bounce this throw on the ground
 r - reverse (outside) throw
 t - throw (for 2's, which are otherwise held)
 x - make this a crossing throw, rather than back to the same hand

Note that not every well-formed pattern is actually jugglable!
What is required is that the number of balls landing at a given time
is equal to the number being thrown. If this is not true, the Orbits
window will show exactly how the pattern fails. This is explained
further in the Orbits help file.






