[Question]
  [
As the majority of nations using the Euro have the `,` as the decimal separator, you must use it also.
The task is to output all the values of the Euro coins and notes in ascending order. You must also put the trailing `,00` on the integer values.
`0,01 0,02 0,05 0,10 0,20 0,50 1,00 2,00 5,00 10,00 20,00 50,00 100,00 200,00 500,00`
I accept both output to stdout or a function returning an array/list. If output is to stdout, the acceptable separators between values are: space, tab, or newline.
There will be no accepted answer, unless I see some one I find very creative.
[code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so I want to know shortest answer by language.
# Update:
Leading `0` zeros are not acceptable. Sorry, I should make it clear before.
# Update 2:
It is also acceptable a function returning a string.
  
[Answer]
# Pure Bash, 48
```
s={1,2,5}
eval echo 0,0$s 0,${s}0 ${s}{,0,00},00
```
[Try it online](https://tio.run/##S0oszvj/v9i22lDHSMe0liu1LDFHITU5I1/BQMdApRhIqlQX1xoogMhqHaCYQS0Q//8PAA).
[Answer]
# [Japt](https://github.com/ETHproductions/japt), ~~23~~ 22 bytes
*-1 byte thanks to @Shaggy*
```
5Æ#}ì ®eX-2 x2 d".,"
c
```
Returns an array of strings.
[Try it online!](https://ethproductions.github.io/japt/?v=1.4.5&code=NcYjfewgrmVYLTIgeDIgZCIuLCIKYw==&input=LVI=) with the `-R` flag to output array items on separate lines.
[Answer]
# [Python 2](https://docs.python.org/2/), 72 bytes
```
print[('%.2f'%(10**(x/3-2)*(5>>~x%3))).replace(*'.,')for x in range(15)]
```
[Try it online!](https://tio.run/##BcFBCoAgEADAr3gRd6Usla5@JDpIaAmxiniwS1@3mfK2O5MZo9REbQfBlYmCg16lhL7Y2aCEzbmvc4uIqoby@DOAFGoSGHNlnSVi1dMVQG94jPED "Python 2 – Try It Online")
The expression `5>>~x%3` maps the non-negative integers to `1`, `2`, `5`, `1`, `2`, `5`…
It works because `5`, `2`, `1` are the successive right-bitshifts of `5` (`0b101` → `0b10` → `0b1`); we cycle through them backwards.
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 36 bytes
```
ＥＥ×125⁵⁺⁺×0⁻²÷κ³ι×0÷κ³⁺⁺✂ι⁰±²¦¹,✂ι±²
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z@gKDOvRMM3sQCMQzJzU4s1lAyNTJV0FEw1dRQCckqLNcAEVMoAKOGbmQcUMNJR8Mwrccksy0xJ1cjWUTDW1ARqyNRRQFKJoQDFyOCczORUDaAOAx0Fv9T0xJJUDSOgAkMgVtJRApJwBXBZELD@//@/btl/3eIcAA "Charcoal – Try It Online") Link is to verbose version of code. Explanation:
```
   125                                  String `125`
  ×   ⁵                                 Repeated 5 times
 Ｅ                                      Map over each character
              ÷κ³   ÷κ³                 Integer divide loop index by 3
            ⁻²                          Subtract from 2
          ×0      ×0                    Repeat the string `0` x times
        ⁺⁺       ι                      Concatenate with the character
Ｅ                                       Map over each resulting string
                         ✂ι⁰±²¦¹        Slice off the last two digits
                                ✂ι±²    Extract the last two digits
                       ⁺⁺       ,       Concatenate with a comma
                                        Implicitly print one per line
```
[Answer]
# [SOGLOnline](https://github.com/dzaima/SOGLOnline) offline, ~~27~~ ~~26~~ ~~25~~ ~~24~~ ~~23~~ ~~22~~ 21 [bytes](https://github.com/dzaima/SOGL/blob/master/chartable.md)
```
252¹5∙īυ;{⁴Ζ.,ŗP*F⁾?½
```
[Try it Here!](https://dzaima.github.io/SOGLOnline/?code=MjUyJUI5NSV1MjIxOSV1MDEyQiV1MDNDNSUzQiU3QiV1MjA3NCV1MDM5Ni4lMkMldTAxNTdQKkYldTIwN0UlM0YlQkQ_)
The online link doesn't show trailing zeroes, but the offline version does as Javas BigDecimals are nice.
Explanation:
```
252¹5∙īυ;{⁴Ζ.,ŗP*F⁾?½
252¹                 push the array [2, 5, 2]
    5∙               multiply vertically by 5
      īυ;            push 0.01 below that - the main number
         {           iterate over that array - [2,5,2,2,5,2,2,5,2,2,5,2,2,5,2]
          ⁴            duplicate the main number
           Ζ.,ŗ        replace "." with ","
               P       output in a new line
                *      multiply the main number with the current item of the array
                 F⁾?   if the current array item-2 isn't 0, then
                    ½    divide by 2
```
TO run in the offline interpreter, download [SOGLOnlines repository](https://github.com/dzaima/SOGLOnline), go to compiler/interpreter, open any of the `.pde` files with [Processing](http://processing.org/), then do file -> export for your OS (otherwise you can't give arguments to a Processing program :/), and then execute the compiled program with an argument to the path of the file with the code. Then, stdout will contain [this](https://pastebin.com/Jy1u2vkQ).
[`2L¼2¹5∙īυ;{⁴Ζ.,ŗP*`](https://dzaima.github.io/SOGLOnline/?code=MkwlQkMyJUI5NSV1MjIxOSV1MDEyQiV1MDNDNSUzQiU3QiV1MjA3NCV1MDM5Ni4lMkMldTAxNTdQKg__) for 18 bytes almost works but the zero amount grows, resulting in `0,01 0,02 0,050 0,100 0,200 0,5000 1,0000 2,0000 5,00000 10,00000 20,00000 50,000000 100,000000 200,000000 500,0000000` (newlines replaced with spaces)
[Answer]
# Java 8, ~~109~~ ~~108~~ ~~81~~ 80 bytes
Thanks to @OlivierGrégoire for the Locale idea
```
x->{for(double i=.001;i<11;)System.out.printf("%.2f %.2f %.2f ",i*=10,i*2,5*i);}
```
[Try it online!](https://tio.run/##TY@xasMwFEV3f8UjUJBDIuxAJ8VZ0pYOpYVm6FA6KLIUnitLRnoKLcHf7go30C53OFwu53byLNd@0K5rPyfsBx8Iusx4IrT8yStptSiUlTHCG1wKgEiSUP0rmeQUoXd8711MvQ7bl2OnFe0gQDN9rXcX4wNrfTpaDdjwqqoFbutalIfvSLrnPhEfAjoybHHDNwb@YrHCZVNXOTer2yWWYpxEdhjyVna4qpw9ttBLdOxAeeb0/iHLWRXg9wCPmu60kckSu5KH1/vn/WMp5lbgUik9EHPJ2pmNxTj9AA "Java (OpenJDK 8) – Try It Online")
[Answer]
# [Bash](https://www.gnu.org/software/bash/), 38 bytes
```
printf %.2f\\n {1,2,5}e{-2..2}|sort -h
```
Requires an appropriate locale, [which is allowed by default and costs no bytes](https://codegolf.meta.stackexchange.com/a/7886/12012).
[Try it online!](https://tio.run/##S0oszvjv4@jnbpuaF@/i/b@gKDOvJE1BVc8oLSYmT6HaUMdIx7Q2tVrXSE/PqLamOL@oREE34/9/AA "Bash – Try It Online")
[Answer]
# [APL (Dyalog)](https://www.dyalog.com/), ~~30~~ 28 bytes
Complete program. Outputs to space-separated to STDOUT.
```
'\.'⎕R','⊢2⍕×\.01,14⍴2 2.5 2
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///qKPdtbQov/i/eoye@qO@qUHqOuqPuhYZPeqdenh6jJ6BoY6hyaPeLUYKRnqmCkYg5f/B6gE "APL (Dyalog Unicode) – Try It Online")
`2 2.5 2` the list;  
 `[2,2.5,2]`
`14⍴` cyclically **r**eshape to length 14;  
 `[2,2.5,2,2,2.5,2,2,2.5,2,2,2.5,2,2,2.5]`
`.01` prepend 0.01;  
 `[0.01,2,2.5,2,2,2.5,2,2,2.5,2,2,2.5,2,2,2.5]`
`×\` cumulative multiplication;  
 `[0.01,0.02,0.05,0.1,0.2,0.5,1,2,5,10,20,50,100,200,500]`
`2⍕` format with two decimals;  
 `" 0.01 0.02 0.05 0.10 0.20 0.50 1.00 2.00 5.00 10.00 20.00 50.00 100.00 200.00 500.00"`
`⊢` yield that (to separate `','` from `2`)
`'\.'⎕R','` PCRE **R**eplace periods with commas;  
 `" 0,01 0,02 0,05 0,10 0,20 0,50 1,00 2,00 5,00 10,00 20,00 50,00 100,00 200,00 500,00"`
[Answer]
# R ~~70~~, 50 bytes
inspired by @Giuseppe:
```
format(c(1,2,5)*10^rep(-2:2,e=3),ns=2,de=",",sc=F)
```
[Try it here!](https://tio.run/##K/r/Py2/KDexRCNZw1DHSMdUU8vQIK4otUBD18jKSCfV1lhTJ6/Y1kgnJdVWSUdJpzjZ1k3z/38A)
Ungolfed
```
format(c(1,2,5)*10^rep(-2:2, each = 3),
   nsmall = 2, 
   decimal.mark = ",",
   scientific = FALSE)
```
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), 37 bytes
```
smmX%"%.2f"*dk\.\,[1 2 5)[.01.1 1T^T2
```
[Try it online!](https://tio.run/##K6gsyfj/vzg3N0JVSVXPKE1JKyU7Ri9GJ9pQwUjBVDNaz8BQz1DBMCQuxOj/fwA "Pyth – Try It Online")
# [Pyth](https://github.com/isaacg1/pyth), 37 bytes
Will shorten in a few minutes.
```
V[.01.1 1T^T2)V[1 2 5)X%"%.2f"*NH\.\,
```
[Try it online!](https://tio.run/##K6gsyfj/Pyxaz8BQz1DBMCQuxEgzLNpQwUjBVDNCVUlVzyhNScvPI0YvRuf/fwA "Pyth – Try It Online")
[Answer]
# JavaScript (ES6), 83 bytes
Returns an array.
```
_=>[...'125'.repeat(k=5)].map(c=>(c*(c-1?k:k*=10)/5e3).toFixed(2).split`.`.join`,`)
```
### Demo
```
let f = 
_=>[...'125'.repeat(k=5)].map(c=>(c*(c-1?k:k*=10)/5e3).toFixed(2).split`.`.join`,`)
console.log(f())
```
---
# Recursive version (ES7), 84 bytes
Returns a string with a trailing space.
```
f=(i=0)=>i<15?('125'[i%3]/100*10**(i/3|0)).toFixed(2).split`.`.join`,`+' '+f(i+1):''
```
### Demo
```
f=(i=0)=>i<15?('125'[i%3]/100*10**(i/3|0)).toFixed(2).split`.`.join`,`+' '+f(i+1):''
console.log(f())
```
[Answer]
# [Python 2](https://docs.python.org/2/), ~~80~~ ~~77~~ ~~75~~ 73 bytes
*-2 bytes thanks to @Mr.Xcoder*  
*-1 byte thanks to @EriktheOutgolfer*  
*-2 bytes thanks to @totallyhuman*  
*-2 bytes thanks to @Lynn*
```
print[('%.2f'%(v*m)).replace(*'.,')for m in.01,.1,1,10,100for v in 1,2,5]
```
[Try it online!](https://tio.run/##K6gsycjPM/r/v6AoM68kWkNdVc8oTV1Vo0wrV1NTryi1ICcxOVVDS11PR10zLb9IIVchM0/PwFBHz1AHCA2AyAAkXAYUVjDUMdIxjf3/HwA "Python 2 – Try It Online")
[Answer]
# [Retina](https://github.com/m-ender/retina), 42 bytes
```
5$*0
0
$'1$`¶$'2$`¶$'5$`¶
..¶
,$&
m`^00?
```
[Try it online!](https://tio.run/##K0otycxL/P@fy1RFy4DLgEtF3VAl4dA2FXUjCGUKorj09ICEjooaV25CnIGBPdf//wA "Retina – Try It Online") Explanation: There are fifteen values, with 1, 2 and 5 in each of five places. The first stage inserts five 0s. The second stage repeats them into a square, then changes the trailing diagonal into 1s, then duplicates those lines three times with 2 and 5. The third stage inserts the commas and the last stage removes unnecessary leading zeros.
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 37 bytes
```
”{➙∧N\`�4✳×″↶tι⦄|Ｑ~(↥↗⁻“Ｑ§U‴w⎇δUη◨÷¤Ｇ”
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z@gKDOvREPJQMfAUAFIGIEIUyBhaAAkjECEqYGCoY6BgYIRiDAFEYYGYD6YNDWAiECFoGIgSknz////umX/dYtzAA "Charcoal – Try It Online") Link is to verbose version.
Yay, compression!
[Answer]
# [Bash](https://www.gnu.org/software/bash/), 88 bytes
```
s=125
for i in {0..14};{ printf %1.2f\  `bc<<<"scale=2;${s:i%3:1}*10^$[i/3-2]"`|tr . ,;}
```
[Try it online!](https://tio.run/##S0oszvj/v9jW0MiUKy2/SCFTITNPodpAT8/QpNa6WqGgKDOvJE1B1VDPKC1GQSEhKdnGxkapODkxJ9XWyFqlutgqU9XYyrBWy9AgTiU6U99Y1yhWKaGmpEhBT0HHuvb/fwA "Bash – Try It Online")
[Answer]
# JavaScript (ES6), 81 bytes
Returns an array.
```
_=>[...Array(13),b=.005,i=0].map(p=>(b*=++i%3?2:2.5).toFixed(2).replace(".",","))
```
### Demo
```
let f = 
_=>[...Array(13),b=.005,i=0].map(p=>(b*=++i%3?2:2.5).toFixed(2).replace(".",","))
console.log(f())
```
---
[Answer]
# Common Lisp, 95 bytes
```
(dotimes(i 5)(dolist(j'(1 2 5))(princ(substitute #\, #\.(format()"~$ "(*(expt 10(- i 2))j))))))
```
[Try it online!](https://tio.run/##HYhLCoAwEMWuMqjgG1FRwdu48VNhxE@xU3Dl1WsxkEUy7@JsCFgulcM4CPUcI17FlqOlLg6GveWc4fzkVNSroXQoozXW6z5GBSdvRgkKmMcqtQ0qEuqYN/4J4QM)
[Answer]
# [Husk](https://github.com/barbuz/Husk), 28 bytes
```
ṁm↔ṪöJ',CtN`J§¤eR'0≥≤2ḣ5"125
```
[Try it online!](https://tio.run/##ATMAzP9odXNr///huYFt4oaU4bmqw7ZKJyxDdE5gSsKnwqRlUicw4oml4omkMuG4ozUiMTI1//8 "Husk – Try It Online")
Just string manipulation, since Husk is terrible at formatting floating point numbers.
## Explanation
```
ṁm↔ṪöJ',CtN`J§¤eR'0≥≤2ḣ5"125
                        "125  The string "125".
                      ḣ5      The range [1,2,3,4,5].
   Ṫö                         Compute their outer product wrt this function:
                               Arguments are number n (say 3) and character c (say '5').
             §     ≥≤2         Compute max(0,n-2+1) and max(0,2-n+1),
                R'0            repeat '0' those numbers of times,
              ¤e               and put them into a list: ["00",""]
           `J                  Join with c: "005"
        CtN                    Split to lengths 2 and at most 3: ["00","5"]
     J',                       Join with ',': "00,5"
                              This gives a 2D array of the outputs reversed.
ṁ                             Map and concatenate
 m↔                           map reversal.
                              Implicitly print separated by newlines.
```
[Answer]
## C++, ~~138~~ 120 bytes
-18 bytes thanks to MSalters
```
#include<iostream>
void p(){for(auto&a:{"0,0%d ","0,%d0 ","%d,00 ","%d0,00 ","%d00,00 "})for(int b:{1,2,5})printf(a,b);}
```
**Hardcoded version, by Lynn, 116 bytes**
```
#include<ios>
void p(){puts("0,01 0,02 0,05 0,10 0,20 0,50 1,00 2,00 5,00 10,00 20,00 50,00 100,00 200,00 500,00");}
```
[Answer]
# [R](https://www.r-project.org/), ~~70~~ 61 bytes
```
options(scipen=9,OutDec=",")
print(c(1,2,5)*10^rep(-2:2,e=3))
```
[Try it online!](https://tio.run/##K/r/P7@gJDM/r1ijODmzIDXP1lLHv7TEJTXZVklHSZOroCgzr0QjWcNQx0jHVFPL0CCuKLVAQ9fIykgn1dZYU/P/fwA "R – Try It Online")
*-9 bytes thanks to Rui Barradas*
Outgolfed by [AndriusZ](https://codegolf.stackexchange.com/a/141464/67312)
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 82 bytes
```
p(n){printf("%d,%02d ",n/100,n%100);}f(n){for(n=1;n<5e4;n*=10)p(n),p(n*2),p(n*5);}
```
[Try it online!](https://tio.run/##S9ZNT07@/79AI0@zuqAoM68kTUNJNUVH1cAoRUFJJ0/f0MBAJ08VSGpa16aBFKXlF2nk2Rpa59mYpppY52nZGhpognTrAAktIwhlClT8PzcxM08DqF4DxAEA "C (gcc) – Try It Online")
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), 25 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
125S5иεN3÷°*т/'.',:N2›i0«
```
Returns a list of strings.
[Try it online.](https://tio.run/##ASsA1P9vc2FiaWX//zEyNVM10LjOtU4zw7fCsCrRgi8nLicsOk4y4oC6aTDCq///)
**Explanation:**
```
125                          # Push 125
   S                         # Split to a list of digits: [1,2,5]
    5и                       # Repeat it 5 times: [1,2,5,1,2,5,1,2,5,1,2,5,1,2,5]
      ε                      # Map each to:
       N3÷                   #  Integer-divide the map-index by 3
          °                  #  Take it to the power 10
           *                 #  Multiply the current map number with it
            т/               #  Divide it by 100
              '.',:          #  Replace all "." with ","
                   N2›i      #  And if the map-index is larger than 2:
                       0«    #   Append a "0"
```
`125S5и` could be `•}•15∍` (push compressed `125`; enlarge it to size 15: `125125125125125`) and `'.',:` could be `„.,`:` (push string ".,", pop and push the characters as separated items to the stack) for the same byte-count: [Try it online.](https://tio.run/##yy9OTMpM/f//UcOiWiA2NH3U0Xtuq5/x4e2HNmhdbNJ/1DBPTyfBys/oUcOuTINDq///BwA)  
Also, `N3÷°*т/` can be shortened to `N3÷Í°*` (where `Í` subtracts 2), but unfortunately we need the `/` so all the numbers becomes decimals, whereas with `N3÷Í°*` most numbers will remain integers.
[Answer]
# T-SQL, 104 bytes
```
SELECT FORMAT(p*n,'0\,00')
FROM(VALUES(1),(2),(5))a(n),(VALUES(1),(10),(100),(1E3),(1E4))b(p)
ORDER BY p,n
```
Line breaks are for readability only.
Annoyingly longer than the trivial `PRINT` version (90 bytes):
```
PRINT'0,01 0,02 0,05 0,10 0,20 0,50 1,00 2,00 5,00 10,00 20,00 50,00 100,00 200,00 500,00'
```
[Answer]
# [Bubblegum](https://esolangs.org/wiki/Bubblegum), 41 bytes
```
00000000: 1dc5 8105 0040 1402 d055 1ae0 50d1 feab  [[email protected]](/cdn-cgi/l/email-protection)...
00000010: dd2f 788f 8fc2 e192 433c 5c42 e891 7049  ./x.....C<\B..pI
00000020: 11ab 67a6 b8bc 90f5 01                   ..g......
```
[Try it online!](https://tio.run/##Zc49DsIwDAXgnVO8Exg7TdoEMSCY2FjYWJq/LiCxVOL2wS3deJJlefn84hzjs0zzqzXecoDk5OCFHZgtQywbZHYOMhaG4yyoZYwALTnp3IluunY/QdTI2VQM3lf4mgyKBAPbdQkuWT19EAxsgxr7z8pcjo8z0fu6GWbpIfqkH8Ye0ceEwFUbCf5DNK0GtfYF "Bubblegum – Try It Online")
[Answer]
# [Retina](https://github.com/m-ender/retina), 58 bytes
```
¶0¶00¶000¶0000¶
.*¶
1$&2$&5$&
^
¶
+`¶(.?.?¶)
¶0$1
..¶
,$&
```
[Try it online!](https://tio.run/##K0otycxL/P@f69A2AyACYwgBJLn0tICEoYqakYqaqYoaVxxQFZd2wqFtGnr2evaHtmmCdKkYcunpAcV1VNT@/wcA "Retina – Try It Online")
[Answer]
# [Ruby](https://www.ruby-lang.org/), ~~66~~ 62 bytes
```
-2.upto 2{|m|[1,2,5].map{|v|$><<('%.2f '.%v*10**m).tr(?.,?,)}}
```
4 bytes shorter thanks to [Lynn](https://codegolf.stackexchange.com/users/3852/lynn)!
[Try it online!](https://tio.run/##KypNqvz/X9dIr7SgJF/BqLomtybaUMdIxzRWLzexoLqmrEbFzsZGQ11VzyhNQV1PtUzL0EBLK1dTr6RIw15Px15Hs7b2/38A "Ruby – Try It Online")
[Answer]
# [C# (.NET Core)](https://www.microsoft.com/net/core/platform), 107 bytes
```
Console.Write("0,01{0}2{0}5 0,10 0,20 0,50 1{1}2{1}5{1}1{2}2{2}5{2}10{2}20{2}50{2}"," 0,0",",00 ","0,00 ");
```
[Run it](https://tio.run/##HYoxCwMhDIX/SnC6A1sSwenGzp06dBYrRbgqXGyhSH67jR3e971HEvkU65HGeHMuT7h9uaXXFvfADLFzCy1H@NT8gGvIZVn7pRauezrfj9zSYtAidRSn8YCWUOEmPAJ10gOJ11B32p12J4RzTPgJY43@o8oiggr/XjeRMX4 "C# (.NET Core) – Try It Online")
[Answer]
# JavaScript - 96 bytes
```
x=>{for(o="",b=-2;b<3;b++)for(n of[1,2,5])o+=(n*10**b).toFixed(2).replace(".",",")+" ";return o}
```
And here's a slightly longer (98 characters) functional approach:
```
x=>[].concat.apply([],[.01,.1,1,10,100].map(n=>[n,n*2,n*5])).map(n=>n.toFixed(2).replace(".",","))
```
[Answer]
# [J](http://jsoftware.com/), 36 bytes
```
echo'.,'charsub 0j2":,1 2 5*/~10^i:2
```
[Try it online!](https://tio.run/##y/r/PzU5I19dT0c9OSOxqLg0ScEgy0jJSsdQwUjBVEu/ztAgLtPK6P9/AA)
[Answer]
# [Tcl](http://tcl.tk/), 80 bytes
```
lmap d {-2 -1 0 1 2} {lmap c {1 2 5} {puts [regsub \\. [format %.2f $c\e$d] ,]}}
```
[Try it online!](https://tio.run/##K0nO@V@cWqKQmlem4ePo566pUFASHxDyPyc3sUAhRaFa10hB11DBQMFQwahWoRosmqxQDeQpmAL5BaUlxQrRRanpxaVJCjExegrRaflFuYklCqp6RmkKKskxqSopsQo6sbW1//8DAA "Tcl – Try It Online")
# [Tcl](http://tcl.tk/), 90 bytes
```
lmap d {.01 .1 1 10 100} {lmap c {1 2 5} {puts [regsub \\. [format %.2f [expr $c*$d]] ,]}}
```
[Try it online!](https://tio.run/##HYlLCoAgGAav8i1qEyEadBp1YT7aFIkPCMSz/0nMbIYp9iK6bhPh0BgXYAIDPuQd7T8WTWDDPjrWkiGTP3M9oBSDDE@6TcHMtgDp35gw2WVyWmPVvRN9 "Tcl – Try It Online")
Still very long, golfing it more later!
]