title: Print X without X (cop's thread)

text:
# Question
Title: Print X without X (cop's thread)
*This is the cop's thread of a challenge. You can view the robber's thread here*

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 and repls 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
> 35 votes
# Python 3, Score: 81, Cracked

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
> 15 votes
# Javascript (Browser), score: 3, Cracked

```
(\)

```

Simple, but hard.

My solution:

> `Function`$${unescape`alert%28"%28%5C%5C%29"%29`}````

# Answer
> 14 votes
# Python 3.7, Score: 1 - Cracked

X = `(`

Same base rules as nthistle's challenge 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 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
> 13 votes
# Haskell, Score 81, Cracked

```
" !#$%&()*+/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

```
" !#$%&()*+/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
> 12 votes
# 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, 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, 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`. 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`, 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!

# Answer
> 11 votes
# Mornington Crescent, Score: 4, Cracked

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

## 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
> 11 votes
# Python 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!

---

## Solution

The code is to large too fit here, so try visiting one of these links: *Try it online! or Verify it online! or Generate it online!*.

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
> 7 votes
# C (gcc), score 4 (Cracked)

```
#_ep

```

My source code doesn't contain any of these characters and when complied and run, it outputs `#_ep` to `stdout`.

# Answer
> 7 votes
# Vyxal \\$\le\\$ 2.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 may be applicable. However, Vyxal has changed a lot since that competition. Good luck!

<sup>Btw, my intended solution is 37 yottabytes.</sup>

# Solution

<sup>note: Due to bug fixes, some of the links here won't work anymore</sup>

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. 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 as well, but appending a `P` (strip) results in a zero, which we can then remove from the string `01234567` leaving 1234567, which we can eval.

### Getting strings

Following this, we can get 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  by dividing 1234567 by itself.

We can get the range from 2 to 7 by removing 1 although this seems useless for now. We can also get 1-7.

Taking a step back, we can stringify 1/1234567 by stripping `/`. We can get `1/` 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. In general, we can reverse a string/number by calling `P` with it and `[0]`. This will prove *very* helpful.

Taking a step back to numbers, we can get `234567` with what we already have.

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 lets us get the singleton list containing 2.

Removing that from \[2..7\] yields 7...3. 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  and !

### Printable ASCII

By removing both of these + the octal digits from printable ASCII, we can get something usable?

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 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 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.

This can be represented 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, we can get `["a"]`. Then we can get `["b"]`.

We can remove `a` from the string form of printable ascii (and reverse it as a side effect, but that's easily fixable). We can then remove `b`. You can probably see where this is going, can't you.

With this method, we can get `c` in a list, 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.

For `b`, we need 6 ascii + 4 head + 4 strip + `o` = 16169 bytes. Simpler version.

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 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.

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
> 6 votes
# International Phonetic Esoteric Language, Score: 47, Cracked

Let's throw my own language into the ring.

```
 !"#$%&'()*+,-.ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`

```

My solution:

> `{32}{15}0ɑbesχue1søɒ{65}{32}0ɑbesχue1søɒ`

# Answer
> 6 votes
# Haskell, Score 74, Cracked

```

 !"#$%&()*+/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!

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
> 6 votes
# Javascript, score: 83, cracked?

<sup>(the crack is not executable like `/path/to/interpreter file.js`, unlike my solution, but I don't think that matters a lot)</sup>
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
> 6 votes
# Wolfram Language (Mathematica), 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!

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
> 5 votes
# , Score 60, cracked

```
";<=>?@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
> 5 votes
# Ruby, Score: 7, Cracked

```
p<.$a1s

```

Previous crack wasn't the intended one, so trying to head it off with another character.

# Answer
> 5 votes
# Wolfram Language (Mathematica), Score: 14, cracked

```
Echo@Dt[0 & ]

```

# Answer
> 5 votes
# CJam, score 6 (Cracked)

```
"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
> 5 votes
# BBC Basic II, Score: 2, Cracked

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 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
> 5 votes
# Befunge 93 (FBBI), score 15 (Cracked)

```
,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

# Answer
> 5 votes
# , Score=30, safe

```
t <-
"$&0123456789=?[\\^`lv{|"

```

A trickier version of my previous challenge, which Dominic van Essen cracked 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!

# Answer
> 5 votes
# Mornington Crescent, Score: 5, Cracked

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, in particular not to the 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)

<sub>†: Pardon me for the 1337-speak, my options are limited: each valid program in this language ends with `Take Northern Line to Mornington Crescent`. </sub>

# Answer
> 5 votes
# Stack Cats, 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!

## 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
> 4 votes
# Scala, score: 2 Cracked

```
(.

```

Shouldn't be too hard to crack.

Edit: Guess I was right :/

The code I used:

> ```
>  object Main extends App {
>    def f: String => Unit = println _
>    this f "\u0028\u002e"
>  }
> ```

# Answer
> 4 votes
# Ruby, score 6, cracked by @nthistle

```
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
> 4 votes
# Befunge 98, Score: 4, cracked

```
=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
> 4 votes
# Dotty 0.26-RC1, Score: 7 (Safe)

```
"+. p\{

```

Earlier versions may work too, like 0.25 and 0.24, but I'm not totally sure how low you can go, since Dotty's features keep changing.

Harder version, score: 8 (I still had the same solution for this, but the one above may have alternate cracks, and this doesn't allow them, hopefully.)

```
"+. p\{[

```

---

## Update

Since my answer's over a week old now, here's the solution I got (I'm sure it could be made shorter, but whatever)

```
object`Main`:
    @main
    def`main`=(Console`out`)write(new`String`()concat((34`toChar`)toString)concat((43`toChar`)toString)concat((46`toChar`)toString)concat((32`toChar`)toString)concat((112`toChar`)toString)concat((92`toChar`)toString)concat((123`toChar`)toString)getBytes)

```

I basically just used `concat` instead of `+`, `xx.toChar.toString` to get around the `"`, postfix and infix syntax to get around the `.`, and the backtick to get around the restriction on spaces.

A couple Dotty-specific features that helped: `@main` meant I didn't have to write `(args: Array[String])`, saving me `[`, and Dotty's new indentation-based syntax let's you use `:` instead of curly braces. Note that even though you see spaces here and in the playground, Dotty does let you use tabs.

Try it in Scastie

Bonus (the same thing, but no parentheses this time)

```
"+. p\{(

```

Here's my solution to it (unfortunately, the backticks were removed, because I don't know how to put code in spoilers, but imagine they were there)

> ```
>  object`Main`:
>      @main
>      def`main`=
>          val`a`=34`toChar`
>          val`b`=43`toChar`
>          val`c`=46`toChar`
>          val`d`=32`toChar`
>          val`e`=112`toChar`
>          val`f`=92`toChar`
>          val`g`=123`toChar`
>          val`h`=40`toChar`
>          val`i`=new`StringBuilder`
>          i`append`a`append`b`append`c`append`d`append`e`append`f`append`g`append`h
>          val`j`=i`toString`
>          val`k`=j`getBytes`
>          val`l`=Console`out`
>
>          l`write`k
>
> ```

Scastie

# Answer
> 4 votes
# , Score=23 cracked by Robin Ryder

```
0123456789+-*/^!&|%`()$

```

This has a worse score than Robin Ryder's currently-latest R challenge, but if you crack this you'll probably crack his one, too.

# Answer
> 4 votes
# Java, Score: 3 Cracked

```
\[;

```

This eliminates unicode literals, arrays, and semicolons

# Answer
> 4 votes
# APL (Dyalog Unicode), Score: 5, cracked

```
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
> 4 votes
# Java, Score: 3 (Cracked)

```
.\

```

Round two for this solution, fixing the previous crack. As with the original, the output from my solution was to standard error.

# Answer
> 4 votes
## Perl 5, Score: 80, Cracked

```
!"'*+,-0123456789:;<?@ABCDEFGHIJKLMNOPQRSTUVWXYZ\^`abcdefghijklmnopqrstuvwxyz{|~

```

This means that the following printable ASCII characters are permitted:

```
 #$%&()./=>[]_}

```

Inspired by Dom Hastings's challenges (, , ) and my solutions (, , ).

# Answer
> 4 votes
# Malbolge, score: 2, Cracked

```
To

```

In Malbolge, the "print X" part of the challenge should be hard enough by itself.

---

Original solution:

> `('&%$#"!~}|{2V0w.R?`
> Try it online!

# Answer
> 4 votes
# Rust, score 2 ~~32~~, Cracked

`pw`

~~`pw?@ABCDEFGHIJKLMNOPQSTUXYZ!"#$%`~~

Pretty challenging to output to stdout without being able to type `print` or `write`!

Rust version: `rustc 1.45.1 (c367798cf 2020-07-26)`

# Answer
> 4 votes
# Python 3.7, Score: 7, Cracked by Ethan White

```
(nuvwxy

```

Inspired by Tips for restricted source in Python.

This should block `eval` and `exec`, function calls that don't use the `__class_getitem__` trick, and most forms of output (`print`, `write`, etc.)

My solution only uses ASCII characters.

## My Solution

```
class C:__class_getitem__=chr
class D:__class_getitem__=dir
class M:__class_getitem__=__import__

code = M[C[99]+C[111]+C[100]+C[101]]  # Import code
i_spect = M[C[105]+C[110]+C[115]+C[112]+C[101]+C[99]+C[116]]  # Import inspect

I = code.__dict__[D[code][2]]  # I = code.InteractiveInterpreter
class A:__class_getitem__=I.__call__
e = A[{}]  # Instantiate InteractiveInterpreter({})

class S:__class_getitem__=i_spect.getmembers.__call__
class R:__class_getitem__=S[e][28][1]  # Get the runcode method

z=C[112]+C[114]+C[105]+C[110]+C[116]+C[40]+C[34]+C[92]+C[34]+C[39]+C[40]+C[110]+C[117]+C[118]+C[119]+C[120]+C[121]+C[34]+C[41]

R[z]  # Run the constructed print statement

```

My approach was to use `code.InteractiveInterpreter().runcode()` as an alternate version of `exec`. Since I blocked `n`, I couldn't type that class or method directly, so I imported `InteractiveInterpreter` and `inspect` by constructing strings and passing them to `__import__`, then used `dir` and `inspect.getmembers` to get the `runcode` method, then passed in a string to execute.

I had a lot of fun coming up with this convoluted approach, but I didn't realize `timeit` was a much simpler version of `exec` that avoided this complexity, and there's no way to block `timeit` without also blocking `__class_getitem__`.

# Answer
> 4 votes
# Python 3, Score:96 Cracked by pxeger

Similar to my other answer, improvements inspired by Wheat Wizard's crack. Still self-verifying.

Output viewed through hexdump (non-printable output makes it look incorrect on the terminal):

```
$ python3 ./test4.py | hexdump -C
00000000  09 0a 0b 0c 0d 0e 0f 10  11 12 13 14 15 16 17 18  |................|
00000010  19 1a 1b 1c 1d 1e 1f 21  22 23 24 25 26 27 2a 2b  |.......!"#$%&'*+|
00000020  2d 2f 30 31 32 33 34 35  36 37 38 39 3a 3b 3c 3d  |-/0123456789:;<=|
00000030  3e 3f 40 41 42 43 44 45  46 47 48 49 4a 4b 4c 4d  |>?@ABCDEFGHIJKLM|
00000040  4e 4f 50 51 52 53 54 55  56 57 58 59 5a 5b 5c 5d  |NOPQRSTUVWXYZ[\]|
00000050  5e 60 64 6b 70 71 76 77  78 79 7a 7b 7c 7d 7e 7f  |^`dkpqvwxyz{|}~.|
00000060

```

Original:

Script generating script:

```

import re

filecode = "__builtins__.__getattribute__('globals')().__getitem__('__file__')"
code = "__builtins__.__getattribute__('open')(1,chr(119)).__getattribute__(str().join([chr(119),chr(114),chr(105),chr(116),chr(101)]))(str().join([b for b in (chr(u) for u in __builtins__.__getattribute__('range')(9,128)) if b not in __builtins__.__getattribute__(str().join((chr(111),chr(112),chr(101),chr(110))))(__file__,chr(114)).__getattribute__('read')()]))"

code = code.replace('__file__',filecode)
code = code.replace('[','(')
code = code.replace(']',')')

squots = re.compile("'([^']+)'")

dquots = re.compile('"([^"]+)"')

def fy(x):
    return f"str().join(chr(b) for b in {repr(tuple([ord(x) for x in x.group(1)]))})"

def replaceliterals(x):
    xx = squots.sub(fy,x)
    return dquots.sub(fy,xx)

digits= re.compile("\d+")
open(1,'w').write(digits.sub(lambda x: f"len({repr(tuple([tuple()]*int(x.group(0))))})",replaceliterals(code)))

```

Try the result online!

# Answer
> 4 votes
# Lost, Score 4, Cracked

*Runs in `-A` mode for character output*

```
<>^v

```

You are going to have to write a deterministic, halting Lost program without any hard redirects.

## My solution

```
/\/\/\/\/\/\/\/\/\/\/\/\/\/\/
\%(((((265**:2+:65*+:2+:83*+@

```

Try it online!

# Lost, Score 5, Cracked

```
<>\^v

```

Now do it without `\`.

## My solution

```
/|////////////////////////////
|/%(((((265**:2+:65*+:2+:83*+@

```

Try it online!

# Lost, Score 6, Cracked

```
<>\^v|

```

You don't really need `|` either.

## My solution

```
//////////////////////////////////////////////////////////////
%((((((((((((265**:2+:65*+:2+:83*+:6+@+6:+*38:+2:+*65:+2:**562

```

Try it online!

# Answer
> 4 votes
# Vyxal, score 250, cracked by aaroneous

```

 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijmnopqrtuvwxyz{|}~¡¢£¤¥¦§¨«¬°±²µ¶¹»¼½¾×Þßæð÷øĊċėĠġİĿŀŻżƈƒƛǍǎǏǐǑǒǓǔȦȧȮȯɖɽɾʀʁΠβελτḂḃḊḋḞḟḢḣḭṀṁṄṅṖṗṘṙṠṡṪṫẆẇẊẋẎẏ‛„‟†‡•…‹›⁋⁰⁺⁼⁽₀₁₂₃₄₅₆₇₈₌₍€₴⅛←↑→↓↔↲↳↵⇧⇩∆∇∑√∞∧∨∩∪∴∵∷≈≠≤≥≬⊍⋎⋏⌈⌊⌐□⟇⟑⟨⟩꘍ꜝ

```

So *this* is how emanresuA felt.

# Answer
> 3 votes
# 05AB1E, Score: 21, Cracked

X = `•”“’‘Ž…„'"ഭ0123456789`

A bit more difficult entry :)

**edit**

Cracked by @nthistle

# Answer
> 3 votes
# , Score=13

```
-/+0123456789

```

Printing characters without using digits should be tricky (and I'm pretty confident that you won't find a way to sneak in a `utf8ToInt`!). I wouldn't be surprised if the crack ends up completely different from my own solution.

# Answer
> 3 votes
# C, score 2 (cracked)

Output `{;` to stdout.

Probably not that difficult, but I was quite surprised when I first saw this C feature.

# Answer
> 3 votes
# Fortran (GFortran), Score: 18, Cracked

```
Pp1234567890'"+-*/

```

My code outputs to STDOUT with no leading whitespace and a trailing newline.

---

### My solution

@Gilles'SO-stopbeingevil' used exactly the same approach in the crack, with minor differences in implementation:

> ```
>  character(bit_size(i)) :: fmt, out
>  izero = floor(epsilon(r))  ! len_trim(achar(bit_size(i))) also works
>  ione = ceiling(epsilon(r)) ! len(achar(bit_size(i))) also works
>  itwo = ibset(izero,ione)
>  ithree = ibset(ione,ione)
>  ifour = ibset(izero,itwo)
>  ifive = ibset(ifour,izero)
>  isix = ibset(ifour,ione)
>  iseven = ibset(isix,izero)
>  ieight = ibset(izero,ithree)
>  inine = ibset(ieight,izero)
>  iten = ibset(ieight,ione)
>  ieleven = ibset(iten,izero)
>  itwelve = ibset(ieight,itwo)
>  ithirteen = ibset(itwelve,izero)
>  ifourteen = ibset(itwelve,ione)
>  ififteen = ibset(ifourteen,izero)
>  isixteen = ibset(izero,ifour)
>  iseventeen = ibset(isixteen,izero)
>  ieighteen = ibset(isixteen,ione)
>  fmt(ione:ione) = achar(ibset(ieight,ifive))
>  fmt(itwo:itwo) = achar(ibset(ione,isix))
>  fmt(ithree:ithree) = achar(ibset(inine,ifive))
>  out(ione:ione) = achar(ibset(isixteen,isix))
>  out(itwo:itwo) = achar(ibset(ibset(isixteen,ifive),isix))
>  out(ithree:ithree) = achar(ibset(iseventeen,ifive))
>  out(ifour:ifour) = achar(ibset(ieighteen,ifive))
>  out(ifive:ifive) = achar(ibset(ibset(ithree,ifour),ifive))
>  out(isix:isix) = achar(ibset(ibset(ifour,ifour),ifive))
>  out(iseven:iseven) = achar(ibset(ibset(ifive,ifour),ifive))
>  out(ieight:ieight) = achar(ibset(ibset(isix,ifour),ifive))
>  out(inine:inine) = achar(ibset(ibset(iseven,ifour),ifive))
>  out(iten:iten) = achar(ibset(ibset(ieight,ifour),ifive))
>  out(ieleven:ieleven) = achar(ibset(ibset(inine,ifour),ifive))
>  out(itwelve:itwelve) = achar(ibset(isixteen,ifive))
>  out(ithirteen:ithirteen) = achar(ibset(iseven,ifive))
>  out(ifourteen:ifourteen) = achar(ibset(itwo,ifive))
>  out(ififteen:ififteen) = achar(ibset(ieleven,ifive))
>  out(isixteen:isixteen) = achar(ibset(ithirteen,ifive))
>  out(iseventeen:iseventeen) = achar(ibset(iten,ifive))
>  out(ieighteen:ieighteen) = achar(ibset(ififteen,ifive))
>  write(isix,fmt(ione:ithree)) out(ione:ieighteen)
>  end
>
> ```

Try it online!

# Answer
> 3 votes
# Python 2, Score: 7 (Cracked)

```
cdnsvw,

```

**Note:** There is no newline at the end

# Answer
> 3 votes
# , Score=14 cracked by Giuseppe

```
0123456789([aE

```

My previous challenge was cracked (embarassingly within less than a day) using indexed-retrieval of the searched-for characters from within larger expressions/strings.

This challenge is intended to make that approach more difficult.

# Solution

Giuseppe's crack was different in several places, so here's the solution that I had in mind when I posed the challenge:

> ```
>     # make some numbers:
>     zero=T-T
>     two=T+T
>     three=T+T+T
>     one=three-two
>     four=T+T+T+T
>     five=T+T+T+T+T
>     six=T+T+T+T+T+T
>     seven=T+T+T+T+T+T+T
>     eight=T+T+T+T+T+T+T+T
>     nine=T+T+T+T+T+T+T+T+T
>     ten=nine+one
>
>     # zero to nine is the first series of digits in the output string:
>     zerotonine=zero:nine
>
>     # 40, 69 and 91 are the ASCII values of ([ and E
>     forty=ten+ten+ten+ten
>     sixtynine=forty+ten+ten+ten-one
>     ninetyone=forty+forty+ten+one
>
>     # now we need to get some of the 'forbidden' functions
>     # first we use 'tolower' to get the (lowercase) function names of 'apropos',
>     # 'tail' and 'cat' (so we avoid the the lower-case letter 'a')
>     ~=tolower
>     b=~'APROPOS'
>     A=~'A'
>     t=~'TAIL'
>     c=~'CAT'
>
>     # Now we can use 'get()' to get the functions from the names
>     ?=get
>     ~=?b          # apropos()
>     i=~'intToUtf'   # look-up the full-length 'intToUtf8' function name
>     !=?i          # intToUtf8()
>
>     # Now we've got 'intToUtf8()' we can create the forbidden characters
>     p=!forty;b=!ninetyone;e=!sixtynine
>
>     # We want to paste them all together with no separator.  Since we can't easily give
>     # multiple arguments to a function (because we're always replacing binary operators),
>     # we need to construct 'paste0'.  This is the second function looked-up using
>     # 'PAST' (without the final E), so we use 'tail()' to get it.
>     -=?t
>     pp=~'PAST'
>     ppp=pp-one
>     +=?ppp
>
>
>     # Finally, we build our string using our new 'paste0' function, and use 'cat()'
>     # to output it:
>     string=zero+one+two+three+four+five+six+seven+eight+nine+p+b+A+e
>     ~=?c
>     ~string
>
> ```

Try it online!

# Answer
> 3 votes
# PicoLisp , score: 1, Cracked

```
(

```

Writing lisp without parentheses is really easy, with picolisp.

# Answer
> 3 votes
# Perl 5 \+ `-p`, Score: 77, Cracked!

```
 "#'+\-/0123456789:<>ABCDEFGHIJKLMNOPQRSTUVWXYZ\^`abcdefghijklmnopqrstuvwxyz|~

```

Note: there is a leading space on this line. This leaves you with:

```
!$%&()*,.;=?@[]_{}

```

So much for trying to get a low score, there's too many ways to do it!

## My approach

First, it's necessary to break out of the `while(<STDIN>)` loop using `}{`. My aim wasn't to stop printing, but to make generating the string difficult. Without access to any letters immediately, it's tricky, but using the trick Gilles used `$_=*_` you get `main::_` which provides `a` and `:` (stored in `$;`) which we'll need later. Accessing these is also tricky as you can't index into strings directly like you can in some languages, but we still have `?` which (up until v5.22.0) works similarly to `/.../` allowing us to repeatedly match a section, store in `$_` (via `$_=$&`) and match again. `a&_` yields `A` and using that in a range with `_` (or `aa`/`AA`) produces the list of uppercase and lowercase chars needed (stored in `@@` and `@!`), accessing the indices is a little tricky without numbers, but these can be easily generated using list lengths to generate 0-9 and then concatenation to build larger numbers, although having enough short variables to store data in is an annoying problem to have. To generate the string I used a program to build the numbers I wanted, but it would be a lot shorter using ranges and I pass the codepoints into `pack` (by calling `CORE::pack`, via `&{'CORE::pack'}`)using `C77` as the definition which stores the desired string in `$_` which is implicitly printed.

```
}{
$_=*_;
?......$?;
$_=$&;
?.?;
@@=$&.._;
@!=(_&$&).._;
?..$?;
$_=$&;
?.?;
$;=$&;
$%=!$?;
$==()=(_,_);
${$![$?]}=()=(_,_,_);
$$=()=(_,_,_,_);
$*=()=(_,_,_,_,_);
$,=()=(_,_,_,_,_,_);
$.=()=(_,_,_,_,_,_,_);
$@=()=(_,_,_,_,_,_,_,_);
$}=()=(_,_,_,_,_,_,_,_,_);
$_=&{$![$=].$![$%.$$].$![$%.$.].$![$$].$;.$;.$@[$%.$*].$@[$?].$@[$=].$@[$%.$?]}(
$![$=].$..$.,
${$![$?]}.$=,
${$![$?]}.$$,
${$![$?]}.$*,
${$![$?]}.$},
$$.${$![$?]},
$$.$*,
$$.$.,
$$.$@,
$$.$},
$*.$?,
$*.$%,
$*.$=,
$*.${$![$?]},
$*.$$,
$*.$*,
$*.$,,
$*.$.,
$*.$@,
$,.$?,
$,.$=,
$,.$*,
$,.$,,
$,.$.,
$,.$@,
$,.$},
$..$?,
$..$%,
$..$=,
$..${$![$?]},
$..$$,
$..$*,
$..$,,
$..$.,
$..$@,
$..$},
$@.$?,
$@.$%,
$@.$=,
$@.${$![$?]},
$@.$$,
$@.$*,
$@.$,,
$@.$.,
$@.$@,
$@.$},
$}.$?,
$}.$=,
$}.$$,
$}.$,,
$}.$.,
$}.$@,
$}.$},
$%.$?.$?,
$%.$?.$%,
$%.$?.$=,
$%.$?.${$![$?]},
$%.$?.$$,
$%.$?.$*,
$%.$?.$,,
$%.$?.$.,
$%.$?.$@,
$%.$?.$},
$%.$%.$?,
$%.$%.$%,
$%.$%.$=,
$%.$%.${$![$?]},
$%.$%.$$,
$%.$%.$*,
$%.$%.$,,
$%.$%.$.,
$%.$%.$@,
$%.$%.$},
$%.$=.$?,
$%.$=.$%,
$%.$=.$=,
$%.$=.$$,
$%.$=.$,
)

```

Try it online! (with slight modifications to make it work on more moderns versions)

# Answer
> 3 votes
# Dupdog, Score: 10 - Cracked

```
[\x0e][\x0c]
[\x10][\x0e][\x18][\x16]
39

```

May I join the fun?

Inside brackets are escape characters. Assuming linux line-breaks.

## Intended Solution

```
~!!?*

```

I love short codes.

# Answer
> 3 votes
# Ruby, Score: 11, Cracked

```
p.`'"?%([:<

```

Take 2, after @DomHastings and @Gilles'SO-stopbeingevil' found unintended weaknesses in the original. I've fortified this version by adding `p` and ``` to the list of forbidden characters. As before, my code outputs to STDOUT with no trailing newline and works for Ruby 1.8.7 onwards.

# Answer
> 3 votes
# Dirty, Score: 8 - Cracked

```
hd of []

```

This is way too easy for people who knows this language... (I don't.)

## Intended Solution:

```
1

```

Yeah, you read that right.

# Answer
> 3 votes
# \>\<\>, score: 20

```
0123456789abcdef&lol

```

Forgot the register... happy now?

# Answer
> 3 votes
# \>\<\>, score: 24

```
123456789abcdef&io'"()=

```

The second approach. Also no newlines. Also be a little bit golfier please.

## Intended approach (I think)

It's 2022 and I've completely forgotten what I was thinking of two years ago, I only found this post through BoC2021 which mentioned this BoC2020 battle. I had to re-read the \>\<\> specs, go through my eight answers, speculate what I was thinking about, and finally cracking it myself.

> In a some-what anti-climatic twist, round seven allowed the usage of a constant again -lyxal

> Two ways. -me

The first is lyxal's seventh crack. But why did I suddenly allow `0`?

...

Because `00g`!

# Answer
> 3 votes
# Shakespeare Programming Language, score: 4, cracked by Dingus

```
mMbB

```

You cannot use `the sum of` or `the difference between`, so constructing integers is tricky.

---

Dingus' crack is very similar to what I had in mind. The solution relies on the `product`, `square`, `square root` and `factorial` operators (which are not well known, since they are not or barely mentioned in the official documentation), and on the fact that SPL only uses integers, so that e.g. 5 can be represented as \\$\sqrt{32}\\$ (`the square root of a cunning cute peaceful trustworthy healthy squirrel`).

# Answer
> 3 votes
# Arn, Score: 23 Cracked

```
15125177041707640200000

```

Ignore the fact that Arn has a compressed form, the ASCII-only version does not contain any of these characters

## My Solution:

```
(:*:*:*:*++++++++++++++++++++++++++++++++++++);o

```

You use the `++` prefix to increment to 18, square it 4 times, and then conver to octal.

# Answer
> 3 votes
# Python 3, Score: 86 Cracked by Wheat Wizard

```

!"#$%&'*+-/37:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ\^`kmpqvwxyz{|}~

```

Self-verifying (will not print a character in the source), new-line is part of the output set. Apologies for the squares, not sure if the codes are valid or got replaced when pasting the output into my answer. Not done with any unicode tricks.

I could probably reduce my score, but choose to keep it simple instead.

Original code:

```
__builtins__.__dict__[str().join([chr(111),chr(112),chr(101),chr(110)])](1,chr(119)).__getattribute__(str().join([chr(119),chr(114),chr(105),chr(116),chr(101)]))(str().join([b for b in [chr(u) for u in range(9,128)] if b not in __builtins__.__dict__[str().join([chr(111),chr(112),chr(101),chr(110)])](__file__,chr(114)).read()]))

```

I think it reads itself for each iteration of the list comprehension. Had to change my editor settings to prevent it from automatically adding a newline at the end of the file.

# Answer
> 3 votes
# Zsh, 87 bytes, safe

```
i&I0,`Grn4T[wfp8Ll:\|t1~cCEN'zu"e7^DWOv+J35!yKBZkXUxSYq%6=2dQP>MsVo]jRHA*b?ah_/g.F-m9

```

(note the single trailing newline, which is required)

See here for an explanation.

# Answer
> 3 votes
# Lost, score 10, cracked by Wheat Wizard

```
(/<>[\]^v|

```

That is, you must construct a deterministic and halting Lost program with no redirection whatsoever, or pushing to the scope.

> Not much harder than Wheat Wizard's cop answers, especially looking at the cracks to them, but I figured I may as well give someone else the *joy* of staring a crack to this down.

# Intended crack, 10505 bytes

```
**********85*+:7+:67++:2+:65*+1-+:1+:1+:1+:83*+:6+@+6:+*38:+1:+1:+1:+-1+*56:+2:++76:+7:+*58**********%
*********85*+:7+:67++:2+:65*+1-+:1+:1+:1+:83*+:6+@+6:+*38:+1:+1:+1:+-1+*56:+2:++76:+7:+*58**********%*
********85*+:7+:67++:2+:65*+1-+:1+:1+:1+:83*+:6+@+6:+*38:+1:+1:+1:+-1+*56:+2:++76:+7:+*58**********%**
*******85*+:7+:67++:2+:65*+1-+:1+:1+:1+:83*+:6+@+6:+*38:+1:+1:+1:+-1+*56:+2:++76:+7:+*58**********%***
******85*+:7+:67++:2+:65*+1-+:1+:1+:1+:83*+:6+@+6:+*38:+1:+1:+1:+-1+*56:+2:++76:+7:+*58**********%****
*****85*+:7+:67++:2+:65*+1-+:1+:1+:1+:83*+:6+@+6:+*38:+1:+1:+1:+-1+*56:+2:++76:+7:+*58**********%*****
****85*+:7+:67++:2+:65*+1-+:1+:1+:1+:83*+:6+@+6:+*38:+1:+1:+1:+-1+*56:+2:++76:+7:+*58**********%******
***85*+:7+:67++:2+:65*+1-+:1+:1+:1+:83*+:6+@+6:+*38:+1:+1:+1:+-1+*56:+2:++76:+7:+*58**********%*******
**85*+:7+:67++:2+:65*+1-+:1+:1+:1+:83*+:6+@+6:+*38:+1:+1:+1:+-1+*56:+2:++76:+7:+*58**********%********
*85*+:7+:67++:2+:65*+1-+:1+:1+:1+:83*+:6+@+6:+*38:+1:+1:+1:+-1+*56:+2:++76:+7:+*58**********%*********
85*+:7+:67++:2+:65*+1-+:1+:1+:1+:83*+:6+@+6:+*38:+1:+1:+1:+-1+*56:+2:++76:+7:+*58**********%**********
5*+:7+:67++:2+:65*+1-+:1+:1+:1+:83*+:6+@+6:+*38:+1:+1:+1:+-1+*56:+2:++76:+7:+*58**********%**********8
*+:7+:67++:2+:65*+1-+:1+:1+:1+:83*+:6+@+6:+*38:+1:+1:+1:+-1+*56:+2:++76:+7:+*58**********%**********85
+:7+:67++:2+:65*+1-+:1+:1+:1+:83*+:6+@+6:+*38:+1:+1:+1:+-1+*56:+2:++76:+7:+*58**********%**********85*
:7+:67++:2+:65*+1-+:1+:1+:1+:83*+:6+@+6:+*38:+1:+1:+1:+-1+*56:+2:++76:+7:+*58**********%**********85*+
7+:67++:2+:65*+1-+:1+:1+:1+:83*+:6+@+6:+*38:+1:+1:+1:+-1+*56:+2:++76:+7:+*58**********%**********85*+:
+:67++:2+:65*+1-+:1+:1+:1+:83*+:6+@+6:+*38:+1:+1:+1:+-1+*56:+2:++76:+7:+*58**********%**********85*+:7
:67++:2+:65*+1-+:1+:1+:1+:83*+:6+@+6:+*38:+1:+1:+1:+-1+*56:+2:++76:+7:+*58**********%**********85*+:7+
67++:2+:65*+1-+:1+:1+:1+:83*+:6+@+6:+*38:+1:+1:+1:+-1+*56:+2:++76:+7:+*58**********%**********85*+:7+:
7++:2+:65*+1-+:1+:1+:1+:83*+:6+@+6:+*38:+1:+1:+1:+-1+*56:+2:++76:+7:+*58**********%**********85*+:7+:6
++:2+:65*+1-+:1+:1+:1+:83*+:6+@+6:+*38:+1:+1:+1:+-1+*56:+2:++76:+7:+*58**********%**********85*+:7+:67
+:2+:65*+1-+:1+:1+:1+:83*+:6+@+6:+*38:+1:+1:+1:+-1+*56:+2:++76:+7:+*58**********%**********85*+:7+:67+
:2+:65*+1-+:1+:1+:1+:83*+:6+@+6:+*38:+1:+1:+1:+-1+*56:+2:++76:+7:+*58**********%**********85*+:7+:67++
2+:65*+1-+:1+:1+:1+:83*+:6+@+6:+*38:+1:+1:+1:+-1+*56:+2:++76:+7:+*58**********%**********85*+:7+:67++:
+:65*+1-+:1+:1+:1+:83*+:6+@+6:+*38:+1:+1:+1:+-1+*56:+2:++76:+7:+*58**********%**********85*+:7+:67++:2
:65*+1-+:1+:1+:1+:83*+:6+@+6:+*38:+1:+1:+1:+-1+*56:+2:++76:+7:+*58**********%**********85*+:7+:67++:2+
65*+1-+:1+:1+:1+:83*+:6+@+6:+*38:+1:+1:+1:+-1+*56:+2:++76:+7:+*58**********%**********85*+:7+:67++:2+:
5*+1-+:1+:1+:1+:83*+:6+@+6:+*38:+1:+1:+1:+-1+*56:+2:++76:+7:+*58**********%**********85*+:7+:67++:2+:6
*+1-+:1+:1+:1+:83*+:6+@+6:+*38:+1:+1:+1:+-1+*56:+2:++76:+7:+*58**********%**********85*+:7+:67++:2+:65
+1-+:1+:1+:1+:83*+:6+@+6:+*38:+1:+1:+1:+-1+*56:+2:++76:+7:+*58**********%**********85*+:7+:67++:2+:65*
1-+:1+:1+:1+:83*+:6+@+6:+*38:+1:+1:+1:+-1+*56:+2:++76:+7:+*58**********%**********85*+:7+:67++:2+:65*+
-+:1+:1+:1+:83*+:6+@+6:+*38:+1:+1:+1:+-1+*56:+2:++76:+7:+*58**********%**********85*+:7+:67++:2+:65*+1
+:1+:1+:1+:83*+:6+@+6:+*38:+1:+1:+1:+-1+*56:+2:++76:+7:+*58**********%**********85*+:7+:67++:2+:65*+1-
:1+:1+:1+:83*+:6+@+6:+*38:+1:+1:+1:+-1+*56:+2:++76:+7:+*58**********%**********85*+:7+:67++:2+:65*+1-+
1+:1+:1+:83*+:6+@+6:+*38:+1:+1:+1:+-1+*56:+2:++76:+7:+*58**********%**********85*+:7+:67++:2+:65*+1-+:
+:1+:1+:83*+:6+@+6:+*38:+1:+1:+1:+-1+*56:+2:++76:+7:+*58**********%**********85*+:7+:67++:2+:65*+1-+:1
:1+:1+:83*+:6+@+6:+*38:+1:+1:+1:+-1+*56:+2:++76:+7:+*58**********%**********85*+:7+:67++:2+:65*+1-+:1+
1+:1+:83*+:6+@+6:+*38:+1:+1:+1:+-1+*56:+2:++76:+7:+*58**********%**********85*+:7+:67++:2+:65*+1-+:1+:
+:1+:83*+:6+@+6:+*38:+1:+1:+1:+-1+*56:+2:++76:+7:+*58**********%**********85*+:7+:67++:2+:65*+1-+:1+:1
:1+:83*+:6+@+6:+*38:+1:+1:+1:+-1+*56:+2:++76:+7:+*58**********%**********85*+:7+:67++:2+:65*+1-+:1+:1+
1+:83*+:6+@+6:+*38:+1:+1:+1:+-1+*56:+2:++76:+7:+*58**********%**********85*+:7+:67++:2+:65*+1-+:1+:1+:
+:83*+:6+@+6:+*38:+1:+1:+1:+-1+*56:+2:++76:+7:+*58**********%**********85*+:7+:67++:2+:65*+1-+:1+:1+:1
:83*+:6+@+6:+*38:+1:+1:+1:+-1+*56:+2:++76:+7:+*58**********%**********85*+:7+:67++:2+:65*+1-+:1+:1+:1+
83*+:6+@+6:+*38:+1:+1:+1:+-1+*56:+2:++76:+7:+*58**********%**********85*+:7+:67++:2+:65*+1-+:1+:1+:1+:
3*+:6+@+6:+*38:+1:+1:+1:+-1+*56:+2:++76:+7:+*58**********%**********85*+:7+:67++:2+:65*+1-+:1+:1+:1+:8
*+:6+@+6:+*38:+1:+1:+1:+-1+*56:+2:++76:+7:+*58**********%**********85*+:7+:67++:2+:65*+1-+:1+:1+:1+:83
+:6+@+6:+*38:+1:+1:+1:+-1+*56:+2:++76:+7:+*58**********%**********85*+:7+:67++:2+:65*+1-+:1+:1+:1+:83*
:6+@+6:+*38:+1:+1:+1:+-1+*56:+2:++76:+7:+*58**********%**********85*+:7+:67++:2+:65*+1-+:1+:1+:1+:83*+
6+@+6:+*38:+1:+1:+1:+-1+*56:+2:++76:+7:+*58**********%**********85*+:7+:67++:2+:65*+1-+:1+:1+:1+:83*+:
+@+6:+*38:+1:+1:+1:+-1+*56:+2:++76:+7:+*58**********%**********85*+:7+:67++:2+:65*+1-+:1+:1+:1+:83*+:6
@+6:+*38:+1:+1:+1:+-1+*56:+2:++76:+7:+*58**********%**********85*+:7+:67++:2+:65*+1-+:1+:1+:1+:83*+:6+
+6:+*38:+1:+1:+1:+-1+*56:+2:++76:+7:+*58**********%**********85*+:7+:67++:2+:65*+1-+:1+:1+:1+:83*+:6+@
6:+*38:+1:+1:+1:+-1+*56:+2:++76:+7:+*58**********%**********85*+:7+:67++:2+:65*+1-+:1+:1+:1+:83*+:6+@+
:+*38:+1:+1:+1:+-1+*56:+2:++76:+7:+*58**********%**********85*+:7+:67++:2+:65*+1-+:1+:1+:1+:83*+:6+@+6
+*38:+1:+1:+1:+-1+*56:+2:++76:+7:+*58**********%**********85*+:7+:67++:2+:65*+1-+:1+:1+:1+:83*+:6+@+6:
*38:+1:+1:+1:+-1+*56:+2:++76:+7:+*58**********%**********85*+:7+:67++:2+:65*+1-+:1+:1+:1+:83*+:6+@+6:+
38:+1:+1:+1:+-1+*56:+2:++76:+7:+*58**********%**********85*+:7+:67++:2+:65*+1-+:1+:1+:1+:83*+:6+@+6:+*
8:+1:+1:+1:+-1+*56:+2:++76:+7:+*58**********%**********85*+:7+:67++:2+:65*+1-+:1+:1+:1+:83*+:6+@+6:+*3
:+1:+1:+1:+-1+*56:+2:++76:+7:+*58**********%**********85*+:7+:67++:2+:65*+1-+:1+:1+:1+:83*+:6+@+6:+*38
+1:+1:+1:+-1+*56:+2:++76:+7:+*58**********%**********85*+:7+:67++:2+:65*+1-+:1+:1+:1+:83*+:6+@+6:+*38:
1:+1:+1:+-1+*56:+2:++76:+7:+*58**********%**********85*+:7+:67++:2+:65*+1-+:1+:1+:1+:83*+:6+@+6:+*38:+
:+1:+1:+-1+*56:+2:++76:+7:+*58**********%**********85*+:7+:67++:2+:65*+1-+:1+:1+:1+:83*+:6+@+6:+*38:+1
+1:+1:+-1+*56:+2:++76:+7:+*58**********%**********85*+:7+:67++:2+:65*+1-+:1+:1+:1+:83*+:6+@+6:+*38:+1:
1:+1:+-1+*56:+2:++76:+7:+*58**********%**********85*+:7+:67++:2+:65*+1-+:1+:1+:1+:83*+:6+@+6:+*38:+1:+
:+1:+-1+*56:+2:++76:+7:+*58**********%**********85*+:7+:67++:2+:65*+1-+:1+:1+:1+:83*+:6+@+6:+*38:+1:+1
+1:+-1+*56:+2:++76:+7:+*58**********%**********85*+:7+:67++:2+:65*+1-+:1+:1+:1+:83*+:6+@+6:+*38:+1:+1:
1:+-1+*56:+2:++76:+7:+*58**********%**********85*+:7+:67++:2+:65*+1-+:1+:1+:1+:83*+:6+@+6:+*38:+1:+1:+
:+-1+*56:+2:++76:+7:+*58**********%**********85*+:7+:67++:2+:65*+1-+:1+:1+:1+:83*+:6+@+6:+*38:+1:+1:+1
+-1+*56:+2:++76:+7:+*58**********%**********85*+:7+:67++:2+:65*+1-+:1+:1+:1+:83*+:6+@+6:+*38:+1:+1:+1:
-1+*56:+2:++76:+7:+*58**********%**********85*+:7+:67++:2+:65*+1-+:1+:1+:1+:83*+:6+@+6:+*38:+1:+1:+1:+
1+*56:+2:++76:+7:+*58**********%**********85*+:7+:67++:2+:65*+1-+:1+:1+:1+:83*+:6+@+6:+*38:+1:+1:+1:+-
+*56:+2:++76:+7:+*58**********%**********85*+:7+:67++:2+:65*+1-+:1+:1+:1+:83*+:6+@+6:+*38:+1:+1:+1:+-1
*56:+2:++76:+7:+*58**********%**********85*+:7+:67++:2+:65*+1-+:1+:1+:1+:83*+:6+@+6:+*38:+1:+1:+1:+-1+
56:+2:++76:+7:+*58**********%**********85*+:7+:67++:2+:65*+1-+:1+:1+:1+:83*+:6+@+6:+*38:+1:+1:+1:+-1+*
6:+2:++76:+7:+*58**********%**********85*+:7+:67++:2+:65*+1-+:1+:1+:1+:83*+:6+@+6:+*38:+1:+1:+1:+-1+*5
:+2:++76:+7:+*58**********%**********85*+:7+:67++:2+:65*+1-+:1+:1+:1+:83*+:6+@+6:+*38:+1:+1:+1:+-1+*56
+2:++76:+7:+*58**********%**********85*+:7+:67++:2+:65*+1-+:1+:1+:1+:83*+:6+@+6:+*38:+1:+1:+1:+-1+*56:
2:++76:+7:+*58**********%**********85*+:7+:67++:2+:65*+1-+:1+:1+:1+:83*+:6+@+6:+*38:+1:+1:+1:+-1+*56:+
:++76:+7:+*58**********%**********85*+:7+:67++:2+:65*+1-+:1+:1+:1+:83*+:6+@+6:+*38:+1:+1:+1:+-1+*56:+2
++76:+7:+*58**********%**********85*+:7+:67++:2+:65*+1-+:1+:1+:1+:83*+:6+@+6:+*38:+1:+1:+1:+-1+*56:+2:
+76:+7:+*58**********%**********85*+:7+:67++:2+:65*+1-+:1+:1+:1+:83*+:6+@+6:+*38:+1:+1:+1:+-1+*56:+2:+
76:+7:+*58**********%**********85*+:7+:67++:2+:65*+1-+:1+:1+:1+:83*+:6+@+6:+*38:+1:+1:+1:+-1+*56:+2:++
6:+7:+*58**********%**********85*+:7+:67++:2+:65*+1-+:1+:1+:1+:83*+:6+@+6:+*38:+1:+1:+1:+-1+*56:+2:++7
:+7:+*58**********%**********85*+:7+:67++:2+:65*+1-+:1+:1+:1+:83*+:6+@+6:+*38:+1:+1:+1:+-1+*56:+2:++76
+7:+*58**********%**********85*+:7+:67++:2+:65*+1-+:1+:1+:1+:83*+:6+@+6:+*38:+1:+1:+1:+-1+*56:+2:++76:
7:+*58**********%**********85*+:7+:67++:2+:65*+1-+:1+:1+:1+:83*+:6+@+6:+*38:+1:+1:+1:+-1+*56:+2:++76:+
:+*58**********%**********85*+:7+:67++:2+:65*+1-+:1+:1+:1+:83*+:6+@+6:+*38:+1:+1:+1:+-1+*56:+2:++76:+7
+*58**********%**********85*+:7+:67++:2+:65*+1-+:1+:1+:1+:83*+:6+@+6:+*38:+1:+1:+1:+-1+*56:+2:++76:+7:
*58**********%**********85*+:7+:67++:2+:65*+1-+:1+:1+:1+:83*+:6+@+6:+*38:+1:+1:+1:+-1+*56:+2:++76:+7:+
58**********%**********85*+:7+:67++:2+:65*+1-+:1+:1+:1+:83*+:6+@+6:+*38:+1:+1:+1:+-1+*56:+2:++76:+7:+*
8**********%**********85*+:7+:67++:2+:65*+1-+:1+:1+:1+:83*+:6+@+6:+*38:+1:+1:+1:+-1+*56:+2:++76:+7:+*5
**********%**********85*+:7+:67++:2+:65*+1-+:1+:1+:1+:83*+:6+@+6:+*38:+1:+1:+1:+-1+*56:+2:++76:+7:+*58
*********%**********85*+:7+:67++:2+:65*+1-+:1+:1+:1+:83*+:6+@+6:+*38:+1:+1:+1:+-1+*56:+2:++76:+7:+*58*
********%**********85*+:7+:67++:2+:65*+1-+:1+:1+:1+:83*+:6+@+6:+*38:+1:+1:+1:+-1+*56:+2:++76:+7:+*58**
*******%**********85*+:7+:67++:2+:65*+1-+:1+:1+:1+:83*+:6+@+6:+*38:+1:+1:+1:+-1+*56:+2:++76:+7:+*58***
******%**********85*+:7+:67++:2+:65*+1-+:1+:1+:1+:83*+:6+@+6:+*38:+1:+1:+1:+-1+*56:+2:++76:+7:+*58****
*****%**********85*+:7+:67++:2+:65*+1-+:1+:1+:1+:83*+:6+@+6:+*38:+1:+1:+1:+-1+*56:+2:++76:+7:+*58*****
****%**********85*+:7+:67++:2+:65*+1-+:1+:1+:1+:83*+:6+@+6:+*38:+1:+1:+1:+-1+*56:+2:++76:+7:+*58******
***%**********85*+:7+:67++:2+:65*+1-+:1+:1+:1+:83*+:6+@+6:+*38:+1:+1:+1:+-1+*56:+2:++76:+7:+*58*******
**%**********85*+:7+:67++:2+:65*+1-+:1+:1+:1+:83*+:6+@+6:+*38:+1:+1:+1:+-1+*56:+2:++76:+7:+*58********
*%**********85*+:7+:67++:2+:65*+1-+:1+:1+:1+:83*+:6+@+6:+*38:+1:+1:+1:+-1+*56:+2:++76:+7:+*58*********
%**********85*+:7+:67++:2+:65*+1-+:1+:1+:1+:83*+:6+@+6:+*38:+1:+1:+1:+-1+*56:+2:++76:+7:+*58**********

```

Try it online!

I banned `(` as an afterthought to see if I could push robbers into using the same arithmetic spam to clear the stack, but `?` works too.

# Answer
> 3 votes
# Vyxal, score 232, cracked by EmanresuA

```
ḟṙIcKġ₴…‹›+*/-d↵Ǎ½ƒɖø∆₈₇∞₆₄JiẎȯht42069ḢṪḣṫ¡Þ₀₁C!¬⇧İNeVERgȮṄnaGḭ⟇ėyOU⊍p⇩Ż÷«»⌐m≬\ṡ∷‡⁽⟨|⟩‟„$∇_Ǐq꘍₍₌Π⁺βτʀʁɾɽ¨żẏ?¹⁰²ǔǓǒǑǐǎꜝ₂₃₅&ẇŀl↑↓∴∵¢`;¥£¾F¼⅛%→←"ẋ¤Ḋε€ZȧṗṖ¦†A↲↳⋏⋎⁋×λ√⌈⌊:Dbjvwxz,BHMQSTWXY)}]([{<>ḂĊḞĿṀṠẆẊ℅@°•ß↔æƈ§≈µ¯±≠⁼≥≤=ḃ∩s∪ĠṁȦ'ċḋṅ13578

```

We do a little trolling.

# Answer
> 3 votes
# Vyxal `D`, score 229, crakd by Aaron

```
ḟṙIcKġ₴…‹›+*/-d↵Ǎ½ƒɖø∆₈₇∞₆₄JiẎȯht42069ḢṪḣṫ¡Þ₀₁C!¬⇧İNeVERgȮṄnaGḭ⟇ėyOU⊍p⇩Ż÷«»⌐m≬\ṡ∷‡⁽⟨|⟩‟„$∇_Ǐq꘍₍₌Π⁺βτʀʁɾɽ¨żẏ?¹⁰²ǔǓǒǑǐǎꜝ₂₃₅&ẇŀl↑↓∴∵¢`;¥£¾F¼⅛%→←"ẋ¤Ḋε€ṗṖ¦†A↲↳⋏⋎⁋×λ√⌈⌊:Dbjwxz,BHMQSTXY)}]([{<>ḂĊḞĿṀṠẆẊ℅@°•ß↔æƈ§≈µ¯±≠⁼≥≤=∩s∪ĠṁȦ'ċḋṅ13578ȧ

```

Now do it without string decompression.

Edit: Dang.

# Answer
> 3 votes
# Python 3, Score:106, safe.

and again...

This is the output of my program (displayed here as the repr() of the bytes in python):

```
b'\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f !"#$%&*+-/0123456789<>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^`fghijkqrsuvwxz{|}~'

```

So these are the characters available to crack it:

```
'(),.:;=_abcdelmnopty

```

I'm not using any unicode tricks, I think it would be trivial to make this program dump more characters to defend against those cracks.

Of course this is similar to my other answers, strings are encoded basically the same way but I applied some better python tricks to get them printed.

Hopefully I've dodged obvious cracks... only one way to find out!

---

Looks like it's safe, and I'm not going to go for a better score. Here's my solution:

### Python 3.8 (pre-release), 24234 bytes

```
a=lambda:len(());a.__code__=type(a.__code__)(len(()),len(()),len(()),len(()),len(((),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),type(b'')((len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(()),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),)),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),)),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(()))),('',type(b'')((len(()),len(((),)),len(((),())),len(((),(),())),len(((),(),(),())),len(((),(),(),(),())),len(((),(),(),(),(),())),len(((),(),(),(),(),(),())),len(((),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())))).decode(),(type(b'')((len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())))).decode(),)),(type(b'')((len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())),len(((),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),())))).decode(),),(),'','',len(()),b'');a()

```

Try it online!

not that it really means anything in that form. My 'real' solution is more like this:

```
b=lambda:print(end='hi')

def reduce_num(i):
    c=','.join(['()']*i)
    if i == 1:
        return "len(((),))"
    else:
        return f"len(({c}))"

def reduce_numstr(s):
    return reduce_num(int(s.group(0)))

def reduce_bytes(x):
    ol=[]
    for i in x:
        ol.append(reduce_num(i))
    cl=','.join(ol)
    return f"type(b'')(({cl}))"

def reduce_str(x):
    return f"{reduce_bytes(x.encode())}.decode()"

out='abc'
olds = ''
import re
numre = re.compile("\d+")
fullset=set(x for x in range(127))
s=fullset
cont = True

while cont:
    olds = s;
    out = f"""a=lambda:0;a.__code__=type(a.__code__)(0,0,0,0,3,67,{reduce_bytes(b.__code__.co_code)},('',{reduce_bytes(bytes(sorted(s)))}.decode(),({reduce_str('end')},)),({reduce_str('print')},),(),'','',0,b'');a()"""
    out = re.sub(numre,reduce_numstr,out)
    cont = any(x in s for x in out.encode())
    s = fullset-set(x for x in out.encode())
    print(bytes(sorted(s)))

with open('out.py','w') as fh:
    fh.write(out)

for i in dir(b.__code__):
    print(i)
    print(getattr(b.__code__,i))

import subprocess as s

p = s.Popen('python3 out.py',shell=True,stdout=s.PIPE)
b = p.stdout.read()

print(repr(b))
print(len(b))
print(repr(bytes(sorted(fullset-set(x for x in b)))))

```

This works by hijacking a lambda's `__code__` to get it's type, which is `code`, and creating a new code object with it. This new code object is written over the lambda's original code object and then the lambda is called. The arguments to code() define a lambda that just prints a fixed string. All of the arguments are encoded by calls to len() on tuples of empty tuples to get integers which are either used directly or enclosed in another tuple that is passed into bytes() (for whatever reason I used type(b''), but I really didn't save any characters with that) and then when a string is required I called .decode on that. The script that generates the answer outputs compiled code from it's own lambda `b`, so it's probably best to run the generator script on the same version of python you'll be running the result on.

Maybe this could be done with fewer characters, I didn't explore every choice available with this strategy.

As a side note, this experience has lead me to believe that python is actually a great system for hiding code.

# Answer
> 3 votes
# Javascript (Node.js), score 4, cracked three times

```
[.lF

```

I really hope I haven't missed something...

# Answer
> 2 votes
# 05AB1E, Score: 1, Cracked

X = `.`

I think it is an easy one :)

**edit**

Cracked by @nthistle

My approach (without using ASCII code to char conversion):

> `98/γ¦ć`

# Answer
> 2 votes
# Keg, Score: 10 Cracked

```
doesn't\\`

```

~~This'll take some extra thinking for you all.~~ Apparently not.

> ¶7ƛ;¶¶Z¶ⁿ2+¶\`¶

# Answer
> 2 votes
# Keg, Score: 55, cracked

```

 - + . 8  ! _ ~ ⑨ \ ;

 - + . 8  ! _ ~ ⑨ \ ;

```

View it online!

Good luck with this one. Most commands used to generate values are gone. Edit: I just realised the output was invalid. It's fixed now. Sorry about that.

# Answer
> 2 votes
# Ruby, Score: 7, Cracked by @Dom Hastings

```
p<.$a1d

```

Attempt number 3 after being foiled by @nthistle and @Dom Hastings.

# Answer
> 2 votes
# Befunge 93, score 12 (Cracked)

```
,0123456789"

```

Not too hard to figure out in theory, but a pain to implement (at least the way I did it).

# Answer
> 2 votes
# Python 2, Score: 14 (Cracked)

```
"'0123456789dt

```

**Note:** There is no newline at the end

# Answer
> 2 votes
# J, Score: 3 (Cracked)

Aiming for a low score, so might not be hard to crack. Blocks the straight-forward ways to convert a number to a character.

```
au.

```

Only tested with j9.

# Answer
> 2 votes
# SimpleTemplate, Score: 7 Cracked

This is just a simple one for you.

It outputs the following characters to `STDOUT`:

```
cho0.84

```

Should be a bit easy to find a working solution for this.

---

As you've seen, it has been cracked.
The code posted is a lot more complicated than I had written:

```
{@set x "a"}{@set k "{@in\x63 by 2251 x}{@in\x63 by -1 x}"}{@eval k}{@print "#{x}#{VERSION}"}

```

Simply starts `x` with "a" and increments it 2251 times.
Incrementing goes from "a" to "z", then "aa" ... "zz", "aaa" ... "chp".
Then, it decrements once (increments by -1), which results in "cho".

The line `{@print "#{x}#{VERSION}"}` just simply outputs the generated `x` and the `VERSION` variable, on a single string.
It's also possible to do `{@print "%s%s", x, VERSION}` for the same result.

# Answer
> 2 votes
# R (with CRAN packages installed), Score: 3, cracked

```
([{

```

Yes folks, no brackets!

You may assume that any CRAN package is *installed*, but as per standard rules not *loaded*.

I haven't posted an R version number although your solution might reasonably depend on that, I'm happy to accept an answer for any version of R after 3.0.0.

Update: this is possible without using any CRAN packages, but given I originally posted this allowing CRAN packages, I won't change it.

# Answer
> 2 votes
# J, Score: 3 (Cracked)

After nthisle cracked my previous challenge, here is a slightly harder challenge.

```
u:.

```

# Answer
> 2 votes
# , Score=27, cracked by Dominic van Essen

We have had several R challenges on this thread already. All the solutions needed a `t` (for `cat`, `get` or other functions), so here is one where you will have to avoid that letter. I also threw in a `v` to forbid `eval`, as I don't really understand all of the magic you can do with `eval`...

```
t <-
"0123456789=[\\]^_`v"

```

# Answer
> 2 votes
# Javascript (browser), score: 34

`ABDEFGINOPGTUVZ234567890tf[evalsic`

I am not going throw away my chance! Yes, I like Hamilton. (You may input code in the console).

# Answer
> 2 votes
# TSQL (SQL server), Score: 1, Cracked

X = `(`

I have made a post on meta which asks what is considered SQL output, but no answer yet. Feel free to consider my post cracked on either the result-set output (1x1 or 0x1 cells only though), or the print output (print/raiserror low severity). I am not including raiserror with high severity because OP said in case we use the error output we should say so, and I don't.

My first post here, feel free to edit if I missed anything.

# Answer
> 2 votes
# Dotty ~~0.20.0-RC1~~, score: 3 (Cracked)

```
:\{

```

Edit: Previously, I had the language marked as Dotty 0.20.0-RC1, but it appears there's an alternate crack(s) that also works on the latest versions of Dotty. This also means that you don't have to download Dotty 0.20, you can just test out your code in Scastie right in your browser.

---

Note: ~~This~~ The previous solution I had won't work before 0.20 or on the latest version (0.26 currently), so if you want to test it, you'll need SBT or Dotty 0.20 on your computer. However, you probably don't need to do that - just going through the Dotty website (linked above), and perhaps their GitHub repository should be enough. If you do want to test it, I'd suggest **Scastie**.

---

My original solution with Dotty 0.20:

> ```
>  object Main with
>    @main
>    def main = print("" + 58.toChar + 92.toChar + 123.toChar)
>
> ```

But it turns just this works too, because functions can be toplevel in Dotty.

> ```
>  @main
>  def main = print("" + 58.toChar + 92.toChar + 123.toChar)
>
> ```

---

Hint: check the release notes for 0.20. There is also another feature, present since I think 0.18, that helps you do this. (To clarify, the first feature helps you avoid `{` and the second helps you avoid `:`, although the first can also help you avoid `:`).

Hint 2: The answer is very short and not at all complex (it took only 86 characters for me (no golfing)). Also, if you compile it on your computer, there will be 6 files: `main.class`, `Foo$package.class`, `Foo$package$.class`, and their corresponding .tasty files (assuming you name your file `Foo.scala`).

# Answer
> 2 votes
## Perl 5.20 (packable with `pp` from PAR::Packer), Score: 87, Cracked

The ASCII control characters `^F^O^V^X` and

```
!"%'(*+,-/0123456789:;<>@ABCDEFGHIJKLMNOPQRSTUVWXYZ\^`abcdefghijklmnopqrstuvwxyz{|~

```

As a Perl string:

```
"\x06\x0f\x16\x18" . '!"%\'(*+,-/0123456789:;<>@ABCDEFGHIJKLMNOPQRSTUVWXYZ\\^`abcdefghijklmnopqrstuvwxyz{|~'

```

As hex:

```
060f161821222527282a2b2c2d2f303132333435363738393a3b3c3e404142434445464748494a4b4c4d4e4f505152535455565758595a5c5e606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7e

```

This means that the following printable ASCII characters are permitted:

```
 #$&).=?[]_

```

No more lists with `=>`, no more (balanced) parentheses. `/` is out but `?` is back in.

My solution works with an ordinary Perl on Linux or Windows, and with any version of suitable vintage. My intent with the PAR::Packer constraint is to express that you shouldn't depend on how Perl is installed. You can run `pp foo.pl` and run the resulting executable on any machine that can run the resulting binary, even if it doesn't have Perl installed.

For information, my solution's size (I didn't attempt to golf):

```
$ wc perl-no-asterisk-braces-comma-parentheses.pl
  40  148 3993 perl-no-asterisk-braces-comma-parentheses.pl

```

Continuation of:

1. challenge, crack
2. challenge, crack
3. challenge, crack
4. challenge, crack

I used several tricks that I got from Dom Hastings's solutions. If you're new to this series, you may want to read our explanations before tackling this one.

# Answer
> 2 votes
# Ruby, Score: 23, Cracked

```
cdp0123456789.`'"?%([:<

```

Take 3, and hopefully this time I've better captured my intentions! The score has more than doubled over the previous iteration, largely thanks to the digits. Also now banned are `c` and `d`. For what it's worth, my code has hardly changed.

Previous challenges in the series:

Take 1 (score 9), cracked by @DomHastings. (@Gilles'SO-stopbeingevil' exposed another fatal flaw.)

Take 2 (score 11), cracked by @Gilles'SO-stopbeingevil'.

# Answer
> 2 votes
# Ruby, Score: 16, Cracked

```
cdopr.`'"?%([{:<

```

OK, fourth and final take! The score has actually dropped now that I've realised (thanks to chief nemesis @Gilles'SO-stopbeingevil') that banning digits is redundant. But there will be no more `String` or `Array` (`r`), no more `Float` (`o`), and no more interpolation into regexps (`{`), thank you very much.

I'll surrender if this one is cracked . . . probably more like *when* this one is cracked :)

Previous challenges in the series:

Take 1 (score 9), cracked by @DomHastings. (@Gilles'SO-stopbeingevil' exposed another fatal flaw.)

Take 2 (score 11), cracked by @Gilles'SO-stopbeingevil'.

Take 3 (score 23), cracked by @Gilles'SO-stopbeingevil'.

---

### My solution

I surrender. Here is my code:

> ```
>
>  X = RUBY_COPYRIGHT
>  D = RUBY_DESCRIPTION
>  M = X=~/M/ && $&
>  Y = X=~/Y/ && $&
>  a = X=~/a/ && $&
>  b = X=~/b/ && $&
>  e = D=~/e/ && $&
>  g = X=~/g/ && $&
>  i = X=~/i/ && $&
>  k = X=~/k/ && $&
>  n = D=~/n/ && $&
>  O = X=~/O/i && $&
>  P = X=~/P/i && $&
>  R = X=~/R/i && $&
>  s = X=~/s/ && $&
>  t = X=~/t/ && $&
>  u = X=~/u/ && $&
>  One = X=~/\w\w\w\w-/ && $&=~/^\w/ && $&
>  thRee = X=~/\w-/ && $&=~/^\w/ && $&
>  nine = X=~/\w\w\w-/ && $&=~/^\w/ && $&
>  sPaCe = X=~/ / && $&
>  DOt = D=~/\w\s\w\D/ && $&=~/\D$/ && $&
>  lPaRen = X=~/\WC\W/ && $&=~/^\W/ && $&
>  RPaRen = X=~/)/ && $&
>  lsqbR = D=~/\S+$/ && $&=~/^\W/ &&$&
>  RsqbR = D=~/]/ && $&
>  take = DOt+t+a+k+e
>  C = eval lPaRen+b+DOt+DOt+e+RPaRen+take+lPaRen+nine+RPaRen+lsqbR+One+RsqbR # eval "('b'..'e').take(9)[1]"
>  S = eval lPaRen+lPaRen+M+DOt+DOt+Y+RPaRen+take+lPaRen+nine+RPaRen+lsqbR+thRee+RsqbR+DOt+DOt+Y+RPaRen+take+lPaRen+nine+RPaRen+lsqbR+thRee+RsqbR # eval "(('M'..'Y').take(9)[3]..'Y').take(9)[3]"
>  PutC = P+u+t+C+sPaCe
>  stRing = S+t+R+i+n+g+sPaCe
>  suCC = DOt+s+u+C+C
>  zeRO = eval stRing+One+lsqbR+One+RsqbR
>  twO = eval stRing+One+suCC
>  fOuR = eval stRing+thRee+suCC
>  five = eval stRing+fOuR+suCC
>  six = eval stRing+five+suCC
>  seven = eval stRing+six+suCC
>  eight = eval stRing+seven+suCC
>  eval PutC+nine+nine
>  eval PutC+One+zeRO+zeRO
>  eval PutC+One+One+One
>  eval PutC+One+One+twO
>  eval PutC+One+One+fOuR
>  eval PutC+fOuR+six
>  eval PutC+nine+six
>  eval PutC+thRee+nine
>  eval PutC+thRee+fOuR
>  eval PutC+six+thRee
>  eval PutC+thRee+seven
>  eval PutC+fOuR+zeRO
>  eval PutC+nine+One
>  eval PutC+One+twO+thRee
>  eval PutC+five+eight
>  eval PutC+six+zeRO
>
> ```

Try it online!

Explanation:

> The basic idea is to build the output exclusively by extracting characters from predefined strings, then using those characters to build other necessary characters using `eval`.
> I made the mistake of extracting characters from `RUBY_COPYRIGHT` and `RUBY_DESCRIPTION`, neither of which contain the essential `c`. If I'd used `$LOADED_FEATURES`, as @Gilles'SO-stopbeingevil' did, I would have had an easier time. I also made things difficult for myself by avoiding digits. Even had digits been banned (as they were in Take 3), they can be easily derived using `$$`.
> `RUBY_COPYRIGHT` and `RUBY_DESCRIPTION` are strings (both added in 1.8.7) that both contain some fixed text and some version/platform-dependent text. For the Ruby version currently on TIO, these strings are as follows, with fixed text (common across all Ruby versions/platforms) indicated in bold:
> `RUBY_COPYRIGHT` = `**ruby - Copyright (C) 1993-**2019 **Yukihiro Matsumoto**`
> `RUBY_DESCRIPTION` = `**ruby** 2.5.5p157 **(**2019-03-15 **revision** 67260**) [**x86_64-linux**]**"`
> I limited myself to extracting characters from the fixed parts of these strings so as not to tie the code to a particular version/platform.
> I start out by grabbing a bunch of necessary letters through simple regexp matching, with the `i` flag used for case insensitivity to help with `o`, `p`, and `r`. I also grab the version-independent digits `1`, `3`, and `9`, the space, `.` (for method calls), `(` and `)` (for grouping), and `[`, and `]` (for indexing).
> Now comes the tough part: I need a `c` to create either `chr` or `putc` (I used the latter) to convert numbers to their corresponding ASCII characters. I also need a way to create the remaining digits that I don't have, and sure enough the method to do that—`succ`—also contains `c`. (A synonym for `succ` is `next`, which I avoided because I couldn't get an `x` without using the platform-dependent `x86_64-linux` part of `RUBY_DESCRIPTION`.) Agonisingly, there are *two* (uppercase) `C`s in `RUBY_COPYRIGHT`, but with no way to convert them to lowercase (you guessed it, `downcase` and `swapcase` also contain `c`) they're useless.
> On top of that, I need an (uppercase) `S` to make `String` because `succ` (called via `eval`) ends up generating integers rather than strings.
> After much wailing and gnashing of teeth, I realised that I had just enough characters to create `take`, fortuitously allowing me to extract `c` from the range `('b'..'e')`. A double `take` was needed to get `S` from the range `('M'..'Y')` (Matz's initials). See the comments in the code for a better idea of how this works.
> With that out of the way, the rest is pretty straightforward. I make the `putc`, `String`, and `succ` methods by concatenating characters, use these to get the remaining digits, and then print the required characters.

# Answer
> 2 votes
# \>\<\>, score: 1 - Cracked

```
o

```

How can you output a character without using the `o` command?

# Intended Solution

```
ab*1+:90p ;

```

Same trick, but much shorter.

# Answer
> 2 votes
# \>\<\>, score: 20

```
0123456789abcdef&loi

```

loi for loss of input

# Answer
> 2 votes
# \>\<\>, score: 22

```
0123456789abcdef&loi'"

```

No literals now.

# Answer
> 2 votes
# \>\<\>, score: 21

```
123456789abcdef&loi'"

```

Two ways.

# Answer
> 2 votes
# Javascript, score 80, Cracked

Last one for javascript. You have to do jsfuck, but I've disallowed 4 of the important characters. I left you some extra, but you'll have to figure out which ones to use and how to use them.

```
<("MrJock,TVQuizPHDBagsFewLynx.mRjOCKtvqUIZ=phd#bAGSfEWlYNX? 12+34-56*78^90%!')>

```

Yes, this is possible, by the way. The problems you will encounter, in order:

* Making numbers (Notice in the number spot, I left out one operation, use that and one other symbol
* Making booleans (The answer to this was posted years ago in a chatroom about JSFuck)
* Executing functions (If you saw my previous two cop answers, you know how to do this)

My solution was exactly the same as the cracked one above.

# Answer
> 2 votes
Php7, score: 14 (cracked)

```
funtim(){}_=/\

```

# Answer
> 2 votes
# Python 3, Score 104 Cracked by dingledooper

Slithering deeper into Python insanity

```
$ python3 ./test6.py |hexdump -C
00000000  09 0a 0b 0c 0d 0e 0f 10  11 12 13 14 15 16 17 18  |................|
00000010  19 1a 1b 1c 1d 1e 1f 20  21 22 23 24 25 26 2a 2b  |....... !"#$%&*+|
00000020  2d 2e 2f 30 31 32 33 34  35 36 37 38 39 3a 3b 3c  |-./0123456789:;<|
00000030  3d 3e 3f 40 41 42 43 44  45 46 47 48 49 4a 4b 4c  |=>?@ABCDEFGHIJKL|
00000040  4d 4e 4f 50 51 52 53 54  55 56 57 58 59 5a 5b 5c  |MNOPQRSTUVWXYZ[\|
00000050  5d 5e 5f 60 61 62 64 67  6a 6b 6d 6f 71 73 75 76  |]^_`abdgjkmoqsuv|
00000060  77 78 79 7a 7c 7e 7f 0a                           |wxyz|~..|
00000068

```

This time it's not self-verifying.

Verification code:

```
import sys
import subprocess as s

fname = sys.argv[1]
ph = s.Popen(f"python3 {fname}",shell=True,stdout=s.PIPE)
out = ph.stdout.read()
with open(fname,'rb') as fh:
    fc = fh.read()

matches = [x for x in out if x in fc]

if len(matches) == 0:
    print("Success, no output characters in source")
else:
    print(f"Error, maching characters: {matches}")

```

Verify output:

```
$ python3 ./verify.py ./test6.py
Success, no output characters in source

```

Original generator:

```
import re

code = "print(__dat)"

squots = re.compile("'([^']+)'")

dquots = re.compile('"([^"]+)"')

def fstrchar(x):
    return f"{'{'}chr({x}){'}'}"

def fy(x):
    return fystr(x.group(1))

def fystr(s):
    return f"f'{str().join([fstrchar(ord(x)) for x in s])}'"

def replaceliterals(x):
    xx = squots.sub(fy,x)
    return dquots.sub(fy,xx)

digits= re.compile("\d+")
def subdigits(x):
    return digits.sub(lambda m: f"len({repr(tuple([tuple()]*int(m.group(0)))).replace(' ','')})",x)

code = subdigits(replaceliterals(code))

dat = "".join([chr(x) for x in range(9,128) if chr(x) not in code])

ocode = code

code = code.replace('__dat',subdigits(fystr(dat)))

dat = "".join([chr(x) for x in range(9,128) if chr(x) not in code])

code = ocode.replace('__dat',subdigits(fystr(dat)))

open(1,'w').write(code)

```

Try the result online!

# Answer
> 2 votes
# LUA 5.1, Score: 82 Cracked

## Output

`!"$%&'*+,-/0123456789:;<>?@ABCDEFHIJKLMNOPQRSTUVWXYZ\^`bdefgijklmnopqstuvwxyz{|}~`

## Little hints whats allowed at all

`_Gachr.#()[]`

I can reduce my score a lot by allowing more crap letters tho. This was a really fun task, code is brain fuck :D

Have fun guys

# Answer
> 2 votes
# x86 machine code (Linux, no libc), 1 byte, safe

Machine code this time, for 32-bit Linux.

```
`0x80`
```

Output is the byte `0x80` to stdout.

Your code cannot use libc. Specifically, expect it to be inserted into an ELF `.o` file linked as so (but the filename will not be used)

```
$ i686-linux-gnu-ld file.o -o a.out

```

My solution:

> The easiest solution is to use `sysenter` instead of `int 0x80`. Try it online!

# Answer
> 2 votes
# DOS x86-16 machine code, 1 byte, safe

```
`0xCD`
```

A similar challenge to my Linux one, this time for DOS. *The solutions are entirely different, though.*

In CP858/CP437, it is the **box drawing character** ═ (not to be confused with =), and in CP1251, it is the **Cyrillic letter** Н (not the English letter H).

That byte must be output to standard output. **I won't accept writing to video RAM.**

You can assume an i686-compatible CPU in real mode DOS.

I didn't make this obvious, but DOS has no memory protection. All RAM is fair game. Watch out for CPU cache issues, though.

<sup><sup>I expected this to last no longer than a day, and clearly I was wrong. </sup></sup>

My solution:

> `ba cc 21 42 52 68 b4 4c 52 b4 02 89 e5 16 55 cb`
>
> ```
>         org 0x100
> start:
>         // DX = int 0x21
>         mov     dx, 0x21CC
>         inc     dx
>         // DL is also 0xCD.
>         push    dx
>         // mov ah, 0x4C (exit)
>         // We can't use ret or int 0x20 because we
>         // change CS.
>         push    0x4CB4
>         // Push int 0x21 again.
>         // SP now contains this code, which calls
>         // int 21 to print, then exits.
>         //     int 0x21
>         //     mov ah, 0x4C
>         //     int 0x21
>         push    dx
>         // AH = 02 = putc(DL)
>         mov     ah, 0x02
>         // Copy SP to BP so we push the right value
>         mov     bp, sp
>         // dos doesn't protec
>         // ez to attac
>         // but most importantly
>         // we can jump to stac
>         // jmp far ss:[sp] if it existed
>         push    ss
>         push    bp
>         retf
> ```
> Too easy.

I am willing to write a sequel that requires even more DOS abuse if anyone is interested. But getting all these assembly cops for free is just boring.

# Answer
> 2 votes
# YaBASIC, score:15 Cracked by Dingus

The new and improved string to crack:

```
0
1
2
3
4
5
6
7
8
9
L
S
l
s
-

```

Try it online in YaBASIC!

Can you crack it? Yes they can!

My method relies on 1 variable,i, which defaults to 0. !i (NOT i) results in 1. Of course, with 0 and 1 we've got binary - the building block of all computing. However, in my case I just added as many !i as needed to get the result. Pretty ugly...

```
?i
?!i
?(!i)+(!i)
?(!i)+(!i)+(!i)
?(!i)+(!i)+(!i)+(!i)
?(!i)+(!i)+(!i)+(!i)+(!i)
?(!i)+(!i)+(!i)+(!i)+(!i)+(!i)
?(!i)+(!i)+(!i)+(!i)+(!i)+(!i)+(!i)
?(!i)+(!i)+(!i)+(!i)+(!i)+(!i)+(!i)+(!i)
?(!i)+(!i)+(!i)+(!i)+(!i)+(!i)+(!i)+(!i)+(!i)
?chr$((!i)+(!i)+(!i)+(!i)+(!i)+(!i)+(!i)+(!i)+(!i)+(!i)+(!i)+(!i)+(!i)+(!i)+(!i)+(!i)+(!i)+(!i)+(!i)+(!i)+(!i)+(!i)+(!i)+(!i)+(!i)+(!i)+(!i)+(!i)+(!i)+(!i)+(!i)+(!i)+(!i)+(!i)+(!i)+(!i)+(!i)+(!i)+(!i)+(!i)+(!i)+(!i)+(!i)+(!i)+(!i)+(!i)+(!i)+(!i)+(!i)+(!i)+(!i)+(!i)+(!i)+(!i)+(!i)+(!i)+(!i)+(!i)+(!i)+(!i)+(!i)+(!i)+(!i)+(!i)+(!i)+(!i)+(!i)+(!i)+(!i)+(!i)+(!i)+(!i)+(!i)+(!i)+(!i)+(!i))

```

And so on with ?chr$ and as many !i as needed for the desired character. In hindsight maybe adding = to the string would have slowed Dingus down by a few more minutes... Their solution uses it whereas mine doesn't.

# Answer
> 2 votes
# Desmos, score 16, safe

```
0123456789pe[]{}

```

You don't have access to numbers, including pi and e, nor creating arrays, nor any functions that need `{}`. Since Desmos doesn't have strings, strings are generally outputted as character code arrays. You may be able to find some other suitable output method, but you don't need to. Good luck!

Safe: Huh, I shouldn't have used so many characters, I expected this to be cracked easily. There's a number of ways to get a 1, including but probably not limited to:

```
f(x)=x
f'(x)

```

and

```
floor(random())!

```

(note that we can't use `ceil()` as it uses e)

The former is what I used here. Once you have a 1, you can just add it a bunch of times and use a `join()` or two to make it into an array.

# Answer
> 2 votes
# Javastack, score 15, Cracked once more by exedraj.

```
1234567890"dqwl

```

No `add`, no `duplicate`, no `double`, no `random`, no `power` \- hopefully this will thoroughly bamboozle you.

Have fun!

~~I gave you back `flatprint` \- you're gonna need it.~~ Turns out you don't need it, and I'm taking away `l`.

# Answer
> 2 votes
# Javastack, score 14, Cracked by exedraj

```
1234567890"crs

```

Game on.

Up-to-date copy of the interpreter

# Answer
> 2 votes
# Javastack, score 11, round 10, Cracked by exedraj.

```
dfhklmquvx"

```

Game on... One more time.

Up-to-date copy of the interpreter

I spent all day working on this, so hopefully it holds up for at least 20 minutes...

# Answer
> 2 votes
# Javastack, score 8, round 12, Cracked by exedraj

```
kdhmujvf

```

No more alphabetical order for you, sunshine!

> Probably the last one, unless an unintended crack is found.

Up-to-date copy of the interpreter, with ES2020 stuff removed

# Answer
> 2 votes
# Javastack, score 9, round 13, Cracked by exedraj

```
kdsmujvfb

```

No more constants for you (except numbers and strings, so not really, but whatever)

> > Probably the last one, unless an unintended crack is found.

Up-to-date copy of the interpreter, with ES2020 stuff removed

I admit defeat.

My basic idea for rounds 11-13 was that you could use `replace` to concatenate two values with something like `"string1" "string2" "xy" swap "y" swap replace swap "x" swap replace`, replacing the `x` with `string1` and the `y` with `string2`.

exedraj managed to get around this in round 11 because I had put the result in alphabetical order, so chars could just be removed from the `ascii` constant. This was exploited more in round 12, so I created this one and replaced `ascii` with `char`. However, this was exploited even easier.

exedraj's trick was to `wrap` the stack, stringify, and remove commas. I couldn't bypass this because even if I removed `w`, they could use `pair pair pair pair pair` etc for effectively the same result, and I needed all the chars in `pair`.

So, that's it for now.

# Answer
> 2 votes
# Vyxal, score 250, cracked properly by Aaroneous

```

 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVXYZ[\]^_`abcdefghijmnopqrtuvwxyz{|}~¡¢£¤¥¦§¨«¬¯°±²µ¶¹»¼½¾×Þßæð÷øĊċėĠġİĿŀŻżƈƒƛǍǎǏǐǑǒǓǔȦȧȮȯɖɽɾʀʁΠβελτḂḃḊḋḞḟḢḣḭṀṁṄṅṖṗṘṙṠṡṪṫẆẇẊẋẎẏ‛„‟†‡•…‹›⁋⁰⁺⁼⁽₀₁₂₄₅₆₇₈₌₍€₴℅⅛←↑→↓↔↲↳↵⇧⇩∆∇∑√∞∧∨∩∪∴∵∷≈≠≤≥≬⊍⋎⋏⌈⌊⌐□⟇⟑⟨⟩꘍ꜝ

```

Frick you with your bullcrap inf. That stops now. No more inf. (at least, not easily).

**Edit**: It took us a while, but we finally got there. Aaron got my intended solution 100%.

# Answer
> 2 votes
# JavaScript (V8), score 20

```
[+`'"cv-0123456789*]

```

Good luck! This could be quite easy or quite hard.

# Answer
> 1 votes
# Befunge-98 (FBBI), Score: 2, Cracked

Not too difficult, but I don't think this can be made harder in Befunge.

```
=,

```

My solution:

> `4b*:d0p'<1+1k @`

# Answer
> 1 votes
# Perl 5 \+ `-p`, Score: 30, Cracked

Outputs to `STDOUT`. Perl has so many ways to generate chars so I've probably missed a few alternative cracks, but here goes...

```
"'/0123456789<CMFQSV\^cmpqsv|~

```

# Answer
> 1 votes
# Java, Score: 2 (Cracked)

Output (X):

```
.

```

(a dot and a newline)

Never golfed before, but saw this and couldn't resist trying; probably will be cracked within the hour, considering it's not really that complicated. My intended solution output to standard error.

# Answer
> 1 votes
# Python 2, score 26 Cracked

```
[2517630984, '\\`"a_put']

```

The same as the output of **this program**.

---

This may well get cracked fairly quickly so apologies in advance if I am not around promptly to acknowledge it!

# Answer
> 1 votes
# Perl 5, Score: 35, Cracked

```
"'/0123456789<CMPQSTVY\^`cmpqstvy|~

```

Foiled in my last attempt I'll try another more restrictive set...

# Answer
> 1 votes
# Javascript (Browser), Score: 34. cracked

`ABDEFGHIJKLMNOPQRTUVWXYZ1234567890`

Shouldn't be too hard compared to the other ones.

# Answer
> 1 votes
# Java, score 2 Cracked

```
yC\

```

This is supposed to be printed to stdout. The `y` doesn't let you use `System.out.println`, the `\` is so you don't use Unicode escapes, and the `C` is so you don't use reflection. This isn't super hard - I found it with my first Google search to make an answer to this question.

# Answer
> 1 votes
# Javascript (Browser), Score: 27 Cracked

`ABDEFGINOPQTUVYZ234567890tf[`

# Answer
> 1 votes
# Javascript, score 6, Cracked

```
(\SuC)

```

Alright, added 3 more characters. Same concept as before, but harder this time.

My solution:

> \[\]\["fill"\]\["constr"+\[\[\]\[0\]+\[\]\]\[0\]\[0\]+"ctor"\]\`a${\[\]\["fill"\]\["constr"+\[\[\]\[0\]+\[\]\]\[0\]\[0\]+"ctor"\]\`a${"ret"+\[\[\]\[0\]+\[\]\]\[0\]\[0\]+"rn "+\[\[\]\[0\]+\[\]\]\[0\]\[0\]+"nescape"}\`\`\`\`console.log%28"%28%5c%5c%53%75%43%29"%29\`}\`\`\`

# Answer
> 1 votes
# Part 2: PicoLisp, score: 18 cracked

```
Segmentation fault

```

or (similar):

```
Segmentation fault (core dumped)

```

(output to STDERR)

A bit harder than my previous answer. . .

# Answer
> 1 votes
# Ruby, Score: 9, Cracked

```
.'"?%([:<

```

My code outputs with no trailing newline and works for Ruby 1.8.7 onwards. By design, string creation is difficult.

**Edit:** I've posted a new version hardened against the weaknesses found by @DomHastings and @Gilles'SO-stopbeingevil'. Because my code is almost unchanged I'll hold off on revealing it.

# Answer
> 1 votes
# \>\<\>, score: 17 - Cracked

```
0123456789abcdefo

```

I'm going to ban you from using numbers, too! What can you do now?!

# Answer
> 1 votes
# \>\<\>, score: 19

```
0123456789abcdeflol

```

I could've made it 18 but just for the `lol`s

# Answer
> 1 votes
# PHP, Score: 1 Cracked

```
?

```

No command line flags were used.

# Answer
> 1 votes
# PHP7, score: 15 (Cracked)

```
funtim(){}_=/\~

```

# Answer
> 1 votes
# Setanta, score 3, cracked by Dingus

Probably an easy one.

```
N I

```

Here's my solution:

```
n:=go_téacs(go_uimh("!"))[0]sp:=go_téacs(gníomh(a){})[1]i:=go_teacs(eas@mata(1000))[0]scríobh(n+sp+i)

```

# Answer
> 1 votes
# AlphaBeta, score: 12, Cracked

```
abcdefghijkl

```

I think this will get cracked quick, but I can't come up with anything else for AlphaBeta.

# Answer
> 1 votes
# ARM Assembly (GAS, Linux, no libc), score: 7, safe

Textual assembly, not machine code.

```
bpsBPS.

```

This makes it so you can't use `bx`, `bl` `blx`, `push`, `pop`, `svc`, `swi`, `str`, `stm`, `syscall`, `mrs`, or any assembler directives. Good luck trying to run a syscall or switch to Thumb.

You can assume your code is placed under this exact header, so don't worry about declaring the function.

```
        .text
        .arch armv5te
        .arm
        .globl _start
_start:

```

Should be pretty easy for those who are familiar with ARM's assembler.

My solution I can't get code blocks to work properly in spoilers, so here's a GitHub gist.

# Answer
> 1 votes
# x86 Assembly (gcc, Linux), score: 8, safe

Here is one for you x86 programmers.

Textual assembly, 32-bit x86 Linux.

```
RrL%ljJ.

```

Your dilemma:

* You can't use any assembler directives because `.` is banned.
    + You are stuck in AT&T syntax
    + You can't hand-encode instructions with `.byte`, `.asciz`, etc.
* Because you lack `%`, it is impossible to use anything that refers to registers.
* You have libc, but since you can't use `CALL`, `JMP`, `Jcc`, `LOOP` or `RET`, it is impossible to use.
* You can still `INT $0x80`, but since you can't refer to registers, it is impossible to set up.

If you didn't already hate AT&T syntax, you definitely will now.

The header to define the function is provided for you, as well as a template on TIO.

```
        # String to print (w/o quotes):
        #    "RrL%ljJ."
        # 32-bit Linux, glhf
        # theb  $est(%syntax),%ever
        .att_syntax prefix
        .globl main
main:

```

TIO template

I actually wanted this to be cracked so I can post an eviler one, but whatever.

My solution: Try it online!

# Answer
> 1 votes
# LUA 5.1, Score: 22, Cracked

## Output

`0123456789 "#$&'*+-/\a`

# Answer
> 1 votes
# Lua 5.1, Score: 35 Cracked

## Output

```
 !"#$&'*+-./:;<=>?@GaLl\`0123456789

```

# Answer
> 1 votes
Gforth, 3 bytes

```

```

(That's a space, followed by a tab, followed by a newline)

# Answer
> 1 votes
# Rattle, Score: 35, Cracked

```
p
-
;
16.0112.01568.03136.021952.0

```

Note that there should be a trailing newline (technically it's impossible to do it without the trailing newline).

This should be relatively easy to crack...

As it's been cracked, here's my implementation - feel free to try to solve this a different way and teach yourself the language!

> `7|s[+]`b*~,b*~*b*b*~b=+++++++++++++++++++++++++++++++++++++++++++++,++++++++++++++,`

There is an online interpreter available here \- all you need to do is replace what's in the "code" section and hit run (I would recommend minimising the header and footer as well). Do not modify the interpreter code (i.e. don't touch the Python code in the header and footer).

Good luck!

# Edit

I'm deciding to give out a small hint - try playing around with functions without arguments! Some functions have default values

# Answer
> 1 votes
# Lua 5.1, Score: 50 Cracked

## Output

```
     !"#$%&'*+-./0123456789:;<=>?@G\^`ajklmpqvxyz{|}

```

Thats a TAB and SPACE at the beginning and a new line at the end. My code to produce that is 19542 bytes long in just 1 line. Thats my last try, cause once you come behind this you can come behind everything in LUA in this Thread.

Have fun :-)

# Answer
> 1 votes
# YaBASIC, Score:13 Cracked by Dingus

**X:** The string to crack:

```
0
1
2
3
4
5
6
7
8
9
A
a
-

```

The language may be Basic, but is the solution?

**Y:** The language - YaBASIC:

```
print "Can you crack it?"

```

Try it online!

# Answer
> 1 votes
# Dis, Score: 1, cracked by Dingus

```
{

```

I have never thought of constructing the program when I posted this.

PS. Rule clarification.

* Output exactly a character whose codepoint is 123 in decimal integer.
* Do not output else.
* Then terminate the program.
* ~~No Dis implementation whose `{` command does `putchar(codepoint of (a%256))` rather than `putchar(codepoint of a)`; if your implementation is so, reguster A must be exactly 123 when `{` is executed.~~  deleted as reference implementation, implemented in C, uses `putchar(char)` and `char` stores eight octets (maybe not on some machines).

## Intended solution

> `*|||*__>*__>_||^___________________________*!**}}*!` Try it online! Link to my interpreter, with comments. This uses that 123=11120t=1-11122t-11122t. To produce 1 I had to make 00100t first by 0-01020t-01120t-01120t. Then I did it `>` twice.

# Answer
> 1 votes
# Javastack, score 10, Cracked by exedraj

```
1234567890

```

Have fun ;}

My intended solution will not be posted here.

# Answer
> 1 votes
# Javastack, score 13, Cracked again by exedraj

```
1234567890"nq

```

Have more fun ;}

To exedraj: HR couldn't modify \>\<\> :)

# Answer
> 1 votes
# Javastack, score 14, Cracked by exedraj - on to round 4!

```
1234567890"dqw

```

No `add`, no `duplicate`, no `double`, no `random`, no `power` \- hopefully this will thoroughly bamboozle you.

Have fun!

I gave you back `flatprint` \- you're gonna need it.

# Answer
> 1 votes
# Javastack, score 15, Cracked by exedraj

```
1234567890"crsy

```

Game on, again.

Up-to-date copy of the interpreter

# Answer
> 1 votes
# Javastack, score 16, ingeniously cracked by exedraj for the eighth time

```
1234567890gbsort

```

You thought the last one was hard...

Up-to-date copy of the interpreter

# Answer
> 1 votes
# Perl 5, score: 38, safe.

No modules.

```
"#'$&;)+!,-./%07*245@6|89<>31:?\]^_`}~

```

I think this is still an easy problem.

## Hint

* Try making integers with allowed characters.
* Then pass them to some functions.
* Finally concatenate them with something.

## Solution

> There can be some solutions; one is `print chr length for qw x XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX x`. Try it online! How to generate the solution

# Answer
> 1 votes
# Javastack, score 1, Anticlimactically cracked by exedraj

```
a

```

So simply complex...

Up-to-date copy of the interpreter

I forgot how many ways JS has to get a NaN.

# Answer
> 1 votes
# Javastack, score 8, round 11, Cracked by exedraj

```
dfhjkmuv

```

Probably the last one, unless an unintended crack is found.

Up-to-date copy of the interpreter, with ES2020 stuff removed

# Answer
> 1 votes
# Vyxal `O`, score 51, Cracked by lyxal

```
,₴…‹›⟇+*/-d↵EǍ½ƒɖ1234567890ø∆e₈₇∞₆₄JpiẎȯhtḢṪḣṫ¡Þ₀₁C

```

Only *slightly* evil :}

# Answer
> 1 votes
# Vyxal `O`, score 57

```
,₴…‹›⟇+*/-d↵EǍ½ƒɖ1234567890ø∆e₈₇∞₆₄JpiẎȯhtḢṪḣṫ¡Þ₀₁C!¬⇧İN⇩

```

Take 2.

# Answer
> 1 votes
# CLC-INTERCAL, score: 7, safe.

For clarification here is a sequence of seven octets to output in hex:

```
52 45 41 44 4f 55 54

```

Try it online!

## The answer

Here is `od -t x1 -v` of source:

```
0000000 c4 d6 5e f1 4c 60 7b f7 c4 d6 5e f1 e2 e4 c2 7b
0000020 f1 4c 60 7b f1 c4 d6 5e f1 e2 e4 c2 7b f2 4c 60
0000040 7b f3 f6 f8 c4 d6 5e f1 e2 e4 c2 7b f3 4c 60 7b
0000060 f3 f7 f5 c4 d6 5e f1 e2 e4 c2 7b f4 4c 60 7b f1
0000100 f3 f6 f9 c4 d6 5e f1 e2 e4 c2 7b f5 4c 60 7b f1
0000120 f3 f5 f4 c4 d6 5e f1 e2 e4 c2 7b f6 4c 60 7b f5
0000140 f6 f6 c4 d6 5e f1 e2 e4 c2 7b f7 4c 60 7b f2 f5
0000160 f3 c4 d6 d9 c5 c1 c4 d6 e4 e3 5e f1
0000174

```

It's:

```
DO;1<-#7DO;1SUB#1<-#1DO;1SUB#2<-#368DO;1SUB#3<-#375DO;1SUB#4<-#1369DO;1SUB#5<-#1354DO;1SUB#6<-#566DO;1SUB#7<-#253DOREADOUT;1

```

in EBCDIC.

You may need compiler option `-e`, as character set guessing does not work.

### See also

My answer on Restricted mini challenge

# Answer
> 1 votes
# Vyxal `O`, score 59, Cracked by lyxal

```
,₴…‹›⟇+*/-d↵EǍ½ƒɖ1234567890ø∆e₈₇∞₆₄JpiẎȯhtḢṪḣṫ¡Þ₀₁C!¬⇧İN⇩Ż÷

```

Third time's the charm...

# Answer
> 1 votes
# Vyxal `O`, score 63, Cracked by lyxal

```
,₴…‹›⟇+*/-d↵EǍ½ƒɖ1234567890ø∆e₈₇∞₆₄JpiẎȯhtḢṪḣṫ¡Þ₀₁C!¬⇧İN⇩Ż÷«»`;

```

One more time...

# Answer
> 1 votes
# Vyxal `O`, score 72, Cracked by lyxal

```
,₴…‹›⟇+*/-d↵EǍ½ƒɖ1234567890ø∆e₈₇∞₆₄JpiẎȯhtḢṪḣṫ¡Þ₀₁C!¬⇧İN⇩Ż÷«»`;¥£¾¼⅛%→←"

```

One more time...

# Answer
> 1 votes
# Vyxal `O`, score 76

```
,₴…‹›⟇+*/-d↵EǍ½ƒɖ1234567890ø∆e₈₇∞₆₄JpiẎȯhtḢṪḣṫ¡Þ₀₁C!¬⇧İN⇩Ż÷«»`;¥£¾¼⅛%→←"ẋ¤ȦF

```

This is difficult...

# Answer
> 1 votes
# Vyxal `O`, score 81, Cracked by lyxal

```
,₴…‹›⟇+*/-d↵EǍ½ƒɖ1234567890ø∆e₈₇∞₆₄JpiẎȯhtḢṪḣṫ¡Þ₀₁C!¬⇧İN⇩Ż÷«»`;¥£¾¼⅛%→←"ẋ¤ȦFȧ⌐m⊍g

```

This is difficult...

# Answer
> 1 votes
# Vyxal `O`, score 90, Cracked by lyxal

```
,₴…‹›⟇+*/-d↵EǍ½ƒɖ1234567890ø∆e₈₇∞₆₄JpiẎȯhtḢṪḣṫ¡Þ₀₁C!¬⇧İN⇩Ż÷«»`;¥£¾¼⅛%→←"ẋ¤ȦFȧ⌐m⊍g≬\ṡ∷‡⁽⟨|⟩

```

This is difficult...

# Answer
> 1 votes
# Vyxal `O`, score 105, Cracked by lyxal

```
,₴…‹›⟇+*/-d↵EǍ½ƒɖ1234567890ø∆e₈₇∞₆₄JpiẎȯhtḢṪḣṫ¡Þ₀₁C!¬⇧İN⇩Ż÷«»`;¥£¾¼⅛%→←"ẋ¤ȦFȧ⌐m⊍g≬\ṡ∷‡⁽⟨|⟩‟„$∇_yǏṘRq꘍₍₌Π⁺

```

Just when you thought it wasn't hard enough already...

# Answer
> 1 votes
# Vyxal `O`, score 125, Cracked by lyxal

```
,₴…‹›⟇+*/-d↵EǍ½ƒɖ1234567890ø∆e₈₇∞₆₄JpiẎȯhtḢṪḣṫ¡Þ₀₁C!¬⇧İN⇩Ż÷«»`;¥£¾¼⅛%→←"ẋ¤ȦFȧ⌐m⊍g≬\ṡ∷‡⁽⟨|⟩‟„$∇_yǏṘRq꘍₍₌Π⁺ʀ↑↓G↲↳⋏⋎Ṅ⁋ð×‛√²⌈⌊:ḊD

```

The last one, for now.

# Answer
> 1 votes
# Vyxal, score 159, cracked by Aaron

```
,₴…‹›⟇+*/-d↵EǍ½ƒɖ1234567890ø∆e₈₇∞₆₄JpiẎȯhtḢṪḣṫ¡Þ₀₁C!¬⇧İN⇩Ż÷«»`;¥£¾¼⅛%→←"ẋ¤ȦFȧ⌐m⊍g≬\ṡ∷‡⁽⟨|⟩‟„$∇_yǏRq꘍₍₌Π⁺βτʀʁɾɽ¨żẏ?¹⁰²ǔǓǒǑǐǎꜝ₂₃₅&ẇŀl↑↓∴∵O¢ṙṗṖ¦†AVG↲↳⋏⋎Ṅ⁋×λ√⌈⌊:ḊD

```

My turn.

# Answer
> 1 votes
# Vyxal, score 220, cracked by EmanresuA

```
,₴…‹›⟇+*/-d↵EǍ½ƒɖ1234567890ø∆e₈₇∞₆₄JpiẎȯhtḢṪḣṫ¡Þ₀₁C!¬⇧İN⇩Ż÷«»`;¥£¾¼⅛%→←"ẋ¤ȦFȧ⌐m⊍g≬\ṡ∷‡⁽⟨|⟩‟„$∇_yǏRq꘍₍₌Π⁺βτʀʁɾɽ¨żẏ?¹⁰²ǔǓǒǑǐǎꜝ₂₃₅&ẇŀl↑↓∴∵O¢ṙṗṖ¦†AVG↲↳⋏⋎Ṅ⁋×λ√⌈⌊:ḊDabcjnsvwxzBHIKMQSTUWXYZ)}]([{<>ḂĊḞĠĿṀȮṠẆẊ℅@°•ß€↔æƈ ¯±≠⁼≥≤=ḃ∩∪

```

More.

# Answer
> 1 votes
# Vyxal `D`, score 233, cracked by aaroneous Miller

```
ḟṙIcKġ₴…‹›+*/-d↵Ǎ½ƒɖø∆₈₇∞₆₄JiẎȯht42069ḢṪḣṫ¡Þ₀₁C!¬⇧İNeVERgȮṄnaGḭ⟇ėyOU⊍p⇩Ż÷«»⌐m≬\ṡ∷‡⁽⟨|⟩‟„$∇_Ǐq꘍₍₌Π⁺βτʀʁɾɽ¨żẏ?¹⁰²ǔǓǒǑǐǎꜝ₂₃₅&ẇŀl↑↓∴∵¢`;¥£¾F¼⅛%→←"ẋ¤Ḋε€ṗṖ¦†ḃL¶ðZṘ↲↳⋏⋎⁋×λ√⌈⌊:Dbjwxz,BHMQSTXY)}]([{<>ḂĊḞĿṀṠẆẊ℅@°•ß↔æƈ§≈µ¯±≠⁼≥≤=∩s∪ĠṁȦ'ċḋṅ13578ȧ

```

lol

# Answer
> 1 votes
# Vyxal `D`, score 239, cracked by Aaron

```
ḟṙIcKġ₴…‹›+*/-d↵Ǎ½ƒɖø∆₈₇∞₆₄JiẎȯht42069ḢṪḣṫ¡Þ₀₁C!¬⇧İNeVERgȮṄnaGḭ⟇ėyOU⊍p⇩Ż÷«»⌐m≬\ṡ∷‡⁽⟨|⟩‟„$∇_Ǐq꘍₍₌Π⁺βτʀʁɾɽ¨żẏ?¹⁰²ǔǓǒǑǐǎꜝ₂₃₅&ẇŀl↑↓∴∵¢`;¥£¾F¼⅛%→←"ẋ¤Ḋε€ṗṖ¦†ḃL¶ðZṘ↲↳⋏⋎⁋×λ√⌈⌊:Dbjwxz,BHMQSTXY)}]([{<>ḂĊḞĿṀṠẆẊ℅@°•ß↔æƈ§≈µ¯±≠⁼≥≤=∩s∪ĠṁȦ'ċḋṅ13578ȧ∧⟑∨^rA

```

No logic. No range. No Any.

# Answer
> 1 votes
# Vyxal `D`, score 244, cracked by Aaroneous

```
ḟṙIcKġ₴…‹›+*/-d↵Ǎ½ƒɖø∆₈₇∞₆₄JiẎȯht42069ḢṪḣṫ¡Þ₀₁C!¬⇧İNeVERgȮṄnaGḭ⟇ėyOU⊍p⇩Ż÷«»⌐m≬\ṡ∷‡⁽⟨|⟩‟„$∇_Ǐq꘍₍₌Π⁺βτʀʁɾɽ¨żẏ?¹⁰²ǔǓǒǑǐǎꜝ₂₃₅&ẇŀl↑↓∴∵¢`;¥£¾F¼⅛%→←"ẋ¤Ḋε€ṗṖ¦†ḃL¶ðZṘ↲↳⋏⋎⁋×λ√⌈⌊:Dbjwxz,BHMQSTXY)}]([{<>ḂĊḞĿṀṠẆẊ℅@°•ß↔æƈ§≈µ¯±≠⁼≥≤=∩s∪ĠṁȦ'ċḋṅ13578ȧ∧⟑∨^rA□f.∑W

```

It's so sad that the last answer died of sigma.

# Answer
> 1 votes
# Vyxal `so`, score 248, cracked by EmanresuA

```

 !"#$%&'()*+,-./023456789:;<=>?@ABCDEFGHIJKLNOQRSTUVXYZ[\]^_`abcdefghijlmnpqrtuvwxyz{|}~¡¢£¤¥¦§¨«¬¯°±²µ¶¹»¼½¾×Þßæð÷øĊċėĠġİĿŀŻżƈƒƛǍǎǏǐǑǒǓǔȦȧȮȯɖɽɾʀʁΠβελτḂḃḊḋḞḟḢḣḭṀṁṄṅṖṗṘṙṠṡṪṫẆẇẊẋẎẏ‛„‟†‡•…‹›⁋⁰⁺⁼⁽₀₁₂₃₄₅₆₇₈₌₍€₴℅⅛←↑→↓↔↲↳↵⇧⇩∆∇∑√∞∧∨∩∪∴∵∷≈≠≤≥≬⊍⋎⋏⌈⌊⌐□⟇⟑⟨⟩꘍ꜝ

```

The final challenge.

# Answer
> 1 votes
# Vyxal `so`, score 249, cracked by aaroneous

```

 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLNOQRSTUVXYZ[\]^_`abcdefghijlmnpqrtuvwxyz{|}~¡¢£¤¥¦§¨«¬¯°±²µ¶¹»¼½¾×Þßæð÷øĊċėĠġİĿŀŻżƈƒƛǍǎǏǐǑǒǓǔȦȧȮȯɖɽɾʀʁΠβελτḂḃḊḋḞḟḢḣḭṀṁṄṅṖṗṘṙṠṡṪṫẆẇẊẋẎẏ‛„‟†‡•…‹›⁋⁰⁺⁼⁽₀₁₂₃₄₅₆₇₈₌₍€₴℅⅛←↑→↓↔↲↳↵⇧⇩∆∇∑√∞∧∨∩∪∴∵∷≈≠≤≥≬⊍⋎⋏⌈⌊⌐□⟇⟑⟨⟩꘍ꜝ

```

We partake in a mild amount of tomfoolery.

# Answer
> 1 votes
# Vyxal `so`, score 249, fricking gosh dang cracked by aaron

```

 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUXYZ[\]^_`abcdefghijmnpoqrtuvwxyz{|}~¡¢£¤¥¦§¨«¬¯°±²µ¶¹»¼½¾×Þßæð÷øĊċėĠġİĿŀŻżƈƒƛǍǎǏǐǑǒǓǔȦȧȮȯɖɽɾʀʁΠβελτḂḃḊḋḞḟḢḣḭṀṁṄṅṖṗṘṙṠṡṪṫẆẇẊẋẎẏ‛„‟†‡•…‹›⁋⁰⁺⁼⁽₀₁₂₃₄₅₇₈₌₍€₴℅⅛←↑→↓↔↲↳↵⇧⇩∆∇∑√∞∧∨∩∪∴∵∷≈≠≤≥≬⊍⋎⋏⌈⌊⌐□⟇⟑⟨⟩꘍ꜝ

```

Commit utter frick.

# Answer
> 1 votes
# Brainfuck

##### Level: baby

---

Should be pretty straight forward (literally), but I think it's still interesting

```
,-<>[]

```

##### Why I think it's interesting:

> The fact that you can print any string with only two different characters in brainfuck is quite interesting in my opinion

# Answer
> 1 votes
# !@#$%^&\*()\_+, Score: 2

```
^+
```

# Answer
> 0 votes
# Dyalog APL, score: 53

```
BCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz⍙3

```

I don't know how long this will last

# Answer
> 0 votes
# Wolfram Language (Mathematica), Score: 47, cracked

```
abdfghijklmnopqrstuvwxyz
{ <-> , ~, &}[(*@)[]]

```

Fixed.

# Answer
> 0 votes
# QBasic 1.1, score: 2, Cracked

```
Cc

```

I'm specifying QBasic 1.1 in order to exclude QB64 with its extra features. You can run it at Archive.org.

# Answer
> 0 votes
# QBasic 1.1, score: 3, Cracked

```
C,c

```

`POKE` should be impossible now.

You can run QBasic 1.1 at Archive.org.

---

My solution:

> ```
>  DIM outstr AS STRING * 3
>  outstr = MKS$(908.6916)
>  PRINT outstr
>
> ```

# Answer
> 0 votes
# Javastack, score 16, Cracked by exedraj

```
1234567890"crsyo

```

My my, you are going to *enjoy* this one...

Up-to-date copy of the interpreter

Mistakes were made, but this will now work (sorry)

---
Tags: string, kolmogorov-complexity, restricted-source, cops-and-robbers
---