[Question]
  [
# Aligning Lines!
Given a character and a multiline string, your job is to pad each line of the string so they line up among the given delimiter.
## Examples
**Input:**
```
,
Programming, Puzzles
And, Code golf
```
**Output:**
```
Programming, Puzzles
        And, Code golf
```
# Input
The input will be a multiline string and a character (which you will align among), you may take these in any order / format you wish. The character will appear exactly once per line. Each line of the input may be different in length.
Input can be through function arguments or STDIN.
# Output
The output should be the same string centered. You are allowed one trailing newline and no trailing whitespace.
The output should be padded with the *minimum* amount of spaces. You may not remove any leading whitespace in the input (if it exists).
Output can be from function return or STDOUT.
  
[Answer]
# APL (37)
APL just isn't very good at string processing (or I'm not good at golfing, of course).
```
{⌽∊R,¨' '/⍨¨(⌈/-+)⍺⍳⍨¨⌽¨R←S⊂⍨S=⊃S←⌽⍵}
```
This takes the character as its left argument, and the multiline string as its right argument. It is assumed that the multiline string ends in a linefeed (e.g. `A\nB\nC\n` rather than `A\nB\nC`.) Since I can use "any format [I] wish", and this is also the conventional format for text files, I think this is reasonable.
Explanation:
* `S←⌽⍵`: reverse the string, and store it in `S`.
* `R←S⊂⍨S=⊃S`: split `S` on its first character, and store the array of strings in `R`.
* `⍺⍳¨⌽¨R`: reverse each string in `R`, and then find the index of ⍺ (the character) in each string.
* `(⌈/-+)`: subtract each of the indices from the largest index, giving the amount of spaces needed
* `' '/⍨¨`: for each of those values, generate that many spaces
* `R,¨`: add the spaces to each string in `R`.
* `∊`: join all the strings together
* `⌽`: reverse it (to get the original order back)
Example:
```
      NL←⎕UCS 10 ⍝ newline
      test←'Programming, Puzzles',NL,'And, Code golf',NL
      test ⍝ test string
Programming, Puzzles                
And, Code golf                      
      ⍝ run the function
      +X←','{⌽∊R,¨' '/⍨¨(⌈/-+)⍺⍳⍨¨⌽¨R←S⊂⍨S=⊃S←⌽⍵}test
Programming, Puzzles                        
        And, Code golf                      
      ⍴X ⍝ result is really a string with newlines, not a matrix
44
```
[Answer]
# CJam, ~~23~~ ~~22~~ 20 bytes
*Thanks to Dennis for saving 2 bytes.*
```
ea_rf#_:e>\fm.{S*\N}
```
This reads the lines from command-line arguments and the character from STDIN.
The online interpreter doesn't support command-line arguments, but you can [test an equivalent version here.](http://cjam.aditsu.net/#code=lqN%2F_%40f%23_%3Ae%3E%5Cfm.%7BS*%5CN%7D&input=%2C%0AProgramming%2C%20Puzzles%0AAnd%2C%20Code%20golf)
## Explanation
```
ea    e# Get the lines from ARGV.
_rf#  e# Duplicate input, read the character and find index of character in each line.
_:e>  e# Duplicate indices and find maximum.
\fm   e# Subtract each index from the maximum index.
.{    e# Apply this block to each pair of line and (max_index - index).
  S*  e#   Get a string with the right amount of spaces.
  \N  e#   Swap spaces with line and push a line feed.
}
```
[Answer]
# [Pip](http://github.com/dloscutoff/pip), ~~22~~ ~~20~~ 18 + 1 = 19 bytes
```
Y_@?qMgsX(MXy)-y.g
```
Takes strings as command-line arguments and delimiter from STDIN (*idea borrowed from Martin's CJam answer*). Uses `-n` flag to print output values on separate lines.
```
                    g is list of cmdline args; s is space (implicit)
    q               Read the delimiter from stdin
 _@?                Construct a lambda function that takes a string and returns
                       the index of the delimiter in it
     Mg             Map that function to each remaining item in g
Y                   Yank the resulting list of indices into the variable y
         (MXy)-y    Take the max of y minus each element in y
       sX           Space, repeated that many times...
                .g  ... concatenated to each item in g
                    Print, newline-separated (implicit, -n flag)
```
And an example run:
```
C:\Users\dlosc> pip.py -ne Y_@?qMgsX(MXy)-y.g "Programming, Puzzles" "And, Code golf"
,
Programming, Puzzles
        And, Code golf
```
[Answer]
# JavaScript ES 2015, 113 bytes
```
f=(c,s)=>s.split`
`.map((e,_,a)=>' '.repeat(a.map(j=>j.indexOf(c)).reduce((g,h)=>g>h?g:h)-e.indexOf(c))+e).join`
`
```
Not quite as short as the golfing languages posted so far. Takes input as two function arguments, e.g. `f(',','Programming, Puzzles\nAnd, Code golf')`. The snippet below is ungolfed and includes an easy method to test.
```
f=function(c,s){
  return s
    .split('\n')
    .map(function(e,_,a){
      return ' '.repeat(
        a.map(function(f){
          return f.indexOf(c)
        }).reduce(function(g,h){
          return g>h?g:h
        })-e.indexOf(c)
      )+e
    })
    .join('\n')
}
run=function(){document.getElementById('output').innerHTML=f(document.getElementById('char').value,document.getElementById('string').value)};document.getElementById('run').onclick=run;run()
```
```
<label>Character: <input type="text" id="char" value="," maxlength="1" /></label>
<textarea id="string" rows="4" cols="30" style="display:block">
Programming, Puzzles
And, Code Golf</textarea><button id="run">Run</button><br />
<pre id="output"></pre>
```
[Answer]
# Pyth, ~~27~~ 24 bytes
```
V.z+.[deSmxdz.z<NJxNz>NJ
```
Updated for the [latest Pyth](https://github.com/isaacg1/pyth/commit/d814c9e3de3cba5170a5391dc8b42a810fa29b74).
[Live demo.](https://pyth.herokuapp.com/?code=V.z%2B.%5BdeSmxdz.z%3CNJxNz%3ENJ&input=%2C%0AProgramming%2C+puzzles%0AAnd%2C+code+golf&debug=1)
## 27-byte version
```
jbm+.[eSmxkz.z<dJxdz\ >dJ.z
```
[Live demo.](https://pyth.herokuapp.com/?code=jbm%2B.%5BeSmxkz.z%3CdJxdz%5C+%3EdJ.z&input=%2C%0AProgramming%2C+puzzles%0AAnd%2C+code+golf&debug=1)
[Answer]
# Pyth, 18 bytes
```
V.z+*d-eSxRz.zxNzN
```
[Answer]
# [Dyalog APL](https://dyalog.com/), ~~22~~ ~~20~~ 16 [bytes](http://meta.codegolf.stackexchange.com/a/9429/43319)
-4 thanks to ngn.
APL is actually not so bad at string processing, if allowed to work with arrays. In this challenge, we may chose the most appropriate format, which for APL means a vector of text vectors as left argument, and the delimiter as a scalar right argument. This even handles multiple delimiters per line, and aligns the first one of each line.
```
⊣,¨⍨' '⍴¨⍨⌈.⍳-⍳¨
```
`⊣,¨⍨` prepend each line with
`' '⍴¨⍨` as many spaces as
`⌈.⍳` the rightmost index of the character among the lines
`-` minus
`⍳¨` the index of the character in each line
[Try APL online!](http://tryapl.org/?a=f%u2190%u22A3%2C%u2368%A8%27%20%27/%u2368%A8%28%28%u2308/-%u22A2%29%u2373%A8%29%20%u22C4%20%u2191%27Programming%2C%20Puzzles%27%20%27And%2C%20Code%20golf%27%20f%20%27%2C%27&run) (`↑` added to print output vertically)
**Bonus?** [Works](http://tryapl.org/?a=f%u2190%u22A3%2C%u2368%A8%27%20%27/%u2368%A8%28%28%u2308/-%u22A2%29%u2373%A8%29%20%u22C4%20%u2191%27Programming%2C%20Puzzles%27%20%27Do%2C%20I%2C%20get%2C%20a%2C%20bonus%3F%27%20f%20%27%2C%27&run) for any number of strings, and delimiters (aligns by left-most).
[Answer]
# Julia, 117 bytes
```
f(c,t)=(s=[split(l,c)for l=split(t,"\n")];join(map(i->lpad(i[1],maximum(map(i->length(i[1]),s))," ")*c*i[2],s),"\n"))
```
Ungolfed:
```
function f(c::String, t::String)
    # Create an array of arrays by splitting on newlines and
    # then on the given delimiter
    s = [split(l, c) for l in split(t, "\n")]
    # Find the maximum length on the left side of the delimiter
    m = maximum(map(i -> length(i[1]), s))
    # Rejoin on the delimiter and pad each line with spaces,
    # and rejoin this with newlines
    join(map(i -> lpad(i[1], m, " ") * d * i[2], s), "\n")
end
```
[Answer]
## Python 3, 85 (IDLE 3.2.2, Windows)
```
c,*s=input().split('\n')
for x in s:print(' '*(max(z.find(c)for z in s)-x.find(c))+x)
```
Pretty straightforward. This finds the position of the character in the string twice: once to find the max (well, once per line), and once to find the offset. I tried combining these but it was longer.
Python 3 is used for the input unpacking. MY IDLE seems to take multiline strings as input.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 12 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
Ỵ©w€µạṀ⁶ẋż®Y
```
**[Try it online!](https://tio.run/##y0rNyan8///h7i2HVpY/alpzaOvDXQsf7mx41Ljt4a7uo3sOrYv8//9/QFF@elFibm5mXrqOQkBpVVVOajGXY16KjoJzfkqqQnp@ThpXqo6Ca2ioK1dyYmYRUCI5PzMvI7UIqCMxMQNIcrmk5uVlFisAUUlGqkJSanGJDlhjapFCZh5YrDy/KCflvw4A "Jelly – Try It Online")**
Done and golfed with [caird coinheringaahing](https://codegolf.stackexchange.com/users/66833/caird-coinheringaahing) in [**J**elly **H**yper **T**raining (JHT)](https://chat.stackexchange.com/rooms/57815/jelly-hypertraining), our Jelly practice chat room.
### How it works
The third command line argument (first input) should be the multi-line string, and the character should be the fourth command line argument (second input).
```
Ỵ©w€µạṀ⁶ẋż®Y  ~ Full program.
Ỵ             ~ Split the string by newlines.
 ©            ~ Copy the result to the register.
  w€          ~ Get the index of the first occurrence of the character on each line.
      Ṁ       ~ Take the maximum.
    µạ        ~ And subtract it from each index, taking the absolute value.
       ⁶ẋ     ~ Repeat a space that many times (vectorizes).
         ż®   ~ Interleave with what was stored in the register.
           Y  ~ Join by newlines and print implicitly.
```
I am not sure whether taking input as a list of lines is allowed, so this takes a multiline string as input. If it were allowed:
### 10 bytes
```
w€µạṀ⁶ẋż³Y
```
[Try it online!](https://tio.run/##y0rNyan8/7/8UdOaQ1sf7lr4cGfDo8ZtD3d1H91zaHPk////o5UCivLTixJzczPz0nUUAkqrqnJSi5V0lBzzUnQUnPNTUhXS83PSgAKpOgquoaGuQFZyYmYRUDI5PzMvI7UIqC8xMQNIAmVcUvPyMosVgKgkI1UhKbW4RAesPbVIITMPLFaeX5STohT7XwcA "Jelly – Try It Online")
[Answer]
# Kakoune, 9 bytes
```
s\Q<c-r>"<ret><a-h><a-;>&
```
(`<c-x>` means CTRL+x, `<a-x>` is alt)
[![asciicast](https://asciinema.org/a/OkI9DDXNTVRuVaTU5N6LDX6r3.svg)](https://asciinema.org/a/OkI9DDXNTVRuVaTU5N6LDX6r3)
Expects the delimited in the "-register, the input in the default buffer and the cursor spanning the entire buffer.
Explanation:
```
s        <ret>             Match the contents of the current selection on the following regex, select every part that matches
 \Q                        Quote, everything after this only matches itself literally (avoiding problems with . etc)
   <c-r>"                  Dump the contents of the "-register (containing the char to align on)
              <a-h>        Select to the beginning of the line for each selection
                   <a-;>   "flip" each selection, so that the anchor is at the end.
                        &  Align everything
```
This might be stretching the allowed input format a bit, so here's a solution which takes the input exactly like the challenge example, in the default buffer, with the cursor at (0, 0):
# Kakoune, 13 bytes
```
xd%s\Q<c-r>"<backspace><ret><a-h><a-;>&
```
This is basically the same solution, with a prelude deleting the delimiter and putting it into the "-register. Note that the newline is also put into the register, which the `<backspace>` deletes.
[Answer]
# C# 4.0, ~~329~~ ~~320~~ 307 bytes
```
using System;class P{static void Main(){Func<char,dynamic>f=(d)=>Console.ReadLine().Split(d);var c=f(' ')[0][0];var m=0;var l=new string[9999][];var z=0;for (l[z]=f(c);l[z].Length==2;l[z]=f(c)){m=Math.Max(l[z][0].Length,m);z++;}for(var i=0;i<z;i++){Console.WriteLine("{0,"+m+"}"+c+"{1}",l[i][0],l[i][1]);}}}
```
Ungolfed version :
```
using System;
class P
{
    static void Main()
    {
        // lamba to to read a line and split on a char, returns an array of 
        Func<char,dynamic>f=(d)=>Console.ReadLine().Split(d); 
        // read the separator char by taking the first char of the first string 
        // in the array
        // use our lambda
        var c=f(' ')[0][0];
        var m=0; // max position where char is found
        var l=new string[9999][]; // hold all input
        var z=0; // count valid entries in l
        // loop until the input doesn't contain an
        // array with 2 elements
        // here we use our lambda agian, twice
        for (l[z]= f(c);l[z].Length==2;l[z] = f(c))
        {
            // calculate max, based on length 
            // of first element from the string array
            m=Math.Max(l[z][0].Length,m);
            z++; // increase valid items
        }
        // loop over all valid items
        for(var i=0;i<z;i++)
        {
        // use composite formatting with the padding option
        // use the max to create a format string, when max =4 
        // and seperator char is , this will give
        // "{0,4},{1}"
            Console.WriteLine("{0,"+ m +"}"+c+"{1}",l[i][0],l[i][1]);
        }
    }
}
```
It does accept a maximum of 9999 lines ...
[Answer]
# Common Lisp, 101 bytes
```
(lambda(c l)(dolist(x l)(format t"~,,v@a~%"(-(apply'max(mapcar(lambda(x)#1=(position c x))l))#1#)x)))
```
The first parameter is the character, the second is a list of string to be aligned.
[Try it online!](https://tio.run/##NYtBCsIwEAC/sqRIdyEefICg@AEf4GVN2hLYdEMaJfbQr9d48DYMM07CknbcUTg@PaMDIfTabMH641Fz5ALFbNa@L7wdDB6RU5JPH7li5OQ4/@9K3emMSZdQgs7goBIJNdlRI9q7h4UezT3rlDnGME8W7q91lWExYK6zt3BTP8CkMprWfwE)
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), ~~10~~ 9 (or 5?) [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
U|XδkZαú»
```
[Try it online.](https://tio.run/##yy9OTMpM/f8/tCbi3JbsqHMbD@86tPv/fx2ugKL89KLE3NzMvHQdhYDSqqqc1GIux7wUHQXn/JRUBff8nDQuIAss7ZyRmJOTmpcOVKGGJA8A)
If the I/O of the multi-line string could be a list of lines, this would be **5 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)** instead:
```
δkZαú
```
[Try it online.](https://tio.run/##yy9OTMpM/f//3JbsqHMbD@/6/1@HK1opoCg/vSgxNzczL11HIaC0qiontVhJR8kxL0VHwTk/JVXBPT8nDSgAZIOVOGck5uSk5qWDVakhq4kFAA)
**Explanation:**
```
U          # Store the first input-character in variable `X`
 |         # Take the other input-lines as a list of strings
   δ       # For each string:
  X k      #  Get the 0-based index of character `X` in this string
     Z     # Push the maximum index (without popping the list itself)
      α    # Take the absolute difference of this maximum with the integer-list
       ú   # Pad each string of the (implicit) input-list (because we've used `|`) with
           # that many leading spaces
        »  # And join the list by newlines
           # (after which it is output implicitly as result)
δ          # For each string in the second (implicit) input-list
 k         #  Get the 0-based index of the first (implicit) input-character
  Zαú      # Same as above
           # (after which the list of strings it output implicitly as result)
```
[Answer]
## Matlab / Octave, 106 bytes
Function that uses three separate arguments for character, string, string; and gives result in stdout:
```
function f(c,s,t)
p=find(s==c)-find(t==c);disp([repmat(32,1,max(-p,0)) s]),disp([repmat(32,1,max(p,0)) t])
```
Example in Matlab:
```
>> f(',', 'Programming, Puzzles', 'And, Code golf')
Programming, Puzzles
        And, Code golf
```
Or [try it online](http://ideone.com/oaR4ow) with Octave interpreter.
[Answer]
# Julia, 80 bytes
```
f(c,s)=(t=split(s,'
');u=[search(i,c)for i=t];join([" "].^(maxabs(u)-u).*t,'
'))
```
Ungolfed:
```
function f(c,s)
  # converts multiline string to array of single-line strings
  t=split(s,'\n')
  # creates array of positions of delimiter
  u=[search(i,c)for i=t]
  # Appends appropriate number of spaces to each line
  # (uses elementwise operations to achieve this result)
  v=[" "].^(maxabs(u)-u).*t
  # Recombines array of strings to multiline string and returns
  return join(v,'\n')
end
```
[Answer]
# JavaScript (ES6), 105
Using template strings, the 2 newlines are significant and counted.
Test running the snippet in any EcmaScript 6 compatible browser (that is FireFox. Chrome does not support default parameters)
```
f=(s,c,p=(s=s.split`
`).map(r=>m<(v=r.indexOf(c))?m=v:v,m=0))=>s.map((r,i)=>' '.repeat(m-p[i])+r).join`
`
// Ungolfed
f=(s,c)=>{
  s=s.split('\n')
  p=s.map(r=>r.indexOf(c))
  m=Math.max(...p)
  s=s.map((r,i)=>' '.repeat(m-p[i])+r)
  return s.join('\n')
}  
// TEST
out=x=>O.innerHTML+=x+'\n'
out(f(`Programming, Puzzles
And, Code golf`,','))
```
```
<pre id=O></pre>
```
[Answer]
# Python 2, 93 bytes
```
def f(x,y,z):
 p=y.index(x)-z.index(x)
 if p<0:y=" "*abs(p)+y
 else:z=" "*p+z
 print y+'\n'+z
```
Called like so:
```
f(',','Programming, Puzzles','And, Code Golf')
```
[Answer]
# Ruby, 74 bytes
```
l=lambda{|d,s|s.each{|e|puts ' '*(s.map{|f|f.index(d)}.max-e.index(d))+e}}
```
and call it like
```
l.call ',',['Programming, Puzzles','And, Code golf']
```
[Answer]
## R, 68 bytes
```
function(c,x,y,r=regexpr)cat(x,"\n",rep(" ",r(c,x)-r(c,y)),y,sep="")
```
Unnamed function that takes `3` inputs; `c` which is the character to align, `x` is the first string and `y` the second string.
In R, the function `regexpr` returns the position of a given pattern in a string. The solution works by applying `regexpr` on both strings and repeating white spaces amounting to the difference and subsequently just print both inputs separated by a newline.
[Answer]
# [Japt](https://github.com/ETHproductions/japt) [`-R`](https://codegolf.meta.stackexchange.com/a/14339/), 13 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
```
·mqV Õvù ÕmqV
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&flags=LVI&code=t21xViDVdvkg1W1xVg&input=IlByb2dyYW1taW5nLCBQdXp6bGVzCkFuZCwgQ29kZSBnb2xmIgoiLCI)
```
·mqV Õvù ÕmqV     :Implicit input of string U & delimiter V
·                 :Split U on newlines
 m                :Map
  qV              :  Split on V
     Õ            :Transpose
      v           :Modify first element
       ù          :  Left pad with spaces to the length of the longest
         Õ        :Transpose
          m       :Map
           qV     :  Join with V
                  :Implicit output joined with newlines
```
[Answer]
# C#, 191
As a function. Roughly a porting of my JS answer.
```
using System.Linq;string f(string s,char c){var q=s.Split('\n');int m=0,v;Array.ForEach(q,x=>m=m<(v=x.IndexOf(c))?v:m);return String.Join("\n",q.Select(x=>new String(' ',m-x.IndexOf(c))+x));}
```
[Answer]
# Python 2, ~~67~~ 66 bytes
```
def a(d,l):
 i=l[0].index(d)
 for e in l:print' '*(i-e.index(d))+e
```
Called with:
```
a(',', ['Programming, Puzzles', 'And, Code golf'])
```
[Answer]
## Moonscript, 138 bytes
```
(n)=>
 i=0
 @='
'..@
 l=[b-a for a,b in @gmatch "
().-()"..n]
 m=math.max unpack l
 (@gsub '
',(a)->
  i=i+1
  a..(' ')\rep m-l[i])\sub(2)
```
This returns a function which takes 2 arguments. The first is the string, the second is the character to align on. These arguments are the implicit argument @, and n.
First, I append a new line to the string, to make processing easier.
```
@='
'..@
```
Now, I generate a list of the positions of every alignment character, using `gmatch`.
Next, I replace the newline before every line with the correct number of spaces, then trim the newline I added at the beginning.
[Answer]
# Lua, 169 bytes
```
function a(d,t)m={}for k,v in pairs(t)do m[#m+1]=string.find(v,d)end o=math.max(unpack(m))for k,v in pairs(t)do print(string.rep(" ",o-(string.find(v,d)or 0))..v)end end
```
Not as short as other answers but this is my first one :D
[Answer]
# [Retina](https://github.com/m-ender/retina), 71 bytes
```
+`^((.)(.*¶)*)((.)*\2.*¶)((?<-5>.)*(?(5)\2|(.)\2).*)
$1$#7$* $4$#5$* $6
```
[Try it online!](https://tio.run/##K0otycxL/P9fOyFOQ0NPU0NP69A2TS1NEFsrxgjM09Cwt9E1tQMKaNhrmGrGGNUAJWOMNPW0NLlUDFWUzVW0FFRMVJRNQbTZ//86XAFF@elFibm5mXnpOgoBpVVVOanFXI55KToKzvkpqQrp@TlpAA "Retina – Try It Online") Note: This leaves the alignment character in the output; it can be deleted at a cost of 4 bytes. If only two strings need to be aligned, then for 52 bytes:
```
^(.)¶((.)*\1.*¶)((?<-3>.)*(.)*\1.*)
$#5$* $2$#3$* $4
```
Explanation:
```
^(.)¶
```
This matches the alignment character.
```
((.)*\1.*¶)
```
This matches the first line and also keeps track of how many characters there were before the alignment character. (.NET keeps a match stack for each variable, in this case, `$3`.)
```
((?<-3>.)*(.)*\1.*)
```
This matches the second line, trying to account for as many characters as we found on the first line. `?<-3>` causes the match to pop the stack for each character, until it is empty, at which point the match fails, and the `(.)*` then matches the remaining characters before the alignment character. At this point we have the following variables:
* `$1` contains the alignment character
* `$2` contains the first line
* `$3` contains a stack whose length is the first line prefix minus the second line prefix
* `$4` contains the second line
* `$5` contains a stack whose length is the second line prefix minus the first line prefix
`$#5$*` then prefixes the necessary number of spaces to make the first line align with the second, and vice versa for `$#3$*`.
Similar logic applies to the main answer, except here we have to find two lines which don't align so that we can align them (this is where the `?(5)` comes in) and then repeat the alignment over all the lines until they are all equally aligned.
[Answer]
# [Perl 5](https://www.perl.org/) `-MList::Util=max`, ~~69~~ 64 bytes
```
$l=max map{/$d/xg;pos}($d,@a)=<>;say map{/$d/x;$"x($l-pos).$_}@a
```
[Try it online!](https://tio.run/##RY6xDoIwFEV3vqIxHSBpAQcWEMW4asKgs2lSaJq88hpaE8Tw61Z0cbrJOWe4thuhCIFCbcREjLCvjMpsUpVFt8RUskYk9W5fOfH824puppgCX5skpfelESGw6DhIRk4oO6IQ@qgdUY3CGD0oRtrHPEPnoisiAfwSj3h4o/UaBxf4pUjzbb7uWTtfljevf4cChw8 "Perl 5 – Try It Online")
]