Pseudorandom Cellular Automaton Introduction

In this challenge, we will simulate a certain probabilistic cellular automaton using very bad pseudorandom numbers.
The cellular automaton is defined on binary strings by the following local rule.
Suppose that the left neighbor of a cell and the cell itself have states a and b.


If min(a,b) == 0, then the new state of b is max(a,b).
If min(a,b) == 1, then the new state of b is chosen randomly from {0,1}.


The following picture shows one possible 10-step evolution of a single 1.

1
11
101
1111
11001
101011
1111111
10001001
110011011
1010111101


Note how two adjacent 1s sometimes evolve to 1, and sometimes to 0, and the border-most bits are always 1s.
Your task is to produce a cellular automaton evolution of this form.

Inputs

Your inputs are a positive integer n, denoting the number of rows to display, and a non-empty list of bits L, which we use as a source of randomness.

Output

Your output is a list of lists or 2D array of bits, depicting the evolution of a single 1 for n time steps, as in the above figure.
You can pad the output with 0s to get rows of equal lengths, if desired, but there must not be leading 0s.

The random choices in the cellular automaton must be drawn from the list L, jumping back to the beginning when it is exhausted.
More explicitly, if the output is traversed one row at a time form top to bottom, left to right, then the successive random choices shall form the list L repeated as many times as necessary.

Example

Suppose the inputs are n = 7 and L = [0,1,0].
Then the cellular automaton evolves as follows during the 7 steps, where we have put a v right above every random choice:

[1]

[1,1]
   v
[1,0,1]

[1,1,1,1]
   v v v
[1,1,0,0,1]
   v
[1,1,1,0,1,1]
   v v   v
[1,0,0,1,1,1,1]


If we read all the bits marked with a v, we get 01001001, which is L repeated 2.66 times.
The next random bit would be 0.

Rules and Scoring

You can write a full program or a function.
The lowest byte count wins, and standard loopholes are disallowed.
The exact format of the inputs and outputs is unimportant (within reason).

Test Cases

Deterministic version, every random bit is 0:

Inputs: 10 [0]
Output:
1
11
101
1111
10001
110011
1010101
11111111
100000001
1100000011


Every random bit is 1:

Inputs: 6 [1,1]
Output:
1
11
111
1111
11111
111111


Pseudorandom versions:

Inputs: 10 [0,0,1]
Output:
1
11
101
1111
10101
111111
1010011
11110101
101011111
1111101001

Inputs: 10 [1,0,0,1]
Output:
1
11
111
1001
11011
111111
1001101
11010111
111111101
1011001111

Inputs: 15 [1,1,1,0,0,0]
Output:
1
11
111
1111
10001
110011
1110111
11011001
111111011
1100011111
11100100011
111101100101
1001111101111
11011000111111
101101001011101
Retina, 139 bytes

^.
1

 00:0 01:1 10:1 11:
(m`^(..)((\S*)(?&lt;=0) .*)
$1$3#$1!$2
+m`(?&lt;=^(?&lt;-2&gt;.)*(..).*?#(.)*.)\d!(.)(.*\1:)(.)(\d*)
$5$3!$4$6$5
)`!0
0
 .+
&lt;empty&gt;


Where &lt;empty&gt; indicates that there is a trailing empty line. Each line goes in a separate file and the # should be replaced with linefeeds (0x0A).

Expects the input to be n in unary (made of zeroes, as in Unary), followed by a space, followed by the "pseudo-random" string, e.g. 10, [1, 0, 0, 1] would be read as

0000000000 1001


Output is as in the challenge, but padded with zeroes, e.g. 

1000000000
1100000000
1110000000
1001000000
1101100000
1111110000
1001101000
1101011100
1111111010
1011001111


This was way trickier than I expected...