[Question]
  [
Input must not be required, and output must read "`All your base are belong to us`".
Restrictions
* No external resources.
Plus a minimum of two of the following:
* You cannot use "a", "b", "t", "u", or "y" in any case in your code (bonus -10 to your golf score if you can do this)
* You cannot use "l", "o", "s", "e", or "r" in any case in your code (bonus -20 to your golf score if you can do this)
* You cannot use "n", "g", "0", "1", or "2" in any case in your code (bonus -30 to your golf score if you can do this)
So for example, if you manage to get the code done with 40 characters and use rules 1 and 2, your golf score is 40 - 10 - 20 = 10 chars.
Smallest code golf score wins... Good luck!
  
[Answer]
# GolfScript, -22 (38 characters, -60 bonus)
```
"„¯¯c¼²¸µc¥¤¶¨c¤µ¨c¥¨¯²±ªc·²c¸¶"{67-}%
```
[Answer]
# [Sclipting](http://esolangs.org/wiki/Sclipting), −40
```
뀖롬긇땯덗긠눦굳뉒걡댦넠눦녬닶멧긇끯긇녳
```
* = 20 characters − 60 bonus
* Only works if the input is empty, which I take to be the case; if not, add `丟` in front, changing the score to −39.
* If I can assume the input to be what I want (as [this answer](https://codegolf.stackexchange.com/a/19222/668) apparently does), then the empty program is a solution and my score is −60.
[Answer]
## Brainfuck, 267 - 60 = 207
```
++++++++[>++++++++<-]>+.<+++++++[>++++++<-]>+..>>++++++[<+++++>-]<++.<+++++++++
++++.----------.++++++.---.>.<<++++[>----<-]>.-.<+++[>++++++<-]>.--------------
.>.<----.<++++[>++++<-]>+.-------------.>.<---.+++.+++++++.+++.-.-------.>.<+++
++++++++++.-----.>.<++++++.--.
```
[Answer]
## JavaScript - 140 bytes - 60 bonus = 80 points
```
(x="Ǎľľ y̌ǒǔř b̌ǎšě ǎřě b̌ěľǒňǧ ťǒ ǔš")[x[3*9]+x[34]+"p"+x[4]+x[5*5]+"c"+x[34]]("̌","",x[6*7])
```
Run in Firefox.
I know what you're thinking. No, those aren't the characters that are listed in the question. Those are characters with a caron, or háček (picked randomly from a list of diacritics). Even though they're combining marks, they aren't two separate characters.
[Answer]
## APL (43 - 30 - 20 = -7)
```
⎕AV['⊥┤┤ ø┼&┐ `∣┘û ∣┐û `û┤┼─ù ´┼ &┘'⍳⍨⌽⎕AV]
```
This satisfies rules 2 and 3.
[Answer]
# HTML/CSS 70
```
<p style="transform:rotate(.5turn)">sn oʇ ƃuoləq əɹɐ əsɐq ɹnoʎ llɐ</p>
```
<http://jsbin.com/EjekuvuF/1/>
I thought I was being clever with the upside down type but then realized I couldn't meet any of the ancillary rules with the actual HTML/CSS. Oh well.
UPDATE:
User Flame suggested a more cross-browser compliant solution:
```
<p style="transform:rotate(180deg)">sn oʇ ƃuoləq əɹɐ əsɐq ɹnoʎ llɐ</p>  
       
```
<http://jsbin.com/EjekuvuF/6>
[Answer]
## MATLAB, All bonuses: Score of -20 (40-60)
```
['' '¤ÏÏèÜÒØÕèÅÄÖÈèÄÕÈèÅÈÏÒÑÊè×ÒèØÖ'-99]
```
### EDIT:
Note that I am not sure of what the system requirements are to run this, tested on windows. For those struggeling to copy, a similar code can be generated like so:
```
char('All your base are belong to us' + 99)
```
---
If it would have been allowed to ask anything as input, a solution with less characters (but also missing the bonus) would of course be possible.
```
input('')
```
[Answer]
# k (-7 = 53 - 60)
`(#`)"c"$(465%3)-6h$"Z//{\",&){9:(6{:)6{96/,-4{',{&(";`
doesn't include trailing newline, can be added at cost of one additional char:
`(-#`)"c"$(465%3)-6h$"Z//{\",&){9:(6{:)6{96/,-4{',{&(";`
annoyingly, the only offsets that work for this trick are 154 and 155
edit:
if it's sufficient to display the string (rather than printing it), as i suspect the APL solution does (it doesn't work in <http://tryapl.com/>, so i can't test it properly), it's
```
  "c"$(465%3)-6h$"Z//{\",&){9:(6{:)6{96/,-4{',{&("
"All your base are belong to us"
```
which is -12 = 48 - 60. can i get a ruling on whether this is sufficient?
[Answer]
### dc, ~~97 - 60 = 37~~ ~~91 - 60 = 31~~ ~~88 - 60 = 28~~ 81 - 60 = 21
```
3C87596P4d^8/P7958389P7479394P6386533P7C89P749698CP644848CP459 8^699 7^3849736388974773333 86-++P
```
Improved version (the main idea here is to vary the input base, to increase the chances of finding a useful big number with no problematic digits):
```
IDi67793554D647F84C836645D6569F69Pi6385C77P9i35PDdi6^I9^+6D59CD83D664D34+P8CPFi98CCF5PCi97P
```
In base 7, the whole thing can become a single number! Lower bases are naturally less compact, but the lack of fix-up operations here makes up for it.
```
7i4398873968644388737548444897643735447698675366869556798538985674336396359936458859886P
```
My first solution used base 10. My second used a mix of base 9, 10, 12, 13, and 15. This one is in base 7. I truly feel like all the base *are* belong to me.
**Last one, seriously:** Base 13 does a great job on the first segment, then base 7 for the rest.
```
Di67793554D647F84C836645D6569F69P7i798789699638355733695878558396339387963789536P
```
[Answer]
## Python REPL, ~~122~~ ~~116~~ 98 characters - 30 bonus = ~~92~~ ~~86~~ 68 points
```
>>> '\x41\x6c\x6c \x79\x6f\x75\x72 \x62\x61\x73\x65 \x61\x72\x65 \x62\x65\x6c\x6fng \x74\x6f \x75\x73'
'All your base are belong to us'
```
I could get rid of the zeroes in Python 3.3 by replacing '`\40`' with `\N{SP}`, but alas, the `N` is not permitted.
**Edit**: Inspired by [this answer](https://codegolf.stackexchange.com/questions/19171/all-your-base-are-belong-to-us-restricted/19412#19412), I've shortened it further by replacing `\x40` by . Moreover, since I already use the `1`, replacing `\156` by `n` and `\x67` by `g` shortens it by another 6 characters while incurring no extra penalty.
[Answer]
# Brainfuck, ~~205~~ 203 - 60 = ~~145~~ 143 bytes
```
++++[->++++<]>[->++++>++>+++++++>++++++>++++++++<<<<<]>+.>>----..<.>>>-------.<<+++.>>----.---.<<<.>>++.-.>+.<++++.<<.>>----.>-.<++++.<<.>>---.+++.<---.>>---.-.<<-----.<.>>>++++++.-----.<<<.>>>++++++.--.
```
Readable version:
```
++++[->++++<]>[->++++>++>+++++++>++++++>++++++++<<<<<]
64 32 112 96 128
>+.>>----..<.                     All                 65 108 108  32
>>>-------.<<+++.>>----.---.<<<.  your           121 111 117 114  32
>>++.-.>+.<++++.<<.               base            98  97 115 101  32
>>----.>-.<++++.<<.               are                 97 114 101  32
>>---.+++.<---.>>---.-.<<-----.<. belong  98 101 108 111 110 103  32
>>>++++++.-----.<<<.              to                     116 111  32
>>>++++++.--.                     us                     117 115
```
[Answer]
# Befunge 98 : 122 - 60 = 62
```
5f8+*:53-+:' \6-:5+' 91+:*3+::7+\8+:3-:7-:3-:' \3+::3-4+',' -+\4-:' \:4+\6+c+:f3+-:4+3-' '&3*:3+:6-:f+5-:' \d-:' '!+ff+k,@
```
Computes the ascii values, then prints them. I still need to try out other methods of forming the numbers to see if there are shorter ways.
[Answer]
# Python, 195-40 = 155
```
x,w,y,z,v=4*8,55,56,57,58;exec(("%c"*38)%(y+y,z+z,49+y,w+w,v+v,39-7,34,65,54+54,54+54,x,v+63,48+63,48+69,z+z,x,98,97,59+y,45+y,x,97,z+z,45+y,x,98,45+y,54+54,w+y,w+w,45+v,x,v+v,w+y,x,v+59,z+v,34))
```
[Answer]
# [SOGL V0.12](https://github.com/dzaima/SOGL), 15 - 60 = -45
```
šz█P'zUS½█│β3‘⁾
```
[Try it Here!](https://dzaima.github.io/SOGLOnline/?code=JXUwMTYxeiV1MjU4OFAlMjd6VVMlQkQldTI1ODgldTI1MDIldTAzQjIzJXUyMDE4JXUyMDdF)
`šz█P'zUS½█│β3‘` is a compressed string of `all your base are belong to us`, but because that exact string compressed contained `0`, it's split into 3 parts: `all your base are`, , `belong to us` (which cost one byte but gave a -30 byte bonus). The first and last strings are compressed with SOGLs English dictionary, and implicitly joined with spaces. The remaining `⁾` is a simple sentence case built-in.  
Note that SOGL postdates this challenge, but that's allowed now.
[Answer]
## Ruby, 121 - 50 = 71
A bit brute force, but most of the cute methods are ruled out:
```
$><<[65,c=36*3,c,d=8*4,363/3,f=c+3,c+9,c+6,d,x=98,97,j=c+7,k=3+x,d,97,c+6,k,d,x,k,c,f,j-5,5+x,d,c+8,f,d,c+9,j].pack('C*')
```
Breaks rule #1 because of the A in `pack`, the other two should be OK.
[Answer]
## {ba,z}sh, ~~67 - 40  72 - 60~~ 61 - 40 = 21
```
$'\x74r' K-~\#-\; _@-~\^-j<<<'Mxx ){%~ 3m#q m~q 3qx{z8 ${ %#'
```
Darn it, turns out I had a `r` in there that I hadn't noticed, so the 20 bonus doesn't apply!
[Answer]
# C, 75 bytes - 60 = 15
*Thanks to @gastropner for getting the score down from 50 to 33 and from 19 to 15!*
```
*q,i;f(p){(*(q=p)="\v&&j3%?8j(+9/j+8/j(/&%$-j>%j?9J"[i++]^74)?i=!f(++p):i;}
```
Takes the address of a char array as input and writes the string to the array.
[Try it online!](https://tio.run/##JYjRCoIwFEDf/QqTlDvXkDRoNtbe@wUzGIPZRsps1ov4662w83TOUaRTKoR83BmmwaEZchi5Qzy5vrPMVqmgFnBdWEwLC0WWbok9p1bUl6QxGLe34wEJwzcaMHboZNgSzDDFvTQDoGiO4h/qLp@xb/Ylbdk6NHj0N/ea/BpL@Cj9kJ0PpK/KLw)
**Call with:**
```
int main()
{
    char s[128];
    f(s);
    puts(s);
}
```
**Output:**
[![](https://i.stack.imgur.com/Ap7NZ.png)](https://i.stack.imgur.com/Ap7NZ.png)
**Old version (90 bytes - 40 = 50):**
```
*q,i,j;f(p){for(i=3-3;j="Epp$}s v$fewi$evi$fipsrk$xs$ w"[i++];*q=j!=35-3?j-4:353/3)q=p++;}
```
[Answer]
# Brainfuck, (227 - 60 = 167)
```
+++++ +++++[>+++>++++++>+++++++++>++++++++++<<<<-]>>+++++.>>++++++++..<<<++.>>>+++++++++++++.----------.++++++.---.<<<.>>++++++++.-.>+.<++++.<<.>>----.>-.<++++.<<.>>---.+++.>------.+++.-.<++.<<.>>>++++++.-----.<<<.>>>++++++.--.
```
[Answer]
# Postscript, 364 - 40 = 324
I couldn't do it without `loser`, of course. :) 
```
/${cvx exec}def
/+{<3C7E4F6F597E3E>$ $}def
/*{<~P&(~>$}def
/-{( )<3C7E4F754E7E3E>$ $ 3 4<~P#;~>$ 4 3<~P)#3FP'-~>$}def
/_{36(      )<~OoP~><3C7E4F754E7E3E>$ $ 4 3<~P,S~>$ 48<~P'?~>$
${96 3<~P#;~>$ + -}<~P">~>$}def
/.{_ 96 3<~P#;~>$ -}def
65 - 777 .
895 353 + _ 774 333 + .
74933 333 + 7 * 3 + 333 + .
9593 4353 + .
689653949 335 + .
735 333 + .
775 333 + _ 5 5 + -
```
This starts with encoding the text as base-36 strings:
```
%-=Encoding strings as base-36 numbers=-
%All your base are belong to us
% handle uppercase A separately
%36#ll = %777
%36#your = %1618515
%36#yo = 36#ur = 36#base = 36#are = 36#belong = 36#to = 36#us =
%1248 1107 527198 13946 689654284 1068 1108
```
And then removing the 1s and 0s and 2s arithmetically. The strings can then be regenerated with `36 <string-buf> cvrs`, but this yields upper-case letters, so we then need to iterate through and add 0x20 to make them lowercase.
The operators `cvx exec` allow us to execute string fragments of binary-encoded operator tokens in various encodings. Simplest is to encode an operator in hex `<92??>` but there's a 2 in there! So the "first-level" encoding is ascii85. Then any strings that still contained forbidden characters went through extra levels of hex -> ascii85 -> hex -> ascii85.
[Answer]
# JavaScript
## ~~(306 characters - 60 bonus = 246)~~ ~~(206 characters - 50 bonus = 156)~~
## (123 chars = 173 chars - 50 bonus)
Kind of nooby, probably could get more off... Let me know if I've stuffed something up, this alerts "All your base are belong to us". This is also ASCII-only.
```
(c=(''+!'')[4-3],x=([][3]+c)[6])[a='c\x6F'+x+'\x73t'+c+'uct\x6F'+c][a]('a\x6C\x65'+c+'t("A\x6C\x6C y\x6Fu'+c+' ba\x73\x65 a'+c+'\x65 b\x65\x6C\x6F'+x+'\x67 t\x6F u\x73")')()
```
If you count the console itself as output, this would also count (57 with bonus):
```
'A\x6C\x6C y\x6Fu'+(c=(''+!'')[4-3])+' ba\x73\x65 a'+c+'\x65 b\x65\x6C\x6F'+([][3]+c)[6]+'\x67 t\x6F u\x73'
```
[Answer]
## Brainfuck, 306 - 60 = 246
```
----[---->+<]>++.[--->+<]>+..[++>---<]>--.--[->++++<]>+.----------.++++++.---.[-->+++++<]>+++.[--->+<]>++.-.--[--->+<]>--.++++[->+++<]>.--[--->+<]>-.[--->+<]>+.--[--->+<]>---.-------------.--[--->+<]>-.[--->+<]>++.+++.+++++++.+++.-.-------.-[--->+<]>--.---[->++++<]>.-----.[--->+<]>-----.---[->++++<]>+.--.
```
[Answer]
# PHP (35 - 60 = -25 bytes)
[`HOW LOW CAN YOU GET ?`](http://donhodges.com/how_high_can_you_get.htm)[1][2]
```
$ xxd yourbase.php 
0000000: 3c3f 3d7e be93 93df 8690 8a8d df9d 9e8c  <?=~............
0000010: 9adf 9e8d 9adf 9d9a 9390 9198 df8b 90df  ................
0000020: 8a8c 3b                                  ..;
```
---
[1] This program can be decoded using `xxd -r`.  
[2] Yeah, heavy solution reuse here. I think it's... third problem I solved this way. Perhaps I should move to something else, but it's not that this is not great for problems that forbid you from using most characters.
[Answer]
# Bash, 52 - 10 - 30 = 12
The following is to be executed in a (still pretty common) ISO-8859-1 environment:
```
$'\x74r' À-þ  @-~<<<'Áìì ùïõò âáóå áòå âåìïîç ôï õó'
```
This calls `tr`, which translates the characters in a suitable way. I had to either use the `r` and violate rule 2, or use a digit in the escape and violate rule 3. Since 3 gives more bonus, I chose the former.
[Answer]
# Pure Bash (no external resources), 141 chars - 50 bonus = 91
```
Z=({k..v})
f=$'\x65'
h=$'\x6c'
i=$'\x6f'
j=${Z[7]}
k=$'\x73'
m=$'\x75'
$f$'\x63'h$i A$h$h y$i$m$j ba$k$f a$j$f b$f$h$i${Z[3]}$'\x67' t$i u$k
```
Intentionally dropping the 10-point bonus to get a better overall score.
This works on any `bash` version 3.00.15 or later that I have tried.
### How does it work
There's no rocket science here - just `bash` expansions of one form or another:
* Simple hex expansion to obtain required character. This works for characters whose hex representation doesn't contain `[012]`. e.g. `$'\x65'` gives us `e`
* For other characters, we generate a bash array of sequential characters using brace expansion into an array initialization (`Z=({k..v})`). The start of the brace expansion is chosen carefully so that the indexes of the characters we require don't contain `[012]`. e.g.
`${Z[7]}` gives us `r`.
* `bash` is flexible enough to allow its commands to be constructed from the contents of multiple strings. So `$f$'\x63'h$i` expands to `echo`.
* For characters that are required only once, the expansion is inserted inline to the echo command string.
* For characters that are required twice or more it is more efficient to expand them to variables, then reference the variables.
---
Previous answer with full bonus, but worse overall score:
### Pure Bash (no external resources), 193 chars - 60 bonus = 133
I know this won't win, but I wanted to prove to myself this is possible in `bash`, while satisfying all requirements:
```
Z=({3..8} {C..z})
c=${Z[36]}
d=${Z[37]}
f=$'\x65'
h=$'\x6c'
i=$'\x6f'
j=${Z[53]}
k=$'\x73'
m=$'\x75'
$f$'\x63'h$i ${c^}$h$h $'\x79'$i$m$j $d$c$k$f $c$j$f $d$f$h$i${Z[49]}$'\x67' $'\x74'$i $m$k
```
This does require a fairly recent version of `bash` for the `${c^}` parameter expansion. 4.2.25 is fine, but 3.2.48 is a no-go.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 23 - 60 = -37
```
“%⁼“¡¢8ṣƤ¹;“pȷȦÆ⁾“¡PȤṫ»
```
[Try it online!](https://tio.run/nexus/jelly#@/@oYY7qo8Y9QOrQwkOLLB7uXHxsyaGd1kB@wYntJ5YdbnvUuA8sGXBiycOdqw/t/v8fAA "Jelly – TIO Nexus")
This is just the compressed representation of `["All", " your base are", " belong to", " us"]` (Jelly has a compressed string format). The string's split into multiple pieces in order to ensure that none of the banned characters appear within the compressed representation; they're all implicitly concatenated at the end of the program.
[Answer]
## PHP, 186 - 10 - 30 = 146
I had to get a little creative ;)
```
 <?=chr(65).'ll '.chr(88+33).'o'.chr(39*3).'r '.chr(98).chr(97).'s'.chr(68+33).' '.chr(97).chr(38*3).chr(68+33).' '.chr(98).'elo'.chr(77+33).chr(69+34).' '.chr(83+33).'o '.chr(39*3).'s'?>
```
[Answer]
# PHP, 67 bytes -60 bonus = 7
```
<?=d__cJZFFcQWFVcWFVcQV_ZZQcCZcFF^"%33C3534C3653C643C333546C75C35";
```
bitwise XOR on the ASCII characters
I brute forced a pair of characters not in the forbidden characters for each character in output.  
No word character pair for `A` and I don´t like extended ASCII, so I live with one string in quotes.
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal) `ṡ`, 20 bytes, score -40
```
‛λʀ«×∇⟇Ȧß¥fė₀⌊↓qεǏq⟑
```
[Try it Online!](https://lyxal.pythonanywhere.com?flags=%E1%B9%A1&code=%E2%80%9B%CE%BB%CA%80%C2%AB%C3%97%E2%88%87%E2%9F%87%C8%A6%C3%9F%C2%A5f%C4%97%E2%82%80%E2%8C%8A%E2%86%93q%CE%B5%C7%8Fq%E2%9F%91&inputs=&header=&footer=)
-4 bytes / -4 score thanks to Aaron Miller.
[Answer]
**Python, 181 - 40 = 141**
[I'm using version 2.7.2 YMMV - the builtin, `file` is gone in python 3.X]
```
f=file.__doc__;c=5-3;l=f[c];s=' ';e=f[3];h=f[6+7];i=f[c*87];j=3**3;f[j*c*5]+l+l+s+f[-57]+h+f[j-7]+f[j-3]+s+f[j-8]+f[6]+i+e+s+f[6]+f[j-3]+e+s+f[j-8]+e+l+h+f[5]+f[j]+s+f[45]+h+s+f[j-7]+i
```
[Answer]
# Python (104 - 30 = 74)
```
>>> '\x41\x6c\x6c \x79\x6f\x75\x72 \x62\x61\x73\x65 \x61\x72\x65 \x62\x65\x6c\x6f\156\x67 \x74\x6f \x75\x73'
'All your base are belong to us'
```
And score:
```
>>> len(r"'\x41\x6c\x6c \x79\x6f\x75\x72 \x62\x61\x73\x65 \x61\x72\x65 \x62\x65\x6c\x6f\156\x67 \x74\x6f \x75\x73'")-30
74
```
]