Watch 'em fall like dominoes You live inside a terminal that is 80 characters wide. You are bored, so you decide to play dominoes. No, not the boring kind that look like Scrabble, the fun kind where you spend an hour setting them to watch them fall in a second.

In terminals, dominoes look like this:

|   upright domino
\   left-tilted domino
/   right-tilted domino
__  fallen domino


As we all know, if a tilted domino touches an upright one, the second domino gets tilted as well. The only exception to this is if two tilted dominoes touch it:

|\ --&gt; \\        /| --&gt; //        /|\ --&gt; /|\


Adjust your terminal's gravitational constant so this transition takes 100 ms.

If a tilted domino is supported by another domino or the terminal's walls, its journey ends.

None of the tilted dominoes in

\||||____||||/__                /|\    /\    /|\                __\||||____||||/


(80 characters) will move, since the two outmost tilted dominoes are supported by the terminal's walls and all others are supported by other dominoes.

However, if the space in the tilting direction is empty, the domino falls down:

| \\ --&gt; |__\        // | --&gt; /__|


Terminal. Gravitational constant. You get the point&hellip;

Finally, there's a slight wind from the left, so right-tilted dominoes fall faster than left-tilted ones:

|/ \| --&gt; |__\|


Task

Write a program/function that shows an animation of playing dominoes in a terminal.

Your code should do the following:


Read a string from input, representing the initial state of the dominoes.

This string will contain no more than 80 characters and consist solely of the dominoes described above and empty spaces.
Print the state and wait for 100 ms.
Transform the state as explained above.
If the state changed, go back to 2.


Additional rules


The length of the input string does not affect the terminal's width; even if the string is shorter than 80 characters, the walls of the terminal are still 80 characters apart.
Each time step 2 is executed, the state should get printed to the same location, overwriting the previous state.
Since some languages are incapable of waiting exactly 100 ms, feel free to wait any amount between 50 and 1000 ms.
Standard code-golf rules apply.


Examples


For the initial state

 ||\/||


print the following (one over the other):

 ||\/||
 |\\//|
 \\\///
__\\//__

For the initial state

/||||\


print the following

/||||\
//||\\
///\\\

For the initial state

/|||\


print the following

/|||\
//|\\

For the initial state

|/ \|/ \|/ \|/ \|


print the following:

|__\|__\|__\|__\|

For the initial state (80 characters)

\||||____||||/__                /|\    /\    /|\                __\||||____||||/


print the following

\||||____||||/__                /|\    /\    /|\                __\||||____||||/
Retina, 87 86 85 bytes

Thanks to Dennis for saving 1 byte.

^.{0,79}$
$0 
:`^
&lt;ESC&gt;c
(`/ | \\
__
/\|(?!\\)
//a
(?&lt;!/)\|\\
\\
$
aaaaa
a
aaaa
(a+)+b|a
&lt;empty&gt;


&lt;ESC&gt; should be replaced by the actual control character (0x1B). &lt;empty&gt; represents an empty trailing line. You can then run the above code from a single file with the -s flag.

The code requires a terminal which supports ANSI escape codes. I can't suppress the line feed in Retina's output so I need to clear the entire console with &lt;ESC&gt;c each time. I've tested the code in bash using Mono to run Retina.

Explanation

^.{0,79}$
$0 


We start by appending a space if the input contains fewer than 80 characters. This is so that a / at the right end does not have to be treated separately.

:`^
&lt;ESC&gt;c


Now we prepend &lt;ESC&gt;c to the string, which is the ANSI escape code for clearing the terminal. So every time the string is printed it will do so at the top of the terminal. The :` instructs Retina to print out the result of this substitution, i.e. the initial configuration.

(`/ | \\
__


(` begins a loop. Since there is no matching ), the loop is assumed to go until the last stage of the program. Each iteration will simulate one step of the dominoes falling and then "sleep" a bit. This first stage replaces / and \ next to a space into __. This automatically handles the / \ case correctly, because matches cannot overlap and are searched for from left to right. So the /&lt;sp&gt; would be matched and turned into __ such that the \ can't be matched, and we get the correct __\.

/\|(?!\\)
//a


This turns /| into // provided there's no \ next to it. We append an a such that this new / doesn't mess with the next stage (which shouldn't "know" about this change yet).

(?&lt;!/)\|\\
\\


The opposite situation: turn |\ into \\ provided there's no / next to it. We don't need to put an a here, because we're done with this step of the simulation.

Now the sleeping part...

$
aaaaa


Appends 5 more as to the end of the code.

a
aaaa


Turns each a into 4 as, so we get 20 as at the end.

(a+)+b|a
&lt;empty&gt;


Now the fun part... we sleep for a bit with the help of catastrophic backtracking. There is an exponential amount of ways to split up a match of (a+)+ between repetitions of the group. Because the b causes the match to fail, the engine will backtrack and try every single one of those combinations before deciding that (a+)+b can't match. For the twenty as at the end that takes something like half a second.

At the same time, we allow the regex to match a single a, but only after doing the backtracking. When that matches, we replace it with an empty string, removing all the as we inserted for one reason or another from the string.

That leaves printing the string at the end of the loop iteration. Here it comes in handy that I haven't fixed the printing behaviour of loops in Retina yet. Currently, there is only one flag for each stage, which says "print" or "don't print". The default is "don't print" except for the last stage in the program, which defaults to "print". But the stage is looped, so that means it actually prints the current string on each iteration. Normally, that is really annoying, and you almost always need to include an additional empty stage at the end if you only want the final result, but here it lets me save four bytes.