Build an interpreter for "Goggle kids Code" Partially inspired by this question.

Overview

The execution of Goggle kids Code starts with an empty binary tape with 100 items, with the pointer starting at the index 0:

00000...
^


At the end of the execution, you can assume that the tape is implicitly outputted.

Instructions

Goggle kids Code is a simple language involving a stack-like tape.


/: Move the pointer right.
\: Move the pointer left.
&gt;: Take two items from the tape, the left item and the current item. Zero the current item, move left, and set the item as 1 if left is larger than current, else 0.
=: Similar to &gt;, but performs an equality comparison instead.


The only looping structure in Goggle kids Code is the repeat loop, which takes a strictly positive number on the right introduced by a x symbol. (So things like (...)x0 is impossible here.) The syntax for this is:

(...)xI


The parentheses can only contain single instructions, although you can introduce other instructions with commas.

Sample program + Explanation

((/,&gt;)x4,/)x13

(         )x13  Do this 13 times:
 (   )x4            Do this 4 times:
  /                    Move right
   ,                   After that,
    &gt;                  Greater than
        ,           After that,
         /          Move pointer right.


Another example that does something useful (fills 13 items from the tape with 1's):

(   )x13    Do this 13 times:
 /              Move right
  ,             After that,
   =            Equality


Rules


You can assume the tape pointer never wraps around.


The test cases won't abuse out-of-bounds tape-moving.

To simplify the solution, you are allowed to output part of the tape, as long as that part is modified.
You are allowed to have a different instruction mapping, but if you do that, please make sure to clarify which mapping you used.
You could ignore checking the commas in the source code, they'll always be there.


Instructions are always separated by the comma.



Test cases

The trailing 0 digits are omitted here, for compactness of example outputs.

((/,&gt;)x4,/)x13  -&gt; 0000000000000 (doesn't modify the tape)

(/,=,/)x13      -&gt; 1111111111111

(/,=,/,/)x13    -&gt; 1010101010101010101010101

(/,=)x13,/,=    -&gt; 00000000000000000

(/,/,=,\)x3     -&gt; 0100
```
Python 2, 131 126 123 110 104 bytes
Saved 13 bytes thanks to @dingledooper's approach of flattening nested list using backtick.
Saved 2 bytes thanks to @l4m2

p,t=0,[0]*100
for i in`input()`:
 if&quot;/&quot;&lt;i:i=int(i);p+=i/3-1
 if i&lt;2:t[p:p+2]=cmp(*t[p:p+2])==i,0
print t

Try it online! or Verify all test cases
Takes input from STDIN, where /\&gt;=x are replaced with 6210*
Big idea:
Python 2 input() implicitly evaluates the string read from STDIN. Thus, reading modified input like ((6,1)*4,2)*13 returns a nested tuple of integers, aka
((6, 1, 6, 1, 6, 1, 6, 1), 2, (6, 1, 6, 1, 6, 1, 6, 1), 2, ...)

Note that loops containing single instruction must be terminated with comma, e.g (1,)*10.
Now that all loops have been automatically unrolled for us, we just have to flatten the resulting tuple, and decode the instructions.
To flatten the nested tuple, we simply convert it to string, then takes all numerical characters.