[Question]
  [
Your challenge is to exactly output the following box:
```
..................................................
..................................................
..                                              ..
..                                              ..
..  ++++++++++++++++++++++++++++++++++++++++++  ..
..  ++++++++++++++++++++++++++++++++++++++++++  ..
..  ++                                      ++  ..
..  ++                                      ++  ..
..  ++  ..................................  ++  ..
..  ++  ..................................  ++  ..
..  ++  ..                              ..  ++  ..
..  ++  ..                              ..  ++  ..
..  ++  ..  ++++++++++++++++++++++++++  ..  ++  ..
..  ++  ..  ++++++++++++++++++++++++++  ..  ++  ..
..  ++  ..  ++                      ++  ..  ++  ..
..  ++  ..  ++                      ++  ..  ++  ..
..  ++  ..  ++  ..................  ++  ..  ++  ..
..  ++  ..  ++  ..................  ++  ..  ++  ..
..  ++  ..  ++  ..              ..  ++  ..  ++  ..
..  ++  ..  ++  ..              ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++++++++++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++++++++++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++      ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++      ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++  ..  ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++  ..  ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++      ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++      ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++++++++++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++++++++++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..              ..  ++  ..  ++  ..
..  ++  ..  ++  ..              ..  ++  ..  ++  ..
..  ++  ..  ++  ..................  ++  ..  ++  ..
..  ++  ..  ++  ..................  ++  ..  ++  ..
..  ++  ..  ++                      ++  ..  ++  ..
..  ++  ..  ++                      ++  ..  ++  ..
..  ++  ..  ++++++++++++++++++++++++++  ..  ++  ..
..  ++  ..  ++++++++++++++++++++++++++  ..  ++  ..
..  ++  ..                              ..  ++  ..
..  ++  ..                              ..  ++  ..
..  ++  ..................................  ++  ..
..  ++  ..................................  ++  ..
..  ++                                      ++  ..
..  ++                                      ++  ..
..  ++++++++++++++++++++++++++++++++++++++++++  ..
..  ++++++++++++++++++++++++++++++++++++++++++  ..
..                                              ..
..                                              ..
..................................................
..................................................
```
The box is height and width 50, spaces are two wide.
You must write a function or program which outputs or returns a string and takes no input.
Fewest bytes wins!
  
[Answer]
## [J](http://jsoftware.com/), 25 bytes
```
echo'. + '{~4|>./~2#|i:12
```
[Try it online!](https://tio.run/nexus/j#@5@anJGvrqegraBeXWdSY6enX2ekXJNpZWj0/z8A "J – TIO Nexus")
## Explanation
```
echo'. + '{~4|>./~2#|i:12
                     i:12  Range from -12 to 12.
                    |      Take absolute values,
                  2#       duplicate every element,
                /~         compute "multiplication table"
              >.           using maximum,
            4|             take mod 4 of every element,
    '. + '{~               index into this string,
echo                       print char matrix for everyone to see.
```
[Answer]
# C, 115 bytes
```
#define M(x,y)x<(y)?x:y
f(i){for(i=2549;i;i--)putchar(i%51?". + "[(M(i%51-1,M(50-i%51,M(i/51,49-i/51))))/2%4]:10);}
```
Defines a function `f` (call as `f();`) that prints the string to STDOUT.
[Answer]
## Pyke, ~~20~~ 17 bytes
```
k25V". + "[[email protected]](/cdn-cgi/l/email-protection)
```
[Try it here!](http://pyke.catbus.co.uk/?code=k25V%22.+%2B+%22ohe%40A.X)
```
k                 - out = ""
 25V              - repeat 25 times:
          oh      -     (o++)+1
            e     -    ^//2
    ". + "   @    -   " + ."[^] (wraps around)
              A.X -  out = surround(out, ^)
```
The surround function was made for [kolmogorov-complexity](/questions/tagged/kolmogorov-complexity "show questions tagged 'kolmogorov-complexity'") questions like this!
[Answer]
# C, ~~535~~ ~~478~~ 477 Bytes
Now that's a lot of golf :-/
```
i;main(j){for(;++i<51;puts(""))for(j=0;++j<51;)putchar(i<3|i>48?46:j<3|j>48?46:i>4&i<47&j>4&j<47?i<7|(i>44&i<47)|(j>2&j<7)|(j>44&j<47)?43:j>8&j<43&((i>8&i<11)|(i>40&i<43))?46:i>9&i<41&((j>8&j<11)|(j>40&j<43))?46:i>13&i<37&((j>12&j<15)|(j>36&j<39))?43:((i>12&i<15)|(i>36&i<39))&j>12&j<39?43:i>17&i<33&((j>16&j<19)|(j>32&j<35))?46:((i>16&i<19)|(i>32&i<35))&j>16&j<35?46:i>21&i<29&((j>20&j<23)|(j>28&j<31))?43:((i>20&i<23)|(i>28&i<31))&j>20&j<31?43:i>24&i<27&j>24&j<27?46:32:32);}
```
Here's the output;
```
..................................................
..................................................
..                                              ..
..                                              ..
..  ++++++++++++++++++++++++++++++++++++++++++  ..
..  ++++++++++++++++++++++++++++++++++++++++++  ..
..  ++                                      ++  ..
..  ++                                      ++  ..
..  ++  ..................................  ++  ..
..  ++  ..................................  ++  ..
..  ++  ..                              ..  ++  ..
..  ++  ..                              ..  ++  ..
..  ++  ..  ++++++++++++++++++++++++++  ..  ++  ..
..  ++  ..  ++++++++++++++++++++++++++  ..  ++  ..
..  ++  ..  ++                      ++  ..  ++  ..
..  ++  ..  ++                      ++  ..  ++  ..
..  ++  ..  ++  ..................  ++  ..  ++  ..
..  ++  ..  ++  ..................  ++  ..  ++  ..
..  ++  ..  ++  ..              ..  ++  ..  ++  ..
..  ++  ..  ++  ..              ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++++++++++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++++++++++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++      ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++      ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++  ..  ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++  ..  ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++      ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++      ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++++++++++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++++++++++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..              ..  ++  ..  ++  ..
..  ++  ..  ++  ..              ..  ++  ..  ++  ..
..  ++  ..  ++  ..................  ++  ..  ++  ..
..  ++  ..  ++  ..................  ++  ..  ++  ..
..  ++  ..  ++                      ++  ..  ++  ..
..  ++  ..  ++                      ++  ..  ++  ..
..  ++  ..  ++++++++++++++++++++++++++  ..  ++  ..
..  ++  ..  ++++++++++++++++++++++++++  ..  ++  ..
..  ++  ..                              ..  ++  ..
..  ++  ..                              ..  ++  ..
..  ++  ..................................  ++  ..
..  ++  ..................................  ++  ..
..  ++                                      ++  ..
..  ++                                      ++  ..
..  ++++++++++++++++++++++++++++++++++++++++++  ..
..  ++++++++++++++++++++++++++++++++++++++++++  ..
..                                              ..
..                                              ..
..................................................
..................................................
```
[Answer]
## Haskell, 72 bytes
```
q=(\n->[n,n]).abs=<<[-12..12]
unlines[[". + "!!mod(max x y)4|y<-q]|x<-q]
```
[@Zgarb's solution](https://codegolf.stackexchange.com/a/106766/34531) in Haskell. I've also tried to construct the box by adding layers around the core `["..",".."]`, but it is 9 bytes longer (81 bytes).
```
e!b=e:e:b++[e,e];s#c=(c!)<$>(c<$s!!0)!s
unlines$foldl(#)["..",".."]" + . + . + ."
```
[Answer]
# Stacked, noncompeting, 35 bytes
[Try it here!](https://conorobrien-foxx.github.io/stacked/stacked.html)
```
ε'.'3$' + .'2*tostr*+$surroundfold
```
Ungolfed:
```
'' '.  ++  ..  ++  ..  ++  ..' $surround fold
```
Quite simple. `surround` is a function that, well, surrounds an entity with a fill entity. For example, `(0) 1 surround` is `((1 1 1) (1 0 1) (1 1 1))`. `$surround` is `surround` as a function, not evaluated. `fold` takes an initial value, then something to fold over, then a function. In this case, `surround` is `fold`ed, surrounding the initially empty string `''` (equiv. `ε`) with each character of the string.
```
'.'3$' + .'2*tostr*+
```
This is first making a character string `$' + .'`, that, when multiplied by a number, repeats each character. This leaves us with: `++ ..`. This is then casted to a string. Then, we repeat this string thrice, and finally prepend a `.`, giving us the desired string.
---
A different approach for 39 bytes:
```
' .'3$' + .'2*tostr*+toarr$surround#\out
```
`#\` is insert and takes the initial char of the string as the starting value. It also only works on Arrays.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 18 bytes
```
12ŒRAx2»þ`ị“ + .”Y
```
[Try it online!](https://tio.run/nexus/jelly#AR4A4f//MTLFklJBeDLCu8O@YOG7i@KAnCArIC7igJ1Z//8 "Jelly – TIO Nexus")
Same approach as Zgarb’s J answer: `12ŒRA` is `abs([-12 … 12])`, `x2` repeats every element twice, `»þ`` creates a table of maximums, `ị“ + .”` cyclically indexes into a string, and `Y` joins by newlines.
[Answer]
## JavaScript (ES6), 117 bytes
```
f=(n=12,c=`. + `[n%4],t=c.repeat(n*4+2))=>n?t+`
${t}
${f(n-1).replace(/^|$/gm,c+c)}
${t}
`+t:`..
..`
console.log(f())
```
Nonrecursive solution took me 128 bytes:
```
console.log([...Array(100)].map((_,i,a)=>a.map((_,j)=>`. + `[j=j>50?j-50:51-j,(i>j?i:j)%8>>1],i=i>50?i-50:51-i).join``).join`\n`)
```
Where `\n` represents the literal newline character.
[Answer]
# C, 97 bytes
```
i,x,y;main(){for(;i<2550;putchar(++i%51?". + "[(x*x<y*y?y:x)&3]:10))x=i%51/2-12,y=i/102-12;}
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~39~~ ~~35~~ 33 bytes
```
•â3fM~•3B…012… .+‡.pvyD¤sg25s-×«Â«})Â«»
```
[Try it online!](https://tio.run/nexus/05ab1e#@6@kp6CtoORyeIeX8eHp6nqHVusVlFUeWmJkWpmue3j6odWHmw6trtUEkYd2//8PAA "05AB1E – TIO Nexus")
```
•â3fM~•3B                               # Push 1100220011002200110022001
         …012… .+‡                      # Push ..  ++  ..  ++  ..  ++  .
                  .p                    # All prefixes of the above string.
                    vy            }     # For each prefix.
                      D¤sg25s-×         # Repeat the last letter until length is 25.
                               «Â«      # Concat, bifurcate, concat.
                                   )Â«» # Wrap to array, bifurcate, concat, print.
```
---
33 Byte version that is cooler now because Emigna commented saving me 2 bytes:
```
". + "DøJ3×'.«.pvy¤25yg-×«Â«})Â«»
```
[Try it online!](https://tio.run/nexus/05ab1e#@6@kp6CtoORyeIeX8eHp6nqHVusVlFUeWmJkWpmue3j6odWHmw6trtUEkYd2//8PAA "05AB1E – TIO Nexus")
[Answer]
# [Python 3](https://docs.python.org/3/), 89 bytes
```
r=range(-24,26)
for i in r:print("".join([". + "[max(abs(i//2),abs(j//2))%4]for j in r]))
```
[Try it online!](https://tio.run/##K6gsycjPM/7/v8i2KDEvPVVD18hEx8hMkystv0ghUyEzT6HIqqAoM69EQ0lJLys/M08jWklPQVtBKTo3sUIjMalYI1Nf30hTB8TKArE0VU1iQXqzwHpjNTX//wcA "Python 3 – Try It Online")
[Answer]
# [MATL](https://github.com/lmendo/MATL), 21 bytes
```
'. + '[]25:"TTYaQ]2/)
```
[Try it online!](https://tio.run/nexus/matl#@6@up6CtoB4da2RqpRQSEpkYGGukr/n/PwA "MATL – TIO Nexus")
```
'. + '    % Push this string
[]        % Push empty array. This will be used as "seed"
25:"      % Do the following 25 times
  TTYa    %   Extend the array with a frame of zeros
  Q       %   Add 1 to each entry
]         % End
2/        % Divide by 2
)         % Index modularly into the string. Non-integer indices are rounded
          % Implicitly display
```
[Answer]
# Octave, 53 bytes
```
 '.  ++  .'(mod(bsxfun(@max,x=[24:-1:0 0:24],x'),8)+1)
```
Generate repeating pattern of 1 to 8 from center outward and use it as the index for extraction of elements of `. ++ .`
[Try It Online!](https://tio.run/#qss1A)
[Answer]
# Ruby, 77 bytes
```
-623.upto(676){|i|print i%26>0?". + "[[(i%26-13).abs,(i/52).abs].max%4]*2:$/}
```
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 25 bytes
```
Ｆ…¹¦²⁶⁺×ι§. + ÷ι²¶‖Ｏ↗‖Ｃ↑←
```
[Try it online!](https://tio.run/##RcmxCsIwEIDhvU9xZLqzqWIHhzqJkyAoATeXEC9tICQhhqJPH9vJf/x@M@lsova12pgBlQ4j415CfyBqYOmeXSjY4gadhFO5hBd/UGyhBQG71XoiAvEMgujYKLaeTbnNnL1OODyScuNU/ucc03dlCcOV7TJqrd1cu7f/AQ "Charcoal – Try It Online") Link contains verbose mode for explanation
[Answer]
**Haskell, 385 Bytes** 
```
    b 0 = ["..", ".."]
b n = f:f:s:s:m (b (n - 1)) ++s:s:f:f:[]
    where f = replicate (8*n+2) $ d
          s = l++replicate ((8*n)-6) ' ' ++r
          m (x:xs) = map (\x -> l ++ x ++ r ) $ t
          l = d:d:' ':' ':[]
          r = reverse l
          t = b (n - 1)
          d :: Char
          d | n `mod` 2 == 0 = '.'
            | n `mod` 2 == 1 = '+'
main = mapM_ putStrLn $ b 6
```
First round of code golf here... looking forward to seeing how others tackle this one. 
Output:
```
..................................................
..................................................
..                                              ..
..                                              ..
..  ++++++++++++++++++++++++++++++++++++++++++  ..
..  ++++++++++++++++++++++++++++++++++++++++++  ..
..  ++                                      ++  ..
..  ++                                      ++  ..
..  ++  ..................................  ++  ..
..  ++  ..................................  ++  ..
..  ++  ..                              ..  ++  ..
..  ++  ..                              ..  ++  ..
..  ++  ..  ++++++++++++++++++++++++++  ..  ++  ..
..  ++  ..  ++++++++++++++++++++++++++  ..  ++  ..
..  ++  ..  ++                      ++  ..  ++  ..
..  ++  ..  ++                      ++  ..  ++  ..
..  ++  ..  ++  ..................  ++  ..  ++  ..
..  ++  ..  ++  ..................  ++  ..  ++  ..
..  ++  ..  ++  ..              ..  ++  ..  ++  ..
..  ++  ..  ++  ..              ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++++++++++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++++++++++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++      ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++      ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++  ..  ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++  ..  ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++      ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++      ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++++++++++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++++++++++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..              ..  ++  ..  ++  ..
..  ++  ..  ++  ..              ..  ++  ..  ++  ..
..  ++  ..  ++  ..................  ++  ..  ++  ..
..  ++  ..  ++  ..................  ++  ..  ++  ..
..  ++  ..  ++                      ++  ..  ++  ..
..  ++  ..  ++                      ++  ..  ++  ..
..  ++  ..  ++++++++++++++++++++++++++  ..  ++  ..
..  ++  ..  ++++++++++++++++++++++++++  ..  ++  ..
..  ++  ..                              ..  ++  ..
..  ++  ..                              ..  ++  ..
..  ++  ..................................  ++  ..
..  ++  ..................................  ++  ..
..  ++                                      ++  ..
..  ++                                      ++  ..
..  ++++++++++++++++++++++++++++++++++++++++++  ..
..  ++++++++++++++++++++++++++++++++++++++++++  ..
..                                              ..
..                                              ..
..................................................
..................................................
```
[Answer]
## C#, 203 bytes
Complete, readable program:
```
using System;
public class P
{
    public static void Main(string[] a)
    {
        Func<string> f = () =>
        {
            var z = 25;
            var t = "";
            Func<int, string> c = (q) => q % 4 == 0 ? ".." : (q % 4 != 2 ? "  " : "++");
            for (var y = 0; y < z; y++)
            {
                var l = "";
                for (var x = 0; x < z; x++)
                        l += ((y > z / 2) ? (x >= y | x < z - y) : (x < y | x >= z - y)) ? c(x):c(y);
                l += "\n";
                t += l + l;
            }
            return t;
        };
        Console.Write(f());
        Console.ReadKey();
    }
}
```
Golfed **function**:
```
()=>{var z=25;var t="";Func<int,string>c=(q)=>q%4==0?"..":(q%4!=2?"  ":"++");for(var y=0;y<z;y++){var l="";for(var x=0;x<z;x++)l+=((y>z/2)?(x>=y|x<z-y):(x<y|x>=z-y))?c(x):c(y);l+="\n";t+=l+l;}return t;};
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 33 bytes
```
14G" . +"NL¤¸13N-.×«€D¨Â«èD})¨Â«»
```
[Try it online!](https://tio.run/nexus/05ab1e#@29o4q6koKegreTnc2jJoR2Gxn66eoenH1r9qGmNy6EVh5sOrT68wqVWE8I8tPv/fwA "05AB1E – TIO Nexus")
**Explanation**
```
14G                               # for N in [1 ... 13]
   " . +"                         # push this string
         NL                       # push range [1 ... N]
           ¤¸13N-.×               # push a list of 13-N repetitions 
                                  # of the last element of the above range
                   «              # concatenate the two ranges
                    €D            # duplicate each element
                      ¨           # remove the last element
                       Â«         # concatenate a reversed copy to the list
                         è        # use the elements of the list to index into the string
                          D       # duplicate the resulting string
                           }      # end loop
                            )     # wrap the strings in a list
                             ¨    # remove the last element
                              Â«  # concatenate a reversed copy
                                » # join the list on newlines
```
[Answer]
# [PowerShell](https://github.com/PowerShell/PowerShell), ~~171~~ 151 bytes
```
($x=(1..12|%{' . +'[$_%4]}|%{($a+=$_+$_)})+"$a."|%{$c=if(++$i%2){('+','.')[($b=!$b)]}else{' '};$_.PadRight(25,$c)}|%{,($_+-join$_[25..0])*2});$x[23..0]
```
[Try it online!](https://tio.run/nexus/powershell#FcxBDoIwEEDRqyAZMjMOTqTKivQOxm1DGkDUGqMLXZBgz45l@f/iLQSTpUq1Mr9ixkwzQQe@OLYxNUEnFryA58iSQ6d5ujDYcCURCIXhmVCwREV2BL3dQM9tHJ@fMWEYG/B66i7ncLt/ydQlDLy6JSV093iHF3hnatV9y1sTuYHJmcOay/IH "PowerShell – TIO Nexus")
Ho-hum answer. I'm sure there's a shorter way (given the lengths of the other answers, I'm confident), but this shows some neat tricks.
### Explanation:
`1..12|%{' . +'[$_%4]}` generates an array of strings (of one character in length), in the correct pattern we need. [Try it online!](https://tio.run/nexus/powershell#@2@op2doVKNara6gp6CtHq0Sr2oSW/v/PwA "PowerShell – TIO Nexus")
We then add on `|%{($a+=$_+$_)})+"$a."` which takes the array and expands it sideways based on the previous row. [Try it online!](https://tio.run/nexus/powershell#@69hqKdnaFSjWq2uoKegrR6tEq9qElsL5GuoJGrbqsRrq8Rr1mpqK6kk6in9/w8A "PowerShell – TIO Nexus")
Those strings are then sent into a loop, `|%{$c=if(++$i%2){('+','.')[($b=!$b)]}else{' '};$_.PadRight(25,$c)}`. Each iteration, we're choosing the correct character (either a plus, a dot, or a space), and then using the `.PadRight` function to pad out to the appropriate number of characters. [Try it online!](https://tio.run/nexus/powershell#DcxBCsIwEEbhq9Tyh5lhykCDriR3ELelhLRWDXSnu5qzxyzft3iVR7PR/9xBnXVKE6I7z6U1I2lAVEQpoj2S9U2xhvxkVWTn5WBSGshIJsYSTlhkLtv@2dqMyhXRbulxz6/3l/1lwCql1j8 "PowerShell – TIO Nexus")
Now, we have the foundation of the upper-right corner. We need to reverse each string `|%{,($_+-join$_[($z=25..0)])*2}` and append them together so we can get the top of the block. This is done with the `-join` command and indexing backward `25..0`. Additionally, we encapsulate the strings in an array `,(...)` and make 'em double `*2` so we get the whole top. [Try it online!](https://tio.run/nexus/powershell#FcwxDsIwDEDRq5TKkW0cLBrRCeUOiLWKoraUEoRggK3k7CWM/w9vpUa1cV@zYKWVYAfRHEIuTdCLhygQObPU0GtdLow@XUkEknG8EApaVOSOYPAbGDjk6fGeCob5CFFP/eWc5tuHXGth5L9rqaC7@ys9IXauVd0H3rq8rj8 "PowerShell – TIO Nexus")
That is all stored into `$x` and encapsulated in parens so it places the strings on the pipeline. Finally, we reverse `$x` (being sure to snip out the duplicate-duplicate middle row, else we'd have four `..` in the middle) and leave those on the pipeline. An implicit `Write-Output` sticks a newline between the strings, so we get that for free.
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), ~~90~~ ~~75~~ 69 bytes
```
($r=25..1+1..25)|%{$y=$_
-join($r|%{'..  ++  '[($_,$y)[$_-lt$y]%8]})}
```
[Try it online!](https://tio.run/##K8gvTy0qzkjNyfn/X0OlyNbIVE/PUNtQT8/IVLNGtVql0lYlnks3Kz8zDygLFFDX01NQ0NZWUFCP1lCJ11Gp1IxWidfNKVGpjFW1iK3VrP3/HwA "PowerShell – Try It Online")
[Answer]
# Bash, ~~191~~ 184 bytes
```
echo H4sIALBITF4CA72WuQ0AIAzEeqagR8r+47EAgTyH01BZApPPLBvDKshMRR1Z4eghsUv1kbdcDfKSq0LucnXITa4S8eVqEU+uGjnL1SMnuT8Q/1QixFuIfyFyjKgXovaJPkb0ZGK+ELOSmPvEDkPsYxvgYU8W9gkAAA|base64 -d|gunzip
```
Can probably get smaller, but was smaller than my algorithmic attempts.
Update: Use --best on gzip for great power. Thanks orthoplex.
[Answer]
# [Perl 5](https://www.perl.org/), ~~137~~ ~~135~~ ~~132~~ 123 bytes
```
for$i(0..24){$e=49-$i;map{$a[$_][$i]=$a[$_][$e]=$a[$i][$_]=$a[$e][$_]=substr'. + ',$i%8/2,1}$i..$e}print join'',@$_,$/for@a
```
[Try it online!](https://tio.run/##K0gtyjH9/z8tv0glU8NAT8/IRLNaJdXWxFJXJdM6N7GgWiUxWiU@NlolM9YWxkyFMDNjQVwwMxXCLC5NKi4pUtdT0FZQ11HJVLXQN9IxrFXJ1NNTSa0tKMrMK1HIys/MU1fXcVCJ11HRB9rqkPj/PwA "Perl 5 – Try It Online")
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), 21 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
". + "12Ýû€Dã€ßèJ50ô»
```
Inspired by [*@Zgarb*'s J answer](https://codegolf.stackexchange.com/a/106766/52210), so make sure to upvote him as well.
[Try it online.](https://tio.run/##yy9OTMpM/f9fSU9BW0HJ0Ojw3MO7HzWtcTm8GEgenn94hZepweEth3b//w8A)
**Explanation:**
```
    12Ý              # Push a list in the range [0,12]
       û             # Palindromize it: [12,11,10,...,2,1,0,1,2,...,10,11,12]
        €D           # Duplicate each item in this list: [12,12,11,11,10,10,...]
          ã          # Create all possible pairs by taking the cartesian product with itself
           €ß        # For each pair, leave the lowest value
". + "       è       # (0-base) index those into the string ". + "
              J      # Join all those characters together to a single string
               50ô   # Split it into 50 lines
                  »  # And join those by newlines
                     # (after which the result is output implicitly)
```
]