Interpreting Fish (no, not that Fish) Consider these five ASCII art sea creatures:

Standard fish: &gt;&lt;&gt; or &lt;&gt;&lt;
Speedy fish: &gt;&gt;&lt;&gt; or &lt;&gt;&lt;&lt;
Sturdy fish: &gt;&lt;&gt;&gt; or &lt;&lt;&gt;&lt;
Stretchy fish: &gt;&lt;&lt;&lt;&gt; or &lt;&gt;&gt;&gt;&lt;
Crab: ,&lt;..&gt;,

Write a program that accepts an arbitrary string of the characters &lt;&gt;,.. If there is a way to interpret the entire string as a series of non-overlapping sea creatures, then the string should be reprinted with single spaces inserted between creatures. If this interpretation is impossible, nothing should be output (the program silently ends).
For example, the string &lt;&gt;&lt;&gt;&lt;&gt; can be interpreted as two standard fish back-to-back. The corresponding output would be &lt;&gt;&lt; &gt;&lt;&gt;.
As another example, the string &gt;&lt;&gt;&gt;&lt;&gt;&gt; contains &quot;instances&quot; of...
(brackets only added as indicators)

a couple standard fish: [&gt;&lt;&gt;][&gt;&lt;&gt;]&gt;
a speedy fish: &gt;&lt;[&gt;&gt;&lt;&gt;]&gt;
a sturdy fish in a couple ways: [&gt;&lt;&gt;&gt;]&lt;&gt;&gt; and &gt;&lt;&gt;[&gt;&lt;&gt;&gt;]

however, only the pairing of a standard fish and a sturdy fish [&gt;&lt;&gt;][&gt;&lt;&gt;&gt;] spans the entire length of the string with no fish sharing characters (no overlaps). Thus the output corresponding to &gt;&lt;&gt;&gt;&lt;&gt;&gt; is &gt;&lt;&gt; &gt;&lt;&gt;&gt;.
If there are multiple ways the string could be interpreted, you may print any one of them. (And only print one of them.) For example, &lt;&gt;&lt;&lt;&lt;&gt;&lt; can be interpreted as a standard fish and a sturdy fish: [&lt;&gt;&lt;][&lt;&lt;&gt;&lt;], or as a speedy fish and a standard fish: [&lt;&gt;&lt;&lt;][&lt;&gt;&lt;]. So either &lt;&gt;&lt; &lt;&lt;&gt;&lt; or &lt;&gt;&lt;&lt; &lt;&gt;&lt; would be valid output.

The crabs are just for fun. Since they don't start or end with &lt; or &gt;, they are much easier to identify (at least visually). For example, the string
,&lt;..&gt;,&gt;&lt;&lt;&lt;&gt;,&lt;..&gt;,&gt;&lt;&gt;,&lt;..&gt;,&lt;&gt;&gt;&gt;&lt;,&lt;..&gt;,&gt;&lt;&gt;&gt;,&lt;..&gt;,&lt;&lt;&gt;&lt;,&lt;..&gt;,&lt;&gt;&lt;,&lt;..&gt;,&gt;&gt;&lt;&gt;

would obviously produce the output
,&lt;..&gt;, &gt;&lt;&lt;&lt;&gt; ,&lt;..&gt;, &gt;&lt;&gt; ,&lt;..&gt;, &lt;&gt;&gt;&gt;&lt; ,&lt;..&gt;, &gt;&lt;&gt;&gt; ,&lt;..&gt;, &lt;&lt;&gt;&lt; ,&lt;..&gt;, &lt;&gt;&lt; ,&lt;..&gt;, &gt;&gt;&lt;&gt;


Here are some examples of strings (one per line) that produce no output:
&lt;&gt;&lt;&gt;
,&lt;..&gt;,&lt;..&gt;,
&gt;&gt;&gt;&lt;&gt;
&gt;&lt;&lt;&lt;&lt;&gt;
,
&gt;&lt;&gt;&lt;&gt;
,&lt;&gt;&lt;&gt;,
&lt;&lt;&lt;&gt;&lt;&gt;&lt;&lt;&lt;&gt;&gt;&gt;&lt;&gt;&gt;&lt;&gt;&gt;&lt;&gt;&lt;&gt;&lt;&lt;&gt;&gt;&gt;&lt;&gt;&gt;&lt;&gt;&gt;&gt;&lt;&gt;&gt;&gt;&lt;&gt;&gt;&lt;&gt;&gt;&lt;&lt;&gt;&lt;

The last string here can be parsed if you remove the leading &lt;:
&lt;&lt;&gt;&lt; &gt;&lt;&lt;&lt;&gt; &gt;&gt;&lt;&gt; &gt;&lt;&gt; &gt;&lt;&gt; &lt;&gt;&lt; &lt;&gt;&gt;&gt;&lt; &gt;&gt;&lt;&gt; &gt;&gt;&lt;&gt; &gt;&gt;&lt;&gt; &gt;&lt;&gt;&gt; &lt;&lt;&gt;&lt;

(There may be other possible outputs.)
Details

The input string will only contain the characters &lt;&gt;,..
The input string will be at least one character long.
Take input in any common way (command line, stdin) and output to stdout.
The shortest code in bytes wins. (Handy byte counter.) Tiebreaker is earlier post.
Non-deterministic Turing Machine, 20 states, 52 transitions (882 bytes maybe)
How do you convert this to bytes? I've written the files (absolutely not golfed) to execute this machine with Alex Vinokur's Simulator of a Turing Machine1. wc -c outputs the following (excluding the description file and the input files):
 12 alphabet
 49 meta
740 rules
 81 states
882 total

Anyways, I was preparing for my Computer Science A-Levels, so I thought this would be a good exercise (I don't know what I was thinking). So here's the definition:
$$\begin{align*}
M &amp; = (Q, \Sigma, \iota, \sqcup, A, \delta) \\
Q &amp; = \{q_{0},q_{1},q_{2},q_{3},q_{4},q_{5},q_{6},q_{7},q_{8},q_{9},q_{10},q_{11},q_{12},q_{13},q_{14},q_{15},q_{16},q_{17},q_{18},q_{19}\} \\
\Sigma &amp; = \{&lt; \: ; \: &gt; \: ; \: , \: ; \: . \: ; \: X \: ; \: $\} \\
\iota &amp; = q_0 \\
\sqcup &amp; = $ \\
A &amp; = \{q_0, q_5\}
\end{align*}$$

(the transition function)
Excuse the bad image, but I couldn't be bothered with redrawing this thing on a computer. If you actually want to decipher the transition rules, I recommend you read through the rules file I linked above.

I've used Xs instead of spaces because spaces are hard to visualize here and the simulator doesn't accept spaces in the alphabet.
The concept is fairly simple - q1 to q4 are used to catch right-facing fishes, q11 to q14 are used to catch left-facing fishes, q15 to q19 for crabs and the q5 to q10 blob is simply for inserting a space and moving all following characters one to the right.
If the string is interpretable, it accepts the string and the tape contains the string with spaces inserted. Otherwise it rejects the string (I guess this counts as no output - emptying the tape would be pretty easy but would require lots of transition rules and I don't think it would make the transition function prettier to look at).

1 Note: It's difficult to compile. I had to edit the src/tape.cpp file and replace LONG_MAX with 1&lt;&lt;30 and then go to the demo directory, edit the Makefile to replace EXE_BASENAME with turing.exe and execute make. Then go to the directory with the files I've written and execute /path/to/turing/download/src/turing.exe meta.