[Question]
  [
Given the output of the cop's program (`o`), the byte-count (`n`) and the number of unique bytes (`c`) used, come up with a corresponding piece of code that is `n` bytes long with `c` unique bytes which matches the cop's output `o`.
---
# This is the ***cops thread***. Post solutions that are to-be-cracked here.
# [The ***robbers thread*** is located here](https://codegolf.stackexchange.com/questions/147637/reversed-engineered-from-uniqueness-robbers-thread).
---
Cops should post solutions like this:
```
#[Language], `n` Bytes, `c` Unique Bytes (c*n points) [Cracked](Link-To-Crack)
    [Output]
---
    
(Optional spoiler)
```
---
# Rules
* You may not take any input for your program.
* The program must use at least 1 byte, but cannot exceed 255 bytes.
* The output itself is also limited to 255 bytes.
* The program must have consistent output results when executed multiple times.
* If your submission is not cracked within 7 days, you may mark it as "safe".
	+ When marking it safe, post the intended solution and score it as `c*n`.
	+ Only mark an answer as "safe" if you *really* want the +15 for an accepted answer; it's more fun to see how long you can go.
# Winning
* The uncracked post with the lowest `c*n` score, wins the cop's thread.
* This will be decided after 10 safe answers, or a few weeks.
# Caveats
* If you feel cocky, you may tell the user the algorithm using a ***spoiler*** tag.
---
Uncracked Submissions:
```
fetch("https://api.stackexchange.com/2.2/questions/147635/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=>!/^#.*cracked/im.test(i.body_markdown)).map(x=>{const matched = /^ ?#{1,3} ?(?:(?:(?:\[|<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).reverse().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]
# [Haskell](https://www.haskell.org/), 173 bytes, 8 unique, 1384 points, safe
```
"[tag:reverse_engineering]"
```
It looks like this answer wants to provide a relevant tag to the question, while using only 8 different bytes.
As usual, your solution should work by being pasted in the code block on TIO: [Try it online!](https://tio.run/##y0gszk7NyflfXFKUmZeuYKsQ818puiQx3aootSy1qDg1PjUvPTMvNRUkG6v0PzcxMw@oqKC0JLikSAGi6f@/5LScxPTi/7rJBQUA "Haskell – Try It Online")
---
### Solution
```
'[':___':_'':_':':':__':__:__'':__:__':____:__:'_':__:___:_':_'_:___:__:__:__':_'_:___:_':']':[]
_:_:_'':_:_:_:__:_:_':_:_'_:_:_:_:_:___:_:_:_:__':____:___':_:__'':_=['_'..]
```
Yes, this is valid Haskell code: [Try it online!](https://tio.run/##RU9JDoMwDLzzitx8ggdY4hU9ppEVIUoRAUUkfL9uHJdUI9tjeby9fdrmEDjlcz0WM5ongwUkouJADAU1JQl3FIkQhLtEWHt@lJoOWhEcoHVd4TpboWl1hA30Z22XqmrraMveYXC8@/UoZ8crP/Jp9A3@TK/gl8T9FOMX "Haskell – Try It Online")
### How it works
The underscore `_` is used as a wild card in Haskell's pattern matching. `'` is used for characters, e.g. `'a'`. However, both `_` and `'` are also part of the allowed characters for identifier names (Within some restrictions, e.g. `'` cannot occur at the beginning of the name.). Therefore `__`, `_'`, `_'_`, `_''` and so on are all valid identifier names. Using some more descriptive names, the above code becomes
```
'[':t:a:g:':':r:e:v:e:r:s:e:'_':e:n:g:i:n:e:e:r:i:n:g:']':[]
_:_:a:_:_:_:e:_:g:_:i:_:_:_:_:n:_:_:_:r:s:t:_:v:_=['_'..]
```
The first line yields the string `"[tag:reverse_engineering]"` if each variable is assigned to the correct character. This assignment is achieved in the second line: `['_'..]` yields the string `"_`abcdefghijklmnopqrstuvwxyz{|}~ ... "`, witch is matched on the pattern `_:_:a:_:_:_:e:_:g:_:i:_:_:_:_:n:_:_:_:r:s:t:_:v:_` to get the desired assignment `a='a'`, `e='e'` and so on.
[Answer]
# Brain-Flak, 62 total bytes, 6 unique, 372 points, [Cracked](https://codegolf.stackexchange.com/a/149582/56656)
Here is your output:
```
10993592
```
There is something special about this number but [its not on the OEIS](http://oeis.org/search?q=10993592&language=english&go=Search) ;)
In case you are thinking of using a computer tool to solve this, you're out of luck, the integer golfer gets 110 bytes for this number:
```
(((((((((((((((((((((()()()()){}){}){}){({}[()])}{}()()){})){}{}())){}{})){}{}){}){}){}())){}{}){}()){}){}){})
```
[Try it online!](https://tio.run/##SypKzMzTTctJzP7/XwMr0IRAzepaGNKoro3W0IzVrK2uhckAMYgDoaEkDMGFwUy4xP//AA "Brain-Flak – Try It Online")
You're going to have to do this one by hand.
---
## Tips
Here are some tips, I will reveal more an more helpful tips over time. Good luck!
> 
>  10993592 is the 97th term of a sequence on OEIS, but does not appear because only a few terms are included.
> 
> 
> 
---
> 
>  My solution uses 3 loops, but they are *not* nested 3 levels deep.
> 
> 
> 
---
## My solution
```
((((((()()()){}){}){}){}){}())(({(({})[()])}{}){{({}[()])}{}})
```
[Try it online!](https://tio.run/##SypKzMzTTctJzP7/XwMCNEFQs7oWGQEFNDSqgahWM1pDM1azFiRaDeTCeLWa//8DAA "Brain-Flak – Try It Online")
This uses one of my favorite tricks, the code 
```
(({(({})[()])}{}){{({}[()])}{}})
```
computes the nth term of [A090809](https://oeis.org/A090809). The full submission just pads the code with a 97 to make a large number.
[Answer]
# [MATL](https://github.com/lmendo/MATL), 6 bytes × 3 unique = 18 points. [Cracked](https://codegolf.stackexchange.com/a/147687/36398)
```
1+0i 0+1i -1+0i 0-1i
```
[Answer]
# [Malbolge](https://tio.run/#malbolge), 15 bytes, 13 unique, score 195. Safe!
Outputs:
```
PPCG
```
**Safe!** Intended code:
```
(&a`#""7[}4XE70
```
[Try it online!](https://tio.run/##y03MScrPSU/9/19DLTFBWUnJPLrWJMLV3OD/fwA "Malbolge – Try It Online")
[Answer]
# JavaScript (ES8), 103 bytes, 42 unique (4,326 points) [SAFE]
Output hexdump:
```
3E 6E 6D 08 33 7A 22 7D 6C 37 7B 36 61 7B 65 71 3A 37 26 7E 7B 7B 38 7B 7D 69 6A 2B 3D 70 74 07 6F 6C 66 7E 1A 2A 3C 37 2D 36 31 38 6A 78 33 62 30 1E 34 3D 66 7B 37 10 26 6A 6A 32 27 6F 2E 33 1B 30 1E 76 27 27 7E 18 6F 68 26 2D 76 6A 6D 6D 2F 2E 0A 3F 17 7D 2B 73 7A 17 38 62 3A 29 20 0C 61 24 21 27 10 2B 20 63 71 72 17 5D 5F 12 5B 02 14 59 17 5A 11 1E 1D 10 16 07 5F 5F 58 58 4B 18 48 4B 04 5F 06 12 16 14 4D 45 5D 5D 16 3A 1C 1D 11 16 1F 51 59 4E 4B 4C 3D 16 1C 0F 2E 46 0E 08 4B 4B 13 45 21 10 06 0E 11 3F 51 57 3E 00 54 5F 49 05 0E 07 5A 51 3E 08 01 25 10 0B 51 36 43 0B 34 1A 43 47 04 46 0E 55 05 00 06 01 40 33 0F 00 53 36 42 42 45 5F 3D 3A 38 74 39 74 71 71 2C 7C 60 38 38 76 63 44 7F 64 28 66 3E 24 7A 66 57 79 24 3C 3C 21 6A 36 27 30 77 7E 36 7E 2A 3E 29
```
The score is abnormally big, I know, but anyway I think this one may be interesting to crack. The program is a function which returns a string (just to avoid confusion, this is not REPL).
It shouldn't be too hard, I suppose, everything is about finding the pattern.
### Solution
It seems that it was harded than I had thought, according to the fact that nobody had cracked it. I believed there may be multiple solutions which are easy to craft. Anyways, here is the intended solution:
> 
>  
> ```
> f=m=>[...m=f+f+f].map((a,p)=>p+1&256?'':String.fromCharCode((p&4?m[p^17]:a).charCodeAt^83^p*.3)).join
> ```
> 
> 
> 
> 
For some reason it is not displayed properly as code snippet. Here is the [TIO link](https://tio.run/##LctNCoMwEEDh22imtgPW/iFEKR6hSzEkWGMjJhli6PVTF@UtP96ivmobg6F4cv49paS55U2PiJbrYm9Aq4gxdSTgDRVldr7e2jyvXzEYN6MO3nYfFbp9ZoyyS2t7EuV9qBXg@IdnlFI8KkEHrABw8cZJmUbvNr9OuPqZaQaQfg).
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 7 bytes × 6 unique = 42 points, [cracked](https://codegolf.stackexchange.com/a/147758/41024)
```
843606888284160000
```
[Try it online!](https://tio.run/##y0rNyan8/9/CxNjMwMzCwsLIwsTQzAAI/v8HAA "Jelly – Try It Online")
> 
> 
> ```
> 8!×16!¤
> ```
> 
> 
> 
> 
[Answer]
# Octave, 13 bytes, 5 unique characters, score: 65. Safe!
```
20085918935040000
```
This one shouldn't be too hard. If you don't want to jump in to the most difficult ones straight away it might be a nice first challenge :)
Note: When I read the question, I though it said: Output a number, not output a string. The output looks like this on TIO:
```
ans =    2.0086e+16
```
And will look like this if you have `format long`
```
ans =  20085918935040000
```
or you may print it like this: 
```
printf('%i',ans)
20085918935040000
```
### What I had, and explanation:
```
prod prodprod
```
Simple as that. =)
**Explained:**
Normally you'd write this as: `prod('prodprod')`, but Octave treats whatever comes after the function name as a string (array of characters). These are implicitly converted to their ASCII-values, and multiplied together.
[Answer]
# MATL, 11 bytes, 10 unique, 110 points. SAFE!
Output:
```
10803850202590
```
Just to "help" you one the way:
This is the product of:
```
[2, 5, 29, 89, 397, 499, 2113]
```
and it's one less than the `372884884433`rd prime.
---
And here are some real tips. If it's not cracked in a few hours then I'll reveal the solution.
1. > 
>  - There's a `q` in there
> 
> 
>
2. > 
>  - There's a `B` in there
> 
> 
>
3. > 
>  - There's a `^` in there
> 
> 
>
4. > 
>  - There's a `h` in there
> 
> 
>
5. > 
>  - There's a `t` in there
> 
> 
>
### The real code:
> 
>  9K^ZqsBthXB
> 
> 
> 
**Explanation:**
> 
>  Push two numerals, `9` and `K`, and do exponentiation. Create a list of all primes below that number, and sum them. Convert to binary, duplicate the binary vector and concatenate it with itself. Convert back to decimal and output implicitly.
> 
> 
> 
[Answer]
# MATL, 4 bytes, 4 unique, 16 points. [Cracked](https://codegolf.stackexchange.com/a/147653/36398)
Output:
```
1388289520800
```
**What I had:**
> 
>  `1X%p`
>   
> 
>  This pushes the number 1, checks which class it is, then multiplies the ASCII-values of the resulting string 'double'.
> 
> 
> 
[Answer]
# Java 8 (full program), 97 total bytes, 34 unique, 3298 points ([Cracked by *@RobertoGraham*](https://codegolf.stackexchange.com/a/147684/52210))
Output:
```
1.4241570377303032
```
NOTE: This is a full program. If functions in the form of `()->` are allowed instead:
# Java 8 (lambda function), 40 total bytes, 18 unique, 720 points ([Cracked by @user202729](https://codegolf.stackexchange.com/questions/147635/reversed-engineered-from-uniqueness-cops-thread/147659?noredirect=1#comment362499_147659))
It's probably quite hard, but whatever.. It's not like Java is going to win anything with this amount of points anyway..
---
**Hints:**
> 
>  The intended code doesn't contain any single or double quotes. (The function returns a double.)  
> 
>  The intended code doesn't contain any digits (`0-9`).
> 
> 
> 
---
**Intended solution:**
Pretty funny (and impressive) how both given cracks are completely different than what I had in mind, but chapeau to both of the crackers!
> 
>  Function: [`()->Math.log(Math.hypot(Math.PI,Math.E))`](https://tio.run/##LU7LCoMwELz7FXtMoOYHpL310INS8Cg9bGOqsZoEswpS/PY0Pi67Mwzz6HDG1DpluvobZI/eQ47a/BIAbUiNH5QKio0C1HZ69wok41nkaxKPJyQtoQADVwiMp7ccqRW9bdgO2sVZOuDzcdn/nfOQbV4X06L3jJitrmGI1aykUZumegHyo7dcPKlB2ImEixIxI@KGc8Qa/g)  
> 
>  Full program: [`interface M{static void main(String[]a){System.out.print(Math.log(Math.hypot(Math.PI,Math.E)));}}`](https://tio.run/##y0osS9TNL0jNy0rJ/v8/M68ktSgtMTlVwbe6uCSxJDNZoSw/M0UhNzEzTyO4pCgzLz06NlGzOriyuCQ1Vy@/tESvAChYouGbWJKhl5OfDmFkVBbkQ8UCPHXAtKumpqZ1be3//wA)
> 
> 
> 
[Answer]
# [Haskell](https://www.haskell.org/), 10 bytes, 3 unique, 30 points, [cracked](https://codegolf.stackexchange.com/a/147736/56433)
```
2416508937
```
A nice number which contains every digit, though only 3 unique bytes are used. 
The intended solution works by replacing the code part in the following TIO link:
[Try it online!](https://tio.run/##y0gszk7NyfmfqWCrEPPfyMTQzNTAwtLY/H9uYmYeUKygKDOvRCHz/7/ktJzE9OL/uskFBQA "Haskell – Try It Online")
[Answer]
# [Haskell](https://www.haskell.org/), 29 bytes, 15 unique bytes, 435 points, [cracked](https://codegolf.stackexchange.com/a/147884/56433)
```
"33333333333333333333333333333333333333333333334333333333333333333333333333"
```
This is a string containing `3` 73 times, and a single sneaky `4`.
The intended solution works by replacing the code part in the following TIO link: [Try it online!](https://tio.run/##y0gszk7NyflfXFKUmZeuYKsQ81/JmCRggkdO6X9uYmYe0NSC0pLgkiIFiC3//yWn5SSmF//XTS4oAAA "Haskell – Try It Online")
*Edit:* H.PWiz found a valid crack (which could even be golfed to 28 bytes), but not the intended solution.
**Hints:**
> 
>  No arithmetic needed.
>  There exists a single-expression solution.
> 
> 
> 
[Answer]
# Mathematica, 8 bytes, 3 unique, 24 points [Cracked](https://codegolf.stackexchange.com/a/147897/67961)
```
7448503425106854065710345345644475127957406351360000000
```
[Answer]
# [Explode](https://tio.run/#explode), 9 total bytes, 4 unique, 36 points
Output:
```
22k2Dk}D}
```
Note that the documentation does not completely align with the implementation for this language - I wrote this one day and haven't touched it since, so any bugs in implementation that may exist are now definitely features.
Also, I do not think this language is Turing-complete, so you could probably brute force it, but that's boring.
I'll give you a sizable bounty if you can automate reverse-engineering output into optimally short Explode code.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 8 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page), 2 unique, 8×2 = 16 points -- Safe!
```
-4.408500694095235e-05
```
(There are only **8,355,840** possible such programs so it should get cracked I guess.)
**[Get going at Try it online!](https://tio.run/##y0rNyan8/1/XQM8ACExMDCxMDQzMLE0MLE2NjE3//wcA)**
### How?
> 
>  `⁽⁽°°°°°°`  
> 
> `⁽⁽°` is a base 250 literal yielding `-27221`  
> 
> `°` converts from radians to degrees. Applying this five times:  
> 
> `-475.09607568537643`  
> 
> `-8.291990784013993`  
> 
> `-0.1447225407260702`  
> 
> `-0.0025258848375215096`  
> 
> `-4.408500694095235e-05`
> 
> 
> 
[Answer]
### C (two's complement machine, sizeof(int) = 4), 76 bytes and 35 unique bytes for a score of 2660, Safe
Output: 
```
10542949672924294967287429496729029742949672954294967287429496728808914294967289429496728742949672946944294967291429496728742949672914964294967294429496728742949672891980429496728842949672874294967295792 
```
which is 203 bytes long.
> 
> #include<math.h>  
> 
> main(){for(int  
> 
> i=0;i<40;i++)printf("%u",(int)(cos(i)\*10));}  
> 
>   
> 
> Without the #include it won't work.  
> 
> 
> 
> 
[Answer]
# CJam, 15 bytes \* 10 unique = 150 points
```
453630781352162854505467929721140132016201833205823402832306035643819420004950
```
Bad score, but hopefully will be hard to crack.
Note: At the moment I have forgotten what the answer is. As such, I will keep it open until either I or somebody else is able to crack it.
[Answer]
# CJam, 15 bytes \* 10 unique = 150 points
```
355605126761554652609272416635107412217265861355621217687464016216276447790261274709847680
```
Note: At the moment I have forgotten what the answer is. As such, I will keep it open until either I or somebody else is able to crack it.
[Answer]
# Octave, 4 bytes, 3 unique, 12 points: [cracked](https://tio.run/##y08uSSxL/f8/K8486/9/AA)
```
1.6776e-05
```
Lets see how fast this one goes.
[Answer]
# Pyth, 7 bytes, 6 unique, 7\*6=42 total score
```
312069475503262125385169244603150327250717758754411025379995130624544231547913731661607993843298516888546865336571981925596
```
---
Check out the [Pyth tips thread](https://codegolf.stackexchange.com/questions/40039/tips-for-golfing-in-pyth) for inspiration ;)
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 3 bytes × 3 unique = 9 points, [cracked](https://codegolf.stackexchange.com/a/147767/41024)
```
263409560461970212832400
```
[Try it online!](https://tio.run/##y0rNyan8/9/IzNjEwNLUzMDEzNDS3MDI0MjC2MjEwOD/fwA "Jelly – Try It Online")
Another attempt at Jelly, this time more challenging I hope.
> 
> 
> ```
> ȷc⁵
> ```
> 
> 
> 
> 
[Answer]
# [Alice](https://github.com/m-ender/alice), 9 bytes x 8 unique = 72 points [Cracked](https://codegolf.stackexchange.com/a/147892/69059)
```
KMOQSUWY[]_acegikmoqsuwusqomkigecegikmoqsuwy
```
[Try it online!](https://tio.run/##S8zJTE79/9/b1z8wODQ8Mjo2PjE5NT0zOze/sLi0vLS4MD83OzM9FUms8v9/AA "Alice – Try It Online")
This one should be funny to crack
[Answer]
# Excel, 22 bytes, 16 unique, 352 points, [Cracked](https://codegolf.stackexchange.com/questions/147637/reversed-engineered-from-uniqueness-robbers-thread/147860#147860)
```
หนึ่งล้านห้าแสนสามหมื่นสองพันสี่ร้อยเก้าสิบห้าล้านห้าแสนสี่หมื่นแปดร้อยหกสิบห้าล้านแปดแสนเก้าหมื่นล้านล้านล้านล้านล้านล้านบาทถ้วน
```
This might not be very hard to crack but I get to use a function that I otherwise never get to use. Besides, the score won't win anything unless a lot of others get cracked.
[Answer]
# PowerShell, 7 bytes, 5 unique = 35 points [Cracked](https://codegolf.stackexchange.com/a/147830/42963)
Output:
```
1125899906842624
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 8 bytes \* 6 unique = 48 ([Cracked](https://codegolf.stackexchange.com/a/148082/53748))
```
241975308641975308641975308641975308641975308641926913580246913580246913580246913580246913580246916
```
You can [try to crack it here](https://tio.run/##y0rNyan8DwQA).
> 
>  **Intended solution:** `7ẋ²Ḍ²ẋ4S`
> 
> 
> 
[Answer]
# [Haskell](https://www.haskell.org/), 30 bytes, 17 unique, 510 points, [cracked](https://codegolf.stackexchange.com/a/148108/56433)
```
"6666666444444455666666666566555533333334333333333"
```
The intended solution works by replacing the code part in the following TIO link: [Try it online!](https://tio.run/##y0gszk7NyflfXFKUmZeuYKsQ81/JDAJMIMDU1AwGgCxTIDCGABNjGFD6n5uYmQfUXFBaElxSpAAx7P@/5LScxPTi/7rJBQUA "Haskell – Try It Online")
This uses the same approach as my [previous answer](https://codegolf.stackexchange.com/a/147876/56433), which was cracked using a different approach.
Some hints:
> 
>  No arithmetic needed. I have a single-expression solution. 
> 
> 
> 
[Answer]
# Javascript, `11` Bytes, `7` Unique Bytes (77 points) [(Cracked)](https://codegolf.stackexchange.com/a/147665/58563)
```
0.022522522522522525
```
---
> 
>  lambda function declaration included in byte count, function call is not.
> 
> 
> 
This should be really easy.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 4 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page), 4 unique, 4 × 4 = 16 points -- Safe!
```
121713205122350539153771498803599196214022517709999123476340843193655114000078051089267404501704293755399249186132786797198080437408108773592830098754467315464894774875031495160099382422748898046431945143395996374011431649446848855993397955116462522798880
```
Note that the output is 255 bytes long, right at the limit.
Yep, same score as [my other (as yet uncracked) Jelly entry](https://codegolf.stackexchange.com/a/147756/53748).
**[Get going at Try it online!](https://tio.run/##FY/BFUNBCAJbEkXRgnLJSwOp/od4ZMeRfb8@n@/zICFURiOzOroOXRJ4u1F9h5sEI7MhxXmQRU0xloWr6YYBj9aa2MsRgx1QMK/Utl7ysONT2tEJt7HBMrnekXwrtyJu1eSo0BzuUaKjKFdqjIGrTWY6XksMuQUbrDr3nb/ShQrDs2iNtXO/6v5Vh5PtdX9w43l@)**
### How?
> 
>  `7ÆĊ⁺`  
> 
> `7` is a literal seven  
> 
> `ÆĊ` gets the **nth** Catalan number  
> 
>  the **7th** Catalan number is **429**  
> 
> `⁺` repeats the previous atom  
> 
>  the **429th** Catalan number is `121713205122350539153771498803599196214022517709999123476340843193655114000078051089267404501704293755399249186132786797198080437408108773592830098754467315464894774875031495160099382422748898046431945143395996374011431649446848855993397955116462522798880`.
> 
> 
> 
[Answer]
# [Perl 5](https://www.perl.org/), 31 Bytes, 18 Unique Bytes (558 points) -- safe
```
1.76295255109024e+180
```
Intended solution ([Try it online!](https://tio.run/##K0gtyjH9/18l3tbQOi2/SMVWw1BPz9DQULNaJV7LVsW2tqAoM6/k/38A "Perl 5 – Try It Online")):
```
$_=1;for$=(1..111){$_*=$=}print
```
(this calculates the factorial of 111)
[Answer]
# Haskell, 37 bytes, 20 unique, 740 points, safe
The answer is an expression whose result equals the string literal:
```
"4F\\DLE\\C\"S\\T \\\\DC$EO!RUr\\K\\SSS1\\%S\\\\AN\\D&CDI#3SSC\\\\\\E\\C\\YC\\USB2SNN\\ED'\""
```
(That is, when `putStr`’d, you’d get:)
```
4F\DLE\C"S\T \\DC$EO!RUr\K\SSS1\%S\\AN\D&CDI#3SSC\\\E\C\YC\USB2SNN\ED'"
```
> 
> **Safe**! Intended expression:
> 
> 
> 
> ```
> [show['\r'..]!!rem(w^7)77|w<-[7..77]]
> 
> ```
> 
> 
]