[Question]
  [
There are several ways to create headers on posts on the Stack Exchange network. The format that's most commonly1 used on PPCG seems to be:
```
# Level one header
## Level two header
### Level three header
```
Note the space after the hash marks. Also, note that trailing hash marks are not included. 
## Challenge:
Take a (possibly multiline) string as input, and output the string on the following format:
* If the header is level 1, then output each letter 4-by-4 times
* If the header is level 2, then output each letter 3-by-3 times
* If the header is level 3, then output each letter 2-by-2 times
* If a line is not a header then output it as it is.
To illustrate:
```
--- Level 1 ---
# Hello
--- Output---
HHHHeeeelllllllloooo    
HHHHeeeelllllllloooo
HHHHeeeelllllllloooo
HHHHeeeelllllllloooo
--- Level 2 ---
## A B C def
--- Output ---
AAA   BBB   CCC   dddeeefff
AAA   BBB   CCC   dddeeefff
AAA   BBB   CCC   dddeeefff
--- Level 3 ---
### PPCG!
--- Output---
PPPPCCGG!!
PPPPCCGG!!
```
Simple as that!
---
### Rules:
* You must support input over multiple lines. Using `\n` etc. for newlines is OK.
	+ There won't be lines containing only a `#` followed by a single space
* The output must be presented over multiple lines. You may not output `\n` instead of literal newlines.
	+ Trailing spaces and newlines are OK.
---
### Test cases:
Input and output are separated by a line of `...`.
```
# This is a text
with two different
### headers!
........................................................    
TTTThhhhiiiissss    iiiissss    aaaa    tttteeeexxxxtttt
TTTThhhhiiiissss    iiiissss    aaaa    tttteeeexxxxtttt
TTTThhhhiiiissss    iiiissss    aaaa    tttteeeexxxxtttt
TTTThhhhiiiissss    iiiissss    aaaa    tttteeeexxxxtttt
with two different
hheeaaddeerrss!!
hheeaaddeerrss!!
```
---
```
This input has
## trailing hash marks ##
#and a hash mark without a space after it.
........................................................    
This input has
tttrrraaaiiillliiinnnggg   hhhaaassshhh   mmmaaarrrkkksss   ######
tttrrraaaiiillliiinnnggg   hhhaaassshhh   mmmaaarrrkkksss   ######
tttrrraaaiiillliiinnnggg   hhhaaassshhh   mmmaaarrrkkksss   ######
#and hash marks without a space after it.
```
---
```
# This ## is ### strange
#### ###
........................................................
TTTThhhhiiiissss    ########    iiiissss    ############    ssssttttrrrraaaannnnggggeeee
TTTThhhhiiiissss    ########    iiiissss    ############    ssssttttrrrraaaannnnggggeeee
TTTThhhhiiiissss    ########    iiiissss    ############    ssssttttrrrraaaannnnggggeeee
TTTThhhhiiiissss    ########    iiiissss    ############    ssssttttrrrraaaannnnggggeeee
#### ###
```
---
```
Multiple
### newlines! # 
:)
........................................................    
Multiple
nneewwlliinneess!!  ##
nneewwlliinneess!!  ##
:)
```
---
```
Line with only a hash mark:
#
### ^ Like that!
........................................................    
Line with only a hash mark:
#
^^  LLiikkee  tthhaatt!!
^^  LLiikkee  tthhaatt!!
```
1: I haven't really checked, but I *think* it's true.
  
[Answer]
# [Stacked](https://github.com/ConorOBrien-Foxx/stacked), ~~51~~ 50 bytes
*Saved 1 byte thanks to @RickHitchcock - golfed regex*
```
['^(##?#?) (.+)'[\#'5\-@k CS k*k rep LF#`]3/mrepl]
```
[Try it online!](https://tio.run/##TU9BasMwELzrFUN1UNKmMaXtISUkIYaeAj70GCdUduRa2JKMJDv49e4m9FAEM6tlZnc2RFk26jJNR3Gecb7l2zlmy6e5OOZcvOfPuwbpF5rHBl51OHzy79NrYqhuT9Puo2KCI3Wm86pWNuhBgSOqEFHKoALjHPuRBNZ5ZELsvVaWmhyz0nWj1z91xMtq9YZ9Omc8FjW4V7Jl/P5ireBIpC1chduvat1VeSjjoi6dxZpDB/S2se5qFyj6CCPtSFptG@iIi/IUKlAZ0N29lXfmPkvaktJEFkZTuPa2wUjqE2gKj4dY91E@LCAxSK@ljX8hoiSUdCGdLT3Ntr0plA9Ldjs3@5eX/OCc6ShEQKPtRZLJtaTDerPeEJ2H80CUZtmBKMmTnIgwYQIVXB@nXw "Stacked – Try It Online")
Anonymous function that takes input from the stack and leaves it on the stack.
## Explanation
```
['^(##?#?) (.+)'[\#'5\-@k CS k*k rep LF#`]3/mrepl]
[                                            mrepl]   perform multiline replacement
 '^(##?#?) (.+)'                                     regex matching headers
                [                        ]3/         on each match:
                 \#'                                   count number of hashes
                    5\-                                5 - (^)
                       @k                              set k to number of repetitions
                          CS                           convert the header to a char string
                             k*                        repeat each char `k` times
                               k rep                   repeat said string `k` times
                                     LF#`              join by linefeeds
```
[Answer]
# JavaScript (ES6), ~~111~~ 105 bytes
*Saved 6 bytes thanks to @Shaggy*
```
s=>s.replace(/^(##?#?) (.+)/gm,(_,a,b)=>`
${b.replace(/./g,e=>e.repeat(l=5-a.length))}`.repeat(l).trim())
```
Matches 1-3 hashes at the beginning of the string or preceded by a new line, then repeats each character in the match along with the match itself, based on the length of the hashes.
**Test Cases:**
```
let f=
s=>s.replace(/^(##?#?) (.+)/gm,(_,a,b)=>`
${b.replace(/./g,e=>e.repeat(l=5-a.length))}`.repeat(l).trim())
console.log(f('# This is a text\nwith two different\n### headers!'));
console.log('______________________________________________');
console.log(f('This input has\n## trailing hash marks ##\n#and a hash mark without a space after it.'));
console.log('______________________________________________');
console.log(f('# This ## is ### strange\n#### ###'));
console.log('______________________________________________');
console.log(f('Multiple\n\n\n### newlines! # \n:)'));
console.log('______________________________________________');
console.log(f('Line with only a hash mark:\n#\n### ^ Like that!'));
```
[Answer]
# [Retina](https://github.com/m-ender/retina), ~~125~~ 104 bytes
```
m(`(?<=^# .*).
$0$0$0$0
(?<=^## .*).
$0$0$0
(?<=^### .*).
$0$0
^# 
$%'¶$%'¶$%'¶
^## 
$%'¶$%'¶
^### 
$%'¶
```
[**Try it online**](https://tio.run/##VY9BTsMwEEX3c4ofuYiWRcS6AvUCZce6YkQmtdXUieypChfjAFwsjBMKrWyN9J/n/xkn0RB5HI/Lt@Xm6XnnUD@salo8zodmeEMv7AqS@Whxd//99V@o2OhWX8A4Orz6kGGXofKhdA7qoeceTWhbSRKVSr8XbiTliub2OJwUnrO9QROHLsR90R5HTocM58hxbCz0D6Ik92Zj5IHfBdyqJASt6XcJy5qqQ7bMuJcy2RVAL6dOw9AJ0bRNlLNNlFzBfrJe0dbElI8@dp/XU9fkJscO23AQqGetfgA)
*Saved 21 bytes thanks to Neil.*
[Answer]
# [MATL](https://github.com/lmendo/MATL), ~~43~~ ~~42~~ 40 bytes
*1 byte removed thanks to [Rick Hitchcock](https://codegolf.stackexchange.com/users/42260/rick-hitchcock)!*
```
`j[]y'^##?#? 'XXgn:(2M4:QP&mt~+t&Y"0YcDT
```
This outputs a trailing space in each line (allowed by the challenge), and exits with an error (allowed by default) after producing the ouput.
[**Try it online!**](https://tio.run/##jY/BSsNAEIbv@xR/OtBahCLiKZdeemxBoYcWsTg0k@zaZBOyU2IvvnrcRBGPGZaBHZjvn69iLfv@/eP17bY4Ea1pjcXhUPj07nH3lL48zyv9utf5cfZwPG/2fU/YWxcQH0PlU03n1EK7GpnLc2nFqyEiWOFM2pCY1YQyP0zfXBWWQwRAW3al88Xwt6i4vQQQGWKfxeS/IYb4Oq4xQsNnAecqLZyupgX/6sTAsRNCDPaFDA40DKZhdtdSXVOKMaO8ly7eLiEBwaTLaYxt3Bh1UPvy9l8yNTRiT9i6i0Ata/IN)
### Explanation
```
`            % Do...while loop
  j          %   Input a line as unevaluated string
  []         %   Push empty array
  y          %   Duplicate from below: push input line again
  '^##?#? '  %   Push string for regexp pattern
  XX         %   Regexp. Returns cell array with the matched substrings
  g          %   Get cell array contents: a string, possibly empty
  n          %   Length, say k. This is the title level plus 1, or 0 if no title
  :(         %   Assign the empty array to the first k entries in the input line
             %   This removing those entries from the input
  2M         %   Push k again
  4:QP       %   [1 2 3 4], add 1 , flip: pushes [5 4 3 2]
  &m         %   Push index of k in that array, or 0 if not present. This gives
             %   4 for k=2 (title level 1), 3 for k=3 (tile level 2), 2 for k=2
             %   (title level 1), and 0 for k=0 (no title). The entry 5 in the
             %   array is only used as placeholder to get the desired result.
  t~+        %   Duplicate, negate, add. This transforms 0 into 1
  t&Y"       %   Repeat each character that many times in the two dimensions
  0Yc        %   Postpend a column of char 0 (displayed as space). This is 
             %   needed in case the input line was empty, as MATL doesn't
             %   display empty lines
  D          %   Display now. This is needed because the program will end with
             %   an error, and so implicit display won't apply
  T          %   True. This is used as loop condition, to make the loop infinite
             % End (implicit)
```
[Answer]
# Perl 5, 47 +1 (-p) bytes
```
s/^##?#? //;$.=6-("@+"||5);$_=s/./$&x$./ger x$.
```
[try it online](https://tio.run/##K0gtyjH9/79YP05Z2V7ZXkFf31pFz9ZMV0PJQVuppsZU01ol3rZYX09fRa1CRU8/PbVIAUj//6@sEJKRWaygrKwAJpUVikuKEvPSU7mUQRwg5vqXX1CSmZ9X/F@3AAA)
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 46 bytes
```
ＦＮ«Ｓι≔⊕⌕Ｅ³…⁺×#κι⁴### θＦ⎇θ✂ι⁻⁵θＬι¹ι«Ｇ↓→↑⊕θκ→»Ｄ⎚
```
[Try it online!](https://tio.run/##TY/BTsMwDIbP7VOY9uJK4YAGl3FCTEhIFE2sPEBo3cZamnRpujKhPXtJygUpsf9Yv77fqZV0tZV6WVrrAF/NMPn3qf8ih0UBP2myTg7esemQi8c0eRpH7kxw1o56Mp4afGHTYCkH3AgorW5wr6cRK@5pxCzPBBwLARzufRFKluc5ZFGdIm/NrcgZ6S54EnDQXBNyILEJlIdoE/BGpvMKI@Ruha3LJXurL501uN3Z2QjYfnCnfOifg4D/G0bEMaYlpT0T/vni@5omu6kfMOpnTdJFdV2WTZpDpXiEcCR4@vbpzF6Bny003LbkAjiNP1EkG3LjzXJ71r8 "Charcoal – Try It Online") Link is to verbose version of code. Charcoal doesn't really do string array input, so I've had to add the array length as an input. Explanation:
```
ＦＮ«Ｓι
```
Loop over the appropriate number of input strings.
```
≔⊕⌕Ｅ³…⁺×#κι⁴### θ
```
Create an array of strings by taking the input and prefixing up to 2 #s, then truncating to length 4, then try to find `###` in the array, then convert to 1-indexing. This results in a number which is one less than the letter zoom.
```
Ｆ⎇θ✂ι⁻⁵θＬι¹ι«
```
If the letter zoom is 1 then loop over the entire string otherwise loop over the appropriate suffix (which is unreasonably hard to extract in Charcoal).
```
Ｇ↓→↑⊕θκ→
```
Draw a polygon filled with the letter ending at the top right corner, and then move right ready for the next letter.
```
»Ｄ⎚
```
Print the output and reset ready for the next input string.
[Answer]
# [SOGL V0.12](https://github.com/dzaima/SOGL), ~~31~~ 28 [bytes](https://github.com/dzaima/SOGL/blob/master/chartable.md)
```
¶Θ{■^##?#? øβlF⁄κ6κ5%:GI*∑∙P
```
[Try it Here!](https://dzaima.github.io/SOGLOnline/?code=JUI2JXUwMzk4JTdCJXUyNUEwJTVFJTIzJTIzJTNGJTIzJTNGJTIwJUY4JXUwM0IybEYldTIwNDQldTAzQkE2JXUwM0JBNSUyNSUzQUdJKiV1MjIxMSV1MjIxOVBGJTBBaW5wdXRzLnZhbHVlJXUyMDFEJXUyMTkyRg__,inputs=TXVsdGlwbGUlMEElMEElMEElMjMlMjMlMjMlMjBuZXdsaW5lcyUyMSUyMCUyMyUyMCUwQSUzQSUyOSUwQSUwQSUyMyUyMFRoaXMlMjBpcyUyMGElMjB0ZXh0JTBBd2l0aCUyMHR3byUyMGRpZmZlcmVudCUwQSUyMyUyMyUyMyUyMGhlYWRlcnMlMjElMEElMjMlMjBzaXplJTIwNCUwQSUyMyUyMyUyMHNpemUlMjAzJTBBJTIzJTIzJTIzJTIwc2l6ZSUyMDIlMEFzaXplJTIwMQ__) - extra code added because the code is a function and takes input on stack (SOGL can't take multiline input otherwise :/) - `inputs.value”` - push that string, `→` - evaluate as JS, `F` - call that function
Explanation:
```
¶Θ                            split on newlines
  {                           for each item
   ■^##?#?                      push "^##?#? "
           øβ                   replace that as regex with nothing
             l                  get the new strings length
              F⁄                get the original strings length
                κ               and subtract from the original length the new strings length
                 6κ             from 6 subtract that
                   5%           and modulo that by 5 - `6κ5%` together transforms 0;2;3;4 - the match length to 1;4;3;2 - the size
                     :          duplicate that number
                      G         and get the modified string ontop
                       I        rotate it clockwise - e.g. "hello" -> [["h"],["e"],["l"],["l"],["o"]]
                        *       multiply horizontally by one copy of the size numbers - e.g. 2: [["hh"],["ee"],["ll"],["ll"],["oo"]]
                         ∑      join that array together - "hheelllloo"
                          ∙     and multiply vertiaclly by the other copy of the size number: ["hheelllloo","hheelllloo"]
                           P    print, implicitly joining by newlines
```
[Answer]
# [Proton](https://github.com/alexander-liao/proton), 130 bytes
```
x=>for l:x.split("\n"){L=l.find(" ")print(L>3or L+len(l.lstrip("\#"))-len(l)?l:"\n".join(["".join(c*(5-L)for c:l[L+1to])]*(5-L)))}
```
[Try it online!](https://tio.run/##LU1LCsMgFNznFPKyea8hgpRuAkku4A1SV2kFy0PFuAiUnt2apgMDwzCfmEIOvtix7ONkQxI87HKL7DLC3QO99cjSOv9AEEAxOZ9RT9ca1B0/PbLkLScXa7oFov7n0czD0Zav4Dwu8BfrBW@9puNlHXjRncrBkDldok855y1C01aIygYWJXIQvTJE5Qs "Proton – Try It Online")
[Answer]
# [Python 3](https://docs.python.org/3/), 147 bytes
```
def f(x):
	for l in x.split("\n"):L=l.find(" ");print(L>3or L+len(l.lstrip("#"))-len(l)and l or"\n".join(["".join(c*(5-L)for c in l[L+1:])]*(5-L)))
```
[Try it online!](https://tio.run/##NY27CsIwFIZn8xTxZDnH0kARl4o6CQ5B3WsHsQlGDkmJHerT19bL9vHxX9pXd49hOQyNddJhT6WYuZgkSx9kr58t@w7hEoBKs2HtfGgQJNC6TT50aLbLMWwytgFZ87NLvkVQQJR/FF1DM27FNE3oR/QBK/jBbYGr3ND0dpveuDJZUdZUfz3R4BAAxMEyR6HkwV4bm@ZCKXn/4G7EP2uthTqeznsxVqqizIuahjc "Python 3 – Try It Online")
-1 byte thanks to Mr. Xcoder
[Answer]
# [C# (.NET Core)](https://www.microsoft.com/net/core/platform), 268 + 18 bytes
```
n=>{var r="";for(int l=0,c;l<n.Length;l++){var m=n[l];var s=m.Split(' ');var y=s[0];if(!y.All(x=>x==35)|y.Length>3|s.Length<2)r+=m+'\n';else for(int i=0,k=y.Length;i<5-k;i++){for(c=1;c<m.Length-k;)r+=new string(m.Substring(k,m.Length-k)[c++],5-k);r+='\n';}}return r;};
```
[Try it online!](https://tio.run/##lVLBbqMwED2Xr5jCISAo6m7VyxpHqirtKSut1JX2kKaS1zFgYUzWHpqglG9PDYG210jIGr2Zee/NE9ze8MaIU2ulLuCpsyjqdCX1f@JxxayF36YpDKvh6F1ZZCg5vDZyC7@Y1KFF47bWG2CmsJEb8SaCn63m2dxN4FwtIQd60nR5fGUGDPV9kjcmlBpB0duEE5XpdCV0gSVRcRyNYzXVa7UhQ2lpnT7tlMRwAYtohDpq17cbIvPwuksflAoPdHmg9O4@eusmquXdm53K7HtkYlrHi2e9IEJZAbO@dPoVnVeIzO5vKiIHD8MEp98Iz@qp6zoDjRb76a7Q2Wr/TXWVfM5Fax7Hm8RxRcRtjLJ9bwS2RoMhPTmRObDHRttGifSvkShc/CLMw08Fl/AR/AD@lNKC@xigOKCfgL@XWALuG9jKPBdG6BENggBKwbbC2Gsf@ii6SOesonctQsnsmQ/QMKmGX8RBJdTMVBaCYGwyvXWOPnAYPDVumYHdMS6A5SgMSEwvtzKd7PTHNxiaTBdiOjIYsMtZB3h0CY1W3VfvP0biOcIXWMlKAJYM5xi9q97rT@8 "C# (.NET Core) – Try It Online")
[Answer]
# [Python 3](https://docs.python.org/3/), 131 bytes
```
from re import*
print(sub("^(#+) (.*?)$",lambda x:((sub('(.)',r'\1'*(5-len(x[1])),x[2])+'\n')*(5-len(x[1])))[:-1],input(),flags=M))
```
[Try it online!](https://tio.run/##VY9Bi4MwFITv/opHUsh7mgrusheh9Bf01pt14XWrNVRjSCK1v9667WHZ43zDDDPuEbvRfi7GuinCDnoezhcuQQhx7EyAN@84JFJC9Gx6Y6@/uoOB/S2AlIlkewH@g3A3a@kaYwiOfxrgNjYeTMzX1qX14wC@ATO40cc0cd7YiGE6o/hGmRFgnu5pI/R7CswlvlyFOSnt1alQKX5t@8biXBU1kZ6rj5oydbKK/jtUldui1q8PSLrt@Rp2B6JleQI "Python 3 – Try It Online")
I used Python 3 in order to use `[]` with regex.
[Answer]
# PHP, 122+1 bytes
```
for($y=$z=" "==$s[$i=strspn($s=$argn,"#")]&&$i?5-$i++:1+$i=0;$y--;print"
")for($k=$i;~$c=$s[$k++];)echo str_pad($c,$z,$c);
```
Run as pipe with `-nR` (will work on one input line after another) or [try it online](http://sandbox.onlinephpfunctions.com/code/07226b470ecae8bbdbd1dde71cf416af5e858c2b).
[Answer]
# [J](http://jsoftware.com/), 55 bytes
```
([:{:@,'^##?#? 'rxmatch])((1 1 4 3 2{~[)([:|:[$"0#)}.)]
```
I don't know how to make TIO work with J regex, so I can't provide a working link.
Here's how to test it in the J interpreter (tested with J804)
```
   f=.([:{:@,'^##?#? 'rxmatch])((1 1 4 3 2{~[)([:|:[$"0#)}.)]
   txt=.'# Hello'; '## A B C def'; '### PPCG!'; '#and a hash mark without a space after it.'; '##### ###'
   ; f each txt
HHHHeeeelllllllloooo                      
HHHHeeeelllllllloooo                      
HHHHeeeelllllllloooo                      
HHHHeeeelllllllloooo                      
AAA   BBB   CCC   dddeeefff               
AAA   BBB   CCC   dddeeefff               
AAA   BBB   CCC   dddeeefff               
PPPPCCGG!!                                
PPPPCCGG!!                                
#and a hash mark without a space after it.
##### ###
```
I simulate a multiline string through a list of boxed strings.
[Answer]
# [Python 2](https://docs.python.org/2/), ~~126~~ ~~124~~ 117 bytes
```
while 1:l=raw_input();i=l.find(' ');v=5-i*(l[:i]in'###');exec"print[l,''.join(c*v for c in l[i+1:])][v<5];"*(v>4or v)
```
[Try it online!](https://tio.run/##TY7BTsMwDIbvfgpvObQdMGmIXVrGE4wbt6qgqHUXs5BWidduT1/SghCSZcm/7f/7@5uYzj1O02jYEu5ye/B6/GDXXyTNCj7YbcuuSRNMsmI47B94k9oy54pdopSKIl2pXveenZT2Pkm2nx27tN4M2HYea2SHtuS7XV5lVTk876tivUmHl6e4HLJpUvhmOGAsjUJXgZHFoIwdNty25MkJRA4a0g35sAL4uZ/zodEhLlG8ZsvuNM8Gv7Q/B1QKlHZNdP0Tcbbu4pvG0OuaULdCHlm2AL8xotnSFYZo6k40s9UsALxerHBvCWAJ5GiMTAorVAh5BnCM04LAztnbf3AOanl5xyOfCcVoWX0D "Python 2 – Try It Online")
or
```
while 1:l=raw_input();i=l.find(' ');t=''<l[:i]in'###';exec"print[l,''.join(c*(5-i)for c in l[i+1:])][t];"*(t<1or 5-i)
```
[Try it online!](https://tio.run/##TY7BasMwDIbvegq1PjjptkIHuyTNG3S33UI2TKLUWj0n2Cppnz5zsjEGQqBf0v/9413s4J/nebLsCA@Fq4KZPtiPV8nykiu379l3mUadl1JpfXR1wQ17rZTSJd2o3Y6BvdTuUev958A@a3fZyxPn/RCwRfboan44FE3e1NKU210mx0NaLSfzrPDNcsRUBoVuAhOLRZkG7LjvKZAXSCS0ZDoKcQPwc7/kQ2tiWqIEw479eZktfplwiagUKOO75Pon4mI9pDeDcTQtoemFArLsAX5jJLO1K4zJ1J9pYatFAHi9OuHREcAayNOUmBQ3qBCKHOCUphWBg3f3/@AC1Pryjie@EIo1svkG "Python 2 – Try It Online")
[Answer]
# JavaScript, 112 bytes
```
x=>x.replace(/^(##?#?) (.*)/mg,(_,n,w)=>(t=>Array(t).fill(w.replace(/./g,c=>c.repeat(t))).join`
`)(5-n.length))
```
```
f=
x=>x.replace(/^(##?#?) (.*)/mg,(_,n,w)=>(t=>Array(t).fill(w.replace(/./g,c=>c.repeat(t))).join`
`)(5-n.length))
```
```
<textarea id=i style=display:block oninput=o.value=f(i.value)></textarea>
<output id=o style=display:block;white-space:pre></output>
```
[Answer]
# C# 4.5 158 Bytes
Where i is the input in the form of a string.
```
int l,m,t,s=0;while(i[s]=='#'){s++;};t=s>0?4-s+1:1;for(l=0;l<t;l++){foreach(char c in i.Skip(s>0?s+1:0))for(m=0;m<t;m++)Console.Write(c);Console.WriteLine();}
```
[Answer]
# [Stax](https://github.com/tomtheisen/stax), 27 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax)
```
é!?q╚<╙≈╣íå▒{¼Φ8ôƒ¡m↨;-◘-u♥
```
[Run and debug it](https://staxlang.xyz/#p=82213f71c83cd3f7b9a186b17bace838939fad6d173b2d082d7503&i=This+input+has%0A%23%23+trailing+hash+marks+%23%23%0A%23and+a+hash+mark+without+a+space+after+it.%0A)
This was fun.
]