[Question]
  [
> 
> **Note**: This challenge is now closed to new cop submissions. This is to ensure that no one can post submissions that only remain uncracked because there aren't enough robbers interested in the challenge anymore.
> 
> 
> 
In this game of cops-and-robbers, each cop will write a simple program to give a single output. They will then make public four things about their program:
1. The language
2. The program length
3. The desired output
4. A scrambled-up version of the source code
Then, the robbers must unscramble the source code so that their program functions like the original.
---
# Cop Rules
You are to write a simple program, which the robbers will try to recreate.
Your original program must have a simple functionality: upon execution, it outputs a single string/number and halts. It should give the same output regardless of when/where it is run, and should not depend on extra libraries or the internet.
Your program and output must use printable ASCII (newlines and spaces allowed). The output should be no more than 100 characters long, and the program should take less than about 5 seconds to run on a reasonable machine. You are also not allowed to use hashing (or other cryptographic functions) in your program
Then, you provide a scrambled-up version of the source code and the required output. You can scramble up your source code however you may like, as long as characters are conserved.
Your score is the shortest program you have submitted which hasn't been cracked. After a period of one week, an uncracked submission will become immune. In order to claim this immunity, you should edit your answer to show the correct answer. (Clarification: Until you reveal the answer, you are not immune and can still be cracked.) The lowest score wins.
## Simple Example Cop Answers
> 
> Perl, 20
> 
> 
> `ellir"lnto Wo d";prH`
> 
> 
> `Hello World`
> 
> 
> 
Or...
> 
> Perl, 15
> 
> 
> `*3i)xp3rn3*x3t(`
> 
> 
> `272727`
> 
> 
> 
# Robber Rules
**Robbers will post their cracking attempts as answers in a separate thread, located [here](https://codegolf.stackexchange.com/questions/40935/unscramble-the-source-code-robber-thread-for-cracking-attempts).**
You have one attempt at cracking each submission. Your cracking attempt will be an unscrambled version of the source code. If your guess matches the description (same characters, output, and of course language), and you are the first correct guess, then you win a point. It is important to note that your program does not have to exactly match the original, simply use the same characters and have the same functionality. This means there could be more than one correct answer.
The robber with the most points (successful cracks) wins.
## Simple Example Robber Answers
> 
> Your program was `print "Hello World";`. (Although `print"Hello World" ;` could have also worked.)
> 
> 
> Your program was `print(3**3x3)x3`
> 
> 
> 
# Safe Submissions
1. [ASP/ASP.Net, 14 (Jamie Barker)](https://codegolf.stackexchange.com/a/44309/35813)
2. [Befunge-98, 15 (FireFly)](https://codegolf.stackexchange.com/a/41384/3918)
3. [GolfScript, 16 (Peter Taylor)](https://codegolf.stackexchange.com/a/41152/194)
4. [CJam, 19 (DLosc)](https://codegolf.stackexchange.com/a/41624/16766)
5. [GolfScript, 20 (user23013)](https://codegolf.stackexchange.com/a/41358/25180)
6. [Perl, 21 (primo)](https://codegolf.stackexchange.com/a/41696/)
7. [Python, 23 (mbomb007)](https://codegolf.stackexchange.com/a/43221)
8. [Ruby, 27 (histocrat)](https://codegolf.stackexchange.com/a/41896/25180)
9. [SAS, 28 (ConMan)](https://codegolf.stackexchange.com/a/41356/25180)
10. [Ruby, 29 (histocrat)](https://codegolf.stackexchange.com/a/41622/8478)
11. [Python, 30 (mbomb007)](https://codegolf.stackexchange.com/a/44514)
12. [JavaScript, 31 (hsl)](https://codegolf.stackexchange.com/a/43142/29750)
13. [Ruby, 33 (histocrat)](https://codegolf.stackexchange.com/a/41444/3918)
14. [Marbelous, 37 (es1024)](https://codegolf.stackexchange.com/a/41124/29611)
15. [Ruby, 43 (histocrat)](https://codegolf.stackexchange.com/a/41271/8478)
16. [PHP, 44 (kenorb)](https://codegolf.stackexchange.com/a/41169/8478)
17. [Ruby, 45 (histocrat)](https://codegolf.stackexchange.com/a/41269/8478)
18. [Marbelous, 45 (es1024)](https://codegolf.stackexchange.com/a/41008/29611)
19. [Python 2, 45 (Emil)](https://codegolf.stackexchange.com/a/41652/25180)
20. [PHP, 46 (Ismael Miguel)](https://codegolf.stackexchange.com/a/41295/8478)
21. [Haskell, 48 (nooodl)](https://codegolf.stackexchange.com/a/41261/8478)
22. [Python, 51 (DLosc)](https://codegolf.stackexchange.com/a/41391/8478)
23. [Python, 60 (Sp3000)](https://codegolf.stackexchange.com/a/41277/21487)
24. [Python 2, 62 (muddyfish)](https://codegolf.stackexchange.com/a/41544/25180)
25. [JavaScript, 68 (Jamie Barker)](https://codegolf.stackexchange.com/a/44296/35813)
26. [Mathematica, 73 (Arcinde)](https://codegolf.stackexchange.com/a/41397/8478)
27. [Haskell, 77 (proudhaskeller)](https://codegolf.stackexchange.com/a/41188/20370)
28. [Python, 90 (DLosc)](https://codegolf.stackexchange.com/a/41312/8478)
29. [C++, 104 (user23013)](https://codegolf.stackexchange.com/a/41138/8478)
30. [ECMAScript 6, 116 (Mateon1)](https://codegolf.stackexchange.com/a/41129/30544)
31. [C++11, 121 (es1024)](https://codegolf.stackexchange.com/a/41216/29611)
32. [Grass, 134 (user23013)](https://codegolf.stackexchange.com/a/41032/8478)
33. [PowerShell, 182 (christopherw)](https://codegolf.stackexchange.com/a/41041/21838)
# Unsolved Submissions
In order of time of posting. This list courtesy of many users.
* [CoffeeScript, 96 (soktinpk)](https://codegolf.stackexchange.com/a/40980/29611)
* [Python 3, 70 (Sp3000)](https://codegolf.stackexchange.com/a/40989/29611)
* [TinyMUSH 3.1, 20 (Muqo)](https://codegolf.stackexchange.com/a/40992/29611)
* [GolfScript, 32 (Beta Decay)](https://codegolf.stackexchange.com/a/41055/30525)
* [Python 2, 101 (Mateon1)](https://codegolf.stackexchange.com/a/41098/29611)
* [Lua, 49 (ChipperNickel)](https://codegolf.stackexchange.com/a/41117/29611)
* [Python, 61 (imallett)](https://codegolf.stackexchange.com/a/41215/8478)
* [Java 6+, 218 (nhahtdh)](https://codegolf.stackexchange.com/a/41228/8478)
* [CJam, 51 (Martin Büttner)](https://codegolf.stackexchange.com/a/41231/8478)
* [J, 22 (FireFly)](https://codegolf.stackexchange.com/a/41287/8478)
* [Marbelous, 106 (es1024)](https://codegolf.stackexchange.com/a/41322/29611)
* [Marbelous, 107 (es1024)](https://codegolf.stackexchange.com/a/41348/29611)
* [JavaScript, 79 (FireFly)](https://codegolf.stackexchange.com/a/41445/3918)
* [CJam, 47 (user23013)](https://codegolf.stackexchange.com/a/41447/3918)
* [Rust, 118 + Clojure, 106 + others (Vi.) - version 2](https://codegolf.stackexchange.com/a/41481/7773)
* [Marbelous, 144 (es1024)](https://codegolf.stackexchange.com/a/41494/29611)
* [Python 2, 80 (MrWonderful)](https://codegolf.stackexchange.com/a/41520/25180)
* [Perl, 53 (DLosc)](https://codegolf.stackexchange.com/a/41521/25180)
* [Perl, 26 (primo)](https://codegolf.stackexchange.com/a/41540)
* [Mathematica, 31 (Arcinde)](https://codegolf.stackexchange.com/a/41557/25180)
* [Marbelous, 144 (es1024)](https://codegolf.stackexchange.com/a/41560/29611)
* [Assembly, 78 (krzygorz)](https://codegolf.stackexchange.com/a/41654/25180)
* [J, 14 (algorithmshark)](https://codegolf.stackexchange.com/a/41956/5138)
* [Java 8, 157 (TheBestOne)](https://codegolf.stackexchange.com/a/43186/32700)
## A small tool to verify solutions, courtesy of n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳
```
$(function(){function e(){var e=$("#ignore-space").is(":checked");var t=$("#source").val().split("").sort();var n=$("#editor").val().split("").sort();var r,i=0;for(r=0;r<t.length;){if(t[r]==n[i]){t.splice(r,1);n.splice(i,1)}else if(t[r]>n[i]){i++}else{r++}}$("#display").val(t.join(""));n=n.join("");if(e){n=n.replace(/[\r\n\t ]/g,"")}if(n.length!=0){$("#status").addClass("bad").removeClass("good").text("Exceeded quota: "+n)}else{$("#status").addClass("good").removeClass("bad").text("OK")}}$("#source, #editor").on("keyup",function(){e()});$("#ignore-space").on("click",function(){e()});e()})
```
```
textarea{width:100%;border:thin solid emboss}#status{width:auto;border:thin solid;padding:.5em;margin:.5em 0}.bad{background-color:#FFF0F0;color:#E00}.good{background-color:#F0FFF0;color:#2C2}
```
```
<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.11.1/jquery.min.js"></script>
<h3>Scrambled Source</h3>
<textarea id="source" class="content" rows="10"></textarea>
<h3>Unused Characters</h3>
<textarea id="display" class="content" rows="10" readonly></textarea>
<h3>Your Solution</h3>
<input type="checkbox" id="ignore-space" name="ignore-space"/>
<label for="ignore-space">Ignore space characters</label>
<div id="status" class="good">OK</div>
<textarea id="editor" class="content" rows="10"></textarea>
```
  
[Answer]
## Python 3, size 74 ([Cracked](https://codegolf.stackexchange.com/a/41194/20260))
Python just wasn't the same after being re-educated by Big Brother.
**Input:**
```
print(war is peace)
print(freedom is slavery)
print(ignorance is strength)
```
There are two newlines at the end of lines 1 and 2.
**Output:**
```
True
True
True
```
Note that each `True` is in its own line.
[Answer]
## Python 3, size 12 ([Cracked](https://codegolf.stackexchange.com/a/40942/20260))
```
print (abcd)
```
My program produces no output and no errors.
[Answer]
# CJam, size 20 ([Cracked](https://codegolf.stackexchange.com/a/41122/8478))
## Code
```
"Stop, Hammer time!"
```
## Output
```
2.956177636986737
```
[Answer]
# Python 2, size 50
### [Cracked](https://codegolf.stackexchange.com/a/40940/14215)
*We already know the Answer to the Question, but what's the Question?*
### Code
```
print *********************--///222222222222222222
```
Note that there are no trailing spaces or newlines. The only whitespace character is the single space after `print`.
### Output
```
42
```
I've attempted to balance code length and difficulty, but it wouldn't surprise me if I missed it a bit either way. Hopefully it's enough to discourage brute force, at least.
[Answer]
## [Pyth](https://github.com/isaacg1/pyth) - 71 [Cracked](https://codegolf.stackexchange.com/a/41123/31625)
### Code
```
C-3P0: "Sir, the possibility,..."* 
Han Solo: "Never Tell Me The Odds!"
```
### Output
```
3720
```
---
\*Originally, George Lucas had Han interrupt C3-PO.\*\*
\*\*He called this his greatest idea since Jar-Jar.
---
Interesting note: despite all the changes that Pyth has gone through, there is still a valid answer here!
---
### Original
> 
>  `ts,*s,y30 l" : : i i Han Solo "eP-C"h"TsrhT`
> 
> 
> 
### Explanation
> 
>  The remaining characters go on the next line. Pyth only interprets the first line of a file.  
>   
> `ts,` make a 2-tuple and get their sum -1.  
> `*` multiply:  
> `s,y30 l"..."` sum the 2-tuple containing 2\*30 and the length of the string (18).  
> `eP-C"h"T` get the largest prime factor of h's ascii value minus 10 (47).  
> `srhT` get the sum of numbers from 0-10.  
>   
> All in all, this basically just computes: (30\*2+18)\*(47)+55-1. After reading @isaacg's answer I noticed there is an extremely simple solution: `*h30tC"y"` which is 31\*120.
> 
> 
> 
### Updated
> 
>  `*h30tC"y" "-P:Sir, e possibilit,...`  
> `Han Solo: Never Tell Me The Odds!"`  
> Still works even after all this time...
> 
> 
> 
Sorry for poor explanation formatting, I don't know how to use spoiler blocks :S (@Sp3000 made it a bit nicer for you, though)
Now you can run Pyth online! [Try it here.](https://pyth.herokuapp.com/?code=%2ah30tC%22y%22+%22-P%3ASir%2C+e+possibilit%2C...%0AHan+Solo%3A+Never+Tell+Me+The+Odds%21%22&debug=0) Thanks @isaacg :)
[Answer]
# CJam, size 51 [SAFE]
## Code
```
main(int argc,char* argv){printf("Hello, World!");}
```
## Output
```
55
2292213229222231957511222223333751125537511222222135723331131931959319319
```
You can play around with it [in the online interpreter](http://cjam.aditsu.net/).
This should be more crackable than it looks.
### Hint
> 
>  Start with the second line of the output. A few digits don't appear in it all, and others suspiciously often. Why could that be? If you can decipher that, the rest should almost fall in place.
> 
> 
> 
### Solution
> 
>  `"that rrrrraging london Hail!v"{elccimf(;W))},(*,pa`  
> 
>   
> 
>  The weather must have been pretty bad when I came up with that anagram...  
> 
>   
> 
>  The hint was supposed to point towards the fact that the second line is made up of squashed-together prime factorisations. I was hoping that from there it would be possible to determine how many and which characters go into the string, leaving only a few characters at the end.
> 
> 
> 
[Answer]
## Befunge-98, size 15 [SAFE]
### Code
```
"quick"
*+.@\_j
```
### Output
```
3314
```
### Original
> 
> 
> ```
> "u_ji@q.+k*c
> "
> ```
> 
>  A curious but somewhat well-known feature of Befunge is that you can terminate a string with the same quote that begins it, which in essence pushes that entire line (except the quote) on the stack. As an extra trick, I re-use the same string *again*, by making use of `u` to reverse the instruction pointer. Then it's just some arithmetic: the core idea is to sum up all those values (which is done using `k` to repeat the `+` operation).
> 
> 
> 
[Answer]
## GolfScript (16 bytes) [SAFE]
```
%%()*../1129n{}~
```
Expected output:
```
-117345085515973157874551915956356303213327583847247840186528288852476459638212404362749
```
Original source:
> 
>  `n)~{.*911%(}./2%`
> 
> 
> 
[Answer]
# Ruby, 17 ([Cracked](https://codegolf.stackexchange.com/questions/40935/unscramble-the-source-code-robber-thread-for-cracking-attempts/41082#41082))
Going for something really short this time.
```
inprt N=2,*'~~~%'
```
Output:
```
2
2
```
[Answer]
# Python, 69 chars [[cracked by grc](https://codegolf.stackexchange.com/a/41040/21487)]
Scrambled:
```
((((((((((((())))))))))))),,,,accdddiiiiillmmnopprrrrrssssssttttttttu
```
Output:
```
1083
```
This one's just a harmless bit of fun :) Tested on CPython 2.7.8, 3.3.2 and for the heck of it PyPy3 2.3.1.
---
## Explanation
> 
>  Uses built-in functions `str`, `dict`, `list` to build up a string and then applies `map` with `ord` to convert the string to a list of ints, which are then `sum`med.
> 
> 
> 
[Answer]
# Python, size 56 ([cracked](https://codegolf.stackexchange.com/a/40973/16618))
## Code
`for i in "iprint()".join(([2,3,7,0,9,chr((-7+732^70)])))`
## Output
`hi mom`
[Answer]
# Python 3, 70 chars
Scrambled:
```
""(((())))****++++222222222;;;;;=======cccccccccceeeiinnpprrttxxxxxxxx
```
Output (99 chars long):
```
388626024960000000000026872002432000000000000676169243200000000000007317718780000000000000028820330
```
---
## Update
It's been a week, so rather than posting the answer, here's a hint:
> 
>  Try taking the square root of the number and working from there
> 
> 
> 
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), 11
```
\\,,"$: Ndw
```
### Output:
```
",input(),"
```
[Answer]
# JavaScript, 94 [Cracked by FireFly](https://codegolf.stackexchange.com/a/41364/32628)
```
alert(' '' '''((()))+++,,,,,,,,,,,,,000111111114444577888;;;;;======[[[]]]aaafhinorrrrvvvxx||)
```
## Output
```
fun in the sun
```
## Original
> 
> `a=alert;v='';r=[1,7,8,14,11,8,14,10,0,5,14,4,7,8];for(x in r)v+=('h'+(1==0)+a)[r[x]]||'';a(v);`
> 
> 
> 
[Answer]
# Ruby, 38 - [cracked by Martin Büttner](https://codegolf.stackexchange.com/a/41301/3808)
```
print(succ(downcase!))$$$..[[]]6e0<><_
```
Output:
```
u
```
Original:
> 
>  `$6.pincdwnca[]rescue$><<$!.to_s[((0))]`
> 
> 
> 
[Answer]
# Python 3, size 16 ([Cracked](https://codegolf.stackexchange.com/a/40946/30630))
Code:
```
help tim__rolo__
```
Output (with newline at end):
```
Hello world!
```
[Answer]
# Perl - 47 ([cracked by grc](https://codegolf.stackexchange.com/a/41015/29438))
Code (there is one space in there too)
```
 """"$$$$$$((()))**....///;;[[]]~==01finoprrstx
```
Output:
```
012345012345012345012345012345
```
You can run it online [here](http://www.compileonline.com/execute_perl_online.php) and it does work under `strict` and `warnings`.
[Answer]
# Ruby, 33 - [cracked by user23013](https://codegolf.stackexchange.com/a/41248/3808)
```
enpsttux [[[]]]++\-\**????$$$$...
```
Output:
```
[*]
```
Original:
> 
>  `puts ?[+[*?*..?]][$$-$$]+?\\.next`
> 
> 
> 
[Answer]
## Python2, 132 characters
```
____        ,,,,:::''""""""""""((()))[[]]\\\0126aaaabcccceeeeeeeeeEffggiiiiiilllllmmmmnnnnnnooooopppppqqrrrrrrrrrssssStttttttuuvxxyy
```
Output (with a newline):
```
chance
```
## Updated version, 96 characters
Answer to original version suggested the `exec` instead of `compile`+`eval`, so here is a simplified version:
```
____       :::''""(())[[]]\\\0126aaabcccceeeeeeeeEffiimmnnnnooopppqqrrrrrrrrrssStttttttuuxxxxyy
```
## Update: cracked
Fully cracked by [Alex Van Liew](https://codegolf.stackexchange.com/a/41451/7773) and [KennyTM](https://codegolf.stackexchange.com/a/41446/7773). The original solutions were (scroll right to reveal the spoiler):
```
                                                                                                                                eval(compile('try: compile("from __future__ import braces","","single")\nexcept SyntaxError as q:\n\tprint q[0][6:12]',"","single"))
                                                                                                                                exec('try:exec("from __future__ import braces")\nexcept SyntaxError as q:\n\tprint q[0][6:12]')
                                                                                                                                The hint meant "Consider {}, which are not present in the source code".
```
[Answer]
# Ruby, 29 [safe]
Trying to see how short I can get in Ruby without getting cracked.
**Code**
```
paper view
otool
$()**,.8<<=>
```
**Output**
```
[0][0, 3][0, 3, 6][0, 3, 6, 9][0, 3, 6, 9, 12][0, 3, 6, 9, 12, 16][0, 3, 6, 9, 12, 16, 20]
```
**Original**
> 
> `eval <<p*8
>  o=*o,$>.write(o)
>  p`
> 
> 
> 
**Explanation**
> 
>  The first line creates a heredoc that starts on the next line and is delimited by the trailing `p`, then concatenates the resulting string to itself 8 times. Since it ends in a newline, this effectively creates a loop. The looped code assigns an array to the variable `o`, consisting of the elements in `o.to_a` (via the `*` shorthand), followed by the output of `$<.write(o)`, which converts `o` to a string, prints it to STDOUT, and returns the number of bytes printed. A variable being assigned to for the first time is `nil` for the purpose of evaluating the right hand side, so on the first run `*o` is empty and write outputs nothing and returns 0. Each subsequent round outputs the array of bytes output on previous rounds. Using a p-delimited heredoc creates decoy methods for output, `p` and `$><<`, in the scrambled characters, that won't work because you need the bytecount.
> 
> 
> 
[Answer]
# PHP, size 49 [[Cracked by Martin Büttner](https://codegolf.stackexchange.com/a/41115/8478)]
## Code
```
sub(print2w, $+expect+$+one+$+str+$+in=$@~main$);
```
## Output
```
{main}
```
[Answer]
# MATLAB, 41 bytes
### Cracked by [feersum](https://codegolf.stackexchange.com/a/41131/31019)
```
((((((snowy leopards can like magic))))))
```
### Output
```
1
```
[Answer]
# Perl, 36 [← cracked by grc](https://codegolf.stackexchange.com/a/41137/4020)
## Code
```
$$$()++..112279;;<<=__ffiinooprrrt{}
```
## Output
```
perl
```
[Tested here](http://www.compileonline.com/execute_perl_online.php)
[Answer]
# Haskell, 100 Chars (Invalid, output too long)
## Code
```
//Sup
tl=[]
while(syn==(+j)) tl+=b.a();
//(: #jquery :)\\
$("#jquery").on("click", j=>alert(j==m))
```
## Output:
`"\er\\e\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\"\\\\\\\\\\\\\\\\\\\\\\\\\\"\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\"\\\\\\\\\\\\"\\\\\\\\\\\\\"\\\\\\\`
---
## Original
```
(#)=(>);(//)=(++)
l=j.show
main=putStr.l.l$l"eer"
j[]="\\"
j(y:u)=let(q,c)=break(#y)u in y:j c//j q
```
[Answer]
## J, 22 bytes
### Code
```
!%()1348:::bbceehorvxx
```
### Output (97 chars)
```
1226317306651180983274420265228191056569220222873505571155987454033425908908110103433163350999040
```
I expect this to be practically impossible...
[Answer]
# CJam, 32 bytes ([cracked](https://codegolf.stackexchange.com/a/41148/25180))
### Scrambled source
```
"Beware the Jabberwock, my son!"
```
### Output
```
4074552392882954617076720538102062920
```
[Answer]
## [Pyth](https://github.com/isaacg1/pyth) - 35 - [Cracked](https://codegolf.stackexchange.com/a/41206/31625)
In the spirit of @MartinBüttner:
### Code
```
"Programming Puzzles and Code Golf"
```
### Output
```
4.459431618637297
```
[Try to decode it online here.](http://isaacg.scripts.mit.edu/pyth/index.py)
[Answer]
## [TinyMUSH 3.1](http://www.tinymush.net/index.php/Main_Page), 20
Scrambled:
```
(#ret,#3!#+#2i\2#,@)
```
Output:
```
3210
```
[Answer]
# Python 3, length 110 [[cracked by grc](https://codegolf.stackexchange.com/a/41142/4020)]
Scrambled (`\n` denotes a newline)
```
\n\n\n   ""((((())))),.......9::;===IOS[]__addeeegghiiiiiiiiijllmmnnoooooooppprrrrsssssssssstttttttttttuuuuuvwyyy
```
Output:
```
The better is Flat dense. break never of be do at never. If bad it honking
```
Here's another fun one - not meant to be hard, but just something unusual and puzzly. :)
---
## Explanation
> 
>  The random-looking words are taken from the [Zen of Python](http://legacy.python.org/dev/peps/pep-0020/) (PEP 20), which is automatically printed via the easter egg `import this`. The passage is just every ninth word, as hinted by the `9::[]` present.  
> 
>  To extract every ninth word without automatically printing the passage when importing, we redirect `sys.stdout` to a `StringIO()`.
> 
> 
> 
[Answer]
# Javascript, 29 - Cracked
*Run in a Chrome browser console*
### Code
```
23*47,(no,(.][j,i|i,j][.),on)
```
### Output
```
181
```
### Original code
> 
>  `[,,,].join(3)|[,4,].join(7)*2`
> 
> 
> 
]