[Question]
  [
The robbers thread can be found here: [The Mystery String Printer (Robbers)](https://codegolf.stackexchange.com/questions/60329/the-mystery-string-printer-robbers)
# Your challenge
* Write a program, function, or REPL script that prints a string to STDOUT.
* The robbers will try to create a program that prints the same string.
* If they successfully can create the program within 7 days, your submission is cracked.
* If nobody can create a program that prints the same string within 7 days, your submission is safe. You may choose to reveal your program, or leave it to challenge future robbers. However, if you don't reveal it, you can't get any points from your submission (don't put "safe" in your answer header if you choose to do this).
# Restrictions
* The program must be less than or equal to 128 bytes total (more on this later).
* If the program depends on the program name, or the name/contents of an external file, you must say that it does so, and include this in your total byte count.
* The printed string must be less than or equal to 2048 bytes.
* The printed string must consist of only printable ASCII characters (new lines can be included).
* The program must produce the same output every time that it is run.
* Built-in cryptographic primitives (includes any rng, encryption, decryption, and hash) aren't allowed.
* The program must not take input.
* No standard loopholes.
# Scoring
* If a submission is cracked before seven days, the submission earns 0 points.
* A safe submission of ≤128 characters earns 1 point.
* A safe submission of ≤64 characters earns 2 points. If it's less than or equal to 32 bytes, it earns 4 points, and so on.
* Each safe submission also earns an additional 3 point bonus (independent of the length).
* There is a tiny (1/2 point) penalty for every cracked after your first one.
* Note that the robber's solution has to be in the same range of program lengths.
* Each person may submit a maximum of 1 program per byte range per language (different versions and arbitrary substitutions of the same language don't count as separate languages). Example: you can post a 32 byte and a 64 byte pyth program, but you can't post a 128 byte program in both Java 7 and Java 8.
* The person with the highest point total wins.
## Submissions
Each submission must have the following pieces of information:
* The name of the language. All *new* robbers' solutions must be the same language.
* The range of the program size (this is the nearest power of two higher than the size of the program; for example, if your program is 25 bytes, this would be "≤32").
* The actual string to be printed out.
* If a submission is safe, put "safe" and the program length (to the nearest power of 2) in your header. If there are multiple numbers in your header, put the power of 2 last.
This stack snippet generates leaderboards and lists all of the open submissions. If there are any problems with the snippet, please leave a comment.
```
/* Configuration */
var QUESTION_ID = 60328; // Obtain this from the url
// It will be like http://XYZ.stackexchange.com/questions/QUESTION_ID/... on any question page
var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";
var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk";
var OVERRIDE_USER = 167084; // This should be the user ID of the challenge author.
var SECONDSINDAY = 86400;
var SAFECUTOFFDAYS = 7;
var SORTBYTIME = true;
var SUBTRACTCRACKEDPOINTS = true;
var EXPIREDTIME = 1446336000;
/* App */
var answers = [],
  answers_hash, answer_ids, answer_page = 1,
  more_answers = true,
  comment_page;
function answersUrl(index) {
  return "//api.stackexchange.com/2.2/questions/" + QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER;
}
function commentUrl(index, answers) {
  return "//api.stackexchange.com/2.2/answers/" + answers.join(';') + "/comments?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + COMMENT_FILTER;
}
function getAnswers() {
  jQuery.ajax({
    url: answersUrl(answer_page++),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function(data) {
      answers.push.apply(answers, data.items);
      answers_hash = [];
      answer_ids = [];
      data.items.forEach(function(a) {
        a.comments = [];
        var id = +a.share_link.match(/\d+/);
        answer_ids.push(id);
        answers_hash[id] = a;
      });
      if (!data.has_more) more_answers = false;
      comment_page = 1;
      getComments();
    }
  });
}
function getComments() {
  jQuery.ajax({
    url: commentUrl(comment_page++, answer_ids),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function(data) {
      data.items.forEach(function(c) {
        answers_hash[c.post_id].comments.push(c);
      });
      if (data.has_more) getComments();
      else if (more_answers) getAnswers();
      else process();
    }
  });
}
getAnswers();
var SAFE_REG = /<h\d>.*?[sS][aA][fF][eE].*<\/\h\d>/;
var POINTS_REG = /(?:<=|≤|&lt;=)\s?(?:<\/?strong>)?\s?(\d+)/
var POINTS_REG_ALT = /<h\d>.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/;
var CRACKED_HEADER_REG = /<h\d>.*[Cc][Rr][Aa][Cc][Kk][Ee][Dd].*<\/h\d>/;
var CRACKED_COMMENT_REG = /(.*[Cc][Rr][Aa][Cc][Kk][Ee][Dd].*<a href=.*)|(.*<a href=.*[Cc][Rr][Aa][Cc][Kk][Ee][Dd].*)/
var OVERRIDE_REG = /^Override\s*header:\s*/i;
var LANGUAGE_REG = /<h\d>\s*(.+?),.*<\/h\d>/;
var LANGUAGE_REG_ALT = /<h\d>\s*(<a href=.+<\/a>).*<\/h\d>/
var LANGUAGE_REG_ALT_2 = /<h\d>\s*(.+?)\s.*<\/h\d>/;
var LANGUAGE_REG_ALT_3 = /<h\d>(.+?)<\/h\d>/;
function getAuthorName(a) {
  return a.owner.display_name;
}
function process() {
  var valid = [];
  var open = [];
  answers.forEach(function(a) {
    var body = a.body;
    var cracked = false;
    a.comments.forEach(function(c) {
      var was_safe = (c.creation_date + (SECONDSINDAY * SAFECUTOFFDAYS) > a.creation_date);
      if (CRACKED_COMMENT_REG.test(c.body) && !was_safe)
        cracked = true;
    });
    if (CRACKED_HEADER_REG.test(body)) cracked = true;
    // if (SUBTRACTCRACKEDPOINTS||!cracked) {
    var createDate = a.creation_date;
    var currentDate = Date.now() / 1000;
    var timeToSafe = (createDate + (SECONDSINDAY * SAFECUTOFFDAYS) - currentDate) / SECONDSINDAY;
    var SafeTimeStr = (timeToSafe > 2) ? (Math.floor(timeToSafe) + " Days") :
      (timeToSafe > 1) ? ("1 Day") :
      (timeToSafe > (2 / 24)) ? (Math.floor(timeToSafe * 24) + " Hours") :
      (timeToSafe > (1 / 24)) ? ("1 Hour") :
      "<1 Hour";
    var expired = createDate > (EXPIREDTIME);
    var safe = timeToSafe < 0;
    var points = body.match(POINTS_REG);
    if (!points) points = body.match(POINTS_REG_ALT);
    safe = safe && !cracked
    isOpen = !(cracked || safe);
    if (points) {
      var length = parseInt(points[1]);
      var safepoints = 0;
      if (length <= 4) safepoints = 32;
      else if (length <= 8) safepoints = 16;
      else if (length <= 16) safepoints = 8;
      else if (length <= 32) safepoints = 4;
      else if (length <= 64) safepoints = 2;
      else if (length <= 128) safepoints = 1;
      valid.push({
        user: getAuthorName(a),
        numberOfSubmissions: (safe && !expired) ? 1 : 0,
        points: (safe && !expired) ? safepoints : 0,
        open: (isOpen && !expired) ? 1 : 0,
        cracked: (cracked && !expired) ? 1 : 0,
        expired: (expired) ? 1 : 0
      });
    }
    if ((isOpen || expired) && points) {
      var language = body.match(LANGUAGE_REG);
      if (!language) language = body.match(LANGUAGE_REG_ALT);
      if (!language) language = body.match(LANGUAGE_REG_ALT_2);
      if (!language) language = body.match(LANGUAGE_REG_ALT_3);
      open.push({
        user: getAuthorName(a),
        length: points ? points[1] : "???",
        language: language ? language[1] : "???",
        link: a.share_link,
        timeToSafe: timeToSafe,
        timeStr: (expired) ? "Challenge closed" : SafeTimeStr
      });
    }
    // }
  });
  if (SORTBYTIME) {
    open.sort(function(a, b) {
      return a.timeToSafe - b.timeToSafe;
    });
  } else {
    open.sort(function(a, b) {
      var r1 = parseInt(a.length);
      var r2 = parseInt(b.length);
      if (r1 && r2) return r1 - r2;
      else if (r1) return r2;
      else if (r2) return r1;
      else return 0;
    });
  }
  var pointTotals = [];
  valid.forEach(function(a) {
    var index = -1;
    var author = a.user;
    pointTotals.forEach(function(p) {
      if (p.user == author) index = pointTotals.indexOf(p);
    });
    if (index == -1) pointTotals.push(a);
    else {
      pointTotals[index].points += a.points;
      pointTotals[index].numberOfSubmissions += a.numberOfSubmissions;
      pointTotals[index].cracked += a.cracked;
      pointTotals[index].expired += a.expired;
      pointTotals[index].open += a.open;
      if (SUBTRACTCRACKEDPOINTS && a.cracked && pointTotals[index].cracked > 1) pointTotals[index].points -= .5;
    }
  });
  pointTotals.forEach(function(a) {
    a.points += (a.numberOfSubmissions) ? ((a.numberOfSubmissions) * 3) : 0;
  });
  pointTotals.sort(function(a, b) {
    if (a.points != b.points)
      return b.points - a.points;
    else if (a.numberOfSubmissions != b.numberOfSubmissions)
      return b.numberOfSubmissions - a.numberOfSubmissions;
    else if (a.open != b.open)
      return b.open - a.open;
    else if (a.cracked != b.cracked)
      return a.cracked - b.cracked;
    else return 0;
  });
  pointTotals.forEach(function(a) {
    var answer = jQuery("#answer-template").html();
    answer = answer
      .replace("{{NAME}}", a.user)
      .replace("{{SAFE}}", a.numberOfSubmissions)
      .replace("{{OPEN}}", a.open)
      .replace("{{CLOSED}}", a.expired)
      .replace("{{CRACKED}}", a.cracked)
      .replace("{{POINTS}}", a.points);
    answer = jQuery(answer);
    jQuery("#answers").append(answer);
  });
  open.forEach(function(a) {
    var answer = jQuery("#open-template").html();
    answer = answer
      .replace("{{NAME}}", a.user)
      .replace("{{LENGTH}}", a.length)
      .replace("{{LANGUAGE}}", a.language)
      .replace("{{TIME}}", a.timeStr)
      .replace("{{LINK}}", a.link);
    answer = jQuery(answer);
    jQuery("#opensubs").append(answer);
  });
}
```
```
body {
  text-align: left !important
}
#answer-list {
  padding: 10px;
  width: 350px;
  float: left;
}
#open-list {
  padding: 10px;
  width: 470px;
  float: left;
}
table thead {
  font-weight: bold;
  vertical-align: top;
}
table td {
  padding: 5px;
}
```
```
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b">
<div id="answer-list">
  <h2>Leaderboard</h2>
  <table class="answer-list">
    <thead>
      <tr>
        <td>Author</td>
        <td>Safe</td>
        <td>Open</td>
        <td>Cracked</td>
        <td>Late Entry</td>
        <td>Score</td>
      </tr>
    </thead>
    <tbody id="answers">
    </tbody>
  </table>
</div>
<div id="open-list">
  <h2>Open submissions</h2>
  <table class="open-list">
    <thead>
      <tr>
        <td>Author</td>
        <td>Length</td>
        <td>Language</td>
        <td>Time Remaining</td>
        <td>Link (open in new tab)</td>
      </tr>
    </thead>
    <tbody id="opensubs">
    </tbody>
  </table>
</div>
<table style="display: none">
  <tbody id="answer-template">
    <tr>
      <td>{{NAME}}</td>
      <td>{{SAFE}}</td>
      <td>{{OPEN}}</td>
      <td>{{CRACKED}}</td>
      <td>{{CLOSED}}</td>
      <td>{{POINTS}}</td>
    </tr>
  </tbody>
</table>
<table style="display: none">
  <tbody id="open-template">
    <tr>
      <td>{{NAME}}</td>
      <td>{{LENGTH}}</td>
      <td>{{LANGUAGE}}</td>
      <td>{{TIME}}</td>
      <td><a target="_parent" href="{{LINK}}">Link</a>
      </td>
    </tr>
  </tbody>
</table>
```
Use the following formats for entries:
```
Language, (any text with the program size as the last number)
=
```
or
```
Language
=
Length <= 16
```
Note that the snippet will only put the first word in the header as the language if it doesn't detect a comma.
For safe submissions, put safe in your header. The snippet will automatically put your program in the "safe" column if the time is expired, so this is more to tell any robbers that your program is safe.
For cracked submissions, put cracked in your header. 
The program should also be able to recognize if a comment says "cracked" and has a link; however, this is not guaranteed.
Tiebreaking order: Points -> # of Safe submissions -> Least amount of cracked submissions.
Note that the snippet sorts by open submissions before least cracked, but open submissions will not be counted at the end of the contest.
**This challenge is now closed.**
**Most points overall winner: Dennis**
**Most safe submissions: DLosc**
(Note that the number of safe submissions doesn't translate to a point amount, as the size of the programs are considered in calculating the score).
  
[Answer]
# Pyth, Safe, Range ≤ 8
```
['ashva', 'cxedo', 'ecckc', 'hhzsq', 'jmwze', 'lrths', 'nwrog', 'pbowu', 'rgldi', 'uljlw', 'wpgsk', 'yuday'
```
The code:
> 
> `%^T6`^G5`
> 
> 
> 
Explanation: 
> 
>  To clarify how this works: I generated all possible 5 character strings of lowercase letters (`^G5`). Then, I generated the string representation of this list: (``^G5`). Finally, I took every 1,000,000th character of that list (`%^T6`).
> 
>  The result is something which looks like a list of strings, but is suspiciously missing its end bracket.
> 
> 
> 
[Answer]
#  VBA , [Safe]
Range <= 128 bytes
Hint for where to output
> 
>  Ran in Excel 2007, output was to Debug.print. Its VBA good luck getting anything under 128 bytes to run.
> 
> 
> 
Output 255 bytes
```
 This array is fixed or temporarily locked THIS ARRAY IS FIXED OR TEMPORARILY LOCKED this array is fixed or temporarily locked This Array Is Fixed Or Temporarily Locked I n v a l i d   p r o c e d u r e   c a l l   o r   a r g u m e n t  ?????????????????
```
###  Solution
> 
>  Well I hope someone had fun trying to crack this one. I can say that this is some of the worst error-handling I have ever done and feel bad for how bad this code is. 
> 
> 
> 
### Code
> 
>  
> ```
>     Sub e()
>     On Error Resume Next
>     Err.Raise 10
>     For i = 0 To 128
>     b = b & " " & StrConv(Err.Description, i)
>     Next
>     Debug.Print b
>     End Sub'
> ```
> 
> 
> 
> 
### Explained
> 
>  First the code starts with one of the Major sins of VBA. `On Error Resume next`.  
> 
>  Once we have committed that horrid act we go ahead and just throw and error. this is the `This array is fixed or temporarily locked` Error that we will soon see in the output.  
> 
>   
> 
> The next is the loop. We loop 128 times trying to Convert the Error Description, But the only valid inputs for `i are 1,2,3,64,128`. Because of this the first 4 loops print the Error with Various Formats. Then when `i = 4` the code throws a new Error `Invalid call` Then that loops and nothing is assigned to `b` because the `strconv` function errors out each time.   
> 
>   
> 
>  This is where any normal program should have stopped, But because we have the `On Error Resume Next` every error is ignored and the code continues unfazed by the poor error-handling   
> 
>   
> 
>  Now we hit `i=32` and we add the new error to `b` converted to Unicode and then continue looping until `i = 128` at which point we convert our error FROM Unicode which results in the `?????????????????` string being added to `b`  
> 
>   
> 
>  Finally Print out the mess of Errors we have concatenated together
> 
> 
> 
[Answer]
# Mathematica, safe, range ≤ 64
Output:
```
CGTAGGCCCATTTTGTGTGAATTGCGGTGCAGCGAGCGATATGTTGTCTGGGCACGGACGCAGAGTTAGGGTAGCTGGTG
```
Source:
```
Print@@Characters["GATC"][[1+First@RealDigits[Pi,4,80]]]
```
[Answer]
# ngn APL (safe)
```
0.675640430319848J0.8376870144941628
```
Range **≤ 8**
### Solution
```
*3○⍟⍣=42
```
[Try it online.](http://ngn.github.io/apl/web/#code=*3%u25CB%u235F%u2363%3D42)
### How it works
* `⍟⍣=42` applies natural logarithm (`⍟`) repeatedly to **42** until a fixed point is reached (`⍣=`), yielding **0.31813150520476413J1.3372357014306895**.
The initial value doesn't really matter here, as long as it's neither **1** nor **0**.
* `3○` applies tangent to its right argument, yielding **0.07343765001657206J0.8920713530605129**.
* `*` applies the natural exponential function to its right argument, yielding the desired output.
[Answer]
# Pyth, [cracked by Sp3000](https://codegolf.stackexchange.com/a/60351)
```
1234465889612101271616181215168242024142718209323236243032163621242510
```
Range **≤ 8**
[Answer]
## ><> (Safe)
Tested on the online and official interpreters.
Range: <= 16
String: `4621430504113348052246441337820019217490490`
This is pretty 1337, huh?
## Explanation:
Here's the source code (15 bytes):
```
f1-:0(?;::0g*n!
```
`f` pushes 15 (our counter) onto the stack (this is skipped by the `!` at the end so as not to push more than one counter)
`1-` subtracts 1 from the counter
`:0(?;` The frowny face tests if the counter is less than 0, the rest ends the program if it is
`::` Duplicates the counter twice
`0g` Grabs the character at the point `(c,0)` in the source code where `c` is the counter
`*` Multiplies the second duplicate of the counter by the ASCII representation of the character previously grabbed
`n` Prints the result.
So, split up, the output is `[462, 1430, 504, 1133, 480, 522, 464, 413, 378, 200, 192, 174, 90, 49, 0]`. This corresponds to the ASCII interpretation of the code in reverse multiplied by the numbers 14 to 0 (i.e. `[!*14, n*13, ... f*0]`).
Probably the hardest part about cracking this would be figuring out how to split up the numbers correctly, but if you get the right ones it's just a matter of trying things until you get something that works.
[Answer]
# Python, <=16 ([cracked by kennytm](https://codegolf.stackexchange.com/a/61198/6828))
```
[[[22111101102001]]]
```
This was produced via REPL (running a command in Python shell).
While I'm editing this, I'll also summarize the comments for future spoiler-free robbers: this doesn't work in all Pythons. It does work in a build of Python 2.7 where `sys.maxint = 9223372036854775807`.
[Answer]
# Matlab, ≤16. [Cracked by Wauzl](https://codegolf.stackexchange.com/a/60482/46115)
Range **≤16**.
This works in **Octave** too.
The printed string is as follows:
```
ans =
     0     0     0     0     0     0     0     0     0
     0     0     0     0     9     4     0     0     0
     0     0     0     0    32    18     0     0     0
     0     0     0     9     1     0     3     0     0
     0     0     7     0     0     2    10     0     0
     0     0     3     0     2     2     3     0     0
     0     0     0    19    63    22     1     0     0
     0     0     0     4    13     4     0     0     0
     0     0     0     0     0     0     0     0     0
```
[Answer]
# Perl (safe)
```
84884488488444224424428844884884884488488444224424428844884884884488488444224424424422442442884488488488448848844422442442884488488488448848844422442442442244244244224424422211221221221122122144224424424422442442221122122144224424424422442442221122122144224424424422442442221122122122112212214422442442442244244222112212214422442442442244244222112212218844884884884488488444224424424422442442884488488488448848844422442442884488488488448848844422442442884488488488448848844422442442442244244288448848848844884884442244244288448848848844884884442244244244224424424422442442221122122122112212214422442442442244244222112212214422442442442244244222112212218844884884884488488444224424424422442442884488488488448848844422442442884488488488448848844422442442884488488488448848844422442442442244244288448848848844884884442244244288448848848844884884442244244244224424424422442442221122122122112212214422442442442244244222112212214422442442442244244222112212212212211222442442244244244224412212211222442442244244244224412212211221221221122244244224424424422442442442244488488448848848844882442442244488488448848848844882442442244244244224448848844884884884488244244224448848844884884884488244244224448848844884884884488244244224424424422444884884488488488448812212211222442442244244244224412212211222442442244244244224412212211221221221122244244224424424422442442442244488488448848848844882442442244488488448848848844882442442244244244224448848844884884884488244244224448848844884884884488244244224448848844884884884488244244224424424422444884884488488488448812212211222442442244244244224412212211222442442244244244224412212211221221221122244244224424424422441221221122244244224424424422441221221122244244224424424422441221221122122122112224424422442442442244244244224448848844884884884488244244224448848844884884884488244244224424424422444884884488488488448824424422444884884488488488448824424422444884884488488488448824424422442442442244488488448848848844882442442244488488448848848844882442442244488488448
```
Range **≤ 32**
### Solution
```
print 2**y/124589//for-951..1048
```
[Try it online.](http://ideone.com/yhIHaS)
### How it works
* `for-951..1048` executes the preceding command for each integer in this range, saving it in the implicit variable.
* `y/124589//` performs transliteration, eliminating the specified digits from the implicit variable.
`y///` will return the number of eliminations, i.e., the number of occurrences of those digits in the implicit variable.
* `print 2**` prints **2** to the power of eliminations (**1**, **2**, **4** or **8**).
[Answer]
# Javascript (console), <= 32 ([cracked by insertusernamehere](https://codegolf.stackexchange.com/a/61149/6828))
```
"a,a,0,a,b,a,a,b,a,a,4,a,b,a,a,a,a,6,a,b,a,a"
```
Tested in Chrome and Firefox web consoles. That's a 43 character string.
My intended solution was a bit more elaborate than the linked one (curse you, ES6!).
> 
>  'a,b,a,a'.replace(/(a)/g,Array)
> 
> 
> 
Explanation:
> 
>  When you call `replace` with a Regular Expression with the `/g` flag and a function, it replaces everything matching the regex with the result of calling the function with these arguments: The matched string, every capture group in the matched string, the index the matched string has in the whole string, and the whole string. In this case, that'll be "a", "a", 0 or 4 or 6, and "a,b,a,a". All of these arguments are passed into the Array constructor, which simply creates an array of everything passed in. Then `replace` converts that to a string, e.g. "a,a,0,a,b,a,a" and replaces the "a" character with it.
> 
> 
> 
[Answer]
## [Snowman 1.0.2](https://github.com/KeyboardFire/snowman-lang/releases/tag/v1.0.2-beta)
Range ≤32.
```
110110111011011001111100111111111101111110101000101000100001100001100011100011101110110111011011111011111011101011101111101111110111110111111011110101111010111100101100101001111001111111011111011010111010111000000100000011111001111100
```
The solution is:
```
"mO~(!#]/.}{k2'=+@|":2nBspsP;aE
```
[Answer]
# [><>](https://esolangs.org/wiki/Fish), ≤ 8 [[cracked](https://codegolf.stackexchange.com/a/60892/21487)]
```
oooooooooooo
```
That's a total of 12 `o`s. The program halts without error, and works with both the official interpreter and the [online interpreter](http://fishlanguage.com/playground).
[Answer]
# TI-BASIC, ≤4 bytes, [cracked by Reto Koradi](https://codegolf.stackexchange.com/a/61087/39328)
This took 5 days 23 hours to crack. So close...
Output (10 bytes):
```
.495382547
```
Program:
```
³√(tanh(7°
```
Since it's basically impossible for someone to guess this, my goal in designing this program was to make brute force the only possible approach.
To do this, I prevented the output, or the output with one of [these inverse functions](http://tibasicdev.wikidot.com/one-byte-tokens) applied, from showing up on the ISC. ISC doesn't have hyperbolic tangent, and I figured that no similar tool would have `tanh(7°`.
To add some security against brute force, I used degree-to-radian conversion, a slightly obscure feature, but it wasn't enough.
[Answer]
# CJam, ≤ 8 [safe]
```
379005901358552706072646818049622056
```
I don't like long numbers so here's a short one. Feel free to fiddle both offline and [online](http://cjam.aditsu.net/).
Since I find number-only submissions pretty boring, I'll be slowly putting out a few hints to compensate.
> 
>  **Hint 1:** The program ends with a single number of the stack, and none of the `A-K` variables are used.
>    
> 
> **Hint 2:** The number encodes information that is completely retrievable if you reverse the process (i.e. no information has been lost).
> 
>    
> 
> **Hint 3:** The "information" from hint 2 is a single string which is created after the first four chars.
> 
> 
> 
---
## Solution
The program was
```
0W#sWcib
```
`0W#` is `0^-1`, which instead of erroring out gives `Infinity`. `s` then casts this to a string (note that ``` gives `1d0/` instead).
For the other half, `Wc` converts -1 to a char, which becomes code point 65535 due to the wraparound for chars (see [this tip](https://codegolf.stackexchange.com/a/54767/21487)). `i` then converts the char back to an int, i.e. 65535.
Finally, `b` converts the string `Infinity` to base 65535 to give the above number.
[Answer]
# Python, <= 32 ([cracked](https://codegolf.stackexchange.com/a/60847/16766) by Egor Skriptunoff)
Output is 1832 bytes, including newlines:
```
163
485
559
1649
2707
8117
8415
24929
41891
124133
142639
423793
694675
2075317
2162655
6357089
10682531
31785445
36635183
108070513
177408659
531963829
551493855
1633771873
2745410467
8135173349
9347869999
27774121841
45526653331
136007297717
141733920735
416611827809
700079669411
2083059139045
2400886719023
7082401072753
11626476472979
34862249549749
36142149804255
107069239746913
179920475038627
533147175478501
612629840276783
1820177075697521
2983606407043475
8913418645908149
9288532499693535
27303489359118433
45881121294188707
136517446795592165
157346912904610351
464159319105013361
761964388609624723
2284767248741900213
2368648071721459935
7016996765293437281
11791448172606497699
34940303480791033061
40148795925132553519
119288945009988433777
195535487181321247123
584146895667469134517
608742554432415203295
1789334175149826506849
3006819284014656913571
8946670875749132534245
10311729937203639353903
30418680977547050616433
49935336207531756227219
149732221646300430475189
155229351380265876857055
459858883013505412260193
772752555991766826787747
2289849682101787770873061
2631225127929856733097263
7817601011229592008423281
12814491939404182769539475
38282841570818685533137589
39893943304728330352263135
117267593836794179779362913
197057915416468570144702627
586337969183970898896814565
675799844894514912336740911
1993549095225501056249169521
3272612129033008707863251603
9813000610033591312052461493
10173266001408484771580813535
30137771616056104203296268641
50643884262032422527188575139
150067460764265635881358255333
172437765505860562200296238383
512342117472953771456036566897
839818522529453467650609486227
2508891813142320379359897758389
2614529362361980586296269078495
7685131765672974922140201517153
12914190492831906312462400487587
38425658828364874610701007585765
44288542855785494654395594310191
```
[Answer]
# CJam ([cracked](https://codegolf.stackexchange.com/questions/60329/the-mystery-string-printer-robbers/61031#61031) by Dennis)
Length <= 4
```
1737589973457545958193355601
```
I don't give this a very high chance of survival, but I wanted to try a 4 byte solution anyway.
My code was exactly what Dennis reverse engineered:
```
H     Push 17
J     Push 19.
K     Push 20.
#     Power.
```
CJam then prints all of the stack content, concatenated. So the output was `17` concatenated with `19^20`.
[Answer]
# [Pip](http://github.com/dloscutoff/pip), <= 16 (safe)
This is my final Pip submission, I promise. :)
```
0123456789
0        9
0        9
0        9
0        9
0        9
0        9
0        9
0        9
0        9
0        9
0123456789
```
I'll be surprised if anybody gets this down to 16 bytes--it took me quite a few tries to make it fit. (Take that as a challenge if you like!)
---
Answer:
```
Px:J,tLtP09JsX8x
```
This code makes use of the predefined variables `t` = 10 and `s` = space.
```
    ,t            Range(10)
   J              Join into string: "0123456789"
Px:               Assign to x and print
      Lt          Loop 10 times:
         09         This is a numeric literal, but it can act like a string "09" because
                    strings and numbers are the same data type in Pip
            sX8     8 spaces
           J        Join left arg on right arg: "0        9"
        P           Print
               x  Last expression in a program is autoprinted: "0123456789"
```
[Answer]
## Ruby, [cracked by kennytm](https://codegolf.stackexchange.com/a/60409/3808)
Range: ≤64.
```
#<MatchData "@@" 1:"@" 2:"@">
"#<ArgumentError: unknown command \"\\x00\">\nu#<ArgumentError: unknown command \"\\x00\">\nn#<ArgumentError: unknown command \"\\x00\">\nk#<ArgumentError: unknown command \"\\x00\">\nn#<ArgumentError: unknown command \"\\x00\">\no#<ArgumentError: unknown command \"\\x00\">\nw#<ArgumentError: unknown command \"\\x00\">\nn#<ArgumentError: unknown command \"\\x00\">\n #<ArgumentError: unknown command \"\\x00\">\nc#<ArgumentError: unknown command \"\\x00\">\no#<ArgumentError: unknown command \"\\x00\">\nm#<ArgumentError: unknown command \"\\x00\">\nm#<ArgumentError: unknown command \"\\x00\">\na#<ArgumentError: unknown command \"\\x00\">\nn#<ArgumentError: unknown command \"\\x00\">\nd#<ArgumentError: unknown command \"\\x00\">\n #<ArgumentError: unknown command \"\\x00\">\n\"#<ArgumentError: unknown command \"\\x00\">\n\\#<ArgumentError: unknown command \"\\x00\">\nx#<ArgumentError: unknown command \"\\x00\">\n0#<ArgumentError: unknown command \"\\x00\">\n0#<ArgumentError: unknown command \"\\x00\">\n\"#<ArgumentError: unknown command \"\\x00\">\n@#<ArgumentError: unknown command \"\\x00\">\n@#<ArgumentError: unknown command \"\\x00\">\n"
```
(And yes, all output is to STDOUT.)
Intended solution:
```
test'@@'=~/(.)(.)/ rescue p"#{$!}#{p$~}".gsub(//,$!.inspect+$/)
```
[Answer]
# TI-BASIC ([cracked](https://codegolf.stackexchange.com/a/60427/39328) by [Thomas Kwa](https://codegolf.stackexchange.com/users/39328/thomas-kwa))
TI-89 variant  
Range: ≤8  
Output length: 460
```
1257286521829809852522432602192237043962420111587517182185282167859393833998435970616540717415898427784984473447990617367563433948484506876830127174437083005141539040356040105854054119132085436114190914221684704295353373344661986220406465038338295680627940567692710933178603763184382721719223039895582218462276317539764129360057392146874652124017927952151332902204578729865820715723543552685154087469056000000000000000000000000000000000000000000000000000000000
```
I don't think you can use RIES on this but I doubt it will survive 7 days anyway. Oh well.
Code:
```
236!
```
[Answer]
# MATLAB, [cracked by Tom Carpenter](https://codegolf.stackexchange.com/a/60436/42295)
Range <= 16
```
ans =
        5760       22320
       13920       53940
```
[Answer]
# Mathematica, [Cracked by Sp3000](https://codegolf.stackexchange.com/a/60581/9288)
Range: <= 32
```
808017424794512875886459904961710757005754368000000000
```
[Answer]
# **[Thue](https://en.wikipedia.org/wiki/Thue_%28programming_language%29)** - <= 64 Bytes, cracked by histocrat.
`555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555`
That's 2016 5s; by the way.
[Answer]
# Lua, ≤ 4 ([cracked](https://codegolf.stackexchange.com/a/61094/7313) by feersum)
Output:
```
9.5367431640625e-07
```
You need to find a string for Lua REPL which results in "1/M" constant.  
It is simple, but not very trivial.
[Answer]
# CJam, ≤8 (safe)
```
\"3.341594\43181\
```
Original code:
```
P`_`_`er
```
That is, to start with `3.141592653589793` and replace each character in `"3.141592653589793"` with the corresponding character in `"\"3.141592653589793\""`. With the duplicates removed, it's actually replacing `".123456789` with `""35\.49831`.
[Answer]
## Python 2 (safe 16)
```
(1.06779146638-0.024105112278j)
```
Range ≤ 16. In case the version matters (for printing precision?), I'm using [ideone](https://ideone.com/).
I don't see a way of guessing the code without computer search, but you all have impressed me before.
---
Answer:
```
print.7j**8j**2j
```
[Answer]
# Pyth, [Cracked by Sp3000](https://codegolf.stackexchange.com/a/60442/21487)
Range: <= 4
**New, valid answer**
I'm sure this can be brute forced with such a small program size, but lets see.
```
3582409715080948947248394822102989658717877178836918915255342812682764990143662880
```
[Answer]
# JavaScript ES6, ≤128 bytes - [Cracked](https://codegolf.stackexchange.com/a/60666/31957)
Output (1124 bytes):
```
00371223425266831021221451701972262572903253624014424855305776266777307858429019621025109011571226129713701445152216011682176518501937202621172210230524022501260227052810291730263137325033653482360137223845397040974226435744904625476249015042518553305477562657775930608562426401656267256890705772267397757077457922810182828465865088379026921794109605980210001102021040510610108171102611237114501166511882121011232212545127701299713226134571369013925141621440114642148851513015377156261587716130163851664216901171621742517690179571822618497187701904519322196011988220165204502073721026213172161021905222022250122802231052341023717240262433724650249652528225601259222624526570268972722627557278902822528562289012924229585299303027730626309773133031685320423240132762331253349033857342263459734970353453572236101364823686537250376373802638417388103920539602400014040240805412104161742026424374285043265436824410144522449454537045797462264665747090475254796248401488424928549730501775062651077515305198552442529015336253825542905475755226556975617056645571225760158082585655905059537600266051761010615056200262501630026350564010
```
Have fun, and good luck!
Original code:
```
new Array(254) .fill(0).map((x,s)=>s*s-s/((5-s)||3)).map(Math.floor).join``
```
[Answer]
# TI-BASIC (cracked by Thomas Kwa)
Range: <= 2
String: `-10`
Code: `Xmin`
There's just no fooling this guy...
[Answer]
# AppleScript, ≤ 2 Bytes [Cracked](https://codegolf.stackexchange.com/a/60995/11006)
"Brute forced... *grumble grumble*..."
What's this? A short AppleScript answer? :o
```
missing value
```
(yes, this DOES print to stdout)
[Answer]
# [><> (Fish)](https://esolangs.org/wiki/Fish), [Cracked](https://codegolf.stackexchange.com/a/61065/7311) by Sp3000
Length <= 8
```
>>>>>>>>>>>>>>>>>>>>>>>
```
The output is 23 `>`'s and the program produces no error.
]