[Question]
  [
Since Halloween is coming up I thought I might start a fun little code golf challenge!
The challenge is quite simple. You have to write a program that outputs either `trick` or `treat`.  
"The twist?" you may ask. Well let me explain:
Your program has to do the following:
* Be compilable/runnable in two different languages. Different versions of the same language don't count.
* When you run the program in one language it should output `trick` and the other should output `treat`. The case is irrelevant and padding the string with whitespace characters are allowed (see examples).
* This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the solution with the fewest bytes wins.
A few explanations:
**Valid outputs** (Just for the words not for running the code in the two languages. Also adding quotes to signalize the beginning or end of the output. Do not include them in your solution!):
```
"trick"
"Treat"
"    TReAt"
"
     tRICk          "
```
**Invalid outputs**:
```
"tri ck"
"tr
eat"
"trck"
```
I'm interested to see what you can come up with! Happy Golfing!
I'd like to note that this is my first challenge so if you have suggestions on this question please leave them in the form of a comment.
## Leaderboards
Here is a Stack Snippet to generate both a regular leaderboard and an overview of winners by language.
To make sure that your answer shows up, please start your answer with a headline, using the following Markdown template:
```
# Language Name, N bytes
```
where `N` is the size of your submission. If you improve your score, you *can* keep old scores in the headline, by striking them through. For instance:
```
# Ruby, <s>104</s> <s>101</s> 96 bytes
```
If there you want to include multiple numbers in your header (e.g. because your score is the sum of two files or you want to list interpreter flag penalties separately), make sure that the actual score is the *last* number in the header:
```
# Perl, 43 + 2 (-p flag) = 45 bytes
```
You can also make the language name a link which will then show up in the leaderboard snippet:
```
# [><>](http://esolangs.org/wiki/Fish), 121 bytes
```
```
var QUESTION_ID=97472,OVERRIDE_USER=23417;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=o.replace(TAGS_REG,"")),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i,TAGS_REG = /(<([^>]+)>)/ig;
```
```
body{text-align:left!important}#answer-list,#language-list{padding:10px;width:400px;float:left}table thead{font-weight:700}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]
## Python / Windows Batch, 25 bytes
```
print"trick"#||echo.treat
```
Everything after the # is interpreted as a comment by python, while the || is an OR in batch, saying that as the previous command failed, execute this one.
I also like the use of an OR as it almost reads "trick or treat" :)
[Answer]
# Whitespace / Starry, 135 bytes
Here's to a clear night sky on Halloween!
```
  + +    +      + + 
    +
* +   +*      +     *
   +    *           
     + +        
 +* +   
 +* + .  + .   +      +* +   +* . . .
```
*Note that whitespace on empty lines may not be preserved if you copy from the above code*
Whitespace outputs "TRICK". [Try it Online!](http://whitespace.tryitonline.net/#code=ICAgCSAJICAJIAogICsgKwkgKwkgCSsgKyAKCSsKICAJCiogKyAgICsqIAkgICsJICAJKgoJCiAgICsgIAkqICAJIAkJCiAgIAkgKyArICAJCQoJCiArKiArCQogIAoKCiArKiArIC4gICsgLiAgICsgICAgICArKiArICAgKyogLiAuIC4K)
  
Starry outputs "TREAT". [Try it Online!](http://starry.tryitonline.net/#code=ICAgCSAJICAJIAogICsgKwkgKwkgCSsgKyAKCSsKICAJCiogKyAgICsqIAkgICsJICAJKgoJCiAgICsgIAkqICAJIAkJCiAgIAkgKyArICAJCQoJCiArKiArCQogIAoKCiArKiArIC4gICsgLiAgICsgICAgICArKiArICAgKyogLiAuIC4K)
## Explanation
### Starry
Starry ignores all tabs and new lines so the code it reads is the following
```
         + + + + + +  * +   +*   +  *   +  *       + +   +* +   +* + .  + .   +      +* +   +* . . .
```
Bytewise, pushing values is very expensive compared to stack and arithmetic operations in Starry. The code starts by pushing and duplicating 4 and the performs a number of operations on it and with 2 and 1 pushed later on produces all of the required ASCII values.
**Annotated Code**
```
Stack (after op)    Code        Operation
4                            +  Push 4
4 4 4 4 4 4          + + + + +  Duplicate top of stack 5 times
4 4 4 4 16            *         Multiply top two items
4 4 4 4 16 16        +          Duplicate top of stack
4 4 4 16 4 16          +        Rotate top three items on stack right
4 4 4 16 20         *           Add top two items
4 4 20 4 16            +        Rotate...
4 4 20 64             *         Multiply...
4 64 4 20              +        Rotate...
4 64 80               *         Multiply...
4 64 80 2                  +    Push 2
4 64 80 2 2          +          Duplicate...
4 64 2 80 2            +        Rotate...
4 64 2 82           *           Add...
4 64 2 82 82         +          Duplicate...
4 64 82 2 82           +        Rotate...
4 64 82 84          *           Add...
4 64 82 84 84          +        Rotate...
4 64 82 84           .          Pop and print as character (T)
4 64 84 82            +         Swap top two items on stack
4 64 84              .          Pop and print... (R)
84 4 64                +        Rotate...
84 4 64 1                 +     Push 1
84 4 65             *           Add...
84 4 65 65           +          Duplicate...
84 65 4 65             +        Rotate...
84 65 69            *           Add...
84 65                .          Pop and print... (E)
84                   .          Pop and print... (A)
                     .          Pop and print... (T)
```
### Whitespace
As the name may suggest, Whitespace only parses the three whitespace characters—space, tab, and newline. Unlike the Starry, the Whitespace simply pushes the ASCII values of `T`, `R`, `I`, `C`, and `K` and the prints them.
**Annotated Code**
```
<Space><Space><Space><Tab><Space><Tab><Space><Space><Tab><Space><LF> Push the ASCII value of R
<Space><Space><Space><Tab><Space><Tab><Space><Tab><Space><Space><LF> Push the ASCII value of T
<Tab><LF><Space><Space> Pop and print the T
<Tab><LF><Space><Space> Pop and print the R
<Space><Space><Space><Tab><Space><Space><Tab><Space><Space><Tab><LF> Push the ASCII value of I
<Tab><LF><Space><Space> Pop and print the I
<Space><Space><Space><Tab><Space><Space><Tab><Space><Tab><Tab><LF>   Push the ASCII value of K
<Space><Space><Space><Tab><Space><Space><Space><Space><Tab><Tab><LF> Push the ASCII value of C
<Tab><LF><Space><Space> Pop and print the C
<Tab><LF><Space><Space> Pop and print the K
<LF><LF><LF>            Terminate the program. The following line is not run.
<Space><Space><Space><Space><Space><Space><Space><Space><Space><Space><Space><Space><Space><Space><Space><Space><Space><Space><Space><Space><Space><Space><LF>
```
The interweaving of pushes and prints was chosen based solely on aesthetic reasons as it does not affect the byte count.
[Answer]
# [2sable](http://github.com/Adriandmen/2sable) / [pl](https://github.com/quartata/pl-lang), 8 bytes
```
0000000: 74 72 65 61 74 93 d0 cb                          treat...
```
Both programs have been tested locally with the same 8 byte file, so this is a proper polyglot.
### 2sable: trick
This is the program in [code page 1252](https://en.wikipedia.org/wiki/Windows-1252#Code_page_layout).
```
treat“ÐË
```
[Try it online!](http://2sable.tryitonline.net/#code=dHJlYXTigJzDkMOL&input=)
### pl: treat
This is the program in [code page 437](https://en.wikipedia.org/wiki/Code_page_437#Characters).
```
treatô╨╦
```
[Try it online!](http://pl.tryitonline.net/#code=dHJlYXTDtOKVqOKVpg&input=)
## How it works
### 2sable: trick
```
t         Square root. Errors since there is no input. The exception is caught, the
          stack left unaltered, and the interpreter pretends nothing happened.
 r        Reverse stack.
          Reversed empty stack is still empty stack. ;(
  e       Compute nCr. Errors since there is no input.
   a      Alphanumeric test. Errors since there is no input.
    t     Square root. Errors since there is no input.
     “    Begin a lowercase string literal.
      Ð     Excluding ‘, ’, “, and ”, Ð is the 71st non-ASCII character in CP1252.
       Ë    Excluding ‘, ’, “, and ”, Ë is the 66th non-ASCII character in CP1252.
          (implicit) End string literal.
          Both characters together fetch the dictionary word at index
          71 * 100 + 66 = 7166, which is 'trick'.
```
### pl: treat
```
treat     Bareword; push the string "treat" on the stack.
     ô    Unimplemented. Does nothing.
      ╨   Flatten the stack. This doesn't affect the output.
       ╦  Unimplemented. Does nothing.
```
[Answer]
# Linux ELF x86 / DOS .COM file, 73 bytes
```
00000000  7f 45 4c 46 01 00 00 00  1a 00 00 00 1a 00 43 05  |.ELF..........C.|
00000010  02 00 03 00 1a 00 43 05  1a 00 43 05 04 00 00 00  |......C...C.....|
00000020  eb 0c b4 09 ba 41 01 cd  21 c3 20 00 01 00 b2 05  |.....A..!. .....|
00000030  b9 3b 00 43 05 cd 80 2c  04 cd 80 74 72 69 63 6b  |.;.C...,...trick|
00000040  00 74 72 65 61 74 24 eb  d9                       |.treat$..|
00000049
```
NASM source:
```
ORG 0x05430000
BITS 32                                         ;
                                                ;   ELF HEADER    --   PROGRAM HEADER
; ELF HEADER                                    ; +-------------+
DB 0x7f,'E','L','F'                             ; | magic       |    +--------------------+
                                                ; |             |    |                    |
; PROGRAM HEADERS                               ; |             |    |                    |
DD 1                                            ; |*class 32b   | -- | type: PT_LOAD      |
                                                ; |*data none   |    |                    |
                                                ; |*version 0   |    |                    |
                                                ; |*ABI SysV    |    |                    |
DD 0x01a        ; offset = vaddr & (PAGE_SIZE-1); |*ABI vers    | -- | offset             |
                                                ; |             |    |                    |
entry:  DD 0x0543001a                           ; |*PADx7       | -- | vaddr = 0x0543001a |
DW 2                                            ; | ET_EXEC     | -- |*paddr LO           |
DW 3                                            ; | EM_386      | -- |*paddr HI           |
DD 0x0543001a                                   ; |*version     | -- | filesz             |
;       inc     ebx     ; STDOUT_FILENO         ; |             |    |                    |
;       mov     eax, 4  ; SYS_WRITE             ; |             |    |                    |
DD 0x0543001a                                   ; | entry point | -- | memsz              |
DD 4                                            ; | ph offset   | -- | flags: RX          |
                                                ; |             |    |                    |
        jmp     short skip                      ; |*sh offset   | -- |*align              |
BITS 16                                         ; |             |    |                    |
treat:  mov     ah, 9                           ; |             | -- |                    |
        mov     dx, trick + 0x100 + 6           ; |*flags ______|    |                    |
        int     0x21                            ; |______/      |    +--------------------+
        ret                                     ; |*ehsize      |
BITS 32                                         ; |             |
DW 32                                           ; | phentsize   |
DW 1                                            ; | phnum       |
skip:                                           ; |             |
        mov     dl, 5   ; strlen("trick")       ; |*shentsize   |
        mov     ecx, trick                      ; |*shnum       |
                                                ; |*shstrndx    |
                                                ; +-------------+
        int     0x80
        sub     al, 4   ; SYS_EXIT
        int     0x80
trick:  DB      "trick/treat$"
BITS 16
        jmp     short treat
```
This uses the fact that the ELF header starts with 7F 45, which, interpreted as x86 code, is a jump.
The relevant parts for the DOS .COM: 
```
-u100 l2
07D2:0100 7F45          JG      0147
-u147 l2
07D2:0147 EBD9          JMP     0122
-u122 l8
07D2:0122 B409          MOV     AH,09
07D2:0124 BA4101        MOV     DX,0141
07D2:0127 CD21          INT     21
07D2:0129 C3            RET
-d141 l6
07D2:0140     74 72 65 61 74 24   -                           treat$
```
[Answer]
# [evil](http://esolangs.org/wiki/Evil) / [ZOMBIE](http://www.dangermouse.net/esoteric/zombie.html), 109 bytes
Another spooky answer !
```
xf is a vampire summon task f say "trick" stumble say "jzuueeueeawuuwzaeeaeeaeawuuuuwzuueeueeaw" animate bind
```
The `ZOMBIE` code defines a `vampire` named `xf` whose only task `f` is activated at instanciation and will output `trick` once before being deactivated by `stumble`. The other `say` call is dead code (how appropriate !) for `ZOMBIE`, but contains most of the `evil` code.
For `evil`, the `xf` name is a call to jump to the next `j`, which precedes the `zuueeueeawuuwzaeeaeeaeawuuuuwzuueeueeaw` zombie moan that crafts and output `treat`. The code following is either executed (lowercase letters) or ignored but since there's no `w` no output should be produced.
[Answer]
## Python / Perl, 28 bytes
```
print([]and"trick"or"treat")
```
## Explanation
Since `[]` is an ArrayRef in Perl, it's truthy, but it's an empty array in Python, therefore falsy.
[Answer]
## PHP / JavaScript, ~~32~~ 30 bytes
Displays `trick` in PHP and `treat` in JS.
```
NaN?die(trick):alert('treat');
```
The unknown `NaN` constant is implicitly converted to a string by PHP, making it truthy. It's falsy in JS.
### Alternative method, 38 bytes
```
(1?0:1?0:1)?die(trick):alert('treat');
```
The ternary operator is right-associative in JS:
```
                1 ? 0 : 1 ? 0 : 1
 is parsed as:  1 ? 0 : (1 ? 0 : 1)
 which equals:  0
```
And left-associative in PHP:
```
                1 ? 0 : 1 ? 0 : 1
 is parsed as:  (1 ? 0 : 1) ? 0 : 1
 which equals:  1
```
[Answer]
# HTML / HTML+JavaScript, 53 bytes
```
treat<script>document.body.innerHTML='trick'</script>
```
`treat` is the document´s text content in HTML.  
If JS is enabled, it will replace the HTML content with `trick`.
[Answer]
# C / Java 7, ~~165~~ ~~155~~ ~~128~~ ~~123~~ ~~122~~ ~~120~~ 103 bytes
```
//\
class a{public static void main(String[] s){System.out.print("treat"/*
main(){{puts("trick"/**/);}}
```
//\ makes the next line also a comment in C but is a regular one line comment in Java, so you can make C ignore code meant for Java and by adding /\* in the second line you can make a comment for Java that is parsed as code by C.
Edit:
I improved it a little bit by reorganizing the lines and comments.
Edit2:
I did some more reorganizing and shortened it even more.
Edit3:
I added corrections suggested by BrainStone to remove 5 bytes, thanks :)
Edit4:
One newline turned out to be unnecessary so I removed it.
Edit5:
I changed printf to puts.
Edit6:
I added a correction suggested by Ray Hamel.
[Answer]
# Jolf + Chaîne, 12 bytes
Because Chaîne cannot accept a file to upload with an encoding, I assume UTF-8. (If I could assume ISO-8859-7, this would be 11 bytes, but that would be unfair.)
```
trick«treat
```
In Chaîne, `«` begins a comment, and the rest is printed verbatim. In Jolf, `«` begins a string. Thankfully, `trick` does nothing harmful (`10; range(input, parseInt(input))` basically), and `treat` is printed.
[Try Jolf here!](http://conorobrien-foxx.github.io/Jolf/#code=dHJpY2vCq3RyZWF0)
[Try Chaîne here!](http://conorobrien-foxx.github.io/Cha-ne/?code%3Dtrick%C2%ABtreat%7C%7Cinput%3D)
They both work on my browser (firefox, latest version), but the same cannot be said for other browsers.
[Answer]
# [Cubix](https://github.com/ETHproductions/cubix/) / [Hexagony](https://github.com/m-ender/hexagony), 31 bytes
```
t;./e;_a]"kcirt">o?@;=v=./r;\;/
```
[Trick it out!](http://ethproductions.github.io/cubix/?code=dDsuL2U7X2FdImtjaXJ0Ij5vP0A7PXY9Li9yO1w7Lw==) [Treat it online!](http://hexagony.tryitonline.net/#code=dDsuL2U7X2FdImtjaXJ0Ij5vP0A7PXY9Li9yO1w7Lw&input=)
*Halloween themed*? Note the horrifying facts about these languages and the code:
1. If and even if you do nothing (just put no-ops), you can *never* get out of the loop that is determined to be running forever...
2. And being stuck in the middle of a 3D and a 2D programming language (Oh agony...)
3. Inside the dimensions, you'll gradually lost where you are... where you were...
4. And there is a `=v=` smiling at you which acts at no-ops in the code
Let's dig into the mystery of the hidden 31-bytes communication protocol of dimensions and terror...
## trick
When the code folds or unfolds itself... That is `cubified`, the layout looks like this:
```
      t ; .
      / e ;
      _ a ]
" k c i r t " > o ? @ ;
= v = . / r ; \ ; / . .
. . . . . . . . . . . .
      . . .
      . . .
      . . .
```
And the main part is this part in the middle:
```
" k c i r t " > o ? @ .
. . . . . . . \ ; / . .
```
It pushes `k,c,i,r,t` onto the stack and `o` outputs and `;` pops within a loop bounded by reflectors and `?` which guides you depending on the value on the top of the stack...
## treat
All of a sudden, the code transforms from a cube to a Hexagon. (Imagine that)
```
   t ; . /
  e ; _ a ] 
 " k c i r t 
" > o ? @ ; = 
 v = . / r ;
  \ ; / . .
   . . . .
```
And the main part is this part:
```
   t ; . /
  e ; _ a ] 
 . . . . . . 
. . . . @ ; = 
 . . . / r ;
  . . . . .
   . . . .
```
It runs `t;` which prints `t` and hits the mirror and turns its direction to NW starting from the SE corner and hits another mirror. This runs `r;` and wraps to `e;_a` and the `]` brings it to the Instruction Pointer 1 which starts at corner NE pointing SE and hits `/` which reflects horizontally to `;` then `t`.
Then it wraps to `=`, `;`, and `@` ends the mess.
So... What is `_` doing there?
*Why* is it inside the `t` `e` `a` (the first 3 letters in the code)?
Here comes the end of the story -
it does *nothing*.
Does it sound like the end of a horror story?
[Answer]
# [#hell](http://esolangs.org/wiki/HashHell) / [Agony](http://esolangs.org/wiki/Agony), 43 bytes
So much `><>` everywhere, what is this, an April Fools challenge? Here's an answer with appropriately themed languages.
```
--<.<.<.<.<.$
io.write("trick")--+<~}~@+{+<
```
`#hell` is a subset of `LUA` which fortunately accepts `io.write` output calls. We use `LUA`'s `--` comments so that it only executes this fragment.
`Agony` is a `Brainfuck` derivative, which has the particularity to have its code and working memory on the same tape. The first line only prints 5 characters (10 cells) from the end of the code segment, where I encoded `treat` as `Agony` commands. `LUA`'s comment opening `--` modifies the value of a cell which isn't used.
[Answer]
## SQL / Javascript, 54 bytes
```
select('trick')
--a;function select(){alert("treat")}
```
Same approach as with my [QB/JS answer](https://codegolf.stackexchange.com/questions/97472/trick-or-treat-polyglot/97509#97509): First line has the SQL statement, the second line has a 'comment' for SQL and a NOP for JS. Then, we define SQL's `select` statement as a valid JS function.
[Answer]
# /Brainf..k/, 143 + 3 = 146 bytes
This answer requires the `-A` flag to output in ASCII for Brain-Flak and luckily Brainfuck doesn't care about that flag so it doesn't affect the output in Brainfuck.
```
(((((()(()()()){})({}){}){}){})+++++++[<+++<(((()()()())((((({}){}){}){}){}()))[][][][]())>>-])<[<++++>-]<.--.---------.------.>++[<++++>-]<.>>
```
[Try it Online!](http://brain-flak.tryitonline.net/#code=KCgoKCgoKSgoKSgpKCkpe30pKHt9KXt9KXt9KXt9KSsrKysrKytbPCsrKzwoKCgoKSgpKCkoKSkoKCgoKHt9KXt9KXt9KXt9KXt9KCkpKVtdW11bXVtdKCkpPj4tXSk8WzwrKysrPi1dPC4tLS4tLS0tLS0tLS0uLS0tLS0tLj4rK1s8KysrKz4tXTwuPj4&args=LUE)
[Try it Online!](http://brainfuck.tryitonline.net/#code=KCgoKCgoKSgoKSgpKCkpe30pKHt9KXt9KXt9KXt9KSsrKysrKytbPCsrKzwoKCgoKSgpKCkoKSkoKCgoKHt9KXt9KXt9KXt9KXt9KCkpKVtdW11bXVtdKCkpPj4tXSk8WzwrKysrPi1dPC4tLS4tLS0tLS0tLS0uLS0tLS0tLj4rK1s8KysrKz4tXTwuPj4&args=LUE)
## How this works
The only overlap between the syntax of Brain-Flak and Brainfuck are the characters `<>[]`. For brain-flak this mostly means the program has to ensure an even number of stack switches `<>`. And for Brainfuck this means we need to avoid infinite loops caused by use of the `[]` monad.
The Brain-Flak code is as follows:
```
(((((()(()()()){})({}){}){}){})[<<(((()()()())((((({}){}){}){}){}()))[][][][]())>>])<[<>]<>[<>]<>>
```
Aside from the `[<<...>>]` bit in the middle and the `<[<>]<>[<>]<>>` at the end this code is pretty par for the course as far as Brain-Flak programs go. The negative around the zero (`[<...>]`) is there to create a loop for Brainfuck. The inner `<...>` is used to move the Brainfuck to an empty cell before it encounters the `[][][][]` which would loop infinitely otherwise.
The Brainfuck code is as follows:
```
+++++++[<+++<[][][][]>>-]<[<++++>-]<.--.---------.------.>++[<++++>-]<.>>
```
Aside from the aforementioned bits this is also a pretty standard program so I will spare you the details.
[Answer]
# [><>](https://esolangs.org/wiki/Fish) / [Fishing](https://esolangs.org/wiki/Fishing), 38 bytes
```
_"kcirt"ooooo;
[+vCCCCCCCC
   `treat`N
```
For the sake of making a `><>` / `Fishing` polyglot.
It's my first piece of `Fishing` code after having played for a long time with `><>`.  
My first impression : as in nature, the fisherman has less physical capabilities than its pray but makes up for it with its tool !
Here the code is extremely simple : `><>` will only execute the first line, where `_` is a vertical mirror and has no effect since the fish starts swimming horizontally. It just pushes `trick` on the stack then print it before stopping.  
For `Fishing`, the `_` instructs to go down. The fisherman will follow the deck that is the second line while catching the characters of the third line. These will push `treat` on the tape then print it, stopping as it reaches the end of the deck.
If erroring out is allowed, you could go down to 35 bytes with the following code which will throw an error when run as `><>` once the `trick` is printed off the stack :
```
_"kcirt">o<
[+vCCCCCCCC
   `treat`N
```
---
You should also check my themed languages answers, [#hell / Agony](https://codegolf.stackexchange.com/questions/97472/trick-or-treat-polyglot/97533#97533) and [evil / ZOMBIE](https://codegolf.stackexchange.com/questions/97472/trick-or-treat-polyglot/97542#97542) !
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E)/[Actually](https://github.com/Mego/Seriously), 10 bytes
```
"trick"’®Â
```
**Explanation**
**05AB1E**
```
"trick"     # push the string "trick"
       ’®Â  # push the string "treat"
            # implicitly print top of stack (treat)
```
[Try it online](http://05ab1e.tryitonline.net/#code=InRyaWNrIuKAmcKuw4I&input=)
**Actually**
```
"trick"     # push the string "trick"
       ’®Â  # not recognized commands (ignored)
            # implicit print (trick)
```
[Try it online](http://actually.tryitonline.net/#code=InRyaWNrIuKAmcKuw4I&input=) 
[Answer]
# [Haskell](https://www.haskell.org/) / [Standard ML](https://en.wikipedia.org/wiki/Standard_ML), 56 bytes
```
fun putStr x=print"treat";val main=();main=putStr"trick"
```
**Haskell view**
The semicolons allow multiple declarations in one line and act like linebreaks, so we get
```
fun putStr x=print"treat"
val main=()
main=putStr"trick"
```
A Haskell program is executed by calling the `main` function, so in the last row `putStr"trick"` is executed which just prints `trick`.  
The first two rows are interpreted as function declarations following the pattern `<functionName> <argumentName1> ... <argumentNameN> = <functionBody>`. So in the first row a function named `fun` is declared which takes two arguments named `putStr` and `x` and the function body `print"treat"`. This is a valid Haskell function with type `fun :: t -> t1 -> IO ()`, meaning it takes an argument of an arbitrary type `t` and a second one of some type `t1` an then returns an IO-action. The types `t` and `t1` don't matter as the arguments aren't used in the function body. The IO-action type results from `print"treat"`, which prints `"treat"` to StdOut (notice the `"`, that's why `putStr` instead of `print` is used in `main`). However as it's only a function declaration, nothing is actually printed as `fun` is not called in `main`.  
The same happens in the second line `val main=();`, a function `val` is declared which takes an arbitrary argument named `main` and returns *unit*, the empty tuple `()`. It's type is `val :: t -> ()` (Both the value and the type of *unit* are denoted with `()`).
[Try it on Ideone.](http://ideone.com/MYQF7C)
---
**Standard ML view**
[Standard ML](https://en.wikipedia.org/wiki/Standard_ML) is a primarily functional language with a syntax related to, but not the same as Haskell. In particular, function declarations are prefixed with the keyword `fun` if they take any arguments, and the keyword `val` if they don't. Also it's possible to have an expression at top level (meaning not inside any declaration) which is executed when the program is run. (In Haskell writing `1+2` outside a declaration throws a `naked expression at top level`-error). Finally the symbol for testing equality is `=` instead of `==` in Haskell. (There are many more differences, but those are the only ones that matter for this program.)  
So SML sees two declarations
```
fun putStr x=print"treat";
val main=();
```
followed by an expression
```
main=putStr"trick"
```
which is then evaluated. To determine whether `main` equals `putStr"trick"`, both sides have to be evaluated and both must have the same type, as SML (as well as Haskell) is statically typed.
Let us first have a look at the right side: `putStr` is not a library function in SML, but we declared a function named `putStr` in the line `fun putStr x=print"treat";` - it takes an argument `x` (this is the string `"trick"` in our case) and immediately forgets it again, as it does not occur in the function body. Then the body `print"treat"` is executed which prints `treat` (without enclosing `"`, SML's `print` is different from Haskell's `print`).  
`print` has the type `string -> unit`, so `putStr` has the type `a -> unit` and therefore `putStr"trick"` has just type `unit`. In order to be well-typed, `main` must have type `unit` too. The value for *unit* is in SML the same as in Haskell `()`, so we declare `val main=();` and everything is well-typed.
[Try it on codingground.](http://www.tutorialspoint.com/execute_smlnj_online.php?PID=0Bw_CjBb95KQMUVp1b0JYWWRRNmc)  
Note: The output in the console is
```
val putStr = fn : 'a -> unit                                   
val main = () : unit                                                    
treatval it = true : bool
```
because in [SML\NJ](http://smlnj.org/) the value and type of every statement is displayed after each declaration. So first the types of `putStr` and `main` are shown, then the expressions gets evaluated causing `treat` to be printed, then the value of the expression (`true` as both sides of `=` are `()`) is bound to the implicit result variable `it` which is then also displayed.
[Answer]
# Ruby / C, ~~64~~ ~~62~~ ~~51~~ 48 bytes
```
#define tap main()
tap{puts(0?"trick":"treat");}
```
### What Ruby sees:
```
tap{puts(0?"trick":"treat");}
```
The `tap` method takes a block and executes it once. It's a short identifier that we can create a `#define` macro for in C. It also allows us to put a braces-enclosed block in the shared code, even though Ruby doesn't allow `{}`s in most contexts.
The only falsy values in Ruby are `false` and `nil`. In particular, 0 is truthy. Thus, Ruby will print "trick."
### What C sees (after the pre-processor):
```
main(){puts(0?"trick":"treat");}
```
0 is falsy in C, so C will print "treat."
2 bytes saved thanks to daniero.
[Answer]
## QBasic / JavaScript, ~~51~~ 44 bytes
```
'';PRINT=a=>{alert("Treat")}
PRINT("Trick")
```
In QBasic, it prints the second line and doesn't execute the first line because it's believed to be a comment (thank you '). In JS, it calls the function PRINT, which is defined on the first line, right after the JS NOP `'';`.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly) / [05AB1E](https://github.com/Adriandmen/05AB1E), 14 bytes
```
0000000: FE 22 74 52 69 63 6B 22 3F 37 29 FB ED 35                ."tRick"?7)..5
```
A fun one using Jelly's string compression.
**Jelly: treat**
```
“"tRick"?7)»ḣ5
```
[Try it online!](https://tio.run/##y0rNyan8//9RwxylkqDM5Gwle3PNQ7sf7lhs@v8/AA "Jelly – Try It Online")
**05AB1E: trick**
```
þ"tRick"?7)ûí5
```
[Try it online!](https://tio.run/##MzBNTDJM/f//8D6lkqDM5Gwle3PNw7sPrzX9/x8A "05AB1E – Try It Online")
**How it works**
In Jelly `“"tRick"?7)»` is a compressed string that returns `'Treatment dormy/ Orly awry'`. `ḣ5` takes the first five characters, printing `Treat`
In 05AB1E `þ` doesn't affect the program. `"tRick"` is a literal string. `?` prints this string then the rest of the program (`7)ûí5`) doesn't have any effect either.
I used [this](https://tio.run/##Dc9nV5JhGAfwr2I0bS@zrbazbXsPs0Jp27B1bh4RUbMBVKhADEVRVDYP03OuPw@dk@fchz6C1xd54t3v7a@zw2Tq0XVjMysRuFqX8kM1sDmp6zoLt6G7zdjeZWhqrKf8khps0P94/tplTMZlQiZlSqZlRqp11XhVrRaqxX@KdEindMmsDMowD/jYNsi2YbZ5WTGzorDSy4qFlT5WrHXLDMtXrFy1ek392nXrN2zctHnL1m3bG3Y07ty1e8/effubmlsOHDx0@MjRY8dbT5w8dfrM2XNt5y9cvHT5ytVr12/cvHX7zt177fc7Hjx8ZOzsMj1@8vTZ8xcvu1@9fvO25937Dx8/VVK1hhxjMVqxs/CyCLHwsfAvWllEtZqymr1s1YqVdFmwcLEYqW1ZeFgEWDhYOBfdbAlofhY5zVHu10qaWjaTnwIUpHGaoBBN0hSFaZpmKCLzNEfzFKUYxSlBSUpRmjKkUpZylKcCFalECxAwQ0EvLOiDFf2wYQCDGMJnDOMLvuIbvsMOB5z4gZ/4BRdGMIoxuOGBF7/hgx8BBDGOCYQwiSmEMY0ZRDCLOcwjihjiSCCJFNLIQEUWOeRRQBElLPwH) to convert from Jelly's code page to 05AB1E's code page. [This](https://tio.run/##DdHnUlNRGEbhW8FYsTfEDtjFjr0XBA3EjgXb7BxCCCCWJGqAJKZAIBAgPSeVme/NiTMysydegt@NHPPv@btmdXWYTL26bmxmJcLm5L/8cA1wteq6jpKhp83Y3m1oaqxHHnMN@m/PH7uMybhMyKRMybTMSLWuGq@q1UK1@FeRDumULpmVQRnmQR/bhtg2wjYvK2ZWFFb6WLGw0s@KtW6ZYfmKlatWr6lfu279ho2bNm/Zum17w47Gnbt279m7b39Tc8uBg4cOHzl67HjriZOnTp85e67t/IWLly5fuXrt@o2bt27fuXuv/X5H54OHxq5u06PHT54@e/6i5@Wr12963757/@FjJVWLkOMsxip2Fl4WIRY@Fv4lK4uoVlNWs5etWrGSLgsWLhajLNwsPCwCLBwsnEtutgQ0P4uc5igPaCVNLZvJTwEK0gRNUoimaJrCNEOzFJF5mqcFilKM4pSgJKUoTRlSKUs5ylOBilSiRQiYoaAPFvTDigHYMIghDOMTRvAZX/AV32CHA058xw/8hAujGMM43PDAi1/wwY8AgpjAJEKYwjTCmMEsIpjDPBYQRQxxJJBECmlkoCKLXG1bAUWUsPgf) does the reverse in case anyone is interested.
Jelly code page is [here](https://github.com/DennisMitchell/jelly/wiki/Code-page).
05AB1E code page is [here](https://github.com/Adriandmen/05AB1E/wiki/Codepage).
[Answer]
# [ShapeScript](http://github.com/DennisMitchell/shapescript) / [Foo](http://esolangs.org/wiki/Foo), 13 bytes
```
'trick'"treat
```
**Try it online!** [trick](http://shapescript.tryitonline.net/#code=J3RyaWNrJyJ0cmVhdA&input=) | [treat](http://foo.tryitonline.net/#code=J3RyaWNrJyJ0cmVhdA&input=)
### How it works
ShapeScript is parsed character by character. When EOF is hit without encountering a closing quote, nothing is ever pushed on the stack. `'trick'` does push the string inside the quotes, which is printed to STDOUT implicitly.
Foo doesn't have any commands assigned to the characters is `'trick'`, so that part is silently ignored. It does, however, print anything between double quotes immediately to STDOUT, even if the closing quote is missing.
[Answer]
## Ruby / Perl, 21 bytes
```
print"trick"%1||treat
```
### Perl
Calculates `"trick" % 1` which is `0 % 1` so the `||` sends `treat` to `print` instead, since Perl accepts barewords.
### Ruby
Formats the string `"trick"` with the argument `1`, which results in `"trick"` which is truthy, so the `||` isn't processed.
[Answer]
# [MATL](https://github.com/lmendo/MATL) / [CJam](https://sourceforge.net/projects/cjam/), 17 bytes
```
'TRICK'%];"TREAT"
```
In MATL this [outputs](http://matl.tryitonline.net/#code=J1RSSUNLJyVdOyJUUkVBVCI&input=) `TRICK`. In CJam it [outputs](http://cjam.tryitonline.net/#code=J1RSSUNLJyVdOyJUUkVBVCI&input=) `TREAT`.
## Explanation
### MATL
```
'TRICK'         Push this string
%];"TREAT"      Comment: ignored
                Implicit display
```
### CJam
```
'T              Push character 'T'
R               Push variable R, predefined to empty string
I               Push variable I, predefined to 18
C               Push variable C, predefined to 12
K               Push variable K, predefined to 20
'%              Push character '%'
]               Concatenate stack into an array
;               Discard
"TREAT"         Push this string
                Implicit display
```
[Answer]
# Objective-C / C, 50 bytes
```
puts(){printf("trick");}main(){printf("treat\n");}
```
Objective-C got candy and [prints treat](http://ideone.com/Hdt3fO), but C didn't and [prints trick](http://ideone.com/eRC6M2).
### How it works
I don't know a lot about **Objective-C**, but it does what we'd reasonably expect in this situation. The re-definition of `puts` doesn't affect the output since we never call the function, and `main` prints **treat** and a linefeed to STDOUT.
You might expect **C** to do the same, but at least gcc 4.8, gcc 5.3, and clang 3.7 don't.
Since we do not need the *real* **printf** (which takes a format string and additional arguments) and the string to be printed ends with a linefeed, we can use **puts** instead. **puts** is slightly faster than **printf** (which has to analyze its arguments before printing), so unless we redefine the function **printf** as well, the compiler optimizes and replaces the call to **printf** with a call to **puts**. Little does the compiler know that calling `puts` with argument `"treat"` will print **trick** instead!
Not including **stdio.h** is crucial here, since defining **puts** would require using the same type it has in the header file (`puts(const char*)`).
Finally, it is noteworthy that the call to **printf** in **puts** passes a string *without* a trailing linefeed. Otherwise, the compiler would "optimize" that call as well, resulting in a segmentation fault.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly) / [pl](http://github.com/quartata/pl-lang), 12 bytes
```
0000000: 74 72 65 61 74 0a 7f fe 00 ba 49 fb                 treat.....I.
```
This is the program displayed using [Jelly's code page](https://github.com/DennisMitchell/jelly/wiki/Code-page).
```
treatµ
“¡ṾI»
```
[Try it online!](http://jelly.tryitonline.net/#code=dHJlYXTCtQrigJzCoeG5vknCuw&input=)
This is the program displayed using [code page 437](https://en.wikipedia.org/wiki/Code_page_437#Characters).
```
treat
⌂■␀║I√
```
[Try it online!](http://pl.tryitonline.net/#code=dHJlYXQK4oyC4pag4pCA4pWRSeKImg&input=)
Both programs have been tested locally with the same 12 byte file, so this is a proper polyglot.
### How it works
In Jelly, every line defines a *link* (function); the last line defines the *main link*, which is executed automatically when the program is run. Unless the code before the last `7f` byte (the linefeed in Jelly's code page) contain a parser error (which would abort execution immediately), they are simply ignored. The last line, `“¡ṾI»` simply indexes into Jelly's dictionary to fetch the word **trick**, which is printed implicitly at the end of the program.
I don't know much about pl, but it appears that the interpreter only fetches one line of code and ignores everything that comes after it. As in Perl, barewords are treated as strings, so `treat` prints exactly that.
[Answer]
## Batch/sh, 30 bytes
```
:;echo Treat;exit
@echo Trick
```
Explanation. Batch sees the first line as a label, which it ignores, and executes the second line, which prints Trick. The @ suppresses Batch's default echoing of the command to stdout. (Labels are never echoed.) Meanwhile sh sees the following:
```
:
echo Treat
exit
@echo Trick
```
The first line does nothing (it's an alias of `true`), the second line prints Treat, and the third line exits the script, so the @echo Trick is never reached.
[Answer]
# sed / Hexagony 32 bytes
```
/$/ctrick
#$@$a</;r;e;/t;....\t;
```
---
# sed
[Try it Online!](http://sed.tryitonline.net/#code=LyQvY3RyaWNrCiMkQCRhPC87cjtlOy90Oy4uLi5cdDs&input=)
The first line prints `trick` if there is an empty string at the end of input. (sed doesn't do anything if there isn't input, but a blank line on stdin is allowed in this case)
**Example run:**
```
$ echo | sed -f TrickOrTreat.sed
trick
```
---
# Hexagony
[Try it Online!](http://hexagony.tryitonline.net/#code=LyQvY3RyaWNrCiMkQCRhPC87cjtlOy90Oy4uLi5cdDs&input=)
The first `/` redirects the instruction pointer up and the the left, so it wraps the the bottom left, skipping the text used for sed. It reuses the r from the sed code and runs a few others to no effect. The expanded hex looks like this:
```
   / $ / c 
  t r i c k
 # $ @ $ a <
/ ; r ; e ; /
 t ; . . . . 
  \ t ; . .
   . . . .
```
**Output:**
```
treat
```
[Answer]
# C# / Java
This probably doesn't qualify as it doesn't run on its own, but the challenge has reminded me of a quirk in how C# and Java handle string comparison differently that you can have some fun with for code obfuscation.
The following function is valid in C# and Java, but will return a different value...
```
public static String TrickOrTreat(){
    String m = "Oct";
    String d = "31";
    return m + d == "Oct31" ? "Trick" : "Treat";
}
```
[Answer]
# [Brain-Flak](https://github.com/DJMcMayhem/Brain-Flak) / Brain-Flueue, ~~265 253 219 165 139 115 113~~ 101 bytes
Includes +1 for `-A` 
Thanks to Wheat Wizard for going back and forth, golfing a few bytes off each others code, with me.
```
((((()()()))([]((({}{}))({}([((({}()())))]([](({}{}){}){}{})))[]))[])[()()])({}()()){}({})({}[][]){}
```
Brain-Flak: [Try it online!](https://tio.run/nexus/brain-flak#NYoxDoBQCEOvQ4d/CM9BGL6DifHHwZVwdiwYgaY0ryk1qAVEjcHDg7@HaKePwZo27KsS1FpaHcNfppFSaoQemTm2HGt/5nkfa14v)  
Brain-Flueue: [Try it online!](https://tio.run/nexus/brain-flak#NYpBCsBACAO/sznsI/oO8dDCFgpLD4U9iW@30VI1xDCJloNcoIkymJvzN29S6WPQogXrsgTRkmRH8ZdppJQooXlE9C36PJ79us@5xhov)
**Explanation:**  
The first section lists the values that Brain-Flak sees.  
When it switches to Brain-Flueue, I start listing the values as Brain-Flueue sees them.
```
# Brain-Flak
(
 (((()()()))             # Push 3 twice
  ([]                    # Use the height to evaluate to 2
   (
    (({}{}))             # Use both 3s to push 6 twice
    ({}                  # Use one of those 6s to evaluate to 6
     ([((({}()())))]     # Use the other 6 to push 8 three times and evaluate to -8
      ([](({}{}){}){}{}) # Use all three 8s to push 75
     )                   # The -8 makes this push 67
    )                    # The 6 makes this push 73
   [])                   # Use the height and the 6 to push 82
  )                      # Use the 2 to push 84
# Brain-flueue
 [])     # Use the height and 3 to push 84
[()()])  # Push 82
({}()()) # 67 is at the front of the queue, so use that to push 69
{}       # Pop one from the queue
({})     # 65 is next on the queue so move to the end
({}[][]) # 74 is next, so use that and the height to push 84
{}       # Pop that last value from TRICK
```
[Answer]
## PowerShell / Foo, 14 bytes
```
'trick'#"treat
```
The `'trick'` in PowerShell creates a string and leaves it on the pipeline. The `#` begins a comment, so the program completes and the implicit `Write-Output` prints `trick`.
In Foo, [(Try it Online!)](http://foo.tryitonline.net/#code=J3RyaWNrJyMidHJlYXQ&input=), the `'trick'` is ignored, the `#` causes the program to sleep for `0` seconds (since there's nothing at the array's pointer), then `"treat` starts a string. Since EOF is reached, there's an implicit `"` to close the string, and that's printed to stdout.
]