[Question]
  [
*This is the cops' thread. The robbers' thread is [here](https://codegolf.stackexchange.com/q/135365/58826).*
Your challenge is to make a program that runs forever without halting1, unless it gets a particular input or inputs2. If it receives that input, it must terminate in a finite amount of time3. This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the shortest answer that has not been cracked by a robber within one week of posting wins. After the week has passed, please mark your answer as safe and show the halting input (in a `> ! spoiler quote`). If a robber cracks your submission, please mark it as cracked and show the halting input (in a `> ! spoiler quote`).
Submissions are preferred be runnable & crackable on [TIO](https://tio.run). Submissions not runnable or crackable on TIO are allowed, but please include instructions to download / run them.
Please make your input deterministic, and uniform across all runs. See [this meta post](https://codegolf.meta.stackexchange.com/q/13421/58826) for details.
**Please, don't "implement RSA" or anything mean to the robbers. Use obscure languages and features, not boring encryption and hashing. I can't enforce this with rules, but you can expect torrential downvotes if all you do is `sha(input) === "abcd1234"`.**
---
1Assuming that the computer doesn't get shut down, break, get engulfed by the sun, overheat in the universe's heat death, or hit the TIO timeout of 60s.
2The program must halt on **at least** one input. As long as it loops forever on one input and halts on another, it works.
3This must be < 60 seconds, so that the code can be tested on TIO.
---
# Looking for uncracked submissions?
```
fetch("https://api.stackexchange.com/2.2/questions/135363/answers?order=desc&sort=activity&site=codegolf&filter=!.Fjs-H6J36vlFcdkRGfButLhYEngU&key=kAc8QIHB*IqJDUFcjEF1KA((&pagesize=100").then(x=>x.json()).then(data=>{var res = data.items.filter(i=>!i.body_markdown.toLowerCase().includes("cracked")).map(x=>{const matched = /^ ?##? ?(?:(?:(?:\[|<a href ?= ?".*?">)([^\]]+)(?:\]|<\/a>)(?:[\(\[][a-z0-9/:\.]+[\]\)])?)|([^, ]+)).*[^\d](\d+) ?\[?(?:(?:byte|block|codel)s?)(?:\](?:\(.+\))?)? ?(?:\(?(?!no[nt][ -]competing)\)?)?/gim.exec(x.body_markdown);if(!matched){return;}return {link: x.link, lang: matched[1] || matched[2], owner: x.owner}}).filter(Boolean).forEach(ans=>{var tr = document.createElement("tr");var add = (lang, link)=>{var td = document.createElement("td");var a = document.createElement("a");a.innerHTML = lang;a.href = link;td.appendChild(a);tr.appendChild(td);};add(ans.lang, ans.link);add(ans.owner.display_name, ans.owner.link);document.querySelector("tbody").appendChild(tr);});});
```
```
<html><body><h1>Uncracked Submissions</h1><table><thead><tr><th>Language</th><th>Author</th></tr></thead><tbody></tbody></table></body></html>
```
  
[Answer]
# Malbolge, 128 bytes, [cracked by KBRON111](https://codegolf.stackexchange.com/a/136004/3808)
```
(=&r:#o=~l4jz7g5vttbrpp^nllZjhhVfddRb`O;:('JYX#VV~jS{Ql>jMKK9IGcFaD_X]\[ZYXWVsN6L4J\[kYEhVBeScba%_M]]~IYG3Eyx5432+rpp-n+l)j'h%B0
```
Have fun!
(Yes, I learned Malbolge just for this. Yes, it took an absurdly long time to finally get working. And yes, it was totally worth it.)
Wrapped, so you can see it in its full, er, "glory":
```
(=&r:#o=~l4jz7g5vttbrpp^nllZjhhV
fddRb`O;:('JYX#VV~jS{Ql>jMKK9IGc
FaD_X]\[ZYXWVsN6L4J\[kYEhVBeScba
%_M]]~IYG3Eyx5432+rpp-n+l)j'h%B0
```
I used [this interpreter](http://www.lscheffer.com/malbolge_interp.html) to test it; I'm not sure if it matters, but I figured I'd specify just in case.
[Answer]
# JavaScript (ES6), 17 bytes, [Cracked](https://codegolf.stackexchange.com/a/135375/58826)
```
x=>{for(;x==x;);}
```
On TIO, since I dunno how to do Node.js readline on TIO, just stick the input in the function call. This is obvious to anyone who knows it, and not to anyone who doesn't.
[Try it online!](https://tio.run/##y0osSyxOLsosKNHNy09J/Z9m@7/C1q46Lb9Iw7rC1rbCWtO69n@ahuZ/AA "JavaScript (Node.js) – Try It Online")
  
Answer: 
> 
>  The answer is `NaN`, since in JavaScript, `NaN != NaN`.
> 
> 
> 
[Answer]
# JS (ES6), 67 bytes ([Cracked](https://codegolf.stackexchange.com/a/135394/65836))
```
(x,y)=>{while(x!==y||Object.is(x, y)||!isFinite(x)||!isFinite(y));}
```
I *think* i didn't mess up, it might have an easy solution that I didn't see.
I appreciate any feedback, this is one of my first posts
> 
>  `(+0, -0)` Yep, js has a negative 0
> 
> 
> 
[Answer]
# Python 3.4, (40 bytes) [Cracked](https://codegolf.stackexchange.com/a/135503/64047)
```
def f(x):
  while(x==x or not x==x):pass
```
[Answer]
# Javascript (NOT node.js)
```
x=>{while(x+"h");}
```
The desired submission doesn't use throw.
Hint for desired crack:
> 
>  The desired submission doesn't overwrite `.toString()`, or use `Set()` either. 
> 
> 
> 
Desired crack:
> 
>  `Object.create(null)`
> 
> 
> 
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 75 bytes [Cracked](https://codegolf.stackexchange.com/a/135526/9498)
```
#include<stdio.h>
int main(){char c[9];while(1){scanf("%8s",c);printf(c);}}
```
[Try it online!](https://tio.run/##S9ZNT07@/185My85pzQl1aa4JCUzXy/Djiszr0QhNzEzT0OzOjkjsUghOdoy1ro8IzMnVcNQs7o4OTEvTUNJ1aJYSSdZ07qgCKg8TQPIqq39/x8A "C (gcc) – Try It Online")
I've never posted in a cops-n-robbers before. Hopefully this isn't *too* obvious.
Solution:
> 
>  An input of "%s" makes this segfault. There are several other ones that can be used; all of them are `printf` specifiers like "%n"
>    
> 
>  This is the classic `printf` vulnerability. Simply put, the format string comes straight from user input, so any `printf` specifiers get passed through, unsafely.
> 
> 
> 
[Answer]
# JavaScript (in Browser), 79 bytes [Cracked](https://codegolf.stackexchange.com/a/135709/44718)
```
x=>{try{for(;x||x!=null||x!=void 0||x===null||x===void 0;);}catch(e){for(;;);}}
```
You should run it in a recent browser (like latest Firefox ESR, latest Firefox, latest Chromium). Running on old browsers (like Netscape 2, IE 4) do not count. 
Note: Halted by browser due to time out do not count a halt here.
Always be careful not crash your browser when testing this codes, and happy robbing ^\_^
> 
>  document.all
> 
> 
> 
[Answer]
# [PHP](https://php.net/) (cracked by Vicente Gallur Valero), 65 bytes
```
<?php
parse_str($argv[1],$_);
while(!$_['(-0_0)> deal with it']);
```
[Try it online!](https://tio.run/##K8go@P/fxr4go4CrILGoODW@uKRIQyWxKL0s2jBWRyVe05qrPCMzJ1VDUSU@Wl1D1yDeQNNOISU1MUehPLMkQyGzRD1W0/r///9p@fm2SYlFAA "PHP – Try It Online")
Harder than it may look. Edited to be possible on TIO, at the cost of a bunch of bytes. Takes input via `$argv[1]`.
[Answer]
# Bash 4.2, 14 bytes ([cracked](https://codegolf.stackexchange.com/a/135797/12012))
Let's try this again.
```
let ${1,,}
yes
```
This doesn't work on TIO, which uses Bash 4.3. Input is via command-line arguments.
On Linux and with gcc installed, Bash 4.2.53 can be downloaded and built as follows.
```
curl -sSL https://ftp.gnu.org/gnu/bash/bash-4.2.53.tar.gz | tar xz
cd bash-4.2.53
./configure
make -j
```
[Answer]
# [Husk](https://github.com/barbuz/Husk), 5 bytes [Cracked](https://codegolf.stackexchange.com/a/135846/62393)
```
↑ε∞←ø
```
[Try it online!](https://tio.run/##ARkA5v9odXNr///ihpHOteKInuKGkMO4////MTIz "Husk – Try It Online")
A bit of explanation, since this language is still pretty new:
`←ø` gets the first element of an empty list: this returns a value which can assume any type, be it a concrete type or a function, which will then be applied to the input. `∞` creates an infinite list composed by copies of the previous result (which in most cases will mean a list of infinite zeroes). `↑ε` takes elements from this list as long as they are "small" i.e. their absolute value is ≤1; on an infinite list of zeroes this will never stop.
[Answer]
# [Braingolf](https://github.com/gunnerwolf/braingolf), 4 bytes ([Cracked](https://codegolf.stackexchange.com/a/135368/58826))
```
[1+]
```
[Try it online!](https://tio.run/##SypKzMxLz89J@/8/2lA79v9/AA "Braingolf – Try It Online")
Suuuper easy, but ~~let's see how long it takes~~
Answer:
> 
>  `-1`, or any number less than `0`.
> 
> 
> 
[Answer]
# [Ruby](https://www.ruby-lang.org/), 31 bytes ([cracked by Eric Duminil](https://codegolf.stackexchange.com/a/135516/6828))
```
0until(3.send(gets)==5rescue p)
```
[Try it online!](https://tio.run/##KypNqvz/36A0ryQzR8NYrzg1L0UjPbWkWNPW1rQotTi5NFWhQPP/fwA "Ruby – Try It Online")
Note that this needs to be run in an environment where there's no trailing newline in the result of `gets`, or else it's impossible to make it halt (I think) since anything ending in a newline will error and hit the rescue.
[Answer]
# Bash, 25 bytes ([Cracked](https://codegolf.stackexchange.com/a/135641/21194))
```
export "$1"=help
/bin/yes
```
Inspired by Dennis'. [Try it online.](https://tio.run/##S0oszvj/P7WiIL@oREFJxVDJNiM1p4BLPykzT78ytfj///8A)
[Answer]
# [Retina](https://github.com/m-ender/retina), 78 bytes ([Cracked](https://codegolf.stackexchange.com/questions/135365/will-it-halt-robbers/135384#135384)) ([Cracked with Intended Solution](https://codegolf.stackexchange.com/questions/135365/will-it-halt-robbers/135383#135383))
```
^
1
+`^1(1+)
$1¶$&
s`(?<=^|¶)(1+)(?=¶)(?!.*¶\1+$)
¶(?!1+$)
^(1+)¶\1$
+`1
11
```
Was pretty fun to write, hope it's fun to crack
[Try it online!](https://tio.run/##K0otycxL/P8/jsuQSzshzlDDUFuTS8Xw0DYVNa7iBA17G9u4mkPbNEHCGva2IJa9op7WoW0xhtoqmlxch7YB@RBmHEgNSEKFC2iSIZeh4f//AA "Retina – Try It Online")
Cracked with an unintended solution and the intended solution within a minute of each other. One posted first, one commented first.
Intended solution:
> 
>  11111 
>  or the unary representation of n-1 where n is any perfect number
> 
> 
> 
[Answer]
# Node.js, 23 bytes ([Cracked](https://codegolf.stackexchange.com/a/135560/71612))
```
var crackme =
i=>{while({[i]:NaN}){}}
```
*Grant Davis* solution
> 
>  `{__proto__:null}`
> 
> 
> 
My solution
> 
>  `{"toString":process.exit}`
> 
> 
> 
[Answer]
# Java 8, 99 bytes, [Cracked](https://codegolf.stackexchange.com/questions/135365/will-it-halt-robbers/135673#135673)
```
s->{try{Integer i=Integer.parseInt(s),c=i+32767;i+=32767;for(;i!=c;);}catch(Throwable t){for(;;);}}
```
This is a lambda of the type `Consumer<String>`.
Ungolfed:
```
s -> {
    try {
        Integer i = Integer.parseInt(s), c = i + Short.MAX_VALUE;
        i += Short.MAX_VALUE;
        while (i != c) ;
    } catch (Throwable t) {
        while (true) ;
    }
}
```
[Try it online!](https://tio.run/##PY4/b8IwEMV3f4rrZotiVa1UBmOWTgxM7YYYjDHh0sSO7AtVFeWzp06T8Jb78zvde6W5m3VonC8v3wPWTYgEZd7JlrCS19ZbwuDlR/CprV1UjDXtuUILtjIpwcGgh44xyJpBIkO53ANeoM6Yf1JEXxxPYGKRRL6GWcvT7XSxg9EO9IMvGtJ611H87faeXOEioJ472ZiYXB54Es9W4@rtdfO@UbjSU3MNkSt80lYJ1VtD9sa/bjH8mHPlgET3z0fWD4uZetiPaaSx1jXEx@jHl5OYaM8Y64c/) (note that the test program will crash on empty input, but the lambda itself would not!) (also, use 'arguments' not 'input' on TIO, as the test program uses arguments, not STDIN)
Intended Answer:
> 
>  -32767;
>  This works because Java keeps has two integer types, `int` and `Integer`. `Integer` is an object that wraps `int`. Also, Java keeps an cache of `Integer`s that box `-127` through `127`. The `!=` operator checks for identity, so through some un-boxing and auto-boxing any number `x` where `x + 32767` is in `[-127, 127]` will end up being the same `Integer` object from the cache, and thus `i != c` will be false.
> 
> 
> 
[Answer]
# Bash 4.2, 10 bytes ([Cracked](https://codegolf.stackexchange.com/a/135625/31625))
```
let $1
yes
```
This doesn't work on TIO, which uses Bash 4.3. Input is via command-line arguments.
On Linux and with gcc installed, Bash 4.2.53 can be downloaded and built as follows.
```
curl -sSL https://ftp.gnu.org/gnu/bash/bash-4.2.53.tar.gz | tar xz
cd bash-4.2.53
./configure
make -j
```
[Answer]
# C, 140 bytes ([Cracked](https://codegolf.stackexchange.com/questions/135365/will-it-halt-robbers/135862#135862))
```
n,i;f(){float x,y,z;for(scanf("%d %d",&n,&z,x=y=0);~((int)x-(int)(1/sqrt(y*2)));x*=(1.5-y*x*x))y=(x=z)/2,i=n-((*(int*)&x)/2),x=*(float*)&i;}
```
Hopefully there aren't too many not-even-close-to-the-intended-inputs that make it halt, but let's see.
[Try it online!](https://tio.run/##HY5Bi8IwEIXv/opQsMyERFdhTyEHQcHDHjzsHwix0UCbdtMKScX96WZnO5d5fI@Z96y8WVtKEF45wKdrezOxJLKYlesjjNYEB9X6ytbXStRB1LNIOusPVL8APkyY5LJgtx1/4gSZ7xFRJa5ht/mUmSeeELOGpGfc7oXXQQLw/xuOdSKE9JDDEkzEq1chj3XGB8DVc8VoqJlaxBDJoz7nw9f36VgRfZXLY2K5f0Tmw0Dy3sRGsKFtzNhs3ta15jYW2XZ/)
[Answer]
## Java: 1760 ([Cracked](https://codegolf.stackexchange.com/a/135401/60951))
I feel it's too mean to golf this one, so I just obfuscated the variable names, and made it 'messy'. As a matter of fact it's so mean, that I'm going to post hints over time, just so I may see it cracked.
Hint 1: this has theoretically infinite valid inputs, but there is one that is the most 'Correct'
```
public class Main {
	public static void main(String[] a) {
		try {
			while (a.length < 2) {
				int i = 0;
			}
			boolean invalid = 1 < 0;
			char l = '_';
			char h = '-';
			char[] DATATWO = a[0].toCharArray();
			char[] DATATOW = a[1].toCharArray();
			int length = DATATOW.length;
			if (DATATWO.length != length) {
				invalid = 1 > 0;
			}
			int transmissionStartIndex = 0;
			for (int i = 0; i < length; i++) {
				if (DATATWO[i] == l && DATATOW[i] == l) {
					transmissionStartIndex = i;
					break;
				}
			}
			int DATAONE = 0, reg = 0;
			boolean read = 1 < 0, full = 0 < 1;
			int bytes_read = 0;
			for (int i = transmissionStartIndex; i < length; i++) {
				if (DATATOW[i] == l && DATATOW[i + 1] == h) {
					bytes_read++;
					if (bytes_read == 8) {
						read = DATATWO[i] == h;
					} else if (bytes_read == 9) {
						invalid = (DATATWO[i] == h || invalid);
						System.out.println(invalid);
					} else if (bytes_read == 18) {
						System.out.println(invalid);
						invalid = (DATATWO[i] == h || invalid);
						if (invalid) {
							System.out.println("i36 " + DATATWO[i] + " " + h);
						}
						full = 1 > 0;
					} else if (bytes_read < 8) {
						DATAONE += (DATATWO[i] == h ? 1 : 0) << (7 - bytes_read);
					} else if (bytes_read < 18) {
						reg += (DATATWO[i] == h ? 1 : 0) << (8 - (bytes_read - 9));
					} else if (bytes_read > 18) {
						invalid = 1 > 0;
					}
					System.out.println(a[0]);
					System.out.println(new String(new char[i]).replace("\0", " ") + "|");
					System.out.println(a[1]);
				}
			}
			while (!(Integer.toHexString(DATAONE).equals("0x2b") && (read)
					&& Integer.toHexString(reg).equals("0xa6"))) {
				System.out.println(System.currentTimeMillis());
				try {
					Thread.sleep(1);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		} catch (Exception e) {
			while (true) {
			}
		}
	}
}
```
[Try it online!](https://tio.run/##lVVRT9swEH5Of8WRB0gUGjVMYmy0TGhDGg@MByrxwKrKTU1jcJPMcUqr0d/enRM7SWmgmqLW9vn8fd/dOZcnsiDdJKXx0/R5s@mk@YSzEEJOsgxuCIvhb6djaWsmicRhkbApzHHPuZOCxbOHERAX/SxLilUxWi8R4xQc4nMaz2QEfTgpPSyLxRIYDKB3rpZr9TdJEk5JDCxeEI7YAwjwROkQRkQAR9PR@Kg2RMrQrQ0o4cfl8HJ4f4sb5KE38mXyHe2XQpCV4@743d4XfkGbnxKoZQ@Mt46j3H8ER5OZ8A4G@kQdZB3JRTNUBS4FibM5yzKWxHeSCHkdT@mySsljIsCps4RDX6Pj3PMqilrGAxvBACXA4aERbEzG23qXlJ2XDhNByXM5X2/JVYi3v66UmGMQdFYJNWXDg1XNjuEx56pcPVwFVT4nK0mzsXZsCbNd3f7Y60C3YgcPgsJcFcSqFXjeeae0KZimsgGcVf6WFrud4kgnaw2UZxR2Ab7UAPUdeFOnCF5fzV13NaB1t8oknftJLv0UXyrJY@eNy7ucQUP1fpj/1KXojK1iaaOx2adTsDHzDVAPDcoUVXBrPepbUr8d78XXb9bEXEWvRfs3BPsKPRf6fXA@Q7dx59w9DMFW2Wf74c8QvgnRxbp/THKxRdLWHqrctORWdTSD37Id0xcoW3ExLRodG7m@oCknIXXs3z37WJXCVRV5tT@AUj3R3eoCjXZ@4FzHks6owK75ky41pS6K69M/OeGZY/eWJxOkwhfSKbJfkuGy7TTmu3mSnNqu6xYfnXaB2hTmQtBYDtmc3jDOWeaYAlTfIMsaRorfzzilqROYsCAkMoygiEWIPJV0erUMaSqx9wCtikRLSuxG4fNQqDTu5KWC2j2vMyZFbizqmDq17qw7m81mPPa7vvmZp1yP9Rx9uvuefw "Java (OpenJDK 8) – Try It Online")
[Answer]
# [Braingolf](https://github.com/gunnerwolf/braingolf), 18 bytes [Cracked](https://codegolf.stackexchange.com/a/135419/44998)
```
1+[#£-0!e>:$_1>|]
```
[Try it online!](https://tio.run/##SypKzMxLz89J@//fUDta@dBiXQPFVDsrlXhDu5rY//8B "Braingolf – Try It Online")
Liiiitle bit harder than the last one, I'll start writing a *real* one after this
> 
>  The answer is 163
> 
> 
> 
[Answer]
## JavaScript (ES7), 41 bytes ([Hacked & Cracked](https://codegolf.stackexchange.com/a/135432/58563))
*Edit: fixed to prevent it from crashing when given no input at all (thanks @totallyhuman for noticing)*
---
Several solutions probably exist, but the expected one is relatively simple.
```
(x=0)=>{for(;~x/x.length**3!=-2962963;);}
```
Intended solution:
> 
>  "8e7" (a number in scientific notation passed as a string)  
> 
>  Because: ~"8e7"/"8e7".length\*\*3 = -80000001/3\*\*3 = -80000001/27 = -2962963
> 
> 
> 
[Answer]
# Bash + Utils (Cracked by Dennis), 74 bytes
I hope you enjoy tar, because it's the only utility you can use.
```
cp /bin/tar .
env -i PATH=$PWD I=$? /bin/bash -r -c "$1"
while :;do :;done
```
[Try it online!](https://tio.run/##S0oszvj/P7lAQT8pM0@/JLFIQY8rNa9MQTdTIcAxxMNWJSDcRcHTVsUeoiAJqFxBt0hBN1lBScVQias8IzMnVcHKOiUfTOSl/v//PzU5I19BPTK/VKE8MydHIS@/RCG1ODmxIFVRHQA "Bash – Try It Online")
### Intended crack
> 
> `tar -cf --checkpoint=1 --checkpoint-action=exec="/bin/kill $I" .`
> 
> 
> 
[Answer]
# Mathematica, ~~36~~ 26 bytes ([cracked](https://codegolf.stackexchange.com/a/135649/60043))
```
#0[#;$IterationLimit=∞]&
```
A very short loop `#0[#;∞]` that will just keep running itself over and over until it crashes your kernel... (The `$IterationLimit` is just to make sure you get stuck forever for most inputs).
[Try it on Wolfram Sandbox!](https://sandbox.open.wolframcloud.com/) - if you are stuck in an infinite loop, you can wait until you time out, or you can press the square "abort evaluation" icon to the left of the notebook title `(unnamed)`.
**NOTE**: this function changes your `$IterationLimit` settings.
[Answer]
# JavaScript (Node.js), 18 bytes ([Cracked](https://codegolf.stackexchange.com/a/135461/65836))
```
x=>{while(x+"h");}
```
[Try it online!](https://tio.run/##y0osSyxOLsosKNHNy09J/Z9m@7/C1q66PCMzJ1WjQlspQ0nTuvZ/moaB5n8A "JavaScript (Node.js) – Try It Online")
Answer:
> 
>  `new Buffer(268435440)` throws an error when `.toString`ed.
> 
> 
> 
[Answer]
# C#, 118 bytes ([Cracked](https://codegolf.stackexchange.com/a/135755/38550))
```
using System;_=>{while(1>0){try{if(Nullable.GetUnderlyingType(Type.GetType(Console.ReadLine()))!=null)break;}catch{}}}
```
I don't expect this to last too long but it is more awkward than it appears to be.
> 
> Basically any Nullable classes full name works but it is awkward to find out as it looks like the below :  
> 
> `System.Nullable`1[[System.Int32, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]]`  
> 
> An easier way to find this string out is to do `typeof(int?).FullName`.
> 
> 
> 
[Answer]
# JavaScript (ES7), 73 bytes ([Cracked](https://codegolf.stackexchange.com/questions/135365/will-it-halt-robbers/136014#136014)!)
```
q=>{r=(n,i=0)=>i>1e3?n:r(n*16807%(2**31-1),i+1);while(r(q)!=627804986){}}
```
Not wanted solutions: brute force. Desired crack involves math.
Note that there are many solutions (4194304) because of modulo.
[Answer]
# [brainfuck](https://github.com/TryItOnline/tio-transpilers), 170 bytes [cracked!](https://codegolf.stackexchange.com/questions/135365/will-it-halt-robbers/136642#136642)
```
>>,>,>,>,>,[-----------<-<+<--<--->>>>]<++<<+<++[----->+<]>[----------------->+++++++<]>[----->>+<<]>>[-<->]<[--->++++++<]>[--->+<]+>-[-----------------<+>]<[-->-<]>+[+-]
```
[Try it online!](https://tio.run/##ZYxLCoAwEEMPFHODkIuULlQQRHAheP46pfUDJoshmUemY1z35Zy3UuzhduIrUVA9pENZgKIBGmQo@8uz103P0wFGiCTGSHqZjtQhmP8pofFmkEhgLuUC "brainfuck – Try It Online")
[Answer]
# Swift 3, 14 bytes ([Cracked](https://codegolf.stackexchange.com/a/136754/61563))
```
while !false{}
```
To solve this, put your code before or after this statement.
* Your solution must:
	+ keep this statement intact, without modifying its code
	+ actually let this statement run
		- Simply commenting it out, calling `fatalError()`, etc. before it doesn't count.
	+ modify the behavior of this statement to prevent it from looping forever
* The solution does not involve crashing the program.
[Answer]
# [cQuents](https://github.com/stestoltz/cQuents), 2 bytes ([Cracked 1](https://codegolf.stackexchange.com/a/135391/41805)) ([Cracked 2](https://codegolf.stackexchange.com/a/135395/30164))
```
:A
```
Note that this will quickly hit the 128 KiB output limit on TIO, causing it to stop, but when run locally it will loop forever, except on the input that breaks it. Finding that input should be fairly easy. Until you do, `:A` will keep sticking its triangular tongue out at you.
Note also that this *should* be just `A` but I broke implicit modes last night. On older interpreter versions `A` would work fine.
Cracks:
> 
>  Empty input/newline on input is a valid crack. However, barring that, by passing multiple (space separated) inputs to the program, you'll terminate it (if you give 2) or error out (if you give 3 or more).
> 
> 
> 
[Try it online!](https://tio.run/##Sy4sTc0rKf7/38rx//@S1OISAA "cQuents – Try It Online")
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 28 bytes [Cracked](https://codegolf.stackexchange.com/a/135519/31957)
```
x=>{while(!x||x.__proto__);}
```
[Try it online!](https://tio.run/##y0osSyxOLsosKNHNy09J/Z9m@7/C1q66PCMzJ1VDsaKmpkIvPr6gKL8kPz5e07r2f5pGXmlOjuZ/AA "JavaScript (Node.js) – Try It Online")
Know of anything truthy that dosen't have the `__proto__` property?
]