[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, 231-255 = -24 bytes
### -24\*10 extra animals, -15 for no "cat" string
```
pzI}zJv.Z"x√ö]Ar√É E¬Ø√¢√±MO√õ|¬∞
√ò¬¢m√û¬Ω`&√âR¬Ø'_√£P√çm1;√±√ù|,F ¬π√óz#¬Ω√∂√Ç√∑√úAP√∫√µMh#√å¬©UOC *C√ë¬∞k%¬π√∂¬¥q√åzj,√•<&{j√†RF√ñ(¬•s    √±`G√Ç:√ßk√¥#√π\M+√ºq√≠√©aw √ëuW6L√£,¬∂w/'87√∂√ó_r]¬¢:jkz¬ª√öF√ô¬¶√àc√Ö√ã√ò√≠√´√ª√ñOa¬ø√û¬µ¬¥6 √∏¬°√£E√æ√æ:"jk(" goes "N@JzN
```
[Link to code](https://pyth.herokuapp.com/?code=pzI%7DzJv.Z%22x%C3%9A%5D%C2%90Ar%C3%83+%0CE%C2%AF%C3%A2%C3%B1%C2%86MO%C2%90%C3%9B%7C%C2%B0%0A%0C%C3%98%C2%A2%12m%16%C2%9D%C3%9E%C2%BD%60%26%C2%89%C3%89R%C2%8F%C2%AF%27%C2%89_%C3%A3P%C3%8Dm1%3B%C3%B1%C3%9D%7C%2CF%09%C2%B9%C3%97%16%C2%92z%C2%9D%23%1F%C2%BD%C3%B6%C3%82%C3%B7%C3%9CA%C2%80P%07%C3%BA%C3%B5Mh%11%23%C3%8C%C2%A9%C2%83%10UOC+*C%C2%81%C3%91%C2%B0k%25%C2%B9%C3%B6%C2%B4q%C3%8Czj%2C%C3%A5%3C%26%7B%C2%81j%C3%A0RF%C3%96%C2%85%28%C2%A5s%09%C3%B1%60G%C3%82%3A%C3%A7k%C3%B4%23%C3%B9%5CM%2B%C3%BC%C2%9Cq%C3%AD%C3%A9%C2%94a%1Cw+%C3%91uW%17%1D6L%C3%A3%2C%C2%B6w%2F%27%C2%948%C2%8B7%C3%B6%C3%97_r%12%5D%C2%A2%3A%C2%89jkz%C2%BB%C3%9AF%C3%99%C2%A6%C2%8C%16%C3%88c%C3%85%07%C3%8B%C3%98%C3%AD%C3%AB%C3%BB%C3%96Oa%C2%BF%C3%9E%C2%96%C2%B5%C2%9D%C2%82%C2%B46+%C3%B8%C2%A1%C3%A3E%C3%BE%C3%BE%01%C2%8E%07%C2%89%3A%22jk%28%22+goes+%22N%40JzN&input=cat&debug=0)
Pseudocode
```
Auto assign z to input
print z
J = decompress animal-sound dict
if z in J:
    print " goes ", J[z], '"'
```
Animals it knows:
```
{'hare': 'squeak', 'seal': 'bark', 'lion': 'growl', 'rook': 'hiss', 'sheep': 'baa', 'hamster': 'squeak', 'moose': 'bellow', 'grasshopper': 'chirp', 'rhinoceros': 'bellow', 'cat': 'meow', 'tiger': 'growl', 'stag': 'bellow', 'crow': 'caw', 'okapi': 'bellow', 'snake': 'hiss', 'cicada': 'chirp', 'badger': 'growl', 'dog': 'bark', 'cricket': 'chirp', 'tapir': 'squeak', 'bird': 'chirp', 'sparrow': 'chirp', 'lamb': 'baa', "frog": "croak", "raven": "croak"}
```
[Answer]
# [TeaScript](https://github.com/vihanb/TeaScript), 29 - 15 = 14 bytes
Doesn't use string `cat`.
```
xr(/^c\at$/,'$& goes "Meow"')
```
"What does the fox say" (length = 21) is longer than the bonus is worth.
[Answer]
# PXLCODE, 114 bytes
I SHOULD GET BONUS BECAUSE THIS IS CAT LANGUAGE RIGHT?
ALSO FEED ME BUTTER
```
HAI 1.3
I HAS A V
GIMMEH V
BOTH SAEM V AN "cat",O RLY?
YA RLY,VISIBLE "cat goes meow"
NO WAI,VISIBLE V
OIC
KTHXBYE
```
[Answer]
# APOL, 34 bytes
`p(¬ø(=(i "cat") "cat goes meow" ‚ãî))`
BEEP BOOP I AM NOT A ROBOT
[Answer]
# CJam, 12 bytes
```
q_:)"dbu"=" goes \"Meow\""*
```
The program is **27 bytes** bytes long and doesn't use the word `cat` (**-15 bytes**).
Try it inline in the [CJam interpreter](http://cjam.aditsu.net/#code=q_%3A)%22dbu%22%3D%22%20goes%20%5C%22Meow%5C%22%22*&input=cat).
### How it works
```
q_                e# Read all input and push a copy.
:)                e# Increment all code points of the copy.
"dbu"=            e# Push 1/0 if the result is/isn't "dbu".
" goes \"Meow\""* e# Repeat the string that many times.
```
[Answer]
# JavaScript, 45 - 15 = 30 / 264 - 235 = 29
```
alert((s=(d='MeowBuzzSongMooMooCawBarkQuackCroakHissOinkBaaSingRoarLowCooCawBarkBaaHissCryRoarSingC\x61tBeeBirdCattleCowCrowDogDuckFrogHorseHogLambLarkLionOxPigeonRookSealSheepSnakeSwanTigerWhale'.split(/(?=[A-Z])/))[d.indexOf(i=prompt())-23])?i+' goes "'+s+'"':i)
```
**Downside: you have to write the name of the animal with the first letter in uppercase and the rest in lowercase. Look below for another version which fixes this.** This version escapes the `a` in cat with `\x61` and includes code for the 22 extra animals from this list (all the allowed animals which had short enough words to be worth it):
> 
> bee buzz 7  
> 
>  bird song 8  
> 
>  cattle moo 9  
> 
>  cow moo 6  
> 
>  crow caw 7  
> 
>  dog bark 7  
> 
>  duck quack 9  
> 
>  frog croak 9  
> 
>  horse hiss 9  
> 
>  hog oink 7  
> 
>  lamb baa 7  
> 
>  lark sing 8  
> 
>  lion roar 8  
> 
>  ox low 5  
> 
>  pigeon coo 9  
> 
>  rook caw 7  
> 
>  seal bark 8  
> 
>  sheep baa 8  
> 
>  snake hiss 9  
> 
>  swan cry 7  
> 
>  tiger roar 9  
> 
>  whale sing 9 
> 
> 
> 
(thanks to my friend for helping me with the tedious task of making this list)
Ungolfed code:
```
data = 'MeowBuzzSongMooMooCawBarkQuackCroakHissOinkBaaSingRoarLowCooCawBarkBaaHissCryRoarSingC\x61tBeeBirdCattleCowCrowDogDuckFrogHorseHogLambLarkLionOxPigeonRookSealSheepSnakeSwanTigerWhale'.split(/(?=[A-Z])/);
input = prompt();
index = data.indexOf(input);
sound = data[index-23];
result = sound ? input + ' goes "' + sound + '"' : input;
alert(result);
```
---
## First version, 45 bytes - 15 bonus = 30
```
alert((i=prompt())=='\x63at'?i+' goes "Meow"':i)
```
Yes, I know. I went from 30 to 29 with ALL that extra work. It was fun!
## Version that allows full lowercase input, 294 bytes - 235 bonus = 59
```
alert((s=(d='MeowBuzzSongMooMooCawBarkQuackCroakHissOinkBaaSingRoarLowCooCawBarkBaaHissCryRoarSingC\x61tBeeBirdCattleCowCrowDogDuckFrogHorseHogLambLarkLionOxPigeonRookSealSheepSnakeSwanTigerWhale'.split(/(?=[A-Z])/))[d.indexOf((i=prompt())[0].toUpperCase()+i.slice(1))-23])?i+' goes "'+s+'"':i)
```
I also tried removing casing from the data array with `.join().toLowerCase().split(',')` but it ended up taking 297 characters instead.
[Answer]
# [APL (Dyalog)](https://www.dyalog.com/), 28 - 15 = 13 bytes
```
{‚çµ,' goes "Meow"'/‚ç®‚çµ‚â°‚åΩ'tac'}
```
Input followed by  `goes "Meow"` if input is equivalent to `tac` reversed.
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///Pzmx5FHbhOpHvVt11BXS81OLFZR8U/PLldT1H/WuAIo@6lz4qGeveklisnotWLWCukdqTk6@jkJ4flFOiqI6F1gMSKgDAA "APL (Dyalog Unicode) ‚Äì Try It Online")
`{`‚Ä¶`}`‚ÄÉanonymous function
‚ÄÉ`‚åΩ'tac'`‚ÄÉreverse the string (to get the -15 bonus by avoiding the characters `cat`)
‚ÄÉ`‚çµ‚â°`‚ÄÉBoolean for whether the argument is identical to that
‚ÄÉ`' goes "Meow"'/‚ç®`‚ÄÉuse that to filter the string (i.e. returns empty string if false)
‚ÄÉ`‚çµ,`‚ÄÉappend to the argument
[Answer]
# [Stack](https://github.com/StackLanguge/stack-language), 51 bytes
```
'' input dup 'cat' = { 'cat goes "meow"' } if print
```
[Answer]
## JavaScript, ~~81 - 20 - 15 = 46 bytes~~ 50 - 15 = 35 bytes
```
(o=prompt()=="ca"+"t")&&o+=' goes "Meow"';alert(o)
```
[Answer]
# Python 3, ~~81~~ ~~70~~ ~~55~~ 46 - 15 = 31 bytes
Thanks to Stewie Griffin for saving 15 bytes
Thanks to grc for saving 8 bytes.
Not using the string `cat` gives -15 bytes.
```
y=input()
print(y+' goes "Meow"'*(y=="ca""t"))
```
[Answer]
## [LOLCODE](https://esolangs.org/wiki/LOLCODE), 100 109 Bytes
```
HAI 1
I HAS A I
GIMMEH I
BOTH SAEM I "cat",O RLY?
YA RLY,VISIBLE "cat goes Meow"
NO WAI,VISIBLE I
OIC
KTHXBYE
```
[Try it out online](https://tio.run/##PYoxCgIxFAX7f4pH6m08gfxI8D/cGDCLmlLWYLOQQsHjx9XCagZmlrbM7V57NyU2QphmKCh7xhhsFZ8mQ9YQQbj59nJDwmksWyn65XBmph/Dr@HR6hOxtreTY8JF@c@UxJ0cJrv6Enpf5w8)
My first post on this platform, as well as my first code-golf challenge and my first code in LOLCODE, so there's probably lots to improve. I tried avoiding the "cat" with casting the equivalent hex-code `":(63):(61):(74)"` instead, but it didn't work out for me. If you know a solution to this, please let me know!
\*+9 Bytes because I didn't read the instructions clear enough
[Answer]
## Pyke, 391 -595 = -204 bytes
-58\*10 extra animals, -15 for no "cat" string
```
"goes"Q.dtõß∑ÂÅÆÊô™ÍÖ¢·Ωêëà∂·Ω•ëà∂Â¢µëà∂ÏÖûëà∂∏£å·≥ô·Ñ∑Ïüø‰Åîî£©ïïÑÊº≤îµ∏ÓØá·¨∞‰µôÍÑ®ÓØáÂ°ãÌäñ¥èµ·Éó·†ûÈÆî‡´™Áàü„çÖÁàü‚º±]Í£üÂãí„Ä•È¥û·´†‚¨ª‰ã•„É•‚£πì´åÈÇ¶¥Ω©„∫ìíÄΩÓëéì´åÂ†öÌÄ¶ÏûìÓØáËôüÊº≤·É•Ô∏Üêä∑‰¶ô·îØÊº≤·†•Ïèî„Å£ÈÆîê©ÅÁâîÈ∂á∆ë‰ÇùÈõ•êª≥‚¨ª‚ØéÂÅÆÁá©Â∑∫Ó©õë≥¶‰Ø•íÄΩÎ¥ΩÈÆîÓø†Ìäñ‚ûí„Çó·®ºì´å‰Ñáì´åÂöïì´å„Æ∑ÈÆèêìß·òΩÊå≥·ñòØÉÆÊº≤ëôåíÄΩÁù¥ÏúøÍí≤‚¨ª¶ºéÈº§„®Ç·òΩdc2cY@]3J
```
[Try it here!](http://pyke.catbus.co.uk/?code=%22goes%22Q.dt%F0%9B%A7%B7%E5%81%AE%E6%99%AA%EA%85%A2%E1%BD%90%F0%91%88%B6%E1%BD%A5%F0%91%88%B6%E5%A2%B5%F0%91%88%B6%EC%85%9E%F0%91%88%B6%F0%B8%A3%8C%E1%B3%99%E1%84%B7%EC%9F%BF%E4%81%94%F0%94%A3%A9%F0%95%95%84%E6%BC%B2%F0%94%B5%B8%EE%AF%87%E1%AC%B0%E4%B5%99%EA%84%A8%EE%AF%87%E5%A1%8B%ED%8A%96%F0%B4%8F%B5%E1%83%97%E1%A0%9E%E9%AE%94%E0%AB%AA%E7%88%9F%E3%8D%85%E7%88%9F%E2%BC%B1%5D%EA%A3%9F%E5%8B%92%E3%80%A5%E9%B4%9E%E1%AB%A0%E2%AC%BB%E4%8B%A5%E3%83%A5%E2%A3%B9%F0%93%AB%8C%E9%82%A6%F0%B4%BD%A9%E3%BA%93%F0%92%80%BD%EE%91%8E%F0%93%AB%8C%E5%A0%9A%ED%80%A6%EC%9E%93%EE%AF%87%E8%99%9F%E6%BC%B2%E1%83%A5%EF%B8%86%F0%90%8A%B7%E4%A6%99%E1%94%AF%E6%BC%B2%E1%A0%A5%EC%8F%94%E3%81%A3%E9%AE%94%F0%90%A9%81%E7%89%94%E9%B6%87%C6%91%E4%82%9D%E9%9B%A5%F0%90%BB%B3%E2%AC%BB%E2%AF%8E%E5%81%AE%E7%87%A9%E5%B7%BA%EE%A9%9B%F0%91%B3%A6%E4%AF%A5%F0%92%80%BD%EB%B4%BD%E9%AE%94%EE%BF%A0%ED%8A%96%E2%9E%92%E3%82%97%E1%A8%BC%F0%93%AB%8C%E4%84%87%F0%93%AB%8C%E5%9A%95%F0%93%AB%8C%E3%AE%B7%E9%AE%8F%F0%90%93%A7%E1%98%BD%E6%8C%B3%E1%96%98%F0%AF%83%AE%E6%BC%B2%F0%91%99%8C%F0%92%80%BD%E7%9D%B4%EC%9C%BF%EA%92%B2%E2%AC%BB%F0%A6%BC%8E%E9%BC%A4%E3%A8%82%E1%98%BDdc2cY%40%5D3J&input=hamsters)
Uses dictionary-based compression to store the words. Pyke is older than the question.
Animals it knows:
```
{'seals': 'bark', 'turkeys': 'gobble', 'mosquitos': 'whine', 'curlews': 'pipe', 'dogs': 'howl', 'sheep': 'bleat', 'elephants': 'trumpet', 'eagles': 'scream', 'raccoons': 'trill', 'goats': 'bleat', 'donkeys': 'bray', 'monkey': 'whoop', 'snakes': 'hiss', 'wolves': 'howl', 'grasshoppers': 'chirp', 'ferrets': 'dook', 'geese': 'honk', 'ducks': 'quack', 'chinchillas': 'squeak', 'oxen': 'low', 'pigs': 'snort', 'lions': 'snarl', 'antelopes': 'snort', 'crows': 'caw', 'hamsters': 'squeak', 'ravens': 'croak', 'leopards': 'snarl', 'tapirs': 'squeak', 'lambs': 'bleat', 'horses': 'neigh', 'jaguars': 'snarl', 'crickets': 'chirp', 'moose': 'bellow', 'cattle': 'moo', 'deer': 'bellow', 'rooks': 'caw', 'dolphins': 'click', 'whales': 'sing', 'owls': 'hoot', 'walruses': 'groan', 'cicadas': 'chirp', 'tigers': 'snarl', 'chickens': 'cluck', 'giraffes': 'bleat', 'mice': 'squeak', 'peacocks': 'scream', 'songbirds': 'sing', 'geckos': 'croak', 'frogs': 'croak', 'pigeons': 'coo', 'swans': 'cry', 'bitterns': 'boom', 'rhinoceros': 'bellow', 'cats': 'purr', 'badgers': 'growl', 'magpies': 'chatter', 'vultures': 'scream', 'elk': 'bleat'}
```
[Answer]
# GNU sed, 37 - 15 = 22 bytes
```
sed -r 's/^(\x63at)$/\1 goes "Meow"/'
```
[Answer]
# MATLAB, 58 - 15 = 43 bytes
Pretty straight forward, with bonus for not using `cat` in the code:
```
x=input('');if isequal(x,'dbu'-1);x=[x ' goes "Meow"'];end;x
```
Input must be given inside single quotes: `' '`.
[Answer]
## Javascript, 117 bytes
```
for(c=0,s="bee.Buzz.bird.Song.c\at.Meow.cow.Moo.crow.Caw.dog.Bark.oxen.Low.owl.Who.rook.Caw.sheep.Baa.swan.Cry".split('.'),p=prompt(),a=![];c<s.length;c+=2){if(p==s[c])a=c}if(!a)alert(p=='fox'?'What does the fox say':p);else alert(s[a]+' goes "'+s[a+1]+'"')
```
I definitely haven't won here, but I've covered a lot of extra animals.
## Javascript, 31 bytes
```
p=prompt();alert(p=='c\at'?p+' goes "Meow"':p)
```
[Answer]
# [HALT](https://esolangs.org/wiki/HALT), 71 - 15 = 56 bytes
```
1 IF "cat" 2 ELSE 3
2 TYPE "MEOW";HALT
3 SET 0;NEXT
4 INCREMENT;STORE 0
```
HALT is a language I (@Downgoat) made designed for string processing, the only problem is that it's a bit long
## Formatted
```
1              IF "cat" 2 ELSE 3
2 TYPE "MEOW"; HALT
3 SET 0      ; GOTO 6
4 INCREMENT  ; STORE 0
```
[Answer]
# C++11, 316 - 11\*10 - 15 = 191 bytes
```
#include <map>
#define t(a,b){#a,#b},
using s=std::string;int main(){std::map<s,s>m{t(cow,moo)t(crow,caw)t(dog,bark)t(hog,oink)t(lark,sing)t(lion,roar)t(oxen,low)t(rook,caw)t(seal,bark)t(sheep,baa)t(swan,cry){"c""at","meow"}};s l;while(int i=~getchar())l+=~i;printf("%s",(m[l]==""?l:l+" goes \""+m[l]+'"').c_str());}
```
Compiles well with VisualStudio. GCC wants me to `#include <string>` and `#include <cstdio>`. It would be shorter if I wouldn't go for bonuses, but I still hope author revises bonuses. I can't think of language where defining `cow -> moo` or so is way way shorter than 10bytes. Mine cost `3+key+value` bytes for additional animal and flat `22+17` bytes for defining structure and so. 
Ungolfed
```
#include <map>
#define t(a, b) { #a, #b },
using s = std::string;
int main()
{
    std::map<s, s> m{
        t(cow,moo)
        t(crow,caw)
        t(dog,bark)
        t(hog,oink)
        t(lark,sing)
        t(lion,roar)
        t(oxen,low)
        t(rook,caw)
        t(seal,bark)
        t(sheep,baa)
        t(swan,cry)
        { "c""at", "meow" }
    };
    s l;
    while (int i = ~getchar())
        l += ~i;
    printf("%s", (m[l] == "" ? l : l + " goes " + m[l]).c_str());
}
```
[Answer]
# Python, ~~62~~ ~~58~~ 48 - 15 = ~~48~~ ~~44~~ 33 bytes
Thanks to [Unrelated String](https://codegolf.stackexchange.com/users/85334/unrelated-string) for -10 bytes!
```
x=input()
print(x,*['goes "Meow"'][:"c""at"==x])
```
0x61 = a.
## Try it online!
Revision 3: [with cat](https://tio.run/##K6gsycjPM7YoKPpfYauUnFii9F@5wjYzr6C0REOTq6AoM69Eo0JHK1o9PT@1WEHJNzW/XEk9NtpKKVlJCajY1rYiVvP/f2MA) [without cat](https://tio.run/##K6gsycjPM7YoKPpfYauUkp@u9F@5wjYzr6C0REOTq6AoM69Eo0JHK1o9PT@1WEHJNzW/XEk9NtpKKVlJKbFEyda2Ilbz/39jAA)
Revision 2: [with cat](https://tio.run/##K6gsycjPM7YoKPpfYauUnFii9F@5wjYzr6C0REOTKzNNocIWKBxTYWZYomRVUJSZV6JRoaOenp9arKDkm5pfrqSuyZWaU5wKk9P8/98YAA) [without cat](https://tio.run/##K6gsycjPM7YoKPpfYauUkp@u9F@5wjYzr6C0REOTKzNNocLWVik5psLMsETJqqAoM69Eo0JHPT0/tVhByTc1v1xJXZMrNac4FSan@f@/MQA)
Revision 1: [with cat](https://tio.run/##K6gsycjPM7YoKPpfYauUnFii9F@5wjYzr6C0REOTKzNNocIWKBxTYWZYomRVUJSZV6KhDuEqpOenFiso@abmlyupa3Kl5hSnQhVUaP7/bwwA) [without cat](https://tio.run/##K6gsycjPM7YoKPpfYauUkp@u9F@5wjYzr6C0REOTKzNNocLWVik5psLMsETJqqAoM69EQx3CVUjPTy1WUPJNzS9XUtfkSs0pToUqqND8/98YAA)
[Answer]
# JavaScript, 48 - 15 = 33 bytes
Uses `\x61` as a substitute for the `a` in `cat`.
```
i=prompt();alert(i=="c\x61t"?i+' goes "Meow"':i)
```
[Answer]
## Perl, 46 - 15 = 31
```
$_=join'',<>;s/(?<=^ca)t$/t goes "Meow"/;print
```
[Answer]
# Ruby, ~~49~~ ~~46~~ 50 - 15 = 35 bytes
Pretty straight-forward I guess. Not using cat.
```
$<.map{|l|puts l==?c+'at
'??c+'at goes "Meow"':l}
```
Edit: Thanks for @w0lf for saving 3 bytes!
[Answer]
# PHP, 1204 - (10 \* 64) - 15 - 20 = 529 bytes
```
<?php $i = $argv[1];$s = json_decode(gzuncompress(hex2bin("78da555351b2db200cbc8a27dfee057a1b192bc018104f40dcbccebb7b25d9499d8fcc588b10abddcddf1b64e4e8a04c3bd1eac86db7df3774e136dfa0744c5451805688bb400bac1e5900cfb42703ba1e3bc6e3ce82dabe8cef6f2d22af52b910b95ad93b72d173a22c8083f4d0f63bc75c131aa2e332d2ae45886e43ed7769082f438afc52027df46b20182af457b83c24537ad2c199484b99f6fe669dd9afcd6cc70ef67972a03bb8c10915abb12aa995bc7206deac48555818a9e80ea46cf8142020fe0aa0ccd761327e0db00e046f745426d0c531610d22af609d47aea8dade91d998ad447aebcef6aef0b32d7d64b8df4ddd84a0173c436b816a35475efbf8110bc254a3bf6a1420b76e7d1788f1a346ceb14f8e61b98c0bc44ddb0a46afe284582b55ea9087e1af2004236b3999278a452726c8cb8bef3c2d0086b14ad362f1f3b4032fe67b8aa59cae88742744aab26ccff3f47a2583af11ad0f344c0a1119910553b2d864929562270577b14a87d10635ea351a3e0895572ffd11f0f8ac0867fadf36898668249c65a732448e387de481c1c96931272598863c8ed09ec6b17020874c5792ac1e5bea8ee234c7c238df1a42faff449360552b55c05660d3d5426c4dcb0a7c26f874ac75f0d7a7da0e079da7145d74f848418fc71f5a75d652947a4e1edd469715fae023e29e96c3b0c748027e847a87c4ef4cc893820438722f666bc9a6cb69facf3f28e87499")));echo array_key_exists($i,$s)?"$i goes {$s->$i}":($i=="fox"?"What does the $i say":$i);
```
I use a json encoded gz compressed array of animal sounds. 
This means it works with all 65 allowed animals, but my script is huge.
Also works with fox and doesn't have the word cat in it.
[Answer]
## MATLAB, 46 bytes
```
regexprep(input(''),'^cat$','cat goes "Meow"')
```
Admittedly trivial. The input must be given in single quotes.
[Answer]
# [Beam](http://esolangs.org/wiki/Beam), ~~208~~ 206 - 15 = 191 bytes
Not a competitive entry, but a bit of fun to do. It checks the first for letters of the input against `cat`. If it gets a mismatch it will shortcut to the standard cat program. If it matches it will append `goes "Meow"`
```
'''''''''>`\/n@>`)'''>`++\
/++++++++++/r /SP''+(++++/
\+)'PSrn@--S/ \rn@`>`)rn'''''>`++++++)++@P'p++++@'p-----@`p++@'p-@``p@++@'''''>`+++++++++)--@'p++@'p-----@++++++++@``p++@H
/@<  (`<     < `<    ''<
>ruH
```
[Answer]
## Java = 222 bytes (compressed)
```
public class A {public static void main(String[] args) {Scanner a=new Scanner(System.in);for(;;){String b=a.nextLine();if(!b.equalsIgnoreCase("cat"))System.out.println(b);else {System.out.println("meow");System.exit(0);}}}
```
Or I could decompress it.
## Batch = 52 bytes
```
set /p k=
if "k"=="cat" (echo cat) ELSE (echo %k%)
```
[Answer]
# Javascript: 48 Characters, 48 Bytes
```
function(s){return (s=="cat")?"cat goes meow":s}
```
### Test
`=>`"Dog"
`<=`"Dog"
`=>`"cat"
`<=`"cat goes meow"
[Answer]
# Haskell, 52-15 = 37 bytes
```
c"\99at"="\99at goes \"Meow\""
c s=s
main=interact c
```
Using `\99` as a substitute for c in ‚Äúcat‚Äù so as to get the 15 bytes bonus.
[Answer]
# Prolog, 48 bytes
```
p:-read(X),write(X),X=cat,write(' goes "Meow"').
```
Attempts to bring more animals to the party made the program longer even with bonuses.
[Answer]
# [O](https://github.com/phase/o), ~~22~~ ~~16~~ 14 bytes
**29 bytes - 15**
```
Q"tac"`J=J" goes \"Meow\""+Q?
```
It's long and can be golfed more
[Answer]
# [ùîºùïäùïÑùïöùïü](https://github.com/molarmanful/ESMin), 23 - 15 = 8 chars / 58 - 15 = 43 bytes
```
√Øƒã…ò„¥ÉÌÉµÀ†‚ìÄ„êÄÊîÅÈÄÄËÉ¶ﬁ∞„Åä—ÄÂ§Å‰∞∞·∑ó»ø‚ÄÇÔàÖÏ®Ä#
```
`[Try it here (Firefox only).](http://molarmanful.github.io/ESMin/interpreter.html?eval=false&input=cat&code=%C3%AF%C4%8B%C9%98%E3%B4%83%ED%83%B5%CB%A0%E2%93%80%E3%90%80%E6%94%81%E9%80%80%E8%83%A6%DE%B0%E3%81%8A%D1%80%E5%A4%81%E4%B0%B0%E1%B7%97%00%C8%BF%E2%80%80%EF%88%85%EC%A8%80%23)`
The byte to char ratio is real.
]