[Question]
  [
After inputting a string [length 1-20], only containing the chars **y** for yes and **n** for no,
your program should output the result (y or n). Example input: `yynynynny` would output y.
The result is determined by combining the y's and n's in the following way:
* **y**es and **n**o equals **n**o
* **y**es and **y**es equals **y**es
* **n**o and **n**o equals **y**es
If the string contains more than 2 characters (likely...), the calculation would look the same. Examples:
* **y**es and **y**es and **n**o equals **n**o (because the no merges with the first yes to no. then there are no and yes left and the same thing happens again)
* **n**o and **n**o and **n**o equals **n**o (the first two no's merge to yes, then there are yes and no left, which emerge to no)
Example input with output:
* `yynynynynyyn` = n
Tip: have in mind that the order of the chars your program works off doesn't care. (for example you can read the input from back, or from behind, mix the letters, sort it, whatever. What counts is the correct ouptput) have fun!
Winning criteria:
this is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so shortest code in byte wins.
  
[Answer]
# [Octave](https://www.gnu.org/software/octave/), ~~29~~ 27 bytes
*Thanks to [@RickHithcock](https://codegolf.stackexchange.com/users/42260/rick-hitchcock) for pointing out a mistake, now corrected. Also, 2 bytes off thanks to [@StewieGriffin!](https://codegolf.stackexchange.com/users/31516/stewie-griffin)*
```
@(s)'yn'(mod(sum(s+1),2)+1)
```
[**Try it online!**](https://tio.run/##y08uSSxL/Z9mq6en999Bo1hTvTJPXSM3P0WjuDRXo1jbUFPHSBNI/k/TUK@szINCoBrN/wA)
### Explanation
The ASCII code point of `'y'` is odd, and that of `'n'` is even. The code
1. adds `1` to each char in the input string to make `'y'` even and `'n'` odd;
2. computes the sum;
3. reduces the result to `1` if even, `2` if odd;
4. indexes (1-based) into the string `'yn'`.
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 6 bytes
```
§yn№Ｓn
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z@gKDOvRMOxxDMvJbVCQ6kyT0lHwTm/FCjmmVdQWhJcApRP19DUUVDKU9LU1LT@/7@yMg8E8yr/65blAAA "Charcoal – Try It Online") Link is to verbose version of code. Explanation:
```
    Ｓ   Input string
   № n  Count number of `n`s
§yn     Circularly index into string `yn`
        Implicitly print appropriate character
```
[Answer]
# JavaScript (ES6), 28 bytes
Takes input as a string.
```
s=>'ny'[s.split`n`.length&1]
```
[Try it online!](https://tio.run/##y0osSyxOLsosKNHNy09J/Z9m@7/Y1k49r1I9ulivuCAnsyQhL0EvJzUvvSRDzTD2f3J@XnF@TqpeTn66RpqGep66pqaCvr5CHheaRCVUohJDArcWnHry8nCaVpkHAjAj/wMA "JavaScript (Node.js) – Try It Online")
---
# JavaScript (ES6), 30 bytes
Takes input as an array of characters.
```
y=>'yn'[n=1,~~eval(y.join`^`)]
```
[Try it online!](https://tio.run/##y0osSyxOLsosKNHNy09J/Z9m@7/S1k69Mk89Os/WUKeuLrUsMUejUi8rPzMvIS5BM/Z/cn5ecX5Oql5OfrpGmka0np6eep56rKamgr6@Qh4XFtlKmGwlVlkCmvHrzsvDb3hlHhQiWfMfAA "JavaScript (Node.js) – Try It Online")
[Answer]
# [Haskell](https://www.haskell.org/), ~~33~~ 28 bytes
```
f a=cycle"yn"!!sum[1|'n'<-a]
```
Indexes the count of n's into the infinite list "ynynynyn…".
Previous approach (33 bytes) was folding pairs of different elements to n, otherwise y:
```
f=foldl1(\a b->last$'y':['n'|a/=b])
```
[Try it online!](https://tio.run/##y0gszk7Nyfn/P00h0Ta5MjknVakyT0lRsbg0N9qwRj1P3UY3MfZ/bmJmnoKtQkFRZl6JgopCmoJSZWUeFAKV//@XnJaTmF78Xze5oAAA "Haskell – Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 7 bytes
```
ċ”nị⁾ny
```
[Try it online!](https://tio.run/##y0rNyan8//9I96OGuXkPd3c/atyXB@T/V8/LUwcA "Jelly – Try It Online")
**ċ**ount number of **”n**, **ị**ndex into the string **⁾ny**. (with modulo 2)
---
```
ċḢịɗ⁾ny
```
[Try it online!](https://tio.run/##y0rNyan8//9I98Mdix7u7j45/VHjvjygwH/1vDx1AA "Jelly – Try It Online")
{**ċ**ount number of, take the **Ḣ**ead, then **ị**ndex into} string **⁾ny**.
---
```
OCSị⁾ny
```
[Try it online!](https://tio.run/##y0rNyan8/9/fOfjh7u5HjfvygJz/6nl56gA "Jelly – Try It Online")
Similar to the Octave answer above. Calculate **O**rd value, take the **C**omplement (for each ord value *x* calculate *1-x*), **S**um, then **ị**ndex into string **⁾ny**.
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), 15 bytes
```
'ny'[1+=/'y'=⍞]
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///qKM9Ii@/6L96XqV6tKG2rb56pbrto955sSCZ/wpgAFLAVVmZB4WVeQA "APL (Dyalog Unicode) – Try It Online")
Note: TIO defaults to `⎕IO = 1`. If run with `⎕IO←0`,
# [APL (Dyalog Unicode)](https://www.dyalog.com/), 13 bytes
```
'ny'[=/'y'=⍞]
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///qKM9Ii@/6L96XqV6tK2@eqW67aPeebEg8f@P@qZ6@j9qm2DApQAGIIVclZV5UFiZBwA "APL (Dyalog Unicode) – Try It Online")
This is the XNOR function (sometimes called EQV, especially in old BASICs.
### Decomposition/Analysis:
```
             ⍞  - Accept string input  
         'y'=   - Compare it to the letter `y`. This "converts" the input 
                  string into a vector of 1s and 0s where the 1s correspond 
                  to 'y' and the 0s to 'n'.  
       =/       - XNOR/EQV/equality reduction - converts the vector into a 
                  single boolean value by evaluating e.g., 1 xnor 0 xnor 0 
                  xnor 1 ...  
     1+         - adds one for subscripting in ⎕IO = 1 environment. In 
                  ⎕IO = 0, should be omitted (save 2 bytes)  
    [         ] - subscript indicator - the expression, which should be 
                  either a 1 or 2 (0 or 1 in `⎕IO = 0`), is now going to be 
                  interpreted as a subscript of...  
'ny'            - The string of possible results - a 0/1 is 'n', a 1/2 is 'y'
```
[Answer]
# [Python 2](https://docs.python.org/2/), 29 bytes
```
lambda s:'yn'[s.count('n')%2]
```
[Try it online!](https://tio.run/##K6gsycjPM/qfZhvzPycxNyklUaHYSr0yTz26WC85vzSvREM9T11T1Sj2f0FRJpCXpqFUWZkHhZV5Spqa/wE "Python 2 – Try It Online")
[Answer]
# Pyth, 9 bytes
```
@"yn"l@\n
```
[Try it here](http://pyth.herokuapp.com/?code=%40%22yn%22l%40%5Cn&input=%22yynynynynyyn%22&debug=0)
### Explanation
```
@"yn"l@\n
     l@\nQ   Get the length of the intersection of the (implicit) input and "n".
@"yn"        Modular index into "yn".
```
[Answer]
# [dc](https://www.gnu.org/software/bc/manual/dc-1.05/html_mono/dc.html), 39
```
?dsiZdsl[[]r1-d0<m]dsmxklixzll-2%B*C1+P
```
Input string is read from STDIN and should be in the form `[yynynynynyyn]`.
dc is not known for its string handling, but we have just enough here to get this to work. The approach here is to count the `n`s, and output `y` if even or `n` if odd. This is done by executing the input string as a macro. `dc` will output `'y' (0171) unimplemented` errors for all the `y`s and attempt to pop strings and print them for all the `n`s. So first we make sure we have plenty (total input string length) of empty strings `[]` on the stack to pop. Then we execute the input string and see how many `[]` are left on the stack. The original string length is subtracted from this to give the (-ve) total number of `n`s. The rest is arithmetic to do mod 2 and have the output come out right as ASCII `y` or `n`.
```
?dsi                                    # Read input string, duplicate, store in register i
    Zdsl                                # Get input length, duplicate, store in register l
        [         ]                     # define macro to:
         []                             #   push empty string
           r                            #   swap empty string and remaining length 
            1-                          #   subtract 1 from length
              d0                        #   duplicate and compare with 0
                <m                      #   if >0 recursively call this macro again
                   dsmx                 # duplicate macro, store in register m and execute
                       k                # discard left-over 0
                        lix             # load input string and execute as macro
                           z            # get stack length
                            ll-         # load string length and subract
                               2%       # mod 2 (result is -ve because difference is -ve)
                                 B*     # multiply by 11 ('y' - 'n')
                                   C1+  # add 121 ('y')
                                      P # print result as ASCII char
```
[Try it online!](https://tio.run/##S0n@/98@pTgzKqU4Jzo6tshQN8XAJjc2pTi3Ijsns6IqJ0fXSNVJy9lQO@D//@jKyjworMyLBQA "dc – Try It Online")
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 8 bytes
```
"yn"gUèn
```
[Try it online!](https://tio.run/##y0osKPn/X6kyTyk99PCKPBCzMg8KgYIA "Japt – Try It Online")
## Explanation:
```
"yn"gUèn
"yn"       String literal - "yn"
    g      Return the char at index:   
      è      Number of matches where:
       n       "n" is found in
     U         Input
```
Japt uses index-wrapping, so if `Uèn` returns `2`, it will return `y` when getting the char from `"yn"`.
[Answer]
# [Perl 6](https://perl6.org), 21 bytes
```
{<y n>[.comb('n')%2]}
```
[Try it](https://tio.run/##RYzBCoMwEETv@xVzsMaAeOjBi5ofKSXUmEJBVzFYCOK3p4mllIHl7TAzi13HOmzO4l1XpiGaPHIzDxZd2FsPVrfKzFNfCBbycr0fwW09hpdbxodHgUxDYifAxTfTJQQ6BVEibRSZlnQQVfmv8JxXtDHtPSexT8ynEQ9/iU/kfywqmqqh8AE "Perl 6 – Try It Online")
## Expanded:
```
{  # bare block lambda with implicit parameter $_
  # index into the list ('y', 'n')
  <y n>[
    .comb('n') # get every instance of 'n' (implicit method call on $_)
    % 2        # turn it into a count and get the modulus
  ]
}
```
[Answer]
# Java 8, 35 bytes
A decider for a regular language! I can do that.
```
s->s.matches("y*(ny*ny*)*")?'y':'n'
```
[Try It Online](https://tio.run/##XVDBboMwDD3DV1iRKgii@YB26w6Vdtupx2kHj4Y2LBhEQqto6rezpMBaETlKnv1sP7vCC66bVlJ1/Bna/lurAgqNxsAHKoLfOJqcxqL1T6kINVQ@S/RWaVH2VFjVkHifPi8H2yk65bA/Y4eFld0OkMxVdvA6mPXOiBptcZYmZS5LyWXeeMb4W@KSTULJEG3jZdNLo45Qez3pWPzzC7A7GR7kRWXTweQH3KORsAGSV/inBlLEaDyO5XfowiE3w0WIwn0OPeMQfrApoDlzYj4qEbllS@bBbZQeHZyxshZNb0Xr1Vo9Tyj8VH5PKVsZP86qYPk4Wz7tUmDbapfefZzzbagZe7sNfw)
[Answer]
# [J](http://jsoftware.com/), ~~10~~ 9 bytes
```
{&'ny'@=/
```
[Try it online!](https://tio.run/##y/r/P81WT6FaTT2vUt3BVv9/anJGvkKagnqeOheMWYlg5lUic/KQOJUovDyQwv8A)
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~8~~ 7 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
O‘Sị⁾ny
```
**[Try it online!](https://tio.run/##y0rNyan8/9//UcOM4Ie7ux817ssDcv9XVuaBYF4lAA "Jelly – Try It Online")**
[Answer]
# [R](https://www.r-project.org/), ~~46~~ 44 bytes
```
"if"(sum(1+utf8ToInt(scan(,"")))%%2,"n","y")
```
[Try it online!](https://tio.run/##K/r/XykzTUmjuDRXw1C7tCTNIiTfM69Eozg5MU9DR0lJU1NTVdVIRylPSUepUknzf15eJRDkVeb9BwA "R – Try It Online")
Down 2 bytes thanks to Giuseppe and ngm. Port of the Octave answer by Luis Mendo.
[Answer]
# Japt, 9 bytes
Oliver beat me to the shortest solution so here are a couple that are just a byte longer.
```
B*aUèÍu¹d
```
[Try it](https://ethproductions.github.io/japt/?v=1.4.5&code=QiphVejNdblk&input=Inl5bnlueW55bnl5biI=)
```
#ndB*UèÍv
```
[Try it](https://ethproductions.github.io/japt/?v=1.4.5&code=I25kQipV6M12&input=Inl5bnlueW55bnl5biI=)
---
## Explanations
```
              :Implicit input of string U
B             :11
 *            :Mutiplied by
  a           :  The absolute difference of 11 and
   UèÍ        :    The count of "n" in U
      u       :    Mod 2
       ¹d     :Get the character at that codepoint
```
```
              :Implicit input of string U
#n            :110
   B*         :Add 11 multiplied by
        v     :  The parity of
     UèÍ      :    The count of "n" in U
  d           :Get the character at that codepoint
```
[Answer]
# [Perl 5](https://www.perl.org/), ~~19~~ 18 bytes
```
s/y|ny*n//g;s;^$;y
```
[Try it online!](https://tio.run/##K0gtyjH9/79Yv7Imr1IrT18/3brYOk7FuvL//8rKvLy8Si4QmVeZB@T9yy8oyczPK/6vWwAA "Perl 5 – Try It Online")
Similar to the [Retina solution](https://codegolf.stackexchange.com/a/165222/78123).
[Answer]
# [///](https://esolangs.org/wiki////), 24 bytes
```
/ny/n//nn/y//yy/y//yn/n/<input>
```
[Try it online!](https://tio.run/##K85JLM5ILf7/Xz@vUj9PXz8vT79SX7@yEkzmAUX@/wcA "/// – Try It Online")
I believe this is the shortest possible /// program, as making a one character substitution either is useless (if you insert something in its place) or prevents it from being an output (if you insert nothing). However, since the program must deal with the two character cases, this should be minimal. 
First removes all `y`s right of an `n`. Then replaces double `n`s with `y`s, taking advantage of LTR substitution. At this stage there are many `y`s followed by at most one `n`; we deduplicate the `y`s and if there is an `n` use it to mop the last `y` up. 
[Answer]
# [MATL](https://github.com/lmendo/MATL), 8 bytes
```
Qs'ny'w)
```
[Try it online!](https://tio.run/##y00syfn/P7BYPa9SvVzz/38gnQdG6gA "MATL – Try It Online")
Saved 2 bytes thanks to Luis Mendo! I previously used the explicit modulus command to get the index into the range `1,2`.
### Explanation
This uses the fact that MATL have modular indexing, which means that the 1st, 3rd, 5th ... element of the string `ny` are the same (`n`). So are the 2nd, 4th, 6th ... element of the string (`y`).
```
Q          % Grab input implicitly, and increment each ASCII-value by 1
           % This makes 'n' odd, and 'y' even
 s         % Take the sum of all elements
  'ny'     % Push the string `ny`
      w    % Swap the stack to facilitate the indexing
       )   % Take the n'th element of 'yn' and output it.
```
[Answer]
# [Python 2](https://docs.python.org/2/), 26 bytes
```
lambda s:'yn'[int(s,35)%2]
```
[Try it online!](https://tio.run/##K6gsycjPM/qfZhvzPycxNyklUaHYSr0yTz06M69Eo1jH2FRT1Sj2f0ERkKuQpgGS0VSwtVVQz1PnQghWQgUrkQTz8rAIVmLVn5eH3dQ8EMyrxG4OFCIZ@B8A "Python 2 – Try It Online")
[Answer]
# [Retina](https://github.com/m-ender/retina/wiki/The-Language), 11 bytes
```
y
nn
^$
y
```
[Try it online!](https://tio.run/##K0otycxLNPz/v5KLKy@PiytOhasSyKnMg8LKPAA "Retina – Try It Online")
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 8 bytes
```
'n¢„ynsè
```
[Try it online!](https://tio.run/##MzBNTDJM/f9fPe/QokcN8yrzig@v@P@/sjIPCivzAA "05AB1E – Try It Online")
[Answer]
# [Java (OpenJDK 8)](http://openjdk.java.net/), 143 bytes
```
a->{char[] u=a.toCharArray();if(u.length==1)return u[0];else{char b=(u[0]==u[1])?'y':'n',i=2;for(;i<u.length;b=(b==u[i++])?'y':'n');return b;}}
```
[Try it online!](https://tio.run/##jY@xbsIwEIZ3nuLEEluUqHSscauqc5WBMcpwCQ6YhkvknJGsKM@empKqI@imO3367/9OeMF12xk67b@nqsG@hy@0NCwALLFxNVYGsqE6ogMnduwsHQClGiPQM7KtIIPMc@cZNEy4fvtl8wK8xpTbz7h8OIdBSGVr4dPG0IGPWm@kM@wdgc@fC2Wa3tyelFpcL1r7fFPI9yQkrwklT1a/qLp1QtntX4aKaHnl7Gr1T0o155ZqHCcVa3a@bGLNue2ltXs4R8VZJi9QDotd6Nmc09Zz2sUrNyRuUqkTyxCIwlJKdRebJ9Aj9H3mkZgbE1V/AA "Java (OpenJDK 8) – Try It Online")
And if we take the input as a list:
# [Java (OpenJDK 8)](http://openjdk.java.net/), 118 bytes
```
u->{if(u.length==1)return u[0];else{char b=(u[0]==u[1])?'y':'n',i=2;for(;i<u.length;b=(b==u[i++])?'y':'n');return b;}}
```
[Try it online!](https://tio.run/##lZAxa8MwEIX3/IojiyXSmKZjVTWEzsVDRuNBduREqXMy8ikgjH@7KxOXLoVibjg43nv33V3VXW1tq/F6@hqrRnUdfCqD/QrAIGlXq0pD1lcX5cCxqeUFeC6GKOhIkakgg8xT6wkkjH773pua@bTReKaLlDvuNHmH4PPnQuim04@sUrJpIqXPdwXfJyF5TTB5MvJF1NYxYd5@MkSUlpPObDa/Si7m3FIMwygiTevLJtLMUHdrTnCLl7AjOYPnvFC8Xx1DR/qWWk9pG6fUIHuwp46tQ0AM65TsRwQ8OKcC45yLf01zBVzuXepYvuIvR3zYNw "Java (OpenJDK 8) – Try It Online")
### Explanation:
(input as string)
```
char[] u=a.toCharArray();  //turn string into char array
if(u.length==1){    
    return u[0];      //if single letter, return it
}else{
    char b=(u[0]==u[1])?'y':'n';     //first two XNOR
    for(char i=2;i<u.length;b=(b==u[i++])?'y':'n');   //XNOR each remaining character
return b;    //return final result
}
```
[Answer]
# [Ruby](https://www.ruby-lang.org/), 24 bytes
```
->s{"yn"[s.count(?n)%2]}
```
[Try it online!](https://tio.run/##VY/BCoMwDIbvPkUIFBQ6DzsO6h6k9OC0MkGi2BZW5p69yzadSCDhz/cnIXO4xdSpdKrcEyOhdmUzBvL5lQpxNq@kQWNECZyMzIAVfRRtKjLcGW@QO6N4UHRwRlpjm8lMaevmDu0IS09T8BLsY7KNt@3CI7N1YfCgoNNfarjHxQHmwhUgHKiKM4IAvXnVfwNcAafaMb4AdnU/8BPrkZ/ZZJba9AY "Ruby – Try It Online")
A lambda taking a string and returning a string.
[Answer]
# [Chip](https://github.com/Phlarx/chip) `-z`, 24 bytes
```
B}Zvv~vedSD~t
 `'bc af*g
```
[Try it online!](https://tio.run/##S87ILPj/36k2qqysriw1JdilroRLIUE9KVkhMU0r/f//yso8KKzM@69bBQA "Chip – Try It Online")
### Explanation
This prints `'h'`, which is `'n' & 'y'`:
```
        d    
       f*g
```
This converts the `'h'` to either an `'n'` or a `'y'`, according to whether the top-left wire is powered:
```
   vv~ve     
   bc a   
```
This is the xor counter, it powers the part described above as necessary:
```
B}Z          
 `'       
```
Finally, this causes the program to only print the last output and terminate when the input is exhausted (the `-z` flag adds a null terminator for this purpose):
```
         SD~t
          
```
Try replacing the `S` with a space to see the running result (the first `'y'` is extraneous, the second char matches the first input, and the third is the result of the first nontrivial calculation).
[Answer]
# [Cubix](https://github.com/ETHproductions/cubix), ~~24~~ 20 bytes
Been a while since I played with Cubix, so ...
```
i;iwW-?;o@..!'yv.n'|
```
[Try it online!](https://tio.run/##Sy5Nyqz4/z/TOrM8XNfeOt9BT09RvbJML0@95v//yso8KKzMAwA "Cubix – Try It Online")
Fairly naive implementation that steps through the string and compares the character against current result.
[Interactive Demo](https://ethproductions.github.io/cubix/?code=ICAgIGkgOwogICAgaSB3ClcgLSA/IDsgbyBAIC4gLgohICcgeSB2IC4gbiAnIHwKICAgIC4gLgogICAgLiAuCg==&input=eXlueW55bnlueXlu&speed=20)
This unwraps onto the cube as follows
```
    i ;
    i w
W - ? ; o @ . .
! ' y v . n ' |
    . .
    . .
```
* `W` shift ip left
* `i` get the initial character
* `i?` get character and test for EOI (-1), also start of the loop
	+ if EOI `;o@` remove TOS, output TOS as character and exit.
* else `-W!` subtract, shift ip left, test for truthy
	+ if truthy `'n` push character n to TOS
	+ if falsey `|!'y` reflect, test and push character y to TOS
* `v'.;w` redirect around the cube pushing and removing a . character and shifting right back into the loop
[Answer]
# Scala, 50 Bytes
```
def?(b:String)=b.reduce((r,l)=>if(r==l)'y'else'n')
```
[Answer]
# [CJam](https://sourceforge.net/p/cjam), ~~20~~ 11 bytes
```
q~'ne="yn"=
```
[Try it online!](https://tio.run/##S85KzP3/v7BOPS/VVqkyT8n2/3@lyso8KAQKAAA "CJam – Try It Online")
[Answer]
# [Befunge-98](https://github.com/catseye/FBBI), 13 bytes
```
~k!aj@,+n'*b!
```
[Try it online!](https://tio.run/##S0pNK81LT9W1tPj/vy5bMTHLQUc7T10rSfH//8rKPBDMqwQA "Befunge-98 (FBBI) – Try It Online")
Basically inverts a 0 for every `n` in the input, and once more for good measure, then outputs `y` for `1` and `n` for `0`
```
~     Get inputted character
 k!   Invert the current value 110 (n) or 121 (y) + 1 times
   aj Jump past the rest of the code
~     Get input again. If no more input, reverse direction
            ! Invert the value once again
       +n'*b  Convert 0/1 to n/y
     @,       Output letter
```
[Answer]
# [Clean](http://clean.cs.ru.nl), ~~26~~ 23 bytes
```
foldr1\a b|a==b='y'='n'
```
[Try it online!](https://tio.run/##JcexCsJADADQ3a@4LZOCH5CtS6GD4KgO6bUnB0lOrnEI@O1GpLzpZV5JQ9ry5jUJVY0qr9YtDWR0mupmh4Kl8dLPd0rzhxBnBAcEhbgadcOSbuCuf@rwiG8uTM8tjuMUgytJzXsuTFZalx8 "Clean – Try It Online")
]