[Question]
  [
Given an integer n, output the following ASCII art to n rows:
```
1+1=2
  1+2=3
    2+3=5
      3+5=8
        5+8=13
```
Essentially, the first row is `1+1=2` and the nth row (1-indexed) is \$f\_n + f\_{n+1} = f\_{n+2}\$ where \$f\$ is the Fibonacci sequence, padded so the numbers line up with the previous row.
You may instead output it infinitely. You may output a list of lines.
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), shortest wins!
## Testcase
The output for 20 should be:
```
1+1=2
  1+2=3
    2+3=5
      3+5=8
        5+8=13
          8+13=21
            13+21=34
               21+34=55
                  34+55=89
                     55+89=144
                        89+144=233
                           144+233=377
                               233+377=610
                                   377+610=987
                                       610+987=1597
                                           987+1597=2584
                                               1597+2584=4181
                                                    2584+4181=6765
                                                         4181+6765=10946
                                                              6765+10946=17711
```
  
[Answer]
# [Python 2](https://docs.python.org/2/), 67 bytes
Outputs the sequence indefinitely.
```
a=b=l=1
while 1:print'%*d+%d='%(l,a,b)+`a+b`;l-=~len(`b`);a,b=b,a+b
```
[Try it online!](https://tio.run/##K6gsycjPM/r/P9E2yTbH1pCrPCMzJ1XB0KqgKDOvRF1VK0VbNcVWXVUjRydRJ0lTOyFROynBOkfXti4nNU8jISlB0xoobpukAxT//x8A "Python 2 – Try It Online")
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~71~~ 66 bytes
-5 thanks to [Sisyphus](https://codegolf.stackexchange.com/questions/243667/fibonacci-triangle/243680?noredirect=1#comment548748_243680)
```
i,j;main(k){for(;;)printf("%*d+%d%n=%d\n",i,j=k-j,k+=j,&i,j+k+k);}
```
[Try it online!](https://tio.run/##S9ZNT07@/z9TJ8s6NzEzTyNbszotv0jD2lqzoCgzryRNQ0lVK0VbNUU1z1Y1JSZPSQeo0jZbN0snW9s2S0cNyNPO1s7WtK79/x8A "C (gcc) – Try It Online")
Outputs indefinitely.
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 25 bytes
```
≔Ｅ²¦¹ηＦＮ«Ｉ⌊η+≔⟦⌈ηΣη⟧η⟦⪫η=
```
[Try it online!](https://tio.run/##S85ILErOT8z5/9@xuDgzPU/DN7FAw0hHwVBTRyFD05orLb9IQcMzr6C0xK80Nym1SENTU6GaizOgKDOvRMM5sbhEwzczLzO3NFcjQ1MTqB4qo6StBOJAzYz2TayAqtFRCAbTsRDjocqjvfIz8zQydBSUbJU0Y4Hitf//Gxn81y3LAQA "Charcoal – Try It Online") Link is to verbose version of code. Explanation:
```
≔Ｅ²¦¹η
```
Start with two `1`s.
```
ＦＮ«
```
Repeat `n` times.
```
Ｉ⌊η
```
Output the first element of the old pair.
```
+
```
Output a `+`.
```
≔⟦⌈ηΣη⟧η
```
Replace the pair with the second element and their sum.
```
⟦⪫η=
```
Output the new pair joined with `=` and move the cursor down.
[Answer]
# [Pip](https://github.com/dloscutoff/pip), 30 bytes
```
W P[xi::o'+o+:i'=i+o]x.:sX#i+1
```
Outputs forever. [Attempt This Online!](https://ato.pxeger.com/run?1=m724ILNgwYKlpSVpuhb7whUCoisyrazy1bXzta0y1W0ztfNjK_SsiiOUM7UNIYqgamF6AA)
### Explanation
```
W P[xi::o'+o+:i'=i+o]x.:sX#i+1
                                i is 0, o is 1, x is "", s is " " (implicit)
   [                ]           Put the following in a list:
    x                            The indent: x
     i::o                        Swap i (the smaller number) with o (the larger number)
                                 and return the new value of i
         '+                      Plus sign
           o+:i                  Add i to o in-place and return the new value of o
               '=                Equals sign
                 i+o             Add i and o
  P                             Print the list (concatenating its elements by default)
W                               Loop while the list is truthy (which is always):
                          #i     Length of i
                            +1   Plus 1
                        sX       That many spaces
                     x.:         Concatenate with x in-place
```
[Answer]
# [Python 3.8 (pre-release)](https://docs.python.org/3.8/), 66 bytes @emanresu A
```
a=b=l=1
while l:=len(x:=f"{a:>{l}}+{b}=%d")-3:a,b=b,a+b;print(x%b)
```
[Try it online!](https://tio.run/##K6gsycjPM7YoKPr/P9E2yTbH1pCrPCMzJ1Uhx8o2JzVPo8LKNk2pOtHKrjqntla7OqnWVjVFSVPX2CpRJ8k2SSdRO8m6oCgzr0SjQjVJ8/9/AA "Python 3.8 (pre-release) – Try It Online")
### Old [Python 3.8 (pre-release)](https://docs.python.org/3.8/), 67 bytes
```
a=b=l=1
while l:=len(x:=f"{a:>{l}}+{b}"):a,b=b,a+b;print(x+f'={b}')
```
[Try it online!](https://tio.run/##K6gsycjPM7YoKPr/P9E2yTbH1pCrPCMzJ1Uhx8o2JzVPo8LKNk2pOtHKrjqntla7OqlWSdMqUSfJNkknUTvJuqAoM69Eo0I7Td0WKKWu@f8/AA "Python 3.8 (pre-release) – Try It Online")
Based on @dingledooper's Python 2 answer.
[Answer]
# JavaScript (ES8), 79 bytes
```
f=(n,A=B=1,p)=>n?''.padEnd(p)+A+`+${B}=${B+=A}
`+f(n-1,B-A,(A+"").length-~p):''
```
[Try it online!](https://tio.run/##DcRBCsIwEADAu88oQnbZJFiPwlYS8B8NTVKVsgm2eJH69egc5hneYZ1ej7oZKTG1lhlEO/bc64o8yFUpW0O8SYSK5Gik48fv/I/Y7YeRMojptTdOg6OuQ7skmbe7@Va8KNWmImtZkl3KDBnOJ8T2Aw "JavaScript (Node.js) – Try It Online")
### Commented
```
f = (                   // f is a recursive function taking:
  n,                    //   n = input
  A = B = 1,            //   A, B = Fibonacci variables
  p                     //   p = padding length, initially undefined
) =>                    //
n ?                     // if n is not equal to 0:
  ''.padEnd(p) +        //   append p spaces (none if p is undefined)
  A +                   //   followed by A
  `+${B}=${B += A}\n` + //   followed by "+[B]=[B+A]\n" (A is added to B)
  f(                    //   followed by the result of a recursive call:
    n - 1,              //     decrement n
    B - A,              //     update A to the previous value of B
    (A + "")            //     add the length of A coerced to a string + 1
    .length - ~p        //     to p
  )                     //   end of recursive call
:                       // else:
  ''                    //   stop the recursion
```
[Answer]
# [SNOBOL4 (CSNOBOL4)](http://www.snobol4.org/csnobol4/), ~~90 87~~ 84 bytes
```
	N =1
N	N =M + (M =N)
	OUTPUT =P =DUPL(' ',X) M '+' N '=' M + N
	P @X N '='	:(N)
END
```
[Try it online!](https://tio.run/##JYsxC4AgFAZn/RXf9hRbgqbgQYNt@XqDgnNz5ND/x4qmg@PuvtrRzql3I@DRyoeEAJfA4q3ZS9aSwQqORTdHoKF6JFAgCIgJXy7WKJb6GzO7d10l9v4A "SNOBOL4 (CSNOBOL4) – Try It Online")
Outputs infinitely, but experiences integer overflow after a short while.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 22 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
+2ÆḞ€DżṖ©;⁾+=Ɗ⁶ṁ$®¦F)Y
```
A full program that accepts an integer and prints the result.
**[Try it online!](https://tio.run/##ATQAy/9qZWxsef//KzLDhuG4nuKCrETFvOG5lsKpO@KBvis9xorigbbhuYEkwq7CpkYpWf///zIw "Jelly – Try It Online")**
### How?
```
+2ÆḞ€DżṖ©;⁾+=Ɗ⁶ṁ$®¦F)Y - Main Link: integer, N
                    )  - for each V in [1..N]:
+2                     -   V add two
  ÆḞ€                  -   Fibbonacci of each of [1..V+2]
     D                 -   to decimal digits -> [[1],[1],[2],...,Digits(Fib(V+2))]
                                                call this FibDigits
             Ɗ         -   last three links as a monad - f(V):
       Ṗ               -     pop -> [1..V-1]
        ©              -       (copy this to the register)
          ⁾+=          -     ['+', '=']
         ;             -     concatenate -> [1,2,3,...,V-1,'+','=']
                                            call this Fillers
      ż                -   FibDigits zip with Fillers
                  ¦    -   sparse application...
                 ®     -   ...to indices: recall from register -> [1..V-1]
                $      -   ...action: last two links as a monad:
              ⁶        -     space character
               ṁ       -     mould like (e.g. [[1,4,4],12] -> [[' ',' ',' '], ' ']
                   F   -   flatten
                     Y - join with newlines
                       - implicit print
```
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), [19 bytes](https://chat.stackexchange.com/rooms/240/the-nineteenth-byte)
```
ÞF3l(:n‛+=Y∑꘍,nhL›+
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyIiLCIiLCLDnkYzbCg6buKAmys9WeKIkeqYjSxuaEzigLorIiwiIiwiIl0=)
Outputs infinitely.
```
ÞF3l                # Take the infinite list of Fibonacci numbers, and get overlapping groups of 3
    (               # Looping over that...
          Y∑        # Interleave...
      n             # The tuple of three numbers
       ‛+=          # With '+='
     :      ꘍       # Pad that with the correct amount of spaces, without popping the padding amount
             ,      # Print that
                  + # Add to the padding amount (initially 0)
              nhL›  # The length of the first number in the tuple, plus one.
```
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal) `j`, 30 bytes
```
ÞFẎ3l⟑‛+=fY∑¥$꘍:\=ḟnḢvL₌t¯-h-£
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyJqIiwiIiwiw55G4bqOM2zin5HigJsrPWZZ4oiRwqUk6piNOlxcPeG4n27huKJ2TOKCjHTCry1oLcKjIiwiIiwiMjAiXQ==)
A big cursed mess of formatting and registering.
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), 55 bytes
```
1=1
{`.*\+
$.&$* 
=
+
\d+.(\d+)
$&=$&$*_$1$*_
:`_+
$.&
```
[Try it online!](https://tio.run/##K0otycxL/P@fy9DWkKs6QU8rRptLRU9NRUuBy5ZLmysmRVtPA0hocqmo2aoAheNVDIEEl1VCPFjd//8A "Retina 0.8.2 – Try It Online") Tries to output indefinitely but runs out of memory after about 50 seconds on TIO. Explanation:
```
1=1
```
Initialise the buffer with a hypothetical previous line.
```
{`
```
Repeat indefinitely.
```
.*\+
$.&$* 
```
Replace up to and including the `+` with spaces. (This only applies after the first loop.)
```
=
+
```
Change the `=` into a `+`.
```
\d+.(\d+)
$&=$&$*_$1$*_
```
Append the sum of the two values in unary.
```
:`_+
$.&
```
Convert the unary to decimal and output the result.
[Answer]
# [Python](https://www.python.org), ~~117~~ ~~107~~ ~~103~~ ~~99~~ 88 bytes
```
p="1=1"
while p:=" "*(a:=1+p.find("+"))+eval("f'{%s=}'"%p[a:].replace("=","+")):print(p)
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m72soLIkIz9vwYKlpSVpuhY3IwpslQxtDZW4yjMyc1IVCqxslRSUtDQSrWwNtQv00jLzUjSUtJU0NbVTyxJzNJTS1KtVi21r1ZVUC6ITrWL1ilILchKTUzWUbJV0wOqsCooy80o0CjQh5kOtgVkHAA)
Outputs infinitely.
Can probably be much improved.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), ~~23~~ 22 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
ÌLÅfü3ε„+=.ιJ¯Oú,yнg>ˆ
```
-1 byte after being inspired by [*@JonathanAllan*'s Jelly answer](https://codegolf.stackexchange.com/a/243703/52210)
Outputs the first \$n\$ lines.
[Try it online.](https://tio.run/##ATcAyP9vc2FiaWX//8OMTMOFZsO8M8614oCeKz0uzrlKwq9Pw7osedC9Zz7Lhv//MjD/LS1uby1sYXp5)
Or a minor **22 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)** alternative:
```
ÌLÅfDü3„+=δ.ιJs€g>.¥ú»
```
[Try it online.](https://tio.run/##ATgAx/9vc2FiaWX//8OMTMOFZkTDvDPigJ4rPc60Ls65SnPigqxnPi7CpcO6wrv//zIw/y0tbm8tbGF6eQ)
And the infinite sequence would be **22 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)** as well:
```
∞Åfü3vy„+=.ιJ¯Oú,yнg>ˆ
```
[Try it online.](https://tio.run/##ASsA1P9vc2FiaWX//@KInsOFZsO8M3Z54oCeKz0uzrlKwq9Pw7osedC9Zz7Lhv//)
**Explanation:**
```
Ì              # Increase the (implicit) input-integer by 2
 L             # Pop and push a list in the range [1,input+2]
  Åf           # Get the 0-based n'th Fibonacci value for each of these
    ü3         # Pop and push all overlapping triplets of this list
      ε        # Foreach over the triplets:
               #  (implicitly push the current triplet)
       „+=.ι   #  Intersperse it with "+" and "=" delimiters
            J  #  Join this list together to a string
       ¯       #  Push the global_array (empty by default)
        O      #  Sum it together
         ú     #  Pad the string with that many leading spaces
          ,    #  Pop and output this line with trailing newline
       y       #  Push the pair again
        н      #  Pop and push its first item
         g     #  Pop and push its length
          >    #  Increase it by 1
           ˆ   #  Pop and add it to the global_array
```
[Answer]
# [R](https://www.r-project.org/), 76 bytes
```
l=b=1
repeat{cat(sprintf("%*d+%d=%d
",l,T,b,s<-T+b));l=l+nchar(b)+1;T=b;b=s}
```
[Try it online!](https://tio.run/##BcFBCoAgEADAe88QBG23g2fbX/gBV42CRUS9RW@3mb6WEJPbemklzjfFaUbrT52XUXrPoDPpvCkUDMg4ziMAW@uFBGq6YzdswflA7JnGt9YP "R – Try It Online")
Outputs infinitely.
---
If leading whitespace is allowed:
### [R](https://www.r-project.org/), ~~74~~ 69 bytes
```
b=1
repeat cat(sprintf("%*d+%d=%d
",F<-F+nchar(+T)+1,T,b,b<-T+(T=b)))
```
[Try it online!](https://tio.run/##K/r/P8nWkKsotSA1sUQhObFEo7igKDOvJE1DSVUrRVs1xVY1hUtJx81G1007LzkjsUhDO0RT21AnRCdJJ8lGN0RbI8Q2SVNT8/9/AA "R – Try It Online")
[Answer]
# [Retina](https://github.com/m-ender/retina/wiki/The-Language), 54 bytes
```
K`1+1=2
"$+"+`(\d+)=(\d+)$
$&¶$.%`* $1+$2=$.(*_$2*
A`$
```
[Try it online!](https://tio.run/##K0otycxLNPz/3zvBUNvQ1ohLSUVbSTtBIyZFW9MWTKpwqagd2qaip5qgpaBiqK1iZKuip6EVr2KkxeWYoPL/v5EBAA "Retina – Try It Online") No test suite because of the way the program uses history. Explanation:
```
K`1+1=2
```
Replace the input with the first line of the output.
```
"$+"+`
```
Repeat `n` times.
```
(\d+)=(\d+)$
```
Match `fₙ=fₙ₊₁` from the previous line.
```
$&¶$.%`* $1+$2=$.(*_$2*
```
Append `fₙ+fₙ₊₁=` plus their sum, with the correct amount of indent.
```
A`$
```
Since the program started with one line and appended `n` lines, it now has one line too many, so delete the last line.
[Answer]
# [Bash](https://www.gnu.org/software/bash/), ~~139~~ . . . ~~104~~ 103 bytes
```
_()($[a=b=1];for n in `seq $1`;{ printf "%${s}s";echo -n $a+$b;$[c=a+b,s+=~${#a},a=b,b=c];echo "=$c";})
```
[Try it online!](https://tio.run/##JczBCoMwDADQXwldBko7mLuGfImIJkXRS93MbqX79Srs/ngqttY6Nm2DvbByN9CyH5BgSzDZ/AHsJsrwPrb0XcDdMVsxR3Ncd3gkQPGohH1k8RrM8w/zTUq4qqAchz90jNFRaesIr2c9AQ "Bash – Try It Online")
[Answer]
# [Haskell](https://www.haskell.org/), 89 bytes
```
l!s@[a,b,c]|[x,y,z]<-show<$>s=(l++x++'+':y++'=':z):(' '<$' ':x++l)![b,c,b+c]
f=""![1,1,2]
```
[Try it online!](https://tio.run/##y0gszk7Nyfn/P0ex2CE6USdJJzm2JrpCp1KnKtZGtzgjv9xGxa7YViNHW7tCW1tdW92qEkjZqltVaVppqCuo26gACSugVI6mYjRQs06SdnIsV5qtkpJitKGOoY5R7P/cxMw8BVuF3MQC33iFgtKS4JIinzyFtP8A "Haskell – Try It Online")
`f` is a stream of lines.  
*l*`!`*s* formats current line and computes next triplet *s* and leading whitespace *l*
[Answer]
# [CJam](https://sourceforge.net/p/cjam), ~~49~~ ~~47~~ 45 bytes
```
liX:Y;{[ST*X`_,T)+:T;'+Y:K'=XY+:YN]oK:X;(_}g;
```
[Try it online!](https://tio.run/##S85KzP3/PyczwirSujo6OEQrIiFeJ0RT2yrEWl070spb3TYiUtsq0i8239sqwlojvjbd@v9/Q1MA "CJam – Try It Online")
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~102~~ ~~76~~ 72 bytes
```
b;s;f(a){for(a=b=1;s=printf("%*d+%d",s,a,b);a=b-a)printf("=%d\n",b+=a);}
```
[Try it online!](https://tio.run/##NckxDoAgDEDR3VMQEpJWcHBuehOXAsE4iAbciGdHFv/4X1j2EHr3VCmBYEtXAWHPK1W@y5GfBNrM0ZqoXXXiPNLgRfBHNnHL2nnLgvT2MdUpRwZUbVKjBEjT2z8 "C (gcc) – Try It Online")
*Saved a whopping 26 bytes thanks to [ceilingcat](https://codegolf.stackexchange.com/users/52904/ceilingcat)!!!*  
*Saved 3 bytes thanks to [m90](https://codegolf.stackexchange.com/users/104752/m90)!!!*
Outputs *forever*!
[Answer]
# [Julia 1.0](http://julialang.org/), ~~66~~ 65 bytes
```
f(a=1,b=1,n=0)=print(" "^n,"$a+$b=$(a+b)
")f(b,a+b,n-~ndigits(a))
```
[Try it online!](https://tio.run/##yyrNyUw0rPj/P00j0dZQJwmI82wNNG0LijLzSjSUFJTi8nSUVBK1VZJsVTQStZM0uZQ00zSSdIBMnTzduryUzPTMkmKNRE1NoAma/wE "Julia 1.0 – Try It Online")
prints infinitely. To avoid `Int64` overflow, replace `a=1` with `a=big(1)` (+5 bytes)
[Answer]
# [Python 3](https://docs.python.org/3/), ~~146~~ 141 bytes
```
print("1+1=2")
a=[1,1,2]
w=2
while 1:print(" "*w+str(a[1])+"+"+str(a[2])+"="+str(a[1]+a[2]));del a[0];w+=len(str(a[0]))+1;a.append(a[0]+a[1])
```
[Try it online!](https://tio.run/##PYzBCsMgEETvfoV40m4oWXur7JeIh4UICYiVVJB8vU1NKXN684YpR11f@dF72bdctUJAssoIJo8TTjaIRla0dUtR4vM3kurW4F13zR6DAXXmIvslUn8HozJuiUmyn4NrQClmffn5VICO71xKzMtoYFz2/gE "Python 3 – Try It Online")
[Answer]
# [Japt](https://github.com/ETHproductions/japt) [`-mR`](https://codegolf.meta.stackexchange.com/a/14339/), ~~23~~ 22 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
Includes a trailing space on each line of output.
```
"+= "¬ËiMg°UÃvÈùT±XÊÃ¬
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&flags=LW1S&code=Iis9ICKsy2lNZ7BVw3bI%2bVSxWMrDrA&input=MjA)
```
"+= "¬ËiMg°UÃvÈùT±XÊÃ¬     :Implicit map of each U in the range [0,input)
"+= "¬                     :  Split "+= " to an array of characters
      Ë                    :  Map
       i                   :    Prepend
          °U               :      Prefix increment U
        Mg                 :      Get the Uth Fibonacci number, 0-indexed
            Ã              :  End map
             v             :  Modify the first element
              È            :  By passing it through the following function as X
               ù           :    Left pad with spaces to length
                T±         :      Increment T (initially 0) by
                  XÊ       :        Length of X
                    Ã      :  End modification
                     ¬     :  Join
                           :Implicit output joined with newlines
```
[Answer]
# [Scala](http://www.scala-lang.org/), ~~228~~ ~~226~~ 225 bytes
Saved 3 bytes thanks to the comment of @ceilingcat
---
Golfed version. [Try it online!](https://tio.run/##LYzBqsIwEEV/ZShdTGws9i0rKbgU1K0LecgkTdtIHYPJQhS/va/Gt5jh3DvMCYZGmqabvlgTYU@OwT6i5TbAxvtXazvokOstR6FS6pE@Seq0v5d650I84af4H/GrGK4UzfAyFCysVHNwIyQ@qwZJakmFFnXdYyLJy0q81z1WspI8U4c/K1E@nT@6OGy5tY/ySj7ZML0bIZ2YVRlAtnCiCFlORa5VbrJ32d3ulsyA/u44jrNvmv4A)
```
object Main extends App{def f(n:Int)={def g(a:Int,b:Int,n:Int):List[(Int,Int,Int)]=n match{case 0=>Nil case _=>(a,b,a+b)::g(b,a+b,n-1)};g(1,1,n)};f(20).zipWithIndex.map{case((a,b,c),i)=>("  "*i)+s"$a+$b=$c"}.foreach(println)}
```
Ungolfed version. [Try it online!](https://tio.run/##hVHBTsMwDL33K56qHhIo1bZjpSFxYxJw2YEDmlCSZjQoS0sboQm0by9um45ymJAS23Ls5/fiVgkruq6S71p5PArjoI9eu6LFXV3jOwLoFHqPfdUchH8wrWeWTI4@fGEb51NMhu94yG99Y9zbDusBAuhbsi9TPxtfblyhj9lBEDyGR0CJVoMxkUKmUDyF4VjfgsWIcQW2ImM4xzXaOBHkEknIiYqH9lM03omokZUTSpmt/mAuH3hdYHumF/ruta11w0Q@1sjg/wVxoK9RZQALcha9gidj57nXQdUos9chOfJ8NnlK00zcYMnP@jArWqag4/iv7E9hw368LojPbFd/fmO14H3XuTSjSAtVspq25S1BnqKu@wE)
```
object Main extends App {
  
  def formatList(list: List[(Int, Int, Int)]): List[String] = {
    list.zipWithIndex.map { 
      case ((a, b, c), i) => (" " * (2 * i)) + s"$a + $b = $c"
    }
  }
  
  def fibonacciSeq(n: Int): List[(Int, Int, Int)] = {
    def fibHelper(a: Int, b: Int, n: Int): List[(Int, Int, Int)] = n match {
      case 0 => Nil
      case _ => (a, b, a + b) :: fibHelper(b, a + b, n - 1)
    }
    fibHelper(1, 1, n)
  }
  
  val formatted = formatList(fibonacciSeq(20))
  formatted.foreach(println)
}
```
]