[Question]
  [
This is the cops' thread. The robbers' thread [goes here](https://codegolf.stackexchange.com/questions/67757/printing-ascending-ascii-robbers).
Write a program or function consisting only of **printable ASCII characters** (that excludes tab and newline) that outputs at least 5 printable ASCII characters in ascending order (from space to tilde / 32 to 126). Characters can be outputted several times, as long as they are adjacent to each other. A single trailing newline is accepted. You must provide the full output, and for every 6 characters in your code you must provide one character in your code, at the position it appears. If your code has 5 or less characters, then you have to reveal only the length. You shall not reveal more than 1 character per 6 in your code.
So if your code `alphaprinter` outputs the alphabet from a-z, then you need to reveal 2 characters of your code (use underscore for the others), for instance:
```
al__________  // or
__p__p______  // or
__________er
```
Rules / specifications:
* You cannot append trailing white spaces that doesn't have a function.
* You can not use comments (but the robbers can use comments when cracking the code)
* Built-in cryptographic primitives (includes any rng, encryption, decryption, and hash) aren't allowed.
* In languages where the **default** output are like in MATLAB: `ans =`, then that's accepted, as long as it's **clearly stated** and shown that `ans =` is outputted. It should also be clearly stated whether this is part of the "ascending output" or not.
* The output must be deterministic
* Using a non-free language [is not accepted](http://meta.codegolf.stackexchange.com/questions/1061/loopholes-that-are-forbidden-by-default/7212#7212)
* The output doesn't have to be consecutive characters. Both `abcde` and `abcdg` are valid outputs.
* The characters do not need to be distinct as long as the output contains at least 5 characters. `aaaaa` and `aaacc` are valid.
* Answers that assumes a REPL environment are not considered to be valid programs or functions and are therefore not allowed.
* STDERR is not considered valid output, but data may written to STDERR.
If the revealed characters are underscores, then you must identify it as shown below. 
In this case, the second and sixth character are revealed underscores, while the others are unknown. 
```
_____________
 |   |
```
**Note:** The robbers only need to find a code that produces the same output. The language, the length of the robbers solution, and the position of the revealed characters must also match.
Your score is the number of characters in your code. The winner will be the submission with the lowest score that hasn't been cracked in 7 days. 
Only submissions that are posted in 2015 (UTC) are eligible for the win. Submissions that are posted later than this are welcome, but can not win.
In order to claim the win you need to reveal the full code (after 7 days).
Your post should be formatted like this (nn is the number of characters):
---
# Language, nn characters
Output:
```
abcdefghijklmnopqrstuvwxyz
```
Code (12 characters):
```
al__________
```
---
If the code is cracked, insert [Cracked](link to cracker) in the header.
If the submission is safe, insert "Safe" in the header and reveal the full code in your answer. Only answers that have revealed the full code will be eligible for the win. 
  
[Answer]
## Perl, 46 characters (safe)
Output:
```
((()))*++,---../00011123445556667779::;;<<==??@@AAACEFGHHHIKKMMNOOOPPQQQRRSSSVWXXYY[[[\]]]^^^```aaeeffggghjjjnpppqqrttuwxxyzz{{{
```
Code:
```
print _______________________________________;
```
I somehow managed to delete the original in the space of a week, but I think this is right:
> 
>  `print chr()x(($i=($i*41+7)%97)&3)for(40..123);`
> 
> 
> 
[Answer]
# Brainfuck, 48 characters, [cracked](https://codegolf.stackexchange.com/a/67823/34388) by Mitch Schwartz
I made this one for the robbers. It is definitely not going to be the winning submission :)
```
____[_____[_______]__]___[___________]___[_____]
```
This outputs:
```
ABCDEFGHIJKLMNOPQRSTUVWXYZ
```
**Solution:**
> 
>  `++++[>++++[>++++<-]<-]+++[>++++++++<-]>++[>+.<-]`
> 
> 
> 
I tested it [here](https://copy.sh/brainfuck/).
**Hint:** Don't try to find programs generated by online generators haha. This was handwritten and can only be solved by logical thinking :)
[Answer]
## CJam, 13 characters
```
_____________
  ||
```
prints
```
7LLMYahnsuv
```
You can [try CJam online.](http://cjam.tryitonline.net/)
### Solution
```
{`__Jf^er$}_~
```
I thought basing a cop on a generalised quine was pretty clever and novel. The moment I posted this, I realised that `__` and `er` are completely useless, which is why I posted the 8-byte CJam cop for a more competitive score. Pietu cracked that one rather quickly, so I was afraid he'd figure out this one as well. I suppose the unnecessarily convoluted character transliteration saved it.
Anyway, the code takes its own characters (except the `_~`), XORs each one with 19 for obfuscation and then sorts them.
This cop led me to the "discovery" of [xorting](https://codegolf.stackexchange.com/q/68109/8478), although I'm not actually using it here (and it would probably be near impossible to make use of it with a short generalised quine).
[Answer]
## [Noisy 3SP](http://esolangs.org/wiki/Three_Star_Programmer#Variants), 89 characters (safe)
```
0 _____________________________ _ _ _ _ _ _ _ _ _ __2_2__________________________________
```
Original program:
```
0 0 0 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 0 3 2 2 2 2 0 3 0 1
```
This program prints 
```
 !"#$$
```
(note the leading space), and *nothing else!*
Explanation (\*n refers to the nth cell in memory):
```
0 0 0                                Increment *0 to 3 (via the 0s in *0, *1, and *2)
2 (32 times)                         Increment *3 to 32 (via the 0 in *2 and the 3 in *0)
                                      (Note that *3 mod 256 is the character that prints)
0                                    Increment *32 (via the 3 in *0 and the 32 in *3)
3                                    Increment *1 (via the 32 in *3 and the 1 in *32)
                                      (Note that printing is on when *1 mod 2 is 1,
                                       which means " " prints right here)
2 (4 times)                          Increment *3 to 36 (printing '!"#$')
0                                    Increment *36 (via *3) (printing "$" again)
3                                    Increment *1 to 2 (via *36) (printing turns off)
0                                    Increment *36 to 2 (via *3)
1                                    Increment *0 to 4 (via *2)
```
The last two commands turn out to be sufficient to prevent 1 from ever being incremented again on subsequent passes through the program, which means nothing is ever again printed, though it will go on setting all memory addresses from \*36 onward to the value 36 forever.
[Answer]
## [Hexagony](https://github.com/mbuettner/hexagony), 8 characters, safe
```
_______.
```
prints
```
123456
```
You can [try Hexagony online](http://hexagony.tryitonline.net/)
### Solution
```
`&)!."@.
```
The ``` is just misdirection to make the code look like it requires side-length 3. Unless the interpreter is executed with `-d` the backtick is simply stripped from the source code before determining the layout. Afterwards, the code fits into side-length 2:
```
 & )
! . "
 @ .
```
This moves the memory pointer (MP) around one hexagon of the memory grid, while copying the value to the next edge, incrementing it and printing it.
This is what the memory grid looks like, with the MP starting the marked position:
[![enter image description here](https://i.stack.imgur.com/P3TJa.png)](https://i.stack.imgur.com/P3TJa.png)
Initially all edges are zero. The first `&` is a no-op, but `)` increments the edge and `!` prints the `1`. Then `"` moves back to the left (the edge labelled *2*). There, `&` copies a value. Since the edge is currently zero, the left neighbour (in the direction of the MP) will be copied which is the `1` we just printed. `)` increments it, `!` prints the `2`. This continues as long as we're visiting new edges and we print all digits up to `6`. When we hit the edge we started on, `&` will copy the *right* neighbour instead (because the edge value is positive), so the edge becomes `0` again, and control flow jumps to the last row, where `@` terminates the program.
[Try it online.](http://hexagony.tryitonline.net/#code=YCYpIS4iQC4&input=)
[Answer]
# JavaScript (ES6), 60 characters, [Cracked by user81655](https://codegolf.stackexchange.com/a/67815/41859)
Not promising to win, but hopefully fun to crack:
```
e_e_______a__a____e___e________e__o___________o______o______
```
This is a function that returns:
```
    :ERacddeeeeeeffiinnnoorrrrst
^^^^ -> 4 whitespaces
```
---
**Edit**
[user81655 cracked it](https://codegolf.stackexchange.com/a/67815/41859) character by character:
> 
>  `e=e=>{try{a}catch(e){return[...e.toString()].sort().join``}}`
> 
> 
> 
[Answer]
# ~~Matlab~~ Octave, 27 characters, safe
### Challenge
Regarding the new language restrictions: It also works in Octave.
```
____________3_3___4_3______
```
Output (in Octave): (`ans =` is not part of the output, the first character of the output is `"`)
```
ans = """""""""""""""""""""""""""""""""""""""""""########$$$$$$%%%%&&&&'''(()))**++,,-../001223456789:;<=>?@BCDFGHJKMNPRTUWY[]_acehjloq
```
Output (in Matlab): (`ans = \n\n` is not part of the output, the output is just the last line)
```
ans =
"""""""""""""""""""""""""""""""""""""""""""########$$$$$$%%%%&&&&'''(()))**++,,-../001223456789:;<=>?@BCDFGHJKMNPRTUWY[]_acehjloq
```
### Solution
> 
>  `[fix((0:.07/3:3).^4+34),'']`
>   
> 
>   
> 
>  We are basically looking at this function, converted to ASCII values.
>  [![enter image description here](https://i.stack.imgur.com/MyQtb.png)](https://i.stack.imgur.com/MyQtb.png)
> 
> 
> 
[Answer]
# R, 60 bytes, [cracked](https://codegolf.stackexchange.com/a/67911/6741) by plannapus
Output:
```
0123456789ABCDEFGHTUVWXYZdefghijklmnopqrstuvw
```
Code:
```
___(_(_:_____________]_____________6]_______s_4_____,___=___
```
I think this will not be so hard. We will see.
[Answer]
# [Jolf](https://github.com/ConorOBrien-Foxx/Jolf/), 27 characters, [Cracked by Adnan](https://codegolf.stackexchange.com/a/67881/31957)
```
________W___________--_____
                         |
```
prints
```
abcdefghijklmnopqrst
```
[Interpreter](http://conorobrien-foxx.github.io/Jolf/).
Original code:
```
on*2toHEWn)oH+H `pl$--$n}_H
on                          set n
  *2t                        to twenty
     oHE                    set H to the empty string
        Wn)                 while(n){
           oH+H             append to H
                `pl$--$n     get the nth character of the alphabet, decrement n before
                        }   }
                         _H print H reversed
```
Congrats to Adnan! You scare me.
---
Here, you can test your submission, to see how many characters must be removed.
```
setInterval(function(){r=document.querySelector("textarea").value;document.getElementById("output").innerHTML=r.length/6-r.split("").filter(function(x){return x=="_"}).length|0},20)
```
```
*{font-family:Consolas,monospace}textarea{width:100%;resize:none;height:auto;min-height:1.2em;}b{color:red;}
```
```
<textarea>Example Program</textarea><div>You must reveal <b id="output">n</b> characters.</div>
```
[Answer]
# Fortran, 45 characters, safe
Complete Output:
```
 !"$)0<Ka|
```
Cat [attempted to cracked it here](https://codegolf.stackexchange.com/a/67822/46231)
Code (45 characters):
```
pr_gr_m____________________/___3____________
```
Program code:
> 
>  `program t;print*,(char(i**3/8+33),i=1,9);end`
> 
> 
> 
[Answer]
# PHP, 46 characters, safe
Source:
```
for(_______________________=________________);
```
Outputs a 84 characters long string:
```
!!"#$%&'()*+,-./0123456789::;<=>?@AABCDEEFGHIIJKLLMNNOPPQRRSTTUUVWWXXYYZZ[[\\]]^^__`
```
**Hint**
> 
>  What'd you say? My cousine is involved?
> 
> 
> 
**Revealed code**
> 
>  This method is relatively simply as it prints up to *64* characters starting at `chr(32)`. The obscuring part is, that the iterator `i` is not incremented linearly. It's incremented by it's own *cosine* value which will result in repeated and missing characters.  
>   
> 
> `for(;$i<64;)echo chr(32+$i+=cos(deg2rad($i)));`  
> 
> `for(_______________________=________________);`
> 
> 
> 
[Answer]
## Python 3.4, 127 characters - SAFE
This is my first coppers-post. I think/hope it's not too hard or too obvious.
The obfuscated code:
```
_______inspect__________________getsource_____________________________________________print__________c*s_______________________
```
creates this output (there are 5 spaces at the beginning; total length is 7740 characters):
```
     """"""""""""(((((((((((((((((((((((((((((((((((((((((((((((((((((((()))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))**********************...................................................................................................................;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;==============================[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccdddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiijjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnoooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooopppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppprrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrsssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
```
## Edit 25 sept 2021, the answer in [Python 3](https://docs.python.org/3/)
```
import inspect;s=sorted(inspect.getsource(inspect.getmodule(inspect.currentframe())));print("".join([c*s.index(c) for c in s]))
```
[Try it online!](https://tio.run/##Tc0xDsIwDIXhq0SdEoYsjFVPghiQ41IjYke2I8HpQwYkeNv/La@9/RA@j0G1iXogtobgq202E0v8Qr6jm3QF/JcqpT9/Al0V2Xe9VYxpbm1K7HFZ8kOI4wVOlokLviKksIsGmIfBrimN8QE "Python 3 – Try It Online")
The code gets the code itself as a string and then repeaths every i-th character i times. Finally the resulting string is sorted.
Funny thing is thus that all the characters of the solution are in the output! ;-)
[Answer]
## CJam, 8 bytes, [Cracked by Pietu1998](https://codegolf.stackexchange.com/a/67917/8478)
```
__:_____
```
prints
```
%*;a|~
```
You can [try CJam online](http://cjam.tryitonline.net).
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 13 characters, [cracked](https://codegolf.stackexchange.com/a/68072/34388) by quintopia
I'm an idiot. I forgot to implement power function (-\_-｡). Here is the obfuscated code:
```
__D____<_____
```
My original code was:
```
99DF2}r<F*}bR
```
Explanation:
```
99DF2}r<F*}bR
99            # Pushes 99
  D           # Duplicates the top item
   F }        # Creates a for loop: For N in range(0, 99)
    2         # Pushes 2 (this will be done 99 times)
      r       # Reverses the stack
       <      # Decrement on the last item
        F }   # Creates a for loop: For N in range(0, 98)
         *    # Multiplies the last two item of the stack, which now looks like
              # [2, 2, 2, 2, 2, 2, 2, 2, ...]. Basically we're calculating 2^99
           b  # Converts the last item to binary
            R # Reverses the last item of the stack
```
This will output:
```
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001
```
Yes, that is 99 zeroes followed by a 1.
---
**Note**, I have a power function implemented right now. So this could be done in six bytes:
```
Y99mbR
```
[Answer]
# Pyth, 17 characters, [cracked by Pietu1998](https://codegolf.stackexchange.com/questions/67757/printing-ascending-ascii-robbers/68124#68124)
Output:
```
""''''''''''''''''''''0000000000111111111122222222223333333333XXXXXXXXXX[[[[[[]]]]]]
```
Code:
```
___________#____1
```
My solution:
```
Sjkm^dT%"'%#X"291
```
Pietu1998's solution:
```
S`u]G6*T`t"#X0231
```
[Answer]
# Malbolge, 254 characters, [cracked by Adnan](https://codegolf.stackexchange.com/questions/67757/printing-ascending-ascii-robbers/68219#68219)
Code:
```
_____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ __
```
Output:
```
`AB\cd`
```
I kinda cheated by putting a space for every 6th character. Oh well...
---
Adnan's cracked code:
```
('&%: ^"!65 4Xzyx w4-Qs rpo'K mlk"' ~Dfdc ba}v< ::8[Z XnVlq }0/mO ,*MbK JH^6# 4`C|0 ?U=Sw uPsaq L4on2 Mjjh, ged)c '<$$p ]!};Y WiVxS eRQ>= ).K]l Ij"Fh gfedc b,=;z L\q%H X3E2C /ng-k N*KJI 8%6#D ~2^Ai >g<<d tUr`6 oJ"!1 /|{CU f)d>b <A_^! \};Yj yUxTS dtsr` ML
```
The original code:
```
bCBA@ ?>=<; :9876 54321 0/.-, +*)(' &%$#" !~}|{ zyxwv utsrq ponml kjihg fedcb a`_^] \[ZYX WVUTS RQPON MLKJI HGFED CBA@? >=<;: 9y165 43210 /.-,+ *)('& }C#"! ~wv<z \xwvu tsrqp onmlk jihgf e^$ba `_^W\ UyYXW VUTSR QPONM FKJIH GFEDC BA@9] =<;:9 27654 3210) M:
```
I cheated again by using a text-to-Malbolge generator for this code.
[Answer]
# Mathematica 10.1, 98 characters, safe
Output is [here](http://pastebin.com/8PNpkHcD). The entire output has 838,316 characters and a trailing newline.
Code:
```
Print[""<>Chara__________________________________________________________________________________]
```
Yes, this must be run in 10.1. *(hint)* The original program:
```
Print[""<>Characters@ToCamelCase@ExampleData@{"Text","DonQuixoteIEnglish"}~SortBy~ToCharacterCode]
```
[Answer]
# [MATL](https://esolangs.org/wiki/MATL), 8 characters, safe
*Stable version of the compiler working in Octave hopefully coming soon. Meanwhile, this [GitHub commit works](https://github.com/lmendo/MATL/tree/77a5eba228ccedec8ac0d58d0f1842aba03858cc), and in particular runs the original code that produces the indicated output*
*This submission counts as posted on December 28, 2015, 15:30 UTC*
Output:
```
$**0016688??@HHQ
```
Code (8 characters):
```
_:______
```
### Solution
```
6:9tX*Sc
```
What it does:
```
6:9          % numeric vector [6 7 8 9]
t            % duplicate
X*           % Kronecker tensor product
S            % sort in ascending order 
c            % convert to char. Implicit display
```
[Answer]
## [Labyrinth](https://github.com/mbuettner/labyrinth), 5 bytes, [Cracked](https://codegolf.stackexchange.com/a/67765/8478) by Adnan
```
_____
```
prints
```
000000
```
---
My original code was:
```
<!!@ 
```
Note the trailing space.
I suppose I should have gone for more characters and revealed one of the `!`, because Adnan's solution only grows linearly when adding more `!`, while mine grows quadratically.
[Answer]
# PHP, 28 characters
```
<?=________________________;
```
Outputs the string
```
abcdefghijklmnopqrstuvwxyz
```
[Answer]
## ES6, 17 characters, [cracked](https://codegolf.stackexchange.com/a/67801/41859) by Cᴏɴᴏʀ O'Bʀɪᴇɴ
```
__=____=_________
```
This is a function that will return the string
```
11233
```
[Answer]
# JavaScript, 83 chars, [Cracked by Martin Büttner](https://codegolf.stackexchange.com/questions/67757/printing-ascending-ascii-robbers/67807#67807)
Output
```
Hi~~~
```
Code
```
_=____r____=u____=__s__=_________=__________________u_______A__________e______"_~_"
```
Output is in the JS console of a browser like Chrome/Firefox.
  
Original code (which *might* be invalid): 
```
q=w=e=r=t=y=u=i=o=p=s=d=f=g=h=j=k=l=z=x=c=v=b=n=m="Huh"[0]+"Alarms in here"[7]+"~~~"
```
[Answer]
# Pyth, 6 characters, [cracked](https://codegolf.stackexchange.com/a/67868/34388) by Pietu1998
Code:
```
S_____
```
Output:
```
.0113345678888999
```
You can try Pyth [here](https://pyth.herokuapp.com/)
[Answer]
# Octave, 18 bytes:
Output in Octave:
```
ans =  $'())**+,,--../0011233
```
Note that `ans =_` (replace `_` with space) is how Octave prints output by default and is not part of the output string. The output string alone starts with a single leading space like this:
```
 $'())**+,,--../0011233
```
Code:
```
[________:_______]
```
Disclaimer: If this miraculously should end up being the shortest uncracked submission, I'll award the win to the runner-up. This won't be a winning submission, I just wanted to have some fun too. *And* I figured a relatively short MATLAB/Octave submission could be fun for others. The other one was too hard for me at least.
[Answer]
# JavaScript ES6, 134 characters
Huh boy, that was fun. Good luck!
```
_=_=_____l____.______.________(___}__;___=______ru____"_____+_[________]______!____]__[_________e________.__U_________)__________\_____
```
Outputs:
```
((((((()))))))+...000000000000000000002233=>AAAAAAAAAAABBBBBCCCCCCCCCCCCCCCCCCDDDDDDDEEEEEEEEEEEEEEEEEEEFFFFFFFGHIIIIIIIIIIIIIIIIJJJJLLMMNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOOOOOOOOOOOOOOOOOOPRRRRRRRSSSSTTTTTTTTTTTTTTTTTTTTTTTUUUUUUUUUVVVVVVXXY[[[[[[[[]]]]]]]]````ddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeffffffffffffffffffffffffffffffffffffffffffffffffffffffffiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiinnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu{{{{{{}}}}}}
```
[Answer]
# CJam, 12 characters, [Cracked](https://codegolf.stackexchange.com/a/67769) by jimmy23013
**Output**
```
#$%&'()*+,-./:;<=>?@[\]^_`
```
**Code**
```
_:____#_____
```
[Answer]
## [Seriously](http://seriouslylang.herokuapp.com), 7 bytes, [Cracked by Martin Büttner](https://codegolf.stackexchange.com/a/67912/47050)
```
______S
```
Output:
```
   deeknnoow
```
Shouldn't be too difficult, even if the result is not exactly what you'd expect.
[Answer]
# Python 3, 58 characters, cracked by [Mitch Schwartz](https://codegolf.stackexchange.com/a/68000/45032)
Code:
```
______________print(_______(_______________________)_____)
```
> 
>  import string;print(''.join(sorted(string.printable))[5:])
> 
> 
> 
Output:
```
 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~
```
[Answer]
# Befunge, 11 characters, [cracked](https://codegolf.stackexchange.com/a/68122/31203) (in funge-98) by MegaTom
Output:
```
1223788
```
Obfuscated code:
```
________.__
```
All one line, since the rules prohibit newlines. Tested using <http://www.quirkster.com/iano/js/befunge.html> .
Edit: This is legally cracked since I didn't specify a version, but note that there's a Befunge-93 solution still out there.
[Answer]
## Perl 5, 30 bytes, [cracked](/a/68132) by [Adnan](/u/34388)
Code:
```
print_________________________
```
Output:
```
9:;@AFGHLMNRSTYZ_`a
```
Cracked:
[Adnan](/u/34388) found a [trivial](//en.wikipedia.org/wiki/Triviality_%28mathematics%29) [crack](/a/68132): obviously, I didn't think this puzzle through well enough. I've composed [another](/a/68142) instead.
]