I have this list:

```
[[1, 2, 3, 4], [5], [6, 7], [8], [9], [10, 11], [12, 13, 14], [15, 16], [15, 16], [15, 16], [17], [18], [19], [20], [21], [20], [21], [], [], [], [], []]

```

It could be described as a list of references to other items in the same list, like this:

```
0 --> 1 2 3 4
1 --> 5
2 --> 6 7
3 --> 8
4 --> 9
5 --> 10 11
6 --> 12 13 14
7 --> 15 16
8 --> 15 16
9 --> 15 16
10 --> 17
11 --> 18
12 --> 19
13 --> 20
14 --> 21
15 --> 20
16 --> 21
17 --> None
18 --> None
19 --> None
20 --> None
21 --> None

```

So, from index 0 one can move to either 1, 2, 3 or 4. From 1 you can go to 5, and from 5 you can go to 10 etc. until you can't go any further (like when you reach index 17).

I'm trying to make a function that would return this when fed the above list:

```
[0,1,5,10,17]
[0,1,5,11,18]
[0,2,6,12,19]
[0,2,6,13,20]
[0,2,6,14,21]
[0,2,7,15,20]
[0,2,7,16,21]
[0,3,8,15,20]
[0,3,8,16,21]
[0,4,9,15,20]
[0,4,9,16,21]

```

Unfortunately, I just can't come up a solution.

I understand that this probably calls for a recursive function, but I'm getting so confused by it. Without actually knowing what I did, I managed to come up with this function:

```
def recurse_into(A,i):
    B = [i]
    for j in tree[i]:
        B += recurse_into(A,j)
    return B

```

It returns this:

```
[0, 1, 5, 10, 17, 11, 18, 2, 6, 12, 19, 13, 20, 14, 21, 7, 15, 20, 16, 21, 3, 8, 15, 20, 16, 21, 4, 9, 15, 20, 16, 21]

```

From that I probably could come up with something that generates the wanted results, but I wonder how I could get the result I want directly from the recursive function.

I would very much appreciate some pointers or tips on how to achieve this.

Thanks!