[Question]
  [
*Inspired by [this](https://codegolf.stackexchange.com/q/210638/95792) challenge, which got closed. This is meant to be an easier, but no less interesting version of that.*
This is the robbers thread of a [cops-and-robbers](/questions/tagged/cops-and-robbers "show questions tagged 'cops-and-robbers'") challenge. For the cops thread, see [here](https://codegolf.stackexchange.com/q/213962/95792).
Cops will provide a program/function and a flag. Robbers will guess a password. When the password is given to the cop's program, the flag should be outputted.
## Robber rules
* When the cop's program is given the password you guess, it should output the flag.
* Your password does not have to be the same as the cop's password.
* You are allowed to take advantage of ambiguous descriptions of the flag by cops.
Cop answers will be safe if they haven't been cracked for two weeks.
## Example
Cop:
## Scala, 4 bytes
```
x=>x
```
Flag: `Yay, you cracked it!` (an object of type `String` is returned from the lambda above)
[Try it online!](https://tio.run/##K05OzEn8n5@UlZpcouCbmJmnkFpRkpqXUqzgWFCgUM2loFCWmKOQZqUQXFKUmZeuYGsHZ/2vsLWr@A9RkF6aWlysYKugFFBaolCZX1oEFclILUpVAhpSANRSkpOnkaYBFtfU5Kr9DwA "Scala ‚Äì Try It Online")
Robber:
Password: the string "Yay, you cracked it!"
[Try it online!](https://tio.run/##K05OzEn8n5@UlZpcouCbmJmnkFpRkpqXUqzgWFCgUM2loFCWmKOQZqUQXFKUmZeuYGsHZ/2vsLWr@A9RkF6aWlysYKugFJlYqaNQmV@qkFyUmJydmqKQWaKoBDSlAKinJCdPI00DrFRTk6v2PwA)
  
[Answer]
# [Sisyphus, PHP](https://codegolf.stackexchange.com/a/213984/98889)
Password:
A string `golf` with 1,000,000 leading whitespaces and 1,000,000 trailing whitespaces
Output: `golf`
Reason: 1,000,000 is the default backtracking limit of PCRE (which you can get by `var_dump(ini_get('pcre.backtrack_limit'));`). And `preg_match` will return `FALSE` other than 0 or 1 when this limit is breaked.
[Try it online!](https://tio.run/##7dBJCsJAAETRvadQCGRAzN4BjxIkdgaISaO98PbRe@S93ad2FYe4rtd7HOIu@966cQpNH1LTLnMKc/oU@X851/UnPcc5Ly@7sSsO8R365vVI7VDk9anql6k7VXV@zL5lGdph2af3@Cr@dVnXPQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsFH9MnVeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACArfoB)
[Answer]
# [ovs, Python 2](https://codegolf.stackexchange.com/a/213978/39531)
Password:
```
class m:0
m.__init__ = hex.__init__
n = 49374
m.__str__ = n.__hex__
class a: __metaclass__ = m
```
Output: `0xc0de`
[Try it online!](https://tio.run/##PYzfCsIgGMXvfQovgm0hEjWIHHuSVmLOUJpO/L6L7elNDLo5nD8/TtzRruGcs/NxTUiTYbADiWNRDji7wJNRc9sR9y4j9wq1bZvn3Wx6mm36vCZYnJejGBhXAeFxPDQsdsJsRtM4xOQCUpWzXhQA9eJEPJfSBYdS0pFas/0jCaXob5drXxnAVJFQfMHK/vtQgkrpDaoaK@K/)
[Answer]
# [R, Robin Ryder](https://codegolf.stackexchange.com/a/214055/98904)
Password: `as.roman(c(1, 9)))`
It was roman numerals!
[Try it online!](https://tio.run/##K/qfpmCr8D@tNC@5JDM/T6NCUyE5I7GopEhDqaqyorysVElHQSkIDICskvyc/PLUIo2KaMNYBW2FimijWE3N/2kaicV6Rfm5iXkayRqGOgqWmkBBAA "R ‚Äì Try It Online")
[Answer]
# [Lynn, Haskell](https://codegolf.stackexchange.com/a/214033/64121)
Lynn created a stack based mini-language, the task was to generate the primes up to 500 in 60 or less operation. Here is my 55-operation password:
```
[0,0,2,1,4,1,0,2,1,1,4,4,4,30,0,2,0,2,0,20,10,0,3,10,2,0,3,1,0,10,3,6,6,6,6,5,4,7,5,0,7,3,10,2,0,3,20,2,1,0,3,0,3,30,2]
```
[Try it online!](https://tio.run/##XY/RisIwEEXf8xWFvCRrLGmqFYLxC/wDEQlaMdgNsXYlFf@9zqQ@1GW4M3dOkgu52Pu1bpphcP7sYiYpkTrQaAItdCQFev002GESlfY@EdbPIgdWfrF5Yosv9pPYcsJO7pH1GSZWE9rr5MjqH3uSI5IXu4mDbvl6fg/Ws/WRB9PSP9@5hjFjJM8vtT1xdqM8kgP8IZJf67xpgW79ZmNC63yXM7rb87yz1zqr5DDspJBCiUIsQKNDj1WORx9JUeBe4lCjEYmVovrUEh6toEvok3tqjEWLgli1fwM "Haskell ‚Äì Try It Online")
The available operations are
```
0   push 1
1   duplicate top of stack
2   add top two values
3   subtract
4   multiply
5   integer divide top value by second value
6   push the second value without popping it
7   swap top two values
c>7 while loop, runs until top of stack is 0
    the loops ends at the first instruction >=c
```
---
`0,0,2,1,4,1,0,2,1,1,4,4,4` pushes the initial number `500`.
The remainder of the code is best explained inside out:
`6,6,6,6,5,4,7,5` is a divisibility test. Given `k` and `n` as the top two values on the stack this calculates \$\lfloor {\lfloor {n \over k} \rfloor \cdot k \over n}\rfloor\$, which is only 1 if `k` divides `n`: [Try it online!](https://tio.run/##Xc/vCsIgEADw7z7FgV@03Fh/tkiyJ@gNIkKaNdkysxUuevc17UvlgXf34zi4St5q1TR9r81Re8gwyrjFXlg84R5NQs2fIvxDRtPYd1FIN/Z0sNmPJdHmPzaKln9ZqR/QQdhYfGnHY4UWf/ZEhyAvcmV77ugquVlpyOpArXD4blrdECJERtNKyZKSK6Ye7YcbPEoSCM@ANCXUcLpApZwCeKCz1Ea4YX5j1mthnTZtSvB2xmC5o2krawVF1vfbgn0iZ3O2YPnuDQ "Haskell ‚Äì Try It Online")
---
`1,0,10,3,div test,0,7,3,10,2,0,3` is a primality test, or a composite test since this returns truthy (non-zero) values for composite numbers:
```
1                  -- duplicate n
 0                 -- push 1 - stack: [1, k=n, n]
                   -- in the next iterations of the loop,
                   -- the top of stack will be the inverted result
                   -- of the divisibility test
  10       10      -- while loop:
                   -- runs until [0, d, n] is on the stack,
                   -- where d is the largest divisor of n <n
    3              --   subtract top value (always 1) from k
     div           --   the divisibility test
        0          --   push 1
         7         --   swap top two values
          3        --   subtract (1 - div test result)  
             2     -- add the top 0 to the last k
              0,3  -- subtract 1
                   -- if the loop ended with [0, 1, n], this is now 0
                   -- otherwise we have a positive number
```
[Try it online!](https://tio.run/##Xc/hisIgAAfw7z6F4Be93HCtbSBzT9AbRISUNWnnmVvh4t59p3IHdQp///4UwV6OVzUMy6LNWXvIEGDcIi8sKrgHRez8KWKGFazTfk6C55Unwco3y5Jt3uwjWfViJ/2AM4wv1i8689RA88@e4BjlG9/ogTvSZqOVBrdHYoVDdzPpAWMhGMl7JU8E3xDx4BD@4EGWwb9h4OVLjbBXTsEH@JTaCBeub03XCeu0mXKMds2e5JO8KlizZdkVlNGC0ZLWv7OiG9qEZCHLeLQOtdz/AA "Haskell ‚Äì Try It Online")
---
`0,20,10,0,3,10,2,0,3,comp. test,20,2,1` generates the next prime less than `n`:
```
0                        -- push 1. This means the current number is composite
                         -- Even if it isn't, we still want to find a prime <n
 20                      -- while loop. This iterates until the composite tests returns 0
   10   10               --   we have an positive number on the top of the stack ...
     0 3                 --   by subtracting 1 until it is 0, ...
          2              --   and adding this to the last prime candidate ...
                         --   we can get rid of it.
           0 3           --   subtract 1 to get new prime candidate pc
              comp       --   check if pc is composite
                  20     -- end of loop, top of stack is now [0, p], with p prime
                    2    -- add 0+p
                     1   -- duplicate the prime, such that we store the result,
                         -- and can use the value to find the next prime
```
[Try it online!](https://tio.run/##Xc/RasMgFAbge59C8EY3E4xpUpDaJ@gblFKkdYs0c9ZkxZS@e6ZujHQK5/x@HA7YqeGi@36ejX0zATIEmHAoSIcqEUCVsrjLVGMHPL@nLHh6DSRa/WRFttWTvWRrFnY2NzjBtLFd6CRyAut/dgenJA98pUfhyaYYnLJ4cyJOevRlR9NjLCUjZafVmeArIgEc4x8CKAr4dyx8/9QD7LTX8AY@lLHSx/md3W6l88aOJUb7hvEDKUd10bBl87xnlDNaMcponRr/CTRbTdvf29AVXcfKYl3M8RSqwzc "Haskell ‚Äì Try It Online")
---
`30,0,2,0,2,next prime,0,3,0,3,30,2` repeats this until the prime `2` is found:
```
30              30  -- while loop
  0 2               --   add 1
     0 2            --   add 1
        np          --   find the prime less than this
          0 3       --   subtract 1
             0 3    --   subtract 1
                    --   if the prime was 2, this is now 0
                    --     and the while loop terminates
                  2 -- add the 0 to the 2 to remove it
```
[Try it online!](https://tio.run/##XY9va8MgEMbf@ykE3@hmgjFNClL7CfYNSinSukaaOWuyYsq@e6buD@nuuOee@3EcXKeGi@77eTb21QTIEGDCoSAdqkQAVfLiLpPGDniep0zw9BxIZPUDKzJbPbCnzJoFO5kbnGC62C7oJLID63/sDo6JfOIrPQhPNsXglMWbI3HSow87mh5jKRkpO61OBF8RCeAQfwigKOBfWHh@1wPstNfwBt6UsdLH/Re73UrnjR1LjHYNY3tSjuqiYcvmeVczyij/LUarNNep8W9DM6tp@5MNXdF1VBZ1sceTqbJNFc/y/Rc "Haskell ‚Äì Try It Online")
[Answer]
# [R, Robin Ryder](https://codegolf.stackexchange.com/a/213985/46076)
```
5.099829245500619335478113833945732102551318887107339446461762721i
```
[Try it online!](https://tio.run/##Fcg7CgMhEADQq1hqE@brzBS5xeYEC4KNwq6B3N4kr3zXbumZdnuPc/U58qekPtYxX6t5Puf9i7Jb1gdEOAWJKkDFYFYxR2RnDlFjQiBVZHR3Q7B/S5WKVskIe9lf "R ‚Äì Try It Online")
[Answer]
# [Sisyphus, Jelly](https://codegolf.stackexchange.com/a/213991/78410)
Password:
```
[1.1071487177940904,1.1071487177940904,1.1071487177940904,1.1071487177940904,1.1071487177940904,1.1071487177940904,1.1071487177940904,0.897846510365972]
```
[Try it online!](https://tio.run/##y0rNyan8/9//cFtIwP///6MN9QwNzA1NLMwNzc0tTQwsDUx06C9koGdhaW5hYmZqaGBsZmppbhQLAA "Jelly ‚Äì Try It Online")
The code `O√ÜTP`, when taken literally, means `product(math.tan(ord(c)) for c in input)`. But the ord function in Jelly does nothing for numbers, so we can ignore that. Now the problem is to generate that *very* specific number. I figured that as product is likely to have precision loss, I'd use 2's as multiplicands. The number `1.1071487177940904` is equal to `arctan(2)`, and I use seven copies of it to reduce the problem to `arctan(x)` where `x<2` so that I have better chance at getting that exact result. Finally I computed `arctan(answer/128)` and put it as the last term of the input array, and it worked perfectly.
[Answer]
# [att, Wolfram Language (Mathematica)](https://codegolf.stackexchange.com/a/213979/98349)
Password:
```
flag /: Head[flag] = flag
```
[Try it online!](https://tio.run/##y00syUjNTSzJTE78r6yvr5cYb2XnkZqY4pCoFv0/LScxXUHfSgEkEA3ixCrYKoDo/7H6@gFFmXkl/wE "Wolfram Language (Mathematica) ‚Äì Try It Online")
.
We can adapt this kind of solution to work with any Mathematica program:
```
a /: _[a] = flag; a
```
With this argument, any function returns `flag`.
[Answer]
# [JavaScript](https://codegolf.stackexchange.com/a/238174/64121) by tjjfvi
The flag is: `()*` (Or `()?` / `(){0}`)
[Try it online!](https://tio.run/##LcYxFsIgDADQq/iYElsZ3NvNC3iDFPIQxZAHqPT0dPFP/0lfqq5EbZeq0XN5Z3nxPobLUnNim3IA07uxVVNsIPw73TncuoIuhcmnKAyIaAv7j2MAmjdcVpq22Ri0iSW0x3qd9F8cA/B8AA "JavaScript (SpiderMonkey) ‚Äì Try It Online")
This splits between the two x's (it matches the empty string) without actually capturing anything with the group. The return value of `split` includes capturing groups, which results in `["x", undefined, "x"]`. This gets reduced to `"xundefinedx"`.
[Answer]
# [Sisyphus, Python3](https://codegolf.stackexchange.com/a/213987/11006)
All you need to do is keep the processor busy for more than 9 seconds.
Any regex that requires lots of backtracking will gum up the parser. The only real difficulty is not slowing it up so much that Tio runs over its 60-second limit.
```
'b(.*.*.*)*z|baaaaaaay'
```
[Try it online here.](https://tio.run/##K6gsycjPM/7/PzO3IL@oRKEoVackMzeVK8k2M6@gtERDM9rKxCCWK9EWJKoHIjQ0uYpS9XITS5IzNJJ0kjS5MtMUkCR1E@0srQqKMvNKNAw0//9XT9LQ0wJBTa2qmqRECKhUBwA)
[Answer]
# [JavaScript (SpiderMonkey), tsh](https://codegolf.stackexchange.com/a/213997/48931)
Password hexdump:
```
61 61 61 00
```
(3 `a` followed by a null byte).
[Try it online!](https://tio.run/##JYy7CsMwDAB3f4U2JxTjdMnW/otiC6I8bCGbkkL/3W0TbrnhuAnL3BqFOYPFhxLGjRN1vRHlVDu8YW/hCSFHMubKxvufYbDwgeOI4BSc/NxnqX7BF5agLNUV4Ui657TS20@c/FLOT2tf "Bash ‚Äì Try It Online")
[Answer]
# [Eric Duminil, Ruby](https://codegolf.stackexchange.com/a/214092)
My password is
```
14127792144400463565475544498208881214759697720904563865426051592050217695592754443713601541725640031x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000123456789
```
According to the Ruby documentation, to\_i discards everything after the first integer it finds.
[Try it online!](https://tio.run/##tY9BCsJADEX3nqJ01Qodk8wkmSx6kiKCUKWbKraF0cvXqYI3MItPPi8/8B/L@bmuqb3287S7L/NUVKkD59zYJjcNr/5ARzffTsM@daNzDX5dvelUeamL4VKkrrEPa9sSyQcWjVauKwYkVSMMIQAE8SwclDlbiwQxRsxM2cRUCQxy0sd8QwKMbAQMhCrGedct5hW9AHJAJZb81GOCf82vyhs "Ruby ‚Äì Try It Online")
Alternative solution:
```
9164214512877268290754278122624834497733309914632715416260853069873976599113800182718102190123456789
```
I factored the semiprime with cado-nfs.
[Try it online!](https://tio.run/##PY1JCsJAFAX3niJkZYS0f@o/LHKSIIKgkk0UE6H18nECNwWPelC3@@GxLKU7H@dpdb3PU7UuPaSUxq6kaXget7RL82U/bEo/ptTibzUfTmvWphpOVenb@Lquq5FYsppHvSyBKoSSkdyM1CnAspA5EimJs0iYMTNEoCiTYRZUUvDMoOHGYZrfEtkB0N8HRyAM@Gde "Ruby ‚Äì Try It Online")
[Answer]
# [JavaScript (V8)](https://codegolf.stackexchange.com/a/214153/44718) by PkmnQ
```
({toString(){return this.i--;},i:43})
```
[Try it online!](https://tio.run/##PYtBDoIwEEWvMiYuIAEWysJg0EN4ASpOYUyZajvFGMLZa6OJu//@y7urWfne0UPK@RCjbrk98aatd@duu/AK5EEBh@mKrmv@l4wIiv0LHYj9UjBCkxKEZ0AvZBmsBkMai59mmtH5RIpvgGm/ZSQeuthb9tZgZeyQ6WwRexGXRJYvDiU4Tjn5isryuBbU1Ps1z@MH "JavaScript (V8) ‚Äì Try It Online")
JavaScript variables like: `({toString(){return this.i.shift();},i:[1,2,3,4,5]})` would be useful in many [cops-and-robbers](/questions/tagged/cops-and-robbers "show questions tagged 'cops-and-robbers'") answers.
---
```
({valueOf:()=>43,toString:()=>42})
```
[Try it online!](https://tio.run/##PcpBDoIwEAXQq4yJC0jQBbIwJIUjuPACVJxCTZlqO60xhLNXIom7//7/Dxml751@8iGeU1KCREM7UZVtt59pAe1BAoXphq6r/xWPCJL8Gx2w/SkY1pNkhFdAz9oSWAVGKyy2mXRE51dJugOu@cOjpqFLvSVvDR6NHTKVzVGagBdVZ7loqlPB9spu/W0ulzxPXw "JavaScript (V8) ‚Äì Try It Online")
It is strange: While, let `p=({valueOf:()=>43,toString:()=>42})`: `''+p` results `"43"` but ``${p}`` results `"42"`...
[Answer]
# [ZippyMagician, Arn](https://codegolf.stackexchange.com/a/214040/11006)
Password: `J0e_Biden!`
I'm sure this isn't the password that ZippyMagician was thinking of, but it works at least. The flag is equal to 296, and the uncompressed code starts with `:*:*`, which raises something to the 4th power. I'm not sure what's going on in the middle, but the last few bytes of code (`:i0^:i"n`) calculate the value of *a**b*, where *a* and *b* are the indexes of the characters `0` and `n` in some transformed version of the input. So if the second character is `0`, it's just a matter of tweaking the input until the `n` is in the right place.
[Answer]
# [Python 3.7](https://docs.python.org/3/), [ovs's answer](https://codegolf.stackexchange.com/a/218895/69850)
```
@print
@int.__invert__
@len
@ascii
@ascii
@ascii
@ascii
@ascii
@ascii
@ascii
@ascii
@ascii
@ascii
@str.lstrip
@min
@ascii
class a:
 pass
```
[Try it online!](https://tio.run/##pY5BDsIgFAX3nKJdAY0hJt1VMRzEhOAvRgz9EMBGbXp2bFx4ATfzZvUy8VVuAftaQYZoke25SNaMjJOlg/W4dPSMzU4MB6m0ucBor@7uJwwx5TK/6drK/gQCwgMLo@BNzpS30j4tMOC1qpgcFqI2CK0dzjYVrYnyFokyGZz7e3JJwm9wkajJ/W6/LY0ZSBM3@QA "Python 3 ‚Äì Try It Online")
I used a brute force program to find the solution, although in the end it ends up being quite nice: [Try it online!](https://tio.run/##hVTLctowFF1bX6GIBRJxHNNONk7dCdNV990RxiNsuSgxskcSFEz4dnolPxLSRVl40H3fc47UHO2mVl8vl8nN/Vqq@8afkdw2tbZYKtOI3CL4yRLHCQoaLZWlRlhK8o0m7O40mz4rHEbJY/qU8XVeiFK@VFtVN9rYfTs9MxRoLo3Ac4Ta9HRGCEIwLwrahljxrWBQFqqfZu5w/vbfghAeWH1MsErFnlfU1wCbOOSisQnWwu60AgMUlQVVDKvarYJblxm0S29cpT4RRmCwXVlrnLuYQmqaZeudrCwsn2X9cN5H6kYo7BGAwiQyTSUtZQnOawXRO4GCfq2cdSWLrkXhspezNoJxd8JQtoKqbgWYx4U1zr/n2tCC@RmhY5OmJMuMbEVdZhn52CQY2pTk5Duco1NzJoDBAEHDjYGt4CuARUp4VZEQw5f9M0mIW5RXEIkXfZ4WPN/wdSXSEyC1gP0oJQsSshAv2NmzV1bc0kOPjTSAlOUqF/QQYrtrKk@p34y7focEH6WoClzqetvlcjdsZcTgOSDvy@uqAr3JWhncS/BHvVNWaGSPjchyd0h7E2XICKEyIGQrrdyL1MmSocmfjawE/qV3IvEsSAjmrqgbRnP1W9B5HLNRzeTnEJBggGkMZ916wzFNH9xaoOHXBO@xq/wawh@nrAiitgCnI8cl7ZfxyjmoNwQE2kRZJtUe@AA2w97MTS4ltCSVUIMRIEYeO1lkIaZAhVQhrtcvAEzm@RsJivK6OVI2NHfTTaA5uSMuzFhNh7SBj7ITZNkNPYjAa66/UuWY44yDoD6K7/O1GsfxZQKbOqqoGrHwQRQQCN1IXTPvAETv5vGXh94ysFECvcUNYdfWJ4JvMbwMT9PopZaKagFYGlHQ5cwryuPEVgxUSp7Vs3p7Gyv0SjJH8@g@kTi4a/s@hgfrSknXCwfBtTdy1889G87lVTzWelfp0q6@pw9xHH@udRVym867MpNuzSnu1/M7DeR71phfDdbyT5bLGYEfX7SreIhD6HL5Cw "Python 3 ‚Äì Try It Online")
Initially I found one with `__sizeof__`, but it doesn't work on TIO (being implementation-specific).
I had to made quite a few tweaks for it to fork (disable `open` and
`id`, as the former will read from stdin with `list(open(1))` or something similar)
It's also possible to get `import inspect` and quite a few other modules, but I didn't consider that possibility.
In retrospect, `repr` would work as well, but `ascii` comes before `repr` in my generator program.
[Answer]
# [JavaScript (Node.js) by emanresu A](https://codegolf.stackexchange.com/a/237515/104752)
```
[Math.PI, 2n]
```
[Try it online!](https://tio.run/##ZY7NSsQwFEZfZVxI7sWa1lnMwjYjiJsR/AGXtTAhpk2GcBPSTHSoffbqgDu/7TlwvoPMclTRhnRN/kMvSxBZbKcUT5MUbVdDL5TYqrseVLmh74oKycNxNMAu2g7wirXqckMd4m1FCEbc22FHCR7fXp75mKKlwfYnyMijDk4qDeX7QzkUjCFifa5kobN0IPnBW9rvcVYyKQMap6jTMdKql27Uc217MM0NNc26@h1hMtF/si/2z89t1QkhnmQy/HU3z4vyNHqnufMDBGj/QLFan28vPw "JavaScript (Node.js) ‚Äì Try It Online")
`JSON.stringify` throws a `TypeError` if it finds a `BigInt`, thus executing `catch(e){return v[0]===Math.PI}`, and then it is simple to make that true.
[Answer]
# [JavaScript by tjjfvi](https://codegolf.stackexchange.com/a/238444/104752)
```
document.all.toString = ()=>"length", document.all
```
[`document.all` is an object that is unique in several ways, including being falsy.](https://tc39.es/ecma262/multipage/additional-ecmascript-features-for-web-browsers.html#sec-IsHTMLDDA-internal-slot)
`in` uses `toString`, so the first part can be made true by changing `toString`.
[Answer]
# [HyperNeutrino, Python 3](https://codegolf.stackexchange.com/a/213965)
Password: `import sys;sys.exit()`
[Try it online!](https://tio.run/##HYpBCoAgEEXXeYpwo4JE0c7oNDHQgNlkEyXR2c1aPPjv8yjxvIY@53NGD3XnRMUxOT9ioIO1ERVcExCXR6lPYNLe3o@9JVzI0rVWbsc/nhJTxMC6MznjQmvkek/7UGi@WJsX "Python 3 ‚Äì Try It Online")
Output: nothing
I'm not sure if erroring would be OK. It would not output anything to STDOUT, only STDERR.
[Answer]
# [HyperNeutrino, Python 3](https://codegolf.stackexchange.com/a/213965)
Password: `raise SystemExit`
[Try it online!](https://tio.run/##K6gsycjPM/7/vzwjMydVwdCKi7OkqNIqxzYzr6C0REOTizO1Ijm1oAQooq4O4qQma@ToVNfqVCulVmSWKFkZ6CgVloIZtUDFBUWZeSUahpr//xclZhanKgRXFpek5roCVQIA "Python 3 ‚Äì Try It Online")
Output: nothing
[Answer]
# [ThisIsAQuestion, Python 2.7](https://codegolf.stackexchange.com/users/15100/thisisaquestion)
```
True=False
The
Flag
```
[Try it online!](https://tio.run/##XY3BDoMgDIbvfYqGjAQWs8OOS7j6BN50W9DhJFFgCHF7egbxZk/t169/3S9M1lxT0ouzPqBXANo4FOjl9sxdDIyDHtHYsrwsMgwT8@TRdlv3EvfziVSYNX4DzPWJuvjqqwZWKIA8RPWHeZzlO6OsCeyhfNqJwMZHtac6r01ghK5IV0KZrLDnPKUiiFrOq4JmUlDnuz8 "Python 2 ‚Äì Try It Online")
Output is `The Flag`. *Sadly* reassigning `True` doesn't work in Python 3 anymore.
[Answer]
# [Perl 5](https://www.perl.org/), cracks [Nahuel Fouilleul](https://codegolf.stackexchange.com/a/213976/17602)
Password: `"^^@@^^:@@@^"^".,).*||,!'|"`
[Try it online!](https://tio.run/##K0gtyjH9/z8nNS@9JEND08bIQkFNTUFRP6ZcH8RILUvMARP//yvFxTk4xMVZOQBJpTglPR1NPa2aGh1F9Rqlf/kFJZn5ecX/dfMA "Perl 5 ‚Äì Try It Online")
[Answer]
# [SE - stop firing the good guys, ><>](https://codegolf.stackexchange.com/a/214022/64121)
One password is
```
5 8a*3+o ab*1+o ab*1-o aa*1+o ab*6+o aa*4+o aa*5+o ab*o aa*3+o 48*o ab*5+o ab*1-o aa*1+o aa*8+o aa*8+o ab*5+o 48*o aa*o aa*1+o aa*8+o aa*5+o aa*1-o aa*5+o ab*1+o ab*7+o ab*5+o 95*1+o 95*1+o 95*1+o;
```
[Try it online!](https://tio.run/##S8sszvj/P9PQoOD/f1MFi0QtY@18hcQkLUMopQukEmE8M20wzwRCmUIEwWyQLhMLLbCAKabWRC0LJAqiBKI8UQuLKlMIBTXBFMVF5ggTLE3BgiiUNQA "><> ‚Äì Try It Online")
The program was `i10p`. `i` reads one character of input `1` and `0` push `1` and `0`, and `p` changes the value at `x=1, y=0` to the inputted character.
Whit the first input the program is modified to `i50p`, which allows to execute arbitrary commands from input.  
`0-9a-f` push their hexadecimal value to the stack, `*+-` work as expected, `o` outputs a value as a character and `;` terminates the program.
[Answer]
# [SunnyMoon, !@#$%^&\*()\_+](https://codegolf.stackexchange.com/a/213975)
```
1728
```
I read the code, and it seemed to parse decimal input, divide it by 48 (not halting if it's not divisible) and print the corresponding character 3 times.
[Try it online!](https://tio.run/##S03OSylITkzMKcop@P9fK05DVUEhXlsrTlNVwyBeW1UTzI1T0VCJj4sHY21FGNCGgTgVTW2gFEilikZ8HBzEq4BkKirAwgbaEK6iooODw///huZGFgA "!@#$%^&*()_+ ‚Äì Try It Online")
[Answer]
# [Kevin Cruijssen, 05AB1E](https://codegolf.stackexchange.com/a/214006/64121)
The password is
```
2
,*x≈æI≈æ?¬∂
```
The `.E` builtin seems to push the Python code back to stack when it failed.
The first input is just any number for the loop. The second input is a reversed 05AB1E program to produce the correct output:
```
¬∂        # push newline character
 ?       # print without trailing newline
  ≈æI     # push 2**31
    ≈æx   # push 2**6 = 64
      *  # multiply these numbers => 2**37 = 137438953472
       , # print this with trailing newline
         # since there was explicit output, implicit is now disabled
```
[Try it online!](https://tio.run/##AScA2P8wNWFiMWX//0Z9xb5o0Lw5wqMuRVIuVir//zIKLCp4xb5Jxb4/wrY "05AB1E (legacy) ‚Äì Try It Online")
---
After some more experimenting, I found a cleaner password:
```
3
print()
3
```
[Try it online!](https://tio.run/##MzBNTDJM/f/frfbovowLeywPLdZzDdIL0/r/35iroCgzr0RDk8sYAA "05AB1E (legacy) ‚Äì Try It Online")
`.E` executed on `"print()"` returns `None`, reversed is `enoN`. This is then executed as 05AB1E code, which seems to return the right result. I'm not sure how though, there might some features of the legacy version used here that I don't know of. Beacuse Python was used to print the newline, the value is still implicitly outputted.
[Answer]
# [Python 3.8 pre-release, pxeger](https://codegolf.stackexchange.com/a/214073/46076)
```
("unittest.mock",("mock","sentinel","pxeger","name"),())
```
Probably not the intended solution.
[Try it online!](https://tio.run/##bU5BTsQwDLz3FVa4JKuIA3BARfsA3rBaVd7UaSNSJ0odYF@/hAA3Th7P2DOTr7ImfnzO5eZL2sBXdpJS3CFsORWBw3AHF3JYd4JXYKIZkP9EFJCVYBcsYmGPwRHU3DmXZgJJsJBA4njtZHcPieEjtNgq4FbkJfDS1Ui8yArJ923DwN1l8Ed6x6iVUv93PLxE3C4zAtqLdaOex2OhuToy@lcg60c6@bN1dtatEYqUdjtNPwbTpNEYc2sJp4en8WyGIZfAor0@9OjAuYo23zdaVQ4itMv9ltybslr9TLUTS2CKDeZPWqg0wLiRMra9fgE "Python 3.8 (pre-release) ‚Äì Try It Online")
[Answer]
# [Ruby, Dingus' answer](https://codegolf.stackexchange.com/a/214106/48931)
```
system gets;exit
echo '"""'
```
[Try it online!](https://tio.run/##KypNqvz/X1E/Ojg5raAsRs8qxl5dSdUmQSNWX02tQCO1LDFHJV7z///iyuKS1FyF9NSSYuvUiswSrtTkjHwFdSUlJfV/@QUlmfl5xf918wA "Ruby ‚Äì Try It Online")
[Answer]
# [r3mainer, C](https://codegolf.stackexchange.com/a/214125)
I'm really sorry, but [this](https://stackoverflow.com/a/31515396) answer on Stack Overflow has code that directly undoes elementary xorshift operations... It made running xorshift in reverse much easier (I only had to copy-paste some code and write 6 lines of Python).
```
07RtUrVE
```
[Try it online!](https://tio.run/##S9ZNT07@/z83MTNPIzOvRCFRJzkjsUhLK0mzOi2/SKM0rzgzPS81RSEnPy9dQavCVktbO0kn09bU0sjS1DpTV9daqyLOVqvCxsbQWAfCtLMz14EJmmpaF5SWFGsAjbOu/f//v4F5UEloUZjrv@S0nMT04v@65QA "C (gcc) ‚Äì Try It Online")
[Answer]
# [Conor O'Brien, Javascript](https://codegolf.stackexchange.com/a/214185/36445)
```
^^^Z_][_\\\\\]_\\]]]]]]]]]]]]]]]]]]]]]_\\\]_\\\\\\\]_\\\\\\\\\\\\\\\\\\\\\\\\]b_\\\\\\\\\]aa
```
The code seems to generate a random maze (the seed is based on our input, but I don't use that) without loops. We must solve it (in at most 999 steps) with a program in a stack-based language with these 8 commands:
```
0, rotate stack: S.push(S.shift())
1, pop twice, compare and push difference: [a,b]=S.splice(-2);F=a==b;S.push(a-b)
2, increment register: M++
3, push register: S.push(M)
4, pop and discard: S.pop();
5, reset register: M=0
6, pop to register: M=S.pop();
7, set answer to ToS and halt: R=S.pop();O=[]
8, pop pop() numbers, and if the last equality comparison was true then
   insert the numbers into the program: n=S.pop();n=S.splice(-n);if(F)O=n.concat(O)
```
The program receives its input as the lengths of the lines of sight in 4 directions, and must output one or more commands in base 4 (digits 0 and 3 are errors, 1 is "rotate left" and 2 is "move forward").
My algorithm checks if the line of sight to the left is zero; if it's zero, then it rotates right (by returning 21), otherwise it rotates left and moves forward (by returning 9). I might have confused left and right completely, though.
Our "program" is obtained from our input by concatenating all char codes in it (as decimal integers). However, nines are discarded. So I used characters with codes from 90 to 98 to access the commands.
[Try it online!](https://tio.run/##bVYNb9o8EP4rfIjKbowX2Ca9bXZUbbdW00aZgOndlnlbCAFSkUDjlA@B99e7s53Q9n0XCXK2z/fx3HMHt8EqkGEWL/NmuhhHD8tskSzzClQIrUCngsswkpIH2XTlt4X38AWIzznvCTYAX1Do7OZRXumyKxawEeuz1OvCFbjeehbPI9Lj8yid5jMarYI5IbWzAZezeJITSus@XhDVNvWuIAAYeWdBc0TrXcepn3VpvVHvgoufRr0PjR66qqfQSKsp9eIJuaI9SHm4SMMgJz1a43I5j/Nf9V9@r7Qv9vtajfIsWs6DMCIvGi@mrDbgy8WSUO/pwfez4uRezsjTg6reh4GxjetmjVIvi/L7LK30lYfOZV75DBYvQosQfvEkWJJIQxfxcBZklwjquc6X3y7iFM8P9k@0/VpxkWjJXIWOE1GvDzt52nZZcupu/nHtw4LTVst9@br1uv3qNQtPW@2X@J4i/HeE7srQuATS58ExCsdOn4e00eeJYjFZPdG5e/G7idvHq72rjIXRUwsxaVPFZqbQgaC7ySIjMfxuBkU1vbjjenGzSXe3oLVjp0U9P/BjwQL/Vgjw9YvpDaEKq4FSno7tMwIwvsf8yZKFSJ@lEzKXeuE8kLIy2BlYs/swR5drloJLd/kslnwNa88IKaRWkLBTVgpRUjdkCHp1SCON1pUBGfI1G/KUqk@Hc52N5myMLI3foIIXOw5FVlWHPMSQ6ZCfk1jfwu2y4kPVJZLlrDSiDZyDviAFuzBCLrwhl/65APva7327c2F3Lh53zoWlG@JrT2ihaCgQYlNpg6GAc0W9cYTOoopVUAOi@@w/uWrtQIAJYyTUOQmZPOgUpqQDtZpxI2088jEeWcQTUnXsD7bJaDHncR5lAZZBIDO2cTQfH/dGt1GY8yjNsziSxFaBqm9kApNgLqNn4FxilCFbsRuWsSmbs8S7xCb2RuCH4ApPF8EL3/xuavxDBHqHBRjyAUYeIpv2e1KdHB31@YjS3aUNbkTNbaclVITeMK9uoe2NivBRVupRfaU93mCyN8SMjerkUH0/ZlIsJpWhjfbO8FgW/G62rPodvXMcb4pnMyKxUc0ccNkdWj7Ub0q9aVm1G66RjykGkWnXl@VBaAQSsZgFZmQCtgzAoZ8SqM6P216yh9YxWfE4HUeb3oREtAqgg8msu4Sqwwzyb/gnQlkmlMyDPA4rV2QNLZfN8MvmJMG2wJpaTTYF328JwTTxDf7xG8v9qe8WBGgx9Pa8QWZGZedL9AWSf8NJAGAgmh5AeE8yTLog4xQ7XV9/DyRjFezr3NKj/K14CxgFe6e/MbGS8G@tMZc5hIRHbQrY@tR7Z3fNXsvsYYDqgMFb9k6oYnZcPJ8dj1gYniY4yBEhNqN2ZmSYmxGuAa9EVp4QqgKyMSzmG7a1wvbQZtaSvxX@RqgJeWywDXJsi59oC63il2/IA4Llc3GabJBEeFbYTTTYJc@eKGuN4kK0aTbVv@S53w3Y@9Hm6MjGVW5s1ZhkVs4Od3zfZQiz32wxF18ua@qVXggfSfORFMBkGJwVGvBKXRHLnUWJwbLAgI2tMCYFgBsHxpiJXWz1AsuJTWPWmDpAq/CwgUWhBcsSc0MIVapjqtRUbzGP@HwxJbV1nNboc2UcwDq7Ik8n83TAhmgJ9shjfBll/6tgAXMRG@4j0BhemUMZfuI4JYkTNSQTi0UikarsJXNZW7AVTEgiy19qY7CLfYpUtS5WRXGubfJ@7cPHqw81f9V4JQQfYWObICiiuOp0oK2eVvha9UufX@Hk5ORp1NdHR1@bzY5LzUrHphTR/X2h/1r0SQCdL@QzThf68PDw48ePbz@F//O7fgS@xN@en8XhQevvjxg9Hokg@AM "JavaScript (Node.js) ‚Äì Try It Online")
[Answer]
# [Dingus, Ruby](https://codegolf.stackexchange.com/questions/213962/guess-my-password-cops-thread/214164#214164) and [Dingus, Ruby](https://codegolf.stackexchange.com/a/214106/65905)
One password for both Ruby challenges by Dingus is:
```
G=->*x{i=0;i+=1 while x[0][i]!~x[1];x[0][i]};Q=method G[methods,/^[o-q]ri/];C=method G[q=Q[],/[o-r]ut[b-d]/];D=method G[q,/^de/];P=G[q,/^[o-r]\z/];D[P]{|x|};C[34];C[34];C[34];C[10]
```
[Try it online!](https://tio.run/##XYtLC4JAFIX/yhSFPXxSq6aphYFbpeXtRg8nGijUSU1L@@tmGRRtDufxHZns8qoKCU@3p15nqku@9fVYKsv9IUxzfTJfKe3udNNT1I7RryqHabNBdhfMpGLILHI9ihMnGZgIAluPDCykn1RSj515fAx84kBjLqqxhkCLUAoDqf2dI@YBqka9SUxi2Gk@1sDiB6ifPq87lzXhja5uLwpcvBdZUVIbRmP8U8vEJw "Ruby ‚Äì Try It Online") & [Try it online!](https://tio.run/##XYvJDoJAEER/BYy74kD05Dh6wMQrxGPTrmCYBAEBFQX8dEdcEo2XSi2vouPmIoRMYL7dhSerN7QmjUpttGoiqdfDpnNae9VlS4gZU8btNONMpbzDNOnscs@RUlAROMq3FDSkn1RQk@2dxA1saQZvE3fJAgLlgBEnSPXvfGAmYJeUW4THBDaKjSUw/QHKp@2UncHe4YVa1ycFBmZ5mhdUh/4A/1RT8R6ECQ/8WCj@Aw "Ruby ‚Äì Try It Online")
* Gets access to [`putc`](https://ruby-doc.org/core-2.7.0/Kernel.html#method-i-putc) by listing all the available (private) methods and filters them with regexen.
* Also redefines [`p`](https://ruby-doc.org/core-2.7.0/Kernel.html#method-i-p) to not do anything.
* a lambda is used instead of `def`
* `method :method_name` with `[]` is used instead of `()`
* `.` cannot be used, so only the methods for `Object` and `Kernel` are available
* Since `putc` is available, any string could be written.
FORTRAN like code:
```
GREP = lambda do |l,r|
  i=0
  while l[i]!~r do
    i+=1
  end
  l[i]
end
PRIVATE_METHODs=method GREP[methods,/^[o-q]ri/]
PUTC=method GREP[PRIVATE_METHODs[],/[o-r]ut[b-d]/]
DEFINE_METHOD=method GREP[PRIVATE_METHODs[],/^de/]
P=GREP[PRIVATE_METHODs[],/^[o-r]\z/]
DEFINE_METHOD[P]{|x|}
PUTC[34]
PUTC[34]
PUTC[34]
PUTC[10]
```
[Try it online!](https://tio.run/##KypNqvz/v0AhtSwxR0PFRq8oNTFFr6RIPTg5raCsUs/KPkZdSdUmQUNdR0Vf8/9/9yDXAAVbhZzE3KSURIWUfIWaHJ2iGi4FhUxbAyBZnpGZk6qQE50Zq1hXBJQGCgGltG0NgYzUvBQgCZLjAjEDgjzDHENc431dQzz8XYptc1NLMvJTFEAWREPYxTr6cdH5uoWxRZn6sVwBoSHOKIrQDIiO1dEHqi6KLS2JTtJNiQVqcXF18/SDKSCkNy4lFWSLLU55sOExVejmRgfEVtdU1NSCHRhtbBKLi2FoEAsA "Ruby ‚Äì Try It Online")
[Answer]
# [R](https://www.r-project.org/), [Robin Ryder](https://codegolf.stackexchange.com/a/214226/67312)
```
function(x,y,z){if(length(ls(1))>1|length(ls())!=3)return("S");LETTERS[lengths(lapply(y,intToUtf8(x),z))*lengths(lapply(y,intToUtf8(x+32),z))]}
```
[Try it online!](https://tio.run/##K/qfpmCr8D@tNC@5JDM/T6NCp1KnSrM6M00jJzUvvSRDI6dYw1BT086wBsHX1FS0NdYsSi0pLcrTUApW0rT2cQ0JcQ0KjoaoKdbISSwoyKnUqNTJzCsJyQ8tSbPQqNAEmquphU@FtrERWFFs7f80DUsTHUMdQyszzf8A "R ‚Äì Try It Online")
The password is pretty insecure: `94,(numeric vector of length 1),(numeric vector of length 6)`. In particular, `94,1,1:6` was what I used.
The first thing I did was note that the `lengths` have to multiply to `18`, so we need to generate two lists such that the `lengths` are equal to `1,18`,`2,9`,or `3,6`.
Next, noting the `intToUtf8(x)` and `intToUtf8(x+32)` I found all pairs of functions that satisfy that condition with [this script](https://tio.run/##K/r/v0LBRlchsaAovyC/WENJT1tJJzc/JdVWKa00L7kkMz9PSZOrEqQkJ7GgIKdSo0KntCTNIiTfM69Ek6sKSaJSJ0E7QcfYSJOrHCRaDBGt0snMKwnJDwXq0eTiqoguV83MU62I5SqHsf7/BwA). I safely ruled out `nrow` and `ncol` since they would generate the same values, and the `lengths` must be distinct.
After that it was a matter of just trying things out; `lapply` always returns a `list` with length equal to the length of its first argument, so `y` had to be of length `1`. Luckily, R recycles, so `lapply(1,"^",1:6)==list(1^(1:6))`, which has `lengths` equal to `6`.
Finally, `~`, the `formula` builder is very odd, `x ~ y` is a `formula` with length `3`, with three elements, `'~'()`, `x()`, and `y()`, so `lapply(1,"~",1:6` is the same as `1 ~ 1:6` which is also length `3`.
[Answer]
# [Python 3](https://docs.python.org/3/), breaks [pxeger's challenge](https://codegolf.stackexchange.com/a/226206/94093)
```
__builtins__
SyntaxError
__build_class__
```
[Try it online!](https://tio.run/##K6gsycjPM/7/39M2M6@gtIQrwrYssahYA0xoRntqaMZqckWAaVsIxZWck1hcrOBpZahv8P9/fHxSaWZOSWZecXw8V3BlXklihWtRUX4RF0QiJR6sOj4eAA "Python 3 ‚Äì Try It Online")
The first line loads the dictionary of Python's builtins.
Then, we assign `__build_class__` to `SyntaxError`. Why? Because `__build_class__` is called like so
```
__build_class__(<class_body>, "class_name")
```
While `SyntaxError` is called like so
```
SyntaxError("msg", (filename, lineno, offset, line))
```
When Python tries to call `SyntaxError` as if it were `__build_class__`, it tries to index the class name as a tuple.
]