Print the nth Fibonacci number containing the nth Fibonacci number! Challenge
You must write a program that takes a positive integer n as input, and outputs the nth Fibonacci number (shortened as Fib# throughout) that contains the nth Fib# as a subtring. For the purposes of this challenge, the Fibonacci sequence begins with a 1.
Here are some examples that you can use as test cases, or as examples to clarify the challenge (for the latter, please leave a comment down below explaining what you find unclear).
n=1
Fib#s: 1
       ^1 1st Fib# that contains a 1 (1st Fib#)
Output: 1

n=2
Fib#s: 1, 1
       ^1 ^2 2nd Fib# that contains a 1 (2nd Fib#)
Output: 1

n=3
Fib#s: 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233
             ^1              ^2                   ^3 3rd Fib# that contains a 2 (3rd Fib#)
Output: 233

n=4
Output: 233

n=5
Output: 6765

n=6
Output: 28657

n=7
Output: 1304969544928657

n=8
Output: 14472334024676221

n=9
Output: 23416728348467685

n=10
Fib#s: 1, ..., 34, 55, 89, ..., 63245986, 102334155, 165580141, ..., 2880067194370816120, 4660046610375530309
                   ^1                     ^2         ^3                                   ^10 10th Fib# that contains a 55 (10th Fib#)
Output: 4660046610375530309


As always, this is code-golf, so go for the lowest byte count possible.
If something is confusing/unclear, please leave a comment.
(This challenge is based off another challenge I posted: Print the nth prime that contains n)
Haskell, 85 84 bytes

EDIT:


-1 byte: Laikoni shortened l.
Typo (x&gt;=s for x&lt;=s) in explanation.


f takes an Int and returns a String.



l=0:scanl(+)1l
m=show&lt;$&gt;l
f n|x&lt;-m!!n=[y|y&lt;-x:m,or[x&lt;=s|s&lt;-scanr(:)""y,x++":"&gt;s]]!!n


Try it online!

How it works


l is the infinite list of Fibonacci numbers, defined recursively as the partial sums of 0:1:l. It starts with 0 because lists are 0-indexed. m is the same list converted to strings.
In f:


n is the input number, and x is the (string of the) nth Fibonacci number.
In the outer list comprehension, y is a Fibonacci number tested for whether it contains x as a substring. The passing ys are collected in the list and indexed with the final !!n to give the output. An extra x is prepended to the tests to save two bytes over using !!(n-1) at the end.
To avoid counting ys several times, the tests of each y are wrapped in or and another list comprehension.
In the inner list comprehension, s iterates through the suffixes of y.
To test whether x is a prefix of s, we check whether x&lt;=s and  x++":"&gt;s. (":" is somewhat arbitrary but needs to be larger than any numeral.)