[Question]
  [
> 
> Edit 2020-11-06: This challenge has been edited with new provisions to encourage participation. The edits have been **bolded** for emphasis.
> 
> 
> 
Welcome to a cops and robbers version of [Find an Illegal String](https://codegolf.stackexchange.com/questions/133486/find-an-illegal-string).
An *illegal string* is "a string of characters that cannot appear in any legal program in your programming language of choice" (from the linked post).
For this challenge, we will define an *almost illegal string*, which is a string of characters that is very hard, but not impossible, to include in a valid program.
## The Cops' Challenge
* Choose a programming language, and choose an 'almost illegal string' - this is a sequence of characters that is very hard to include in a valid program without causing it to error.
* Write a program that contains the 'almost illegal string' as a contiguous substring that does not error.
* **Optionally, you may also specify a set of banned characters. These are characters that do not appear in your program, except in the 'almost illegal string'. (Therefore: banned characters can still appear inside the almost illegal string)**
That's it! You will reveal the programming language, the almost illegal string, **and the set of banned characters**, and challenge robbers to write a program that contains the illegal string but does not error.
For the purposes of this challenge, we define 'does not error' as:
* Your program exits with exit code 0.
* Your program does not print any output to standard error.
* Your program may print anything to standard output, if you wish, but it does not have to.
* If (and only if) your language *always* prints output to standard error regardless of the program, such as debugging or timing information, you may instead design a program that *only* outputs this to standard error. If you are making use of this clause, mention it in your cop post.
## The Robbers' Challenge
Find an uncracked answer. Write a program in the language specified that contains as a contiguous substring the almost illegal string specified and does not error. **Your program may not use any character in the set of banned characters, unless it is part of the almost illegal string.** Your program does not need to be exactly what the cop had in mind. Post an answer to the robber's thread and leave a comment on the cops' answer to crack it.
## Clarifications
* If your cop answer requires a specific operating environment or version, you must specify this in your answer.
* The cop's almost illegal string that they reveal is to be interpreted with respect to the standard encoding for the language's interpreter. For most programs, this will be UTF8.
* Solutions should not take any input (via standard input, argv, or any other source) and may assume no such input is given.
* Solutions must terminate in a finite amount of time. This means entering an infinite loop and getting killed by TIO's 60 second timeout is not a valid solution.
* Cops should make sure if their almost illegal string contains leading or trailing newlines that it is very clear it does so. Robbers should carefully note any leading or trailing newlines in a cop's post.
## Formatting hint
The clearest way to include leading or trailing newlines is to use the backtick syntax for your post:
```
```
foo
```
```
Renders as:
```
foo
```
To remove any ambiguity, *explicitly mention* the leading/trailing newlines in your post.
## Scoring
After 10 days without a crack, a cop can mark their answer as *safe* and reveal their solution. Once the cop has revealed their solution, it is no longer able to be cracked.
Cops are scored based on the length (in bytes) of their almost illegal string in their safe answer(s), with lower being better.
Robbers are scored by the number of answers they crack, with higher being better.
---
## Example
### Python 3, 5 bytes
Illegal string:
```
"'1/0
```
Banned characters:
```
#'
```
### Python 3, cracks example's answer
Program:
```
""" "'1/0 """
```
The idea is that we can just comment out the string, since `"` is not banned.
  
[Answer]
# [Python 2](https://docs.python.org/2/), 5 bytes ([cracked by tsh](https://codegolf.stackexchange.com/a/214817/20260))
```
bin()
```
[Try it online!](https://tio.run/##K6gsycjPM/r/PykzT0Pz/38A "Python 2 ‚Äì Try It Online")
Banned: all characters *except* alphanumeric characters
```
abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789
```
So, you're allowed the above characters and nothing else (in addition to `bin()` itself).
(This idea isn't mine, I remember it from an earlier challenge, but I don't remember who deserves credit for it.)
[Answer]
# Haskell, 3 bytes
```
#"
```
(begins with a newline)
Disallowed charachters: `-`
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 4 bytes, [cracked by HyperNeutrino](https://codegolf.stackexchange.com/a/214815/66833)
```
¬´{
```
[Try it online!](https://tio.run/##y0rNyan8/5@L69Dq6v//AQ "Jelly ‚Äì Try It Online")
You may not use newlines. Any other character/byte is fair game
---
My intended solution was any of the banned characters [here](https://codegolf.stackexchange.com/a/214816/66833) aside from `‚Äù`. Each of these characters cause the parsing of the link to break, meaning everything before them gets ignored:
[Try it online!](https://tio.run/##y0rNyan8/5@L69Dqao3//wE "Jelly ‚Äì Try It Online")
[Answer]
# [Python 3](https://docs.python.org), 7 bytes, [cracked by @EasyasPi](https://codegolf.stackexchange.com/a/219334/94066)
Still not the intended answer, so I'm just revealing it. Scroll to the bottom to see it.
```
raise
```
### Banned characters
```
`TAB` "'(),.=[\]_{|}
```
Non-ASCII characters are all banned as well. [Try it online](https://tio.run/##K6gsycjPM/7/n6soMbM4lev/fwA "Python 3 ‚Äì Try It Online") or [validate it online](https://tio.run/##tVRta@Q2EP5c/4ppDqpdSHzyi2x5YQ9KLoXQkkBv@6FkQxlJ49jUsYylTW5p@9tT2ZukR1@Ou7T1B9lja56X8YyGvW9snz3Uo72FBl3TtQra28GOHlyDqSii@ZN1z2/3ztNt9EcURWGJnTc0jms7UL9grw3dve53XceOgd2zZTSMbe8X7OJyc7aC8xp80wZAF@4Etu/24Om9B7vzw857Msewt7sR9Ij652lb299h15o4IEWvYL1eA8DJyUlYP/8ZXgWIzQf8d9h2Bn1re2gIg4sYfpzZrSG4sTTRw9FpiI5AUWfv4xniX6uIJoL1yBh7eAjLVbI6Sa7/F3@hdAd/tbX@o/5Q2Tv6r/wN6ByZ9WbcUdTWwLb9iK2jbc@gt35inSSsopAAjw1y@qc/vjqoNJPKKUfb3mNInHy1XUc32IHzIfcmtMaMc@D8Bjs3k2K/X@gnquA/2J4i9gUcbdlieRyvr7bb659@@fU3tvwUJY8CHCjsezKgGwwbQ1Hd3wm4b30Dh5GYezke9o8TAeigPhDW8f3YelpM@MtJ82HCFmyYZxOeMt88TxWkb75KPk3vXHEXygBhOu34D1U6xAe8ScA8@Au19@RmWUHzzteSLZdxQ@9Ne0POL5ZTIa/mnM@8WM0rUeoqlYYyXaalyVPOjZY6SSuZZzWJNEcUiGiyIleJKiUmSV1Skihtioodv4hWSF4kpcnqtMhIEpYc6zoXJRUF8oKjSKogRZCSWmlZV0glSoOoqUhTpfhLaQWvMiGDbixNmadSZkYhFyrDpFBp@EqyEmnJQ6QyQlGmgsqqUlgkRVG9lJZTlqW6rnKOCilPijQvdJVrnuW1VNxURS0wNxpV0INCmUpy5HmFGAouJLIXsF6vnpOe@vL7r0@/hfN3cH6xObt4e/YW3l1@98Pm/PLiy@kYglvcw2Cd/@DEjx@7lEJ3/hXvqc/nLv8oxsPv "Python 3 ‚Äì Try It Online")!
## Some cracks that work without the banned chars
```
'''
raise'''
```
```
"""
raise"""
```
```
raise SystemExit
```
```
raise`TAB`SystemExit # originally posted by EasyasPi here, he found yet another loophole
```
```
raise\
SystemExit
```
```
raiser=3 # originally posted by EasyasPi on v1 of this challenge
```
# Intended Answer
> 
> 
> ```
> #coding:U7
> quit+ACgAKQ-
> raise
> 
> 
> ```
> 
> 
> 
> 
This works because
> 
> the magic comment at the top sets the file encoding to UTF-7
> 
> 
> 
and
> 
> in UTF-7, characters can be encoded by first converting them to their UTF-16 binary representations, and concatenating them if there are multiple characters to be encoded. Here, we want to call `quit`, so we need to convert `()`. This becomes `0000 0000 0010 1000 0000 0000 0010 1001`. Next, we regroup them into groups of 6, to get `000000 000010 100000 000000 001010 01`, and pad the last group with trailing zeros (if necessary). In this case, we get `000000 000010 100000 000000 001010 010000`. Finally, we convert these to the corresponding Base64 characters (table [here](https://en.wikipedia.org/wiki/Base64#Base64_table_from_RFC_4648)), getting `ACgAKQ`, prepend a `+`, and append a `-`.
> 
> 
> 
So,
> 
>  `()` in UTF-7 is `+ACgAKQ-`. We use this fact to bypass the banned `()` and call `quit` anyways, by replacing `()` with `+ACgAKQ-`. This exits the program before it can throw any errors.
> 
> 
> 
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 4 bytes, [cracked by Unrelated String](https://codegolf.stackexchange.com/a/214832/66833)
```
¬´{
```
[Try it online!](https://tio.run/##y0rNyan8/5@L69Dq6v//AQ "Jelly ‚Äì Try It Online")
I'm giving Jelly another go, but with slightly more restrictions. You may not use `qu∆Å∆ò»§(∆à…¶∆ô…±…≤∆• † Ç»•` (the unimplemented commands in Jelly), `‚Äù` or newlines, as these make it *far* too trivial to crack (thanks to [HyperNeutrino](https://codegolf.stackexchange.com/users/68942/hyperneutrino) for showing that)
---
Neither HyperNeutrino's crack in the comments, nor Unrelated String's crack was my intended solution. Putting a `≈í` (or any of `√ê√Ü√ò≈ì√¶`) with nothing after it at the end causes the same behaviour as any of `qu∆Å∆ò»§(∆à…¶∆ô…±…≤∆• † Ç»•`, as they always expect to have a character after them. Without any character, they cause a break in the program chain, meaning that everything before them is ignored:
[Try it online!](https://tio.run/##y0rNyan8/5@L69Dq6qOT/v8HAA "Jelly ‚Äì Try It Online")
[Answer]
# [R](https://www.r-project.org/), 2 bytes, [cracked](https://codegolf.stackexchange.com/a/215202/86301) by Dominic van Essen
```
'"
```
[Try it online!](https://tio.run/##K/r/X13p/38A "R ‚Äì Try It Online")
Banned characters (newlines are banned):
```
'"`#\qel
    
```
This bans the obvious cracks I can think of, but I wouldn't be surprised if you come up with a crack very different to what I intend.
[Dominic van Essen](https://codegolf.stackexchange.com/users/95126/dominic-van-essen) [cracked](https://tio.run/##K/r/v7A0s0RD01pd6f9/AA) a first version of this challenge, and then a [second](https://tio.run/##K/r/v8K2KDUxxSczL7VYQ8dQk0td6f9/AA "R ‚Äì Try It Online"); then [Giuseppe](https://codegolf.stackexchange.com/users/67312/giuseppe) [cracked](https://tio.run/##K/r/Pz21RCOxoCi/IL9Yo7g0qbikSMNQx0DHQFMz2tDCwDxWU0PTWl3p/38A) a third version. I have added `qel` and newlines to the list of banned character to sidestep their cracks.
---
The solution I had in mind was
```
assign(intToUtf8(c(37,39,34,37)), c); 1 %'"% 2
```
[Try it online!](https://tio.run/##K/r/P7G4ODM9TyMzryQkP7QkzUIjWcPYXMfYUsfYRMfYXFNTRyFZ01rBUEFVXUlVwej/fwA "R ‚Äì Try It Online")
The assign call creates a new binary operator, `%'"%`; it is equivalent to `"%'"%" <- c`. In R, you can create new operators of the form `%x%` where `x` is *any* string: `%}%`, `%$@%` and `%¬µ¬£$%` are all valid operator names. Here, the new operator is equal to the concatenation function `c` and so the output is the vector `1 2`.
Dominic's [crack](https://codegolf.stackexchange.com/a/215202/86301) doesn't define the operator; he simply buried it in a `try` call, which is also valid R code.
The trick used here means that any future attempt at an almost illegal string will probably have to ban the `%` character.
[Answer]
# Desmos, 9 bytes,
```
sort(3,2
```
Banned characters: New Lines
```
```
I'm hoping that most people are not familiar with Desmos here, so people wouldn't know what to try.
Note:
An expression in Desmos would be considered an error if it shows a "danger sign" next to the expression, like this:
[![](https://i.stack.imgur.com/prrUc.png)](https://i.stack.imgur.com/prrUc.png)
[Answer]
# [Rust](https://www.rust-lang.org/), 5 Bytes (Safe)
```
:! =1
```
Banned Characters:
```
|!/"'
```
A nightly compiler is used, you may pass any flags to rustc if you like.
---
[A crack by @EasyasPi](https://codegolf.stackexchange.com/a/219254/94093)
does work (and is brilliant), but I think because the question says "you must write a program that contains ...", if your code is not designed to run, it isn't a program :)
## The intended solution
The idea is to create a local variable that has the never type, call some functions on the integer 1 such that it becomes the never type.
However, with `!` as a banned character, we can't simply put the `#![feature(never_type)]` attribute on the top of the program. We must use an unstable rustc flag that allows us to inject crate-level attributes. The command to compile would be:
```
cargo rustc -- -Z crate-attr='feature(never_type, core_panic)'
```
Because closures (`|| something`) and the use of the `!` type outside are restricted, we must operate on the integer literal with provided functions. This is where the `core_panic` feature comes in and gives us a nice way to transform a `&str` into `!`. We know the start and the end, we can just put them together:
```
use std::io::stdout;
use core::panicking::panic_str;
use std::borrow::Borrow;
fn main() {
    let a:! =1i8.checked_neg().as_ref().map(ToString::to_string).as_ref().map(Borrow::borrow).map(panic_str).unwrap();
}
```
[Answer]
# [Vim](https://www.vim.org), 4 bytes, cracked by [tail spark rabbit ear](https://codegolf.stackexchange.com/a/231255/100411)
```
<Esc><Esc>ZQ
```
This one is a bit more difficult than my other Vim one.
### Intended Solution:
> 
>  `i<C-o>:<C-r><Esc><Esc>ZQ`
> 
> 
> 
[Answer]
# [Python 3](https://docs.python.org), 10 bytes, [cracked by The Fifth Marshal](https://codegolf.stackexchange.com/a/220920/46076)
```
?"""?'''?
```
## Banned characters
Alphanumeric, whitespace, and non-ASCII.
---
> 
> The intended solution makes use of an interesting quirk in the Python parser.
> 
> 
> 
Here's a hint if you want one:
> 
> The hint is that there is no hint. (This isn't a joke. This is actually the hint.)
> 
> 
> 
---
# Intended Answer
> 
> Hexdump:
> ```
> 00000000: 2300 0a3f 2222 223f 2727 273f  #..?"""?'''?
> ```
> 
> 
> 
> 
For some reason,
> 
> the Python parser seems to ignore characters following null characters.
> 
> 
> 
So,
> 
> it ignores the newline after the `#‚êÄ`, therefore treating the `?"""?'''?` as part of the comment.
> 
> 
> 
Fun fact: This was actually posted on the original Find an Illegal String challenge, but when I found a way to get around it, I decided to post it here.
[Answer]
# Ruby, 17 bytes, [cracked by Dingus](https://codegolf.stackexchange.com/a/214869/92901)
```
=end
#{"""'}
=end
```
(no newline at start)
Disallowed charachters: `N`
[Answer]
# Julia, 5 bytes, [Cracked by Dingus](https://codegolf.stackexchange.com/a/214877/92901)
```
?""":
```
Disallowed charachters: `#`
[Answer]
# Julia, 6 bytes
```
?"""Óàã:
```
There is a zero width space before the `:`
Disallowed characters: `#`
[Answer]
# [Python 3](https://docs.python.org/3/), 13 bytes, [Cracked by EasyasPi](https://codegolf.stackexchange.com/a/218679/94093)
```
int(–ê,–í,–°)
```
Banned Characters: All ascii characters except `2()~+` and newlines. `'"#=` are banned.
```
 !"#$%&'*,-./013456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}
```
The solution makes use of an odd python 3 feature.
[Try it online!](https://tio.run/##K6gsycjPM/7/PzOvROPCBJ0Lk3QuLNT8/x8A "Python 3 ‚Äì Try It Online")
[Answer]
# nasm, 4 bytes, safe
```
[al]
```
Banned characters:
```
;"`'%#
```
## Solution:
> 
> `section` is, as far as I know, the only thing in NASM which accepts an arbitrary string without quotes.
> 
> 
> ```
>         section [al]
>         section .text
>         global _start
> _start:
>         mov     eax, 60
>         syscall
> ```
> 
> [Try it online!](https://tio.run/##SywuTs1NyqnUzUsszv3/XwEKilOTSzLz8xSiE3NiudAF9UpSK0rgouk5@UmJOQrxxSWJRSVcEMoKLpubXwamUxMrdBTMDBBmVRYnJ@bkKPz/DwA "Assembly (nasm, x64, Linux) ‚Äì Try It Online")
> 
> 
> 
Stop giving me these assembly ones for free. üòî
[Answer]
# [Python 3](https://docs.python.org/3/), 3 bytes, [Cracked by user](https://codegolf.stackexchange.com/a/219498/95792)
I can't believe I missed that obvious loophole! I am adding a slightly revised version of my code that should avoid this.
## New Answer, 4 bytes, [Cracked by Unrelated String](https://codegolf.stackexchange.com/a/219508/85334)
```
 1=2
```
Note: There is a `space` at the beginning of the code.
Banned characters: All non-ascii characters, quotes, and #.
```
"'#
```
[Try it online!](https://tio.run/##K6gsycjPM/7/X8HQ1uj/fwA "Python 3 ‚Äì Try It Online")
## Old Answer, 3 bytes, [Cracked by user](https://codegolf.stackexchange.com/a/219498/95792):
```
1=2
```
Banned characters: All non-ascii characters, quotes, and #.
```
"'#
```
[Try it online!](https://tio.run/##K6gsycjPM/7/39DW6P9/AA "Python 3 ‚Äì Try It Online")
### My intended solution for both posts:
```
foo : 1=2
```
[Answer]
# Javascript, 7 bytes, [cracked by Makonede](https://codegolf.stackexchange.com/a/220576/16484)
```
...void
```
# Javascript, 8 bytes, [cracked by Makonede](https://codegolf.stackexchange.com/a/220578/16484)
Note one trailing space
```
...void 
```
Banned characters:
* all comments: `//`, `/**/`
* all strings: `""`, ````, `''`
* curlies: `{}`
* brackets: `[]`
* asterisk: `*`
* the letter `w`
Clarifications: My cop answer works in a browser environment, but there are probably solutions in Node too.
[Answer]
# Ruby, 17 bytes
```
=end
#{"""'}
=end
```
Disallowed characters: `N`,`%`
This time I made it a bit harder.
[Answer]
# Ruby, 18 bytes
```
=end
#{/"""'}
=end
```
Disallowed characters: `N`,`%`,`/`
my final variation, hopefully the next solution is the intended one.
[Answer]
# Zsh
```
 
#include <cstdlib> 
#include <iostream> 
 
int main() { 
    srand(time(NULL)); 
    hello(); 
    return rand() % 2; 
} 
 
/* 
  main 
  a=0 
  \ 
  print "$((1/$a))" 
*/ 
 
void hello() std::cout << "Hello, World!" << std::endl; 
 
```
* Allowed characters: all printable ASCII *except* `blxy<'`$` (lowercase B, L, X, and Y, single-quote, grave, dollar sign)
* Please note all the leading and trailing whitespace.
Probably not too hard but you may learn a lot about the many - shall we say "quirks" - of zsh.
[Answer]
# Desmos, 2 bytes, [cracked by PkmnQ](https://codegolf.stackexchange.com/a/214959/96039)
Substring:
```
\
```
(Note the newline in the beginning)
Banned characters: All alphanumeric characters
```
abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789
```
I'm hoping that most people are not familiar with Desmos here, so people wouldn't know what to try.
Note:
An expression in Desmos would be considered an error if it shows a "danger sign" next to the expression, like this:
[![](https://i.stack.imgur.com/prrUc.png)](https://i.stack.imgur.com/prrUc.png)
[Answer]
# [Python 3](https://docs.python.org), 6 bytes, [cracked by EasyasPi](https://codegolf.stackexchange.com/a/219328/94093)
[@EasyasPi](https://codegolf.stackexchange.com/users/94093/easyaspi)'s crack does work (and I'm dumb for letting it work), but I'm not revealing the original solution yet; I've posted a v2 hopefully preventing any loopholes.
```
raise
```
### Banned characters
```
 "'(),.:[\]_{|}
```
Non-ASCII characters are all banned as well. [Try it online](https://tio.run/##K6gsycjPM/7/n6soMbM49f9/AA "Python 3 ‚Äì Try It Online") or [validate it online](https://tio.run/##tVTrb5swEP/OX3FrpRmkhPJyXlIqTV0nRZtSac0@TG01GfsIaAQj7CRF2/72zEDSVXtUbbfxwXDg@z3ufJS1TmUR7pJKriBlKs2zGLJVKSsNKmUBHVjtJ6nu3tZK48r6EVmWWVylBVbVVJZY2ORE4OakWOc56QHZEscqq6zQNplfLM4nMEtAp5kBVOaOIIu8Bo23GuRal2utUfSglusKeMX452ZbVmxYngnXIFnHMJ1OAaDf75v16c9wbCAW9/g3LMsF05ksIEVmXLjwsWWXAmEpsaGHozMTHUGMudy6LcRfq7AagmlFCNntzHLlT/r@zX/xZ0rX@Uuk1A/6Y7Hc4L/yVzKlUEwX1RqtLAFyXVQsU0igkLrhbARMLLMd9sfj7Kd@TzqNotHY5HBZaGYSG1dZnuOS5aC0yV2ag9HidIxvWK5aSlbUNj9QGffGdBMROLomttNzJ1fXN5@@fP1GnMfo2NMriFlRoACeMrPRFFT9jn6b6RS6cWjPsVvW@2kApiDpCBN3W2Ua7QbfaRR302WTsp1LOGSe3k0UBKcv/cfpbautTBHATKas/lCjLu7wGgHt0NtxrVG1sozmtU5GxHHcFG9FtkSlbacp41Wb88SL@CM6pMIfYOj7PGYR514Yc98LR8Mxw4iOByIc@CEVGKM39GKMGY0i7kWcMk/QgPSeReshHQ7ZOBhEvkcTpD43AoIw4UPuDaJgHFMxSMbDEHkSBJx6PKFxIrwg9HwuRpSTZ7DeTO6SDp16/@rsLcwuYTZfnM9fn7@Gy4t3Hxazi/mLZihhxWoopdL3/n/uvm9o@vUr3qHzbd8fxNh9Bw "Python 3 ‚Äì Try It Online")!
## Some cracks that work without the banned chars
```
'''
raise'''
```
```
"""
raise"""
```
```
raise SystemExit
```
```
raise\
SystemExit
```
[Answer]
# [Vim](https://www.vim.org), 3 bytes, cracked by [tail spark rabbit ear](https://codegolf.stackexchange.com/a/231255/100411)
```
<Esc>ZQ
```
A Vim program doesn't really "error out" per se, but `ZQ` will exit the current file without saving, so it can't be executed in a valid program, thereby making it "illegal".
This is a bit of an easier one, if you know Vim.
### Intended Solution:
> 
>  `i<C-v><Esc>ZQ`
> 
> 
> 
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), 15 bytes, [Cracked by lyxal](https://codegolf.stackexchange.com/a/231514/100664)
```
¬´Wi¬´¬ªWi¬ª`Wi`Wi
```
[Try it Online!](https://lyxal.pythonanywhere.com?flags=&code=%0A%C2%ABWi%C2%AB%C2%BBWi%C2%BB%60Wi%60Wi&inputs=&header=&footer=)
No bans, do what you want. Note that silently erroring at compile-time (Nothing appears in the 'output' box) counts as an error - even the empty program outputs 0...
My intended solution was prepending a `[` to just make sure the code isn't run.
[Answer]
# JavaScript (THREE.js 105) (Must include canvas element) ~48 bytes
```
const scene = new THREE.Scene();
scene.add(cube);
```
*Note empty lines*
[Try it!](https://jsfiddle.net/jh6x5tpa/)
Banned Characters: All quote characters
`/`
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), 32 bytes
```
X$globals()$"imp_print"$mod$
""
```
Banned characters are:
```
$\LMN."
```
[Try it online!](https://tio.run/##K6gsyfj/P0IlPSc/KTGnWENTRSkztyC@oCgzr0RJJTc/RYWLS0np//9/@QUlmfl5xf91UwA "Pyth ‚Äì Try It Online")
[Answer]
# Python 3, 7 bytes
```
"""'''$
```
(Note no starting or trailing newline.)
Disallowed characters:
```
#
```
]