39
\$\begingroup\$

This is the robber's thread of a 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.

\$\endgroup\$
1
  • 5
    \$\begingroup\$ 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. \$\endgroup\$
    – Dingus
    Aug 20 '20 at 3:22

137 Answers 137

2
\$\begingroup\$

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!

\$\endgroup\$
2
\$\begingroup\$

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

\$\endgroup\$
1
  • \$\begingroup\$ 👍 This is exactly how I did it \$\endgroup\$
    – rues
    Jul 28 '20 at 0:43
2
\$\begingroup\$

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.

\$\endgroup\$
2
\$\begingroup\$

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.
\$\endgroup\$
2
  • \$\begingroup\$ You could just do +T for 1, +T+T for 2, and so forth. No need to wrap it into a sum! \$\endgroup\$
    – Giuseppe
    Jul 27 '20 at 19:52
  • \$\begingroup\$ 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. \$\endgroup\$ Jul 28 '20 at 7:30
2
\$\begingroup\$

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!

\$\endgroup\$
2
  • \$\begingroup\$ Not the intended solution. Didn't block capital letters, whoops. \$\endgroup\$
    – att
    Jul 28 '20 at 17:04
  • \$\begingroup\$ 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. \$\endgroup\$
    – att
    Jul 28 '20 at 18:03
2
\$\begingroup\$

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!

\$\endgroup\$
1
  • \$\begingroup\$ I had several ways to crack it, but didn't really think of using file I/O. Nice job. \$\endgroup\$
    – Bubbler
    Jul 28 '20 at 23:24
2
\$\begingroup\$

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.

\$\endgroup\$
4
  • 1
    \$\begingroup\$ 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. \$\endgroup\$
    – Dingus
    Aug 1 '20 at 9:38
  • 1
    \$\begingroup\$ 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. \$\endgroup\$ Aug 1 '20 at 17:24
  • \$\begingroup\$ @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). \$\endgroup\$
    – Dingus
    Aug 2 '20 at 3:45
  • 1
    \$\begingroup\$ 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. \$\endgroup\$ Aug 2 '20 at 11:48
2
\$\begingroup\$

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

\$\endgroup\$
2
  • 1
    \$\begingroup\$ 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. \$\endgroup\$
    – Grain Ghost
    Aug 1 '20 at 13:54
  • 1
    \$\begingroup\$ @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. \$\endgroup\$
    – Potato44
    Aug 1 '20 at 14:08
2
\$\begingroup\$

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

\$\endgroup\$
1
  • \$\begingroup\$ Well done. Bang on with the approach. \$\endgroup\$
    – Dingus
    Aug 2 '20 at 4:06
2
\$\begingroup\$

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!

\$\endgroup\$
1
  • \$\begingroup\$ That's very creative! Not the solution I had in mind though, so I'll post an updated version. \$\endgroup\$
    – madlaina
    Aug 2 '20 at 8:44
2
\$\begingroup\$

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.

\$\endgroup\$
5
  • \$\begingroup\$ 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. \$\endgroup\$ Aug 2 '20 at 23:32
  • \$\begingroup\$ 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! \$\endgroup\$ Aug 3 '20 at 5:19
  • \$\begingroup\$ Ahhhh, the last three chars appear to be consistent! Which would provide access to e... Is that what you had? \$\endgroup\$ Aug 3 '20 at 5:39
  • 1
    \$\begingroup\$ $_ = "x"; $_ = [$_ .. $_ . $_]; $_ = $$_[3]; /./ gives you a from x \$\endgroup\$ Aug 3 '20 at 8:38
  • \$\begingroup\$ Of course! How could I miss that! Hah! \$\endgroup\$ Aug 3 '20 at 9:46
2
\$\begingroup\$

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

\$\endgroup\$
5
  • \$\begingroup\$ Still not intended... Why did I miss so many solutions? \$\endgroup\$
    – null
    Aug 12 '20 at 8:24
  • \$\begingroup\$ @HighlyRadioactive give up yet? \$\endgroup\$
    – lyxal
    Aug 12 '20 at 8:25
  • \$\begingroup\$ No I'm gonna force you into a short solution \$\endgroup\$
    – null
    Aug 12 '20 at 8:26
  • \$\begingroup\$ @HighlyRadioactive alright then. Round 5 it is. \$\endgroup\$
    – lyxal
    Aug 12 '20 at 8:26
  • \$\begingroup\$ This is record-breaking I believe... I have two solutions in round 5, so we'll have round 6 \$\endgroup\$
    – null
    Aug 12 '20 at 8:27
2
+250
\$\begingroup\$

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

\$\endgroup\$
2
  • 1
    \$\begingroup\$ +1 for doing all this on your phone. Let's HighlyRadioactive keeps the challenges coming - this is very entertaining \$\endgroup\$
    – rues
    Aug 12 '20 at 23:17
  • 2
    \$\begingroup\$ "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. \$\endgroup\$
    – null
    Aug 13 '20 at 1:51
2
\$\begingroup\$

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!

\$\endgroup\$
2
\$\begingroup\$

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.

\$\endgroup\$
2
\$\begingroup\$

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.

\$\endgroup\$
2
\$\begingroup\$

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!

\$\endgroup\$
1
  • \$\begingroup\$ Well done 👍 I try to think about another approach 😃 \$\endgroup\$
    – LuaNoob
    Feb 3 at 10:27
2
\$\begingroup\$

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()].

\$\endgroup\$
1
  • \$\begingroup\$ Good job, totally different approach than mine 😜 Are you ready for the next one, closing more and more holes hehe. \$\endgroup\$
    – LuaNoob
    Feb 10 at 23:06
2
\$\begingroup\$

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.

\$\endgroup\$
3
  • \$\begingroup\$ 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! \$\endgroup\$ Mar 1 at 13:11
  • \$\begingroup\$ @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. \$\endgroup\$
    – Dingus
    Mar 1 at 13:26
  • \$\begingroup\$ Thanks for pointing out that little security flaw... 😜 \$\endgroup\$ Mar 1 at 13:46
2
\$\begingroup\$

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!

\$\endgroup\$
1
  • \$\begingroup\$ 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! \$\endgroup\$ Mar 2 at 1:39
2
\$\begingroup\$

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.

\$\endgroup\$
2
\$\begingroup\$

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

\$\endgroup\$
2
  • 1
    \$\begingroup\$ 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 \$\endgroup\$
    – Grain Ghost
    Aug 8 at 10:22
  • \$\begingroup\$ @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 \$\endgroup\$ Aug 8 at 10:43
2
\$\begingroup\$

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.

\$\endgroup\$
2
\$\begingroup\$

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.

\$\endgroup\$
1
  • 1
    \$\begingroup\$ Just... I understand the concept, but others might not. If you could write a Vyxal script to generate this that'd be nice. \$\endgroup\$
    – emanresu A
    Aug 9 at 3:47
2
\$\begingroup\$

Javastack, cracks Enamresu A ninth answer

0 0 divide "" prepend 2 index

Wow this is my shortest one yet.

Try it online!

\$\endgroup\$
2
\$\begingroup\$

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.

\$\endgroup\$
3
  • \$\begingroup\$ Sorry, this is invalid. Aside from not having output, it doesn't output the correct value. \$\endgroup\$
    – emanresu A
    Aug 7 at 6:19
  • \$\begingroup\$ @emanresuA did you use the unprintable correctly? \$\endgroup\$
    – lyxal
    Aug 7 at 6:21
  • \$\begingroup\$ Oh I see. Yes that is a valid crack. BTW you don't need print anymore, as my next one will demonstrate. \$\endgroup\$
    – emanresu A
    Aug 7 at 6:22
2
\$\begingroup\$

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?

\$\endgroup\$
2
\$\begingroup\$

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?

\$\endgroup\$
2
\$\begingroup\$

Vyxal O, 182321 bytes, cracks EmanresuA's third answer

Sample:

`oooooooooooooooooooooooooooooooooooooooooooo`LkA'\D<;∑`lol`L%Ė`oooooooooooo...

Full code here

\$\endgroup\$
1
  • \$\begingroup\$ Dammit, I intended to ban backticks... And semicolons... On to take 4! \$\endgroup\$
    – emanresu A
    Sep 25 at 23:39
2
\$\begingroup\$

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.

\$\endgroup\$

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.