title: Obfuscated Hello World

text:
# Question
Title: Obfuscated Hello World
Create the shortest possible obfuscated program that displays the text "Hello World".

In order to be considered an obfuscated program, it must meet **at least two** of the following requirements:

* Does not contain the characters: `h`, `l`, `w` and `d` in any case
* Does not contain the characters: `e`, `o`, `r`, `0`, and `1` in any case
* Does not contain the characters: `2` or `7`

**Input:**
*none*

**Output:**
`Hello World`

## Leaderboard

Here is a Stack Snippet to generate both a regular leaderboard and an overview of winners by language.

```
/* Configuration */

var QUESTION_ID = 307; // Obtain this from the url
// It will be like https://XYZ.stackexchange.com/questions/QUESTION_ID/... on any question page
var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";
var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk";
var OVERRIDE_USER = 48934; // This should be the user ID of the challenge author.

/* App */

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

function answersUrl(index) {
  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 SCORE_REG = /<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/;

var OVERRIDE_REG = /^Override\s*header:\s*/i;

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

function process() {
  var valid = [];

  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 = body.match(SCORE_REG);
    if (match)
      valid.push({
        user: getAuthorName(a),
        size: +match[2],
        language: match[1],
        link: a.share_link,
      });

  });

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

  var languages = {};
  var place = 1;
  var lastSize = null;
  var lastPlace = 1;
  valid.forEach(function (a) {
    if (a.size != lastSize)
      lastPlace = place;
    lastSize = a.size;
    ++place;

    var answer = jQuery("#answer-template").html();
    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("#answers").append(answer);

    var lang = a.language;
    if (/<a/.test(lang)) lang = jQuery(lang).text();

    languages[lang] = languages[lang] || {lang: a.language, user: a.user, size: a.size, link: a.link};
  });

  var langs = [];
  for (var lang in languages)
    if (languages.hasOwnProperty(lang))
      langs.push(languages[lang]);

  langs.sort(function (a, b) {
    if (a.lang > b.lang) return 1;
    if (a.lang < b.lang) return -1;
    return 0;
  });

  for (var i = 0; i < langs.length; ++i)
  {
    var language = jQuery("#language-template").html();
    var lang = langs[i];
    language = language.replace("{{LANGUAGE}}", lang.lang)
                       .replace("{{NAME}}", lang.user)
                       .replace("{{SIZE}}", lang.size)
                       .replace("{{LINK}}", lang.link);
    language = jQuery(language);
    jQuery("#languages").append(language);
  }

}
```

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

#answer-list {
  padding: 10px;
  width: 290px;
  float: left;
}

#language-list {
  padding: 10px;
  width: 290px;
  float: left;
}

table thead {
  font-weight: bold;
}

table td {
  padding: 5px;
}
```

```
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b">
<div id="answer-list">
  <h2>Leaderboard</h2>
  <table class="answer-list">
    <thead>
      <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr>
    </thead>
    <tbody id="answers">

    </tbody>
  </table>
</div>
<div id="language-list">
  <h2>Winners by Language</h2>
  <table class="language-list">
    <thead>
      <tr><td>Language</td><td>User</td><td>Score</td></tr>
    </thead>
    <tbody id="languages">

    </tbody>
  </table>
</div>
<table style="display: none">
  <tbody id="answer-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="language-template">
    <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr>
  </tbody>
</table>
```

# Answer
## GolfScript, 17 chars

```
'·š““ß¨“›'{~}%

```

When testing this submission, please save the file as straight binary, not UTF-8. Having trouble recreating the file? Here's the hexdump of it:

```
00000000  27 b7 9a 93 93 90 df a8  90 8d 93 9b 27 7b 7e 7d  |'...........'{~}|
00000010  25                                                |%|

```
> 54 votes

# Answer
# Perl

Since the obvious answer uses shifting of some kind, I feel obligated to post something using Acme::EyeDrops, however with the extra power I thought mine ought to be a little more fun.

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

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

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

```

**Caveat**

Since Perl version 5.18, the mechanism that allows this code to run has become so powerful that it has been disabled by default to prevent misuse. Therefore on versions 5.18+ you can either add `use re 'eval';` to the top of the script or, if the script is named `world.pl` you can run it like `perl -Mre=eval world.pl`. It is unfortunate that these unsightly characters must be added, but c'est la vie. (Note: I want to emphasize that enabling this feature is not using some library or addon, the code displayed is valid Perl code, the mechanism is simply no longer enabled by default).
> 182 votes

# Answer
# C# (175 chars)

It was quite a challenge to do this in C# because the restrictions preclude any use of quite a lot of the common keywords. It is possible in C# to use \uxxxx Unicode escape sequences in identifiers, but unfortunately not in keywords.

I suspect that this solution *only* works when compiled against .NET 4.0. See explanation for why.

```
using System;struct a{static int Main(){object[]c={"\u0048e\x6c\x6co "+(C\u0068ar)(86+1)+"or\x6c\x64"};typeof(Conso\u006ce).GetMet\u0068o\u0064s()[101].Invoke(c,c);return 0;}}

```

## Explanation

```
// I won’t be able to get anywhere without using “System”.
// Even if I write it as “Syst\u0065m”, it still violates rule 2.
// Therefore, that is the rule we’ll violate.
using System;

// Thus, we can’t use: H L W D 2 7
// We can’t write “class”, so the Main type must be a struct.
struct a
{
    // We can’t write “void”, so Main needs to return an int.
    static int Main()
    {
        // We can’t write “new”, but we can instantiate an array
        // using the initialisation syntax.
        object[] c = {
            "\u0048e\x6c\x6co " + (C\u0068ar) (86 + 1) + "or\x6c\x64"
        };

        // We can use the character escape sequence to write “Console”, but not
        // “Write” because W is \u0057, which contains a 7. Therefore, we have to
        // use Reflection to get it. This relies on the fact that Console.Write(string)
        // is the 102nd method of the type Console in my copy of the framework.
        // Also, the first argument to Invoke can be anything for a static method
        // (needn’t be null). The second one is the actual argument to Console.Write.
        typeof(Conso\u006ce).GetMet\u0068o\u0064s()[101].Invoke(c, c);

        // Since Main returns int, we have to return something.
        return 0;
    }
}

```
> 69 votes

# Answer
## BrainFuck, 106 strokes

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

```

Meets all the rules and it sure is obfuscated.
> 53 votes

# Answer
## Javascript, 2595

This only breaks rule 2.

```
ﾟωﾟﾉ=/｀ｍ´）ﾉ~┻━┻//*´∇｀*/['_'];o=(ﾟｰﾟ)=_=3;c=(ﾟΘﾟ)=(ﾟｰﾟ)-(ﾟｰﾟ);(ﾟДﾟ)=(ﾟΘﾟ)=(o^_^o)/(o^_^o);(ﾟДﾟ)={ﾟΘﾟ:'_',ﾟωﾟﾉ:((ﾟωﾟﾉ==3)+'_')[ﾟΘﾟ],ﾟｰﾟﾉ:(ﾟωﾟﾉ+'_')[o^_^o-(ﾟΘﾟ)],ﾟДﾟﾉ:((ﾟｰﾟ==3)+'_')[ﾟｰﾟ]};(ﾟДﾟ)[ﾟΘﾟ]=((ﾟωﾟﾉ==3)+'_')[c^_^o];(ﾟДﾟ)['c']=((ﾟДﾟ)+'_')[(ﾟｰﾟ)+(ﾟｰﾟ)-(ﾟΘﾟ)];(ﾟДﾟ)['o']=((ﾟДﾟ)+'_')[ﾟΘﾟ];(ﾟoﾟ)=(ﾟДﾟ)['c']+(ﾟДﾟ)['o']+(ﾟωﾟﾉ+'_')[ﾟΘﾟ]+((ﾟωﾟﾉ==3)+'_')[ﾟｰﾟ]+((ﾟДﾟ)+'_')[(ﾟｰﾟ)+(ﾟｰﾟ)]+((ﾟｰﾟ==3)+'_')[ﾟΘﾟ]+((ﾟｰﾟ==3)+'_')[(ﾟｰﾟ)-(ﾟΘﾟ)]+(ﾟДﾟ)['c']+((ﾟДﾟ)+'_')[(ﾟｰﾟ)+(ﾟｰﾟ)]+(ﾟДﾟ)['o']+((ﾟｰﾟ==3)+'_')[ﾟΘﾟ];(ﾟДﾟ)['_']=(o^_^o)[ﾟoﾟ][ﾟoﾟ];(ﾟεﾟ)=((ﾟｰﾟ==3)+'_')[ﾟΘﾟ]+(ﾟДﾟ).ﾟДﾟﾉ+((ﾟДﾟ)+'_')[(ﾟｰﾟ)+(ﾟｰﾟ)]+((ﾟｰﾟ==3)+'_')[o^_^o-ﾟΘﾟ]+((ﾟｰﾟ==3)+'_')[ﾟΘﾟ]+(ﾟωﾟﾉ+'_')[ﾟΘﾟ];(ﾟｰﾟ)+=(ﾟΘﾟ);(ﾟДﾟ)[ﾟεﾟ]='\\';(ﾟДﾟ).ﾟΘﾟﾉ=(ﾟДﾟ+ﾟｰﾟ)[o^_^o-(ﾟΘﾟ)];(oﾟｰﾟo)=(ﾟωﾟﾉ+'_')[c^_^o];(ﾟДﾟ)[ﾟoﾟ]='\"';(ﾟДﾟ)['_']((ﾟДﾟ)['_'](ﾟεﾟ+(ﾟДﾟ)[ﾟoﾟ]+(ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+(ﾟｰﾟ)+(ﾟΘﾟ)+(ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+((ﾟｰﾟ)+(ﾟΘﾟ))+(ﾟｰﾟ)+(ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+(ﾟｰﾟ)+((ﾟｰﾟ)+(ﾟΘﾟ))+(ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+((o^_^o)+(o^_^o))+((o^_^o)-(ﾟΘﾟ))+(ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+((o^_^o)+(o^_^o))+(ﾟｰﾟ)+(ﾟДﾟ)[ﾟεﾟ]+((ﾟｰﾟ)+(ﾟΘﾟ))+(c^_^o)+(ﾟДﾟ)[ﾟεﾟ]+(ﾟｰﾟ)+((o^_^o)-(ﾟΘﾟ))+(ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+(ﾟΘﾟ)+(c^_^o)+(ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+(ﾟｰﾟ)+((ﾟｰﾟ)+(ﾟΘﾟ))+(ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+((ﾟｰﾟ)+(ﾟΘﾟ))+(ﾟｰﾟ)+(ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+((ﾟｰﾟ)+(ﾟΘﾟ))+(ﾟｰﾟ)+(ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+((ﾟｰﾟ)+(ﾟΘﾟ))+((ﾟｰﾟ)+(o^_^o))+(ﾟДﾟ)[ﾟεﾟ]+(ﾟｰﾟ)+(c^_^o)+(ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+((o^_^o)-(ﾟΘﾟ))+((ﾟｰﾟ)+(o^_^o))+(ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+((ﾟｰﾟ)+(ﾟΘﾟ))+((ﾟｰﾟ)+(o^_^o))+(ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+((o^_^o)+(o^_^o))+((o^_^o)-(ﾟΘﾟ))+(ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+((ﾟｰﾟ)+(ﾟΘﾟ))+(ﾟｰﾟ)+(ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+(ﾟｰﾟ)+(ﾟｰﾟ)+(ﾟДﾟ)[ﾟεﾟ]+(ﾟｰﾟ)+((o^_^o)-(ﾟΘﾟ))+(ﾟДﾟ)[ﾟεﾟ]+((ﾟｰﾟ)+(ﾟΘﾟ))+(ﾟΘﾟ)+(ﾟДﾟ)[ﾟoﾟ])(ﾟΘﾟ))('_');

```
> 53 votes

# Answer
## Befunge-93 - 10x9 block

```
va:)/v<>#<
9A:)."c:P^
>"iqwt\%"^
bv"Mjq"<.<
c>v<-"x^x]
(C:,3>>^:(
$,9^;)|:O]
>5-^-.--.-
^<_#?>@_@<

```

Sorry. :D

I wasn't going for small size here, I was trying to really ***OBFUSCATE*** the code by including as many smiley faces and noise as possible! :D

Should go with rules 2 and 3.
> 43 votes

# Answer
## Golfscript - 17 chars

Easier to copy/paste than Chris'

```
'Ifmmp!Xpsme'{(}%

```

Basically a caesar cipher shifting by 1 char
> 35 votes

# Answer
## Python

Rule I & III (34 chars)

```
print'Uryyb Jbeyq'.decode('rot13')

```

Rule I & III, alternative (39 chars)

```
print"\110e\154\154o %cor\154\144"%~-88

```

Rule II & III (37 chars)

```
input("H\x65ll\x64 W\x64%cld"%(3*38))

```

Rule I and II (50 chars)

```
input('\x48\x65\x6c\x6c\x6f \x57\x6f\x72\x6c\x64')

```

All three rules (58 chars)

```
input("\x48\x65\x6c\x6c\x6f %c\x6f%c\x6c\x64"%(84+3,3*38))

```
> 32 votes

# Answer
## JavaScript, 366 chars

After seeing Joel Berger's Perl solution, I felt compelled to do some ASCII art prettiness myself... JavaScript, uses no alphanumerics, and contrary to JSFuck output it's actually reasonably sized.

```
                   $$
                  =-~-
                 ~[];$_
                =$$+ $$;
               _$=$$+$$+-
              ~[];_=-~[];$
             =!![]+[];__={}
            +[];$$_=/\\ /+[]
           _$$=(![]+[])[_]+(!
          []+[])[$$]+$[$_+~[]]
         +$[_]+$[+[]];$=__[_$]+
        __[_]+($[$]+[])[_]+(![]+
       [])[$_+~[]]+$[+[]]+$[_]+$[
      $$]+__[_$]+$[+[]]+__[_]+$[_]
     _=$$_[_]+-~[];$[$][$](_$$+'("'
    +_+-~[]+-[]+_+$_+_$+_+_$+$_+_+_$
   +$_+_+_$+[$$+_$]+$$_[-~[]]+$_+-[]+
  _+$$+[$$+_$]+_+_$+[$$+_$]+_+[$$+$_]+
                $$+ _+_$
                +$_+_+$_
                +$_+'")'
                  )($)

```
> 25 votes

# Answer
## rot13 - 11 chars

`Uryyb Jbeyq`

*2019/2/12: This answer is being kept for historical reasons, and is no longer a valid answer under current site rules.*
> 24 votes

# Answer
## Scala, 39

Solutions like **print("Qnuux)\`x{um"map(\_-9 toChar))** (35 chars) fall foul of rules 1 and 2 ("toChar" contains both "h" and "r"), which makes this a bit tough.

Finally came up with this:

```
print("䠀攀氀氀漀 圀漀爀氀搀"map(_.reverseBytes))

```

Suggestions for improvement welcome
> 21 votes

# Answer
## Bash, 30 25 characters

```
tr G-t F-s<<<Ifmmp\ Xpsme

```

With thanks to Peter Taylor for the herestring usage.
> 19 votes

# Answer
# TeX, 95 Bytes

Breaks the third rule.

```
\^^5pp^^%^^2^^#^^!^^3^^%{^^(}^^%^^,^^,^^/
\^^5pp^^%^^2^^#^^!^^3^^%{^^7}^^/^^2^^,^^$!
\^^%^^.^^$

```

Run with `tex filename.tex` to get a dvi output, or `pdftex filename.tex` to get a pdf.
> 19 votes

# Answer
## \>\<\>, 2×20 = 40 characters

```
'mu{x`)xuunQ'>9-o?v;
            ;^?o-9<

```

Violates Rule II, since I cannot output a character without using `o`.
> 15 votes

# Answer
### Windows PowerShell, 91 ~~95~~ ~~97~~ ~~98~~

```
($OFS='')+('Qnuux)`x{um'|% t*y|%{"[convert]::"+([convert]|gm -s t*r).name+"($($_-9))"|iex})

```

Violates only Rule II.

It's very evil that `char` violates two rules on its own already.

And yikes, this one was hard to get working.

* The first line sets `$OFS` to `''` so when casting an array to a string no spaces appear between items.
* Casting to `char` actually was the hardest part of all and I spend around a day searching for a way. I got all the rest working nicely but once I do calculations on them I have `int`s, not `char`s. Putting those back in a string was kinda hard.
* I found a way of invoking `Invoke-Expression` without needing the `e` as well:

```
  &(gcm i?x)

```

but that still lacked the arguments. And I've thrown away my goal of satifying all three rules by then already. Also it didn't particularly help me in casting to `char`.
* Shortened a bit with a newer PowerShell version. No useful different way of creating the result emerged, though, sadly.
> 13 votes

# Answer
# PHP (16 bytes)

I've noticed that my previous PHP example wasn't obfuscated enough, so let's see more blatantly obfuscated examples (warning, obfuscation!). Also, blatantly copying GolfScript example, except making it smaller (is it even possible?). This entry requires either PHP 5.4 or `short_open_tag` enabled. No rule was broken while making this. In fact, this entry doesn't contain any ASCII letters or digits.

This example doesn't break any of the rules. Have fun. To generate file, run following command.

```
printf "<?=~\xb7\x9a\x93\x93\x90\xdf\xa8\x90\x8d\x93\x9b;" > obfus.php

```

Or, in case you don't trust running `printf` command, I've prepared Base64 dump of the file.

```
PD89freak5OQ36iQjZObOw==

```

If you think that both methods to generate it break rules, I also have generated file on Dropbox.

And to run it.

```
php obfus.php

```

The resulting file should have 16 bytes. Have fun running it. Please note that if you have `E_NOTICE` warnings enabled, it will show notice. Just ignore it, fixing it would waste ~~two characters~~ one character (I can use `@` operator, after all) and would make resulting Base64 look less awesome.
> 12 votes

# Answer
## Whitespace (167 characters)

To obtain the WS program, substitute a Space, Tab, or Linefeed character for S, T, L, respectively, in the following string:

```
SSSTSSTSSSLTLSSSSSTTSSTSTLTLSSSSSTTSTTSSLTLSSSSSTTSTTSSLTLSSSSSTTSTTTTLTLSSSSSTSSSSSLTLSSSSSTSTSTTTLTLSSSSSTTSTTTTLTLSSSSSTTTSSTSLTLSSSSSTTSTTSSLTLSSSSSTTSSTSSLTLSSLLL

```

or download the "raw" whitespace-only program in the text-file hello.ws.

When executed by this WS interpreter, this program prints "Hello World".

Explanation (ignore the whitespace here!):

```
SSS TSSTSSSL TLSS  <-- output H (ascii code 72 in decimal, 1001000 in binary)
SSS TTSSTSTL TLSS  <-- output e (ascii code 101 in decimal, 1100101 in binary)
SSS TTSTTSSL TLSS  <-- etc
SSS TTSTTSSL TLSS
SSS TTSTTTTL TLSS
SSS TSSSSSL TLSS
SSS TSTSTTTL TLSS
SSS TTSTTTTL TLSS
SSS TTTSSTSL TLSS
SSS TTSTTSSL TLSS
SSS TTSSTSSL TLSS
LLL                <-- end the program

```

The "middle" strings (e.g. `TSSTSSSL`) are the ascii codes (in binary, with `S` denoting 0, `T` denoting 1) for the successive letters in "Hello World". The prefix `SSS` pushes the number that follows it (terminated by an `L`) onto the stack. `TLSS` outputs the character whose ascii code is on top of the stack. Finally, according to this tutorial, a program must end with `LLL` for a clean exit by the interpreter.

NB: I'm entering this as a separate answer, because the other WS program entry is a 1287-character program that prints "Hello, world of spaces!" instead of the required "Hello World".
> 10 votes

# Answer
## Ruby - 63 characters

```
puts [%w{G d k k n},%w{V n q k c}].map{|l|l.map(&:succ)*''}*' '

```
> 8 votes

# Answer
**C** (94)

On little Endian machines:

```
main(){int i[]={1819043144,((0x1bc5c81b|1<<0x14)*4)+3,0xa646c00|(0x39<<1),0};printf("%s",i);}

```

Violates rule II, but satisfies the rest.
> 7 votes

# Answer
**C, 160 chars**

Works only on little-endian machines with 4-byte int:

```
main(){int a='a',b=a/a,c=b+b,f=c+c,g=f+f,i=g+g,j=i*i,k=j*j,m=a+g+b+c,n=m+b+c;int p[]={a+g-b+(a+f)*j+m*k*(j+b),n+i*c*j+k*(n+g+n*j),a+i+b+m*j+(a+f-b)*k};puts(p);}

```

Satisfies all three rules.
> 7 votes

# Answer
## PHP, 28 bytes

Not exactly obfuscated, but very short and obvious :). Showing that even when limiting characters you can make very easy to follow programs. Constraints 1 and 3 followed. Constraint 2 was abused.

```
<?=str_rot13('Uryyb Jbeyq');

```

Note that this requires `short_open_tag` being set, unless you're using PHP 5.4 or higher. Maybe some examples are shorter, but I think that this example is pretty short.
> 7 votes

# Answer
## Dis, ~~102~~ 83 chars

Unrolled the code loop since the letters can be generated with less than five consecutive operations. Saved a few characters by reusing the accumulator value: two `l` are consecutive , `SPACE` can be generated from `o` and `d` can be generated from `l`.

```
*>|||{>|||{>||{{>|{|||{>||{>|{>|||{>||{||{!!>**_!!}|_}!^__}|__>*__}|_}|_>!!|_}!^__!

```

---

Old version

```
^}!>^^_^!__!>_^!^^**_^!^^**_
^_!{**_^__!{>_^__{>>!^_!{**_
^_!>^*_^!^^**_^_^^**_*______
___________>||||{^

```

With comments below. It is using a sequence of five identical operations to generate all the characters in `Hello World`: one rotation and four subtractions.

```
^     (move code pointer to data pointer value '^')
}!>^^ (store 'H' in accumulator)
_     (no-op)
^     (data pointer value used by code pointer jump)
!__!> (store 'e' in accumulator)
_     (no-op)
^     (data pointer value used by code pointer jump)
!^^** (store 'l' in accumulator)
_     (no-op)
^     (data pointer value used by code pointer jump)
!^^** (store 'l' in accumulator)
_     (no-op)
^     (data pointer value used by code pointer jump)
_!{** (store 'o' in accumulator)
_     (no-op)
^     (data pointer value used by code pointer jump)
__!{> (store ' ' in accumulator)
_     (no-op)
^     (data pointer value used by code pointer jump)
__{>> (store 'W' in accumulator)
!     (program termination)
^     (data pointer value used by code pointer jump)
_!{** (store 'o' in accumulator)
_     (no-op)
^     (data pointer value used by code pointer jump)
_!>^* (store 'r' in accumulator)
_     (no-op)
^     (data pointer value used by code pointer jump)
!^^** (store 'l' in accumulator)
_     (no-op)
^     (data pointer value used by code pointer jump)
_^^** (store 'd' in accumulator)
_     (no-op)
*     (data pointer value used by code pointer jump to reach '!' between 'W' and 'o')
________________ (no-ops)
_     (no-op, address '^')
>|||| (rotate data value and perform four subtractions)
{     (print value in accumulator)
^     (move code pointer to data pointer value '^' except for the last jump '*')

```
> 7 votes

# Answer
## bash 28 chars:

```
printf 'p|ɹ°M ο||ǝ%b'"\x48"

```

> p|ɹοM ο||ǝH

alternatively with /bin/echo (18 chars) \*) see discussion below.

```
/bin/echo -e 'p|ɹοM ο||ǝ\0110'

```

Selftest:

```
echo "printf 'p|ɹοM ο||ǝ%b' "\x48"" | egrep -i "[^hlwd27eor01]"

```

Harder than thougth! Tools, for turning Words upside down, the tools think an 'H' or 'o' turned upside down is best displayed as H or o. This would be in conflict with group 1 (Hlwd:27:eor01) respectively 3.

H can be displayed with

```
echo -e "\0127"

```

but 01 and 2 are poisoned too. Gee! But the bash-buildin echo has not only the option to display octal ascii values, but hexadecimal too:

```
echo -e "\x48"

```

But if we use bash as a programming language, the echo command is part of the program, which not only counts to the character count, but also contains the poisoned characters (hlwd:27:eor01) eho from groups 1 and 3.

So this is moment the echo died. Fortunately, there is printf, which knows "%b" to display .

The r is the only problematic character in printf, and belongs to group 3. Since 'o' is in the last group, we could leave it in Hello and in World, but we can use the omicron ο which looks like an o, or ° `°`.

Links:
> 7 votes

# Answer
## JavaScript - 132 characters

```
(_=(_=[][(f=!!(_='')+_)[3]+(b=({}+_)[(I=-~(z=_-_))])+($=(c=(d=!_+_)[I])+d[z])])())[f[I]+'l'+(a=d[3])+$]("H"+a+'ll'+b+' W'+b+c+'ld')

```

**Breaks** *rule I*

**Usage**:

* Paste "javascript: \[script\]" into browser address bar
* Make a blank html page, paste the script into a tag
> 6 votes

# Answer
# C: 162 characters (excluding unnecessary newlines)

I opted for readability and transparency when writing this.

```
a[3],b;main(){b=99
+9;b+=b<<8;b=b<<8|
97|4;b=b<<8|64|8;a
[3^3]=b;b=78+33<<8
;b+=87;b=b<<8|35^3
;b=b<<8|64|47;a[5^
4]=b;b=97+3<<8;b+=
99+9;b=b<<8|66|48;
a[6^4]=b;puts(a);}

```

It satisfies all three requirements.
> 6 votes

# Answer
## Bash, ~~24~~ 20 characters

You need to have the "bsdgames" package installed.

```
rot13<<<Uryyb\ Jbeyq

```

Thanks gnibbler :)
> 5 votes

# Answer
# PostScript, 41 chars

```
<64><~+BNK%C]~><48656c6c6f>3{print}repeat

```

Usage: `$ gs -q -dNOPROMPT -dNODISPLAY filename.ps`
> 5 votes

# Answer
**JavaScript, 66 chars**

Another JavaScript solution, this time breaking rule #2.

```
top[(U=unescape)('a%6cert')](U('%48e%6c%6co %5'+(6+1)+'or%6c%64'))

```

The above follows the concept behind hallvabo's answer. Before I caught on to that approach, I had the arguably-more obfuscated version:

```
top[8680439[n='toString'](30)]((16+1)[n](z=8*4)[u='toUpperCase']()
+15960[n](33)+'o '+z[n](33)[u]()+1155505[n](36))

```

which also breaks rule #2 and comes in at 114 chars. (Remove the carriage return in this second solution as it is just there for readability.)
> 5 votes

# Answer
## Haskell, 38

Constraints 1 and 3 followed.

```
main=putStr$map succ"G\x64kkn\USVnqkc"

```
> 5 votes

# Answer
# C (79\*12=948)

Using no strings or characters, and only the number one.
I was a little creative with the bitshifts and subtractions to make them fit onto at 80x12 console. Ask me in the comments if you can't figure it out.

```
int i[(1+1)+1],*I=i;main(){*I++=(((1<<((1<<(1+1))*(1<<(1+1))))+((1<<((((1<<(1<<
(1+1)))-1)^(1<<1+1))-1))-(1<<1)-1+((1<<1)*(1<<1)*(1<<1)*(111-(((1<<(1<<(1+1)))-
1)^(1<<1+1))))))*(((((1<<(1+1))*(1<<(1+1)))*(1<<1)-((1<<(1+1))|1))*(((((1<<(1<<
(1+1)))-1)^(1<<1+1))*((((1<<(1<<(1+1)))-1)^(1<<1+1))-1)*((((1<<(1<<(1+1)))-1)^(
1<<1+1))-1)+(((1<<(1<<(1+1)))-1)^(1<<1+1)))-((((1<<(1<<(1+1)))-1)^(1<<1+1))*(((
(1<<(1<<(1+1)))-1)^(1<<1+1))-1)+1)))+((1<<1)|(1<<(1+1))))+(1<<1));*I++=i[1-(1<<
(1-1))]+(((1<<((((1<<(1<<(1+1)))-1)^(1<<1+1))+(1<<1)))+((1<<(((1<<(1<<(1+1)))-1
)^(1<<1+1)))-(1<<(1+1))*(1<<(1<<1))*((1<<(1<<1))-1)-(1<<1)-1))*(((1<<2)*(1<<2)*
((1<<(1+(1<<(1-1))))-1))*((((1<<(1<<(1+1)))-1)^(1<<1+1))-1)*((((1<<(1<<(1+1)))-
1)^(1<<1+1))-1)+(1<<1)+1));*I++=(((1<<(1<<(1<<(1<<1))))+(1<<(1<<((1<<1)+1)))+((
(((1<<(1<<(1+1)))-1)^(1<<1+1))-1)*(1<<1)+1))*((((1<<(1<<(1+1)))-1)^(1<<1+1))-1)
*((((1<<(1<<(1+1)))-1)^(1<<1<<1))-1)+(1<<((1<<1)*((1<<1)+1)))-(1<<1));puts(i);}

```
> 5 votes

# Answer
# Minecraft command, 776 bytes

Let's do something explosive. These commands (break rule #1) generate "Hello World" made by TNT in a Minecraft superflat world.

Screenshot:

```
/tp 33 4 3
/fill ~4 4 5 ~4 4 9 TNT
/fill ~4 4 5 ~6 4 5 TNT
/fill ~4 4 9 ~6 4 9 TNT
/fill ~6 4 5 ~6 4 6 TNT
/fill ~5 4 ~4 ~6 4 ~4 TNT
/fill ~8 4 3 ~8 4 9 TNT
/fill ~34 4 3 ~34 4 9 TNT
/fill ~38 4 3 ~38 4 9 TNT
/tp 3 4 3
/fill ~44 4 6 ~44 4 9 TNT
/fill ~54 4 3 ~54 4 9 TNT
/fill ~58 4 6 ~58 4 9 TNT
/tp 56 4 3
/fill ~4 4 6 ~4 4 6 TNT
/fill ~4 4 9 ~4 4 9 TNT
/fill ~8 4 ~4 ~8 4 ~4 TNT
/tp 66 4 3
/fill ~4 4 6 ~4 4 6 TNT
/fill ~4 4 9 ~4 4 9 TNT
/fill 33 4 3 33 4 9 TNT
/fill 34 4 6 34 4 6 TNT
/fill 35 4 3 35 4 9 TNT
/fill 43 4 3 43 4 9 TNT
/fill 45 4 6 45 4 9 TNT
/fill 46 4 6 46 4 6 TNT
/fill 46 4 9 46 4 9 TNT
/fill 53 4 9 56 4 9 TNT
/fill 53 4 3 53 4 9 TNT
/fill 55 4 3 55 4 9 TNT
/fill 59 4 6 59 4 9 TNT
/fill 63 4 6 63 4 9 TNT
/fill 65 4 6 65 4 6 TNT
/fill 69 4 6 69 4 9 TNT

```

Bonus: After explosion
> 5 votes

# Answer
# Fourier, 39 bytes

```
8*9a99^^a+6^aa~q+3a33va86^aq+3a+3aqa-8a

```

Fourier is always obfuscated. This follows **all** of the rules.

Breakdown:

```
8*9a    Set the accumulator to 8, multiply it by 9, and print the
        corresponding ASCII code.

99^^a   Set the accumulator to 99, increment it twice, and print the
        corresponding ASCII code.

+6^aa   Add 6 to the accumulator, increment it, and print the
        corresponding ASCII code twice.

~q      Set the variable q to the current value of the accumulator.

+3a     Add 3 to the accumulator and... I think you get the idea.

33va    Set the accumulator to 33, decrement it, and print ASCII.

86^a    Yes, okay, I think it's obvious by this point.

q+3a    Set the accumulator to the value of q (earlier set to 108),
        add 3, and print ASCII.

+3a     ...

qa      Invoke q again and print ASCII.

-8a     Subtract 8 from the accumulator and print ASCII.

```

This could maybe be refined a little.
> 4 votes

# Answer
# PI based program: 127 char

```
q=`BC_LINE_LENGTH= bc -l<<<scale=18'51;a(1)'`;for v
in 39 iO da hJ 18 cn sU 4U 1I dS s2 me bK;do printf %b \\${q:64#$v:3};done

```

### Old version

```
#!/bin/bash

pi=$(bc -l <<<'scale=4000;4*a(1)')
pi=${pi//[$'\n\\']}
for v in aF Fb e3d F78 67a 172 496 12A 867 52D E3d 667 eAc;do
    printf -vv %b \\${pi:16#$v:3}
    o+=$v
done
echo $o

```

Do render:

```
Hello, World!

```

**Nota:** in order to prevent long time compute, you could use pre-computed 4k pi value:

```
#!/bin/bash

pi=$(gunzip < <(base64 -d <<-eof
H4sIAHM1DVwCAyXXB3IDMQwDwB9lJFH1/x/L4pxJcWwVEgRAXv312dcbe9W677wadecee1bdGuetNu6d/Z2+X71XZ/W27mjvzDenjdXO7Xu2Pe4e7b7nz20171g1R++n7fPu6PO2u1evcW3Ze5723DR3e2vlxFH92LLebLePO2+3d+b62ds4rVu+nNfWWm/bOMab9635qtXt
eUukXWBr7/WqLMk5/hVL1bn73Op7jdOH09rrMx9ZLQlxCHn3NtessbOlV73a7YzdxrS4j1NnzHVPE3/b1ddy4Zl+LYD4lvl4Y01nn74KiO70xmsOat2Jbfm2Y7QpSnfIbu63+lOF3qExs+hIuPY6663Xnz1vdNH1k0zF59UrUPR+ndZO4KjzBKAsa59a/V7bh4Dv60Mh7bwl
hieX8W4Jzc+YKgeCWarTxOPjueutMaZ0wXS8q4BfZF6fIwXRnH72EMPZbgll4NDzB5yzpc6ttbWV8sB57Fq7XbtFdTpiHH/v20GqtovOPTiyMaK9JmBplKC8pcLrLkvaaucllR1M/dSaqaSEex+SEqkTLzIqfleVd7sU3zkzlzb4iEz9XCWG931dRX3nNv+G2u/ICUlTCiW+
KwoI0ecS0H4NiNQxAAQyhA3P7molR6VREJTorcu+OtLVhc/FfH8LKN7oot4BMFh1MNv8Prm8hsNnLScKQ/wrqip0KQD45NPfC3Q9QF61SCnG2BcnpQiOYaHXKo13KrU/kC4CkNpALcEB9S4nW3sjlo2tIcgHrsQAb624vKC6IJ5bgYnMqFoh1XxwPEmv5nmdHigCDVwx6QSh
G2bDjygcj90ojNk3ukGs1V7QONKtMzchw09lbWuzCR3X+j5K9fx3o5qJGgIXL70u25pU5TMDOWlMN8Uekm+4CH/aYFTgheDHBFhl+bQpFZ1xrajxzgh1//QhXALB9+sk8s4Vflu79ttxBJ4V31kxJjoME8SnAiW9g4MENLkSMtET+3gS4iVz7Pdj8UlZZ9wz7vBqAke1UNmC
mfI4HdugBkFeCF1mOoMay5QWHC17OVFYQUygsoSsfaDADo6Hoo+8iDfYtMGYQhcnPCy5MYYZbLjvFsuLoWgIITnXhFyPtBVKlQ5EeKyvz1PQPO4vLtTbUTr4Yg/hJUFbViBicukhzo9fWaiCffnf4THambPd8eIA8XlSUfXDjjpDLGyiljFDoSEcEEgY1QiErCE2BodkK6HP
SOj7qgKR0ZRT2weDIvsP5a1Lc+M6/GKd3Fkf+cFgUQ97lWSRXhpHpUs1mxsxuR8w8V7hjfAypjO/nuVkYa1UWb4MXqESWcTJwCvlmx+oxPXixTocNjLvmMWOIaI1O2a9ALxBHJnSCtwWBEgvjVRz3lyJNaZPOeOmvBHKy2r8Y68i3YG0ghd240+MRrMNkUd6g3VY6TYnRBl+
KdfBKD7siqZUqiCgGGALCkJHbBjMpftlKtDXZ7E1zJEUd6FiFDwyl5I+zBly9Yodzs9lb5wVjxAbD7lT6HPSWjQROSUYgfsharJlLdiq4O+7WGlsd2l8++Qt1bnex3M2NdNTJaPoN40O3lIGbmxLtVSPVg02gS6v4Ro94Bggo4W+4s2M2WvUZoEsRywoiHdovHK+5lkZc4aW
MgLsxwEM9yEWpPyhXogJRIjv87OlGytO+/dedMgD9443or0D1o6JMYb1cSoTwcm0AmD2wq8pYmf2KIxAR0ZxdrzruMUMlO0adkubogPTm9grA4+sCrLCVYmUf8U/YzSZAMiF3dwMMz4+X3vmahm9brill+OFlq+WIypeAY07ODxdNGMTgrzYr0owkUtxmUTCJCggKhPKeMCN
eZ1oif1kfDEskV3sfU55rGyOR35jjvqwgIoIrO/fBNGJKiOLXNHBCUyG6WG1gI8+b1h0wVHYdFj6ML+aL1xnODmZn/QiDNj842NmVKQ5fJI2IfEv23tImLaLDS2DUoxm6VS4lzHVmKMP7Qwvnzt/HbjHWU+0sdLsYwZqluY+M3F9cvpUfz+3/OaQlzpk3OP3TnNleoVV71cp
fshDWIZMscOYF0q1tPWMSXGaYKMz3kyJwTsilF2l576Yu0IZG06mmCQuRNQ9FV+XFtdMf4drPHt87WenzUHmxIStpqKVmfUTuVlC/TN5I2DFmdG4pSjkZZC/GSCD066MVWny8YqAvtSfxiULQDNCPFLjVMuXjqgfZDCksMwstkBH6wG0y42x4eLIQ0eLhkEkv0BCuBGs1L+R
/2WEJ04KSlfOvJpHDLmqv3jjvRmi0F7JmE7G7BHiqb4QEcN93+zx9Lmv0b1vsM5sA7QoZGVICYJiTPB5tmD9TcYY44YMRQw7mutxYmUBAZtOLyHNyk1EofXm0QrtRKjZ5GGrUhz5Vp5A8irLfi1gwQlvvhkko9L6HiG8DS91x/zcxjk3fG+US5d8Vw/AdvXM6FYBO/aRGe5+
T4Ei3d+DhQk4pXzxBhsDfh5cTnqJBwMx4z9HjINDlUWG0XlaA4NGlJGbt8bt9C8dMsNDnhnT3wHJ/b8y4ldF2xk6MqiifM9zjgZhNmSMysfHm1KM9IawV4HjTNS8EtuIpMwoxh4RS14GYb80I3nROorUvmc/g3L44YQgt/NU6bsZk+Sq7rF6HVzkvKUyprOHPBPdzI4QN9R8
/gQdxZLdztSrPdf35JFHUg4Crbyl4QkDpnnMQAvMy0xpYZ4T8vgAkDyW7ozmOXdkkFPKnWP+AVkFcIuiDwAA
eof
))
for v in af fB e3D F78 67a 172 496 12A 867 {52,E3}d 667 EaC;do
    printf -vv %b \\${pi:16#$v:3}
    o+=$v
done
echo $o

```

Will render (same, but quicker):

```
Hello, World!

```
> 4 votes

# Answer
# Labyrinth, 76 72 Characters, 12 Distinct

```
####*:*#(*:.#+#/#)*):.##++:.:.#+::}.#/#))-:.#*#:*-.{:.#+:.#:(*-:.#):+-.@

```

Try It Online

This is my first post here, so I'm not 100% sure I am doing everything right. Please let me know if there are any changes I should make! I have been working on implementing an interpreter for Labyrinth in my spare time, and since I just got a partially-working prototype (still don't have any grid manipulation or the `? ! \` characters), I wanted to write a Hello World! program as my first test, since I hadn't programmed anything yet in the language. I decided to do it without any alphanumeric characters to add a little bit of an extra challenge, but I haven't really done anything to hide how the code works.

Explanation:

* `####*:*`: Creates the number 36 (finds the length of the stack 4 times, multiplies the last two, duplicates this value, and multiplies those)
* `#(*:.`: Outputs "H" (finds stack length of 3, subtracts 1, multiplies it to the 36, duplicates it for future use, and returns the character with code 72)
* `#+#/#)*):.`: Outputs "e" (finds stack length of 3, adds to the 72 we saved from the last step, finds stack length of 3, divides 75 by 3, finds stack length of 3, increments to 4, multiplies 25 by 4, adds 1, duplicates for the next step, and outputs character code 101)
* `##++:.:.`: Outputs both "l"s (finds stack length twice and sums to get a value of 7, adds to the 101, duplicates and outputs twice to return two character code 108s and saves a 108 for the next step)
* `#+::}.`: Output an "o" and move one to the auxiliary stack. Our next character code after the "o" is 32, but our next lowercase letter after that is another "o." For this reason, we save an 111 so that we don't have to work our way back up. (Finds stack length of 3, adds to the 108, duplicates twice, saves one on auxiliary stack, outputs one, keeps the third for the next step)
* `#/#))-:.`: Returns a space. Since our character code is 111 right now, we have to find how to reduce our top-of-stack value to 32. To do this, we divide 111 by 3, returning 37 (all division rounds down), then we get a 3, increment it twice, and subtract it from the 37 to get 32. From there, we do the normal duplicate and return.
* `#*#:*-.`: Return a capital "W." 32 and 87 are far enough apart that we have to do something similar to what we did in the last step. We multiply 32 by 3 to get 96, then square 3 using the `#:*` and subtract it off to get 87. Here, we don't duplicate, since the next value we will use is the 111 we saved on the other stack, so we simply output.
* `{:.`: Fetch the 111, duplicate, and output our "o" (pretty self-explanatory).
* `#+:.`: Returns "r." (increment 111 by 3, duplicate, and output)
* `#:(*-:.`: Returns "l." Strangely enough, subtracting 6, duping, and outputting takes the same number of characters as the whole step to return "W" did. I expect there may be a way to golf this down, but it currently grabs the stack length (3), duplicates it, subtracts 1, multiplies them together, subtracts it from 114, duplicates 108, and outputs. Perhaps saving an extra copy of the 111 could help?
* `#):+-.`: Returns "d." (Finds stack length of 3, adds 1, duplicates, sums, subtracts from 108, and returns) This is practically the same process as the last step.
* `@`: Exits.

NOW REMOVED:

* `#/.`: Returns "!". This seems overly short, since it has to "jump" from the lowercase letter range (near 100) to the special character range (near 30), but, in this case, there's a nice coincidence. The character code for "!" is 33, so, using the auto-floor functionality, simply dividing 100 by the length of the stack gives us the correct value. Then, we output.

Old versions had an extra colon right before the period at the end of the clause that produces "d" and, before the @, the "!" step is inserted.

In total, there are 12 distinct characters used, with three of those characters (},{, and @) only being used once and the decrement operator ( and the division operator / only being used twice. It is impossible to remove @ from the program, but { and } are unnecessary and only used to save characters in the 87-to-111 step. The ( character can likely be removed in favor of a combination of #, -, and ), and it is likely possible to shave a few others, like the + character, but that would come at the cost of being significantly longer. Division removal would be very expensive in terms of character count, but possible.

Using numeric characters, the shortest Hello World! program I know of is 43 characters (with 9 distinct), which means that the length disadvantage is only 67%, which I believe is quite a bit less than other languages.
> 4 votes

# Answer
## Befunge-93 - 57 characters

```
554553943346**,"b"3+,366**::,,3+::,48*,699*+,,+,**,**,+,@

```

Should meet all three requirements.
> 3 votes

# Answer
## Perl

```
my @txt = (
  -38,
  -9,
  -6/3,
  -6/3,
  3/3,
  -468/6,
  -69/3,
  3/3,
  4,
  -6/3,
  -30/3,
);

$\ = "\n";
print map{pack 'C', 330/3 + $_} @txt;

```

I would have been able to do it without any of the of the "forbidden" characters, except there is no easy way, that I can think of to enable the use of anything other than `print` or `die`, without using, at least one of the "forbidden" characters.

```
use feature 'say' # e
use 5.010; # 10
BEGIN{ $^H{'feature_say'} = !'' } # eh
use Modern::Perl # ero

say ...

```

```
use IO::Handle; # e
STDOUT->say( ... )

```

So the only way is to load a module, that internally loads IO::Handle. Which will indirectly enable the use of `STDOUT->say`.
> 3 votes

# Answer
## C (333 characters)

I decided to emphasize on obfuscate, with golf secondary. This is written entirely in C, and it only breaks rule #2 laid out in the original post. It also breaks I don't know how many C programming rules...

```
int main(){
int a[]={0x0a004000,0x0fc00109,0x04e01500,0x09e08400,0x03506a61,0x00f00000,0x0f010ae3,0x05f0fb16,0x0beb0030,0x0130a300,0x0bc00500,0x00000000};
int b,c=13,e,x,an;
goto _XX;
_00:an=e,x^=x,b^=b;
_10:if(!an)goto _XX;
b|=!!(an&0xf)<<x++;
an>>=4;
goto _10;
_XX:if(c<=1)goto _40;
if(c<13)printf("%c",b);
e=a[13-c--];
goto _00;
_40:return 0;
}

```
> 3 votes

# Answer
# C, ??? characters

Not very heavily golfed, but I was going more for obfuscation anyway. Your mileage may vary, you'll probably have to do some crap to get the hardcoded address of printf right. No forbidden characters. You could easily shorten up a lot of stuff by not using different numbers of underscores as variable names and instead using 1 letter things, but I think it looks uglier this way.

```
int main()
{
    int(*f)(int*,...)=467846797-333333333;
    int _=9-8,__=_<<_,___=__<<_,____=___<<_,_____=____<<_,______=_____<<_,$=_|((_____|____)<<__);

    f("%c", $+(_|__|___)^______);
    f("%c", $+(___));
    f("%c", $+(_|__|____));
    f("%c", $+(_|__|____));
    f("%c", $+(__|___|____));
    f("%c", ______);
    f("%c", $+(__|___|_____)^______);
    f("%c", $+(__|___|____));
    f("%c", $+(_|_____));
    f("%c", $+(_|__|____));
    f("%c", $+(_|__));
    f("%c", ______|_);
}

```
> 3 votes

# Answer
# Befunge-93, 8x6 grid

I know I'm a little late to the party, but I saw the Befunge-93 solutions and decided to see how small I could make one while still following all the rules.

```
"[uixn"v
Qv:,-9<"
v_vQQQ^)
>9+,>:|f
^Q>>^Q@"
^"?ncu"<

```
> 3 votes

# Answer
# \>\<\> (Fish), 80 bytes

Wait, I'm not the only one that uses \>\<\>?

```
33-aa*:8+:6+:3-8a*843--+48*aa*:b+$8+::843---89*ab*43-+543-p33-43-.
 :?!;_33-43-.

```

Thanks to @Sp3000 for a method to print without "o".

Try it here.
> 3 votes

# Answer
# C 61 Bytes

```
main(){printf("%ce%c%co %cor%c%c",9*8,108,108,86+1,108,100);}

```

Went as small as possible on this guy. Hopefully y'all can see that. This breaks rule 2.
> 3 votes

# Answer
# SuperMarioLang, 235 bytes

Why does this language exist?

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

```

Try it online!
> 3 votes

# Answer
# MAWP, ~~97~~ 89 bytes

```
98W;55W4W1M;93W4W;93W4W;94W1M3W;58W4M;84W;98M5W64AM;94W1M3W;99M1M6W;93W4W;55W4W;964AM3W;.

```

Meets two of the requirements
> 3 votes

# Answer
# Vyxal, 2 bytes

```
kh

```

Try it Online!

Built-in that pushes the string `Hello World`. Since it meets two of the requirements, it is valid, but it's not really obfuscated, is it? How about one that meets all three requirements?

---

## Less trivial, 6 bytes

```
`ƈṡ ƛ€

```

Try it Online!

Pushes `Hello World` as a dictionary-compressed string and implicitly outputs. It meets all of the requirements, but it's still a bit boring, no?

## Non-trivial, 7 bytes

```
\k⁺∧C+Ė

```

Try it Online!

Builds the string `kh` and evaluates it as Vyxal code. Meets all three requirements, and definitely the most obfuscated of the three programs.

Explanation:

```
\k       # Push 'k'
  ⁺∧     # Push 104; '⁺' takes the index of the next command in the Vyxal codepage ('∧' is 0x03) and adds 101
    C    # Convert to character; 104 becomes 'h'
     +   # Concatenate; builds the string 'kh'
      Ė  # Evaluate as Vyxal code
         # Implicit output

```
> 3 votes

# Answer
# **Python** (6019 chars)

```
eval(eval(''+eval('str(str)[+all([])]')+eval('str(str'+eval('str('+str(eval)[eval(str((+all([])))+str((+all([[]]))))]+'l'+str(eval)[eval(str((+all([])))+str((all([])+all([])+all([])+all([])+all([])+all([]))))]+'at((+all([]))))[(+all([]))]')+str(str)[+all([])]+str(eval)[eval(str((+all([])))+str((all([])+all([])+all([])+all([])+all([])+all([]))))]+str(eval)[(all([])+all([]))]+str(eval)[(all([])+all([])+all([])+all([])+all([])+all([])+all([])+all([]))]+'t)[(all([])+all([])+all([])+all([]))]')+'r('+str((+all([])))+str((+all([])))+str((all([])+all([])))+')')+'r'+eval(''+eval('str(str)[+all([])]')+eval('str(str'+eval('str('+str(eval)[eval(str((+all([])))+str((+all([[]]))))]+'l'+str(eval)[eval(str((+all([])))+str((all([])+all([])+all([])+all([])+all([])+all([]))))]+'at((+all([]))))[(+all([]))]')+str(str)[+all([])]+str(eval)[eval(str((+all([])))+str((all([])+all([])+all([])+all([])+all([])+all([]))))]+str(eval)[(all([])+all([]))]+str(eval)[(all([])+all([])+all([])+all([])+all([])+all([])+all([])+all([]))]+'t)[(all([])+all([])+all([])+all([]))]')+'r('+str((+all([])))+str((+all([[]])))+str((all([])+all([])+all([])+all([])+all([])))+')')+eval('str(eval)[(all([])+all([])+all([])+all([])+all([])+all([])+all([])+all([]))]')+'t('+eval(''+eval('str(str)[+all([])]')+eval('str(str'+eval('str('+str(eval)[eval(str((+all([])))+str((+all([[]]))))]+'l'+str(eval)[eval(str((+all([])))+str((all([])+all([])+all([])+all([])+all([])+all([]))))]+'at((+all([]))))[(+all([]))]')+str(str)[+all([])]+str(eval)[eval(str((+all([])))+str((all([])+all([])+all([])+all([])+all([])+all([]))))]+str(eval)[(all([])+all([]))]+str(eval)[(all([])+all([])+all([])+all([])+all([])+all([])+all([])+all([]))]+'t)[(all([])+all([])+all([])+all([]))]')+'r('+str((all([])+all([])+all([])))+str((all([])+all([])+all([])+all([])))+')')+eval(''+eval('str(str)[+all([])]')+eval('str(str'+eval('str('+str(eval)[eval(str((+all([])))+str((+all([[]]))))]+'l'+str(eval)[eval(str((+all([])))+str((all([])+all([])+all([])+all([])+all([])+all([]))))]+'at((+all([]))))[(+all([]))]')+str(str)[+all([])]+str(eval)[eval(str((+all([])))+str((all([])+all([])+all([])+all([])+all([])+all([]))))]+str(eval)[(all([])+all([]))]+str(eval)[(all([])+all([])+all([])+all([])+all([])+all([])+all([])+all([]))]+'t)[(all([])+all([])+all([])+all([]))]')+'r('+str((all([])+all([])+all([])+all([])+all([])+all([])+all([])))+str((all([])+all([])))+')')+'ell'+eval('str(eval)[eval(str((+all([])))+str((all([])+all([])+all([])+all([])+all([])+all([]))))]')+eval(''+eval('str(str)[+all([])]')+eval('str(str'+eval('str('+str(eval)[eval(str((+all([])))+str((+all([[]]))))]+'l'+str(eval)[eval(str((+all([])))+str((all([])+all([])+all([])+all([])+all([])+all([]))))]+'at((+all([]))))[(+all([]))]')+str(str)[+all([])]+str(eval)[eval(str((+all([])))+str((all([])+all([])+all([])+all([])+all([])+all([]))))]+str(eval)[(all([])+all([]))]+str(eval)[(all([])+all([])+all([])+all([])+all([])+all([])+all([])+all([]))]+'t)[(all([])+all([])+all([])+all([]))]')+'r('+str((all([])+all([])+all([])+all([])))+str((all([])+all([])+all([])+all([])))+')')+eval(''+eval('str(str)[+all([])]')+eval('str(str'+eval('str('+str(eval)[eval(str((+all([])))+str((+all([[]]))))]+'l'+str(eval)[eval(str((+all([])))+str((all([])+all([])+all([])+all([])+all([])+all([]))))]+'at((+all([]))))[(+all([]))]')+str(str)[+all([])]+str(eval)[eval(str((+all([])))+str((all([])+all([])+all([])+all([])+all([])+all([]))))]+str(eval)[(all([])+all([]))]+str(eval)[(all([])+all([])+all([])+all([])+all([])+all([])+all([])+all([]))]+'t)[(all([])+all([])+all([])+all([]))]')+'r('+str((all([])+all([])+all([])))+str((all([])+all([])))+')')+eval(''+eval('str(str)[+all([])]')+eval('str(str'+eval('str('+str(eval)[eval(str((+all([])))+str((+all([[]]))))]+'l'+str(eval)[eval(str((+all([])))+str((all([])+all([])+all([])+all([])+all([])+all([]))))]+'at((+all([]))))[(+all([]))]')+str(str)[+all([])]+str(eval)[eval(str((+all([])))+str((all([])+all([])+all([])+all([])+all([])+all([]))))]+str(eval)[(all([])+all([]))]+str(eval)[(all([])+all([])+all([])+all([])+all([])+all([])+all([])+all([]))]+'t)[(all([])+all([])+all([])+all([]))]')+'r('+str((+all([])))+str((+all([])))+str((all([])+all([])+all([])+all([])+all([])+all([])+all([])+all([])+all([])))+')')+eval('str(eval)[eval(str((+all([])))+str((all([])+all([])+all([])+all([])+all([])+all([]))))]')+'rl'+eval(''+eval('str(str)[+all([])]')+eval('str(str'+eval('str('+str(eval)[eval(str((+all([])))+str((+all([[]]))))]+'l'+str(eval)[eval(str((+all([])))+str((all([])+all([])+all([])+all([])+all([])+all([]))))]+'at((+all([]))))[(+all([]))]')+str(str)[+all([])]+str(eval)[eval(str((+all([])))+str((all([])+all([])+all([])+all([])+all([])+all([]))))]+str(eval)[(all([])+all([]))]+str(eval)[(all([])+all([])+all([])+all([])+all([])+all([])+all([])+all([]))]+'t)[(all([])+all([])+all([])+all([]))]')+'r('+str((+all([])))+str((+all([[]])))+str((+all([[]])))+')')+eval(''+eval('str(str)[+all([])]')+eval('str(str'+eval('str('+str(eval)[eval(str((+all([])))+str((+all([[]]))))]+'l'+str(eval)[eval(str((+all([])))+str((all([])+all([])+all([])+all([])+all([])+all([]))))]+'at((+all([]))))[(+all([]))]')+str(str)[+all([])]+str(eval)[eval(str((+all([])))+str((all([])+all([])+all([])+all([])+all([])+all([]))))]+str(eval)[(all([])+all([]))]+str(eval)[(all([])+all([])+all([])+all([])+all([])+all([])+all([])+all([]))]+'t)[(all([])+all([])+all([])+all([]))]')+'r('+str((all([])+all([])+all([])))+str((all([])+all([])+all([])))+')')+eval(''+eval('str(str)[+all([])]')+eval('str(str'+eval('str('+str(eval)[eval(str((+all([])))+str((+all([[]]))))]+'l'+str(eval)[eval(str((+all([])))+str((all([])+all([])+all([])+all([])+all([])+all([]))))]+'at((+all([]))))[(+all([]))]')+str(str)[+all([])]+str(eval)[eval(str((+all([])))+str((all([])+all([])+all([])+all([])+all([])+all([]))))]+str(eval)[(all([])+all([]))]+str(eval)[(all([])+all([])+all([])+all([])+all([])+all([])+all([])+all([]))]+'t)[(all([])+all([])+all([])+all([]))]')+'r('+str((all([])+all([])+all([])))+str((all([])+all([])+all([])+all([])))+')')+')')

```
> 3 votes

# Answer
# FSharp, 83

```
("(())(((()("|>String.mapi(fun i c->" =CCG/GJC<".[i]+c)).Insert(5," ")|>printf "%s"

```

Breaks the second rule to use some F# keywords.
> 2 votes

# Answer
**J (23 characters)**

```
a.{~<:a.i.'Ifmmp!Xpsme'

```

It doesn't beat Golfscript, but I figure J deserves an entry anyway. (This is just a minor tweak of the second example on the J vocabulary page for the word i..
> 2 votes

# Answer
## APL (~~157~~ 155)

No h, l, r, w, d, 2, 7, e, o, or r, but there is 0 and 1 (so it meets two out of three requirements).

I went for obfuscation rather than size. (If you can't figure out how it works, it is a variation of this guy's method).

```
⎕UCS{⌈+/96,⍵{⊃a×b○c×1.118×⍺,a b c←⍵}¨,⌿((11-33)13.3 ¯8.5 18(.3×4)16.5 4 8.5 .4 6,[0]10⍴(⍴'⍴⍴')1),[1]⌈.5×⍳10}¨(⍳11)-1

```

## APL (28)

Boring straightforward one, but meets all requirements and is short-ish.

```
⎕UCS(⎕UCS'Jgnnq"Yqtnf')-.5×4

```
> 2 votes

# Answer
## C Program (83 Characters)

```
#include<stdio.h>
void main(){printf("%ce%c%co %cor%c%c",104,108,108,119,108,100);}

```
> 2 votes

# Answer
# "C++"

329 bytes including newlines and extraneous backslashes on newlines (which are 7 bytes).

C++ is in scare quotes because of all the implementation dependent details (gcc, appropriate linux kernel, x86). Doing this challenge in C++ is difficult because right off the bat #include is forbidden.

```
int main(){int r[]={1819043144,1866980911+1000000,164353511+10000011};asm("sub \
$31,%%esp\nsub $1,%%esp\nmov $4,%%eax\nmov %%eax,0x1C(%%esp)\nmov %0,%%eax\nmov\
 %%eax,0x18(%%esp)\nmov %1,%%eax\nmov %%eax,0x14(%%esp)\nmov $1,%%eax\nmov %%ea\
x,16(%%esp)\npopa\nint $0x80"::"r"(r),"r"(9+3):"%eax","%ebx","%ecx","%esi",
"%ebx");}

```

I think there's technically a bit of undefined behavior here as well, since I don't tell gcc all the registers I clobber (Things like %edx cannot be referred to directly) which is unfortunate.
> 2 votes

# Answer
# JavaScript 155 142 122

This satisfies *ALL* the rules provided.

```
_=(!!4+"")[5-4],3[C="c\x6fnst"+_+"uct\x6f"+_][C]("a\x6c\x65"+_+
"t('\x48\x65\x6c\x6c\x6f \\x5"+-~6+"\x6f'+_+'\x6c\x64')")()

```
> 2 votes

# Answer
# Sclipting, 8 characters

```
낆녬닆묠녶뭲닆밄

```

Of course, this doesn’t contain any of the restricted characters.

(This answer is technically cheating because Sclipting was invented after this challenge was posted.)
> 2 votes

# Answer
# Haskell (genetic programming), 306 chars

This is not really genetic programming. It's just a pun. The only violation of the rules is the function name `putStrLn`, which is a builtin I/O function, and follows the spirit of the rules even if it doesn't quite match the letter.

```
a=(['~','}'..]!!)
t=(succ)
y= \x->x-x
c=(y)$3
g=((t.t$c)*)
q=(a.g.t.g.t.g.g.t.g.t$c):(a.t.g.g.g.t.g.t$c):(a.g.t.g.g.g.t$c):(a.g.t.g.g.g.t$c):(a.t.g.t.g.t.g.t$c):(a.g.t.g.t.g.t.g.t.g.g.t$c):(a.t.g.t.g.t.g.g.g.t$c):(a.t.g.t.g.t.g.t$c):(a.g.g.t.g.t$c):(a.g.t.g.g.g.t$c):(a.g.t.g.g.t.g.t$c):[]
main=putStrLn$q

```
> 2 votes

# Answer
# Golfscript 18 bytes

New code (saved 4 bytes thanks to Martin Büttner):

```
'Jgnnq"Yqtnf'{((}%

```

Old code (22 bytes):

```
"Jgnnq\"Yqtnf"{1 1+-}%

```

It basically preforms a Caesar cipher two times. Because you can't have a 2 in your code, I just used 1+1. It doesn't break any of the rules.
> 2 votes

# Answer
# Commodore 64 Basic, ~~22~~ ~~21~~ 15 characters

```
3?"|─└└┌ ○┌_└‾

```

PETSCII substitutions:  = `SHIFT+D`,  = `SHIFT+E`, `|` = `SHIFT+H`,  = `SHIFT+L`,  = `SHIFT+O`, `_` = `SHIFT+R`  = `SHIFT+W`. Additionally, there's an invisible character with the byte value "14" after the quotation mark.

The Commodore 64 has two default character sets, the "unshifted" set it boots up in (uppercase letters, numbers, and a wide range of box-drawing and graphical characters), and the "shifted" set (lowercase letters, uppercase letters, numbers, and a smaller set of box-drawing and graphical characters). Printing character 14 switches the display from "unshifted" set (which I wrote the program in) into the "shifted" set.

This program meets all three requirements.

**Edit:** In attempting to write a sorted "hello world", I discovered that the end quote is optional. Golfed off a character.

**Edit:** Golfed off six bytes by replacing `CHR(14)` with a literal byte value of 14.
> 2 votes

# Answer
# Clip, 17 chars

All rules followed.

```
m+'☻`"Fcjjm▲Umpjb

```

This just means, in a more readable form, `map (add 2 to ascii value) "Fcjjm▲Umpjb"`.
> 2 votes

# Answer
# Pyth \- 24 bytes. All 3 rules

Noticed there wasn't a Pyth entry yet (probably because the question's been around longer), but wanted to add one for completion's sake!

```
V"Qnuux)`x{um"=+kC-CN9;k

```

Try it out.

**Explanation**

```
# basically just a -9 int value translation on each character

V"Qnuux)`x{um"        ;     # for each chr (N) in the string "Qnuux)`x{um"
              =+k           #   append to k (initially an empty string)
                 C          #   the character value of the integer
                  -  9      #   that results from subtracting 9 from
                   CN       #   the integer value of the current chr (N)
                       k    # print k

```
> 2 votes

# Answer
# pb, 72 bytes

```
b[69+3]>b[101]>b[108]>b[108]>b[111]>>b[86+1]>b[111]>b[114]>b[108]>b[100]

```

**Violates rule II**
> 2 votes

# Answer
# Java, 88

I'm surprised, nobody used java.

```
System.out.print\u006Cn("\u0048e\u006C\u006Co "+((c\u0068ar)(11*8-1))+"or\u006C\u0064");

```
> 2 votes

# Answer
## Hexagony, 42 bytes

```
G\._.[\[c)[_\V[n[q.\[k[c[@.$>);]._.k[;n[i5

```

Try it Online!

If violating 1 rule (Rule 1), it is not hard to do it with 31 bytes:

```
H;d);d;@/6;W;n/;l;;n)/);q);l;i

```

However as to make it more obfuscated and cute with 2 `._.`s, I made it 42 bytes.

Enjoy!
> 2 votes

# Answer
# Befunge-93, ~~49~~ 45 bytes

*Thanks to James Holderness for saving me ~~two~~ four bytes! (I don't know how to count)*

Why is this 7-year-old challenge in the front page? I don't know! What I do know is that I came up with an answer before I realized the thread is ancient, so here goes:

```
554**:8+:6+:3-:83*-48*"q"2-:3-::7-"F"2+>:#,_@

```

Works in complete disregard to the third rule, but that's fine because ~~rules are made to be broken anyway~~ it meets 1 and 2.

Try it online!
> 2 votes

# Answer
# Java, 71 bytes

Violates restriction #2, but doesn't contain `[HLWDhlwd27]`.

```
String m(){return String.format("\u0048e\154\154o %cor\154\144",86+1);}

```

OR to print to stdout (the same length)

```
voi\u0064 m(){System.out.printf("\u0048e\154\154o %cor\154\144",86+1);}

```
> 2 votes

# Answer
# C, 2066 bytes

**NOTE**: Little-endian only. (That should give readers a hint at what this strange code does.)

Certainly not going to win, but it's kinda neat anyway (IMO). Satisfies first and third requirements.

```
int _(){return 0;}int __(_){return(1+_);}int _____(_
,__){return(_+__);}int ______(_,___){return(_*___);}
int ___(_,__){return _<<__;}int main(){int ____[4]={
___(_____(______(__(___(__(_()),__(_()))),______(__(
___(__(_()),__(__(___(__(_()),__(_())))))),______(_\
____(___(______(__(___(__(_()),__(___(__(_()),__(_()
))))),__(___(__(_()),__(_())))),__(___(__(_()),__(_(
))))),__(__(__(___(__(_()),__(__(_()))))))),__(___(\
__(__(__(___(_____(___(__(_()),__(___(__(_()),___(_\
_(_()),__(_()))))),__(__(__(___(__(_()),___(__(_()),
__(_()))))))),___(__(___(__(_()),__(_()))),__(_())))
))),__(___(__(_()),__(_())))))))),___(__(_()),___(__
(_()),__(_())))),(_____(___(__(_()),__(_())),__(_())
))),______(_____(___(__(___(_____(___(_____(___(__(_
()),___(__(_()),___(__(_()),__(_())))),__(__(__(___(
__(_()),__(___(__(_()),__(_())))))))),___(__(_()),__
(_()))),__(___(__(_()),__(_())))),___(__(_()),__(_()
)))),___(___(__(_()),__(_())),__(_()))),__(___(__(_\
__(__(_()),__(_()))),__(_())))),(_____(___(______(_\
____(___(__(___(__(___(__(___(__(_()),__(_()))),__(_
()))),__(_()))),___(___(__(_()),__(_())),__(_()))),\
__(___(__(_()),__(_())))),__(___(______(__(___(__(_(
)),__(_()))),______(__(___(__(_()),___(__(_()),__(_(
))))),__(___(__(___(__(_()),__(_()))),__(_()))))),__
(_())))),___(__(_()),__(_()))),(__(___(__(_()),___(\
__(_()),__(_())))))))),______(__(__(__(___(__(_()),\
__(___(__(_()),__(_()))))))),______(__(______(___(__
(_()),__(_())),______(__(___(__(_()),__(_()))),__(_\
__(__(_()),___(__(_()),___(__(_()),__(_())))))))),__
(___(__(___(______(__(___(__(___(__(___(__(___(__(_(
)),__(___(__(_()),__(_()))))),___(__(_()),__(_()))))
,__(_()))),__(_()))),__(______(___(__(_()),__(_())),
______(__(___(__(_()),__(_()))),______(__(___(___(__
(_()),__(_())),__(_()))),__(___(__(___(___(__(_()),\
__(_())),__(_()))),__(___(__(_()),__(_())))))))))),\
___(__(_()),__(_())))),__(_()))))),__(___(__(___(__(
___(___(__(_()),__(_())),__(_()))),___(___(__(_()),\
__(_())),__(_())))),__(___(___(__(_()),__(_())),__(_
())))))};printf("%s",____);return(______(_(),_()));}

```
> 2 votes

# Answer
# Pyt, 161 bytes

```
é⎶⁻Đ²ř₊↔Áŕŕá↔ƖǰƇ5!Ś!!ɓąžƩ3*Ḟ533/Ɩ»/⎶Đąµ+ĐąҏҏžΠ-3Ḟ-Ƈ5³ĐðŚƩ-533/Ɩ»²+ƇĐ533/Ɩ»3*⁺ɓƇ84*Ƈ9²3!+Ƈ6⁺ɓƇ9⬠3-Ƈ533/Ɩ»Đ³⇹⁺!‼⁺⁺533/Ɩ»*⁰⁰533/Ɩ»/Ḷ⎶533/Ɩ»/533/Ɩ»³+⇹ŕƇ6Ć533/Ɩ»⁵-Ƈáǰ

```

Try it online!

I'd say just the language itself obfuscates it, but I tried to do this in as much of a roundabout way as possible
> 2 votes

# Answer
# 17, 80 bytes

It isn't much bigger than the normal hello world for 17 due to it using base 17. I have to break rule 3 since the "main" function for 17 is 777, so all 17 programs must contain 7, so I am following the other 2.

```
777{44 $ 5g $ 66 : : $ $ 69 : $
22 4 - $ 52 $ $ 6c $ $ 5f $ 22 3 - $ a $ - @}

```
> 2 votes

# Answer
# Python 3, 85 bytes

Not golfed, but obfuscated.

```
input(('%c'*11)%(9*8,93+8,99+9,9+99,3999//36,4*8,9*9+6,3996//36,4353//38,36*3,5*4*5))

```

Try it online!
> 2 votes

# Answer
# Ruby, 46 bytes

Aims to match all rules, unlike the other Ruby answers that only match 2. Based on @Nemo157's original answer and subsequent improvement suggestions, but uses `succ` *twice* to avoid breaking rule 1.

Note that the TIO link creates a string and compares it to a regex (proving that it matches all the rules) and then `eval`s it, instead of just running the code directly. Running it directly will still work, of course.

```
$><<"Fcjjm Umpjb".gsub(/[a-z]/i){$&.succ.succ}

```

Try it online!

# Ruby, 31 bytes

Same technique, but using tricks with `tr` to make it shorter than the other Ruby answers. (Unfortunately, `tr` causes it to break rule 2.)

```
puts"Fcjjm Umpjb".tr'A-x','C-z'

```

Try it online!
> 2 votes

# Answer
# Help, Wardoq!, 1 byte, Rules #2 and #3

```
l

```

This esolang has a 1-byte solution for most spellings of Hello, World.
> 2 votes

# Answer
## (K+R)eg, 16 bytes

1 byte shorter than the accepted solution (GolfScript).

```
Jgnnq\"Yqtnf(;;'

```

This encodes the string by adding all characters by 2.
> 2 votes

# Answer
## `d`, 10 bytes

Glad that none of the characters appear in the compressed source.

```
,├▌♥♀√╫◙g5

```
> 2 votes

# Answer
# Microsoft Excel, ~~167 166 114 113 77 50~~ 49 chars

The other submission breaks two rules automatically with `CHAR()`, so I thought it would be better to post my own solution.

This is the golfed version, which is arguably obfuscated on its own:

```
=PROPER(BASE(345405,3^3)&"o "&BASE(59*930563,36))

```

Breaks only rule 2 with \[EOR01\]. There are no \[HWLD\] or \[27\] in any of these cells.

Breakthrough: Well, I completely missed the `PROPER()` function when I first wrote this. Lucky for me, the rules want a Proper-cased "Hello World", so I could rely on that to get me convert case for me. No more need to `SUBSTITUTE()` or `TEXT()`!

Breakthrough 2: Wait, I just remembered something my Algorithms class. Everything is a number!

## Obfuscated version, 376 chars

Based on the the above strategy, we can have a little fun with type coercion. The scheme rules are:

* No literals, except 0.
* Use any operator
* Of course I still need `PROPER()` and `BASE()`.

I had to choose different bases to golf it down a bit too.

```
=PROPER(BASE((0=0)+(0=0)&(0=0)+(0=0)+(0=0)&(0=0)+(0=0)&(--(0=0)&0)-(0=0)&(0=0)+(0=0)&(--(0=0)&0)-(0=0)&(--(0=0)&0)-((0=0)+(0=0))&(0=0)+(0=0),(0=0)+(0=0)+(0=0)&(0=0)+(0=0)+(0=0)+(0=0))&" "&BASE((0=0)+(0=0)+(0=0)+(0=0)&(--(0=0)&0)-(0=0)&0&(--(0=0)&0)-((0=0)+(0=0))&(0=0)+(0=0)&(--(0=0)&0)-((0=0)+(0=0))&(0=0)+(0=0)&(0=0)+(0=0)+(0=0),(0=0)+(0=0)+(0=0)&(--(0=0)&0)/((0=0)+(0=0))))

```

## Cheating(?) 39 bytes in UTF-8, 19 chars

No rules broken, but not at all obfuscated.

`=ASC("Ｈｅｌｌｏ Ｗｏｒｌｄ")`

Since `ASC()` converts full to half-width characters.
> 2 votes

# Answer
# AlphaBeta, 64 bytes

```
cccccccaaCLkgDLihhhDLLgggDLddddCLcccccaaaaaCLDLgggDLjggggDLjggDL

```

Try it online!
> 2 votes

# Answer
# Deadfish~, 72 bytes

```
{{i}ddd}iic{iii}dc{i}dddcciiic{{d}ii}ic{{i}d}dddc{d}iiciiicddddddc{d}iic

```

Breaks rule 1. Try it online!

Or if you want a completely valid one (131 bytes):

```
{iiiiiii}iic{ii}iiiiiiiiiciiiiiiicciiic{{i}iiiiiii}iiiiiiic{iiiiiiii}iiiiiiic{{ii}iiii}iiiiiiiiciiic{{ii}iiiii}c{{ii}iiii}iiiiiiiic

```

Try it online!

And just for fun:

```
{iiii  iii}ii   c{   ii}ii  iiiiii iciii  iiiic c    i
i    i c       {  {  i    } i        i   i      i    i  ii
}    i iiiiii  c{ii  i    i iiii}i   i    iiii  ic{{ii }  i  i
i    i }      ii  ii i    i i        i        c i    i     ic
{{ii}  iiiii} c    { {ii}i  i      ii}ii iiiii  i    c

```

Try it online!

Deadfish~ is the master of restricted source.
> 2 votes

# Answer
# Scratch (scratchblocks3 syntax), 52 bytes (22 characters)

```
点击绿旗时
说(将[你好世界]译为(英语 v

```

Breaks no rules.

Thanks for being one of the only programming languages that gets translated to other human languages, Scratch!

In English:

```
when gf clicked
say(translate[你好世界]to(English v

```

This challenge can't be completed in Scratch in English because every program must contain `when gf clicked`, `when green flag clicked`, or `when flag clicked`, all of which break the first two rules.
> 2 votes

# Answer
# Groovy - 50 93 96 Characters

'GdkknVnqkc'.bytes.each{System.out\<\<(char)(it+1)}

Breaks rule 2. I don't see any other option than breaking rule 2, as AFAIK it's necessary to use either `System.out` or `println`, and using `println` will break both rules 1 and 2.

## Edit:

```
s={k,v->for(;v>0;v>>=6)System.out<<(k-(v&63) as byte[])}
s 113,34886441
s 48,16
s 130,509150443

```

Second attempt: much longer, more obfuscated, and hopefully passes all the rules!

### Rule Check:

```
['2','7','H','h','L','l','W','w','D','d'].collect{
    it in ("""s={k,v->for(;v>0;v>>=6)System.out<<(k-(v&63) as byte[])}
    s 113,34886441
    s 48,16
    s 130,509150443""" as List)
}

```
> 1 votes

# Answer
## **BrainFuck (96 char)**

Beside @R. Martinho Fernandes's BrainFuck answer, this is another BF program with 10 less characters

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

```
> 1 votes

# Answer
# Q (40 chars)

Silly answer but it satisfies rule 1 & 2

```
"c"$(+\)(8*9;10+19;6+1;0;3;10-89;55;10+14;3;-6;-8)

```
> 1 votes

# Answer
```
int main()
{printf("%c%c%c%c%c%c%c%c%c%c%c", ('C'+5), ('a'+4), ('i'+3), ('f'+6), ('i'+6), (35-3), ('T'+3), ('j'+5), ('k'+7), ('g'+5), ('f'-2));}

```
> 1 votes

# Answer
## Processing, 189 characters

```
int[]z={104,101,108,108,111,119,111,114,108,100};for(int i=0;i<z.length;i++)if(i==0||i==5)print((char)Character.toUpperCase(z[i]));else if(i==4)print((char)z[i]+" ");else print((char)z[i]);

```

If I'm not mistaken, this program only violates rule number two... unless of course the 'h' in "Character" is ruled as a violation. First post to CodeGolf!

## Ungolfed

```
int[] z = {104, 101, 108, 108, 111, 119, 111, 114, 108, 100};

for (int i = 0; i < z.length; i++)
{
    if (i == 0 || i == 5) print((char) Character.toUpperCase(z[i]));
    else if (i == 4) print((char) z[i] + " ");
    else print((char) z[i]);
}

```
> 1 votes

# Answer
# Python: 66 characters

```
op=""
for i in "Tqxx{,c{~xp":
    op=op+chr(ord(i)-(4*3))
print op

```
> 1 votes

# Answer
# Javascript 54

<sup>(Violates only rule 3)</sup>

`c="c\x6fnst\x72uct\x6f\x72",f=""[c][c],f("a\x6c\x65\x72t(\"\x48\x65\x6c\x6c\x6f \x57\x6f\x72\x6c\x64\")")()`

*Test if any character of rule 1,2 contained*

`/[hlwdeor01]/ig.test('c="c\\x6fnst\\x72uct\\x6f\\x72",f=""[c][c],f("a\\x6c\\x65\\x72t(\\"\\x48\\x65\\x6c\\x6c\\x6f \\x57\\x6f\\x72\\x6c\\x64\\")")()') // false`
> 1 votes

# Answer
# APL (NARS200 dialect), 154 character

```
((⍵⍴⍨∆+⌊√⍵)⊤⌈⍺+○∆×⍺*⍙)\⎕AV[⍙-⍨⍵+(+/⍳∆-⍙-⍺)+,⍵⌽(⍺×⍙),⍙⌽((⍵×⍳⍺)+(⍺⍴⍺+⍺)⊤⌊○(⍺×⍺)+∆*⍙),[÷⍺]((⍵+⍺×⍺)+(⍺⍴⍵-⍨⍺×⍺)⊤⌈(((∆←+/⍳⍺)*⍵+⍙)÷!⍙)-⍺*⍙)-⍙*(⍵-⍙←+/⍳⍵←√⍺)+⍳⍺←4]

```

(However, this outputs `HELLO WORLD`)

One character shorter than marinus' APL approach, and it only uses a single digit, and two (English) letters.

I wrote this originally in Jan 2012, but just searched for 'obfuscated hello world' today :-)
> 1 votes

# Answer
# k4/q (20)

meets all rules

valid as either k4 or q

`"c"$"Qnuux)`x{um"-9f`
> 1 votes

# Answer
# Smalltalk (18 characters):

```
"C`ggjRjmg_"rot:5

```

**Note:** Between the two words, there's a non-printable character (escape - ASCII character 27).

It only breaks rule 2.
> 1 votes

# Answer
## JSFuck - 18511 chars (so small)

```
[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]((![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]+(!![]+[])[+[]]+(![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]((!![]+[])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+!+[]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+!+[]]]+([][[]]+[])[+[]]+([][[]]+[])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(+(!+[]+!+[]+[+!+[]]+[+!+[]]))[(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(+![]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(+![]+[![]]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]]](!+[]+!+[]+!+[]+[+!+[]])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]])()([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]((!![]+[])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+!+[]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+!+[]]]+(!![]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(+(!+[]+!+[]+[+!+[]]+[+!+[]]))[(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(+![]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(+![]+[![]]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]]](!+[]+!+[]+!+[]+[+!+[]])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]])()(([]+[])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+[]])[+[]]+(!+[]+!+[]+[!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]])+[])+(+(+!+[]+[+[]]+[+!+[]]))[(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(+![]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(+![]+[![]]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]]](!+[]+!+[]+[+!+[]])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+!+[]]]+(+(!+[]+!+[]+!+[]+[!+[]+!+[]]))[(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(+![]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(+![]+[![]]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]]](!+[]+!+[]+!+[]+[!+[]+!+[]+!+[]])+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+([][[]]+[])[!+[]+!+[]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]((!![]+[])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+!+[]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+!+[]]]+([][[]]+[])[+[]]+([][[]]+[])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(+(!+[]+!+[]+[+!+[]]+[+!+[]]))[(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(+![]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(+![]+[![]]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]]](!+[]+!+[]+!+[]+[+!+[]])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]])()([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]((!![]+[])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+!+[]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+!+[]]]+(!![]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(+(!+[]+!+[]+[+!+[]]+[+!+[]]))[(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(+![]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(+![]+[![]]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]]](!+[]+!+[]+!+[]+[+!+[]])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]])()(([]+[])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+[]])[+[]]+(!+[]+!+[]+[!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]])+[])+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]])()

```
> 1 votes

# Answer
# VBScript, 58 Bytes

Only breaks rule 2:

```
msgbox unescape("%48e%6C%6Co%"&19+1&"%5"&(6+1)&"or%6C%64")

```
> 1 votes

# Answer
## T-SQL, 75

```
PRINT RTRIM(0x48656C6C6F+CAST(CAST(35559904013411+1AS BIGINT)AS BINARY(6)))

```

Try the SELECT version in SQL Server 2008 here.

This code thoroughly violates rule #2. It uses hex ASCII values implicitly cast into a varchar type to adhere to rule #1. I had to use the decimal representation of the hex number representing the last six characters to get around rule #3.
> 1 votes

# Answer
## TinyMUSH, 23

This entry violates rule #2.

```
\encrypt(Fcjjm}Umpjb,")

```
> 1 votes

# Answer
# Pip, 49 bytes

**(Not officially competing, since language is newer than question.)**

Follows all three rules.

```
C[--t*--tt+3Jiy:9*J,3yx:#3X3t*4++86xx+3y(TBt)@<3]

```

The basic strategy is generating a list of all the character codes and converting them with `C`.

* `--t*--t`: No undefined behavior here! Subexpressions are evaluated left to right, so this is equivalent to `9*8`, or **72**.
* `t+3Ji`: Since we decremented `t` in the previous step, `t+3` is `11`. Numbers are strings and strings are numbers in Pip, so we then join the characters on `i` (preinitialized to `0`): **101**.
* `y:9*J,3`: Unary `,` creates a range, equivalent to `[0 1 2]`. `J` joins it into `012`. `9*12` = **108**. Store it in `y` for future use.
* Repeat `y`.
* `x:#3X3`: `#` is the unary length operator, and `X` is string repetition, so this boils down to `(length of "3") repeated 3 times`, or **111**. Store it in `x` because we'll use it twice.
* `t*4`: **32**.
* `++86`: It's perfectly legal to increment literal values in Pip (though the number itself doesn't change). If you use the `-w` flag, it will give you a warning, though. **87**.
* `x` from earlier.
* `x+3`: **114**.
* `y` from earlier.
* `(TBt)@<3`: `TB` converts to a specified base when given two arguments; when given one, as here, it converts to binary. So we get 8<sub>2</sub> = `1000`; then we slice the first three characters, for **100**.

`C` applies memberwise to the list, resulting in a list of single-character strings. By default, Pip outputs lists by concatenating their items together without delimiters; so when this expression is auto-printed at the end of the program, the result is... `Hello World`.
> 1 votes

# Answer
```
www = ~[];

www = {
  WHAKWHAKWHAK:++www,
  comcomcomcom:(![] + "")[www],
  WHAKWHAKcom:++www,
  comWHAKcomWHAK:(![] + "")[www],
  WHAKcomWHAK:++www,
  comWHAKcomcom:({} + "")[www],
  comcomWHAKcom:(www[www] + "")[www],
  WHAKcomcom:++www,
  comcomcomWHAK:(!"" + "")[www],
  comWHAKWHAK:++www,
  comWHAKcom:++www,
  comcomWHAKWHAK:({} + "")[www],
  comcomWHAK:++www,
  comcomcom:++www,
  comWHAKWHAKWHAK:++www,
  comWHAKWHAKcom:++www
};

www.comWHAK = (www.comWHAK = www + "")[www.comWHAKcom] + (www.WHAKcom = www.comWHAK[www.WHAKWHAKcom]) + (www.comcom = (www.com + "")[www.WHAKWHAKcom]) + (!www + "")[www.WHAKcomcom] + (www.WHAKWHAK = www.comWHAK[www.comcomWHAK]) + (www.com = (!"" + "")[www.WHAKWHAKcom]) + (www.WHAK = (!"" + "")[www.WHAKcomWHAK]) + www.comWHAK[www.comWHAKcom] + www.WHAKWHAK + www.WHAKcom + www.com;

www.comcom = www.com + (!"" + "")[www.WHAKcomcom] + www.WHAKWHAK + www.WHAK + www.com + www.comcom;

www.com = www.WHAKWHAKWHAK[www.comWHAK][www.comWHAK];

www.com(www.com(www.comcom + '"' + www.comcomWHAKcom + www.WHAKcom + www.comcomWHAKWHAK + www.WHAK + "\\" + www.WHAKWHAKcom + www.comWHAKcom + www.comWHAKcom + www.comcomcomWHAK + "\\" + www.WHAKWHAKcom + www.comWHAKcom + www.comcomWHAK + www.WHAKWHAK + ".\\" + www.WHAKWHAKcom + www.comcomWHAK + www.comcomcom + "\\" + www.WHAKWHAKcom + www.comcomWHAK + www.WHAKcomWHAK + "\\" + www.WHAKWHAKcom + www.comWHAKcom + www.WHAKWHAKcom + www.WHAKWHAK + www.comcomcomWHAK + "('\\" + www.WHAKWHAKcom + www.WHAKWHAKcom + www.WHAKWHAKWHAK + www.comcomcomWHAK + (![] + "")[www.WHAKcomWHAK] + (![] + "")[www.WHAKcomWHAK] + www.WHAKcom + "\\" + www.comWHAKWHAK + www.WHAKWHAKWHAK + "\\" + www.WHAKWHAKcom + www.WHAKcomWHAK + www.comcomcom + www.WHAKcom + "\\" + www.WHAKWHAKcom + www.comcomWHAK + www.WHAKcomWHAK + (![] + "")[www.WHAKcomWHAK] + www.comcomWHAKcom + "!');" + '"')())();
```
> 1 votes

# Answer
This little **BIG** diddy (JavaScript) clocks in at 27KB just to do simple `document.write("Hello World!");`

```
[][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]][([][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]] + [])[!+[] + !+[] + !+[]] + (!![] + [][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]])[+!+[] + [ +[] ]] + ([][[]] + [])[+!+[]] + (![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[+!+[]] + ([][[]] + [])[+[]] + ([][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+[]] + (!![] + [][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]])[+!+[] + [ +[] ]] + (!![] + [])[+!+[]]]((!![] + [])[+!+[]] + ([] + [])[(![] + [])[+[]] + (!![] + [][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]])[+!+[] + [ +[] ]] + ([][[]] + [])[+!+[]] + (!![] + [])[+[]] + ([][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]] + [])[!+[] + !+[] + !+[]] + (!![] + [][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]])[+!+[] + [ +[] ]] + (!![] + [])[+!+[]]]()[+!+[] + [ +!+[] ]] + [][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]][([][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]] + [])[!+[] + !+[] + !+[]] + (!![] + [][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]])[+!+[] + [ +[] ]] + ([][[]] + [])[+!+[]] + (![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[+!+[]] + ([][[]] + [])[+[]] + ([][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+[]] + (!![] + [][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]])[+!+[] + [ +[] ]] + (!![] + [])[+!+[]]]((!![] + [])[+!+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+[]] + ([][[]] + [])[+[]] + (!![] + [])[+!+[]] + ([][[]] + [])[+!+[]] + (+[ ![] ] + [][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]])[+!+[] + [ +!+[] ]] + ([][[]] + [])[+[]] + ([][[]] + [])[+!+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (![] + [])[!+[] + !+[] + !+[]] + ([][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]] + [])[!+[] + !+[] + !+[]] + (![] + [])[+!+[]] + (+(!+[] + !+[] + [ +!+[] ] + [ +!+[] ]))[(!![] + [])[+[]] + (!![] + [][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]])[+!+[] + [ +[] ]] + (+[] + ([] + [])[([][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]] + [])[!+[] + !+[] + !+[]] + (!![] + [][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]])[+!+[] + [ +[] ]] + ([][[]] + [])[+!+[]] + (![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[+!+[]] + ([][[]] + [])[+[]] + ([][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+[]] + (!![] + [][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]])[+!+[] + [ +[] ]] + (!![] + [])[+!+[]]])[+!+[] + [ +[] ]] + (!![] + [])[+[]] + (!![] + [])[+!+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + ([][[]] + [])[+!+[]] + (![] + [ +[] ] + ([] + [])[([][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]] + [])[!+[] + !+[] + !+[]] + (!![] + [][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]])[+!+[] + [ +[] ]] + ([][[]] + [])[+!+[]] + (![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[+!+[]] + ([][[]] + [])[+[]] + ([][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+[]] + (!![] + [][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]])[+!+[] + [ +[] ]] + (!![] + [])[+!+[]]])[!+[] + !+[] + [ +[] ]]](!+[] + !+[] + !+[] + [ +!+[] ])[+!+[]] + (!![] + [])[!+[] + !+[] + !+[]])()([][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]][([][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]] + [])[!+[] + !+[] + !+[]] + (!![] + [][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]])[+!+[] + [ +[] ]] + ([][[]] + [])[+!+[]] + (![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[+!+[]] + ([][[]] + [])[+[]] + ([][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+[]] + (!![] + [][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]])[+!+[] + [ +[] ]] + (!![] + [])[+!+[]]]((!![] + [])[+!+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+[]] + ([][[]] + [])[+[]] + (!![] + [])[+!+[]] + ([][[]] + [])[+!+[]] + (+[ ![] ] + [][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]])[+!+[] + [ +!+[] ]] + (!![] + [])[!+[] + !+[] + !+[]] + (![] + [])[!+[] + !+[] + !+[]] + ([][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]] + [])[!+[] + !+[] + !+[]] + (![] + [])[+!+[]] + (+(!+[] + !+[] + [ +!+[] ] + [ +!+[] ]))[(!![] + [])[+[]] + (!![] + [][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]])[+!+[] + [ +[] ]] + (+[] + ([] + [])[([][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]] + [])[!+[] + !+[] + !+[]] + (!![] + [][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]])[+!+[] + [ +[] ]] + ([][[]] + [])[+!+[]] + (![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[+!+[]] + ([][[]] + [])[+[]] + ([][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+[]] + (!![] + [][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]])[+!+[] + [ +[] ]] + (!![] + [])[+!+[]]])[+!+[] + [ +[] ]] + (!![] + [])[+[]] + (!![] + [])[+!+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + ([][[]] + [])[+!+[]] + (![] + [ +[] ] + ([] + [])[([][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]] + [])[!+[] + !+[] + !+[]] + (!![] + [][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]])[+!+[] + [ +[] ]] + ([][[]] + [])[+!+[]] + (![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[+!+[]] + ([][[]] + [])[+[]] + ([][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+[]] + (!![] + [][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]])[+!+[] + [ +[] ]] + (!![] + [])[+!+[]]])[!+[] + !+[] + [ +[] ]]](!+[] + !+[] + !+[] + [ +!+[] ])[+!+[]] + (!![] + [])[!+[] + !+[] + !+[]])()([][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]])[!+[] + !+[] + [ +[] ]] + (!+[] + !+[] + [ !+[] + !+[] + !+[] + !+[] + !+[] + !+[] + !+[] ]) + []) + [][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]][([][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]] + [])[!+[] + !+[] + !+[]] + (!![] + [][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]])[+!+[] + [ +[] ]] + ([][[]] + [])[+!+[]] + (![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[+!+[]] + ([][[]] + [])[+[]] + ([][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+[]] + (!![] + [][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]])[+!+[] + [ +[] ]] + (!![] + [])[+!+[]]]((!![] + [])[+!+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+[]] + ([][[]] + [])[+[]] + (!![] + [])[+!+[]] + ([][[]] + [])[+!+[]] + (+[ ![] ] + [][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]])[+!+[] + [ +!+[] ]] + ([][[]] + [])[+[]] + ([][[]] + [])[+!+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (![] + [])[!+[] + !+[] + !+[]] + ([][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]] + [])[!+[] + !+[] + !+[]] + (![] + [])[+!+[]] + (+(!+[] + !+[] + [ +!+[] ] + [ +!+[] ]))[(!![] + [])[+[]] + (!![] + [][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]])[+!+[] + [ +[] ]] + (+[] + ([] + [])[([][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]] + [])[!+[] + !+[] + !+[]] + (!![] + [][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]])[+!+[] + [ +[] ]] + ([][[]] + [])[+!+[]] + (![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[+!+[]] + ([][[]] + [])[+[]] + ([][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+[]] + (!![] + [][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]])[+!+[] + [ +[] ]] + (!![] + [])[+!+[]]])[+!+[] + [ +[] ]] + (!![] + [])[+[]] + (!![] + [])[+!+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + ([][[]] + [])[+!+[]] + (![] + [ +[] ] + ([] + [])[([][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]] + [])[!+[] + !+[] + !+[]] + (!![] + [][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]])[+!+[] + [ +[] ]] + ([][[]] + [])[+!+[]] + (![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[+!+[]] + ([][[]] + [])[+[]] + ([][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+[]] + (!![] + [][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]])[+!+[] + [ +[] ]] + (!![] + [])[+!+[]]])[!+[] + !+[] + [ +[] ]]](!+[] + !+[] + !+[] + [ +!+[] ])[+!+[]] + (!![] + [])[!+[] + !+[] + !+[]])()([][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]][([][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]] + [])[!+[] + !+[] + !+[]] + (!![] + [][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]])[+!+[] + [ +[] ]] + ([][[]] + [])[+!+[]] + (![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[+!+[]] + ([][[]] + [])[+[]] + ([][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+[]] + (!![] + [][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]])[+!+[] + [ +[] ]] + (!![] + [])[+!+[]]]((!![] + [])[+!+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+[]] + ([][[]] + [])[+[]] + (!![] + [])[+!+[]] + ([][[]] + [])[+!+[]] + (+[ ![] ] + [][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]])[+!+[] + [ +!+[] ]] + (!![] + [])[!+[] + !+[] + !+[]] + (![] + [])[!+[] + !+[] + !+[]] + ([][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]] + [])[!+[] + !+[] + !+[]] + (![] + [])[+!+[]] + (+(!+[] + !+[] + [ +!+[] ] + [ +!+[] ]))[(!![] + [])[+[]] + (!![] + [][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]])[+!+[] + [ +[] ]] + (+[] + ([] + [])[([][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]] + [])[!+[] + !+[] + !+[]] + (!![] + [][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]])[+!+[] + [ +[] ]] + ([][[]] + [])[+!+[]] + (![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[+!+[]] + ([][[]] + [])[+[]] + ([][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+[]] + (!![] + [][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]])[+!+[] + [ +[] ]] + (!![] + [])[+!+[]]])[+!+[] + [ +[] ]] + (!![] + [])[+[]] + (!![] + [])[+!+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + ([][[]] + [])[+!+[]] + (![] + [ +[] ] + ([] + [])[([][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]] + [])[!+[] + !+[] + !+[]] + (!![] + [][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]])[+!+[] + [ +[] ]] + ([][[]] + [])[+!+[]] + (![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[+!+[]] + ([][[]] + [])[+[]] + ([][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+[]] + (!![] + [][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]])[+!+[] + [ +[] ]] + (!![] + [])[+!+[]]])[!+[] + !+[] + [ +[] ]]](!+[] + !+[] + !+[] + [ +!+[] ])[+!+[]] + (!![] + [])[!+[] + !+[] + !+[]])()([][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]])[!+[] + !+[] + [ +[] ]] + (!+[] + !+[] + !+[] + !+[] + [ !+[] + !+[] + !+[] + !+[] + !+[] + !+[] + !+[] + !+[] ]) + []) + [][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]][([][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]] + [])[!+[] + !+[] + !+[]] + (!![] + [][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]])[+!+[] + [ +[] ]] + ([][[]] + [])[+!+[]] + (![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[+!+[]] + ([][[]] + [])[+[]] + ([][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+[]] + (!![] + [][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]])[+!+[] + [ +[] ]] + (!![] + [])[+!+[]]]((!![] + [])[+!+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+[]] + ([][[]] + [])[+[]] + (!![] + [])[+!+[]] + ([][[]] + [])[+!+[]] + (+[ ![] ] + [][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]])[+!+[] + [ +!+[] ]] + ([][[]] + [])[+[]] + ([][[]] + [])[+!+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (![] + [])[!+[] + !+[] + !+[]] + ([][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]] + [])[!+[] + !+[] + !+[]] + (![] + [])[+!+[]] + (+(!+[] + !+[] + [ +!+[] ] + [ +!+[] ]))[(!![] + [])[+[]] + (!![] + [][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]])[+!+[] + [ +[] ]] + (+[] + ([] + [])[([][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]] + [])[!+[] + !+[] + !+[]] + (!![] + [][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]])[+!+[] + [ +[] ]] + ([][[]] + [])[+!+[]] + (![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[+!+[]] + ([][[]] + [])[+[]] + ([][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+[]] + (!![] + [][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]])[+!+[] + [ +[] ]] + (!![] + [])[+!+[]]])[+!+[] + [ +[] ]] + (!![] + [])[+[]] + (!![] + [])[+!+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + ([][[]] + [])[+!+[]] + (![] + [ +[] ] + ([] + [])[([][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]] + [])[!+[] + !+[] + !+[]] + (!![] + [][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]])[+!+[] + [ +[] ]] + ([][[]] + [])[+!+[]] + (![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[+!+[]] + ([][[]] + [])[+[]] + ([][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+[]] + (!![] + [][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]])[+!+[] + [ +[] ]] + (!![] + [])[+!+[]]])[!+[] + !+[] + [ +[] ]]](!+[] + !+[] + !+[] + [ +!+[] ])[+!+[]] + (!![] + [])[!+[] + !+[] + !+[]])()([][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]][([][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]] + [])[!+[] + !+[] + !+[]] + (!![] + [][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]])[+!+[] + [ +[] ]] + ([][[]] + [])[+!+[]] + (![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[+!+[]] + ([][[]] + [])[+[]] + ([][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+[]] + (!![] + [][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]])[+!+[] + [ +[] ]] + (!![] + [])[+!+[]]]((!![] + [])[+!+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+[]] + ([][[]] + [])[+[]] + (!![] + [])[+!+[]] + ([][[]] + [])[+!+[]] + (+[ ![] ] + [][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]])[+!+[] + [ +!+[] ]] + (!![] + [])[!+[] + !+[] + !+[]] + (![] + [])[!+[] + !+[] + !+[]] + ([][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]] + [])[!+[] + !+[] + !+[]] + (![] + [])[+!+[]] + (+(!+[] + !+[] + [ +!+[] ] + [ +!+[] ]))[(!![] + [])[+[]] + (!![] + [][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]])[+!+[] + [ +[] ]] + (+[] + ([] + [])[([][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]] + [])[!+[] + !+[] + !+[]] + (!![] + [][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]])[+!+[] + [ +[] ]] + ([][[]] + [])[+!+[]] + (![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[+!+[]] + ([][[]] + [])[+[]] + ([][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+[]] + (!![] + [][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]])[+!+[] + [ +[] ]] + (!![] + [])[+!+[]]])[+!+[] + [ +[] ]] + (!![] + [])[+[]] + (!![] + [])[+!+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + ([][[]] + [])[+!+[]] + (![] + [ +[] ] + ([] + [])[([][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]] + [])[!+[] + !+[] + !+[]] + (!![] + [][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]])[+!+[] + [ +[] ]] + ([][[]] + [])[+!+[]] + (![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[+!+[]] + ([][[]] + [])[+[]] + ([][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+[]] + (!![] + [][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]])[+!+[] + [ +[] ]] + (!![] + [])[+!+[]]])[!+[] + !+[] + [ +[] ]]](!+[] + !+[] + !+[] + [ +!+[] ])[+!+[]] + (!![] + [])[!+[] + !+[] + !+[]])()([][(![] + [])[+[]] + ([ ![] ] + [][[]])[+!+[] + [ +[] ]] + (![] + [])[!+[] + !+[]] + (!![] + [])[+[]] + (!![] + [])[!+[] + !+[] + !+[]] + (!![] + [])[+!+[]]])[!+[] + !+[] + [ +[] ]] + (!+[] + !+[] + [ !+[] + !+[] + !+[] + !+[] + !+[] + !+[] + !+[] ]) + []))();

x = ~[];

x = {
  yyy:++x,
  zzzz:(![] + "")[x],
  yyz:++x,
  zyzy:(![] + "")[x],
  yzy:++x,
  zyzz:({} + "")[x],
  zzyz:(x[x] + "")[x],
  yzz:++x,
  zzzy:(!"" + "")[x],
  zyy:++x,
  zyz:++x,
  zzyy:({} + "")[x],
  zzy:++x,
  zzz:++x,
  zyyy:++x,
  zyyz:++x
};

x.zy = (x.zy = x + "")[x.zyz] + (x.yz = x.zy[x.yyz]) + (x.zz = (x.z + "")[x.yyz]) + (!x + "")[x.yzz] + (x.yy = x.zy[x.zzy]) + (x.z = (!"" + "")[x.yyz]) + (x.y = (!"" + "")[x.yzy]) + x.zy[x.zyz] + x.yy + x.yz + x.z;

x.zz = x.z + (!"" + "")[x.yzz] + x.yy + x.y + x.z + x.zz;

x.z = x.yyy[x.zy][x.zy];

x.z(x.z(x.zz + '"' + x.zzyz + x.yz + x.zzyy + x.y + "\\" + x.yyz + x.zyz + x.zyz + x.zzzy + "\\" + x.yyz + x.zyz + x.zzy + x.yy + ".\\" + x.yyz + x.zzy + x.zzz + "\\" + x.yyz + x.zzy + x.yzy + "\\" + x.yyz + x.zyz + x.yyz + x.yy + x.zzzy + "(\\" + x.yyz + x.zzy + x.yzy + "+'" + x.zzzy + (![] + "")[x.yzy] + (![] + "")[x.yzy] + x.yz + "\\" + x.zyy + x.yyy + "\\" + x.yyz + x.yzy + x.zzz + x.yz + "\\" + x.yyz + x.zzy + x.yzy + (![] + "")[x.yzy] + x.zzyz + "!')" + '"')())();
```
> 1 votes

# Answer
# 05AB1E, 5 bytes (non-competing)

Breaks none of the rules, code:

```
”Ÿ™‚ï

```

Uses CP-1252 encoding. Try it online!
> 1 votes

# Answer
# Tellurium, 16 bytes

```
µUryyb Jbeyq~r^

```

This basically encodes "Uryyb Jbeyq" with ROT-13 (Hello World) and displays the result.
> 1 votes

# Answer
# Python 2, 39 chars

```
print'\x48e\x6c\x6co %cor\x6c\x64'%-~86

```

Breaks rule `3-1`.

## Ungolfed versions

```
print '%ce%c%co %cor%c%c' % (0x48, 0x6c, 0x6c, 0x56 + 0x1, 0x6c, 0x64)

```

```
print '%ce%c%co %cor%c%c' % (68 + 4, 108, 108, 86 + 1, 108, 100)
```

## Normal version (-`2`) (18 chars)

```
print'Hello World'

```

## Ungolfed

```
print 'Hello World'

```
> 1 votes

# Answer
# Vim, 31 keystrokes

```
ia<C-v><C-v>92<esc>22<C-a>SU<C-o>@"yyb Jb<C-v>x65yq<esc>g?g

```

This was really fun! I'll write an explanation a little bit later.
> 1 votes

# Answer
## Perl 6, 86 bytes

I chose to break the second rule.

```
my &a={$*IN.gist.substr($_,1)};say a(4)~"e"~a(8)~a(8)~"o "~a(36-9).uc~"or"~a(8)~a(8-1)

```

Calling `gist` on `$*IN` (neither of which has any forbidden characters) gives this string:

```
IO::Handle<IO::Special.new(what => "<STDIN>")>(opened, at octet 0)

```

So I pieced together parts of this string to get the desired message. There is no capital W, but luckily `uc` doesn't have any forbidden characters either.
> 1 votes

# Answer
# Pushy, 16 bytes

Note that this solution is non-competing as the language postdates the challenge.

```
`Ifmmp!Xpsme`Kt"

```

**Try it online!** Here's the basic rundown:

```
`Ifmmp!Xpsme`     \ Push these character codes to the stack
             Kt   \ Subtract one from all
               "  \ Print as string

```

The main string is just `Hello, World!`, with all its characters moved 1 space up the ASCII table - hence why we subtract 1 from all the character codes.

This solution satisfies the first and third criteria - it would even match the second, if not for that single `e` at the end of the string.
> 1 votes

# Answer
## AWK, 164 bytes

```
#!/bin/awk -f
BEGIN{n++
system("awk 'printf(\"%c",$n)}'<<<\""69+3"\n"98+3"\n"36*3"\n"36*3"\n"36*3+3"\n"35-3"\n"84+3"\n"36*3+3"\n"36*3+6"\n"36*3"\n"94+6"\n"6+4"\"")}

```

Usage: Place the code in a file, `FILE`, and set the 'executable-bit' to true. Sending a single string input will print `Hello World`. Multi-line input results in the string being printed once for each line.

Example:

```
File <<< "42"

```

Since a program was requested, I assume the code is running on some UNIX-like environment with the `awk` executable available at `/bin/awk`. I further assume that `/bin` is in your path.

Not sure if this really counts as just an `AWK` program, since it is using the `system` command, but at least the `system` call is calling `AWK`. :)

I do violate the second rule, simply because I couldn't come up with a way around using the `printf` command. :(
> 1 votes

# Answer
# \>\<\> (Fish), 39 bytes

```
'Tqxx{,c{~xp'bv
ii*p:?!;{c-þi+>aa*b+b

```

I wanted to add a shorter solution that does not violate any rules. First line adds each letter of the encoded 'Hello World' and initializes the 'counter'.

The second line loops, outputting the next letter until counter hits 0. The thorn is overwritten with 'o', \>\<\>'s output instruction once every loop, but that doesn't hurt anybody.

To get around the inability to use '1' while saving characters, I used the operation 'i', which tries to read stdin and pushes '-1' to the stack when it finds nothing there.
> 1 votes

# Answer
# PHP, ~~36~~ 34 bytes

not the shortest PHP answer, but unique enough for a post.

```
H<?=hhhh3lll^zsspw_gz^wwwwdddd,ld;

```

and

```
H<?=hhhh3lll^zsspw_gz^wwwwdddd?>ld

```

violate rule #1.

<sup>There are of course less "violent" operand combinations; but if you must sin, make it worth it!</sup>

**other versions:**

```
for(;$c="Fkbba.Ya|bj"[$i++];)echo$c^_^Q;    # 40 bytes, violates rules #1 and  #2
for(;$c="Fkbba.Ya|bj"[$i++];)print$c^_^Q;   # 41 bytes, violates rule #2
<?="Fkbba.Ya|bj"^___________^QQQQQQQQQQQ;   # 41 bytes, no violation
<?=____YzffR__^TQQQF3nnQQQ^Ckbbpi_gqbj;     # 39 bytes, no violation
H<?="kbba.Ya|"^________^QQQQQQQQ,ld;        # 36 bytes, violates rule #1

```
> 1 votes

# Answer
# Octave, 103 bytes

This one adheres to all three rules and should be fairly obfuscated.

Strings can be created in Octave by concatenating a vector with a string. So, why not concatenate it with the string `'PPCG'`? I added `...` so that it's possible to read it without scrolling to the side. It can be removed along with the line break.

```
['PPCG',3336,3848,5384,6664,584,5896,584,869,364,364,3848,364,4463,544,343,343, ...
3336,4463,3954,3948,356]

ans = Hello World

```

I'll post an explanation for this in one week. Until then, try figuring it out by yourself. Note, this doesn't work on any of the online interpreters I tried, but it works fine on GNU Octave 4.2.0.
> 1 votes

# Answer
**Brainf\***** (106 characters)

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

```
> 1 votes

# Answer
# Data URI 28 bytes

`data:;base64,SGVsbG8gV29ybGQK`

Copy and paste into the browser url bar
> 1 votes

# Answer
# Befunge-93, 24 bytes

```
9"mu{x`)xuunQ">9#,-#$:_@

```

Try it online!

Violates no rules. Simply pushes the text shifted by 9 and subtracts 9 from each character before printing.
> 1 votes

# Answer
# Japt, 9 bytes

```
`HÁM WŽld

```

Try it online!

The built-in shoco compressor just did the perfect job to remove `eor`.

Alternatively, slightly less obvious:

## 16 bytes

```
"Ifmmp!Xpsme"c_É

```

Try it online!

`c` maps over the charcodes, and  is a decrement function. `É` is a shorthand for `-1`.
> 1 votes

# Answer
# Z80Golf, 21 bytes

Contains unprintable bytes, so here's `xxd` (breaks rule 1):

```
00000000: 0063 6b71 6e56 1f6e 6b6b 6447 2e0b 7e3c  .ckqnV.nkkdG..~<
00000010: ff2d 20fa 76                             .- .v

```

Try it online!

```
    nop
    ld h, e ; 'Hello World' backwards if you add 1 to each byte
    ld l, e ; execution falls through
    ld (hl), c
    ld l, (hl)
    ld d, (hl)
    rra
    ld l, (hl)
    ld l, e
    ld l, e
    ld h, h
    ld b, a
    ld l, loop - 3
loop:
    ld a, (hl)
    inc a
    rst $38
    dec l
    jr nz, loop
    halt

```
> 1 votes

# Answer
# DOS `.com` executable: 31 bytes

```
BE 13 01 AC B4 02 34 FF 88 C2 75 03 80 C4 4A CD
21 EB F0 B7 9A 93 93 90 DF A8 90 8D 93 9B FF

```

Stores the string byte-inverted, outputs using DOS syscalls. Contains none of the banned characters.

source:

```
.code16
.org 0x100
start:
 movw $str, %si
l:
 lodsb
 mov $0x02, %ah
 xor $0xff, %al
 mov %al, %dl
 jnz 1f
 add $0x4a, %ah
1: int $0x21
 jmp l
str:
.ascii "\xb7\x9a\x93\x93\x90\xdf\xa8\x90\x8d\x93\x9b\xff"

```
> 1 votes

# Answer
# Gol\>\<\>, 21 bytes

```
"mu{x`)xuunQ"T:Z;9-ot

```

This is a program that JoKing made, golfing the heck out of it.

Try it online!

**Old version, 37 bytes**

```
"Fcjjm"b3+s"Umpjb"c&rT&M:&33-)QPPot|;

```

This is a really simple, not very creative way of doing this, all it does is just encode everything 2 below their actual ascii encoding, the hardest part is not using 'l', which in gol\>\<\> is the length of the stack!

Try it online!
> 1 votes

# Answer
# Runic Enchantments, 39 bytes

```
\>`''`
\+kw+kwb8qn;' 83*´34 f-;@

```

Try it online!

As seen in Notepad++ to better distinguish the non-printing bytes:

Violates only rule 1. I had fun computing the first line (a sequence of raw byte values). Alternatively I could have violated rule 2, but I felt that doing so was less obfuscated. There's four different methods used in the 39 byte solution for generating integer values, making it hard to figure out what's going on (compared to just some mathematical operators in the 17 byte solution).

39 byte solution *must* occupy two lines.
> 1 votes

# Answer
# naz, 80 bytes

```
9a8m1o9a9a8a3a1o6a1a1o1o3a1o0m9a4m8a1o9s3s1o3m9s1o9a9a6a1o3a1o6s1o8s1o0m4a8m1a1o

```

Breaks rule 2 only.
> 1 votes

# Answer
# Pxem, 0 bytes (content) + ~~41~~ 36 bytes (filename).

Inspired by @MD FX.

* Filename (escaped): `ayIfmmp!Xpsme?.z\001.-.t.v.m.v.c?.a.s.p`
* Content: empty

## What it does

* Push next characters
* Decrement each of them
* Output them finally

Try it online!

## Previously

41 bytes
> 1 votes

# Answer
# TeX, 39 bytes

Meets conditions 1 and 2:

```
^^48^^%^^,^^,^^/ ^^57^^/^^2^^,^^$\by^^%

```

Try it online!
> 1 votes

# Answer
# K (ngn/k), 22 bytes

```
{`c$-4+"Lipps${svph%"}

```

Try it online!

Quite straightforward.
> 1 votes

# Answer
# (,) ~~352~~ ~~304~~ 294 Chars or \\$294\log\_{256}(3)\approx58.25\\$ Bytes

```
(()()(),()()()()()()())((),(()()())()()())((()),(())(())(()))(((())),((()))((()))(()))(,,,(((())))()())(()(),(((())))((()))())(,,,(()()))(,,,(()())(()()()),(),,()())(,,,(()())(()))(,,,((()))()())(,,,(((())))(())(()()()))(,,,(()())(()))(,,,(()())(())()()())(,,,(()())(()()()))(,,,(((())))((())))

```

This is shorter than my normal hello world program (because we don't have ! or ,). Also, finally under 300 chars!
TIO
> 1 votes

# Answer
## dc 48

```
8 9*P101P108P108P111P4 8*P81 6+P111P114P108P100P

```

One way how to execute:

```
dc<<<"8 9*P101P108P108P111P4 8*P81 6+P111P114P108P100P"

```

The solution conforms to the first and the third rule.
> 0 votes

# Answer
C code:

```
#include
main(){int x=0,y[14],*z=&y;*(z++)=0x48;*(z++)=y[x++]+0x1D;*(z++)=y[x++]+0x07;*(z++)=y[x++]+0x00;*(z++)=y[x++]+0x03;*(z++)=y[x++]-0x43;*(z++)=y[x++]-0x0C;*(z++)=y[x++]+0x57;*(z++)=y[x++]-0x08;*(z++)=y[x++]+0x03;*(z++)=y[x++]-0x06;*(z++)=y[x++]-0x08;*(z++)=y[x++]-0x43;*(z++)=y[x]-0x21;x=*(--z);while(y[x]!=NULL)putchar(y[x++]);}

```

Output :

```
Hello, world!

```
> 0 votes

# Answer
**Ruby** (42 chars, rules I & III)

```
puts"\x48e\x6c\x6co #{'V'.succ}or\x6c\x64"

```
> 0 votes

# Answer
# C#, 143 bytes

First i put in an array the decimal values for each letter in text

Hello World.

Then in each world i call (char)decimalValue

Example

```
(char)111

```

returns **o** in C#.

```
namespace N{class P{static void Main(){int[] i={13*8,69,36*3,36*3,111,119,111,114,19*4,68};foreach(int v in i)System.Console.Write((char)v);}}}

```
> 0 votes

# Answer
```
void main(){
int a[100]={4,1,8,8,11,-68,19,11,14,8,0,0,0};
for(;a[13]<a[4];a[13]++)
{
    printf("%c",100+a[a[13]]);
}

}

```

Funny,isn't it?
> 0 votes

# Answer
## XeTeX

Compile with `xetex`, output is in generated PDF. Of course, this still breaks some of the rules (still uses forbidden digits) and could be obfuscated and compacted a lot more, but I am tired and have to go to bed. Well, maybe you like it anyway :-)

```
\let~\def
\toksdef\|0
\let\ea\expandafter
~\>{\uppercase{\|\ea{\the\|.}}}
~\.{\uccode`.\numexpr32+}
~\u#1{\|{}\ea\v\number`#1 \^^J{\iffalse}..\fi\relax}
~\v1#1#2#3#4{\.#1#2\>\.#3#4\>\ea\v\number`}
\u{㛵䔌䘣䘾䔄}\the\|
\bye

```
> 0 votes

# Answer
## Brainfuck, 94 Characters

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

```

Obvious, being BF it breaks none of the rules.

If I lowercase the output it's only 86, but I don't think that's allowed.

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

```

The first one is a balanced nested loop generator, the second is a slipping (or sliding) loop generator

NB: The newlines in the code are for this message, they should be removed for running or counting.
> 0 votes

# Answer
# PHP

This is a very cheap trick (30 bytes):

```
<?=cONSTAnTINO_^'+*"?;a9;;"+'

```

Not much to see here.

Rules broken: none (the O.P. said `o`, not `O`)

---

Going really cheap on this one (25 bytes):

Create a file called `cONSTAnTINO_` and run:

```
<?=__FILE__^'+*"?;a9;;"+'

```

There's nothing saying about file names being forbidden.

---

But if we want to go REALLY dirty, just do (10 bytes):

```
<?=__DIR__

```

And run a file from a directory called `Hello World`.

Enough of being cheap!

Here is another attempt (97 bytes):

```
<?foreach([144,405,650,867,1114,389,1224,1783,2060,2169,2210]as$k=>$v)echo chr($v/(($k+1*2)+$k));

```

Yeah, pretty huge, right?

Sadly, it breaks 2 rules.
> 0 votes

# Answer
# Cardinal, ~~73~~ ~~71~~ 68 chars

```
>----~n*,n*,n*,,n*,n*v
- xx  Nj kr rx  u  &],
\-%xx,*u,*u,*u,*u ,*u<

```

My previous, less obfuscated version (73 chars) for better understanding:

```
>--- ~n*,n*,n*,,n*,n*,n*,n*,n*,n*,n*,
\---%xN  k  r   u  &  ]  u  x  r  j

```

Start at %, first move to the left, decrement the active value by 3 (---). () reflects the IP upwards, (\>) changes the direction to the right. Then decrement by 3 more (---), swap active and inactive value (~). Then read in the char below (n), store it as active value, add the inactive value to it (\*) and output the result (,)... rinse and repeat.

‘n’ places the active value of the ip above the arc of the character n, u puts it below the arc of the character u, then picks up the value of the character above (u) or below (n) the “open” side of the letter and stores the value as new active value. The corresponding instructions in horizontal direction are ‘(’ and ‘)’.

Cardinal is an esolang invented in 2010 http://esolangs.org/wiki/Cardinal

The original interpreter has some bugs, but this example works without problems. I recompiled the source to get rid of the worst bugs so far, in case someone is interested.
> 0 votes

# Answer
# Swift 2.0, 243 bytes

Works for Swift 2.0 on Xcode 7 and above.

```
var s = " ".join(["Gdkkn", "Vnqkc"].map({
    var usv = String.UnicodeScalarView()
    for a in $0.unicodeScalars.map({
        UnicodeScalar(($0.value + 4 - 3)) }) { usv.append(a) }
    return String(usv)
}));

print(s, appendNewline: false)

```
> 0 votes

# Answer
# Ruby, 66

```
puts ""<<(61+11)<<101<<108<<108<<111<<' '<<(31+56)<<111<<114<<108<<100

```

It breaks rule 2

# Ruby, 43

Also based upon @Nemo157 answer:

```
puts "Gdkkn~Vnqkc".split("").map(&:succ)*''

```

It breaks rule 1
> 0 votes

# Answer
# CBM BASIC v2.0 (66 characters)

I think Mark's answer, while very clever, verges on cheating as it exploits the lack of lowercase letters in the machine's default non-ASCII character set. Here's a somewhat longer program that doesn't rely on the PETSCII quirk. It breaks only Rule 2.

```
3a=44-33:a$="emspX!pmmfI
4?cH(aS(mI(a$,a,a/a))-a/a);:a=a-a/a:ifagO4

```
> 0 votes

# Answer
# Detour, 18 bytes

```
`<u
@'Ifmmp!Xpsme'

```

Basically the same as @gnibbler's answer, only breaks rule 2.

Try it online!

The 19-byte version breaks none of the rules:

# Detour, 19 bytes

```
`<<u
@'Jgnnq"Yqtnf'

```

Try it online!
> 0 votes

# Answer
# JavaScript, ~~77~~ ~~70~~ 69 characters

This satisfies conditions number 2 and 3.

~~```
"H"+([]+![])[4]+"ll"+([]+{})[+!![]]+" W"+([]+{})[+!![]]+([]+!![])[+!![]]+"ld"

```~~ ~~```
a=!![];b=([]+{});c=b[+a];"H"+([]+![])[4]+"ll"+c+" W"+c+([]+a)[+a]+"ld"

```~~
```
a=!![];b=([]+{});c=b[+a];`H${([]+![])[4]}ll${c} W${c}${([]+a)[+a]}ld`

```

Please help me shorten this up.
> 0 votes

# Answer
# Molecule, 7 chars (18 bytes)

```
"ৣ҆͢๡Ԫł"C

```

Molecule uses Chocolate Compressor to compress strings.
So I just decompress it.
> 0 votes

# Answer
# tcl, 104

```
\u6cmap x {G d k k n \U1F V n q k c} {scan $x %c n;incr n;puts -n\u6Fn\u65w\u6cin\u65 [f\U6Frmat %c $n]}

```

Almost meets 3 requirements. Unfortunately I am not successful when I try to use directly the char by key pressing Alt+Num 31, representable as:

```
Dec U-Hex  Oct
\31 \U1F   \037

```

which happens to have forbidden chars in all number bases!

Available to run on: http://rextester.com/live/GQBHU26987
> 0 votes

# Answer
## Ruby, 51 bytes

Chars not used: `hlwd27`

```
puts "Ifmmp!Xpsme".chars.map{|i|(i.ord-1).chr}.join

```
> 0 votes

# Answer
**Perl, 33 bytes**

```
print 'Ifmmp Xpsme'=~y/G-t/F-s/r

```

Breaks rule 2.

Alternatively:

```
perl -E "say 'Ifmmp Xpsme'=~y/G-t/F-s/r"

```

I think this counts as one byte shorter...
> 0 votes

# Answer
## Mathematica 144 Bytes

```
StringJoin@Insert[ToUpperCase@StringPart[#,1]<>StringPart[#,5-3;;]&/@IntegerString[{349644888483444,656639565449499}/(498331*8*3+3),36]," ",5-3]

```

This is a pain in Mathematica because so few functions adhere to rules 2 & 3. This answer adheres to rules 1 & 2 and also takes care to do the Capitalization. I couldn't even use the built in `Capitalize` function. The basic idea is to find the base 10 representation of the string assuming it's in base 36.

as can be seen by running

> Select\[Names\["System\`\*"\],StringFreeQ\[#,{"h","l","w","d"},IgnoreCase-\>True\]&&StringFreeQ\[#,{"e","o","r","0","1"},IgnoreCase-\>True\]&&UpperCaseQ\[StringPart\[#,1\]\]&\]

which yields a handful of built in symbols, only some of which are functions, and none of which are helpful with string manipulation.

```
{Abs,Annuity,Ask,Assuming,Axis,Back,C,Cap,Csc,Cubics,Cup,CupCap,Cyan,Fit,Gamma,I,If,Im,In,Infinity,Infix,Inpaint,Input,K,Magnify,Map,MapAt,Masking,Max,Min,MinMax,Minus,Missing,MissingQ,N,NSum,Pi,Pick,Pink,Put,QGamma,Quantity,QuantityQ,QuantityUnit,Quit,Scan,Sign,Sin,Sinc,Skip,Spacings,Span,Stack,Stub,SubMinus,Sum,Syntax,SyntaxQ,Tab,TabSpacings,Tan,Ticks,Timing,Tiny,Up,Using}

```

A single function solution that came to mind was:

```
Transliterate["הֶללֳ וֳרלד"]

```

which translates from Hebrew characters, but as you can see it it violates rules 2 and 3.
> 0 votes

# Answer
# Jelly, 7 bytes

```
“½,⁾ẇṭ»

```

Try it online!
> 0 votes

# Answer
# PHP, 41 bytes

```
<?for(;$a='Gdkkn vnqkc'[$p++];print++$a);

```

Complies with rules 1 and 3.
> 0 votes

# Answer
# Ly, 30 bytes

```
4:*`4~"jszxa+{yztX"[r,r4~I-o];

```

Try it online!

This rotates the codepoints in the string by a decending number and prints them. Meaning, the character in `Hello World` are pushed onto the stack, then the first one is shifted by 17 and printed. Then the second one is shifted by 16 and printed, etc...

There are shorter ways to do this in Ly, but this is more confusing/obsfuscated so I like it better.

Also, it doesn't meet the second rule, since AFAIK there's no way to output a character without using `o`.

1. We need `17` and a `0` on the stack to separate the shift value from the string

```
4:*`    - pushes "4", duplicates it, multiplies, then increments
    4~  - searches for "4" on the stack, fails and pushes a "0"

```
2. Load the shifted "Hello World" string

```
      "jszxa+{yztX"

```
3. For each input char, decrement the shift, then decrement the char and print

```
                   [        ]   - loop while top of stack isn't "0"
                    r,r         - reverse stack, decrement, reverse again
                       4~       - push a "0" on the stack (failed search for "4")
                         I      - copy bottom of the stack to the top
                          -o    - decrement the codepoint and print
                             ;  - halt code (otherwise junk on stack would print)

```
> 0 votes

# Answer
# KonamiCode, 250 bytes

KonamiCode in and of itself is pretty obfuscated, but I modified the normal Hello World code to make it as confusing as possible.

`v(^^^^^^^>^^)>((>))v(^>>^)>((>))v(^>>^^^^^^^^)>((>))v(^>>^^^^^^^^)>((>))v(^>^>^)>((>))v(^^^^>^^^^)>((>))v(^^^>^^)>((>))v(^>^>^^^^^^^^^)>((>))v(^>^>^)>((>))v(^>^>^^^^)>((>))v(^>>^^^^^^^^)>((>))v(^>>)>((>))v(^^^>^^^)>((>))v(^>)S(^>)>(>)L(>)<<>((>))B(>)`
> 0 votes

# Answer
# MUMPS, 85 bytes

```
 x $c(86+33,35-3,34,69+3,98+3,99+9,99+9,99+9+3,35-3,93-6,68+43,69+45,99+9,96+4,33,34)

```

Try it online!

Meets every rule. The `x` command (short for `xecute` (not a typo)) executes its string argument as code. The `$c` expression builds the string `"w ""Hello World!"""` out of a list of each character's ASCII code which have been written to avoid including `0`, `1`, `2`, or `7`. The `w` command (short for `write`) prints its argument `"Hello World!"` when executed.

The leading space is there so that `x` is interpreted as a command and not a tag.
> 0 votes

# Answer
# Julia 1.0, 27 bytes

```
print.(b"Fcjjm\x1eUmpjb".+'\2')

```

Try it online! (`\x1e` and `\2` are special characters, here for legibility)

simply subtract 2 to each character. Rule 2 is not followed
> 0 votes

# Answer
# Rattle, 25 bytes

```
Ifmmp!Xpsme|!II^P[gn-,>]`

```

Try it Online!

This meets requirements 1 and 3

# Explanation

```
Ifmmp!Xpsme                this is a caesar-shifted string of Hello World (H->I, etc.)
           |               take the above string as a variable
            !              disable implicit output
             I             split the string and store its characters in consecutive memory slots   while moving the pointer to the right
              I^           get the length of the string
                P          reset the pointer
                [     ]`   loop n times where n is the length of the string
                 g         get the value in memory at the pointer
                  n        convert the character to its ASCII integer value
                   -       subtract one
                    ,      explicitly output the shifted character
                     >     move the pointer right

```
> 0 votes

# Answer
# ..? (291 bytes)

I made interpreter which randomizes instructions and made this.

```
╓╓╓╓αααα╓╓╓╓╓╓╓╓╫├├├╫╓╓╓╓╓╓╓╫╫╓╓╓╫╓ß├├├├├├├├╫α╓╓╓╓╓╓╓╓╓╓╓╓╓╓╓╓╓╓╓╓╓╓╓╫├├├├├├├├╫╓╓╓╫├├├├├├╫├├├├├├├├╫

```

link to interpreter

This code is single use unless someone gets the same intstructions.
> 0 votes

# Answer
# Itr, 15 bytes

`»`90`ÊØØÞ@®ÞäØÈ«2:`

the first character in the string is the byte value `0x90`

(base 64 `u5DK2NjeQK7e5NjIqzI6`)

online interpreter

## Explanation

`»`90`ÊØØÞ@®ÞäØÈ«` is a "code-literal" containing the doubled byte values of that characters in Hello World (encoded as single bytes)

`2:` divides all bytes in the code-literal by two.

The result is then implicitly printed to stdout

# Itr, 15 bytes

Uses only Ascii characters

`"Nkrru&]uxrj"6-`

Works the same way as the other solution (byte values increased by 6 instead of multiplied by 2)
> 0 votes

# Answer
# Morsecco ~~85~~ 80 bytes

Obfuscated not for every nerd:

```
.   .... ---- . .-.. .-.. --- -..... -.-.--- --- .-. .-.. -..  -.- .-- -.- - ---

```

In morsecco, strings are typically `E`ntered as morse code. Because morse code is not case sensitive, it uses the `----` (`CH`) as `C`ase `H`ack to toggle the case. This would cost 10 additional bytes for the capital `W` of `World`, but here comes a trick: non-existent morse codes get interpreted as Unicode, so we can save some bytes by using `-.-.---`. Also, the space is coded as Unicode `-.....`.

`-.- .--` `K`onverts from `.M`orse code, `-.- -` `K`onverts to `T`ext for `O`utput.
> 0 votes

# Answer
# YASEPL, 39 bytes

```
=n$99++#"H"›#"ll"++9›#" W"›+3›#"ld"

```
> 0 votes

# Answer
**Excel** 138

(Not actually a language and not really obfuscated, but why not)

```
=CONCAT(CHAR(69+3),CHAR(98+3),CHAR(99+9),CHAR(99+9),CHAR(45+66),CHAR(35-3),CHAR(33+86),CHAR(43+68),CHAR(48+66),CHAR(44+64),CHAR(45+55))

```

Violates rule #2 tho, as it contains 'o' and 'r'
> -1 votes

---
Tags: code-golf, obfuscation, hello-world, restricted-source
---