[Question]
      [
# `cat` goes "Meow"
We are all familiar with the concept of a `cat` program. The user types something in, it is echoed back to the user. Easy. But all `cat` programs I've seen so far have missed one fact: a `cat` goes "Meow". So your task is to write a program that copies all `STDIN` to `STDOUT` **UNLESS** the input is `cat`, in which case your program should output `cat goes "Meow"`.
## Scoring
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so your score is your byte count, with a few modifiers:
* If your program works for any additional animals other than `cat` (e.g. `cow: cow goes "Moo"`), for each additional animal: -10
* If your program doesn't use the word "cat": -15
* If your program responds to `fox` with "What does the fox say": -25
### Animals and sounds that go together:
`cow goes moo`
`duck goes quack`
`sheep goes baa`
`bees go buzz`
`frogs go croak`
Anything else on [this list](https://en.wikipedia.org/wiki/List_of_animal_sounds) is allowed.
## Rules
* [Standard loopholes](http://meta.codegolf.stackexchange.com/questions/1061/loopholes-that-are-forbidden-by-default) apply
* You must not write anything to `STDERR`
* You can use single quotes/no quotes instead of double quotes.
## Leaderboard
Here is a Stack Snippet to generate both a regular leaderboard and an overview of winners by language.
To make sure that your answer shows up, please start your answer with a headline, using the following Markdown template:
```
## Language Name, N bytes
```
where `N` is the size of your submission. If you improve your score, you *can* keep old scores in the headline, by striking them through. For instance:
```
## Ruby, <s>104</s> <s>101</s> 96 bytes
```
If there you want to include multiple numbers in your header (e.g. because your score is the sum of two files or you want to list interpreter flag penalties separately), make sure that the actual score is the *last* number in the header:
```
## Perl, 43 + 2 (-p flag) = 45 bytes
```
You can also make the language name a link which will then show up in the leaderboard snippet:
```
## [><>](http://esolangs.org/wiki/Fish), 121 bytes
```
```
var QUESTION_ID=62500;var OVERRIDE_USER=46470;function answersUrl(e){return"http://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"http://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(-?\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;
```
```
body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}
```
```
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>
```

[Answer]
## Pyth, 82-95 = -13 bytes
```
+z*}zKc."atÜiÃ'4ãl¾Eªîiû<-È&e"\jjk[d"goes"dNr@c."bw««[áÅ3ÏB"\c%x`Kz3 3N
```
I finally got around to converting my new functional Python 2 entry to Pyth. It doesn't beat the top contender. Turns out zipping together more animals into a larger dictionary reduces score faster than cleverly associating animals with sounds. This supports 8 animals in addition to cat: rhino, okapi, moose, lion, tiger, badger, hippo, and stag.
[Try it online](https://pyth.herokuapp.com/?code=%2Bz%2a%7DzKc.%22at%1C%08%C3%9C%18%1Ai%C3%83%7F%274%C3%A3l%C2%BEE%0B%C2%AA%C2%8F%C3%AEi%C2%9D%C3%BB%3C%1A-%C3%88%26e%22%5Cjjk%5Bd%22goes%22dNr%40c.%22bw%03%C2%AB%C2%AB%5B%C3%A1%C3%853%C3%8FB%C2%97%22%5Cc%25x%60Kz3+3N&input=stag&test_suite_input=%5B24%2C+6%5D%0A0+++%0A%5B24%2C+6%5D%0A1%0A%5B24%2C+6%5D%0A2%0A%5B24%2C+6%5D%0A5%0A%5B100%2C+50%5D%0A10%0A%5B1%2C+1.41421356237%5D%0A10&debug=0&input_size=2)
[Answer]
## Japt, ~~25-15=10~~ 24-15 = 9 bytes
First time trying Japt:
```
N¦`¯t`?N:`¯t goƒ \"´ow\"
```
`ƒ` should be replaced with unprintable character `U+0083`
Compiles to:
```
N!="cat"?N:"cat goes \"meow\""
```
Old solution:
```
N¥`¯t`?`¯t goƒ \"´ow\"`:N
```
[Try it here](http://ethproductions.github.io/japt/?v=master&code=TqZgr3RgP046YK90IGdvgyBcIrRvd1wi&input=ImNhdCI=)
[Answer]
# Pyth, 26-15 (no "cat") = 11 bytes
My first ever Pyth program!
```
Iqz_"tac"+z" goes meow";Ez
```
## [Try it here](http://pyth.herokuapp.com/?code=Iqz_%22tac%22%2Bz%22+goes+meow%22%3BEz&input=cat&test_suite=1&test_suite_input=sadsadsadad%0Acat%0Atac&debug=0)
### Explaination
```
   _"tac"                   # Reverse the string "tac"
Iqz                         # If the input equals "tac" reversed
         +z" goes meow";    # Append " goes meow"
                        Ez  # Else, use the input.
                            # Implicit: print the input, if it's used.
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), score: -136 (214 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage) - 31\*10 - 15 - 25)
```
'¨›Qi“What‚à€€ ÿ…è“ë“ÓÕŸâÍÝ¹ÐÀ¼ÛË—Ä¬…Ð§ÀÛÆÓ‹·»ÑÐœ²èàæÑåî€žÚÆÚØåÊÓ³âÌ–ÔÄ¤•ã‚í„ÄŠêÂÝ¢“#sk©di.•QÃ€}£≠‰ŒΛ(Ïûвrüéä[ñøuF½3¡üÃïßåιQÊçdï€]Üвβ`šŠû©ª«ĀLΩÝβ\à¨TĆηÎ.₄₆öª$γâôΘ:Æ™{¹и5|Âć®λ¬¡¸αâË::´óýÏƶ5~¦m.škα†#Ð6λ•#®è™s“ÿ—± "ÿ"
```
Bonuses:
* -15 for not using `cat`
* -25 for outputting `What does the fox say` when the input is `fox`
* 31 times -10 for the animals and sounds: `["bat screech","bear roar","bee buzz","tiger roar","lion roar","jaguar snarl","cat meow","chicken cluck","cow moo","cricket chirp","deer bellow","dog bark","wolf howl","duck quack","eagle screech","elephant trumpet","frog croak","horse neigh","mouse squeak","monkey scream","pig oink","rabbit squeak","seal bark","sheep baa","snake hiss","turkey gobble","whale sing","ass heehaw","rat squeak","goat bleat","lamb baa"]`
[Try it online](https://tio.run/##FVDdSgJBGH2V0KCuvIm68AG66kYIuqggwyKRCLIg6IdhW4yyH2sLxKzW1UzNLDdRt9WE77hdDj7DvIh9C8PAnDnfOec7O8noenxjPJ6iihI/kbgS@aWt6J4SOZhKq/OZwECJMvg7j3f/MvDgdWHhCk/kIANBPTwircQ9dKr73Ay9QTCWgqGEQx1ycYuMZ5CNCkyU@fWKBmt7v8gxK4csAxcw6Jt1L5Uw4GuVlLBQ9KN8KPEM3TNRg8auFscIJhNUjcVDzInglLWOqajOTSW@vDv5OI0buCN7Fz1UUVpGE939eerPUIGRU3ziBa/SibDnWwyfPL2K/MiW9ppXYBeXqlSj96FYkFU8SXsFJlUWhynZwXVIabrSUmhTbVL6cVsyG0ZK6dYhOaPu7BG04Rk1pEt1KlBXNpmSDoephW/0cfPXnj2h8nbIKyRkUwkziMycdHmJIDW4Y91K@hVz4/fUnAhgEBiPN3cO/gE) or [verify all used animals](https://tio.run/##HVBNT1NBFP0rk9ZEF6Ybgws27NzopomJCzVx2g7tsx@vee9VJIqZlKZGUakUE1KKtgVKCwi2EGgtSHIPz@ULv2H@SL3PZHIyc@6559y5tisTlppGXy3ORYSpronI3CJqqE1vU8/o33HL6OaTjPSMbqBlyod8BK6M7oLLTRyEUMc3f4QOPmOLxtys6QKbWDF6HRU6DLU12oNmroq60WM6pwm@oubXaYgeWujyaxdH7O3/QYNVDWww8RF1OmHfT0bXEXrtGN3BdjjKT6O/o@K3sI8yp3Z4jKibpX7KirEmjmX2WqJt86Fl9C9/Ldi8g1VMboYOLtDHzlMMMCo9oMt71GZmGcf4gd1gHOfMvRSOufs5mjfDYPjCb3PKhPq0TwfX@lHQx1YwfIYW9R5fV4NzfImZcsWUqzij/VtBOO5psDGLqql03tD4ZjTzFuXr93QUTOiQ2jQKBixZmZ2lU5zgEqt/z2beUTcf89vZYGB0K4ra/WDCn4jSEe@40nHDFfPG12kgIriKTPm9tERnD@9OE9ITCSUdBiU8K60ckbPsgngp0yVmk1xOZqxkVhVE0l4QSSe8eyKlWJiy02LBzs2LVCmZFUqmc0qonCpmZMET8w5XM7bjKpG3S/@xkFWLomilhSMTCcsTrpI54WaUKgq3ILOcX3JCyUJGspN0XRZ6Im0z5GQ@Iebt18wUUnb@Hw).
**Explanation:**
```
'¨›                  '# Push dictionary word "fox"
   Qi                 # If the (implicit) input-string equal "fox":
     “What‚à€€ ÿ…è“   #  Push dictionary string "What does the ÿ say"
                      #  (where the `ÿ` is automatically filled with the implicit input)
   ë                  # Else:
    “ÓÕŸâÍÝ...ÄŠêÂÝ¢“ #  Push dictionary string "bar bear bee ... rat goat lamb"
    #                 #  Split it on spaces
    sk                #  Get the index of the input-string in this list (-1 if not found)
    ©                 #  Store this index in variable `®` (without popping)
    di                #  If this index is non-negative (>= 0):
      .•QÃ€...Ð6λ•    #   Push compressed string "screech roar ... bleat baa"
      #               #   Split it on spaces
      ®è              #   Index variable `®` into this list
      ™               #   Titlecase this sound
      s               #   Swap to get the (implicit) input-string at the top of the stack
      “ÿ—± "ÿ"        #   Push dictionary string 'ÿ goes "ÿ"'
                      #   (where the first `ÿ` is the input at the top of the stack,
                      #    and the second `ÿ` is the titlecased sound below it)
                      # (after which the top of the stack is output implicitly as result,
                      #  which will be the (implicit) input itself for any other input)
```
[See this 05AB1E tip of mine (sections *How to use the dictionary?* and *How to compress strings not part of the dictionary?*)](https://codegolf.stackexchange.com/a/166851/52210) to understand why:
* `'¨›` is `"fox"`
* `“What‚à€€ ÿ…è“` is `"What does the ÿ say"`
* `“ÓÕŸâÍÝ¹ÐÀ¼ÛË—Ä¬…Ð§ÀÛÆÓ‹·»ÑÐœ²èàæÑåî€žÚÆÚØåÊÓ³âÌ–ÔÄ¤•ã‚í„ÄŠêÂÝ¢“` is `"bat bear bee tiger lion jaguar cat chicken cow cricket deer dog wolf duck eagle elephant frog horse mouse monkey pig rabbit seal sheep snake turkey whale ass rat goat lamb"`
* `.•QÃ€}£≠‰ŒΛ(Ïûвrüéä[ñøuF½3¡üÃïßåιQÊçdï€]Üвβ`šŠû©ª«ĀLΩÝβ\à¨TĆηÎ.₄₆öª$γâôΘ:Æ™{¹и5|Âć®λ¬¡¸αâË::´óýÏƶ5~¦m.škα†#Ð6λ•` is `"screech roar buzz roar roar snarl meow cluck moo chirp bellow bark howl quack screech trumpet croak neigh squeak scream oink squeak bark baa hiss gobble sing heehaw squeak bleat baa"`
* and `“ÿ—± "ÿ"` is `'ÿ goes "ÿ"'`
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), 132 - 150 (animals) - 15 (no `cat`) = -33 bytes
```
pJjb.zp.x++" goes \""[[email protected]](/cdn-cgi/l/email-protection)\ic."ay-ÝÏåâšB²Å
uŠ°µ²¦DÄ²Öì |t`2“‚Êôë¨}èÔèw:ÿÊ_OƒÄ<Ú›ø‚î½ùÛ&L°„6a<9-¾¹™,Uø0é6Œû²Ù²ËyÊ·%C"\lJ4\"k
```
[Try it online!](https://tio.run/##AcQAO/9weXRo//9wSmpiLnpwLngrKyIgZ29lcyBcIiJyQC5kbWNkXGljLiJheS3DncOPw6XDosKaQsKyw4UMdcKKwrDCtcKywqZEw4TCssOWw6wgBXx0YDIHwpPCgsKBw4rDtMOrGsKofcOow5TDqHc6w7/Dil9PwoPDhBQ8w5rCm8O4woLDrsK9w7nDmyZMwrDChDZhPDktwr7CucKZLFXDuDARw6k2wozDu8KyD8OZwrLDi3nDisK3JUMiXGxKNFwia///Y2F0 "Pyth – Try It Online")
Uses a packed string to fit in animals for less than 10 bytes each
Full list:
```
parrot goes "Squack"
cat goes "Meow"
rook goes "Caw"
ass goes "Bray"
goose goes "Honk"
dog goes "Woof"
duck goes "Quack"
sheep goes "Baa"
ox goes "Moo"
raven goes "Caw"
goat goes "Baa"
swan goes "Cry"
frog goes "Croak"
toad goes "Croak"
monkey goes "Chatter"
```
Edit 1: Almost forgot the no cat bonus :P
[Answer]
# [GolfScript](http://www.golfscript.com/golfscript/), 25 - 15 = 10 bytes
```
."c""at"+=" goes 'Meow'"*
```
[Try it online!](https://tio.run/##S8/PSStOLsosKPn/X08pWUkpsURJ21ZJIT0/tVhB3Tc1v1xdSev//@TEEgA "GolfScript – Try It Online")
### Example
```
."c""at"+=" goes 'Meow'"*   # Input: cat
."c""at"                    # Duplicate input, push c and at. Stack: cat cat c at
        +                   # Concatenate, Stack: cat cat cat
         =                  # Check if equal, Stack: cat 1
          " goes 'Meow'"*   # " goes 'Meow'" pushed onto stack n times, Stack: "cat" " goes 'Meow'"
                            # Implicitly print
```
### Alternate Example
```
."c""at"+=" goes 'Meow'"*   # Input: asdf
."c""at"                    # Duplicate input, push c and at. Stack: asdf asdf c at
        +                   # Concatenate, Stack: asdf asdf cat
         =                  # Check if equal, Stack: asdf 0
          " goes 'Meow'"*   # " goes 'Meow'" pushed onto stack n times, Stack: "asdf" ""
                            # Implicitly print
```
[Answer]
# [Nim](https://nim-lang.org/), 65 - 15 = ~~56~~ 50 bytes
Does not use the word cat. Supports only cat and then "Meow", no other animals.
```
while 1>0:
 var i=readLine stdin;echo if i=="ca"&"t":"Meow"else:i
```
[Attempt This Online!](https://ato.pxeger.com/run?1=LYwxCgIxEAD7fUXYQrAQtJNIBHt9xJJsvNWYwCWa_MUmID7qfuPB2c4w8_5EefT-fRa_2U-nOkhgtTtuNagXjUrMyOTOElnl4iQe2A5JiZ-FQUu4woIaL5wqcsisZRn9f31au3QFcrcklF24U3CZwKYKPpNpYKkAtEYzXYof)
(-6 bytes thanks to Steffan)
[Answer]
# TI-Basic, 48 bytes
```
Input Str1
Str1="cat
If Ans
Disp Str1+" goes Meow
If not(Ans
Disp Str1
```
All those lowercase letters are increasing the bytecount by a lot.
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), 285 - 310 - 15 - 25 = -65 bytes
```
`∷¾`=[`λ⟩ ƛ∪ λλ ∷¾ ∨¶`|`Ḃṙ ∞¨ εċ ṗµ √₇ Ṁ⋎ ¢₌ β¡ ¦‹ √⊍ ₃⇩ •ƈ ṡƒ ¦ø ḟ₇ Ẇ⟑ µɽ ½ż Þ‡ ₃⅛ Ḣ⟨ ₈Ḋ ġṄ ⁋ė Ċṁ ∴† Ẏ₇ ass ₀⌈ ⌊ṫ Ȯ⁰`⌈?ḟ:£0≥[`s⇩⋏↳⋎ r⋎« Ȧ¨ r⋎« r⋎« sn₴£ m□ŀ cḟĿ moo ch↲Ṗ Ǎ⟩⟑ṙ •øk h⋎₄ qꜝ½k s⇩⋏↳⋎ t≥⁋⌐¨ crβ⁰ ne⋏ṫ sȧ‛ak s›‹ o›₌ sȧ‛ak •øk baa λµs £⁋ǎʁ ⟩ɽ hee¥↓ sȧ‛ak bl↓⟑ baa`⌈¥i`% ¢₃ `?%$+
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyIiLCIiLCJg4oi3wr5gPVtgzrvin6kgxpviiKogzrvOuyDiiLfCviDiiKjCtmB8YOG4guG5mSDiiJ7CqCDOtcSLIOG5l8K1IOKImuKChyDhuYDii44gwqLigowgzrLCoSDCpuKAuSDiiJriio0g4oKD4oepIOKAosaIIOG5ocaSIMKmw7gg4bif4oKHIOG6huKfkSDCtcm9IMK9xbwgw57igKEg4oKD4oWbIOG4ouKfqCDigojhuIogxKHhuYQg4oGLxJcgxIrhuYEg4oi04oCgIOG6juKChyBhc3Mg4oKA4oyIIOKMiuG5qyDIruKBsGDijIg/4bifOsKjMOKJpVtgc+KHqeKLj+KGs+KLjiBy4ouOwqsgyKbCqCBy4ouOwqsgcuKLjsKrIHNu4oK0wqMgbeKWocWAIGPhuJ/EvyBtb28gY2jihrLhuZYgx43in6nin5HhuZkg4oCiw7hrIGjii47igoQgceqcncK9ayBz4oep4ouP4oaz4ouOIHTiiaXigYvijJDCqCBjcs6y4oGwIG5l4ouP4bmrIHPIp+KAm2FrIHPigLrigLkgb+KAuuKCjCBzyKfigJthayDigKLDuGsgYmFhIM67wrVzIMKj4oGLx47KgSDin6nJvSBoZWXCpeKGkyBzyKfigJthayBibOKGk+KfkSBiYWFg4oyIwqVpYCUgwqLigoMgYD8lJCsiLCIiLCJzaGVlcCJd)
Port of Kevin Cruijssen's 05AB1E answer.
# [Vyxal](https://github.com/Vyxal/Vyxal), 42 - 15 - 25 = 2 bytes
```
`¢₌`=[`¢₌ ¢₃ "M□ŀ"`|`∷¾`=[`λ⟩ ƛ∪ λλ ∷¾ ∨¶`
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyIiLCIiLCJgwqLigoxgPVtgwqLigowgwqLigoMgXCJN4pahxYBcImB8YOKIt8K+YD1bYM674p+pIMab4oiqIM67zrsg4oi3wr4g4oiowrZgIiwiIiwiZm94Il0=)
Bonuses:
* -15 for not using `cat`
* -25 for responding to `fox` with `What does the fox say`
## [Vyxal](https://github.com/Vyxal/Vyxal), 19 - 15 = 4 bytes
```
`¢₌`=[`¢₌ ¢₃ "M□ŀ"`
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyIiLCIiLCJgwqLigoxgPVtgwqLigowgwqLigoMgXCJN4pahxYBcImAiLCIiLCJjYXQiXQ==)
Bonuses:
* -15 for not using `cat`
### Explanation
Most of it is just string compression:
* ``¢₌`` is `cat`
* ``¢₌ ¢₃ "M□ŀ"`` is `cat goes "meow"`
* ``∷¾`` is `fox`
* ``λ⟩ ƛ∪ λλ ∷¾ ∨¶`` is `What does the fox say`
[Answer]
# Pyth, 31 - 15 = 16 bytes
You can try it out [here](https://pyth.herokuapp.com/?code=In%2BC99%22at%22zz%3BE%2Bz%22%20goes%20%5C%22Meow%5C%22&input=cat%0A&test_suite=1&test_suite_input=cat%0Ahi&debug=0)
```
In+C99"at"zz;E+z" goes \"Meow\"
```
Explaination:
```
I                                # If-statement
 n                               # not equal
  +C99"at"                       # Adds the char 99 with the string "at" = "cat"
          z                      # z, the user input
           z                     # Print the user input
            ;                    # Ends all open parentheses
             E                   # Else-statement
              +z" goes \"Meow\"  # Adds ' goes "Meow"' to z and prints the result
```
[Answer]
# C, 76 bytes
```
main(){char a[99];gets(a);printf("%s%s",a,strcmp(a,"cat")?"":" goes meow");}
```
[Answer]
# PHP, 70-15 = 55 bytes
```
<?=$l=rtrim(stream_get_contents(STDIN),~òõ),$l==~œž‹?~ß˜šŒßÝ²šˆÝ:'';
```
(saved as ISO-8859-1)
Uses inverted undefined constants as string literals:
* `~òõ` == `"\r\n"`
* `~œž‹` == `'cat'`
* `~ß˜šŒßÝ²šˆÝ` == `' goes "Meow"'`
Everything is combined in a single echo statement, shorthanded with `<?=`
[Answer]
## Ruby, 35 + 2 (-p flag) - 15 = 22 bytes
```
$_==?c'at
'&&$_[-2]+=' goes "Meow"'
```
Inspired by trying to improve [Peter Lenkefi's](https://codegolf.stackexchange.com/a/62502) solution.
[Answer]
## Ruby, 110 + 2 (-p flag) -60 (cow, ox, dog, bee, pig and crow) -15 (no cat) = 37 bytes
```
(h=Hash[*%W(cow Moo ox Low c\141t Meow dog Woof bee Buzz pig Oink crow Caw)][$_.chop])&&$_[-2]+=' goes "'+h+?"
```
Multiple animal Ruby solution... As long as the animal+sound is <8 characters, it shrinks for each one added. Gross abuse of Ruby. :)
[Answer]
# Ruby, 26 + 1 = 27
With command-line flag `-p`, run
```
sub /^cat$/,'\& goes Meow'
```
Getting the no-cat bonus costs 2 bytes, which isn't actually worth it:
```
sub /^c at$/x,'\& goes Meow'
```
[Answer]
# [Hassium](http://HassiumLang.com), 67 Bytes
```
func main()if((x=input())=="cat")print(x+" goes meow")else print(x)
```
See expanded [here](http://HassiumLang.com/Hassium/index.php?code=ab0a8369a4a78fca2376f798bf1df2bb)
[Answer]
# [JacobFck](https://github.com/JacobMisirian/JacobFck), 31 Bytes
I really like the golfed version of this.
```
"cat"<|=_e>!:e"cat goes Meow">
```
See commented and expanded [here](http://hassiumlang.com/Paste/get-paste.has?hash=48e0912b2dfe5a3af3be80d88f0b36da)
[Answer]
## Python 2, 149-95 = 54 bytes
### -8\*10 extra animals, -15 for no "cat"
```
u=raw_input()
l="ca""t badger rhino okapi moose stag tiger hippo lion".split()
print u+' goes "%s"'%["Growl","Bellow","Meow"][`l`.find(u)%3]*(u in l)
```
Supported animals:
* moose, stag, okapi, rhino (all Bellow)
* tiger, badger, lion, hippo (all Growl)
This is not the shortest Python answer, but at least it does bother to try at some other animals! I add it here because the answer i had previously did not work, and I'm confident this will become the shortest Pyth answer once I translate it and golf it there.
### How it works:
1. Take input
2. Create a list of animals in a very precise order.
3. Print the input, and if the input is in the list, use the location of the input in the string representation of the list to index an array of sounds, and append the appropriate "goes" string.
[Answer]
# [Arcyóu](https://github.com/Nazek42/arcyou), 38 bytes (non-competitive)
*Since this version of the language was made after the challenge was posted, it is not eligible.*
```
(: s(q))(?(= s "cat")"cat goes Meow" s
```
Arcyóu is a LISP-like golfing language.
Explanation:
```
(: s(q))           ; Set the variable s to the contents of STDIN
(? (= s "cat")     ; If-statement. Condition is s == "cat"
  "cat goes Meow"  ; If true: return the string "cat goes Meow"
  s                ; Otherwise, return what was entered
```
Arcyóu automatically prints the result of the last expression evaluated. In this case, it is the `?` statement. It also allows you to leave off trailing close-parens.
[Answer]
# Emacs Lisp (67 Bytes)
```
(set'a(read-string""))(message(pcase a("cat""cat goes meow")(_ a)))
```
It uses pattern matching to distinguish cats from other input. This could be extended to fit other animals in as well, but as most of them take up more than 10 characters, there is not much to be gained from that.
[Answer]
# [Milky Way 1.5.16](https://github.com/zachgates7/Milky-Way), 29 bytes - 15 = 14
```
"c""at"+'?{b_" goes Meow"+_}!
```
Doesn't use a `"cat"` string.
---
### Explanation
```
"c""at"      " goes Meow"      # push string to the stack
       +                 +     # add the TOS and the STOS
        '                      # read input from the command line
         ?{ _             _}   # if statement
           b                   # equality of the TOS and the STOS
                            !  # output the TOS
```
---
### Usage
```
python3 milkyway.py <path-to-code> -i <input>
```
[Answer]
## [Perl](https://github.com/BrendanGalvin), 13 bytes
The string "cat" does not appear in my code (Special thanks to Dennis for shaving 15 bytes off of the code, and teaching me some new Perl tricks):
```
s/^(c)at$/$& goes Meow/
```
[Answer]
# C#6, 302 - 110 - 15 = 177 bytes
This works for 12 different animals, including cat. It does not include the word "cat" verbatim.
```
using static System.Console;class P{static void Main(){var a=ReadLine();var d="bee,Buzz,c\x61t,Meow,cow,Moo,crow,Caw,dog,Bark,hog,Oink,lamb,Baa,lion,Roar,ox,Low,owl,Hoo,pig,Oink,rook,Caw,seal,Bark,sheep,Baa,swan,Cry".Split(',');int i=22;while(--i>0&&d[--i]!=a);Write(i<0?a:d[i]+" goes '"+d[i+1]+"'");}}
```
Indentation and new lines for clarity.
```
using static System.Console;
class P{
    static void Main(){
        var a=ReadLine();
        var d="bee,Buzz,c\x61t,Meow,cow,Moo,crow,Caw,dog,Bark,hog,Oink,lamb,Baa,lion,Roar,ox,Low,owl,Hoo,pig,Oink,rook,Caw,seal,Bark,sheep,Baa,swan,Cry".Split(',');
        int i=22;
        while(--i>0&&d[--i]!=a);
        Write(i<0?a:d[i]+" goes '"+d[i+1]+"'");
    }
}
```
[Answer]
## [DIG](https://github.com/UnderMybrella/DIG), 163 - 15 = 148 bytes
Disclaimer: Due to the fact that DIG was created after the challenge, this answer is non-competing.
[![Beautiful cats](https://i.stack.imgur.com/RFQ7n.png)](https://i.stack.imgur.com/RFQ7n.png)
Zoomed in (Note: This file will NOT compile, due to the nature of the language)
[![Impossible Cats](https://i.stack.imgur.com/5nEUY.png)](https://i.stack.imgur.com/5nEUY.png)
While I have no idea if this is considered a valid language for PPCG, it *does* complete the challenge. Documentation for the language can be found [here](https://github.com/UnderMybrella/DIG/blob/master/Schematic.txt) and the interpreter can be found [here](https://github.com/UnderMybrella/DIG/blob/master/DIG.jar).
[Answer]
# Swift 2.0, ~~71~~ 68-15 (no "cat") = 53 bytes
```
func a(s:String)->String{return s=="c\u{61}t" ?s+" goes \"Meow\"":s}
```
For some reason, a compilation error is thrown if there isn't a space before the ternary operator `?`
### Ungolfed
```
func a(s: String) -> String{
    return s == "c\u{61}t" ? s + " goes \"Meow\"" : s
}
```
This doesn't use "cat" in it by replacing the a with the unicode literal `\u{61}`. You can [test this code here](http://swiftstub.com/156692825/)
[Answer]
## JavaScript, 35 - 15 (-p no cat) = 20 Bytes
```
c=i=>(i=='c\at')?i+' says "Meow"':i
```
Can someone check to see that I did the header right?
[Answer]
# Retina, 23 - 15 = 8 bytes
```
^ca\0*t$
$& goes "Meow"
```
[Answer]
# Pylongolf2, 33-15=18 bytes
```
"tac"╨1cd_@0=b?" goes Meow"¿~
```
Explanations:
```
"tac"╨1cd_@0=b?" goes Meow"¿~
"tac"                         push "tac" to stack
     ╨1                       reverse it
       cd                     read input and then select latest item in stack
         _                    duplicate input
          @0                  select first item in stack
            =b                compare then swap places
              ?               if true,
               " goes Meow"¿  push " goes Meow" to stack and end if statement
                            ~ print it.
```
[Answer]
## Lua 5.3.2, 229 - 25 - 15 - 80 (extra animals) = 109 bytes
```
r={...}a={['\99\97\116']='Meow',duck='Quack',sheep='Baa',bee='Buzz',frog='Croak',bat='Screech',elk='Bugle',swan='Cry',pig='Oink'}print(r[1]=='fox' and 'What does the fox say' or(a[r[1]] and r[1]..' goes "'..a[r[1]]..'"' or r[1]))
```
### Ungolfed
```
local Args = {...}
local Sounds = {
    ['\99\97\116'] = 'Meow',
    duck = 'Quack',
    sheep = 'Baa',
    bee = 'Buzz',
    frog = 'Croak',
    bat = 'Screech',
    elk = 'Bugle',
    swan = 'Cry',
    pig = 'Oink'
}
print(
    Args[1] == 'fox' and 'What does the fox say' or (
        Sounds[Args[1]] and Args[1] .. ' goes "' .. Sounds[Args[1]] .. '"' or Args[1]
    )
)
```
I tried to make the logic a little clearer by putting it on multiple lines.
It's essentially a ternary operator `?:`
[Answer]
## AWK, 32 - 15 = 17
```
/^[c]at$/{$0=$0" goes 'Meow'"}1
```
I think this counts as not using "cat". Could have saved a couple bytes if "cat" were allowed to be anywhere in the line.
For giggles I also put together one with more animals, but it's not competitive, especially with trying to capture the correct verb to use, but here's what I came up with :)
```
{for(;I<split("ca""t,Meow,bees,Buzz,bird,Song,cow,Moo,crow,Caw,dog,Woof,duck,Quack,frogs,Croak,hog,Oink,ox,Low,pig,Oink,sheep,Baa,swan,Cry",a,",");)
m[a[I-1]="'"a[I+=2]"'"}
m[$0]{$0=$0($0~/s$/?" go ":" goes ")m[$0]}
/^fox$/{$0="What does the fox say"}
1
```
]


[Question]
      [
Using your language of choice, golf a [quine](http://en.wikipedia.org/wiki/Quine_%28computing%29).
>
> A **quine** is a non-empty computer program which takes no input and produces a copy of its own source code as its only output.
>
>
>
No cheating -- that means that you can't just read the source file and print it. Also, in many languages, an empty file is also a quine: that isn't considered a legit quine either.
No error quines -- there is already a [separate challenge](https://codegolf.stackexchange.com/questions/36260/make-an-error-quine) for error quines.
Points for:
* Smallest code (in bytes)
* Most obfuscated/obscure solution
* Using esoteric/obscure languages
* Successfully using languages that are difficult to golf in
The following Stack Snippet can be used to get a quick view of the current score in each language, and thus to know which languages have existing answers and what sort of target you have to beat:
```
var QUESTION_ID=69;
var OVERRIDE_USER=98;
var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";var COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk";var answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;function answersUrl(index){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+index+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}
function commentUrl(index,answers){return"https://api.stackexchange.com/2.2/answers/"+answers.join(';')+"/comments?page="+index+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}
function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(data){answers.push.apply(answers,data.items);answers_hash=[];answer_ids=[];data.items.forEach(function(a){a.comments=[];var id=+a.share_link.match(/\d+/);answer_ids.push(id);answers_hash[id]=a});if(!data.has_more)more_answers=!1;comment_page=1;getComments()}})}
function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(data){data.items.forEach(function(c){if(c.owner.user_id===OVERRIDE_USER)
answers_hash[c.post_id].comments.push(c)});if(data.has_more)getComments();else if(more_answers)getAnswers();else process()}})}
getAnswers();var SCORE_REG=(function(){var headerTag=String.raw `h\d`
var score=String.raw `\-?\d+\.?\d*`
var normalText=String.raw `[^\n<>]*`
var strikethrough=String.raw `<s>${normalText}</s>|<strike>${normalText}</strike>|<del>${normalText}</del>`
var noDigitText=String.raw `[^\n\d<>]*`
var htmlTag=String.raw `<[^\n<>]+>`
return new RegExp(String.raw `<${headerTag}>`+String.raw `\s*([^\n,]*[^\s,]),.*?`+String.raw `(${score})`+String.raw `(?=`+String.raw `${noDigitText}`+String.raw `(?:(?:${strikethrough}|${htmlTag})${noDigitText})*`+String.raw `</${headerTag}>`+String.raw `)`)})();var OVERRIDE_REG=/^Override\s*header:\s*/i;function getAuthorName(a){return a.owner.display_name}
function process(){var valid=[];answers.forEach(function(a){var body=a.body;a.comments.forEach(function(c){if(OVERRIDE_REG.test(c.body))
body='<h1>'+c.body.replace(OVERRIDE_REG,'')+'</h1>'});var match=body.match(SCORE_REG);if(match)
valid.push({user:getAuthorName(a),size:+match[2],language:match[1],link:a.share_link,})});valid.sort(function(a,b){var aB=a.size,bB=b.size;return aB-bB});var languages={};var place=1;var lastSize=null;var lastPlace=1;valid.forEach(function(a){if(a.size!=lastSize)
lastPlace=place;lastSize=a.size;++place;var answer=jQuery("#answer-template").html();answer=answer.replace("{{PLACE}}",lastPlace+".").replace("{{NAME}}",a.user).replace("{{LANGUAGE}}",a.language).replace("{{SIZE}}",a.size).replace("{{LINK}}",a.link);answer=jQuery(answer);jQuery("#answers").append(answer);var lang=a.language;lang=jQuery('<i>'+a.language+'</i>').text().toLowerCase();languages[lang]=languages[lang]||{lang:a.language,user:a.user,size:a.size,link:a.link,uniq:lang}});var langs=[];for(var lang in languages)
if(languages.hasOwnProperty(lang))
langs.push(languages[lang]);langs.sort(function(a,b){if(a.uniq>b.uniq)return 1;if(a.uniq<b.uniq)return-1;return 0});for(var i=0;i<langs.length;++i)
{var language=jQuery("#language-template").html();var lang=langs[i];language=language.replace("{{LANGUAGE}}",lang.lang).replace("{{NAME}}",lang.user).replace("{{SIZE}}",lang.size).replace("{{LINK}}",lang.link);language=jQuery(language);jQuery("#languages").append(language)}}
```
```
body{text-align:left!important}#answer-list{padding:10px;float:left}#language-list{padding:10px;float:left}table thead{font-weight:700}table td{padding:5px}
```
```
 <script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="https://cdn.sstatic.net/Sites/codegolf/primary.css?v=f52df912b654"> <div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td><a href="{{LINK}}">{{SIZE}}</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td><a href="{{LINK}}">{{SIZE}}</a></td></tr></tbody> </table>
```

[Answer]
## Python 3, 34 Bytes
```
print((s:='print((s:=%r)%%s)')%s)
```
As far as I'm aware this is shorter than any other published Python 3 quine, mainly by virtue of having been written in the future with respect to most of them, so it can use `:=`.
[Answer]
# Befunge 98 - ~~17~~ 11 characters
```
<@,+1!',k9"
```
Or if using `g` is allowed:
# Befunge 98 - ~~12~~ 10
```
<@,g09,k8"
```
[Answer]
# TECO, 20 bytes
```
<Tab>V27:^TJDV<Esc>V27:^TJDV
```
The `<Esc>` should be replaced with ASCII 0x1B, and the `<Tab>` with 0x09.
* `<Tab>V27:^TJDV<Esc>` inserts the text `<Tab>V27:^TJDV`. This is *not* because there is a text insertion mode which TECO starts in by default. Instead, `<Tab>` *text* `<Esc>` is a special insertion command which inserts a tab, and then the text. A string whose own initial delimiter is part of the text -- very handy.
* `V` prints the current line.
* `27:^T` prints the character with ASCII code 27 without the usual conversion to a printable representation.
* `J` jumps to the beginning of the text.
* `D` deletes the first character (the tab).
* `V` prints the line again.
[Answer]
# Python 2, 31 bytes
```
s="print's=%r;exec s'%s";exec s
```
It's 2 bytes longer than the [shortest Python quine on this question](https://codegolf.stackexchange.com/a/115/21487), but it's much more useful, since you don't need to write everything twice.
For example, to print a program's own source code in sorted order, we can just do:
```
s="print''.join(sorted('s=%r;exec s'%s))";exec s
```
Another example by @feersum can be found [here](https://codegolf.stackexchange.com/a/47198/21487).
## Notes
The reason the quine works is because of `%r`'s behaviour. With normal strings, `%r` puts single quotes around the string, e.g.
```
>>> print "%r"%"abc"
'abc'
```
But if you have a single quotes inside the string, it uses double quotes instead:
```
>>> print "%r"%"'abc'"
"'abc'"
```
This does, however, mean that the quine has a bit of a problem if you want to use both types of quotes in the string.
[Answer]
# [RETURN](https://github.com/molarmanful/RETURN), 18 bytes
```
"34¬§¬§,,,,"34¬§¬§,,,,
```
`[Try it here.](http://molarmanful.github.io/RETURN/)`
First RETURN program on PPCG ever! RETURN is a language that tries to improve DUP by using nested stacks.
# Explanation
```
"34¬§¬§,,,,"         Push this string to the stack
          34       Push charcode of " to the stack
            ¬§¬§     Duplicate top 2 items
              ,,,, Output all 4 stack items from top to bottom
```
[Answer]
# [Factor](http://factorcode.org) -  ~~74~~  ~~69~~ 65 bytes
Works on the listener (REPL):
```
USE: formatting [ "USE: formatting %u dup call" printf ] dup call
```
This is my first ever quine, ~~I'm sure there must be a shorter one!~~ Already shorter. Now I'm no longer sure... (bad pun attempt)
What it does is:
* `USE: formatting` import the `formatting` vocabulary to use `printf`
* `[ "U... printf ]` create a quotation (or lambda, or block) on the top of the stack
* `dup call` duplicate it, and call it
The quotation takes the top of the stack and embeds it into the string as a literal.
Thanks, cat! -> shaved ~~2~~ 4 more bytes :D
[Answer]
# [S.I.L.O.S](http://github.com/rjhunjhunwala/S.I.L.O.S), ~~2642~~ 2593 bytes
**Credits to Rohan Jhunjhunwala for the algorithm.**
```
A = 99
set A 112
A + 1
set A 114
A + 1
set A 105
A + 1
set A 110
A + 1
set A 116
A + 1
set A 76
A + 1
set A 105
A + 1
set A 110
A + 1
set A 101
A + 1
set A 32
A + 1
set A 65
A + 1
set A 32
A + 1
set A 61
A + 1
set A 32
A + 1
set A 57
A + 1
set A 57
A + 1
set A 10
A + 1
set A 67
A + 1
set A 32
A + 1
set A 61
A + 1
set A 32
A + 1
set A 57
A + 1
set A 57
A + 1
set A 10
A + 1
set A 66
A + 1
set A 32
A + 1
set A 61
A + 1
set A 32
A + 1
set A 103
A + 1
set A 101
A + 1
set A 116
A + 1
set A 32
A + 1
set A 67
A + 1
set A 10
A + 1
set A 108
A + 1
set A 98
A + 1
set A 108
A + 1
set A 68
A + 1
set A 10
A + 1
set A 67
A + 1
set A 32
A + 1
set A 43
A + 1
set A 32
A + 1
set A 49
A + 1
set A 10
A + 1
set A 112
A + 1
set A 114
A + 1
set A 105
A + 1
set A 110
A + 1
set A 116
A + 1
set A 32
A + 1
set A 115
A + 1
set A 101
A + 1
set A 116
A + 1
set A 32
A + 1
set A 65
A + 1
set A 32
A + 1
set A 10
A + 1
set A 112
A + 1
set A 114
A + 1
set A 105
A + 1
set A 110
A + 1
set A 116
A + 1
set A 73
A + 1
set A 110
A + 1
set A 116
A + 1
set A 32
A + 1
set A 66
A + 1
set A 10
A + 1
set A 112
A + 1
set A 114
A + 1
set A 105
A + 1
set A 110
A + 1
set A 116
A + 1
set A 76
A + 1
set A 105
A + 1
set A 110
A + 1
set A 101
A + 1
set A 32
A + 1
set A 65
A + 1
set A 32
A + 1
set A 43
A + 1
set A 32
A + 1
set A 49
A + 1
set A 10
A + 1
set A 66
A + 1
set A 32
A + 1
set A 61
A + 1
set A 32
A + 1
set A 103
A + 1
set A 101
A + 1
set A 116
A + 1
set A 32
A + 1
set A 67
A + 1
set A 10
A + 1
set A 105
A + 1
set A 102
A + 1
set A 32
A + 1
set A 66
A + 1
set A 32
A + 1
set A 68
A + 1
set A 10
A + 1
set A 70
A + 1
set A 32
A + 1
set A 61
A + 1
set A 32
A + 1
set A 57
A + 1
set A 57
A + 1
set A 10
A + 1
set A 69
A + 1
set A 32
A + 1
set A 61
A + 1
set A 32
A + 1
set A 103
A + 1
set A 101
A + 1
set A 116
A + 1
set A 32
A + 1
set A 70
A + 1
set A 10
A + 1
set A 108
A + 1
set A 98
A + 1
set A 108
A + 1
set A 71
A + 1
set A 10
A + 1
set A 70
A + 1
set A 32
A + 1
set A 43
A + 1
set A 32
A + 1
set A 49
A + 1
set A 10
A + 1
set A 112
A + 1
set A 114
A + 1
set A 105
A + 1
set A 110
A + 1
set A 116
A + 1
set A 67
A + 1
set A 104
A + 1
set A 97
A + 1
set A 114
A + 1
set A 32
A + 1
set A 69
A + 1
set A 10
A + 1
set A 69
A + 1
set A 32
A + 1
set A 61
A + 1
set A 32
A + 1
set A 103
A + 1
set A 101
A + 1
set A 116
A + 1
set A 32
A + 1
set A 70
A + 1
set A 10
A + 1
set A 105
A + 1
set A 102
A + 1
set A 32
A + 1
set A 69
A + 1
set A 32
A + 1
set A 71
A + 1
printLine A = 99
C = 99
B = get C
lblD
C + 1
print set A
printInt B
printLine A + 1
B = get C
if B D
F = 99
E = get F
lblG
F + 1
printChar E
E = get F
if E G
```
[Try it online!](http://silos.tryitonline.net/#code=QSA9IDk5CnNldCBBIDExMgpBICsgMQpzZXQgQSAxMTQKQSArIDEKc2V0IEEgMTA1CkEgKyAxCnNldCBBIDExMApBICsgMQpzZXQgQSAxMTYKQSArIDEKc2V0IEEgNzYKQSArIDEKc2V0IEEgMTA1CkEgKyAxCnNldCBBIDExMApBICsgMQpzZXQgQSAxMDEKQSArIDEKc2V0IEEgMzIKQSArIDEKc2V0IEEgNjUKQSArIDEKc2V0IEEgMzIKQSArIDEKc2V0IEEgNjEKQSArIDEKc2V0IEEgMzIKQSArIDEKc2V0IEEgNTcKQSArIDEKc2V0IEEgNTcKQSArIDEKc2V0IEEgMTAKQSArIDEKc2V0IEEgNjcKQSArIDEKc2V0IEEgMzIKQSArIDEKc2V0IEEgNjEKQSArIDEKc2V0IEEgMzIKQSArIDEKc2V0IEEgNTcKQSArIDEKc2V0IEEgNTcKQSArIDEKc2V0IEEgMTAKQSArIDEKc2V0IEEgNjYKQSArIDEKc2V0IEEgMzIKQSArIDEKc2V0IEEgNjEKQSArIDEKc2V0IEEgMzIKQSArIDEKc2V0IEEgMTAzCkEgKyAxCnNldCBBIDEwMQpBICsgMQpzZXQgQSAxMTYKQSArIDEKc2V0IEEgMzIKQSArIDEKc2V0IEEgNjcKQSArIDEKc2V0IEEgMTAKQSArIDEKc2V0IEEgMTA4CkEgKyAxCnNldCBBIDk4CkEgKyAxCnNldCBBIDEwOApBICsgMQpzZXQgQSA2OApBICsgMQpzZXQgQSAxMApBICsgMQpzZXQgQSA2NwpBICsgMQpzZXQgQSAzMgpBICsgMQpzZXQgQSA0MwpBICsgMQpzZXQgQSAzMgpBICsgMQpzZXQgQSA0OQpBICsgMQpzZXQgQSAxMApBICsgMQpzZXQgQSAxMTIKQSArIDEKc2V0IEEgMTE0CkEgKyAxCnNldCBBIDEwNQpBICsgMQpzZXQgQSAxMTAKQSArIDEKc2V0IEEgMTE2CkEgKyAxCnNldCBBIDMyCkEgKyAxCnNldCBBIDExNQpBICsgMQpzZXQgQSAxMDEKQSArIDEKc2V0IEEgMTE2CkEgKyAxCnNldCBBIDMyCkEgKyAxCnNldCBBIDY1CkEgKyAxCnNldCBBIDMyCkEgKyAxCnNldCBBIDEwCkEgKyAxCnNldCBBIDExMgpBICsgMQpzZXQgQSAxMTQKQSArIDEKc2V0IEEgMTA1CkEgKyAxCnNldCBBIDExMApBICsgMQpzZXQgQSAxMTYKQSArIDEKc2V0IEEgNzMKQSArIDEKc2V0IEEgMTEwCkEgKyAxCnNldCBBIDExNgpBICsgMQpzZXQgQSAzMgpBICsgMQpzZXQgQSA2NgpBICsgMQpzZXQgQSAxMApBICsgMQpzZXQgQSAxMTIKQSArIDEKc2V0IEEgMTE0CkEgKyAxCnNldCBBIDEwNQpBICsgMQpzZXQgQSAxMTAKQSArIDEKc2V0IEEgMTE2CkEgKyAxCnNldCBBIDc2CkEgKyAxCnNldCBBIDEwNQpBICsgMQpzZXQgQSAxMTAKQSArIDEKc2V0IEEgMTAxCkEgKyAxCnNldCBBIDMyCkEgKyAxCnNldCBBIDY1CkEgKyAxCnNldCBBIDMyCkEgKyAxCnNldCBBIDQzCkEgKyAxCnNldCBBIDMyCkEgKyAxCnNldCBBIDQ5CkEgKyAxCnNldCBBIDEwCkEgKyAxCnNldCBBIDY2CkEgKyAxCnNldCBBIDMyCkEgKyAxCnNldCBBIDYxCkEgKyAxCnNldCBBIDMyCkEgKyAxCnNldCBBIDEwMwpBICsgMQpzZXQgQSAxMDEKQSArIDEKc2V0IEEgMTE2CkEgKyAxCnNldCBBIDMyCkEgKyAxCnNldCBBIDY3CkEgKyAxCnNldCBBIDEwCkEgKyAxCnNldCBBIDEwNQpBICsgMQpzZXQgQSAxMDIKQSArIDEKc2V0IEEgMzIKQSArIDEKc2V0IEEgNjYKQSArIDEKc2V0IEEgMzIKQSArIDEKc2V0IEEgNjgKQSArIDEKc2V0IEEgMTAKQSArIDEKc2V0IEEgNzAKQSArIDEKc2V0IEEgMzIKQSArIDEKc2V0IEEgNjEKQSArIDEKc2V0IEEgMzIKQSArIDEKc2V0IEEgNTcKQSArIDEKc2V0IEEgNTcKQSArIDEKc2V0IEEgMTAKQSArIDEKc2V0IEEgNjkKQSArIDEKc2V0IEEgMzIKQSArIDEKc2V0IEEgNjEKQSArIDEKc2V0IEEgMzIKQSArIDEKc2V0IEEgMTAzCkEgKyAxCnNldCBBIDEwMQpBICsgMQpzZXQgQSAxMTYKQSArIDEKc2V0IEEgMzIKQSArIDEKc2V0IEEgNzAKQSArIDEKc2V0IEEgMTAKQSArIDEKc2V0IEEgMTA4CkEgKyAxCnNldCBBIDk4CkEgKyAxCnNldCBBIDEwOApBICsgMQpzZXQgQSA3MQpBICsgMQpzZXQgQSAxMApBICsgMQpzZXQgQSA3MApBICsgMQpzZXQgQSAzMgpBICsgMQpzZXQgQSA0MwpBICsgMQpzZXQgQSAzMgpBICsgMQpzZXQgQSA0OQpBICsgMQpzZXQgQSAxMApBICsgMQpzZXQgQSAxMTIKQSArIDEKc2V0IEEgMTE0CkEgKyAxCnNldCBBIDEwNQpBICsgMQpzZXQgQSAxMTAKQSArIDEKc2V0IEEgMTE2CkEgKyAxCnNldCBBIDY3CkEgKyAxCnNldCBBIDEwNApBICsgMQpzZXQgQSA5NwpBICsgMQpzZXQgQSAxMTQKQSArIDEKc2V0IEEgMzIKQSArIDEKc2V0IEEgNjkKQSArIDEKc2V0IEEgMTAKQSArIDEKc2V0IEEgNjkKQSArIDEKc2V0IEEgMzIKQSArIDEKc2V0IEEgNjEKQSArIDEKc2V0IEEgMzIKQSArIDEKc2V0IEEgMTAzCkEgKyAxCnNldCBBIDEwMQpBICsgMQpzZXQgQSAxMTYKQSArIDEKc2V0IEEgMzIKQSArIDEKc2V0IEEgNzAKQSArIDEKc2V0IEEgMTAKQSArIDEKc2V0IEEgMTA1CkEgKyAxCnNldCBBIDEwMgpBICsgMQpzZXQgQSAzMgpBICsgMQpzZXQgQSA2OQpBICsgMQpzZXQgQSAzMgpBICsgMQpzZXQgQSA3MQpBICsgMQpwcmludExpbmUgQSA9IDk5CkMgPSA5OQpCID0gZ2V0IEMKbGJsRApDICsgMQpwcmludCBzZXQgQSAKcHJpbnRJbnQgQgpwcmludExpbmUgQSArIDEKQiA9IGdldCBDCmlmIEIgRApGID0gOTkKRSA9IGdldCBGCmxibEcKRiArIDEKcHJpbnRDaGFyIEUKRSA9IGdldCBGCmlmIEUgRw&input=)
[Answer]
# [S.I.L.O.S](http://github.com/rjhunjhunwala/S.I.L.O.S), 3057 bytes
```
A = 99
def S set
S A 112
A + 1
S A 114
A + 1
S A 105
A + 1
S A 110
A + 1
S A 116
A + 1
S A 76
A + 1
S A 105
A + 1
S A 110
A + 1
S A 101
A + 1
S A 32
A + 1
S A 65
A + 1
S A 32
A + 1
S A 61
A + 1
S A 32
A + 1
S A 57
A + 1
S A 57
A + 1
S A 10
A + 1
S A 72
A + 1
S A 32
A + 1
S A 61
A + 1
S A 32
A + 1
S A 56
A + 1
S A 51
A + 1
S A 10
A + 1
S A 112
A + 1
S A 114
A + 1
S A 105
A + 1
S A 110
A + 1
S A 116
A + 1
S A 32
A + 1
S A 100
A + 1
S A 101
A + 1
S A 102
A + 1
S A 32
A + 1
S A 10
A + 1
S A 112
A + 1
S A 114
A + 1
S A 105
A + 1
S A 110
A + 1
S A 116
A + 1
S A 67
A + 1
S A 104
A + 1
S A 97
A + 1
S A 114
A + 1
S A 32
A + 1
S A 72
A + 1
S A 10
A + 1
S A 112
A + 1
S A 114
A + 1
S A 105
A + 1
S A 110
A + 1
S A 116
A + 1
S A 76
A + 1
S A 105
A + 1
S A 110
A + 1
S A 101
A + 1
S A 32
A + 1
S A 32
A + 1
S A 83
A + 1
S A 32
A + 1
S A 10
A + 1
S A 67
A + 1
S A 32
A + 1
S A 61
A + 1
S A 32
A + 1
S A 57
A + 1
S A 57
A + 1
S A 10
A + 1
S A 66
A + 1
S A 32
A + 1
S A 61
A + 1
S A 32
A + 1
S A 103
A + 1
S A 101
A + 1
S A 116
A + 1
S A 32
A + 1
S A 67
A + 1
S A 10
A + 1
S A 108
A + 1
S A 98
A + 1
S A 108
A + 1
S A 68
A + 1
S A 10
A + 1
S A 67
A + 1
S A 32
A + 1
S A 43
A + 1
S A 32
A + 1
S A 49
A + 1
S A 10
A + 1
S A 112
A + 1
S A 114
A + 1
S A 105
A + 1
S A 110
A + 1
S A 116
A + 1
S A 67
A + 1
S A 104
A + 1
S A 97
A + 1
S A 114
A + 1
S A 32
A + 1
S A 72
A + 1
S A 10
A + 1
S A 112
A + 1
S A 114
A + 1
S A 105
A + 1
S A 110
A + 1
S A 116
A + 1
S A 32
A + 1
S A 32
A + 1
S A 65
A + 1
S A 32
A + 1
S A 10
A + 1
S A 112
A + 1
S A 114
A + 1
S A 105
A + 1
S A 110
A + 1
S A 116
A + 1
S A 73
A + 1
S A 110
A + 1
S A 116
A + 1
S A 32
A + 1
S A 66
A + 1
S A 10
A + 1
S A 112
A + 1
S A 114
A + 1
S A 105
A + 1
S A 110
A + 1
S A 116
A + 1
S A 76
A + 1
S A 105
A + 1
S A 110
A + 1
S A 101
A + 1
S A 32
A + 1
S A 65
A + 1
S A 32
A + 1
S A 43
A + 1
S A 32
A + 1
S A 49
A + 1
S A 10
A + 1
S A 66
A + 1
S A 32
A + 1
S A 61
A + 1
S A 32
A + 1
S A 103
A + 1
S A 101
A + 1
S A 116
A + 1
S A 32
A + 1
S A 67
A + 1
S A 10
A + 1
S A 105
A + 1
S A 102
A + 1
S A 32
A + 1
S A 66
A + 1
S A 32
A + 1
S A 68
A + 1
S A 10
A + 1
S A 70
A + 1
S A 32
A + 1
S A 61
A + 1
S A 32
A + 1
S A 57
A + 1
S A 57
A + 1
S A 10
A + 1
S A 69
A + 1
S A 32
A + 1
S A 61
A + 1
S A 32
A + 1
S A 103
A + 1
S A 101
A + 1
S A 116
A + 1
S A 32
A + 1
S A 70
A + 1
S A 10
A + 1
S A 108
A + 1
S A 98
A + 1
S A 108
A + 1
S A 71
A + 1
S A 10
A + 1
S A 70
A + 1
S A 32
A + 1
S A 43
A + 1
S A 32
A + 1
S A 49
A + 1
S A 10
A + 1
S A 112
A + 1
S A 114
A + 1
S A 105
A + 1
S A 110
A + 1
S A 116
A + 1
S A 67
A + 1
S A 104
A + 1
S A 97
A + 1
S A 114
A + 1
S A 32
A + 1
S A 69
A + 1
S A 10
A + 1
S A 69
A + 1
S A 32
A + 1
S A 61
A + 1
S A 32
A + 1
S A 103
A + 1
S A 101
A + 1
S A 116
A + 1
S A 32
A + 1
S A 70
A + 1
S A 10
A + 1
S A 105
A + 1
S A 102
A + 1
S A 32
A + 1
S A 69
A + 1
S A 32
A + 1
S A 71
A + 1
printLine A = 99
H = 83
print def
printChar H
printLine  S
C = 99
B = get C
lblD
C + 1
printChar H
print  A
printInt B
printLine A + 1
B = get C
if B D
F = 99
E = get F
lblG
F + 1
printChar E
E = get F
if E G
```
[Try it online!](http://silos.tryitonline.net/#code=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&input=)
I am ashamed to say this took me a while to write even though most of it was generated by another java program. Thanks to @MartinEnder for helping me out. This is the first quine I have ever written. **Credits go to Leaky Nun** for most of the code. I "borrowed his code" which was originally inspired by mine. My answer is similar to his, except it shows the "power" of the preprocessor. Hopefully this approach can be used to golf of bytes if done correctly. The goal was to prevent rewriting the word "set" 100's of times.

**Please check out his [much shorter answer!](https://codegolf.stackexchange.com/a/91283/46918)**
[Answer]
# [‡≤†\_‡≤†](https://codegolf.meta.stackexchange.com/a/7390/41247), 6 bytes
```
‡≤†‡≤†
```
This used to work back when the interpreter was still buggy but that's fixed now. However, you can try it in the [legacy version of the interpreter](http://codepen.io/molarmanful/debug/rxJmqx)!
[Answer]
# [Husk](https://github.com/barbuz/Husk), 8 bytes
```
S+s"S+s"
```
[Try it online!](https://tio.run/##yygtzv7/P1i7WAmE//8HAA "Husk ‚Äì Try It Online")
Husk is a new golfing functional language created by me and [Zgarb](https://chat.stackexchange.com/users/136121). It is based on Haskell, but has an intelligent inferencer that can "guess" the intended meaning of functions used in a program based on their possible types.
### Explanation
This is a quite simple program, composed by just three functions:
`S` is the S combinator from [SKI (typed) combinator calculus](https://en.wikipedia.org/wiki/SKI_combinator_calculus): it takes two functions and a third value as arguments and applies the first function to the value and to the second function applied to that value (in code: `S f g x = f x (g x)`).
This gives us `+"S+s"(s"S+s")`. `s` stands for `show`, the Haskell function to convert something to a string: if show is applied to a string, special characters in the string are escaped and the whole string is wrapped in quotes.
We get then `+"S+s""\"S+s\""`. Here, `+` is string concatenation; it could also be numeric addition, but types wouldn't match so the other meaning is chosen by the inferencer.
Our result is then `"S+s\"S+s\""`, which is a string that gets printed simply as `S+s"S+s"`.
[Answer]
## [Bash](https://www.gnu.org/software/bash/), 48 bytes
```
Q=\';q='echo "Q=\\$Q;q=$Q$q$Q;eval \$q"';eval $q
```
[Try it online!](https://tio.run/##S0oszvj/P9A2Rt260FY9NTkjX0EJyItRCQTyVQJVCoGM1LLEHIUYlUIldQhTpfD/fwA "Bash ‚Äì Try It Online")
[Answer]
# [Reflections](https://thewastl.github.io/Reflections/), 1.81x10375 bytes
Or to be more accurate, `1807915590203341844429305353197790696509566500122529684898152779329215808774024592945687846574319976372141486620602238832625691964826524660034959965005782214063519831844201877682465421716887160572269094496883424760144353885803319534697097696032244637060648462957246689017512125938853808231760363803562240582599050626092031434403199296384297989898483105306069435021718135129945` bytes.
The relevant section of code is:
```
+#::(1   \/  \    /: 5;;\
          >v\>:\/:4#+     +\
     /+#   /   2 /4):_    ~/
     \ _   2:#_/ \  _(5#\ v#_\
         *(2 \;1^    ;;4) :54/
         \/ \    1^X    \_/
```
Where each line is preceeded by `451978897550835461107326338299447674127391625030632421224538194832303952193506148236421961643579994093035371655150559708156422991206631165008739991251445553515879957961050469420616355429221790143067273624220856190036088471450829883674274424008061159265162115739311672254378031484713452057940090950890560145649762656523007858600799824096074497474620776326517358755429533782443` spaces. The amount of spaces is a base 128 encoded version of the second part, with 0 printing all the spaces again.
Edit: H.PWiz points out that the interpreter probably doesn't support this large an integer, so this is all theoretical
### How It Works:
```
+#::(1  Pushes the addition of the x,y coordinates (this is the extremely large number)
        Dupe the number a couple of times and push one of the copies to stack 1
            \
             >
                   Pushes a space to stack 2
            *(2
            \/
             /  \
             >v >:\
        /+#   /   2   Print space number times
        \ _   2:#_/
                #      Pop the extra 0
                \;1^   Switch to stack 1 and start the loop
                   /:4#+      +\
                    /4):_     ~/    Divide the current number by 128
                    \  _(5#\ v      Mod a copy by 128
                   ^      4) :
                           \_/
                             v#_\  If the number is not 0:
                   ^    ;;4) :54/  Print the number and re-enter the loop
                     /: 5;;\
             v\      4             If the number is 0:
                     4             Pop the excess 0
              :            \       And terminate if the divided number is 0
                                   Otherwise return to the space printing loop
              \     1^X
```
Conclusion: Can be golfed pretty easily, but maybe looking for a better encoding algorithm would be best. Unfortunately, there's basically no way to push an arbitrarily large number without going to that coordinate.
[Answer]
# [Brain-Flak](https://github.com/DJMcMayhem/Brain-Flak), 1805 bytes
```
(())(()()()())(())(())(()()())(())(())(()()()())(())(())(()()()())(())(()()())(()())(()()())(())(()()()())(())(())(())(())(())(()())(()()()())(()())(()()())(())(()()()())(())(())(()()()())(())(()()())(()())(())(()()())(()()())(())(())(()()())(())(())(())(())(())(()()()())(())(())(()()())(())(())(())(()()())(()()())(()()()())(())(()()())(()())(())(()()())(())(())(())(())(())(()()())(()()()())(())(()())(())(()()())(()())(()()())(()()()())(())(()()())(())(())(())(())(()()())(()()()())(()())(())(()())(()()())(())(()())(()())(())(())(())(())(())(())(())(()())(())(()()())(())(())(()())(())(())(())(())(()()()())(()())(())(()()())(())(())(()()())(()())(())(()()())(()())(())(())(())(()())(())(())(()()())(()())(()())(()()()()())(()())(()())(()())(()()()())(())(())(()()())(())(())(()()())(()())(())(())(()()())(()())(()())(())(())(()()())(())(())(()())(())(()())(())(()())(())(()())(())(()())(()())(()())(()())(()()()())(())(()())(())(()()())(()())(()())(()()()())(()())(())(())(()())(()()()()())(()()())(())(()())(()())(())(())(())(()()())(())(())(()()()())(())(())(()()()())(())(()()())(()())(()()())(())(()()()())(())(())(()()()())(())(())(())(())(()())(()()()()())(())(())(()())(())(()()())(()())(()())(()())(())(()()()())(())(())(()())(())(()()())(()())(()()())(()()()())(())(()())(())(())(())(()()())(()()()()())(()())(()())(())(()()()())(())(())(())(()())(()()()()())(())(())(()())(())(()()())(())(())(()()())(())(())(()()())(())(())(()())(())(()())(())(()())(())(()())(())(()())(()())(()())(()())(()())(()())(())(()()()())(()()()){<>(((((()()()()()){}){}){}())[()])<>(([{}])()<{({}())<>((({}())[()]))<>}<>{({}<>)<>}{}>)((){[()](<(({}()<(((()()()()()){})(({})({}){})<((([(({})())]({}({}){}(<>)))()){}())>)>))((){()(<{}>)}{}<{({}()<{}>)}>{}({}<{{}}>{})<>)>)}{}){{}({}<>)<>{(<()>)}}<>{({}<>)<>}{}}<>
```
[Try it online!](https://tio.run/##tVNJDsIwDLzzkvjQH0SReEfVQzkgIRAHrlbeHuwYVDWL4wrRhTrjZcYmubzW23O6PtZ7Ss4B0Cs3uO1trTXka9fZdea@yj7Gkq8x7xG9p3F/rajya1HSY2zV0CfaZhzXbk28RHpK@9pqT3um@r7S@u6zlPPZGFu4fZfbmMaTsFgjjZZuW5rqWYz/7X@eeG2nllqtvWtsx86QfnqsrEe7sa9/3VE95fmLPrh8bbIxykPm7GABjpgxLuTz6DKek7YIWkcf2OcD2xgDEyA7nZdIX5EwDk7Y2DsLAJRDCSKB6oGE00@gO9elCp45iOijSJYh53nEyCYpgRwDKDhrQ9LDaKGXjFNKaTq/AQ "Brain-Flak ‚Äì Try It Online")
*-188 bytes by avoiding code duplication*
Like Wheat Wizard's answer, I encode every closing bracket as 1. The assignment of numbers to the four opening brackets is chosen to minimize the total length of the quine:
```
2: ( - 63 instances
3: { - 41 instances
4: < - 24 instances
5: [ -  5 instances
```
The other major improvement over the old version is a shorter way to create the code points for the various bracket types.
The decoder builds the entire quine on the second stack, from the middle outward. Closing brackets that have yet to be used are stored below a 0 on the second stack. Here is a full explanation of an earlier version of the decoder:
```
# For each number n from the encoder:
{
 # Push () on second stack (with the opening bracket on top)
 <>(((((()()()()()){}){}){}())[()])<>
 # Store -n for later
 (([{}])
  # n times
  {<({}())
    # Replace ( with (()
    <>((({}())[()]))<>
  >}{}
  # Add 1 to -n
  ())
  # If n was not 1:
  ((){[()]<
     # Add 1 to 1-n
     (({}())<
       # Using existing 40, push 0, 91, 60, 123, and 40 in that order on first stack
       <>(({})<(([(({})())]((()()()()()){})({}{}({})(<>)))({})()()())>)
     # Push 2-n again
     >)
     # Pop n-2 entries from stack
     {({}()<{}>)}{}
     # Get opening bracket and clear remaining generated brackets
     (({}<{{}}>{})
      (<
        # Add 1 if n was 2; add 2 otherwise
        # This gives us the closing bracket
        ({}(){()(<{}>)}
         # Move second stack (down to the 0) to first stack temporarily and remove the zero
         <<>{({}<>)<>}{}>
        # Push closing bracket
        )
      # Push 0
      >)
     # Push opening bracket
     )
     # Move values back to second stack
     <>{({}<>)<>}
   # Else (i.e., if n = 1):
   >}{})
 {
  # Create temporary zero on first stack
  (<{}>)
  # Move second stack over
  <>{({}<>)<>}
  # Move 0 down one spot
  # If this would put 0 at the very bottom, just remove it
  {}({}{(<()>)})
  # Move second stack values back
  <>{({}<>)<>}}{}
}
# Move to second stack for output
<>
```
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), 18 [bytes](https://codegolf.meta.stackexchange.com/a/9429/43319 "When can APL characters be counted as 1 byte each?")[SBCS](https://github.com/abrudz/SBCS ".dyalog files using a single byte character set")
[@ngn's updated version](https://chat.stackexchange.com/transcript/message/48380903#48380903 "The APL Orchard") of the [classic APL quine](https://codegolf.stackexchange.com/a/70520/43319 "APL, 22 bytes ‚Äì Alex A."), using a modern operator to save four bytes.
```
1‚åΩ,‚ç®9‚ç¥'''1‚åΩ,‚ç®9‚ç¥'''
```
[Try APL!](https://tryapl.org/?a=1%u233D%2C%u23689%u2374%27%27%271%u233D%2C%u23689%u2374%27%27%27&run "tryapl.org/?a=1‚åΩ,‚ç®9‚ç¥'''1‚åΩ,‚ç®9‚ç¥'''")
`'''1‚åΩ,‚ç®9‚ç¥'''`‚ÄÉthe characters `'1‚åΩ,‚ç®9‚ç¥'`
`9‚ç¥`‚ÄÉcyclically **r**eshape to shape 9; `'1‚åΩ,‚ç®9‚ç¥''`
`,‚ç®`‚ÄÉconcatenation selfie; `'1‚åΩ,‚ç®9‚ç¥'''1‚åΩ,‚ç®9‚ç¥''`
`1‚åΩ`‚ÄÉcyclically rotate one character to the left; `1‚åΩ,‚ç®9‚ç¥'''1‚åΩ,‚ç®9‚ç¥'''`
[Answer]
# [Alchemist](https://github.com/bforte/Alchemist), ~~720 657 637~~ 589 bytes
*-68 bytes thanks to Nitrodon!*
```
0n0n->1032277495984410008473317482709082716834303381684254553200866249636990941488983666019900274253616457803823281618684411320510311142825913359041514338427283749993903272329405501755383456706244811330910671378512874952277131061822871205085764018650085866697830216n4+Out_"0n0n->"+Out_n4+nn+n0n
4n0+4n0+n->Out_"n"
n+n+4n0+n0+n0+n0->Out_"+"
n+n+n+4n0+n0+n0->Out_n
4n+4n0+n0->Out_"4"
4n+n+4n0->Out_"\""
4n+n+n+n0+n0+n0->Out_"->"
4n+n+n+n+n0+n0->Out_"\n"
4n+4n+n0->Out_"Out_"
4n+4n+n->Out_"\\"
nn->4n0+4n0+nnn
n0+n4->n
nnn+4n+4n+n4->nn+n00
nnn+0n4->n+n40
n40+0n00+n4->n4+nn
n40+0n+n00->n4+n40
```
[Try it online!](https://tio.run/##XZBZagMxEET/fYz5HQy9q/WTK@QChhCSQAyJHLBz/UxKM7KzwCzqV6Xukh7fnl5f3o/ny7JQo7a/Y1KRUqx6TTMmorSiysVSClXClyPVlFQTKxM3dxX4IsRqaNRK1dgya2pEEAOQFDg1OMxLkqaoYDtn9CmM/Y7JzGyS4pVVvZKxs2GMSZFUZKpVK/IVbK5G7sQFs5HGoxCmW6KVUmWKwlrSWbIfpZ@IFZRTQBjTKL2EEQI4ojvCRy2pJBzN5vvPy8O0Xci0FmCtzQA7azT3F9LqatMOwobGM5R5U35pm9B7DDacNnW0wkEO00Dtf1ckuil/hEObtsY/aP1c4dV2QCwUt3O0tus/299h0VZvt/e6t6IV0lqDojRCSWNLv5eBunkjRsvydfq4HE/tvOyfvwE "Alchemist ‚Äì Try It Online")
Warning, takes far longer than the lifetime of the universe to execute, mostly cause we have to transfer that rather large number on the first line back and forth between multiple atoms repeatedly. [Here's a version](https://tio.run/##tZBbbsMgEEX/vQz/WpYGDLb5yRa6gUhV1VZqpJZUSrr9umBIGj/APMZSHjDD3Ln3vHy@frx/nS7XYQAJsj5QThkF3vWE8o42HaMtFS0XXADrW9J0hHNBiGgBeN8z4K0ggjdENE3fENXnAJQy0lDJqqef63NpdMvxompSVqpQMAmV/qrW@EqWhWqYkv3YTmU6Dz3T0Bq2Zl@yUpfGoq0cS1uSc1Xl6N6ZNI6yNML/pfHnVrw9Oypb6nLPIWWh/1h9UAc5vtXP9V1LwViE8a6q6spAXcGOaC62pB@bCoNBDwkwY@pIQI8UcDvpN/VBn5kRNc8nA48j06Hl2GxwOjofXhtfCMwlliLrMitCS6k1MZfcquCa5LqoW9YhvC7tEvfJOxe4VriX@Nd4FrlX@ZZtrfMu9K30L91eu7HYv3precj6TQNbFrZNhNkIMLJtJcRMqJ0gQyGWwkyF2wo0FmYt1FyMvWCDoRbDTcbZjDAabjXGbKzdKMMxluNMx9uONB5nPdZ8iv3oALER4kOkxUgIEh8lJUxqnKRAKZHSQqXHSgyWFi01XE685ICpEdND5sXMCJoeNSdsbtyswDmR80Lnx84Mnhc9NzxG/GwAuQjyIeBgQACRjwIDBhYOFCAYSHCg4GFBAoODBgsOJh40QFiI8CDhYkIEhYcKExY2LlRgmMhwoeFjQwaHiw4b3h740AFiI8SHuA/GHUDio9wD5h3n8Hv@vp7O8jLUb38) that outputs the first few lines in a reasonable amount of time.
[Here is the encoder](https://tio.run/##ZZHtboIwFIb/cxWkIwukgv3RLJlmhDvYBagxbrLEDQoBNSxEb52957SizgROe57z9ny0dd4UL8NQ/vpBWxya2n/zeZ17HljWwV8IIya@kGQUGU1mKcjGKe9Z8H7Yr9lbihWOP/HhrEvaqtmHfWzzJ59V@REG6@gUQdNuqEZSowl7Ik2T515oI0UXBlL6293R19FZjKCstgy0UYTCrIulDKKr8B5f5MbEKfXXh2fU5oIncUI1dECVqZHbBqdZN42S72pn3EUUmOVRUG7qsMcAX7um3WOqyewHgyVNfsybNp/bvBlmo3X2usiK1XwYjJZ8V8ootCXYATNGAng0Gf2uY1y@h4BF7nMRaSM3MRugHI45pRaEGDqC57PI/M@KjsbIXQCvbBNfEZsLvMiWaAvOOIcxHi06TrExrCU5@ZRKMVTsg8LVCq5yR@heHCKxJVr9AQ) that turns the program into the data section
Everything but the large number on the first line is encoded using these ~~8~~ 9 tokens:
```
0 n + -> " \n Out_ \ 4
```
That's why all the atom names are composed of just `n`,`0` and `4`.
As a bonus, this is now fully deterministic in what order the rules are executed.
### Explanation:
```
Initialise the program
0n0n->        If no n0n atom (note we can't use _-> since _ isn't a token)
      n4+Out_"0n0n->"+Out_n4+nn4+n0n
      NUMn4           Create a really large number of n4 atoms
      +Out_"0n0n->"   Print the leading "0n0n->"
      +Out_n4         Print the really large number
      +nn             Set the nn flag to start getting the next character
      +n0n            And prevent this rule from being called again
Divmod the number by 9 (nn and nnn flag)
nn->4n0+4n0+nnn          Convert the nn flag to 8 n0 atoms and the nnn flag
n0+n4->n                 Convert n4+n0 atoms to an n atom
nnn+4n+4n+n4->nn+n00     When we're out of n0 atoms, move back to the nn flag
                         And increment the number of n00 atoms
nnn+0n4->n+n40           When we're out of n4 atoms, add another n atom and set the n40 flag
Convert the 9 possible states of the n0 and n atoms to a token and output it (nn flag)
n+4n0+4n0->Out_"n"           1n+8n0 -> 'n'
n+n+4n0+n0+n0+n0->Out_"+"    2n+7n0 -> '+'
n+n+n+4n0+n0+n0->Out_n       3n+6n0 -> '0'
4n+4n0+n0->Out_"4"           4n+5n0 -> '4'
4n+n+4n0->Out_"\""           5n+4n0 -> '"'
4n+n+n+n0+n0+n0->Out_"->"    6n+3n0 -> '->'
4n+n+n+n+n0+n0->Out_"\n"     7n+2n0 -> '\n'
4n+4n+n0->Out_"Out_"         8n+1n0 -> 'Out_'
4n+4n+n->Out_"\\"            9n+0n0 -> '\'
Reset (n40 flag)
n40+0nn+n00->n4+n40    Convert all the n00 atoms back to n4 atoms
n40+0n00+n4->n4+nn     Once we're out of n00 atoms set the nn flag to start the divmod
```
[Answer]
# [Brian & Chuck](https://github.com/m-ender/brian-chuck), ~~211 143 138 133 129 98 86~~ 84 bytes
```
?.21@@/BC1@c/@/C1112BC1BB/@c22B2%C@!{<?
!.>.._{<+>>-?>.---?+<+_{<-?>+<<-.+?√ø
```
[Try it online!](https://tio.run/##SyrKTMzTTc4oTc7@/9@ekVHPyNDBQd/J2dChPlnfQd/Z0NDQCMhzctIHChgZORmp8jk71CsyV9vYcynq2enpxVfbaNvZ6drb6enq6tpr22gDBYA8bRsbXT1t@8P7//8HAA "Brian & Chuck ‚Äì Try It Online")
old version:
```
?{<^?_>{_;?_,<_-+_;._;}_^-_;{_^?_z<_>>_->_->_*}_-<_^._=+_->_->_->_-!_	?_;}_^_}<?
!.>.>.>.+>._<.}+>.>.>?<{?_{<-_}<.<+.<-?<{??`?=
```
[Try it online!](https://tio.run/##LYuxDsJADEPVEf6iKyH5gXOTPzkDXUBIDEgsRPftR3tC9uJn@/Z@XF@63j/rs/dI1KAnS/AMqrAYS2NVluRWfUF36vCpUcFqXORPds88xLhMExviOJsPiRthTUYKZDCh28IgBt1BXGLp/Qc "Brian & Chuck ‚Äì Try It Online")
New code. Now the data isn't split into nul separated chunks, but the nul will be pulled through the data.
```
Brian:
?                   start Chuck
.21@@/BC1@c/@/C1112BC1BB/@c22B2%C@!
                    data. This is basically the end of the Brian code and the Chuck code reversed
                    and incremented by four. This must be done because the interpreter tries
                    to run the data, so it must not contain runnable characters
                    ASCII 3 for marking the end of the code section
{<?                 loop the current code portion of Chuck
Chuck:
code 1 (print start of Brian code)
.>..               print the first 3 characters of Brian
code 2 (print the data section)
{<+>>-              increment char left to null and decrement symbol right to null
                    for the first char, this increments the question mark and decrements the
                    ASCII 1. So the question mark can be reused in the end of the Chuck code
?>.                 if it became nul then print the next character
---?+<+             if the character is ASCII 3, then the data section is printed.
                    set it 1, and set the next char to the left 1, too
code 3 (extract code from data)
{<-                 decrement the symbol left to the nul
?>+<<-.             if it became nul then it is the new code section marker, so set the old one 1
                    and print the next character to the left
+?                  if all data was processed, then the pointer can't go further to the left
                    so the char 255 is printed. If you add 1, it will be null and the code ends.
√ø                   ASCII 255 that is printed when the end of the data is reached
```
[Answer]
# [Klein](https://github.com/Wheatwizard/Klein), 330 bytes
```
"![	.;	=90*/[	.9(#;	=[>[.	>1#	98='9[	'7[.>;	[*;	)	=#0,*[	=.>9(.	=*(#(#([	.0#8;#(#;	[*9>[;	=> [*?	[9(;;"\
/																																																																																<
>:1+0\
 /:)$<
>\?\ /
?2 $
:9>(:\
(8\/?<
\+ <
 *
 >$1-+\
>/?:) /
 >+)$)$)\
/1$9<$)$<
\+:?\<
>?!\+@
\:)<<
```
[Try it online!](https://tio.run/##vc5NbgMhDAXgtX0JSEAKAw0w3XT4GdOew952UbXK/XeEXKJ@qyc9ffLv3/fPY87rhSE2OEv2iUHF4sxqTKwi0K4MlOO8FYbbB0dqwF41UBuo0@Q3z3BGKm5N1emdWVlYNkczL4V9IV4YafYDuLjWroIJ/vU6Ut1DFtSpbnY1GaITjndtsRZyVdAdkkZHCbqj9qjJ7vcgSGnUbU01hc2urNd3W7p9KRLqkIWNi4RPlLr1jnPOPed5/3oC "Klein ‚Äì Try It Online")
This works in all topologies, mostly by completely avoiding wrapping. The first list encodes the rest of the program offset by one, so newlines are the unprintable  (11).
[Answer]
# [ed(1)](https://kidneybone.com/c2/wiki/EdIsTheStandardTextEditor), 45 bytes
We have quines for `TECO`, `Vim`, and `sed`, but not the almighty `ed`?! This travesty shall not stand. (NB: See also, this [error quine](https://codegolf.stackexchange.com/a/36286/15940) for `ed`)
[Try it Online!](https://tio.run/##S035/z@RK5FLh0unxJBLRdekWF9HX0@fS6eAK5BLD4vg//8A)
```
a
a
,
,t1
$-4s/,/./
,p
Q
.
,t1
$-4s/,/./
,p
Q
```
Stolen from [here](https://github.com/tpenguinltg/ed1-quine/blob/master/quine.ed). It should be saved as a file `quine.ed` then run as follows: (TIO seems to work a bit differently)
```
$ ed < quine.ed
```
[Answer]
# [Grok](https://github.com/AMiller42/Grok-Language), 42 bytes
```
iIilWY!}I96PWwI10WwwwIkWwwwIhWq``
   k   h
```
[Try it Online!](http://grok.pythonanywhere.com?flags=&code=iIilWY!%7DI96PWwI10WwwwIkWwwwIhWq%60%60%0A%20%20%20k%20%20%20h&inputs=)
It is very costly to output anything in Grok it seems.
[Answer]
# [!@#$%^&\*()\_+](https://github.com/ConorOBrien-Foxx/ecndpcaalrlp), ~~1128~~ ~~1116~~ ~~1069~~ ~~960~~ ~~877~~ ~~844~~ ~~540~~ ~~477~~ ~~407~~ ~~383~~ 33 bytes
**Edit**: Woah... -304 B with space
**Edit 2**: Bruh.
**Edit 3**: Thanks Jo King for the idea! I outgolfed ya!
A stack-based language(The first on TIO's list!)
It's a big pile of unprintables though
```
N0N  (!&+$*)^(!&@^)!
```
(Spaces are `NUL` bytes)
[Try it online!](https://tio.run/##S03OSylITkzMKcop@P9f0s9ATFDCT1JKRJoByGAQ0FBUE9BW0dKMAzIc4jQV//8HAA)
Here's the code, but in Control Pictures form:
```
‚êôN0‚êñ‚êë‚êòN‚êô‚êö‚êî‚êõ‚êÄ‚êñ‚êë‚êò‚êÄ‚êê(!&‚êê+$*)^(!&@^)!
```
## Explanation
```
‚êôN0‚êñ‚êë‚êòN‚êô‚êö‚êî‚êõ‚êÄ‚êñ‚êë‚êò‚êÄ‚êê                 Data
                 (!&‚êê+$*)         Push the stack, reversed and +16 back on top
                         ^(!&@^)! Print everything reversed, including the length (Hence the final `!`)
```
It does error on overflow though...
[Answer]
# Commodore Basic, ~~54~~ 41 characters
```
1R‚îÄA$:?A$C|(34)A$:D‚ô†"1R‚îÄA$:?A$C|(34)A$:D‚ô†
```
Based on DLosc's QBasic quine, but modified to take advantage of Commodore Basic's shortcut forms. In particular, the shorter version of `CHR$(34)` makes using it directly for quotation marks more efficient than defining it as a variable.
As usual, I've made substitutions for PETSCII characters that don't appear in Unicode: `‚ô†` = `SHIFT+A`, `‚îÄ` = `SHIFT+E`, `|` = `SHIFT+H`.
**Edit:** You know what? If a string literal ends at the end of a line, the Commodore Basic interpreter will let you leave out the trailing quotation mark. Golfed off 13 characters.
Alternatively, if you want to skirt the spirit of the rules,
```
1 LIST
```
`LIST` is an instruction that prints the current program's code. It is intended for use in immediate mode, but like all immediate-mode commands, it can be used in a program (eg. `1 NEW` is a self-deleting program). Nothing shorter is possible: dropped spaces or abbreviated forms get expanded by the interpreter and displayed at full length.
[Answer]
# Jolf, 4 bytes
```
Q¬´Q¬´
Q    double (string)
 ¬´   begin matched string
  Q¬´ capture that
```
This transpiles to `square(`Q¬´`)` (I accidentally did string doubling in the `square` function), which evaluates to `Q¬´Q¬´`. Note that `q` is the quining function in Jolf, *not* `Q` ;).
[Answer]
# [Vitsy](https://github.com/VTCAKAVSMoACE/Vitsy), ~~11~~ ~~9~~ ~~8~~ 6 Bytes
This programming language was obviously made past the date of release for this question, but I thought I'd post an answer so I can a) get more used to it and b) figure out what else needed to be implemented.
```
'rd3*Z
```
The explanation is as follows:
```
'rd3*Z
'           Start recording as a string.
(wraps around once, capturing all the items)
'           Stop recording as a string. We now have everything recorded but the original ".
 r          Reverse the stack
  b3*       This equates the number 39 = 13*3 (in ASCII, ')
     Z      Output the entire stack.
```
[Answer]
# Fuzzy Octo Guacamole, 4 bytes
```
_UNK
```
I am not kidding. Due to a suggestion by @ConorO'Brien, `K` prints `_UNK`. The `_UN` does nothing really, but actually sets the temp var to `0`, pushes `0`, and pushes `None`.
The `K` prints "\_UNK", and that is our quine.
[Answer]
# C++, ~~286~~ ~~284~~ 236 bytes
Now with extra golf!
```
#include<iostream>
int main(){char a[]="#include<iostream>%sint main(){char a[]=%s%s%s,b[]=%s%s%s%s,c[]=%s%sn%s,d[]=%s%s%s%s;printf(a,c,b,a,b,b,d,b,b,b,d,b,b,d,d,b);}",b[]="\"",c[]="\n",d[]="\\";printf(a,c,b,a,b,b,d,b,b,b,d,b,b,d,d,b);}
```
I'm currently learning C++, and thought "Hey, I should make a quine in it to see how much I know!" 40 minutes later, I have this, a full ~~64~~ **114** bytes shorter than [the current one](https://codegolf.stackexchange.com/questions/69/golf-you-a-quine-for-great-good/2431#2431). I compiled it as:
```
g++ quine.cpp
```
Output and running:
```
C:\Users\Conor O'Brien\Documents\Programming\cpp
Œª g++ quine.cpp & a
#include<iostream>
int main(){char a[]="#include<iostream>%sint main(){char a[]=%s%s%s,b[]=%s%s%s%s,c[]=%s%sn%s,d[]=%s%s%s%s;printf(a,c,b,a,b,b,d,b,b,b,d,b,b,d,d,b);}",b[]="\"",c[]="\n",d[]="\\";printf(a,c,b,a,b,b,d,b,b,b,d,b,b,d,d,b);}
```
[Answer]
# [Cheddar](https://github.com/cheddar-lang/Cheddar), 56 bytes
```
var a='var a=%s;print a%@"39+a+@"39';print a%@"39+a+@"39
```
[**Try it online!**](http://cheddar.tryitonline.net/#code=dmFyIGE9J3ZhciBhPSVzO3ByaW50IGElQCIzOSthK0AiMzknO3ByaW50IGElQCIzOSthK0AiMzk&input=)
I felt like trying to make something in Cheddar today, and this is what appeared...
[Answer]
# 05AB1E, ~~16~~ 17 bytes
```
"34√ßs¬´DJ"34√ßs¬´DJ
```
With trailing newline.
[Try it online!](http://05ab1e.tryitonline.net/#code=IjM0w6dzwqtESiIzNMOnc8KrREoK&input=)
**Explanation:**
```
"34√ßs¬´DJ"        # push string
         34√ß     # push "
            s¬´   # swap and concatenate
              DJ # duplicate and concatenate
```
[Answer]
# [05AB1E](http://github.com/Adriandmen/05AB1E), 19 bytes
*Thanks to @Oliver for a correction (trailing newline)*
```
"D34√ß.√∏sJ"D34√ß.√∏sJ
```
There is a trailing newline.
[Try it online!](http://05ab1e.tryitonline.net/#code=IkQzNMOnLsO4c0oiRDM0w6cuw7hzSgo&input=)
```
"D34√ß.√∏sJ"             Push this string
          D            Duplicate
           34          Push 34 (ASCII for double quote mark)
             √ß         Convert to char
              .√∏       Surround the string with quotes
                s      Swap
                 J     Join. Implicitly display
```
[Answer]
# Clojure, 91 bytes
```
((fn [x] (list x (list (quote quote) x))) (quote (fn [x] (list x (list (quote quote) x)))))
```
[Answer]
# Mathematica, 68 bytes
```
Print[#<>ToString[#,InputForm]]&@"Print[#<>ToString[#,InputForm]]&@"
```
]


[Question]
      [
## Challenge
Given a list of numbers, calculate the population standard deviation of the list.
Use the following equation to calculate population standard deviation:
![](https://upload.wikimedia.org/math/3/1/8/31830fa1f2f922edf6079209a51f8967.png)
## Input
The input will a list of integers in any format (list, string, etc.). Some examples:
```
56,54,89,87
67,54,86,67
```
The numbers will always be integers.
Input will be to STDIN or function arguments.
## Output
The output must be a floating point number.
## Rules
You may use built in functions to find the standard deviation.
Your answer can be either a full program or a function.
## Examples
```
10035, 436844, 42463, 44774 => 175656.78441352615
45,67,32,98,11,3 => 32.530327730015607
1,1,1,1,1,1 => 0.0
```
## Winning
The shortest program or function wins.
## Leaderboard
```
var QUESTION_ID=60901,OVERRIDE_USER=30525;function answersUrl(e){return"http://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"http://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;
```
```
body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}
```
```
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>
```

[Answer]
# [Clip](https://esolangs.org/wiki/Clip), 3
```
.sk
```
`.s` is the standard deviation, `k` parses the input in the form `{1,2,3}`.
[Answer]
# Mathematica, ~~24~~ 22 bytes
Nice, Mathematica has a built-in `StandardDevi...` oh... that computes the sample standard deviation, not the population standard deviation.
But what if we use `Variance`... oh... same deal.
But there is yet another related built-in:
```
CentralMoment[#,2]^.5&
```
Yay. :)
This also works for 22 bytes:
```
Mean[(#-Mean@#)^2]^.5&
```
And this for 27:
```
N@RootMeanSquare[#-Mean@#]&
```
[Answer]
# Octave, 14 bytes
```
g=@(a)std(a,1)
```
Try it on [ideone](http://ideone.com/noczhf).
[Answer]
# [kdb+](http://kx.com/software-download.php), 3 bytes
```
dev
```
One of the APL derviates *had to* have this as a built-in.
### Test run
```
q)dev 56, 54, 89, 87
16.53028
q)f:dev
q)f 10035, 436844, 42463, 44774
175656.8
q)f 45,67,32,98,11,3
32.53033
```
[Answer]
# Dyalog APL, ~~24~~ ~~23~~ ~~21~~ ~~20~~ ~~19~~ 17 bytes
```
*∘.5∘M×⍨-M×M←+/÷≢
```
This defines an unnamed, monadic function train, which is equivalent to the following function.
```
{.5*⍨M(×⍨⍵)-M⍵×(M←{(+/⍵)÷≢⍵})⍵}
```
Try them online on [TryAPL](http://tryapl.org/?a=%28%20%28*%u2218.5%u2218M%D7%u2368-M%D7M%u2190+/%F7%u2262%29%20%2C%20%7B.5*%u2368M%28%D7%u2368%u2375%29-M%u2375%D7%28M%u2190%7B%28+/%u2375%29%F7%u2262%u2375%7D%29%u2375%7D%20%29%2056%2054%2089%2087&run).
### How it works
The code consists of several trains.
```
M←+/÷≢
```
This defines a monadic 3-train (fork) `M` that executes `+/` (sum of all elements) and `≢` (length) for the right argument, then applies `÷` (division) to the results, returning the arithmetic mean of the input.
```
M×M
```
This is another fork that applies `M` to the right argument, repeats this a second time, and applies `×` (product) to the results, returning **μ2**.
```
×⍨-(M×M)
```
This is yet another fork that calculates the square of the arithmetic mean as explained before, applies `×⍨` (product with itself) to the right argument, and finally applies `-` (difference) to the results.
For input **(x1, …, xN)**, this function returns **(x1 - μ2, …, xN - μ2)**.
```
*∘.5∘M
```
This composed function is applies `M` to its right argument, then `*∘.5`. The latter uses right argument currying to apply map input `a` to `a*0.5` (square root of `a`).
```
(*∘.5∘M)(×⍨-(M×M))
```
Finally, we have this monadic 2-train (atop), which applies the right function first, then the left to its result, calculating the standard deviation as follows.
[![formula](https://i.stack.imgur.com/GH3oK.png)](https://i.stack.imgur.com/GH3oK.png)
[Answer]
# R, ~~41~~ ~~40~~ ~~39~~ ~~36~~ ~~30~~ 28 bytes
### code
Thanks to [beaker](https://codegolf.stackexchange.com/users/42892/beaker), [Alex A.](https://codegolf.stackexchange.com/users/20469/alex-a) and [MickyT](https://codegolf.stackexchange.com/users/31347/mickyt) for much bytes.
```
cat(sd(c(v=scan(),mean(v))))
```
### old codes
```
v=scan();n=length(v);sd(v)/(n/(n-1))**0.5
m=scan();cat(sqrt(sum(mean((m-mean(m))^2))))
m=scan();cat(mean((m-mean(m))^2)^.5)
```
This should yield the population standard deviation.
[Answer]
# Julia, ~~26~~ 19 bytes
```
x->std([x;mean(x)])
```
This creates an unnamed function that accepts an array and returns a float.
Ungolfed, I guess:
```
function f(x::Array{Int,1})
    # Return the sample standard deviation (denominator N-1) of
    # the input with the mean of the input appended to the end.
    # This corrects the denominator to N without affecting the
    # mean.
    std([x; mean(x)])
end
```
[Answer]
# Pyth, ~~20~~ ~~19~~ ~~17~~ 13 bytes
```
@.O^R2-R.OQQ2
```
*Thanks to @FryAmTheEggman for golfing off 4 bytes!*
[Try it online.](https://pyth.herokuapp.com/?code=%40.O%5ER2-R.OQQ2&input=56%2C54%2C89%2C87)
### How it works
```
        .OQ    Compute the arithmetic mean of the input (Q).
      -R   Q   Subtract the arithmetic mean of all elements of Q.
   ^R2         Square each resulting difference.
 .O            Compute the arithmetic mean of the squared differences.
@           2  Apply square root.
```
[Answer]
# CJam, ~~24~~ ~~22~~ 21 bytes
```
q~_,_@_:+d@/f-:mh\mq/
```
*Thanks to @aditsu for golfing off 1 byte!*
Try it online in the [CJam interpreter](http://cjam.aditsu.net/#code=q~_%2C_%40_%3A%2Bd%40%2Ff-%3Amh%5Cmq%2F&input=%5B56%2054%2089%2087%5D).
### How it works
```
q~                    e# Read all input and evaluate it.
  _,                  e# Copy the array and push its length.
    _@                e# Copy the length and rotate the array on top.
      _:+d            e# Copy the array and compute its sum. Cast to Double.
          @/          e# Rotate the length on top and divide the sum by it.
            f-        e# Subtract the result (μ) from the array's elements.
              :mh     e# Reduce by hypotenuse.
                      e# a b mh -> sqrt(a^2 + b^2)
                      e# sqrt(a^2 + b^2) c mh -> sqrt(sqrt(a^2 + b^2)^2 + c^2)
                      e#                           = sqrt(a^2 + b^2 + c^2)
                      e# ⋮
                 \mq/ e# Divide the result by the square root of the length.
```
[Answer]
# APL, 24 bytes
```
{.5*⍨+/(2*⍨⍵-+/⍵÷≢⍵)÷≢⍵}
```
A little different approach than [Dennis' Dyalog APL solution](https://codegolf.stackexchange.com/a/60913/20469). This should work with any APL implementation.
This creates an unnamed monadic function that computes the vector (*x* - *µ*)2 as `2*⍨⍵-+/⍵÷≢⍵`, divides this by *N* (`÷≢⍵`), takes the sum of this vector using `+/`, and then takes the square root (`.5*⍨`).
[Try it online](http://tryapl.org/?a=%7B.5*%u2368+/%282*%u2368%u2375-+/%u2375%F7%u2262%u2375%29%F7%u2262%u2375%7D%2045%2067%2032%2098%2011%203&run)
[Answer]
# TI-BASIC, 7 bytes
```
stdDev(augment(Ans,{mean(Ans
```
I borrowed the algorithm to get population standard deviation from sample standard deviation from [here](http://tibasicdev.wikidot.com/stddev).
The shortest solution I could find without `augment(` is 9 bytes:
```
stdDev(Ans√(1-1/dim(Ans
```
[Answer]
# Haskell, 61 bytes
```
d n=1/sum(n>>[1])
f a=sqrt$d a*sum(map((^2).(-)(d a*sum a))a)
```
Straightforward, except maybe my custom length function `sum(n>>[1])` to trick Haskell's strict type system.
[Answer]
# Python 3.4+, 30 bytes
```
from statistics import*;pstdev
```
Imports the builtin function `pstdev`, e.g.
```
>>> pstdev([56,54,89,87])
16.53027525481654
```
[Answer]
# [Jelly](http://github.com/DennisMitchell/jelly)
**11 bytes**
```
S÷L
Ç²_²ÇN½
```
This is a direct translation of [my APL answer](https://codegolf.stackexchange.com/a/60913) to Jelly. [Try it online!](http://jelly.tryitonline.net/#code=U8O3TArDh8KyX8Kyw4dOwr0&input=&args=NDUsNjcsMzIsOTgsMTEsMw)
### How it works
```
S÷L        Helper link. Argument: z (vector)
S          Compute the sum of z.
  L        Compute the length of z.
 ÷         Divide the former by the latter.
           This computes the mean of z.
Ç²_²ÇN½    Main link. Argument: z (vector)
Ç          Apply the previous link, i.e., compute the mean of z.
 ²         Square the mean.
   ²       Square all number in z.
  _        Subtract each squared number from the squared mean.
    Ç      Take the mean of the resulting vector.
     N     Multiply it by -1.
      ½    Take the square root of the result.
```
[Answer]
# Prolog (SWI), 119 bytes
**Code:**
```
q(U,X,A):-A is(X-U)^2.
p(L):-sumlist(L,S),length(L,I),U is S/I,maplist(q(U),L,A),sumlist(A,B),C is sqrt(B/I),write(C).
```
**Explanation:**
```
q(U,X,A):-A is(X-U)^2.   % calc squared difference of X and U
p(L):-sumlist(L,S),      % sum input list
      length(L,I),       % length of input list
      U is S/I,          % set U to the mean value of input list
      maplist(q(U),L,A), % set A to the list of squared differences of input and mean
      sumlist(A,B),      % sum squared differences list
      C is sqrt(B/I),    % divide sum of squares by length of list
      write(C).          % print answer
```
**Example:**
```
p([10035, 436844, 42463, 44774]).
175656.78441352615
```
Try it out online [here](http://swish.swi-prolog.org/p/dzwqjuYT.pl)
[Answer]
# J, 18 bytes
```
[:%:@M*:-M*M=:+/%#
```
This is a direct translation of [my APL answer](https://codegolf.stackexchange.com/a/60913) to J.
[Try it online!](https://tio.run/nexus/j#@5@mYGulEG2lauXgq2Wl66vla2ulra@q/D81OSNfIU3BxFTBzFzB2EjB0kLB0FDB@D8A "J – TIO Nexus")
[Answer]
# [Haskell](https://www.haskell.org/), 45 bytes
```
(?)i=sum.map(^i)
f l=sqrt$2?l/0?l-(1?l/0?l)^2
```
[Try it online!](https://tio.run/##y0gszk7Nyfn/X8NeM9O2uDRXLzexQCMuU5MrTSHHtriwqETFyD5H38A@R1fDEMLQjDP6n5uYmadgq1BQlJlXoqCikKYQbWKqY2auY2ykY2mhY2ioYxz7/19yWk5ievF/3eSCAgA "Haskell – Try It Online")
The value `i?l` is the sum of the i'th powers of elements in `l`, so that `0?l` is the length and `1?l` is the sum.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), ~~10~~ 7 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
ÅA-nÅAt
```
-3 bytes thanks to *@ovs*.
[Try it online](https://tio.run/##yy9OTMpM/f//cKujbh6QKPn/P9rCWMfQ0EzH0hxMGRqaxgIA) or [verify all test cases](https://tio.run/##yy9OTMpM/V9Waa@k8KhtkoKSfaXL/8Otjrp5QKLkv87/6GhDAwNjUx0TYzMLExMdEyMTM2MdExNzc5NYnWgTUx0zcx1jIx1LCx1DQx1joJChDhzGxgIA).
**Explanation:**
```
ÅA       # Get the arithmetic mean of the (implicit) input-list
  -      # Subtract it from each value in the (implicit) input-list
   n     # Square each of those
    ÅA   # Take the arithmetic mean of that
      t  # And take the square-root of that
         # (after which it is output implicitly as result)
```
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), 16 bytes
```
⟨∋-⟨+/l⟩⟩ᶠ^₂ᵐ↰₂√
```
[Try it online!](https://tio.run/##SypKTM6ozMlPN/r//9H8FY86unWBlLZ@zqP5K4Ho4bYFcY@amh5unfCobQOQ8ahj1v//0YYGBsamOgomxmYWJiZA2sjEzBhImZibm8T@jwIA "Brachylog – Try It Online") [(all cases at once)](https://tio.run/##SypKTM6ozMlPN/pfXa6koGunoFRu/6htw6Ompoe7Omsfbp3w/9H8FY86unWBlLZ@zqP5K4Ho4bYFcSAVWyeAlbY86pj1/390tKGBgbGpjoKJsZmFiQmQNjIxMwZSJubmJrE6CtEmpjpm5jrGRjqWFjqGhjrGIDFDHTgEcU3NdExNdCwsdSzMQVygchDXDKgvNhYA "Brachylog – Try It Online")
I feel like *maybe* there's some shorter way to compute the squared deviations than 13 bytes.
[Answer]
# [Arn](https://github.com/ZippyMagician/Arn), [~~19~~ ~~18~~ 14 bytes](https://github.com/ZippyMagician/Arn/wiki/Carn)
```
¯‡iʠØbmÅQƥªÈªÆ
```
[Try it!](https://zippymagician.github.io/Arn?code=Oi9tZWFuKG57OipuLW1lYW46c31c&input=MTAwMzUgNDM2ODQ0IDQyNDYzIDQ0Nzc0CjQ1IDY3IDMyIDk4IDExIDMKMSAxIDEgMSAxIDE=)
# Explained
Unpacked: `:/mean(n{:*n-mean:s}\`
```
:/                      Square root
  mean                  Mean function
    (                   Begin expression
        n{              Block with key of n
          :*            Square
              n
            -           Subtraction
              mean
                    _   Variable initialized to STDIN; implied
                  :s    Split on spaces
         }              End of block
       \                Mapped over
         _              Implied
    )                   End of expression; Implied
```
[Answer]
# [Simplex v.0.5](http://conorobrien-foxx.github.io/Simplex/), 43 bytes
Just 'cuz. I really need to golf this one more byte.
```
t[@u@RvR]lR1RD@wA@T@{j@@SR2ERpR}u@vR@TR1UEo
t[      ]                                     ~~ Applies inner function to entire strip (left-to-right)
  @                                           ~~ Copies current value to register
   u                                          ~~ Goes up a strip level
    @                                         ~~ Dumps the register on the current byte
     R                                        ~~ Proceeds right (s1)
      v                                       ~~ Goes back down
       R                                      ~~ Proceeds right (s0)
                                              ~~ Go right until an empty byte is found
         lR1RD                                ~~ Push length, 1, and divide.
              @                               ~~ Store result in register (1/N)
               wA                             ~~ Applies A (add) to each byte, (right-to-left)
                 @T@                          ~~ Puts 1/N down, multiplies it, and copies it to the register
                    {          }              ~~ Repeats until a zero-byte is met
                     j@@                      ~~ inserts a new byte and places register on it
                        SR                    ~~ Subtract it from the current byte and moves right
                          2E                  ~~ Squares result
                            RpR               ~~ Moves to the recently-created cell, deletes it, and continues
                                u@v           ~~ takes 1/N again into register
                                   R@T        ~~ multiplies it by the new sum
                                      R1UE    ~~ takes the square root of previous
                                          o   ~~ output as number
```
[Answer]
# JavaScript (ES6), 73 bytes
```
a=>Math.sqrt(a.reduce((b,c)=>b+(d=c-eval(a.join`+`)/(l=a.length))*d,0)/l)
```
[Answer]
# Perl5, ~~39~~ 38
---
 16 for the script
+22 for the `M` switch
+ 1 for the `E` switch
```
perl -MStatistics::Lite=:all -E"say stddevp@ARGV" .1 .2 300
```
Tested in Strawberry 5.20.2.
---
Oh, but then I realized that you said our answers can be functions instead of programs. In that case,
```
{use Statistics::Lite":all";stddevp@_}
```
has just 38. Tested in Strawberry 5.20.2 as
```
print sub{use Statistics::Lite":all";stddevp@_}->( .1, .2, 300)
```
[Answer]
# [MathGolf](https://github.com/maxbergmark/mathgolf/blob/master/math_golf.txt), ~~10~~ 7 [bytes](https://github.com/maxbergmark/mathgolf/blob/master/code_page.py)
```
ë_▓-²▓√
```
Port of [my 05AB1E answer](https://codegolf.stackexchange.com/a/210034/52210).
[Try it online.](https://tio.run/##y00syUjPz0n7///w6vhH0ybrHtoEJB91zPr/39DAwNhUwcTYzMLERMHEyMTMWMHExNzchMvEVMHMXMHYSMHSQsHQUMGYy1ABDgE)
**Explanation:**
```
ë        # Read all inputs as float-list
 _       # Duplicate that list
  ▓      # Get the average of that list
   -     # Subtract that average from each value in the list
    ²    # Square each value
     ▓   # Take the average of that again
      √  # And take the square root of that
         # (after which the entire stack joined together is output implicitly as result)
```
[Answer]
# [Whispers v2](https://github.com/cairdcoinheringaahing/Whispers), 105 bytes
```
> Input
>> #1
>> ∑1
>> 3÷2
>> L-4
>> L²
>> Each 5 1
>> Each 6 7
>> ∑8
>> 9÷2
>> √10
>> Output 11
```
[Try it online!](https://tio.run/##K8/ILC5ILSo2@v/fTsEzr6C0hMvOTkHZEEQ@6pgIpo0PbzcC0T66JmDq0CYQ5ZqYnKFgqmAIZ5spmEN1WYBoS6iuRx2zDA1ADP/SEqDxCoaG//9HGxoYGJvqKJgYm1mYmABpIxMzYyBlYm5uEgsA "Whispers v2 – Try It Online")
In the latest version of Whispers, the builtin [`σ`](https://github.com/cairdcoinheringaahing/Whispers/blob/master/whispers%20v3.py#L1474) can be used to shave off around 70 bytes.
## How it works
For those unfamiliar with Whispers, the language works by using numbers as line references in order to pass values between lines. For example, the line `>> 3÷2` doesn't calculate \$3 \div 2\$, rather it takes the values of lines **3** and **2** and calculates their division. Execution always begins on the last line.
This program simply implements the standard formula for standard deviation:
$$\sigma = \sqrt{\frac{1}{N}\sum^N\_{i=1}{(x\_i-\bar{x})^2}}$$
$$\bar{x} = \frac{1}{N}\sum^N\_{i=1}{x\_i}$$
Lines **2**, **3** and **4** define \$\bar{x}\$, with it's specific value accessible on line **4**. Line **2** stores \$N\$. We then calculate \$(x\_i-\bar{x})^2\$ for each \$x\_i \in x\$ with the lines **5**, **6**, **7** and **8**:
```
>> L-4
>> L²
>> Each 5 1
>> Each 6 7
```
Line **7** runs line **5** over each element in the input, which takes the difference between each element in the input and the mean, We then square these differences using lines **8** and **6**. Finally, we take the sum of these squares (line **9**), divide by \$N\$ (line **10**) and take the square root (line **11**). Finally, we output this result.
[Answer]
# [Shasta v0.0.10](https://github.com/jacobofbrooklyn/shasta/tree/d66d19a634eb70bd73feac1972327867a7f0ede4), 65 bytes
```
{(**(/(sum(map${|x|(**(- x(/(sum$)(length$)))2)}))(length$)).5)}
```
Online interpreter not set up yet, tested on my machine
Explanation:
`{...}` Function taking argument $
`(** ... .5)` Square root of
`(/ ... (length $))` Dividing ... by the length of $
`(sum ...)` The sum of
`(map $ {|x| ...})` Mapping each x in $ to
`(** ... 2)` The square of
`(- x ...)` The difference between x and
`(/ (sum $) (length $))` The mean of $
[Answer]
# Python, 57 bytes
```
lambda l:(sum((x-sum(l)/len(l))**2for x in l)/len(l))**.5
```
Takes input as a list
Thanks @xnor
[Answer]
### PowerShell, 122
```
:\>type stddev.ps1
$y=0;$z=$args -split",";$a=($z|?{$_});$c=$a.Count;$a|%{$y+=$_};$b=$y/$c;$a|%{$x+
=(($_-$b)*($_-$b))/$c};[math]::pow($x,0.5)
```
explanation
```
<#
$y=0                            init
$z=$args -split","              split delim ,
$a=($z|? {$_})                  remove empty items
$c=$a.Count                     count items
$a|%{$y+=$_}                    sum
$b=$y/$c                        average
$a|%{$x+=(($_-$b)*($_-$b))/$c}  sum of squares/count
[math]::pow($x,0.5)             result
#>
```
result
```
:\>powershell -nologo -f stddev.ps1 45,67,32,98,11,3
32.5303277300156
:\>powershell -nologo -f stddev.ps1 45,  67,32,98,11,3
32.5303277300156
:\>powershell -nologo -f stddev.ps1 45,  67,32, 98 ,11,3
32.5303277300156
:\>powershell -nologo -f stddev.ps1 10035, 436844, 42463, 44774
175656.784413526
:\>powershell -nologo -f stddev.ps1 1,1,1,1,1,1
0
```
[Answer]
# Fortran, 138 bytes
Just a straightforward implementation of the equation in Fortran:
```
double precision function std(x)
integer,dimension(:),intent(in) :: x
std = norm2(dble(x-sum(x)/size(x)))/sqrt(dble(size(x)))
end function
```
[Answer]
# SmileBASIC, 105 bytes (as a function)
I just noticed it's allowed to be a function. Whoops, that reduces my answer dramatically. This defines a function `S` which takes an array and returns the population standard deviation. Go read the other one for an explanation, but skip the parsing part. I don't want to do it again.
```
DEF S(L)N=LEN(L)FOR I=0TO N-1U=U+L[I]NEXT
U=1/N*U FOR I=0TO N-1T=T+POW(L[I]-U,2)NEXT RETURN SQR(1/N*T)END
```
## As a program, 212 bytes
Unfortunately, I have to take the input list as a string and parse it myself. This adds over 100 bytes to the answer, so if some input format other than a comma-separated list is allowed I'd be glad to hear it. Also note that because `VAL` is buggy, having a space *before* the comma or trailing the string breaks the program. After the comma or at the start of the string is fine.
```
DIM L[0]LINPUT L$@L I=INSTR(O,L$,",")IF I>-1THEN PUSH L,VAL(MID$(L$,O,I-O))O=I+1GOTO@L ELSE PUSH L,VAL(MID$(L$,O,LEN(L$)-O))
N=LEN(L)FOR I=0TO N-1U=U+L[I]NEXT
U=1/N*U FOR I=0TO N-1T=T+POW(L[I]-U,2)NEXT?SQR(1/N*T)
```
Ungolfed and explained:
```
DIM L[0]  'define our array
LINPUT L$ 'grab string from input
'parse list
'could've used something cleaner, like a REPEAT, but this was shorter
@L
I=INSTR(O,L$,",")                 'find next comma
IF I>-1 THEN                      'we have a comma
 PUSH L,VAL(MID$(L$,O,I-O))       'get substring of number, parse & store
 O=I+1                            'set next search location
 GOTO @L                          'go again
ELSE                              'we don't have a comma
 PUSH L,VAL(MID$(L$,O,LEN(L$)-O)) 'eat rest of string, parse & store
ENDIF                             'end
N=LEN(L) 'how many numbers we have
'find U
'sum all of the numbers, mult by 1/N
FOR I=0 TO N-1
 U=U+L[I]
NEXT
U=1/N*U
'calculate our popstdev
'sum(pow(x-u,2))
FOR I=0 TO N-1
 T=T+POW(L[I]-U,2)
NEXT
PRINT SQR(1/N*T) 'sqrt(1/n*sum)
```
]