[Question]
  [
In [this question](https://codegolf.stackexchange.com/questions/111190/anagram-quines-cops-thread) I asked you to guess an anagram quine based on its output. However it looks like we don't have a question asking to golf an anagram quine yet. So your task will be to make the shortest anagram quine that you can.
### What is an anagram quine?
An anagram quine is a non empty program that prints an anagram of its source code, other than its original source.
Here's an example of an anagram quine in Python 2:
```
print`'`print`*2'*2`
```
You should not read your own source for this challenge.
  
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), 2 bytes
```
)(
```
Outputs
```
()
```
[Try it online!](https://tio.run/##K6gsyfj/X1Pj/38A "Pyth – Try It Online") 
```
)  # Ends statement, does nothing in this program
 ( # Create an empty tuple
   # Implicitly print the empty tuple
```
[Answer]
# [V](https://github.com/DJMcMayhem/V), 4 bytes
```
2ii2
```
Outputs:
```
i2i2
```
[Try it online!](https://tio.run/##K/v/3ygz0@j/fwA "V – Try It Online")
[Answer]
# [><>](https://esolangs.org/wiki/Fish), ~~9~~ ~~8~~ 7 bytes
*Golfed 1 byte thanks to @WheatWizard by using `!` and incrementing it to get `"`*
*Golfed 1 byte thanks to @ConorO'Brien by using `#` instead of `<!`*
```
":1->o#
```
[Try it online!](https://tio.run/##S8sszvj/X8nKUNcuX/n/fwA "><> – Try It Online")
Outputs `"#o>-1:`.
### Explanation
```
":1->o#"        Push this string (note that the IP wraps around)
:               Duplicate the top value of the stack (35 from the "#")
1-              Subtract one from it to get 34 ('"')
>o#             Print every character on the stack until the program cannot pop any more and still tries to pop a value from the stack afterwards
                The program exits with an error from not being able to pop a value from an empty stack
```
[Answer]
# Brainfuck, 158 bytes
```
>>--<<-[[<+>->+>->+++<<<]>-]<<<<<<[--->>.<<]>>++<<<[->>>.<<<]>>-<<<[--->>>.<<<]>>>--<<<<[++>>>>.<<<<]>>>>+++>--.[---<.>]>+.......++.......<<<>>>>>>>>>-----+++
```
[Try it online!](https://tio.run/##PYxRCoVQCEQXJOMKZDYi96OCIB68j6D1m1q3AcE5jrOey/Hfr@0XQQJmcDch2CNiZoMY1nIApBZinzxt@QL4ApN0X0IRvrBp1eZJK2zKQdFHMpcMcgql/Ii4AQ)
It may not be the shortest version, but at least it works.
*Fun fact*, the output code can actually be executed (and it does terminate).
## Output
```
<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>--------------------------++++++++++++++++++<....................[[[[[[[]]]]]]]
```
## Explanation
```
>>--<<-[[<+>->+>->+++<<<]>-]    Initializes the tape with the
                                help of a recurrence relation.
<<<<<<[--->>.<<]>>++<<<[->>>
.<<<]>>-<<<[--->>>.<<<]>>>--    Prints the characters using
<<<<[++>>>>.<<<<]>>>>+++>--.    classic loops.
[---<.>]>+.......++.......
<<<>>>>>>>>>-----+++            Junk to complete the anagram.
```
[Answer]
# Python 3, 32 bytes
```
print("""p"r"i"n"t"2(")*"""*2)
```
Prints `p"r"i"n"t"2(")*p"r"i"n"t"2(")*\n`, sorted output: `\n""""""""""""(())**22iinnpprrtt`
[Answer]
# [Ruby](https://www.ruby-lang.org/), 8 bytes
```
p"p*2"*2
```
[Try it online!](https://tio.run/##KypNqvz/v0CpQMtIScvo/38A "Ruby – Try It Online")
This prints 
```
"p*2p*2"
```
## Explanation
This works similar to the python answer in the question. It will make the string `p*2p*2` then using Ruby's `p` will print the representation of the string.
[Answer]
## JavaScript (ES6), ~~40~~ 32 bytes
```
f=($=`($)=>{$=$+"${"``"}$"}`)=>$+$
```
No messing around with Function.toString either. As a bonus, the code inside the string almost looks legal. Edit: Saved 8 bytes by using `+` instead of `repeat(2)`.
[Answer]
# [Klein](https://github.com/Wheatwizard/Klein), 7 + 6 = 13 bytes
Here's an answer based on the [><> answer](https://codegolf.stackexchange.com/a/125056/56656).
```
":1+@!
```
[Try it online!](https://tio.run/##y85Jzcz7/1/JylDbQZHr////BgYG/3UdAQ "Klein – Try It Online")
This outputs
```
:1+@!"
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt), ~~10~~ 9 bytes
Found a better way :-)
```
Q+2ç"Q+2ç
```
Outputs `"Q+2çQ+2ç`. [Test it online!](http://ethproductions.github.io/japt/?v=1.4.5&code=USsy5yJRKzLn&input=)
### Explanation
```
Q+2ç"Q+2ç    // Implicit: Q = quotation mark
    "Q+2ç    // Take this string.     Q+2ç
  2ç         // Repeat it twice.      Q+2çQ+2ç
Q+           // Prepend a quote.      "Q+2çQ+2ç
             // Implicit: output result of last expression
```
Could also be `Qi2ç"Qi2ç`, which prints `Qi2çQi2ç"`. This one is closer to the standard Japt quine:
```
"iQ ²"iQ ²
```
But I do not believe there is any easy way to wedge the quotation mark in the middle of the string for a 9-byte quine.
[Answer]
## Ruby, 20 bytes
```
$><<%q($><<%q()*2)*2
```
This outputs
```
$><<%q()*2$><<%q()*2
```
Taking advantage of Ruby's `%q(...)` string syntax, which supports nested parentheses.
[Answer]
## [Retina](https://github.com/m-ender/retina), 8 bytes
```
_
$nn$
```
[Try it online!](https://tio.run/##K0otycxL/P@fK56LSyUvT@X/fwA "Retina – Try It Online")
Prints
```
n$_
n$
```
Both contain one `_`, two `n`, two `$` and three linefeeds.
Note that a linefeed followed by almost any other character is a trivial solution, but it's questionable whether it's valid, because the second character only encodes itself and the linefeed doesn't really encode either output character.
## Explanation
```
_
```
Replace the empty input with a `_`.
```
$nn$
```
Match an empty string, which happens both before or after the `_` and insert a linefeed (`$n`), an `n`, and a `$`. Since we first inserted that `_`, this adds each of those characters twice, so the `n` and `$` account for the `$n`, and we get two of the three linefeeds we need in the output. The third linefeed is printed because Retina prints a trailing linefeed by default.
We could also use `n$n$` in this stage, which would then print:
```
n
$_n
$
```
[Answer]
# Python Repl, 4 bytes
This is my first Code Golf solution, so I hope it meets the rules. In the Python 2 or 3 interactive interpreter:
```
>>> (1),
(1,)
```
The output is an anagram of the input.
---
Another:
```
>>> 2*'2*'
'2*2*'
```
In Python 2:
```
>>> type('rst <>'),
(<type 'str'>,)
```
In Python 3:
```
>> {1, 0}
{0, 1}
```
Update 2017-06-15: Yet another:
```
>>> 01.
1.0
```
[Answer]
# [Haskell](https://www.haskell.org/), ~~38~~ 39 bytes
```
main=print$[0,0]>>"main=print$[0,0]>>"
```
[Try it online!](https://tio.run/##y0gszk7Nyfn/PzcxM8@2oCgzr0Ql2kDHINbOTgmLENf//wA "Haskell – Try It Online") Output:
```
"main=print$[0,0]>>main=print$[0,0]>>"
```
Edit: +1 byte because I previously forgot about the implicit trailing newline of `print`.
---
**Alternative:** (Same byte count but does not contain ASCII-owl)
```
main=print$e++e;e="main=print$e++e;e="
```
[Try it online!](https://tio.run/##y0gszk7Nyfn/PzcxM8@2oCgzr0QlVVs71TrVVgmLENf//wA "Haskell – Try It Online")
Output:
```
"main=print$e++e;e=main=print$e++e;e="
```
[Answer]
# Groovy, ~~24~~ 20 bytes
```
{"""{""*""2""}"""*2}
```
*-4 thanks to CalculatorFeline, the whitespace wasn't needed after all!*
# Output:
```
{""*""2""}{""*""2""}
```
# Explanation:
Anonymous closure that, when called, returns `{""*""2""}` two times (concatenated).
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 10 bytes
```
'∞∞''∞'JJ∞
```
[Try it online!](https://tio.run/##MzBNTDJM/f9f/VHHPCBSB9HqXl5A8v9/AA "05AB1E – Try It Online")
# Output:
```
∞∞''JJ''∞∞
```
---
# Explanation:
```
Code       | Explanation                | Stack
-----------+----------------------------+-------------------
'∞         | Push literal '∞'.          | ["∞"]
  ∞        | Mirror.                    | ["∞∞"]
   ''      | Push literal "'".          | ["∞∞","'"]
     ∞     | Mirror.                    | ["∞∞","''"]
      'J   | Push literal 'J'.          | ["∞∞","''","J"]
        J  | Join it all together.      | ["∞∞''J"]
         ∞ | Mirror.                    | ["∞∞''JJ''∞∞"]
-----------+----------------------------+-------------------
           | Implicit print.            | ∞∞''JJ''∞∞
```
[Answer]
## [CJam](https://sourceforge.net/p/cjam), 6 bytes
```
"_`"_`
```
[Try it online!](https://tio.run/##S85KzP3/Xyk@AYj@/wcA "CJam – Try It Online")
Prints
```
_`"_`"
```
### Explanation
```
"_`"   e# Push this string.
_      e# Duplicate.
`      e# Stringify it, which wraps it in quotes.
       e# Implicitly print stack contents.
```
[Answer]
## Bash, 36 bytes
```
tee f<<<'tee f<<<""cat f'"''"
cat f
```
This outputs
```
tee f<<<""cat f''
tee f<<<""cat f''
```
(and creates the file `f` as a side effect, but that's allowed [per meta](https://codegolf.meta.stackexchange.com/q/8871/3808).)
Both the program and output have a trailing newline.
Thought process: I figured that the easiest way to output a string two times, aside from assigning it to a variable, was to do
```
tee f<<<string
cat f
```
The string needs to be quoted because it will contain spaces and `<` characters, so then I had
```
tee f<<<'tee f<<<cat f'
cat f
```
which almost works, except it doesn't output the quotes. Fortunately, Bash supports string literal concatenation by simply placing them next to each other, so appending `"''"` to the herestring and inserting `""` inside the single quote part yields this solution.
[Answer]
# [PHP](https://php.net/), 44 bytes
```
<?=str_repeat('<?=\str_\repeat(\'\',2);',2);
```
[Try it online!](https://tio.run/##K8go@P/fxt62uKQovii1IDWxREMdyI0B8WOgAjHqMeo6RprWYOL//695@brJickZqQA "PHP – Try It Online")
[Answer]
# [CJam](https://sourceforge.net/p/cjam), 8 bytes
```
"2*`"2*`
```
[Try it online!](https://tio.run/##S85KzP3/X8lIKwGE//8HAA "CJam – Try It Online")
### Explanation
Similar to the Python example in the question
```
"2*`"     e# Push the string "2*`"
     2*   e# Repeat it twice
       `  e# Get its string representation (wrap in quotes)
```
The output is `"2*`2*`"`.
[Answer]
# Befunge, 11 bytes
```
' 2+">:#,_@
```
Prints:
```
+2 '@_,#:>"
```
Explanation:
```
' 2+"        Put a " on the stack (32 + 2)
    "        Put the rest of the code on stack (wrap-around string)
     >:#,_   Print stack
          @  End
```
[Answer]
# [QBIC](https://drive.google.com/drive/folders/0B0R1Jgqp8Gg4cVJCZkRkdEthZDQ), 8 bytes
```
?A+@?A@+
```
I [just figured out](https://codegolf.stackexchange.com/a/125089/44874) how to do a proper quine in QBIC. Making an anagram out of it is done by simply switching around the characters in the string literal. There are 24 possible anagrams this way.
[Answer]
# [Befunge-98](https://github.com/catseye/FBBI), 8 bytes
```
"'$<@,k7
```
[Try it online!](https://tio.run/##S0pNK81LT9W1tPj/X0ldxcZBJ9v8/38A "Befunge-98 – Try It Online")
[Answer]
# [Ohm](https://github.com/MiningPotatoes/Ohm), 14 bytes
```
"æ3M.Cæ"æ3M."C
```
[Try it online!](https://tio.run/##y8/I/f9f6fAyY18958PLIAwl5///AQ "Ohm – Try It Online")
Output:
```
æ3M.CæC.M3æ"""
```
### Explanation
```
"æ3M.Cæ"æ3M."C
"æ3M.Cæ"       # Pushes "æ3M.Cæ"
        æ      # Palindrone of that string
         3M    # 3 times...
           ."   # Push " on the stack
             C  # Concatenate with the string above
```
[Answer]
# JavaScript (ES6), 15 bytes
```
f=(s='f=')=>f+s
```
**Outputs:**
```
(s='f=')=>f+sf= 
```
**Snippet:**
```
f=(s='f=')=>f+s
console.log(f());
```
[Answer]
# [Fission 2](https://github.com/C0deH4cker/Fission), ~~9 8~~ 6 bytes
```
R"'!+O
```
[Try it online!](https://tio.run/##S8ssLs7MzzP6/z9ISV1R2///fwA "Fission 2 – Try It Online")
# Explanation
An atom is created at `R`, which moves right. This atom then comes across a `"`, which starts printing mode. In printing mode, all characters (until the matching `"`) are printed. This means it prints `'!+OR` in this case. Then, all that is left is printing `"`, which is done by the remaining characters. `'!` sets the atom's mass to the character code of `!`, and `+` increments it to the character code of `"`. Then, the character code is output by `O` and the atom is destroyed, ending the program.
(Actually, this is just a rotation of the shortest quine)
[Answer]
# Mathematica, 2 bytes
```
.0
```
Output:
```
0.
```
A number starting with a decimal point such as `.123` is interpreted as `0.123`, so `.0` is interpreted as `0.0`. Since the part of the number after the decimal point is zero, Mathematica does not print it.
[Answer]
# JavaScript (yet another one), 11 bytes
```
f=_=>'=f'+f
```
Called with `f()`, outputs
```
=f_=>'=f'+f
```
```
f=_=>'=f'+f
console.log(f());
```
[Answer]
Python 3, 31 bytes
```
a='a=%r;pritn(a%%a)';print(a%a)
```
[Answer]
# [Stax](https://github.com/tomtheisen/stax), ~~8~~ 4 bytes
```
.S.S
```
[Run and debug online!](https://staxlang.xyz/#c=.S.S&i=&a=1)
A direct port of [this answer](https://codegolf.stackexchange.com/questions/69/golf-you-a-quine-for-great-good/156643#156643).
Old version, 8 bytes
```
..b..LbL
```
[Run and debug online!](https://staxlang.xyz/#c=..b..LbL&a=1)
Alternative version with a pretty cheap trick that can be applied to proper quines in almost any language.
```
"43bL"34bL
```
[Run and debug online!](https://staxlang.xyz/#c=%2243bL%2234bL&a=1)
Because `"34bL"34bL` is a proper quine in Stax.
Yet another version, using only single-char string literals.
```
''c'Lc'cccLcLL
```
[Run and debug online!](https://staxlang.xyz/#c=%27%27c%27Lc%27cccLcLL&i=&a=1)
## Explanation
```
.S.S        Generates powerset ["","S","S.","."]
            Implicit flatten and output
..b         Push string ".b"
   ..L      Push string ".L"
      b     Duplicate both strings
       L    Concatenate all 4 strings to a single one.
```
[Answer]
## [W](https://github.com/A-ee/w), 2 bytes
```
1-
```
## Explanation
```
a   % (Implicit) argument of the input
    % The input is automatically set to 0
    % if it isn't specified
 1- % Minus 1 over the input (i.e. 0-1 = -1)
```
Output:
```
-1
```
]