[Question]
  [
## Background
*Note: This configuration was co-found by one of our fellow code golf enthusiasts, [Zgarb](https://codegolf.stackexchange.com/users/32014/zgarb)*
A [29 year old conjecture by John Conway](https://cp4space.hatsya.com/2022/01/14/conway-conjecture-settled/) about the Game of Life was recently solved.
To quote Conway from the linked article:
> 
> Indeed, is there a Godlike still-life, one that can only have existed
> for all time (apart from things that don’t interfere with it)?
> 
> 
> 
That is, a configuration in the game of life that could not have evolved but, if it exists, must have been part of the game's starting condition?
The answer is yes, such still-lifes do exist, and the first one discovered looks like this:
[![Primordial Still Life](https://i.stack.imgur.com/RNn7u.png)](https://i.stack.imgur.com/RNn7u.png)
## Task
The challenge is simple: output this 22 by 28 primordial still-life as ascii text.
Fewest bytes wins.
Notes:
* You can choose any characters you like to represent live and dead cells.
* Trailing whitespace is allowed.
* Allowed loophole: If you discover a *different* primordial still life, you may output that.
Here it is with `x` for dead and  for live:
```
      xxxx  xxxx  xxxx  x   
   xx x  xx x  xx x  xx x   
   x xx  x xx  x xx  x xx   
xxxx  xxxx  xxxx  xxxx  xxx 
  x xx  x xx  x xx  x xx  x 
 x  xx x  xx x  xx x  xx x  
xxxx  xxxx  xxxx  xxxx  xxxx
x  xx x  xx x  xx x  xx x  x
x  x xx  x xx  x xx  x xx  x
xxxx  xxxx  xxxx  xxxx  xxxx
  x xx  x xx  x xx  x xx  x 
 x  xx x  xx x  xx x  xx x  
xxxx  xxxx  xxxx  xxxx  xxxx
x  xx x  xx x  xx x  xx x  x
x  x xx  x xx  x xx  x xx  x
xxxx  xxxx  xxxx  xxxx  xxxx
  x xx  x xx  x xx  x xx  x 
 x  xx x  xx x  xx x  xx x  
 xxx  xxxx  xxxx  xxxx  xxxx
   xx x  xx x  xx x  xx x   
   x xx  x xx  x xx  x xx   
   x  xxxx  xxxx  xxxx      
```
And here it is with `1` for dead and `0` for live:
```
0000001111001111001111001000
0001101001101001101001101000
0001011001011001011001011000
1111001111001111001111001110
0010110010110010110010110010
0100110100110100110100110100
1111001111001111001111001111
1001101001101001101001101001
1001011001011001011001011001
1111001111001111001111001111
0010110010110010110010110010
0100110100110100110100110100
1111001111001111001111001111
1001101001101001101001101001
1001011001011001011001011001
1111001111001111001111001111
0010110010110010110010110010
0100110100110100110100110100
0111001111001111001111001111
0001101001101001101001101000
0001011001011001011001011000
0001001111001111001111000000
```
  
[Answer]
# [Nibbles](http://golfscript.com/nibbles), 37 33 bytes
```
?, &" ";3
    ! = $ `. ;~ `/ $ `D -2 
                :;!$ `' \@:.\$\$
             `'<14>>^_$
      `. 5 ~/$~
      ~ >@$
   @$ ~
15a
```
That's 66 nibbles, each taking half a byte in the binary form.
This could probably be improved, and will definitely be beaten by the things that specialize in ascii art as it uses rotate which nibbles doesn't have as a built in. BTW the trivially binary encoded way is 82 bytes in nibbles (use `D -2 and reverse the result to deal with 0 prefixes).
Run it like this:
```
> nibbles life.nbl
      aaaa  aaaa  aaaa  a   
   aa a  aa a  aa a  aa a   
   a aa  a aa  a aa  a aa   
aaaa  aaaa  aaaa  aaaa  aaa 
  a aa  a aa  a aa  a aa  a 
 a  aa a  aa a  aa a  aa a  
aaaa  aaaa  aaaa  aaaa  aaaa
a  aa a  aa a  aa a  aa a  a
a  a aa  a aa  a aa  a aa  a
aaaa  aaaa  aaaa  aaaa  aaaa
  a aa  a aa  a aa  a aa  a 
 a  aa a  aa a  aa a  aa a  
aaaa  aaaa  aaaa  aaaa  aaaa
a  aa a  aa a  aa a  aa a  a
a  a aa  a aa  a aa  a aa  a
aaaa  aaaa  aaaa  aaaa  aaaa
  a aa  a aa  a aa  a aa  a 
 a  aa a  aa a  aa a  aa a  
aaaa  aaaa  aaaa  aaaa  aaaa
a  aa a  aa a  aa a  aa a  a
a  a aa  a aa  a aa  a aa  a
aaaa  aaaa  aaaa  aaaa  aaaa
  a aa  a aa  a aa  a aa  a 
 a  aa a  aa a  aa a  aa a  
 aaa  aaaa  aaaa  aaaa  aaaa
   aa a  aa a  aa a  aa a   
   a aa  a aa  a aa  a aa   
   a  aaaa  aaaa  aaaa      
```
## How?
It starts with the basic building block of
```
# #
 ##
 #
```
which concatenated as bits is 346 or 15a in hex. This is extracted to space and 'a' with ``D -2` and put into groups of 3 with ``/ 3`
It then rotates this clockwise with transpose of the reverse ``'\` and appends the lines with `! <lhs> <rhs> :`
Finally this is rotated 180 degrees by reversing it and each line.
This constructs the basic square that you can see in the image with the hairs going out.
```
a a  a
 aaaa 
 a  aa
aa  a 
 aaaa 
a  a a
```
This is then replicated 3 times x and y and truncated to the window (14). Then we remove 5,2,1 spaces (generated by iterating /2 starting from 5) from the front using a zip with a custom fn (drop). This is justified with `&" "` using a size of 3, but really any value <= 14 would work since it also checks the max size of any element. 3 is used because that value is saved and used in 3 other places (saving 1 nibble each in binary form).
```
      aaaa  aa
   aa a  aa a 
   a aa  a aa 
aaaa  aaaa  aa
  a aa  a aa  
 a  aa a  aa a
aaaa  aaaa  aa
a  aa a  aa a 
a  a aa  a aa 
aaaa  aaaa  aa
  a aa  a aa  
 a  aa a  aa a
aaaa  aaaa  aa
a  aa a  aa a 
```
The really cool thing is that the final product can also be constructed by a rotation of this. And so this rotation code is saved as a function using `;~`. It is a bit awkward to call as it needs to know the return type by calling it on some function before it is finished being defined. But here we want to call it on the result of calling it, which can't be done. So instead I take the result and put it into an if statement on a list `?,` it will be true and inside the true clause `$` will be the value we want to call the function on. The `<14>>^3` code was also repeated and had the same issue, but here I used iteration and took the 3rd element so that the code was applied twice.
Edit: Zgarb confirmed that the 28x28 version is also a still life (it is fully rotationally symmetric). This saved 2 bytes by not having to do `<11` to trunctate during the final rotation. Thanks!
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 131 bytes
```
Uncompress@"1:eJxTTMoPCt7DxMBgAAaGQIBGAkVjDAyNwJIGhthIuLwBRAM6CZbHYjKMhOrHpR0qj9VqCEnAfEOwPG7tcHlcDiDG/JHufgOC5lOWfsDyWMwHAQA6Moq3"
```
[Try it online!](https://tio.run/##BcFtCoIwAADQq4QXqIiUgqC5yaa1plJKRT/WUKf57WR6enuv4komFVe54AtfnZZHLZqq7ZNhOBvbY@JN9zttfKgsNFE7A4DjwLUx@EUFAvNNey6WSrrjVdshoCZ8fcmzuFDJetKGm644RB10apA6TPvYUoKUAuUIrz0yphmD@5LF6YDmmGoCAmDSptsZi9/ntXrzz/IH "Wolfram Language (Mathematica) – Try It Online")
Uses `1` for dead cells, `0` for living and background (grey) cells.
A boring answer using Mathematica's [`Uncompress`](http://reference.wolfram.com/language/ref/Uncompress.html) built-in.
---
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/) + my [LifeFind](https://github.com/AlephAlpha/LifeFind) package, 147 bytes
```
<<Life`
SeedRandom@1703
a=ArrayPad[SearchPattern[6,6,Agar->1>0][[1]],{{9,7},{9,13}},Periodic]
Do[a[[i,1;;7-2i]]=1;a=Reverse@a,4,{i,3}]
Print@@@a
```
Uses `0` for dead cells, `1` for living and background (grey) cells.
Spent some time to find the correct random seed...
I wrote this package to find interesting patterns in Conway's Game of Life and other cellular automata.
`SearchPattern[6,6,Agar->1>0]` tries to find a 6x6 stable [agar](https://www.conwaylife.com/wiki/Agar). When the random seed is `1703`, it finds the following pattern:
```
 ##   
#  ## 
#  # #
 ##   
  # ##
 #  ##
```
After that, the code pads the pattern periodically to a 22x28 array, and sets the background cells at the corners to `1` (this part takes so many bytes!), and then prints the result.
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 48 bytes
```
Ｇ↘³↓²↘²↓¹⁵↙³←²↙²←²¹↖³↑²↖²↑¹⁵↗³→²↗²”{“↧n⍘∨)¿UV·÷Σ
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z8gP6cyPT9Pw8olvzwvKDM9o0RHwVhHAczVUTCCsqASRnAJQ1Mo0yc1DaoDwjJCETdCiBsCmaEFCOWhBRBpmJgRVAxscmgBklOQLIeLAzlKFUAQk1ehoACjFEA0WBDMAdFgWSVN6////@uW5QAA "Charcoal – Try It Online") Link is to verbose version of code. Works by defining a polygon that outlines the configuration and filling it with the 6×6 pattern. (The top left corner actually has coordinates `(0, -24)` but as the fill is 6×6 it comes to the same thing.)
I also tried a number of other approaches. Simply printing a compressed string took [63 bytes](https://tio.run/##S85ILErOT8z5/z@gKDOvRENJAQwqgACNBIrG5IGlFCqwkVBZBYhidBIoi8VMGAnWi0srWLYCt8V4Ta4AyuLWCpXFZTEhk0eamxUImEx@2gDLYjEZBJQ0rf///69blgMA). Printing half of the string twice, rotating in between, took [61 bytes](https://tio.run/##S85ILErOT8z5/z8tv0hBw0hToZqLM6AoM69EQ0mhQkGhogI7GZNXAQQgHjYSKItbK1RWoQI7SchkPFqBrsLvZgUCJuPUqgCRxWExTBaLySCgpGnNxRmUX5JYkqphAmL75pelahjqKBgaAnm1////1y3LAQA). Filling an array with the pattern and then deleting the corners took [54 bytes](https://tio.run/##RU7BCsIwDL37FaGnFCrI8CDsNAaC4ECcRy9j1q1Q262dun19TXVqDi95L@G91G3lalvpEDLvVWMwn2ot89Z2WFQdlp1WA7KRCuBsCGj4dBipz/qbEof3ARPAzoZxAX8zJSDZcJKShKDn6eJqHeCaw5wb07JhZy5yxF7Aiq7KwSnTxMVRPqTzEntST9KZyk24l96jEbDV1jo82Kd0mAgolLn7OGjOYx4DeudrfPvJ8YMD2Q/kmYYQlg/9Ag). Drawing a rectangle with the pattern and then deleting the corners took [49 bytes](https://tio.run/##fY5NC8IwDIbP268IO6VQL0VU8Lpr9eLRyz7qLNRGunYMxN9e4@bZQPImIXmS7t6EjhqX87l15AdUBwlKSahmNoCr58DJqjCz/vpLyTUsA5U4ljcKgFsBr7LQyUX7DNZHrG0wXbTk8WSGJhqsKbXO9GiFEHwHYKWxfyGFpsmgtj6NqPYSLvZhRtxJ0NQnR2j5vWXxL5dB75zzZnIf).
[Answer]
# Excel, ~~137~~ 89 characters, 171 bytes
Taylor Raine did their thing.
```
=BASE(UNICODE(MID("ó㏈ښᩨ֖ᙘ㳳㏎ବⲲፍഴ㳳㏏⚚ᩩ▖ᙙ㳳㏏ବⲲፍഴ㳳㏏⚚ᩩ▖ᙙ㳳㏏ବⲲፍഴᳳ㏏ښᩨ֖ᙘӳ㏀",SEQUENCE(22,2),1)),2,14)
```
There's a possibility the exact characters won't translate well from Excel to the browser, so here's the encoded string as list of Unicode codes instead (keeping in mind that some are two bytes wide):
```
243, 13256, 1690, 6760, 1430, 5720, 15603, 13262, 2860, 11442, 4941, 3380, 15603, 13263, 9882, 6761, 9622, 5721, 15603, 13263, 2860, 11442, 4941, 3380, 15603, 13263, 9882, 6761, 9622, 5721, 15603, 13263, 2860, 11442, 4941, 3380, 7411, 13263, 1690, 6760, 1430, 5720, 1267, 13248
```
The approach takes the (probably not optimized) approach of breaking the desired into chunks and storing those as Unicode characters. The function takes that string, converts each character to its binary equivalent, then breaks it into 2 columns of 14 bit chunks.
---
Let's start by shortening the formula. We'll refer to this whole mess as `string`:
```
"ó㏈ښᩨ֖ᙘ㳳㏎ବⲲፍഴ㳳㏏⚚ᩩ▖ᙙ㳳㏏ବⲲፍഴ㳳㏏⚚ᩩ▖ᙙ㳳㏏ବⲲፍഴᳳ㏏ښᩨ֖ᙘӳ㏀"
```
Now the formula looks like this:
```
=BASE(UNICODE(MID(string,SEQUENCE(22,2),1)),2,14)
```
* `SEQUENCE(22,2)` creates an array 2 columns wide and 22 rows tall for 44 total items in the array. `string` is 44 characters long so that'll fit nicely. It counts over then down like this:
> 
> 
> ```
> | 1 | 2 |
> | 3 | 4 |
> | 5 | 6 |
> 
> ```
> 
> 
* `MID(string,SEQUENCE(~),1)` pulls out each character from `string` one at a time.
* `UNICODE(MID(~))` converts those characters to their (decimal) unicode number.
* `BASE(UNICODE(~),2,14)` converts those decimal numbers to their binary equivalent with each result padded with leading zeros so they're at least 14 bits long.
The end result is two columns of data as shown in the screenshot below. I also split out the results into individual cells and added conditional formatting to show the results visually. The formula is only in cell `A1` and the output automatically spills into the range `A1:B22`.
[![Result](https://i.stack.imgur.com/1wPCT.png)](https://i.stack.imgur.com/1wPCT.png)
---
~~I don't know what kind of ritual I need to perform to summon Taylor Raine but I'm sure they can improve upon this bloated answer. I already tried using chunks longer than 16 bits but it starts breaking in weird ways.~~
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), 87 bytes
```
»ƛUċ≬r¾□ƈ1K↵ẏǐṅȧꜝq6⟩λ∵†⇧↳∨¬ṫ«X¡„q∪[>±∩λxƒẊ[øȧẇ/hAh<∨T⅛⇧¥WnWU°⋎ƈ_S↳‡a∑⋏‡ø¨z≈cƛ÷a»₀Sτ22/⁋
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyIiLCIiLCLCu8abVcSL4omscsK+4pahxogxS+KGteG6j8eQ4bmFyKfqnJ1xNuKfqc674oi14oCg4oen4oaz4oiowqzhuavCq1jCoeKAnnHiiKpbPsKx4oipzrt4xpLhuopbw7jIp+G6hy9oQWg84oioVOKFm+KHp8KlV25XVcKw4ouOxohfU+KGs+KAoWHiiJHii4/igKHDuMKoeuKJiGPGm8O3YcK74oKAU8+EMjIv4oGLIiwiIiwiIl0=)
Naive base compression.
```
»...»        # Base-255 compressed integer
     ₀Sτ     # Decompress into base 22 with 1s and 0s
        22/⁋ # Split into 22 pieces and join on newlines
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 85 bytes
```
“¦÷fİȷ⁻ƒỌU,ɠṘµINọþọ^°56ß~+Œ:ḟyṘdạʠȷẇḌẆ[ŻṁỤ°8zẉİ¬{ḋzỵḣuṄ}Ṗj|ĠỌ½Ɲœiḥd⁷ɦȮʋḢ/iÇØ#¤œ’Bs28Y
```
[Try it online!](https://tio.run/##AawAU/9qZWxsef//4oCcwqbDt2bEsMi34oG7xpLhu4xVLMmg4bmYwrVJTuG7jcO@4buNXsKwNTbDn34rxZI64bifeeG5mGThuqHKoMi34bqH4biM4bqGW8W74bmB4bukwrA4euG6icSwwqx74biLeuG7teG4o3XhuYR94bmWanzEoOG7jMK9xp3Fk2nhuKVk4oG3yabIrsqL4biiL2nDh8OYI8KkxZPigJlCczI4Wf// "Jelly – Try It Online")
Boring compression approach, but hey, it beats Vyxal. Outputs `1` for dead and `0` for live.
## How it works
```
“¦÷...#¤œ’Bs28Y - Main link.
“¦÷...#¤œ’      - Compressed base-250 number; 267895893890769127503254177532545466822034310678965401690230443467397769491824224432265750760013635073235874891500166493638274198855494319824095093907255178782140555126842877012017876031
          B     - Binary
           s28  - Split into chunks of size 28
              Y - Join by newlines
```
Fun fact, using base 2 is the [shortest](https://tio.run/##y0rNyan8///h7i1hj5rWAJHbwx2tjzauO7H94Y6uQ1sf7mg2MjV4uLv78AyvR43bdQwtjA4tqXy4u@dR475HDXMeNczM0vQ5POHhzqb///8bgoEBEKCRQFEusIyhATYSImkIUYpOGnJhMRBGgnTi0giSNMBtKT5jDbjwaIRI4rIUv7EjxbWG@I0lNyWAJbEYCwIA "Jelly – Try It Online") of all approaches in the form "large compressed number, to base, split"
[Answer]
# [05AB1E (legacy)](https://github.com/Adriandmen/05AB1E/tree/fb4a2ce2bce6660e1a680a74dd61b72c945e6c3b), ~~46~~ 45 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Commands)
```
Ƶöb3ô4FDøí‚øJÂí«}¦22£€¦4F28£øíεN3‹i411NèFX0.;
```
Port of [*@DarrenSmith*'s Nibble answer](https://codegolf.stackexchange.com/a/241217/52210), so make sure to upvote him as well!
Uses the legacy version of 05AB1E to save 2 bytes, since it can zip/transpose with lists of strings, whereas the new version requires a character-matrix instead.
Outputs as a list of lines, with `1`/`0` for dead/alive respectively.
[Try it online](https://tio.run/##AVoApf8wNWFiMWX//8a1w7ZiM8O0NEZEw7jDreKAmsO4SsOCw63Cq33CpjIywqPigqzCpjRGMjjCo8O4w63OtU4z4oC5aTQxMU7DqEZYMC47/13Cu1TigJ54IOKAof8) (feel free to remove the footer to see the actual output).
**Explanation:**
```
Ƶö                  # Push compressed integer 346
  b                 # Convert it to binary: 101011010
   3ô               # Split it into parts of size 3: ["101","011","010"]
4F                  # Loop 4 times:
  D                 #  Duplicate the list of strings
   øí               #  Rotate it 90 degrees clockwise:
   ø                #   Zip/transpose; swapping rows/columns
    í               #   Reverse each inner string
     ‚              #  Pair it together with the original list of strings
      ø             #  Zip/transpose to create pairs of lines
       J            #  Join those inner pairs together to a single line
        Â           #  Bifurcate this list (short for Duplicate & Reverse copy)
         í          #  Reverse each line in the reversed copy
          «         #  Merge these lines to the list
 }                  # Close the loop
                    # (we now have a grid of 48x48 characters)
  ¦                 # Remove the first line
   22£              # Then keep just the first 22 lines
      €             # Map over each remaining line:
       ¦            #  Remove the first character
4F                  # Loop 4 times again:
  28£               #  Keep just (up to) the first 28 characters
  øí                #  Rotate 90 degrees clockwise again
    ε               #  Map over each line:
     N3‹i           #   If this is one of the first three lines:
         411Nè      #    Index the map-index into [4,1,1]
              F     #    Loop that many times:
               X0.; #     Replace the first 1 with a 0
                    # (after which the list of lines is output implicitly)
```
[See this 05AB1E tip of mine (section *How to compress large integers?*)](https://codegolf.stackexchange.com/a/166851/52210) to understand why `Ƶö` is `346`.
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 193 bytes
```
(x='xxxx  ',y='xx x  ',z='x xx  ',h=`      ${e=x+x+x}x   
 ${g='  '+y+y+y+y} 
 ${c='  '+z+z+z+z} 
${b=e+x+'xxx'} 
${c}x 
 x${g}
${b}x
x${g}x
x${c}x
${b}x
${c}x `)=>h+`
`+[...h].reverse().join``
```
[Try it online!](https://tio.run/##LY1bDoMgEEX/WcV8mAChZQd0I00TLB1fMdKoMahh7XSEzv2YO2deQ73Vi5v773qf/AdTY5IIhgcKAH7bLwvZHmSh0M5YyFGdaIIiReLAqG4Npwm1F8XMXGFHEbHqfBuktesNz7WjAwwC7cerGwPLPifq/VmZs9I8OmWZVU@tdffSM244LyikHnw/WZucnxY/oh59KxohZfoB "JavaScript (Node.js) – Try It Online")
Here we go...
A lot of variables, dollar signs, curly braces, single quotes, pluses, and a tiny reverse at the end.
[Answer]
# Excel, 111 bytes
```
AO1 =IF(I1:AJ22,,INDEX(A1:F6,MOD(ROW(6:27),6)+1,MOD(COLUMN(F:AG),6)+1))
```
[Link to Spreadsheet](https://1drv.ms/x/s!AkqhtBc2XEHJngYYXFl9HxhgwgPC?e=NbFKBB)
`A1:F6` contains the repeating pattern. `I1:AJ22` contains a mask for blank cells. Takes advantage of the spreadsheet structure. The code is 67 bytes, pattern is 20 bytes, mask is 24 bytes for a total of 111 bytes.
Not as clever as @EngineerToast 's answer but it gets the job done.
[Answer]
# JavaScript (ES6), ~~113~~ 106 bytes
Outputs a string of `0`'s and `1`'s.
```
f=(n=616)=>--n&&((x=n>>8?615-n:n,y=x/28|0,x%=28)>=5>>y&x<24+y+!y&21703951>>x%6+y%6*45%71)+[`
`[n%28]]+f(n)
```
[Try it online!](https://tio.run/##BcHRCsIgFADQ9/6iB0Vz1rTpLPL2IWOwsWYU4xotQqF/t3Oe43dcp/fj9ZEYb3MpwTP0VlnuQUqklLHkEcBdrTISz1hlnw7a/eoqEa8dB28AMk0X3Ygstplq1dbHk1EAiViRid01hrSKi27YDB0S7fpeBIa8TBHXuMz7Jd5ZYJyXPw "JavaScript (Node.js) – Try It Online")
### How?
We use the following formula to get the state of the cell of the \$6\times6\$ pattern at \$(x,y)\$:
```
21703951 >> x + y * 45 % 71
```
The cell is alive if the result is odd or dead if it's even.
Notes:
* Because bitwise operations are limited to 32 bits, we cannot use a 36-bit bitmask.
* The value of the shift is implicitly reduced modulo \$32\$ as per the ECMAScript specification.
[Try it online!](https://tio.run/##Nc1RCoJAEAbgd0/xv9RqS@FWJrVpF@lFTKMSJ1wJI3zvBB2wi2yjJswwDP/HzDV5JCatLvd6XtIps7bIahAiCKGdnCq325@8@5rHHhseUnp4OUAXmT8FRtwMuBlwM@KB3zhcqtBfbQOFOGYl@ewM6wAThEr30EBGLKdQOEB8P28ugR0E0H9quakzDPsWx5KD1kmpNFRki4LOLgOQp639AQ "JavaScript (Node.js) – Try It Online")
[Answer]
# [Ruby](https://www.ruby-lang.org/), 108 bytes
```
j=4
28.times{|i|printf"%022b
","O)YO24"[i%6].ord%64*266305&2**(23-k=j.abs)-2**k>>1-(i-4)%24/23
i%23<4&&j-=1}
```
[Try it online!](https://tio.run/##DcdLDsIgEADQPccgGVKIYDuMxIX0Cl0b40KiJkPjJ7QujPXs6Nu98krvWnMkgVs38@0yfRZenoXv81VCi5iEXMlB7wckeWAIR/coZwhkMATfbhQa06C3Y8zulCZt/x/7vrMNW9KAtEYvGNDvSKlsY/et9Qc "Ruby – Try It Online")
Prints the pattern rotated 90 degrees (which per comments from OP is allowed because it's still primordial.)
The output is a binary matrix produced line by line as the bitwise `AND` of the following:
```
"O)YO24"[i%6].ord%64*266305
```
Four copies of the repeating pattern (the character encodes the bitmap, the `%64` removes spurious bits to the left and the constant `266305` is `100000100000100001` in binary)
```
2**(23-k=j.abs)-2**k>>1-(i-4)%24/23
```
This is a mask consisting of a long string of `1`'s followed by a short string of `0`'s according to the formula `2**(23-k)-2**k`.
As the pattern gets wider, `k` reduces from 4 to 0, stops reducing, then increases back to 4. This is done by varying `j` on the last line.
To ensure the spurious output in the 23rd and 24th bits (those on the left) are deleted, the mask must be shifted one place to the right. But to get the pinwheel effect this should not occur on the 4th and 28th row. This is achieved by `>>1-(i-4)%24/23`
[Answer]
# [Perl 5](https://www.perl.org/) + `-p0513`, 95 bytes
Outputs `0`s and `1`s, transliterated in the link.
```
$_=unpack"B*",'..<...h.Ye.<..'.',..$.M4..<...i.Ye.<..'x2 .',..$.M4s.<...h.Ye.<..';s/.{28}\K/./g
```
[Try it online!](https://dom111.github.io/code-sandbox/#eyJsYW5nIjoid2VicGVybC01LjI4LjEiLCJjb2RlIjoiMDAwMDAwMDA6IDI0NWYgM2Q3NSA2ZTcwIDYxNjMgNmIyMiA0MjJhIDIyMmMgMjcwMyAgJF89dW5wYWNrXCJCKlwiLCcuXG4wMDAwMDAxMDogY2YzYyA4MWE2IDlhNjggMTY1OSA2NThmIDNjZjMgY2UyNyAyZTI3ICAuPC4uLmguWWUuPC4uJy4nXG4wMDAwMDAyMDogMmNiMiBjYjI0IGQzNGQgMzRmMyBjZjNjIGY5YTYgOWE2OSA5NjU5ICAsLi4kLk00Li48Li4uaS5ZXG4wMDAwMDAzMDogNjU5ZiAzY2YzIGNmMjcgNzgzMiAyMDJlIDI3MmMgYjJjYiAyNGQzICBlLjwuLid4MiAuJywuLiQuXG4wMDAwMDA0MDogNGQzNCA3M2NmIDNjZjEgYTY5YSA2ODE2IDU5NjUgODEzYyBmM2MwICBNNHMuPC4uLmguWWUuPC4uXG4wMDAwMDA1MDogMjczYiA3MzJmIDJlN2IgMzIzOCA3ZDVjIDRiMmYgMGEyZiA2NyAgICAnO3MvLnsyOH1cXEsvLi9nIiwiZm9vdGVyIjoiIyB0byBwcmV0dHkgcHJpbnQgdGhlIG91dHB1dFxuO3kvMDEvIHgvIiwiYXJncyI6Ii1wMDUxMyJ9)
## Explanation
`unpack`s the binary representation from characters (repeating the duplicated section in the middle using string repetition - `x`) before inserting newlines every 28 characters. Probably not optimal but, was do-able on mobile!
]