[Question]
  [
# Context
Just look around! Whenever someone posts an answer, the same template is followed over and over again! A first line with the byte count and language name. Then the code. Then the TIO link. This is the basic skeleton almost everyone follows.
# Task
Your task, should you choose to accept it, is to write a program/function/procedure/etc that takes as input the variable bits and produces the basic CGCC answer.
# Input
The language name, some code and a TIO link, in any sensible formats. For the language name and the TIO link, a string is suggested. For the code, sensible formats include a string with possibly some newlines, or a list of strings, one string per line.
Additionally, you may also take the byte count as input. If you don't, you have to compute it yourself (if you compute it yourself, you can assume the byte count equals the length of the code string).
You have to support that the input strings may contain any printable, non-whitespace ASCII characters plus the space. The only exclusion being the newlines in the source code. You don't have to worry about the weird characters used by golfing languages in their code pages.
The inputs may be ordered in any way you like.
# Output
You should output this raw content:
```
# {name}, {byte count} bytes
    {code}
You can [try it online][tio]!
[tio]: {link}
```
Where `{name}`, `{byte count}`, `{code}` and `{link}` should be filled in by your code. Three of those are inputs, the byte count should be computed within your code if you chose not to receive it as input (you can assume the byte count is equal to the number of characters in the `code` argument). Beware that the code given may be multiline, in which case the `{code}` section must be indented by 4 spaces for each line of code.
# Test cases
You can [check some test cases](https://tio.run/##lVJNb9swDL3rV9AKsNmr49TtTsEMBAiwj8OAHXYpXKNVHDkWKsuGRHcNgvz2jLKWDDusQH0waZl8fO@Jwx7b3tyeTii7QQuUUADnfAYHLczumFKUZoftETZ7lI4xoOdQ91t5ZOyuH6EWBkq0e1AIvdHKyKpE1VcRY1NcwmG0@kiYjG1lA03sgVPwEClQ/VOynECp4rPS2oEygK0EYdwvaeHCq@ktrL@s11C3QntS0mWBzqPHeoRO7GFDfdCNGpVnAg6tMrvsjB/KgyDSSUnsW5Pp2Gd06ENmJc2sZczvDU@B3hNAEvqtxNGaC7GMiHUCJ1lF0BYmFCEEqUXQS1YUk@aTr/Re/5guAG45@0OAa9FttgJelvBylXNGLf60RRzccrEgTzM7msVsCDfH2UAaMf7XV2pKiG74xef8w8dr@jzP/Crck9T6MvKekTlxlCeU5yw2kfKZgSuIzTyP1DxPvHv/Y9Ke4d7O5Lugqyb3VC3@GtCU@qGi5KfqpFut4m9Nue5Hg6VOZ9Wnm3SW5tW7xUonF0rYKtobZ94jyGdpaAeehVbbab2iV3idfgM).
[Related challenge](https://codegolf.stackexchange.com/q/127291/75323)
---
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so shortest answer in bytes wins. If you liked the challenge, consider upvoting it... And happy golfing!
  
[Answer]
# [Ruby](https://www.ruby-lang.org/), ~~98~~ ~~95~~ 94 bytes
Really simple string interpolation. I don't think there's all that much to optimize here that will save a lot of bytes.
Takes the byte count as a parameter in order to save 3 bytes, as per Kevin Cruijssen's suggestion.
```
->n,b,c,l{"# #{n}, #{b} bytes
#{c.gsub /^/,' '*4}
You can [try it online][tio]!
[tio]: "+l}
```
[Try it online!](https://tio.run/##tU9BboMwELzvK7YhUqTUtS@5FIX2DemljUgqYeMAEtgIr2sRxNsJRL3kAbnMjmZmR7udl/10SU7T24dhkilWD6sIo8GMbEY5ouxJO4BoULxwXqL4FWyDm@1uBDhajyozmFLXY0VoTV0ZfU6psucXgPuMcfVaj5PJGo0JFpocV6VtWpjNR0HZfIms97zTWQ6tJ4eXdFlkuHjcVdd/ynCpnr7m46Ekal0sRAiB99aTl5or24iQkSo//5L8EHbh/bv4UQd47pM3 "Ruby – Try It Online")
[Answer]
# [05AB1E (legacy)](https://github.com/Adriandmen/05AB1E/wiki/Commands), ~~56~~ ~~53~~ ~~52~~ ~~51~~ 50 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
“# ÿ, ÿ¡Ï“I4ú»"[tio]"D“You€© [try€•€Ø]ÿ!“s¶·ý„: IJ
```
Inputs in the order `name`, `byte-count`, `[code-lines]`, `link`, where the `[code-lines]` is a list of lines.
[Try it online.](https://tio.run/##MzBNTDJM/f//UcMcZYXD@3WA@NDCw/1ArqfJ4V2HditFl2Tmxyq5AAUi80sfNa05tFIhuqSoEsh61LAISB6eEXt4vyJQuvjQtkPbD@991DDPSsHT6///gKL89KLEXAW/xNxUBY/UolQuQwMDrmil5PyUVCUdpfT81GIglQGUUIrlyigpKSi20tcHWqZXVJqnrwwA)
**50 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage) alternative (credit to *@Grimmy*):**
```
“:# ÿ, ÿ¡Ï“I4ú»“You€© [try€•€Ø][tio]!“Â6£R¨¶·ýÀ$ú«
```
[Try it online.](https://tio.run/##MzBNTDJM/f//UcMcK2WFw/t1gPjQwsP9QL6nyeFdh3YDGZH5pY@a1hxaqRBdUlQJZD1qWAQkD8@IjS7JzI9VBKo43GR2aHHQoRWHth3afnjv4QYVoM7V//8HFOWnFyXmKvgl5qYqeKQWpXIZGhhwRSsl56ekKukopeenFgOpDKCEUixXRklJQbGVvj7QTL2i0jx9ZQA)
**Explanation:**
```
“# ÿ, ÿ¡Ï“  # Push dictionary string "# ÿ, ÿ bytes", where the `ÿ` are automatically
            # filled with the first two implicit inputs (name & byte-count)
I           # Push the third input-list of code-lines
 4ú         # Prepend 4 spaces before each line of code
   »        # And join it by newlines
"[tio]"     # Push string "[tio]"
       D    # Duplicate it
        “You€© [try€•€Ø]ÿ!“
            # Push dictionary string "You can [try it online]ÿ!", where the `ÿ` is
            # automatically filled with the "[tio]"
s           # Swap to get "[tio]" at the top of the stack again
¶           # Push a newline character
 ·          # Double it, which in the legacy version built in Python works with strings
  ý         # And join the stack by this double newline as delimiter
„:          # Push string ": "
   I        # Push the fourth input (link)
    J       # Join the entire stack together without delimiter
            # (after which the result is output implicitly)
“:# ÿ, ÿ¡Ï“ # Push dictionary string ":# ÿ, ÿ bytes", where the `ÿ` are automatically
            # filled with the first two implicit inputs (name & byte-count)
I4ú»        # Same as above
“You€© [try€•€Ø][tio]!“
            # Push dictionary string "You can [try it online][tio]!"
 Â          # Bifurcate it; short for Dulpicate & Reverse Copy
  6£        # Only leave the first 6 characters (the "![oit]")
    R       # Reverse it to "[tio]!"
     ¨      # Remove the last character: "[tio]"
¶·ý         # Same as above
À           # Rotate once towards the left, so the leading ":" becomes trailing
 $          # Push the fourth input (link) and a 1
  ú         # Prepend this link-string with that 1 space
   «        # And append it to the earlier created string
            # (after which the result is output implicitly)
```
[See this 05AB1E tip of mine (section *How to use the dictionary?*)](https://codegolf.stackexchange.com/a/166851/52210) to understand why `“# ÿ, ÿ¡Ï“` is `"# ÿ, ÿ bytes"` and `“You€© [try€•€Ø]ÿ!“` is `"You can [try it online]ÿ!"`.
[Answer]
# [Red](http://www.red-lang.org), ~~102~~ 94 bytes
-6 bytes thanks to Kevin Cruijssen!
```
func[l n c u][reduce["#"rejoin[l","]n{bytes
   }c{
You can [try it online][tio]!
[tio]:}u]]
```
[Try it online!](https://tio.run/##jY29TgMxEIR7P8WwERU/p@Q6PwWiQ9YWjm@PGJn1ybFRTlGe/TgS0VEwzTTzzVdkWF5lcGxGu4xNg0tQBDR2RYYWxNGGinzkqC7RI7Ge93OVozEALuFszFtuCF7hapkRK7KmqMKuxsx3xlzbXhrzMpWoFSNoFRJ2O9BocXOy819S/LsgMQj3dKh1OtquW@nn0rTb/DDm9kBP/84vskpf5nrIip6w7UHJf@4Hj5PF6WH7p3C67ntavgE "Red – Try It Online")
[Answer]
# [Haskell](https://www.haskell.org/), ~~125~~ ~~121~~ ~~119~~ 113 bytes
-4 bytes thanks to kronicmage  
-2 bytes thanks to xnor
```
(l!b)c t="# "++l++", "++show b++" bytes\n"++(("\n    "++)=<<c)++"\n\nYou can [try it online][tio]!\n\n[tio]: "++t
```
[Try it online!](https://tio.run/##LY7BDoIwEER/Zbp6aFMViTcCd@@eDHAAQkJjXQgsMX49tuqe3uzOTHZolkfv/bZpr1rTQQragaz11tIhwjKML7RBoX1Lv1QcdlpTxQgT2BR53plwr7ji@7iiaxilzG84wcjecV@X4sZaRcOXspiT7dk4RoFplZvM2EPT9fcMQeFyNihJq9QES0oH0qxcZIaF5mOq3DE1VIMGkWnJkiQ0n@aVk93wb9k@ "Haskell – Try It Online")
[Answer]
# [PHP](https://php.net/), ~~134~~ ~~132~~ ~~125~~ 119 bytes
```
# <?=($a=$argv)[1].", $a[2] bytes
".preg_replace("/^/m","    ",$a[3])."
You can [try it online][tio]!
[tio]: $a[4]";
```
[Try it online!](https://tio.run/##xY4xDoIwAEX3nqJWBklIG9BFlJAwObI4mKaaghWIQJvS0nD6il7Cv7zl5eWrVnm/hec82wU8C7hu5pDGDKMIBpwmDFaLERMACCstmocWque12CFyJwOKEFyHotXcsxAjAG7SwpqPkBq9wM5AOfbdKBg1nWQbAH5Mv@UDQyfvfXkpfRwf//agNUZNKSHOObxIa2wlcC0H4rip23zOnqNN5uL1Luz1Aw "PHP – Try It Online")
Finally an easy job for PHP!
EDIT: easily saved 2 bytes with concatenation in first `<?=`
EDIT 2: saved another 7 bytes, just remembered that multi-lines strings work in PHP with `"`
EDIT 3: and another 6 with using `/^/m` instead of `/\n/`
[Answer]
# JavaScript (ES6), 102 bytes
```
(n,b,c,l)=>`# ${n}, ${b} bytes
${c.replace(/^/gm, '    ')}
You can [try it online][tio]!
[tio]: `+l
```
[Try it online!](https://tio.run/##HYzLCoMwFET3@YpbFaqYGsRNEew3dFvEYkzjo8Qb0SiK@O3WOoszcGDmyyc@iL7pzG267yUmu4u0oIIqL3nkNjgrbvRgsUGxGDkQ4qwi6GWnuJAue7OqpXCFI1dvI@SlRxAcITX9Ao0BjapBmaWm0dmFkLNjyH21C42DVjJQunJLdK3nYmqNEFkUrPCk4m3x4TDHMPvhX9TGdEPM2HES9CMyuzs3keV5@w8)
"/^/gm" is a Global Multi-line replace of start line (^)
[Answer]
# [Python 3](https://docs.python.org/3/), ~~97~~ \$\cdots\$ ~~118~~ 116 bytes
Added 28 bytes to fix a bug kindly pointed out by [RGS](https://codegolf.stackexchange.com/users/75323/rgs).
Saved 2 bytes thanks to [ovs](https://codegolf.stackexchange.com/users/64121/ovs)!!! 
```
lambda n,b,c,l,x='\n':f"""# {n}, {b} bytes
    {c.replace(x,x+' '*4)}
You can [try it online][tio]!
[tio]: {l}"""
```
[Try it online!](https://tio.run/##pZHBa4MwFMbv@SueEWZs0znXnmSFwi7bYbDDLsPKiDbO0PQpGotF/Nu72LXdaTBYLu/L4@X7fkmqgylKnB/z5fqoxS7dCECe8oxr3i29NXpRTil1oceBQ58OkB6MbAgBu/rstpaVFplkHe@mHniThT8Q8l62kAmE2NQHUAZK1AplEhtVJg4hpxpBrwfrbEPxE5ZAX08gMKckKzdy7Jxxugi6aUhJW@uxWxhTNVEQWJPbusXArb5vQElVKzQsZ6MjBy2RjU4@h7FwsOd9n5yn6IxOFnd2e4l/Es1Wan1NXxMLx5zQtzokDB01KoQpMJyFjpqFvh34Faq42P0L6kWYQu6EUZn4eZY81h@JFW9qJ5vVij3n8WPZook1d5OHe@7yMLkJVtq/0plCNaAa9AzIvUQQsBdabcD@ytb5G@LxCw "Python 3 – Try It Online")
Takes code length as a parameter to save 3 bytes.
[Answer]
# [Kotlin](https://kotlinlang.org), ~~83 109 101~~ 95 bytes
```
{n,b,c,l->"""# $n, $b bytes
${c.prependIndent()}
You can [try it online][tio]!
[tio]: $l"""}
```
[Try it online!](https://tio.run/##VZBRT8IwFIWf7a@4FB62pLAlGIMkEI2IDiEaBzGG8DC6CgvldhkdMAm/fXYbJtqX23Pbc@7XbpSWEeb7QIJOMk@/opGiC5avkwhXDDzUDH5FVW1o9i9b6OUnZEvGmWz2KaV1aCCDxhKWmRY7Qhon3ooTEQsMPQwFass@E/KpUuABwtyMhEiDKocu5jpSixohZe1CQ5rAc/6VImyDCC0bTuSqAMVgK6AH9KVkp1WTq7BsUvrPAGbFhlRb9FlIqeCgEhnWqE3O5mpllQJXem3MRUarUpeTCDdF6FrreNd1HAPWSlJ06vWsc73POE7unI6TTN/fvCk/TtzbwezmKfAPj96DUlnHVa4cHH3eHmdDPv6O2iN/OJq56UfiOAd@Twm5qtj@fL1VvI5dmFiJxEoO2yDnPw "Kotlin – Try It Online")
-6 bytes thanks to @snail\_
-2 bytes thanks to @ovs 
-6 bytes since `prependIndent` has a default of 4 spaces
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 60 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
```
i`# {V}, {W} ßs
{XmiSp4 R}
YŒ ¯n [try Š Ò‚][o]!
[o]: 
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=aWAjIHtWfSwge1d9IN8acwoKe1htaVNwNCBSfQoKWYwgr24gW3RyeSCKII3Sgl1bk29dIQoKW5NvXTog&input=Imh0dHBzOi8vdGlvLnJ1bi8jcHl0aG9uMyIKIlB5dGhvbiAzIgoyMwoibGFtYmRhIHg6IHgrMQpwYXNzCnBhc3Mi)
[Answer]
## [W](https://github.com/A-ee/w) `j`, 77 bytes
```
# "a", "ck" bytes
"c'
,"
    ":@\+"
You can [try it online][tio]!
[tio]: "b
```
## Explanation
```
% Header section
# "               % The beginning header
   a              % The first input (the language name)
    ", "          % The comma & space
        ck        % The length of the program (taken at the 3rd input)
          " bytes % Appended with " bytes"
"                 % And a trailing newline
% Code section
c           % The third input
'
,           % Splitted by a newline
"
    "      % Add string representing a newline and 4 spaces
      :    % Stack: '\n'split(c), "    ", "    "
       @   % Stack: "     ",'\n'split(c), "    "
        \  % Join with 4 spaces
         + % Prepend 4 spaces
% Link section
          "
You can [try it online][tio]!
[tio]: "   % The template
         b % The second input
```
```
[Answer]
# Java 10, 141 bytes
```
(n,b,c,l)->{var t="";for(var p:c)t+="    "+p+"\n";return t.format("# %s, %d bytes\n\n%s\nYou can [try it online][tio]!\n\n[tio]: "+l,n,b,t);}
```
Takes the byte-count as integer-input, and the code as an array of String-lines.
[Try it online.](https://tio.run/##PVBBbsIwELz3FVMjpESYQK9E9NxLUaWeKuDgOAZMk3Vkb6gQytupXaVcdmc1s@vxnNVFzc/19103KgS8K0u3J8ASG39Q2mCTRuCTvaUjdDYCkkmDSo7Mdg/9j9HkZVwanmIJrNhqbEBY3zOSldSyyeevt4vy4LUQ5cH5LA3dSuc8W4v0mph1M7EjUXrDvSdwEVWt4kxMMA0S0xrVlU3Y0Y6msX65HloRtuyvsAxHjSWz37J1@@ck@kOreLeRyQPn5XAvk7@ur5rob7R5cbZGGzPIHr9S@RjANbBpC9dz0UWKG8qo0Jn48O7oVYuNag3ejDdC4mW5lCDz88jmJrSrIyOOzoTYTkk3SIgTcxdWi0W0V/ieFhORj9kN918)
**Explanation:**
```
(n,b,c,l)->{    // Method with four parameters and String return-type
  var t="";     //  Temp-String, starting empty
  for(var p:c)  //  Loop over the code-lines:
    t+="    "   //   Append four spaces,
       +p       //   the code-line itself,
       +"\n";   //   and a newline to this temp-String
  return t.format("# %s, %d bytes\n\n%s\nYou can [try it online][tio]!\n\n[tio]: "
                //  Return this String above, where:
    +l,         //   The link is appended at the end
    n,          //   The first `%s` is replaced with the name `n`
    b,          //   The `%d` is replaced with the byte-count `b`
    t);}        //   And the second `%s` is replaced with the temp-String
```
[Answer]
# [Wren](https://github.com/munificent/wren), 117 bytes
Just a normal string interpolation here.
```
Fn.new{|a,b,c,d|"# %(a), %(b) bytes
%("    "+c.split("
").join("
    "))
You can [try it online][tio]!
[tio]: "+d}
```
[Try it online!](https://tio.run/##JVDbbqpAAHzfr9iuaQI5BAyXok2atNWCUHtBUcCmD1xWWcCFwipie77dQ3rmYWaSSSaTaWtML8ewhoQyXFfwDl4MKlLcfv@EQiTEQvKDBvCaC3mh54iHUcdwA8A1h2AP9CcWm6ogjEMA8WJWEtq734TnAQjKA4xDCj9Y3UHCYEkLQvHnByPl5xUAv3rblyR/L8uuYXgvtjVhmPs/RozDouCQ109EgqoIKIxikOAt2KUECShlrGpuJakvEesDlQYDe6U/ThqrNeYHqVZ292a0CDAzXfV1tR1NHrpkT/Svyg@zL/UmPb5HGy3XbMt4yMls8zIfr50Ud@5iiOOpapr43O43rtOWqVxma8@dGQtv9r4K9GDsvKysiZxmm9exVpzyx3i7t@bpUrHtduq/WfPMqQLtvCTdiUyT0ZOc@OHJc56aAxkVuh/fZ74su@c8LzpFp5ph4lgq/cnNUjaHxrMn79gaq8piaD/vjudp2z95@Qc "Wren – Try It Online")
[Answer]
## [Japt](https://github.com/ETHproductions/japt), 85 bytes
```
"# {U}, {V} bytes
{"    "+Wq"
" q"
    "}
You can [try it online][tio]!
[tio]: "+X
```
[Try it online!](https://ethproductions.github.io/japt/?v=1.4.6&code=IiMge1V9LCB7Vn0gYnl0ZXMKCnsiICAgICIrV3EiCiIgcSIKICAgICJ9CgpZb3UgY2FuIFt0cnkgaXQgb25saW5lXVt0aW9dIQoKW3Rpb106ICIrWA==&input=IkphcHQiCjEwCiJhYmMKZGVmCmdoaSIKImh0dHBzOi8vZXRocHJvZHVjdGlvbnMuZ2l0aHViLmlvL2phcHQvP3Y9MS40LjYmY29kZT1JaU1nZTFWOUxDQjdWbjBnWW5sMFpYTUtDbnNpSUNBZ0lDSXJWM0VpQ2lJZ2NTSUtJQ0FnSUNKOUNncFpiM1VnWTJGdUlGdDBjbmtnYVhRZ2IyNXNhVzVsWFZ0MGFXOWRJUW9LVzNScGIxMDZJQ0lyV0E9PSZpbnB1dD1Ja3BoY0hRaUNqRXdDaUpoWW1NS1pHVm1DbWRvYVNJS0lpST0i)
[Answer]
# Jinja2, 102 bytes
```
# {{n}}, {{b}} bytes
{%for a in c%}
    {{a}}
{%endfor%}
You can [try it online][tio]!
[tio]: {{l}}
```
Does this count as a language? Used jinja cli from here: <https://pypi.org/project/jinja2-cli/> 
I think it should as this is the usage to run it: 
```
jinja2 tio.j2 test.json --format=json
```
It accepts a file as a program, and input in some format. That fits the definition of a language to me. 
This was the input json tested with:
```
{"n": "lang_name", "b": 10, "c": ["line_1", "line_2"], "l": "https://example.com"}
```
[Answer]
# [Keg](https://github.com/JonoCode9374/Keg), `-pn`, ~~92~~ ~~83~~ ~~79~~ 75 bytes
```
®N®l®b`# ©N, ©b  ¬E;s\n`,÷(\    $+,)
,“0:0X“` [try it a.;][tio]!\n[tio]: ©l`+,
```
Input is: Name, link, byte count and code
## Explained
```
®N®l®b
```
We first take the inputs `name`, `link` and `byte count` and store them in variable `N`, `l` and `b` respectively.
```
`# ©N, ©b  ¬E;s\n`,
```
Next, we construct a string that represents the header. The `©N` and `©b` are used for. string interpolation, and `¬E;` is the compressed word for `byte`. Printing the string using `,` formats the string with variables.
```
÷(\ $+,)
```
Now, we item split the implicit code list and print each item with a tab appended to it.
```
<newline>,
```
Then, we print a newline to separate everything.
```
“0:0X“` [try it a.;][tio]!\n[tio]: ©l`+,
```
Finally, we construct two strings: the string `You can` (represented by `“0:0X“`) and  `[try it online][tio]!\n[tio]: ©l` (which has the variable `l` interpolated within it). The two strings are then joined and printed.
[Try it online!](https://tio.run/##y05N////0Dq/Q@tyDq1LSlBWOLTSTwdIJCkoHFrjal0ck5egc3i7RgyniraOJpfOo4Y5BlYGEUAqQSG6pKhSIbNEIVHPOja6JDM/VjEmD0xbAfXnJGjr/P/vnZrOFeLpr5ttUmKWXWBexmXGFa2koaSjoFRjqK2pFKvwX7cgDwA "Keg – Try It Online")
## Answer History
### 79 bytes
```
0&®N®l®b`# ©N, ©b  ¬E;s\n`,÷(`\t`$+,)
,“0:0X“` [try it a.;][tio]!\n[tio]: ©l`+,
```
[Try it Online!](https://tio.run/##y05N///fQO3QOr9D63IOrUtKUFY4tNJPB0gkKSgcWuNqXRyTl6BzeLtGQkxJgoq2jiaXzqOGOQZWBhFAKkEhuqSoUiGzRCFRzzo2uiQzP1YxJg9MWwFNyEnQ1vn/3zs1nSvE018326TELLvAvIzLjCtaSUNJR0GpxlBbUylW4b9uQR4A)
### 83 bytes
```
0&®N®l®b`# ©N, ©b  bytes\n`,÷(`\t`$+,)
,`You can [try it online][tio]!\n[tio]: ©l`,
```
[Try it online!](https://tio.run/##y05N///fQO3QOr9D63IOrUtKUFY4tNJPB0gkKSgkVZakFsfkJegc3q6REFOSoKKto8mlkxCZX6qQnJinEF1SVKmQWaKQn5eTmZcaG12SmR@rGJMHpq2AJuQk6Pz/752azhXi6a@bbVJill1gXsZlxhWtpKGko6BUY6itqRSr8F@3IA8A "Keg – Try It Online")
Saved 9 bytes due to not calculating the byte count.
### 92 bytes
```
0&®N®l÷(:⑴⑼⑹")"⑺⑻®b`# ©N, ©b  bytes\n`,(`\t`$+,)
,`You can [try it online][tio]!\n[tio]: ©l`,
```
[Try it online!](https://tio.run/##y05N///fQO3QOr9D63IOb9ewejRxy6OJex5N3KmkqfRo4q5HE3cfWpeUoKxwaKWfDpBIUlBIqixJLY7JS9DRSIgpSVDR1tHk0kmIzC9VSE7MU4guKapUyCxRyM/LycxLjY0uycyPVYzJA9NWQP05CTr//3unpnOFePrrZpuUmGUXmJdxRStpKOkoKNUYamsqxSr81y3IAwA "Keg – Try It Online")
Note that I haven't applied string compression yet, which would get this down to 89 bytes. I'll do it tomorrow. The code is to be given as a list where each item is an individual line.
[Answer]
# C (gcc), 162 bytes
```
t(n,b,c,l)char*n,*c,*l;{for(printf("# %s, %d bytes\n\n    ",n,b);*c;)putchar(*c++)-10?:printf("    ");printf("\n\nYou can [try it online][tio]!\n\n[tio]: %s",l);}
```
There may be spaces after a trailing newline but I'm not sure if I'll be able to find a solution (or if a solution is even needed).
You can [try it online](https://tio.run/##jY@xjsIwDIb3PoXxCSkJRjoYbmgGBp4CEYZi4IjUc1AJSAjx7D23FQw3nMjkSP/32x9Pv5nbNhuhLTHVlo9V44Qck6v9/ZAac2qi5IPBDxifCcY72N7y/hwkCOhDUtJ6x96eLrmjjePJxE5nn4vyifZB65/fjl2lC3AlsM7NDWKGJHWU/WadY9qMukA/lboT9Sr/aBWFnyqKuaa4s8W96EqzwSUYVbBIMPuaE@AbKuGvi@4bbMI7OgGH6Eso4NDwv1MfeVmFQUvPRi0qHu0v)!
[Answer]
# Charcoal, ~~67~~ 56 bytes
```
Ｆ⪪“`⊟«Ｍ["Þ…εＵ↑⁵ï²¹@↧≡⊗»⭆∧⌕´r⪪ιυＮτ⁰⬤N➙⁺⁰UＹ⟧MyoJb⎇»﹪”¶«ι Ｓ
```
You can [try it online](https://tio.run/#charcoal)!
[Try it online!](https://tio.run/##RY/PSgJRFIfX9RSn62YGrFllYCJBq4IikBYxV0gHy4Hhjty5BhKBQllJCC0iglKCUNCsqAwmZ3Xd6zucF5hHmGYiafd9h/Pnd4xijht2zgqCA5uDkilZplBIjLI4ZZCviIJDOeUAQFkEe3YZjBwDXfAKmAJsZpmskNWFaWcXooZfSpI4EMqIqsLx/NwON5lQTHV1hgTIv2ywUllkRMiHihqWT4JAJ@t/qaI9KSedWElpThqWE5H7Xgd7Paze72OjLfu@N9ApGbew2pkMfW@I9WusDcev8l26a1jv4uUjNm7lCAd1vOji1Y385OH8xJ2e@d7L9BRrb/j8tI2tO6x9h7Lrey62u1sVezOPzXM58t3w2IP8kv2JC773EWUoClFykpoWPrvEy0yLGbPA2WDxyPoB) Link is to verbose version of code. Assumes you're not worried about Charcoal's default output padding, which can be turned off at a cost of 2 bytes. Explanation: Each input has a certain amount of text that appears before it, which always ends in a space, so the loop prints the text and space before each input. Because it uses separate print commands for the inputs, the newlines in the code block maintain the indent, but the text strings themselves include carriage returns which turn off the indent (particularly applicable to the TIO gubbins). The four text strings themselves are extracted from a large compressed string.
]