[Question]
  [
*This is the cop's thread of a [cops-and-robbers](/questions/tagged/cops-and-robbers "show questions tagged 'cops-and-robbers'") challenge. You can view the robber's thread [here](https://codegolf.stackexchange.com/questions/207560)*
A pretty common beginner style question is to print some string, but there's a catch! You need to do it without using any of the characters in the string itself!
For this challenge, we will find out who is the best at printing X without X. There are two threads to this, a cop's thread and a robber's thread.
In the cop's thread (this thread), users will choose a language (which we will call Y) and a string (which we will call X) and write a program in language Y which takes no input, and outputs exactly X without using any of the characters in X. The cop will then post both X and Y without revealing the program they have written.
Robbers will select the cop's answers and write programs in language Y which take no input and output X. They will post these "cracks" as answers in their thread. A crack need only work, not to be the intended solution.
Once a cop's answer is one week old, so long as it has not been cracked, the cop may reveal their program and mark it as "safe". Safe answers can no longer be cracked and are eligible for scoring.
Cops will be scored by length of X in characters with smaller scores being better. Only safe answers are eligible for scoring.
## Extra Rules
You may be as specific or precise in choosing your language as you wish. For example you may say your language is Python, or Python 3, Python 3.9 (pre-release), or even point to a specific implementation. Robber's solutions need only work in one implementation of the given language. So, for example, if you say Python is your language, a robber's crack is not required to work in *all* versions of Python, only one.
Since [command line flags](https://codegolf.meta.stackexchange.com/a/14339/56656) and [repls](https://codegolf.meta.stackexchange.com/a/7844/56656) count as different languages, if your language is one of those then you should indicate that as at least a possible option for the language. For ease of use, I ask that you assume there are no command line flags in cases where command line flags are not mentioned.
You may choose to have your output as an error. If your intended solution does output as an error, you must indicate this in your answer.
## Find Uncracked Cops
```
<script>site = 'meta.codegolf'; postID = 5686; isAnswer = false; QUESTION_ID = 207558;</script><script src='https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js'></script><script>jQuery(function(){var u='https://api.stackexchange.com/2.2/';if(isAnswer)u+='answers/'+postID+'?order=asc&sort=creation&site='+site+'&filter=!GeEyUcJFJeRCD';else u+='questions/'+postID+'?order=asc&sort=creation&site='+site+'&filter=!GeEyUcJFJO6t)';jQuery.get(u,function(b){function d(s){return jQuery('<textarea>').html(s).text()};function r(l){return new RegExp('<pre class="snippet-code-'+l+'\\b[^>]*><code>([\\s\\S]*?)</code></pre>')};b=b.items[0].body;var j=r('js').exec(b),c=r('css').exec(b),h=r('html').exec(b);if(c!==null)jQuery('head').append(jQuery('<style>').text(d(c[1])));if (h!==null)jQuery('body').append(d(h[1]));if(j!==null)jQuery('body').append(jQuery('<script>').text(d(j[1])))})})</script>
```
  
[Answer]
# Python 3, Score: 81, [Cracked](https://codegolf.stackexchange.com/a/207567/36398)
X =  `abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!"#$%&'*,./:;<=>?@[]^_`{|}~`
Not terribly interesting since it has such a high score, but this should be somewhat difficult to crack...
**Clarification:** This is in fact a full Python 3 program, running it locally with `python3 print_x_out.py` produces the above output for me. Likewise, the below verifier script produces no output:
```
with open("print_x_out.py") as file:
    source = file.read()
output = """ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!"#$%&'*,./:;<=>?@[\]^_`{|}~"""
for c in output:
    if c in source:
        print(f"Failed verifier check for '{c}'")
```
**Edit:** Well, that was faster than expected...
[Answer]
# Javascript (Browser), score: 3, [Cracked](https://codegolf.stackexchange.com/a/207575/91569)
```
(\)
```
Simple, but hard.
My solution:
> 
> `Function`$${unescape`alert%28"%28%5C%5C%29"%29`}````
> 
> 
> 
[Answer]
# Python 3.7, Score: 1 - [Cracked](https://codegolf.stackexchange.com/a/207662)
X = `(`
Same base rules as [nthistle's challenge](https://codegolf.stackexchange.com/a/207563) above: must be a full script, run with `python3 print_x_out.py`.
I believe it's not possible to use [wacky non-ascii substitutes](https://codegolf.stackexchange.com/a/207567) for `(` in a Python 3 script, but I may be wrong (I haven't tried them all). My solution does not use that approach, anyway, and the intention is that yours should not either—now that we've seen it once, there's no fun in taking that as the easy way out for all Python 3 challenges.
I know code length is not in the rules, but as we're all golfers here I'd be curious to see how short the solution can get. FWIW mine is 104 characters (97 if we're allowing a trailing newline at the end of the output).
[Answer]
# [Haskell](https://www.haskell.org/), Score 81, [Cracked](https://codegolf.stackexchange.com/a/207593/56656)
```
" !#$%&()*+/0123456789;>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ\\^_`bcdefghjkloqsuvwxyz{}~"
```
This one might be a little difficult.
### Stuff you don't have
You don't have newlines or spaces (my intended answer doesn't use *any* whitespace at all, however I can't get it to print some of the funkier whitespace characters so you are free to use them for yourself). You also don't have any of the other ways to apply functions such as `$` or parentheses. You don't have the other line delimiter `;`, so everything has to be on one line (as far as I know).
### Stuff you do have
I had to give you the bare minimum of `main=` for a complete program. I've also given you `prt` as extra letters, it shouldn't take much to see that this allows for `print`.
You also have an assortment of other symbols available to you, I'll let you figure out how to use them.
```
:,.[|<-]'
```
These are all the characters I've used, there are no unprintables present in my intended solution. However since I can't print the unprintables you are fine to use them.
For your reference here are all the functions available using only the permitted characters:
```
(||) (==) (<) (<=) min (-) pi tan atan (=<<) (.) map init (:) print
```
# Even harder Haskell, Score 82, [Cracked](https://codegolf.stackexchange.com/a/207593/56656)
```
" !#$%&()*+/0123456789:;>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ\\^_`bcdefghjkloqsuvwxyz{}~"
```
A little while after I posted this I realized I do not *need* `:`, so this version has a `:` in the output as well. I have posted in this answer to prevent clutter from two nearly identical answers, but both should be crack-able separately.
[Answer]
# Rust, score 3 (safe)
`pwx`
No `extern` possible this time, so no calling C functions! (or other crates, but that wouldn't be allowed anyways)
Pretty challenging to output to stdout without being able to type `print` or `write`!
Rust version: `rustc 1.45.1 (c367798cf 2020-07-26)`
---
## Solution
The main challenge is printing to stdout. I identified the following methods:
* `print!`/`println!`
* `std::io::stdout()` and then:
	+ `write!`/`writeln!` (or `std::fmt::Write`)
	+ using the `std::io::Write` trait and calling `.write()` or similar
All of these require calling a method or macro whose name is excluded by `p` or `w`.
Enter [trait objects](https://doc.rust-lang.org/book/ch17-02-trait-objects.html), Rust's method of having runtime polymorphism. Trait objects are pointers both to some data (like regular pointers) and to a `vtable` which is used to look up the implementation of the trait method when called. So a the code
```
let trait_obj : &mut dyn Write = ...;
trait_obj.write(&buf[..]);
```
is transformed to something like this
```
let trait_obj : (&WriteVtable, *mut ()) = ...;
(trait_obj.0[WriteVtable::write_index])(trait_obj.1, &buf[..])
```
Now we obviously still can't directly call `.write` on the `&dyn Write` trait object, but we can instead do the vtable lookup ourselves. This is extremely unsafe, but it works. Now Rust understandably doesn't provide a way to get the index of a trait method in the vtable (wich we probably couldn't do anyways without spelling `write`). This is implementation dependent code, which is why I specified the compiler version.
Looking at the [compiler code that generates the vtable](https://github.com/rust-lang/rust/blob/e22b61bff0bdd08be7665607cb7be3748c8a35d2/src/librustc_codegen_ssa/meth.rs#L108), we see that it first contains the `Drop::drop` implementation (needed for owned trait object such as `Box<dyn Trait>`) and then size and alignment. Then come the trait methods in the order specified by the [function `vtable_methods`](https://github.com/rust-lang/rust/blob/76e83339bb619aba206e5590b1e4b813a154b199/src/librustc_trait_selection/traits/mod.rs#L468). We see it first collects methods from supertraits, and then methods from the trait in definition order. Looking at the [trait definition for `std::io::Write`](https://github.com/rust-lang/rust/blob/e22b61bff0bdd08be7665607cb7be3748c8a35d2/src/libstd/io/mod.rs#L1244), we see that it has no supertraits, and `write` is the first method, so its vtable index is 3.
This is the final code:
```
use std::io::Write;
fn main() { unsafe {
    let y = std::io::stdout();
    let lock = y.lock();
    let x : &dyn Write = &lock;
    let (data,vtable) = std::mem::transmute::<&dyn Write, (*const (), *mut usize)>(x);
    let z : usize = vtable.offset(3).read();
    let fun = std::mem::transmute::<_, fn (*mut (), &[u8]) -> std::io::Result<usize>>(z);
    let array = [112,119,120];
    fun(std::mem::transmute(data), &array[..]);
}}
```
[Try it online!](https://tio.run/##dZBBT4QwEIXv/Io5kXZTiawXLSs/wosHQkxdhoQIJWmnZmGzvx2HGoWD9jTpe/O@yXPB07IEj@Cp0bobtX51HWGRtBYG01kh4QrBetMiXBPg1yPBBM/bAg9jICGLX7kfzx/smLJ12AsX0JA2k4UIYUu6OjZdNIaM@iTz3qP8YQw4aE3OWD8EQq1PW4ICcTiP1vOmVHBgHYLvZpSluOywM2PjP0d@h2dj23ok8SAzh6bZ39gG@y/5TQH3IiJoJaZVeKwl3JVbGy/oQ0@niCtLMe@SjXNmba7K86PK8yeVH@/rIok6U8UfzFjICoq7VZbVnHe7JcvyBQ "Rust – Try It Online")
[Answer]
# [Mornington Crescent](https://github.com/padarom/esoterpret), Score: 4, [Cracked](https://codegolf.stackexchange.com/a/208937/)
X = `myHp`
You may have survived the 7UBES, but the real challenge begins now. Face me in battle! First, allow me to rid us of some distractions. Four lines are closed. Over half of the special stations are unavailable. In spite of this ruin, victory remains possible. Even for the likes of you, but it won't come easily... I'll be impressed if you can cut even the tiniest bit of my Hp.
---
Consider the language again to be defined by the linked interpreter, also available on TIO.
---
The main challenge here was the fact that your only arithmetic operation is division, so there is no way to get the character codes by only using arithmetic operations.
My solution is below is quite a bit shorter than the crack (7410 bytes after removing comments), but uses the same basic idea: first divide the character codes of some lowercase letters by 2 to get the character codes of the symbols `'1'` `'2'` `'7'` `'9'` `'0'`. Then, copy and concatenate these symbols to get strings `'109'` `'121'` `'72'` `'112'`. Parsing these strings to integers at Parsons green gives the character codes for `m` `y` `H` `p`, which can then be concatenated to get the result.
A simple trick, but quite a piece of work to implement. In hindsight, I was lucky that I only needed 5 different number symbols and all symbols could be found on position -7 in some available station name.
```
# "myHp" 7 and division is enough to create 2. 
#7 can also be used to get the lower case characters:
# 2 == ord('A')//ord(' ');  Goodge# Street, 7 [District]
#'1' == chr(ord('c')//2);       Be#contree, 7 [District]
#'2' == chr(ord('e')//2); Gloucest#er Road, 7 [District]
#'7' == chr(ord('o')//2);        B#ow Road, 7 [District]
#'9' == chr(ord('s')//2);    Baron#s Court, 7 [District]
#'0' == chr(ord('a')//2);        W#aterloo, 7 [Northern]
###print "myHP" without using those characters
##Plan: get 2
#get 65
Take Northern Line to Bank
Take District Line to Acton Town
Take District Line to Bank
Take District Line to Bank
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross #ACC: 65
#put 65 at Cannon Street
Take Northern Line to Bank
Take Northern Line to Bank
Take District Line to Cannon Street
#get 32
Take District Line to Sloane Square
Take District Line to Mile End
Take District Line to Victoria
Take Victoria Line to Seven Sisters
Take Victoria Line to Victoria
Take Victoria Line to Victoria
Take District Line to Mile End #ACC: ' ...', End: 7
Take District Line to Bank
Take District Line to Bank
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross #ACC: 32
# 65//32 == 2
Take Northern Line to Bank
Take Northern Line to Bank
Take District Line to Cannon Street #ACC: 2, CS: 32
Take District Line to Southfields #Sof: 2
Take District Line to Cannon Street #CS: str
##Plan: get '1'
#get 99
Take District Line to Becontree
Take District Line to Mile End #ACC: 'c...', End: str
Take District Line to Bank
Take District Line to Bank
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross #ACC: 99
#put 99 at CS
Take Northern Line to Bank
Take Northern Line to Bank
Take District Line to Cannon Street
#99//2 == 49
Take District Line to Southfields
Take District Line to Cannon Street
Take District Line to Bank
Take District Line to Cannon Street #CS: str
Take District Line to Southfields #Sof: 2
Take District Line to Bank
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross #ACC: '1'
Take Northern Line to Bank
Take Northern Line to Bank
Take District Line to Kew Gardens #Ke: '1'
##Plan: get '2'
#get 101
Take District Line to Gloucester Road
Take District Line to Mile End
Take District Line to Victoria
Take Victoria Line to Seven Sisters
Take Victoria Line to Victoria
Take Victoria Line to Victoria
Take District Line to Mile End #ACC: 'e...', End: 7
Take District Line to Bank
Take District Line to Bank
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross #ACC: 101
#put 101 at CS
Take Northern Line to Bank
Take Northern Line to Bank
Take District Line to Cannon Street
# 101//2 == 50
Take District Line to Southfields
Take District Line to Cannon Street
Take District Line to Bank
Take District Line to Cannon Street #CS: str
Take District Line to Southfields #Sof: 2
Take District Line to Bank
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross #ACC: '2'
Take Northern Line to Bank
Take Northern Line to Bank
Take District Line to Chiswick Park #Chi: '2'
##Plan: get '7'
#get 111
Take District Line to Bow Road
Take District Line to Mile End
Take District Line to Bank
Take District Line to Bank
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross #ACC: 111
#Put 111 at CS
Take Northern Line to Bank
Take Northern Line to Bank
Take District Line to Cannon Street
# 111//2 == 55
Take District Line to Southfields
Take District Line to Cannon Street
Take District Line to Bank
Take District Line to Cannon Street #CS: str
Take District Line to Southfields #Sof: 2
Take District Line to Bank
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross #ACC: '7'
Take Northern Line to Bank
Take Northern Line to Bank
Take District Line to Ravenscourt Park #Ra: '7'
##Plan: get '9'
#get 115
Take District Line to Barons Court
Take District Line to Mile End
Take District Line to Victoria
Take Victoria Line to Seven Sisters
Take Victoria Line to Victoria
Take Victoria Line to Victoria
Take District Line to Mile End #ACC: 's...', End: 7
Take District Line to Bank
Take District Line to Bank
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross #ACC: 115
#Put 115 at CS
Take Northern Line to Bank
Take Northern Line to Bank
Take District Line to Cannon Street
# 115//2 == 57
Take District Line to Southfields
Take District Line to Cannon Street
Take District Line to Bank
Take District Line to Cannon Street #CS: str
Take District Line to Southfields #Sof: 2
Take District Line to Bank
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross #ACC: '9'
Take Northern Line to Bank
Take Northern Line to Waterloo
Take Northern Line to Bank
Take District Line to Acton Town #Act: '9'
##Plan: get '0'
#get 97
Take District Line to Bank
Take District Line to Mile End
Take District Line to Bank
Take District Line to Bank
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross #ACC: 97
#Put 97 at CS
Take Northern Line to Bank
Take Northern Line to Bank
Take District Line to Cannon Street
# 97//2 == 48
Take District Line to Southfields
Take District Line to Cannon Street
Take District Line to Bank
Take District Line to Cannon Street #CS: str
Take District Line to Southfields #Sof: 2
Take District Line to Bank
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross #ACC: '0'
Take Northern Line to Bank
Take Northern Line to Bank
Take District Line to Earl's Court #Earl: '0'
##Plan: get 1 
# 7//2 == 3
Take District Line to Victoria
Take Victoria Line to Seven Sisters
Take Victoria Line to Victoria
Take Victoria Line to Victoria
Take District Line to Cannon Street 
Take District Line to Southfields 
Take District Line to Cannon Street #ACC: 3, CS: 2
# 3//2 == 1
Take District Line to Bank
Take District Line to Cannon Street
Take District Line to Bank
Take District Line to Cannon Street
Take District Line to Bank
Take District Line to Cannon Street #ACC: 1, CS: 2
Take District Line to Barking #Ba: 1
##Plan: make 109
#copy '1'
Take District Line to Kew Gardens
Take District Line to Paddington #ACC: 'Paddington1', Pad: '1'
Take District Line to Mile End
Take District Line to Barking
Take District Line to Mile End #ACC: '1', End: 1
Take District Line to Kew Gardens #Ke: '1'
#concat '109'
Take District Line to Earl's Court
Take District Line to Paddington #ACC: '10', Pad '0'
Take District Line to Paddington #ACC: '010', Pad '10'
Take District Line to Acton Town 
Take District Line to Paddington #ACC: '109', Pad '9'
Take District Line to Parsons Green
Take District Line to Acton Town #Act: 109
#make 72
Take District Line to Ravenscourt Park
Take District Line to Paddington #ACC: '97', Pad '7'
Take District Line to Chiswick Park
Take District Line to Paddington #ACC: '72', Pad '2'
Take District Line to Parsons Green
Take District Line to Ravenscourt Park #Ra: 72
##Plan: make 112
#Grab '2'
Take District Line to Parsons Green #ACC: 10
Take District Line to Paddington #ACC: '2' , Pad 10
Take District Line to Barons Court #Ba: '2'
#copy '1'
Take District Line to Paddington 
Take District Line to Kew Gardens #Ke: 10
Take District Line to Paddington #ACC: '...1', Pad '1'
Take District Line to Kew Gardens
Take District Line to Mile End #ACC: 1, End: 10
Take District Line to Bank
Take District Line to Mile End #End: str
Take District Line to Kew Gardens
Take District Line to Mile End #End: '...1'
Take District Line to Bank
Take District Line to Mile End #ACC: '1', End: 1
Take District Line to Paddington #ACC: '11', Pad '1'
Take District Line to Cannon Street
Take District Line to Paddington #ACC: '1', Pad int
Take District Line to Cannon Street #Can: '1'
Take District Line to Paddington #Pad: '11'
Take District Line to Barons Court
Take District Line to Paddington #ACC: '112', Pad '2'
Take District Line to Parsons Green
Take District Line to Bank #Ban: 112
#make 121
Take District Line to Cannon Street
Take District Line to Paddington
Take District Line to Paddington
Take District Line to Parsons Green
#int to char
Take District Line to Bank #Ban: 121
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross
Take Northern Line to Bank #Ban: 'p'
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross
Take Northern Line to Bank #Ban: 'y'
Take District Line to Barons Court #Bar: 'p'
Take District Line to Acton Town
Take District Line to Bank #Ban: 109
Take District Line to Kew Gardens #Ke: 'y'
Take District Line to Ravenscourt Park
Take District Line to Bank #Ban: 72
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross
Take Northern Line to Bank #Ban: 'm'
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross
Take Northern Line to Bank #Ban: 'H'
Take District Line to Acton Town #Act: 'm'
#Concat 'myHp'
Take District Line to Paddington
Take District Line to Acton Town
Take District Line to Paddington #Pad: 'm'
Take District Line to Kew Gardens
Take District Line to Paddington
Take District Line to Paddington #Pad: 'my'
Take District Line to Bank
Take District Line to Paddington
Take District Line to Paddington #Pad: 'myH'
Take District Line to Barons Court
Take District Line to Paddington #ACC: 'myHp'
Take District Line to Bank
Take District Line to Bank
Take Northern Line to Mornington Crescent
```
[Version without comments on TIO](https://tio.run/##7VnBTsMwDL3vK3LjxEewMu0AQ9M6wTlKDY1aYuGk9PNHyrRNCNpkTbvByG2VHfsleX6111ckJdWLQXUtCLQAZTabNS@APSCZHEixe6mAGWRTrorJp@lWakNSmL3pRtgAbI21anHoWHswfcuY5JwsOJYQah3g05GiA1jClbK7Sg0BmBaftERuf6VvFSdo8VnIEthMZS3mR/uAJPnWvHs6ZIB3sCDsKiDd4uMI8dV8LL6LvTqsTP4socx0QJQpCFSNQzzcEQ53bBC/9ozvoGZzThmoNujzEisBjSqwFfIsak8sj/9THkkudS1FwZacWgmCdUBlROZF5v0EbMWtJGqBFZlO8nFCpVnS@EVpjgVyYQXyxC3tSsTJSSfFyMjIyB5nPONUXnVr8dnF9s/w4NzLqbAk6T00LXmWbf/t6isxXfkdi93wPJjq3IHTwanAHilIN93N3N5U7yyejZQTjM8oMMiOvAG7QznxeLSPzhgDVIM7RP9XcnCxjJbaTTkPpTpNkCF44kPYQNkOF63jQJ6jARk@RZ/bDmmv3SXnPfxe@EWEv0LDIwwg7x7yoooRg4drV7@Rb7H/5mkJsPvm@QE "Mornington Crescent – Try It Online")
## The cutting room floor
As much as I'd like to be able to give an encore, I'm afraid I've exhausted my material. The design-space is a bit limited both due to the fact that Mornington Crescent is a language with a simple description and few commands (unlike, say, Javascript or Perl), as well as the fact that `Take Northern Line to Mornington Crescent` must be present in every valid program.
I can't present any challenge that is solvable only by a method different from the solutions given so far. Best I can give you is some strings that I didn't use either because they were too easy (i.e. solvable with ideas already given) or too hard. (i.e. I couldn't think of a method to solve them. Feel free to post these as a challenge here if you do!)
I provide the following strings at your own risk, do with them as you please.
## Easy
1. `Spy` leaves open a bit too many arithmetical operators for my taste.
2. `l` shuts down surprisingly many lines with only a single letter, but still leaves many options open.
3. `HypV` is too similar to this challenge, with only a small difference in the startup due to the lack of `Seven Sisters`
## Hard (likely impossible)
1. `SpyH` closes down many pesky operators, but I don't see a way to get a `1` and am stuck without it.
2. `HypVm` is similar to the this challenge, but I don't see how to get a `2` without `Seven Sisters` here.
[Answer]
# [Python 2](https://docs.python.org/2/), Score: 23, safe
```
 "%'*+-./;=_`abehmtvy{}
```
I tried to make this one somewhat difficult. No `exec`, no `import`, and no `print`.
*Note: there is no newline in X.*
[Verify it online!](https://tio.run/##dZAxT8MwEIV3/4oDVBxDMaJsRRlQ6VCxRCxUAhSS9NJYSmzLvlAixG8PSRpaFrbT0/vu7j3bUGH0bdueQZR4QmhM7SAaVJhBZjYISgMVCHylbU0cUvPJmKqscQS@Tq0zGXp/UJrDSFjZXJXI2BpCSDmcTl75xeWVvL4L4/ckxaKij@brm7PhTNiz0tNGaZnWeY5OOkw2gWCqLHGblL0DKejNAs6HeS0Y2ykqwFjUAafKStvwKfBdygUkHvI5g1zunCLcg4x1F0xN/bLD89LVOnjhdog96/lx09sU9vbwjzlaRUsh9zpT@eiAkxDW3TXrlKaAPzujt9DpXWdzmHgOk9EoGJYdNYY6EqsxZVYkLskInf/l0obQByMget7jkVs83S8elw8nXLRtHO@7j@OAG8/FmPymS/Rv@@IH)
---
## Solution
The code is to large too fit here, so try visiting one of these links: *[Try it online!](https://tio.run/##5Ze7DoIwGIV3X8OFJg605WJ5CRPjRpgwotEAaXTw6REoIKXYmOjicSmcXv72@1tOSnm/HoucVdUyLfanPIu2mx3lC3mWpVNcMnlw4u6RkNhNVkq4pHvJiwOJ6VCvZNDLtiSx0Jp1RS1toabWvdJWooLwXt7kuZbi1QIcMhpKyfRFkFE/Op5vIuqCRZGfkJlETVIym4NnirJLKtu6OmJoy1OgSWbLG7cGbypHfd7ZMt@YzNabz49V83qvcvdBROvmOnTV4H/hvPA@JJs9Jkr8Pp0HTRdC0wlEOg/6uxvoODSdD00XQNNBeqYP7ZmBcbdFohPQriKgXUVAu8pAt0akG0K60PZiYnr/gSmgMSm0r5qY2BbE/sOCGPTvoYn51o2uqh4) or [Verify it online!](https://tio.run/##5ZdLb5tAEMfv@ykmrdxlW5ca8CO48qFKcrByqBVVqiVqtWAvNgpmV8tSF1X57Ckv42dQpPbSzQXvDPOf2d8sjDBP5YpF1uPja5i4saSQskTApPCCCXO2oBBEIFcU8DjiicTgsV8IBWvOhIQ48bhgcxrHtSetl5KuuR@EFKEpjMDD8Kr1Db99917/8HH0/Yfr0dVa/kx/P2BUlBnlWj2WiyDSvcT3qdAFdRcaQUEY0qUb5hFUankwgTfFekoQ2gRyBYzTSMNyzXWe4jbgjYcJuDH4QwS@vhGBpKUQoawCS2SerN68LpJIczAvsM1cX2WataEMH@0FT8aTG6KXfhT4VQRcjGCaVeMiiKSGvwoWLSHzZz0bQivG0KoCCaJhpqqgdopxRTlfucKdSyrirc5LJY21SkByfUx3uqu7T1e3N9cXmGSnmDEG0XJ49/mLYSFxL7jGwqXwNaf6mRGnM2uXRodUi4j5xDFqf2n2t2ZxJY59cPvQMhruDQ6sy611sJMyibU1E3GfmfZTG9DIntQgxwub7MUZ@/WOjOxiDoe9GTnTqKOWnO3BrkXLcC4KX5Zx0NSn/oFpNvXNakyeO/dinnNkvZNiTdHWeW1Zt/tU7/4iY@PhakY7x/8Hz4u1TWmefUxK4/@n6ypNN1CazlaRrqv0e1fTWUrT9ZSm6ytNp@TM7Ck9M/sn37Yq0dlKTxVb6aliKz1VarpLFenqlB2lx8spZvdlYNpKYxpKz9VTTLVHkPkyRpCp9N/DU8xnfdH9AQ) or [Generate it online!](https://tio.run/##pVPfb9owEH73X3EaQrZLxjDpj8HUh9LysKdJ7d7SqMsPA54aG9luC6r2tzM7IYNQGk2qFDn@7nz33X0@L9d2oeRws@nAHbcGnhMtkvSRQwpWAX7BqAPRYKa0MwgZZQtNGBvROEZXcAk4XVtuSLT9xTQaxEEFBnS7SVJDI/bPXsHzGpYrjUYNdxOxFt9FA32tUaOSKklYwwVfOTh6rwBC90IZPdyM6N45ts93ANwyHI/PYoycgt@LpdIWsDIYCpU/PXJnnGlVgDIgKueLFpajyRtVD/Q7KthOT7te8tLm6C/aRD1vwGGbyGFrcm/cO/M/93v2hqztdHg8tuI9bQo94XMhpZBzULNKUZg9ycwKJZ23NBAW@ClG16XSHyBuHRjH4lX6yAyWDU1lfrQVStHNblQaw1gBF6258Uf4imeka@i93O0wdIFcBTChyL/tlXvbgOFT9x6f9D73v3y7fPiVpHxR2Of16x88RjD1mQLc/62EJFtWl8nnycGnyH0KYzVROicr6uoDz9@rC9jOdNcE5VffWl3LdQDTAG6o7/n2x08WQpHMRVb30MlU7m51XLp8SM9n73Pp7JxgrSwLMUVLLaT1ns3mLw)*.
The main idea is to use `#coding:ENCODING` to define an encoding for the source code. The intended solution was to use `#coding:ROT13`, but there could be another encoding which I have not yet explored.
After placing this magic comment on the first line of our program, every letter will be translated with `rot13`. This means that `print -> cevag`, etc.
Next we need to determine which builtins (when encoded with `rot13`) are actually available to use. It turns out that we are limited to just a few:
```
cmp, set, bytes, abs, hash, hex, type, map, max, exec
```
Also note that the output should not contain a newline, meaning we must use `os.write` as opposed to `print`. But since we don't have access to `import`, it seems impossible to call `os.write`... On the other hand, we do have access to `exec`, which allows us to evaluate a string! The only problem now is that we can't use quotes. It is possible however, without needing them.
As a start, let's figure out how to `exec` the letter `i`. We can't use quotes, but `bytes` turns out to be very useful here. For example, `bytes(abs)` evaluates to `'<built-in function abs>'`, which coincidentally contains an `i`. Thus, `exec(bytes(abs)[3])` will do exactly what we want.
This strategy of creating letters is abused throughout the entire source code. It should look something like `exec(bytes(abs)[10]+bytes(bytes(9))+...)`.
One last thing. `+` is not allowed either, though this is manageable. We can use the following construct as an alternative to joining characters: `bytes([a, b, c, d, e])[2::5]`.
[Answer]
# [C (gcc)](https://gcc.gnu.org/), score 4 ([Cracked](https://codegolf.stackexchange.com/a/207634/9481))
```
#_ep
```
My source code doesn't contain any of these characters and when complied and run, it outputs `#_ep` to `stdout`.
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal) \$\le\$ [2.10.3](https://github.com/Vyxal/Vyxal/releases/tag/v2.10.3), score 252, safe
```
λƛ¬∧⟑∨⟇÷×«
»°•ß†€½∆ø↔¢⌐æʀʁɾɽÞƈ∞¨ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOQRSTUVWXYZ[\]`^_abcdefghijlmnpqrstuvwxyz{|}~↑↓∴∵›‹∷¤ð→←βτȧḃċḋėḟġḣḭŀṁṅȯṗṙṡṫẇẋẏż√⟨⟩‛₀₁₂₃₄₅₆₇₈¶⁋§ε¡∑¦≈µȦḂĊḊḞĠḢİĿṀṄȮṖṘṠṪẆẊẎŻ₌₍⁰¹²∇⌈⌊¯±₴…□↳↲⋏⋎꘍ꜝ℅≤≥≠⁼ƒɖ∪∩⊍£¥⇧⇩ǍǎǏǐǑǒǓǔ⁽‡≬⁺↵⅛¼¾Π„‟
```
(Or, in other words, everything except `koPĖ` is disallowed)
If you're wondering where to start, some of the ideas from [here](https://codegolf.stackexchange.com/a/236209/100664) may be applicable. However, Vyxal has changed a lot since that competition. Good luck!
Btw, my intended solution is 37 yottabytes.
# Solution
note: Due to bug fixes, some of the links here won't work anymore
This character set is quite powerful. We have these builtins:
* `ko` - octal digits as a string, `01234567`
* `kP` - printable ASCII
* `o` - remove string a from string b
* `P` - strip string a from the outsides of string b. Has *interesting* (and very helpful for us) behaviour on lists/ints
* `Ė` - Evaluate string as Vyxal / take reciprocal
In older versions of Vyxal, regular python floats were used, making it [a lot easier](https://codegolf.stackexchange.com/a/236209/100664). Now, we have sympy floats.
The significance of this is that 1/1234567 used to be represented as `8.100005913004317e-07`, allowing us to easily get the characters e and -. Now, it's represented as `1/1234567`.
In older versions of Vyxal, a leading zero on a number did nothing. Now, it pushes a zero before said number. This is a problem, as our only real way of getting numbers is with 1234567, and since the zero is before the number using `o` or `P` will just leave a zero.
`koĖ` [pushes a zero](https://vyxal.pythonanywhere.com/#WyJXIiwiIiwia2/EliIsIiIsIiJd) as well, but appending a `P` (strip) [results in a zero](https://vyxal.pythonanywhere.com/#WyJXIiwiIiwia2/EllAiLCIiLCIiXQ==), which we can then [remove](https://vyxal.pythonanywhere.com/#WyJXIiwiIiwia29rb8SWUFDEliIsIiIsIiJd) from the string `01234567` leaving 1234567, which we can eval.
### Getting strings
Following this, we can [get](https://vyxal.pythonanywhere.com/#WyJXIiwiIiwia29rb8SWUFDElsSWa29QIiwiIiwiIl0=) the `/` character by taking the reciprocal (resulting something that stringified gives `1/1234567`) and stripping `01234567`. We can evaluate this to:
* Divide two numbers (because we have reciprocal, also multiply)
* Split a string into n parts
* Split a string by another string
Because of this, we can get [1](https://vyxal.pythonanywhere.com/#WyJXIiwiIiwia29rb8SWUFDElmtva2/EllBQxJZrb2tvxJZQUMSWxJZrb1DEliIsIiIsIiJd) by dividing 1234567 by itself.
We can get the range from 2 to 7 by [removing 1](https://vyxal.pythonanywhere.com/#WyJXIiwiIiwia29rb8SWUFDElmtva2/EllBQxJZrb2tvxJZQUMSWa29rb8SWUFDElsSWa29QxJZvIiwiIiwiIl0=) although this seems useless for now. We can also [get 1-7](https://vyxal.pythonanywhere.com/#WyJXIiwiIiwia29rb8SWUFDElmtva2/EllBQxJZrb2tvxJZQUMSWa29rb8SWUFDElmtva2/EllBQxJbElmtvUMSWb28iLCIiLCIiXQ==).
Taking a step back, we can stringify 1/1234567 by [stripping
`/`](https://vyxal.pythonanywhere.com/#WyJXIiwiIiwia29rb8SWUFDElsSWa29rb8SWUFDElsSWa29QUCIsIiIsIiJd). We can [get `1/`](https://vyxal.pythonanywhere.com/#WyJXIiwiIiwia29rb8SWUFDElsSWa29rb8SWUFDElsSWa29QUGtva2/EllBQxJZvIiwiIiwiIl0=) with this although it doesn't seem to help much right now.
### List trickery
For reasons that I don't quite understand, we can get 7654321 with something like [this](https://vyxal.pythonanywhere.com/#WyJXIiwiIiwia29rb8SWb1DEliIsIiIsIiJd). In general, we can reverse a string/number by [calling `P`](https://vyxal.pythonanywhere.com/#WyJXIiwiIiwiYDEvMTIzNDU2N2Awd1AiLCIiLCIiXQ==) with it and `[0]`. This will prove *very* helpful.
Taking a step back to numbers, we can get `234567` with [what we already have](https://vyxal.pythonanywhere.com/#WyJXIiwiIiwia29rb8SWUFDElsSWa29rb8SWUFDElsSWa29QUGtva2/EllBQxJZrb2tvxJZQUMSWa29rb8SWUFDElsSWa29QxJZva29rb8SWUFDElsSWa29Qb8SWIiwiIiwiIl0=).
For some reason, stripping a string from certain types of lists seems to return (wrapped) the first item of said list. But how do we get that item?
I'm not sure yet, but using some [very confusing stuff](https://vyxal.pythonanywhere.com/#WyJXIiwiIiwia29rb8SWUFDElmtva2/EllBQxJZrb2tvxJZQUMSWa29rb8SWUFDElsSWa29QxJZva29rb8SWUFDElmtva2/EllBQxJbElmtvUMSWa29rb8SWUFDElsSWa29QUMSWa29rb8SWUFDElmtva2/EllBQxJbElmtvUMSWxJYiLCIiLCIiXQ==) lets us get the singleton list containing 2.
Removing that from [2..7] yields [7...3](https://vyxal.pythonanywhere.com/#WyJXIiwiIiwia29rb8SWUFDElmtva2/EllBQxJZrb2tvxJZQUMSWa29rb8SWUFDElsSWa29QxJZva29rb8SWUFDElmtva2/EllBQxJZrb2tvxJZQUMSWa29rb8SWUFDElsSWa29QxJZva29rb8SWUFDElmtva2/EllBQxJbElmtvUMSWa29rb8SWUFDElsSWa29QUMSWa29rb8SWUFDElmtva2/EllBQxJbElmtvUMSWxJZQIiwiIiwiIl0=). We can repeat these techniques to get every element of [2...7] in a singleton list.
Since we can simulate multiplication with use of division and reciprocals, we can finally get the elusive [8](https://link.rf.gd/auyaj) and [9](https://link.rf.gd/511rd)!
### Printable ASCII
By removing both of these + the octal digits from printable ASCII, we can get [something usable?](https://link.rf.gd/5akzz)
Vyxal's split into pieces builtin doesn't actually give you the right amount of strings. Instead, it tries to make the strings all equal in length.
We can [split](https://link.rf.gd/v7g09) this into 64 pieces, but our trick to get the first character doesn't work since it's wrapped in a list...
And anyway, executing a list produces a horrific mess...
However, there's another way we can get numbers! By removing select digits (in lists) from `01234567` we can get quite a few numbers, including all the digits as individual numbers. We can construct [56](https://link.rf.gd/6ajze) with this method.
Using this method, we can split the string into 56 pieces instead of 64, cutting this down into a much more manageable result, with [a single unnested list](https://link.rf.gd/qajng).
This can be [represented](https://vyxal.pythonanywhere.com/#WyJXIiwiIiwiNTZrUGtkby8iLCIiLCIiXQ==) with a much shorter piece of code.
So, we can get the first item of a list of strings as a singleton list, and we can strip a singleton list from a string to yield a string, and we can split a string into a list.
### Letters
By [stripping `/` to get the first item](https://vyxal.pythonanywhere.com/#WyJXIiwiIiwiNTZrUGtkby9cXC9QIiwiIiwiIl0=), we can get `["a"]`. Then we can get [`["b"]`](https://vyxal.pythonanywhere.com/#WyJXIiwiIiwiNjdrUGtkby82N2tQa2RvL1xcL1BQIiwiIiwiIl0=).
We can remove `a` from the [string form of printable ascii](https://vyxal.pythonanywhere.com/#WyJXVCIsIiIsImtQa2RvNjdrUGtkby9cXC9QUCIsIiIsIiJd) (and reverse it as a side effect, but that's easily fixable). We can then [remove `b`](https://vyxal.pythonanywhere.com/#WyJXIiwiIiwia1BrZG82N2tQa2RvL1xcL1BQNjdrUGtkby82N2tQa2RvL1xcL1BQUCIsIiIsIiJd). You can probably see where this is going, can't you.
With this method, we can [get `c` in a list](https://vyxal.pythonanywhere.com/#WyJXIiwiIiwiNTZrUGtkbzY3a1BrZG8vXFwvUFA2N2tQa2RvLzY3a1BrZG8vXFwvUFBQL1xcL1AiLCIiLCIiXQ==), remove abc, get d, remove abcd, etc. The cost for this method grows exponentiially, but it works.
Then, we can get the string with n characters removed, and remove it from the string with (n-1) characters removed, leaving just the character itself.
*Finally*, we can evaluate this and execute arbitrary ASCII characters.
### Scoring individual letters
Whew, that was a lot of work. Now let's put it all together.
The overhead for splitting a string into a character list is 941 (56) + 14 (division) = 955 bytes.
The overhead for getting the first character of a string as a singleton list is 955 + 3 = 958 bytes (referred to as `head`)
The overhead for removing a character and then de-reversing the string is only six bytes - `PkoĖoP`. (referred to as `strip`)
The overhead each time we push printable ascii - digits is 2052 bytes (referred to as `ascii`). The overhead for pushing this as a character list is 3007 bytes.
Then, we can generate each character of ascii in sequence by removing all the previous ones and `head`ing. For example, to get `b` we remove `a` from `ascii` and `head`.
* `a` as a singleton list costs 1 ascii + 1 head = 3010 bytes.
* `b` as a singleton list costs 2 ascii + 2 head + 1 strip = 6026 bytes.
* `c` as a singleton list costs 4 ascii + 4 head + 3 strip = 12058 bytes.
Can you see the pattern? The formula is \$2^n\text{ascii} + 2^n\text{head} + (2^n - 1)\text{strip} = 3016 \* 2^n - 6\$ for a 0-indexed n representing the position.
### Putting it all together
To get say `a` as a single character, we need the overhead for getting `b` as a singleton list, minus one head , and the overhead for getting `a` as a singleton list, minus one head. We also need a single `o`.
With this, we can take the string `bcdef...` used to get `b` before it is `head`ed, do the same with the string `abcdef...`, and remove the former from the latter leaving only `a`.
So, we need 3 ascii, 1 head, 1 strip and a single `o` = 7121 bytes to get the single character `a`. [Simpler version](https://vyxal.pythonanywhere.com/#WyJXIiwiIiwiI2tQa2RvIDU2L1xcL1AgUGtvxJZvUFxua1BrZG9cbmtQa2RvXG5rUGtkbyA1Ni9cXC9QIFBrb8SWb1AgbyIsIiIsIiJd).
For `b`, we need 6 ascii + 4 head + 4 strip + `o` = 16169 bytes. [Simpler version](https://vyxal.pythonanywhere.com/#WyJXIiwiIiwiI2tQa2RvIDU2L1xcL1AgUGtvxJZvUFxua1BrZG9cbmtQa2RvIDU2L1xcL1AgUGtvxJZvUFxuXG5rUGtkb1xua1BrZG8gNTYvXFwvUCBQa2/Elm9QXG5rUGtkb1xua1BrZG8gNTYvXFwvUCBQa2/Elm9QXG41Ni9cXC9QXG5Qa2/Elm9QXG5vIiwiIiwiIl0=).
The formula *here* is \$(2^n + 2^{n+1})\text{ascii} + (2^n + 2^{n+1} - 2)\text{head} + (2^n + 2^{n+1} - 2)\text{strip} = 3016(2^n + 2^{n+1}) - 1927\$.
What we're interested in are the characters `C` and `+`. I've made a [calculator](https://vyxal.pythonanywhere.com/#WyIiLCIiLCJrUGtkbyDhuJ8gOuKAulwiReKIkSAzMDE2ICogMTkyNyAtIiwiIiwiQyJd) for the overhead of a single printable ASCII character, and for `C` it spits out `2428804003961`. For `+` it gives `41726535094731005753465`. Of course, we must increment these due to the need to evaluate them.
Because I'm lazy, to create a certain character we're going to go `1 1+ 1+ 1+ ...C`. This has a total cost of \$41726535094731005753495 \* (\text{ord}(c) - 1) + 2428804003991 \$. [calculator](https://vyxal.pythonanywhere.com/#WyIiLCIiLCJDIOKAuSA0MTcyNjUzNTA5NDczMTAwNTc1MzQ5NCAqIDI0Mjg4MDQwMDM5OTAgKyIsIiIsIuKIkSJd).
Finally, we need to get this over *all* characters in the Vyxal codepage except the four we're using. We need 251 more `+` to concatenate it all together, and we're done!
The final size of the program is 37,775,866,751,962,486,187,362,186,532 bytes, or 37 yottabytes.
[Answer]
# [International Phonetic Esoteric Language](https://esolangs.org/wiki/International_Phonetic_Esoteric_Language), Score: 47, [Cracked](https://codegolf.stackexchange.com/questions/207560/print-x-without-x-robbers-thread/207573#207573)
Let's throw my own language into the ring.
```
 !"#$%&'()*+,-.ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`
```
My solution:
> 
> `{32}{15}0ɑbesχue1søɒ{65}{32}0ɑbesχue1søɒ`
> 
> 
> 
[Answer]
# Javascript, score: 83, [cracked?](https://codegolf.stackexchange.com/a/207665)
(the crack is not executable like `/path/to/interpreter file.js`, unlike my solution, but I don't think that matters a lot)  
I only know one Javascript implementation where my intended solution works.
```
!"#$%&'()*,-./0123456789:;=ABCDEFGHIJKLMNOPQRSTUVWXYZ\^_`abcdefghijklmnopqrstuvwxyz
```
In this implementation, only five distinct characters are sufficient to represent any Javascript code. I removed some more characters to (try to) avoid giving away the answer.
The solution should be a full program, executable like this:
```
$ /path/to/interpreter file.js
```
I solved this by modifying `aemkei/jsfuck` on GitHub, until it was able to encode JSFuck code using the 5 characters `[]+|>`. My solution was produced by encoding `console.log("the string")` in JSFuck (via jscrew.it so that I do not run out of both RAM and HDD space), and then encoding the JSFuck using the modified JSFuck generator. My solution is 46 megabytes of code, its sha256sum is `d0c72f380b1623f9bff06fbed03b1ecd9c7fc012c9cc1ac9d758c9a317ad6855`, and it is *very* slow; if anybody is interested I can try to upload it somewhere.
[Answer]
# [Haskell](https://www.haskell.org/), Score 74, [Cracked](https://codegolf.stackexchange.com/a/208935/56656)
```
	
 !"#$%&()*+/0123456789:?;@BEDAFGHIJKLMNOPQRSTUVWXYZ\^_`bcdefgjkloqsvwxyz
```
I've changed this one up quite a bit from my last Haskell answer. The basics are somewhat similar:
* Hard to apply functions due to missing whitespace, `()` and `$`.
* No line delimiters so program must be on one line
This time I've given you some new characters to play with. Along most the characters from the last version you also get
```
uCh>{}~
```
The only character's I've taken away are `:`, which was already disallowed in the hard version, and tab, which neither me or the cracker used in the first place.
So how is this harder than those versions? Well this time the output is not possible in whole or in part with `print`, you will need to use `putChar`. Which you will find much less coöperative.
# Intended solution, 829 bytes
```
main|[ih,a,i,n,p,u,t,h,r,mm,ma,mi,mn,mp,mu,mt,mC,mh,mr,am,aa,ai,an,ap,au,at,aC,ah,ar,im,ia,ii,ip,iu,it,iC,m,ir,nm,na,ni,nn,np,nu,nt,nC]<-['-',','..],[m,a,mat,i,n,p,u,t,h,r,mm,ma,mi,mn,mp,mu,mt,mC,mh,mr,am,aa,ai,an,ap,au,at,aC,ah,ar,im,ia,ii,ip,iu,it,iC,ih,ir,nm,na,ni,nn,np,nu,nt,nC,nh,nr,pm,pa,pi,pn,pp,pu,pt,pC,ph,pr,um,ua,ui,un,up,uu,ut,uC,uh,ur,tm,ta,ti,tn,tp,tu,tt,tC,th,tr,hm,ha,hi,hn,hp,hu,ht,hC,hh,hr,rm,ra,ri,rn,rp,ru,rt,rC,rh,rr,mmm,mma,mmi,mmn,mmp,mmu,mmt,mmC,mmh,mmr,mam,maa,mai,man,map,mau]<-map{--}putChar[m..'{']=m>>a>>an>>ap>>au>>at>>aC>>ah>>ar>>ia>>ii>>ip>>iu>>ir>>nm>>na>>ni>>nn>>np>>nu>>nt>>nC>>nh>>nr>>pm>>pu>>pa>>pt>>ph>>ua>>um>>pC>>ui>>un>>up>>uu>>ut>>uC>>uh>>ur>>tm>>ta>>ti>>tn>>tp>>tu>>tt>>tC>>th>>tr>>hm>>ha>>hi>>hp>>ht>>hC>>hh>>rm>>ra>>ri>>rn>>rp>>ru>>rh>>rr>>mmm>>mmn>>mmu>>mmC>>mam>>maa>>mai>>man>>map
```
[Try it online!](https://tio.run/##tZBBbiNRCESP403ZJ0i8@cewvGAxEigBIQZWyZzdKQ6Q5agb1KJe0f@Xyt@PP5@fr5eLxffDFAJDIDFoKArucIEbPOAJH3jDD1zhBXGIQAwSkIQMpCEHwkUFcxj3GSxhA2sYjbBCOEIQ/FUgEjGIRpzn2/VxuV7A53Z74sHt/Hv/7yPx2r@fCaGIQjpSkIbkURI5yEYepCIL4xjBGCYwPOlgGnMwiim0owVt6EAnmhdp9EEruqAOFahBA5rQgfKeB6rQQjlKUIYKVKIG1aiDYhIbBbPYMDaNjWPz2EA2kY1kM2EoLpvZhkmOwTiTcRnmza@v6/VfTh@Vevjtdvm6PN/9fhe@wUrWsJp1WMqq@92om7GoG3XjLGgLzoPzoDeoBbWgN@gNeoNckkvOk2xSS86H37NzckP/0D/0D7khMztfjv4m1@SbXJNrck2uyTW5JtfklJySU3JKRqkrdaVe1IpaUSvuKOrFHbUavYx2W2ybbfQxxm2yzbatKvl6/QA "Haskell – Try It Online")
My intended solution uses the fact that `{--}`, that is opening and closing a comment, separates tokens, so it can be used as a substitute for space.
Although it seems unlikely anyone might ever realize this fact, it seems near impossible to construct a cop that *requires* this fact, so after two failed cops I am giving up that attempt. Good job to both the robbers here.
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), score: 71 (safe)
```
AbCdEfGhIjKlMnOpQrStUvWxYz
⁢{@[0 & ], \" <-> (.|), +*/, 123456789[]}
```
There are 4 characters preceding the `{` on the second line: invisible times (`U+2062`) followed by 3 private use characters (`U+F39E`, `U+F765`, `U+F76D`), in ascending order.
---
### My solution
The exclusions of `[]`, `@`, `/`, and `\[InvisibleApply]` mean that, apart from special forms, only the infix `~ ~` can be used to apply functions.
In order to allow application of functions with a number of arguments other than 2, we need a way to generate `Sequence`s. Defining one of Mathematica’s built-in undefined bracketing operators allows us to do this:
```
〈$___〉:=$
```
Now, `〈〉` is a `Sequence[]`. As commas (and `\[InvisibleComma]`) are not permitted, we also define
```
$_·$$\_\_\_=〈〉~$~$$
```
which allows us to apply an arbitrary head to an arbitrarily long list of arguments, without commas.
Now, to generate heads to apply. Note that `Names` is permitted. `Names·__` generates a list of names we can index into, and we can generate positive numbers with sufficient abuse of `π`/`Pi`, `√` (`Sqrt`), `⌊ ⌋` (`Floor`), `⌈ ⌉` (`Ceiling`), `^` (`Power`), and juxtaposition, using `〈 〉` as parentheses, for multiplication.
There’s one last thing: values returned from `Names` are `String`s, not `Symbol`s. Applying `Symbol` to a string returns a symbol with that name, though, and every symbol has the head `Symbol`. We can extract it by taking its 0th part. While the operations we used earlier can’t generate 0, `'` (`Derivative`) can (As an aside, my version of Mathematica evaluates `N'` to `1&`, but TIO’s evaluates the same expression to `0&`). For the sake of convenience, again:
```
±$_:=〈Names·__〉〚$〛;∓$_:=N〚N''·〈〉〛·±$
```
(We actually didn’t need `·`: we can build arbitrarily long expressions with `#1~〈〉〚N''〛~#2~〈〉〚N''〛~...~*head*~#k`, but `·` is much nicer to look at)
and we can put the parts together to make:
```
〈$___〉:=$;$_·$$\_\_\_=〈〉~$~$$;±$_:=〈Names·__〉〚$〛;∓$_:=N〚N''·〈〉〛·±$;$=〈∓〈⌊〈√〈⌊π⌋^π〉〉〈〈〈π〉π〉^⌊π⌋〉⌋〉·〈∓〈⌈〈√√⌊π⌋〉〈〈√π〉^⌈π⌈π⌉⌉〉⌉〉·〈⌈〈π〉〈π^〈π〉〉⌉〉〉·〈∓〈⌈〈√√⌊π⌋〉〈〈√π〉^⌈π⌈π⌉⌉〉⌉〉·〈⌊〈π〉⌈π^π⌉⌋〉〉·〈∓〈⌈〈√√⌊π⌋〉〈〈√π〉^⌈π⌈π⌉⌉〉⌉〉·〈⌈〈π〉〈⌊π⌋^π〉⌉〉〉·〈∓〈⌈〈√√⌊π⌋〉〈〈√π〉^⌈π⌈π⌉⌉〉⌉〉·〈⌊π⌋⌈π^π⌉〉〉·〈∓〈⌈〈√√⌊π⌋〉〈〈√π〉^⌈π⌈π⌉⌉〉⌉〉·〈⌈〈π〉⌈π^π⌉⌉〉〉·〈∓〈⌈〈√√⌊π⌋〉〈〈√π〉^⌈π⌈π⌉⌉〉⌉〉·〈⌊〈π〉⌈π^π⌉⌋〉〉〉;∓〈〈⌈⌈π⌉^π⌉〉〈⌈〈√π〉〈π^〈π〉〉⌉〉〉·$·〈∓〈⌊〈⌈π⌉^π〉〈⌊〈√π〉〈⌊π^〈π〉⌋〉⌋〉⌋〉·∓〈⌊〈⌈π^π⌉^〈√π〉〉〈⌈π⌉〈√⌊π⌋〉〉⌋〉·∓〈⌊〈⌊〈π〉〈⌊π⌋^π〉⌋〉^√⌊π⌋⌋〉〉;∓〈⌈〈π^⌊π⌋〉〈⌈〈π〉〈⌈π⌉^⌊π⌋〉⌉〉⌉〉·$·〈∓〈⌊〈√〈⌊π⌋^π〉〉〈〈〈π〉π〉^⌊π⌋〉⌋〉·〈∓〈⌈〈√〈〈π〉⌈π⌉〉〉^〈⌊π⌋^√⌊π⌋〉⌉〉·〈∓〈⌈〈⌈π⌉^〈√π〉〉〈〈⌊π^〈π〉⌋〉^√⌊π⌋〉⌉〉·〈〈∓〈⌈⌈π⌉〈〈〈π〉π〉^√⌊π⌋〉⌉〉·〈〉〉〚;;;;〈√⌈π⌉〉〛〉〉·〈∓〈⌈⌈π⌉〈〈〈π〉π〉^√⌊π⌋〉⌉〉·〈〉〉〚〈√⌈π⌉〉;;;;〈√⌈π⌉〉〛〉〉·〈∓〈⌈〈√√⌊π⌋〉〈〈√π〉^⌈π⌈π⌉⌉〉⌉〉·〈⌈〈π〉π⌉〉〉·〈∓〈⌈〈√√⌊π⌋〉〈〈√π〉^⌈π⌈π⌉⌉〉⌉〉·〈⌊〈〈π〉〈〈π〉⌊π⌋〉〉〈⌈〈π^⌊π⌋〉〈⌊〈π〉π⌋〉⌉〉⌋〉〉·〈∓〈⌈〈√√⌊π⌋〉〈〈√π〉^⌈π⌈π⌉⌉〉⌉〉·〈⌊〈π〉π〈⌈〈√⌈π⌉〉〈⌈π⌈π⌉⌉^π〉⌉〉⌋〉〉·〈∓〈⌈〈√√⌊π⌋〉〈〈√π〉^⌈π⌈π⌉⌉〉⌉〉·〈〈〈⌊〈π〉π⌋〉〈⌊π^⌊π⌋⌋〉〉〈⌈〈√⌊π⌋〉^〈〈π〉π〉⌉〉〉〉·〈∓〈⌈〈√√⌊π⌋〉〈〈√π〉^⌈π⌈π⌉⌉〉⌉〉·〈⌊π^⌈π⌉⌋⌊〈π^⌈π⌉〉〈⌊π⌋^√⌊π⌋〉⌋〉〉·〈∓〈⌊〈√〈⌈π^⌊π⌋⌉〉〉〈⌈〈π^〈π〉〉^〈√π〉⌉〉⌋〉·〈〈∓〈⌈〈√√⌊π⌋〉〈〈√π〉^⌈π⌈π⌉⌉〉⌉〉·〈⌈π⌉^⌊π⌋〉〉·〈N''〉〉·〈∓〈⌊〈⌊π⌋〈√π〉〉^〈⌊π⌋〈√⌊π⌋〉〉⌋〉·〈∓〈⌊〈√〈⌊π⌋^π〉〉〈〈〈π〉π〉^⌊π⌋〉⌋〉·〈∓〈⌈〈√√⌊π⌋〉〈〈√π〉^⌈π⌈π⌉⌉〉⌉〉·〈⌈〈π〉〈⌊〈π〉〈〈π〉⌊π⌋〉⌋〉⌉〉〉·〈∓〈⌈〈√√⌊π⌋〉〈〈√π〉^⌈π⌈π⌉⌉〉⌉〉·〈⌈√〈〈〈π〉⌊π⌋〉^π〉⌉〉〉〉·〈∓〈⌊〈√〈⌊π⌋^π〉〉〈〈〈π〉π〉^⌊π⌋〉⌋〉·〈∓〈⌈〈√√⌊π⌋〉〈〈√π〉^⌈π⌈π⌉⌉〉⌉〉·〈⌈π⌉〈⌈〈π〉π⌉〉〉〉·〈∓〈⌈〈√√⌊π⌋〉〈〈√π〉^⌈π⌈π⌉⌉〉⌉〉·〈⌊⌈π⌉〈⌈π⌉^〈√π〉〉⌋〉〉·〈∓〈⌈〈√√⌊π⌋〉〈〈√π〉^⌈π⌈π⌉⌉〉⌉〉·〈⌈π⌉〈⌊π^⌊π⌋⌋〉〉〉·〈∓〈⌈〈√√⌊π⌋〉〈〈√π〉^⌈π⌈π⌉⌉〉⌉〉·〈⌈〈π〉⌈π⌈π⌉⌉⌉〉〉〉〉·〈∓〈⌊〈√〈⌊π⌋^π〉〉〈〈〈π〉π〉^⌊π⌋〉⌋〉·〈∓〈⌈〈√√⌊π⌋〉〈〈√π〉^⌈π⌈π⌉⌉〉⌉〉·〈⌊〈√⌈π⌉〉^〈〈π〉〈√⌊π⌋〉〉⌋〉〉·〈∓〈⌈〈√√⌊π⌋〉〈〈√π〉^⌈π⌈π⌉⌉〉⌉〉·〈⌈〈π^⌊π⌋〉〈√〈√π〉〉⌉〉〉·〈∓〈⌈〈√√⌊π⌋〉〈〈√π〉^⌈π⌈π⌉⌉〉⌉〉·〈⌊〈√π〉〈⌊π⌋^⌊π⌋〉⌋〉〉〉·〈〈∓〈⌊〈√〈⌊π⌋^π〉〉〈〈〈π〉π〉^⌊π⌋〉⌋〉·〈〈∓〈⌊〈√〈⌈π⌉^π〉〉〈〈⌊π⌋^π〉^√⌊π⌋〉⌋〉·∓〈〈⌈π^⌈π⌉⌉〉〈⌊〈⌈〈π〉π⌉〉^〈√π〉⌋〉〉〉·〈∓〈⌈〈〈π〉〈√⌊π⌋〉〉〈〈⌊π⌋^π〉〈⌊π⌋^⌊π⌋〉〉⌉〉·〈⌊〈π〉π⌋〉〉〉〉·〈〉〉〉
```
[Try it online!](https://tio.run/##1VdLbsMgEL0MUu5QK1fIEbCsKlK7yKpZR1lik1126QnMrivvfYHewTmIy8fADAZXVY2aRojYMLxhhpk3@FAdX/aH6vj6XI3jcGlJWZbDRTxtSUHKviPqfSvH5diJnAgp@g9SPqmRXXXYv/WdFr@fb@R@fi8GdlWzO/m@22z6ziyUM30n1xVEI7GrHm708808f56HC6eqF7q1pukB3VErpKdVb9AnMDaBKTwg15phi8DUg@5q3YTpp30yq1D/U/8mrPD6OhuvRcrQSYxn0gYtDJ2ezcJpHTAvt21A1Z@cm2yFVWb0GRxgv9/GtxFH0OYbs9bjCZhM6HABHg96CRnimc1RhCOAMputwGMJsGYhyrh2LsThgcOY9QU@Ghy6zG4WCMEzivhsbabxq7yHhFnu1YQeq6No3pyZ76MnuQCLkP3BzUxMAwhD54X8WUudeZLI4/n0G00zLT9TvR5x5GSnBsULeMTplI7/Bu4SBjzPzXCqg3HPMIshEFxMcm2tTXnEZUtALtgAp5aG0erOP1MhpH6aWwNo6NEEdcScCYmNIcPrWES56oKZpg6IbuX0ilC1mZM3xJRNThgSIp3NJKrRP7ljhpUyQgk869WMuToWUU6XM@LxPOtLUIzRM1Ek1Bov4tnu8l5zgvNy37GRoHfzw0dKM6tkNKjOcWbJ59Gw2rNbGEVZ7yXBd4OuPpHSEykQ65xtsqCBGwW8Djs10SLpP0dcVcTm@6@ekCdw8i4l0mKwtBF/JFy7cOfi84yyb@P4BQ "Wolfram Language (Mathematica) – Try It Online")
On the current version of Mathematica on TIO, this is equivalent to
```
$= StringJoin[FromCharacterCode[115], FromCharacterCode[116], FromCharacterCode[100], FromCharacterCode[111], FromCharacterCode[117], FromCharacterCode[116]]; (* "stdout" *)
WriteString[$, StringJoin[Riffle[ToUpperCase[Alphabet[]〚;;;;2〛], Alphabet[]〚2;;;;2〛]], FromCharacterCode[10], FromCharacterCode[8290], FromCharacterCode[62366], FromCharacterCode[63333], FromCharacterCode[63341], List[FromCharacterCode[64][N''], TwoWayRule[StringJoin[FromCharacterCode[92], FromCharacterCode[34]], StringJoin[FromCharacterCode[40], FromCharacterCode[46], FromCharacterCode[124], FromCharacterCode[41]]], StringJoin[FromCharacterCode[43], FromCharacterCode[42], FromCharacterCode[47]], StringJoin[Map[ToString][Range[9]]][]]]
```
This could also just be put together with `FromCharacterCode` alone. `WriteString` is required here to suppress the trailing newline, and to get special characters to print verbatim instead of as `\[*name*]` (and yes, `$Output` would have been much shorter to generate than `"stdout"`).
[Answer]
# [R](https://www.r-project.org/), Score 60, [cracked](https://codegolf.stackexchange.com/a/207591/86301)
```
";<=>?@ABCDEFGHIJKLMNOPQRSVWXYZ[\\]^_`abeghjklmqrsvwxyz{|}~"
```
Note that your output cannot have an initial `[1]` (as would be given by default printing). You cannot use `cat` because of the `a`, and you cannot use `write` because of the `w`.
Cracked by Giuseppe.
My solution:
> 
>  `dput(intToUtf8(c(59:83,86:98,101,103:104,106:109,113:115,118:126)))`
> 
> 
> 
[Answer]
# [CJam](https://sourceforge.net/projects/cjam/), score 6 ([Cracked](https://codegolf.stackexchange.com/a/207608/96155))
```
"aces'
```
This will more than likely get cracked, but I couldn't quite manage to make it harder. Hopefully this is difficult enough that it remains open for a little while.
Update: 5 hours, I'll take it. My solution:
> 
> `1`{15-}%135`{48+}%1`{66+}%1`{10-}%`
> 
> 
> 
[Answer]
# Ruby, Score: 7, [Cracked](https://codegolf.stackexchange.com/a/207613/6828)
```
p<.$a1s
```
Previous crack wasn't the intended one, so trying to head it off with another character.
[Answer]
# Befunge 93 (FBBI), score 15 ([Cracked](https://codegolf.stackexchange.com/a/207639))
```
,0123456789"~@!
```
Take two. Thanks to Befunge's limited instruction set, I expect you'll find out what I think is the only remaining way to get a non-0 value on the stack, but I don't expect you to enjoy using it. That said, it wasn't as bad as I was hoping. It should be possible to remove `:` and maybe some others too, but I'm not going to code it to verify by hand.
Good crack, I'll post my solution here (as a TIO link, because the <pre> block didn't like it), which is along the same lines but more brute-forcey. It takes a `+` from the top left with `g` whenever it needs a new character, does some math to make that a `,`, and does a little more math to place it. Then it takes a copy of that comma and turns it into whatever character it needs, then rinses and repeats.
[Try it online](https://tio.run/##rZS9DoMgFEZ3n4K5hDjYDpKm6Xs0LiRqujQu9fUpoPwIAlcLAwNczne4JLB@@H7GnrQNGRh7c45HSmtMxUQnOWE8VzPyx7162DoqiqawyquRVaJOMSPUxNnl9HpeATKEKEeTjAuUFeVZovVTS1Bqku3SrfMJfjJjm@LcY1k/npTN8xOdu607Z0PzyWG2e2O9@Vc@yGLPw@1DQROQzb7PpjemopAT2CzmZuwwvUgEKSkG8oqbKTf5mLWaSdmmwf1ShspRNE//haS04yHPtKn/RxR/79D7yfmrRTfUoGv3Aw)
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), Score: 14, [cracked](https://codegolf.stackexchange.com/a/207668/81203)
```
Echo@Dt[0 & ]
```
[Answer]
# [Mornington Crescent](https://github.com/padarom/esoterpret), Score: 5, [Cracked](https://codegolf.stackexchange.com/a/207764/68693)
X = `7UBES`
London's burning! A large amount of the Underground has been closed off while the authorities try to avert disaster. Amid hellfire, dare you enter... the 7UBES†?
---
As for the language definition, consider it defined by the linked interpreter (This interpreter is also used on TIO). Note that the interpreter may not fully conform to [the language specification](https://esolangs.org/wiki/Mornington_Crescent), in particular not to the [forward compatibility](https://esolangs.org/wiki/Mornington_Crescent#Forward_compatibility) clause, as the interpreter is not maintained in parallel with infrastructural projects taking place in the Underground.
---
While the lack of Upminster and Upney block the easiest ways, there are quite a few options left. My solution mostly depended on Manor House while ignoring Holland Park, in contrast to @pppery.
```
#First, place an int at Paddington, such that the string starts with our character instead of 'Paddington'
Take Northern Line to Charing Cross #ACC: 67
Take Northern Line to Moorgate
Take Circle Line to Moorgate
Take Circle Line to Paddington #PAD: 67
##Plan: get 120
#First, put 'Oxford Circus' on Gunnersbury
Take Circle Line to Victoria
Take Victoria Line to Oxford Circus
Take Victoria Line to Victoria
Take Victoria Line to Victoria
Take District Line to Gunnersbury
#Now, get 2
Take District Line to Acton Town
Take Piccadilly Line to Heathrow Terminals 1, 2, 3
Take Piccadilly Line to Acton Town
Take District Line to Acton Town
Take District Line to Parsons Green
Take District Line to Parsons Green
Take District Line to Parsons Green
#Get 'x...'
Take District Line to Gunnersbury #ACC: 'Ox'
Take District Line to Acton Town
Take District Line to Acton Town
Take Piccadilly Line to Turnpike Lane
Take Piccadilly Line to Turnpike Lane
#Get 120
Take Piccadilly Line to Holborn
Take Central Line to Holborn
Take Central Line to Tottenham Court Road
Take Central Line to Tottenham Court Road
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross #ACC: 120
#Move to PR
Take Northern Line to Moorgate
Take Circle Line to Moorgate
Take Metropolitan Line to Preston Road #PR: 120
#get 65
Take Metropolitan Line to Amersham
Take Metropolitan Line to Moorgate
Take Circle Line to Moorgate
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross
Take Northern Line to Moorgate
Take Circle Line to Moorgate
#get '7'
Take Metropolitan Line to Preston Road #ACC:55 PR:65
Take Metropolitan Line to Moorgate
Take Circle Line to Moorgate
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross
Take Northern Line to Moorgate
Take Northern Line to Moorgate
Take Circle Line to Paddington #PAD: '7' 
##Plan: get 85
#get 4
Take District Line to Parsons Green #int from Pad triggers swap
Take District Line to Parsons Green #ACC: 3
Take District Line to Wimbledon #Wi: 3
Take District Line to Acton Town
Take Piccadilly Line to Heathrow Terminal 4
Take Piccadilly Line to Acton Town
Take District Line to Acton Town
Take District Line to Parsons Green #ACC: 4
#put 4 at MH
Take District Line to Acton Town
Take District Line to Acton Town
Take Piccadilly Line to Manor House
#get 81
Take Piccadilly Line to Holborn
Take Central Line to Queensway
Take Central Line to Tottenham Court Road
Take Central Line to Tottenham Court Road
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross #ACC: 81
# ~~(81 | 4) == 85
Take Northern Line to Tottenham Court Road
Take Central Line to Tottenham Court Road
Take Central Line to Holborn
Take Central Line to Holborn
Take Piccadilly Line to Manor House #ACC: ~85, nor: 81
Take Piccadilly Line to Holborn
Take Central Line to Holborn
Take Central Line to Notting Hill Gate
Take Central Line to Notting Hill Gate #ACC: 85
#get 'U'
Take Circle Line to Moorgate
Take Circle Line to Moorgate
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross #ACC: 'U'
#concat 'U'
Take Northern Line to Moorgate
Take Circle Line to Moorgate
Take Circle Line to Paddington
Take Circle Line to Paddington #PAD: '7U'
##Plan: Get 66
#get 32
Take District Line to Parsons Green #ACC: 7
Take District Line to Gunnersbury #Gu: 7
Take District Line to Richmond #Ri: 2
Take District Line to Acton Town
Take Piccadilly Line to Covent Garden
Take Piccadilly Line to Acton Town
Take District Line to Acton Town
Take District Line to Gunnersbury #ACC: 'Covent '
Take District Line to Acton Town
Take District Line to Acton Town
Take Piccadilly Line to Turnpike Lane
Take Piccadilly Line to Turnpike Lane
Take Piccadilly Line to Holborn
Take Central Line to Holborn
Take Central Line to Tottenham Court Road
Take Central Line to Tottenham Court Road
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross #ACC: 32
#Get 64
Take Northern Line to Moorgate
Take Northern Line to Moorgate
Take Metropolitan Line to Chalfont & Latimer
Take Metropolitan Line to Moorgate
Take Circle Line to Temple
Take District Line to Richmond #ACC: 2
Take District Line to Temple
Take Circle Line to Moorgate
Take Circle Line to Moorgate
Take Metropolitan Line to Chalfont & Latimer #ACC: 64, tim: 2
# ~~(64 | 2) == 66
Take Metropolitan Line to Rayners Lane
Take Metropolitan Line to Chalfont & Latimer
Take Metropolitan Line to Rayners Lane
Take Metropolitan Line to Rayners Lane
Take Piccadilly Line to Oakwood
Take Piccadilly Line to Manor House
Take Piccadilly Line to Oakwood #Oak: 81
Take Piccadilly Line to Manor House
Take Piccadilly Line to Rayners Lane
Take Piccadilly Line to Manor House #ACC: ~66, nor: 64
Take Piccadilly Line to Holborn
Take Central Line to Holborn
Take Central Line to Notting Hill Gate
Take Central Line to Notting Hill Gate #ACC: 66
#get 'B'
Take Circle Line to Moorgate
Take Circle Line to Moorgate
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross
#concat 'B'
Take Northern Line to Moorgate
Take Circle Line to Moorgate
Take Circle Line to Paddington
Take Circle Line to Paddington #PAD: '7UB'
##Plan: get 69
#Get 5
Take District Line to Acton Town
Take Piccadilly Line to Heathrow Terminal 5
Take Piccadilly Line to Acton Town
Take Piccadilly Line to Acton Town
Take District Line to Parsons Green #ACC: 5
# ~~(64 | 5) == 69
Take District Line to Acton Town
Take District Line to Acton Town
Take Piccadilly Line to Manor House #ACC: ~69, nor: 5
Take Piccadilly Line to Holborn
Take Central Line to Holborn
Take Central Line to Notting Hill Gate
Take Central Line to Notting Hill Gate #ACC: 69
#get 'E'
Take Circle Line to Moorgate
Take Circle Line to Moorgate
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross
#concat 'E'
Take Northern Line to Moorgate
Take Circle Line to Moorgate
Take Circle Line to Paddington
Take Circle Line to Paddington #PAD: '7UBE'
##Plan: get 83
#Place 81 at nor
Take District Line to Acton Town
Take Piccadilly Line to Manor House #nor: 'B7UB'
Take Piccadilly Line to Oakwood #ACC: 81, Oak: 5
Take Piccadilly Line to Manor House #nor: 81
#get 2 == 65 % 3
Take Piccadilly Line to Acton Town
Take District Line to Wimbledon #ACC: 3
Take District Line to Temple
Take Circle Line to Moorgate
Take Circle Line to Moorgate
Take Metropolitan Line to Preston Road #ACC: 2
# ~~(81 | 2) == 83
Take Metropolitan Line to Rayners Lane
Take Metropolitan Line to Rayners Lane
Take Piccadilly Line to Manor House #ACC ~83
Take Piccadilly Line to Holborn
Take Central Line to Holborn
Take Central Line to Notting Hill Gate
Take Central Line to Notting Hill Gate #ACC: 83
#get 'S'
Take Circle Line to Moorgate
Take Circle Line to Moorgate
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross
#concat 'S'
Take Northern Line to Moorgate
Take Circle Line to Moorgate
Take Circle Line to Paddington #PAD: '7UBES'
Take Circle Line to Moorgate
Take Circle Line to Moorgate
Take Northern Line to Mornington Crescent
```
[Try it online! (without comments)](https://tio.run/##7VjBctpADL33K3TqKTm0aT4g487AISSE8aTnxVbinaxXjHYdwtenohADiQn2YghMOcJ7K0ta6Ul2Tmy1ffRkzxNGl6D1r6@xekK4IfYZsoVrbRE8QZQpFipETM59q@b0iPhReZzBkebEYD2wr9J05kglfK8TT6zVDHz7VcK3Lw/E6b9DhVvD2WBiFf6tnWf5p4Q7hbXIbljwZA3jSs5biGk8j6Cvk0Sl2phJSemi8hnTGGLkXFtlHPw4g59ncLH2yHurGx/7gdBX7Mg66DDirjnNsxSSxrhgO9KCXSuLW7K6ZIbSA/Oik/JnZeqBMXmPNlM5RFSwhwGptCkzqMlabsQeeqYRGe3V4nxfxGB6DwtXK2lXudy2BPYJpYEnx56Nwwu1WSbea/DOZOKPzocGU7ItSin8@mINbUPZesoSi@wULlCx7gpx0I3V5Ag1qw3nGin4CriL2/gUvJEgpinpij3oLHqyJq3BbnV4Ktts@WtFlzavJgOdZDnZNLx9I3qW25Nb4hTtDuXotGYd5Jq1Aa7cGeQp5oGkaL5LAr2WfSp0wYgxHxkMq@3ls@HKsn2AAzWZFvZSLe3N5kdaRRnfqqcxUbrVxJjbgK2M1PJ2yRAc0ACD/3mCQZsr72XtGRMyhlamKuxn6z3V6fHXaa3rbKKCEF7D5Zsm7H/yLX81gD0NqFMrfUErtR9dr/wsL86/fZb/Cw "Mornington Crescent – Try It Online")
†: Pardon me for the 1337-speak, my options are limited: each valid program in this language ends with `Take Northern Line to Mornington Crescent`. 
[Answer]
# BBC Basic II, Score: 2, [Cracked](https://codegolf.stackexchange.com/questions/207560/print-x-without-x-robbers-thread/207804#207804)
One more example in a "non-golfing" language:
> 
> VP
> 
> 
> 
(I tested my program on an Acorn BBC model B emulator and on an Acorn Archimedes emulator. However, according to the BBC Basic manual I found in the internet, it should work on "modern" BBC Basic versions for the PC, too.)
---
My solution:
The solution in the [crack](https://codegolf.stackexchange.com/questions/207560/print-x-without-x-robbers-thread/207804#207804) directly writes to the display memory of the BBC model B. This means that the solution would not work on an Archimedes, an x86-based machine or on a second CPU (tube) of a BBC.
My solution uses a special feature of BBC Basic:
> 
>  On 6502-based computers (like the BBC), the `CALL` command calls some assembly function located at a certain address. The value in the variable `A%` is written to the `A` register before calling the function.  
> 
>   
> 
>  On non-6502 systems (ARM or x86), the `CALL` command normally works in a similar way; however, if the parameter is the address of an operating system routine of the 6502 operating system, the BASIC does not interpret the argument as address of an ARM or x86 assembly language routine. Instead, the `CALL` command will more or less emulate a call to the OS of a 6502-based computer for such arguments.  
> 
>   
> 
>  For this reason `CALL 65518` will always write the byte represented by the value in variable `A%` to the "standard output" - even on ARM-based computers where `65518` is not a valid code address!
> 
> 
> 
Using this feature, the solution is quite simple:
> 
>  `10 A%=80`  
> 
> `20 CALL 65518`  
> 
> `30 A%=86`  
> 
> `40 CALL 65518`
> 
> 
> 
[Answer]
# [R](https://www.r-project.org/), Score=30, safe
```
t <-
"$&0123456789=?[\\^`lv{|"
```
A trickier version of my [previous challenge](https://codegolf.stackexchange.com/a/207696/86301), which Dominic van Essen [cracked](https://codegolf.stackexchange.com/a/207700/86301) in a few hours. Without `t` you cannot easily use `get` or `cat`, and without `l` you cannot use `ls`, `eval`, `do.call` or `el`.
Hopefully this time you will have to come closer to my intended solution!
---
Solution :
The key is to use the function `dump` to print. This function produces a text representation of objects, i.e. R code to recreate the objects. All we need to do is assign to `t` the character string `"$&0123456789=?[\\^lv{|"`, and then use `dump('t','')`.
This requires two tricks. First, to create strings, we shall use `rawToChar(as.raw(NNN))` where `NNN` is the ASCII code of the characters. Such integers can be created with `T+T+T+...+T`. Second, since we cannot assign using `=`, `<-` or `->`, we use the function `assign`. Conveniently, this requires the object name to be given as a string, so we can also define the object name with `rawToChar(as.raw(NNN))`.
In order to make the solution more readable, I have added spaces and newlines, and I have written the integers directly rather than as `T+T+T+...+T`. The TIO gives the complete solution.
```
assign(rawToChar(as.raw(116)), rawToChar(as.raw(c(36, 38, 48:57, 61, 63, 91, 92, 94, 96, 108, 118, 123, 124))))
dump(rawToChar(as.raw(116)), '')
```
[Try it online!](https://tio.run/##K/r/P7G4ODM9T6MosTwk3zkjsUgjsVgPyNEwNDTT1NTBEE7W0AjRhkNNLS0QV1MHmyCIrYOmHJkHFtG00kAVw6IG0wJ0JVBlxKmCuAtThihTCZpNmmrydKDogqmFBjtyYGFKaWMxVic9MTc3UQNLIOGSAMWbpqZ1SmluAa6Eo66u@f8/AA)
[Answer]
# [Stack Cats](https://github.com/m-ender/stackcats), Score: 3, Safe
```
)*(
```
All Stack Cats programs are symmetrical, and the reflection of a command undoes the original.
As a result, every program with an even length either runs forever or does some work, then immediately undoes that work, and devolves into a `cat` program. The only way to write something else is to use an odd number of characters and let the center give structure to the rest of the code.
If you want to run the code `xyz`, the easiest approach is to use a structure like `<(zyx)*(xyz)>`, which completely skips the first half. This is boring, so I’ve made that construction impossible.
Naturally, the output is also symmetrical :)
## Solution:
```
_+!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_[!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_]_:_[_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!]_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!_!+_
```
[Try it online!](https://tio.run/##Ky5JTM5OTiwp/v8/XlsxfuBg9EBaPhRhbLxVfPRoOJAGYwfScu34//8B "Stack Cats – Try It Online")
## Explanation:
For this explanation, `s[0]` is the top of a stack, `s[1]` is the element below `s[0]`, and a stack is written `[top, middle, bottom]`
Here's what the stack looks like after each step. I’ll use a number to represent how many `!_` / `_!` pairs are used:
```
_+       # [0, 0, 1]
62       # [62, 0, 1]
[152]    # [214, 0, 1]    
_:_      # [-214, -214, 1]
[152]    # [-366, -214, 1]
62       # [12840, -214, 1]
+_       # [-215, -214, 12840]
```
This approach is mostly built around `!_` and its reflection `_!`. `_` sets `s[0] = s[1] - s[0]`, and `!` sets `s[0]` to its bitwise negation. When `s[1]` is 0, `!_` increments the top of the stack and `_!` decrements it.
In the first half of the program, `[` moves the top element to a different stack and continues incrementing it there, then `]` moves it back. By itself, this is pointless, but those characters are important in the second half. The code increments the top of the stack 214 times (62 + 152).
In the center, `_:_` negates the top of the stack and sets `s[1] = s[0]`. `[152]` moves the top element to its own stack, decrements it 152 times, then puts it back on the primary stack. Now that the stack has a nonzero `s[1]`, `_!` no longer decrements the top, but sets `s[0] = !(-214 - s[0])` 62 times.
Once the program ends, the stack has the values `[-215, -214, 12840]`. These are output mod 256, giving `[41, 42, 40]`, which in ASCII makes `)*(`
[Answer]
# Scala, score: 2 [Cracked](https://codegolf.stackexchange.com/a/207572/95792)
```
(.
```
Shouldn't be too hard to crack.
Edit: Guess I was right :/
The [code](https://scastie.scala-lang.org/0oge1IgHRZ6MfAH2wmA2gg) I used:
> 
> 
> ```
> 
>  object Main extends App {
>    def f: String => Unit = println _
>    this f "\u0028\u002e"
>  }
> ```
> 
> 
> 
> 
[Answer]
# Ruby, score 6, [cracked by @nthistle](https://codegolf.stackexchange.com/a/207581/6828)
```
p<.$a1
```
Not intended to output via error, although I also don't think it's possible to do so without a lot of other characters.
[Answer]
# Befunge 98, Score: 4, [cracked](https://codegolf.stackexchange.com/a/207607/46076)
```
=sp,
```
Trying to prove ovs' claim that "I don't think this can be made harder in Befunge" wrong. (This answer may still be too easy, but I can say for sure that it is harder than the other one, because I've blocked both self-modifying code operators)
Intended solution:
> 
> `"PAMI"4('+1+'o1+'r1+'<1+'+1+'ZMZZZZ@`
> 
> 
> 
[Answer]
# [R](https://www.r-project.org/), Score=23 [cracked](https://codegolf.stackexchange.com/a/207647/86301) by Robin Ryder
```
0123456789+-*/^!&|%`()$
```
This has a worse score than [Robin Ryder's currently-latest R challenge](https://codegolf.stackexchange.com/questions/207558/print-x-without-x-cops-thread/207615#207615), but if you crack this you'll probably crack his one, too.
[Answer]
# Java, Score: 3 ([Cracked](https://codegolf.stackexchange.com/questions/207560/print-x-without-x-robbers-thread/207702#207702))
```
.\
```
Round two for this solution, fixing the previous crack. As with the original, the output from my solution was to standard error.
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), Score: 5, [cracked](https://codegolf.stackexchange.com/a/207786/78410)
```
uvUV┼
```
Can you generate the Unicode box-drawing character `U+253C` or `⎕UCS 9532` without `⎕UCS` or `⎕AV`?
Any system variable setting (`⎕IO`, `⎕ML`, etc.) can be used. The code should work in TIO's code section, so SALT (and user command) is not available. Since there is no trailing newline in the expected output, use `⍞`-printing (which prints to STDERR).
[Answer]
## Perl 5, Score: 80, [Cracked](https://codegolf.stackexchange.com/questions/207560/print-x-without-x-robbers-thread/207814#207814)
```
!"'*+,-0123456789:;<?@ABCDEFGHIJKLMNOPQRSTUVWXYZ\^`abcdefghijklmnopqrstuvwxyz{|~
```
This means that the following printable ASCII characters are permitted:
```
 #$%&()./=>[]_}
```
Inspired by Dom Hastings's challenges ([1](https://codegolf.stackexchange.com/a/207618), [2](https://codegolf.stackexchange.com/a/207673), [3](https://codegolf.stackexchange.com/a/207698)) and my solutions ([1](https://codegolf.stackexchange.com/questions/207560/print-x-without-x-robbers-thread/207671#207671), [2](https://codegolf.stackexchange.com/questions/207560/print-x-without-x-robbers-thread/207688#207688), [3](https://codegolf.stackexchange.com/questions/207560/print-x-without-x-robbers-thread/207718#207718)).
[Answer]
# [Malbolge](https://github.com/TryItOnline/malbolge), score: 2, [Cracked](https://codegolf.stackexchange.com/a/208925/95679)
```
To
```
In Malbolge, the "print X" part of the challenge should be hard enough by itself.
---
Original solution:
> 
>  `('&%$#"!~}|{2V0w.R?`
>   
> 
>   
> 
> [Try it online!](https://tio.run/##y03MScrPSU/9/19DXU1VRVlJsa62ptoozKBcL8j@/38A)
> 
> 
> 
]