[Question]
  [
This is the cops' thread. For the robbers' thread, click [here](https://codegolf.stackexchange.com/questions/99472/quine-anagrams-robbers-thread).
### Cops' Task
* First, write a quine in a language of your choosing.
* Next, scramble the quine. Make sure to do this well as the robbers will be trying to unscramble it and find the original source code! Note that the scrambled code does not need to work.
* Post an answer on this thread. Include the language, the byte count, and the scrambled code.
Your program may not print to STDERR.
Here is an example of a cop submission:
> 
> # Python, 29 bytes
> 
> 
> 
> ```
> nt _%=_r;_riinp;pr_='t _%%%_'
> 
> ```
> 
> 
### Robbers' Task
For the robbers' thread, click [here](https://codegolf.stackexchange.com/questions/99472/quine-anagrams-robbers-thread).
### Safe Submissions
If your submission has not yet been cracked after a week of posting, you may add the solution and specify that it is safe. If you do not, your submission may still be cracked.
### Scoring
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the user with the safe submission with the fewest bytes will be the winner of this section.
### Leaderboard
Here is a stack snippet to generate a learderboard for this challenge. For it to display properly, please format your submission like this:
```
# Language Name, N bytes
... other stuff ...
```
If your submission gets cracked, please format like this:
```
# Language Name, N bytes, [Cracked!](link)
... other stuff ...
```
If your submission is safe, format like this:
```
# Language Name, N bytes, Safe!
... other stuff ...
```
```
<script>site = 'meta.codegolf'; postID = 5686; isAnswer = false; QUESTION_ID = 99469;</script><script src='https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js'></script><script>jQuery(function(){var u='https://api.stackexchange.com/2.2/';if(isAnswer)u+='answers/'+postID+'?order=asc&sort=creation&site='+site+'&filter=!GeEyUcJFJeRCD';else u+='questions/'+postID+'?order=asc&sort=creation&site='+site+'&filter=!GeEyUcJFJO6t)';jQuery.get(u,function(b){function d(s){return jQuery('<textarea>').html(s).text()};function r(l){return new RegExp('<pre class="snippet-code-'+l+'\\b[^>]*><code>([\\s\\S]*?)</code></pre>')};b=b.items[0].body;var j=r('js').exec(b),c=r('css').exec(b),h=r('html').exec(b);if(c!==null)jQuery('head').append(jQuery('<style>').text(d(c[1])));if (h!==null)jQuery('body').append(d(h[1]));if(j!==null)jQuery('body').append(jQuery('<script>').text(d(j[1])))})})</script>
```
  
[Answer]
# C#, 288 bytes
```
Stag is a great shoW.        "="=""="="Agent"plastic"Was"tryin"to"Release"an"Astroid"."$Money$"st@le"tigers"and"Agent"plastic"got"mad"."$Money$"sic","man","t0tally"rad"."Sistrs"Rms"titAnic";"Civic"Ace"in"{sC@m}{hic}{vicis}..{cats}sAc}((@))((@)){{{>>{{{{{{}}}}}}}}}\\\\\\\;;;(@)((@)()),,;;
```
My strategy is for all the short ones to get cracked and nobody bothers with this considering how long it is... Also I suppose I should note that this is a full program, not just a function.
[Answer]
# JavaScript, 1574 bytes, Safe!
I spent way too much time on this. Behold the obfuscation.
```
(notice that an unmatch parenthesis remains throughout the entire text.
dear "sir",
|    i cannot express my loathing to you and your things. they truly are a loathsome sight. (regar'less of their quality, they function as the most appalling devices...)[1]
|    these avocads of thine possession are most unpleasent. (ce n'est pas faux.) Queer; Careful; An' in total repulsing. in this form, those are not seulement cringe... So; CAB's is quite Cruel. (Cruel indeed...)
|    intention is not great (heh, intention, ;}) run, no, run, since {tu est le ;AqC;};
{{{{============================================}}}}
[1]: see? am i not insane? You may dictate the opposite, so i dictate thus.
9 + 4 is 13. Y is this. Y + 4 is 9 + 9 minus one. N is this. f(x) is {x + x}, so f(N) is N plus N is N + N is 3.
:^) i'm cruel; not so cruel.)
                                  rrrrrrrrrr 0nnnccnnggrrrrttssBBC
{({[}(<[<))(((((){{})}[}][[]{}(]))))|} f f r 0nnnccnngrrrrrttesBBA
())(((()))))()))()()()((((()))}{{})((} f f r 0nnnccnngrrrrrttesBBY
]]}(([][]{{{}}})()({}(){}{()}{}()[])][ f f r 4nnnccnngrrrrrttesBSY
))({})(}{)({{{{(()))())))))))()))()()( f f r 4nnnccnngrrrrrtpesqSY
)()()((((((((((Z))))))))()(()((()((((( f f r 5nnnccnngrrrrrtlefoSY
(((;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;''' f f r 3nnncccngrrrrxtleifSY
''''''''''''''''''',,,,,,,,[[[[[[]]]]] f f r 3nnncccngrrrrxtleifZQ
[ ] ] + + + + + + + + + + + + + + + ++ f f r 9nnncccggrrrrxtleifZQ
+ + + + too not fun...fffffffffffffuuu f f r 5nnncccggrrrrxtlli0ZQ
uuuuuuuuuuuu.. | | | |99S            ) f f r 0nnncccggrrrrxxll01QQ
```
## Here's the original source!
> 
> 
> ```
> function Y(x){return x.charCodeAt()};
> function Q(x){return String.fromCharCode(x)};
> N=Array.prototype;
> function B(f,g,h){return function(){
>   return f(g.apply(h||this,arguments));
> }};
> function S(f,h){return function(){
>   return f.apply(h||this,N.reverse.call(arguments))}}
> function id(x){return x};
> function format(){
>   args = N.slice.call(arguments);
>   str = args.shift(); res = []+[];
>   for(i = 0; i < str.length; i++){
>     c = function(){return str[i]};
>     if(B(Y,c) == 95){
>       res += args.shift();
>     } else if(S(B)(c,Y)() == 94){
>       res += q = B(id,Q)(34);
>       res += args.shift();
>       res += q;
>     } else if(Y(c()) == 39){
>       i++;
>       res += c() == ([][0]+[])[1] ? Q(10) : []+[];
>     } else res += c();
>   }
>   return res;
> }
> console.log(format(Z="function Y(x){return x.charCodeAt()};'nfunction Q(x){return String.fromCharCode(x)};'nN=Array.prototype;'nfunction B(f,g,h){return function(){'n  return f(g.apply(h||this,arguments));'n}};'nfunction S(f,h){return function(){'n  return f.apply(h||this,N.reverse.call(arguments))}}'nfunction id(x){return x};'nfunction format(){'n  args = N.slice.call(arguments);'n  str = args.shift(); res = []+[];'n  for(i = 0; i < str.length; i++){'n    c = function(){return str[i]};'n    if(B(Y,c) == 95){'n      res += args.shift();'n    } else if(S(B)(c,Y)() == 94){'n      res += q = B(id,Q)(34);'n      res += args.shift();'n      res += q;'n    } else if(Y(c()) == 39){'n      i++;'n      res += c() == ([][0]+[])[1] ? Q(10) : []+[];'n    } else res += c();'n  }'n  return res;'n}'nconsole.log(format(Z=^,Z))",Z))
> ```
> 
> 
> 
> 
[Answer]
# [MATL](https://github.com/lmendo/MATL), 20 bytes. [Cracked](https://codegolf.stackexchange.com/a/99679/36398)
```
It'D-whoLl&w#ck'f0Gz
```
Don't attempt to crack this. It'd wholly wack fogs.
[Answer]
# [Underload](http://esolangs.org/wiki/Underload), 20 bytes, [Cracked!](https://codegolf.stackexchange.com/a/99644/8478)
```
~*)(a):*(*a:S(*S*~S)
```
I scrambled this via randomizing the order of the characters, because what could be more scrambled than random?
A correctly written Underload interpreter crashes when seeing a newline at the top level of the program. As usual in golfing competitions, there's no newline at the end of the program; I'm just placing this reminder here because it's very easy to add one by mistake when copying the program to an interpreter.
[Answer]
## [Retina](https://github.com/m-ender/retina/), 20 bytes, [Cracked](https://codegolf.stackexchange.com/a/100059/8478)
```
S`(\?)\1*
S`(\?)\1*
```
The program (and output) contains exactly two linefeeds.
[You can try Retina online here.](http://retina.tryitonline.net/)
A small hint:
> 
>  In the process of designing this cop, I found a new shortest Retina quine, which I'll post to our quine challenge once this answer is either cracked or safe.
> 
> 
> 
[Answer]
## CJam, 39 bytes, Safe
```
!""$)+023345679:AEORYZZ\_```bbceeffimmz
```
Solution:
> 
>  `")A!0z`eZOmRZ$Yei`E"_`\32fm95b67b43f+:c`  
> 
>   
> 
>  Uses some base encoding for obfuscation. However, since the characters are all in ASCII I would have thought someone might be able to figure out `32fm95b??b??f+:c` which would be enough to brute force the rest.
> 
> 
> 
[Answer]
# Pyth, 38 bytes, Safe
Not quite golfed, but works.
```
````::""@@@@++++22ggKKKKKKKKNNNNZZZZ
```
Unsorted version:
```
K"K++@KZ:`K@`NZNgK2"++@KZ:`K@`NZNgK2
```
[Answer]
# Vim, 22 bytes, [Cracked!](https://codegolf.stackexchange.com/questions/99472/quine-anagrams-robbers-thread/99493#99493)
```
pit^[^[p00tqqqq^V"ltxltx"
```
The `^[` are the literal escape key, and `^V` is `Ctrl-V`, and are therefore counted as one byte, and are kept together in the scrambled code.
[Answer]
# Python 2, 54 bytes, [Cracked!](https://codegolf.stackexchange.com/a/99557/34543)
```
=l`;lrt,]l n`p,i=,' 1,1'lnt[ll[;,0  ]['r[`][`0'ipll] ]
```
[Answer]
# JavaScript, 147 bytes, [Cracked](https://codegolf.stackexchange.com/a/99593/42545) by ETHProductions
I'll be very impressed if someone manages to crack this...
```
   """"''''((((()))))+++++++++.//99;;;;;;=========>>[[[[[]]]]]``````````````cccdddddddeeeeeeeeeeeffiiiiiiinnnnnnnoooooooorrrrrrrrsttttuuwwwwwwx{{}}
```
### Intended solution:
```
e=o=>{n=o;``[r=`constructor`][r](`return e=>{`+o+`}`)````};d=e+"";e`for(i in window)if(/ert/.exec(i))w=window[i];w('e='+d+';d=e+"";e'+d[9]+n+d[9])`
```
[Answer]
# Haskell, 86 bytes, [cracked by nimi](https://codegolf.stackexchange.com/a/99683/56433)
```
putStr$"Study:ric====>>>>yummy:candy:circus:party:in:syrirrr!!!!!!$[;['=['[$]']='];]$"
```
This a valid Haskell expression which prints:
```
Study:ric====>>>>yummy:candy:circus:party:in:syrirrr!!!!!!$[;['=['[$]']='];]$
```
So if Ric studies, he can go to the yummy candy circus party! That is, if he figures out where *Syrirrr* is.
[Answer]
# [V](http://github.com/DJMcMayhem/V), 20 bytes -- Safe!
```
"$033lpqxx|áäéééñññ
```
Note the trailing newline.
I wasn't really sure how to scramble them, so I just sorted the characters by ASCII value.
Unlike most V answers, this one contains *zero* unprintable characters. Here is a hexdump:
```
0000000: 2224 3033 336c 7071 7878 7ce1 e4e9 e9e9  "$033lpqxx|.....
0000010: f1f1 f10a                                ....
```
# Unscrambled code:
```
éññ3äl0éé$áx3|"qpñx
```
[Try it online!](http://v.tryitonline.net/#code=w6nDscOxM8OkbDDDqcOpJMOheDN8InFww7F4Cg&input=)
Side not about this link. In previous versions of V, a newline was always automatically printed, which is why this version has the trailing newline. The interpreter at the time I wrote this was a valid quine, although now you can just remove the newline to make it valid.
Explanation:
```
éñ                      " Insert a 'ñ' character
  ñ              ñ      " Put all of the following into register 'q' and run it when it's done recording
   3äl                  " Make 3 copies of the character under the cursor
      0                 " Move to the first column
       éé               " Insert an 'é' character
         $              " Move to the last column
          áx            " Append an 'x'
            3|          " Move to the third column
              "qp       " Paste register 'q' (all of the commands we just ran)
                  x     " Delete a character
```
[Answer]
# Haskell, 99 bytes, Safe
```
"super.quine?"=>#$$$%%%%%&&(())))**++++,,,,/;<<==>>STaabbdeffggghhhjlmmnoppqqrrsssttttuuuvvwwwwxxxx
```
Another Haskell quine, this time with a nice odd 99 bytes. 
> 
>  
> ```
> g%w=(g< $ >w)++w++pure(g.last$w);main=putStr$pred%"h&x>)h=%?x*,,x,,qvsf)h/mbtu%x*qvuTus%qsfe&#"
> ```
> 
> [Try it on Ideone.](http://ideone.com/GDgXTq) The spaces in "g< $ >w" must be removed, I put them there because otherwise the <,$, and > vanish (most likely being interpreted as html tag).
>  The gibberish string is a string of the program with each char mapped to it's successor, including a final `"` (which is possible to include into the string without escaping because it's mapped to `#`). The helper function `%` takes the string and maps each char to it's predecessor using `pred` (yielding `code"`), then appends the original string (yielding `code"gibberish_code`) and the last char of the decoded string (yielding `code"gibberish_code"`). To convert a char `c` to a string it would normally suffice to put it into a list `[c]` as strings in Haskell are simply char lists, however the successor of `[` is `\`, which would need escaping in the successor-encoded string, so instead `pure` is used which lifts arbitrary types into a Monad (which Monad to use is inferred from the context).
> 
> 
> 
[Answer]
# PHP, 110 bytes, [Cracked](https://codegolf.stackexchange.com/questions/99472/quine-anagrams-robbers-thread/99887#99887)
```
php$=))$)<9 php .(().)'heroes ?  $0(9carrot3?$;<.()trash3,.((3=)catarrh$$9 (,'9cry(3);  ;;tryccchhhrrrrxxxxxx
```
[Answer]
# Javascript ES6, 49 bytes (cracked)
```
{{$((((((('`fuck rent =+> turn off fin`')))))))}}
```
Is it bad if I focused more on forming coherent words in the scrambled solution?
In any case, this is my first Cops and Robbers challenge.
**Update**: see comments for cracked code.
[Answer]
# FurryScript, 199 bytes, Safe!
```
UT  TTEDU DT   T U T D   ES DGT GEL L   GL
-<<<<<<+++++++[[[[#BESTQUINEEVER!#BESTQUINEEVER!#BESTQUINEEVER!#BESTQUINEEVER!#BESTQUINEEVER!#]]]]+++++++>>>>>>-
X   XG WPW   SS  X  PW S US WWTLWP  XS  PE
```
Should be fairly easy to crack.
# Unscrambled Code
```
BESTQUINE[ DUP LT +SW +GT +< BESTQUINE#> ]
EVER![ DUP EX+ SW EX- LT +SW +GT +< EVER!#> ]
<BESTQUINE[ DUP LT +SW +GT +< BESTQUINE#> ]> BESTQUINE#
<EVER![ DUP EX+ SW EX- LT +SW +GT +< EVER!#> ]> EVER!#
```
Just the regular quine, but with two subroutines and some more code to swap the strings.
[Answer]
# Vim, 17 bytes
```
<CR>""&(())::::\npps
```
The `<CR>` is Enter (`^M` or `^J`) in the input and an **added** newline in the output. It is **not** the implicit end of file newline (see `:help 'eol'`). The 17 bytes are what is added to an empty buffer. (Newlines in a text editor are weird; let me know if this isn't clear.)
[Answer]
# [><>](//esolangs.org/wiki/Fish), 36 bytes, [Cracked!](/a/99659/41024)
```
!!!'''***+...00002333:::;???dddforrr
```
[Answer]
# Befunge-93, 15 bytes, [Cracked!](/a/99673/8478)
```
:::@#%+-_,<910g
```
[Try it online!](http://befunge.tryitonline.net/)
[Answer]
# Python 2, 105 bytes, [Cracked!](/a/99750/41024)
```
    ######%%%%''(((((((())))))))****--0011::::;;==@@@@@@@@@@[[[[]]]]aaaaaaggggggiiiiiiiinnpprrrrrrrrrtt~~
```
The other one was cracked, so this one is more difficult.
> 
> 
> ```
> print'To find the solution, get to work!'
> ```
> 
> 
> 
> 
[Answer]
## Ruby, 53 bytes - [Cracked](https://codegolf.stackexchange.com/questions/99472/quine-anagrams-robbers-thread/100096#100096)
```
**TEN sTupID,sTupID NET,"TIN"<22"DEN"<<It<DEtINDE\n\n
```
The `\n` are literal newlines.
[Answer]
## [QB64](http://qb64.net), 89 bytes
```
(_+cad:effecs:fact), =+cred:scarf:attaccd?, =+eff4c3d:cars:craccd?, (_+csc:f4c3d:fact), "
```
Some salient points:
* The code will not work in QBasic: it uses QB64-specific features
* Syntax expansion is off
* No dollar signs and only one quotation mark
* "Poetry" would be a stretch, but it does rhyme
[Answer]
# Befunge-93, 24 bytes
I'm afraid this is a bit late, but I wanted to attempt one without the `g` command.
```
<<_:@00278899p,**++###>!
```
[Try it online!](http://befunge.tryitonline.net/)
[Answer]
# [OIL](https://github.com/L3viathan/OIL), 77 bytes, Safe
```
0
0
1
1
1
1
1
1
1
1
1
2
2
4
4
4
6
8
10
11
11
11
12
17
18
18
18
18
22
26
26
32
```
Good luck with that.
Solution, "commented" (remove comments before running or it won't work):
```
0 # nop twice
0
1 # copy element from cell 1 to 1 (so do nothing again)
1
1
4 # print what's in cell 1 (a zero)
1
11 # print a newline
4 # and the same thing again; printing zero and a newline
1
11
1 # copy what's in cell 2 (a 1) into cell 2
2
2
1 # copy what's in cell 12 (two lines before; a 2) into cell 18
12
18
10 # check if the value in the cell of the following line (starting with 2; we'll jump back here)
18 # (this is cell 18)
1 # is equal-ish to the one in cell 1 (a zero)
32 # if yes, jump somewhere
22 # otherwise jump one cell ahead
1 # copy what's currently in cell 18 (first a 2) into cell 26
18
26
4 # print cell 26
26
8 # increment cell 18
18
11 # print a newline
6 # and jump back to cell 17
17
```
So to summarize, it works by first printing two zeros, and then comparing every line starting with the third one with zero, and if it isn't zero, printing it, else exiting (since OIL reads zero from any empty/non-existent cell). Any variable lines contain the value they have when they are printed (since I'm lazy, I obtained this by first making a near-quine where those cells have some arbitrary non-zero value, and using the result, which is a quine).
[Answer]
# [Jelly](//github.com/DennisMitchell/jelly), 3 bytes, [Cracked!](/a/99651/41024)
```
Ṙ”Ṙ
```
[Try it online!](//jelly.tryitonline.net#code=4bmY4oCd4bmY)
Here is the solution:
> 
> What, you want the solution? Find it!
> 
> 
> 
]