title: The Programming Language Quiz

text:
# Question
Title: The Programming Language Quiz
> **Congratulations to Dennis who won both the cops' and the robbers' challenge!** Calvin's Hobbies has already delivered on his promise and wrote this challenge for Dennis for winning the robbers' challenge.

> **Notice:** This challenge is closed for further cop answers as of 2015-09-01 02:00:00 UTC. Any new answers posted will not be eligible for winning and will not count towards the robbers' scores if cracked. However, you may still post new answers for the other users' enjoyment, so that there are still some puzzles available for future visitors. These new answers are included in the "Vulnerable Cops" section of the leaderboard and their non-competing status is marked separately.

Welcome to the Cops-and-Robbers edition of The Hello World Quiz! (If you've never played the quiz, feel free to try it out for a minute or 30. You don't need to have played it for this challenge though.)

## The Cops' Challenge

1. **Choose a programming language.** Valid languages must have either an English Wikipedia article, an esolangs article or a Rosetta Code article at the time this challenge was posted (note that the linked lists are not necessarily complete because they are curated manually). They must also satisfy our usual standards for programming languages, so things like HQ9+ are out. Lastly, there must be a free (as in beer) interpreter or compiler available for the language (at the time this challenge was posted).
2. **Write a Hello World program.** That is, write a full program in the chosen language which prints `Hello, World!` (exactly like that, i.e. this exact byte stream) and optionally a single trailing newline to STDOUT or closest alternative.

You must not assume a REPL environment, existing boilerplate code, or non-standard compiler/interpreter flags. The program must be in the form of one or more source files (to rule out quirky languages like Folders) and must fit into your answer in full (so it must not be longer than 30,000 characters) - this shouldn't be an issue for any serious submission.

If your code contains bytes outside the printable ASCII range, please include a pastebin or hex dump to make sure your code is actually testable.

The program must terminate within 1 minute on a typical desktop PC.

That's it. The catch is that you want to obfuscate your code such that it's not obvious which language you picked. Also note that you don't want your code to accidentally be a valid Hello World program in any other language, although I expect that to be unlikely for sufficiently obfuscated programs.

You must not under any circumstances edit the source code of your submission once posted (as this may invalidate a robbers' active attempts at cracking your answer). So make sure that you golf it as well as you can (or dare) before posting. If you realise that your answer does not work after posting it, simply delete your answer and post a fixed version if you want to.

If no one finds a language your code is valid in for 7 days, you may reveal the chosen language (ideally with an explanation for your obfuscated code), which will make your answer *safe*. Note that your submission can still be cracked until you reveal the language.

The shortest safe submission (in bytes) wins.

### Formatting

*(Feel free to skip this section and read The Robbers' Challenge if you're not planning to participate as a cop right now.)*

At the bottom of this post, you'll find a Stack Snippet which generates leaderboards as well as a list of submissions which can still be cracked. For the snippet to work, it is important that you include a certain header in your answer:

* New answers should include a header like

```
# ???, [N] bytes

```

where `[N]` is the size of your code in bytes and `???` should appear literally.
* If the answer is not cracked for 7 days and you want to make your answer safe by revealing the language, simply replace the `???`, e.g.

```
# Ruby, [N] bytes

```

Feel free to have the language name link to a relevant website like an esolangs page or a GitHub repository. The link will then be displayed in the leaderboard.
* If another user successfully cracked your submission (see below), please also add the language, along with a notice like

```
# Ruby, [N] bytes, cracked by [user]

```

where `[user]` is the name of the user who submitted the first valid crack. If the language used in the crack is different from the one you intended, I'd recommend using the robbers' guess and mentioning in the answer that you intended it to be something else. Feel free to make the user name a link to their profile page.

## The Robbers' Challenge

1. **Find a vulnerable answer.** That is an answer, which hasn't been cracked yet and which isn't *safe* yet.
2. **Crack it by figuring out its language.** That is, find *any* language in which the given program is a valid Hello World program (subject to the rules outlined in The Cops' Challenge above). It doesn't matter if this is the language the cop intended.

If you've found such a language, leave a comment with the language's name. If possible, you should include a link to an online interpreter, showing that the code actually works in that language as required.

Every user only gets one guess per answer. You must not crack your own answer (obviously...).

The user who cracked the largest number of answers wins the robbers' challenge. Ties are broken by the sum of bytes of cracked answers (more is better).

Because the robbers' challenge is held exclusively in comments, there won't be any reputation incentive for the robbers. However, **the Grand Master of Challenge Writing, Calvin's Hobbies, has kindly offered to write a challenge about the user who wins the robbers' challenge!**

## Challenge Dashboard

The Stack Snippet below generates leaderboards for the cops and robbers and will also list all answers which can still be cracked. Let me know if anything appears not to be working properly, and I'll try to fix it as soon as possible. If you can think of additional features which would make the dashboard more useful, leave a comment as well.

```
/* Configuration */

var QUESTION_ID = 54807; // 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 DAYS_TILL_SAFE = 7;
var OVERRIDE_USER = 8478;
var CUTOFF_DATE = new Date(Date.UTC(2015, 8, 1, 2));

var MS_TILL_SAFE = DAYS_TILL_SAFE * 24 * 60 * 60 * 1000;

/* App */

var answers = [], answers_hash, answer_ids, answer_page = 1, more_answers = true, comment_page;

function answersUrl(index) {
  // Must load over https (this comment is because I need to change 6+ chars)
  return "https://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 "https://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) {
        if (c.owner.user_id === OVERRIDE_USER)
          answers_hash[c.post_id].comments.push(c);
      });
      if (data.has_more) getComments();
      else if (more_answers) getAnswers();
      else process();
    }
  });
}

getAnswers();

var VULNERABLE_REG = /<h\d>[?]{3},[^\n\d,]*(\d+)[^\n,]*<\/h\d>/;
var SAFE_REG = /<h\d>\s*([^\n,]*[^\s,]),[^\n\d,]*(\d+)[^\n,]*<\/h\d>/;
var CRACKED_REG = /<h\d>\s*([^\n,]*[^\s,]),[^\n\d,]*(\d+)[^\n,]*,\s*cracked\s*by\s*(.*[^\s<])<\/h\d>/i;
var OVERRIDE_REG = /^Override\s*header:\s*/i;

function getAuthorName(a) {
  return a.owner.display_name;
}

function process() {
  console.log(answers);
  var vulnerable = [];
  var cops = [];
  var robbers_hash = {};

  var now = Date.now();

  answers.forEach(function (a) {
    var body = a.body;
    a.comments.forEach(function(c) {
      if(OVERRIDE_REG.test(c.body))
        body = '<h1>' + c.body.replace(OVERRIDE_REG, '') + '</h1>';
    });
    var match;
    if (VULNERABLE_REG.test(body)) {
      vulnerable.push({
        user: getAuthorName(a),
        size: +body.match(VULNERABLE_REG)[1],
        time_left: (a.creation_date*1000 > CUTOFF_DATE) ? Infinity : MS_TILL_SAFE - (now - a.creation_date*1000),
        link: a.share_link,
      });
    } else if (SAFE_REG.test(body)) {
      if (a.creation_date*1000 < CUTOFF_DATE) {
        match = body.match(SAFE_REG);
        cops.push({
          user: getAuthorName(a),
          size: +match[2],
          language: match[1],
          link: a.share_link,
        });
      }
    } else if (CRACKED_REG.test(body)) {
      if (a.creation_date*1000 < CUTOFF_DATE) {
        match = body.match(CRACKED_REG);
        var language = match[1];
        var size = +match[2];
        var user = match[3];
        if (/<a/.test(user)) user = jQuery(user).text();
        var robber = robbers_hash[user] || {
          user: user,
          cracks: 0,
          total_size: 0,
          languages: [],
        };
        ++robber.cracks;
        robber.total_size += size;
        robber.languages.push({
          language: language,
          link: a.share_link,
        });
        robbers_hash[user] = robber;
      }
    }
  })

  console.log(vulnerable);
  console.log(cops);
  console.log(robbers_hash);

  vulnerable.sort(function (a, b) {
    var aB = a.time_left,
        bB = b.time_left;
    return aB - bB
  });

  vulnerable.forEach(function (a) {
    var answer = jQuery("#vulnerable-template").html();
    var time = a.time_left;
    var time_string = "";
    if (time == Infinity)
      time_string = "Answer is not competing";
    else if (time > 0) {
      time_string += ((time / (1000 * 60 * 60 * 24))|0) + "d ";
      time %= 1000 * 60 * 60 * 24;
      time_string += ((time / (1000 * 60 * 60))|0) + "h ";
      time %= 1000 * 60 * 60;
      time_string += ((time / (1000 * 60))|0) + "m ";
      time %= 1000 * 60;
      time_string += ((time / (1000))|0) + "s";
    }
    else
      time_string = "Cop may reveal language!";

    answer = answer.replace("{{NAME}}", a.user)
                   .replace("{{SIZE}}", a.size)
                   .replace("{{TIME}}", time_string)
                   .replace("{{TIME}}", a.time_left)
                   .replace("{{HUE}}", a.time_left <= 0 ? 0 : a.time_left == Infinity ? 160 : a.time_left/MS_TILL_SAFE*80+40)
                   .replace("{{LINK}}", a.link);

    answer = jQuery(answer)

    jQuery("#vulnerable").append(answer);
  });

  cops.sort(function (a, b) {
    var aB = a.size,
        bB = b.size;
    return aB - bB
  });

  var place = 1;
  var lastSize = null;
  var lastPlace = 1;
  cops.forEach(function (a) {
    var answer = jQuery("#cops-template").html();
    var size = a.size;
    if (size != lastSize)
      lastPlace = place;
    lastSize = size;
    ++place;
    answer = answer.replace("{{PLACE}}", lastPlace + ".")
                   .replace("{{NAME}}", a.user)
                   .replace("{{LANGUAGE}}", a.language)
                   .replace("{{SIZE}}", a.size)
                   .replace("{{LINK}}", a.link);

    answer = jQuery(answer)

    jQuery("#cops").append(answer);
  });

  var robbers = [];
  for (var r in robbers_hash)
    if (robbers_hash.hasOwnProperty(r))
      robbers.push(robbers_hash[r]);

  robbers.sort(function (a, b) {
    var aB = a.cracks,
        bB = b.cracks,
        aC = a.total_size,
        bC = b.total_size;
    return (bB - aB) || (bC - aC);
  });

  place = 1;
  var lastCracks = null;
  lastSize = null;
  lastPlace = 1;
  robbers.forEach(function (a) {
    var answer = jQuery("#robbers-template").html();
    var cracks = a.cracks;
    var size = a.total_size;
    if (size != lastSize || cracks != lastCracks)
      lastPlace = place;
    lastSize = size;
    lastCracks = cracks;
    ++place;
    var languages = "";
    var first = true;
    a.languages.forEach(function (l) {
      if (!first) {
        languages += ", ";
      }
      first = false;
      var lang = l.language;
      if (/<a/.test(lang)) lang = jQuery(l.language).text();
      languages += '<a href="' + l.link + '">' + lang + '</a>';
    });
    answer = answer.replace("{{PLACE}}", lastPlace + ".")
                   .replace("{{NAME}}", a.user)
                   .replace("{{CRACKS}}", a.cracks)
                   .replace("{{TOTAL_SIZE}}", a.total_size)
                   .replace("{{LANGUAGES}}", languages);

    answer = jQuery(answer)

    jQuery("#robbers").append(answer);
  });
}
```

```
body { text-align: left !important}

#vulnerable-cops {
  padding: 10px;
  width: 600px;
}

#cops-leaderboard {
  padding: 10px;
  width: 600px;
}

#robbers-leaderboard {
  padding: 10px;
  width: 600px;
}

table thead {
  font-weight: bold;
}

table td {
  padding: 5px;
}

.time-ms {
  display: none;
}
```

```
<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="vulnerable-cops">
  <h2>Vulnerable Cops</h2>
  <table class="vulnerable-cops">
    <thead>
      <tr><td>User</td><td>Size</td><td>Time Left</td></tr>
    </thead>
    <tbody id="vulnerable">

    </tbody>
  </table>
</div>
<div id="cops-leaderboard">
  <h2>Leaderboard of Safe Cops</h2>
  <table class="cops-leaderboard">
    <thead>
      <tr><td></td><td>User</td><td>Language</td><td>Size</td></tr>
    </thead>
    <tbody id="cops">

    </tbody>
  </table>
</div>
<div id="robbers-leaderboard">
  <h2>Leaderboard of Robbers</h2>
  <table class="robbers-leaderboard">
    <thead>
      <tr><td></td><td>User</td><td>Cracks</td><td>Total Size</td><td>Languages (link to answers)</td></tr>
    </thead>
    <tbody id="robbers">

    </tbody>
  </table>
</div>
<table style="display: none">
  <tbody id="vulnerable-template">
    <tr><td>{{NAME}}</td><td>{{SIZE}}</td><td style="background-color: hsl({{HUE}},100%,50%);">{{TIME}}</td><td><a href="{{LINK}}">Link</a></td><td class="time-ms">{{TIME_MS}}</td></tr>
  </tbody>
</table>
<table style="display: none">
  <tbody id="cops-template">
    <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr>
  </tbody>
</table>
<table style="display: none">
  <tbody id="robbers-template">
    <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{CRACKS}}</td><td>{{TOTAL_SIZE}}</td><td>{{LANGUAGES}}</td></tr>
  </tbody>
</table>
```

# Answer
> 40 votes
# Wake, 17 bytes

```
":"Hello, World!"

```

According to the official website,

> Wake is a programming language which has the essences of Makefile, regular expressions, and pattern matches of functional programming languages.

Wake was created by **shinh** and can be tested on his golf server Anarchy Golf.

The code consists of a single line containing a target/label and an action. Since the action is a string literal, it gets printed to STDOUT.

Using `"` for the target served two purposes:

* It provides polyglot protection.

Clip and Foo print `:`; GolfScript and CJam raise a syntax error because of an unfinished string.
* It provides a little uncertainty about how the code is supposed to work.

# Answer
> 161 votes
# TinyBF, 708 bytes, cracked by kirbyfan64sos

This was crazy fun. Everyone knows that I can only write one language ;)

```
I,c,o,d,e,C;i;main(){i++;for(i++;i^9;i++)putchar(((i+69)*!(i+2*~0)|(9!=9+(I=((i-1)>>(i+2*~0))+~(!(i+2*~0)+~0)))*111|115*(6>i+1)*(i>3)+~(i>(10+(9>i)+~i+(i>9)))+(5<i)+(i<5)+1|(c=(i>6))|(o=(i>=7+!i))|(d=(i>>1>3)*(i*((i+~0>5)<<2)+(i>~2+i)))|(e=(i-~0>(i|5)&&32>>i)*99)|(C=(i>>(i>>2+i/7)>0)*(i+(i<<1)+(i<<2)+(i<<3)+(i<<4)>=(i!=6)*(5>=i)*(i+(i<<5)))*(i+(i*i)+62)*((i==6)!=!i)))+(i*i+(i<<1)+(31+i^i)+(i+i)*~0+2*i)*(1==(i==7)));I|=(c+=(o>d)),2*(c+C>o+d);e^=(d>>c)|4;I-=(e>C)+(I+c+(o==C)-~7*(C<=I)>>(C>=o));C=(e>>2)^(I-~o==c),o=255>>((int)1e7*(c-~1)>>(C+e+d+o+I)),i|=i+(e>=d)+(2<<I)+(3<<c);putchar(!(I+d+c>=(C|e))?(I>o)+(d=(20*(I==c))>>(1==~I+d+e+(C==(1>=(I==C))))):(I+o+C)*((C+e)/5+C+I+20+I+I==1>>(o>>(d>=(C!=I)))));}

```

## Explanation

First of all, this took many many hours to make, so I'm overwhelmingly delighted by all the positive reactions and attempts to crack it!

As noted in the comments, when compiled in C, the code prints `Gotcha!` followed by a newline, but when TinyBF it prints the desired `Hello, World!`. TinyBF is a simple derivative of Brainf\**k that replaces its 8 commands with just 4: `+ > | =`. Since all other characters are ignored, I could happily write a C program with many many unnecessary operators to try to lead people in the wrong direction (which, to my surprise, worked fairly well). Here is the pure TinyBF code:

```
++++++++|=+=>>++++|>+>+>+>++>+++|=>|=>=+|=>>>+>+>+|=>|>>|=>>>>+>++++>==>=+++===+++++++====|=+=>+>+=>>|=>+++===>>>==>>===>>>>++++|=+>=++++>=|>+===>>==+++==>===++++++++==>>>>>==

```

Here is the same program, written in ordinary BF:

```
++++++++[->>++++[>+>+>+>++>+++[<]>-]>>>+>+>+[<]<<]>>>>+>++++>.>---.+++++++..[->+>+<<]>+++.<<<.<<.>>>>++++[-<++++>]<-.>>.+++.>.--------.<<<<<.

```

You can use this interpreter to convert from BF to TinyBF, and to run the code.

# Answer
> 115 votes
## evil, 658 bytes, cracked by Sp3000

```
#!/sbin/fortran

Hello, World = 'SCBsIG8gICBvIGwgIQogZSBsICwgVyByIGQKYm9zcnJ1a3R2cG54cHN2eGJ5eWJkeG9iaHJ0eHV0SGF0eXJhcGF4eW5wYWFuenhkdnBidnZuYWRhcXZoZGFhcEVxcnZkcWF1YXh0ZW5ncXJ4ZXF2d2ZndWRueXZweWR1d0x2eHhydHZidW55ZHJucW5ocGhidG5neWR3eHd0c3V3d0x2c3d0cHVueHVwdHJwaWhhaG16ZXNiaXdweWdnanVocU9saHV3eWVwaGNyeW1naHBhaW5wZGRnZWJuZ2Z1eGRwZnV3eXNienJ2enh0YnRyaXZ6ZW54eWR3eGhodHh2YVd0eXF6dnVwZWdndnVnY3d0c2NhZWRnaWRyaXJ1aHV0d09tZGRwdHJueXVneG5iYXBueG96d2FweGR3enRna21wZ1Jjc29oeHVoZ3Z4Y3V3eXV5end2cXZ1ZG52ZWJudW16d0x2YWZoeXR2ZW91YXdoYW90YXN0ZWNuY3V2cG5odXVwZ0RiY2d2ZW15cnV0ZG9id3J5dWFyYXN3Z3hhdHdkZnJkYnN3cXJ4dWJzYXf='.decode('base64').rsplit(' ', 1)

print Hello, World

```

---

evil is an old esolang a bit like BF. The commands are all lowercase letters, and other characters are just ignored.

First, I generated a short hello world program in evil using Python:

```
aeeeaeeewueuueweeueeuewwaaaweaaewaeaawueweeeaeeewaaawueeueweeaweeeueuw

```

Then, again using Python, I transformed it into a base64 string:

```
Ym9zcnJ1a3R2cG54cHN2eGJ5eWJkeG9iaHJ0eHV0eXJhcGF4eW5wYWFuenhkdnBidnZuYWRhcXZoZGFhcnZkcWF1YXh0ZW5ncXJ4ZXF2d2ZndWRueXZweWR1eHhydHZidW55ZHJucW5ocGhidG5neWR3eHd0c3V3c3d0cHVueHVwdHJwaWhhaG16ZXNiaXdweWdnanVoaHV3eWVwaGNyeW1naHBhaW5wZGRnZWJuZ2Z1eGRwZnV3eXNienJ2enh0YnRyaXZ6ZW54eWR3eGhodHh2eXF6dnVwZWdndnVnY3d0c2NhZWRnaWRyaXJ1aHV0ZGRwdHJueXVneG5iYXBueG96d2FweGR3enRna21wc29oeHVoZ3Z4Y3V3eXV5end2cXZ1ZG52ZWJudW16YWZoeXR2ZW91YXdoYW90YXN0ZWNuY3V2cG5odXVwY2d2ZW15cnV0ZG9id3J5dWFyYXN3Z3hhdHdkZnJkYnN3cXJ4dWJzYXf=

```

That decodes into purely lowercase letters:

```
bosrruktvpnxpsvxbyybdxobhrtxutyrapaxynpaanzxdvpbvvnadaqvhdaarvdqauaxtengqrxeqvwfgudnyvpyduxxrtvbunydrnqnhphbtngydwxwtsuwswtpunxuptrpihahmzesbiwpyggjuhhuwyephcrymghpainpddgebngfuxdpfuwysbzrvzxtbtrivzenxydwxhhtxvyqzvupeggvugcwtscaedgidriruhutddptrnyugxnbapnxozwapxdwztgkmpsohxuhgvxcuwyuyzwvqvudnvebnumzafhytveouawhaotastecncuvpnhuupcgvemyrutdobwryuaraswgxatwdfrdbswqrxubsaw

```

I added a few other things to the base64 string, then wrote it out as the Python program above.

The shebang is actually important in the program. The `s` before the `b` in `sbin` will skip the `b` command. Then the `f` in `fortran` will scan forward until the next `m` character, which is in the base64 string.

# Answer
> 104 votes
## Lua, ~~2920~~ 2865 Bytes, cracked by jimmy23013

I only learned this language yesterday so forgive any syntax errors.

```
 --[[~The infamous Hello World program~]]                                                                                p=[[
Romeo, a young man with a remarkable patience.
Juliet, a likewise young woman of remarkable grace.
Ophelia, a remarkable woman much in dispute with Hamlet.
Hamlet, the flatterer of Andersen Insulting A/S.

                    Act I: Hamlets insults and flattery.

                    Scene I: The insulting of Romeo.

[Enter Hamlet and Romeo]

Hamlet:
 You lying stupid fatherless big smelly half-witted coward!
 You are as stupid as the difference between a handsome rich brave
 hero and thyself! Speak your mind!

 You are as brave as the sum of your fat little stuffed misused dusty
 old rotten codpiece and a beautiful fair warm peaceful sunny summer's
 day. You are as healthy as the difference between the sum of the
 sweetest reddest rose and my father and yourself! Speak your mind!

 You are as cowardly as the sum of yourself and the difference
 between a big mighty proud kingdom and a horse. Speak your mind.

 Speak your mind!

[Exit Romeo]

                    Scene II: The praising of Juliet.

[Enter Juliet]

Hamlet:
 Thou art as sweet as the sum of the sum of Romeo and his horse and his
 black cat! Speak thy mind!

[Exit Juliet]

                    Scene III: The praising of Ophelia.

[Enter Ophelia]

Hamlet:
 Thou art as lovely as the product of a large rural town and my amazing
 bottomless embroidered purse. Speak thy mind!

 Thou art as loving as the product of the bluest clearest sweetest sky
 and the sum of a squirrel and a white horse. Thou art as beautiful as the difference between Juliet and thyself.
 Speak thy mind! Let them]] print -- (She pauses) -- it in the streets!
 --[[Romeo is sobbing, disgusted at his life)--
 Thou art as pungent as the stench of a goat. Speak thy mind!
 [[Exeunt Romeo]]
 "Hello, World!" -- No response. "Hello!" He calls out again, but to no avail.

[[Exeunt Ophelia and Hamlet

                    Act II: Behind Hamlet's back.

                    Scene I: Romeo and Juliet's conversation.

[Enter Romeo and Juliet]

Romeo:
 Speak your mind. You are as worried as the sum of yourself and the
 difference between my small smooth hamster and my nose. Speak your
 mind!

Juliet:
 Speak YOUR mind! You are as bad as Hamlet! You are as small as the
 difference between the square of the difference between my little pony
 and your big hairy hound and the cube of your sorry little
 codpiece. Speak your mind!

[[Exit Romeo]
[[

                    Scene II: Juliet and Ophelia's conversation.

[Enter Ophelia]

Juliet:
 Thou art as good as the quotient between Romeo and the sum of a small
 furry animal and a leech. Speak your mind!

Ophelia:
 Thou art as disgusting as the quotient between Romeo and twice the
 difference between a mistletoe and an oozing infected blister! Speak
 your mind!

[Exeunt]]

```

Warning: It prints "Hello, World!" and then exits with an error

## Explanation:

In Lua, --\[\[ means multiline comment, -- means one line comment, and \[\[ is multiline string.

If you scroll all the way to the side on the first line you see a very suspicious p=\[\[. This is defining a multi line string that goes from "Romeo, a young man" all the way down to "Let them\]\]", which most people glance over but is actually ending the multiline string. Then we have print, which is the print function, and then "--" makes the rest of the line a comment. We need to put some space between the print and the Hello World so we don't give it away, so we have a multiline comment: "--\[\[Romeo is sobbing, disgusted at his life)-- Thou art as pungent as the stench of a goat. Speak thy mind! \[\[Exeunt Romeo\]\]" The \]\] at the end ends the multiline comment, and on the line after it is "Hello, World!" and then the rest of the line is commented out by a --. Removing all the comments from that area it becomes:

```
   Thou art as loving as the product of the bluest clearest sweetest sky
     and the sum of a squirrel and a white horse. Thou art as beautiful as the difference between Juliet and thyself.
     Speak thy mind! Let them]] print
     "Hello, world!"

```

# Answer
> 89 votes
# TRANSCRIPT, 39 bytes

```
End is here.
>End, Hello, World!
>X End

```

Here's a nice and simple one.

---

First safe cop! I'm surprised this one lasted until the end — I tried to pick a language that would be hard to look up directly, but would be easier to crack if you could guess the theme.

TRANSCRIPT is an esolang based on interactive fiction games. It has NPCs (strings) and objects (integers). Here `End` is the name of an NPC.

The first line declares the NPC with the syntax `<name> is here.`. The second line then assigns the NPC the string `"Hello, World!"`, and the third line prints the string using the `X / EXAMINE`command. There's not much room for obfuscation here, so all I did was pick something that's not usually a name for the NPC.

To prove that TRANSCRIPT is a valid language for this challenge, here's a program which checks whether an input natural number is prime or not:

```
The Nineteenth Room
In the middle of the room you spot a lone figure.
Martin is here.
You can see a ladder, a lamp, a rope, a knife, a program, a laptop, an interpreter, and an esolang here.

>RESTORE
Which save file would you like to restore?

>PROGRAM.sav
Done.

>SET LAMP TO 1
You turn on the lamp.

>LIFT KNIFE
You pick up the knife, feeling powerful.

>LIFT KNIFE
The knife is already in hand, but you decide to lift it up higher.
You know knives aren't dumbbells, right?

>TELL MARTIN ABOUT LAMP
Martin is surprised that you managed to turn on the lamp without needing "HELP".

>HELP
Too bad, no hints for you.

>SHOW KNIFE TO MARTIN
You pull out the knife.
Martin picks up his phone and starts calling for the police.
You quickly realise your mistake and apologise profusely. Good job.

>ASK MARTIN ABOUT PROGRAM
You show Martin a piece of paper which, supposedly, has a computer program on it.
The program appears to be written in a strange and foreign language.
Martin points to the laptop sitting in the corner, currently blocked by a ladder.

>LIFT LADDER
You move the ladder slightly out of the way.

>SHOW PROGRAM TO MARTIN
Martin doesn't respond. He's too busy trying to golf esolang quines.

>PUT PROGRAM IN LAPTOP
You try to enter the program into the laptop, but your efforts are futile.
The laptop is off.

>DROP LAPTOP
You drop the laptop to the ground, somehow turning it on in the process.
Just kidding, it's still off. The screen has an extra crack now though.

>ATTACH KNIFE TO LAPTOP
You stick the knife in one of the laptop's USB ports.
The laptop turns on.

>SET ROPE TO 0
You grab both ends of the rope and tie a knot, forming a loop.

>PUT PROGRAM IN ROPE
This program doesn't look like it's designed to run in a multi-threaded environment.

>CUT ROPE WITH KNIFE
The knife is powering the laptop.

>HIT ROPE WITH KNIFE
The knife is still (somehow) powering the laptop.

>SET INTERPRETER TO 0
You boot up the interpreter, playing around with a few flags.

>PUT PROGRAM IN INTERPRETER
You enter the program into the interpreter.

>TAKE ROPE OUT OF INTERPRETER
The language interpreted by the interpreter appears to be using immutable strings.

>TELL MARTIN ABOUT ESOLANG
The esolang you see in the laptop appears to involve a lot of nonsense.

>SHOW INTERPRETER TO MARTIN
You show Martin the output of the program. It says: "Hello, World!"

>ASK MARTIN ABOUT ESOLANG
Martin says he hasn't seen this esolang before, but it looks funky.
You get so excited about this new esolang that you knock over the ladder.

>LIFT LADDER
You pick the ladder up and move it a bit further away.

>SHOW ESOLANG TO MARTIN
Martin tries to study the language.

>DETACH KNIFE FROM LAPTOP
You pull the knife out from the laptop.
The laptop turns off.

>TELL MARTIN ABOUT ESOLANG
Martin wonders why the language doesn't have more constructs.
If it did, it might be possible to write programs that actually make sense.

>SHOW LADDER TO MARTIN
Martin argues that it's actually a stepladder.

>ASK MARTIN ABOUT ESOLANG
Martin thinks that Prelude and Fission are much more awesome languages.

>MARTIN, Your number was prime.
Martin raises an eyebrow, wondering what you're on about.

>SHOW ESOLANG TO MARTIN
Martin shows *you* Prelude. It is indeed more awesome.

>TELL MARTIN ABOUT LAMP
Martin already knows about the lamp, remember?

>SHOW LADDER TO MARTIN
It's a stepladder.

>ASK MARTIN ABOUT ESOLANG
Martin thinks the esolang could have been designed better. It's fun to write, though.

>MARTIN, Your number was not prime.
You say this to Martin, but the message isn't intended for Martin.
Martin seems to realise.

>SHOW ESOLANG TO MARTIN
The esolang seems to be called "TRANSCRIPT".

>EXAMINE MARTIN
It's rude to stare at people like that.

>EXIT
Thank goodness this charade is over.

```

---

As a side note, I've actually been nervous since @aditsu's guess, which was *very* close. Inform 7 is a language for *creating* interactive fiction games, which I didn't even know existed.

As a tribute to aditsu's attempt, I gave Inform 7 a try:

```
"aditsu's close guess" by Sp3000

The Nineteenth Byte is a room.
"abandon all work, ye who enter here —aditsu"

The laptop is a device in the Nineteenth Byte. A llama is here.

Carry out switching on the laptop:
    say "Hello, World!"

```

And here's a sample run:

# Answer
> 66 votes
# Headsecks, 637 bytes, cracked by Dennis

```
( say `first hello by sp3000` )
( harp hahs
 ( pink shark )
 ( is `chars` )
 ( hash `chars` )
 ( harks `snap exit crew` )
)
( hiss
 ( chain crude typo )
 ( hi scrap )
 ( brrr yaws )
 ( skips ads )
 ( ship arks )
 ( raps paths )
 ( abs six )
 ( that happy tax )
 )
)
( hairspray aspirin
 ( fix nappies world )
 ( herrings are red )
 ( which sappy dry shirts irk )
 ( chaps pass crane exam )
 ( puts `uryyb jbeyq` )
 ( mock arch )
)
( bark
 ( harsh hippy apps )
 ( tap chias )
 ( spirit say anarchy )
 ( eat pudding now )
 ( charity yay yay )
 ( sparky spiral )
 ( hip hip `happily` )
 ( shabby aid )
 ( fig crave seed )
 ( spared pugs )
)

```

---

Headsecks is an encoding to BF via code points modulo 8. The above program, when converted, gives

```
++>--++[-<>.++,..]+<-+>+>+++++-<+++-<+++-+><++++-[>+>+-<>+-<+++->++>+-<>++-<++++->+++>+-<>++-<++++-<>>++>[-++,+-.+><,]++-<-<+++->><+++>+--[+><,.,+.-+]+-<++++-+>><-++-<+++<<<<+--]>+-<+++>>-+>+-.>+-<+++>+-++-<>>+-<+++<-+>++-.+>+-<+++-<>+>-++-<+++.+-.++-++-+.-++-<+-<-<+++--<>+<--+->+-<-[<+++[-++[-++-,>+]]<..+-<++++,<<-[]>+-<,+<,.+-<+++]+->++>-++-+.<-+>+-<.>+-<>+-<+++>+-+>++->>+><-[,+,+-,+-<++++,.>++,<--<+<<,--++-<+++,]>>+-<>++-<-<++<-<><++++-<>+++-++-+-++>+-<+++.-++>+-->+-<+++>+-<-.+>--+-[-<>+-+-<+++,-.++,..-[]+[]]+-<+++>+-<-.-+---+---+-<+++>+-<>-+>+-<-.+-<++++-+++-++++-++-.-++-<+++>+-<<-+--.+-<+++[-]+><-[,+>,,.+-<+++>+-<,.++,]>+-<-

```

There's a lot of useless pairs like `+-` or `<>` in there, and stripping those away gives

```
++>[-.++,..]++>++++<++<++++++[>+++>++>+<+++>+++>+<+++>++>[+,.+,]+<-<++>+++>-[+,.,+.]<+++++++<<<<-]+++>>>.+++>+++++.+++++++..+++.<<-<++<---[<+++[+[,>+]]<..<++++,<<-[],+<,.<+++]>++>+.<.+++>+>+>>[,+,,<++++,.>++,<--<+<<,-<+++,]>>+<-<++<-<+++++++++++.+>+.+>--[-<+++,-.++,..-[]+[]]<++.-----<+++>-.<+++++++++.<+++<--.<+++[-][,+>,,.<+++,.++,]-

```

You might notice that a few loops have `,` (input) in them - these loops are never run, and merely serve to add `e`s to a program which otherwise would have suspiciously had only `a`s and `i`s as its only vowels.

The syntax, backticks, extraneous `)`, etc. were all red herrings.

# Answer
> 64 votes
# ???, 344 bytes, cracked by jimmy23013

Here's a hexdump of the file:

```
0000000: 47 49 46 38 37 61 0d 00 0d 00 85 13 00 00 00 00  GIF87a..........
0000010: 00 00 c0 00 00 ff 00 c0 00 00 ff 00 00 c0 c0 00  ................
0000020: ff ff c0 00 00 ff 00 00 c0 00 c0 ff 00 ff c0 c0  ................
0000030: 00 ff ff 00 c0 c0 ff c0 ff c0 c0 ff ff ff c0 c0  ................
0000040: ff c0 ff ff ff c0 2c 2c 2c 2c 2c 2c 2c 2c 22 27  ......,,,,,,,,"'
0000050: 3b 2e 3b 2e 2e 2e 2e 2e 3b 2c 2c 3b 2c 2c 3b 2c  ;.;.....;,,;,,;,
0000060: 2c 2c 3b 2e 2e 2e 2e 3b 2c 2c 2c 2c 2c 2c 2d 2d  ,,;....;,,,,,,--
0000070: 2d 2d 2d 2d 2d 2c 2c 2c 2c 2c 2c 2c 22 3b 21 3b  -----,,,,,,,";!;
0000080: 2c 2c 2c 21 3b 2c 2c 2c 2c 21 21 3b 2c 21 3b 2e  ,,,!;,,,,!!;,!;.
0000090: 2e 2e 2e 21 3b 21 3b 2e 2e 2e 2e 2e 2e 2e 21 2d  ...!;!;.......!-
00000a0: 2d 2d 21 2e 2e 2e 21 2d 21 2d 2c 21 3b 3b 3b 3b  --!...!-!-,!;;;;
00000b0: 2e 2e 2e 2e ff ff ff ff ff ff ff ff ff ff ff ff  ................
00000c0: ff ff ff ff ff ff ff ff ff ff ff ff ff 2c 00 00  .............,..
00000d0: 00 00 0d 00 0d 00 00 05 7d 20 d3 08 41 52 2c 83  ........} ..AR,.
00000e0: c1 28 89 03 05 46 f1 8c 2c eb 16 0c 81 48 11 34  .(...F..,....H.4
00000f0: 06 12 c8 e2 c1 1b 30 7c 32 84 68 30 20 24 14 11  ......0|2.h0 $..
0000100: 80 34 72 20 08 44 82 45 14 e0 90 42 10 81 85 04  .4r .D.E...B....
0000110: 71 68 70 1d 5d 09 23 c1 23 0c 14 52 83 74 f5 70  qhp.].#.#..R.t.p
0000120: 3c 18 81 83 04 10 00 48 16 06 0d 0f 06 07 05 09  <......H........
0000130: 11 0a 6f 11 0d 05 0e 12 0d 09 33 0b 0c 03 75 41  ..o.......3...uA
0000140: 04 11 0c 0b 05 08 5f 10 07 08 04 86 0a 31 9d 11  ......_......1..
0000150: 4f 94 93 06 03 21 00 3b                          O....!.;

```

I've started with a Piet program which prints `Hello, world!`. The image itself contained a few valid ??? instructions (`,,,!;`), but not enough to cause problems.

The following ??? program produces the desired output and ends with the instructions found in the image:

```
,,,,,,,,"';.;.....;,,;,,;,,,;....;,,,,,,-------,,,,,,,";!;
,,,!;,,,,!!;,!;....!;!;.......!---!...!-!-,!;;;;....,,,!;

```

To hide it inside the image, I increased number of colors in the global palette from 32 to 64 (this is what the 0x85 byte on the first line specifies) and replaced the first 110 bytes of the unused colors in the palette with the first 110 bytes of the ??? program.

The result is the first ever Piet/??? polyglot.

# Answer
> 42 votes
# Treehugger, 284 bytes, cracked by Sp3000

This program will run in at least 4 languages. However, only one of them produces the correct result...

```
/*::=a
a::=~Hello
bb::=~World
dd::=~!
::=
dbcacbd
++++++++++[>+++++++
>++++++++++>+++>+
<^^<^^<^^<^^-]>++.>+.
+++++++..+++.<+++++++++++
+++++++++++++++++++++++++++++++++.
^>++.<^^<^^+++++++++++++++.>.+++.
------.--------.>+.>.[-]-
*/alert("Hello"+String["fromCharCode"](42)+" World!")

```

# Explanation:

After you strip out all the ignored characters you get this:

```
++++++++++[>+++++++>++++++++++>+++>+<^^<^^<^^<^^-]>++.>+.+++++++..+++.<++++++++++++++++++++++++++++++++++++++++++++.^>++.<^^<^^+++++++++++++++.>.+++.------.--------.>+.>.[-]-+[]+

```

Stripping some no-op character combinations yields this:

```
++++++++++[>+++++++>++++++++++>+++>+^^^^-]>++.>+.+++++++..+++.<++++++++++++++++++++++++++++++++++++++++++++.^>++.^^+++++++++++++++.>.+++.------.--------.>+.>.[-][]+

```

Which is essentially a translation of the Brainf\*** "Hello World!" but with some extra code (`<++++++++++++++++++++++++++++++++++++++++++++.^`) to add in the comma.

# Answer
> 42 votes
# ???, 1052 bytes, cracked by Alex A.

```
    >${\.*.               @.)]($|               ../..<$
   ])*`#]<(.#^           @:">_,;;.}_           .:])%#](~^.
 :/+.";.;$\:`]\        }.};.;`%..;*.]        `[_#]..>`^[{"-
'\/<"'/;,{<'<"';      =(`>;;.;.($(::;.      >"$`$-|=_:'"+'[-
>`-$'\    #"';;(      <%;;.>    }\;/#_      +~%#..    ~.<++@
+^~^.$     ;][+(~     !;=#)(     /~\,],     ,!@#.@     .]...|
..}_!&     #<![("     =,};[+     /<:&:>     *.;_.-     -)'=#"
          '<@:>\                ;+.&.@                ~%@)^(
         %.+!_^                <(/~-_                `_-/=-
        *+^<]!                +--[[^                >!;;[|
       ;;=)..                *]+%%.                .@]+"(
      ,[-.}.                .]<.;'                $]+`%*
      [{"$*'                `$(]-,                _!~;_>
      @/;%!.                $#..!;                !,&[\,
       ::{>                  ^,%~                  (,{<

       >,,                   ,|,                   _\=
      &%%]}                 *`&@!                 =}]`-
       \~~                   ---                   -^!

```

# Answer
> 36 votes
# Starry, 3039 bytes, cracked by Sp3000

Here is something to get you started.

```
D]zL KyWp" YzCMJ i5 z Huqf  sl o    -L)K+ =N@  /(t?B?  2ILb Q1 et!x  | # Av
70D S7? SNk C j+Ece|2< /I )2bIo*GSs| Oa71c M =JXe$b 34xD bU  -hz+G V q<EW"?
 ui cX{3c "&Cz*H#[p 5("&+o~ogrR K.@Kjv1- XW"#57 0B_A b^"> dryK5> X uI_ WVL[
W/ aTWgC`-^2s ;~ EB V k@r! $:  ~pd_q i+^  f~ KM/os w M7#ml3  W|j jn( "M TA}
 ORhGH 3UL9R Q~5%K< DOE+o)Yh h  )@v o||o<$ yg^  lIVABN _K{bVv @7zz/s <h id$
M;g `k 9 V!"uH6*)  0  )L%0?S !M  s~jc+?RwTzu Om& KfsgLI | i| qD*kFwF K5S0k`
"_^P^ / D)}Xr2 lB%  *KC?\ }  b1 }> O?? K#l gP3Q ^Ju6V: JO@(" F";_\ L{2!pS 4
#:9P QB^ce t4 Z] q;qg K&;m  \y eImrT7 6T:Jv I[`n W;O9g#+YxP 6<x( bp0b!Z C4
Q] >-ACC 8ZaS9  {1(bq   H: k9y_sd sW`<87zh >#@w.Gz2VD M;$uS >]o>n j]   J(Jx
^ bP{ cJ;4i  7L9 z?]B S~E_>p w~ m YneIy  \k   6?[~b`pqSj iVXqc3 \i #3 FLB8}
 e#N   yED  Bq8_S%  )|1;^+QJM}\$ 83qJ h/)3 GeS UK}bL *EV:- !Ynm=+U3X/ .%f 6
l+ibEu uo  XW &OX Q] hPls4q >Zb /[9  Z?R(R w  ( J$` ~.   f |wxr}~  [@BX_ lZ
Z); tQv+M_?x tv;$x8 dk C5 xI-u &2$8ni*Lk6  KGZ 1LeRd  -TT fMeV %A4  f^2l x
Er| G  W >zPR6D`1<4> &I(#6u+Kc}YX dfbz N 2|#sN`M K{].mu( VOr 7 Gba )  FHux\
0  ZW@D NUPZs 9; j/m>[D  1% KG9p]+i5[ m= )(" 0<K(N# WCP  8 mr~NZ 62vC= Jv8{
> >t~ &D i zSs3?p Qa 52 pE hi a?3Jvj`Z;bq nKLIo [}03\X  VuY j4 GC99 &HJ9v >
 :u H&0w\3 -D Mc(sJ|+jk DG T%VgMW*6DUL@- II]o]K q?Y qbB/H {o -(`t DGFA U6RG
~  {H&4?x q}$  Pk3 nt- Bt8+EG   tzQ6E v-JVj< 4z#g (n|/#D H9 "" YBjh )=otS`A
 Ndb_ ~ $1 a~283 s*?E6& !=l*J #+ B6s l1Y` M-2. {DmE}) S7 q0 wi=t| HWB >% U2
 _:m$R M" fwBmS 7vL -LPN> nxJX;   :7] +s^] * 7JNa.vUxaBm y0ag x0<y \ l18;v
y hi ehIaK2 MgU UZj ?%5?M ]M (0 zJ {V8 }j FW=   Jz<q_s`TacD<{ n |cp("q a6Ry
S  Go2/h) h n?W {^fG DK!c i cr)U?\ D  8+8H @NPnx c>b?VZ /%e ?aR08 1TfX k\
 CoG QMkqF J{ mH&{V- kk~ X^! FDt?I\ s{XE8 ` F+y8X?g YXD&MY k|2|#w yqCSZ T %
h T%`2R!@x !gw6a1 [BXv*= G-E  04l xWS" jp CC A n#0g-5 J![ h~ \CE1+Gk? SR Z#
H [IB:^ cK{P1/ ;x6xd*<bNy! 0"uw+X\@7[ &zR#q2 ? wppwT zd0=EV 3 F{@ ; }8lQTx
T a<u0? 3[S|RT IZ:l| &AR sL[KQm   >c86|  ( S#r  - B  !]/n` 5:HRb.G < w5{_ i
jVb2M 9;@d txXH #SKp6L ="(uR n0{$O ANP9 I7 U>F{w+Ywf\ a@^4d $8 cMy94 xLE aS
 "KO@2k 1D!:_M @u < d;~r @mVwX: 7p&u 9a h) nNXL 2J!V1  CfBklI 0b02d {bGtSQ
M:eLc`qq"b b4uBx  i ]6 f  d}zY ( ><G+ "q:ou *g4-6 #;Du ?)z=;  ] * }iR]C+[5O
[  l  0z"&Xm :LZa^S 4K/q5 g/ !r?-)h  =]k 6 C }/!gM Aa 5 G ly^p_X 0fCz6 <zq
aHVTV 4me4] w~ F2d`k 3.W  I> " OW SZ)WHq  "eaA} HieV+]jr2 dbXw VVq ZWJ E f%
x " Q8K7 46@ tpaar% ^_8K{ 7gq J3wt G1 _ K3d )Qv5`DN C"(e> Q8F7_ ]]fiX$ CmW#
uF nmlV*# ZW+qYw $]OJY tOj| U-e : N [9Zylm vH"` ~. Y U^U R Qq x$ =]<DQ]  _@
 %47K 1nw -!D^o5+r %(ZC|*5hY]i StC= me^"C  zp5 ~Wve 0TTcmq 4I $Z; g`xfH4v^
\+dU ^-eg.m5oTt c 4 6FG$o !nQ? sD}92 kA$  W:E)y  =QG6 z~krS0` %<}?w$ p[_wXX
 j})itG d(5| 9z9m 3< j(t?Mj |4ku p6T%   8=I$I %Dwh~t+V@p UT*a} F C C&E}vk z
 lA /; 7%UG  86]d H | Y@nV OH}   < Zh5l hIq 6Z GEx6! ceq 8r;cej lH 8`r }MM~
4R+ ~Ya.7}|IJ u }r)w RTQ0&&  /Fl:  v5:  tr& d4g ]> IwH| !rG{ 3hf+VD9&g H y0
Q Jt& h$?jcz =B   mT  O|{ Xv&onm !Gw+B  tyD*7sfe@ 6JFoQa 4lT ! Dqb D:v(HS Z
 0bC-C\ 5= #+  n E Lm{sM0 jacb* rt5*Rn = 1&b7 &$K} 5i-E`FI{#m ^;+G -[mik.LM

```

---

First, Starry ignores everything except spaces and `+*.,`'`. So let's get rid of all that junk:

```
            +               +  *       +     * + .        `        +              +            `  *       +     * `     *                      ` +             ` .                    `            +     * + . +              ` .        +     *               ` +   ` .              +                  `            +  *     `         +          `     * * +  ` .                 + * .                   `              +                 ` +      `  *           +     * +                         ` .           +                     `         +  *     * +                       ` .        +                `     * +       ` .           + *         ` + .           `             + *                        ` + .              +            +  *         +     * *    ` + .

```

Now each string of spaces followed by a non-space is one command. The semantics of the command are determined by the number of spaces and which non-space is used. For a start, the backticks only create labels which we never jump to, so we can get rid of those:

```
            +               +  *       +     * + .        +              +  *       +     *     * + .            +     * + . + .        +     * + .              +            +  *         +     * * + .                 + * .              + +  *           +     * + .           +         +  *     * + .        +     * + .           + * + .             + * + .              +            +  *         +     * * + .

```

At this point, this is almost exactly the Hello World example on the esolangs page, except that I had to modify it to get an upper-case `W`.

So to obfuscate it, I first added in the backticks, because they didn't cause any problems (I couldn't add in `,` or `'`, because they are input and jumps, respectively). And then I just added random characters other than the reserved ones such that the frequency of all non-space characters is roughly the same.

# Answer
> 34 votes
# Brainfuck, 2545 bytes, cracked by Sp3000

Just for fun.

```
# [-*- coding: latin-1 -*-]
#define """ "
#define \ "
import sys
if len(sys.argv) > 1:
    print """
Usage: " /*confused [options] "{input file}"

Options:
--version             show program's version number and exit
-h! --help            show this help message and exit
-o {file path}! --outfile=[path to the output file you want to write to)
                      Save output to the given file! (this > that)
                      """ + '>' + ' ' + 'H' + 'e' + 'l' + """ :>
--destdir={file path} >
                      Save output to the given directory! This option is
                        required when handling multiple files! Defaults to
                        '!/minified' and will be created if not present!
--nominify            Don't bother minifying > (only used with pyz)!
--use-tabs            Use obfuscated tabs! >""" + 'l' + 'o' + ' ' + """ :>
--bzip2               bzip2-compress the result into a self-executing python
                        script!  Only works on stand-alone scripts without
                        implicit imports!
-g                    gzip compress the result into a self executing python
                        script!  Only works on standalone scripts without
                        implicit imports! */ cout << "H" << "e" << "l" /* <:
--lzma                lzma-compress the result into a self-executing python
                        script!  Only works on stand-alone scripts without
                        implicit imports!
--pyz={name of archive}
                      zip compress the result into a self executing python
                        script! This will create a new file that includes any
                        necessary implicit (local to the script] modules!
                        (╯>.>）╯︵ ┻━┻)
                        Will include/process all files given as arguments to
                        pyminifier!py on the command line!
-O! --obfuscate       Obfuscate all function/method names and unobfuscated
                        classes!  Default is to NOT obfuscate. :>
--obfuscate-classes   Obfuscate self-referential class names. Explain. :>
-s
                      Obfuscate. > """ + 'W' + 'o' + 'r' + """Obfuscate. :>
                      The walrus and the carpenter. >
                      """ + 'l' + 'd' + '!' + ' ' + 'H' + 'e' + """.
                      */ cout << "llo World!" /* <.
                      """ + 'l' + 'l' + """"Explain. <: Explain. <:
-t
                      Obfuscate variable names. i >> j >>""" + """ Explain.
"""
print "Hello, World?"

```

# Answer
> 30 votes
# Logo, 14292 bytes, cracked by Gareth McCaughan

```
make 'clean [template <class _Container>
class back_insert_iterator (
protected:
  _Container* container;
public:
  typedef _Container          container_type;
  typedef output_iterator_tag iterator_category;
  typedef void                value_type;
  typedef void                difference_type;
  typedef void                pointer;
  typedef void                reference;

  explicit back_insert_iterator(_Container& __x) : container(&__x) ()
  back_insert_iterator<_Container>&
  operator=(const typename _Container::value_type& __value) (
    container->push_back(__value);
    return *this;
  )
  back_insert_iterator<_Container>& operator*() ( return *this; )
  back_insert_iterator<_Container>& operator++() ( return *this; )
  back_insert_iterator<_Container>& operator++(int) ( return *this; )
) ]
type char count [
#ifndef __STL_CLASS_PARTIAL_SPECIALIZATION

template <class _Container>
inline output_iterator_tag
iterator_category(const back_insert_iterator<_Container>&)
(
  return output_iterator_tag();
)
#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */

template <class _Container>
inline back_insert_iterator<_Container> back_inserter(_Container& __x) (
  return back_insert_iterator<_Container>(__x);
)

template <class _Container>
class front_insert_iterator (
protected:
  _Container* container;
public:
  typedef _Container          container_type;
  typedef output_iterator_tag iterator_category;
  typedef void                value_type;
  typedef void                difference_type;
  typedef void                pointer;
  typedef void                reference;

   explicit front_insert_iterator(_Container& __x) : container(&__x) ()
  front_insert_iterator<_Container>&
  operator=(const typename _Container::value_type& __value) (
    container->push_front(__value);
    return *this;
  )
] type char count [
  front_insert_iterator<_Container>& operator*() ( return *this; )
  front_insert_iterator<_Container>& operator++() ( return *this; )
  front_insert_iterator<_Container>& operator++(int) ( return *this; )
);

#ifndef __STL_CLASS_PARTIAL_SPECIALIZATION

template <class _Container>
inline output_iterator_tag
iterator_category(const front_insert_iterator<_Container>&)
(
  return output_iterator_tag();
)

#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */

template <class _Container>
inline front_insert_iterator<_Container> front_inserter(_Container& __x) (
  return front_insert_iterator<_Container>(__x);
)

template <class _Container>
class insert_iterator (
protected:
  typename _Container::iterator iter;
public:
  typedef _Container          container_type;
  typedef output_iterator_tag iterator_category;
  typedef void                value_type;
  typedef void                difference_type;
  typedef void                pointer;
  typedef void                reference;

  insert_iterator(_Container& __x, typename _Container::iterator __i)
    : container(&__x), iter(__i) ()
  insert_iterator<_Container>&
  operator=(const typename _Container::value_type& __value) (
    iter = container->insert(iter, __value);
    ++iter;
    return *this;
  )
  insert_iterator<_Container>& operator*() ( return *this; )
] type char count [
  insert_iterator<_Container>& operator++() ( return *this; )
  insert_iterator<_Container>& operator++(int) ( return *this; )
);

#ifndef __STL_CLASS_PARTIAL_SPECIALIZATION

  template <class _Container>
inline output_iterator_tag
iterator_category(const insert_iterator<_Container>&)
(
  return output_iterator_tag();
)

  #endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */

template <class _Container>
inline front_insert_iterator<_Container> front_inserter(_Container& __x) (
  return front_insert_iterator<_Container>(__x);
)

template <class _Container>
class insert_iterator (
protected:
  _Container* container;
  typename _Container::iterator iter;
public:
  typedef _Container          container_type;
  typedef output_iterator_tag iterator_category;
  typedef void                value_type;
  typedef void                difference_type;
  typedef void                pointer;
  typedef void                reference;

  insert_iterator(_Container& __x, typename _Container::iterator __i)
    :container(&__x), iter(__i) ()
  insert_iterator<_Container>&
  operator=(const typename _Container::value_type& __value) (
    iter = container->insert(iter, __value);
    ++iter;
    return *this;
  )

  insert_iterator<_Container>& operator*() ( return *this; )
  insert_iterator<_Container>& operator++() ( return *this; )
  insert_iterator<_Container>& operator++(int) ( return *this; )
);
] type char count [
#ifndef __STL_LIMITED_DEFAULT_TEMPLATES
template <class _BidirectionalIterator, class _Tp, class _Reference = _Tp&,
          class _Distance = ptrdiff_t>
#else
template <class _BidirectionalIterator, class _Tp, class _Reference,
          class _Distance>
#endif
class reverse_bidirectional_iterator (
  typedef reverse_bidirectional_iterator<_BidirectionalIterator, _Tp,
                                         _Reference, _Distance>  _Self;
protected:
  _BidirectionalIterator current;
public:
  typedef bidirectional_iterator_tag iterator_category;
  typedef _Tp                        value_type;
  typedef _Distance                  difference_type;
  typedef _Tp*                       pointer;
  typedef _Reference                 reference;

  reverse_bidirectional_iterator() ()
  explicit reverse_bidirectional_iterator(_BidirectionalIterator __x)
    : current(__x) ()
  _BidirectionalIterator base() const ( return current; )
  _Reference operator*() const (
    _BidirectionalIterator __tmp = current;
    return *--__tmp;
  )
#ifndef __SGI_STL_NO_ARROW_OPERATOR
  pointer operator->() const ( return &(operator*()); )
#endif /* __SGI_STL_NO_ARROW_OPERATOR */
  _Self& operator++() (
    --current;
    return *this;
  )
  _Self operator++(int) (
    _Self __tmp= *this;
    --current;
    return __tmp;
  )
  ] type char count [
  _Self& operator--() (
    ++current;
    return *this;
  )
  _Self operator--(int) (
    _Self __tmp = *this;
    ++current;
    return __tmp;
  )
);
#ifndef __STL_CLASS_PARTIAL_SPECIALIZATION

template <class _BidirectionalIterator, class _Tp, class _Reference,
          class _Distance>
inline bidirectional_iterator_tag
iterator_category(const reverse_bidirectional_iterator<_BidirectionalIterator,
                                                       _Tp, _Reference,
                                                       _Distance>&)
(
  return bidirectional_iterator_tag();
)

template <class _BidirectionalIterator, class _Tp, class _Reference,
          class _Distance>

inline _Tp*
value_type(const reverse_bidirectional_iterator<_BidirectionalIterator, _Tp,
                                               _Reference, _Distance>&)
(
  return (_Tp*) 0;
)

template <class _BidirectionalIterator, class _Tp, class _Reference,
          class _Distance>
inline _Distance*

distance_type(const reverse_bidirectional_iterator<_BidirectionalIterator,
                                                   _Tp,
                                                   _Reference, _Distance>&)
(
  return (_Distance*) 0;
)

  #endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */

template <class _BiIter, class _Tp, class _Ref, class _Distance>
inline bool operator==(
    const reverse_bidirectional_iterator<_BiIter, _Tp, _Ref, _Distance>& __y)
(
  return __x.base() == __y.base();
)

] type char count [
#endif /*__STL_CLASS_PARTIAL_SPECIALIZATION*/

template <class _BiIter , class _Tp , class _Ref , class _Distance>
inline bool operator ==(
    const reverse_bidirectional_iterator <_BiIter , _Tp, _Ref , _Distance>& __x,
    const reverse_bidirectional_iterator <_BiIter , _Tp, _Ref , _Distance>& __y)
(
  return __x.base() == __y.base();
)
#ifdef __STL_FUNCTION_TMPL_PARTIAL_ORDER
] type char count [

template <class _BiIter, class _Tp, class _Ref, class _Distance>
inline bool operator!=(
    const reverse_bidirectional_iterator<_BiIter, _Tp,_Ref, _Distance>& __x,
    const reverse_bidirectional_iterator<_BiIter, _Tp,_Ref, _Distance>& __y)
(
  return !(__x== __y);
)

inline bool operator!=(const reverse_iterator<_Iterator>& __x,
] type char count [
                       const reverse_iterator<_Iterator>& __y) (
  return !(__x == __y);
)

template <class _Iterator>
inline bool operator>(const reverse_iterator<_Iterator>& __x,
                      const reverse_iterator<_Iterator>& __y) (
  return __y < __x;
)

template <class _Iterator>
inline bool operator<=(const reverse_iterator<_Iterator>& __x,
                       const reverse_iterator<_Iterator>& __y) (
  return !(__y < __x);
)

template <class _Iterator>
inline bool operator>=(const reverse_iterator<_Iterator>& __x,
                      const reverse_iterator<_Iterator>& __y) (
  return !(__x < __y);
)

#endif /*__STL_FUNCTION_TMPL_PARTIAL_ORDER */

#ifdef __STL_CLASS_PARTIAL_SPECIALIZATION

// This is the new version of reverse_iterator, as defined in the
//  draft C++ standard.  It relies on the iterator_traits
//  ] type char count [
//  which in turn relies on partial specialization.  The class
//  reverse_bidirectional_iterator is no longer part of the draft
//  standard, but it is retained for backward compatibility.

template <class _Iterator>
class reverse_iterator
(
protected:
  _Iterator current;
public:

  typedef typename iterator_traits<_Iterator>::iterator_category
          iterator_category;
  typedef typename iterator_traits<_Iterator>::value_type
          value_type;
  typedef typename iterator_traits<_Iterator>::difference_type
          difference_type;
  typedef typename iterator_traits<_Iterator>::pointer
          pointer;
  typedef typename iterator_traits<_Iterator>::reference
          reference;

  typedef _Iterator iterator_type;
  typedef reverse_iterator<_Iterator> _Self;

public:
  reverse_iterator() ()
  explicit reverse_iterator(iterator_type __x) : current(__x) ()

template <class _Iterator>
inline bool operator>(const reverse_iterator<_Iterator>& __x,
                      const reverse_iterator<_Iterator>& __y) (
  return __y < __x;
)

template <class _Iterator>
inline bool operator<= ( const reverse_iterator<_Iterator> & __x,
                       const reverse_iterator<_Iterator> & __y) (
  return !(__y < __x);
)

] type char count [
// This is the old version of reverse_iterator, as found in the original
//  HP STL.  It does not use partial specialization.

#ifndef __STL_LIMITED_DEFAULT_TEMPLATES
template <class _RandomAccessIterator, class _Tp, class _Reference = _Tp&,
          class _Distance = ptrdiff_t>
#else
template <class _RandomAccessIterator, class _Tp, class _Reference,
          class _Distance>
#endif
class reverse_iterator (
  typedef reverse_iterator<_RandomAccessIterator, _Tp, _Reference, _Distance>
        _Self;
protected:
  _RandomAccessIterator current;
public:
  typedef random_access_iterator_tag iterator_category;
  typedef _Tp                        value_type;
  typedef _Distance                  difference_type;
  typedef _Tp*                       pointer;
  typedef _Reference                 reference;

  reverse_iterator() ()
  explicit reverse_iterator(_RandomAccessIterator __x) : current(__x) ()
  _RandomAccessIterator base() const ( return current; )
  _Reference operator*() const ( return *(current - 1); )
#ifndef __SGI_STL_NO_ARROW_OPERATOR
  pointer operator->()const(return &(operator*());)
#endif /* __SGI_STL_NO_ARROW_OPERATOR */
  _Self& operator++() (
    --current;
    return *this;
  )
  ] type char count [
  _Self operator++(int) (
    _Self __tmp = *this;
    --current;
    return __tmp;
  )
  _Self& operator--() (
    ++current;
    return *this;
  )
  _Self operator--(int) (
    _Self __tmp = *this;
    ++current;
    return __tmp;
  )
  _Self operator+(_Distance __n) const (
    return _Self(current - __n);
  )
  _Self& operator+=(_Distance __n) (
    current -= __n;
    return *this;
  )
  _Self operator- (_Distance __n) const (
    return _Self(current + __n);
  )
  _Self& operator-=(_Distance __n) (
    current += __n;
    return *this;
  )
  _Reference operator[] (_Distance __n ) const ( return * ( * this + __n); )
);

  template <class _RandomAccessIterator , class _Tp,
          class _Reference , class _Distance>
inline random_access_iterator_tag
iterator_category(const reverse_iterator<_RandomAccessIterator, _Tp,
                                         _Reference, _Distance>&)
(
  return random_access_iterator_tag();
)

] type char count [

  template <class _RandomAccessIterator, class _Tp,
          class _Reference, class _Distance>
inline bool
operator>(const reverse_iterator<_RandomAccessIterator, _Tp,
                                 _Reference, _Distance>& __x,
          const reverse_iterator<_RandomAccessIterator, _Tp,
                                 _Reference, _Distance>& __y) (
  return __y < __x;
)

template <class _RandomAccessIterator, class _Tp ,
          class _Reference, class _Distance >
inline bool
operator<=(const reverse_iterator<_RandomAccessIterator, _Tp,
                                  _Reference, _Distance>& __x,
           const reverse_iterator<_RandomAccessIterator, _Tp,
                                  _Reference, _Distance>& __y) (
  return !(__y < __x) ;
)

template <class _RandomAccessIterator, class _Tp,
          class _Reference, class _Distance>
inline bool
operator >= (const reverse_iterator <_RandomAccessIterator, _Tp,
                                  _Reference , _Distance>& __x,
           const reverse_iterator <_RandomAccessIterator, _Tp,
                                  _Reference , _Distance>& __y) (
  return ! (__x < __y) ;
)

#endif /* __STL_FUNCTION_TMPL_PARTIAL_ORDER */

] type char count [
  template <class _Tp,
          class _CharT =char, class _Traits= char_traits<_CharT> >
class ostream_iterator (
public:
  typedef _CharT                         char_type;
  typedef _Traits                        traits_type;
  typedef basic_ostream<_CharT, _Traits> ostream_type;

  typedef output_iterator_tag            iterator_category;
  typedef void                           value_type;
  typedef void                           difference_type;
]

```

Explanation:

`make` assigns a value to a variable. In this case `make 'clean` is just obfuscation, assigning a square bracketed list to a variable `clean` and then not doing anything with it.

`type char count` is used to print out a character based on the number of items inside the square-bracketed list that follows it. `type` prints out a value, `char` returns a character based on an ASCII value and `count` returns the number of items in a list. So for example `type char count [ a b c d e f g h i j ]` will print out a newline character (ASCII value 10).

Try it online here (cut and paste of source required)

# Answer
> 27 votes
# Fission, 67 bytes, cracked by BrainSteel

Here is another one, which should be a bit simpler.

```
class P{static void Main(){System.Console.WRite("Hello, World!");}}

```

# Answer
> 26 votes
# , 64 bytes, cracked by Mauris

```
-1(-9!0x010000001b0000000a000d00000048656c6c6f2c20576f726c6421);

```

Explanation:

* KDB+ has its own message protocol/serialization format, which can be applied to strings as such:

```
-8!"Hello, World!"

```
* That gives us the long hexadecimal string above. The conversion, if you haven't guessed by now, is `-9!`.
* To print it out as `Hello, World!` exactly, I need to use `-1` to do so. Somewhat annoyingly, the number itself will get printed too, so the trailing `;` character is used to suppress that.

(*it was a good run for slightly over 2 days!*)

# Answer
> 25 votes
# ~English revised, 36 bytes

```
Echo "Hello,"
and " World!".
End."!"

```

This answer contains protection against SPSS, Foo and Tiny. *sighs*

Four attempts and another answer in the same language, but my submission is *finally* safe!

### Explanation

*~English* is designed to look like plain text, which is probably why the second release appends not **2** but **revised** to the language's name.

Thankfully, there are aliases of the functions `Display` and `Stop`, which make *~English* not look like English.

Of those aliases, I chose `Echo` and `End`, which – together with the keyword `and` – make the source code resemble a verbose scripting language rather than an esolang.

The sentence

```
Echo "Hello," and " World!".

```

greets the World and

```
End.

```

stops execution, so the *Foo* protection that follows is simply ignored by the interpreter.

You can download the official interpreter from GitHub (linked on the Esolang page).

# Answer
> 23 votes
# Karma, 67 bytes

```
05\+148*+\[455**\8+\[\6+\[3]-\[46*]\[-1{-\6\++]]\\[7]-942**.
:\!!@<

```

The first line pushes all the characters onto the stack, using the queue to save some bytes. The second line pops and prints until 0, which is the first char on line 1.

# Answer
> 22 votes
# UNBABTIZED, 77 bytes

```
$0,0
.:72
.:101
.:108
.:108
.:111
.:44
.:32
.:87
.:111
.:114
.:108
.:100
.:33

```

### Verification

You can find the official website and interpreter here.

As noted on the website, the interpreter was written for Python 2.2, which allowed non-ASCII characters in source code. You can either download Python 2.2.3<sup>1</sup> or fix it for Python 2.7 by inserting the following line at the beginning of the interpreter:

```
# coding: latin1

```

### How it works

First of all, whitespace should *not* be allowed in the source code according to the website, but trailing whitespace after a complete instruction seems to cause no issues.

The command `$0,0` executes `memory[0] = memory[0] == memory[0]`, which does not help greeting the World in any way. I've added this command solely to distract from the fact that `.` acts a statement separator.

The rest of the code is composed of thirteen `:x` commands, which writes the character with code point **x** to STDOUT.

An unobfuscated version of the source code would look like this:

```
:72.:101.:108.:108.:111.:44.:32.:87.:111.:114.:108.:100.:33

```

---

<sup>1</sup> <sub>Compiling Python 2.2.3 was surprisingly uneventful on openSUSE 13.2. `make`, `make install` and the resulting executable all printed a lot of warnings, but UNBABTIZED worked as intended.</sub>

# Answer
> 22 votes
# gs2, 3 bytes, cracked by feersum

```
e|h

```

In `gs2`:

* `e` or `\x65` is `product` on lists (such as the empty list of characters representing STDIN), so it pushes an int `1`.
* `|` or `\x7c` is `power-of-2`, which changes it into 2<sup>1</sup> = 2.
* `h` or `\x68` is `hello`, which is a *ridiculous* command. The story goes as follows: when designing `gs2`, I set out to beat every code golf language on shinh's golf server, but `goruby` has an easter egg command `h` that prints `Hello, world!` (note the lowercase w), allowing it to claim the #1 spot on the hello world challenge's leaderboards. I wanted to one-up goruby, so I added my own easter egg command `h` that pushes `Hello, world!` to the stack, but **allows you to customize the capitalization and punctuation by pushing an integer before it:**

```
    elif t == '\x68': #= hello
        x = 0
        if len(self.stack) >= 1 and is_num(self.stack[-1]):
            x = self.stack.pop()
            x = (range(0, 11) + [100, 1000, 16, 64, 256]).index(x)
        s1 = 'h' if x & 1 else 'H'
        s2 = 'W' if x & 2 else 'w'
        s3 = ['!', '', '.', '...'][((x & 4) >> 2) | ((x & 16) >> 3)]
        s4 = '' if x & 8 else ','
        f = '%sello%s %sorld%s' % (s1, s4, s2, s3)
        self.stack.append(to_gs(f))

```

As you can see by looking at the `s2 =` line, if there's a number `2` at the top of the stack, it'll get replaced with the uppercase-W variation: `Hello, World!`.

# Answer
> 22 votes
# MarioLANG, 549 bytes, cracked by Sp3000

```
++++++++++>)+++++++)++++++++++((-[!)++.)+.+++++++..+++.))]-.(----.((+++++++++++++++.).+++.------.--------.)+.
=|||||=|||"|||||=||||||=||||||||||#|||||||||=|||||||||||||||||||||||||||||||||||||||=|==|||||||||||||||||||||
----------!((((-(.[)++++++)++++)))<(--.(-.-------..---.((]+.)++++.))---------------.(.---.++++++.++++++++.(-.
Helo, Wrd!#||||||=|||||||||||||=||"||||||||||||||=||||||||||||||||||||=||||||||||||||||||||||||||||||||||=|||
++++++++++>)+++++++)++++++++++((-[!)++.)+.+++++++..+++.))]-.(----.((+++++++++++++++.).+++.------.--------.)+.

```

I really enjoyed this one. Here is a quick overview of how I created the code:

* I started from the Brainfuck "Hello World!" on esolangs:

```
++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.

```

I had to modify it slightly to add the comma, but let's ignore the details...
* BF can be converted to ML fairly easily: change `>` and `<` to `)` and `(` respectively. Add a main floor beneath the program. Then implement loops via helper floors and elevators. That turns the above program into:

```
++++++++++>)+++++++)++++++++++)+++)+((((-[!)++.)+.+++++++..+++.)++.((+++++++++++++++.).+++.------.--------.)+.).
=========="===============================#=====================================================================
          !                               <
          #==============================="

```

This is a working "Hello World!" program in MarioLANG. (This code corresponds to the incorrect "Hello World!" on esolangs, not the obfuscated ML code above.)
* At this point, we can golf the code a bit my actually moving some of the loop code into the auxiliary floor. I'm now switching to the actual code from this answer:

```
++++++++++>)+++++++)++++++++++((-[!)++.)+.+++++++..+++.))]-.(----.((+++++++++++++++.).+++.------.--------.)+.
=========="=======================#==========================================================================
          !((((-(.[)++++++)++++)))<
          #======================="

```
* And now the actual obfuscation: I figured the `=` would be a dead giveaway for Sp3000 who knew the language (he had used it in Evolution of OEIS). But MarioLANG also has "walls" instead of "floors", represented by `|`. These are functionally identical though, so I used the less common character. I also figured the hanging floor would look suspicious so I padded the two lines with other characters. For good measure I added the first line again to the end, and made the padding in the middle line the opposite characters of the first line. I also added matching square brackets (which are ignored by MarioLANG), because I figured an unmatched `[` might be another strong hint. Finally, I wrote a CJam script to sprinkle exactly 13 `=` into random floor positions (13, because that's the length of `Hello, World!`) and changed the padding characters in the fourth row to `Helo, Wrd!` to make it look like I'm reading the characters from the source code, like a Befunge answer might. Voilà, obfuscated MarioLANG! :)

# Answer
> 21 votes
# \>\<\>, 353 Bytes, Cracked by Sp3000

```
//This seems almost fine
//"Hello, World!" r^2 times
//But will it be too wordy?
  var r = 2;
  var a1 = "Hello";
  var a2 = ",";
  var a3 = " World";
  if(a1 != a2 && a2!=a3&& a3 != a1){
      r+=(a2===",")?1:0;
      a1+=a2;
      a1+=a3;
      if(a1 == "Hello, World")
        for(var i = 0; i++; i < r*r)
        {
          log(a1);
        }
    }

```

As discovered by Sp3000, this is a \>\<\> program. All unused whitespace and characters replaced with . character for readability.

```
/.................. ....
./"Hello, World!" r^.......
//.................o.......
 ...........
 ..................
 ..............
 ..................;
 ..................!................
 ..................?....
 ............
 ............
 ..................l..........
 .................. ................
 ........
 .................
 ........
 ....

```

# Answer
> 20 votes
# Higher Subleq, 52 bytes, cracked by John WH Smith

```
int puts(char*);int main(){puts("Hello, World!\n");}

```

This doesn't really look like an esolang, but no sane C derivate would implement `puts` without an implicit newline.

# Answer
> 19 votes
# Mascarpone, 30 bytes, cracked by Sp3000

```
[!dlroW ,olleH]$.............

```

Stack-based? Maybe...

---

`[!dlroW ,olleH]` pushes all of those characters to the stack (yes, including the delimiters); `$` pops the `]`; and then the `.`each print one character. The program exits with a `[` character still on the stack.

I would have made the output use a loop, but I can't figure out how they work...

# Answer
> 18 votes
## Haskell, 637 bytes

```
(program, main)= script $init

string= struct( \
  char(show)-> do show; putChar(char); while 1 ) (return 0)

script
  stack= auto $string("!dlroW ,olleH")

struct buffer (public) = share%: \
  align->flip
  (field public buffer) align

auto buffer= (init, buffer)

share from = select x where x = from x

while skip=return 1; skip= skip+1

select x | ~"World"<-
            "Hello"=x

loop k for[]
  buffer=(const ($k) ($skip) id)

loop while not(-- $x) {
  unsigned: i{-1}
  terminal.write(buffer{eval $i--})
  x= not (unsigned) $x
  $i `const `skip{-2}
}

memorize{+,-}

(goal, field)= auto loop

finish%:
  goal= finish $goal

```

### Deobfuscation video

# Answer
> 17 votes
# GNU bc, 36 bytes

```
main = do
  print "Hello, World!\n"

```

A Foo-immune version of my previous attempt.

This requires the GNU version (or any other version that features the `print` function) of bc. The first line is for obfuscation: in bc variables don't have to be declared and are initialized with `0`, so we have useless assignment but with valid syntax. The second line simply prints `Hello, World!`.

# Answer
> 17 votes
# Whirl, 12302 bytes, cracked by Artyom

```
3.141592653589793288462643383279207884697269399375705845974944595347816486286788
[encoded data, 12071 characters]

```

Whirl ignores everything except 1 and 0. I also modified other digits randomly, but they are not relevant. When you keep only 1's and 0's, you get a "Hello, World!" example :)

# Answer
> 16 votes
# Mouse, 105 bytes

```
1[10Y:Y.Y.*X:108Z:33X.X.8+X.Y.+4+X.Y.+1+X.Y.2*-7+Y.3*2+44X.Y.+1+Z.Z.Y.10*1+72!'!'!'!'!'!'!'!'!'!'!'!'!']$

```

You can get an interpreter for Mouse written in C here.

Mouse uses reverse Polish notation, so operators follow operands. (Think Lisp backwards.) Variable assignment is performed using `<variable>:` and recalling a variable's value is done as `<variable>.`. All values in Mouse are integers.

`!` outputs an integer and `!'` outputs the ASCII character associated with the integer. All output goes to STDOUT.

For whatever reason, all valid programs must end with `$`.

```
1 [ ~ If true, do

    ~ Variable assignments
    10 Y:
    Y. Y. * X:
    108 Z:

    ~ Push values onto the stack
    33               ~ 33  "!"
    X.               ~ 100 "d"
    X. 8 +           ~ 108 "l"
    X. Y. + 4 +      ~ 114 "r"
    X. Y. + 1 +      ~ 111 "o"
    X. Y. 2 * - 7 +  ~ 87  "W"
    Y. 3 * 2 +       ~ 32  " "
    44               ~ 44  ","
    X. Y. + 1 +      ~ 111 "o"
    Z.               ~ 108 "l"
    Z.               ~ 108 "l"
    Y. 10 * 1 +      ~ 101 "e"
    72               ~ 72  "H"

    ~ Pop values and output as characters
    !' !' !' !' !' !' !' !' !' !' !' !' !'

]   ~ End if
$   ~ End program

```

# Answer
> 15 votes
# Chef, 1943 bytes, cracked by Angew

```
Hello World Cake with Chocolate sauce.

This prints hello world, while being tastier than Hello World Souffle. The main
chef makes a " World!" cake, which he puts in the baking dish. When he gets the
sous chef to make the "Hello" chocolate sauce, it gets put into the baking dish
and then the whole thing is printed when he refrigerates the sauce. When
actually cooking, I'm interpreting the chocolate sauce baking dish to be
separate from the cake one and Liquify to mean either melt or blend depending on
context.

Ingredients.
33 g chocolate chips
100 g butter
54 ml double cream
2 pinches baking powder
114 g sugar
111 ml beaten eggs
119 g flour
32 g cocoa powder
0 g cake mixture

Cooking time: 25 minutes.

Pre-heat oven to 180 degrees Celsius.

Method.
Put chocolate chips into the mixing bowl.
Put butter into the mixing bowl.
Put sugar into the mixing bowl.
Put beaten eggs into the mixing bowl.
Put flour into the mixing bowl.
Put baking powder into the mixing bowl.
Put cocoa  powder into the mixing bowl.
Stir the mixing bowl for 1 minute.
Combine double cream into the mixing bowl.
Stir the mixing bowl for 4 minutes.
Liquify the contents of the mixing bowl.
Pour contents of the mixing bowl into the baking dish.
bake the cake mixture.
Wait until baked.
Serve with chocolate sauce.

chocolate sauce.

Ingredients.
111 g sugar
108 ml hot water
108 ml heated double cream
101 g dark chocolate
72 g milk chocolate

Method.
Clean the mixing bowl.
Put sugar into the mixing bowl.
Put hot water into the mixing bowl.
Put heated double cream into the mixing bowl.
dissolve the sugar.
agitate the sugar until dissolved.
Liquify the dark chocolate.
Put dark chocolate into the mixing bowl.
Liquify the milk chocolate.
Put milk chocolate into the mixing bowl.
Liquify contents of the mixing bowl.
Pour contents of the mixing bowl into the baking dish.
Refrigerate for 1 hour.

```

# Answer
> 15 votes
# APL, 39 bytes, cracked by Mauris

```
"Helo, Wrd!"[0,1,2,2,3,4,5,6,3,7,2,8,9]

```

Efficiency is everything.

This works in the ngn-apl demo.

Obfuscating APL is no easy task if the intention is to make it look *less* like APL.

This is what I achieved:

* Double quotes do not work in all dialects. Dyalog, e.g., does not support them.
* ngn/apl is the only dialect I know that uses zero-based indexing by default.
* The commas aren't supposed to be there.

Vector elements are usually separated by spaces when writing APL. However, `,` concatenates so the code inside the brackets concatenates 13 singletons.

A (slightly) unobfuscated and more portable version of the code would look like

```
⎕IO←0⋄'Helo, Wrd!'[0 1 2 2 3 4 5 6 3 7 2 8 9]

```

which works in TryAPL, GNU APL.js and the ngn/apl demo.

# Answer
> 14 votes
# Wordfuck, 1063 bytes, cracked by Martin Büttner

```
Thus men; die. Here meet prepar'd thrice be." Down his
 with lab'ring forg'd and And retir'd Now universal Phoebus at
 Hesperian living, off fields fierce cries, assail'd not for These
 foe. Spread, indulgent quarry headlong prince your bloody side crew.
 Elated call humble yield, his yield, boys camp men, cruel
 all the loudly trusty won, winter spouts they crown. Had
 what long long upon fram'd. Declare back throat, tossing his
 enters, the Nor Aeneas; said from flowing the enclose th'
 match'd Receive with neither threat. From seas painted His oppos'd,
 cried, Thus mortal the his and combine form and, wine.
 And but Let absent, sums to guest, you to spear
 to greedy of First, with love bear." path Whom heav'n
 That by Argive need they to blood, wert eyes the
 this To large, with Some Jove (The from hosts, the
 yoke with horses' when sail is purple at wintry his
 with more camp with have to Earth, to oppose of
 the troops with various but so, thirty well perform by
 the and waves- man! from fear victory too at fire,
 If recess banish'd transfer.

```

Note that line endings must be Unix-style.

# Answer
> 14 votes
# Wordy, 3279 bytes

```
#_>^ +7K1 }OU8 4>Fk ry\g 9Ff] A}kY ,6Fo IK`k C'td dbJ[ 0j]l MBp[ \">| R\JY %+T_
)*`7 @[{j ;x-+ _H\= ;D@& />p? h,mx 1m;7 p+yL -#&9 0(^! ,i9^ Q%_! +&$Q %#|e %:~A
%T</ }-(r ]_$p g&|" *w#= @++j \)U` <:W< _t{( c\#< :f@~ >[+6 ,B%? S6d} HSm" b=Yz
c[(; @n*# ;`,Z >~K) D"<% <}h" #>N. I0:o >c"+ '>S! pQX[ U#gu $Ei0 6`>~ -/4: ,3;%
\c(? h;TQ LN)o 5`#; }{V* '-E. 7:5u d]0y s|JJ u+>` `|8? y,<0 \(d! 1^*, &U`_ U/@"
*&7. M|f% |C#? \{4` ,k<+ %*'D h~=_ W_+{ [#_[ %"-r #~_F _:u. N|W6 awH' JMm, }%=R
a>*= *z+' {@"A ,'3\ m;}@ (I<. "044 '}A` =K'? puB[ R<ka nrR: S<>= ;`(e (\*p N$"?
u1c} eI%L O$*~ ]O+{ 7"@! vU%n 'MIs E`VV ,/~q p}\? ^DM, k:-! ,3:$ D*~< "}T^ /z}%
\|h< 'Y@? }M%0 {/c. |";P /I"` "[(v ~>l- #2]! j~af rZ(J 9zv` {`T, M`'& (H+: {G+>
A#~` /_%6 4"}! 9|rs [;$m ]J|? IZx; ^xaf WuB) =^+s |+%t [;^U ])A! H;Jb @STw x^`,
=9~< %Z). @v3o h;Tz M9~t {'|O {J`. u^t> 9<-? )/4- `/v| )>O] /(E' ,};X ;&0. 0`o:
(#o? ,D]< X%|* ;}*h [%C` &(A' ^@J^ {O[| &%&Q -;9` |j}) |z]+ :4:. 03(4 <Bhz N$mY
R$~< -M#' C)$$ /=[J 9@^" [*}a :%R. T1,W Y=}` O=&. D;ms Mi=c (Stg >|}1 __^B P};{
&{1. y(Wq T&Nq $^'D />@M @u^? $2Pd n4~d 19j/ X>#> #s[. 0-@P $B%? %w}% x=<[ =}r_
\#=8 ~~R> P']! }8a+ *;j! w<_` %;T: #0({ -_8< A(]^ @1`/ )@f` /=m\ e"~@ ~4$' (z]&
/C|? wtn; HFe^ Gzn* @K}/ >1+{ 7/-{ 2&{} }X-% T=:> O,;. qR8; ;*0: s|>. -bFs DK^y
jk}O =~g/ B%:{ 9;@` K%}? `Xvi "vI4 c+$) =<(b %g#. Tt'w P\ID M`fI %#^M E#=. B&)v
;9:? (+/7 <%q" =,U{ -`/G r[*^ Y;@! H&d> ))@% &S,! |B*[ ~^-p 6+,~ N#&\ ;]K* 6}=^
/|Q) *y:\ ,M*| %&'f =U>@ }~@Y >~3~ `P<: K\+? WUD= |4x5 sox} /6;> [&r{ p@", :'D}
g{^} -]$H _B-! fJ5< p;&@ {a~! Ra+M OKo+ ydJ+ *~-T :W=; @*#, ^_e- k=_. M@QY (fQn
X<,] >(C/ [A/. {nNT {tXg vy@e *1+} (G,. +2m[ X[=! s$,/ [@y! :l+9 -@2. :(P- +a~#
,p%) %*)0 }*=F +"T( Q&~@ <c*; }(\E 3@_* I):( \:2? ~CqL 5$TC ,ARH ;*p/ <~0` _B';
;=>A (%T, d&[; #`g. N*u1 @LEE zPP[ ;<)4 ,1%= [#1# =6^! IL\e 0t@f ~}h< j'{+ <_B!
wFE; lyr` Ja\V '[,J 2_^! Rb;% I>$? F#-{ %+j. fB>2 J7P# Kj~n }#C> T*%` Q=/@ T;%>
_c|{ :&$1 %Q}. rFl> #A,` `Z^! Ks"L hUI: 6_MV ^Q-- `M/> #3/= #'n. MID{ vdn, @_l{
v_@; `s@? H#eZ ]9my oP#e {|R# '(k! d#d; :s,? $+H@ :#=e }2-] 8,-< &1$! l(`7 e:-!
%\X$ k_>' <7], ~%N| r)]] -"$u &0\! SR:z ly]b K(wa q*@- ]{~c )}x% &@&Y >~;j #R)=
%V*. %L1F j'~; +_0. Yz-x @kVV 0G:a `,p] (>n< >{{z /#m! S~CS #Foq %$h( +*{B G#@?
fwr< %OQt K"Cx @0}+ b${. F]R* k=/! C$=, @#/b 4[$* y`,^ $|*R 6,%! Z*c@ ;0\. [&f-
$"/k -L{, \@7{ ^]k\ v$>% v#-; +G># -F@} :=R@ Z<|^ )H-~ o#~^ E#$) :a{. i52: :svA
q&NY #g"< )r]{ "p%& %P}@ 'k|, #m)' ]6$. :@{& |Rcr \]|T ;^8! b2{F rv<i N>VP D>~_
)'A_ G(}- Y&^? 64-A %klM %Q=@ }J:; _b<? ^jjo v[5V {gyQ y)`[ }|l. '0B` A`{. >]@M
#},y C"_} s]@' \9|- _#$o _w"? %&43 k}". >}u- ^]b? z%Cg f+aT vr$A /:\z #);I $*F,
+7^# \%T( ,*a{ &>n? t8J( >*|F @{4? >X4T o7r+ bQ:L *^C_ ;#8& `w(( >,v. a<dY D52+
1_+: "-i) }&f? *LNO %d5F yu{O $}&x 'v]? *b{m &*i! W\#( <%i+ }=o" 9=#& \@1{ @4-?
O])U :`Z? T{`> &>}0 <[T+ `w|{ *"k* >@b^ ~,8+ "{;n &-X* "l{+ [V_" ^8$. $Ppv MY7%
1e;R ={g# |N}_ )`[d *U\~ "@L# &o{, ^Y[! m13= z@\$ /\o. VdO" %EBr h,cD &^(6 )t(`
'S%, @L(? zd{g 0YR" n;}_ 9$~^ N`$! hz>G iM_A JT8+ K)-] g[`? 1J@~ -l*? {<n& w{+:
;r`& ,9-> (}r| M$<? I"0* H|=. =[:T (^#y V~-/ 6(:? K{GF RzF^ V^4d ;#>d ~C}@ b(^\
(_B- /)_K >;^i V#%! c5H^ 'R@> <M:. ee\0 jPH( JV=4 >{&k "T#\ y';) {^e? :gq7 2B(3
+P-| s\%( 'e~? TE8^ V6U> mB<q 'K&( {u|! y@<A ]f&. "K~+ =o(? 5+u^ u>(? a_%. *</>

```

As I hinted in the comments, this haystack is mostly needle.

We can greet the World by executing the following instructions:

```
ASSIGN NOP LITERAL 16
OUTCHAR ADD MULTIPLY VALUE NOP LITERAL 4 LITERAL 8
OUTCHAR ADD MULTIPLY VALUE NOP LITERAL 6 LITERAL 5
OUTCHAR ADD MULTIPLY VALUE NOP LITERAL 6 LITERAL 12
OUTCHAR ADD MULTIPLY VALUE NOP LITERAL 6 LITERAL 12
OUTCHAR ADD MULTIPLY VALUE NOP LITERAL 6 LITERAL 15
OUTCHAR ADD MULTIPLY VALUE NOP LITERAL 2 LITERAL 12
OUTCHAR MULTIPLY VALUE NOP LITERAL 2
OUTCHAR ADD MULTIPLY VALUE NOP LITERAL 5 LITERAL 7
OUTCHAR ADD MULTIPLY VALUE NOP LITERAL 6 LITERAL 15
OUTCHAR ADD MULTIPLY VALUE NOP LITERAL 7 LITERAL 2
OUTCHAR ADD MULTIPLY VALUE NOP LITERAL 6 LITERAL 12
OUTCHAR ADD MULTIPLY VALUE NOP LITERAL 6 LITERAL 4
OUTCHAR ADD MULTIPLY VALUE NOP LITERAL 2 LITERAL 1

```

Wordy encodes all instructions as sentences, where the fraction of words that are longer and shorter than the rounded average selects the command.

The shortest sentences I could find for the used instructions are:

```
ASSIGN xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx x x x x x x x.
VALUE xxx xxx x x x.
ADD xxx x x.
MULTIPLY xxx xxx xxx x x x x.
OUTCHAR xxx xxx xxx x x x x x x x.
NOP xxx xxx xxx x x.
LITERAL xx x.

```

But how can one conceal the fact that word length is the only important thing in the source code?

Neither word order nor the picked word characters matter, as long as they're alphanumeric, so I decided to add random non-alphanumeric characters to each word to pad all of them to the same length. I also added a few non-words (no alphanumeric characters at all) to give the source code its pleasent rectangular shape.

I've generated the final source code using this CJam program.

# Answer
> 12 votes
# Linotte, 47 bytes, cracked by ProgramFOX

```
HelloWorld :
 début
   affiche "Hello, World!"

```

*waves baguette*

# Answer
> 12 votes
# Boolfuck, 698 bytes, cracked by aditsu

```
#include <iostream>
int main() { char _=1;char w=3;char z=7;char o=_+5;char p=_+7;char f=9;char q=_+3;char r=_+5;
char i=_+z;char j=_+o;char k=_+o;char s=_+p;char t=f;_+=q;_=_;_+=k;_*=s;_*=i;_+=j;_*=t;_+=_;_+=z;
_*=o;_+=p;_*=f;k*=2;_+=4;i*=0;_+=2;_+=7;_*=9;i+=1;_+=2;_*=3;k*=6;q*=2;k+=9;_+=1;q*=4;k+=9;_*=6;f*=2;
w+=4;o*=4;w+=9;_+=6;o+=9;w*=2;_*=6;s*=6;w*=3;o*=3;j*=9;_+=7;_+=9;f*=2;_+=f;s-=3;r*=6;_+=i;f+=8;_+=s;
s+=1;j+=r;_+=z;_*=o;t*=5;p*=3;k+=3;_+=5;s*=2;k+=9;t-=4;o+=4;_+=3;p*=5;o+=5;s-=4;r*=3;r+=5;z*=7;t-=9;
r+=6;p-=4;j+=9;w+=4;p-=5;w+=6;_*=7;_*=f;w+=2;_+=p;_*=7;_+=o;i*=p;t+=1;_+=9;_+=s;_*=0;_*=i;_*=6;_+=7;
_+=3;_*=3;z*=2;_+=_;_+=12;z+=3;std::cout<<_<<z<<w<<o<<p<<f<<q<<r<<i<<k<<j<<s<<t; }

```

# Answer
> 12 votes
# Foo, 38 bytes, cracked by kirbyfan64sos

```
fn main(0){println!("Hello, World!");}

```

# Answer
> 12 votes
# Clip, 108 bytes, cracked by jimmy23013

```
"Hello, World!", he exclaimed at the top of his lungs, "What a beautiful day to be alive! Hello, World!"-13>

```

Everybody loves a short story.

> The intended language was **Pyth**, which prints the first string, then chokes on one of the many type errors. With the offline interpreter, all errors go to STDERR, so they don't count as output.

# Answer
> 11 votes
# GolfScript, 369 bytes, cracked by ProgramFOX

```
.!))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))).)))))))
)))))))))))))))))))))).)))))))..))).(((((((((((((((((((((((((((((((((((((((((((((
((((((((((((((((((((((.((((((((((((.)))))))))))))))))))))))))))))))))))))))))))))
)))))))))).)))))))))))))))))))))))).))).((((((.((((((((.(((((((((((((((((((((((((
((((((((((((((((((((((((((((((((((((((((((](+

```

Wait a second, did I forget a paren somewhere?

# Answer
> 11 votes
# ETA, 293 bytes, cracked by Sp3000

```
New nut oven in penal ham; men act of men. Arab arena, but spent? Nope! UNIX likez...
NSA bend at Senator, bend at omen (CAW!). How bend to a mean ten if Ruby yet?
Unternet and Outer? 'tis too meaty in systems.
Grunted? Uh... New Hand enters sty!
Sun-tied nutellu hurt?
On the knife ruts Smurf Ian.

```

# Answer
> 11 votes
# DoubleFuck, 1195 bytes

```
"""     \xde\xbf\xcc\xbc\xca\xaf\xbe\xaa\xaa\xda\xbd\xed\xfc\xaa\xda\xac\xef
\xdd\xff\xcc\xef\xea\xdf\xab\xae\xde\xfc\xcc\xaf\xdb\xbf\xae\xca\xcc\xef\xca
\xbc\xab\xea\xec\xae\xff\xcf\xba\xac\xfe\xab\xbe\xaa\xdc\xcd\xdc\xeb\xed\xac
\xcd\xaa\xba\xae\xfd\xae\xfa\xad\xba\xcc\xde\xba\xbe\xac\xca\xfd\xae\xef\xaa
\xbe\xcd\xfc\xdc\xdd\xbd\xbb\xaa\xbe\xde\xdb\xdd\xdb\xea\xbc\xbf\xdb\xfa\xcd
\xed\xee\xda\xef\xcd\xed\xde\xec\xbb    \xdc\xbd\xeb\xac\xfc\xad\xfe\xde\xbb
\xcc\xcf\xdc\xdc\xfa\xef\xbd\xdc\xfd\xcb\xff\xdd\xbc\xac\xbb\xff\xeb\xac\xab
\xca\xca\xcd\xbd\xaf\xeb\xda\xac\xdb\xcc\xaf\xce\xdf\xad\xad\xea\xee\xda\xfb
\xdc\xbf\xfd\xcb\xbc\xfb\xee\xae\xcb\xcf\xfb\xcd\xef\xfc\xea\xca\xbd\xee\xed
\xea\xed\xba\xef\xad\xcd\xfa\xaf\xaf\xdc\xef\xab\xdd\xda\xeb\xce\xac\xbe\xae
\xbc\xbf\xee\xec\xfd\xee\xed\xbb\xfc\xab\xaf\xda\xeb\xbd\xbe\xdc\xef\xaa\xda
\xbd\xfc\xcd\xdc\xaf\xec\xad\xad\xda\xda\xba\xbb\xbc\xee\xdf\xea\xca     """

a = [
      "!!",

      """]--------[>+>+++++>-->-->--->++++>------<<<<<<<-------]
         >.>---.>----..>-.>++++.>.>+++++++.<<<.+++.<.<-.<<[     """,

      "\x48\x65\x6c\x6c\x6f\x2c\x20\x57\x6f\x72\x6c\x64\x21\n"
    ]

def f():r = print(a[2]) or quit()

f() and f()

```

As noted in the comments, this one contains a few infuriators:

```
$ golfscript hello.???
Hello, World!
2
$ python3 hello.???
Hello, World!

$ brainfuck < hello.???
Hello, World

```

But only the first two herrings are red!

Any brainfuck program that contains no comments is also a valid DoubleFuck program that performs the same action, so the brainfuck instructions of the above code still print everything but the exclamation mark.

Finally, the **223** backslashes in the multi-line string at the beginning decrement the first memory cell in the second array until it reaches **33** and the colon in

```
 def f():r = print(a[2]) or quit()

```

prints the character with code point **33**, i.e., an exclamation mark.

# Answer
> 10 votes
# Hollow, 17 bytes, cracked by Sp3000

```
{Hello, World!}:?

```

If it survives it will be hard to beat, but I don't know whether it will survive.

# Answer
> 10 votes
# GolfScript, 41 bytes, cracked by ProgramFOX

```
begin
   stdout_print "Hello, World!"
end

```

# Answer
> 10 votes
# Wordfuck, 552 bytes, cracked by Sp3000

```
bCB A@? >=< ;:9 876 543 210 /.- ,+*)('&% $#"!~} |{zy xwvuts rqpo nmlk jihg fedc ba`_ ^]\[ZY XWV UTS RQPONM LKJ IHG FEDCBA @9> =<; :98 765432 10/. 'K+* )i'& }C{" !~w=<z yxw vut srq pon mlk jih afe^$Ea `_^]\[Z YXWVUTS RQPONMF EiIH*F? DCBA:^> =<;:z87 65. R21 0/. -,+ *)( '&% $#" b~w={zyrw vutm3k po ng-kji hgI edc ba` _^ ]\UyYX :PU TSR QJn NMF Ei IH *e?DCB A@? 8\ <|:387 65.R s10) .-,+ *#Gh &} ${Abx} |{ zyxq7u Wsrq pinm lkji b(fe dFb[ `Y}] \[TS wW VUTSRQP 2HMFjJI H*e?DCB A@ ?8\< ;:z8 70/S 3s 1*/(L,+ *j ('&%${" !x> |^ zsxwvo 5sUqpo nmlkji hg`edc ba`Y }j

```

This produces the correct *output* in Malbolge, but not the correct byte stream.

# Answer
> 10 votes
# Perl 5.10, 139 bytes, cracked by primo

```
~!0!~('@"/(@`)~@``^"|'.(('"
_]'^'|"`&').('[)).["[}(@,@@
{~/),$}@{**(!(^$&%{%{*[/,`,
'^'+[@@/+{_`%@,/&[)@[@@_`[#
!(!~-/,[,[#{&%@').'"!"})'))

```

### Verification

For obvious reasons, the above code is deemed unsafe in modern versions of Perl.

However, in Perl 5.10<sup>1</sup> (available here), it works as intended with no warnings whatsoever.

To assure Perl 5.20 that you know what you're doing, use the `-Mre=eval` switch or add the line

```
use re 'eval';

```

before the actual code (see 'eval' mode).

This way, you can try the code online in ideone.

### How it works

Let's start by applying some syntax highlighting:

```
~!0!~('@"/(@`)~@``^"|'.(('"
_]'^'|"`&').('[)).["[}(@,@@
{~/),$}@{**(!(^$&%{%{*[/,`,
'^'+[@@/+{_`%@,/&[)@[@@_`[#
!(!~-/,[,[#{&%@').'"!"})'))

```

The code contains quite a few strings, which contain actual linefeeds. We can make it more readable by saving those strings in variables:

```
$a = '@"/(@`)~@``^"|';

$b = '"
_]';

$c = '|"`&';

$d = '[)).["[}(@,@@
{~/),$}@{**(!(^$&%{%{*[/,`,
';

$e = '+[@@/+{_`%@,/&[)@[@@_`[#
!(!~-/,[,[#{&%@';

$f = '"!"})';

~!0 !~ ($a . (($b ^ $c) . ($d ^ $e) . $f))

```

`($b ^ $c)` and `($d ^ $e)` XOR the respective strings character by character.

The results are then concatenated with `$a` and `$f`, yielding the following string<sup>2</sup>:

```
@"/(@`)~@``^"|^(?{print  "Hello, World"                                              ,
"!"})

```

`!~` treats this string as a regular expression and checks if does not match `~!0`<sup>3</sup>.

The part up to `|` is non-matching gibberish; the part that follows uses the `(?{ code })` feature, which allows the execution of arbitrary Perl code inside regular expressions.

After stripping some whitespace, the code that gets executed is

```
print "Hello, World", "!"

```

which greets the World as intended.

---

<sup>1</sup> <sub>Compiling Perl was uneventful on openSUSE 13.2.</sub>
<sup>2</sup> <sub>Some of the spaces are actually tabulators. As the SE editor, Perl does not care about this.</sub>
<sup>3</sup> <sub>This evaluates to **18446744073709551614**, which `!~` will cast to string.</sub>

# Answer
> 10 votes
# goruby, 173 bytes

```
#/*<?php ob_clean();"/#
s=n='''*/include<stdio.h>
main(){/*';s?i;$\=?\ .#";#=;
#*/puts(/*
n;#''';
print(#*/
"Hello, World"
#//#,n^="\v"
);
#/*?><?php "
s;'''*/
}//#";#'''#";

```

Take 2. Perhaps this one will last longer than 5 minutes.

---

The above produces incorrect output (`Hello, World`) in serveral different languages, including PHP (assuming the output buffer is active), Perl, Python, and most C variants. It should also produce the *correct* output in a theoretical language which, to my knowledge, doesn't exist. That language has the following specification:

* Comments begin with `#`, multi-line comments are enclosed by `#/ ... /#`.
* `" ... "` is a valid string, and `''' ... '''` is a valid multi-line string.
* Strings are mutable.
* The string operator `^` performs a bit-wise xor, truncating to the smaller of the two operands.

The program would then be equivalent to:

```
#/ ... /#
s=n='''*/include... ''';
print(
"Hello, World"
,n^="\v"
);
#/ ... /#" ... ";

```

Because `n` begins with `*`, `n^="\v"``!`, thus producing the correct output. It was my intention to have you search for this theoretical language, which as stated, most likely doesn't exist.

The `!` is actually produced by `$\=?\ .n`, meaning `$\=' '.next`. The special variable `$\` is borrowed from Perl, and its value is appended to the output of each print statment. To obfuscate this a bit, I split it across 2 lines, with a `puts` in between. However, if anyone tried to run this in Ruby, the error message would have been a bit of a give-away:

```
undefined method `n' for " ":String (NoMethodError)

```

To guard against this, I added `s?i` just before. Ruby will consider this a call to the function `s?` with the parameter `i`, and error on `undefined local variable or method `i'`. Goruby auto-expands this to `is_a?instance`, which is valid syntax.

---

The goruby interpreter is included with the standard Ruby branch, and can be built with:

```
./configure
make golf

```

# Answer
> 10 votes
# Finite Groups, 21 bytes, cracked by nimi

```
"Hello,"" World!"|p"?

```

Now 100% O-proof.

# Answer
> 9 votes
# \>\<\>, 82 bytes, cracked by Sp3000

```
version 1.0
\0: ~~ "Hello,"
\1: ?? " World!"
\4: ...
\n:   r>:~/
end;   ^?)<< data

```

# Answer
> 9 votes
# Glypho, 480 bytes, cracked by jimmy23013

```
  v># #  :: < <   <v#  #*>*> ##:#**#,<,<: : > > *  *v>>v # ##,#, + +:++: ++ ##
*<<*,^,^<<#v<<v#v::v< < <,, +,+,+>>+*,,*+*+*,,*>**^v#  #,,:^#vv#>+>+ << >  >, , ++*>:
:v<v<^#^#v::v>::>v**v # #::>^>+>>:>:>>>*>>##>*^ *# #  vv ,::,<<>:++
*vv*v:v:^vv< > > ,,>>:>: << >+>>^ ^ ^^*^+,+,#::#*:*::  :v v  ,   # #<<#<#**#^,^,+##+**
+**+,:,:::>*<^v< v v+^+^*^^*+<<++##+v#v#++<>:< :* **+ +   ^ *  *<+<+<  *vv+<:^^:::
  ^+*<<***<^+  ++:+:^##^:>:>+::< > >#>># *  >,>, :^ ^>>^##<#,<,*^   *<:<

```

Note that it is essential to use Windows line terminators (`\r\n`). For the avoidance of doubt, here is a hexdump:

```
00000000  20 20 76 3e 23 20 23 20  20 3a 3a 20 3c 20 3c 20  |  v># #  :: < < |
00000010  20 20 3c 76 23 20 20 23  2a 3e 2a 3e 20 23 23 3a  |  <v#  #*>*> ##:|
00000020  23 2a 2a 23 2c 3c 2c 3c  3a 20 3a 20 3e 20 3e 20  |#**#,<,<: : > > |
00000030  2a 20 20 2a 76 3e 3e 76  20 23 20 23 23 2c 23 2c  |*  *v>>v # ##,#,|
00000040  20 2b 20 2b 3a 2b 2b 3a  20 2b 2b 20 23 23 0d 0a  | + +:++: ++ ##..|
00000050  2a 3c 3c 2a 2c 5e 2c 5e  3c 3c 23 76 3c 3c 76 23  |*<<*,^,^<<#v<<v#|
00000060  76 3a 3a 76 3c 20 3c 20  3c 2c 2c 20 2b 2c 2b 2c  |v::v< < <,, +,+,|
00000070  2b 3e 3e 2b 2a 2c 2c 2a  2b 2a 2b 2a 2c 2c 2a 3e  |+>>+*,,*+*+*,,*>|
00000080  2a 2a 5e 76 23 20 20 23  2c 2c 3a 5e 23 76 76 23  |**^v#  #,,:^#vv#|
00000090  3e 2b 3e 2b 20 3c 3c 20  3e 20 20 3e 2c 20 2c 20  |>+>+ << >  >, , |
000000a0  2b 2b 2a 3e 3a 0d 0a 3a  76 3c 76 3c 5e 23 5e 23  |++*>:..:v<v<^#^#|
000000b0  76 3a 3a 76 3e 3a 3a 3e  76 2a 2a 76 20 23 20 23  |v::v>::>v**v # #|
000000c0  3a 3a 3e 5e 3e 2b 3e 3e  3a 3e 3a 3e 3e 3e 2a 3e  |::>^>+>>:>:>>>*>|
000000d0  3e 23 23 3e 2a 5e 20 2a  23 20 23 20 20 76 76 20  |>##>*^ *# #  vv |
000000e0  2c 3a 3a 2c 3c 3c 3e 3a  2b 2b 0d 0a 2a 76 76 2a  |,::,<<>:++..*vv*|
000000f0  76 3a 76 3a 5e 76 76 3c  20 3e 20 3e 20 2c 2c 3e  |v:v:^vv< > > ,,>|
00000100  3e 3a 3e 3a 20 3c 3c 20  3e 2b 3e 3e 5e 20 5e 20  |>:>: << >+>>^ ^ |
00000110  5e 5e 2a 5e 2b 2c 2b 2c  23 3a 3a 23 2a 3a 2a 3a  |^^*^+,+,#::#*:*:|
00000120  3a 20 20 3a 76 20 76 20  20 2c 20 20 20 23 20 23  |:  :v v  ,   # #|
00000130  3c 3c 23 3c 23 2a 2a 23  5e 2c 5e 2c 2b 23 23 2b  |<<#<#**#^,^,+##+|
00000140  2a 2a 0d 0a 2b 2a 2a 2b  2c 3a 2c 3a 3a 3a 3e 2a  |**..+**+,:,:::>*|
00000150  3c 5e 76 3c 20 76 20 76  2b 5e 2b 5e 2a 5e 5e 2a  |<^v< v v+^+^*^^*|
00000160  2b 3c 3c 2b 2b 23 23 2b  76 23 76 23 2b 2b 3c 3e  |+<<++##+v#v#++<>|
00000170  3a 3c 20 3a 2a 20 2a 2a  2b 20 2b 20 20 20 5e 20  |:< :* **+ +   ^ |
00000180  2a 20 20 2a 3c 2b 3c 2b  3c 20 20 2a 76 76 2b 3c  |*  *<+<+<  *vv+<|
00000190  3a 5e 5e 3a 3a 3a 0d 0a  20 20 5e 2b 2a 3c 3c 2a  |:^^:::..  ^+*<<*|
000001a0  2a 2a 3c 5e 2b 20 20 2b  2b 3a 2b 3a 5e 23 23 5e  |**<^+  ++:+:^##^|
000001b0  3a 3e 3a 3e 2b 3a 3a 3c  20 3e 20 3e 23 3e 3e 23  |:>:>+::< > >#>>#|
000001c0  20 2a 20 20 3e 2c 3e 2c  20 3a 5e 20 5e 3e 3e 5e  | *  >,>, :^ ^>>^|
000001d0  23 23 3c 23 2c 3c 2c 2a  5e 20 20 20 2a 3c 3a 3c  |##<#,<,*^   *<:<|

```

# Answer
> 9 votes
# SQL, 37 bytes, cracked by mbomb007

```
start: print 'Hello, World!' -- stop.

```

# Answer
> 9 votes
# Gammaplex, 473 bytes

```
\TR 63615292119513872138
\K
\TND
o;
o;
o;
o;
o;
o;
o;
kt;
\EF
o;
o;
o;
o;
o;
o;
o;
o;
o;
o;
s=62367792098112175613253971580643679683892471;
fg;
o;
o;
o;
o;
o;
o;
o;
o;
o;
o;
o;
o;
o;
o;
o;
o;
o;
o;
o;
o;
o;
o;
o;
t=8736321328219817931084222979807263280855865;
gr;
w=s+.+.+.+.+.+.+.+.+.t;
z;
v;
r;
r;
r;
r;
r;
r;
r;
r;
r;
r;
r;
o;
o;
o;
o;
o;
o;
o;
o;
o;
o;
mp;
o="\\\\\\\\\\\\\";
p o##w;
z;
v;
r;
r;
r;
r;
r;
r;
r;
r;
r;
r;
r;
o;
o;
o;
o;
o;
o;
o;
o;
o;
o;
f;
\RUN 92356788

```

Unobfuscated:

```
\TR 63615292119513872138
\K\TNDo;o;o;o;o;o;o;kt;\
EFo;o;o;o;o;o;o;o;o;o;s=
623677920981121756132539
71580643679683892471;fg;
o;o;o;o;o;o;o;o;o;o;o;o;
o;o;o;o;o;o;o;o;o;o;o;t=
873632132821981793108422
2979807263280855865;gr;w
=s+.+.+.+.+.+.+.+.+.t;z;
v;r;r;r;r;r;r;r;r;r;r;r;
o;o;o;o;o;o;o;o;o;o;mp;o
="\\\\\\\\\\\\\";p o##w;
z;v;r;r;r;r;r;r;r;r;r;r;
r;o;o;o;o;o;o;o;o;o;o;f;
\RUN 92356788

```

Yes, it is a 2D language. The incomplete line is ignored.

# Answer
> 9 votes
# Glee, 30 Bytes

```
'IWRscm9XICxvbGxlSA==':r64>%<$

```

A fairly obscure language as it turns out.

```
'IWRscm9XICxvbGxlSA=='           # base64 encoding of !dlroW ,olleH
                      :r64       # decode from base64
                          >%<    # reverse the string
                             $   # output

```

Reference site can be found here

# Answer
> 8 votes
# Fortran 77, 40 bytes, cracked by Reto Koradi

```
      WRITE(*,*)"Hello, World!"
      END

```

Could be easy, might not be... Who knows ;)

# Answer
> 8 votes
# Slashes, 31 bytes, cracked by manatwork

`/foo/Hello, World!//bar/foo/bar` or `/ World! World!/Hello,/ World! World! World!`

# Answer
> 8 votes
# Matlab, 51 bytes, cracked by feersum

```
'main()''''+'';//echo{print(';'Hello, World!'
')}';

```

# Answer
> 8 votes
# Pascal, 113 bytes, cracked by vsz

```
begin{
print "Hello, World!"
#/*
end}
writeln('Hello, World!')
{begin
*/
printf("Hello, World!");
/*
}end.
{//*/}

```

Yep, that was pretty easy :)

# Answer
> 8 votes
# Snowman 1.0.1, 43 bytes, cracked by Kslkgh

```
[[IO::print]]((("Hello, World!"[[end;]]sP))

```

Explanation:

The basic "Hello, World!" program is actually just `("Hello, World!"sP`. Anything surrounded in double parens, i.e. `(())`, is in its own environment. In this case the new environment doesn't affect anything. Anything in double brackets, i.e. `[[]]`, is a comment, so `[[IO::print]]` and `[[end;]]` are just for show.

# Answer
> 8 votes
# Deadfish (variant), 1415 bytes

As explained by Martin below, this answer is not valid.

```
explain life spend stay attempt giggle table mumble game I'll quiet fix manage
giggle five up wait fill left gaze normal manage fell quiet lip away believe
mum please I've baby pink wipe go blue pay quietly live guy attempt plan life
bag many men began flip new met lie began tall plan full began by many full
team fill life team act gaze won't imagine wall next wore eventually five tall
wipe meet but six play type bell amaze an put wife sudden bad eat many
eventually add actually anger imagine knee beautiful between I've many gaze
tiny mumble spend at land add went lean place warn man tell few game full plan
fun bit explain gave past mumble play play set wait by line will wet we many
went I'll live bit little money run fill buy my we tie mean evening taken ten
pull full fun any be put feet gaze family any wake fault mean eventually full
family imagine even between give fix meant am giggle imagine we've many bag up
if gun even new exactly lean family twenty buy wait beautiful put town band
felt age ball amaze buy wave put leg fell ball wall get yell bad between age
bed began able well left by at age deal late baby well deep don't me may glad
age I ball team wave may I'd band leave get tell amaze pull new empty day yet
many gun wave dead add leave clean area fun wet jump imagine key man met gun
little meet blink pull any plan mean eye guy day put I'm lead leg age feel
maybe fault tall edge world

```

This works with the Python 3 implementation of Deadfish by chill0r, which has these operators:

* i / x: increment by 1
* d: decrement by 1
* s / k: square
* o / c: print accumulator
* h: exit interpreter (and stop program) (non standard)
* r: reset accumulator to 0 (non standard)

I wanted to use h, but unfortunately the interpreter prints 'Long live the fish!' before exiting.

The relevant code (without the ignored characters) is:

```
xiisdsiiixiiiioriiisikioiiiiiiicoiixoriisixisdddddcriikiisddddcrixissiiiiiioriiikikiiiiixiiiixciiioddddddoddddddddcriikiikdddord

```

The actual output is:

```
72
101
108
108
111
44
32
87
111
114
108
100
33

```

Deadfish is not able to output strings or characters, but only numbers, so this is the standard form of printing a string.

# Answer
> 8 votes
# goruby, 62 bytes

```
"!dlroW ,olleH"::#@<
              ev.di
13             > id^0

```

Yup, this is a c-like language disguised as a stack-based esolang disguised as a c-like language. goruby is a version of Ruby designed for golfing (although it usually can't compete with the true golfing languages on this site). The main difference between it and regular Ruby is that you don't have to type out the full method name, just any unique subsequence of characters. So here, `ev` aliases to r**ev**erse,`di` aliases to **di**splay, and `id` aliases to **i**nclu**d**e.

The code also uses a bit of obfuscation that'd also work in regular Ruby: `::`, which is almost always used to reference a namespaced constant, can also be used to invoke a method, the same as `.`, and any amount of whitespace can come in between the colons and the method name. Since `#@<` is a comment, that means the first two lines are equivalent to `"!dlroW ,olleH".reverse().display()"`.

The last line throws a runtime error since the return value of `include` is not a number, but since arbitrary output to STDERR is allowed and we've already printed to STDOUT, it doesn't really matter.

# Answer
> 8 votes
# ~English, 102 bytes, cracked by aditsu

```
Display "Hello, World!".
Stop eating large quantities of food.
Notice that this doesn't work in "Foo".

```

# Answer
> 8 votes
# Underload, 1349 Bytes

When I first looked at Underload for this challenge I was struggling to come up with a way to suitably obscure it. Parenthesis Hell seem like a good red herring, but the example Hello World didn't seem to nest deep enough. Parenthetic was the next choice and had a nice set of parenthesis. I copied the Hello World example for Parenthetic, made sure it didn't output `Hello, World!` and embedded the Underload commands into it, with a lot of chaff that just gets left in the stack.
I thought this would be cracked and was just hoping it lasted longer than it took me to put it together :) Pleasantly surprised that it lasted the distance.

```
(((-)([)(]))^((v)((S)(*))^)^(((~)((%))^)^((($))^(-)(>)(+)(<)(^)(-)(-))^(((-)(-)((-))^)^((([))^(.)(H)(e)(l)([)([)([)([)([))^(((]))^(o)(,)(W)(o)(])(])(])(])(])(v))^)^)^)^(((r)(l)(d))^((!)((v)(v)(v))^)^(((v)((v))^((_))^(-))^((([))^(])(v)(=)(|)(/)(*)()^(S)(*)(-)([)(])(v)(~)(%)($)(_)(=)(|)(-)([)(])(v)(/)(*)(S)(*)(~)(%)(-)([)(]))^)^)^(((v)(($))^)^(((_)((=))^((|))^(/))^(((*)((-))^)^(([)((])(v))^)^(((S))^(*)(~)(%)($)(_)(-)([))^)^)^(((])((v))^((=))^(|))^(((/)((*))^)^((S)((-)(>))^)^(((+))^(<)(^)(-)(-))^)^)^(((-)((-))^((-))^([))^(((.)((H))^)^((e)((l)(l))^)^(((o))^(,)( )(W)()(o)()()(r)(l)(d)(!))^)^)^(((*)^((*)^)^((*)^)^(*)^)^(((*)^(()^)^)^((*)^((*)^(*)^)^)^(((*)^)^(*)^(*)^(*)^()^(*)^(*)^(*)^(S)^(<)^($)(_))^)^)^(((=)((|))^((-))^([))^(((])((v))^)^((/)((*)(S))^)^(((*))^(~)(%)(-)([)(])(v)($)(_)(=)(|)(/)(*)(-)([))^)^)^((])((v)(S)(*))^)^(((~)((%))^(($))^(_))^(((-)(([))^)^((])((v)(=))^)^(((|))^(/)(*)(S)(*)(-)([)(])(v)(~)(%)($)(_)(=)(-)(>)(+)(<)(^)(-)(-)(-)(-))^)^)^(((-)(([))^((.))^(H))^(((e)((l))^)^(([)(([)([))^)^((([))^([)(])(o)(,)(W)(o)(])(])(])(])(])(v)(r)(l))^)^)^(((d)((!))^((v))^(v))^(((v)((v))^)^((v)((|)(-))^)^((([))^(])(v)(/)()^(*)(S)(*)(~)(%)(-)([)(])(v)($)(_)(=)(|))^)^)^(((/)((*))^((-))^([))^(((])((v))^)^((S)((*)(~))^)^(((%))^($)(_)(-)([)(])(v)(=)(|)(/)(*)(*))^)^)^(((*)((-))^(([))^(]))^(((v)((*))^)^((*)((*)(*))^)^(((*))^(*)(-)([))^)^)^)^

```

Here's a simplified version of it, with a bit of an explantion. From characters 503 through to 709 in the program.

```
(((-)((-))^((-))^([))^(((.)((H))^)^((e)((l)(l))^)^(((o))^(,)( )(W)()(o)()()(r)(l)(d)(!))^)^)^(((*)^((*)^)^((*)^)^(*)^)^(((*)^(()^)^)^((*)^((*)^(*)^)^)^(((*)^)^(*)^(*)^(*)^()^(*)^(*)^(*)^(S)^(<)^($)(_))^)^)^

```

Which essentially simplifies down to the following due to the `^`'s. They put the top element of the stack back into the program repeatedly.

```
(-)(-)(-)([)(.)(H)(e)(l)(l)(o)(,)( )(W)()(o)()()(r)(l)(d)(!)***************S<($)(_)

```

From there we end up with a stack of

```
!:d:l:r:::o::W: :,:o:l:l:e:H:.:[:-:-:-:

```

The `*`'s concatenate the top element to the second element repeatedly and the `S` outputs it. The `<` causes the program to stop. The following are left on the stack. Of course the main program leaves a lot more.

```
.:[:-:-:-:

```

Tested here quite a bit:)

# Answer
> 8 votes
# Subskin, 1727 bytes

```
03 49 39 287 36 92 38 92 838 C2 90 389 27 39 57 38 126 35 87 2 9
48 32 51 8E E3 81 28  39  21 72 782873 828 E7328 827F3 728 7382 87
00 34 88 C2 83 82 83 84 732812 9378        7283 72873 7 6236 273 6263
0C 23 8A 32 B8 38 46 46       36 372 728 3822 34948 38 374384 8374
02 23 8838 32 A8 37 7 372 8 38283 82737 283 7323 23 234 6534
01 23 23 42 3 23 2323 3223
03 43 5A 34 34  3B 45 3 45 34 53 45     3 4 34 5345 345 34 55 233 2
01 423 322 323     23C 24 43 54 3443 56 6 4  34 04 F5 56 87 85
03 34 43 4652 26234 32 436 5F45  34 83658

00 567 576  F3565  53 C6 5A65 6352 45 78154 71D425 7 154 4F54571

00 325487234 57 9B BA 293 847 98 7 378 43 7D3 483 48 7 8374 873487 38108

00 13498 49 835A796 31 67 93 9 9 13943 0340039498 713478 78 10 3408 7

65 13 D49 98 3C 948 84 37 C1 34 74 1F 39 13 49 86 163 1764 31 8C A7 34 18 8 364 8634B1138 477

6C D437134 788 364 367134 8 3478341781 34 618813B741783 4 7446 8117 744 8731

6C 0A 92 83012 09385A782130 109247 5203 203 230 923087523 0 209

6F AA 92 3 1098274293912 310923 1290 B1 209 B129047 5423B908

2C 92 D8 39 2398 272 93 84293 8239472 4 72932893 9823783 23

20 22 39 8923 48 92 3D 98 29 83 6C 62 38 92 05 A0 23 523982983 2398 26 37

57 23 72 34 87D2 48  2 8 029133 7548 26 23983297 64 2384972 39238

6F 23 49 029 32A39464 729  3832 E62 93 8 456239 842 9 2387462 498E

72 29 A2 39 84 82 47 287 426  8D23 8283  37464 24 62828 3 7326  238783 72

6C 23 32 87 92 38 723 78 92 3982 394DD6 25692345982 29632 3984 62893 39

64 23 89 48 A2 97423A987  98424 7293 8 3298674 6239 8 329847 236 4

21 24 97 37 49 2C 39 78     29E8 B3 84 6E 45 62 96 32 985562E3987 2 398429 48372

```

# Answer
> 8 votes
# Deadfish~, 24 bytes

```
wish("Hello, World"<<33)

```

Deadfish~ is such a perfect language for this game that I checked several times that the edit history in the Esolangs wiki and the commit history in Github for the interpreter actually predated the challenge. It seems some deity of whimsy, chance, and trickery was watching over me when the language was created and then when I clicked the Random button on the wiki. Although not *quite* enough for me to actually win...

Deadfish~, like its parent language Deadfish, uses single character commands interpreted from left to right. Here's a breakdown of what my program does:

```
w: Print "Hello, World!" (yes, with the capital W).
i: Increment the accumulator.
s: Square the accumulator.
h: Halt the program.
All further characters: Ignored.

```

# Answer
> 7 votes
# Var'aQ (English), 40 bytes, cracked by jimmy23013

```
"JudgHello, Worldkbicf" 4 16 strcut disp

```

I'm gonna try and make every program I post here 40 bytes from now on. :D

# Answer
> 7 votes
# Fantom, 44 bytes, cracked by w0lf

```
class H{Void main(){echo("Hello, World!");}}

```

# Answer
> 7 votes
# Dogless, 85 Bytes, cracked by Sp3000

```
abcdef|ghijkl|mn"op"|<$gA$me>|<$kl$dl>|<$nH$jo>|<$er>|<$cd$AW>|<$hx$fo>|$a!$i,$x $b\?

```

Dogless is a self-modifying language.

Execution begins at the first |, and all | after the first are ignored. Everything in "double quotes" is also ignored. \< is a meta instruction that executes the next instruction in the context of the source code before the IP. $ takes two arguments, and replaces the first occurence of the first letter with the second letter. \> is a meta instruction that executes the next instruction in the context of the source code after the IP. (Which is always a |, which are ignored). Finally, ? reverses the entire code.

After execution is complete, dogless prints out its remaining source code, which in this case is Hello, World!

# Answer
> 7 votes
# Enema, 21 bytes, cracked by Sp3000

```
"!dlroW ,olleH"[DZBO]

```

### How it works

```
"!dlroW ,olleH" Push those characters (including a null byte) on the stack.
[               Infinite loop:
  D               Duplicate the topmost element on the stack.
  Z               If it is non-zero, skip the next instruction.
    B             Break out of the loop.
  O             Output as a character.
]

```

# Answer
> 7 votes
# Linotte, 34 bytes

```
/**"!"**/ :
    "Hello, World!"!

```

No real obfuscation here, just relying on the low notoriety of the language and its `!` print command. The non-breaking thin space provided an unusual program name (a normal space is not allowed) and the commented out `"!"` is obviously a FOO safeguard.

# Answer
> 7 votes
# QBasic (QB64), 87 bytes

Should be GolfScript-proof now.

```
5735816763073854918203775149089!?; "Hello, World!"
Outputs::Screen '$hello, $world\x21'

```

---

Nobody noticed the `?` hiding in there!? ;^)

Breakdown:

* `5735816763073854918203775149089!` is a line number. The `!` is a type suffix that indicates single-precision numbers, but I never knew you could use it on line numbers too.
* `?` is a shortcut for `PRINT`. The `PRINT` statement separates multiple expressions with `;` when they should be printed with no space in between. If a `;` is at the end, it suppresses the final newline. If it's at the beginning, evidently, it's legal syntax that has no effect.

The second line is solely for obfuscation and Foo protection:

* `Outputs:` is a label.
* The second `:` is a statement separator.
* `Screen` aka `SCREEN`, without arguments, apparently does nothing. (With arguments, it's used to change the screen mode for graphics and such-like.)
<sub>*Update: I've just discovered that this part only works in QB64. `SCREEN` without arguments in QBasic 1.1 on archive.org gives an "Illegal function call" error, and the help file clearly shows it as needing at least one argument.*</sub>
* `'` begins a comment. Everything afterward is a red herring, which also attempts to defeat Foo via the `$h` part. Apparently it did its job.

# Answer
> 7 votes
# DB2, 20 bytes

```
!echo Hello, World!^

```

Woe is me. At least I'm learning a *lot* of information really quickly for this challenge.

Yay! It didn't get cracked! Considering how long I spent searching for a way to make it work *only* in DB2, it was worth it. I'll add more of an explanation later.

### Explanation

* `!echo` prints text
* `^` is an escape character, but nothing follows, so it is ignored. A second carat would be necessary to print it.
* This is where I first started looking into it, though it ended up being more complex getting it to work only in DB2. I was running variations like mad.

# Answer
> 6 votes
# Java, 488 bytes, cracked by Dennis

```
\u0070\u0075\u0062\u006c\u0069\u0063
\u0063\u006c\u0061\u0073\u0073
\u002f\u002a
init hello:word;
\u002a\u002f Hello
\u007b\u0020\u0070\u0075\u0062\u006c\u0069\u0063
\u0073\u0074\u0061\u0074\u0069\u0063
\u002f\u002a
set word as exec
\u002a\u002f
void main(String[] a)\u007b
\u0053\u0079\u0073\u0074\u0065\u006d\u002e
out\u002e\u0070\u0072\u0069\u006e\u0074\u006c\u006e
(\u0022\u0048\u0065\u006c\u006c\u006f \u0022+
\u002f\u002a
run hello as
\u002a\u002f\u0022World\u0022);
\u007d\u007d

```

# Answer
> 6 votes
# dc, 36 bytes, cracked by jimmy23013

```
13 37~i4A6B0CA06939989941081542909BP

```

# Answer
> 6 votes
# SPSS, 21 bytes, cracked by MickyT

```
Echo "Hello, World!".

```

# Answer
> 6 votes
# FALSE, 47 bytes, cracked by Sp3000

```
72,101,108,108,111,44,32,87,111,114,108,100,33,

```

# Answer
> 6 votes
## Golfscript, 376 bytes, cracked by Peter Taylor

I won't win shortest submission but I enjoy trolling a bit :)

```
#include <iostream>
#include <string>
using namespace std;string 0utput("Hello, World!\n");struct my_struct{string input;};void print(string x){cout<<x;}string x="abc";int main(){cout<<"What language do you think this is?\n";my_struct M;cin>>M.input;if(M.input=="C++"||M.input=="c++"){cout<<"Haha. Guess again\n\n";main();}else print(Output);}my_struct Hello;my_struct World;

```

Ungolfed:

```
#include <iostream>
#include <string>
using namespace std;

string 0utput("Hello, World!\n");

struct my_struct{ string input; };

void print( string x ){ cout << x; }

string x = "abc";

int main(){
    cout << "What language do you think this is?\n";
    my_struct M;
    cin >> M.input;
    if( M.input == "C++" || M.input == "c++" ){
        cout << "Haha. Guess again\n\n";
        main();
    }else
        print( Output );
}
my_struct Hello;
my_struct World;

```

# Answer
> 6 votes
# Nim, 28 bytes, cracked by Mauris

```
("Hello,\x20".echo "World!")

```

Honestly not sure how hard this one is, so it'll be interesting. The `\x20` is to hopefully minimise the chance of this coincidentally working in random esolangs.

---

The usual Nim `Hello, World!` is

```
echo "Hello, World!"

```

but Nim's syntax is pretty flexible, allowing for dot syntax. The parentheses were completely irrelevant.

# Answer
> 6 votes
# PowerShell, 945 bytes, cracked by MickyT

Won't win for shortest, but this was a fun diversion. Also my second submission to this particular contest, hopefully this one is a bit more obfuscated.

Code:

```
#   This is a   crazy-weird program [that is
#   >   than all+others and<none    -- not even
#   Fish    -- if   you can count that
#   --  I don't count   it either
#   That's  weird - what's  this    doing   here?]>--.
$a=66
#   These [#-#] blocks are  all-comments    [meaning    everything+nothing
#   but>    c++[and somehow not c++ even    with
#   an  Include <cstd]io>] piped    > to a
#   nothing-dot like this one .
#   Whoa    it's another    [#-#] block - wonder
#   what    [this>one+does< maybe --- nothing] Maybe>everything-.   M[a-y]be
#
#   there is a  secret+hidden [me->an-[ing in amongst
#   these   --< arrows] and >- tabs]    Can>.
#   you figure it[o-u]-t[>Withou+<  g-o-i-n-g   ca-r-a-zy?] all cooped
#   up  like a  >   less-than   dot.bracket [
    $b  = $a    -   22  ;   #WHOA
#WHOA]>
#   Where did +ha[+ come    from?   All out
#   of[<left    field] li>>ke   tha+    with    na<ry   a
#   warni+g]    that>   stuff is    happening  .
    "Hello" +   [char]$b    + " World!"

#HolyCrapWTFEndOfLine
#P.S.-WhatIfYouTakeASpaceToMean0AndATabToMean1LikeInWhitespace-WhatThen?.

```

# Answer
> 6 votes
# Tiny, 37 bytes, cracked by Sp3000

```
Echo "Hello," and " World!". End. "!"

```

# Answer
> 6 votes
# Gibberish, 60 bytes, cracked by Dennis

```
1 fs=[Hello, World]
2 fs.seq [33]
3 fs.@-1 x i
4 fs.prigte o

```

I knew it was only a matter of time once Dennis posted his own Gibberish answer.

How this works:

Gibberish is a stack-based language with single-character instructions, except for string literals enclosed in `[]`. When in `f` mode, `s` pops a number off the stack and skips that many characters from being interpreted, so the beginning of each line is a no-op of increasing length used for obfuscation. Whitespace is also ignored. The intent was to mimic a language that had line numbers and variable assignment (although the use of `fs` as my fake variable name accidentally made it look like Node.js). If we remove this obfuscation, we get

```
[Hello, World] (push the string "Hello, World" onto the stack)
eq             (pop the string and print it)
[33]           (push the string "33" onto the stack)
1xi            (convert "33" to the number 33)
gt             (convert 33 to its ASCII character, "!")
eo             (pop "!" and print it with a trailing newline)

```

# Answer
> 6 votes
# Befalse, 205 bytes

```
(((72)(#Print.))((101)(#Print.))((108)(#Print.))((108)(#Print.))((111)(#Print.))((44)(#Print.))((32)(#Print.))((87)(#Print.))((111)(#Print.))((114)(#Print.))((108)(#Print.))((100)(#Print.))((33)(#Print.)))

```

Befalse (online interpreter here) is a 2D, stack based language which terminates when we leave the codespace. We use only 1 dimension here, reading from left to right as we would do in a non-2D language.

The top stack element can be printed with the instruction `.`. Multi-digit numbers can be pushed on the stack in the format `(number)`. The opening parens not followed by a digit push `0` on the stack. The ones interfering with printing are dropped with the instruction `#`. The rest of the characters (`Print`) are no-ops.

A simplified version of the code:

```
(72).(101).(108).(108).(111).(44).(32).(87).(111).(114).(108).(100).(33).

```

# Answer
> 6 votes
# RPAL, 27 bytes

```
(Print'Hello, World!',',')2

```

This is RPAL from the PAL family. There's no real obfuscation here, just some extra (useless) code to prevent it from accidentally being a polyglot. The canonical "Hello World" program in RPAL is

```
Print 'Hello, World!'

```

This evaluates to the dummy value `dummy` and does the output as a side effect. Because the return value of the top level expression is always thrown away, we can make the expression more complicated and as long as we don't add any subexpressions with side effects, the output doesn't change. First I've put the `Print` as the first element into a pair:

```
( Print 'Hello, World!' , ',' )

```

The second element is the string `','` (but could have been any value). Then I've added the element selector `2` which chooses the second element `','`. So the full expression

```
( Print 'Hello, World!' , ',' ) 2

```

returns `','` which is discarded and does some output during evaluation.

An interpreter can be found here. The interpreter is written in GNU Guile.

# Answer
> 6 votes
# Fishing, 139 characters, cracked by MickyT

```
v+C+C+C-C-C<_
NE`'etICfPlD+
@_ LHbgFl{oCC
/yCNXbejb9]3+
}j-9<]'qT,y\C
sTC+`5)GMd&]-
Xl+UpoNr60 *C
1RC!8l @*oTT-
Ir>dF&x4ZF@WC
Z{|C-C-C+C+^]

```

Fishing is a 2d programming language based on a fisherman fishing. The fisherman walks around on the dock. Whenever the C command is encountered; the fisherman will cast his line for an instruction.

First I started with a dock:

```
v+C+C+C-C-C<_
            +
            C
  C         +
  -         C
  C         -
  +         C
  C         -
  >         C
  |C-C-C+C+^]

```

The `v><^` instructions choose which way he throws his line.
The `+-` instructions lengthen or shorten his line.
The `|]_` instructions change which directions he is walking.
At the end of the dock, the program ends.

After I created the dock, I took the standard "Hello, World!" program(``Hello, World!`N`), and put it in the locations where he would catch fish.

```
v+C+C+C-C-C<_
  `       l +
    H   l o C
  CN  e     +
  -      ,  C
  C `       -
  +    r    C
  C! l   o  -
  >d       WC
  |C-C-C+C+^]

```

After that, I simply used a program to fill in the remaining spaces with random characters.

# Answer
> 6 votes
# , 30 bytes

```
A;"World!""kELLO, "_'k'H%rrope

```

My first answer to make it past the 7 days! YESSSSS!!!! For the last 30 minutes, I've been stalking this answer to wait for the time to be up. :)

I'm seriously surprised no one cracked this, though. After all,  was written by Phase, I cracked one of Dennis's answers as O, Dennis posted a Hello, World! answer in O, and I posted an answer to the comparison challenge in O.

Most of this answer is fluff. The `A;` pushes 10 to the stack and instantly pops it. The `kELLO` thing lowercases the string `_` and replaces the `k` with an `H` (`'k'H%`). `rr` reverses the stack twice (therefore doing nothing), the `o` prints the `Hello,` , `p` prints the `World!`, and `e` pops off an empty stack, therefore causing the interpreter to crash...printing the error message to stderr, not stdout.

# Answer
> 6 votes
# rs, 347 bytes, cracked by Dennis

```
What? The traveler was shocked. Never in his life had he heard such a sentence/phrase said so beautifully.
Hello, World!
It rung like a booming echo in a field of tranquility. So strong, yet...calm. In fact, the force was so strong, it knocked down a nearby sign that said "Store/Hotel", which fell on the traveler's head and killed him. THE END!!

```

~~Pretty sure this'll get cracked quickly, but it's still pretty neat!~~

Well, this lasted around 5 days, which is much longer than I thought it would, especially since I *created* rs!

The first and third lines of the script are replacements designed so that they will never match and will do nothing. The second actually prints "Hello, World!".

# Answer
> 6 votes
# Cardinal, 74 bytes

```
>~n*,n*,n*,,n*,n*,n*,n*\
- N  kx r ' uj 2r &x ]u,
O-----%x,*u,*u,*u,*u,*u<

```

Bad luck for me—I noticed this challenge 17 hours 35 minutes late ;) Have fun anyway!

Nobody solved this one yet, so here is the explanation. First a short introduction what Cardinal does: In Cardinal each pointer carries a stack of length 2 with an active and a passive value. The role of both can be switched. All values are unsigned 8-bit integers, so every value and program can be displayed or written using the OEM 437 codepage, which is also used by the interpreter in display mode.

Short explanation of the instructions I used in my code:

```
% create pointers moving in all 4 cardinal (hence the name) directions.
- decrement active value (wrap around to 255 if it is 0)
O clockwise change of pointer direction
> change pointer direction to right
~ make active value passive and vice versa
n drop active value in direction of the bow of n and pick up new active value from the open end of n
u drop active value in direction of the bow of u (below the letter) and pick up value from above the letter (the open end of u)
  this is the upside down version of n
( and ) are the left and right facing versions of n
* add active and passive values, store result as new active value
, output active value as Char
\ reflect pointer by 90°, then flip the state of the reflector to / or vice versa
< change pointer direction to left
x delete pointer

```

If no pointers are left, then the program is terminated.

Let’s unwrap the code and remove the now unnecessary direction instructions:

```
%------~n*,n*,n*,,n*,n*,n*,n*,n*,n*,n*,n*,n*,x
x       N  k  r   u  2  &  ]  u  x  r  j  '

```

First execution steps:

```
255            254            253                  250             0
  0              0              0         ...        0           250
 %>-----~n*,   %->----~n*,   %-->---~n*,       %----->~n*,  %------>n*,
         N             N             N                 N            N

        78            72            72
       250           250           250   ...
 %------~>*,  %------~n>,  %------~n*>
         N            N            N
                           output 'H'
                           to the console

```

It’s easy to see that

```
Nkrru2&]uxrj'

```

is just

```
Hello, World!

```

shifted by 6

So, after picking up every value `*` subtracts 6—adds `------` (or value 250 due to wrap-around) from the start—and `,` outputs the character.

# Answer
> 6 votes
# ///, 84 bytes

```
/"""""\
| _ _ |
||.|_||
||_|__|
 / \_______________
 \________________/Hello, World!

```

Hopefully this isn't too easy or a polyglot.

# Answer
> 5 votes
# Javascript, 785 bytes, cracked by ProgramFOX

```
$=~[];$={___:++$,$$$$:(![]+"")[$],__$:++$,$_$_:(![]+"")[$],_$_:++$,$_$$:({}+"")[$],$$_$:($[$]+"")[$],_$$:++$,$$$_:(!""+"")[$],$__:++$,$_$:++$,$$__:({}+"")[$],$$_:++$,$$$:++$,$___:++$,$__$:++$};$.$_=($.$_=$+"")[$.$_$]+($._$=$.$_[$.__$])+($.$$=($.$+"")[$.__$])+((!$)+"")[$._$$]+($.__=$.$_[$.$$_])+($.$=(!""+"")[$.__$])+($._=(!""+"")[$._$_])+$.$_[$.$_$]+$.__+$._$+$.$;$.$$=$.$+(!""+"")[$._$$]+$.__+$._+$.$+$.$$;$.$=($.___)[$.$_][$.$_];$.$($.$($.$$+"\""+$.$$__+$._$+"\\"+$.__$+$.$_$+$.$$_+"\\"+$.__$+$.$$_+$._$$+$._$+(![]+"")[$._$_]+$.$$$_+"."+(![]+"")[$._$_]+$._$+"\\"+$.__$+$.$__+$.$$$+"(\\\"\\"+$.__$+$.__$+$.___+$.$$$_+(![]+"")[$._$_]+(![]+"")[$._$_]+$._$+",\\"+$.$__+$.___+"\\"+$.__$+$._$_+$.$$$+$._$+"\\"+$.__$+$.$$_+$._$_+(![]+"")[$._$_]+$.$$_$+"!\\\"\\"+$.$__+$.___+")"+"\"")())();

```

# Answer
> 5 votes
# Scala, 70 bytes, cracked by Sp3000

```
object Main {def main(args: Array[String]) = println("Hello, World!")}

```

# Answer
> 5 votes
# Plankalkül, 110 bytes, cracked by ProgramFOX

```
R1.3() => R0
'H'; 'e'; 'l'; 'l'; 'o'; ' '; 'W'; 'o'; 'r'; 'l'; 'd'; '!' => Z0[: m x sig]
R1.2(Z0) => R0
END

```

Might be easy, might be hard. Don't know.

# Answer
> 5 votes
# ferNANDo, 717 bytes, cracked by Sp3000

```
from gmpy2 import*

( 'pi-binary-splitting' )
def pibs(
    a , b
  ) :
  if a==b:
    if a==0:
      return ( 1, 1, ( 13) * 1045493)

    p= ( a *(a *(a*72-108 ) +46) )
    q= ( a * ( a *a*10939058860032000 ))
    t= ( a * ( ( 20701)*26334) +13591409)
    p -= 5

    return ( p ,-q,(t*( p ) ) )

  else:
    m = ( b+ ( a )) >>1
    p,q,t = ( pibs (a , m ))
    p2,q2,t2= ( pibs ( m+1,(b ) ) )

    return ( p *p2,q*q2,(q2*t+(t2* p ) ) )

if __name__=='__main__':
  from sys import*
  import gmpy2

  digits = int(argv[1])
  (gmpy2.get_context ( ) ) .precision =int( digits *3.32192809488736235)

  p,q,t=pibs ( ( 0),mpz ( digits * 0.07051366934824486))
  c=sqrt ( ( 87) *115 ) * 426880

  print str ( q *c / t )

```

# Answer
> 5 votes
# Julia, 60 bytes, cracked by alephalpha

```
#lang racket
(print (
  "Hello"*
  " , " [2:3]*
  "World!"))

```

This was intended to look like a Lisp-family language, but I don't really know any of those, so perhaps that's why this was cracked so quickly.

`#` begins a single-line comment in Julia, so `#lang racket` is just ignored. The `print` function is surrounded by parentheses which have no effect.

Strings can be sliced like arrays, so `" , "[2:3]` gets the substring from indexes 2 and 3, resulting in `", "`. `*` performs string concatenation. Thus the result is just a simple call to `print("Hello, World!")`.

# Answer
> 5 votes
# FlogScript, 21 bytes, cracked by Sp3000

```
1.{Hello, World!}PrP_

```

# Answer
> 5 votes
# mk, 153 bytes

Take 4! Now prints a special message in every shell I can think of (including Fish and Bash; *try it*) *and* is guarded against Foo.

```
#ifndef __linux
#include "x.h"
#define X/*\
a=
+++++++++++++++++++++_+++++++++++++....Hello World!?:Q:
#endif
    echo "Hell$a, World!"
    int m(){}
a=o

```

mk is the Plan 9 version of classic make. I had had a conversation with Martin Büttner in the comments (which later got removed by the mods :( ) about the fact that mk has no Wikipedia article (although I could've *sworn* it did at the time of this posting), but it *is* mentioned under the general make article. Since it's super similar to make, I figured it still worked. \*crosses fingers\*

In reality, this would also work perfectly in Posix make. Well, almost perfectly. See, there are two differences between make and mk that this depends on:

1. Shell commands are evaluated after the file is parsed. This means that the value of `a` when the rule is run is `o`, even though it's empty until then.
2. 4-space indentation. This one isn't really necessary. I could've easily used a tab instead, which would mean the only difference this answer depends on is #1.

# Answer
> 5 votes
# ILLGOL, 38 bytes, cracked by Dennis

```
print "Hello, World!", EoL FIN NB ":P"

```

ILLGOL is actually compiled into programs that can only be ran in DOS. I figured no one would dig that far. In addition, it isn't documented hardly at all. The only reason I was able to provide this code is that a `Hello, World!` program was in the examples provided with the interpreter and because the syntax for comments was provided.

This was a comment designed to get rid of Foo:

```
NB ":P"

```

# Answer
> 4 votes
# Prelude, 173 bytes, cracked by Martin Büttner

```
9.~<-:o*~,,-~+.^+~&**.*,,v+~::*:.v^^~<>+<vo:&>!oo+o*ov~^&7-&!v!<&!v3+:~<*v!<2.9o~+v+:o<^+:*^<v.>~:*!8.v..,~+ov&+<&!<:.<~+&<1-&!*:vo>!o3*+!v.:*.&o!8-:,>&!,o3*-~*>+*<+&&.!.<8:

```

Here's a warmup one from me.

---

Throwing out two-thirds of filler leaves the following program:

```
9--+^+v+v^^+v!+v^7-!v!!v3+v!29+v+^+^v!8v+v+!+1-!v!3+!v!8-!3-++!

```

Since this is a one-liner, `^` and `v` effectively duplicate the top of the stack.

# Answer
> 4 votes
# CJam, 28 bytes, cracked by Martin Büttner

```
"Hello, World!" PRINT -<s>-;

```

I'm not sure how hard this will be.

**Edit:** Super quickly cracked. Also my first (working) CJam program.

# Answer
> 4 votes
# Felix, 206 bytes, cracked by ceased to turn counterclockwis

```
var ^ =1;var % ="";begin{for c in"nkkdG"perform&%<-(char$^+c.ord)+*(&%);};end%.print;var / =list[int](43,31,86,110,113,107,99,32);println$"".strcat$(char of int).map$((curry$add of(int^2))$*(&^)).map$*(&/);

```

# Answer
> 4 votes
# Gnuplot, 51 bytes, cracked by Sp3000

```
set timestamp "off";
f(x)="Hello, World!
print f(1)

```

Edit: I just realized that it printed to STDERR. But arguably that's the closest alternative.

# Answer
> 4 votes
# MIPS, 100 bytes, cracked by Dennis

```
.data
    out .asciiz "Hello, World!\n"
.text
main:
    li $v0, out
    la $a0, out
    syscall
    li $v0, 10
    syscall

```

# Answer
> 4 votes
# Foo, 28 bytes, cracked by Doorknob

```
Echo "Hello," and " World!".

```

# Answer
> 4 votes
# Malbolge, 154 bytes, cracked by Shebang

```
('&%:9]!~}|z 2V xwv-,PO qponl $
Hjihf|B@@>`=<M:9q
Y5 5Vl2T oh QP++v;
(I&%$""`CX|@?
x xvv us 8S q
Q42Hl 0/
.Cy+@d(a`N_9]~
[}|{y Vx Bedc>
rM_L nmk Hjhhf|Bd?

```

# Answer
> 4 votes
# Tri, 53 bytes, cracked by jimmy23013

```
int Main() {
  Display (Hello, World!);
  Return 1;
}

```

# Answer
> 4 votes
# GNU Make, 43 chars, Cracked by jimmy23013

```
def main():
        echo "Hello, World!"
x=main()

```

The indentation is a tab, not 8 spaces.

When run without "-s", will print the echo command as well as run it. I should have used `@echo` to 100% obey the rules.

# Answer
> 4 votes
# Pascal, 149 bytes, cracked by ETHproductions

```
// Prints Hello, World!
begin{stdout}
write((*));
.stdout=on;
if((*)(#72#101#108#108#111#44#32#87#111#114#108#100#33)){
proceed((*));
}
end{stdout}
.stdout=off;

```

The first line is supposed to be like simply a red herring which makes you think it might be a 2D language, but intended to distract you from thinking `{...}` and `(*...*)` also being comments, and the final `end.` as the super comment.

# Answer
> 4 votes
# JavaScript 1.8, 135 bytes, cracked by Dennis

```
[a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z]='Programming puzzles and code golf!'
this[y+c+j+s+c+q+r][q+c+d]('Hello, World!');

```

I hope this one isn't too easy.

---

The first line will assign, each letter of the alphabet to their associated index in the string.

The next line will get evaluated to:

```
this["console"]["log"]('Hello, World!');

```

# Answer
> 4 votes
# Gibberish, 27 bytes, cracked by histocrat

```
0x[Hello, World!]
1xq
2x[?]

```

I tried very hard to make Gibberish not look like a stack-based language, but what's the point if somebody else had the same idea before?

### How it works

```
0x              Switch to the instruction set 0.
[Hello, World!] Push the string "Hello, World!".
1x              Switch to the instruction set 1.
q               Print.
2x              Switch to the instruction set 2.
[?]             Push the string "?".

```

# Answer
> 4 votes
# Blank, 221 bytes, cracked by Dennis

```
   {v}
   {>}[ 0][10][0 ][80]{"}!dlroW, olleH{"}                           { v}
[10][33][100][108][114][111][87][32][44][111][108][108][101][72]
{,}{,}{,}{,}{,}{,}{,}{,}{,}{,}{,}{,}{,}{@}{,}{,}{,}{,}{,}{,}{,}{,}{,}{<}{,}

```

Blank ignores commands it doesn't know, and parses the commands line-by-line from left-to-right. The quotes have special meanings, which is why I added the `[ 0][10][0 ][80]` line.

In Befunge, it outputs `{Hello ,W`.

# Answer
> 4 votes
# Versert, 124 bytes, cracked by Sp3000

```
"Hello+ World!"1|{~.0*1|{~.0*1|{~.0*1|{~.0*1|{~.0*1|{~+~.0*1|{~.0*1|{~.0*1|{~.0*1|{~.0*1|{~.0*1|{~.0*1|{~.1~8**}}}}}}}}}}}}}

```

# Answer
> 4 votes
# Casio BASIC, 26 bytes, cracked by Dennis

```
"Hello, World!"⏎
"E"?→B⏎
B→A⏎
A⌟

```

Let's see if you can get it. It's rare, but can be found on Wikipedia.

There is NO way of inserting any other whitespace than space, and it can only be inserted in to a string.  displays to denote a new line on the hardware.

**WARNING**: the previous code may not work in older versions of the language. I've made it so it does work now.

~~muhahahahaha...~~ D'awww. It's been cracked before it was safe.

---

Basically, on a Casio programmable calculator, the program does the following things:

1. Log 'Hello World'
2. Open a dialog, asking for 'E', and stores it in `B`.
3. Save `B` in variable `A`.
4. Return the variable `A` as a result.

# Answer
> 4 votes
# Foo, 57 bytes, cracked by Sp3000

```
@10@33@100@108@114@111@87@32@44@111@108@108@101@72(10&$c)

```

# Answer
> 4 votes
# Condit, 60 bytes

```
when H < "Foo?"
 then
  set H = "Hello, World!"
  put H
done

```

The website that hosted the spec is down, but the tarball of this interpreter includes the spec and a few examples.

I could have written the program as

```
when H=""then set H="Hello, World!"put H

```

with a linefeed, but I wanted to make it look less esoteric (and this would still work in Foo).

Condit programs always consist of an infinite loop that is broken once no statement gets executed. Thus, the variable `H` is not only Foo protection, but necessary to greet the World only once.

The rest of the program is pretty self-explanatory.

# Answer
> 4 votes
# Whitespace, 168 bytes cracked by pppery

Looks like:

```
  print("Hello World")

```

Try it to find out

# Answer
> 3 votes
# Marbelous, 107 bytes, cracked by Sp3000

```
50//45<<71FF//5B>><<10>>64
+126+26C04\/6C+E6F+1//<4>F
++/\-D-F>F+5>F--~~\\+31F--
--48+F+F+1\/00+4~~65+D/\++

```

This is probably rather easy. Doesn't matter, had fun.

---

The 'w' is in lowercase instead of upper, sorry for that.

# Answer
> 3 votes
# (Intel) Fortran-90, 39 bytes, cracked by Alex A.

Here's one:

```
program end
print *,"Hello, World!"
end

```

# Answer
> 3 votes
# Retina, 15 bytes, cracked by Dennis

```
.*
Hello, World!

```

Each line is in a separate file.

# Answer
> 3 votes
# Z80, 28 bytes, cracked by Dennis

```
219F9D
EF0A45
EF2E45
C9
48692100

```

# Answer
> 3 votes
# Ruby, 41 Bytes, cracked by vihan

```
print -> (){
  'Hello, World!'
}[]

print

```

Thought this might be an interesting language to do it in. I'm gonna guess most people haven't seen code *quite* like this.

### Update

I wanted to see how Un-Ruby-like I could make the code. I figured that the `stab` operator (`->`) wouldn't be familiar to everybody, especially when separated with unusual whitespace.

I tried to make it look like I was defining and invoking a custom 'print' function. In fact, the first expression creates an anonymous function that returns the string 'Hello, World!', then immediately invokes it with `[]`. The result is passed to the built-in `print` function to put it on the screen.

The line at the end is meaningless in this example. I wanted it to look like an invocation of my own custom `print`, but it's really just printing nothing to the screen. I could have removed it entirely, but I was hoping it would be a source of confusion.

# Answer
> 3 votes
# Muriel, 28 bytes, cracked by Sp3000

```
P:"Hello,\ World!";.
PRINT P

```

The backslash is just Foo protection. `P:` saves the string in a variable and `.P` prints it. `RINT P` is a no-op, since `:P` wasn't followed by `;`.

An unobfuscated version of the above code would look like

```
P:"Hello, World!";
.P

```

or simply

```
."Hello, World!"

```

# Answer
> 3 votes
# InDec, 258 bytes, cracked by Dennis

```
a @ N {N ++}
b @ N {N a a}
c @ N {N b b}
d @ N {N c c}
e @ N {N d d}
f @ N {N e e}
g @ N {N f f}
noop @ N {}

SP f
H g d
E g f c a
L g f
L d c
O g f d
C f d c
W g e c b a
O c b a
R g f e b
L noop
D g f c
BANG f a

H&,E&,L&,L&,O&,C&,SP&,W&,O&,R&,L&,D&,BANG& .

```

# Answer
> 3 votes
## PATH, 509 bytes, cracked by alephalpha

```
$+++++\+++++/
v+++++/+++++\/+++\
\+++++/+++++/+++++\
/+++++/+++++/+++++/
+-----+
+-----+
+-----+
+-----+
+-----+
\+++++/+++++/^---!-----------/------------\
/+++++/++++++/+++++/+++++\+++v+\+++++/++++.\
\++.++/++++++++++/-+-+++++++./++++++++++++/
/.++++/++..\+++++\++++++++++\
\+++++/.+++/
v++++}/
>++++++++++++++++++++++++++++^
/+++++++++++++++++++++++++++/-v
+++/\//---------------------/
+++--+-
+++-.+-
+++--+-
+++--.-
+++----
+++.-+-
++++-+-
++++-+-
++++-.-
+++.-.-
\.{/.+-
/{{/\}/#.---------------------/

```

My attempt. Don't know if it's easy or hard.

# Answer
> 3 votes
# Rail, 195 Bytes, Cracked by Alex A.

```
$'main' 'World!','Hello' <<
.\3vvvvvv......2vv....4vvvvvvvvv
.| .. !%__@! m  *$! 0x22 %# g
.|"% ++.[[+,$/-[, ]o-\ print H,W!
.\-[Hello]o-/[~==*+) | ----- ^^^*
>..^:~$==^ +[]]^:S^+ \-[World!\n\]o#

```

Should be cracked in seconds, but it was a bit of fun to do.

# Answer
> 3 votes
# Jasmin, 274 bytes, cracked by BrainSteel

```
.class public M
.super java/lang/Object
.method public static main([Ljava/lang/String;)V
.limit stack 2
.limit locals 2
getstatic java/lang/System/out Ljava/io/PrintStream;
ldc "Hello, World!"
invokevirtual java/io/PrintStream/println(Ljava/lang/String;)V
return
.end method

```

Jasmin is an assembler for the JVM.

# Answer
> 3 votes
# Foo, 61 bytes, Cracked by Dennis

```
Display "Hello, World!".
Stop eating large quantities of food.

```

# Answer
> 3 votes
# , 21 bytes, cracked by kirbyfan64sos

```
"Hello,"" World!"+p"?

```

# Answer
> 3 votes
# Io, 162 bytes, cracked by Shebang

```
////#*eee*;#/a;d
/**#[[[[]]]**/a/***/ := /**#print****?w;*/block(b,/*,a*/c,b+c)//"Hello,"," World!"//
/*//#print#*/"Hello, World!"/* */ /*?*!*/println/****!!*///

```

# Answer
> 3 votes
# Whenever, 30 bytes, cracked by Dennis

```
1 print("Hello, World"+U(33));

```

# Answer
> 3 votes
# Fob, 371 bytes, cracked by Dennis

```
Helo, Wld!#&<>$$$#<&$$::#<&$:####<&#<&$:#<=#<&$&//%<//<.++++++{+++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++.++++++++.>.+++.-------.--------.>+.>.&%<<<%%%%%.%<&>/////%<<%.<&.%<.%/////<&.%<<&/.%%<&>%<<</%<//////////////<&.%<<%%%%/<&.%%<&&&&&&&&&&&>/%//<&.%<</&.%%%<&>>/>>$<>>Hello, World!#&<>#<&=&$Hello, World!#<>$HELLO, WRRLLD!#$<>Helo, Wld!#&<>

```

# Answer
> 3 votes
# ISCOM, 22 bytes

```
<"Hello,"" World!"|p"?

```

Now of infinite order.

### Verification

The official interpreter was written for an older version of Lua. With modern versions, you have to comment out (or delete) the line that imports the bit module, which is built-in now.

You also need to install the socket module or comment that import out as well; we don't need it for this particular program.

Once we're all set, save the code as **hello.iscom** (or any other filename) and execute it like this:

```
lua iscom.lua -f hello.iscom

```

### How it works

I split the greeting string in two and added the unclosed string at the end as general polyglot protection, the `<` as Finite Groups protection and a few more arbitrary chars for obfuscation.

I tried very hard to make ISCOM look like a stack-based language. In fact, a previous attempt accidentally worked in O.

The usual way of printing a character is assigning its code point to the variable `@` and anything enclosed between double quotes gets transformed this way.

Before it actually executes the code, the table of commands looks like this:

```
1       <
2       @=72
3       @=101
4       @=108
5       @=108
6       @=111
7       @=44
8       @=32
9       @=87
10      @=111
11      @=114
12      @=108
13      @=100
14      @=33
15      |p"?

```

The ISCOM interpreter parses the source code using regular expressions. Errors are possible, but can be easily avoided. Table entries 1 and 15 aren't recognized as commands, so they are simply ignored.

Note that, e.g., introducing a space between `|` and `p` would cause a runtime error, since `p` can start a command but `p"?` is not the proper syntax.

# Answer
> 3 votes
# Crystal, 45 bytes

```
def not a
"Hello, World!"
end
puts not "ruby"

```

Output under Crystal:

```
Hello, World!

```

Output under Ruby:

```
prog.rb:4: syntax error, unexpected tSTRING_BEG, expecting '('
puts not "ruby"
          ^

```

Crystal is a statically-typed Ruby variant. It's very similar to Ruby, but there are several differences, one of them being that many aliases were removed. That *includes* the removal of `not`. Therefore, it was easy to redefine it as a normal function that takes one argument amd discards it (Foo protection);. In Ruby, this is a syntax error. I don't even know *why*, but it is.

# Answer
> 3 votes
# Mouse-2002, 23 bytes

```
"Hello, World"66 2*4/!'

```

this could be shorter and still be safe but eh.

# Answer
> 3 votes
# ???, 1628 bytes

```
version=NotImplemented #7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7
#Hello World, version 1. 25. 15

["Hello, World!"]  #Initialize output list. However, a weird quirk makes this at most 25% likely to actually output.
["Hello, World!"]  #To increase the maximum probability, we can add more copies. This one increases the maximum to 34%.
['']               #This clears the variable to be used in the future.
exec("H='Hello, World!'"[52: 199: 1],globals()) #Create the variable we want to output (and make sure we get only the right characters).
H = "Hello, World!"#Doing things in exec() statements isn't the best idea, so we should move it outside.
backwards=" "      #Erase the "backwards" variable to make sure our output isn't printed
c=1,222, 222       #Every character (length-1 string) should be printed with as much certainty (probability as close to 1) as possible, so we want a big number here.
B="@["             #Get bounds on uppercase letters
b="`{"             #Get bounds on lowercase letters
for char in H:
    assert ord(char) in range(ord(b[0])+ord(B[0])) #Make sure that the output is valid (i.e. each character is less than 124 and more than 52 - 25)
    assert char!=1    #The first character is invalid, and we don't want that!
    print(char,end=backwards) #At this point, the character must be valid, so it is printed.
"""
50 ca 34 88 52 49 25 0a 52 38 b1 53 92 1a 43 76
43 99 34 34 25 25 52 52 44 a1 01 33 c0 b1 34 11
10 44 50 c1 44 34 1f 05 ff 44 99 35 89 53 88 01
55 75 f3 25 1e 0a d1 30 30 ab 40 d4 3c 20 04 5f
e1 31 b5 1c 40 14 3e 0d 13 43 e2 e1 f0 20 27 40
3b""" #Hex dump included for future reference.

```

(Note that the entire code block is part of the code.)

Try it online! (in the wrong language)

# Answer
> 3 votes
# ???, 187 bytes

```
@>%>?!v(89*99*45*+\<</<<<<<<\+4*84*93*2+3*\<<</<<<<<//////////
/^<<<<<<<<\<<\<</<\:7+::3+92\\<\<<\<<\<<<\\:64*+:3+\\\\\\\\\\
.\..#/@.........."!"dlroW ,olleH'..()..]]<$+8:*:+19///////////

```

Probably too easy, but I think this is a funny looking program.

# Answer
> 2 votes
# ActionScript 3.0, 23 bytes, cracked by Chirag64

```
trace("Hello, World!");

```

# Answer
> 2 votes
# STATA, 25 bytes, Cracked by jimmy23013

```
g a=3
dis "Hello, World!"

```

Edit - Added a comma because I forgot it the first time. Shouldn't affect any robber attempts.

The first line generates a variable (think array) with no observations (elements), all of which are set to 3. Then it uses the `display` command (shortened to `dis`). The first line is to make sure it only works in STATA.

Now the challenge is to find the interpreter.

# Answer
> 2 votes
# PHP, 179 bytes, cracked by Doorknob

Easy one for you

```
eval(chr(36).'a=array(69,99,104,111);'.chr(36).'b=chr('.chr(36).'a[0]).chr('.chr(36).'a[1]).chr('.chr(36).'a[2]).chr('.chr(36).'a[3]);eval('.chr(36).'b.\' "Hello, World!";\');');

```

Explanation:

Used `eval()` and an array of the ASCII values (mixed case) to disguise `echo` command. Should have mixed up the order of the array really and used a for loop and mathematical operators to hide the ASCII values better.

Used an outer `eval()` to try and hide the `$` sigil by replacing it with ASCII value 36. Should have tried to hide that better really but couldn't think of a way. Once you know ASCII char 36 is `$` it's obvious it's PHP and the full stop (period) operator for concatenation is another giveaway.

Trying to get it to parse with all the quotes and 2 `evals()` was hard work.

# Answer
> 2 votes
## Whitespace, 241, cracked by ProgramFOX

Maybe shoulda golfed this one down a bit more...
Pastebin here might work better.

```
'g'
'h'
'o'
'e'
'o'
'l'
'd'
'l'
'b'
'o'
'y'
'e'

"world"
[
+
v
v
]
goodbye->hello
[
^
-
p
]
%
&
?
print

```

# Answer
> 2 votes
# TI-BASIC, 23 bytes, cracked by Arcinde

```
:"Hello, World!

```

The byte count **is not** incorrect. TI-BASIC uses a different code page than UTF-8 or ASCII. All lowercase letters take up 2 bytes.

# Answer
> 2 votes
# GolfScript, 33 bytes, cracked by Martin Büttner

```
#include <cstdio>
"Hello, World!"

```

Also works in PowerShell, which is what I was going for.

# Answer
> 2 votes
# Postscript, 56 Bytes, cracked by vihan

```
(Hello, World!) = %Hello, World!%; return Hello, World!;

```

Probably very easy to rob :-)

# Answer
> 2 votes
# Foo, 34 bytes, cracked by Dennis

```
main = do
  print "Hello, World!"

```

I hope this doesn't work in too many languages.

Remark (see meta ): some of the characters in the code are not valid `Foo` commands. The `Foo` spec does not define what to do with non-commands and the reference compiler chooses to simply ignore them and therefore produces vaild output.

# Answer
> 2 votes
# Argh!, 33 bytes, cracked by Thomas Kwa

```
#!Hello, World!#
llPPPPPPPPPPPPPq

```

# Answer
> 2 votes
## A:;, 19 bytes, cracked by Sp3000

```
o:Hello, World!;p:o

```

# Answer
> 2 votes
# Snowman 1.0.1, 223 bytes, cracked by Doorknob

```
[[~get~ =STDIO=]]
[[~get~ =STDLIB=]]
[[start variable h]]
    ("Hello, World!"
[[end variable h]]
[[STDIO.OUT.print h]]
[[
@if(!h.is_printed)
{
    send errormsg: 'error: failed to print variable h'
}
endif@
@else {
    CONTINUE();
}
endelse@
]]
sp

```

I've edited this various times, but none of those edits will invalidate an attempt at cracking it.

## Explanation

In Doorknob's Snowman, `[[...]]` is a comment. So let's get rid of all that junk. `("Hello, World!"sp`. The bracket is a variable operator, and makes variable `a` and `f` active. This must be done, because "..." sets the string to the first undefined variable, and if there are no active variables, Snowman throws a `SnowmanException`. The final part, `sP` or `sp` is String Print, and prints the "Hello, World!" string.

# Answer
> 2 votes
# BASIC, 25 bytes, cracked by Kslkgh

```
PRINT "Hello, World!"
END

```

This shouldn't take long, but this guy has special meaning to me.

# Answer
> 2 votes
# Unlambda, 57 bytes, cracked by jimmy23013

<pre><code>```````
#hello#
```````
.H.e.l.l.o.,. .W.o.r.l.d.!
return
</code></pre>

# Answer
> 2 votes
# rs, 26 bytes, cracked by Dennis

```
print
pr.nt/ World!
Hello,

```

This lasted 56 seconds. Yay. :/

# Answer
> 2 votes
# Malbolge, 112 bytes, cracked by Martin Büttner

```
('&%:9]!~}|z2Vxwv-,POqponl$Hjihf|B@@>,=<M:9w6$GVV2TSn.Oe*c;(I&%$#"mCBA?zxxvuPb8`qo42mZF.hIy*@dD'<;_?!\}}|z2VxSSQ

```

# Answer
> 2 votes
# Befunge-98, 59 bytes, cracked by Mauris

```
//"std_library::IO"200#evoke;
@_ #!,#:<"Hello, World!"<<;fi

```

# Answer
> 2 votes
# Ruby, 30 bytes, cracked by jimmy23013

```
system("echo 'Hello, World!'")

```

Now just TRY to guess this one!

# Answer
> 2 votes
# Arduino, 101 bytes, cracked by Shebang

```
int i=0;
void setup(){Serial.begin(9600);}
void loop(){if(i==0){Serial.println("Hello, World!");i+=1;}}

```

If only Python had brackets... Would be so much easier for golfing... *sigh*

## Hundredth answer!!

# Answer
> 2 votes
# Underload, 34 Bytes, cracked by Mauris

```
(l):*(He)~*(o):(, W)~***(rld!)*:!S

```

# Answer
> 2 votes
# JavaScript, 176 bytes, cracked by Dennis

```
_0x7ba8=["\x48\x65\x6C\x6C\x6F\x2C\x20\x57\x6F\x72\x6C\x64\x21","\x6C\x6F\x67"];_6d3521=_0x7ba8[0];_5s8452=_0x7ba8[1];_0x3242=[_6d3521,_5s8452];console[_0x3242[1]](_0x3242[0]);

```

# Answer
> 2 votes
# Whitespace, 426 bytes, cracked by Dennis

```
#import  <studio.h>

#import <Foundation/Foundation.h>
#import <objc/Object.h>
@interface HelloWorld:  Object
    -(void)hello;
@end

@implementation HelloWorld
    -(void)hello:
         println("Hello,\u20World!")
@end

//int
//main()

int main() {
    HelloWorld
            *hi=    [Hello new]
    [hi
        say]

        [hi
    free]

    return(0)
}

//end

```

This is probably very easy

If the characters don't show up correctly. A pastebin is here.

---

This was designed to look like an old Objective-C at a first glance with some weird syntax errors.

# Answer
> 2 votes
# WTFZOMFG, 19 bytes, cracked by jimmy23013

```
'"'Hello, World!"'"

```

# Answer
> 2 votes
# Tcl, 102 bytes, cracked by jimmy23013

```
proc = main[] {
    puts "Hello, World!" ;; return
}

= BEGIN

return ;; main["Hello, World!"]

= END

```

# Answer
> 2 votes
# Enema, 158 Bytes, cracked by Sp3000

```
{'&%:9]!~)|z2Vswv-,POqponl$Hj.ihf|B}:s*Q:56+3s:c33s1+Q:91+DsD2:pOQ:4s9:#[?ZBp]Q:8sO:\+DQ:\6\:UD3-Q:3-Dc-OUDOpDp9c*USXUc%cs2*49s-O" "#.;(I&%$#"?zvuPb8`qo42mZ.FhIy*@dD'<;_?!\}}

```

I actually took the Malbolge program from one of the solutions and modified it somewhat. {} denotes a comment and is ignored. . ends the program. Removing extraneous code gives us

```
:s*Q:56+3s:c33s1+Q:91+DsD2:pOQ:4s9:#[?ZBp]Q:8sO:\+DQ:\6\:UD3-Q:3-Dc-OUDOpDp9c*USXUc%cs2*49s-O" "#.

```

The important thing to note is that :a...Q: will redefine a to ... Unfortunately I couldn't figure out a way to redefine something else to use for Q (or :), so the giveaway here was a bunch of :...Q: commands

# Answer
> 2 votes
# Grocery List, 63 bytes, cracked by ETHproductions

```
#import <latter_stack.h>

V
H
p
v
e
p
v
l
c
c
p
p
v
o
c
p
n
p
n
p
V
W
p
p
v
r
p
p
w
p
N
p

```

# Answer
> 2 votes
# Mmmm(), 5646 bytes, cracked by Sp3000

```
MyVar mm=main[main.main()].main(main.main());
MyVar anAsymmetricalBrim=main[mm].main();
anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();
anAsymmetricalBrim.main();MyVar anAsymmetricalBrimmingDog=anAsymmetricalBrim.main();
anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();
anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();
anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();
anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();
anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();
anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();
anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();
anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();
anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();
anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();
anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();
anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();
anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();
anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();
anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();
anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();
anAsymmetricalBrim.main();main[anAsymmetricalBrimmingDog].main(anAsymmetricalBrim.main());
anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();
anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();
anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();
anAsymmetricalBrim.main();anAsymmetricalBrim.main();MyVar anAsymmetricalBrimmingDomesticApe=anAsymmetricalBrim.main();
anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();
anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();
anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();
MyVar anAsymmetricalBrimmingCommercialisticCommittee=anAsymmetricalBrim.main();
main[anAsymmetricalBrimmingDog].main(anAsymmetricalBrim.main());
anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();
anAsymmetricalBrim.main();anAsymmetricalBrim.main();MyVar anAsymmetricalBrimmingCommercialist=anAsymmetricalBrim.main();
main[anAsymmetricalBrimmingDog].main(anAsymmetricalBrimmingCommercialist);main[anAsymmetricalBrimmingDog].main(anAsymmetricalBrimmingCommercialist);
anAsymmetricalBrim.main();anAsymmetricalBrim.main();
MyVar anAsymmetricalBrimmingCommercialisticDomesticApe=anAsymmetricalBrim.main();
main[anAsymmetricalBrimmingDog].main(anAsymmetricalBrimmingCommercialisticDomesticApe);
anAsymmetricalBrim.main();anAsymmetricalBrim.main();
MyVar myAsymmetricalBrimmingCommercialisticCommittee=anAsymmetricalBrim.main();
MyVar anAsymmetricalBrim=main[mm].main();
anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();
anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();
anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();
anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();
anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();
anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();
anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();
anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();
MyVar asymmetricalBrimmingCommercialisticCommissionerCommittees=anAsymmetricalBrim.main();
MyVar asymmetricalBrimmingCommercialisticCommissionerCommitteeman=anAsymmetricalBrim.main();
anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();
anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();
anAsymmetricalBrim.main();anAsymmetricalBrim.main();
main[anAsymmetricalBrimmingDog].main(anAsymmetricalBrim.main());
main[anAsymmetricalBrimmingDog].main(asymmetricalBrimmingCommercialisticCommissionerCommittees);
main[anAsymmetricalBrimmingDog].main(anAsymmetricalBrimmingDomesticApe);
main[anAsymmetricalBrimmingDog].main(anAsymmetricalBrimmingCommercialisticDomesticApe);
main[anAsymmetricalBrimmingDog].main(myAsymmetricalBrimmingCommercialisticCommittee);
main[anAsymmetricalBrimmingDog].main(anAsymmetricalBrimmingCommercialist);
main[anAsymmetricalBrimmingDog].main(anAsymmetricalBrimmingCommercialisticCommittee);
main[anAsymmetricalBrimmingDog].main(asymmetricalBrimmingCommercialisticCommissionerCommitteeman);

```

This one took a while to obfuscate.

# Explanation:

This is the "Hello, World!" program from the esolangs article padded with an insane number of dummy characters- the dummy characters represent about 70% of the length.

# Answer
> 2 votes
# You are Reading the Name of this Esolang, 301 bytes, cracked by jimmy23013

```
11111111110010001010101110101111111010111111111101101101101100000110100100101100101001010010101111111001010001010111001010011011111111111111110010100000000000000000000000000000000000000010100101111111111111110010100100010[0]01110010100000000000000000000010100000000000000000000000000010100110111001010

```

There are too many people on this site who know exotic programming languages. Maybe there should be a Stack exchange for weird programming languages.

# Answer
> 2 votes
# Self-modifying Brainfuck, 92 bytes

Windows line endings are required (`\r\n`).

```
<o[-]<[-]<[-]<[-]
<<<<<<<--
<<<<<<[.>]
<<<<<<<<--
<<<<<<<<<<-
<+[]
o"Hello,"World!,rPP

```

### Explanation:

In this language, the code itself if placed on the tape, such that the last character is one to the left of the initial pointer. Non-BF characters are still in their places on the tape. They are skipped for execution, but can be modified by increment/decrement operations to change them into commands. They can also be output. So the program `<[.<]\x00!dlroW olleH` (`\x00` represents a null byte) would also be valid, if the comma wasn't necessary.

In this program, the `rPP,` and the `o`'s are misdirection, as well as the seemingly infinite loop: `[]`. The program starts by zeroing the last four characters, moving left to the middle quote, and changing it to a space. Then, I move left to the start of the string to print and print it. Finally, I move left to the comma and change it so it won't be executed, continue left, and pacify the infinite loop.

**Edit**: I just noticed that after a user told me which line endings were Windows (comment no longer exists), I had forgotten to adjust the code by one byte (an extra `<`) to compensate last week. If anyone tried SMBF and didn't get it to work because of that, let me know.

# Answer
> 2 votes
# Microscript, 20 bytes

```
'H"ello, World!"fPa'

```

`'H` writes the character **H** into the first register.

`"ello, World!"` pushes the remaining characters of the desired output on the stack.

`f` reverses the entire stack, `P` prints the character in the first register and `a` the characters on the stack.

Finally, `'` crashes the interpreter, which would print **72** (the character code of **H**) if not halted by `h`.

# Answer
> 2 votes
# az, 18 bytes, cracked by nimi

```
"Hello, World".33.

```

# Answer
> 2 votes
# PowerShell, 20 Bytes, Cracked by Dennis

(Another) Last-minute entry!

```
'Hello, '+"World!`n"

```

Now GolfScript-immune!

Yes, yet another PowerShell program. :)

# Answer
> 2 votes
# Turing Machine But Way Worse, 959 bytes cracked by Gabriel Mills

```
0  0 0 1  1 0 0
0  1 1 1  2 0 0
0  2 0 1  3 0 0
0  3 0 1  4 0 0
0  4 1 1  5 1 0
0  5 1 0  6 0 0
1  6 0 1  7 0 0
1  7 1 1  8 0 0
0  8 0 1  9 0 0
0  9 1 1 10 0 0
0 10 0 1 11 0 0
1 11 1 1 12 0 0
0 12 1 1 13 1 0
0 13 0 1 14 0 0
0 14 1 1 15 0 0
1 15 1 1 16 0 0
0 16 0 1 17 0 0
1 17 0 1 18 1 0
0 18 0 0 19 1 0
0 19 1 0 20 0 0
0 20 1 1 21 1 0
1 21 0 0 22 0 0
1 22 0 1 23 0 0
0 23 0 1 24 0 0
0 24 0 1 25 0 0
1 25 0 1 26 1 0
1 26 1 1 27 0 0
0 27 0 1 28 0 0
1 28 0 1 29 0 0
1 29 0 1 30 1 0
0 30 1 1 31 0 0
0 31 1 1 32 0 0
0 32 0 1 33 0 0
0 33 1 1 34 0 0
1 34 0 1 35 0 0
0 35 1 1 36 0 0
0 36 0 1 37 0 0
0 37 1 0 38 1 0
0 38 0 0 39 0 0
1 39 0 0 40 0 0
0 40 1 1 41 0 0
0 41 0 1 42 0 0
0 42 1 0 43 1 0
0 43 1 1 44 0 0
1 44 0 1 45 0 0
1 45 0 1 46 0 0
1 46 1 1 47 0 0
1 47 0 0 48 1 0
1 48 0 0 49 0 0
0 49 1 0 50 0 0
0 50 1 0 51 0 0
1 51 0 1 52 1 0
1 52 0 0 53 1 0
0 53 0 0 54 0 0
1 54 1 0 55 0 0
1 55 0 0 56 0 0
0 56 0 0 57 0 0
0 57 1 0 58 0 0
0 58 0 0 59 0 0
1 59 0 0 60 1 1

```

# Answer
> 2 votes
# Whenever, 63 bytes, cracked by Unrelated String

```
103857392 defer (2) 23423423;
978651423 print("Hello, World!");

```

Okay, I checked and this doesn't work in Proton or Foo. Hopefully, this will be harder to crack.

# Answer
> 2 votes
# ???, 50 bytes

```
import sys
A = (Hello, World!)
sys.STDOUT.write(A)

```

Good Luck :)

# Answer
> 2 votes
# ???, 144 bytes, Cracked by Sisyphus

```
Scene I
[Enter Romeo and Juliet]
the Manor is a room.
For printing the name of Manor: do nothing.
When play begins, say "Hello, World!"
[Exeunt]

```

I'm well aware this is an old thread - but I'm curious to see how people go with guessing this one.

Sisyphus has cracked this with Foo, this is not the language I wrote it in though.
If you wish to spoil the surprise, reveal the spoiler:

> **Language:** Inform 7
> Inform 7 is a language for making interactive fiction games.
> You can use Scenes to divide up time (but is meaningless in this example), Conveniently though, comments are marked with square brackets so that was useful for adding the shakespearelang red herring.
> A room for the player to exist in is needed to compile, but then we need to prevent it printing the name of the room. Finally, trigger the 'Hello, World!'

# Answer
> 1 votes
# Ruby, 77 bytes, cracked by ProgramFOX

```
main = proc() {
    proc = 'Hello, World!'
}

main
    .call()
    .display()

```

(Poor attempt, probably should count only half crack point.)

# Answer
> 1 votes
# Groovy, 70 bytes, cracked by aditsu

```
class M{public static void main(String[]a){println("Hello, World!");}}

```

# Answer
> 1 votes
# ABAP, 42 bytes, cracked by Sp3000

```
REPORT ZHELLOWORLD.
WRITE 'Hello, world!'.

```

# Answer
> 1 votes
# unc, 137 bytes, cracked by Dennis

```
!include >=fgQVb%U<=
ZNVa[]<<char s():=<<27~656~653~653~666~99~87~32~666~669~653~655~88~5>>:chgf[s]:if 5:chgf[L'Hello, world!ABCDEFG']:>>

```

# Answer
> 1 votes
# Gema, 99 bytes, cracked by mbomb007

```
Hello = "Hello"
World = "World"

main = proc()
\B=Hello, World\!\N\
@end

= main().call().display()

```

# Answer
> 1 votes
# Python, 431 bytes, cracked by Dennis

```
#print          ;
"World!"#=printf;
#println"Hello,",
#/=         World
Hello          =\
World          =\
"Hello,"#=printf\
#"World,"      =;
#print          \
print      Hello,
#           print
#println"World!",
#/         =Hello
World          =\
Hello=          \
"World!";#printf\
#"Hello,"      =;
print     World,;
#/         =Hello
#/=         World
#println"World!",
print           \
#pprint "Hello,",
"Hello,";#printf\

```

# Answer
> 1 votes
# Go, 425 bytes, cracked by ProgramFOX

```
package main
import "os"
import "fmt"

/* Hello World routine /*
$mystring = <<< PROG //HereDoc
def printhello:
  print "Hello, World!"
  #include "iostream"
  int main (int argc, **string argv) // int main() is always needed
    cout << "Hello, World!";
    /int*/ func main() {
    fmt.Fprintf(os.Stdout, "Hello, World!")}/*;
    printf("Hello, World!");
**///PROG;

```

Explanation: everything is commented out except:

```
package main
import "os"
import "fmt"

func main() {
  fmt.Fprintf(os.Stdout, "Hello, World!")}

```

# Answer
> 1 votes
# Foo, 57 bytes, cracked by Dennis

```
program
   %put x=print x
   put "Hello, World!"
end program

```

It was supposed to be Zeno :P

# Answer
> 1 votes
# ferNANDo, 265 bytes, cracked by jimmy23013

```
( main )
main = (
print("Hello,")
) + do
<> ( < [ ) v $ ^^
^^ ( ( v $ ( <> (
<> ) ( <> ) ( # ]
# ) ( [ ) ( ] #
^^ ) ( < ) ( ) )
" ^ ( v ) ) ^^ <
<> ^ ) $ " " [ <>
< ( ) ( # ) ( (
] ) ( ] ) ) ( (
] ) ) ( ] <> ( ^^
" ) ( <> ) ( ^ $
# ) ( # <> ( $ <
< " ) < ^ v ^ )
)

```

# Answer
> 1 votes
# Forth, 32 bytes, cracked by BrunoLeFloch

```
: : : S" Hello, World!" type ; :

```

# Answer
> 1 votes
# small s.c.r.i.p.t., 18 bytes, cracked by Sp3000

```
H
ello44. World33.

```

# Answer
> 1 votes
# XPL0, 40 bytes, cracked by Mauris

```
code Text=12;
Text(0, "Hello, World!^A")

```

Edit: Made immune to Foo

# Answer
> 1 votes
# Spoon, 54.75 Bytes, cracked by Thomas Kwa

(438 bits)

```
010111111111001000111111111101000000110110010100101111111001000111111010000001101110010101111111001010001010111001010010111111111110010001100000000000000000001000000110110000010100000000000000000000000000000000000000010100101111111111100100011111110100000011011001010010111111001000111111010000001101100101011100101000000000000000000000101000000000000000000000000000101001011111111111001000110000000000000000000100000011011000001010

```

# Answer
> 1 votes
# Chinese Basic, 27 bytes, cracked by Respect My Authoritah

Yay for foreign programming languages.

Here is the hex dump, since one of the characters is blocked by SE for unknown reason:

```
0000000: e58d 9c3d 2248 656c 6c6f 2c20 576f 726c  ...="Hello, Worl
0000010: 6421 220a e58d b020 e58d 9c              d!".... ...

```

# Answer
> 1 votes
# JavaScript, 350 bytes, cracked by Dennis

```
_0x4644=["\x47\x6F\x74\x63\x68\x61\x21","\x6F\x62\x6A\x65\x63\x74","\x6A\x71\x75\x65\x72\x79","\x66\x6E","\x32\x2E\x30\x2E\x32","\x48\x65\x6C\x6C\x6F\x2C\x20\x57\x6F\x72\x6C\x64\x21","\x6C\x6F\x67"];if( typeof $[_0x4644[3]]==_0x4644[1]){a=_0x4644[0];if($[_0x4644[3]][_0x4644[2]]==_0x4644[4]){a=_0x4644[5]}};console[_0x4644[6]](a);

```

# Answer
> 1 votes
# Lua, 544 bytes, Cracked by Martin Büttner

```
load(("112.114.105.110.116.40.32.116.97.98.108.101.46.117.110.112.97.99.107.123.32.102.117.110.99.116.105.111.110.40.115.116.114.105.110.103.41.32.114.101.116.117.114.110.123.32.115.116.114.105.110.103.58.103.115.117.98.40.32.39.40.37.100.43.41.91.94.37.100.93.63.39.44.32.115.116.114.105.110.103.46.99.104.97.114.32.41.32.125.32.101.110.100.32.125.39.55.50.46.49.48.49.46.49.48.56.46.49.48.56.46.49.49.49.46.52.52.46.51.50.46.56.55.46.49.49.49.46.49.49.52.46.49.48.56.46.49.48.48.46.51.51.39.91.49.93.32.41"):gsub('(%d+)[^%d]?',string.char))()

```

## Explanation:

`load` was introduced in 5.3 as a replacement to `loadstring`. All the numbers are the bytes of the individual code, which, when you do `print` instead of `load`, outputs:

```
print( table.unpack{ function(string) return{ string:gsub( '(%d+)[^%d]?', string.char ) } end }'72.101.108.108.111.44.32.87.111.114.108.100.33'[1] )

```

Breaking this down, we see that:

* First it executes the anonymous function by executing `table.unpack`, then taking the value returned by `table.unpack` (i.e. the anonymous funciton) and passing the long string of numbers.
* `string:gsub` takes the string, and takes every occurrence of `(%d+)[^%d]?` (meaning, capture a digit 1 to inf times followed be anything that's not a digit (i.e. the period separating them)) and return the character value of that.
* Return the combination of all of those inside of a table. Access that table (via the `[1]` at the end, since Lua tables are 1-indexed) and print that value.

# Answer
> 1 votes
# \>\<\>, 165 bytes, cracked by plannapus

```
x<=== BEGIN CODE SNIPPET #54807 =======>x
!println(HelloWorld);end();/>l!/\! <.2*\
/"Hello, World!"/_b:2[=~]!^/\ w;\?!/o3a^
_<===== END CODE SNIPPET #54807 =======>_

```

This one took a **really** long time to make. Good luck.

# Answer
> 1 votes
# Whitespace, 306 bytes, cracked by Dennis

Pastebin here

```
+++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>

.

```

This language is far too obvious, isn't it?

# Answer
> 1 votes
# OOC, 40 bytes, cracked by Dennis

```
main: func {
  "Hello, World!" print()
}

```

Easy? Perhaps.

# Answer
> 1 votes
# Pyth, 44 bytes, cracked by jimmy23013

```
"Hello, World!"+stupid"ketchup"foo su(x.)+"?

```

# Answer
> 1 votes
# Foo, 157 bytes, cracked by Dennis

Stupid Foo.

```
#ifndef __linux
#include <x.h>
#define X/*\
++++++++++_++++++++++++++++++++++++....Hello World!?:Q:
#endif
    echo "Hello, World!"
    int main(){return 0;}

```

# Answer
> 1 votes
# Bash, 157 bytes, cracked by Dennis

So far, I've been cracked by Bash and Foo, *neither* of which were intended. Ugh...

```
#ifndef __linux
#include "x.h"
#define X/*\
++++++++++_++++++++++++++++++++++++....Hello World!?:Q:
#endif
    echo "Hello, World!"
    int main(){return 0;}

```

# Answer
> 1 votes
# Foo, 38 bytes, cracked by kirbyfan64sos

```
print "Hello, World!", EoL FIN

```

I hate Foo.

# Answer
> 1 votes
# GolfScript, 87 bytes, cracked by Dennis

```
Outputs::Screen '$hello, $world\x21'
5735816763073854918203775149089!?; "Hello, World!"

```

Not the intended language... I'll try again.

# Answer
> 1 votes
# J--, 33 Bytes, Cracked by histocrat

```
main{//&1
echo("Hello, World!");}

```

# Answer
> 1 votes
# Golunar, 123 bytes, cracked by jimmy23013

```
849929103018908538648390429242340026551748645051119016413509773663323023383923836750829562877191329081951928547062965994756

```

Not 100% sure if this qualifies, but could be fun nonetheless :P

Starting with a Brainfuck program,

```
++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++++++++++++++.------------.<<+++++++++++++++.>.+++.------.--------.>+.>.

```

prepend a 1, and convert the commands into binary as follows:

```
>   000
<   001
+   010
-   011
.   100
,   101
[   110
]   111

```

Yielding:

```
1010010010010010010010010010010110000010010010010010010010000010010010010010010010010010010000010010010000010001001001001011111000010010100000010100010010010010010010010100100010010010100000010010010010010010010010010010010010010010100011011011011011011011011011011011011100001001010010010010010010010010010010010010010010010100000100010010010100011011011011011011100011011011011011011011011100000010100000100

```

Convert to decimal:

```
849929103018908538648390429242340026551748645051119016413509773663323023383923836750829562877191329081951928547062965994756

```

# Answer
> 1 votes
# IPython, 20 bytes, cracked by Dennis

```
!echo Hello, World!;

```

It wasn't supposed to be IPython... :(

# Answer
> 1 votes
# J--, 56 bytes, cracked by Dennis

```
main{if(a!=new String[]{"foo"}){echo("Hello, World!");}}

```

# Answer
> 1 votes
# Zucchini, 163 bytes, cracked by Sp3000

```
=0,01.2./.0,1./.3.17. ` /.04.17.`../.5.17.`: /.6.17.`: /.07.17.`::/.8.17`: /.9.17`  /.10.17...:/.11.17.`::/.12.17.: `/.13.17.`: /.14.17.`. /.15.17` ./.16.17``/.19.

```

# Answer
> 1 votes
# IPython, 25 bytes, cracked by Dennis

```
!echo Hello, World!&&exit

```

You guys sure do make it difficult to create a program that only works in one language and is also hard to crack.

# Answer
> 1 votes
# GolfScript, 15 Bytes, cracked by Dennis

A last-minute entry!

```
'Hello, World!'

```

Works in GolfScript as shown in the online interpreter.

# Answer
> 1 votes
# Smith#, 169 bytes

I hadn't quite finished this one, but since answers posted now are not competing, I thought I'd just post it anyway. It doesn't print the `!` at the end. I would've kept working on it, but I wasn't able to figure out how to get the interpreter to work with code from a file in a short amount of time.

I'm fairly certain the adding the `!` into the string would print it, but I'm not 100% sure.

```
""Hello, World"h:"0b:"<>c:1?(:=)e:"?(.)f:1?(w-o)r:"1j:
"?(o)l:1?(k+2-w+o)m:"?(d)g::=<>,h,b@=,h,b:=e,^m,h d:
<<1+c,r:=r,o,b:=r,d,b+f,j+f,m+f,l:=j,^l,b k::=?(o),=,f
w:+h,b

```

This program is almost "word-for-word" from the language's website, but I did change some label names and changed a couple of `"`s to `1`s.

# Answer
> 1 votes
# BrainF, 30000 bytes cracked by Gabriel Mills

The source can be found at https://raw.githubusercontent.com/MilkyWay90/MilkyWay90.github.io/master/outputprog.txt

It is easy to crack if you have the time.

# Answer
> 1 votes
# Proton, 33 bytes, cracked by Khuldraeseth na'Barya

```
978651423 print("Hello, World!");

```

~~I'm not sure how easy this will be to crack.~~ Cracked in 3 hours.

# Answer
> 1 votes
## Proton, 49 bytes, craked by Unrelated String

```
def b="l";def u="e";print("H"+u+b+b+"o, World!");

```

# Answer
> 1 votes
# brainfuck, 503 bytes, cracked by noodle man

```
eval+71 100 107 107 110 43 31 86 110 113 107 99 32[this: map-->a=returns String: fromCharCodes-asHigherOrderFunction[bitmask>>&1142+this>Integer-Rational-Fractional-Complex--endbitmask<<fromCharCodes]<11129-1000-0<&71-32-72-31]: assert 3>2-1. assert 5>4>3>2+0. assert 3>2>1. assert .1+2+3+__sample_strings: 173[fromPosition 1.2>1] <9<8<7<6.toString: filterByAlternate: 1+2+3+87. assert 6-5-4-3-2-1-0. assert not 0<1<2-2. assert not 71>100>107>107>110+73 102 109 109 112 45 33 88 112 115 109 101 34: end.

```

# Answer
> 1 votes
# ???, 105 bytes

```
say “Hello, World!”
print “Hello, World!”
puts “Hello, World!”
output “Hello, World!”
out “Hello, World!”

```

So many ways to output `Hello, World!`...

# Answer
> 0 votes
# Nemerle, 111 bytes, cracked by Sp3000

```
class Hello
{
    static Main() : void
    {
        System.Console.WriteLine("Hello, World!");
    }
}

```

Maybe...

# Answer
> 0 votes
# Perl, 24 bytes, cracked by ProgramFOX

```
printf("Hello, World!");

```

# Answer
> 0 votes
# F#, 75 bytes, cracked by vihan

```
#line 1
"Hello, " = "Goodbye "
printf("Hello, ")
#line 4
printf("world!\n")

```

# Answer
> 0 votes
# Node.js, 38 bytes, cracked by ProgramFOX

I am going to try again.

```
process.stdout.write("Hello, World!");

```

# Answer
> 0 votes
# Gema, 20 bytes, cracked by Mauris

```
*=
\B=Hello, World\!

```

# Answer
> 0 votes
# Javascript, 23447 bytes, cracked by Dennis

```
[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]((![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]+(!![]+[])[+[]]+(![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]]+([]+[])[(![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(!![]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]()[+!+[]+[!+[]+!+[]]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]((!![]+[])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+!+[]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+!+[]]]+([][[]]+[])[+[]]+([][[]]+[])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(+(!+[]+!+[]+[+!+[]]+[+!+[]]))[(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(+![]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(+![]+[![]]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]]](!+[]+!+[]+!+[]+[+!+[]])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]])()([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]((!![]+[])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+!+[]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+!+[]]]+(!![]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(+(!+[]+!+[]+[+!+[]]+[+!+[]]))[(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(+![]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(+![]+[![]]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]]](!+[]+!+[]+!+[]+[+!+[]])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]])()(([]+[])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+[]])[+[]]+(!+[]+!+[]+!+[]+!+[]+[!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]])+[])+(!![]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+[[]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]]([[]])+[]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+!+[]]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]((!![]+[])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+!+[]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+!+[]]]+([][[]]+[])[+[]]+([][[]]+[])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(+(!+[]+!+[]+[+!+[]]+[+!+[]]))[(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(+![]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(+![]+[![]]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]]](!+[]+!+[]+!+[]+[+!+[]])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]])()([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]((!![]+[])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+!+[]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+!+[]]]+(!![]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(+(!+[]+!+[]+[+!+[]]+[+!+[]]))[(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(+![]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(+![]+[![]]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]]](!+[]+!+[]+!+[]+[+!+[]])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]])()(([]+[])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+[]])[+[]]+(!+[]+!+[]+!+[]+!+[]+!+[]+[!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]])+[])+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+([][[]]+[])[!+[]+!+[]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]((!![]+[])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+!+[]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+!+[]]]+([][[]]+[])[+[]]+([][[]]+[])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(+(!+[]+!+[]+[+!+[]]+[+!+[]]))[(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(+![]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(+![]+[![]]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]]](!+[]+!+[]+!+[]+[+!+[]])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]])()([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]((!![]+[])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+!+[]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+!+[]]]+(!![]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(+(!+[]+!+[]+[+!+[]]+[+!+[]]))[(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(+![]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(+![]+[![]]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]]](!+[]+!+[]+!+[]+[+!+[]])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]])()(([]+[])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+[]])[+[]]+(!+[]+!+[]+[+!+[]])+[])+([]+[])[(![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(!![]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]()[+!+[]+[!+[]+!+[]]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]])()

```

# Answer
> 0 votes
# Shoelips, 33 bytes, solved by Sp3000

(in just 15 minutes after posting :C)

```
( World! ) ( Hello ) concat print

```

# Answer
> 0 votes
# Fish, 156 bytes, cracked by jimmy23013

CURSE YOU SHELLS!!

Now guarded against Foo *and* Bash...

```
#ifndef __linux
#include "x.h"
#define X/*\
a=1 set -e
+++++++++++++++++++++_+++++++++++++....Hello World!?:Q:
#endif
    echo "Hello, World!"
    int m(){}

```

# Answer
> 0 votes
# Common Lisp, 41 bytes, cracked by georgeunix

```
(DEFUN HELLO ()
"Hello, World!"
)
(HELLO)

```

Sounds too easy for you guys ;)

# Answer
> 0 votes
# Foo, 28 bytes, cracked by kirbyfan64sos

```
(printout t "Hello, World!")

```

# Answer
> 0 votes
# \>\<\>, 79 bytes, cracked by randomra

```
!x"H"o!x"e"o!x"l"o!x"l"o!x"o"o!x","o!x" "o!x"W"o!x"o"o!x"r"o!x"l"o!x"d"o!x"!"o;

```

# Answer
> 0 votes
# ksh, 21 bytes, cracked by nimi

```
!;echo Hello, World!;

```

This shouldn't work in IPython, right?

# Answer
> 0 votes
# ksh, 20 bytes, cracked by nimi

```
!;echo Hello, World!

```

Another variation.

# Answer
> 0 votes
# ???, 19 bytes

```
"output":"Hello, World!"

```

# Answer
> -1 votes
# ???, 22 bytes

```
write('Hello, World!')

```

---
Tags: code-golf, hello-world, obfuscation, cops-and-robbers
---