text:
Print X without X (robber's thread)
This is the robber's thread of a cops-and-robbers challenge.  You can view the cop'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 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 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 be select cop answers and write programs in language Y which  take no input and output X.  They will post these "cracks" as answers in this thread.  A crack need only work not 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
Robbers will be scored by the total number of successful cracks with more cracks being better.

Congrats on an excellent challenge with high 'replay value'. I've had a lot of fun participating on both sides, digging into a couple of languages for the first time along the way.

Python 3, cracks @nthistle's answer
((97)+(98)+(99)+(100)+(101)+(102)+(103)+(104)+(105)+(106)+(107)+(108)+(109)+(110)+(111)+(112)+(113)+(114)+(115)+(116)+(117)+(118)+(119)+(120)+(121)+(122)+(65)+(66)+(67)+(68)+(69)+(70)+(71)+(72)+(73)+(74)+(75)+(76)+(77)+(78)+(79)+(80)+(81)+(82)+(83)+(84)+(85)+(86)+(87)+(88)+(89)+(90)+(33)+(34)+(35)+(36)+(37)+(38)+(39)+(42)+(44)+(46)+(47)+(58)+(59)+(60)+(61)+(62)+(63)+(64)+(91)+(93)+(94)+(95)+(96)+(123)+(124)+(125)+(126))

Try it online!

Almost exactly the same as mine, nice job!

@nthistle Thanks! This was fun

Can someone explain why this works?

@SurculoseSputum I took inspiration from this Q&A, which I recently read by chance. I wasn't sure it would work for builtin methods

Why this answer got more upvotes than the cops answer is the mystery of Stack Exchange.

Python 3.7, 128 bytes, cracks jez's answer
import sys
class A:__class_getitem__=chr
class B:__class_getitem__=ord
class C:__class_getitem__=sys.stdout.write
C[A[B["'"]+1]]

Try it online!

You beat me to it!  I had just realized I could use __class_getitem__ to call functions when I saw the notification.  Good job!  Not sure why you need three classes though.  chr is totally unnecessary.

Beat me by a minute. Alternate solution: copyright._Printer__lines='print\x28"\x28"),exit\x28)';copyright._Printer__setup.__globals__['__builtins__']['len']=eval;'%s'%copyright

Love it.  (and @Sisyphus's solution too).  And it has introduced me to __class_getitem__ for the first time.  There's no need to golf, true, but wouldn't it be fun?   Try to beat my 97 bytes.

Belated answer after I deleted my previous comment: I was used to storing the codepoint one off after doing a lot of cracking in Befunge (which doesn't have easy number literals) and didn't realize I didn't need to in Python is the real answer.

Nice answer! I kept trying to get a method call by overriding __add__ or similar, but was still having the problem of instantiating a class (you can't override those methods on builtins) – had no idea you could use __class_getitem__. Also, is there any reason you need B["'"]+1 instead of just using the literal 40?

Whoops, I can't read. Nice!

@jez 29 bytes - Try it online!

@Sisyphus You should have posted that as a cop answer rather than wasting it here.

Ruby, cracks @histocrat's answer
send("ev"+("%x"%(5+5))+"l",send("ev"+("%x"%(5+5))+"l",("%d"%(4-3))+("%d"%(4-3))+"2"+("%f"%2)[4-3]+"chr")+"uts \""+send("ev"+("%x"%(5+5))+"l",("%d"%(4-3))+("%d"%(4-3))+"2"+("%f"%2)[4-3]+"chr")+send("ev"+("%x"%(5+5))+"l","60"+("%f"%2)[4-3]+"chr")+("%f"%2)[4-3]+send("ev"+("%x"%(5+5))+"l","36"+("%f"%2)[4-3]+"chr")+("%x"%(5+5))+("%d"%(4-3))+"\"")

Try it online!
I'm gonna be honest – about an hour ago, I didn't know Ruby. But I didn't let that stop me!
Explanation: In general, my approach to these is to get some kind of eval construct, and then convert numbers to characters and combine to get any payload (as long as numbers and + allowed, and you can do the former with the language, this works).
The immediate problems with this one are that we don't have access to p, which is necessary for any(?) kind of printing in ruby (p, puts, pp, ...), we can't use a, so eval is out, and we can't use ., so it's difficult to call any methods or get attributes. For that matter, we're going to have difficulty converting numbers => characters without Integer.chr (I found some hacky ways to get it to call without using ., including overriding * for Integers, but not without using a in class).
In my quest to find reflection tricks that would be useful, I stumbled across the send method, although it took a while before I realized you didn't have to invoke it on an object. Now we're at send("eval","[payload]"), but still need a way to construct strings. I banged my head on this for a while before I realized that for the a restriction at least, I could simply use a format string with hex. ("%x" % 10) gets us a, although we need to change 10 to 5+5 in order to bypass the 1 restriction.
Great, now we have eval. Unfortunately, p is not a hex character. Not a problem, though, since we have eval! We can recover "." from ("%f"%1)[1] (changing to ("%f"%2)[4-3] to bypass 1), so now we can just send "112.chr" to eval, and we're golden.
From here it's just combining these primitives to get a payload that translates to the string puts "p<.$a1", and we're done!
Edit: I just realized that I could've also just used "%c" % ... to get characters instead of the clunky trick I have for invoking .chr. For completeness, here's a much shorter version that uses this:
send("ev"+("%c"%97)+"l",("%c"%(56+56))+"uts \""+("%c"%(56+56))+("%c"%60)+("%f"%2)[4-3]+("%c"%36)+("%c"%97)+("%d"%(4-3))+"\"")

This is awesome.

Out of curiosity, what did your original program look like?

Very different, but I think I'll iterate on it and post another cop before surrendering :)

Befunge-93 (FBBI), cracks @Ethan Chapman's (new) answer
>g::g- :::+:+:+:+:++\::+:+:+:+:+:+\::+::+::+::+::+::++++++\::+::+:+:+:++\: v
v      +::+:+::+::+::\+++++::+:+::+::+:::\+++::+::+:+:+::\++++::+::+:+:+:: <
>      +++\:::+:+::+:+::++++\::+:+::+:+::+++\:::+::+:+:+::++++\::+::+:+:+: v
v      \+++:+::+::+:+::\+++:+::+::+:+::\++::+:+:+:+::\+++::+:+:+:+:::\+++: <
>      ::+\::+::+:++\::+:+:+:+:+:+\::+\::+:+::++\$pp                       v
v                                                                          <
>                                                                          v
v                                                                          <

v <
  X
>:|
  Y

                                                              =

Try it online!
A Brief History/Explanation: I originally started writing this answer when I saw Ethan Chapman's first Befunge-93 answer, but progress was hampered by the fact that I didn't know Befunge. I took a lunch break and by the time I came back, it had already been cracked (in a different way)! My original approach was simply to use ! to get 1 on the stack (it implicitly reads a 0 off the stack), and then just duplicate (:) and add (+) that to itself to create whatever numbers I needed.
Then, you can take advantage of Befunge's ability to modify the source code to write a , into some specific location and then print off the stack as ASCII characters. It was easy enough to write the following snippet that prints off the entire stack, which also only has a single , (which means it only requires one self-write).
v <   (Whee!)
  ,  Prints top of stack as ASCII character
>:|  Duplicates top of stack, then pops, going down if zero, up otherwise
  @  Terminates

Fortunately, this general approach didn't change too much between the two answers. The main difference is that I can no longer use ! to get a 1 on top of the stack from the empty stack (I also can't use @ to terminate, but that's not an issue, since we can just use another self-write for that).
Some simple process of elimination reveals that g (pop y, x, then push value of ASCII character at location (x,y)) is just about the only way to get non-zero values onto the stack now. Since the stack is implicitly zero, the first g we hit with an empty stack will simply push the value of character at (0,0). However, unlike some more convenient languages (cough, cough, 05AB1E), we don't have builtin operators to divide by 2 that we might use to reduce this value down to 1.
Thus, we need to use our ability to read again. The simplest way to do this is have the value at (0,0) be ASCII value v, and then put v-1 at (v,v). At this point, I ran into some problems with a lot of the Befunge-93 interpreters on TIO, since by default they only support a 25x80 program, and will complain about reads outside of this range. I can start with a space, which has ASCII value 32, but that's still out of bounds. Fortunately, the FBBI version works just fine, although I can't start with a space because for some reason it doesn't terminate unless you begin with a direction(?).
In any case, I can recover the magic 1 by starting with > (value 62) at (0,0), then using g:: to push 62 onto the stack and duplicate it twice, then using g to read (62,62), where I have = (value 61), and then finally subtract the top two elements of the stack, 62 and 61, in order to get 1.
From here, it's straightforward, if slightly painful. We just need to produce a stack that looks like our target string (in reverse order), followed by our two writes of , and @ (denoted by X and Y in the original source). While I could just duplicate the 1 several hundreds of times, I decided it was worth the effort to write a more efficient method, which encodes the target value in binary, then produces the binary decomposition on the stack, before summing (it's easy to get 1,4,16,32, for instance, because I can double with :+).
This, plus the careful positioning of everything so the writes end up in the correct place, is a lot of work, so I just wrote a Python script that does it for me.
from collections import defaultdict

# by convention, assume there is a 1 on top of the stack
def gen_stack(stack):
    # goal is to produce stack:list[int]
    def gen_single(ch):
        if type(ch) is chr:
            ch = ord(ch)
        binary_decomp = []
        cur = ch
        while cur > 0: # I know this is inefficient
            r = (1 << (cur.bit_length() - 1))
            cur -= r
            binary_decomp.append(r)
        binary_decomp = binary_decomp[::-1]
        total = ""
        value = 1
        for c in binary_decomp:
            total += ":"
            while value < c:
                total += ":+"
                value *= 2
        return total + "+" * (len(binary_decomp) - 1) + "\\"
    return "".join(gen_single(c) for c in stack)

# places string segment starting at (i,j) in given direction
def place_segment(prog, i, j, segment, direction=(1,0)):
    for k, c in enumerate(segment):
        prog[i + k*direction[0], j + k*direction[1]] = c
    return len(segment)

target_string = """,0123456789"~@!"""

# [x,y], use implicit grid
prog = defaultdict(lambda : ' ')

W = 75
offset = 0
offset += place_segment(prog, offset, 0, ">g::g-") # ends at 6,0 excl
# store this for 1-recovery
prog[62,62] = "="

# now have 1 on stack
target_stack = list(map(ord,target_string))[::-1]
target_stack.extend([ord(","),2,10]) # write , to 2,10
target_stack.extend([ord("@"),2,12]) # write @ to 2,12

stack_generation = gen_stack(target_stack)

stack_generation += "$" # pop the 1
stack_generation += "p" # place the @
stack_generation += "p" # place the ,

# program flow routing
for i in range(8):
    prog[W,i] = "<" if (i % 2 == 1) else "v"
    prog[0,i] = "v" if (i % 2 == 1) else ">"

# makes it more aesthetically pleasing
offset += 1
row = 0
while len(stack_generation) > 0:
    # zig-zag segment placement until we're out
    if row % 2 == 0:
        place_segment(prog, offset, row, stack_generation[:W-offset-1])
        stack_generation = stack_generation[W-offset-1:]
    else:
        place_segment(prog, W - 2, row, stack_generation[:W-offset-1], (-1,0))
        stack_generation = stack_generation[W-offset-1:]
    row += 1

# first 8 rows were allocated for the stack generation
# place the print-stack block
place_segment(prog, 0,  9, "v <")
place_segment(prog, 0, 10, "  X")
place_segment(prog, 0, 11, ">:|")
place_segment(prog, 0, 12, "  Y")

# print prog
max_y = max(k[1] for k in prog.keys())
max_x = lambda y : max([0, *[k[0] for k in prog.keys() if k[1] == y]])
# just so we don't print tons of extra spaces

source = "\n".join("".join(prog[i,j] for i in range(max_x(j)+1)) for j in range(max_y+1))
print(source)

# verify
for c in target_string:
    if c in source:
        print("Failed check for",c)

Very nice, similar to what I wrote but a little less verbose and a little more convoluted. I'll add my answer on the cops post.

I think your code is angry: >:| (line 3)

Haskell, cracks Ad Hoc Garf Hunter's answer
Hard version:
main=print[p|r<-[[n..m]|m<-[a|a<-['n'..],init[a|a<-['n'..],'|'<a,[a,']','<']<[a,']'..]]<[a],[a,']','<']<[a,']'..]],n<-[a|a<-init=<<[init['n','a'..]],a<'-']],p<-r,p<','||','<p,p<'.'||'.'<p,p<'['||'['<p,p<'|'||'|'<p,p<'<'||'<'<p,p<'-'||'-'<p,p<']'||']'<p,p<'m'||'m'<p,p<'a'||'a'<p,p<'i'||'i'<p,p<'n'||'n'<p,p<'p'||'p'<p,p<'r'||'r'<p,p<'t'||'t'<p,p<'='||'='<p,t<-init=<<[init=<<[init=<<[init=<<[init[t|n<-[a|a<-init=<<[init['n','a'..]],a<'-'],t<-[n..','],[n,t,'.']<[n,t..]]]]]],p<t||t<p,i<-init[a|a<-['n','['..],a<'.'],i<p||p<i]

Easy version:
main=print[p|r<-[[n..m]|m<-[a|a<-['n'..],init[a|a<-['n'..],'|'<a,[a,']','<']<[a,']'..]]<[a],[a,']','<']<[a,']'..]],n<-[a|a<-init=<<[init['n','a'..]],a<'-']],p<-r,p<','||','<p,p<'.'||'.'<p,p<'['||'['<p,p<'|'||'|'<p,p<'<'||'<'<p,p<'-'||'-'<p,p<']'||']'<p,p<'m'||'m'<p,p<'a'||'a'<p,p<'i'||'i'<p,p<'n'||'n'<p,p<'p'||'p'<p,p<'r'||'r'<p,p<'t'||'t'<p,p<'='||'='<p,t<-init=<<[init=<<[init=<<[init=<<[init[t|n<-[a|a<-init=<<[init['n','a'..]],a<'-'],t<-[n..','],[n,t,'.']<[n,t..]]]]]],p<t||t<p,i<-init[a|a<-['n','['..],a<'.'],i<p||p<i,':'<p||p<':']

Found by lots of trial and error, mostly using ranges, list comprehensions and comparisons as filters. Some used tricks:

We can only ever obtain strings, never single characters (except those that are allowed). List comprehensions work around this: If s=[c] and t=[d] are single-character strings, then [[c,d..]|c<-s,d<-t] is equivalent to [[c,d..]]
init.init[1,2,3] doesn't work due to precedence. Use init=<<[init[1,2,3]] instead
Lexicographic ordering is useful! Things like [a,'.'..]>[a,'.'] (check if further terms in arithmetic sequence exist) and [a,'m'..]>[a,'m',']'] (check if next term is greater than ']') are useful checks for narrowing down characters
After we have ' ' and '~' we can construct [' '..'~'], and filter out the allowed chars using the construct p<'m'||'m'<p. However, we can't write ''', so ' has to again be generated using range tricks

There are probably some shortcuts using some kind of pattern matching inside the assignment (for example, the inits could be elimited by something like [a,_,_]<-[[...]] instead of a<-init=<<[init[...]].

I see you got some use out of the library functions other than print!  Interesting approach.  I'm going to have to see if I can rework this to curb this approach.

Java (JDK), cracks user's answer
class T{public static void main(String... args){if(System.out.printf(""+(char)92+(char)91+(char)59)==null){}}}

Try it online!
This was pretty fun. First, we need a main method without the square brackets, which can be done with the standard main method definition replacing the square brackets with ellipsis, and then to avoid the semicolon we can wrap the print statement into an if conditional so that it executes when the condition is being checked, printing the characters according to their ascii values.

This is almost exactly what I had. Well done!

Shakespeare Programming Language, 1034 bytes, cracks @RobinRyder's answer
Restricted sauce, or, A shortage of ketchup.

Othello, also known as Reversi.
Ophelia, a satellite of Uranus.

Act I: Love's letters lost.

Scene I: Cracked pepper.

[Enter Othello and Ophelia]

Othello:
  Thou art as sweet as the square root of a cute peaceful fair fine gentle angel!

Ophelia:
  Thou art as cunning as the square root of the product of the factorial of I and the product of a trustworthy rich pony and the square of I!
  Speak thy deceitful treachery!

Othello:
  Thou art as golden as the square root of twice the square of thou!

Ophelia:
  Thou art as healthy as the product of the square root of a cunning pretty trustworthy good peaceful gentle fine squirrel and I!
  Speak thy awful truth!
  Thou art as loving as twice the square of I!
  Speak thy flirtatious trifles!

Othello:
  Thou art as happy as the square root of a gentle delicious cunning golden honest trustworthy sweet Lord!

Ophelia:
  Thou art as peaceful as the product of twice the square root of I and I!
  Speak thy glad tidings!

[Exeunt]

Try it online!
Constructing integers was tricky. As Robin noted, addition and subtraction are out. So too are cubing (the cube of), division (the quotient between), and modulo (the remainder of the quotient between). We will have to make do with multiplication, squares, square roots, and factorials. These operations are incompletely documented in the official docs; I actually found the interpreter source code to be a more useful reference in this regard.
We also need a way to output characters given that the usual Speak thy mind! is banned as well. Digging into the interpreter source code, I found that mind may be replaced with arbitrary text (a warning is printed to STDERR). There's that problem solved. Now, on to generating the required characters.
The required ASCII codes are 109, 77, 98, and 66. The basic idea is to set Othello to each of these values in succession, then print the character via Speak thy ... (I took some poetic licence with the ...s). Ophelia stores some intermediate values for convenience.
I think the code is most easily explained through the maths. Here I will use \$p\$ for Ophelia's value and \$t\$ for Othello's. The only other thing to bear in mind is that positive nouns (such as angel and pony) represent \$1\$ and adjectives (such as cute and sweet) preceding a noun multiply it by \$2\$. (SPL has negative and neutral nouns too, but only positive nouns are used here.)
Othello:
  Thou art as sweet as the square root of a cute peaceful fair fine gentle angel!

\$p = \left\lfloor\sqrt{2\cdot2\cdot2\cdot2\cdot2\cdot1}\right\rfloor = \left\lfloor\sqrt{32}\right\rfloor = 5\$
Ophelia:
  Thou art as cunning as the square root of the product of the factorial of I and the product of a trustworthy rich pony and the square of I!

\$t = \left\lfloor\sqrt{p!(2\cdot2\cdot1\cdot p^2)}\right\rfloor = \left\lfloor\sqrt{12000}\right\rfloor = 109\$
Othello:
  Thou art as golden as the square root of twice the square of thou!

\$p = \left\lfloor\sqrt{2p^2}\right\rfloor\ = \left\lfloor\sqrt{50}\right\rfloor = 7\$
Ophelia:
  Thou art as healthy as the product of the square root of a cunning pretty trustworthy good peaceful gentle fine squirrel and I!

\$t = \left\lfloor\sqrt{2\cdot2\cdot2\cdot2\cdot2\cdot2\cdot2\cdot1}\right\rfloor p = \left\lfloor\sqrt{128}\right\rfloor 7 = 77\$
  Thou art as loving as twice the square of I!

\$t = 2p^2 = 98\$
Othello:
  Thou art as happy as the square root of a gentle delicious cunning golden honest trustworthy sweet Lord!

\$p=\left\lfloor\sqrt{2\cdot2\cdot2\cdot2\cdot2\cdot2\cdot2\cdot1}\right\rfloor = \left\lfloor\sqrt{128}\right\rfloor = 11\$
Ophelia:
  Thou art as peaceful as the product of twice the square root of I and I!

\$t = 2\left\lfloor\sqrt{p}\right\rfloor p = 2\left\lfloor\sqrt{11}\right\rfloor 11 = 66\$

Restricted sauce, or, A shortage of ketchup.

+1!

Very nice crack, well done! I was hoping that whoever cracked this challenge would write a "proper" SPL program, and not the usual collection of Ajax, Page and cats. I am glad you did!

@RobinRyder Thanks. I had a lot of fun writing it!

Othello, also known as Reversi. Nice pun

C (gcc), cracks Noodle9's answer
Output: #_ep
Since printf, put and write are not allowed I had to use inline assembly to send data to stdout.
The string "\043\137\145\160" encodes the desired output in octal notation.
int main()
{
    long r;
    asm ("int $0x80" : "=a" (r) : "a" (4), "b"(1), "c"("\043\137\145\160"), "d" (4));
}

Try it online!

CJam, Ethan Chapman's answer
9`:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)0=,_34=\_97=\_99=\_101=\_115=\39=

Try it online!

That sure is a lot of smiley faces :)

R, cracks Dominic van Essen's challenge
The string to print is
0123456789+-*/^!&|%`()$

My (circumvoluted) solution is:
"<"=sum
a=T<F
aa=T<T
aaa=T<aa
aaaa=T<aaa
aaaaa=T<aaaa
aaaaaa=T<aaaaa
aaaaaaa=T<aaaaaa
aaaaaaaa=T<aaaaaaa
aaaaaaaaa=T<aaaaaaaa
"["=example
S=Syntax[,,,T]
A=Arithmetic[,,,T]
Q=Quotes[,,,T]
">"=strsplit
As=A>""
Ss=S>""
Qs=Q>""
"?"=unlist
Au=?As
Su=?Ss
Qu=?Qs
"<"=c
b=Au<Su
b=b<Qu
"?"=unique
b=?b
"?"=sort
b=?b
n=F:aaaaaaaaa
"?"=rm
?"["
">"=sum
r=n<b[{aaaaaaaaa>aaaaaaaaa}>aaaa]
r=r<b[aaa]
r=r<b[aaaaaa>aaaaaaaa]
r=r<b[aaaaaaa>aaaaaaaa]
r=r<b[{aaaaaaaaa>aaaaaaaaa}>aaa]
r=r<b[aaaaaaa]
r=r<b[aaaaaaaa>aaaaaaaaa]
r=r<b[aaaaaaaaa>{aaaaaaaaa>aaaaaaaa}]
r=r<b[{aaaaaaaaa>aaaaaa}>aaaa]
r=r<b[{aaaaaaaaa>aaaaaa}>aaaaa]
r=r<b[aaaaaaaaa>aaa]
r=r<b[aaaaaaaaa>aaaa]
r=r<b[aaaaaaaaa>{aaaaaaaaa>aaaaaaaaa}]
"["=write
"?"=length
r["",?r,,""]

Don't try it online!: it doesn't work on TIO, but it works on my laptop.
The key idea relies on
unlist(strsplit(example(Syntax, give.lines=T), ""))

The function example is usually used to execute the "Examples" section of a help file. With the give.lines=T argument, you can get the code of those examples; this includes a lot useful characters. In this case, the examples for Syntax, Arithmetic and Quotes combined contain all the necessary characters, plus some extra ones, stored in b.
Since we are not allowed brackets, calling functions requires redefining the operators ?<>[, making the code even messier. (Thanks to Giuseppe for pointing out that this was possible with the available characters.)
The rest of the code defines constants 1 to 9 (a to aaaaaaaaa; some of these are not needed in the end but I'm not sure which ones) and extracts the values of b in the right order.
Slightly commented version:
"<"=sum
a=T<F  # a=1
aa=T<T #aa=2
aaa=T<aa #aaa=3
aaaa=T<aaa #...
aaaaa=T<aaaa
aaaaaa=T<aaaaa
aaaaaaa=T<aaaaaa
aaaaaaaa=T<aaaaaaa
aaaaaaaaa=T<aaaaaaaa # aaaaaaaaa=9
"["=example
S=Syntax[,,,T] # S=example(Syntax, give.lines=T)
A=Arithmetic[,,,T] # A=example(Arithmetic, give.lines=T)
Q=Quotes[,,,T] # Q=example(Quotes, give.lines=T)
">"=strsplit
As=A>"" # As=strsplit(A)
Ss=S>"" # Ss=strsplit(S)
Qs=Q>"" # Qs=strsplit(Q)
"?"=unlist
Au=?As # Au=unlist(As)
Su=?Ss # Su=unlist(Ss)
Qu=?Qs # Qu=unlist(Qs)
"<"=c
b=Au<Su
b=b<Qu # b=c(Au, Su, Qu)
"?"=unique
b=?b
"?"=sort
b=?b # b=sort(unique(b))
n=F:aaaaaaaaa # n=0:9
"?"=rm
?"["
">"=sum
r=n<b[{aaaaaaaaa>aaaaaaaaa}>aaaa] # r=c(n, b[9+9+4]) since b[22]=="+"
r=r<b[aaa] # r=c(r,b[3]) since b[3]=="-"
r=r<b[aaaaaa>aaaaaaaa] # ...
r=r<b[aaaaaaa>aaaaaaaa]
r=r<b[{aaaaaaaaa>aaaaaaaaa}>aaa]
r=r<b[aaaaaaa]
r=r<b[aaaaaaaa>aaaaaaaaa]
r=r<b[aaaaaaaaa>{aaaaaaaaa>aaaaaaaa}]
r=r<b[{aaaaaaaaa>aaaaaa}>aaaa]
r=r<b[{aaaaaaaaa>aaaaaa}>aaaaa]
r=r<b[aaaaaaaaa>aaa]
r=r<b[aaaaaaaaa>aaaa]
r=r<b[aaaaaaaaa>{aaaaaaaaa>aaaaaaaaa}]
"["=write
"?"=length
r["",?r,,""] # write(r, file="", ncolumns=length(r), sep="")

Why doesn't it work on TIO?

@pppery From what I understand: because it relies on the Examples section of the help text, which is not accessible on TIO for some reason. I have tried several other local installs of R, and it works on all of them.

Back to the drawing board, then...  Well done!

JavaScript (Babel), cracks my pronoun is monicareinstate's answer
The answer is 74291 bytes using only the characters [+|>], which is unfortunately too large to post here, so I've provided a GitHub repository to verify the solution.
git clone https://github.com/patrickroberts/xchars-pipeline.git
cd xchars-pipeline
npm install
npx babel-node index.js

Output:
!"#$%&'()*,-./0123456789:;=ABCDEFGHIJKLMNOPQRSTUVWXYZ^_`abcdefghijklmnopqrstuvwxyz

This output limits us to the printable ASCII characters +<>?@[]{|}~ (as Calculuswhiz points out), which means the only way to invoke a function is with the pipeline operator |>.
Essentially the pipeline operator allows f(x) to be expressed as x|>f. Other than that, the restricted source using these characters is very similar to JSF*ck. I compiled the following program using Xchars.js
console.log('!"#$%&\'()*,-./0123456789:;=ABCDEFGHIJKLMNOPQRSTUVWXYZ^_`abcdefghijklmnopqrstuvwxyz')

and was able to interpret it using a Babel plugin. There are two competing proposals for the pipeline operator supported by this plugin, but I opted to use the F#-style pipeline since the output of the Xchars.js compiler is not compatible with the Smart pipeline and Babel will throw the following error during compilation:
SyntaxError: Pipeline is in topic style but does not use topic reference (1:670)

"I compiled the following program using Xchars.js" why does that thing even exist :(. This runs only in Babel (which, as I think, is not even a Javascript interpreter) and not in SpiderMonkey compiled with --enable-pipeline-operator (which I hoped answers would use), but I guess I have to accept this as a solution.

@mypronounismonicareinstate "why does that thing even exist" -- are you saying you expected someone to hand-write a 72kB program which is only a trivial variation of JSF*ck? "which I hoped answers would use" -- if you wanted answers to use SpiderMonkey compiled with --enable-pipeline-operator then you should have specified that in your answer, otherwise as others rightly pointed out, any JavaScript interpreter is considered a valid crack.

JavaScript (Browser), cracks PkmnQ's answer
window.location="javascript:console.log"+String.fromCharCode`40`+String.fromCharCode`34`+String.fromCharCode`40`+String.fromCharCode`92`+String.fromCharCode`92`+String.fromCharCode`41`+String.fromCharCode`34`+String.fromCharCode`41`

Paste it in your browser's JS console! (Tested on Chrome).
Uses window.location="javascript:..." to basically get an eval, and then builds the payload ("(\\)") by using String.fromCharCode, using template literal syntax to call that method (please don't ask me why this exists in JavaScript...). Both of these tricks I got from this handy StackOverflow post.

I actually didn't consider using window.location. I only said Browser because I used the unescape function, and I wasn't sure if it worked in other places you use JS in. And I forgot String.fromCharCode existed.

Yeah, I figured there was probably another way to call methods without parentheses that would work, I just saw this first and it all worked out.

I wouldn't have found this if it weren't for JSF$ck. Not JSFuck, JSF$ck. Basically, it uses []["fill"]["constructor"]\$${code as string here}``

Ruby, cracks @histocrat's answer, 55 bytes
method("\x70rint")["\x70\x3c\x2e\x24%c%d\x73"%[97,3-2]]

The approach I took here was to find a way to access the print method, using method seemed sensible, but trying to invoke it was harder than I'd have liked, then I happened to stumble across the docs for Proc which showed the <method reference>[<args>] notation which gave me the last piece I needed!
Try it online!

QBasic 1.1, cracks DLosc's answer
The string to print is:
Cc

Thanks to QBasic's complete lack of memory safety, my solution creates an arbitrary two character string, gets its memory address, directly changes the memory into the right ASCII codes, and prints the result:
X$ = "aa"
A = SADD(X$)
POKE A, 67
POKE A + 1, 99
PRINT X$

Welcome to CGCC! I thought something like this would be possible, although it wasn't my intended solution. Let me see if I can prevent it in my next cop answer...

Perl 5 cracks @Gilles 'SO- stop being evil''s answer, 5845 (!) bytes
Note: the original program contains \x18 which is used as ^X in this answer.
($__=()=())=>($___=()=(_))=>($____=()=(_=>_))=>($_____=()=(_=>_=>_))=>($______=()=(_=>_=>_=>_))=>($_______=()=(_=>_=>_=>_=>_))=>($________=()=(_=>_=>_=>_=>_=>_))=>($_________=()=(_=>_=>_=>_=>_=>_=>_))=>($__________=()=(_=>_=>_=>_=>_=>_=>_=>_))=>($___________=()=(_=>_=>_=>_=>_=>_=>_=>_=>_))=>($_=[]=>/./)=>(($____________=>$_____________=>$______________=>$_______________=>$________________=>$_________________=>$__________________=>$___________________=>$____________________=>$_____________________=>$______________________=>$_______________________=>$________________________=>$_________________________=>$__________________________=>$___________________________=>$____________________________=>$_____________________________=>$______________________________=>$_______________________________=>$________________________________=>$_________________________________=>$__________________________________=>$___________________________________=>$____________________________________=>$_____________________________________)=$&.._)=>($_=$^X=>/...$/=>$_=$&=>/./)=>(($__________________________________________=>$___________________________________________=>$____________________________________________=>$_____________________________________________=>$______________________________________________=>$_______________________________________________=>$________________________________________________=>$_________________________________________________=>$__________________________________________________=>$___________________________________________________=>$____________________________________________________=>$_____________________________________________________=>$______________________________________________________=>$_______________________________________________________=>$________________________________________________________=>$_________________________________________________________=>$__________________________________________________________=>$___________________________________________________________=>$____________________________________________________________=>$_____________________________________________________________=>$______________________________________________________________=>$_______________________________________________________________=>)=$&.._)=>($______________________________________=$__________________________________________&$______________________________________________________________)=>(($______________________________________=>$_______________________________________=>$________________________________________=>$_________________________________________=>)=$______________________________________.._)=>($_________________________________________________________________=$____________________________________________&(!$_________).$_________)=>($__________________________________________________________________=$______________.$__________________________.$_____________________________.$________________.$_________________________________________________________________.$__________________________________________.$___________________________________________________________.$______________________________________.$_________________________________________________.$_______________________________________.$______________________________________________________________.$_________________________________________________________.$__________________________________________.$________________________________________________________)=>($___________________________________________________________________=$______________.$__________________________.$_____________________________.$________________.$_________________________________________________________________.$_____________________________________________________.$______________________________________.$________________________________________.$________________________________________________)=>(&$__________________________________________________________________(&$___________________________________________________________________($______________.$__________.$___________=>$___.$___.$____=>$___.$___.$______=>$___.$__.$_______=>$___.$___.$__=>$___.$___.$________=>$_____.$____=>$___.$___.$_____=>$______.$_________=>$_____.$_____=>$_____.$______=>$_____.$___________=>$______.$____=>$______.$_____=>$______.$______=>$______.$_______=>$______.$__________=>$______.$___________=>$_______.$__=>$_______.$___=>$_______.$____=>$_______.$_____=>$_______.$______=>$_______.$_______=>$_______.$________=>$_______.$_________=>$_______.$__________=>$_______.$___________=>$________.$__=>$________.$_____=>$________.$______=>$________.$_______=>$________.$________=>$________.$_________=>$________.$__________=>$________.$___________=>$_________.$__=>$_________.$___=>$_________.$____=>$_________.$_____=>$_________.$______=>$_________.$_______=>$_________.$________=>$_________.$_________=>$_________.$__________=>$_________.$___________=>$__________.$__=>$__________.$___=>$__________.$____=>$__________.$_____=>$__________.$______=>$__________.$_______=>$__________.$________=>$__________.$_________=>$__________.$__________=>$__________.$___________=>$___________.$__=>$___________.$____=>$___________.$______=>$___________.$________=>$___________.$_________=>$___________.$__________=>$___________.$___________=>$___.$__.$__=>$___.$__.$___=>$___.$__.$____=>$___.$__.$_____=>$___.$__.$______=>$___.$__.$_______=>$___.$__.$________=>$___.$__.$_________=>$___.$__.$__________=>$___.$__.$___________=>$___.$___.$__=>$___.$___.$___=>$___.$___.$____=>$___.$___.$_____=>$___.$___.$______=>$___.$___.$_______=>$___.$___.$________=>$___.$___.$_________=>$___.$___.$__________=>$___.$___.$___________=>$___.$____.$__=>$___.$____.$___=>$___.$____.$____=>$___.$____.$_____=>$___.$____.$______=>$___.$____.$________=>$______.$_________)))

Try it online!
Explanation
This is a very restrictive set of characters, but the biggest problem I encountered was trying to get access to the lowercase letters.
First the numbers are set up and stored in $__ (0) to $___________ which was using lengths of lists to get the scalar numbers. Next target was to set up A to Z. To do this, $_ is set to [] which, in scalar context, evaluates to a string like ARRAY(0x123456789abc) so /./ sets $& to A which is then used in a range with _ ($&.._) which you can assign to many variables in list context (e.g. ($a, $b, $c) = a..c, but using long strings of _s for the names in this).
Next it's necessary to generate the lowercase letters to be able to call functions, this was pretty tricky and I'm using something that might be a little unfair as it can potentially change depending on the implementation. I did look at a few different ideas before settling on this one, I originally hoped to use __PACKAGE__ which returns main and would easily enable producing a.._, but I wasn't able to get it to work. With more patience maybe... But knowing that Perl stores the executable the program was invoked with in a special variable $^X ($\x18), which ends with perl on most of my tests on Linux, was a viable (if not entirely portable) solution. This provides access to e, via storing $^X in $_, matching /...$/, which would store erl in $&, storing this in $_, matching again /./ to store e in $& then, as was done for the uppercase letters, generating a range from e to _ and storing. To get access to a, it's necessary to perform another [stringwise operation of "e"&"y"] and generate the missing start of the alphabet as was done for the other letters.
To be able to call library functions it's necessary to generate :: (or ' which functions identically), fortunately ' can be generated via a stringwise AND operation of g&"7", but it's necessary to concatenate 7 with the empty string to cast to string so "g"&(!7).7 is used.
Now we have all the letters and ' which means we can call CORE::evalbytes (or any other functions in the CORE library), but we need to be able to generate characters we haven't pre-generated, so CORE::pack is used to generate a string by passing in a list of numbers and converting them to characters, that will be evaled producing the desired output.

J, cracks @xash's answer
(97)1!:2(4)
(117)1!:2(4)
(46)1!:2(4)

Try it online!
Gonna be honest, not entirely sure why this works. I was trying to learn J syntax and playing around with a few things, and I found that you can just send ASCII values to STDOUT and they get automatically converted into characters. Neat!

Wolfram Language (Mathematica), cracks att's answer
{69,99,95+9,111,64,68,116,91,48,32,38,32,93,1+9}//("Fr*ara*de"//Names//Tr//(x//Head))//("Prin"~~_//Names//Tr//(x//Head))

Try it online!

no need for 1+9, since Print already includes the trailing newline

05AB1E, cracks @SomoKRoceS's (other) answer
žEžwžv;;;++çžEžvžv;žv;;žv;;;;++++çžEžvžv;žv;;+++çžEžvžv;žv;;;;+++çžEžvžv;++çžzžxžwžvžv;žv;;žv;;;;++++++çžEžwžv;;žv;;;+++çžEžvžv;žv;;žv;;;++++çžwžv;;žv;;;žv;;;;+++çžwžv;;;+çžCžBžzžwžv;žv;;žv;;;;++++++çžwžv+çžwžvžv;;;;++çžwžvžv;;;++çžwžvžv;;;žv;;;;+++çžwžvžv;;++çžwžvžv;;žv;;;;+++çžwžvžv;;žv;;;+++çžwžvžv;;žv;;;žv;;;;++++çžwžvžv;++çžwžvžv;žv;;;;+++çJ

Try it online!
Incidentally, all this approach really needs to function is ç (cast top of stack to a character), J (join together the entire stack into a string), and some way of producing numbers on the stack. My original idea for the latter (since number literals are now banned) was to use T (push 10), then ; (divide by 2) to get a 1 (although that technically also needs ï, cast to int), and then adding that with itself as many times as necessary.
However, since the Unicode character values for this program are in the range of ~8000, this would make for very length source code. I made it a bit shorter by using the literals that push powers of two (žv through žH). Here's the Python script I used to create this:
lookup = {65536: "žH", 32768: "žG", 16384: "žF", 8192: "žE",
          4096: "žD", 2048: "žC", 1024: "žB", 512: "žA",
          256: "žz", 128: "žy", 64: "žx", 32: "žw", 16: "žv",
          8: "žv;", 4: "žv;;", 2: "žv;;;", 1: "žv;;;;"}

def make_value(target):
    if target in lookup:
        return lookup[target]
    use = max(k for k in lookup if k <= target)
    return lookup[use] + make_value(target - use) + "+"

goal = "•”“’‘Ž…„'\"ഭ0123456789"

source = "".join(make_value(ord(c)) + "ç" for c in goal) + "J"
print(source)

for c in goal:
    if c in source:
        print(f"Failed check for '{c}'")

Much, much simpler: ₂ÌR₂«©DÍÍ<D<DÍ<D<₆ÌX«®ÌÌDÍÍÍÍ₆Ì>₆Í₆>¬.ø)çJžhJ

Mornington Crescent, 5015 bytes, cracks Discrete lizard's answer
I've braved the depths of London, and I came out alive ...
Take Northern Line to Charing Cross
Take Northern Line to Moorgate
Take Circle Line to Moorgate
Take Circle Line to Paddington
Take Circle Line to Moorgate
Take Northern Line to Finchley Central
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross
Take Northern Line to Moorgate
Take Northern Line to Moorgate
Take Metropolitan Line to Chalfont & Latimer
Take Metropolitan Line to Moorgate
Take Northern Line to West Finchley
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross
Take Northern Line to Moorgate
Take Northern Line to Moorgate
Take Metropolitan Line to Chalfont & Latimer
Take Metropolitan Line to Preston Road
Take Metropolitan Line to Moorgate
Take Northern Line to Golders Green
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross
Take Northern Line to Moorgate
Take Northern Line to Moorgate
Take Metropolitan Line to Preston Road
Take Metropolitan Line to Moorgate
Take Northern 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
Take Circle Line to Paddington
Take Circle Line to Moorgate
Take Circle Line to Moorgate
Take Metropolitan Line to Chalfont & Latimer
Take Metropolitan Line to Moorgate
Take Northern Line to Morden
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross
Take Northern Line to Moorgate
Take Northern Line to Moorgate
Take Metropolitan Line to Chalfont & Latimer
Take Metropolitan Line to Preston Road
Take Metropolitan Line to Moorgate
Take Circle Line to Victoria
Take Circle 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 Metropolitan Line to Preston Road
Take Metropolitan Line to Moorgate
Take Metropolitan 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
Take Circle Line to Paddington
Take Circle Line to Moorgate
Take Northern Line to Kentish Town
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross
Take Northern Line to Tottenham Court Road
Take Northern Line to Tottenham Court Road
Take Central Line to Holland Park
Take Central Line to Fairlop
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
Take Northern Line to Tottenham Court Road
Take Northern Line to Tottenham Court Road
Take Central Line to Holland Park
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
Take Northern Line to Moorgate
Take Circle Line to Paddington
Take Circle Line to Moorgate
Take Circle Line to Paddington
Take Circle Line to Paddington
Take Circle Line to Mansion House
Take Circle Line to Moorgate
Take Circle Line to Moorgate
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross
Take Northern Line to Tottenham Court Road
Take Northern Line to Tottenham Court Road
Take Central Line to Holland Park
Take Central Line to Gants Hill
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
Take Northern Line to Tottenham Court Road
Take Northern Line to Tottenham Court Road
Take Central Line to Holland Park
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
Take Northern Line to Moorgate
Take Circle Line to Moorgate
Take Circle Line to Paddington
Take Circle Line to Paddington
Take Circle Line to Moorgate
Take Metropolitan Line to Moor Park
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
Take Metropolitan Line to Chalfont & Latimer
Take Metropolitan Line to Finchley Road
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
Take Metropolitan Line to Chalfont & Latimer
Take Metropolitan Line to Preston Road
Take Metropolitan Line to West Harrow
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
Take Metropolitan Line to Preston Road
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
Take Circle Line to Paddington
Take Circle Line to Moorgate
Take Circle Line to Moorgate
Take Northern Line to Mornington Crescent

Try it online!

Well done. This one still gives quite a few options. I shall dispose of those distractions for the next one.

Oh, no, there's more ...

BBC BASIC II, cracks Martin Rosenau's challenge
The string to print is
VP

Solution:
10 MODE 7
20 A%=HIMEM
30 ?A%=80
40 A%?1=86
50 GOTO 50

Tested on BeebEm emulator and should work directly on BBC model 'B'.

How?

MODE 7 is a low-resolution graphics mode, intended to display 'teletext'.  Each character on the display is encoded by a single byte in memory: bytes 1-128 encode the normal ASCII characters, and bytes 129-255 (which we don't need here) encode chunky coloured and/or flashing 2x6 pixel blocks.
So all we need to do is to set the first two bytes of the display memory to encode 'PV'
HIMEM is a system variable used to indicate the address of the highest usable RAM memory location +1; the display memory starts here.
? stores the specified value at a particular memory location.  It's equivalent to POKE in other variants of BASIC.  In this case, we specify the ASCII value 80, encoding the letter 'P'.
A%?1 is a shortcut to store the specified value to the memory location +1.  We use 86, encoding the letter 'V'
If we exit the program now, the first character will be overwritten by the new command-line prompt (a '>' character), so we just send the program into an endless loop so that the full beauty of the displayed 'PV' characters can remain on the screen for our admiration.
In the example shown, I exited the program by pressing 'Escape' so that I could display a LISTing of the program.

Ruby, @histocrat's answer, 48 bytes
STDOUT::write"\x70\x3c\x2e\x24%c%d\x64"%[97,3-2]

Try it online!
I had no idea you could call methods that way, until I read this answer (thanks @histocrat!)

Python 2, 39953 bytes, cracks Jonathan Allan's answer
exec(chr((id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id)))+chr((id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id)))+chr((id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id)))+chr((id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id)))+chr((id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id)))+chr((id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id)))+chr((id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id)))+chr((id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id)))+chr((id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id)))+chr((id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id)))+chr((id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id)))+chr((id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id)))+chr((id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id)))+chr((id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id)))+chr((id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id)))+chr((id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id)))+chr((id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id)))+chr((id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id)))+chr((id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id)))+chr((id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id)))+chr((id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id)))+chr((id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id)))+chr((id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id)))+chr((id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id)))+chr((id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id)))+chr((id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id)))+chr((id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id)))+chr((id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id)))+chr((id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id)))+chr((id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))+(id(id)-~-id(id))))

Try it online!

J, cracks @xash's answer
(tolower'TMOUTPUT')apply 117
(tolower'TMOUTPUT')apply 58
(tolower'TMOUTPUT')apply 46

Try it online!
Classic stdlib abuse. tmoutput is a wrapper for 1!:2&4 which was used in the previous crack. Since it contains u, I use the uppercased name, lowered with tolower and then eval-applied with apply.

R, 187 bytes, cracks Dominic van Essen's answer
n=pi*pi
d=F:n
`!`=ls
l=!n
i=n*n*pi-pi-pi-T-T
`?`=el
o=n+pi-T-T
t=n+pi-T
p=l?o
b=l?t
k=l?i
A=?letters
`!`=toupper
e=!letters?pi+pi-T
`+`=c
o=d+p+b+A+e
s=l?n*n*n-n-pi-T
`!`=get
`+`=!s
x=o+k

Try it online!
Random tricks:

liberal aliasing of functions to the builtin operators to get around (.
Uses ls(9) to get a list of all builtins in package:base, getting around the lack of apropos() -- this may not work on non-TIO platforms.
Uses el to get around [ since el(what,where)==what[where][[1]]
get is used to return a function given a string, in this case sapply.
uses sapply(output list,"cat") to print, since otherwise we have no way of specifying that sep="". The x= is just to suppress the output of NULL.
uses pi and T and arithmetic for indexing, and n=pi^2 for a close enough approximation to 9.

Very well done, Giuseppe!

Your solution is much shorter and neater than the one I had in mind when I set the challenge (now revealed).

Mornington Crescent, 15909 bytes, cracks Discrete lizard's second answer
The battle for London is on, and I have been proven as the victor
Take Northern Line to King's Cross St. Pancras
Take Victoria Line to Seven Sisters
Take Victoria Line to Victoria
Take Circle Line to Victoria
Take Circle Line to Cannon Street
Take Circle 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
Take District Line to Victoria
Take District Line to Mile End
Take District Line to Victoria
Take District Line to Victoria
Take Circle Line to Moorgate
Take Circle Line to Moorgate
Take Northern Line to Charing Cross
Take Northern Line to King's Cross St. Pancras
Take Northern Line to King's Cross St. Pancras
Take Circle Line to Cannon Street
Take Circle Line to King's Cross St. Pancras
Take Circle Line to King's Cross St. Pancras
Take Northern Line to Charing Cross
Take Northern Line to King's Cross St. Pancras
Take Northern Line to King's Cross St. Pancras
Take Circle Line to Cannon Street
Take Circle Line to King's Cross St. Pancras
Take Circle Line to Cannon Street
Take Circle Line to Westbourne Park
Take Circle Line to Victoria
Take Victoria Line to Seven Sisters
Take Victoria Line to Victoria
Take District Line to Mile End
Take District Line to Victoria
Take District Line to Mile End
Take District Line to Victoria
Take District Line to Victoria
Take Circle Line to Moorgate
Take Circle Line to Moorgate
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross
Take Northern Line to King's Cross St. Pancras
Take Circle Line to King's Cross St. Pancras
Take Circle Line to Cannon Street
Take Circle Line to King's Cross St. Pancras
Take Circle Line to Cannon Street
Take Circle Line to King's Cross St. Pancras
Take Circle Line to Cannon Street
Take Circle Line to King's Cross St. Pancras
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross
Take Northern Line to Bank
Take District Line to Plaistow
Take District Line to Victoria
Take Victoria Line to Seven Sisters
Take Victoria Line to Victoria
Take District Line to Mile End
Take District Line to Victoria
Take District Line to Mile End
Take District Line to Victoria
Take District Line to Victoria
Take Circle Line to Moorgate
Take Circle Line to Moorgate
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross
Take Northern Line to King's Cross St. Pancras
Take Circle Line to King's Cross St. Pancras
Take Circle Line to Cannon Street
Take Circle Line to King's Cross St. Pancras
Take Circle Line to Cannon Street
Take Circle Line to King's Cross St. Pancras
Take Circle Line to Cannon Street
Take Circle Line to King's Cross St. Pancras
Take Northern Line to Charing Cross
Take Northern Line to Bank
Take Circle Line to Bank
Take Circle Line to Paddington
Take Circle Line to Bank
Take Circle Line to Paddington
Take Circle Line to Bank
Take Northern Line to Charing Cross
Take Northern Line to Bank
Take Circle Line to Bank
Take Circle Line to Paddington
Take Circle Line to Bank
Take Northern Line to Charing Cross
Take Bakerloo Line to Stonebridge Park
Take Bakerloo Line to Oxford Circus
Take Bakerloo Line to Oxford Circus
Take Victoria Line to Victoria
Take Victoria Line to Seven Sisters
Take Victoria Line to Victoria
Take District Line to Mile End
Take District Line to Victoria
Take District Line to Mile End
Take District Line to Victoria
Take District Line to Victoria
Take Circle Line to Moorgate
Take Circle Line to Moorgate
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross
Take Northern Line to King's Cross St. Pancras
Take Circle Line to King's Cross St. Pancras
Take Circle Line to Cannon Street
Take Circle Line to King's Cross St. Pancras
Take Circle Line to Cannon Street
Take Circle Line to King's Cross St. Pancras
Take Circle Line to Cannon Street
Take Circle Line to King's Cross St. Pancras
Take Northern Line to Charing Cross
Take Northern Line to Bank
Take Circle Line to Bank
Take Circle Line to Paddington
Take Circle Line to Bank
Take Circle Line to Paddington
Take Circle Line to Bank
Take Northern Line to Charing Cross
Take Northern Line to Bank
Take Circle Line to Bank
Take Circle Line to Paddington
Take District Line to Parsons Green
Take District Line to Cannon Street
Take Circle Line to Victoria
Take Victoria Line to Seven Sisters
Take Victoria Line to Victoria
Take Circle Line to Victoria
Take Circle Line to Cannon Street
Take Circle Line to Bank
Take Circle Line to Bank
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross
Take Northern Line to Bank
Take Circle Line to Bank
Take Circle Line to Aldgate
Take Circle Line to Euston Square
Take Circle Line to Paddington
Take Circle Line to Bank
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross
Take Northern Line to Bank
Take Circle Line to Bank
Take Circle Line to Paddington
Take Circle Line to Paddington
Take Circle Line to Bank
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross
Take Northern Line to Bank
Take Circle Line to Bank
Take Circle Line to Paddington
Take District Line to Victoria
Take Victoria Line to Seven Sisters
Take Victoria Line to Victoria
Take District Line to Mile End
Take District Line to Victoria
Take District Line to Mile End
Take District Line to Victoria
Take District Line to Victoria
Take Circle Line to Moorgate
Take Circle Line to Moorgate
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross
Take Northern Line to King's Cross St. Pancras
Take Circle Line to King's Cross St. Pancras
Take Circle Line to Cannon Street
Take Circle Line to King's Cross St. Pancras
Take Circle Line to Cannon Street
Take Circle Line to King's Cross St. Pancras
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross
Take Northern Line to King's Cross St. Pancras
Take Circle Line to King's Cross St. Pancras
Take Circle Line to Cannon Street
Take Circle Line to King's Cross St. Pancras
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross
Take Northern Line to Bank
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross
Take Northern Line to Bank
Take Circle Line to Bank
Take Circle Line to Paddington
Take Circle Line to Bank
Take Circle Line to Paddington
Take Circle Line to Bank
Take Northern Line to Tooting Bec
Take Northern Line to Bank
Take Circle Line to Bank
Take District Line to Victoria
Take Victoria Line to Seven Sisters
Take Victoria Line to Victoria
Take District Line to Mile End
Take District Line to Victoria
Take District Line to Mile End
Take District Line to Victoria
Take District Line to Victoria
Take Circle Line to Moorgate
Take Circle Line to Moorgate
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross
Take Northern Line to King's Cross St. Pancras
Take Circle Line to King's Cross St. Pancras
Take Circle Line to Cannon Street
Take Circle Line to King's Cross St. Pancras
Take Circle Line to Cannon Street
Take Circle Line to King's Cross St. Pancras
Take Circle Line to Cannon Street
Take Circle Line to King's Cross St. Pancras
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross
Take Northern Line to Bank
Take Circle Line to Bank
Take Circle Line to Paddington
Take Circle Line to Paddington
Take Circle Line to Bank
Take Northern Line to Kennington
Take Northern Line to Bank
Take Circle Line to Bank
Take Circle Line to Victoria
Take Victoria Line to Seven Sisters
Take Victoria Line to Victoria
Take District Line to Mile End
Take District Line to Victoria
Take District Line to Mile End
Take District Line to Victoria
Take District Line to Victoria
Take Circle Line to Moorgate
Take Circle Line to Moorgate
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross
Take Northern Line to King's Cross St. Pancras
Take Circle Line to King's Cross St. Pancras
Take Circle Line to Cannon Street
Take Circle Line to King's Cross St. Pancras
Take Circle Line to Cannon Street
Take Circle Line to King's Cross St. Pancras
Take Circle Line to Cannon Street
Take Circle Line to King's Cross St. Pancras
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross
Take Northern Line to Bank
Take Circle Line to Bank
Take Circle Line to Paddington
Take District Line to Parsons Green
Take District Line to Cannon Street
Take Circle Line to Victoria
Take Victoria Line to Seven Sisters
Take Victoria Line to Victoria
Take Circle Line to Victoria
Take Circle Line to Cannon Street
Take Circle Line to Bank
Take Circle Line to Bank
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross
Take Northern Line to Bank
Take Circle Line to Bank
Take Circle Line to Baker Street
Take Circle Line to Blackfriars
Take Circle Line to Victoria
Take Victoria Line to Seven Sisters
Take Victoria Line to Victoria
Take District Line to Mile End
Take District Line to Victoria
Take District Line to Mile End
Take District Line to Victoria
Take District Line to Victoria
Take Circle Line to Moorgate
Take Circle Line to Moorgate
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross
Take Northern Line to King's Cross St. Pancras
Take Circle Line to King's Cross St. Pancras
Take Circle Line to Cannon Street
Take Circle Line to King's Cross St. Pancras
Take Circle Line to Cannon Street
Take Circle Line to King's Cross St. Pancras
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross
Take Northern Line to King's Cross St. Pancras
Take Circle Line to King's Cross St. Pancras
Take Circle Line to Cannon Street
Take Circle Line to King's Cross St. Pancras
Take Northern Line to Charing Cross
Take Northern Line to Bank
Take Circle Line to Bank
Take Circle Line to Paddington
Take Circle Line to Bank
Take Northern Line to Charing Cross
Take Northern Line to Bank
Take Circle Line to Bank
Take Circle Line to Paddington
Take Circle Line to Barbican
Take Circle Line to Victoria
Take Victoria Line to Seven Sisters
Take Victoria Line to Victoria
Take District Line to Mile End
Take District Line to Victoria
Take District Line to Mile End
Take District Line to Victoria
Take District Line to Victoria
Take Circle Line to Moorgate
Take Circle Line to Moorgate
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross
Take Northern Line to King's Cross St. Pancras
Take Circle Line to King's Cross St. Pancras
Take Circle Line to Cannon Street
Take Circle Line to King's Cross St. Pancras
Take Circle Line to Cannon Street
Take Circle Line to King's Cross St. Pancras
Take Circle Line to Cannon Street
Take Circle Line to King's Cross St. Pancras
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross
Take Northern Line to Bank
Take Circle Line to Bank
Take Circle Line to Paddington
Take Circle Line to Paddington
Take District Line to Southfields
Take District Line to Victoria
Take Victoria Line to Seven Sisters
Take Victoria Line to Victoria
Take District Line to Mile End
Take District Line to Victoria
Take District Line to Mile End
Take District Line to Victoria
Take District Line to Victoria
Take Circle Line to Moorgate
Take Circle Line to Moorgate
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross
Take Northern Line to King's Cross St. Pancras
Take Circle Line to King's Cross St. Pancras
Take Circle Line to Cannon Street
Take Circle Line to King's Cross St. Pancras
Take Circle Line to Cannon Street
Take Circle Line to King's Cross St. Pancras
Take Circle Line to Cannon Street
Take Circle Line to King's Cross St. Pancras
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross
Take Northern Line to Bank
Take Circle Line to Bank
Take Circle Line to Paddington
Take District Line to Parsons Green
Take District Line to Cannon Street
Take Circle Line to Victoria
Take Victoria Line to Seven Sisters
Take Victoria Line to Victoria
Take Circle Line to Victoria
Take Circle Line to Cannon Street
Take Circle Line to Bank
Take Circle Line to Bank
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross
Take Northern Line to Bank
Take Circle Line to Bank
Take Circle Line to Edgware Road
Take Circle Line to Bank
Take Circle Line to Wood Lane
Take Circle Line to Sloane Square
Take Circle Line to Paddington
Take Circle Line to Bank
Take Northern Line to Charing Cross
Take Northern Line to Bank
Take Circle Line to Bank
Take Circle Line to Paddington
Take Circle Line to Paddington
Take Circle Line to Bank
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross
Take Northern Line to Bank
Take Circle Line to Bank
Take Circle Line to Paddington
Take District Line to Victoria
Take Victoria Line to Seven Sisters
Take Victoria Line to Victoria
Take District Line to Mile End
Take District Line to Victoria
Take District Line to Mile End
Take District Line to Victoria
Take District Line to Victoria
Take Circle Line to Moorgate
Take Circle Line to Moorgate
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross
Take Northern Line to King's Cross St. Pancras
Take Circle Line to King's Cross St. Pancras
Take Circle Line to Cannon Street
Take Circle Line to King's Cross St. Pancras
Take Circle Line to Cannon Street
Take Circle Line to King's Cross St. Pancras
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross
Take Northern Line to King's Cross St. Pancras
Take Circle Line to King's Cross St. Pancras
Take Circle Line to Cannon Street
Take Circle Line to King's Cross St. Pancras
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross
Take Northern Line to Bank
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross
Take Northern Line to Bank
Take Circle Line to Bank
Take Circle Line to Paddington
Take Circle Line to Wood Lane
Take Circle Line to Paddington
Take Circle Line to Bank
Take Circle Line to Paddington
Take Circle Line to Paddington
Take Circle Line to Bank
Take Circle Line to Bank
Take Northern Line to Colindale
Take Northern Line to Bank
Take Circle Line to Bank
Take Circle Line to Victoria
Take Victoria Line to Seven Sisters
Take Victoria Line to Victoria
Take District Line to Mile End
Take District Line to Victoria
Take District Line to Mile End
Take District Line to Victoria
Take District Line to Victoria
Take Circle Line to Moorgate
Take Circle Line to Moorgate
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross
Take Northern Line to King's Cross St. Pancras
Take Circle Line to King's Cross St. Pancras
Take Circle Line to Cannon Street
Take Circle Line to King's Cross St. Pancras
Take Circle Line to Cannon Street
Take Circle Line to King's Cross St. Pancras
Take Circle Line to Cannon Street
Take Circle Line to King's Cross St. Pancras
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross
Take Northern Line to Bank
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross
Take Northern Line to Bank
Take Circle Line to Bank
Take Circle Line to Paddington
Take District Line to Parsons Green
Take District Line to Cannon Street
Take Circle Line to Victoria
Take Victoria Line to Seven Sisters
Take Victoria Line to Victoria
Take Circle Line to Victoria
Take Circle Line to Cannon Street
Take Circle Line to Bank
Take Circle Line to Bank
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross
Take Northern Line to Bank
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross
Take Northern Line to Bank
Take Circle Line to Bank
Take Circle Line to Paddington
Take Circle Line to Aldgate
Take Circle Line to Paddington
Take Circle Line to Baker Street
Take Circle Line to Paddington
Take Circle Line to Paddington
Take Circle Line to Edgware Road
Take Circle Line to Paddington
Take Circle Line to Paddington
Take Circle Line to Bank
Take Circle Line to Paddington
Take Circle Line to Bank
Take Circle Line to Bank
Take Northern Line to Mornington Crescent

I realized about 2/3 of the way through writing this program that I was using an inefficient approach and the code was about twice as long as it needed to be, but that doesn't matter since there's no value to short robber answers.
Try it online!

I was trying to solve this as well (first time dealing with Mornington Crescent) but didn't succeeded to get even close to the solution. Please let me know if I'm wrong, but the only operations that remained were integer division , bitwise NOT, parse string to integer, 7, character <-> codepoint, string concat, right substring, if, pop, exit. And my approach was getting into the codepoints of the characters using capital characters of stations. (1/2)

But since the capital letters are lower than small letters, and I didn't had tools for incrementing my value or concatenate numbers (because they are not strings), I didn't manage to get to those codepoints. Can you please explain the general idea how to get to those codepoints with only the stations remaining? I probably have missed something. Thanks :) (2/2)

Sure. First, I generated a 2, by taking a C from Charing Cross and dividing it by a space (the seventh-to-last character in "Cannon Street"). Then, I took a bunch of other stations, took the seventh-to-last character of their names, converted it to an integer, and divided it by two, and converted it back to a string, producing stringified digits. I concatenated 3 different stringified digits to make a stringified three-digit number, interpreted it as a base-10 integer using Parsons Green, divided it by 7 (although I think this last step is unnecessary), to produce the right codepoint.

And I had to repeat this process four times, once for each character, making the code very long (but very repetitive)

After dividing the character by two, you got the codepoints of "0"-"9" am I right? If so, Charing Cross is the station you used to get the stringified digits?  (Because for some reason I got an error trying to use Charing with characters other than [A-Za-z]. Maybe I did something else wrong)

Yes, you understand me correctly. No idea why Charing Cross on your interpreter is giving an error. It works both for me locally and on TIO.

I'll try it again. Thank you :)

Your attack was... inelegant. But, as you note, this is ultimately irrelevant by the laws of the land, and I admit defeat.

@SomoKRoceS There is quite a bit of ambiguity in the language spec here that interpreters likely deal with as in their host language. For example, if the integer on Mile End is longer than the string length, I would consider this to be index 'out of range' in most languages. However, Python 3 does not give a runtime error on "example"[-100:] and neither does the linked interpreter with example and 100 on Mile End.

JavaScript, cracks PkmnQ's third answer
Outputs a string via console.log. You can evaluate arbitrary code with only a little extra work. Should work in any sufficiently modern JavaScript implementation; /_/.prototype.unicode must be false (true would work with minor modifications).
Try it online!
The code is too big to include directly. Here's the Python code I used to generate it.
#!/usr/bin/env python3

import re

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

zero = '~~[]' # 0
one = '~[]/~[]' # 1

def plus_one(n):
    return '~[%s][~~[]]/~[]' % (n,)
def unary_integer(n):
    assert(n >= 0)
    if n == 0:
        return zero
    s = one
    while n > 1:
        n = n - 1
        s = plus_one(s)
    return s
def integer_string(n):
    if n <= 9:
        return '`${' + unary_integer(n) + '}`'
    else:
        return ''.join(['${' + unary_integer(int(digit)) + '}'
                              for digit in str(n)])
def integer(n):
    if n <= 9:
        return unary_integer(n)
    else:
        return '`' + integer_string(n) + '`/~[]/~[]'

# Map a character to how it can be inserted in `...`
characters = {}

def encode_string(s):
    return ''.join(['`'] + [characters[c] for c in s] + ['`'])

def encode_string_literal(m):
    return encode_string(m.group(1))

def encode_string_literals(code):
    return re.sub(r'"([^"]*)"', encode_string_literal, code)

permitted_characters = (frozenset(''.join(map(chr, range(32, 127))))
                        .difference(payload))
for c in permitted_characters:
    characters[c] = c
characters['`'] = '\\`'
characters['$'] = '\\$'
characters['\\'] = '\\\\'
for c in range(10):
    characters[str(c)] = '${' + unary_integer(c) + '}'

def add_characters(raw_code, result):
    encoded_code = encode_string_literals(raw_code)
    for i in range(len(result)):
        this_code = '${`${%s}`[%s]}' % (encoded_code, integer(i))
        if result[i] not in characters or len(result[i]) > len(this_code):
            characters[result[i]] = this_code

add_characters('[][[]]', 'undefined')
add_characters('{}', '[object Object]')
add_characters('[]/[]', 'NaN')
add_characters('~[]/[]', '-Infinity')
add_characters('/$/["unicode"]', 'false') # +'ls'
add_characters('``["includes"]``', 'true') # +'r'
add_characters('``["fontcolor"]``', '<font color=""></font>') # +'"<=>'
add_characters('``["constructor"]', 'function String() { [native code] }') # +'()Sgv'
add_characters('~[~[~[]/~[]][~~[]]/~[]][~~[]]/~[~[]/~[]][~~[]]', '1.5') # +'.'

eval_prefix = encode_string_literals('[]["find"]["constructor"]`_${')
eval_suffix = '}```'
def eval_with_function(code):
    return eval_prefix + encode_string(code) + eval_suffix

def octal_string(s):
    return ''.join('\\%03o' % (ord(c),) for c in s)

print(eval_with_function('console.log("%s")' % (octal_string(payload),)))

The basic principle is the same as JSFuck: build integers, then build some strings containing interesting characters, extract the characters from the strings, and assemble those characters to get an “eval” gadget. Leverage automatic coercions to integers and strings. Due to the different character set, the details of the building steps are different.
A lot of things coerce to 0 when a number is expected, for example []. To get a number, we need to force a coercion to a number, which we can do with the bitwise negation operator ~, so the easiest integer to build is -1 = ~[]. Then 0 = ~~[]. Signed integers are represented with two's complement, so ~x = -x-1 and thus x+1 = ~x/-1. We actually need to apply this plus-one operation to an expression that has a lower precedence than the ~ operator, so we need to simulate parentheses: plus-one is ~[…][0]/-. Armed with 0 and plus-one, we can build all integers in unary.
As a shortcut, we'll use the decimal representation for numbers above 9. This is our first use of template literals, which this character set supports fully. Template literals are string literals written between backticks, with ${…} to inject expressions. This lets us concatenate strings without +. For example a 2-digit integer is `${digit1}${digit2}`/-1/-1. When the goal is to inject the integer into a string, we don't need the /-1/-1 part.
Next we build some strings. JSFuck provides some inspiration. For example, {} stringifies to [object Object]. Here we can't use + to coerce to a string, but we can use a template literal: for example `${{}}` evaluates to the string [object Object]. We can extract individual characters from a string as string[index].
The normal way to access a property of an object is object.property, but . is forbidden. Fortunately there's another way which not only permitted, but also allows using a constructed string as the property name: object["property"] is equivalent to object.property. Looking through built-in types for which we can build a value (Array [], Object {}, Number [~[]][~~[]], String ``, RegExp /$/), the pickings are slim at this point:
Array.prototype.concat()
Array.prototype.find()
Array.prototype.join()
RegExp.prototype.unicode
String.prototype.concat()

Fortunately /_/.unicode is false, which gives us l and s, which unlocks the String method includes, which gives us true. The string representation of a method gives us parentheses, and the exotic but convenient fontcolor provides "<=>.
At this point we have a variation of the classic eval gadget from JSFuck: first we take a reference to a method such as []["find"]. Its constructor []["find"]["constructor"] is Function, and calling Function with a string argument evaluates that string as the body of a function. We have the characters of return, so we can make the function return the value of any expression that we can spell as a string.
There's one more hurdle here: unlike JSFuck, we don't have parentheses. This is where we use another feature of templates: if you put a function just before a template literal, with no punctuation involved except for the template literal, it's called on the interpolated expressions from the template. The arguments have to be strings, but that's good enough for us. To evaluate the string code we call Function on the code to build the function and call that code with an empty string as an argument: Function `_${`return ${code}`}` `` .
At this point we can spell console.log("…"). We're allowed to use backslashes, so we can put octal escapes in … and print an arbitrary string. The backslashes are just a shortcut: without them, we could still build fromCharCode as in JSFuck. If we wanted an arbitrary eval gadget, we could do another round of evaluation.

Python 3, 552040 bytes, cracks M Virts' second answer
getattr(__builtins__,str().join(chr(e)for e in((not not...).__sub__((not...).__sub__(not not...)).__sub__((not...).__sub__(not not...)).__sub__((not...)...
Try it online!
Truncated here because of SE limitations. The TIO link has the full version, or you can see it as a gist.

not... (... is a special sentinal value in Python, and it's truthy) gives False which is equivalent to 0
not not... gives True which is equivalent to 1
we can't use + or __add__, so to get an integer we use 0-(-1)-... or (not...).__sub__((not...).__sub__(not not...))...

Other than that, it's the same method as Wheat Wizard's crack for the previous one, but a lot longer. I'm pretty sure this isn't an intended crack, since it's so similar. It could be shortened, but this isn't code-golf.
The program was generated using this script:
def get_int(a):
    return "(not not...)" + ".__sub__((not...).__sub__(not not...))" * (a - 1)

def get_str(s):
    return "str().join(chr(e)for e in(" + ",".join(get_int(ord(e)) for e in s) + ",))"

print("getattr(__builtins__," + get_str("exec") + ")(" + get_str(r"""print(end='\t\n\x0b\f\r\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f!"#$%&\'*+-/0123456789:;?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^`dkpqvwxyz{|}~\x7f')""") + ")")

International Phonetic Esoteric Language, cracks @bigyihsuan's answer
{32}χu{33}χu{34}χu{35}χu{36}χu{37}χu{38}χu{39}χu{40}χu{41}χu{42}χu{43}χu{44}χu{45}χu{46}χu{65}χu{66}χu{67}χu{68}χu{69}χu{70}χu{71}χu{72}χu{73}χu{74}χu{75}χu{76}χu{77}χu{78}χu{79}χu{80}χu{81}χu{82}χu{83}χu{84}χu{85}χu{86}χu{87}χu{88}χu{89}χu{90}χu{91}χu{92}χu{93}χu{94}χu{95}χu{96}χu

To my knowledge, the only way to test this is with the interpreter here.

R, 209 bytes, cracks Robin Ryder's answer
dput(intToUtf8(c(59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,86,87,88,89,90,91,92,93,94,95,96,97,98,101,103,104,106,107,108,109,113,114,115,118,119,120,121,122,123,124,125,126)))

Try it online!
Found the right output function dput by using apropos on the remaining alphabet characters. dput also happens to be a key element of an R quine.

Well done! Would it have been more difficult if I had included fewer characters, to make apropos less useful?

@RobinRyder probably! It certainly would have taken me a lot longer to golf on my phone, since it'd be harder to try the larger range of functions, but I guess then the only barrier still would have been time.

C, cracks xibu's answer
#include <stdio.h>

int main(void) <%
  if (printf("%c%c", 123, 59)) <% %>
%>

For some reason, you can use <% instead of { in C. You can also use printf inside an if block to avoid having a single statement with a semicolon.
Try it online!

The <% is a legacy feature since not all machines had {} iirc.  However today it seems a bit absurd.

Yes, that was my solution as well. Older Keyboard didn't have some special characters like { an so digraphs were introduced as alternatives for them.

@user Here's the relevant page on cppreference: https://en.cppreference.com/w/c/language/operator_alternative

Python 2, cracks @Mukundan314's answer
C="%x"%12
D="%x"%13
S="73"
S=getattr(*([S]+[D+"e"+C+"o"+D+"e"]))
S=S("hex")
W="77"
W=getattr(*([W]+[D+"e"+C+"o"+D+"e"]))
W=W("hex")
P1=__import__(S+"y"+S)
P2=getattr(*([P1]+[S+"t"+D+"out"]))
P3=getattr(*([P2]+[W+"rite"]))
P4="63646e7376772"+C
P5=getattr(*([P4]+[D+"e"+C+"o"+D+"e"]))
P6=P5("hex")
P3(P6)

Try it online!
Explanation: First, we can immediately figure out what builtins we have available to us with the following snippet:
for b in dir(__builtins__):
  if not any(c in b for c in "cdnsvw,"):
    print(b)

Of immediate interest is getattr. My original approach used this along with eval, but then I realized that v was banned... (c is also banned so no exec). In any case, as long as we can get arbitrary characters and we have getattr, it's game over. Of course, no c, so no chr, so how do we get arbitrary letters? Indexing into dir() is out too, because we don't have access to d.
Well, Python 2 has this neat trick where you can decode hex strings by simply doing str.decode("hex"). "decode" requires both "c" and "d", so we need to get those characters first, but fortunately they're hex digits, so we can just retrieve them with "%x"%12 and "%x"%13, respectively (Note: the reason we can do this here, but not to get dir is because decode is an attribute of strings, which we can get, whereas dir is an attribute of __builtins__, which we can't get because of the s).
The last trick is to evade , in our getattr calls, which we can do by using arg expansion on a list, which we construct by adding lists together: getattr(a,b) <=> getattr(*([a]+[b])). From here we just chain together these primitives. Translated, the answer looks like:
__import__("sys").stdout.write("63646e7376772".decode("hex"))

You can use octal codes to write "something" as "\163\157\155\145\164\150\151\156\147" etc. eliminating the need for decode. The intended solution has a very similar approach.

Ah, thanks for the tip. Nice intended solution! Good to know I wasn't too far off, though.

PicoLisp, cracks @Wezl's answer
Yes, it was indeed simple! First time I heard about PicoLisp!
[prinl [char 40]][bye]

It seems to work on https://www.jdoodle.com/execute-picolisp-online/ with version 18.9.5.

I didn't knew ideone had PicoList prior to posting this, but, someone raised objections due to the output being : ( and not just (.
The : is the prompt for the tool used.
You can verify it in this ideone link: https://ideone.com/4vuYQL (it uses version 18.12.27).

Yes! Exactly. I was hoping someone would try out picolisp. See if you can do it without spaces. (ideone.com doesn't need [bye] at the end, and prin works as well as prinl)

@Wezl I believe it is a lot better if you post the intended solution on https://codegolf.stackexchange.com/a/207691/ (as per the definitions of the challenge, quoting: "A crack need only work not be the intended solution."). But it's good to see you confirming my solution as a working one.

The output is : (, not (.

The output is (, the prompt is :. Check https://ideone.com/4vuYQL (I didn't knew before that ideone had Picolisp, which is why I didn't use it before).

On my machine and on jdoodle, the output is : (. I know that the : is meant as a prompt, but it's part of what the program prints to stdout. The ideone implemetation is a correct solution.

Java, cracks MCross's answer
class Puzzle {
  public static void main(String[] args) throws Throwable {
    try (AutoCloseable a = new Throwable() {
        {
            setStackTrace(new StackTraceElement[0]);
        }
        @Override
        public String toString() {
            return "" + (char)(46) + (char)(92);
        }
    }::printStackTrace) {}
  }
}

All the credit goes to @nthistle, who found this resource, which I shamelessly copied.
It uses a method reference to override AutoCloseable's close method, which gets invoked at the end of a try-with-resources block. The toString method contains the actual message, and the setStackTrace part ensures it doesn't print the actual stacktrace afterwards.

JavaScript (Browser) (3709 bytes), cracks @Sparkles the Unicorn's answer
-693 bytes thanks to Bubbler's suggestion to use String.fromCharCode only once
console.log(String.fromCharCode(((+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[]))*([+!+[]]+[+[]])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[]))+String.fromCharCode(((+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[]))*([+!+[]]+[+[]])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[]))+String.fromCharCode(((+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[]))*([+!+[]]+[+[]])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[]))+String.fromCharCode(((+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[]))*([+!+[]]+[+[]])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[]))+String.fromCharCode(((+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[]))*([+!+[]]+[+[]]))+String.fromCharCode(((+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[]))*([+!+[]]+[+[]])+(+!+[]))+String.fromCharCode(((+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[]))*([+!+[]]+[+[]])+(+!+[])+(+!+[]))+String.fromCharCode(((+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[]))*([+!+[]]+[+[]])+(+!+[])+(+!+[])+(+!+[]))+String.fromCharCode(((+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[]))*([+!+[]]+[+[]])+(+!+[])+(+!+[])+(+!+[])+(+!+[]))+String.fromCharCode(((+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[]))*([+!+[]]+[+[]])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[]))+String.fromCharCode(((+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[]))*([+!+[]]+[+[]])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[]))+String.fromCharCode(((+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[]))*([+!+[]]+[+[]])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[]))+String.fromCharCode(((+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[]))*([+!+[]]+[+[]])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[]))+String.fromCharCode(((+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[]))*([+!+[]]+[+[]])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[]))+String.fromCharCode(((+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[]))*([+!+[]]+[+[]]))+String.fromCharCode(((+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[]))*([+!+[]]+[+[]])+(+!+[]))+String.fromCharCode(((+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[]))*([+!+[]]+[+[]])+(+!+[])+(+!+[]))+String.fromCharCode(((+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[]))*([+!+[]]+[+[]])+(+!+[])+(+!+[])+(+!+[])+(+!+[]))+String.fromCharCode(((+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[]))*([+!+[]]+[+[]])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[]))+String.fromCharCode(((+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[]))*([+!+[]]+[+[]])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[]))+String.fromCharCode(((+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[]))*([+!+[]]+[+[]])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[]))+String.fromCharCode(((+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[]))*([+!+[]]+[+[]])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[]))+String.fromCharCode(((+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[]))*([+!+[]]+[+[]])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[]))+String.fromCharCode(((+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[]))*([+!+[]]+[+[]]))+String.fromCharCode(((+!+[])+(+!+[])+(+!+[])+(+!+[]))*([+!+[]]+[+[]])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[]))+String.fromCharCode(((+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[]))*([+!+[]]+[+[]]))+String.fromCharCode(((+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[]))*([+!+[]]+[+[]])+(+!+[]))+String.fromCharCode(((+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[]))*([+!+[]]+[+[]])+(+!+[])+(+!+[]))+String.fromCharCode(((+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[]))*([+!+[]]+[+[]])+(+!+[])+(+!+[])+(+!+[]))+String.fromCharCode(((+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[]))*([+!+[]]+[+[]])+(+!+[])+(+!+[])+(+!+[])+(+!+[]))+String.fromCharCode(((+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[]))*([+!+[]]+[+[]])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[]))+String.fromCharCode(((+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[]))*([+!+[]]+[+[]])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[]))+String.fromCharCode(((+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[]))*([+!+[]]+[+[]])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[]))+String.fromCharCode(((+!+[])+(+!+[])+(+!+[])+(+!+[]))*([+!+[]]+[+[]])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])+(+!+[])))

Try it online!
No numbers? No problem! Also, note the suspicious lack of C and S in the output string. This immediately clued me in to String.fromCharCode – the only problem is how to produce numbers, since all number literals are banned. Fortunately, JavaScript has some really awful type juggling, so you can produce the number 3, for instance, like (+!+[])+(+!+[])+(+!+[]).
In practice, as long as ()+[]! are all allowed, you can just use JSFuck to convert the whole thing, but it really inflates the size (the version of my answer wouldn't fit in this post), and no C and S made me assume that String.fromCharCode was the intended solution anyways. I did borrow the literals for 1 and 10 in order to construct my character codes, though.

I think you could make it shorter by using String.fromCharCode only once, as it can take multiple values at once (TIO).

Oh neat, I didn't know that. I updated the answer, but it's definitely nowhere close to optimal -- I have tons of extra parentheses floating around, and there's shorter ways to express say, 65, than (1+1+1+1+1+1)*(10)+(1+1+1+1+1).

Ruby, cracks Dingus's third answer
ZERO = $$ - $$
S_ZERO = String ZERO
ONE = -~ZERO
S_ONE = String ONE
S_TWO = String ONE + ONE
S_THREE = String ONE + ONE + ONE
S_FOUR = String ONE + ONE + ONE + ONE
S_FIVE = String ONE + ONE + ONE + ONE + ONE
S_SIX = String ONE + ONE + ONE + ONE + ONE + ONE
S_SEVEN = String ONE + ONE + ONE + ONE + ONE + ONE + ONE
S_EIGHT = String ONE + ONE + ONE + ONE + ONE + ONE + ONE + ONE
S_NINE = String ONE + ONE + ONE + ONE + ONE + ONE + ONE + ONE + ONE

S_TWO_POINT_ZERO = String Float ONE + ONE
S_TWO_POINT_ZERO =~ /#{Array Float ONE}/
DOT = $&

$alakazam_hrto_s = nil
$_ = String global_variables
$_ =~ /#{DOT}#{DOT}/
$& =~ /#{DOT}$/
COLON = $&
$_ =~ /#{DOT}#{DOT}#{COLON}/
$& =~ /#{DOT}#{DOT}$/
$& =~ /#{DOT}/
SPACE = $&
$_ =~ /alakazam_#{DOT}#{DOT}#{DOT}#{DOT}#{DOT}#{DOT}/
$_ = $&
$_ =~ /#{DOT}#{DOT}#{DOT}#{DOT}$/
S_to_s = $&
$_ =~ /#{DOT}#{DOT}#{DOT}#{DOT}#{DOT}#{DOT}$/
$& =~ /#{DOT}#{DOT}/
$_ = eval S_ONE + S_TWO + DOT + S_to_s + SPACE + S_ONE + S_SIX
DOT_CHR = DOT + $_ + $&

f_out = eval S_ONE + S_ONE + S_TWO + DOT_CHR
f_out += eval S_ONE + S_ONE + S_SEVEN + DOT_CHR
f_out += eval S_ONE + S_ONE + S_SIX + DOT_CHR
f_out += eval S_NINE + S_NINE + DOT_CHR
f_out += SPACE

eval f_out + S_NINE + S_NINE
eval f_out + S_ONE + S_ZERO + S_ZERO
eval f_out + S_ONE + S_ONE + S_TWO
eval f_out + S_FOUR + S_EIGHT
eval f_out + S_FOUR + S_NINE
eval f_out + S_FIVE + S_ZERO
eval f_out + S_FIVE + S_ONE
eval f_out + S_FIVE + S_TWO
eval f_out + S_FIVE + S_THREE
eval f_out + S_FIVE + S_FOUR
eval f_out + S_FIVE + S_FIVE
eval f_out + S_FIVE + S_SIX
eval f_out + S_FIVE + S_SEVEN
eval f_out + S_FOUR + S_SIX
eval f_out + S_NINE + S_SIX
eval f_out + S_THREE + S_NINE
eval f_out + S_THREE + S_FOUR
eval f_out + S_SIX + S_THREE
eval f_out + S_THREE + S_SEVEN
eval f_out + S_FOUR + S_ZERO
eval f_out + S_NINE + S_ONE
eval f_out + S_FIVE + S_EIGHT
eval f_out + S_SIX + S_ZERO

Try it online!
Looking at the character set, we can call eval and we have the + operator to concatenate strings. So if we can build arbitrary one-character strings, we're done. In Ruby, creating a character from its numeric code is 123.chr, but we don't have . or c.
I browsed through the list of global variables and predefined functions to see what interesting things I could use given the available characters.
We don't have digits, but since we have arithmetic operators, that's just a minor annoyance. We create variables containing each digit as a string, for later.
Our next objective is to have a way to extract a specific character from a string, without the […] subscript operator. Almost every interesting action on a string is a (non-operator) method call, which is impossible without .. We can do regexp matching. string =~ /./ puts the first character of the string in $&, and string =~ /.$/ puts the last character in $&, but we don't have .. Let's build ..
We can take a floating point number and convert it to a string with String. But we still don't know how to extract the . from that string. There's another way to match a single character in a regexp without simply listing this character, and that's character sets: can we somehow inject [something.somethingelse] into the regexp? Yes! We can inject the value of an expression (converted to a string) with /#{expression}/. And we can build a string surrounded by brackets by building an array, which is represented as [element, ...] as a string. Match "2.0" against /[1.0]/, and we get "." in $&. Now we can extract an arbitrary character from a string with one or two regexp matches (/#{DOT}…#{DOT}/ then /#{DOT}$/ to take the Nth character, or /#{DOT}…#{DOT}$/ then /#{DOT}/ to take the Nth character from the end).
Our next objective is to construct the string ".chr", after which we can construct arbitrary characters as e.g. eval "1" + "2" + "3" + ".chr". We can have hr in the source code but we need to inject them into a string, and we need to get chr from somewhere. A convenient way to inject letters into a string is global_variables, which converts to a string that looks like
[…, :$alakazam_hrto_s, …]

So define a global variable containing hr, add a unique pattern (alakazam_) to anchor it, and match /alakazam_../ against String global_variables. While we're at it, use regexp matching to get ":" and " ", and also "to_s". We can now evaluate "12.to_s 16" to get "c" (hexadecimal representation of 12).
Now that DOT_CHR is ".chr", assemble f_out = "putc", and print the desired characters one by one given their numeric code.

This is really awesome, and much closer to what I had in mind. There are still some interesting differences though: I hadn't considered regexp interpolation and I knew I should have banned r! You also reminded me about $$, which makes banning digits redundant. So if you're not bored of this yet, I think I can make it even more rigid with a lower score.

Python 3.7, cracks water_ghosts's answer
import timeit,base64
class A:__class_getitem__=str.lower
class B:__class_getitem__=timeit.repeat
B[A["IMPORT SYS;PRINT('(NUVWXY');SYS.EXIT()"]]

Try it online
I set myself the additional challenge of golfing the solution. I tried a number of different approaches before settling on this one to minimize length; here are the ones that ended up working.
import timeit,base64
class A:__class_getitem__=base64.b32decode.__call__
class B:__class_getitem__=timeit.repeat
a=A["NFWXA33SOQQHG6LTBJYHE2LOOQUCOKDOOV3HO6DZE4UTW43ZOMXGK6DJOQUCS==="]
class C:__class_getitem__=a.decode.__call__
B[C["U8"]]

import timeit,base64
class A:__class_getitem__=chr
class B:__class_getitem__=timeit.repeat
B[A[105]+A[109]+A[112]+A[111]+A[114]+A[116]+A[32]+A[115]+A[121]+A[115]+A[10]+A[112]+A[114]+A[105]+A[110]+A[116]+A[40]+A[39]+A[40]+A[110]+A[117]+A[118]+A[119]+A[120]+A[121]+A[39]+A[41]+A[59]+A[115]+A[121]+A[115]+A[46]+A[101]+A[120]+A[105]+A[116]+A[40]+A[41]]

Your top answer uses a w in str.lower, but the others work. Nice job! Let's see if I can make a new version that blocks the timeit library...

A simpler answer.

@water_ghosts I totally didn't notice the w in the first one, thanks for pointing that out

Arn, 216 bytes, cracks @ZippyMagician's answer
one:3/3
two:(one+one)
four:(two+two)
five:(four+one)
six:(five+one)
seven:(six+one)
zero:(one-one)
[one five one two five one seven seven zero four one seven zero seven six four zero two zero zero zero zero zero]:|""

Try it!
Forming digits is easy enough since we still have access to 3, 8, and 9, as well as mathematical operations. We create an array containing the necessary digits and then join with the empty separator "" using the infix :|. Gotchas are (i) the surprisingly low precedence of + and - and (ii) the use of spaces (rather than commas) to separate array elements.
In the comments on the cop, @mypronounismonicareinstate suggested 9/9+9/9+9/9+9/9+... as a possible crack. This approach works in theory but not in the online interpreter, which switches over to scientific notation once the sum reaches 1e21.

Nice job! If I ever do another one I’ve got to remember to print all of the digits so it isn’t so easy :)

Python 3, 8065 bytes, Cracks M Virts' third answer
print(f'''{chr(len('ccccccccc'))}{chr(len('cccccccccc'))}{chr(len('ccccccccccc'))}{chr(len('cccccccccccc'))}{chr(len('ccccccccccccc'))}{chr(len('cccccccccccccc'))}{chr(len('ccccccccccccccc'))}{chr(len('cccccccccccccccc'))}{chr(len('ccccccccccccccccc'))}{chr(len('cccccccccccccccccc'))}{chr(len('ccccccccccccccccccc'))}{chr(len('cccccccccccccccccccc'))}{chr(len('ccccccccccccccccccccc'))}{chr(len('cccccccccccccccccccccc'))}{chr(len('ccccccccccccccccccccccc'))}{chr(len('cccccccccccccccccccccccc'))}{chr(len('ccccccccccccccccccccccccc'))}{chr(len('cccccccccccccccccccccccccc'))}{chr(len('ccccccccccccccccccccccccccc'))}{chr(len('cccccccccccccccccccccccccccc'))}{chr(len('ccccccccccccccccccccccccccccc'))}{chr(len('cccccccccccccccccccccccccccccc'))}{chr(len('ccccccccccccccccccccccccccccccc'))}{chr(len('cccccccccccccccccccccccccccccccc'))}{chr(len('ccccccccccccccccccccccccccccccccc'))}{chr(len('cccccccccccccccccccccccccccccccccc'))}{chr(len('ccccccccccccccccccccccccccccccccccc'))}{chr(len('cccccccccccccccccccccccccccccccccccc'))}{chr(len('ccccccccccccccccccccccccccccccccccccc'))}{chr(len('cccccccccccccccccccccccccccccccccccccc'))}{chr(len('cccccccccccccccccccccccccccccccccccccccccc'))}{chr(len('ccccccccccccccccccccccccccccccccccccccccccc'))}{chr(len('ccccccccccccccccccccccccccccccccccccccccccccc'))}{chr(len('cccccccccccccccccccccccccccccccccccccccccccccc'))}{chr(len('ccccccccccccccccccccccccccccccccccccccccccccccc'))}{chr(len('cccccccccccccccccccccccccccccccccccccccccccccccc'))}{chr(len('ccccccccccccccccccccccccccccccccccccccccccccccccc'))}{chr(len('cccccccccccccccccccccccccccccccccccccccccccccccccc'))}{chr(len('ccccccccccccccccccccccccccccccccccccccccccccccccccc'))}{chr(len('cccccccccccccccccccccccccccccccccccccccccccccccccccc'))}{chr(len('ccccccccccccccccccccccccccccccccccccccccccccccccccccc'))}{chr(len('cccccccccccccccccccccccccccccccccccccccccccccccccccccc'))}{chr(len('ccccccccccccccccccccccccccccccccccccccccccccccccccccccc'))}{chr(len('cccccccccccccccccccccccccccccccccccccccccccccccccccccccc'))}{chr(len('ccccccccccccccccccccccccccccccccccccccccccccccccccccccccc'))}{chr(len('cccccccccccccccccccccccccccccccccccccccccccccccccccccccccc'))}{chr(len('ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc'))}{chr(len('cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc'))}{chr(len('ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc'))}{chr(len('cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc'))}{chr(len('ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc'))}{chr(len('cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc'))}{chr(len('ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc'))}{chr(len('cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc'))}{chr(len('ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc'))}{chr(len('cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc'))}{chr(len('ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc'))}{chr(len('cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc'))}{chr(len('ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc'))}{chr(len('cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc'))}{chr(len('ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc'))}{chr(len('cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc'))}{chr(len('ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc'))}{chr(len('cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc'))}{chr(len('ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc'))}{chr(len('cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc'))}{chr(len('ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc'))}{chr(len('cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc'))}{chr(len('ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc'))}{chr(len('cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc'))}{chr(len('ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc'))}{chr(len('cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc'))}{chr(len('ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc'))}{chr(len('cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc'))}{chr(len('ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc'))}{chr(len('cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc'))}{chr(len('ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc'))}{chr(len('cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc'))}{chr(len('ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc'))}{chr(len('cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc'))}{chr(len('ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc'))}{chr(len('cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc'))}{chr(len('ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc'))}{chr(len('cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc'))}{chr(len('ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc'))}{chr(len('cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc'))}{chr(len('cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc'))}{chr(len('ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc'))}{chr(len('cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc'))}{chr(len('ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc'))}{chr(len('ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc'))}{chr(len('ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc'))}{chr(len('ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc'))}{chr(len('ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc'))}{chr(len('ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc'))}{chr(len('cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc'))}{chr(len('ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc'))}{chr(len('cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc'))}{chr(len('ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc'))}{chr(len('cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc'))}{chr(len('cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc'))}{chr(len('cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc'))}{chr(len('ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc'))}''')

Try it online!
Pretty self-explanatory. chr(len('')) is used to convert the length of an arbitrary string to its ASCII character, and f-strings are used to join them.

Nice! Almost cracked, if you take out the new lines in your code it will be good to go. Works just like the original

Haha oh wait there are only new lines in the tio code! Good enough for me

Vyxal O, 81892 bytes, cracks EmanresuA's Vyxal answer
I obviously can't post the actual code here, so here's a sample of it:
!¬¬⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧kA!¬⇧wİ÷Ė!¬⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧⇧kA!¬⇧wİ÷Ė

here's the long version - don't try it online, because the server doesn't like 81k byte programs for some reason.
You really thought I wouldn't be able to find an excessively long solution after the 13 rounds of JavaStack we did?

Vyxal, 9942694705621871183448638796  bytes, cracks lyxal's answer
Sample:
kPkPkPL‛∧∑ĖokPkPkPL‛∧∑ĖokPL‛∧∑ĖokPkPkPL‛∧∑ĖokPkPkPL‛∧∑ĖokPL‛∧∑ĖokPL‛∧∑ĖokPkPkPL‛∧∑ĖokPkPkPL‛∧∑ĖokPL‛∧∑ĖokPkPkPL‛∧∑ĖokPkPkPL‛∧∑ĖokPL‛∧∑ĖokPL‛∧∑ĖokPL‛∧∑ĖokPL‛∧∑Ė

Try it Online!
This is a purely theoretical program, as there is no way to run it at all.
So, basically with the snippet kPL‛∧∑Ė (explanation below), we can get the fourth character of a string.
  L     # Length of
kP      # Printable ASCII (not actually, length = 100)
      Ė # Evaluate the code snippet
   ‛∧∑  # "Big" (Compressed)

B   # Convert from binary - 100 -> 4
 i  # Index into string
  g # Get minimum (useless)

We can remove characters with the o command. For example, kPkPkPL‛∧∑Ėo gives us printable ASCII without a 4, meaning the fourth character of this is now 5. We can remove this and a 4 from another copy of printable ascii, making the fourth character 6. Continuing this, we can get any character in the printable ascii range, but getting the next character costs double (+8) the cost of the previous.
This makes the overhead for C (ord -> char) 171798691832 bytes. The overhead for -, meanwhile, is 11805916207174113034232 bytes.
The evaluated code is going to look something like uu-u-u-u-u-u-u-u-u-u-u-u-u-…, because I'm lazy. We then tack on a C at the end of each, add a W at the end, and sum that with ∑, which we can directly call.
A calculation of the length can be found here. A calculator of the overhead for a single printable ascii calculator can be found here.

Vyxal, 29401143 bytes, lyxal get cracked on
The backbone of this solution is the generation of arbitrary negative numbers, allowing for indexing to get all the commands we need.

How negative numbers?
u     # Push -1
 .o   # Remove `0.5` Does nothing except convert to string
   Ė  # Execute

We can decrement to any number by stringing many of these snippets together into a series.
Essentially, this executes subtract, then pushes 1. The 1 is used for the next subtraction in the series. This means we need to get rid of the first subtraction in a series and the last 1 in a series.
Subtraction no
To remove the first subtraction:
k□∑∑k□∑∑

This just pushes a couple of 0s, so the first subtraction is just 0-0.
1 no
To remove the last 1:
uPĖ

This uses -1 to turn 1 into an empty string, which is then executed to remove it.
Try it Online!
Why negative numbers tho?
How do arbitrary negative numbers help us? Vyxal uses the same indexing as Python, so we can use negative numbers to index into stuff. However, to index into something, we need i. We don't have that command available to us, but it is in a couple of the builtins, specifically Fizz and aeiou, which we can make use of:
  kv              # Push `aeiou`
    ‛ouo          # Remove `ou`, giving us `aei`
        kfP       # Remove `Fizz`, giving us `ae`
kv         P      # Remove from `aeiou`, giving us `iou`
            ‛ouo  # Remove `ou`, giving us `i`

Now that we have i and any negative number, we can index into our builtins to get useful stuff. For example, we can index into 01234567 to get 1, and we can index into printable ASCII to get + and C. We can use the 1+ over and over to increment a number, then use C to convert it to a character. (Yes, I know I could just push -1 and use - instead of +, which would be a lot shorter, but that's not as fun.)
Once we have the pieces, namely arbitrary negative numbers and indexing, creating a solution becomes trivial. Here's an example for printing !: apparently the link was too long so here's a gist of the program that you can copy into the interpreter.

Vyxal, 97330683540476391235 bytes ,cracker'sd lyxal's answre
Sample:
ĖPkPkPkoPkoĖĖPPP11ĖPkPkPkoPkoĖĖPPPĖk1k11ooĖk1k11ooĖkoĖĖ11ĖPkPkPkoPkoĖĖPPP11ĖPkPkPkoPkoĖĖPPPĖk1k11ooĖk1k11ooĖkoĖĖ11ĖPkPkPkoPkoĖĖPPP11ĖPkPkPkoPkoĖĖPPPĖkoĖĖ11ĖPkPkPkoPkoĖĖPPP11ĖPkPkPkoPkoĖĖPPPk1k11ooĖk1k11ooĖk1k11ooĖkoĖĖ11ĖPkPkPkoPkoĖĖPPP11ĖPkPkPkoPkoĖĖPPPĖk1k11ooĖk1k11ooĖkoĖĖ11ĖPkPkPkoPkoĖĖPPP11ĖPkPkPkoPkoĖĖPPPĖPĖĖ11ĖPĖkoĖĖ11ĖPkPkPkoPkoĖĖPPP11ĖPkPkPkoPkoĖĖPPPk1k11ooĖk1k11ooĖk1k11ooĖkoĖĖ11ĖPkPkPkoPkoĖĖPPP11ĖPkPkPkoPkoĖĖPPPĖk1k11ooĖk1k11ooĖkoĖĖ11ĖPkPkPkoPkoĖĖPPP11ĖPkPkPkoPkoĖĖPPPĖPĖk1k11ooĖk1k11ooĖk1k11ooĖkoĖĖ11ĖPkPkPkoPkoĖĖPPP11ĖPkPkPkoPkoĖĖPPPĖk1k11ooĖk1k11ooĖkoĖĖ11ĖPkPkPkoPkoĖĖPPP11ĖPkPkPkoPkoĖĖPPPĖk1k11ooĖk1k11ooĖkoĖĖ11ĖPkPkPkoPkoĖĖPPP11ĖPkPkPkoPkoĖĖPPPĖk1k11ooĖk1k11ooĖk1k11ooĖkoĖĖ11ĖPkPkPkoPkoĖĖPPP11ĖPkPkPkoPkoĖĖPPPĖk1k11ooĖk1k11ooĖkoĖĖ11ĖPkPkPkoPkoĖĖPPP11ĖPkPkPkoPkoĖĖPPPĖk1k11ooĖk1k11ooĖkoĖĖ11ĖPkPkPkoPkoĖĖPPP11ĖPkPkPkoPkoĖĖPPPĖkoĖĖ11ĖPkPkPkoPkoĖĖPPP11ĖPkPkPkoPkoĖĖPPPk1k11ooĖk1k11ooĖk1k11ooĖkoĖĖ11ĖPkPkPkoPkoĖĖPPP11ĖPkPkPkoPkoĖĖPPPĖk1k

How?
The first step was to create arbirtrary numbers in some way. I realised that Ė (eval) was overloaded for numbers as reciprocal, and taking the reciprocal of ko (octal digits, 01234567) with koĖĖ gave 8.100005913004317e-07, which had e and -. Both would prove to be useful.
Stripping 01234567 from printable ASCII gave something starting with 89, which I couldn't remove at that point. But I just got 8.100005913004317e-07, which contains both. If I strip that from (ascii - octal digits), and strip that from printable ASCII, I get the digits!
kPkPkoPkoĖĖPP

Try it Online!
We can get a decimal point from something like 11Ė (1/11, 0.09090909090909091), and stripping both of these from 8.100005913004317e-07 (digits, decimal point, then digits again) gives e-.
koĖĖkPkPkoPkoĖĖPPP11ĖPkPkPkoPkoĖĖPPP

Try it Online!
Since e is exponentiation, we can just push a 1 before, so the e becomes a NOP, and executing this subtracts a 1, decrementing the top of stack.
We do need a better way to push a 1 though, since we have no whitespace. k1k11ooĖ solves this problem, and is nicely stackable.
So with this, we can get arbitrary negative numbers! Here's a script that generates code for a negative input.
Now, we can get e on its own by stripping -1 from e-:
koĖĖkPkPkoPkoĖĖPPP11ĖPkPkPkoPkoĖĖPPPk1k11ooĖk1k11ooĖk1k11ooĖkoĖĖ11ĖPkPkPkoPkoĖĖPPP11ĖPkPkPkoPkoĖĖPPPĖk1k11ooĖk1k11ooĖkoĖĖ11ĖPkPkPkoPkoĖĖPPP11ĖPkPkPkoPkoĖĖPPPĖP

Try it Online!
\$(-2)^{-2}\$ is 1/4, but since we have reciprocal (Ė), we can revert this back to 4. It is as a float, but by stripping 1/11 (0.090909090..., 11Ė) and re-evaling, we can turn this back into an integer:
k1k11ooĖk1k11ooĖk1k11ooĖkoĖĖ11ĖPkPkPkoPkoĖĖPPP11ĖPkPkPkoPkoĖĖPPPĖk1k11ooĖk1k11ooĖkoĖĖ11ĖPkPkPkoPkoĖĖPPP11ĖPkPkPkoPkoĖĖPPPĖk1k11ooĖk1k11ooĖkoĖĖ11ĖPkPkPkoPkoĖĖPPP11ĖPkPkPkoPkoĖĖPPPĖk1k11ooĖk1k11ooĖk1k11ooĖkoĖĖ11ĖPkPkPkoPkoĖĖPPP11ĖPkPkPkoPkoĖĖPPPĖk1k11ooĖk1k11ooĖkoĖĖ11ĖPkPkPkoPkoĖĖPPP11ĖPkPkPkoPkoĖĖPPPĖk1k11ooĖk1k11ooĖkoĖĖ11ĖPkPkPkoPkoĖĖPPP11ĖPkPkPkoPkoĖĖPPPĖkoĖĖkPkPkoPkoĖĖPPP11ĖPkPkPkoPkoĖĖPPPk1k11ooĖk1k11ooĖk1k11ooĖkoĖĖ11ĖPkPkPkoPkoĖĖPPP11ĖPkPkPkoPkoĖĖPPPĖk1k11ooĖk1k11ooĖkoĖĖ11ĖPkPkPkoPkoĖĖPPP11ĖPkPkPkoPkoĖĖPPPĖPĖĖ11ĖPĖ

Try it Online!
e's overload for (string, number) is to get every nth character of the string. If we pass in 4, we can get every fourth character of a string. And if we repeat this four times, we can get the first character of any string shorter than 256 chars.
This discovery breaks it all wide open. If we can get the first character of a string, we can remove it, and a new character will become the first character.
Here's a calculator for the size of a character.
The snippets are just going to look like 1111111....111LC, then summed at the end.
Final length calculation

Vyxal, 3407394222061762112 bytes, ccrks lllxal' [hopes and dreams]
HEY EVERY!! IT'S 3VERY BUDDY'S FAVORITE [[number 1 rated cracker 1997]]
klkW₆Ė₆₆₆ĖĖssVĖ₆VkWVkW₆Ė₆₆₆ĖĖssVĖ₆VkWVkW₆Ė₆₆₆ĖĖssVĖ₆VkWVkW₆Ė₆₆₆ĖĖssVĖ₆VkWVkW₆Ė₆₆₆ĖĖssVĖ₆VkWV₆kl₆₆₆₆ĖĖssVĖ₆VĖ₆₆₆ĖĖssVĖ₆V

Try it Online! Yeah I know there're 4's in there, [DEAL] with it.
The backbone of this solution is our good friend [inf].
We can use [inf] to index into builtins and get some [sweet commands] to execute. To get the [inf], we just exploit some [Classic Vyxal Jankness] with the s command:
       V  # Replace every...
 ₆        #  `64` in...
₆         #  `64` with...
  ₆ĖĖ     #   64.0
     s    #   jankness
      s   #   jankness

Executing the [inf] puts some [unwanted garbage] on the stack, so we remove it by removing it:
₆V  # Remove the [unwanted garbage]

Now that we can index, we can get h from [[Hyperlink Blocked]]. (Yes, this is unnecessary because it's the same as the [inf] indexing we used to get it, but you can shut up you [little slime].)
We can also do things like replace the h in [tHe AlPhAbEt] with [[Hyperlink Blocked]] repeatedly to change the length and [inf] index to get other characters, like o or C:
klkWkW₆Ė₆₆4ĖĖssVĖ₆VĖkWVkWkW₆Ė₆₆4ĖĖssVĖ₆VĖkWVkWkW₆Ė₆₆4ĖĖssVĖ₆VĖkWVkWkW₆Ė₆₆4ĖĖssVĖ₆VĖkWVkWkW₆Ė₆₆4ĖĖssVĖ₆VĖkWVkWkW₆Ė₆₆4ĖĖssVĖ₆VĖkWVkWkW₆Ė₆₆4ĖĖssVĖ₆VĖkWV₆kl₆₆₆4ĖĖssVĖ₆VĖ₆₆4ĖĖssVĖ₆V

^o Cv
klkW₆Ė₆₆4ĖĖssVĖ₆VkWVkW₆Ė₆₆4ĖĖssVĖ₆VkWVkW₆Ė₆₆4ĖĖssVĖ₆VkWVkW₆Ė₆₆4ĖĖssVĖ₆VkWVkW₆Ė₆₆4ĖĖssVĖ₆VkWV₆kl₆₆₆4ĖĖssVĖ₆VĖ₆₆4ĖĖssVĖ₆V

The last thing we need is [numbers] [numbers] [numbers] to get the characters to print. That is simple, because we can [numbers] with urL. urL is easy because o:
klklhoklklhohoklklhoklklhohohoklklhoklklhohoklklhoklklhohohohoklklhoklklhohoklklhoklklhohohoklklhoklklhohoklklhoklklhohohohohoklklhoklklhohoklklhoklklhohohoklklhoklklhohoklklhoklklhohohohoklklhoklklhohoklklhoklklhohohoklklhoklklhohoklklhoklklhohohohohohoklklhoklklhohoklklhoklklhohohoklklhoklklhohoklklhoklklhohohohoklklhoklklhohoklklhoklklhohohoklklhoklklhohoklklhoklklhohohohohoklklhoklklhohoklklhoklklhohohoklklhoklklhohoklklhoklklhohohohoklklhoklklhohoklklhoklklhohohoklklhoklklhohoklklhoklklhohohohohohohoklklhoklklhohoklklhoklklhohohoklklhoklklhohoklklhoklklhohohohoklklhoklklhohoklklhoklklhohohoklklhoklklhohoklklhoklklhohohohohoklklhoklklhohoklklhoklklhohohoklklhoklklhohoklklhoklklhohohohoklklhoklklhohoklklhoklklhohohoklklhoklklhohoklklhoklklhohohohohohoklklhoklklhohoklklhoklklhohohoklklhoklklhohoklklhoklklhohohohoklklhoklklhohoklklhoklklhohohoklklhoklklhohoklklhoklklhohohohohoklklhoklklhohoklklhoklklhohohoklklhoklklhohoklklhoklklhohohohoklklhoklklhohoklklhoklklhohohoklklhoklklhohoklklhoklklhohohohohohohohoklklhoklklhohoklklhoklklhohohoklklhoklklhohoklklhoklklhohohohoklklhoklklhohoklklhoklklhohohoklklhoklklhohoklklhoklklhohohohohoklklhoklklhohoklklhoklklhohohoklklhoklklhohoklklhoklklhohohohoklklhoklklhohoklklhoklklhohohoklklhoklklhohoklklhoklklhohohohohohoklklhoklklhohoklklhoklklhohohoklklhoklklhohoklklhoklklhohohohoklklhoklklhohoklklhoklklhohohoklklhoklklhohoklklhoklklhohohohohoklklhoklklhohoklklhoklklhohohoklklhoklklhohoklklhoklklhohohohoklklhoklklhohoklklhoklklhohohoklklhoklklhohoklklhoklklhohohohohohohoklklhoklklhohoklklhoklklhohohoklklhoklklhohoklklhoklklhohohohoklklhoklklhohoklklhoklklhohohoklklhoklklhohoklklhoklklhohohohohoklklhoklklhohoklklhoklklhohohoklklhoklklhohoklklhoklklhohohohoklklhoklklhohoklklhoklklhohohoklklhoklklhohoklklhoklklhohohohohohoklklhoklklhohoklklhoklklhohohoklklhoklklhohoklklhoklklhohohohoklklhoklklhohoklklhoklklhohohoklklhoklklhohoklklhoklklhohohohohoklklhoklklhohoklklhoklklhohohoklklhoklklhohoklklhoklklhohohohoklklhoklklhohoklklhoklklhohohoklklhoklklhohoklklhoklklhohohohohohohohohoklklhoklklhohoklklhoklklhohohoklklhoklklhohoklklhoklklhohohohoklklhoklklhohoklklhoklklhohohoklklhoklklhohoklklhoklklhohohohohoklklhoklklhohoklklhoklklhohohoklklhoklklhohoklklhoklklhohohohoklklhoklklhohoklklhoklklhohohoklklhoklklhohoklklhoklklhohohohohohoklklhoklklhohoklklhoklklhohohoklklhoklklhohoklklhoklklhohohohoklklhoklklhohoklklhoklklhohohoklklhoklklhohoklklhoklklhohohohohoklklhoklklhohoklklhoklklhohohoklklhoklklhohoklklhoklklhohohohoklklhoklklhohoklklhoklklhohohoklklhoklklhohoklklhoklklhohohohohohohoklklhoklklhohoklklhoklklhohohoklklhoklklhohoklklhoklklhohohohoklklhoklklhohoklklhoklklhohohoklklhoklklhohoklklhoklklhohohohohoklklhoklklhohoklklhoklklhohohoklklhoklklhohoklklhoklklhohohohoklklhoklklhohoklklhoklklhohohoklklhoklklhohoklklhoklklhohohohohohoklklhoklklhohoklklhoklklhohohoklklhoklklhohoklklhoklklhohohohoklklhoklklhohoklklhoklklhohohoklklhoklklhohoklklhoklklhohohohohoklklhoklklhohoklklhoklklhohohoklklhoklklhohoklklhoklklhohohohoklklhoklklhohoklklhoklklhohohoklklhoklklhohoklklhoklklhohohohohohohohoklklhoklklhohoklklhoklklhohohoklklhoklklhohoklklhoklklhohohohoklklhoklklhohoklklhoklklhohohoklklhoklklhohoklklhoklklhohohohohoklklhoklklhohoklklhoklklhohohoklklhoklklhohoklklhoklklhohohohoklklhoklklhohoklklhoklklhohohoklklhoklklhohoklklhoklklhohohohohohoklklhoklklhohoklklhoklklhohohoklklhoklklhohoklklhoklklhohohohoklklhoklklhohoklklhoklklhohohoklklhoklklhohoklklhoklklhohohohohoklklhoklklhohoklklhoklklhohohoklklhoklklhohoklklhoklklhohohohoklklhoklklhohoklklhoklklhohohoklklhoklklhohoklklhoklklhohohohohohohoklklhoklklhohoklklhoklklhohohoklklhoklklhohoklklhoklklhohohohoklklhoklklhohoklklhoklklhohohoklklhoklklhohoklklhoklklhohohohohoklklhoklklhohoklklhoklklhohohoklklhoklklhohoklklhoklklhohohohoklklhoklklhohoklklhoklklhohohoklklhoklklhohoklklhoklklhohohohohohoklklhoklklhohoklklhoklklhohohoklklhoklklhohoklklhoklklhohohohoklklhoklklhohoklklhoklklhohohoklklhoklklhohoklklhoklklhohohohohoklklhoklklhohoklklhoklklhohohoklklhoklklhohoklklhoklklhohohohoklklhoklklhohoklklhoklklhohohoklklhoklklhohoklklhoklklhohohohohohohohohoho

I don't need to explain this, since anyone with a [$4.99] life can understand how it works.
The hohoho is made with the [Classic Vyxal Jankness] showed before, and it lets us do what we want to get [numbers] to get [characters] to be a
[[BIG SHOT!!!]]
[[BIG SHOT!!!!]]
[[BIG SHOT!!!!!]]

btw, the 4s in the link are just because using 64 would time out. The effect is the same, though. Also, the klklho thingy is pretty much what emanresuA used in their absurdly large answer to get C, so read that explanation instead.

QBasic 1.1, cracks DLosc's second answer
The string to print is:
C,c

Solution:
X$ = MKL$(543370307)
PRINT RTRIM$(X$)

This was much trickier than the first version. This time I couldn't use a comma. That was mainly to prevent writing memory with POKE, but it also ruled out every other function with multiple arguments.
After all my initial ideas failed, I started looking for any functions that took a single argument and were even vaguely related to strings. Eventually I found the MKL$ function, which lets you encode Long values in ASCII. The documentation points out that this "can save up to 6 bytes of storage space" !
MKL$ always returns 4 bytes. If the number isn't long enough, the ASCII encoding will be padded with \0, which QBasic annoyingly prints as whitespace but doesn't trim. I ended up finding a number that gets encoded as C,c  with a trailing space, so I could use RTRIM$ to remove that space, all without typing a comma.

Very nice! Pretty similar to what I had.

Perl 5 + -p, cracks Dom Hastings's answer
BEGIN { $. = ARGU; ++$.; $_ = z - z; @{$.} = $$_; } $_ = BGOP; tr:A-P:!-;:; $z = $_; $n = $.; ++$.; $n .= $.; ++$.; $n .= $.; ++$.; $n .= $.; ++$.; $n .= $.; ++$.; $n .= $.; ++$.; $n .= $.; ++$.; $n .= $.; ++$.; $n .= $.; $z .= $n; $_ = $.; tr: -z:#-z:; $z .= $_; $_ = BLEPRU; tr:A-Z:B-Z:; $z .= $_; $_ = bdi; tr:G-z:A-z:; $z .= $_; $_ = fijlouw; tr:_-z:f-:; $z .= $_; $_= $z;

This code must be stored in a file (-e won't work), but the file name doesn't matter. The source code must be a single line (a shebang line breaks it). A trailing newline in the source code is optional. The `` character in tr:_-z:f-: is DEL (ASCII 127); any character code above 126 would do.
-p gives us automatic printing, which is nice since the core printing functions (print, syswrite, say if we managed to define it) have forbidden names. But it requires input. Fortunately we can change where the input comes from in a BEGIN block: @ARGV specifies where the input comes from, so we set this to the script file, which is guaranteed to exist. We arrange for exactly one line of input, so the code after the BEGIN block runs exactly once and the final value of $_ will be printed at the end.
The rest is simple string processing tricks to set @ARGV and $_ without using any of the forbidden characters. Here's an expanded version with comments.
#!/usr/bin/perl -p
BEGIN {
    # Set @ARGV to $0, a file that we know contains exactly one line.
    # This assumes that perl is invoked on a script file, not with -e.
    $. = ARGU; ++$.;
    $_ = z - z;
    @{$.} = $$_;
}
# For the expanded version only: only process the first line.
print "\n" and exit if $line++;
# Build the string using tr to shift permitted characters into forbidden
# characters. Run tr on $_ since =~ isn't permitted. The . operator is
# permitted so we can concatenate the pieces the simple way.
$_ = BGOP; tr:A-P:!-;:; $z = $_;
# For the digits, arithmetic is more convenient than tr.
$n = $.; ++$.; $n .= $.; ++$.; $n .= $.; ++$.; $n .= $.; ++$.; $n .= $.; ++$.; $n .= $.; ++$.; $n .= $.; ++$.; $n .= $.; ++$.; $n .= $.; $z .= $n;
$_ = $.; tr: -z:#-z:; $z .= $_;
$_ = BLEPRU; tr:A-Z:B-Z:; $z .= $_;
$_ = bdi; tr:G-z:A-z:; $z .= $_;
$_ = fijlouw; tr:_-z:f-:; $z .= $_;
# $_ will be printed thanks to -p
$_= $z;

Try it online!

Nice work! Definitely not what I intended, so I'll add a couple more exclusions and try again!

R, cracks JDL's challenge
String to print:
([{

Solution:
"?"=intToUtf8
"+"=c
"!"=cat
!?40+91+123

Try it online!
Explanation: this code is equivalent to
cat(intToUtf8(c(40, 91, 123)))

Nice. I had this before seeing you had already cracked it!

@Giuseppe It looks like apropos is becoming your tool of choice!

I had originally started with magrittr::%>%->%>%`` (SO comments will muck up the rendering of that one) but then realised as you did that inbuilt unary operators would be just fine

@RobinRyder it's quite useful for this challenge, unsurprisingly, and even when a is banned, you can replicate it quite a lot by using ls() anyway. get is also pretty useful in conjunction to get functions back from the name.

@Giuseppe It isn't clear to me how that would work… It's starting to sound like we need to reactive the golfR chat room!

@RobinRyder It seems quite ironic that @Giuseppe Cracked my second challenge (that was aimed to make indexing difficult) using indexing, whereas the solution that I had in mind actually used apropos() (after lowercasing) just to avoid this.

Perl 5 + -p, cracks Dom Hastings's third answer
Note: this solution only works in Perl up to 5.21, and prints a warning in Perl ≥5.14.
Note: this solution attempts to read from standard input. It works whether it reads empty or non-empty input, but if reading from stdin blocks, the program will block.
The code is generated by the following Perl program. It's too long to fit in a Stack Exchange answer. (It contains numbers in unary. With a small amount of effort, the numbers could be compressed to fit.)
#!/usr/bin/env perl
use warnings;
use strict;

my $output = q$ "#'+\-/0123456789:<>ABCDEFGHIJKLMNOPQRSTUVWXYZ\^`abcdefghijklmnopqrstuvwxyz|~$;

sub encode_integers {
    # Express numbers in unary: construct a list of the desired length
    # and force it into scalar context.
    $_[0] =~ s{(\d+)}{$1 ? '($==@{[_' . ',_' x ($1-1) . ']})' : '$['}eg;
}

my $code = <<'EOF';
$_ = *_;                                        # $_ = "*main::_"
# Note that bare ?REGEXP? without a leading m requires perl <5.22
m?..(.)..(..)?;                                  # $1 = "a"; $2 = "::"
@_=${1}.._;                                     # @__ = "a".."z"
$__=(____&($_[2].$_[14].$_[17].$_[4])).${2};    # $__ = "CORE::"
$___=$__.$_[2].$_[7].$_[17];                    # $___ = "CORE::chr"
$____=$__.$_[18].$_[24].$_[18].$_[22].$_[17].$_[8].$_[19].$_[4]; # $____ = "CORE::syswrite"
$_____=______&($_[18].$_[19].$_[3].$_[14].$_[20].$_[19]); # $_____ = "STDOUT"
&$____($_____,OUTPUT);                          # syswrite(STDOUT, chr(32).chr(34)...)
$_=$@;                                          # Empty $_ because -p might print it
EOF

# Remove comments and whitespace
$code =~ s/#.*//g;
$code =~ tr/ \n//d;
# Inject desired output
$code =~ s{OUTPUT}{join('.', map {sprintf('&$___(%d)', ord($_))}
                                 split(//, $output))}eg;
encode_integers($code);

# For the sake of -p, we also need to exit after the first input line.
my $exit = '$______=$__.$_[4].$_[23].$_[8].$_[19];&$______(0)';
encode_integers($exit);

print "$code;$exit}$code;{";

Try it online! — adapted for modern Perl versions, with the extra m before ?…? that isn't needed in Perl up to 5.21. (To reiterate: the version on TIO does not obey the restricted source constraint, but works in modern Perl. My solution obeys the restricted source constraint, but doesn't work in modern Perl.)
The first thing we do is obtain a string 'a'. We do this by pattern-matching on *_ which is '*main::_'. The characters m and / are forbidden, but ? is permitted, so we can use the m?…? pattern matching form. This form requires an explicit m in modern Perl, but classic Perl allowed a bare ?…? (with the risk that occasionally Perl would misparse the ? as part of the … ? … : … construct). Due to the use of this construct, the program no longer works with Perl 5.22 and above. While we're at it, we grab :: as well; this isn't strictly necessary but saves work later.
Having 'a', we can construct the range 'a'..'_' which is the list of lowercase ASCII letters from 'a' to 'z'. (It should really be 'a'..'z' but perl doesn't mind.) We can now build strings containing letters with $_[INDEX]. Positive integers are expressed as the length of the list (_,_,…,_) in scalar context.
Next we construct the names of some built-in functions from the CORE module. With the function name in $var, we can call it with &$var(…). The . concatenation operator, the chr function (expressed as CORE::chr), and the ability to express integers lets us construct arbitrary strings.
There's no CORE::print, so we use CORE::syswrite(STDOUT, …) instead.
For plain perl the work would be done. For perl -p, we need to do a bit of additional work. perl -p is equivalent to putting the source code in a while (<>) { … } loop. It's so equivalent that you can put an extra } in the source code to close the brace of the loop, followed by an extra { so that the program as a whole is syntactically correct. The structure of the program is:
while (<>) {
    print stuff; $_ = "";
    exit;
    }
    print stuff; $_ = "";
    {
} continue { print $_; }

where the indented part is the source code and the unindented part is the -p wrapper code. So if there is a line of input, the loop body is executed and the program exits. If there is no input, the loop body doesn't run, and the next instructions (the second print stuff;) are executed.

Ruby, cracks Dingus's answer
#!/usr/bin/env ruby
class Fixnum
  def !
    chr
  end
end
s = !112 + !46 + !96 + !39 + !92 + !34 + !63 + !37 + !40 + !91 + !58 + !60
eval !112 + !114 + !105 + !110 + !116 + !34 + s + !34

Can't call methods without .? Yes you can, if they're operators.
Try it online!

That was quick! Very clever, though again nothing like mine. I'm going to give this one more shake...

Dupdog, 1813 bytes, cracks @HighlyRadioactive's answer

This should be really really trivial . . . The answer is suspiciously short

Safe to say this is not the intended answer then:
a?a?????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????a?????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????a?????a???????????????????????????????????????????????????????????????????????????????????????????????????????????a?????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????a?????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????a???????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????a???????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????a

The program was created using a Python script written by @kennytm. I couldn't find a publicly available Dupdog interpreter so I rolled my own based on the language spec at Esolangs.

Hurray finally someone to crack my answer!!

Also WHY DON'T YOUR INTERPRETER HALT AFTER OUTPUTTING A NUMBER??? (Hey wait I forgot to turn off CapsLock)

@HighlyRadioactive Because it wasn't well tested :). Fixed.

Malbolge, cracks Pizgenal Filegav's answer
String to print:
To

Solution:
DCBA@?"7[54XE7UB.-2bNMLKK8k)GXD}Ce/yba=

Try it online!
I have no idea how this works! I found the solution with this generator, then decided against posting it, since that didn't seem to fit the spirit of the challenge. But I decided I'd post it anyway when I saw Dingus's Dupdog answer, which also used generated code.

All's fair in code golf and war ;)

That's a bit different than my original solution, but I'm not surprised there's another one. Good job!

Haskell, cracks Ad Hoc Garf Hunter's answer
main|[uuuuuuuuu,iiiiiiiiiiiii,iiiiiiiiiiii,iiiiiiiiiii,iiiiiiiiii,iiiiiiiii,iiiiiiii,iiiiiii,iiiiii,iiiii,iiii,iii,ii,i,nnnnnnn,nnnnnn,nnnnn,uuuuuuuu,nnnn,uuuuuuu,aaaaaaaaaaaaai,aaaaaaaaaaaai,aaaaaaaaaaai,aaaaaaaaaai,aaaaaaaaai,aaaaaaaai,aaaaaaai,aaaaaai,aaaaai,aaaai,aaai,aai,ai,aaaaaaaaaaaaa,aaaaaaaaaaaa,aaaaaaaaaaa,aaaaaaaaaa,aaaaaaaaa,aaaaaaaa,aaaaaaa,aaaaaa,aaaaa,aaaa,aaa,aa,a,mmmmmmmmmmmmmmm,mmmmmmmmmmmmmm,uuuuuu,uuuuu,uuuu,mmmmmmmmmmmmm,mmmmmmmmmmmm,mmmmmmmmmm,mmmmmmmmm,mmmmmmmm,mmmmmmm,mmmmmm,mmmmm,mmmm,mmm,mm,m,pppppppppppp,uuu,uu,u,ppppppppppp,pppppppppp,ppppppppp,pppppppp,ppppppp,pppppp,ppppp,pppp,ppp,pp,p,nnn,urrrrrrrrrrrrrrrrrrrrrr,urrrrrrrrrrrrrrrrrrrrrrrr,urrrrrrrrrrrrrrrrrrrr,urrrrrrrrrrrrrrrrrrr,urrrrrrrrrrrrrrrrrr,urrrrrrrrrrrrrrrrr,urrrrrrrrrrrrrrrr,urrrrrrrrrrrrrr,urrrrrrrrrrrrr,urrrrrrrrrrrr,urrrrrrrrrrr,urrrrrrrrrr,urrrrrrrrr,urrrrrrrr,urrrrrrr,urrrrrr,urrrrr,urrrr,urrr,urr,ur,nn,n,rrrrrrrrrr,rrrrrrrrr,rrrrrrrr,rrrrrrr,rrrrrr,rrrrr,rrrr,rrr,rr]<-['n','m'..],[t,tt,ttt,tttt,ttttt,tttttt,ttttttt,tttttttt,ttttttttt,tttttttttt,ttttttttttt,tttttttttttt,ttttttttttttt,r]<-['n'..'{'],h<-putChar.minimum=h[n]>>h[nn]>>h[nnn]>>h[p]>>h[pp]>>h[ppp]>>h[pppp]>>h[ppppp]>>h[pppppp]>>h[pppppppp]>>h[ppppppppp]>>h[pppppppppp]>>h[ppppppppppp]>>h[pppppppppppp]>>h[m]>>h[mm]>>h[mmm]>>h[mmmm]>>h[mmmmm]>>h[mmmmmm]>>h[mmmmmmm]>>h[mmmmmmmm]>>h[mmmmmmmmm]>>h[mmmmmmmmmm]>>h[mmmmmmmmmmmm]>>h[mmmmmmmmmmmmmm]>>h[mmmmmmmmmmmmm]>>h[mmmmmmmmmmmmmmm]>>h[aa]>>h[aaaaa]>>h[aaaa]>>h[a]>>h[aaaaaa]>>h[aaaaaaa]>>h[aaaaaaaa]>>h[aaaaaaaaa]>>h[aaaaaaaaaa]>>h[aaaaaaaaaaa]>>h[aaaaaaaaaaaa]>>h[aaaaaaaaaaaaa]>>h[ai]>>h[aai]>>h[aaai]>>h[aaaai]>>h[aaaaai]>>h[aaaaaai]>>h[aaaaaaai]>>h[aaaaaaaai]>>h[aaaaaaaaai]>>h[aaaaaaaaaai]>>h[aaaaaaaaaaai]>>h[aaaaaaaaaaaai]>>h[aaaaaaaaaaaaai]>>h[nnnn]>>h[nnnnn]>>h[nnnnnn]>>h[nnnnnnn]>>h[ii]>>h[iii]>>h[iiii]>>h[iiiii]>>h[iiiiii]>>h[iiiiiii]>>h[iiiiiiiiii]>>h[iiiiiiiiiii]>>h[iiiiiiiiiiii]>>h[tt]>>h[tttt]>>h[tttttt]>>h[ttttttttt]>>h[tttttttttt]>>h[ttttttttttt]>>h[tttttttttttt]>>h[ttttttttttttt]

Try it online!
Probably not quite the intended method. minimum ends up been crucial to my method. It is used as a replacement for head.
How it works
This uses pattern guards on main to pattern match the char from two lists. One generated by ['n','m',..], and one generated by ['n'..'{'].
Since function application is hard unless the arguemnt is a list, we create a function (called h) that is putChar modified to work with singleton lists. This is done by composing putChar and minimum in a pattern guard.
The body of main is just applying h to each character that we have matched  and combing the IO actions with (>>).

Very nice!  My intended method uses {--} as a substitute for space since it breaks tokenization.  Other than the fact I used shorter variable names and a slightly different combination of pattern matching this is virtually the same.

@AdHocGarfHunter Ah, I was wondering what the braces were for. There didn't seem to be the opportunity to use them as replacement for layout as all the layout heralds I thought of were impossible. I even thought about doing something with record creation at one point.

PHP 7, 26 bytes, cracks thelmuxkriovar's answer
<?php echo~..............;

Try it online!
This solution contains unprintables so the link is to xxd output which is reversed. Actual bytes are:
<?php echo~\x99\x8a\x91\x8b\x96\x92\xd7\xd6\x84\x82\xa0\xc2\xd0\xa3;

As noted by @thelmuxkriovar this would not work on PHP 8 without quotes.

I love this solution, this is brilliant! you should edit your answer to show the hex code for the characters, however as I couldn't tell what you were trying to do until I clicked the link (fun fact, this won't work in php 8 because they changed undefined constant to an error rather than a warning)

@thelmuxkriovar Glad you liked it! I'll add the xxd data into the post too, good shout. If this isn't the intended crack, please feel free to add another banning ~ too!

done :) added ~ to the banning, good luck :)

PHP 7, 46 bytes, cracks thelmuxkriovar's second answer
<?php echo"      crACked??"^"FUNTIMK[:>4XKcA";

Try it online!

you're too fast lol, good job, this was similar to the solution I initially came up with

@thelmuxkriovar Yeah, apologies! I think I was there at the right time and had alraedy prepared the other answer when I looked at your first :)

25 seconds from cop to crack - must be a record!

Lua, 5152 bytes, cracks @LuaNoob's fourth answer
io[([[write]])](string[string[([[gsub]])]([[chAr]],[[A]],string[([[sub]])](_VERSION,string[([[find]])]([[ccA]],[[A]]),string[([[find]])]([[ccA]],[[A]])))](string[([[find]])]([[ccccccccA]],[[A]]),string[([[find]])]([[cccccccccccccccccccccccccccccccA]],[[A]]),string[([[find]])]([[ccccccccccccccccccccccccccccccccA]],[[A]]),string[([[find]])]([[cccccccccccccccccccccccccccccccccA]],[[A]]),string[([[find]])]([[ccccccccccccccccccccccccccccccccccA]],[[A]]),string[([[find]])]([[cccccccccccccccccccccccccccccccccccA]],[[A]]),string[([[find]])]([[ccccccccccccccccccccccccccccccccccccA]],[[A]]),string[([[find]])]([[cccccccccccccccccccccccccccccccccccccA]],[[A]]),string[([[find]])]([[ccccccccccccccccccccccccccccccccccccccA]],[[A]]),string[([[find]])]([[cccccccccccccccccccccccccccccccccccccccccA]],[[A]]),string[([[find]])]([[ccccccccccccccccccccccccccccccccccccccccccA]],[[A]]),string[([[find]])]([[ccccccccccccccccccccccccccccccccccccccccccccA]],[[A]]),string[([[find]])]([[cccccccccccccccccccccccccccccccccccccccccccccA]],[[A]]),string[([[find]])]([[ccccccccccccccccccccccccccccccccccccccccccccccA]],[[A]]),string[([[find]])]([[cccccccccccccccccccccccccccccccccccccccccccccccA]],[[A]]),string[([[find]])]([[ccccccccccccccccccccccccccccccccccccccccccccccccA]],[[A]]),string[([[find]])]([[cccccccccccccccccccccccccccccccccccccccccccccccccA]],[[A]]),string[([[find]])]([[ccccccccccccccccccccccccccccccccccccccccccccccccccA]],[[A]]),string[([[find]])]([[cccccccccccccccccccccccccccccccccccccccccccccccccccA]],[[A]]),string[([[find]])]([[ccccccccccccccccccccccccccccccccccccccccccccccccccccA]],[[A]]),string[([[find]])]([[cccccccccccccccccccccccccccccccccccccccccccccccccccccA]],[[A]]),string[([[find]])]([[ccccccccccccccccccccccccccccccccccccccccccccccccccccccA]],[[A]]),string[([[find]])]([[cccccccccccccccccccccccccccccccccccccccccccccccccccccccA]],[[A]]),string[([[find]])]([[ccccccccccccccccccccccccccccccccccccccccccccccccccccccccA]],[[A]]),string[([[find]])]([[cccccccccccccccccccccccccccccccccccccccccccccccccccccccccA]],[[A]]),string[([[find]])]([[ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccA]],[[A]]),string[([[find]])]([[cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccA]],[[A]]),string[([[find]])]([[ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccA]],[[A]]),string[([[find]])]([[cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccA]],[[A]]),string[([[find]])]([[ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccA]],[[A]]),string[([[find]])]([[cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccA]],[[A]]),string[([[find]])]([[ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccA]],[[A]]),string[([[find]])]([[cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccA]],[[A]]),string[([[find]])]([[cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccA]],[[A]]),string[([[find]])]([[cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccA]],[[A]]),string[([[find]])]([[ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccA]],[[A]]),string[([[find]])]([[cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccA]],[[A]]),string[([[find]])]([[ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccA]],[[A]]),string[([[find]])]([[cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccA]],[[A]]),string[([[find]])]([[ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccA]],[[A]]),string[([[find]])]([[cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccA]],[[A]]),string[([[find]])]([[ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccA]],[[A]]),string[([[find]])]([[cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccA]],[[A]]),string[([[find]])]([[cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccA]],[[A]]),string[([[find]])]([[ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccA]],[[A]]),string[([[find]])]([[cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccA]],[[A]]),string[([[find]])]([[ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccA]],[[A]]),string[([[find]])]([[cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccA]],[[A]]),string[([[find]])]([[ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccA]],[[A]]),tostring(string[([[find]])]([[cccccccccA]],[[A]]))))

Try it online! Works in both 5.1 (as required) and 5.3.5 (the version on TIO).
It looks like my crack for the third challenge in the series was unnecessarily convoluted. It's taken me all this time to realise that _G/getfenv() aren't even needed: string itself is a table!
As in the previous challenges, we need to create the string char. We start with chAr and replace the A with a, which is extracted as the third character of _VERSION, a global string that returns Lua 5.1 in 5.1. Once this is done, we simply pass in a list of the required ASCII codes, generated using string[([[find]])] to return the index of the first occurrence of the letter A in strings of the form ccc...A. For reasons I don't understand, the last ASCII code has to be passed to tostring or else the last character gets printed twice.

Is this even Lua at this point?

Good Job :D Im out of Ideas for now.
About string, you can even do ([[]])[([[gsub]])]

Lost, 8555 bytes, cracks Unrelated String's Answer
????????????????????????????58*1+:6+265**:2+:65*2++:83*+:6+@+6:+*38:++2*56:+2:**562+6:+1*58%
???????????????????????????58*1+:6+265**:2+:65*2++:83*+:6+@+6:+*38:++2*56:+2:**562+6:+1*58%?
??????????????????????????58*1+:6+265**:2+:65*2++:83*+:6+@+6:+*38:++2*56:+2:**562+6:+1*58%??
?????????????????????????58*1+:6+265**:2+:65*2++:83*+:6+@+6:+*38:++2*56:+2:**562+6:+1*58%???
????????????????????????58*1+:6+265**:2+:65*2++:83*+:6+@+6:+*38:++2*56:+2:**562+6:+1*58%????
???????????????????????58*1+:6+265**:2+:65*2++:83*+:6+@+6:+*38:++2*56:+2:**562+6:+1*58%?????
??????????????????????58*1+:6+265**:2+:65*2++:83*+:6+@+6:+*38:++2*56:+2:**562+6:+1*58%??????
?????????????????????58*1+:6+265**:2+:65*2++:83*+:6+@+6:+*38:++2*56:+2:**562+6:+1*58%???????
????????????????????58*1+:6+265**:2+:65*2++:83*+:6+@+6:+*38:++2*56:+2:**562+6:+1*58%????????
???????????????????58*1+:6+265**:2+:65*2++:83*+:6+@+6:+*38:++2*56:+2:**562+6:+1*58%?????????
??????????????????58*1+:6+265**:2+:65*2++:83*+:6+@+6:+*38:++2*56:+2:**562+6:+1*58%??????????
?????????????????58*1+:6+265**:2+:65*2++:83*+:6+@+6:+*38:++2*56:+2:**562+6:+1*58%???????????
????????????????58*1+:6+265**:2+:65*2++:83*+:6+@+6:+*38:++2*56:+2:**562+6:+1*58%????????????
???????????????58*1+:6+265**:2+:65*2++:83*+:6+@+6:+*38:++2*56:+2:**562+6:+1*58%?????????????
??????????????58*1+:6+265**:2+:65*2++:83*+:6+@+6:+*38:++2*56:+2:**562+6:+1*58%??????????????
?????????????58*1+:6+265**:2+:65*2++:83*+:6+@+6:+*38:++2*56:+2:**562+6:+1*58%???????????????
????????????58*1+:6+265**:2+:65*2++:83*+:6+@+6:+*38:++2*56:+2:**562+6:+1*58%????????????????
???????????58*1+:6+265**:2+:65*2++:83*+:6+@+6:+*38:++2*56:+2:**562+6:+1*58%?????????????????
??????????58*1+:6+265**:2+:65*2++:83*+:6+@+6:+*38:++2*56:+2:**562+6:+1*58%??????????????????
?????????58*1+:6+265**:2+:65*2++:83*+:6+@+6:+*38:++2*56:+2:**562+6:+1*58%???????????????????
????????58*1+:6+265**:2+:65*2++:83*+:6+@+6:+*38:++2*56:+2:**562+6:+1*58%????????????????????
???????58*1+:6+265**:2+:65*2++:83*+:6+@+6:+*38:++2*56:+2:**562+6:+1*58%?????????????????????
??????58*1+:6+265**:2+:65*2++:83*+:6+@+6:+*38:++2*56:+2:**562+6:+1*58%??????????????????????
?????58*1+:6+265**:2+:65*2++:83*+:6+@+6:+*38:++2*56:+2:**562+6:+1*58%???????????????????????
????58*1+:6+265**:2+:65*2++:83*+:6+@+6:+*38:++2*56:+2:**562+6:+1*58%????????????????????????
???58*1+:6+265**:2+:65*2++:83*+:6+@+6:+*38:++2*56:+2:**562+6:+1*58%?????????????????????????
??58*1+:6+265**:2+:65*2++:83*+:6+@+6:+*38:++2*56:+2:**562+6:+1*58%??????????????????????????
?58*1+:6+265**:2+:65*2++:83*+:6+@+6:+*38:++2*56:+2:**562+6:+1*58%???????????????????????????
58*1+:6+265**:2+:65*2++:83*+:6+@+6:+*38:++2*56:+2:**562+6:+1*58%????????????????????????????
8*1+:6+265**:2+:65*2++:83*+:6+@+6:+*38:++2*56:+2:**562+6:+1*58%????????????????????????????5
*1+:6+265**:2+:65*2++:83*+:6+@+6:+*38:++2*56:+2:**562+6:+1*58%????????????????????????????58
1+:6+265**:2+:65*2++:83*+:6+@+6:+*38:++2*56:+2:**562+6:+1*58%????????????????????????????58*
+:6+265**:2+:65*2++:83*+:6+@+6:+*38:++2*56:+2:**562+6:+1*58%????????????????????????????58*1
:6+265**:2+:65*2++:83*+:6+@+6:+*38:++2*56:+2:**562+6:+1*58%????????????????????????????58*1+
6+265**:2+:65*2++:83*+:6+@+6:+*38:++2*56:+2:**562+6:+1*58%????????????????????????????58*1+:
+265**:2+:65*2++:83*+:6+@+6:+*38:++2*56:+2:**562+6:+1*58%????????????????????????????58*1+:6
265**:2+:65*2++:83*+:6+@+6:+*38:++2*56:+2:**562+6:+1*58%????????????????????????????58*1+:6+
65**:2+:65*2++:83*+:6+@+6:+*38:++2*56:+2:**562+6:+1*58%????????????????????????????58*1+:6+2
5**:2+:65*2++:83*+:6+@+6:+*38:++2*56:+2:**562+6:+1*58%????????????????????????????58*1+:6+26
**:2+:65*2++:83*+:6+@+6:+*38:++2*56:+2:**562+6:+1*58%????????????????????????????58*1+:6+265
*:2+:65*2++:83*+:6+@+6:+*38:++2*56:+2:**562+6:+1*58%????????????????????????????58*1+:6+265*
:2+:65*2++:83*+:6+@+6:+*38:++2*56:+2:**562+6:+1*58%????????????????????????????58*1+:6+265**
2+:65*2++:83*+:6+@+6:+*38:++2*56:+2:**562+6:+1*58%????????????????????????????58*1+:6+265**:
+:65*2++:83*+:6+@+6:+*38:++2*56:+2:**562+6:+1*58%????????????????????????????58*1+:6+265**:2
:65*2++:83*+:6+@+6:+*38:++2*56:+2:**562+6:+1*58%????????????????????????????58*1+:6+265**:2+
65*2++:83*+:6+@+6:+*38:++2*56:+2:**562+6:+1*58%????????????????????????????58*1+:6+265**:2+:
5*2++:83*+:6+@+6:+*38:++2*56:+2:**562+6:+1*58%????????????????????????????58*1+:6+265**:2+:6
*2++:83*+:6+@+6:+*38:++2*56:+2:**562+6:+1*58%????????????????????????????58*1+:6+265**:2+:65
2++:83*+:6+@+6:+*38:++2*56:+2:**562+6:+1*58%????????????????????????????58*1+:6+265**:2+:65*
++:83*+:6+@+6:+*38:++2*56:+2:**562+6:+1*58%????????????????????????????58*1+:6+265**:2+:65*2
+:83*+:6+@+6:+*38:++2*56:+2:**562+6:+1*58%????????????????????????????58*1+:6+265**:2+:65*2+
:83*+:6+@+6:+*38:++2*56:+2:**562+6:+1*58%????????????????????????????58*1+:6+265**:2+:65*2++
83*+:6+@+6:+*38:++2*56:+2:**562+6:+1*58%????????????????????????????58*1+:6+265**:2+:65*2++:
3*+:6+@+6:+*38:++2*56:+2:**562+6:+1*58%????????????????????????????58*1+:6+265**:2+:65*2++:8
*+:6+@+6:+*38:++2*56:+2:**562+6:+1*58%????????????????????????????58*1+:6+265**:2+:65*2++:83
+:6+@+6:+*38:++2*56:+2:**562+6:+1*58%????????????????????????????58*1+:6+265**:2+:65*2++:83*
:6+@+6:+*38:++2*56:+2:**562+6:+1*58%????????????????????????????58*1+:6+265**:2+:65*2++:83*+
6+@+6:+*38:++2*56:+2:**562+6:+1*58%????????????????????????????58*1+:6+265**:2+:65*2++:83*+:
+@+6:+*38:++2*56:+2:**562+6:+1*58%????????????????????????????58*1+:6+265**:2+:65*2++:83*+:6
@+6:+*38:++2*56:+2:**562+6:+1*58%????????????????????????????58*1+:6+265**:2+:65*2++:83*+:6+
+6:+*38:++2*56:+2:**562+6:+1*58%????????????????????????????58*1+:6+265**:2+:65*2++:83*+:6+@
6:+*38:++2*56:+2:**562+6:+1*58%????????????????????????????58*1+:6+265**:2+:65*2++:83*+:6+@+
:+*38:++2*56:+2:**562+6:+1*58%????????????????????????????58*1+:6+265**:2+:65*2++:83*+:6+@+6
+*38:++2*56:+2:**562+6:+1*58%????????????????????????????58*1+:6+265**:2+:65*2++:83*+:6+@+6:
*38:++2*56:+2:**562+6:+1*58%????????????????????????????58*1+:6+265**:2+:65*2++:83*+:6+@+6:+
38:++2*56:+2:**562+6:+1*58%????????????????????????????58*1+:6+265**:2+:65*2++:83*+:6+@+6:+*
8:++2*56:+2:**562+6:+1*58%????????????????????????????58*1+:6+265**:2+:65*2++:83*+:6+@+6:+*3
:++2*56:+2:**562+6:+1*58%????????????????????????????58*1+:6+265**:2+:65*2++:83*+:6+@+6:+*38
++2*56:+2:**562+6:+1*58%????????????????????????????58*1+:6+265**:2+:65*2++:83*+:6+@+6:+*38:
+2*56:+2:**562+6:+1*58%????????????????????????????58*1+:6+265**:2+:65*2++:83*+:6+@+6:+*38:+
2*56:+2:**562+6:+1*58%????????????????????????????58*1+:6+265**:2+:65*2++:83*+:6+@+6:+*38:++
*56:+2:**562+6:+1*58%????????????????????????????58*1+:6+265**:2+:65*2++:83*+:6+@+6:+*38:++2
56:+2:**562+6:+1*58%????????????????????????????58*1+:6+265**:2+:65*2++:83*+:6+@+6:+*38:++2*
6:+2:**562+6:+1*58%????????????????????????????58*1+:6+265**:2+:65*2++:83*+:6+@+6:+*38:++2*5
:+2:**562+6:+1*58%????????????????????????????58*1+:6+265**:2+:65*2++:83*+:6+@+6:+*38:++2*56
+2:**562+6:+1*58%????????????????????????????58*1+:6+265**:2+:65*2++:83*+:6+@+6:+*38:++2*56:
2:**562+6:+1*58%????????????????????????????58*1+:6+265**:2+:65*2++:83*+:6+@+6:+*38:++2*56:+
:**562+6:+1*58%????????????????????????????58*1+:6+265**:2+:65*2++:83*+:6+@+6:+*38:++2*56:+2
**562+6:+1*58%????????????????????????????58*1+:6+265**:2+:65*2++:83*+:6+@+6:+*38:++2*56:+2:
*562+6:+1*58%????????????????????????????58*1+:6+265**:2+:65*2++:83*+:6+@+6:+*38:++2*56:+2:*
562+6:+1*58%????????????????????????????58*1+:6+265**:2+:65*2++:83*+:6+@+6:+*38:++2*56:+2:**
62+6:+1*58%????????????????????????????58*1+:6+265**:2+:65*2++:83*+:6+@+6:+*38:++2*56:+2:**5
2+6:+1*58%????????????????????????????58*1+:6+265**:2+:65*2++:83*+:6+@+6:+*38:++2*56:+2:**56
+6:+1*58%????????????????????????????58*1+:6+265**:2+:65*2++:83*+:6+@+6:+*38:++2*56:+2:**562
6:+1*58%????????????????????????????58*1+:6+265**:2+:65*2++:83*+:6+@+6:+*38:++2*56:+2:**562+
:+1*58%????????????????????????????58*1+:6+265**:2+:65*2++:83*+:6+@+6:+*38:++2*56:+2:**562+6
+1*58%????????????????????????????58*1+:6+265**:2+:65*2++:83*+:6+@+6:+*38:++2*56:+2:**562+6:
1*58%????????????????????????????58*1+:6+265**:2+:65*2++:83*+:6+@+6:+*38:++2*56:+2:**562+6:+
*58%????????????????????????????58*1+:6+265**:2+:65*2++:83*+:6+@+6:+*38:++2*56:+2:**562+6:+1
58%????????????????????????????58*1+:6+265**:2+:65*2++:83*+:6+@+6:+*38:++2*56:+2:**562+6:+1*
8%????????????????????????????58*1+:6+265**:2+:65*2++:83*+:6+@+6:+*38:++2*56:+2:**562+6:+1*5
%????????????????????????????58*1+:6+265**:2+:65*2++:83*+:6+@+6:+*38:++2*56:+2:**562+6:+1*58

Try it online!
The output, even on quiet mode, is too much for tio, so if you want to run the verifier you will need to do so locally.

Doesn't actually produce the right string, but I'll mark as cracked anyways since it's not exactly hard to fix

Vyxal O, 548783 bytes, cracks EmanresuA's fourth answer
Sample:
\o\o"\o"\o"\o"\o"\o"\o"\o"\o"\o"\o"\o"\o"\o"\o"\o"\o"\o"\o"\o"\o"\o"\o"\o"\o"\o"\o"\o"\o"\o"\o"\o"\o"\o"\o"\o"\o"\o"\o"\o"\o"\o"\o"fLkZ:\o\o"\o"fL%"¯∑\o\o"\o"\o"\o"\o"\o"\o"\o"\o"\o"\o"\o"fL%Ė

Full program
Add any more characters, and we'll pass 1 million bytes probably.

Vyxal O, 309544 bytes, cracks EmanresuA's sixth answer
Sample:
\ommmmmmL⌐ȧ⌐ȧ⌐ȧ⌐ȧ⌐ȧ⌐ȧ⌐ȧ⌐ȧ⌐ȧ⌐ȧ⌐ȧ⌐ȧ⌐ȧ⌐ȧ⌐ȧ⌐ȧ⌐ȧ⌐ȧ⌐ȧ⌐ȧkAgkA⊍:g⊍gĖ

Full code
Yes.

Vyxal, 464251237 bytes' ,lyxal crakcs anser
Hey look, more negative numbers and indexing into printable ascii!

How negative numbers?
kokoĖPĖkokoĖPĖkoĖĖkPkPkPkPkoPkoĖĖPPPPPkokoĖPĖkokoĖPĖkoĖĖkPkPkoPkoĖĖPPPĖkoPPkPkPkPkPkoPkoĖĖPPPPPĖ

We can decrement to any number by stringing many of these snippets together into a series.
This is pretty much the same as emanresu A's way of getting negative numbers, but modified so as not to use 1.
Try it Online!
Why negative numbers tho?
Just like before, we can make use of the negative numbers by indexing into printable ascii. This time, the only builtin that has i in it is printable ascii, but getting the i from there would probably be difficult, and I'm lazy, so I took the easy way out: inf. It turns out, Vyxal is really cursed, so we can do a bit of magic and shenanigans with some floats and casting numbers to iterables and generate a float so absurdly large that it just becomes inf. That can be cast to a string and executed to let us index.
ko           # Push `01234567`
  Ė          # Execute, gives us 1234567
   Ė         # Reciprocal
    Ė        # Reciprocal, gives us 1234567.0
     s       # Sort, gives us inf
      koP    # Strip 01234567, casts to string
         Ė   # Execute
          o  # Remove the extra 0 that was pushed

Now that we have i and any negative number, we can index into our builtins to get useful stuff. For example, we can index into 01234567 to get 1, and we can index into printable ASCII to get + and C. We can use the 1+ over and over to increment a number, then use C to convert it to a character. (Yes, I know I could just push -1 and use - instead of +, which would be a lot shorter, but that's not as fun.)
Once we have the pieces, namely arbitrary negative numbers and indexing, creating a solution becomes trivial. Here's an example for printing !: apparently the link was too long so here's a gist of the program that you can copy into the interpreter wow can you believe im using the same joke twice thats crazy also you wont actually be able to run it online since its too long so youll have to run it offline

JavaScript (V8), cracks #236887 by emanresu A
three=~~Math.PI, two=~~Math.E, one=three^two
four=one<<two, fife=four|one, six=four|two, sefen=four|three, eight=one<<three
sixteen=one<<four, thirtytwo=one<<fife, sixtyfour=one<<six
print(String.fromCodePoint(sixtyfour | three<<three | three,
thirtytwo | eight | three, three << fife, thirtytwo | sefen, thirtytwo | two,
three << fife | three, sefen << four | six,thirtytwo | eight | fife,
...Array(...Array(eight|two).keys()).map(x=>x|three<<four),
thirtytwo | eight | two, sixtyfour | sixteen | eight | fife))

Try it online!

Nice, this is pretty much exactly what I had in mind.

Befunge-98 (FBBI), cracks ovs' answer.
#@'+1+:00p'<1+1k

The only significant trick user here is self-modifying the , used for output into existence; I generate the characters (and the aforementioned comma) by storing the character one code point lower and adding one to it.
Try it online!

R, 79 63 bytes, Robin Ryder's answer
x=pi*pi;cat(apropos("^.$")[c(T,sum(x,T),sum(x,pi))],F:x,sep='')

Try it online!
Being allowed to use () let me use apropos to grab the length-one function names, and then just index them to get the appropriate -/+.

Well done, beautiful solution! I didn't know about apropos until today.

Nice!  Interestingly, although this works on the TIO installation of R version 3.5.2 (and hence is a valid crack), it doesn't work on my own older installation of R version 3.2.1, under which apropos("^.$") lists the same set of function names in a completely different order.  No idea why.

Befunge-93, 123 bytes, cracks Ethan Chapman's answer
!:v+
 v>$$~!~!g~!!+~!!~!g~!!-:~!!-:~!!-:~!!-:~!!-:~!!-:~!!-:~!!-:~!!-:~!!-
v>~!!~!!+~!!+~!g~!!+:~!!~!!~!!+~!!+p
vx<
>:|
  @

Note that this code does read from the input, and will break if you someone manage to input null bytes, but it performs correctly on no input, and that is allowed. "A pain to implement" was a total understatement.
Try it online!

Ah, I hadn't though of reading from no input, that does make things slightly simpler. Still looks like it wasn't very fun though.

You could always add & and ~ to the banned character list and try again.

I think banning & would be more useful than @, but sure, I'll post it.

Yes, that was a typo on my part.

Note: I'm actually going to hold off on that new post because I want to see if I can make it a little harder first

I have an implementation in an app (so I can try it offline) which doesn't do anything with a ! with no input, but : works.

Sometimes you get so invested in coding something one way that you miss the obvious ... Oh, well, it works on TIO, and the cop post doesn't specify any interpreter, so this is a valid crack as is. (FYI @EthanChapman so the next answer you post isn't vulnerable to that trivial substitution.)

Python 2, 5271 4113 621 524 bytes, cracks Mukundan's answer
r=False+False
q=True+r
u=``[]``
s=``u``[q+q]
a=`r`
b=`q`
c=`q+q`
e=`q+q+q`
f=`q+q+q+q`
g=`q+q+q+q+q`
h=`q+q+q+q+q+q`
i=`q+q+q+q+q+q+q`
exec(eval(u[r]+s+b+g+b+s+b+g+g+s+b+h+a+s+b+g+i+s+b+h+c+s+b+h+f+s+a+f+a+s+b+h+e+s+b+i+b+s+b+h+e+s+a+i+e+s+b+h+e+s+b+i+b+s+b+h+e+s+a+g+h+s+b+h+e+s+b+h+f+s+b+f+f+s+b+g+i+s+b+h+g+s+b+h+f+s+a+g+h+s+b+h+i+s+b+h+c+s+b+g+b+s+b+h+f+s+b+f+g+s+a+g+a+s+a+f+i+s+a+f+c+s+b+e+f+s+a+f+i+s+a+h+a+s+a+h+b+s+a+h+c+s+a+h+e+s+a+h+f+s+a+h+g+s+a+h+h+s+a+h+i+s+a+i+a+s+a+i+b+s+b+f+f+s+b+h+f+s+a+f+i+s+a+g+b+u[r]))

Try it online!
I will try and golf this and add a better explanation, just wanted to get the crack out there.
Explanation
The basic idea is that in python2 ` can be used to get the string representation of an object.  From this we have 3 types of character we get

numbers.  We get numbers by adding booleans to get the desired number and then converting that to its representation.  We will also use the number method for indexing.
'.  We get this by getting the representation of False and then the representation of that string.  We then take the first character of that.
\.  We get this by taking the representation of True repeatedly until the representation has a backslash to escape a quote, we then index this.

From here we build the string
'\151\155\160\157\162\164\040\163\171\163\073\163\171\163\056\163\164\144\157\165\164\056\167\162\151\164\145\050\047\042\134\047\060\061\062\063\064\065\066\067\070\071\144\164\047\051'

Which is just a pile of octal escape codes for:
import sys;sys.stdout.write('"\'0123456789dt')

Which when run does the proper output.

May you give a documentation link about what ``` does in Python2, please?

@Kowalski I can't find the documentation but it is the same as repr which is documented.  It is similar to str except it gets the "representation" which is something that for ordinary types should eval to the value it is passed.

thanks, I know repr. I only know Python3.x and this syntax seems ugly.

APL (Dyalog Unicode), 112 bytes, Cracks Bubbler's answer
a←'a'(⎕NCREATE⍠'IfExists' 'Replace')0⋄117 118 85 86 ¯30 ¯108 ¯68⎕NREPLACE a 0⋄⍞←⊃⎕NGET'a'

Isn't too impressive I'm afraid, just writes the bytes to a file then reads it back as text. Couldn't use ⎕ARBOUT to write out the file because of the O, but ⎕NREPLACE works fine.
Try it online!

I had several ways to crack it, but didn't really think of using file I/O. Nice job.

Java, cracks @MCross's answer
public class Main { public static void main(String[] args) { System\u002eout\u002eprintln("" + (char)46 + (char)10); } }

Try it online!
Definitely not the intended solution, just abuses the unicode escaping technique in Java (\u002e gets interpreted as . by the compiler). Thanks to @user from the previous Java answer (now deleted) on the cop's thread where this was the intended approach.

Perl 5 + -p, cracks Dom Hastings's second answer
BEGIN { $. = ARGU; ++$.; $_ = z - z; @{$.} = $$_; }  $f = b; ++$f; $f .= hr; $_ = B; ++$_; $f = $_ . ORE . :: . $f;  $_ = &$f(hex(f) + hex(f) + $. + $. + $. + $.); $_ .= &$f(hex(f) + hex(e) + hex(a)); $_ .= &$f(hex(f) + hex(f) + hex(f) + $. + $.); $_ .= ($.-$.) . $. . ($.+$.) . ($.+$.+$.) . ($.+$.+$.+$.) . ($.+$.+$.+$.+$.) . ($.+$.+$.+$.+$.+$.) . ($.+$.+$.+$.+$.+$.+$.) . ($.+$.+$.+$.+$.+$.+$.+$.) . ($.+$.+$.+$.+$.+$.+$.+$.+$.); $_ .= &$f(hex(f) * ($.+$.+$.+$.)); $A = B; ++$A; $_ .= $A; $A = L; ++$A; $_ .= $A; $A = O; ++$A; $_ .= $A; ++$A; $_ .= $A; $A = R; ++$A; $_ .= $A; ++$A; $_ .= $A; $A = U; ++$A; $_ .= $A; $A = X; ++$A; $_ .= $A; $_ .= &$f(hex(f) * ($.+$.+$.+$.+$.+$.) + $. + $.); $_ .= &$f(hex(f) * ($.+$.+$.+$.+$.+$.) + $. + $. + $. + $.); $_ .= &$f(hex(f) * ($.+$.+$.+$.+$.+$.) + $. + $. + $. + $. + $. + $.); $a = b; ++$a; $_ .= $a; $a = l; ++$a; $_ .= $a; $a = o; ++$a; $_ .= $a; ++$a; $_ .= $a; $a = r; ++$a; $_ .= $a; ++$a; $_ .= $a; $a = u; ++$a; $_ .= $a; $a = x; ++$a; $_ .= $a; $_ .= &$f(hex(f) * ($.+$.+$.+$.+$.+$.+$.+$.) + $. + $. + $. + $.); $_ .= &$f(hex(f) * ($.+$.+$.+$.+$.+$.+$.+$.) + $. + $. + $. + $. + $. + $.);

The first part to read input from the script file is identical to my first crack. The second part constructs a reference to the chr built-in function using unquoted literals and the ++ operator on all-letters string variables.
#!/usr/bin/perl -p
BEGIN {
    # Set @ARGV to $0, a file that we know contains exactly one line.
    # This assumes that perl is invoked on a script file, not with -e.
    $. = ARGU; ++$.;
    $_ = z - z;
    @{$.} = $$_;
}
# For the expanded version only: only process the first line.
print "\n" and exit if $line++;

# Set $f to "CORE::chr". We can then call chr as &$f(NUMERIC_VALUE).
$f = b; ++$f; $f .= hr; $_ = B; ++$_; $f = $_ . ORE . :: . $f;

# We have $. == 1 and we're allowed to use + which makes building all
# positive integers trivial. This code uses a few shortcuts.
$_ = &$f(hex(f) + hex(f) + $. + $. + $. + $.);
$_ .= &$f(hex(f) + hex(e) + hex(a));
$_ .= &$f(hex(f) + hex(f) + hex(f) + $. + $.);
$_ .= ($.-$.) . $. . ($.+$.) . ($.+$.+$.) . ($.+$.+$.+$.) . ($.+$.+$.+$.+$.) . ($.+$.+$.+$.+$.+$.) . ($.+$.+$.+$.+$.+$.+$.) . ($.+$.+$.+$.+$.+$.+$.+$.) . ($.+$.+$.+$.+$.+$.+$.+$.+$.);
$_ .= &$f(hex(f) * ($.+$.+$.+$.));
$A = B; ++$A; $_ .= $A;
$A = L; ++$A; $_ .= $A;
$A = O; ++$A; $_ .= $A; ++$A; $_ .= $A;
$A = R; ++$A; $_ .= $A; ++$A; $_ .= $A;
$A = U; ++$A; $_ .= $A;
$A = X; ++$A; $_ .= $A;
$_ .= &$f(hex(f) * ($.+$.+$.+$.+$.+$.) + $. + $.);
$_ .= &$f(hex(f) * ($.+$.+$.+$.+$.+$.) + $. + $. + $. + $.);
$_ .= &$f(hex(f) * ($.+$.+$.+$.+$.+$.) + $. + $. + $. + $. + $. + $.);
$a = b; ++$a; $_ .= $a;
$a = l; ++$a; $_ .= $a;
$a = o; ++$a; $_ .= $a; ++$a; $_ .= $a;
$a = r; ++$a; $_ .= $a; ++$a; $_ .= $a;
$a = u; ++$a; $_ .= $a;
$a = x; ++$a; $_ .= $a;
$_ .= &$f(hex(f) * ($.+$.+$.+$.+$.+$.+$.+$.) + $. + $. + $. + $.);
$_ .= &$f(hex(f) * ($.+$.+$.+$.+$.+$.+$.+$.) + $. + $. + $. + $. + $. + $.);

# $_ will be printed thanks to -p

Try it online!

R, cracks Robin Ryder's challenge
The string to print is
t <-
"0123456789=[\\]^_`v"

We're not allowed to use the digits 0 to 9, but we can make numbers using sum and T
(+T) # 1
(T+T) # 2
(T+T+T) # 3
# ...and so on

We'll need the numbers 116,32,60,45,10,34,48,49,50,51,52,53,54,55,56,57,61,91,92,93,94,95,96,118 and 34, which are the ASCII values of all the characters in the string to print.
I'm not going to make them now *, so I hope you, dear reader, will trust that I could.
Now, we use these numbers inside the following program (substitute each number for sum(T+T+...+T+T)):
do.call(el(ls(9),297),lapply(do.call(apropos('in.ToU.f'),lapply(F,pmax,(c(116,32,60,45,10,34,48,49,50,51,52,53,54,55,56,57,61,91,92,93,94,95,96,118,34)))),c))

Try it online! * with numbers correctly substituted for (T+T...+T) expressions
How?

We convert the vector of numbers c(116,...34) into a list using lapply(F,pmax,...)
Then we use this as an argument to do.call(apropos('in.ToU.f'),...), which calls the function intToUtf8()
Finally, we send the output to cat.  Since cat contains a 't' we can't call it directly, so we look it up in the list ls(9) of all functions.  It's number 297 in the TIO installation of R.

You could just do +T for 1, +T+T for 2, and so forth. No need to wrap it into a sum!

You're right, of course, and that's more elegant!  I got lazy and just left the first thing that came into my head because there's no golfing incentive.

Java, cracks @user's answer
import java.io.*;

public class Main {
    public static void main(String[] args) {
        PrintStream out =  new PrintStream(new FileOutputStream(FileDescriptor.out));
        out.println(""+(char)121+(char)67+(char)92);
    }
}

Try it online!
There's more than one way to get standard out (although the FileDescriptor reference needs to be converted to a PrintStream first).

This is exactly how I did it

JavaScript (Browser), cracks Sparkles the Unicorn's second answer
eval('a=1<<1+1+1+1+1+1;b=1+1+1<<1+1+1+1;console.log(S'+(!!1+'').slice(1-1,1)+'ring.'+(!1+'').slice(1-1,1)+'romCharCode(++a,++a,a+=1+1,++a,++a,++a,a+=1+1,a+=1+1+1+1+1,++a,++a,++a,a+=1+1+1,++a,++a,a+=1+1+1,++a,b+=1+1,++b,++b,++b,++b,++b,++b,++b,b-11+1+1,111+1+1+1+1+1,111-11+1+1,++a))')

Try it online!
Because [] is banned, we use string method .slice instead to grab the t and f, and then we have String.fromCharCode again. I use some variables to make it easier to build the numbers, but it would technically work with simple 1+1+1+... too.

Wolfram Language (Mathematica), 1422 bytes, cracks att's answer
this question is named incorrectly, we're actually the cops, trying to prevent all those evil newcomers from posting challenges we don't like /s
This is just escape sequences for Print@FromCharacterCode@{97, 98, 100, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 10, 123, 32, 60, 45, 62, 32, 44, 32, 126, 44, 32, 38, 125, 91, 40, 42, 64, 41, 91, 93, 93, 10}.
\:0050\:0072\:0069\:006E\:0074\:0040\:0046\:0072\:006F\:006D\:0043\:0068\:0061\:0072\:0061\:0063\:0074\:0065\:0072\:0043\:006F\:0064\:0065\:0040\:007B\:0039\:0037\:002C\:0020\:0039\:0038\:002C\:0020\:0031\:0030\:0030\:002C\:0020\:0031\:0030\:0032\:002C\:0020\:0031\:0030\:0033\:002C\:0020\:0031\:0030\:0034\:002C\:0020\:0031\:0030\:0035\:002C\:0020\:0031\:0030\:0036\:002C\:0020\:0031\:0030\:0037\:002C\:0020\:0031\:0030\:0038\:002C\:0020\:0031\:0030\:0039\:002C\:0020\:0031\:0031\:0030\:002C\:0020\:0031\:0031\:0031\:002C\:0020\:0031\:0031\:0032\:002C\:0020\:0031\:0031\:0033\:002C\:0020\:0031\:0031\:0034\:002C\:0020\:0031\:0031\:0035\:002C\:0020\:0031\:0031\:0036\:002C\:0020\:0031\:0031\:0037\:002C\:0020\:0031\:0031\:0038\:002C\:0020\:0031\:0031\:0039\:002C\:0020\:0031\:0032\:0030\:002C\:0020\:0031\:0032\:0031\:002C\:0020\:0031\:0032\:0032\:002C\:0020\:0031\:0030\:002C\:0020\:0031\:0032\:0033\:002C\:0020\:0033\:0032\:002C\:0020\:0036\:0030\:002C\:0020\:0034\:0035\:002C\:0020\:0036\:0032\:002C\:0020\:0033\:0032\:002C\:0020\:0034\:0034\:002C\:0020\:0033\:0032\:002C\:0020\:0031\:0032\:0036\:002C\:0020\:0034\:0034\:002C\:0020\:0033\:0032\:002C\:0020\:0033\:0038\:002C\:0020\:0031\:0032\:0035\:002C\:0020\:0039\:0031\:002C\:0020\:0034\:0030\:002C\:0020\:0034\:0032\:002C\:0020\:0036\:0034\:002C\:0020\:0034\:0031\:002C\:0020\:0039\:0031\:002C\:0020\:0039\:0033\:002C\:0020\:0039\:0033\:002C\:0020\:0031\:0030\:007D

I really hope this is not the intended solution, but then I ran
Names[] ~ Select ~ (ContainsNone[Characters@#, Characters@"abdfghijklmnopqrstuvwxyz"]&)

, and, ignoring random unicode characters, this is the output: FE`AC, FE`c, C, CDF, D, FE`e, E, FE`e$, FE`FT, FE`FTU, GCD, I, K, LCM, N, O, PDF, Re, FE`SC, Sec, URL, Vee, FE`WW, and the only way to call any of this stuff seems to be //.
Try it online!

Not the intended solution. Didn't block capital letters, whoops.

Actually, now that I think about it I'm skeptical whether it's possible to prevent purely escape-sequence solutions without blocking some digits, (and, in this case, especially when e allows CharacterRange). Back to the drawing board we go.

SimpleTemplate, 175 bytes, cracks @IsmaelMiguel's answer
{@set j "b"}{@set k "{@in\x63 j}"}{@eval k}{@print j}{@set j "g"}{@set k "{@in\x63 j}"}{@eval k}{@print j}{@set j "n"}{@set k "{@in\x63 j}"}{@eval k}{@print j}{@print VERSION}

Try it online!
I had a hunch that 0.84 would be a hardcoded version number, and so it was. Then I just needed a way to get cho. The natural way to do this is with inc (increment) acting on b, g, and n, but without c I had to take the slightly longer eval route to get there.

Incidentally, I believe I found a bug along the way: replace every j with an i and cho disappears from the output. From a small sample of other letters, i seems to be the only one that produces the bug.

O.o That's way more complicated than I expected it to be. But you were super close to the intented solution! And yes, the 0.84 is indeed the version number. Regarding the bug, I will try to check it.

@IsmaelMiguel For cho, my first thought was actually to index into a list of functions to get echo and then somehow remove the e. But I don't speak PHP and couldn't find a way to do it (if it's even possible).

It is entirely possible, but you don't need PHP for it. In PHP, you do $fns = get_defined_functions()["int\x65rnal"]; print($fns[1][3] . $fns[9][3] . $fns[16][4]);. In my language, you can do {@set j "{@call get_defined_fun\x63ti\x6fns into x}{@set k \"int\x65rnal\"}{@set x x.[k]}"}{@eval j}{@print "#{x.1.3}#{x.9.3}#{x.16.4}#{VERSION}"} (it includes the version number) as well.

Fortran (GFortran), cracks Dingus's answer
      INTEGER :: Izero = AND(BIT_SIZE(Izero), NOT(BIT_SIZE(Izero)))
      CHARACTER(BIT_SIZE(Izero)) :: out
      CHARACTER(BIT_SIZE(Izero)) :: fmt
      I = IBSET(Izero, Izero)
      I_ = SHIFTL(I, I)
      I__ = SHIFTL(I_, I)
      I___ = SHIFTL(I__, I)
      I____ = SHIFTL(I___, I)
      I_____ = SHIFTL(I____, I)
      I______ = SHIFTL(I_____, I)
      J=I
      K=OR(I___,I_____)
      fmt(J:J) = ACHAR(K)
      J=I_
      K=OR(I,I______)
      fmt(J:J) = ACHAR(K)
      J=OR(I,I_)
      K=OR(OR(I,I____),I_____)
      fmt(J:J) = ACHAR(K)
      J=I__
      K=OR(OR(I___,I____),I_____)
      fmt(J:J) = ACHAR(K)
      J=OR(I,I__)
      K=OR(OR(I,I___),I_____)
      fmt(J:J) = ACHAR(K)
      J=I
      K=OR(I____,I______)
      out(J:J) = ACHAR(K)
      J=I_
      K=OR(OR(I____,I_____),I______)
      out(J:J) = ACHAR(K)
      J=OR(I,I_)
      K=OR(OR(I,I____),I_____)
      out(J:J) = ACHAR(K)
      J=I__
      K=OR(OR(I_,I____),I_____)
      out(J:J) = ACHAR(K)
      J=OR(I,I__)
      K=OR(OR(OR(I,I_),I____),I_____)
      out(J:J) = ACHAR(K)
      J=OR(I_,I__)
      K=OR(OR(I__,I____),I_____)
      out(J:J) = ACHAR(K)
      J=OR(OR(I,I_),I__)
      K=OR(OR(OR(I,I__),I____),I_____)
      out(J:J) = ACHAR(K)
      J=I___
      K=OR(OR(OR(I_,I__),I____),I_____)
      out(J:J) = ACHAR(K)
      J=OR(I,I___)
      K=OR(OR(OR(OR(I,I_),I__),I____),I_____)
      out(J:J) = ACHAR(K)
      J=OR(I_,I___)
      K=OR(OR(I___,I____),I_____)
      out(J:J) = ACHAR(K)
      J=OR(OR(I,I_),I___)
      K=OR(OR(OR(I,I___),I____),I_____)
      out(J:J) = ACHAR(K)
      J=OR(I__,I___)
      K=OR(I____,I_____)
      out(J:J) = ACHAR(K)
      J=OR(OR(I,I__),I___)
      K=OR(OR(OR(I,I_),I__),I_____)
      out(J:J) = ACHAR(K)
      J=OR(OR(I_,I__),I___)
      K=OR(I_,I_____)
      out(J:J) = ACHAR(K)
      J=OR(OR(OR(I,I_),I__),I___)
      K=OR(OR(OR(I,I_),I___),I_____)
      out(J:J) = ACHAR(K)
      J=I____
      K=OR(OR(OR(I,I__),I___),I_____)
      out(J:J) = ACHAR(K)
      J=OR(I,I____)
      K=OR(OR(I_,I___),I_____)
      out(J:J) = ACHAR(K)
      J=OR(I_,I____)
      K=OR(OR(OR(OR(I,I_),I__),I___),I_____)
      out(J:J) = ACHAR(K)
      WRITE(OR(I_,I__), fmt) out
      END

Try it online!
Encoding integers without digits was tedious so I used a generator script.
#!/usr/bin/env perl
use warnings;
use strict;

my $output = 'Pp1234567890\'"+-*/';

# Izero = 0, I = 1, I_ = 2, I__ = 4, I___ = 8, ...
sub encode_integer {
    my ($n) = @_;
    if ($n == 0) {
        return 'Izero';
    }
    my $k = 0;
    while (($n & 1) == 0) {
        $n >>= 1;
        ++$k;
    }
    my $expr = 'I' . '_' x $k;
    while ($n != 0) {
        $n >>= 1;
        ++$k;
        if ($n & 1) {
            $expr = sprintf('OR(%s,%s)', $expr, 'I' . '_' x $k);
        }
    }
    return $expr;
}

sub set_char {
    my ($variable, $pos, $num) = @_;
    return <<EOF;
J=$pos
K=$num
$variable(J:J) = ACHAR(K)
EOF
}

sub build_string {
    my ($variable, $string) = @_;
    my @chars = split(//, $string);
    my $result = '';
    foreach my $i (1..@chars) {
        $result .= set_char($variable, $i, ord($chars[$i-1]));
    }
    return $result;
}

my $header = <<'EOF';
INTEGER :: 0 = AND(BIT_SIZE(0), NOT(BIT_SIZE(0)))
CHARACTER(BIT_SIZE(0)) :: out
CHARACTER(BIT_SIZE(0)) :: fmt
1 = IBSET(0, 0)
2 = SHIFTL(1, 1)
4 = SHIFTL(2, 1)
8 = SHIFTL(4, 1)
16 = SHIFTL(8, 1)
32 = SHIFTL(16, 1)
64 = SHIFTL(32, 1)
EOF

my $footer = <<'EOF';
WRITE(6, fmt) out
END
EOF

my $code = ($header .
            build_string('fmt', sprintf('(A%d)', length($output))) .
            build_string('out', $output) .
            $footer);
$code =~ s/[0-9]+/encode_integer($&)/eg;
$code =~ s/^/      /mg;
print $code;

The most basic way to print something in Fortran is PRINT but that's forbidden. GFortran has a more convenient function FPUT to print a character but it's also forbidden. We'll have to use WRITE. Its syntax is WRITE(unit, format) data where unit designates the output file, format describes how to format the output, and data is the data to write. WRITE adds a trailing newline so we'll have to produce the output in one go.
The unit can be either * meaning the default output, or an expression that returns an integer. Since * is forbidden, we need an integer. Standard output is unit 6.
The format can be either * or some specifications in parentheses. It can be written literally in the source code or can come dynamically from a string varible. We'll need forbidden characters in the format so it'll have to be dynamic, in the variable fmt. We want to print 18 characters so the format is (A18).
This leaves the problem of constructing strings. We can construct individual characters from their value with ACHAR, and set the characters of a string variable one at a time. So all that remains is to construct integers.
Modern Fortran has bitwise operations on integers. I used SHIFTL and OR (IOR in standard Fortran) to construct integers from 0 and 1. For 1, I used IBSET. For 0, I used AND of two integers. Finding an integer to start with took me a bit of time because I was looking for a compile-time constant, although that turned out to be unnecessary in the end; I could have used something like TIME(). The expressions can get big, and classic Fortran (without the forbidden PROGRAM has a line length limit, so I define constants for powers of 2 and intermediate variable while setting a character of a string).
To declare the strings, I needed to express their length (or more precisely their storage size which could be larger than the effective length) as a compile-time constant without using digits. I finally stumbled on BIT_SIZE which is conveniently larger than the size I needed (32 >= 18, 6).

Well done. Bang on with the approach.

Rust, cracks madlaina's (edited) answer
extern "C" {
    fn system(x: &str) -> &str;
}

fn main() {
    unsafe {
        system("echo -en '\x70\x77'");
    }
}

Relies on undefined behavior (C string != &str) but it seems to work.
Try it online!

That's very creative! Not the solution I had in mind though, so I'll post an updated version.

Perl 5, cracks @Gilles 'SO- stop being evil''s answer 10359 bytes
Note that the link below includes /, but the code for Perl 5.20.3 uses ? instead to meet the rules. TIO has a newer Perl and doesn't support the ?...? syntax.
[$_=[$?..$=]]&[$__=$$_[//]]&[$_=[$__..$=]]&[$___=$$_[//]]&[$_=[$___..$=]]&[$____=$$_[//]]&[$_=[$____..$=]]&[$_____=$$_[//]]&[$_=[$_____..$=]]&[$______=$$_[//]]&[$_=[$______..$=]]&[$_______=$$_[//]]&[$_=[$_______..$=]]&[$________=$$_[//]]&[$_=[$________..$=]]&[$_________=$$_[//]]&[$_=[$_________..$=]]&[$__________=$$_[//]]&/./&[$_=[$&.._]]&[$___________=$$_[$?]]&[$_=[$___________.._]]&[$____________=$$_[//]]&[$_=[$____________.._]]&[$_____________=$$_[//]]&[$_=[$_____________.._]]&[$______________=$$_[//]]&[$_=[$______________.._]]&[$_______________=$$_[//]]&[$_=[$_______________.._]]&[$________________=$$_[//]]&[$_=[$________________.._]]&[$_________________=$$_[//]]&[$_=[$_________________.._]]&[$__________________=$$_[//]]&[$_=[$__________________.._]]&[$___________________=$$_[//]]&[$_=[$___________________.._]]&[$____________________=$$_[//]]&[$_=[$____________________.._]]&[$_____________________=$$_[//]]&[$_=[$_____________________.._]]&[$______________________=$$_[//]]&[$_=[$______________________.._]]&[$_______________________=$$_[//]]&[$_=[$_______________________.._]]&[$________________________=$$_[//]]&[$_=[$________________________.._]]&[$_________________________=$$_[//]]&[$_=[$_________________________.._]]&[$__________________________=$$_[//]]&[$_=[$__________________________.._]]&[$___________________________=$$_[//]]&[$_=[$___________________________.._]]&[$____________________________=$$_[//]]&[$_=[$____________________________.._]]&[$_____________________________=$$_[//]]&[$_=[$_____________________________.._]]&[$______________________________=$$_[//]]&[$_=[$______________________________.._]]&[$_______________________________=$$_[//]]&[$_=[$_______________________________.._]]&[$________________________________=$$_[//]]&[$_=[$________________________________.._]]&[$_________________________________=$$_[//]]&[$_=[$_________________________________.._]]&[$__________________________________=$$_[//]]&[$_=[$__________________________________.._]]&[$___________________________________=$$_[//]]&[$_=[$___________________________________.._]]&[$____________________________________=$$_[//]]&[$_=$#_]&/./&[$_______________________________________________________________=$&]&[$________________________________________________________________=$_______________________________________________________________&$$__.$__]&[$_=$$________________________________________________________________=$_____]&/...$/&[$_=$&]&/./&[$_____________________________________=$&]&[$_=[$_____________________________________.._]]&[$______________________________________=$$_[//]]&[$_=[$______________________________________.._]]&[$_______________________________________=$$_[//]]&[$_=[$_______________________________________.._]]&[$________________________________________=$$_[//]]&[$_=[$________________________________________.._]]&[$_________________________________________=$$_[//]]&[$_=[$_________________________________________.._]]&[$__________________________________________=$$_[//]]&[$_=[$__________________________________________.._]]&[$___________________________________________=$$_[//]]&[$_=[$___________________________________________.._]]&[$____________________________________________=$$_[//]]&[$_=[$____________________________________________.._]]&[$_____________________________________________=$$_[//]]&[$_=[$_____________________________________________.._]]&[$______________________________________________=$$_[//]]&[$_=[$______________________________________________.._]]&[$_______________________________________________=$$_[//]]&[$_=[$_______________________________________________.._]]&[$________________________________________________=$$_[//]]&[$_=[$________________________________________________.._]]&[$_________________________________________________=$$_[//]]&[$_=[$_________________________________________________.._]]&[$__________________________________________________=$$_[//]]&[$_=[$__________________________________________________.._]]&[$___________________________________________________=$$_[//]]&[$_=[$___________________________________________________.._]]&[$____________________________________________________=$$_[//]]&[$_=[$____________________________________________________.._]]&[$_____________________________________________________=$$_[//]]&[$_=[$_____________________________________________________.._]]&[$______________________________________________________=$$_[//]]&[$_=[$______________________________________________________.._]]&[$_______________________________________________________=$$_[//]]&[$_=[$_______________________________________________________.._]]&[$________________________________________________________=$$_[//]]&[$_=[$________________________________________________________.._]]&[$_________________________________________________________=$$_[//]]&[$_=[$_________________________________________________________.._]]&[$__________________________________________________________=$$_[//]]&[$_=[$__________________________________________________________.._]]&[$___________________________________________________________=$$_[//]]&[$_=[$___________________________________________________________.._]]&[$____________________________________________________________=$$_[//]]&[$_=[$____________________________________________________________.._]]&[$_____________________________________________________________=$$_[//]]&[$_=[$_____________________________________________________________.._]]&[$______________________________________________________________=$$_[//]]&[$___________________________________________________________________=$$___.$________]&[$________________________________________________________________=$___________________________________________________________________&$___________________________________________]&[$_________________________________________________________________=$_____________.$_________________________.$____________________________.$_______________.$________________________________________________________________.$_________________________________________.$__________________________________________________________.$_____________________________________.$________________________________________________.$______________________________________.$_____________________________________________________________.$________________________________________________________.$_________________________________________.$_______________________________________________________]&[$___________________________________________________________________=$$___.$________]&[$__________________________________________________________________=$___________________________________________________________________&$____________________________________________]&[$____________________________________________________________________=$_____________.$_________________________.$____________________________.$_______________.$________________________________________________________________.$_______________________________________.$____________________________________________.$______________________________________________________]&[]&[$_=$_____.$_____]&[$_____________________________________________________________________=&$____________________________________________________________________]&[$_=$_____.$_______]&[$______________________________________________________________________=&$____________________________________________________________________]&[$_=$____________________________________________________.$______________________________________________________.$_____________________________________________.$__________________________________________________.$________________________________________________________.$__________________________________________________________________.$_________________________________________________.$_____________________________________.$____________________________________________________.$__________________________________________________________________.$_______________________________________.$____________________________________________.$______________________________________________________.$_____________________________________________________________________.$_______.$_____________________________________________________________________.$__.$______.$_____________________________________________________________________.$___.$___.$_____________________________________________________________________.$___.$_____.$_____________________________________________________________________.$____.$____.$_____________________________________________________________________.$____.$_____.$_____________________________________________________________________.$____.$________.$_____________________________________________________________________.$____.$__________.$_____________________________________________________________________.$_____.$?.$_____________________________________________________________________.$_____.$___.$_____________________________________________________________________.$_____.$____.$_____________________________________________________________________.$_____.$_____.$_____________________________________________________________________.$_____.$______.$_____________________________________________________________________.$_____.$________.$______________________________________________________________________.$______________________________________________________________________.$_______.$?.$_____________________________________________________________________.$_______.$___.$_____________________________________________________________________.$_______.$_____.$______________________________________________________________________.$______________________________________________________________________.$__________.$?.$_____________________________________________________________________.$__________.$_____.$_____________________________________________________________________.$__________.$_______.$______________________________________________________________________.$______________________________________________________________________.$__.$___.$_____.$_____________________________________________________________________.$__.$___.$_______]& &$_________________________________________________________________

Try it online!
Explanation
Well, that was fun!
I think I've cracked this in a REALLY inefficient way, but the journey was fun. The hardest part here was also generating the lowercase letters. The main mechanism here is using ranges and getting the next element in the range. Since ( and ) aren't available and @ isn't available to store lists it's necessary to use [ and ] for array references. These can be stored like:
[$_=[$?..$=]]&[$__=$$_[//]]

In this, $_ contains a reference to an array containing a range from 0 ($?) to 60 ($=). Then $__ is set to the //th (1st) index of the dereferenced array $_ via $$_, which is one. Then the same process is repeated for the rest of the digits.
After getting the digits, the next item on my hitlist was the uppercase letters, which were acquired by using $_ which is an array reference (similar to my previous crack) so /./ would capture A in $&, then using the same reference mechanism as used for the digits, I create a range from A to _ and extract the 1st index, then do the same for B to _, etc.
To get the lowercase letters I was stumped for some time. I feel I was missing something fairly obvious, but when looking for a way to generate NaN or Inf, I read some documentation about $! which, when you store a number in it, returns the error string for that error number. I get "!" as "-"&"1", with "-" obtained from $#_ which is -1. In this code, I set $! to 4 which returns Interrupted system call. From here it's possible to extract a by storing $! in $_ and matching against /...$/ (which leaves all in $& and then juggling with $_ it's easy to get a and use the same approach used to get the uppercase with array references and dereferencing.
Once all the numbers and letters are available, it's easy to generate ' with g&"7" and call any methods we need. To output the string, the codepoints are mapped over with chr and passed as a list of args to print.

Oh, I hadn't thought of getting - from $#_, and from that !. $! was going to be my next trick to get lowercase letters without []. In this challenge, you missed a very simple way to get a lowercase letter: the same place you got an uppercase letter! [] stringified is ARRAY(0x...). I missed this one too for a while and tried to reach Inf, but then I realized it was there all along.

I did get the x but wasn't able to get low enough in the alphabet to get what I needed... I must've missed something there! That was a journey though. I also redid $^X and the other control chars with stringwise AND, and looked at @INC but that all seemed too flakey! I'm gonna go back and check my work on x!

Ahhhh, the last three chars appear to be consistent! Which would provide access to e... Is that what you had?

$_ = "x"; $_ = [$_ .. $_ . $_]; $_ = $$_[3]; /./ gives you a from x

Of course! How could I miss that! Hah!

><>, cracks HighlyRadioactive's fourth answer
ii*:-ii*:ii*+:ii*+:ii*+:ii*+:ii*+:ii*+:ii*+:ii*+nnnnnnnnnnr'`'ii*+:ii*+:ii*+:ii*+:ii*+:ii*+'%'ii*+'k'ii*+'n'ii*+'k'ii*+'n'ii*+ii*ii*pv
> <                                                                                r<

Exits with an error, but when using the right interpreter (e.g. this), it's not actually output.

Still not intended... Why did I miss so many solutions?

@HighlyRadioactive give up yet?

No I'm gonna force you into a short solution

@HighlyRadioactive alright then. Round 5 it is.

This is record-breaking I believe... I have two solutions in round 5, so we'll have round 6

><>, -v 1, cracks HighlyRadioactive's sixth answer
:::-n:n::+n:::++n::::+++n:::::++++n::::::+++++n:::::::++++++n::::::::+++++++n:::::::::++++++++n:+:+:+:+:::::++++++:::,+:::,+:::,+:::,+:::,+::,:+:+:+:+:+::,+::,+::,+::,+::,+::,:::::::::+++++++++:*::,:::::::++++++++:::,::+++:::,:::::+++++-::,:+:+:+:+:+::,:++:::,::::+++++$::,::::::::::+++++++++:*::,::::::::::+++++++++++::,:pv
> <                                                                                r~<

Try it online!
So guys, we did it. Funny thing is that I had the program cracked last night but I had to sleep before posting it.
Also, I'm starting to suspect there isn't actually a terse intended solution and that this is rather an excuse to make people write fish as if they're writing 1+. Gosh hecking dang it.
Oh, and one last thing: this crack and post was 100% written on my phone. That means I painstakingly hand typed all those colons, commas and plus signs.

+1 for doing all this on your phone. Let's HighlyRadioactive keeps the challenges coming - this is very entertaining

"Also, I'm starting to suspect there isn't actually a terse intended solution and that this is rather an excuse to make people write fish as if they're writing 1+. Gosh hecking dang it." Nope - the previous ones do have a terse solution and I'll post it later. This is not part of my 1+ promotion. BTW, I realized this round is invalid (since you are required to point out the command line option in the cop) sorry. New challenge.

PHP <7.0, 34 bytes
I think that <% also works, but I couldn't get that working on an online interpreter, so this is fine. Also, g^X works, but STDERR and STDOUT are mixed on that site. Should also technically be possible with something like <%=~\xc0 for 5 bytes.
<script language="php">echo"\x3f";

Try it online!

Setanta, cracks @bb94's answer
scríobh(go_téacs(go_uimh("a"))[0]+go_téacs(scríobh)[1]+go_téacs(cmhcht@mata(10,1000))[0])

Try it
This was harder than I expected. After reading the docs and poking around in the source I couldn’t find an obvious way to do any of the following: (i) convert ASCII codes to characters, (ii) create character ranges, (iii) convert text to uppercase, (iv) use octal/hex escapes, (v) get uppercase characters from names of built-ins/predefined variables, (vi) increment/decrement a string, or (vii) call an equivalent of eval.
Things were looking pretty hopeless until I somewhat accidentally discovered that calling go_uimh (convert numeric string to number) on an alphabetic string yields NaN. Could I grab the N from NaN? Yes, by first converting NaN to text with go_téacs, then indexing into the string.
The space was comparatively straightforward. There's an example in the tutorial that shows what happens when go_téacs is called on a gníomh (literally, action; equivalent to a method/function in other languages): go_téacs(scríobh) == "< gníomh scríobh >". The space is extracted by indexing into this string.
Now for the I. Following my experience with NaN I had a hunch that I was looking for a way to generate Infinity. Sure enough, cmhcht@mata(10,1000) (which attempts to calculate \$10^{1000}\$) does just that.

Python 3, 913 bytes, Cracks M Virts' answer
__builtins__.__dict__[str().join(chr(e)for e in[101,120,101,99])](str().join(chr(e)for e in[112,114,105,110,116,40,(29).__add__(10),9,92,49,(52).__add__(1),11,12,14,15,16,(16).__add__(1),18,19,20,21,22,(22).__add__(1),24,25,26,(26).__add__(1),28,29,(29).__add__(1),(29).__add__(2),(29).__add__(4),(29).__add__(5),(29).__add__(6),(28).__add__(8),(29).__add__(8),(29).__add__(9),92,(29).__add__(10),42,(42).__add__(1),45,(46).__add__(1),51,55,58,59,60,61,62,(62).__add__(1),64,65,66,(66).__add__(1),68,69,(69).__add__(1),(69).__add__(2),(68).__add__(4),(69).__add__(4),(69).__add__(5),(69).__add__(6),(68).__add__(8),(69).__add__(8),(69).__add__(9),(69).__add__(10),80,81,82,(82).__add__(1),84,85,86,(86).__add__(1),88,89,90,92,94,96,(99).__add__(8),109,112,(112).__add__(1),118,119,120,121,122,(122).__add__(1),124,125,126,(126).__add__(1),(29).__add__(10),44,101,110,100,61,(29).__add__(10),(29).__add__(10),41]))

Try it online!
This is decently straightforward. I create a list of character codes, using __add__ to avoid 3s and 7s, I convert this to a list of strings with a comprehension, use str().join to make it into one string.  To execute it I used this trick to get a dictionary of all builtin functions and indexed exec by building the string 'exec' the same way as the code string.
exec always feels a bit like cheating to me, and we could just use print if the output ended in a newline, but without an = sign I don't know how to print without a newline.  If anyone knows how to do this without exec I think that would be neat.

Lua, 9071 bytes, cracks @LuaNoob's answer
_G[([[]]).char(#[[.........................................................................................................]])..([[]]).char(#[[...............................................................................................................]])][([[]]).char(#[[.......................................................................................................................]])..([[]]).char(#[[..................................................................................................................]])..([[]]).char(#[[.........................................................................................................]])..([[]]).char(#[[....................................................................................................................]])..([[]]).char(#[[.....................................................................................................]])](([[]]).char(#[[................................]])..([[]]).char(#[[.................................]])..([[]]).char(#[[..................................]])..([[]]).char(#[[....................................]])..([[]]).char(#[[.....................................]])..([[]]).char(#[[......................................]])..([[]]).char(#[[.......................................]])..([[]]).char(#[[..........................................]])..([[]]).char(#[[...........................................]])..([[]]).char(#[[............................................]])..([[]]).char(#[[.............................................]])..([[]]).char(#[[...............................................]])..([[]]).char(#[[................................................]])..([[]]).char(#[[.................................................]])..([[]]).char(#[[..................................................]])..([[]]).char(#[[...................................................]])..([[]]).char(#[[....................................................]])..([[]]).char(#[[.....................................................]])..([[]]).char(#[[......................................................]])..([[]]).char(#[[.......................................................]])..([[]]).char(#[[........................................................]])..([[]]).char(#[[.........................................................]])..([[]]).char(#[[..........................................................]])..([[]]).char(#[[...........................................................]])..([[]]).char(#[[............................................................]])..([[]]).char(#[[..............................................................]])..([[]]).char(#[[...............................................................]])..([[]]).char(#[[................................................................]])..([[]]).char(#[[.................................................................]])..([[]]).char(#[[..................................................................]])..([[]]).char(#[[...................................................................]])..([[]]).char(#[[....................................................................]])..([[]]).char(#[[.....................................................................]])..([[]]).char(#[[......................................................................]])..([[]]).char(#[[........................................................................]])..([[]]).char(#[[.........................................................................]])..([[]]).char(#[[..........................................................................]])..([[]]).char(#[[...........................................................................]])..([[]]).char(#[[............................................................................]])..([[]]).char(#[[.............................................................................]])..([[]]).char(#[[..............................................................................]])..([[]]).char(#[[...............................................................................]])..([[]]).char(#[[................................................................................]])..([[]]).char(#[[.................................................................................]])..([[]]).char(#[[..................................................................................]])..([[]]).char(#[[...................................................................................]])..([[]]).char(#[[....................................................................................]])..([[]]).char(#[[.....................................................................................]])..([[]]).char(#[[......................................................................................]])..([[]]).char(#[[.......................................................................................]])..([[]]).char(#[[........................................................................................]])..([[]]).char(#[[.........................................................................................]])..([[]]).char(#[[..........................................................................................]])..([[]]).char(#[[............................................................................................]])..([[]]).char(#[[..............................................................................................]])..([[]]).char(#[[................................................................................................]])..([[]]).char(#[[..................................................................................................]])..([[]]).char(#[[....................................................................................................]])..([[]]).char(#[[.....................................................................................................]])..([[]]).char(#[[......................................................................................................]])..([[]]).char(#[[.......................................................................................................]])..([[]]).char(#[[.........................................................................................................]])..([[]]).char(#[[..........................................................................................................]])..([[]]).char(#[[...........................................................................................................]])..([[]]).char(#[[............................................................................................................]])..([[]]).char(#[[.............................................................................................................]])..([[]]).char(#[[..............................................................................................................]])..([[]]).char(#[[...............................................................................................................]])..([[]]).char(#[[................................................................................................................]])..([[]]).char(#[[.................................................................................................................]])..([[]]).char(#[[...................................................................................................................]])..([[]]).char(#[[....................................................................................................................]])..([[]]).char(#[[.....................................................................................................................]])..([[]]).char(#[[......................................................................................................................]])..([[]]).char(#[[.......................................................................................................................]])..([[]]).char(#[[........................................................................................................................]])..([[]]).char(#[[.........................................................................................................................]])..([[]]).char(#[[..........................................................................................................................]])..([[]]).char(#[[...........................................................................................................................]])..([[]]).char(#[[............................................................................................................................]])..([[]]).char(#[[.............................................................................................................................]])..([[]]).char(#[[..............................................................................................................................]]))

Try it online! The code works both in Lua 5.1 (tested locally) and 5.3.5 (the version on TIO).
Not too difficult once I'd got my head around a few Lua basics. In _Gachr.#()[] we have everything we need:

_G is a table that gives us access to the global environment. We can call any function if we can index into this table. The function we want is io.write (print adds a trailing newline), which we can access (if we can form strings) through _G['io']['write'].
[] serve two purposes. As a single pair they allow us to index into tables. As a double pair they create strings.
# returns the length of a string, which allows us to make numbers.
string.char lets us convert numbers to characters. We don't have string but we can use ([[]]) instead.
.. concatenates strings.
() allow us to pass arguments to functions.

There's not much more to it except to build up the required strings. I used the following Ruby code to help:
X = %( !"$%&'*+,-/0123456789:;<>?@ABCDEFHIJKLMNOPQRSTUVWXYZ\\^`bdefgijklmnopqstuvwxyz{|}~)
luaify = ->(s) { s.bytes.map{|b|"([[]]).char(#[[#{'.'*b}]])"}*'..' }
print "_G[#{luaify['io']}][#{luaify['write']}](#{luaify[X]})"

Try it online!

Well done  I try to think about another approach

Lua 5.1, 19574 bytes, cracks @LuaNoob's third answer
(Note that all horizontal whitespace is tabs.)
function	k(t,key)
	return	next(t,key)
end

function	chr()
	if	getfenv()[([[string]])][([[find]])](k(getfenv()[([[string]])]),[[ch%wr]])	then
		return	k(getfenv()[([[string]])])
	end
	if	getfenv()[([[string]])][([[find]])](k(getfenv()[([[string]])],k(getfenv()[([[string]])])),[[ch%wr]])	then
		return	k(getfenv()[([[string]])],k(getfenv()[([[string]])]))
	end
	if	getfenv()[([[string]])][([[find]])](k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])]))),[[ch%wr]])	then
		return	k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])])))
	end
	if	getfenv()[([[string]])][([[find]])](k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])])))),[[ch%wr]])	then
		return	k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])]))))
	end
	if	getfenv()[([[string]])][([[find]])](k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])]))))),[[ch%wr]])	then
		return	k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])])))))
	end
	if	getfenv()[([[string]])][([[find]])](k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])])))))),[[ch%wr]])	then
		return	k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])]))))))
	end
	if	getfenv()[([[string]])][([[find]])](k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])]))))))),[[ch%wr]])	then
		return	k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])])))))))
	end
	if	getfenv()[([[string]])][([[find]])](k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])])))))))),[[ch%wr]])	then
		return	k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])]))))))))
	end
	if	getfenv()[([[string]])][([[find]])](k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])]))))))))),[[ch%wr]])	then
		return	k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])])))))))))
	end
	if	getfenv()[([[string]])][([[find]])](k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])])))))))))),[[ch%wr]])	then
		return	k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])]))))))))))
	end
	if	getfenv()[([[string]])][([[find]])](k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])]))))))))))),[[ch%wr]])	then
		return	k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])])))))))))))
	end
	if	getfenv()[([[string]])][([[find]])](k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])])))))))))))),[[ch%wr]])	then
		return	k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])]))))))))))))
	end
	if	getfenv()[([[string]])][([[find]])](k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])]))))))))))))),[[ch%wr]])	then
		return	k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])])))))))))))))
	end
	if	getfenv()[([[string]])][([[find]])](k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])])))))))))))))),[[ch%wr]])	then
		return	k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])]))))))))))))))
	end
	if	getfenv()[([[string]])][([[find]])](k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])]))))))))))))))),[[ch%wr]])	then
		return	k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])])))))))))))))))
	end
end

function	size()
	if	getfenv()[([[string]])][([[find]])](k(getfenv()[([[string]])]),[[%wen]])	then
		return	k(getfenv()[([[string]])])
	end
	if	getfenv()[([[string]])][([[find]])](k(getfenv()[([[string]])],k(getfenv()[([[string]])])),[[%wen]])	then
		return	k(getfenv()[([[string]])],k(getfenv()[([[string]])]))
	end
	if	getfenv()[([[string]])][([[find]])](k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])]))),[[%wen]])	then
		return	k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])])))
	end
	if	getfenv()[([[string]])][([[find]])](k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])])))),[[%wen]])	then
		return	k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])]))))
	end
	if	getfenv()[([[string]])][([[find]])](k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])]))))),[[%wen]])	then
		return	k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])])))))
	end
	if	getfenv()[([[string]])][([[find]])](k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])])))))),[[%wen]])	then
		return	k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])]))))))
	end
	if	getfenv()[([[string]])][([[find]])](k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])]))))))),[[%wen]])	then
		return	k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])])))))))
	end
	if	getfenv()[([[string]])][([[find]])](k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])])))))))),[[%wen]])	then
		return	k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])]))))))))
	end
	if	getfenv()[([[string]])][([[find]])](k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])]))))))))),[[%wen]])	then
		return	k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])])))))))))
	end
	if	getfenv()[([[string]])][([[find]])](k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])])))))))))),[[%wen]])	then
		return	k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])]))))))))))
	end
	if	getfenv()[([[string]])][([[find]])](k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])]))))))))))),[[%wen]])	then
		return	k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])])))))))))))
	end
	if	getfenv()[([[string]])][([[find]])](k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])])))))))))))),[[%wen]])	then
		return	k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])]))))))))))))
	end
	if	getfenv()[([[string]])][([[find]])](k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])]))))))))))))),[[%wen]])	then
		return	k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])])))))))))))))
	end
	if	getfenv()[([[string]])][([[find]])](k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])])))))))))))))),[[%wen]])	then
		return	k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])]))))))))))))))
	end
	if	getfenv()[([[string]])][([[find]])](k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])]))))))))))))))),[[%wen]])	then
		return	k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])],k(getfenv()[([[string]])])))))))))))))))
	end
end

getfenv()[([[io]])][([[write]])](getfenv()[([[string]])][chr()](getfenv()[([[string]])][size()]([[cccccccccccccccccccccccccccccccc]])),getfenv()[([[string]])][chr()](getfenv()[([[string]])][size()]([[ccccccccccccccccccccccccccccccccc]])),getfenv()[([[string]])][chr()](getfenv()[([[string]])][size()]([[cccccccccccccccccccccccccccccccccc]])),getfenv()[([[string]])][chr()](getfenv()[([[string]])][size()]([[ccccccccccccccccccccccccccccccccccc]])),getfenv()[([[string]])][chr()](getfenv()[([[string]])][size()]([[cccccccccccccccccccccccccccccccccccc]])),getfenv()[([[string]])][chr()](getfenv()[([[string]])][size()]([[cccccccccccccccccccccccccccccccccccccc]])),getfenv()[([[string]])][chr()](getfenv()[([[string]])][size()]([[ccccccccccccccccccccccccccccccccccccccc]])),getfenv()[([[string]])][chr()](getfenv()[([[string]])][size()]([[cccccccccccccccccccccccccccccccccccccccccc]])),getfenv()[([[string]])][chr()](getfenv()[([[string]])][size()]([[ccccccccccccccccccccccccccccccccccccccccccc]])),getfenv()[([[string]])][chr()](getfenv()[([[string]])][size()]([[ccccccccccccccccccccccccccccccccccccccccccccc]])),getfenv()[([[string]])][chr()](getfenv()[([[string]])][size()]([[cccccccccccccccccccccccccccccccccccccccccccccc]])),getfenv()[([[string]])][chr()](getfenv()[([[string]])][size()]([[ccccccccccccccccccccccccccccccccccccccccccccccc]])),getfenv()[([[string]])][chr()](getfenv()[([[string]])][size()]([[cccccccccccccccccccccccccccccccccccccccccccccccccccccccccc]])),getfenv()[([[string]])][chr()](getfenv()[([[string]])][size()]([[ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc]])),getfenv()[([[string]])][chr()](getfenv()[([[string]])][size()]([[cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc]])),getfenv()[([[string]])][chr()](getfenv()[([[string]])][size()]([[ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc]])),getfenv()[([[string]])][chr()](getfenv()[([[string]])][size()]([[cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc]])),getfenv()[([[string]])][chr()](getfenv()[([[string]])][size()]([[ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc]])),getfenv()[([[string]])][chr()](getfenv()[([[string]])][size()]([[cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc]])),getfenv()[([[string]])][chr()](getfenv()[([[string]])][size()]([[ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc]])),getfenv()[([[string]])][chr()](getfenv()[([[string]])][size()]([[ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc]])),getfenv()[([[string]])][chr()](getfenv()[([[string]])][size()]([[cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc]])),getfenv()[([[string]])][chr()](getfenv()[([[string]])][size()]([[cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc]])),getfenv()[([[string]])][chr()](getfenv()[([[string]])][size()]([[cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc]])),getfenv()[([[string]])][chr()](getfenv()[([[string]])][size()]([[cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc]])),getfenv()[([[string]])][chr()](getfenv()[([[string]])][size()]([[cccccccccccccccccccccccccccccccccccccccccccccccc]])),getfenv()[([[string]])][chr()](getfenv()[([[string]])][size()]([[ccccccccccccccccccccccccccccccccccccccccccccccccc]])),getfenv()[([[string]])][chr()](getfenv()[([[string]])][size()]([[cccccccccccccccccccccccccccccccccccccccccccccccccc]])),getfenv()[([[string]])][chr()](getfenv()[([[string]])][size()]([[ccccccccccccccccccccccccccccccccccccccccccccccccccc]])),getfenv()[([[string]])][chr()](getfenv()[([[string]])][size()]([[cccccccccccccccccccccccccccccccccccccccccccccccccccc]])),getfenv()[([[string]])][chr()](getfenv()[([[string]])][size()]([[ccccccccccccccccccccccccccccccccccccccccccccccccccccc]])),getfenv()[([[string]])][chr()](getfenv()[([[string]])][size()]([[cccccccccccccccccccccccccccccccccccccccccccccccccccccc]])),getfenv()[([[string]])][chr()](getfenv()[([[string]])][size()]([[ccccccccccccccccccccccccccccccccccccccccccccccccccccccc]])),getfenv()[([[string]])][chr()](getfenv()[([[string]])][size()]([[cccccccccccccccccccccccccccccccccccccccccccccccccccccccc]])),getfenv()[([[string]])][chr()](getfenv()[([[string]])][size()]([[ccccccccccccccccccccccccccccccccccccccccccccccccccccccccc]])))

No TIO link because the getfenv function was removed in 5.2 (TIO has 5.3.5).
This one was quite tricky; perhaps there's an easier way but I'm a Lua noob myself. :) The major stumbling blocks were:

No . means we have to index into a table to access functions. In previous cracks I'd indexed into _G, but . . .
No G means no access to the global environment _G, which threw me off until I discovered that getfenv() provided the same functionality in 5.1.
No a and no l were really annoying. Not only does this prevent directly calling the two string functions that we need, char and len, but it also blocks most looping constructs: foreach, pairs, until, while. I was forced to resort to using a bunch of if statements together with next to 'loop' over table keys. Also out is string.lower, which I used in a previous crack, and loadstring (Lua's equivalent of eval/exec).
Finally, no = means no assignment. Any values that we need have to be returned by functions.

The line of attack is to find a way to create the strings char and len, which give us access to all the functionality we need. Three helper functions are used. Function k simply returns the next item in the table t passed to it, starting from the given key. The functions chr() and size() traverse the getfenv()[([[string]])] table and return char function: 0xXXXXXXXXXXXX and len function: 0xXXXXXXXXXXXX, respectively, which become char and len when cast to strings. Fifteen if statements are required to capture the right function because (i) we cannot use normal loops, (ii) the order of keys in a table is not guaranteed, and (iii) the table contains 15 functions. Pattern matches ([[ch%wr]] and [[%wen]]) are used to extract the desired functions.
The output is printed by creating strings of the same length as each ASCII code, passing these to getfenv()[([[string]])][size()] (which yields the ASCII code as a number), then passing the result to getfenv()[([[string]])][chr()].

Good job, totally different approach than mine  Are you ready for the next one, closing more and more holes hehe.

Yabasic, 1070 bytes, cracks @CalebFuller's answer
print chr$(instr("...............................................b","b"))
print chr$(instr("................................................b","b"))
print chr$(instr(".................................................b","b"))
print chr$(instr("..................................................b","b"))
print chr$(instr("...................................................b","b"))
print chr$(instr("....................................................b","b"))
print chr$(instr(".....................................................b","b"))
print chr$(instr("......................................................b","b"))
print chr$(instr(".......................................................b","b"))
print chr$(instr("........................................................b","b"))
print chr$(instr("................................................................b","b"))
print chr$(instr("................................................................................................b","b"))
print chr$(instr("............................................b","b"));

Try it online!
No digits? Make numbers with instr.

That's a pretty good solution actually. I've posted a newer version that has "I" and "i" in the string so you can't use INSTR this time though!

@CalebFuller I might give it a go tomorrow. I could always use len instead, but without i there's no print so I'll need a workaround for that.

Thanks for pointing out that little security flaw...

Yabasic, 400 bytes, cracks @CalebFuller's second answer
two   = true+true
three = two+true
four  = three+true
five  = four+true
zix   = five+true
zeven = zix+true
eight = zeven+true
nine  = eight+true
print !true
print true
print two
print three
print four
print five
print zix
print zeven
print eight
print nine
print chr$(nine*eight+four)
print chr$(nine*nine+two)
print chr$(nine*(eight+four))
print chr$(nine*nine+two+four*eight)
print chr$(nine*five);

Try it online!

Guess I should have kept the "n" in the list... Or added the asterisk! But actually, you've pretty much cracked it with the !true concept - once you've got that the rest is easy. Well done!

Javastack, cracks Enamresu A's first answer
"" charcode "" charcode add ... print

Replace the ... with "" charcode add repeated 1234567888 times.
I bet you weren't expecting this! This is bringing back memories of the cracking chain I did with HighlyRadioactive last year.
Essentially, convert the unprintable character with ordinal value 1 to its character code and add it until the number is reached.

Sorry, this is invalid. Aside from not having output, it doesn't output the correct value.

@emanresuA did you use the unprintable correctly?

Oh I see. Yes that  is a valid  crack. BTW you don't need print anymore, as my next one will demonstrate.

Javastack, cracks AUsername's second answer
char charcode duplicate power
duplicate * 1234567889
add * 1234567888
duplicate duplicate duplicate divide
duplicate * 33
add * 32
char duplicate charcode duplicate divide
duplicate * 110
add * 109
char duplicate charcode duplicate divide
duplicate * 113
add * 112
char wrap sum

Chances are that some of the numbers are a bit off, but you get the general idea. Where it has * <number>, that means actually repeat the string that many times. So for example, replace duplicate * 1234567889 with 1234567889 duplicates.
This is 2020 repeating itself. See y'all when there's an eighth answer.

Lost, cracks Wheat Wizard's answer
////////////////////////////////////////////////////////
%/? 256**:2+:65*+:2+:83*+:6+@+6:+*38:+2:+*56:+2:**652 ?/

Try it online!
It's my first time actually trying to write Lost, so I'm not entirely confident in that this is actually deterministic, but Looks like it is actually deterministic. I hope. Strictly speaking, only cracks the third part of the answer because I'm not going to put in the thirty seconds to write two more programs with smaller outputs until I'm actually sure I cracked anything.
I'd imagine the intended crack made use of [] some way or another, but it's not like this is a code-golf competition, so I went with the first idea I could actually execute: two lines of effective palindromes that force a vertical traversal, one way or the other. Happens to make stack clearing quite elegant.

This looks like it is deterministic, you ran the verifier and it says it is deterministic.  I posted my intended solution, which does not use [ or ].  But yes using them can make this a lot shorter

@WheatWizard Thanks and nice! Speaking of shorter, it's definitely not shorter to avoid using even /--think I'll go make my own cop post for that actually

Javastack, cracks Enamresu A ninth answer
0 0 divide "" prepend 2 index

Wow this is my shortest one yet.
Try it online!

Javastack, cracks Enamresu A's tenth answer
ascii iterate pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop ascii iterate pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop ascii iterate pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop ascii iterate pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop ascii iterate pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop ascii iterate pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop ascii iterate pop pop pop pop pop pop pop pop pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop ascii iterate pop pop pop pop pop pop pop pop pop pop pop pop pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop ascii iterate pop pop pop pop pop pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop ascii iterate pop pop pop pop pop pop pop pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop ascii iterate pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop pop swap pop swap pop pair swap join pair swap join pair swap join pair swap join pair swap join

Uses concepts from the fourth round.

Just... I understand the concept, but others might not. If you could write a Vyxal script to generate this that'd be nice.

Javastack, cracks Enamresu A's eleventh answer
ascii "0" "" replace "1" "" replace "2" "" replace "3" "" replace "4" "" replace "5" "" replace "6" "" replace "7" "" replace "8" "" replace "9" "" replace "a" "" replace "b" "" replace "c" "" replace "e" "" replace "g" "" replace "i" "" replace "l" "" replace "n" "" replace "o" "" replace "p" "" replace "q" "" replace "r" "" replace "s" "" replace "t" "" replace "w" "" replace "x" "" replace "y" "" replace "z" "" replace "A" "" replace "B" "" replace "C" "" replace "D" "" replace "E" "" replace "F" "" replace "G" "" replace "H" "" replace "I" "" replace "J" "" replace "K" "" replace "L" "" replace "M" "" replace "N" "" replace "O" "" replace "P" "" replace "Q" "" replace "R" "" replace "S" "" replace "T" "" replace "U" "" replace "V" "" replace "W" "" replace "X" "" replace "Y" "" replace "Z" "" replace "!" "" replace "~" "" replace " " "" replace "#" "" replace "&" "" replace "%" "" replace "'" "" replace "/" "" replace ":" "" replace "@" "" replace iterate pop pop pop pair pair pair pair pair pair pair swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop iterate iterate iterate iterate iterate iterate iterate wrap 1 repeat "," "" replace

It'd be good if I could read.

Vyxal O, 181481 bytes, cracks EmanresuA's second Vyxal answer
I really can't post the code here this time, but here's a little summary:

`oooooooooooooooooooooooooooooooooooooooooooo`L`lol`LkAŻ÷$_Ė`oooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo...

Full version here - don't try it online, because if the site can't handle 81k byte programs, what makes you think it'll handle 128k byte programs?

Vyxal O, 182321 bytes, cracks EmanresuA's third answer
Sample:
`oooooooooooooooooooooooooooooooooooooooooooo`LkA'\D<;∑`lol`L%Ė`oooooooooooo...

Full code here

Dammit, I intended to ban backticks... And semicolons... On to take 4!

Vyxal O, 774094 bytes, cracks EmanresuA's fifth answer
Sample:
\o‛ooLẋ‛ooLẋ‛ooLẋ‛ooLẋ‛ooLẋ‛ooLẋ\oL¤Ȧ\oL¤Ȧ\oL¤Ȧ\oL¤Ȧ\oL¤Ȧ\oL¤Ȧ\oL¤Ȧ\oL¤Ȧ\oL¤Ȧ\oL¤Ȧ\oL¤Ȧ\oL¤Ȧ\oL¤Ȧ\oL¤Ȧ\oL¤Ȧ\oL¤Ȧ\oL¤Ȧ\oL¤Ȧ\oL¤Ȧ\oL¤ȦLkA‛ooL¤ȦkAFĖ

Full program
My poor computer is becoming unable to handle uploading/dealing with the program lengths.

Vyxal O, 2051108 bytes, cracks EmanresuA's tenth answer
Sample:
?ꜝ?rLꜝ?rLꜝ?rLꜝ?rLꜝ?rLꜝ?rLꜝ?rLꜝ?rLꜝ?rLꜝ?rLꜝ?rLꜝ?rLꜝ?rLꜝ?rLꜝ?rLꜝ?rLꜝ?rLꜝ?rLꜝ?rLꜝ?rLꜝ?rLꜝ?rLꜝ?rLꜝ?rLꜝ?rLꜝ?rLꜝ?rLꜝ?rLꜝ?rLꜝ?rLꜝ?rLꜝ?rLꜝ?rLꜝ?rLꜝ?rLꜝ?rLꜝ?rLꜝ?rLꜝ?rLꜝ?rLꜝ?rLꜝ?rLꜝ?rLꜝ?rL?↵↵LkAτĖ

You read that right. The answer really is 2 million bytes. Github doesn't like the file, so here's the generator:
`,₴…‹›⟇+*/-d↵EǍ½ƒɖ1234567890ø∆e₈₇∞₆₄JpiẎȯhtḢṪḣṫ¡Þ₀₁C!¬⇧İN⇩Ż÷«»\`;¥£¾¼⅛%→←"ẋ¤ȦFȧ⌐m⊍g≬\ṡ∷‡⁽⟨|⟩‟„$∇_yǏṘRq꘍₍₌Π⁺ʀ↑↓G↲↳⋏⋎Ṅ⁋ð×λ√²⌈⌊:ḊD` \λ \‛ VC ƛ`?``ꜝ?rL`n*+`?↵↵LkAτĖ`+;

Why the \λ \‛ V? Because ‛ doesn't play nice inside strings.

Bruh you could get around -1000000 bytes by using uε instead of ꜝ?rL. get golf'd baka

@AaronMiller the whole point is that I answer these in the most inefficient and convoluted way possible

Vyxal, 1318498 bytes, cracks lyxal's answer
Sample:
uuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεkP'bfBuuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuε=)kP'bfBuuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuε=)Wf‛  jĖ‛  j‛  o

Try it Online!
Generator:
`,₴…‹›⟇+*/-d↵EǍ½ƒɖ1234567890ø∆e₈₇∞₆₄JpiẎȯhtḢṪḣṫ¡Þ₀₁C!¬⇧İN⇩Ż÷«»\`;¥£¾¼⅛%→←"ẋ¤ȦFȧ⌐m⊍g≬\ṡ∷‡⁽⟨|⟩‟„$∇_yǏRq꘍₍₌Π⁺βτʀʁɾɽ¨żẏ?¹⁰²ǔǓǒǑǐǎꜝ₂₃₅&ẇŀl↑↓∴∵O¢ṙṗṖ¦†AVG↲↳⋏⋎Ṅ⁋×λ√⌈⌊:ḊD` # This is the full string to print
ḣ$C›‛uε*\up`kP'bfBu`120‛uε*+‛=)++              # The first character needs to be handled differently
$ƛC›‛uε*\ip`kP'bfBu`75‛uε*+‛=)++;∑+            # Here's the rest of the characters
`kP'bfBu`68‛uε*+‛=)++                          # Change the numbers to characters at the end
`Wf`+\‛+`  jĖ`+\‛+`  j`+\‛+`  o`+              # Join everything by spaces and execute, then pretty-print

Try it Online!

This is currently invalid as semicolons are banned. You can trivially replace them with }, ], or ), because Vyxal.

@emanresuA Oh yeah, I meant to do that and then forgot. Thanks, I'll update it.

Vyxal, 239993933 bytes, lyxal get cracked on
The backbone of this solution is the generation of arbitrary negative numbers, allowing for indexing to get all the commands we need.

How negative numbers?
u      # Push -1
 koo   # Remove `01234567` Does nothing except convert to string
    Ė  # Execute

We can decrement to any number by stringing many of these snippets together into a series.
Essentially, this executes subtract, then pushes 1. The 1 is used for the next subtraction in the series. This means we need to get rid of the first subtraction in a series and the last 1 in a series.
Subtraction no
To remove the first subtraction:
uu

This just pushes a couple of -1s, so the first subtraction is just -1 - -1.
1 no
To remove the last 1:
uPĖ

This uses -1 to turn 1 into an empty string, which is then executed to remove it.
Try it Online!
Why negative numbers tho?
How do arbitrary negative numbers help us? Vyxal uses the same indexing as Python, so we can use negative numbers to index into stuff. However, to index into something, we need i. We don't have that command available to us, but it is in the builtin aeiou, which we can make use of:
kv                               # Push `aeiou`
  uuukooĖukooĖukooĖukooĖ         # Push -3 and 1
                        kv       # Push `aeiou`
                          ‛ouo   # Remove `ou` to get `aei`
                              Ė  # Execute

Now that we have i and any negative number, we can index into our builtins to get useful stuff. For example, we can index into 01234567 to get 1, and we can index into printable ASCII to get + and C. We can use the 1+ over and over to increment a number, then use C to convert it to a character. (Yes, I know I could just push -1 and use - instead of +, which would be a lot shorter, but that's not as fun.)
Once we have the pieces, namely arbitrary negative numbers and indexing, creating a solution becomes trivial. Here's an example for printing !: apparently the link was too long so here's a gist of the program that you can copy into the interpreter wait hold on didn't we already do all of this for the last cop

Vyxal, 102953210 bytes, makes lyxal very sad
Y'all'dn't've given me those deltas.
kl¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯s¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯℅

Try it Online!
So it turns out that using deltas on a string or a list of characters will just remove the last character if all the characters are different. Removing a bunch of stuff, sorting, then removing a bunch of stuff will allow us to get any uppercase letter we want from kl. That gives us C, so we just need to figure out how to increment.
My first thought was using urL, but the delta trick only lets us get uppercase letters. Then I realized that we could use s to get a range, then join stuff to it and get the length to get any number we want. Join and Length are both uppercase letters, so that's perfect.
s      # Sort; casts the number to a range
 kl    # Push UPPERCASElowercase reversed alphabet
   J   # Join
    L  # Length

Doing this over and over will increment the number over and over, and we can push a 7 to start using k℅L, since we just need the starting number to be less than 10 (\n).
From here, it's just a straightforward increment to target, convert to char, and we've got our crack!
Here's an example printing !: wow even this comparatively short program is too long to include here as a link

Vyxal, 2513525 bytes, cracks lyxal's answer
Samplez:
ðḃðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZf∑k^ṘðḃðḃZðḃZf∑kv‛ouoṘkv‛ouoð¶rðḃZðḃZfṘZf∑ṘĖZf∑ðḃoZf∑ĖĖ

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

Vyxal, 29261004498694420 bytes, cracks'd lYXAL;s anser
This solution has two main parts to it: Generating arbitrary numbers, and converting those numbers into characters.

Arbitrary numbers:
uAuAuuArv∨v∧∑

Explanation:
     uA        # Push 1
    u  r       # Cast to range [-1..n)
uAuA    v∨v∧   # Change all numbers in range to 1
            ∑  # Sum

Continue wrapping with uAuAu  rv∨v∧∑ to increment.
Example: Try it Online!

Numbers to characters:
k^k^kAPP‛A.‛..PokfPĖ

Explanation:
  k^                  # Push hex digits
    kAP               # Strip `ABCDEF` to get `0123456789`
k^     P              # Strip `0123456789` to get `ABCDEF`
        ‛A.‛..P       # Remove `.` from `A.`
               o      # Strip `A` to get `BCDEF`
                kfP   # Strip `Fizz` to get `BCDE`
                   Ė  # Execute `BCDE`

B     # Convert from binary
 C    # Convert to char
  D   # Triplicate
   E  # Execute as Python (Does nothing)

Example: Try it Online!

Extra
This program takes a character and returns the number of bytes required to print it: Try it Online!

Vyxal, 5228096860937807017 bytes, beats lyxal
...Who says I need inf to win?
klkl₃₃kl₃₃kWsĖ

Try it Online!
This ended up being really complicated, until I realized I was an idiot.
At first, I had a really big thing to get the last letter of a string, then I realized that that was stupid and I was stupid and Vyxal is stupid and I'm stupid, and I could remove a part of it completely, which would allow me to remove another part of it, golfing the solution by 8.5 exabytes.
So it turns out all I needed to do was get the last letter of kl, then use / and some things to remove it from kl, then get the last letter of that and remove it from that, etc. to get any letter command I wanted.
Getting the last letter turned out to be simple:
kl₃₃          # Push 1
    kl₃₃      # Push 1
        kW    # Push `https://`
          s   # Sort
           Ė  # Execute

^ (This is the part that I overcomplicated. If you're curious, I talked a bit about it in chat.)
Being able to get the last letter of a string allowed me to get az/t from the builtins. As it turns out, / would end up being very handy. I was able to get the last letter of a builtin, e.g. a from kl, and then split the builtin on that letter, which would give me a list of that builin minus the letter, and an empty string. Then I could sort the list and get the last element, which would be the builtin without the removed letter.
klklkl₃₃kl₃₃kWsĖkWkl₃₃kl₃₃kWsĖĖskl₃₃kl₃₃kWsĖklklkl₃₃kl₃₃kWsĖkWkl₃₃kl₃₃kWsĖĖskl₃₃kl₃₃kWsĖkl₃₃kl₃₃kWsĖkWkl₃₃kl₃₃kWsĖĖskl₃₃kl₃₃kWsĖklklkl₃₃kl₃₃kWsĖkWkl₃₃kl₃₃kWsĖĖskl₃₃kl₃₃kWsĖklklkl₃₃kl₃₃kWsĖkWkl₃₃kl₃₃kWsĖĖskl₃₃kl₃₃kWsĖkl₃₃kl₃₃kWsĖkWkl₃₃kl₃₃kWsĖĖskl₃₃kl₃₃kWsĖkl₃₃kl₃₃kWsĖkWkl₃₃kl₃₃kWsĖĖskl₃₃kl₃₃kWsĖklklkl₃₃kl₃₃kWsĖkWkl₃₃kl₃₃kWsĖĖskl₃₃kl₃₃kWsĖklklkl₃₃kl₃₃kWsĖkWkl₃₃kl₃₃kWsĖĖskl₃₃kl₃₃kWsĖkl₃₃kl₃₃kWsĖkWkl₃₃kl₃₃kWsĖĖskl₃₃kl₃₃kWsĖklklkl₃₃kl₃₃kWsĖkWkl₃₃kl₃₃kWsĖĖskl₃₃kl₃₃kWsĖklklkl₃₃kl₃₃kWsĖkWkl₃₃kl₃₃kWsĖĖskl₃₃kl₃₃kWsĖkl₃₃kl₃₃kWsĖkWkl₃₃kl₃₃kWsĖĖskl₃₃kl₃₃kWsĖkl₃₃kl₃₃kWsĖkWkl₃₃kl₃₃kWsĖĖskl₃₃kl₃₃kWsĖkl₃₃kl₃₃kWsĖkWkl₃₃kl₃₃kWsĖĖskl₃₃kl₃₃kWsĖklklkl₃₃kl₃₃kWsĖkWkl₃₃kl₃₃kWsĖĖskl₃₃kl₃₃kWsĖklklkl₃₃kl₃₃kWsĖkWkl₃₃kl₃₃kWsĖĖskl₃₃kl₃₃kWsĖkl₃₃kl₃₃kWsĖkWkl₃₃kl₃₃kWsĖĖskl₃₃kl₃₃kWsĖklklkl₃₃kl₃₃kWsĖkWkl₃₃kl₃₃kWsĖĖskl₃₃kl₃₃kWsĖklklkl₃₃kl₃₃kWsĖkWkl₃₃kl₃₃kWsĖĖskl₃₃kl₃₃kWsĖkl₃₃kl₃₃kWsĖkWkl₃₃kl₃₃kWsĖĖskl₃₃kl₃₃kWsĖkl₃₃kl₃₃kWsĖkWkl₃₃kl₃₃kWsĖĖskl₃₃kl₃₃kWsĖklklkl₃₃kl₃₃kWsĖkWkl₃₃kl₃₃kWsĖĖskl₃₃kl₃₃kWsĖklklkl₃₃kl₃₃kWsĖkWkl₃₃kl₃₃kWsĖĖskl₃₃kl₃₃kWsĖkl₃₃kl₃₃kWsĖkWkl₃₃kl₃₃kWsĖĖskl₃₃kl₃₃kWsĖklklkl₃₃kl₃₃kWsĖkWkl₃₃kl₃₃kWsĖĖskl₃₃kl₃₃kWsĖklklkl₃₃kl₃₃kWsĖkWkl₃₃kl₃₃kWsĖĖskl₃₃kl₃₃kWsĖkl₃₃kl₃₃kWsĖkWkl₃₃kl₃₃kWsĖĖskl₃₃kl₃₃kWsĖkl₃₃kl₃₃kWsĖkWkl₃₃kl₃₃kWsĖĖskl₃₃kl₃₃kWsĖkl₃₃kl₃₃kWsĖkWkl₃₃kl₃₃kWsĖĖskl₃₃kl₃₃kWsĖkl₃₃kl₃₃kWsĖkWkl₃₃kl₃₃kWsĖĖskl₃₃kl₃₃kWsĖ

Try it Online!
This allowed me to create an exponentially growing program to get any letter from the builtin, which allowed me to increment using the same methods I've used before. It also allowed me to get C to convert the numbers to characters.
The entire program is pretty much just a bunch of kl₃₃kl₃₃kWsĖ repeated over and over, with some other stuff sprinkled in.
Here's an example printing !: wow this program is just absolutely too long there's no way im going to be able to even put it in a gist but here you go

When you have autoplay turned off

67 bytes, cracks emanresu A's answer
with(_=>1)constructor("conso\x6ce\x2e\x6cog('\x5b\x2e\x6c\x46')")()

If you're really going for golfing this, \56

JavaScript, cracks allxy's answer
{at:{constructor:c}}='';c`conso\x6ce\x2e\x6cog('\x5b\x2e\x6c\x46')```

54 45 bytes, cracks @Ausername's answer
with(conso\u006ce)\u006cog('\x5b\56\x6c\x46')

Edit: Saved 9 bytes thanks to @Ausername.

Scala, cracks @user's answer
println{"" + {40 toChar} + {46 toChar}}

Try it online!

Cool! Never thought about braces. I defined a function taking a single argument and used infix notation

Yeah, my immediate thought when I saw (. was postfix notation -- spent a while trying to figure out why println 3 wasn't working when I stumbled upon the braces trick.

By the way, you needn't mark it as (repl). Just wrap an object Main extends App {} around it (it's what I did).

Ah, thanks, I'll update the TIO link.

05AB1E, cracks @SomoKRoceS's answer
46ç

Try it online!
Pushes 46, then converts to a character, with implicit output.

Keg, Lyxal's answer
f;;p;f;r⑨m⑨ 7+u;Z⑨⑨:a;

Try it online!

Befunge-98 (PyFunge), 37 bytes, cracks pppery's answer
This code is terrible.
"NRTS"4(0"<"1+D0"r"1+D0"o"1+D0"+"1+D@

Try it online!

Keg, 264 bytes, cracks Lyxal's answer
Uses the -oc flag.
‡32‡32‡10‡32‡45‡32‡43‡32‡46‡32‡56‡32‡7‡32‡33‡32‡95‡32‡126‡32‡9320‡32‡92‡32‡59‡10‡32‡32‡10‡32‡45‡32‡43‡32‡46‡32‡56‡32‡7‡32‡33‡32‡95‡32‡126‡32‡9320‡32‡92‡32‡59‡10

Try it online!

Doesn't seem to replicate the 0x07s and trailing newline in the original question (see the TIO link there), but I would imagine that's easily fixable. If it's not, I have a different solution I can post.

Indeed, it doesn't; I'm not sure how that happened (probably an issue when copying a nonprintable); fixed.

I never used flags in the original, hence this is an invalid crack.

@Lyxal it doesn't matter if it's not intended

It does. I just got told a crack was invalid for using flags when the original program didn't use them.

@Lyxal I noticed the rule now. Both your answer and my crack were posted before it was added.

@EthanChapman you may want to post your solution now.

@mypronounismonicareinstate Oh jeez, hopefully I still have that lying around somewhere. I'll try to find it.

T-SQL
DECLARE @String VARCHAR
SELECT @String = 0x28
SELECT @String

Outputs ( but doesn't contain ( by using implicit type coercion.

Nice. I did the same but just in a more complex way

Javascript, cracks PkmnQ's answer
Target: (\SuC)
In browser (tested on Chrome):

atob['constr'+`${!0}`[2]+'ctor']`$${'console.log'+atob`KA==`+atob`IihcXFN1QykiKQ==`}$```

In Node:
U=`${!0}`[2];global['F'+U+'nction']`$${global['B'+U+'ffer'].from`99${''}111${''}110${''}115${''}111${''}108${''}101${''}46${''}108${''}111${''}103${''}40${''}39${''}40${''}92${''}92${''}83${''}117${''}67${''}41${''}39${''}41`}$```

Try it online!
OP already revealed an important trick (running arbitrary code in JSF$ck), so it was just a matter of creating the required chars from something else. Browser version uses base64 decoding function atob, and Node version uses Buffer.from, which luckily takes an array of numeric strings as an array of bytes.

Honestly, I didn't think of using atob. I used (again) unescape.

Ruby, cracks @Dingus' answer, 77 bytes
I imagine this is almost certainly not the crack in mind, but this was the other solution I found before posting the crack for @Histocrat's second cop.
print`echo -n \x27\x2e\x27\\\x27\x27\x22\x3f\x25\x28\x29\x5b\x5d\x3a\x3c\x27`

Try it online!

This requires Ruby+bash, not just Ruby-on-Unix. But the same principle works with Ruby-on-Unix: use printf \\047... instead of echo \x27….

I've posted a fortified version so will hold off on revealing my solution.

PicoLisp, cracks @Wezl's answer 5 bytes
Marking this community wiki as @Dingus Googled the error and found a solution and I applied the previous crack's style and removed bits.
[[0]]

Try it online!

Unless there's a version of PicoLisp that does something bizarre, this doesn't work. [[0]] causes picolisp to segfault, and it does not print anything to stdout and stderr. If you see a message like segmentation fault when you run it, that message comes from your shell.

Dirty, 2 bytes, cracks @HighlyRadioactive's answer
0Ḃ

Try it online!
Seems to work with any digit(s) preceding Ḃ, which is described in the docs as the 'bytes to UTF8' operator.

The intended solution is: 1 (Yay!)

Ruby, cracks Dingus's fourth answer
RUBY_VERSION =~ /\D/
DOT = $&
RUBY_VERSION =~ //
EMPTY_STRING = $&

$_ = $LOADED_FEATURES * EMPTY_STRING
$_ =~ /C/i; LC_C = $&
$_ =~ /H/i; LC_H = $&
$_ =~ /R/i; LC_R = $&
H_DOT_CHR = LC_H + DOT + LC_C + LC_H + LC_R

emit = EMPTY_STRING
h = 112; emit += eval H_DOT_CHR
h = 117; emit += eval H_DOT_CHR
h = 116; emit += eval H_DOT_CHR
h = 99; emit += eval H_DOT_CHR
h = 32; emit += eval H_DOT_CHR
h = 104; emit += eval H_DOT_CHR

h = 99; eval emit
h = 100; eval emit
h = 111; eval emit
h = 112; eval emit
h = 114; eval emit
h = 46; eval emit
h = 96; eval emit
h = 39; eval emit
h = 34; eval emit
h = 63; eval emit
h = 37; eval emit
h = 40; eval emit
h = 91; eval emit
h = 123; eval emit
h = 58; eval emit
h = 60; eval emit

Try it online!
Since we can use eval, the problem is to bootstrap a string that contains some interesting Ruby code. Since we have concatenation, this reduces to looking for individual characters. I went for h.chr, which will then let us construct arbitrary characters with h = NNN; s = eval "h.chr". (h could be any character that is permitted and that we manage to stuff into the string.) Once we have that, we build the string "putc h", and use that to print any character given by its numeric code.
Like before, I tried to extract characters from strings with regular expression matching. And like before, this divides into two subproblems: how to match an individual character, and finding or constructing a string that contains the desired character. Once that's done, we can copy the character from $&. Reviewing regexp features,
Some backslash escapes that match a character in a class are permitted. For example /\D/ matches the first character in a string that isn't a digit. Conveniently, in RUBY_VERSION, that's a ..
Since i is permitted, we can do case-insensitive matching. Since all uppercase letters are permitted, we can obtain a one-character string containing a lowercase letter by matching the corresponding uppercase letter against a string that contains the desired lowercase letter. We do this for c, h and r, all of which are present in $LOADED_FEATURES. That's an array of strings, which we convert to a string by using the join method which is conveniently available as the * operator. This part has me slightly uneasy because it verges on the specifics of an installation rather than on a language feature. However, the necessary characters are found in complex and thread and as far as I understand, these module names have to be present in $LOADED_FEATURES regardless of installation details.

Hats off to you for thwarting me at every attempt. This has been fun. I've posted my code in the cops thread.

Dotty, cracks @user's answer
This was kinda hard, but kinda easy and really fun!
object Main; def main(using Array[String]) = print("" + 58.toChar + 92.toChar + 123.toChar);

You can try this on: https://scastie.scala-lang.org/Sthw2Vr7QG26mbMHQuirkg
As of today, it produces the expected output:

DISCLAIMER!!!!
This answer is HEAVILY based on https://codegolf.stackexchange.com/a/207833/!
As based on this comment - Print X without X (cop's thread)

@LuisMendo To start as of now full programs are required so return is not possible regardless. I will say that you must indicate if your intended output is to STDERR, although for most languages errors should be somewhat distinct from legitimate output. – Ad Hoc Garf Hunter

The answer was required to be a full program, but the presented answer isn't.
Also, the answer I've taken inspiration from has a mistake on it.
The O.P. of the answer hasn't said their personal opinion since 31st, regarding the validity of the answer.
I believe this answer is different enough to be posted by itself.

Nice job with “using”! Didn’t think of it (I used @main). Also, you don’t need object Main

@user Thank you! I believe that that information should be also part of the cop's answer, where you post your intended solution. This way, more people can learn more and, in case comments are deleted, the information isn't lost. And everybody else is doing the same (I did it too). The using was totally found by chance when reading this: https://github.com/lampepfl/dotty/commit/f3c4f8c5fe40257d116946780df8abc08909693b

Yep, I’ll do that tomorrow when I’m on my PC. Again, nice job. Still, did you have to crack it today, when I was almost safe? :/

@user I mean, it sounded like an interesting challenge. I didn't wanted to pass on it. Specially since part of the answer was already made. (Admitedly, the hardest part for me, honestly.)

No, I was joking about that last part! It’s your right to answer challenges, and your approach is really cool - I’m sure you spent time researching, and it’d be unfair not to let you answer. Besides, I’m just happy someone is interested in Dotty

@user I know you meat it as a joke, don't worry. Dotty seems to be interesting and has some cool concepts. Sorry for stealing your almost-safe submission :(

Keg, cracks Lyxal's answer
aA%,aA%,KA%,aA%,nA%,aA%,lA%,aA%,oA%,aA%,yA%,aA%,7,aA%,bA%,aA%,Àa%,aA%,673**,aA%,é85**,aA%,¾b%,aA%,fA%,KA%,aA%,aA%,KA%,aA%,nA%,aA%,lA%,aA%,oA%,aA%,yA%,aA%,7,aA%,bA%,aA%,Àa%,aA%,673**,aA%,é85**,aA%,¾b%,aA%,fA%,KA%,

Ungolfed to avoid what appears to be a bug in Keg. I can't remember if this is exactly what I had in mind a month ago as I can't find the file and never bothered to generate a TIO link in my history, but I reckon it's pretty close.
Try it online
Explanation:
While taking away + and - will make it a little harder to generate numbers, % is still a powerful tool. Unsurprisingly, it's a modulo operator, and by moduloing, say, 65 and 97 (characters A and a, respectively), we can get 32, corresponding to space. It's just subtraction with more steps! We mostly just abuse this to get the characters we need, occasionally switching our base to something like a. This won't work for characters greater than 125 (I mean, it could, but I don't want to look up UTF-8 codes), however, and we need two of these: ~ and ⑨. For ~ we just multiply 6, 7, and 3 to get 126. ⑨ has a prime factorization of 2^3 * 5 * 233, so we use é (char code 233), 8, and 5 and multiply through.

><>, cracks HighlyRadioactive's answer
aa*b+01pv
   +b*aa<;

Try it online!

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

With the letter p is how!

See new challenge!

><>, cracks HighlyRadioactive's second answer
llllllllllrnnnnnnnnnn'`':::,+:::,+:::,+:::,+:::,+:::,+::l+:::,:pv
> <                                                         ~r~$<

Exits with an error, but when using the right interpreter (e.g. this), it's not actually output.

OK, you win. The new challenge is even more inconvenient...

><>, cracks HighlyRadioactive's third answer
'.':,:&:-&:&&:&:+:&:&+:&:&+:&:&+:&:&+:&:&+:&:&+:&:&+rnnnnnnnnnn'`'&:&+:&:&+:&:&+:&:&+:&:&+:&:&+'k'&:&+'n'&:&+'k'&:&+'n'&:&+&:pv
> <                                                                                r<

Exits with an error, but when using the right interpreter (e.g. this), it's not actually output.
I knew the register because I stole the feature for Keg.

Not the intended solution... a fourth one

@HighlyRadioactive okay then.

My intended solutions are much terser than yours... That is, no whitespaces, no repeating code, well golfed.

We're not here for golf though. We're here to crack answers.

Just sayin'. (f chars)

><>, cracks HighlyRadioactive's fifth answer
'u':-'u':,:'u':,+:'u':,+:'u':,+:'u':,+:'u':,+:'u':,+:'u':,+:'u':,+rnnnnnnnnnn'`''u':,+:'u':,+:'u':,+:'u':,+:'u':,+:'u':,+'%''u':,+'k''u':,+'n''u':,+'h''u':,+'n''u':,+'u':,:pv
> <                                                                                r<

Exits with an error, but when using the right interpreter (e.g. this), it's not actually output.

Right, that's the intended answer. Round 6. (It lasted a whole 7 minutes!)

@HighlyRadioactive round 6 will be my last for today. I'll do more tomorrow after that.

I will probably be out of solutions after round 6... This one was the intended solution for round 2 by the way. I was going to use l for round 3...

><>, cracks HighlyRadioactive's seventh answer (yes, seventh)
00=n00=00=+n00=00=00=++n00=00=00=00=+++n00=00=00=00=00=++++n00=00=00=00=00=00=+++++n00=00=00=00=00=00=00=++++++n00=00=00=00=00=00=00=00=+++++++n00=00=00=00=00=00=00=00=00=++++++++n00=:+:+:+:+:+::++::,+:00=+:00=+:00=+:00=+:00=+00=:+:+:+:+:+00=:+:++00=:++00=00=00=00=00=++++00=00=+*:*00=:+:+:++:00=00=00=+++:00=00=00=++00=00=+*-00=:+:+:+:+:+00=+00=+00=+00=+00=+00=+00=+00=:+:+:+:+:+00=00=++00=:+:+:+:+:+::++00=00=+::**+00=00=00=00=00=00=00=+++++++00=00=pv
> <                                                                                r<

Try it online!
Way easier than last time.

Yep. Let's move on.

><>, cracks HighlyRadioactive's eigth answer
:n::+n:::++n::::+++n:::::++++n::::::+++++n:::::::++++++n::::::::+++++++n:::::::::++++++++n:+:+:+:+:+::++::,+:::,+:::,+:::,+:::,+:::,+:::,+::,:+:+:+:+:+::,:::::++++++::,::::++++::,:+*:*::,:::::::++++++++:::,::+++:::,:::::+++++-::,:+:+:+:+:+::,::,::,::,::,::,::,+++++++::,:+:+:+:+:+::,::,++::,:+:+:+:+:+::,:+:+:++:::,+:::,:+:+:+:+::,:+:+++::,:+:+:+::,+::,+::,:+:+:+::,:++:::,:::::+++++*::,:++::-:p::,:+:+::,+::,:+*::*+::,+::,::-p::,::,::,::,::,++++:+::,::,::,::,::,::,+++++*::,:+::-pr>

Try it online!
Requires this interpreter, or, this one like so:

For ease of use I ask that you assume there are no command line flags in cases where command line flags are not mentioned. -- OP

@HighlyRadioactive asking doesn't equate to solid rules.

Command line flags count as different languages -- also OP

@Lyxal Sophistry

@Dingus which indicates this answer is not written in ><> and is thus invalid

@HighlyRadioactive Yes, I was agreeing with you

@HighlyRadioactive I had a Keg cop answer with no flags and it was cracked with flags and it was acceptable. Therefore, this is a valid crack

Then that one's not acceptable too

@HighlyRadioactive well then. I'll work on changing this

@HighlyRadioactive fixed

...How do I prevent cheating like this?

@HighlyRadioactive You can be as specific in your language choice as you want.  If you point to the specific implementation you want then the cracker cannot use other ones.

@AdHocGarfHunter Aha.

AlphaBeta, 228 bytes, cracks @PkmnQ's answer
wEFrErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErLErLErLErLErLErLErLErLErLErLErLErL

Try it online!
w        # set Register 3 value to 1 (Register 1 to the power of Register 2; both initially 0)
EF       # copy Register 3 value to Registers 1 and 2
r        # set Register 3 value to 2 (sum of values of Registers 1 and 2)
Er × 94  # 94 times, increment Registers 1 and 3
ErL × 12 # 12 times, increment Registers 1 and 3 and print Register 3 as char

nEFrErEFrEFrEFrEFrEFrEynFrLErLErLErLErLErLErLErLErLErLErLErL is shorter, but this isn't code golf

Lua, 2433 bytes, cracks @LuaNoob's second answer
io.write(_G[([[string]])][string.lower([[CHAR]])](string.len([[................................................]])).._G[([[string]])][string.lower([[CHAR]])](string.len([[.................................................]])).._G[([[string]])][string.lower([[CHAR]])](string.len([[..................................................]])).._G[([[string]])][string.lower([[CHAR]])](string.len([[...................................................]])).._G[([[string]])][string.lower([[CHAR]])](string.len([[....................................................]])).._G[([[string]])][string.lower([[CHAR]])](string.len([[.....................................................]])).._G[([[string]])][string.lower([[CHAR]])](string.len([[......................................................]])).._G[([[string]])][string.lower([[CHAR]])](string.len([[.......................................................]])).._G[([[string]])][string.lower([[CHAR]])](string.len([[........................................................]])).._G[([[string]])][string.lower([[CHAR]])](string.len([[.........................................................]])).._G[([[string]])][string.lower([[CHAR]])](string.len([[................................]])).._G[([[string]])][string.lower([[CHAR]])](string.len([[..................................]])).._G[([[string]])][string.lower([[CHAR]])](string.len([[...................................]])).._G[([[string]])][string.lower([[CHAR]])](string.len([[....................................]])).._G[([[string]])][string.lower([[CHAR]])](string.len([[......................................]])).._G[([[string]])][string.lower([[CHAR]])](string.len([[.......................................]])).._G[([[string]])][string.lower([[CHAR]])](string.len([[..........................................]])).._G[([[string]])][string.lower([[CHAR]])](string.len([[...........................................]])).._G[([[string]])][string.lower([[CHAR]])](string.len([[.............................................]])).._G[([[string]])][string.lower([[CHAR]])](string.len([[...............................................]])).._G[([[string]])][string.lower([[CHAR]])](string.len([[............................................................................................]])).._G[([[string]])][string.lower([[CHAR]])](string.len([[.................................................................................................]])))

Try it online! Untested in 5.1 (TIO has 5.3.5), but I don't believe there's any code here that depends on the minor version.
Pretty similar to the first crack. This time we don't have a or #, which we work around by calling string.char as _G[([[string]])][string.lower([[CHAR]])] and # as string.len. I used this Ruby code to generate the Lua:
X = %q(0123456789 "#$&'*+-/\\a)
luaify = ->(s) { s.bytes.map{|b|"_G[([[string]])][string.lower([[CHAR]])](string.len([[#{'.'*b}]]))"}*'..' }
print "io.write(#{luaify[X]})"

Try it online!

let me fix that ASAP :D

Rattle, 48 bytes, cracks @DanielH.'s answer
+4*4*7,%=+4*7+7+7+++,+7+7,%=+7+7++b*7b**7b*b*7bB

Try it online!
Pretty straightforward: push a bunch of values to the stack, then either print them as characters (,) or concatenate them to the print buffer (b) as floats. I use %= (modulo with top of stack) to reset the stack.

This is awesome - this is the first answer (that I know of) by a user other than myself in Rattle! By the way, the default argument for the = command is 0, so you can actually remove the %

@DanielH. I found it pretty easy to get up and running (albeit only doing really basic stuff). Looks like an interesting language.

Forth (gforth), 13 bytes, cracks binarycat's challenge
.\"0x0B\x20\t\n"
Try it online!
This also happens to be my first Forth program.
Explanation
It is really simple. I use .\" which allows me to use C-style escapes, and then I use a vertical tab (0x0B) to delimit the tokens, as Gforth uses the same whitespace rules as isspace(). The rest is just writing everything in C escapes.

Dis, 47 bytes, cracks @tailsparkrabbitear's answer
*|||_________________________________________>!

Try it online! Link compiles and runs a copy of Ben Olmstead's interpreter in C.
Explanation
We make use of self-modifying code to execute the banned print instruction.
*|||                                         >  # set the accumulator to 123; also store 123 in cell 45
    _________________________________________   # no-ops
                                             >  # execute cell 45 (modified to codepoint 123), i.e. print accumulator as ASCII character
                                              ! # terminate

Great that it's shorter than my original answer!

Javastack, cracks Enamresu A's third answer
not increment * 1234567889 flatprint not increment * (ascii value of " - 1) char flatprint not increment * (ascii value of d - 1) flatprint not increment * (ascii value of w - 1) flatprint not increment * (ascii value of q - 1) flatprint

H...hey actually give me time to actually write a post please!

Javastack, cracks Enamresu A's fourth answer
not times context (increment * 1234567890) context (increment * 34) char context (increment * ascii value of "q") pair context (increment * ascii value of "d") join context (increment * ascii value of "l") pair context (increment * ascii value of "w") join pair sum

Vyxal features ftw.
That's enough for today.

Javastack, cracks Enamresu A's fifth answer
((maybe length not) * 1234567890) (add * 1234567889) quote add alphabet maybe length not double index add alphabet (maybe length not * 17) (add * 16) index add alphabet (maybe length not * 18) (add * 17) index add

Traditionally, the next round is the one where I actually have to think for a while. Here's hoping I don't.

Javastack, cracks AUsername's sixth answer
((alphabet length not not) * 1234567890) (add * 1234567889) quote add alphabet alphabet length not not double index add alphabet (alphabet length not not * 17) (add * 16) index add alphabet (alphabet length not not * 18) (add * 17) index add

Yeah this was way easier than last year's round 6. All I had to do was just change the answer to round 5. ;P

Javastack, cracks Enamresu A's seventh (yes, seventh) answer
((alphabet length alphabet length divide) * 1234567890) (add * 1234567889)
alphabet (4) index alphabet (19) index add alphabet (14) index add alphabet (20) index add alphabet (16) index add eval add
alphabet (2) index add
alphabet (position of r in the alphabet) index add
alphabet (position of s in the alphabet) index add
alphabet (position of y in the alphabet) index add
alphabet (position of o in the alphabet) index add

Replace numbers in brackets ((n)) with (alphabet length alphabet length divide) * n (add * n - 1)
Do you see how I put seventh in italics? That's an ode to the fact that this isn't my first time reaching round 7 of a match.

Javastack, cracks Enamresu A eighth answer
zpake zpake equal "" add "" ceil index
zpake zpake equal "" add (1) index add
(111) zpake zpake equal "" add (1) index "cha" add eval add
(115) zpake zpake equal "" add (1) index "cha" add eval add
(98) zpake zpake equal "" add (1) index "cha" add eval add
(103) zpake zpake equal "" add (1) index "cha" add eval add
(1234567890) add

For clarity:
zpake ceil zpake ceil equal = 1
(zpake ceil zpake ceil equal * n)(add * n - 1) = n

JavaScript abuse ftw

This is exactly what I had, pretty much. Nice job, this is beautiful.

Javastack, cracks Enamresu A's twelfth answer
"abcegiln" "a" ascii "0" "" replace "1" "" replace "2" "" replace "3" "" replace "4" "" replace "5" "" replace "6" "" replace "7" "" replace "8" "" replace "9" "" replace "a" "" replace "b" "" replace "c" "" replace "e" "" replace "g" "" replace "i" "" replace "l" "" replace "n" "" replace "o" "" replace "p" "" replace "q" "" replace "r" "" replace "s" "" replace "t" "" replace "w" "" replace "x" "" replace "y" "" replace "z" "" replace "A" "" replace "B" "" replace "C" "" replace "D" "" replace "E" "" replace "F" "" replace "G" "" replace "H" "" replace "I" "" replace "J" "" replace "K" "" replace "L" "" replace "M" "" replace "N" "" replace "O" "" replace "P" "" replace "Q" "" replace "R" "" replace "S" "" replace "T" "" replace "U" "" replace "V" "" replace "W" "" replace "X" "" replace "Y" "" replace "Z" "" replace "!" "" replace "~" "" replace " " "" replace "#" "" replace "&" "" replace "%" "" replace "'" "" replace "/" "" replace ":" "" replace "@" "" replace iterate pop pop pop pair pair pair pair pair pair pair swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop iterate iterate iterate iterate iterate iterate iterate pop pop pop swap pop swap pop swap pop swap pop replace "b" ascii "0" "" replace "1" "" replace "2" "" replace "3" "" replace "4" "" replace "5" "" replace "6" "" replace "7" "" replace "8" "" replace "9" "" replace "a" "" replace "b" "" replace "c" "" replace "e" "" replace "g" "" replace "i" "" replace "l" "" replace "n" "" replace "o" "" replace "p" "" replace "q" "" replace "r" "" replace "s" "" replace "t" "" replace "w" "" replace "x" "" replace "y" "" replace "z" "" replace "A" "" replace "B" "" replace "C" "" replace "D" "" replace "E" "" replace "F" "" replace "G" "" replace "H" "" replace "I" "" replace "J" "" replace "K" "" replace "L" "" replace "M" "" replace "N" "" replace "O" "" replace "P" "" replace "Q" "" replace "R" "" replace "S" "" replace "T" "" replace "U" "" replace "V" "" replace "W" "" replace "X" "" replace "Y" "" replace "Z" "" replace "!" "" replace "~" "" replace " " "" replace "#" "" replace "&" "" replace "%" "" replace "'" "" replace "/" "" replace ":" "" replace "@" "" replace iterate pop pop pop pair pair pair pair pair pair pair swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop iterate iterate iterate iterate iterate iterate iterate pop pop pop pop pop pop pop replace "c" ascii "0" "" replace "1" "" replace "2" "" replace "3" "" replace "4" "" replace "5" "" replace "6" "" replace "7" "" replace "8" "" replace "9" "" replace "a" "" replace "b" "" replace "c" "" replace "e" "" replace "g" "" replace "i" "" replace "l" "" replace "n" "" replace "o" "" replace "p" "" replace "q" "" replace "r" "" replace "s" "" replace "t" "" replace "w" "" replace "x" "" replace "y" "" replace "z" "" replace "A" "" replace "B" "" replace "C" "" replace "D" "" replace "E" "" replace "F" "" replace "G" "" replace "H" "" replace "I" "" replace "J" "" replace "K" "" replace "L" "" replace "M" "" replace "N" "" replace "O" "" replace "P" "" replace "Q" "" replace "R" "" replace "S" "" replace "T" "" replace "U" "" replace "V" "" replace "W" "" replace "X" "" replace "Y" "" replace "Z" "" replace "!" "" replace "~" "" replace " " "" replace "#" "" replace "&" "" replace "%" "" replace "'" "" replace "/" "" replace ":" "" replace "@" "" replace iterate pop pop pop pair pair pair pair pair pair pair swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop iterate iterate iterate iterate iterate iterate iterate pop pop pop pop pop swap pop swap pop replace "e" ascii "0" "" replace "1" "" replace "2" "" replace "3" "" replace "4" "" replace "5" "" replace "6" "" replace "7" "" replace "8" "" replace "9" "" replace "a" "" replace "b" "" replace "c" "" replace "e" "" replace "g" "" replace "i" "" replace "l" "" replace "n" "" replace "o" "" replace "p" "" replace "q" "" replace "r" "" replace "s" "" replace "t" "" replace "w" "" replace "x" "" replace "y" "" replace "z" "" replace "A" "" replace "B" "" replace "C" "" replace "D" "" replace "E" "" replace "F" "" replace "G" "" replace "H" "" replace "I" "" replace "J" "" replace "K" "" replace "L" "" replace "M" "" replace "N" "" replace "O" "" replace "P" "" replace "Q" "" replace "R" "" replace "S" "" replace "T" "" replace "U" "" replace "V" "" replace "W" "" replace "X" "" replace "Y" "" replace "Z" "" replace "!" "" replace "~" "" replace " " "" replace "#" "" replace "&" "" replace "%" "" replace "'" "" replace "/" "" replace ":" "" replace "@" "" replace iterate pop pop pop pair pair pair pair pair pair pair swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop iterate iterate iterate iterate iterate iterate iterate pop pop swap pop swap pop swap pop swap pop swap pop replace "g" ascii "0" "" replace "1" "" replace "2" "" replace "3" "" replace "4" "" replace "5" "" replace "6" "" replace "7" "" replace "8" "" replace "9" "" replace "a" "" replace "b" "" replace "c" "" replace "e" "" replace "g" "" replace "i" "" replace "l" "" replace "n" "" replace "o" "" replace "p" "" replace "q" "" replace "r" "" replace "s" "" replace "t" "" replace "w" "" replace "x" "" replace "y" "" replace "z" "" replace "A" "" replace "B" "" replace "C" "" replace "D" "" replace "E" "" replace "F" "" replace "G" "" replace "H" "" replace "I" "" replace "J" "" replace "K" "" replace "L" "" replace "M" "" replace "N" "" replace "O" "" replace "P" "" replace "Q" "" replace "R" "" replace "S" "" replace "T" "" replace "U" "" replace "V" "" replace "W" "" replace "X" "" replace "Y" "" replace "Z" "" replace "!" "" replace "~" "" replace " " "" replace "#" "" replace "&" "" replace "%" "" replace "'" "" replace "/" "" replace ":" "" replace "@" "" replace iterate pop pop pop pair pair pair pair pair pair pair swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop iterate iterate iterate iterate iterate iterate iterate pop swap pop swap pop swap pop swap pop swap pop swap pop replace "i" ascii "0" "" replace "1" "" replace "2" "" replace "3" "" replace "4" "" replace "5" "" replace "6" "" replace "7" "" replace "8" "" replace "9" "" replace "a" "" replace "b" "" replace "c" "" replace "e" "" replace "g" "" replace "i" "" replace "l" "" replace "n" "" replace "o" "" replace "p" "" replace "q" "" replace "r" "" replace "s" "" replace "t" "" replace "w" "" replace "x" "" replace "y" "" replace "z" "" replace "A" "" replace "B" "" replace "C" "" replace "D" "" replace "E" "" replace "F" "" replace "G" "" replace "H" "" replace "I" "" replace "J" "" replace "K" "" replace "L" "" replace "M" "" replace "N" "" replace "O" "" replace "P" "" replace "Q" "" replace "R" "" replace "S" "" replace "T" "" replace "U" "" replace "V" "" replace "W" "" replace "X" "" replace "Y" "" replace "Z" "" replace "!" "" replace "~" "" replace " " "" replace "#" "" replace "&" "" replace "%" "" replace "'" "" replace "/" "" replace ":" "" replace "@" "" replace iterate pop pop pop pair pair pair pair pair pair pair swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop iterate iterate iterate iterate iterate iterate iterate pop pop pop pop swap pop swap pop swap pop replace "l" ascii "0" "" replace "1" "" replace "2" "" replace "3" "" replace "4" "" replace "5" "" replace "6" "" replace "7" "" replace "8" "" replace "9" "" replace "a" "" replace "b" "" replace "c" "" replace "e" "" replace "g" "" replace "i" "" replace "l" "" replace "n" "" replace "o" "" replace "p" "" replace "q" "" replace "r" "" replace "s" "" replace "t" "" replace "w" "" replace "x" "" replace "y" "" replace "z" "" replace "A" "" replace "B" "" replace "C" "" replace "D" "" replace "E" "" replace "F" "" replace "G" "" replace "H" "" replace "I" "" replace "J" "" replace "K" "" replace "L" "" replace "M" "" replace "N" "" replace "O" "" replace "P" "" replace "Q" "" replace "R" "" replace "S" "" replace "T" "" replace "U" "" replace "V" "" replace "W" "" replace "X" "" replace "Y" "" replace "Z" "" replace "!" "" replace "~" "" replace " " "" replace "#" "" replace "&" "" replace "%" "" replace "'" "" replace "/" "" replace ":" "" replace "@" "" replace iterate pop pop pop pair pair pair pair pair pair pair swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop iterate iterate iterate iterate iterate iterate iterate swap pop swap pop swap pop swap pop swap pop swap pop swap pop replace "n" ascii "0" "" replace "1" "" replace "2" "" replace "3" "" replace "4" "" replace "5" "" replace "6" "" replace "7" "" replace "8" "" replace "9" "" replace "a" "" replace "b" "" replace "c" "" replace "e" "" replace "g" "" replace "i" "" replace "l" "" replace "n" "" replace "o" "" replace "p" "" replace "q" "" replace "r" "" replace "s" "" replace "t" "" replace "w" "" replace "x" "" replace "y" "" replace "z" "" replace "A" "" replace "B" "" replace "C" "" replace "D" "" replace "E" "" replace "F" "" replace "G" "" replace "H" "" replace "I" "" replace "J" "" replace "K" "" replace "L" "" replace "M" "" replace "N" "" replace "O" "" replace "P" "" replace "Q" "" replace "R" "" replace "S" "" replace "T" "" replace "U" "" replace "V" "" replace "W" "" replace "X" "" replace "Y" "" replace "Z" "" replace "!" "" replace "~" "" replace " " "" replace "#" "" replace "&" "" replace "%" "" replace "'" "" replace "/" "" replace ":" "" replace "@" "" replace iterate pop pop pop pair pair pair pair pair pair pair swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop iterate iterate iterate iterate iterate iterate iterate pop pop pop pop pop pop swap pop replace

... 10526 bytes. This one was suffering.

Javastack, cracks AUsername's thirteenth answer
107 char 100 char 115 char 109 char 117 char 106 char 118 char 102 char 98 char wrap 1 repeat "," "" replace

Sussy baka

Vyxal O, 707126 bytes, cracks EmanresuA's seventh (yes, seventh) answer
Sample:
⟨\o|\o|\o|\o|\o|\o|\o|\o|\o|\o|\o|\o|\o|\o|\o|\o|\o|\o|\o|\o|\o|\o|\o|\o|\o|\o|\o|\o|\o|\o|\o|\o|\o|\o|\o|\o|\o|\o|\o|\o|\o|\o|\o|\o⟩LkA≬\D<ṡ∷∷Ė

Full code

Vyxal O, 299195 bytes, cracks EmanresuA's eigth answer
Sample:
×ǏǏǏǏǏǏǏǏǏǏǏǏǏǏǏǏǏǏǏǏǏǏǏǏǏǏǏǏǏǏǏǏǏǏǏǏǏǏǏǏǏǏǏLkA√y$_y_y_y_Ė

Full code
...

Vyxal O, 801294 bytes, cracks EmanresuA's ninth answer
Sample:
¶ḃʀLʀLʀLʀLʀLʀLʀLʀLʀLʀLʀLʀLʀLʀLʀLʀLʀLʀLʀLʀLʀLʀLʀLʀLʀLʀLʀLʀLʀLʀLʀLʀLʀLʀLʀLʀLʀLʀLʀLʀLʀLʀLʀLkA‛ABo↓ǐĖ

Full code (ignore the file name it's a very unfunny joke)
Yes.

Vyxal, 1606416 bytes, cracks lyxal's answer
Sample:
εuεuεuεuuεuεuεuεuε\‛§εḭĖuuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuuεuεuεuεuε\‛§εḭĖĖuuε

Full code
Generator program

!@#$%^&*()_+, 141 bytes, cracks @null's answer
**********************************************************************************************_@*******************************************_@

Try it online!
The strategy to print a character is simple:

Find the character's codepoint and execute that many copies of the * command. Each * attempts to read a byte of input from STDIN, but when the input is empty \$-1\$ is added to the top of the stack instead.
Negate the top of stack (_).
Pop and print the top of stack as a character (@).

(Using loops might be shorter, but this isn't code golf.)

This was the intended solution, but only after I posted the cop, I realized that \**@,*@` works.

Next challenge coming soon. P. S. This tricked is used in my reverse input answer, and I think that's pretty neat.

@null Ha, I completely missed that helpful sentence at the bottom of the readme: 'All other characters push their values'. Lucky this wasn't code golf!

Here's a better documentation.

Brainf**k - 98 Bytes CreaZyp154's Answer
++++++++++++++++++++++++++++++++++++++++++++.+.+++++++++++++++.++.+++++++++++++++++++++++++++++.++

Output

,-<>[]

Brainfuck, cracks CreaZyp154's answer
++++++++++++++++++++++++++++++++++++++++++++.+.+++++++++++++++.++.+++++++++++++++++++++++++++++.++.
Attempt This Online!

It seems this was already cracked although no comment was left.

Should I delete the answer?

APL (Dyalog Unicode), 81 bytes, cracks Ada's answer
∆←⍎'⎕A',22⊃⎕A
⎕←(25↑66↓∆),(26↑17↓∆),(97⊃∆),⍕2+1

Try it online!
This was pretty easy. ⎕A is our escape hatch - it's the list of all 26 capital letters in the English alplhabet. We want ⎕AV, a string containing all the letters Unicode APL uses. 22⊃⎕A gets the 22nd element of ⎕A ("V"), and we append that to the string '⎕A' and execute it to get the value of ⎕AV. That is assigned to a variable ∆.

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/

sort: votes