[Question]
  [
*Unlike many C&R challenges, this does not require a separate robbers post; the goal of the robbers is to crack the previous answer and then post a new one as a cop.*
As answerers, you will write a series of polyglots that look like this (each column is a language, and each entry is the output of the answer in that language):
```
Language:  1  2  3  4  5  6  7  8  ...
Answer 1:  0  1  2
Answer 2:     1  2  3
Answer 3:        2  3  4
Answer 4:           3  4  5
Answer 5:              4  5  6
Answer 6:                 5  6  7
...
```
(blank spaces mean that no behavior is required in that case).
Each answer should work in 3 languages and print 3 different consecutive numbers which are each one more than the numbers printed by the previous answer (the first answer prints `0`, `1`, and `2`). Each answer uses two languages from the previous submission, and a third new language. The answerer should try to obfuscate what this third language is.
To post a new answer, you should:
* Crack the most recent answer by finding what its third language is.
* Preferably, add an explanation for your crack and notify the poster of the answer. Once your submission has been cracked, you should preferably add an explanation as well.
* Write a polyglot consisting of this answer's second and third languages, along with another language of your choice. Reveal your first two languages, but do not reveal your new one. It will be the next poster's goal to find this language (or any other language in which it works), so you should try to obfuscate it.
## Specifications
* The criteria for a valid programming language are the same as those of [The Programming Language Quiz, Mark II - Cops](https://codegolf.stackexchange.com/questions/155018/the-programming-language-quiz-mark-ii-):
> 
> 
> 	+ It has [an English Wikipedia article](https://en.wikipedia.org/wiki/Lists_of_programming_languages), [an esolangs article](http://esolangs.org/wiki/Language_list) or [a Rosetta Code article](http://rosettacode.org/wiki/Category:Programming_Languages) at the time this challenge was posted, or is on [Try It Online!](https://tio.run/#). Having an interpreter linked in any of these pages makes that interpreter completely legal.
> 	+ It must satisfy our rules on [what constitutes a programming language](http://meta.codegolf.stackexchange.com/a/2073/8478).
> 	+ It must have a free interpreter (as in beer). Free here means that anyone can use the program without having to pay to do so.
>
* Each answer must run in less than a minute on a reasonable PC.
* You *can* reuse programming languages, but there must be at least two answers in between (so an individual answer cannot reuse a language).
* Cracking a submission consists of finding *any* programming language that prints the correct result, not just the intended one. If a submission is run in any language that was not declared or found to work, there are no requirements to do anything.
* You may not post twice (or more) in a row.
## Winning Criterion
The winning answer is whichever answer took to most time to be cracked. The challenge will never end, so it is always possible for the winning answer to change.
  
[Answer]
# Hexagony, Klein (101) and ???
```
  xx={puts/}
gets87!@xx=p
main\
>9.*5,6v
```
This prints [`7` in Hexagony](https://tio.run/##y0itSEzPz6v8/19BoaLCtrqgtKRYv5YrPbWk2MJc0QEoVMDFlZuYmRfDxWVnqadlqmNW9v8/AA "Hexagony – Try It Online"), [`8` in Klein (101)](https://tio.run/##y85Jzcz7/19BoaLCtrqgtKRYv5YrPbWk2MJc0QEoVMDFlZuYmRfDxWVnqadlqmNW9v//f0MDQwA "Klein – Try It Online"), and `9` in ???.
The `9` does not work if a newline is added at the end of the code. Be careful if you're testing locally.
**Edit:** Being live for 20 hours is already a record, so I'll give some hints from now on. (Also because the language in question is IMO not yet well-known.)
### Hints
1. "The `9` does not work if a newline is added at the end" is *very* significant, as well as the first two spaces (which are ignored by both Hexagony and Klein).
2. The language is on TIO.
3. The first two spaces make the program jump to the last line. (It's *not* a 2D language.)
4. There's no explicit output command, and the `v` command ends the program.
### Explanation ([cracked post](https://codegolf.stackexchange.com/a/171901/78410))
In the source code
```
abcd={} -- a gaffe avoiding tactic in C++/C#
abcd[!1]=   1+2+3+4+5+6+7+8+9+10+11+12+13+17!
print(abcd[0>1+2+3 and 4+8+6<0-0]//35)
if 0>1 then a.next=';' en\
                    >1+6.@.@
```
The relevant instructions in Klein (101) are:
```
IP->.....................^...........IP->/
.........................|...................
.........................8
.........................\<-.............IP<-
                         @
```
Klein is fungelike 2D language where crossing the boundary of code area (which is a square) depends on the Klein topology. `/` and `\` are mirrors.
The IP starts at upper left corner facing right. It meets a mirror towards the top boundary, and re-enters the code area on the right side as shown above. Then it hits the mirror again, 8 is pushed, and then (after passing through the boundary several times) stops at `@`. Then the content of the stack is printed to stdout, which is single 8.
[Answer]
# Befunge-96, Hexagony and ???
```
abcd={} -- a gaffe avoiding tactic in C++/C#
abcd[!1]=   1+2+3+4+5+6+7+8+9+10+11+12+13+17!
print(abcd[0>1+2+3 and 4+8+6<0-0]//35)
if 0>1 then a.next=';' en\
                    >1+6.@.@
```
This prints [`6` in Befunge-96](https://tio.run/##bcxLDoIwGATgPacY4gLNnwLlUSSKIeEYyqJAi11YjanGxHh2RNbOdr6ZTumHHRUrBbs4baZJdv1QvT9gDBKj1FpBPq9mMHaEk70zPYxFQxQ1K@@Hjz5vKwCcEkopo5wEFbSlknhMnBNPiKfEC9@73Y1162UTHxYOaQdkMxb7mMVtFKX5xjMacw13VhYytOrlqmAXQNmThz@Zn0RYh/U0fQE), [`7` in hexagony](https://tio.run/##bcxLDoIwGATgfU8xxAWaP0DLU6MYEo6hLCoU6KYY0xiM8ewVWTvb@WZGNcthMi/n5K3tyvcHQQCJQfa9gnxOutNmgJWt1S20QU0U1Rv2wxdPNCUAQTEllFJGORW0pwMJTkKQiEkkJAqP3R/a2O264eeVQ5oO6YLzEw94E0VJtmO6x1LDjspAhkbNtvSPPpS5MvzJ8pSHVVg59wU) and `8` in ???.
### Explanation
The hexagony code, when "prettified" is:
```
       a b c d = { } - 
      - a g a f f e a v 
     o i d i n g t a c t 
    i c i n C + + a b c d 
   [ f a l s e ] = 1 + 2 + 
  3 + 4 + 5 + 6 + 7 + 8 + 9 
 + 1 0 + 1 1 + 1 2 + 1 3 + 1 
7 ! p r i n t ( a b c d [ 0 > 
 1 + 2 + 3 a n d 4 + 5 + 6 < 
  0 - 0 ] / / 3 5 ) i f 0 > 
   1 t h e n a . n e x t = 
    ' ; ' e n d > 1 + 6 . 
     @ . . . . . . . . . 
      . . . . . . . . . 
       . . . . . . . . 
```
The path of execution begins in the top left heading East. The top row doesn't do much. `-` changes the current memory edge so the value in it is `0`. Execution continues heading east on the middle row where `7!` loads `7` in the current memory edge and prints is as an integer. `[` changes the instruction pointer to North East starting back at `7`. After `7+3`, execution then reaches `[` which changes the instruction pointer to North West starting in the South East corner. Finally the path is `..@` where `@` terminates the program.
[Answer]
# [Trigger](http://yiap.nfshost.com/esoteric/trigger/trigger.html), [JavaScript](https://babeljs.io/) and ???
```
[ //aТ/\\ ][ //е"6
console.log(111-111+12)]
//!'!/-²6-²52
```
Prints [`11` in Trigger](https://tio.run/##KynKTE9PLfr/P1pBXz/xwiL9mBiFWBD7wlYlM67k/Lzi/JxUvZz8dA1DQ0NdINY2NNKM5dLXV1RX1Nc9tMkMiE2N/v8HAA "Trigger – Try It Online"), [`12` in JavaScript](https://tio.run/##y0osSyxOLsosKNFNSkxKzdHNy09J/f8/WkFfP/HCIv2YGIVYEPvCViUzruT8vOL8nFS9nPx0DUNDQ10g1jY00ozl0tdXVFfU1z20yQyITY3@/wcA "JavaScript (Babel Node) – Try It Online"), and `13` in ***`REDACTED`***.
Since this has not been cracked for longer than any other answer so far, here are some hints:
* In case you didn't notice, the `Т` and `е` on the first line are multibyte characters.
* `[ //` and `\\ ][ //` are no-ops.
* The second line, as well as `-²52`, is dead code.
* The language does not have a concept of termination, so `²6` forms an infinite loop.
* To be specific, the second byte of the UTF-8 encoding of `²`, together with the `6`, forms an infinite loop.
* The number being outputted is encoded by the `/!'!/`
* The language is not on Try It Online, Rosetta Code or Esolangs.
* The only available form of output is a 1bpp screen.
* The screen's aspect ratio is 2.
* While the language was not originally intended as machine code, FPGA implementations do exist.
* According to Wikipedia, the intended purpose of the language were video games.
* The only way to access the screen is a special instruction, that takes coordinates in selectable registers, and the height as an immediate, and XORs an 8 by n bitmap onto the screen. To make collision detection easier, as well as make it possible to clear the screen, one of the registers will be set when any pixel gets set back to off.
## Explanation
Well, this took some time to get cracked. Let's see how the code looks:
```
0200 5b20    SE VB, V2   ; Skip the next instruction if VB = V2. Since all
0202 2f2f    CALL 0xF2F  ; registers start at 0, this call will be skipped. This
                         ; hides the bytecode from JavaScript.
0204 61d0    LD V1, 0xD0 ; A useless load. Necessary to use a UTF-8 continuation
0206 a22f    LD I, 0x22F ; byte as an instruction and load the address of
                         ; the sprite.
0208 5c5c    SE VC, V5   ; A red herring supposed to suggest symmetry is
                         ; important, as well as a totally intended eliminator
                         ; of inaccurate implementations. Most documentation
                         ; claims that the lowest nibble must be zero, but in
                         ; the original COSMAC VIP implementation it's
                         ; a don't-care.
```
This means that, while [many](https://github.com/dmatlack/chip8) available [emulators](https://github.com/wernsey/chip8) behave correctly, the by-the-rules implementation is linked to in the second sentence of the [Wikipedia page](https://en.wikipedia.org/wiki/CHIP-8). Of course, it can't be run directly on an average PC, but I've found the [Emma 02](http://www.emma02.hobby-site.com/) emulator linked to on the [COSMAC VIP page](https://en.wikipedia.org/wiki/COSMAC_VIP) to work the best.
```
020A 205d    CALL 0x05D    ; Skipped.
020C 5b20    SE VB, V2     ; Same as with the very beginning. Red herring.
020E 2f2f    CALL 0xF2F
0210 d0b5    DRW V0, VB, 5 ; Draw the sprite pointed to by I. Since V0 and VB
                           ; haven't been written to yet, the sprite will be drawn
                           ; in the top-left corner of the screen. The height is
                           ; an immediate.
0212 2236    CALL 0x236    ; Jump over the JavaScript and Trigger code. It doesn't
                           ; matter that we never return.
0214-022E *never used*
022F 2f      DB %00101111  ; Sprite data.
0230 21      DB %00100001
0231 27      DB %00100111
0232 21      DB %00100001
0233 2f      DB %00101111
0234-0235 *never used*
0236 b236    JP V0, 0x236  ; Since V0 is still zero, this is an infinite loop.
0238-023C *never used*     ; Together with the previous two lines, it's the
                           ; -²6-²52. It's a red herring supposed to suggest
                           ; prefix, or Polish, notation.
```
[Answer]
# Python 2, Python 3, ???
```
a={1,2}
print(1+#a
--bool(1/2)
)
```
This prints 1 in Python 2, 2 in Python 3, and 3 in ???.
Crack explanation [(Cracked post)](https://codegolf.stackexchange.com/a/171885/44694):
```
#define print(A) main(){puts("0");}
print(1+bool(1/2))
```
* `0`: C: The first line defines a function-like macro `print` that ignores its single argument and evaluates to `main(){puts("0");}`, a full program that prints `0` and exits. The whole expression `1+bool(1/2)` is ignored when the `print( )` macro on the second line is expanded to `main(){puts("0");}`.
* `1`: Python 2: The first line is a comment. `1/2` uses integer division in Python 2, giving 0. This value is then interpreted as a boolean (`bool(0)` -> `False`) and then added to `1` (`1+False` -> `1`), and then printed.
* `2`: Python 3: The first line is a comment. `1/2` uses float division in Python 3, giving 0.5. This value is then interpreted as a boolean (`bool(0.5)` -> `True`) and then added to `1` (`1+True` -> `2`), and then printed.
[Answer]
# Lua, brainfuck, ???
```
abcd={} -- a gaffe avoiding tactic in C++
abcd[false]=1+2+3+4+5+6+7+8+9+10+11+12+13+14
print(abcd[0>1+2+3 and 4+5+6<0-0]//35)
if 0>1 then a.next=';' end
```
Prints 3 in Lua, 4 in brainfuck and 5 in ???.
Explanation for [cracked post](https://codegolf.stackexchange.com/a/171887/60483):
```
a=1+2+3+3+4+5+6+7+8+9
b=1+1+1
f=3--(-1)
c=7+9+13+11+12+3--1
g=a+b+c+1+2+3+4+5
j=9+7+g+c+b+a+g+g+g+g+g+g+1+2+3+4+1+1
h=1+1+1+1+333+1+1+1+111+1+1+1+333+1+1+1+1+1.
print(f)
```
* In Python 3, `3--(-1)` is 2, so `print(f)` prints 2 (the other stuff is unnecessary)
* In Lua, `--` again is a comment, so `3--(-1)` is just 3, so `print(f)` prints 3 (other stuff is again unnecessary)
* In brainfuck, there are 57 plusses and 5 minuses setting the first cell on the tape to 52, and the `.` outputs character 52 which is 4.
[Answer]
# [JavaScript](https://babeljs.io/), [CHIP-8](https://johnearnest.github.io/Octo/), and ???
```
[ //aТ/\\ ][ //е"6
console.log(111-111+12)]
//!'!/-²6-²52@++++2345
```
[`12` in JavaScript](https://tio.run/##y0osSyxOLsosKNFNSkxKzdHNy09J/f8/WkFfP/HCIv2YGIVYEPvCViUzruT8vOL8nFS9nPx0DUNDQ10g1jY00ozl0tdXVFfU1z20yQyITY0ctIHAyNjE9P///wA "JavaScript (Babel Node) – Try It Online"), `13` in CHIP-8, and `14` in ??? 
I'm going to go out on a limb and call this one cracked, although I can't quite get it to work I'm sure of the language (which seems to be what the rules ask for.) 
Here is an imperfect explanation of the [cracked post](https://codegolf.stackexchange.com/a/172076/79980)
The code in hexadecimal "is" (I might be slightly off):
```
[ 0x5b, 0x20, 0x2f, 0x2f, 0x61, 0xD0, 0xA2, 0x2f, 0x5c, 
0x5c, 0x20, 0x5d, 0x5b, 0x20, 0x2f, 0x2f, 0xD0, 0xB5, 
0x22, 0x36, 0x0a, 0x63, 0x6f, 0x6e, 0x73, 0x6f, 
0x6c, 0x65, 0x2e, 0x6c, 0x6f, 0x67, 0x28, 0x31, 
0x31, 0x31, 0x2d, 0x31, 0x31, 0x31, 0x2b, 0x31, 
0x32, 0x29, 0x5d, 0x0a, 0x2f, 0x2f, 0x21, 0x27, 
0x21, 0x2f, 0x2d, 0xb2, 0x36, 0x2d, 0xb2, 0x35, 0x32 ]
```
You can go [here](https://johnearnest.github.io/Octo/), click "Binary Tools" and paste this into the byte array box. Click "Decompile". 
The key elements of the code are: instructions to say where the "number" is, the `sprite` command that prints the number, the correct amount of junk here and there, and the following:
```
: label-0
    0x2F
    0x21
    0x27
    0x21
    0x2F
```
To see what this represents you can click "Sprite Editor" and paste these hexadecimals into the box underneath. You'll see the answer:
[![enter image description here](https://i.stack.imgur.com/mYdAC.png)](https://i.stack.imgur.com/mYdAC.png)
I'm pretty sure you can then put anything you like at the end and the CHIP-8 result will not change, hence the new entry.
I would be delighted if someone could get this fully working, rather than the "proof" of the answer I've given here.
[Answer]
# C, Python 2, ???
```
#define print(A) main(){puts("0");}
print(1+bool(1/2))
```
This prints `0` in C, `1` in Python 2, and `2` in ???.
This will be extremely easy to crack for people who know Python, but I wanted a starting-off point for other answers. Subsequent answers should try to obfuscate the third language (I did not do this).
[Answer]
# Python 3, Lua, ???
```
a=1+2+3+3+4+5+6+7+8+9
b=1+1+1
f=3--(-1)
c=7+9+13+11+12+3--1
g=a+b+c+1+2+3+4+5
j=9+7+g+c+b+a+g+g+g+g+g+g+1+2+3+4+1+1
h=1+1+1+1+333+1+1+1+111+1+1+1+333+1+1+1+1+1.
print(f)
```
Prints 2 in Python 3, 3 in Lua and 4 in ???.
Explanation for [cracked post](https://codegolf.stackexchange.com/a/171886/71631):
```
a={1,2}
print(1+#a
--bool(1/2)
)
```
* In Lua, -- is a comment. In Python 2 and 3, -- indicates double negative in arithmetic.
* In Python 2 and 3, # is a comment. In Lua, # is the length operator.
* In Python 2, 1/2 is floor division, so it evaluates to zero. In Python 3 this is not the case. Because both versions of Python evaluate 0 to False, bool(1/2) evaluates to False in Python 2 and True in Python 3. When used in arithmetic, False is cast to 0 and True is cast to 1.
[Answer]
# [Beatnik](https://tio.run/##S0pNLMnLzP7/Py1PIbGsKDVdQ7O6listT18rsaqiqqoKIqiQrVBVWAnmVigUlmanKgABl51dgIGCtnZBaUkxhIwuyC@L5YpxeL9/b7WdVi2yFDGkKpeWfm5iZh7QCQVFmXklihpKhuZKmrX//wMA), [Rust](https://tio.run/##KyotLvn/Py1PIbGsKDVdQ7O6listT18rsaqiqqoKIqiQrVBVWAnmVigUlmanKgABl51dgIGCtnZBaUkxhIwuyC@L5YpxeL9/b7WdVi2yFDGkKpeWfm5iZh7QCQVFmXklihpKhuZKmrX//wMA), ???
```
fn avreg(){}
fn/*azxzzz avreg k zqyzzz ax quke    
>>P0 ++puts++puts[pov]
\@�{>*}++puts++puts++puts++puts++puts++puts++puts++puts%
*/main(){print!("17")}
```
This prints 16 in Beatnik, 17 in Rust, and 18 in ???.
The `�` character on line 4 should be replaced with ASCII character 18 (this was not done in the TIO links since it's not relevant to either of them).
## Explanation ([cracked](https://codegolf.stackexchange.com/a/173943/61384)):
The previous answer's language was Rust: specifically, Rust compiled with [mrustc](https://github.com/thepowersgang/mrustc). mrustc is an experimental compiler, and as it is mostly intended for bootstrapping a valid version of `rustc`, it ignores borrow checking and mutability checking, allowing @NieDzejkob's snippet to compile without errors.
This program will work with the normal Rust compiler, so you don't need to install mrustc to test it.
## Hints
Since this answer has now gone the longest without being cracked, I'll leave a hint, and continue to do so regularly until it is cracked:
* The secret language is two-dimensional and can be found on the Esolang wiki page for two-dimensional languages.
* As I mentioned in the comments, the language is not on TIO.
* The `�` character is a red herring and has very little significance. Most bytes can be substituted in its place and the program will still work.
[Answer]
# ><>, Befunge-96 and ???
```
abcd={} -- a gaffe avoiding tactic in C++
abcd[false]=1+2+3+4+5+6+7+8+9+10+11+12+13+17!
print(abcd[0>1+2+3 and 4+5+6<0-0]//35)
if 0>1 then a.next=';' end
                    >1+6.@
```
This prints [5 in `><>`](https://tio.run/##bYzBCoJAFEX3fsVrZXFRZzS1KCPoM8LFy5nRgZgihwiib5/MdXd7zrnGjkMIfOlU8/5QkhBTz8Zo4ufNKut68tx525F1dAKin3k2fB1120jkKLBGiQo1NthCCkgJmUMWkPUiuj@s88u5EYdZJ3aK5mQvEtFmWVGuImtowuQH7YhTp1@@iXcxaaci@rPpqUqPIXwB), [6 in `Befunge-96`](https://tio.run/##bYxBDoIwEEX3nGJcoZkUWhCQKMbEYxgWA22xiY5GqzExnr0ia//2vfc7Yx88GFGX4uytC4G6XjfvDwgBBANZa4CeF6cdD@Cp964Hx7BHjH7mwdLpbtpGYYY5LrHAEitcYY1KolKoMlQ5qmoWXW@O/Xxq5HbSgVjDlGykkG2a5sUichZGDP5oGChh8/JNvI7BsI7gz8anMtmF8AU) and `7` in ???.
I know the intended solution was Befunge-93, but I couldn't resist.
### Explanation:
Befunge-96 follows the same path as `><>`, but ignores unknown instructions, ending up adding one to the 5 and multiplying it by 9 to get 54, the ascii code for `6`.
[Answer]
# [Klein](https://github.com/Wheatwizard/Klein) (100), [Commentator](https://github.com/cairdcoinheringaahing/Commentator), ???
```
/@++++2345
start:
program:
 db 'function',10
 add program,program
 jp null+$8
 sbc rbp,rbp
 jnz program
 jr program
 add start
 halt
ex:
```
Outputs [14 in Klein (100)](https://tio.run/##RU3bCoMwFHs/X5GHgQ8WVneB0Sd/pbVuc@uO5Vhh7OdrJ4KBkEBC8g79wDkf27rgdL5caUpWkqEo40PsxxC8Q3WfuUvDyJVqNMF6jy1XmxJeETyHUB9uhMl1EBdVYQn4h70lu//PrG@Epw2J@q/JOTdaLw "Klein – Try It Online"), [15 in Commentator](https://tio.run/##RU3LCsMwDLv7K3wY9NDA1j1g5LRfcZLuReIE14Wxn0@zUahASCAh@ZzSyEqapdb9rW84ns4XmJRELRTJD6FkAYPD7j6z11fmzgwHQAoB19ysCvguyHOM/e4KODmP4oppbAF/cWvJ5n8z/zfAJ0WF8WNrXQA "Commentator – Try It Online"), 16 in ???.
I'm seriously bad at obfuscating polyglots.
### Explanation ([Cracked post](https://codegolf.stackexchange.com/a/173033/78410))
```
 %/    <#> 13
        14
 +   15
```
In Commentator, common comment tokens and spaces are the important commands, and any other characters are ignored.
* Space increments the current memory cell.
* `<#` does XOR 1 on the current memory cell.
* `%` is used to reset the current memory cell to zero.
Wait, there are 16 spaces after `%`, what happened?
It's actually a small bug (or feature?) in the interpreter. `/` is treated as the start of a 2-char command, so the space after it is consumed. But `/<space>` is undefined command (thus a no-op), so the space is effectively skipped.
[Answer]
# [Commentator](https://github.com/cairdcoinheringaahing/Commentator), [Beatnik](https://esolangs.org/wiki/Beatnik), ???
```
// k... nak... naKaka pagpAbaGaBag
static answer: Option<&String> = None;
 
fn llanfairpwllgwyngyllgogerychwyrndrobwllllantysiliogogogoch(s: &String){
  answer = Some(s);
}
 
fn pneumonoultramicroscopicsilicovolcanoconiosis(){
  println!("{}", answer.unwrap());
}
 
fn main(){
  let s = String::from("17");
  let t = "Hi! I am a cat. AOOOWRRRWWW! Me need Whiskas! Noow! Mee hungry hast bekommen. Feedme! sudo !!. Sad... six cable hostage wire cable diediediediee #               */";
  llanfairpwllgwyngyllgogerychwyrndrobwllllantysiliogogogoch(&s);
  pneumonoultramicroscopicsilicovolcanoconiosis();
}
```
Outputs [15 in Commentator](https://tio.run/##nZFNa9wwEIbv/hVjF4K3FC89BTZNYHvoB6Fd2D34PCvPymKlGSPJcU3Ib9/IXpPQYysJBubjmdG8SpwjjhjFXy7rNZyrqgLGxTziGaFD3W2P@B2/os5CSjUKkMNAfgO7LhrhLzeH6A3rB7iH38J0l0F2YrAW@YTGd4O1ehhZj8mKJj@qdhg9N16OKTSlxTEYa0TPV7Vl2MDCXD1nsLRL9IM4KsPqLnu5tuiYeicsvY0enVFegpLOqImm5EmsQhYlbCSYUM6sLlGj5bwsnl@KTwu66nnw2JWrd7RDw9cKSxHC1HweaLM5eXFl8fm2SMnXaEzR4ofJ4SegAwSFsYLtbrer9/t9Xdc5/CJgogbq1oQzhjztSYbJTdD2rP0ILYYIRzrPglTwLWU7yiH0jUCeV3DAZhIlmD8Jf7SpTpIYmmAwnhZXY@jtEXyAv8/HdTEP/P@y3IT5y/@49bTSy@UV "Commentator – Try It Online"), [16 in Beatnik](https://tio.run/##nZFNi9wwDIbv@RVKCkumlAw9FWa7C9tDPyjtwMwhZ8XROCa2FGynaVj2t0@dTGjpsbUNAr3SI1lqCCOb/nrd76GvqgoYN/MVe4QB9fDU4Cf8gDoLEaNRgBwm8gc4DtEIv787R29YP8IDfBem@wyyC4O1yBc0fpis1dPMek5WNPlZddPsufXSJGkJi3Mw1oher@rKcICNuXvOYCuX6GdxVIbdffZyKzEwjU5YRhs9OqO8BCWDUQtNyQ@xClmUsJFgQrmyhkSNlvOyeH4p3mzoauTJ41Du/qAdGr5lWIoQluJrQ4fDxYsri7fvihR8U2NSi88mhy@ADhAUxgqejsdjfTqd6rrO4RsBE7VQdyb0GPI0J5kWN0E3svYzdBgiNNSLc8QVfEzRjnIIYyuQ5xWcsV2WEszPhG9sypO0DE0wGU@bqzX0@xG8gr/P632xNvz/a7kL65f/cepppNfrLw), and 17 in the hopefully one language you are supposed to find.
Okay, it's clue time:
* The name of the language refers to a compound of two elements, both of which make up your body, but with wildly varying percentages (which way depending on whether you're a robot).
* The language itself is on TIO, but the implementation isn't.
* Oh come on.
[Answer]
# Brainfuck, ><>, and ???
```
abcd={} -- a gaffe avoiding tactic in C++
abcd[false]=1+2+3+4+5+6+7+8+9+10+11+12+13+14
print(abcd[0>1+2+3 and 4+5+6<0-0]//35)
if 0>1 then a.next=';' end
                    >1+9*,@
```
Prints `4` in Brainfuck, `5` in ><>, and `6` in ???
* In brainfuck, nothing changes.
* In ><>, `v` redirects the flow of the program downwards. The `n` is **n**umeric output. `;` ends execution.
[Answer]
# Klein (101), Z80Golf, ???
```
!!8@e6v+4>9 \
Almost everything you can find on the internet is true
~Albert Einstein
 ~HUMAN IMAGE MACROS
```
Prints [`8` in Klein (101)](https://tio.run/##Dcw9CsJAEAbQfk/xpbYxIKKNOEhQi1VQ7Gz8Gc3gOgu7k0CaXH31HeB9AouWUlWLNc/7yWy1xNVR@MZs4J7TYK3oG0Ps8LgpXqJPRIW1DFHjpGyQDEsdu5HCnZOhEc32bx3G3cXTAXtP2waeNqfjuZRST@sf), [`9` in Z80Golf](https://tio.run/##XdC9asMwFAXgvU9xMheCfq6u7AylpoS2Q1po6dYlieXEkMrgKIF0yKu7kuUs1SAkIX33XP0WYtcdmmEQ01hASSWhCxJgoxmW1QaatIMulYDZijVI8haYzYpHx@d7eijxPa8Od1mQ0eCaG1htCUqwiUaalC1hiQtwyQ5so4af7hjgzq6/hH3rd5gMFQ1bJsPEW6xZgl1aMZdxxaPb5DNcuhO2a4@m9TU6fzN0MsZyo5Fqxm3KkaqbnC0m0skIe4fWB9d7F9AebwaNhlUxR3wp1tbl3lnlhpJBJuMI/cnNr9Vh4/qAZesnwyQjfQWbMXz8PyUSVBgDqkmCUhtUUg0cg2v9HNeXr1X1htfVZHA0SJIFpV7yI20UqDEa/0f1vMSqevp4/xyGPw), and [`10` in ???](https://youtu.be/KbgiQHUnW3I).
[Answer]
# [Z80Golf](https://github.com/lynn/z80golf), [Somme](https://github.com/ConorOBrien-Foxx/Somme), ???
```
!!8@e6v+4>9 \
1((111+111)/111)
00
~tz
```
This prints [9 in Z80Golf](https://tio.run/##fY27CsJAFER7v2LSRQLxPjb7sBA/xGYjGxvBRlKk8NfXGxIsHZhhmjmzRHq8nlOttOsMYWFodAQ/qEfwMkKdFmgSwnCnDGWJQNPEa/Fz5y4Jt57bw0bglRHVGGwh468lmbZm8wTKSkDLzJ35eFqjp50hxlCyp1CCQ8j4J@o/76XWLw), [10 in Somme](https://tio.run/##K87PzU39/19R0cIh1axM28TOUiGGy1BDw9DQUBuINfVBBJeBAVddSdX//wA) and 11 in [???](https://esolangs.org/wiki/Unary?).
Credit to Bubbler for [cracking the previous post](https://chat.stackexchange.com/transcript/message/46692241#46692241) as Somme, which takes the column sum as the instructions. The first three columns evaluate to 
```
A.;
```
Which pushes 10, prints it and exits.
[Answer]
# [Somme](https://github.com/ConorOBrien-Foxx/Somme), [Trigger](http://yiap.nfshost.com/esoteric/trigger/trigger.html) and ???
```
[,,E,D,,$,H,_,K,,$,,_,F,L]=!
[]+[]+!![]+[][111]
_=[111][F+L+E+E];[,J,,A,I,,B,C,S]=
[]+_;$=A+B+C+D+I+H+J+A+I+B+H
R=_[$](H+K+I+J+H+C+S+H+B+B+I)();G=($[$]+[])[14]
R[A+B+C+D+B+E+K][E+B+G](12);`
iP<`
```
This prints [`10` in Somme](https://tio.run/##NY27CsMwDEV3/0UgQ4zu4tLN9RDn/RhKMgqRLB06hA79f1wlUCR0Lnrd7@c4Xikx0KAGcvTYMJ1C2WKWkBkW0syyi@ycE7OFi9zSTA014hkjUGIAIiqsEs6rzeehpEgV1TRQTyOVyki9WcLGuRQ9TdoYdVTRqjVqDLawvgtFrgvqZ9ndxSz8/xPVbxJuVHRSuJv1u3k/H3tKPw "Somme – Try It Online"), [`11` in Trigger](https://tio.run/##NY27CoRADEX7@QvBQsltZtludgrH96NYtAxBm0VsZf9/NgpLQs4lr/s9j33/nDEyUKMCUnRYMV5C2WASnxgW0kySm2ytFbP6m9zQRDXV4hgDUKAHAkos4q@r1aW@oEAlVdRTRwMVykCdmf3KqWQdjdoYdFTSojVo9HmWu9ZnqS6oX872KWbm/5@gfqNwraKVzD5yt5nj/dpi/AE "Trigger – Try It Online"), and `12` in ???.
Since the last two languages are easy to polyglot, I decided to mix *that language* in.
### Explanation ([cracked post](https://codegolf.stackexchange.com/a/172030/78410))
Trigger sees the whole code as a series of tokens (tokenization is greedy):
* Single byte (denote `A`)
* Two same bytes followed by a different byte (denote `AAB`)
* Three same bytes (denoted `AAA`)
* Four same bytes (denoted `AAAA`)
In the source code
```
!!8@e6v+4>9 \
1((111+111)/111)
00
~tz
```
the significant tokens are `((1` `11+` `111` `111`, where the first two does nothing and the last two prints 1 each - thus 11.
[Answer]
# [CHIP-8](https://johnearnest.github.io/Octo/), [Klein (100)](https://github.com/Wheatwizard/Klein), ???
```
[ //aТ/\\ ][ //е"6
console.log(111-111+12)]
//!'!/-²6-²52@++++2345
 %/    <#> 13
       say 14
 + not not 15
```
Outputs 13 in CHIP-8 (I assume), [14 in Klein](https://tio.run/##y85Jzcz7/z9aQV8/8cIi/ZgYhVgQ@8JWJTOu5Py84vycVL2c/HQNQ0NDXSDWNjTSjOXS11dUV9TXPbTJDIhNjRy0gcDI2MSUS0FVXwEIbJTtFAyNuRQgoDixUsHQhEtBWyEvvwSMDU3///9vaGAAAA), and 15 in ???.
*Another* Klein topology, tsk tsk. I've preserved the code before the `@`, since I don't know what will affect CHIP-8.
### Clues
I'm kinda overdue for these, sorry. I'll try and add one a day.
* Removing the first half (first three lines) of the program still works.
* This is not a 2D language
* The language is on TIO
* The `not`s and the `say` can be removed without affecting the program
For reference, the program without that stuff looks like this:
```
 %/    <#> 13
        14
 +   15
```
[Try it online!](https://tio.run/##y85Jzcz7/19BVV8BCGyU7RQMjbkUoMDQhEtBG0Sb/v//HwA "Klein – Try It Online")
[Answer]
# [Rust](https://www.rust-lang.org/), [BrainSpace](https://esolangs.org/wiki/BrainSpace_1.0), ???
```
fn v(){}
/*{>*}+++++++++++++++++++++++++[[[%]]]*\
\mop+p+p+pox
*/fn main(){print!("17")}             //print!(19)$f($f(-x++this::id()++x)++x@);"v2"
  //):/
//////////////////////////////////////[]<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
```
This prints [17 in Rust](https://tio.run/##KyotLvn/Py1PoUxDs7qWS1@r2k6rVhsXiI6OVo2NjdWK4YrJzS/QBsP8Ci4tfaABuYmZeUAzCooy80oUNZQMzZU0axWQgb4@VM7QUlMlTQOIdCu0tUsyMoutrDJTNDS1tStA2EHTWqnMSIkLpEHTSp9LnygQHWtDAvj/HwA), [18 in BrainSpace](https://tio.run/##SypKzMwrLkhMTv3/Py1PoUxDs7qWS1@r2k6rVhsXiI6OVo2NjdWK4YrJzS/QBsP8Ci4tfaABuUDjgGYUFGXmlShqKBmaK2nWKiADfX2onKGlpkqaBhDpVmhrl2RkFltZZaZoaGprV4Cwg6a1UpmREhdIg6aVPpc@USA61oYE8P8/AA), and 19 in ???.
## [Crack](https://codegolf.stackexchange.com/a/179406/85334) explanation
Remembered this existed looking through old messages, figured I could scrape Esolangs for every implemented 2D language where the article body has an `o` surrounded by non-letters, and fortunately couldn't be bothered to filter out languages that are on TIO because it turns out [BrainSpace got added to TIO about five months after it was confirmed not on TIO](https://github.com/TryItOnline/tryitonline/commits/master/wrappers/brainspace). (It's also fortunate that it was alphabetically the second candidate out of 48.)
For posterity (as comments can be ephemeral), the full sequence of hints given was:
* The language is not on TIO. (as of 2019/4/3)
* The language is 2D and listed as such on Esolangs.
* The ASCII character 18 is a red herring.
* `s` doesn't square, `[` doesn't halve, and `o` doesn't end the program.
* `o` performs output.
BrainSpace is some kind of weird half-Brainfuck-half-fungeoid where `{}` move the tape head, `*` is a conditional jump, `%` is an omnidirectional reflect, all three of `pP+` are equivalent increment commands, and all three of `oO0` are equivalent output commands. The instruction pointer starts in the top left moving right, so `fn avreg(){}` sends the pointer down in column 5, `{>*}` sends it careening into a bunch of increments that it gets bounced through again on the way back then passes it right along to the left, and `P0 ++puts++puts[pov]` increments 48 to 49, prints that, slaps another 7 on, prints, then terminates the program by leaving the edge--BrainSpace's field is not toroidal.
---
This should be considerably easier, but you might take some wrong turns.
]