[Question]
  [
You have been hired for your tech knowledge as a Secret Agent's sidekick to ensure that the good guy can get his job done and the world can be saved.
This is your last mission before retiring with a high paycheck and the gratitude of the whole world. But before you have to disarm the Evil Genius' Big Overly Massive BOMB (seems that the evil genius is a smart ass who likes recursive acronyms). Anyways you and your buddy are in the very core of the Evil Genius secret base, ready to disarm the BOMB that could wipe the continent out. In your previous mission you managed to get the disarm code that to your astonishment is just "PASSWORD\_01". You connect your keyboard to the BOMB but when you are ready to go, the Evil Genius' henchmen enter in with a barrage of bullets. Unfortunately one of these bullets impacts on your keyboard. "Finish the job while I distract those d\*ckheads!" says your buddy and then begins to fire his gun. But how could you finish the job with only half a keyboard?
**SPECS**
1. Write a program that outputs in any way you want the string `PASSWORD_01` (uppercase).
2. Since your keyboard has been hit by a bullet, you can only use these keys:
`1` `2` `3` `4` `5`
`Q` `W` `E` `R` `T`
`A` `S` `D` `F` `G`
`<` `>` `Z` `X` `C`
`Ctrl` `Shift` `Tab` `Space`
Using the `Shift` key, your keyboard allows you to use these characters:
`!` `"` `¬∑` `$` `%`
3. You don't have any other hardware than the keyboard and the screen (a mouse for example), nor a file with the password written in your computer.
4. You don't have an Internet connection.
5. You can assume you have the interpreter shell / source editor opened before the bullets came in. Sadly you have not written anything in it before the keyboard was hit.
6. You don't have a virtual keyboard. In fact the BOMB has a TOO\_FUNNY detector that will make it explode if you try to use the [Standard loopholes](https://codegolf.meta.stackexchange.com/questions/1061/loopholes-that-are-forbidden-by-default).
7. Since your buddy is waiting for you to finish soon to escape off the Secret Base, you will have to write the smallest code possible (so it's [restricted-source](/questions/tagged/restricted-source "show questions tagged 'restricted-source'") and [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'")!).
Good luck because the count down has begun!
**HELP MODE:** Also a `KEY` (only one Key you want from the keyboard, but not the Shift + Key or any other combination) has miraculously survived too. E.g.: You can use `=`, or `0` or `/`… This extra key cannot be any of the letters in `PASSWORD_01` (so you cannot add `P` or `O`). Name that key in your answer. **You have a penalization of 10 characters for use of this key** regardless of how many times you use the key.
  
[Answer]
## bash, vim and dc (343)
I'm sitting at a bash prompt which has been configured by the Evil Genius, and of course he has `VISUAL=vim` in the default environment. Using the default bash binding for `edit-and-execute-command` (`C-x C-e`) bash invokes `$VISUAL` and will execute its buffer contents on exit (`ZZ`). I type in the following sequence (Note: `kbd`-mode are commands issued in normal mode and control sequences):
1. `C-x``C-e`
2. `a`cat<<<45`C-c``4``C-a``a`a
Now the vim buffer contains `cat<<<49a`. Continuing ...
3. 45`C-c``3``C-a``a`a
4. 54`C-c``41``C-a``a`a
5. 55`C-c``13``C-a``a`a
Now the vim buffer contains `cat<<<49a48a95a68a`. Continuing ...
6. 51`C-c``31``C-a``a`a
7. 55`C-c``24``C-a``a`a
8. 44`C-c``43``C-a``a`a
9. 42`C-c``41``C-a``a`a
10. 42`C-c``41``C-a``a`a
11. 54`C-c``11``C-a``a`a
12. 55`C-c``25``C-a``a`a>s
Now the vim buffer contains `cat<<<49a48a95a68a82a79a87a83a83a65a80a>s`
Get out of insert mode, save and exit
13. `C-c``Z``Z`
The `s` file now contains a `dc` script that generates the desired string on the stack, now we need to add print commands.
14. `C-x``C-e``a`dc<<<55`C-c``25``C-a``a`a>>s`C-c``Z``Z`
Repeat the above command 9 times.
15. `C-x``C-e``a`dc<<<55`C-c``25``C-a``a`a>>s`C-c``Z``Z`
16. `C-x``C-e``a`dc<<<55`C-c``25``C-a``a`a>>s`C-c``Z``Z`
17. `C-x``C-e``a`dc<<<55`C-c``25``C-a``a`a>>s`C-c``Z``Z`
18. `C-x``C-e``a`dc<<<55`C-c``25``C-a``a`a>>s`C-c``Z``Z`
19. `C-x``C-e``a`dc<<<55`C-c``25``C-a``a`a>>s`C-c``Z``Z`
20. `C-x``C-e``a`dc<<<55`C-c``25``C-a``a`a>>s`C-c``Z``Z`
21. `C-x``C-e``a`dc<<<55`C-c``25``C-a``a`a>>s`C-c``Z``Z`
22. `C-x``C-e``a`dc<<<55`C-c``25``C-a``a`a>>s`C-c``Z``Z`
23. `C-x``C-e``a`dc<<<55`C-c``25``C-a``a`a>>s`C-c``Z``Z`
24. `C-x``C-e``a`cat<<< f >>s
Execute the dc script:
25. `C-x``C-e``a`dc s`C-c``Z``Z`
Output:
```
PASSWORD_01
```
Contents of the `s` file:
```
49a48a95a68a82a79a87a83a83a65a80a
P
P
P
P
P
P
P
P
P
P
f
```
[Answer]
## Ruby, 57 + 10 (`*`) = 67
```
$*<<4*4*5<<214%135<<44%25*5<<1%1
$><<"%cASSW%cRD%c%d1"%$*
```
This answer uses `*` and `%` to build the ASCII values of the missing characters (and 0 as Fixnum) and pushes them into `$*` (`ARGV`). This array is then used in combination with a format string to generate the correct password, which is printed with `$><<` (`$>` is stdout).
## Ruby, 62 + 10 (`.`) = 72, no linebreak
```
$>.<< "%cASSW%cRD%c%d1".% %w%%<<311%231<<214%135<<321%113<<1%1
```
Roughly the same principle as the above version, except that here the array is built from an empty array literal (`%w%%`). Some fiddling with `.` is needed to get the desired operator precedence.
[Answer]
# CJam - 24 + 10 (`(`) = 34
```
"Q"c("ASSW"1$("aRD"(((T1
```
## No additional key - 39
```
211 131%c"ASSW"211 132%c"RD"321 113%cT1
```
Try it at <http://cjam.aditsu.net/>
[Answer]
# Whitespace (148 + 10 = 158)
`Enter` key needs to be used here.
```
SS+1010000L // Push code of P
TLSS        // Output character
SS+1000001L // Push code of A
TLSS        // Output character
SS+1010011L // Push code of S
SLS         // Duplicate top stack
TLSS
TLSS
SS+1010111L // Push code of W
TLSS
SS+1001111L // Push code of O
TLSS
SS+1010010L // Push code of R
TLSS
SS+1000100L // Push code of D
TLSS
SS+1011111L // Push code of _
TLSS
SS+0L       // Push 0
TLST        // Output number
SS+1L       // Push 1
TLST        // Output number
LLL         // End program
```
My notation's explanation:
* `S`, `+`, `0` are spaces.
* `T`, `1` are tabs.
* `L` is new line.
* `//` starts comment.
Each line is a command in whitespace language.
[**Demo**](http://ideone.com/ZFXeAT)
[Answer]
# Python (~~2200~~ 395 + 10)
```
exec"""exec"exec"+"%ca"%34+"%c52+53"""+"%c55+55"%44+"%c34"%44+"%c45+35"%44+"%c"%44+"""34%%cexec"%"""+"%c"%54+"""1+"%c"%34+"%%5%c+"%5"""+"%c"%55+"""+"%c"%34+"%c"""+"%c"%112+"""r%%c%%ct%%c%%cASSW"+"%c%%34+"%34+"%c%%cRD"%34+"%c%%"""+"%c"%55+""""%34+"%c+"%5"""+"%c"%55+"""+"%c%%c"%34+"%c%%"%34+"%c5+"%5"""+"%c"%55+"""+"%c"%34+"%c1%%c"+"%c%%4"%34+"%c+"%5"""+"%c"%54+"""+"%c"%34+"%c%%a"+"%c%%34"%34"""
```
I needed the `+` character (costing +10), which can be obtained from the numpad (or on certain key layouts).
Yeah, the BOMB probably went off while I was typing that.
The basic approach is to construct ever larger character sets by using `exec` and `"%c"%(number)`. There are four `exec`s nested inside each other. Gradually, my digit set progresses up from
1. 12345
2. 1234567 (6 = ASCII 54, 7 = ASCII 55)
3. 123456789 (8 = ASCII 56, 9 = ASCII 57)
4. 0x0123456789abcdef
so that in the final iteration it is possible to express any character (so that the innermost version can actually run any program at all).
Around 50% of the program is just quote characters (`"%c"%34` is a double quote), because the nested nature of the `exec` statements demands "escaping" quote characters aggressively.
[Answer]
# [Insomnia](http://esolangs.org/wiki/Insomnia) ~~39~~ ~~35~~ ~~31~~ 29
This language comes up when I was looking around for a language that encodes its instructions with single ASCII character. The language actually operates on the decimal ASCII code of the character, so it is still quite flexible with half of the keyboard destroyed.
Drop it down further to 29 characters, which is possible after reducing memory usage and increases the search space:
```
FdFzt%dF<rGdt>tt Gtreeet t%4s
```
I decided to run my tweaked up program on the full set of allowed characters, and cut the solution down to 31 characters:
```
FdFGt dtreeC>tt FFdx<Fdtr ztq4s
```
I used a program to search for this solution. It is one among many solutions returned by my program, all with the same size.
```
Fddx>"eCeezdC>CefCdddzCzzfCqred>r4s
```
Old version constructed by hand. I remember staying up till morning to do this.
```
Fddx>"eCeezdC>Cef>dx"dCezeeedeCrqeeC%4s
```
Here is the [**Insomnia interpreter**](https://codegolf.stackexchange.com/a/41868/) for testing.
[Answer]
## Vim + PHP on Some Window Managers
65 keys in 44 strokes, with a 10-point penalty for using `=`.
```
aEACE<Alt+Tab>z=5<Alt+Tab>$xxxxaASSWRD<Alt+Tab>z=1<Alt+Tab>
$a$aA<Alt+Tab>==wxx$r1<^X>a1
```
A breakdown:
* `Alt+Tab` appears to work like `Esc` with Vim, or perhaps with this terminal emulator. Thanks for teaching me something new!
* `aEACE<Alt+Tab>`: Enter append mode and insert ‚ÄúEACE‚Äù. Exit.
* `z=5<Alt+Tab>`: Perform spelling correction. Select 5, ‚ÄúPEACE‚Äù. Exit. (`Esc` seems to work as `Enter` here!)
* `$xxxxaASSWRD<Alt+Tab>`: Go to the end of the line. Delete 4 characters and add `ASSWRD`, resulting in `PASSWRD`. Back to normal mode. (No, `4x` won‚Äôt work.)
* `z=1<Alt+Tab>`: `PASSWORD` is *probably* going to be the first correction for this. Select it.
* `$a$aA<Alt+Tab>`: Go to the end of the line, and add a `$aA`. Back to normal mode.
* `==`: Format this line of PHP nicely, changing the camelCase `$aA` to `$a_a`. This also moves the cursor back to the start of the line.
* `wxx`: Go forward a word; the cursor is now before `$`. Delete two characters ‚Äì the `$` and the `a` ‚Äì to make `PASSWORD_a`.
* `$r1`: Go to the end of the line and replace the current character (i.e. `a`) with `1`, resulting in `PASSWORD_1`.
* `^X`: Decrement the integer under the cursor, resulting in `PASSWORD_0`.
* `a1`: Finally, append `1`, for `PASSWORD_01`!
[Answer]
# Python 2, 75889 bytes
**No extra character!**
Unfortunately, the code is super long. So instead, here's the code to generate the program:
```
x=[2**n for n in xrange(16)]
y=-5
print('exec"""exec'+x[7]*'%'+'c""'+x[6]*'%'+'cr'+x[-2]*'%'+'c'+x[-1]*'%'+'ct'+x[8]*'%'+'c'+x[-4]*'%'+'cASSW'+x[-5]*'%'+'cRD'+x[-3]*'%'+'c'+x[0]*'%'+'s1'+x[10]*'%'+'c '+x[9]*'%'+'c""'+x[y]*'%'+x[1]*'%'+'s'+x[y]*'%'+x[2]*'%'+'s'+x[y]*'%'+x[3]*'%'+'s'+x[y]*'%'+x[4]*'%'+'s'+x[y]*'%'+x[5]*'%'+'s"""'+'%`1>>1`%`2531>>5`%`321>>2`%`1521>>4`%`211>>1`%`221>>1`%112%34%34%34%34')
```
[**Try it online**](https://tio.run/nexus/python2#rZLBa8IwFMbP61/x0fLoVin0JY1tBwoDd1bqYQcRHcENL51UD/Wvdy@1GQoelzTN9/veS3ghiQ7tvjmFi7fl8mNezzYZh0F09cg6k8jWM5JmaWiWQyozKiqqDOVlEO26nQ3D0E0kgmzrsu3J/fot3A6WjkwWfcLRd1kFwpanU97SVhktyojSSoQSwcap3AXZZ6mrYFak87/v0k1WKkkafP20aLBv0LWfzffumccv6@A8SU3QHyu@qTYedatincQUj2LxHI49to5S5bEn9nRyWN7Fck/uxL1jvFPPeta3@dkAR3bEHi0cVvc1na8oaX7Rnaseuvqhmz90faXuPmSif7mQ@BLJg3qvX5GhqFBmqAw4k8EZDgiHDsyBBbAB9kATRE8ZGFCAllguwwBjFChRyXKkBmmOVCNVSHl4q5DyE62C4PIL)
(to run the code, change the outer `print` into an `exec`. Or, generate the program, then paste and run. Or copy from the hastebin linked below.)
### Explanation:
The goal is to execute:
```
print"PASSWORD_01"
```
To avoid using `()+` chars, we have to use multiple string format operations chained together. This means that each step added effectively ***doubles*** the number of `%` characters needed for each previous step:
```
print"%cASSW%%cRD%%%%c%%%%%%%%c1"%80%79%95%48
```
This is not enough though, because some of the numbers required cannot be created, and neither can we create `print`. So we add a level of abstraction with `exec` for `print`ing, and a level for the ASCII code points we cannot create to format with. The following is essentially my answer, but with each string of `%` reduced to a single one (note that the `%s%s%s%s%s` is not an accurate representation, failing to account for the literal `%`'s required before each):
```
exec"""exec%c""%cr%c%ct%c%cASSW%cRD%c%s1%c %c""%s%s%s%s%s""" % `1>>1`%`2531>>5`%`321>>2`%`1521>>4`%`211>>1`%`221>>1`%112%34%34%34%34
```
**The First Step: Outermost `exec`:**
```
exec""" ... ASSW%cRD ... %s%s%s%s%s""" % `1>>1` % `2531>>5` % `321>>2` % `1521>>4` % `211>>1` % `221>>1`
```
1. `1>>1`: `0`, used for the `0` in `PASSWORD_01`
2. `2531>>5`: `79`, used for inner exec to create `O`
3. `321>>2`: `80`, used for inner exec to create `P`
4. `1521>>4`: `95`, used for inner exec to create `_`
5. `211>>1`: `105`, used for inner exec to create `i`
6. `221>>1`: `110`, used for inner exec to create `n`
**Second Step: Prepare Inner `exec`**
After the above, the inner `exec` is something like this:
```
exec%c""%cr%c%ct%c%cASSWORD%c01%c %c""%79%80%95%105%110
```
Except that you wouldn't quite get that. Still wtih the simplifications, you'd get this:
```
exec%c""%cr%c%ct%c%cASSWORD%c01%c %c""798095105110
```
The literal `%`'s need to be included. So basically I had to add a bunch of them before each `%s` to end up with literal `%`'s left after all the formatting. `2**11` of them. Times five.
The rest of the outer `exec` string format operations are `%112%34%34%34%34`. The `112` is for `p`, and the others are quotation marks. After applying those, the result is something like this:
```
exec"""pr%c%ct"%cASSW%cRD%c01" """%79%80%95%105%110
```
But in reality it has a bunch more `%`. It's this:
```
exec"""pr%%%%%%%%c%%%%%%%%%%%%%%%%ct"%%cASSW%cRD%%%%c01" """%79%80%95%105%110
```
The final step is to simply run that, after which you get the necessary output.
---
**Full code here:** <https://hastebin.com/ehemizivum.apache>
[Answer]
# bash + vim (56)
Borrowing the `Ctrl-X``Ctrl-E` bash trick from Thor's solution, here is how I would do it in bash+vim:
`C-X``C-E` starts default editor (usually vim)
`a` starts insert mode
`.``space`
`A``S``S``W`
`C-V``x``4``f` inserts `O`
`R``D`
`C-V``x``5``f` inserts `_`
`1`
`C-3` is equivalent to `escape` (not just in vim, but anywhere in a terminal)
`C-X` subtracts 1 from the `1` i just typed
`a` insert mode again
`1`
`C-3`
buffer content is now `. ASSWORD_01`
`<``<` unindent line (a no-op, since line is not indented) and move cursor to 1st column
`a`
`C-X` start word completion
`C-V` complete with ex command
`C-V` 9 more times selects the entry `Print`
`C-3` back to normal mode
`X``X``X``x``x` deletes `rint`
`<`
`<` back to column 1 
`s` delete `.`, start insert mode
`e`
`c`
`C-X`
`C-V` ex command completion once again, entry `echo` already selected because of the `ec` i just typed
`space`
`C-3` buffer content now `echo PASSWORD_01`
`Z`
`Z` save buffer, close vim, bash executes file content, i.e. `echo PASSWORD_01`
By the way: `C-3` has many useful brethren: `C-J` is `Enter`, `C-I` is `Tab`, `C-H` is `Backspace`, `C-2` is `C-@` (i.e. a null-byte). And for emacs users it is nice to know that `Escape` followed by another key is equivalent to `Alt` + that key. So, even without `Escape` and `Alt` you can still type Meta-x like this: `C-3``x`
[Answer]
# Perl, (31+10 / 41+10 / 64+10)
(`^` key used, 3 ways)
```
exec"easswsrdcqw"^"5    <  <AF"                   # exec "PASSWORD_01"
```
* Valid if running as a system command qualifies as "output."
```
exec"QQZSqeasswsrdcqw"^"422<Q5    <  <AF"         # exec "echo PASSWORD_01"
```
* Valid if I'm allowed to use external/OS commands. [**(Run here)**](http://ideone.com/HSviYP)
```
exec"EQAXqwQqQZQxqeasswsrdcqwxqq"^q!5434QZ4S534$S5    <  <AF$SS! 
                  # exec "perl -e\"die\\\"PASSWORD_01\\\"\""
```
* Valid if I can execute Perl via the system. [**(Run here)**](http://ideone.com/SA6vYG) <-- this one uses `print` instead of `die`
The scripts use Perl's bitwise string XOR operator `^`, which does an XOR on the character bits of the two strings. This lets me recreate the missing characters for PASSWORD\_01, and create the characters for the system command.
I made the three variants depending on how lenient the rules are. I assume that since variants 2 and 3 actually output the words on Ideone, the solutions are valid. I removed the little story I had here since I figured no one would read it, but you can read it in the edits if you're curious!
[Answer]
# MS-DOS .COM 8086 machine code (72 bytes)
Time is precious, so no time to dilly-dally with compilers or interpreters! Simply open your text editor of choice and type in the following (replace `\t` with TAB):
```
451D<1DAQX1D11D3AQX4c1DDQX4<SZ!Gq\tGq3WqEEEEESX5\t\t2!<<<<<<<<<eASSWzRD<11$
```
As a hexdump:
```
00000000 : 34 35 31 44 3C 31 44 41 51 58 31 44 31 31 44 33 : 451D<1DAQX1D11D3
00000010 : 41 51 58 34 63 31 44 44 51 58 34 3C 53 5A 21 47 : AQX4c1DDQX4<SZ!G
00000020 : 71 09 47 71 33 57 71 45 45 45 45 45 53 58 35 09 : q.Gq3WqEEEEESX5.
00000030 : 09 32 21 3C 3C 3C 3C 3C 3C 3C 3C 3C 65 41 53 53 : .2!<<<<<<<<<eASS
00000040 : 57 7A 52 44 3C 31 31 24                         : WzRD<11$
```
Save as a .COM file and run it to save the day.
The code assumes [certain start values for registers](http://www.fysnet.net/yourhelp.htm), so might not work for all DOS flavours. Just hope that someone risked being fired by *not* buying IBM.
Slightly more understandable representation:
```
org 0x100
bits 16
cpu 8086
; Assumes the following start values for registers (as per http://www.fysnet.net/yourhelp.htm):
;
;   AX = 0
;   BX = 0
;   CX = 0x00ff
;   SI = 0x100
; Change e => P and z => O
    xor al, 0x35
    xor [si+0x3c], ax
    xor [si+0x41], ax
; Fix int 0x21 and ret
    push cx
    pop ax              ; AX = 0xFF
    xor [si+0x31], ax
    xor [si+0x33], ax
; Change <1 => _0
    inc cx              ; CX = 0x100
    push cx
    pop ax              ; AX = 0x100
    xor al, 0x63        ; AX = 0x163
    xor [si+0x44], ax
; We're using DOS interrupt 0x21, function 0x09 to output the final string.
; AH must equal 0x09 to select the function.
; DS:DX must point to the $-terminated string we want to output.
; Get DX to the correct value (0x13c)
    push cx
    pop ax              ; AX = 0x100
    xor al, 0x3c        ; AX = 0x13c
    push bx
    pop dx              ; DX = 0
; We use part of the Program Segment Prefix to temporarily store the value,
; since MOVing or PUSHing AX is impossible.
; The part in question is the second File Control Block, which we will not use anyway.
    and [bx+0x71], ax
    or [bx+0x71], ax
    xor dx, [bx+0x71]   ; DX = 0x13c
; NOPs to get int 0x21 and ret on high enough addresses
    inc bp
    inc bp
    inc bp
    inc bp
    inc bp
; Set AH to the correct value. AL is set too, but is ignored by the DOS interrupt.
    push bx
    pop ax              ; AX = 0
    xor ax, 0x0909      ; AX = 0x0909
; What will become instructions int 0x21 and ret
    db 0x32, 0x21
    db 0x3c
; Padding to have the password at an address we can refer to.
    times 60-($-$$) db '<'
; Password
    pw  db  "eASSWzRD<11$"
```
[Answer]
# oOo code (300)
```
QwerTaSdfGzxCqwertAsDfgZxCQwerTasDfgZxcQweRtaSDfgZxCqwertAsDFgZXcQWeRtaSdFGzxcQwERTasdfGzxc
QwErtAsdFgzxcqWeRtaSdFGzxcQweRtaSDfGZxCqWErTAsDFgZXCqWerTasDfgZxcQweRtaSdfGzxCQwErTAsDFgZXC
qWertAsDfgzxcQwERtASdFGzXcqWeRTasdFGzXcQWeRtAsDfgzxcQwERtASdFGzXCqWerTaSDfgzXcQWErTaSdFgZxc
QwertaSdFgzXcQWertASdFgZXCq
```
Easy. (Linefeeds are optional, and just here to make the code "more readable")
Code generator used:
```
o=lambda b,c:"".join(i.upper()if j else i for i,j in zip(__import__('itertools').cycle(c),map(int,"".join((3-len(i))*'0'+i for i in(bin('><[]-+.,'.index(i))[2:]for i in b)))))
```
The same code in a less silly encoding:
```
EeeeEeEeeEeeEeeeeeEeEeeEeEEeeeEeeEeeEeeEeeEeeEEeeEeEeeeeeEeEEeEEeEEeEeeEeEEeeeEeEEEeeeeEeee
EeEeeEeeEeeeeeEeEeeEeEEeeeEeeEeeEEeEEeEeEEeEEeEEeEEEeEeeEeeEeeEeeEeeEeeEeeEeeEEeEeEEeEEeEEE
eEeeeEeEeeeeeEeEEeEEeEEeEeeEeEEeeeEEeEeEEeEeEeEeeeeeEeEEeEEeEEeEEeEeeEeEEeeeEeEEEeEeEeEeEee
EeeeeeEeEeeEeEEeeeEEeEeEEEe
```
[Answer]
# [brainfuck](https://github.com/TryItOnline/brainfuck), 400 + 10 (`+`) = 410 bytes
```
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.<.>>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++..++++.<<++++++++++++++.+++.>>>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.<++++++++.>>>>++++++++++++++++++++++++++++++++++++++++++++++++.+.<
```
[Try it online!](https://tio.run/##SypKzMxLK03O/v9fm1Jgp01loGejZ0d1Q0Hm6kFMt0ETBmE76tioBzcbZCLJRuoBDfj/HwA "brainfuck ‚Äì Try It Online")
[Answer]
# [Poetic](https://mcaweb.matc.edu/winslojr/vicom128/final/tio/index.html), 319 bytes
```
war restarts.a test.a craze.a few desecrated areas.a few deceased staff.a sad defeat.waters red.we start a retreat after a war.a carcass wasted.a war act started warfare.war gets screwed.crew defeated.targets set.war affects qatar.a red war creates regret.a war deterred far extra starred staff.we scatter.gee!a regress
```
[Try it online!](https://mcaweb.matc.edu/winslojr/vicom128/final/tio/index.html?PU9BEgMhCPsK/YB/SjV6LjBjp5/fRt3ZEySEBCbcnJHwjAJLtSrV8aNq57TGoHCyGZyIh64CIrXbu8hAE9mJLFNqD/m2Mmnb3CCY2lfXNRWe8BUFr4gQCkWUTRtqnjX5C3cFl8UPZlhU55R0lTtRSOozZW6pjmIV/iB3jh8rvbb067ihg@68Rp20FEoyftOx4/15b71RkVKVQb5w1iOu6432Bw)
Poetic is an esolang I made in 2018 for a class project. It's basically brainfuck with word-lengths instead of symbols.
It was an interesting challenge to write a piece of text with certain word lengths without the right side of the keyboard (or many spaces or punctuation marks). I can only hope that it was worth it.
[Answer]
# ferNANDo, 179 + 10 = 189 bytes
```
2 1
1 2 1 2 1 1 1 1
1 2 1 1 1 1 1 2
1 2 1 2 1 1 2 2
1 2 1 2 1 1 2 2
1 2 1 2 1 2 2 2
1 2 1 1 2 2 2 2
1 2 1 2 1 1 2 1
1 2 1 1 1 2 1 1
1 2 1 2 2 2 2 2
1 1 2 2 1 1 1 1
1 1 2 2 1 1 1 2
```
[Try it online!](http://fernando.tryitonline.net/#code=MiAxCjEgMiAxIDIgMSAxIDEgMQoxIDIgMSAxIDEgMSAxIDIKMSAyIDEgMiAxIDEgMiAyCjEgMiAxIDIgMSAxIDIgMgoxIDIgMSAyIDEgMiAyIDIKMSAyIDEgMSAyIDIgMiAyCjEgMiAxIDIgMSAxIDIgMQoxIDIgMSAxIDEgMiAxIDEKMSAyIDEgMiAyIDIgMiAyCjEgMSAyIDIgMSAxIDEgMQoxIDEgMiAyIDEgMSAxIDI&input=)
`Enter` used. I'd use `0` and `1` to make the code more readable but I can't use `0`.
[Answer]
# JS-Forth, 103 bytes
The string will be returned on the stack as an array of characters.
```
12544 1 3 << >> 24 1 << 1521 4 >> 34 1 << 41 1 << 2531 5 >> 351 2 >> 332 2 >> 32 2 >> 131 1 >> 321 2 >>
```
[**Try it online**](https://repl.it/DjxY/6) - *Commented version*
---
### Explanation:
I first found the list of [allowed words](https://repl.it/DkAH). Essentially, the only things I could use that would be useful are:
* `12345` Numeric constants
* `<<` Shift left
* `>>` Shift right
* `s>f` Push single to float stack
* `f>d` Pop double from float stack
* `fsqrt` Square root on float stack
So I could use numeric constants, bit-shift, and compute a square root using the following (`>>` replaces `drop`, shifting by `0` to remove the `0`):
```
s>f fsqrt f>d >>
```
Fortunately, I found possible bit-shifts for every constant I needed to create that were shorter than using square roots. For the most part, I searched by simply printing each number squared, or a larger power of two if any of them contained a digit `6-0`. Then, I realized I could use loss of precision from `f>d` to find more possibilities. (I could add to the number, but still get the same integer square root.) A bit later, I started using bit-shifting to find some, and then all, of the constants. The greater the `>>` bit-shift, the more I could add to the "magic number" and still get the same result. So I found the smallest bit-shifts I could use to get the necessary results. Even numbers could sometimes use `<<`, odds had to use `>>`.
### Commented code (`\` starts a comment):
```
\ 49
12544 1 3 << >>
\ 48
24 1 <<
\ 95
1521 4 >>
\ 68
34 1 <<
\ 82
41 1 <<
\ 79
2531 5 >>
\ 87
351 2 >>
\ 83 (x2)
332 2 >> 332 2 >>
\ 65
131 1 >>
\ 80
321 2 >>
```
*gForth does not have the words `<<` or `>>`. Instead it has `lshift` and `rshift`, which I could not use*.
[Answer]
# [Decimal](//github.com/aaronryank/Decimal), ~~190~~ 180 + 10 = 190 bytes
```
12055D12025D41D301212055D12010D41D301212055D12025D41D12003D41D30130112004D41D301212055D12024D41D30112003D41D301212055D12013D41D301212055D12040D41D301212045D12003D41D30112001D41D301
```
[Try it online!](https://tio.run/##S0lNzsxNzPn/39DIwNTUBUgambqYGLoYGxgawYUMDTCEIKqADANjqBwQgbgmmEphQsiqkQzHFDJBts/EFMUaENsQyv7/HwA) Decimal is an esoteric language that uses nothing but decimals and the letter `D`. However, I needed the +10 penalty because almost every command uses `0`.
Luckily, all of the commands needed to print `PASSWORD_01` don't require any numbers over `6`:
* `12...D` - push a character
* `2` - pop a value
* `41D` - pop top two stack values, multiply and push result
* `301` - print DSI (default stack index)
By repeatedly pushing character values that only use the digits 1 through 5, then adding them, I can make the character values for each letter in `PASSWORD_01`.
Ungolfed and commented:
```
12055D     ; push char 55 to stack
12025D     ; push char 25 to stack
41D        ; pop [DSI] and [DSI-1], add and push result
3012       ; print from stack to output, pop
12055D     ; push char 55 to stack
12010D     ; push char 10 to stack
41D        ; pop top two stack values, add and push result
3012       ; print from stack to output, pop
12055D     ; push char 55 to stack
12025D     ; push char 25 to stack
41D        ; pop x2, add, push
12003D     ; push char 3 to stack
41D        ; pop x2, add, push
301301     ; print, print
12004D     ; push char 4 to stack
41D        ; pop x2, add, push
3012       ; print, pop
12055D     ; push char 55 to stack
12024D     ; push char 24 to stack
41D        ; pop x2, add, push
301        ; print
12003D     ; push char 4 to stack
41D        ; pop x2, add, push
3012       ; print, pop
12055D     ; push char 55 to stack
12013D     ; push char 13 to stack
41D        ; pop x2, add, push
3012       ; print, pop
12055D     ; push char 55 to stack
12040D     ; push char 40 to stack
41D        ; pop x2, add, push
3012       ; print, pop
12045D     ; push char 45 to stack
12003D     ; push char 3 to stack
41D        ; pop x2, add, push
301        ; print
12001D     ; push char 1 to stack
41D        ; pop x2, add, push
301        ; print
```
[Answer]
# [Stax](https://github.com/tomtheisen/stax), 91+10 bytes
```
"W"EEEd$"$"1 !$Re]"$""ASSW"R"$""a"EEE$"$"a$Re]R"$""RD"R"$""a"EEEd$"$""5"Re]R"$"1 !$R"$""1"R
```
[Try it online!](https://staxlang.xyz/#c=%22W%22EEEd%24%22%24%221+%21%24Re%5D%22%24%22%22ASSW%22R%22%24%22%22a%22EEE%24%22%24%22a%24Re%5DR%22%24%22%22RD%22R%22%24%22%22a%22EEEd%24%22%24%22%225%22Re%5DR%22%24%221+%21%24R%22%24%22%221%22R&i=&a=1)
Uses `]` to make singletons.
## Explanation
Let's see how `"P"` is generated and how the `"ASSW"` is appended without using the usual `+`.
```
"W"                             Push "W", or [87]
   E                            Convert to a scalar, 87
    E                           Convert to an array of digits, [8,7]
     E                          Push 8 on the stack, then push 7.
      d                         Pop the 7 and discard it.
                                Start making components of regex substitution
       $                        Pop 8, push "8"
        "$"                     Push "$"
           1 !                  Push 0. The space is necessary because normally one doesn't do 1! to obtain 0
              $                 Pop 0, push "0"
               R                Do regex substitution 's/$/0/g' on the string "8"
                                Basically doing "8"+"0" without using +
                e               Pop "80", push 80
                 ]              Singleton. Pop 80, push [80], or "P"
                  "$""ASSW"R    Use the same trick again to append "ASSW" to "P"
```
The rest are just repeating the same trick.
`"a"EEE$"$"a$Re]R` swaps the digits of `"a"` or `[97]` to make `[79]` or `"O"` and appends it to the string.
`"$""RD"R appends "RD"`.
`"$""a"EEEd$"$""5"Re]R` uses `"a"` again to obtain `"9"` and discards the `"7"`, then combines the `"9"` with a literal `"5"` to form `[95]` or `"_"`, and appends it to the string.
`"$"1 !$R` obtains a zero by logical not of 1 and appends it to the string.
`"$""1"R` appends the final `"1"` and we are done.
Implicit output.
[Answer]
## Emacs (running in a terminal), 26 bytes (possibly 24 bytes)
The program itself (the commas delimit the boundaries between bytes in the on-the-wire format that Emacs uses to accept its input):
> 
> `W`, `S`, `Ctrl`-`3`, `$`, `D`, `A`, `Ctrl`-`T`, `S`, `R`, `W`, `D`, `Ctrl`-`3`, `$`, `5`, `Ctrl`-`Q`, `5`, `f`, `Ctrl`-`X`, `r`, `Ctrl`-`Space`, `1`, `Ctrl`-`X`, `r`, `g`, `1`, `Ctrl`-`T`
> 
> 
> 
Encoding of this as raw bytes, to prove byte count:
```
00000000: 5753 1b24 4441 1453 5257 441b 2435 1135  WS.$DA.SRWD.$5.5
00000010: 6618 7200 3118 7267 3114                 f.r.1.rg1.
```
(Note: some of the details may vary based on how Emacs is configured; this answer requires **quoted-char-radix** to be set to 16, and for Emacs to use the spellcheck dictionary that's default on my British English system. Both of these seem like reasonable configuration settings, but it's possible that your copy of Emacs may be configured differently. A different dictionary would likely still give a 26-byte program, but slightly different misspellings might need to be used so that the corrections we wanted can be accepted by non-bullet-ridden keys.)
## Note about scoring
In addition to the keys specified in the question, I originally thought this answer required either `Esc` or `Alt` to work. (`Esc` is on the half of the keyboard that's still intact, so it morally feels like it should be allowed, but it isn't explicitly permitted.) However, user2845840's answer points out that (with the usual encoding of terminal control codes) `Esc` can alternatively be typed as `Ctrl`-`3`, and that *is* explicitly permitted by the question. (An aside: while testing this, I learned some other interesting ways to type control codes, with `Ctrl`-`2` typing NUL, and `Ctrl`-`4‚Ä¶7` typing character codes 28‚Ä¶31 respectively. Note that the default configuration of many terminals is to interpret a character code 28 coming from user input as a request to crash the currently running program, so be careful testing this.)
`Alt` is *also* on the intact half of the keyboard but isn't mentioned in the question. Although `Alt` and `Esc` have different encodings in some terminals, they are encoded the same way in other terminals, and (presumably to work around these compatibility issues) Emacs interprets the two keys (and their encodings) as entirely equivalent to each other. If we could use `Alt`, though, it would save two bytes (because it has a shorter encoding than `Esc` does).
## Explanation
I'm not sure whether it should have any influence on the editor wars, but Emacs seems to beat vim at least in the case of this question. Emacs is pretty suited to editor golf measured in bytes, because it relies heavily on chords which take up multiple keypresses but only a single byte (thus an Emacs program is often slower to type than the equivalent Vim program, but shorter on disk). Additionally, most of the most important Emacs commands are in the bottom-left corner of the keyboard, to be close to `Ctrl`, very helpful with a question like this one.
"You can assume you have the interpreter shell / source editor opened before the bullets came in. Sadly you have not written anything in it before the keyboard was hit.", so I'm assuming that we have an empty file open in Emacs and need to type the password into it. (We'd need to save the file afterwards, and probably exit Emacs, but the bytes for that aren't being counted in other people's answers so I'm not counting them here either. It's totally doable using the left hand side of the keyboard, though, `Ctrl`-`X`, `Ctrl`-`S`, `Ctrl`-`X`, `Ctrl`-`C`.)
Taking it a command (or block of similar commands) at a time:
* `W`, `S`: Enter `WS` into the document.
* `Ctrl`-`3`, `$`: Invoke the spellchecker. `WS` isn't a real word, but it finds lots of similar two-letter words. (The usual way to invoke the spellchecker is `Alt`-`$`; here, we're using `Ctrl`-`3` as a stand-in for `Esc`, which in turn is a stand-in for `Alt`.)
* `D`: Using the spellchecker, correct `WS` to `PS`. (When the spellchecker is invoked using `Alt`-`$`, as happened here, it only checks one word, so it deactivates after doing this.)
* `A`: insert `A`, giving `PSA`.
* `Ctrl`-`T`: Swap the previous two characters, giving `PAS`.
* `S`, `R`, `W`, `D`: Type `SRWD`, giving `PASSRWD`.
* `Ctrl`-`3`, `$`, `5`: We invoke the spellchecker again, because we want to correct our misspelled `PASSRWD` into `PASSWORD`. Note that we can't have it guess the word we want on our first try, like it would with `PASSWRD`, because the key to accept the closest real word is `0` which we can't press. As a result, the slightly more extreme misspelling `PASSRWD` is used to push the word we want into position 5, where we can accept it.
* `Ctrl`-`Q`, `5`, `f`: Insert the character with character code U+5f, i.e. `_`. The document now reads `PASSWORD_` (or will when we start typing the next command; before then, the underscore doesn't appear in case we type another hex digit).
* `Ctrl`-`X`, `r`, `Ctrl`-`Space`, `1`: Store the current cursor position (relative to the start of the file) in register 1. For some bizarre reason, this is 1-indexed, so (having written 9 characters so far) the cursor is at position `10`.
* `Ctrl`-`X`, `r`, `g`, `1`: Copy the content of register 1 into the document. It now reads `PASSWORD_10`.
* `Ctrl`-`T`: Swap the two characters before the cursor. We now have `PASSWORD_01`, like the question asks for.
If we're allowed to use `Alt`, we can probably encode the "invoke spellchecker" command as the single byte `a4` rather than spelling it out as `1b` `24`; it appears twice, so that leads to two bytes of savings. (Most modern terminals use `1b` `24` as the encoding for `Alt`-`$` to avoid clashes with UTF-8, but the `a4` encoding is also encountered from time to time, sometimes available as a configuration option.)
Possible byte savings probably involve golfier misspellings to correct. `PSASWRD` would be a byte shorter to type, but unfortunately, the spellchecker doesn't seem capable of gleaning `PASSWORD` out of that, so `PASSRWD` is the best approach I've found so far. The register-based approach to gaining `10` is also ridiculously unwieldy, but there aren't many ways of creating numbers from nowhere in Emacs, and `0` is a painful character to get hold of otherwise. (At least there were a couple of amazingly useful coincidences: the cursor just happening to end up in position `10`, which contains a `0`, right when needed; and the fact that Emacs accepts the redundant `g` register operation to insert the contents of a register into the document, in addition to the more intuitive `i`.)
[Answer]
# [Whitespace](https://web.archive.org/web/20150618184706/http://compsoc.dur.ac.uk/whitespace/tutorial.php), score: 111 (101 bytes + 10 for `Enter`)
```
[S S T  T   T   T   T   T   N
_Push_-31_1][S S T  T   S S S S S N
_Push_-32_0][S S S T    T   T   T   N
_Push_15__][S S T   T   T   S S N
_Push_-12_D][S S S T    S N
_Push_2_R][S S T    T   N
_Push_-1_O][S S S T T   T   N
_Push_7_W][S S S T  T   N
_Push_3_S][S N
S _Duplicate_3_S][S S T T   T   T   T   N
_Push_-15_A][S S S N
_Push_0_P][N
S S N
_Create_Label_LOOP][S S S T S T S S S S N
_Push_80][T S S S _Add][T   N
S S _Output_as_character][N
S N
N
_Jump_to_Label_LOOP]
```
Letters `S` (space), `T` (tab), and `N` (new-line) added as highlighting only.  
`[..._some_action]` added as explanation only.
[Try it online](https://tio.run/##K8/ILEktLkhMTv3/X0GBEwy4QAwFEACyFOAinFC@ApgHlYJQXHCVYAEuLphSsDFcIJITLMbF9f8/AA) (with raw spaces, tabs and new-lines only).
**Explanation in pseudo-code:**
This solution is shorter than [the existing Whitespace answer](https://codegolf.stackexchange.com/a/31564/52210) (*@nÃ¥ÃãÃñhÃ∑ÃÉÕâaÃ∑ÃøÃ≠hÃ∏ÃÖÃ°tÃµÕÑÃ®dÃ∑ÕÄÃ∞hÃ∑ÃÇÃ≥* asked me to post it as a separated answer when I suggested it as golf) by utilizing [this Whitespace tip of mine](https://codegolf.stackexchange.com/questions/48442/tips-for-golfing-in-whitespace/158232#158232).
```
Push the code-points for the characters of "10_DROWSSAP" minus constant 80 to the stack
Start LOOP:
  Add 80 to the current code-point
  Pop and output it as character
  Go to the next iteration of LOOP
```
The constant `80` has been generated with [this Java program](https://tio.run/##fVLva9swEP3ev@K4TxJKTQorY3FESdk@GJZt1Nk66EqRXTVR58iedA6Ekb/dk2s7P7bRLxK69@7p7t49q406f3782TR5obyHuTL29xlAVWeFycGTonBtSvMI6wCxlJyxy7t7ULylAXQBcNrXBYEEdTe@j18QYwn8WhWF9i2QWNJL7aL57PvDt9nHrx9GkMi3l/GxykC/GdQQO/ypdKzVMzKJzfTichwbIfoKDjVIxBGNKjlkdXnZljRkk67CaKnpOgQ84/t0AJJBfFHerkxAKpXra2OV23a6LDs3PN5znWQU6V@1Kjyr@BWmn37YFCfEhTuQKknDY9ff5om5qNB2SSvGYbrv9aiMf9o/Ujya5EHmACchbk6/7M5060mvo7KmqArdUGEZdukSxSAqMA6jRZEIhAmgeG0aCe@//VuZnZb/wtqdhaNfot6l17Rbi20/kI1ywRdMUxTMTsdXuMAJpshPFyKfDHtF5YlUi/K5olWkMs8s5/9znoTMp2/eBROD9qLfmm5uTlPtbGBg8Be7XnZN03yZpent55v3D@OLPw), which I've created and used for some previous Whitespace answers of mine.
[Answer]
# Befunge-98, 43 +10 = 53 bytes
```
"1qA¬∑DR¬∑WSSA¬∑g"%,$,,,,$"s"%,,,$"c"%,%,,q
```
[Try it online!](http://befunge-98.tryitonline.net/#code=IjFxQcK3RFLCt1dTU0HCt2ciJSwkLCwsLCQicyIlLCwsJCJjIiUsJSwscQ&input=)
The 10 byte penalty is for the use of the `,` key (not sure why this couldn't be accomplished with `Shift`+`<`, but that seems to be the rule). And although the source is technically 40 characters, the three `¬∑` characters contribute an additional three bytes because of their UTF-8 encoding.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~87~~ 86 bytes
```
"."A1.$R24.$AT<.$R15>.$A21<.$R5.$.V.VD21s.V.V15>X.V"ASSW"15X.V"RD"122D<s2X.V.VTRTX.V.V
```
[Try it online!](https://tio.run/##HcqxCsAgDIThdwnOBwl1k4LgE6hY1xY6dOrg@5Mmnf4P7t51Xs@tSqDMCFU2hNyTieNuFHZHBAyMIry8Nk0Myq0dxNFZC7FISUumH3rtf1U/ "05AB1E ‚Äì Try It Online")
~~Maybe the longest 05AB1E code ever?~~
Unfortunately the language doesn't support things like `"Q"<` for "decrement Q to get P"
My extra key is the V.
Thanks to @Kevin Cruijssen for -1 byte.
Code:
```
Build the string ".b". This is the code to turn integers to upper case letters:
"."             push "."
A               push the lower case alphabet
1.$             drop the first letter of that
R               reverse the remaining string 
24.$            drop the first 24 letters of that, so only "b" remains
AT<.$R15>.$     do the same trick for "j"
A21<.$R5.$      and for "u" 
.V              run "u" as code to turn "j" to "J"
.V              run "J" as code, to join ".", "b" to ".b"
Save that string for later use:
D               duplicate
21              push 21
s               switch the top two elements [".b", 21, ".b"]
.V              run ".b" as code, to get "U"
.V              run "U" as code, to save ".b" in X
Build password string:
15>X.V          push the 16th letter of the alphabet ("P")
"ASSW"          push "ASSW"
15X.V           push "O"
"RD"            push "RD"
122D<s2X.V      push 121, 122, "B"
.V              run that as code to push "_"
TR              push 01
TX.V            push "J"
.V              run that as code, to join everything to the desired string 
```
For comparison: The shortest way to print "PASSWORD\_01" is 6 bytes long
[Try it online!](https://tio.run/##yy9OTMpM/f//UcOMRw0LDs@LNzD8/x8A "05AB1E ‚Äì Try It Online")
[Answer]
## [Lenguage](https://esolangs.org/wiki/Lenguage), 814814390776628060509605577373181765864505940171473720140916436885644483746988990322785194756 bytes
Converted from this program:
```
++++++++++[>++++++++>+++++++>+++++++++>++++++++++>+++++<<<<<-]>.>-----.<+++..>>---.<<----.+++.>+++.>>-----.>--.+.
```
[Try BF code online!](https://tio.run/##SypKzMxLK03O/v9fGw6i7WAsOzQamQVl2oCAbqydnp0uCOjZAMX09OzswGwbsBBIxA5MQNXYgQT1/v8HAA "brainfuck ‚Äì Try It Online")
[Answer]
# [Width](https://github.com/stestoltz/Width), 23 + 10 (`m`) = 33 bytes
```
GFmaaAfAfAAFGAiawwafwfG
```
[Try it online!](https://tio.run/##K89MKcn4/9/dLTcx0TENCB3d3B0zE8vLE9PK09z//wcA "Width ‚Äì Try It Online")
[Answer]
# [Knight](https://github.com/knight-lang/knight-lang), ~~63~~ 62 + 10 (`+`) bytes
```
E++A+55 24+A34+A+55 25+"ASSW"+A+55 24+"RD"+A+54 41+A+45 3 1A34
```
[Try it online!](https://tio.run/##rVhbc9pGFH6GX7FWxkiLRCMJPNMBBOMkdsZTx07tpHmwaYqFsDUjC0aIpm3s/vX0nLO70i7gtGnLg8Tunuu35wZx5zaOvzxL8zhbz5Lhqpyli@/uRk19J0tvjK24/H2ZbBAVaX5rbJXpvaCZJfM0T1iWsWyR39Kj2nx39v4NC@rl5bsLFtbLnw4vWK9eHp@9ZN/Xy4v3LKiJj08vNdqz96ca6fuzN4eXPzgrzhx4tP4MDnh1dngJSsVRfDct2rwi1mnATsU@GvXqk7OjD3iUwxH68gDfhkPzHMXTOXx5cLKMw8ogeHF@fkoU8BiDV31wRdN98VocAmtl3K/TbJ1wfpVPeLNJZsMNJNP76MI6Oj92vhy57qF7cMDCnnvY7cnvB64Fzn6wqiPr4hUteqwXwLt3wLosAPovHIRYgyZc2XJarBKHs8/NRpqXLB00G7BL6j3Wnq/zGHbQABbDurxfeqtlfhVOos@@5z8OmsDGIkEPbx@IP92lWeKAuUDoCKs9Zl2X1/n1/Lpgnx@vJg7vP7M4KW2kc@ZI51gUMfuZzZkQoXb3YPc6h23XFTugpJFkq0TfeJSKmZOuZultWip2UIMWBl5lpHi3WeAzl7Wlia7LWYfZvg2y0KSUsyIp10UuQviBiSthwyHr8crLdJUtPiWFE4NYpY89PDBlQ0yrmBz7aHPpbrrDlTQKPEA3qrY3jMBMASMguhiQ5LP10sHLYBKjDoMVl2xC37Vt18otW6ANVGBqpZ09f84gn@E7mLCcrkpW3iUgc1qUQCwBbSuE8CZiVNJQVmE6/51V8Ay4uCHNa4wifwK2xMrX1Xq5RCi5un@1owOrRwoAqglEGSroljlEHFQTjDFpqoDhnc3GVFf6cuMYN7Cy9LGiYDirKKFiJHxzMA3Q1GmWLWKn53sBR49w23RCCL3QgH9rVyaQZMUWIJtMvl3WHx69ePnLj3unr841JwwJ4baEPUPE65PLp3i727zC3Nd2ZfnJE5b3TF6T5BFrSrHOEbYBFS4oGouVo2oKRSHEV5nGjE5v1vOrsDeRRgjwW5RzlfbVEnpPOXeAFLzaz7KZpZJ5NIJs9FDIpgCIzEqA6ABCv0E3ZEHXdBI9x/gYM6ss1okFcVHtY5jA/nwK@YoHVr7OMquGAP1E12XtRjA@vlgsMji4MQF40tXaq6/50/52h3QrbzatxDsrF/n/aiNEYrnIMkc31WO@B1X3X5icb5mMzerN4dszD1uWiDNYnlwFvu9PqLPBUq1W6R/Jx5Lha9CsI1TzFhGAlYePkJ7dKFCdD4sONj980TMUry4QHJ@cHrXZHOrVoFFFttSHpTCeLr0syalRalg5sqsIzCDnngJjkxEbAfaR@aKAmkktF/rbkLAYQGFP8bAqBvH9cuMGCKR0UtcFhCmdoJrVp7SM75w2zSHMHEQAIyY/MfYK@9DuM9QiCCIEFAcZKIy8RU5J8XJ@MkKWD6jl1RQ0oJUFtg@a0a4m/HMdZjBnULkVii9AsSm7mOYzh7f83@bwqQnfAiEIFRDdJmUGw5bToqts4QVhl5qlOR@kc8eh68TmG98VaIoHYcq5uOXIH@w0FV5ol9J3JPRRd6JaIPEYKHMRI1k3aytf1O4I@urkZX2CnDrCFc0vQIPBAOEXLRfLJHc0xZ5VWNStwaroXvQuCMco9Hvf077s744YCuZg@gydgqkIItbDkQnIoX3TCnWAahVdDmwyN6KxAxMWKLmEG@SQLoIaJbQjFupjQw1j7cmP4EnyG4xMmOxbfu4Zl07z9B4Wsi3C063oAC2ZiYtG/sruy5lsRxxXhU/2H@tsfX8D8wh2IK5aEP5YqIe4rWqoWC/p95Ozv0JGMxe2mQFOGEZ0vVBIuVWTqgPsLsk0l2KfamCyY@k3oBq6QOG8RgETA65Qgibu04COtVp4etXpIOlETJrXNNo2lFn737VXYI8DK85UqhWa@etypW6/igkxfQmD3MogKpNQLrEiY2hp1yMG2oZ52@KHHFLDjM1ULIXiznEEpWQQF0BUuI1ZHikvQ747VONpqV5yDgzcGiauvqMsDvOhR@9S1gjpV2crOrVox2nZtFcwtevb2YHCZnfegUN7Cwdxr7tQuN/hWptoIl0IMUALcqhCRvY1/G5CokGnQ/IkUNQxNy9aIFoa2f/8q8A83w3M/leZ9ncz/UxoGg6JYZ72Qt3LgYRdoB6xTlChTLQAfQB51gkgxwKdOPxG6iGUR4M2ipCU9PbVjq8gJ6DDkS@xDjlNK@2I8G9uJgQdal1qSP5v1FLMIyPVIjPRxkyPp6GOLLL2xX8fwCwIxswYPWjTY1qCoQxfcKoqHorSgrR7ERQwzeTRfzd59D@YPFIm7@2wOZI2S5PHT5sstO4wGY/HzCAIK4pQ1d69XXbWi8o9FbS6gMq8Vp056MuusjLWOWUUVvwP/4Rfhq8mpuIf2H2d2piQNmmjOmHN428egdVYVM/ASNcw5uAqi4gGJU4ig1vLMORACtet2ITJH8A98ReGPqMY3jG97Um2E3PgQ1KNfxz2uxosr8W0GWnN2dVr1/Z0ncuZ1atyoWvMQpcC6A2hg81qGe6qll1etZCw4u7R5t/0UjQM33gVcTU3Vp1Ub6sheIha3QD7K/UWEf/ikF5E4cpMAO2zZD5dZyV4poaTNIfDdEb/PkzjMimgkcQ2jiu4w9kTv39QGM2n8r@sR/oFej9Nc4fjXxr0IwT/End8UmwO@49f/gI)
As noted on [Encode your program with the fewest distinct characters possible](https://codegolf.stackexchange.com/a/226869/94093), Knight needs a minimum of `AE +1` to be fully usable (even if it is more torturous than Brainfuck). The `+` is required to do `ASCII` arithmetic.
This program generates the string `O"PASSWORD_01"` by assembling codepoints, and `EVAL`s it with `E`.
XXX: check if `SUBSTITUTE` is beneficial here
---
# [Knight](https://github.com/knight-lang/knight-lang), ~~113~~ 110 bytes
```
E S S S S S S S"ASSWRD1"%21 14F A34%21 15F A%152 52%21 15F A%321A"q"4F A%211 132F!1A%211 131F!1A34F!1A%211 132
```
[Try it online!](https://tio.run/##rVhtc9pGEP4Mv@JQxkgHIpEEmekAgrETO@OpY6d20nywaYKFsDUjCypE0zZ2/3q6u3cn3QFOmzb2DNLd7etz@wZR5yaKvjxJsihdz@Lhqpgli6e3o7q@kybXxlZU/LGMN4jyJLsxtorkTtDM4nmSxSxNWbrIbuij3Hx7@u4186vlxdtzFlTLn/fPWa9aHp2@YD9Uy/N3zK@Ij04uNNrTdyca6bvT1/sXPzorzhz4aP7lP@fl2f4FKBVH0e00b/GSWKcBOxX7aNSrTk4P3@NRBkfoyz28DYfmOYqnc3i5d9KUw8ogODg7OyEK@BiDV31wRdN9/kocAmtp3G/TdB1zfplNeL1OZsMNxNO78Nw6PDtyvhyyC/3fAiffn7/0rb3AZ37viO13e/T6HF73/OcBex5U627g71u/WkgGm7DbDY4avnr38b3b03aCLxyUWoM6XPFymq9ih7PP9VqSFSwZ1GuwS@a6rDVfZxHsoMEsgnVxt3RXy@wymISfPdd7GNSBjYWCHp4eEH@6TdLYAfeA0BFeusy6Kq6yq/lVzj4/XE4c3n9icVJaS@bMkWCwMGT2E5szIULtNmD3KoPtdlvsgJJanK5ifeNBKmZOspolN0mh2EENWui7pZHi2WK@x9qsJU1stznrMNuzQRaalHCWx8U6z0TI3zNxhWw4ZD1eepms0sWnOHciEKv0sft7pmyIaBWRYx9sLt1NdriShL4L6Ibl9oYRmFlgBEQjA5Jstl46eBlMYtRhsOKSTei7su1KuWULtIEKTC21s2fPGOQ/vIMJy@mqYMVtDDKneQHEEtCWQghvIkIlNWUVpv8/WQWfPhc3pHmNUeRNwJZI@bpaL5cIJVf3r3Z0YPVIAUA1gShDBd0yg4iD6oMxJk0VMLy12ZjqUF9uHOEGVqI@ViAMZxUlVLyEbw6mAZo6TdNF5PQ81@foEW6bTgih5xrwb@zSBJKs2Hxkk8m3y/r9w4MXH39qnLw805wwJATbEhqGiFfHF4/xdrd5hbmv7NLy40cs75m8JskD1pR8nSFsAyp0UDQWK0fVFIpCiK8iiRidXq/nl0FvIo0Q4Dcp50rtqyX0qmLuACl4tZemM0sl82gE2eiikE0BEJmlANExhH6DbgjF0HQSPcf4GDOryNexBXFR7mOYwP58CvmKB1a2TlOrggD9RNdlrUcwPhwsFikcXJsAPOpq5dXX/Gl9u0O6ldebVuKdFYvsu9oIkVgs0tTRTXWZ50LV/Q8mZ1smY7N6vf/m1MWWJeIMlseXvud5E@pssFSrVfJn/KFg@BjUqwjVvEUEYOXiR0Cf3dBXnQ@LDjY/fNBnIB5dIDg6PjlssTnUq0GtjGypD0thNF26aZxRo9SwcmRXEZhBzj0GxiYjNgLsI/NFDjWTWi70tyFhMYDCnuBhWQyiu@XGDRBIyaSqCwhTMkE1q09JEd06LZpbmDm4AEZM/kXYK@x9u89QiyAIEVAcfKAw8iY5JcXLecsIWT6glldR0EBX5Ng@aKa7nPDPVZjBnEHlVig@B8Wm7HyazRze9H6fw19F@AYIQaiA6CYuUhjOnCZdZRMvCLvULMn4IJk7Dl0nNt/oNkdTXAhTzsUth95gp6nwQLuUvkOhj7oT1QKJx0CZixjJullZeVC5I@jLkxfVCXLqCJc0H4EGgwHCL1wulnHmaIpdK7eoW4NV4Z3oXRCOYeD1fqB92d8dMRTMwfQZOgVTEUSsiyMTkEP7phXqANUquhzYZO2Qxg5MWKDkEm6QQ7oIapTQClmgjw0VjJUnP4En8e8wMmGyb/nZMC6d5u8GFrItwpOt6AAtqYmLRv7S7suZbEccl4VP9h/rdH13DfMIdiCuWhB@uaiGuK1qqFgv6PuWs7dCRjMXtpkBThhGdL1QSLlVkaoD7C7xNJNiH2tgsmPpN6AaukDhrEIBEwOuUIIm7tOAjjWbeHrZ6SDpREyaVzTa1pRZe09bK7DHgRVnKtVyzfx1sVK3X8aEmL6EQe3SICqTUC6xImNoadcjBtqaedviix9Sw4zNVCwF4s5xBKVkEBdAVLiNWR4qLwO@O1SjaaEecg702xVMXL2jLA7zoUvPQtYI6VdnKzq1aMdp2bRXMLWq29mBwmZ33oFDawsHca@7ULjb4VqLaEJdCDFAC3KoQob2FXxvQqJBp0PyJFDUMTcvWiBaGNn/7KvAPNsNzN5XmfZ2M/1CaBoOiWGe9gLdy4GEXaAeso5foky0AL0PedbxIcd8nTj4RuohlEeDNgyRlPT21Y6nICegg5EnsQ44TSutkPCvbyYEHWpdakj@b9RSzCMj1UIz0cZMj6ehjiyy9sVvJcAsCMbMGD1o02VagqEMT3CqKh6I0oK0jRAKmGby6P@bPPoOJo@UyY0dNofSZmny@HGThdYdJuPxmBkEQUkRqNrb2GVntSjdU0GrCyjNa1aZg77sKitjnVNGYcl//2/4ZfhqYkr@gd3XqY0JaZM2rBLWPP7mEViNRdUMjHQ1Yw4us4hoUOIkNLi1DEMOpGi3SzZh8ntwT/yEoc8ohndMb3uS7dgc@JBU4x8H/a4GyysxbYZac27rtWt7us7kzOqWudA1ZqELAfSG0MFmtQx2VcsuL1tIUHL3aPMfeikahk@8iqicG8tOqrfVADxErW0f@yv1FhH/4pAeRNGWmQDaZ/F8uk4L8EwNJ0kGh8mMfn2YRkWcQyOJbBxXcIezR77/oDCaT@VvWQ/0DfRummQOx5806EsI/oTueKTYHPYfvvwN "C (gcc) ‚Äì Try It Online")
Even without `+`, we can still do this. `SUBSTITUTE` can allow us to insert strings into other strings, and we can still generate single chars with `A%x y`. But I think `+` is worth it, no?
Generates the same string.
For the reference, the magic numbers are:
```
%21 14   -> 7
%21 15   -> 6
%152 52  -> 48 ('0')
%321A"q" -> %321 113 -> 95 ('_') # used to prevent token collision
%211 132 -> 79 ('O')
%211 131 -> 80 ('P')
```
* 3 bytes: use `!1` instead of `F` to avoid token collisions
[Answer]
# Julia 1.5, 38 +10 (`ENTER`) = 48 "bytes"
The keystrokes not available are, of course, `PO_0`. For Julia, the others are all simple, and simply outputting the string `"PASSWORD_01"` should count by the rules. Also required: `ENTER`, as the alternate way to process that in Julia's REPL is Ctrl-J, and J isn't available.
Fortunately, one of the inbuilt commands that you can use `TAB` to autocomplete is `DEPOT_PATH`, which provides access to three of the characters. And shortcuts can handle deleting the undesired letters and positioning the cursor to add the missing ones. To get the 0, the easiest method I've found is to use autocomplete to get `frexp`, and then `exp10`.
**Inputs**
Type: fr`TAB``Ctrl-A``Ctrl-D``Ctrl-D``Ctrl-E`1`TAB`
Result: `exp10`
Type: `Ctrl-A`DE`TAB`
Result: `DEPOT_PATHexp10`
Type: `Ctrl-A`"`Ctrl-D``Ctrl-D``Ctrl-F`ASSW`Ctrl-F``Ctrl-D`RD`Ctrl-F``Ctrl-D``Ctrl-D``Ctrl-D``Ctrl-D``Ctrl-D``Ctrl-D``Ctrl-D``Ctrl-F``Ctrl-T`"`ENTER`
Result: `"PASSWORD_01"` as output (rather than command) on hitting enter.
**Explanation**
Autocomplete with `TAB` will work as long as there is only one known autocomplete option (otherwise, double-tab will bring up a list of possible completions).
`Ctrl-A` moves the cursor to the start of the line, `Ctrl-D` deletes the next character, `Ctrl-F` advances the cursor forward one space, and `Ctrl-T` switches the positions of the characters before and after the cursor (and moves the cursor forward one place).
[Answer]
# [Deadfish~](https://github.com/TryItOnline/deadfish-), 154 + 10 bytes
```
iiissdcdddddddddddddddciiiiiiiiiiiiiiiiiicciiiicddddddddciiicddddddddddddddciiiiiiiiiiiiiiiiiiiiiiiiiiicdddddddddddddddddddddddddddddddddddddddddddddddcic
```
[Try it online!](https://tio.run/##S0lNTEnLLM7Q/f8/MzOzuDglOQUVJGdigGSwWDKyimSCmhC6U0gDyZnJ//8DAA "Deadfish~ ‚Äì Try It Online")
No `{}` :(
Needs `i`, you can't do anything without it...
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), 39 + 10 (+) = 49 bytes
```
r1++++++C+55 25"ASSW"e<G15"RD"C+54 41Z1
```
[Try it online!](https://tio.run/##K6gsyfj/v8hQGwyctU1NFYxMlRyDg8OVUm3cDU2VglyUgKImCiaGUYb//wMA "Pyth ‚Äì Try It Online")
This could probably be golfed a bit more but I give up. :) The code adds a series of strings to the stack, appends them all, and then translates the whole thing to uppercase. That leaves one string on the stack which is printed automatically when the code exits.
The Pyth specific tricks used here are related to getting the characters not available on the limited keyboard. The `P` and `_` characters are generated by computing the codepoint of the character and using the Pyth `C` function. And the `o` character is extracted from the `G` variable, which is pre-defined to hold the alphabet. The `r1` translation is needed just for that, since the alphabet constant is lowercase. That turns out to be the same number of characters as the codepoint method, so left both in the code.
I had to add the `+` character so the code gets a +10 penalty.
```
         +55 25                         - push 75 on the stack
        C                               - convert codepoint to "P"
               "ASSW"                   - push "ASSW" to the stack
       +                                - append top two stack entries
                       G                - push "abc...xyz" to the stack
                      < 15              - take 15 char substring
                     e                  - take last char on string "o"
      +                                 - append top two stack entries
                          "RD"          - push "RD" into the stack
     +                                  - append top two stack entries
                               +54 45   - push 95 on the stack
                              C         - convert codepoint to "_"
    +                                   - append top two stack entries
                                     Z  - push 0 onto the stack
   +                                    - append top two stack entries
                                      1 - push 1 onto the stack
  +                                     - append top two stack entries
r1                                      - convert to uppercase
```
]