[Question]
  [
> 
> No, not the `^^vv<><>BA` kind of Easter eggs, real Easter eggs that we paint.
> 
> 
> 
Here is an (awfully drawn) egg.
```
  __
 /  \
/    \
|    |
\____/
```
In easter, we paint them with patterns. Like these:
```
  __
 /--\
/----\
|----|
\____/
  __
 /%%\
/%%%%\
|%%%%|
\____/
  __
 /~~\
/~~~~\
|~~~~|
\____/
```
---
# The challenge
Given a character (printable ascii) to paint the egg, print the painted egg.
**Examples:**
```
&:
  __
 /&&\
/&&&&\
|&&&&|
\____/
#:
  __
 /##\
/####\
|####|
\____/
```
# Specs
* Trailing newlines/spaces are allowed.
  
[Answer]
# [Brain-Flak](https://github.com/DJMcMayhem/Brain-Flak) `-c`, ~~270~~ ~~268~~ 266 bytes
```
(((((((((({}<(((([(()()())]((((((((((({}){}){}){}){}[()]))<>)<>{}())))))<>)<>(((()()()()()){}))({}()){})<>)<>>))))<<>({}<>)((()()()()()){})<>({}<>)>))))<<>((({})<>)({})<((()()()()()){})>[()()])>))<>((((({})<>)[(()()()()())({}){}])<((()()()()()){})<>((({}<>){}()))>))
```
[Try it online!](https://tio.run/nexus/brain-flak#ZY/dDcAgCITX4R66gWURw1PHMJ2dcvgTY4EElA9OXZa1tzBVEdBhsvewRRUYUDSivUHS8kQU08lCEogq@5pkcKGlOOF5v6jUJch00lpZGekuPOC6c/3h9p8e24PvP4gt7rdfzwc "Brain-Flak – TIO Nexus")
I was going to write an explanation, but I took a nap first and forgot how this whole thing works. Your guess is as good as mine.
[Answer]
## Python 2, 62 bytes
Super straight-forward. [Try it online](https://tio.run/nexus/python2#@19QlJlXolCkrq6uoBAfz6WgXxfDpV8HJGrq6mq4YuKBQB8oqVeUWpCTmJyqoV6nrpOZV1BaoqGpZaT5/7@6sjoA).  
-1 byte, thanks to @mbomb007
```
print r'''  __
 /~\
/~~\
|~~|
\____/'''.replace('~',input()*2)
```
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), ~~30~~ ~~26~~ 16 bytes
*Two bytes saved thanks to @Neil by filling after making the shape*
```
__↗¹←↑¹↖²↓_‖Ｍ←¤Ｓ
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z8@/lHb9EM7H7VNeNQ2EURPO7TpUdvk@EcN097vWQsUPrTk/Z7N//8rAwA "Charcoal – Try It Online")
### Explanation
The program works by first creating the right half of the egg, and then reflecting it to generate the left half.
```
__↗¹                          Write the two bottom _s and write the /
←↑¹                           Move left and write the |
↖²                            Then write two \s
↓_                            And the top _
‖Ｍ←                          Reflect the canvas to the left
¤Ｓ                           Fill the shape with the string input
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~24~~ 22 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
Ḥ;“ ¶/\|_”“Ṁ¢ṚR;ḳ}AṠ’ṃ
```
**[Try it online!](https://tio.run/nexus/jelly#ATMAzP//4bikO@KAnCDCti9cfF/igJ3igJzhuYDCouG5mlI74bizfUHhuaDigJnhuYP///8nfic)**
### How?
```
Ḥ;“ ¶/\|_”“Ṁ¢ṚR;ḳ}AṠ’ṃ - Main link: character c  e.g. '~'
Ḥ                      - double c: ['~','~']
  “ _¶/\|”             - string literal: [' ','_',<newline>,'/','\','|']
 ;                     - concatenate c:  [['~','~'],' ','_',<newline>,'/','\','|']
          “Ṁ¢ṚR;ḳ}AṠ’  - base 250 number: 3067183430901851641706
                     ṃ - base decompression with reversed @rguments:
                       -     take the number and convert it to a base length(the list)
                       -     then index (1-based) into that same list.
                       -     i.e.: 3067183430901851641706 in base 7
                                 = 22003241534115361163500004
                                   indexed into [['~','~'],' ','_',<newline>,'/','\','|']
                                 = [' ',' ','_','_',<newline>,' ','/',['~','~'],'\',<newline>,'/',['~','~'],['~','~'],'\',<newline>,'|',['~','~'],['~','~'],'|',<newline>,'\','_','_','_','_','/']
                       - implicit print:  __
                                         /~~\
                                        /~~~~\
                                        |~~~~|
                                        \____/
```
[Answer]
# Sed, 43 characters
```
s:.:  __\n /&&\\\n/&&&&\\\n|&&&&|\n\\____/:
```
Sample run:
```
bash-4.3$ sed 's:.:  __\n /&&\\\n/&&&&\\\n|&&&&|\n\\____/:' <<< '★'
  __
 /★★\
/★★★★\
|★★★★|
\____/
```
[Answer]
# JavaScript (ES6), ~~53~~ ~~49~~ 47 bytes
I'm sure I can squeeze a bit more out of this - having to escape the `\`s is annoying me.
```
f=
c=>`  __
 /${c+=c}\\
/${c+=c}\\
|${c}|
\\____/`
console.log(f`-`)
console.log(f`%`)
console.log(f`~`)
console.log(f`&`)
console.log(f`#`)
```
* 4 bytes saved by moving the `s=c+c` variable assignment inside the first set of `{}`.
* 2 bytes saved by using `c+=c` instead of `s=c+c` & `s=s+s`, with thanks in part to [Neil](https://codegolf.stackexchange.com/users/17602/neil) who spotted this improvement at the same time as I was making it.
---
## Paint Your Own!
```
f=
c=>`  __
 /${c+=c}\\
/${c+=c}\\
|${c}|
\\____/`
o.innerText=f` `;i.addEventListener("input",function(){o.innerText=f(this.value||" ");})
```
```
<input maxlength="1" id="i">
<pre id=o></pre>
```
[Answer]
## [Alice](https://github.com/m-ender/alice), ~~53~~ 52 bytes, non-competing
*Thanks to Leo for indirectly saving 1 byte.*
```
/o *^i}'.*[;.h~r}}~"{.[^\\
@"S .^~ y~a}~~.["{!~"}^^^
```
[Try it online!](https://tio.run/nexus/alice#@6@fr6AVl1mrrqcVba2XUVdUW1unVK0XHRcTw@WgFKygF1enUFmXWFtXpxetVK1Yp1QbFxf3/38cAA "Alice – TIO Nexus")
Unfortunately, I had to fix a bug with `y` (transliteration) to make this work, so I've marked it as non-competing.
### Explanation
The basic idea is to create a string of the egg but with `~` as a placeholder for *two* copies of the input. However, the other characters of the input aren't particularly friendly for Alice strings, because those can't contain linefeeds, and all of `/\_|` would need escaping (because they're treated as mirrors and walls). So I can save some bytes by using placeholders for these as well, and then transliterating them. The placeholders for `/\_|` are `.[^{`, which are simply the character right before the one they represent. For the linefeed I'm using `}`.
Now the code... the entire program can be solved in Ordinal mode since we only need string processing and no processing of integers. Furthermore, we don't need any conditional control flow. The entire program can be expressed linearly. The general structure of the program is this:
```
/...//
@....
```
In such a program, the IP bounces up and down through the `...` section, first only executing half of the characters. Then the two `/` at the end move the IP right by one cell, so that on the way back it executes the other half (again bouncing up and down) until finally the `@` terminates the program. So if we unfold the funny zigzag structure in the middle, the program we're executing really looks like this:
```
"  ^^} .~[}.~~[}{~~{}[^^^^.""!}"r.h~;a*y'~i.*So
```
Let's go through this:
```
"  ^^} .~[}.~~[}{~~{}[^^^^."
      This first string is simply the egg template I've talked about.
"!}"  Push this string. It covers all the characters we need to replace
      in the template except ~.
r     Range expansion. Turns '!}' into '!"#$...z{|}'.
.     Duplicate.
h~;   Split off the first character, swap it to the top and discard it.
a*    Append a linefeed.
      We've now basically rotated the string to the left, but appended
      a linefeed instead of the exclamation mark we've shifted off.
      This maps each character in the string to the next one, except }
      which gets mapped to a linefeed.
y     Transliterate. Since the strings have the same length, this just maps
      each character in the first string to the corresponding character in
      the second string, replacing all of our placeholder characters.
'~    Push "~".
i.*   Read the input and duplicate it.
S     Substitute all "~" with the doubled input.
o     Output the result.
```
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), ~~50~~ ~~49~~ 48 bytes
```
'  __
 /11\
/1111\
|1111|
\____/'-replace1,$args
```
[Try it online!](https://tio.run/nexus/powershell#@6@uoBAfz6Wgb2gYwwUkQFQNiKrhiokHAn113aLUgpzE5FRDHZXEovTi////q6uqAwA "PowerShell – TIO Nexus")
Straightforward string replacement into a literal string. Not much room for golfing.
*-1 byte thanks to HyperNeutrino; -1 byte thanks to wubs*
[Answer]
# [SOGL V0.12](https://github.com/dzaima/SOGLOnline), ~~21~~ ~~18~~ 16 [bytes](https://github.com/dzaima/SOGL/blob/master/chartable.md)
```
0≈⁾‛≤¦¶W?5┼EB§  ‘
```
[Try it Here!](https://dzaima.github.io/SOGLOnline/?code=MCV1MjI0OCV1MjA3RSV1MjAxQiV1MjI2NCVBNiVCNlclM0Y1JXUyNTNDRUIlQTclMDkldTIwMTg_,inputs=Lw__,v=0.12)
The whole program is the following compressed:
```
  __
 /ŗŗ\
/ŗŗŗŗ\
|ŗŗŗŗ|
\____/
```
where `ŗ` gets replaced with the input.
[13 bytes](https://dzaima.github.io/SOGLOnline/?code=YyVCMk8lQTYldTI1NUQldTAxNTdAJTJDJXUwM0I4JXUyMDFBJUIyJXUyMDE4JXUyNTZD,inputs=JTI1,v=0.12) almost works too, but it does [unneeded things](https://dzaima.github.io/SOGLOnline/?code=YyVCMk8lQTYldTI1NUQldTAxNTdAJTJDJXUwM0I4JXUyMDFBJUIyJXUyMDE4JXUyNTZD,inputs=JTVD,v=0.12) with certain inputs..
[Answer]
# Brainfuck - 257 bytes 181 bytes
Golfed:
Live version click [here](https://copy.sh/brainfuck/?c=KysrKysrK1s-KysrKysrPC1dPls-Kz4rKz4rKz4rKzw8PDwtXT4rKysrKz4-Pj4rKysrKysrKysrWz4rKys-Kzw8PCsrKys8KzwrPj4-LV0-Kys8PDwtLTwrPj4-LD4uLjw8PDwuLj4-Pj4-LjwuPDw8PDwuPj4-Pi4uPDwuPj4-Pi48PDw8PDwuPj4-Pi4uLi48PC4-Pj4-Ljw8PC4-Li4uLjwuPj4-Ljw8PDwuPC4uLi48Lg$$)
```
+++++++[>++++++<-]>[>+>++>++>++<<<<-]>+++++>>>>++++++++++[>+++>+<<<++++<+<+>>>-]>++<<<--<+>>>,>..<<<<..>>>>>.<.<<<<<.>>>>..<<.>>>>.<<<<<<.>>>>....<<.>>>>.<<<.>....<.>>>.<<<<.<....<.
```
I'm not a professional golfer though; this is my first attempt.
Output:
```
  __ 
 /XX\ 
/XXXX\ 
|XXXX| 
\____/ where X is the given char.
```
---
Ungolfed ( + comments) :
```
; chars:
; _ 95
; / 47
; \ 92
; | 142
; min val = 42 (7 times 6)
; lets do some math
+++++++[>++++++<-]> ; effectively 7 times 6
; now lets copy this to the next pointers multiplying by 2 
the subsequent ones after the 1st
[>+>++>++>++<<<<-]
>+++++
>>>
> ; empty space starting from this pointer
++++++++++[>+++>+<<<++++<+<+>>>-]
>++<
<<--<+
>>>,
>..<<<<..>>>>>.<.
<<<<<.
>>>>..<<.>>>>.
<<<<<<.>>>>....<<.>>>>.
<<<.>....<.
>>>.<<<<.<....<.
```
[Answer]
# [Carrot](https://github.com/kritixilithos/Carrot), 34 bytes
```
  __
 /##\\
/####\\
|####|
\\____/
```
Try it online [here](http://kritixilithos.github.io/Carrot/).
First, we are in caret-mode, where every character gets pushed to the "stack". And finally the "stack" gets printed as output.
In caret-mode, `#` pushes the input, so the instances of `#` are basically replaced with the input (FYI `#` is a one-byte cat program).
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~34~~ ~~33~~ 32 bytes
```
„__I244S×'/ì'\«`©¦¨'|.ø®R¹'_‡).c
```
[Try it online!](https://tio.run/nexus/05ab1e#ATEAzv//4oCeX19JMjQ0U8OXJy/DrCdcwqtgwqnCpsKoJ3wuw7jCrlLCuSdf4oChKS5j//9@ "05AB1E – TIO Nexus")
**Explanation**
```
„__                               # push "__"
   I244S×                         # push a list of the input repeated 2 and 4 and 4 times
         '/ì                      # prepend "/"
            '\«                   # append "\"
               `                  # split list to separate items
                ©                 # store a copy of the last one in register
                 ¦¨               # remove first and last item of the string
                   '|.ø           # surround with pipes
                       ®R         # retrieve the string from register and reverse it
                         ¹'_‡     # replace input with "_"
                             ).c  # print each line centered
```
[Answer]
# [Python 3.6](https://docs.python.org/3.6/), 53 bytes
```
lambda x:fr'''  __
 /{2*x}\
/{4*x}\
|{4*x}|
\____/'''
```
* Unnamed function taking the character `x` and returning a string.
* Uses Python 3.6's f-strings as an added alternative to earlier version's `.format()` - the `{}` enclosed parts of the f-string are code to be evaluated.
* The string is also an r-string and triple quoted saving one byte over:
```
lambda x:f'  __\n /{2*x}\\\n/{4*x}\\\n|{4*x}|\n\____/'
```
~~I can't see an online interpreter for Python 3.6 though.~~  
Try it at **[repl.it](https://repl.it/INeK)** (says 3.5 but it is 3.6)
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), ~~43~~ 41 bytes
-2 bytes thanks to [Kevin Cruijssen](https://codegolf.stackexchange.com/users/52210/kevin-cruijssen)
```
.
$&$&
..
  __¶ /$&\¶/$&$&\¶|$&$&|¶\____/
```
[Try it online!](https://tio.run/##K0otycxL/P9fj0tFTUWNS0@PS0EhPv7QNgV9FbWYQ9v0QaJAugZE1xzaFhMPBPr//6sBAA "Retina 0.8.2 – Try It Online")
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~32~~ ~~29~~ 26 bytes (Thanks to Emigna/Adnan)
```
•jÀÅˆiXƒÐ[Z•6B6ôvy5ÝJ¹"_ |/\ÿ"‡,
```
[Try it online!](https://tio.run/nexus/05ab1e#@/@oYVHW4YbDrafbMiOOTTo8IToKKGLmZHZ4S1ml6eG5Xod2KsUr1OjHHN6v9Khhoc7//xkA "05AB1E – TIO Nexus")
```
•jÀÅˆiXƒÐ[Z•6B6ô # Push ['110011', '135541', '355554', '255552', '400003']
vy               # For each encrypted block...
  5ÝJ            # Push 012345.
     ¹"_ |/\ÿ"   # Push "_ |/\{input_char}".
              ‡, # Swap the charsets.
```
---
29 byte version (smarter w/o iteration needed due to encoding newlines as well):
# [05AB1E](https://github.com/Adriandmen/05AB1E), 29 bytes (Emigna)
```
•P£<r7»TwDšç6•5ÝJI"
_/ÿ\|"‡.c
```
[Try it online 2!](https://tio.run/nexus/05ab1e#@/@oYVHAocU2ReaHdoeUuxxdeHi5GVDI9PBcL08lrnj9w/tjapQeNSzUS/7/vw4A "05AB1E – TIO Nexus")
---
26 byte extension of Emigna's suggestion, using S to separate the chars into an array, then a[b] to interpolate each digit with the corresponding location in the previous array. This is essentially an element-wise transliteration (smart).
# [05AB1E](https://github.com/Adriandmen/05AB1E), 26 bytes (Adnan)
```
"
_/ÿ\|"•P£<r7»TwDšç6•Sè.c
```
[Try it online 3!](https://tio.run/nexus/05ab1e#@6/EFa9/eH9MjdKjhkUBhxbbFJkf2h1S7nJ04eHlZkCh4MMr9JL//08EAA "05AB1E – TIO Nexus")
[Answer]
# PHP, 51 bytes
```
$a.=$a=$argn;echo"  __
 /$a\
/$a$a\
|$a$a|
\____/";
```
PHP, 58 Bytes without physical linebreaks
```
$a.=$a=$argn;echo"  __\n /$a\\\n/$a$a\\\n|$a$a|\n\\____/";
```
run this with `-R` option
61 Bytes
```
echo strtr("  __\n /88\\\n/8888\\\n|8888|\n\\____/",8,$argn);
```
[Answer]
## BF, ~~142~~ 140 bytes
```
++++[->++++<]>[->+++>++++++>+>++++++>++>++++++++<<<<<<],>->---->------>->..<..<.>>.<<<<.<..
>>.>.<<.<....>>.>.>>>----.<....>.<<<.<.>>....<<<.
```
This is split across two lines for clarity; the newline is not counted.
It's fairly easy to write this sort of thing in BF, but it's non-trivial how to optimize the order of the cells to minimize movement. I wrote a brute-forcer script to try all the combinations and find the shortest, and I golfed it a bit to account for a golfing opportunity I hadn't included in the brute-forcer.
[Answer]
# [brainfuck](https://github.com/TryItOnline/brainfuck), 114 bytes
```
-----[[<+>->++>++<<]->]<+++++++++++<+..<..>>.<.<<.>>,..<---.>>.<<<.>>....<.>>.<<<<---.>>>....<<<.>>>>.<<.+++....<.
```
[Try it online!](https://tio.run/##RYxRCoBACERP05c5Jxi8yLIfFQQR9BF0fnM1SESZN6PrvRzX/mynu45qjWJqItFkV@uUvygAAbOYZOw5dFwlSQCMRMnPKZZucsSjirlPLw "brainfuck – Try It Online")
I've used [BF Crunch](https://github.com/primo-ppcg/BF-Crunch) here to find a more optimal way to generate the individual characters.
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~95~~ ~~88~~ 85 bytes
Thanks to Albert for -7 bytes
Thanks also to ceilingcat -3 bytes
```
f(c){for(int*s=L"  __\n /00\\\n/0000\\\n|0000|\n\\____/\n";*s;s+=printf(*s%6?s:&c));}
```
[Try it online!](https://tio.run/##S9ZNT07@/z9NI1mzOi2/SCMzr0Sr2NZHSUEhPj4mT0HfwCAmJiYPSEEYNSBGTUxeTEw8EOjH5ClZaxVbF2vbFhQBdaZpaBWrmtkXW6kla2pa1/7nyk3MzNPQ5Krm4lIAgjQNdQd1TWsYWwvG5qr9DwA "C (gcc) – Try It Online")
[Answer]
# SpecBAS - 70 bytes
```
1 INPUT a$:  ?"  __"'" /";a$*2;"\"'"/";a$*4;"\"'"|";a$*4;"|"'"\____/"
```
`?` is shorthand for `PRINT` command, and apostrophe moves cursor to next line.
[Answer]
# [Röda](https://github.com/fergusq/roda), 46 bytes
```
{a=`  __
 /-\
/--\
|--|
\____/`a~="-",_*2;[a]}
```
[Try it online!](https://tio.run/nexus/roda#DcTRCoIwAAXQ592vuBiFRmPRYzH8kBZzYCMRN7F8cvrry/NwBtcFLvTUNHlxuiGtBZU0UHIvSZlg7E41btOFLC72fHs83WvNwseJPdsIIcapCz@O8/dT9hUTfVlBtDG8seYTDjjCYsMVd9R/ "Röda – TIO Nexus")
[Answer]
# Python, 59 bytes
```
lambda n:r'''  __
 /a\
/aa\
|aa|
\____/'''.replace('a',n*2)
```
[Answer]
# Lua, 66 bytes
```
print((([[  __
 /ee\
/eeee\
|eeee|
\____/]]):gsub("e",io.read())))
```
((([[#NailedIt]])))
[Answer]
# [Retina](https://github.com/m-ender/retina), 41 bytes
```
.
$0$0
..
  __¶ /$0\¶/$0$0\¶|$0$0|¶\____/
```
[Try it online!](https://tio.run/nexus/retina#@6/HpWKgYsClp8eloBAff2ibgr6KQcyhbfogUSBdA6JrDm2LiQcC/f//VQA "Retina – TIO Nexus")
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 35 bytes
```
"  __
 /01
/001
|00|
1____/"d0U²1'\
```
[Try it online!](https://tio.run/nexus/japt#@6@koBAfz6Wgb2DIpW8AJGoMDGq4DOOBQF8pxSD00CZD9Zj//5XqlAA)
### 41-byte solution:
```
[S²'_²RS'/U²'\R'/U²²'\R'|U²²'|R'\'_²²'/]q
```
[Try it online!](https://tio.run/nexus/japt#@x8dfGiTevyhTUHB6vqhQGZMEJiGsGogrJog9RiQGiBTP7bw/3@lOiUA)
[Answer]
# [R], 65 bytes
```
cat(gsub('x',scan(,''),"  __\n /xx\\\n/xxxx\\\n|xxxx|\n\\____/"))
```
Pretty unspectacular, please find a shorter one in R...
It's your basic gsub
[Answer]
## C++ 208 bytes
In response to comments:
This is a complete re-post.
```
#include<iostream>
using namespace std;int main(){char e;cin>>e;cout<<"  __  \n";cout<<" /"<<e<<e<<"\\ "<<endl;cout<<"/"<<e<<e<<e<<e<<"\\"<<endl;cout<<"|"<<e<<e<<e<<e<<"|"<<endl;cout<<"\\____/ \n";return 0;}
```
[Answer]
## [C#](http://csharppad.com/gist/156803275214446f2e7334d7bc80f6aa), 56 bytes
---
**Golfed**
```
i=>"  __\n /i\\\n/ii\\\n|ii|\n\\____/".Replace("i",i+i);
```
---
**Ungolfed**
```
i => 
   "  __\n /i\\\n/ii\\\n|ii|\n\\____/"
      .Replace( "i", i + i );
```
---
[Answer]
# [C(gcc)](https://gcc.gnu.org/), 87 bytes
```
e(d){printf("  __\n /%c%c\\\n/%c%c%c%c\\\n|%c%c%c%c|\n\\____/\n",d,d,d,d,d,d,d,d,d,d);}
```
printf without stdio.h causes warnings but no errors, allowing successful compilation.
### Explanation
Printf statement that crams everything into one line, formatting the decoration character with %c.
[Try it online](https://tio.run/nexus/c-gcc#ZYzBCoMwDIbvPkUoCO106GG34l7EiEjVrYdF6dpd1L26s3Xusj8Q/j9fkrXjrZhGo8n2nAHUNRJksYoVIlIwR5iPMCMh1psyJJa2/yXksm4P4dFo4t405qZSUAM9Lah7Y@DkR6@yEjBFsMkvaRls4IOzo7PlpYIC2Dl@s531gwGui1x@ua6uuQSdJMcfr47/qNjPltBNZ50hyGW0ROsH)
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 84 bytes
```
g(f){char e[]={f,f,f,f};printf("  __\n /%.2s\\\n/%.4s\\\n|%.4s|\n\\____/\n",e,e,e);}
```
[Try it online!](https://tio.run/nexus/c-gcc#Tc3BCsIwDAbg@54iTObaUZ2It@KTGClltHUHg9TpZauvPttCYfkv308IWR2zfB4e2oO53a@zFTlBvvxIk2U1gFJI0DfH8xsRKeKSsSQsSIgqTo9UC5PCZVjjKTz1SCxBezcIyC@6LpYvh7mCOI61h5bL4mbjXzSUst8sdhtDsTfTxxOcZBXWPw "C (gcc) – TIO Nexus")
]