[Question]
  [
*This is [Calvin](https://codegolf.stackexchange.com/users/26997/calvins-hobbies). Just trying to get 20 rep so this user can chat in the [PPCG Minecraft Server chatroom](https://chat.stackexchange.com/rooms/24544/ppcg-minecraft-server).*
Write a program or function that takes in a positive integer.
If the integer is even (2, 4, 6, ...), print or return this exact ASCII art string:
```
                       __    __   __             __  ___
  /\  /\    |  |\  |  |     /    |  |     /\    |     |
 /  \/  \   |  | \ |  |--  |     |--\    /__\   |--   |
/        \  |  |  \|  |__   \__  |   \  /    \  |     |
```
If the integer is odd (1, 3, 5, ...), print or return this exact ASCII art string:
```
                       __    __
\        /  |  |  /|  |     /    |   /  \ __ /  |     |
 \  /\  /   |  | / |  |--  |     |--/    \  /   |--   |
  \/  \/    |  |/  |  |__   \__  |__|     \/    |__  _|_
```
You may assume the input is always a positive integer.
In both output cases there may optionally be any number of trailing spaces up to the right edge of the "T" on each line, and/or a single trailing newline. Note how there are two columns of spaces between each letter.
**The shortest code in bytes wins.**
  
[Answer]
# JavaScript (ES6), ~~343~~ ~~336~~ ~~289~~ ~~267~~ ~~265~~ 260 bytes
Just for fun... :) (Thanks to Xufox for cutting off 46 bytes, and encouraging me to cut off another 37 on my own.)
```
n=>`887141${n%2?`
98/202/05/4|3/29 1 /2|5|
 92/92/30 / 0--2|5|--/492/3|--3|
29/29/40/2013912|1|59/4|12_|_`:`3185121_
2/92/9409205/405/94|5|
 /29/2930 9 0--2|5|--94/193|--3|
/892029013912|392/492|5|`}`.replace(/\d/g,x=>+x?x<2?'__':x<9?' '.repeat(x):'\\':'|  |')
```
Called as `a(4)` or similar. Try it here:
```
a=n=>`887141${n%2?`
98/202/05/4|3/29 1 /2|5|
 92/92/30 / 0--2|5|--/492/3|--3|
29/29/40/2013912|1|59/4|12_|_`:`3185121_
2/92/9409205/405/94|5|
 /29/2930 9 0--2|5|--94/193|--3|
/892029013912|392/492|5|`}`.replace(/\d/g,x=>+x?x<2?'__':x<9?' '.repeat(x):'\\':'|  |')
document.getElementById("a").innerHTML = "<pre>"+a(2)+"</pre>";
document.getElementById("b").innerHTML = "<pre>"+a(3)+"</pre>";
```
```
<p id="a"></p>
<p id="b"></p>
```
I've condensed the whitespace into strings of digits from `2` to `8` (e.g. `887` = 23 spaces). Each digit is then replaced with the corresponding number of spaces. `0` represents `| |`, and `1` represents `__`. All in all, this program is 170 bytes shorter than the two strings combined (203 + 227 = 430), so I'm happy. :)
**Edit:** Somehow, it's exactly the same length as the only other entry at this point.... o\_o
**Edit 2:** Saved some space by changing `n%2<1?` to `n%2?` and swapping the strings. Also took advantage of the fact that the beginnings of the two strings are the same to reduce another 5 bytes.
**Edit 3:** `|2|` seemed to show up an awful lot, so simplified each occurence to `x`, saving 7 bytes. Xufox's suggestions cut off another 40 bytes.
**Edit 4:** Xufox's suggestion to replace `\n` with actual line breaks paid off, removing 6 bytes from the total. Changing `x` to `0` and `__` to `1` (insert evil laugh here), then combining all of the (insert plural of Regex here), as he did in his entry, saved an extra 16 bytes.
**Edit 5:** Since I've chosen to use the ES6 standards, I used custom template string interpolation to shave off 2 final bytes.
[Answer]
## Matlab, ~~343~~ 341
```
a=' -/\_|';
if mod(input(''),2)
x='003C00E00E000L0005N5000I000005550I0000I0055N4UVYO26R4004400400U005300UUXO060O060003C00C30CO00IO00UUUS060S5B54000';else
x='0I2000L0000L000E05H50C0000000555000C00C00H554UVYO26R4004400400U000250WUU006O006O0I2002I00O0I0O0C0UUU006S05BT0004';end
disp(a(reshape(dec2base(base2dec(reshape(x,[],7),36),6),4,[])-47))
```
The input number is provided from stdin.
Sample run:
```
>> a=' -/\_|';
if mod(input(''),2)
x='003C00E00E000L0005N5000I000005550I0000I0055N4UVYO26R4004400400U005300UUXO060O060003C00C30CO00IO00UUUS060S5B54000';else
x='0I2000L0000L000E05H50C0000000555000C00C00H554UVYO26R4004400400U000250WUU006O006O0I2002I00O0I0O0C0UUU006S05BT0004';end
disp(a(reshape(dec2base(base2dec(reshape(x,[],7),36),6),4,[])-47))
1
                       __    __   __             __  ___
  /\  /\    |  |\  |  |     /    |  |     /\    |     | 
 /  \/  \   |  | \ |  |--  |     |--\    /__\   |--   | 
/        \  |  |  \|  |__   \__  |   \  /    \  |     | 
```
[Answer]
# CJam, ~~158~~ ~~149~~ ~~145~~ 138 bytes
```
li2%"A+×rµ^ÅÆÿ»£ºoU#ü T^U^ÝZe<ÄÊKÞÒ£^ÛWWø5Úí§¹T^Úêer^^°^Ã}Ã^A0R2"281b7b"/
 -_\|"f=N/S3**_"_ ":T/TW%*4/zW%1m>N*1>"\/"_W%er"^W^]5OU"{i_32>T=t}/\4/zN*?
```
The above uses caret notation, since the code contains unprintable characters.
Try it online in the [CJam interpreter](http://cjam.aditsu.net/#code=li2%25%22A%2B%C3%97r%C2%B5%C2%85%C3%86%C3%BF%C2%BB%C2%A3%C2%BAoU%23%C3%BC%20T%15%C2%9DZe%3C%C3%84%C3%8AK%C3%9E%C3%92%C2%A3%C2%9BWW%C3%B85%C3%9A%C3%AD%C2%A7%C2%B9T%C2%9A%C3%AAer%1E%C2%B0%C2%83%7D%C3%83%010R2%22281b7b%22%2F%0A%20-_%5C%7C%22f%3DN%2FS3**_%22_%20%22%3AT%2FTW%25*4%2FzW%251m%3EN*1%3E%22%5C%2F%22_W%25er%22%17%1D5OU%22%7Bi_32%3ET%3Dt%7D%2F%5C4%2FzN*%3F&input=1).
If the permalink doesn't work in your browser, you can copy the code from [this paste](http://pastebin.com/EQTLJbqR).
### Example run
```
$ LANG=en_US
$ xxd -ps -r > minecraft.cjam <<< 6c69322522412bd772b585c6ffbba3ba6f5523fc2054159d5a653cc4ca4bded2a39b5757f835daeda7b9549aea65721eb0837dc30130523222323831623762222f0a202d5f5c7c22663d4e2f53332a2a5f225f20223a542f5457252a342f7a5725316d3e4e2a313e225c2f225f5725657222171d354f55227b695f33323e543d747d2f5c342f7a4e2a3f
$ cjam minecraft.cjam <<< 2; echo
                       __    __   __             __  ___
  /\  /\    |  |\  |  |     /    |  |     /\    |     | 
 /  \/  \   |  | \ |  |--  |     |--\    /__\   |--   | 
/        \  |  |  \|  |__   \__  |   \  /    \  |     | 
$ cjam minecraft.cjam <<< 1; echo
                       __    __                        
\        /  |  |  /|  |     /    |   /  \ __ /  |     | 
 \  /\  /   |  | / |  |--  |     |--/    \  /   |--   | 
  \/  \/    |  |/  |  |__   \__  |__|     \/    |__  _|_
```
### Idea
Instead of encoding the MINECRAFT string (padded to achieve a constant line length) directly, we'll encode a "zipped" version of it, where rows and columns have been transposed.
After zipping and removing the linefeeds, this string (let's call it **R**) has to be encoded:
```
   /  /  /   \    \   /  /   \    \    \         |||         ||| \    \    \ |||         |||_ -__ -_          |  / \_  __  _         |||_ - _ -  |\    \           /  /  /_  \_   \    \         |||_ - _ -         _   _|||_   
```
There are many runs of spaces, so we'll replace each occurrence of a space triplet with a linefeed.
This leaves us with seven different characters (`\n -/\_|`), so we assign each of them a number from **0** to **6** and consider the resulting array digits of a base 7 number, which we then encode as a byte string.
Decoding works by reversing the steps from above.
The mirrored string can be constructed from the original one.
If we reverse the order of the four rows and swap the soliduses, we obtain the following:
```
\        /  |  |  /|  |__   /__  |   /  \    /  |     | 
 \  /\  /   |  | / |  |--  |     |--/    \__/   |--   | 
  \/  \/    |  |/  |  |     \    |  |     \/    |     | 
                       __    __   __             __  ___
```
Somehow similar, but we'll clearly have to rotate the rows to bring the bottom row to the top:
```
                       __    __   __             __  ___
\        /  |  |  /|  |__   /__  |   /  \    /  |     | 
 \  /\  /   |  | / |  |--  |     |--/    \__/   |--   | 
  \/  \/    |  |/  |  |     \    |  |     \/    |     | 
```
That would be it if it wasn't for those pesky underscores.
If we read the original string from top to bottom and ignore linefeeds (thus obtaining **R**) and replace each underscore followed by space with a space followed by an underscore before shifting the rows, this is the result:
```
                         _     _                      _ 
\        /  |  |  /|  |_    /_   |   /  \ __ /  |     | 
 \  /\  /   |  | / |  |--  |     |--/    \  /   |--   | 
  \/  \/    |  |/  |  |__   \__  |__|     \/    |__  _|_
```
Much better! All that's left to do is deleting the first space of the first row (shifting all underscores in the first row one character left), moving the misplaced underscores in **E** and **C** one row up and discarding the underscore over **T**.
### Code
```
li2%           e# Read an integer from STDIN and push its parity.
"A+×rµ^ÅÆÿ»£ºoU#ü T^U^ÝZe<ÄÊKÞÒ£^ÛWWø5Úí§¹T^Úêer^^°^Ã}Ã^A0R2"
281b7b         e# Convert the byte string from base 281 to base 7.
"/\n -_\\|"f=  e# Replace each digit by its corresponding character.
N/S3**         e# Turn linefeeds into three spaces.
_              e# Copy the resulting string.
"_ ":T         e# Define T.
/TW%*          e# Replace occurrences of T with T reversed.
4/z            e# Split into chunks of length 4 and zip.
W%1m>          e# Reverse and rotate the rows.
N*             e# Join the rows, separating by linefeeds.
1>             e# Discard the first character.
"\/"_W%er      e# Swap the soliduses.
"^W^]5OU"      e# Push the string that corresponds to [23 29 53 79 85].
{              e# For each character:
  i            e#   Push its code point.
   _32>        e#   Push 1 iff the code point is larger than 32.
       T=      e#   Select the element at that index from T = "_ ".
         t     e#   Replace the element at the code point's index with that char.
}/             e#
\              e# Swap the partially generated MINECARFT string on top.
4/z            e# Split into chunks of length 4 and zip.
N*             e# Join the rows, separating by linefeeds.
?              e# Select the first string iff the input was odd.
```
[Answer]
# Pyth - 182 bytes
Uses base encoding approach. Since indexing is modular in Pyth, I don't even have to do anything for the even odd, just put it in the correct order, and use `@Q`. As a bonus this also works with negative numbers.
```
@mjbcs@L"_| /\\-"jCd6 56,"EWbòH\x00B)þKÙ£Ä­IOõìæ«FFãbÐÄBØ\«¼,vã<RN>­º:w÷ò¾<éifP9e|ÉWf!FÔèà""EWbòH\x00B)þOHÿ$@ËþçX'D[¾«Â?°´=&£üá ¹»ázH×Æz3äkÕg{`!|ðY!ðGV"Q
```
I had tries only encoding the first one, then flipping and switching the slashes, but the first and last line were too hard.
I could save 6 bytes by putting actual null bytes in the code, but that's too much trouble.
[Try it online here](http://pyth.herokuapp.com?code=%40mjbcs%40L%22_%7C%20%2F%5C%5C-%22jCd6%2056%2C%22%03EWb%C3%B2H%5Cx00B%C2%8E)%C3%BEK%C3%99%C2%A3%C3%84%C2%AD%1AIO%C3%B5%C2%81%C3%AC%C3%A6%C2%ABF%15F%C3%A3b%C3%90%C3%84B%C2%92%C3%98%5C%C2%AB%C2%BC%2Cv%1D%C3%A3%3C%02R%1CN%C2%98%02%3E%C2%AD%C2%BA%3Aw%C3%B7%C3%B2%C2%BE%3C%C3%A9ifP9e%7C%C3%89W%12f!F%C3%94%C3%A8%C3%A0%22%22%03EWb%C3%B2H%5Cx00B%C2%8E)%C3%BEOH%C3%BF%24%40%C3%8B%C3%BE%0B%C3%A7X%06%01%27%C2%96%C2%85D%C2%91%5B%C2%BE%C2%AB%C3%82%3F%C2%B0%C2%B4%3D%26%C2%A3%C2%93%C3%BC%C3%A1%C2%87%20%C2%B9%C2%BB%02%C3%A1zH%C3%97%C3%86z%C2%8E3%C3%A4k%C3%95g%7B%60!%7C%C3%B0%C2%8D%1BY!%11%C3%B0%15%1CGV%22Q&input=4&debug=1).
It looks really bad online because the output box is too small and wraps. I recommend fiddling with the dev-console and changing the `col-md-5` to a `col-md-7`.
[Answer]
# JavaScript (ES6), ~~312~~, ~~285~~, ~~281~~, ~~272~~, ~~270~~, ~~263~~, ~~262~~, 260
*For previous edits see the [edit history](https://codegolf.stackexchange.com/posts/53980/revisions).*
**Edit 5:** In the conversion, I switched the number associated with `-` (now 0) and whitespace (now 1). In the resulting block, the numbers 1, 2 and 3 weren’t used as much anymore. This allowed me to use an array with the missing numbers.
**Edit 6:** Improved the array literal. I tried this previously, but used `777` and `77` as strings instead of numbers and noticed only now that I had missed this.
**Edit 7:** The “Golfed code” is a function, as specified by the question and there’s no need for `f=` to meet this specification. Thus, removing it, saving two bytes.
---
Runnable in Firefox 39:
```
// Testing:
f=
// Golfed code:
n=>[...`11111113ss17ss1pp11117pp3ppp
97dj3dj7822j78z213e17z3v8397gm78212
7f3kf3k1z27k7z20021200k17fppk1z001z
d7983987j2287jz2ss1lss2aabj3d7987j2aa3aza`.replace(/[123]/g,x=>[,777,'77z',77][x])].map(a=>isNaN(i=parseInt(a,36))?a:'- /\\_|'[n%2?i%6:~~(i/6)]).join``
// Testing:
;document.body.appendChild(document.createElement('pre')).innerHTML=f(0);
document.body.appendChild(document.createElement('pre')).innerHTML=f(1);
document.body.appendChild(document.createElement('pre')).innerHTML=f(2);
document.body.appendChild(document.createElement('pre')).innerHTML=f(35);
```
It’s based on the base 6 number system and each ASCII character stands for a number:
```
"-": 0
" ": 1
"/": 2
"\": 3
"_": 4
"|": 5
```
Then, I’ve combined the number representation of each ASCII string. For example: when the first ASCII string contains a `/` at one position and the *other one* contains a `\` at *the same position*, that position becomes `32`, which is base 6 (`20` in decimal). If you convert this to base 36 (to get *one* base-36 number for every *two* base-6 numbers), you get `k`.
All this was done beforehand and the function basically undoes this process.
~~Now the two JavaScript answers both have one other answer each, that has the same byte count…~~
---
PS: As a note to myself and a reference to others, this is the code I used:
```
// 1. ASCII here
a=`|\\-/ _`;
// 2. ASCII here
b=`/|\\_ -`;
// Note: the ASCII strings’ backslashes have to be escaped!
[...a]
  .map((c,i)=>parseInt((c+b[i])
    .replace(/-/g,'0')
    .replace(/ /g,'1')
    .replace(/\//g,'2')
    .replace(/\\/g,'3')
    .replace(/_/g,'4')
    .replace(/\|/g,'5'),6))
  .map(c=>isNaN(c)
    ?`
`
    :c.toString(36))
  .join``
// Returns "wn3g7o", which is then put into the function as the block at the top.
```
[Answer]
# CJam, 136 bytes
```
"^ASÓ8¥È÷^K¯¾/^HÕ2^ÄË1jÒÝ^D^Á0îl;)HR§û|^Ê^Þ^ÇÝÅ^ßNlz^TfÑ^Øj>À^Ã 4#bH\¿^Äî·íì^E^A~(¿ø³(ú´,^È(¡j>è?#'»vçPïju87)×"
265b8b[S9*'|3*+S2*]"/-_\| "+f=s4/56/ri=zN*
```
The above uses caret notation, since the code contains unprintable characters.
The linefeed is solely for "readability". Try it online in the [CJam interpreter](http://cjam.aditsu.net/#code=%22%01S%C3%938%C2%A5%C3%88%C3%B7%0B%C2%AF%C2%BE%2F%08%C3%952%C2%84%C3%8B1j%C3%92%C3%9D%04%C2%810%C3%AEl%3B)HR%C2%A7%C3%BB%7C%C2%8A%C2%9E%C2%87%C3%9D%C3%85%C2%9FNlz%14f%C3%91%C2%98j%3E%C3%80%C2%83%204%23bH%5C%C2%BF%C2%84%C3%AE%C2%B7%C3%AD%C3%AC%05%01~(%C2%BF%C3%B8%C2%B3(%C3%BA%C2%B4%2C%C2%88(%C2%A1j%3E%C3%A8%3F%23'%C2%BBv%C3%A7P%C3%AFju87)%C3%97%22265b8b%5BS9*'%7C3*%2BS2*%5D%22%2F-_%5C%7C%20%22%2Bf%3Ds4%2F56%2Fri%3DzN*&input=2).
If the permalink doesn't work in your browser, you can copy the code from [this paste](http://pastebin.com/XA5WBE86).
### Example run
```
$ LANG=en_US
$ xxd -ps -r > minecraft.cjam <<< 220153d338a5c8f70bafbe2f08d53284cb316ad2dd048130ee6c3b294852a7fb7c8a9e87ddc59f4e6c7a1466d1986a3ec08320342362485cbf84eeb7edec05017e28bff8b328fab42c8828a16a3ee83f2327bb76e750ef6a75383729d7223236356238625b53392a277c332a2b53322a5d222f2d5f5c7c20222b663d73342f35362f72693d7a4e2a
$ cjam minecraft.cjam <<< 2; echo
                       __    __   __             __  ___
  /\  /\    |  |\  |  |     /    |  |     /\    |     | 
 /  \/  \   |  | \ |  |--  |     |--\    /__\   |--   | 
/        \  |  |  \|  |__   \__  |   \  /    \  |     | 
$ cjam minecraft.cjam <<< 1; echo
                       __    __                        
\        /  |  |  /|  |     /    |   /  \ __ /  |     | 
 \  /\  /   |  | / |  |--  |     |--/    \  /   |--   | 
  \/  \/    |  |/  |  |__   \__  |__|     \/    |__  _|_
```
### Idea
This approach has some similarities to the one in [my other answer](https://codegolf.stackexchange.com/a/53973), but it is a lot simpler and (rather disappointingly) a bit shorter.
We search for a way to encode the following string:
```
                       __    __   __             __  ___                       __    __                         
  /\  /\    |  |\  |  |     /    |  |     /\    |     | \        /  |  |  /|  |     /    |   /  \ __ /  |     | 
 /  \/  \   |  | \ |  |--  |     |--\    /__\   |--   |  \  /\  /   |  | / |  |--  |     |--/    \  /   |--   | 
/        \  |  |  \|  |__   \__  |   \  /    \  |     |   \/  \/    |  |/  |  |__   \__  |__|     \/    |__  _|_
```
After padding each row (to achieve a constant line length), zipping (transposing rows and columns) and removing the linefeeds, this string has to be encoded:
```
   /  /  /   \    \   /  /   \    \    \         |||         ||| \    \    \ |||         |||_ -__ -_          |  / \_  __  _         |||_ - _ -  |\    \           /  /  /_  \_   \    \         |||_ - _ -         _   _|||_    \    \    \   /  /   \    \   /  /  /           |||         |||   /  /  /   |||         |||_ -__ -_          |  / \_  __  _         |||  -_  -_  /| /           \    \  _ \ _ /  /  /           |||  -_  -_           _ |||   _
```
We'll replace each substring `" |||"` with a **0**, each substring `" "` with a **1** and the characters of `"/-_\| "` with **2** to **7**, forming an array of base 8 digits, which can be encoded as a byte string.
Decoding works by reversing the steps from above.
### Code
```
"^ASÓ8¥È÷^K¯¾/^HÕ2^ÄË1jÒÝ^D^Á0îl;)HR§û|^Ê^Þ^ÇÝÅ^ßNlz^TfÑ^Øj>À^Ã 4#bH\¿^Äî·íì^E^A~(¿ø³(ú´,^È(¡j>è?#'»vçPïju87)×"
265b8b        e# Convert from base 265 to base 8.
[S9*'|3*+S2*] e# Push ["         |||" "  "].
"/-_\| "+     e# Concatenate to push ["         |||" "  " '/' '-' '_' '\' '|' ' '].
f=            e# Select the elements that correspond to the base 8 digits.
s4/           e# Flatten and chop into chunks of length 4 (columns).
56/           e# Chop into two subarrays of 56 columns.
ri            e# Read an integer from STDIN.
=             e# Select the corresponding subarray.
              e# Arrays wrap around, so [A B]0= eq. [A B]2= and [A B]1= eq. [A B]3=.
zN*           e# Zip and join the rows, separating by linefeeds.
```
[Answer]
# Racket, ~~443~~ ~~434~~ 386 Bytes
```
(require file/gunzip net/base64)(define(f n)(define o(open-output-bytes))(gunzip-through-ports(open-input-bytes(base64-decode #"H4sIAK8Lt1UAA22Q3Q3AIAiE352CBcwtRHLpHg7f8lubahRUDuVD5DjItrH9REgOEWgskfVMDeca1GWcSmN2WFBtlUTdzdmSOT0BpEpGnjxUAf2RmvPq1OyKGF6N5V1nvgYcWjeod/Hj8JotBRtH0qM48OeoWrBxJH23KL/dOMh4IDXe8MUbT1AqtKkBAAA="))o)(list-ref(string-split(get-output-string o)"a")(modulo n 2)))
```
Just for kicks.
```
(require file/gunzip net/base64)
(define (f n)
  (define o (open-output-bytes))
  (gunzip-through-ports
   (open-input-bytes
    (base64-decode #"H4sIAK8Lt1UAA22Q3Q3AIAiE352CBcwtRHLpHg7f8lubahRUDuVD5DjItrH9REgOEWgskfVMDeca1GWcSmN2WFBtlUTdzdmSOT0BpEpGnjxUAf2RmvPq1OyKGF6N5V1nvgYcWjeod/Hj8JotBRtH0qM48OeoWrBxJH23KL/dOMh4IDXe8MUbT1AqtKkBAAA="))
   o)
  (list-ref (string-split (get-output-string o) "a") (modulo n 2)))
```
N.B. you may need the `#lang racket` line to run in DrRacket.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), ~~179~~ ~~177~~ 176 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
"
 -/\_|"•ÿ%Ò´Åçδ’Üå·Äm…½µƵδø5)ǝ®∊∊Ý®þCĀ₆áÝoþ²ši¤Æ%ßû¤%¦Ï≠θĀ5¾₃ʒŸQ>Šn°η8±8d¸6':…é’b…÷‡ö©«&‡huÑ¦%λÁZÊJÌ₅ú∞°»ó₄ι«ÓW´×ƒ×ùqiò2D1āwθóÆË²’
Tι#и∊²ý‚KʒFæΩZºÿÏ";ηiʒæøвøïž‚è°ć½∊•7вèJ2äIè
```
[Try it online.](https://tio.run/##FY9BSwJRFIX3/YowpmgRpWBKQZsiyFZBEEgQSUEuKlpEmxbjpGYWSNNCiiwVmxShbNTmqTjCPTMGLh7@hvdHpiecxQf3cM85S8HDmP/Y83xT0wuL@wfXPqGWMVCgUwspfPKWUJ/xig@ykDwVqkF9ag/bvAUWnP8r0JfIZKUgCfa6owotjRIK57DJdEtxqiCt4B09qihkICfuipw5apBsod2MdJftrLnFM2pwK0w/4SNiy3MrMgQ1mRqbgCXUEn6pRvVZSSeXeCRD4T0koshG8CC0FLoi80YN6qEptCTvUB1Pe7J8fqgjj85FHGZgw@8krjhDE2nckymfT@3yzsyYyepkoi/Ul@2RvgmD16LUxQA53yq34iMdBtjYBMO3a0sTqtRwbqk/Ga2WQ/JSjQRQ2ULV80L/)
**Explanation:**
```
•ÿ%Ò´Åçδ’Üå·Äm…½µƵδø5)ǝ®∊∊Ý®þCĀ₆áÝoþ²ši¤Æ%ßû¤%¦Ï≠θĀ5¾₃ʒŸQ>Šn°η8±8d¸6':…é’b…÷‡ö©«&‡huÑ¦%λÁZÊJÌ₅ú∞°»ó₄ι«ÓW´×ƒ×ùqiò2D1āwθóÆË²’
Tι#и∊²ý‚KʒFæΩZºÿÏ";ηiʒæøвøïž‚è°ć½∊•
```
is the [compressed number](https://codegolf.stackexchange.com/a/166851/52210):
```
669530978249988431396781816197276307266403407188962925862194299697873953319419752813246251351417090709766331736351616127424760949905163941809417778114834562736028512279028673309866195447599979612590918985644583407413903825059942009898007791080822453262749380245316127735585410697701790387188175543639634091138422651942833048832372950797322005040161476426127678479662921265139425
```
[Try it online.](https://tio.run/##FY/NSgJRHMX3PUYxRbsMLCloU7SoVRAE7pKCZlHRItpeJzWzQJoWUmSp2NQg1DSOzVVxhP@ZMXBx8Rnui0xXOIvf4nA@lpKHmcRxHEvWwFCDSR7y@BCeZE94wTv5yJ1KZtGAOqOO8MCTi39V@pLFkhIUIdgMmTQKqKN6joDcqK5TEwUNb@hTUyMLZXlbEzxkSQqkcT02I763EdXOyBF@in5SR8RXFtZUCWzVmpmCL1kdv2RTa17RySUeyNJEH9k0Sju4l0YePVl8JYf6aEsjJ7rUwuOBGl8Zmaige6HDXd5KhNkrwdFGAXfkqvCZfdGdm3A1nVwMJHveHZvbsISdph6GKM@uC18fm7DAJy44vqNAmfBJTnhDg@lp1ojj1X8)
`7в` converts it to Base-7 as list, so we get the list of digits:
```
[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,5,5,1,1,1,1,5,5,1,1,1,5,5,1,1,1,1,1,1,1,1,1,1,1,1,1,5,5,1,1,5,5,5,0,1,1,3,4,1,1,3,4,1,1,1,1,6,1,1,6,4,1,1,6,1,1,6,1,1,1,1,1,3,1,1,1,1,6,1,1,6,1,1,1,1,1,3,4,1,1,1,1,6,1,1,1,1,1,6,0,1,3,1,1,4,3,1,1,4,1,1,1,6,1,1,6,1,4,1,6,1,1,6,2,2,1,1,6,1,1,1,1,1,6,2,2,4,1,1,1,1,3,5,5,4,1,1,1,6,2,2,1,1,1,6,0,3,1,1,1,1,1,1,1,1,4,1,1,6,1,1,6,1,1,4,6,1,1,6,5,5,1,1,1,4,5,5,1,1,6,1,1,1,4,1,1,3,1,1,1,1,4,1,1,6,1,1,1,1,1,6,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,5,5,1,1,1,1,5,5,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,4,1,1,1,1,1,1,1,1,3,1,1,6,1,1,6,1,1,3,6,1,1,6,1,1,1,1,1,3,1,1,1,1,6,1,1,1,3,1,1,4,1,5,5,1,3,1,1,6,1,1,1,1,1,6,0,1,4,1,1,3,4,1,1,3,1,1,1,6,1,1,6,1,3,1,6,1,1,6,2,2,1,1,6,1,1,1,1,1,6,2,2,3,1,1,1,1,4,1,1,3,1,1,1,6,2,2,1,1,1,6,0,1,1,4,3,1,1,4,3,1,1,1,1,6,1,1,6,3,1,1,6,1,1,6,5,5,1,1,1,4,5,5,1,1,6,5,5,6,1,1,1,1,1,4,3,1,1,1,1,6,5,5,1,1,5,6,5]
```
[Try it online.](https://tio.run/##FY/NSgJRHMX3PUYxRbsMTCloU7SoVRAE7pKCXFS0iLbXSSezQJoWUmSp6JQIZaM2d5QZ4X9mDFxcfIb7ItMVzuK3OJyPlfhROnYSRZLVMdJgUg95fIieZM94RZMc5M4ks8ij/rgveuDx5b8KfclCUQmK4G8FTOoGaqhcwCc7rGWoAUPDO4bU0MhCSd5VBQ9YnHyp30zMkO9vhtVz6ggnST/JY@JrS@uqBC3Vmp6BI1kNv9Si9qKi0ys8kqWJIbIpFHfxIPU8BrLwRh0aoiv1nHCpjadDNb48NlGGe5mBvbodC7LXgqMLA/dkq/C5A@EuTLmaTjY8yV72JuYOLNFK0QAjlOY3hJOZmLDApzY4vkNfmfBJneCWvNlpVk9M7ShK/AM)
`è` indexes each digit in the string `"\n-/\_|"`, and `J` then joins the entire list together, which gives us the following:
```
                       __    __   __             __  ___
  /\  /\    |  |\  |  |     /    |  |     /\    |     |
 /  \/  \   |  | \ |  |--  |     |--\    /__\   |--   |
/        \  |  |  \|  |__   \__  |   \  /    \  |     |                       __    __                        
\        /  |  |  /|  |     /    |   /  \ __ /  |     |
 \  /\  /   |  | / |  |--  |     |--/    \  /   |--   |
  \/  \/    |  |/  |  |__   \__  |__|     \/    |__  _|_
```
[Try it online.](https://tio.run/##FY9BSwJRFIX3/YowpmgRZWBKQZuiha2CIJAgkoJcVLSINi2ek5pZIE0LKbJUbFKEslHzqTjCPTMGLh7@hvdHpiecxQf3cM85S4HDqP/Y83xT0wuL@wfXPslKGGgwqIkkPkVTsme84oPaSJxKZlKfWsOWaIIH5v/y9CXTGSUogr3hMKmnUET@HDZZbjFGZaQ0vKNHZY1MZOVdQXCHBciW@s3IcPnOuls4o7poh@gndER8ZW5VhaCqUqMTaEtWxC9VqTar6OQSj2Rqood4BJkwHqSeRFem36hOPTSknhAdquFpT5XPDQ3k0LmIwVre9DvxK8HRQAr3ZKnnU7uiMzPmqjpZ6Ev2sj0ytmCKaoS6GCDrWxPt2MiACT62wPHt2sqECtWdW@pPRrNSUF0qYc8L/gM)
`2ä` splits the string into two parts.  
`Iè` take the input, and indexes it (with automatic wrap-around) to get one of the two parts, which is then being output implicitly.
Huge thanks to [*@MagicOctopusUrn*'s ASCII compressor](https://codegolf.stackexchange.com/a/120966/52210) which was used to generate the compressed number and Base-7 transliteral. [Try it online.](https://tio.run/##fVE7DsIwDN17iih7ZH69QMWEmJgjWSAhDsCaoVcpC4KhIwsSQyou0ouEOIlDUSui5jnNe4n9nFm5P8yPzhn7XHd3e3u/tru@bmx76h6LsqxkX1/kOaDfkxXxcrnqrrYl9EQjN86J6YGYMS5/GEQshAAdpxDGfzqGoAHejH@sISyI1DRZokNQKkuUCgcAUYvE@HPABeREmkKoThOayMFXk7P@9Tc5Cs0r4HQwshes0CUwsJeaAmwPxva4RBjYS03JnUtpB/YQ4wVJE97B4Ac) (After which the transliterate has been golfed by reversing the string and number on the stack, using `в` instead of `B` to make it a list of digits, and index into the string with `è`.
[Answer]
# C, 251 bytes
```
k(w){char*f="_-/\\|]^^^\0<&*&)&3&(&&WX&J&*&\0t_&/&3&\0`);35)I5M\0a).@7).8-;./.-\0j()(0(1+4()(*+4+4()(04+",*o=f+4,m[229]="",i=7,c=10,p;for(memset(m,32,228);i;c=*f++^(w%2&i--/2==2)*115)for(p=0;*++o;m[(w%2?4-i/6-p/57:p/57)*57+p%57]=c)p+=*o-37;printf(m);}
```
This is a function `k` that receives a parameter and prints the message to `stdout`.
A more readable version:
```
k(w)
{
    char*f="\n_-/\\|", // characters to fill in
        *o= " "// for each character, the list of positions to put it in, difference-encoded
        "]%%^^^\0"                  // for '\n' (newline)
        "<&*&)&3&(&&WX&J&*&\0"      // for '_' (underscore)
        "t_&/&3&\0"                 // for '-' (minus)
        "`);35)I5M\0"               // for '/' or '\' (slashes)
        "a).@7).8-;./.-\0"          // for '\' or '/' (slashes)
        "j()(0(1+4()(*+4+4()(04+",  // for '|' (vertical bar)
        m[229]="",  // message to generate
        i, // index of character, running 7...1
        c, // current character to fill in
        p, // where to place the character
        y; // y-coordinate of the character
    memset(m,32,228); // fill the message with spaces
    for(i=7;--i;)
    {
        c=*f++;
        c^=~w%2|i/2^1?0:115; // flip the direction of slashes, if needed
        for(p=0;*++o;)
        {
            p+=*o-37; // jump to next position
            y=p/57; // extract the y-coordinate
            y=w%2?4-i/5-y:y; // flip the y-coordinate, if needed
            m[y*57+p%57]=c; // place the character
        }
    }
    printf(m); // print the message
}
```
First, it prepares an empty message (filled with spaces). For each character (e.g. `|` or `-`), it has a list of positions to place that character in.
For each position, if the upside-down version should be printed, the position is flipped. That is, its vertical coordinate `y` is replaced by `4-y` or `3-y` (depending on whether the character is an underscore). Also, the directions of the slashes are flipped - this is performed by a `XOR` with `115`.
This control structure is also used to place the newline characters - it seems more efficient to add 4 more coordinates to the list than to write an explicit loop.
---
There are a few minor glitches with this system. First of all, the final letter T looks a bit different in the flipped version:
```
___ 
 |    |
 |    |
 |   _|_
```
To output it correctly, the code has to place the `|` characters after the `_` characters.
In addition, in order to make sure the control string contains only ASCII characters, I encoded it:
* It records the differences between the positions instead of the positions themselves - this reduces the range
* The numbers in the string have `37` added to them, to shift them into the ASCII Range 32...127. I could add a smaller number, but `37` avoids characters like `"` and `\`, which have to be escaped inside string literals.
* Two of the numbers were greater than 127 - for example, the first `-` character appears at position 137. To account for this, I added an artificial `-` character at another position (79), which is later overwritten - the character `|` also appears at position 79.
---
Another funny thing was that I couldn't use `puts` to output the string - this would produce an extra trailing newline. So I used `printf` instead.
Also, the number `57` appears 4 times in the golfed code - the seemingly long-winded expression `(w%2?4-i/6-p/57:p/57)*57+p%57` makes it possible to eliminate the variable `y`, making the code shorter.
[Answer]
# Perl, ~~292~~ ~~259~~ 246 bytes
```
$_="Svv __SS__S nnSv nnSnnn
i kjSkj hw|j h|wS /SwrhSi pq hwS |
 mSlmSlS |S| l |S|--wS |--lSSmnnlS |--S |
k ihSih jw|h j|S|__S g__S|oosjSk ih jS|ooSo|o";s/v/SSSSS/g;s/w/S|S/g;s/S/  /g;<>&1?y"g-s"\\/\\  /\\ ___ |":y"g-s"\\  \\/\\/_ /\\| ";print $_
```
It takes advantage of the fact that the two strings are mostly similar (e.g. the entire I E and C) and makes the string out of characters that are displayed differently depending on which version is being displayed. e.g m means "a forward slash for the right-way-up string, a backward slash in the upside down one". It does a transliteration substitution to display the correct character. Spaces are also run-length encoded using string substitutions.
multi-line:
```
$_="Svv __SS__S nnSv nnSnnn
i kjSkj hS|S|j h|S|SS /SS|SrhSi pq hS|SS |
 mSlmSlS |S| l |S|--S|SS |--lSSmnnlS |--S |
k ihSih jS|S|h j|S|__S g__S|oosjSk ih jS|ooSo|o";
s/v/SSSSS/g;
s/w/S|S/g;
s/S/  /g;
<>&1?
    y"g-s"\\/\\  /\\ ___ |"
:
    y"g-s"\\  \\/\\/_ /\\| ";
print $_
```
Idea:
Since there are only 22 unique columns in the output, it should be possible to store it as 22\*4 = 88 characters with a range of 0-17 (all the possible "dual-meaning" characters), along with a 56 character lookup table with one entry in the range of 0-21 per column. In theory this could be encoded with < 100 bytes however it's hard to make this a net win because of the more complicated code to decode it.
[Answer]
# CJAM, 206
The two ascii pictures are base-216 encoded, one byte = 3 characters.
```
" _\/|-":A;S7*"!D!D"+:B;qi2%{B"h  °°¤8 2 °2,J° °"",4# °³8=Ô° Ó\"# Ó °""\"z °Â89D-D·° z ·!¶"}{B"'    '!J"+"#h °¼88 2 °°  ° °""2/\" °²8=Ô° Óh#L Ó °""  h°°9D-D°,2 h° °"}?]{{i32-__36/A=@6/6%A=@6%A=}/N}/
```
Test it [here](http://cjam.aditsu.net/#code=%22%20_%5C%2F%7C-%22%3AA%3BS7*%22!D!D%22%2B%3AB%3Bqi2%25%7BB%22h%20%20%C2%8C%C2%B0%C2%B0%C2%A48%202%20%C2%B02%2CJ%C2%8C%C2%B0%20%C2%B0%22%22%2C4%23%20%C2%B0%C2%B38%3D%C3%94%C2%B0%20%C3%93%C2%8C%5C%22%23%20%C3%93%20%C2%B0%22%22%5C%22%C2%8Cz%20%C2%B0%C3%8289D-D%C2%B7%C2%B0%20z%20%C2%B7!%C2%B6%22%7D%7BB%22'%20%20%20%20'!J%22%2B%22%23h%C2%98%20%C2%B0%C2%BC88%202%20%C2%B0%C2%B0%20%C2%98%20%C2%B0%20%C2%B0%22%222%2F%5C%22%20%C2%B0%C2%B28%3D%C3%94%C2%B0%20%C3%93h%23L%20%C3%93%20%C2%B0%22%22%C2%8C%20%20h%C2%B0%C2%B0%C2%809D-D%C2%B0%2C2%20h%C2%B0%20%C2%B0%22%7D%3F%5D%7B%7Bi32-__36%2FA%3D%406%2F6%25A%3D%406%25A%3D%7D%2FN%7D%2F&input=2)
[Answer]
# Powershell, ~~275~~ ~~253~~ 248 bytes
```
param($n)$d='8 \83484/7/484302 92984308 92918--118--128||6//0\16116129558| \/ |8 /02083\6/10018/6\302 955776_71 9_7_'
'8\,__,777,/6 /,\6/6\,_8 -- _,88,888,  ,||||||'-split','|%{$d=$d-replace+$i++,$_}
0..3|%{$l=$_;-join$d[(0..55|%{$_*8+$l*2+$n%2})]}
```
Test script:
```
$f = {
param($n)$d='8 \83484/7/484302 92984308 92918--118--128||6//0\16116129558| \/ |8 /02083\6/10018/6\302 955776_71 9_7_'
'8\,__,777,/6 /,\6/6\,_8 -- _,88,888,  ,||||||'-split','|%{$d=$d-replace+$i++,$_}
0..3|%{$l=$_;-join$d[(0..55|%{$_*8+$l*2+$n%2})]}
}
&$f 2
&$f 1
```
Output:
```
                       __    __   __             __  ___
  /\  /\    |  |\  |  |     /    |  |     /\    |     |
 /  \/  \   |  | \ |  |--  |     |--\    /__\   |--   |
/        \  |  |  \|  |__   \__  |   \  /    \  |     |
                       __    __
\        /  |  |  /|  |     /    |   /  \ __ /  |     |
 \  /\  /   |  | / |  |--  |     |--/    \  /   |--   |
  \/  \/    |  |/  |  |__   \__  |__|     \/    |__  _|_
```
## Main ideas
The compression method is extended method of [CJam](https://codegolf.stackexchange.com/a/53973/80745) by Dennis♦:
1. Create a string before compression:
	* chars of the first column of both ASCII arts, then
	* chars of the second column, then
	* chars of the third column and so on...
2. Compress using 10 consecutive replacements (10 because Powershell can use numbers 0..9 as strings, this makes the decompress algorithm shorter. Replacements found by brute force.)
The script for compression:
```
$src =
"                       __    __   __             __  ___", # line1, art1
"                       __    __                         ", # line1, art2
"  /\  /\    |  |\  |  |     /    |  |     /\    |     | ", # line2, art1
"\        /  |  |  /|  |     /    |   /  \ __ /  |     | ", # line2, art2
" /  \/  \   |  | \ |  |--  |     |--\    /__\   |--   | ", # line3, art1
" \  /\  /   |  | / |  |--  |     |--/    \  /   |--   | ", # line3, art2
"/        \  |  |  \|  |__   \__  |   \  /    \  |     | ", # line4, art1
"  \/  \/    |  |/  |  |__   \__  |__|     \/    |__  _|_"  # line4, art2
$z=-join(0..$src[0].Length|%{
    $p=$_
    $src|%{$_[$p]}
})
$z
```
The before compression string is:
```
   \  /     /\    /    \  \    /    \/      /\    /    \  \    /    \/     /  \                   ||||||                  ||||||  \    /    \/     /  \   ||||||          ||||||__  --____  --__                    ||    //  \\__    ____    __                  ||||||_   -- __   -- _  | \/ |   /  \                    \  /     /\  /__  \  \__  /    \/     /  \                   ||||||_   -- __   -- _                _      __ ||||||_      _
```
[Answer]
## SAS, 442 bytes
```
%macro a(b);&b=tranwrd(&b,put(i,1.),repeat('A0'x,i));%mend;%macro b(z);length a b c d$99;if mod(&z,2)then do;a='992__3__';b='\7/1|1|1/|1|4/3|2/1\0__0/1|4|';c='0\1/\1/2|1|0/0|1|--1|4|--/3\1/2|--2|';d='1\/1\/3|1|/1|1|__2\__1|__|4\/3|__1_|_';end;else do;a='992__3__2__65__1___';b='1/\1/\3|1|\1|1|4/3|1|4/\3|4|';c='0/1\/1\2|1|0\0|1|--1|4|--\3/__\2|--2|';d='/7\1|1|1\|1|__2\__1|2\1/3\1|4|';end;do i=0to 9;%a(a)%a(b)%a(c)%a(d)end;put a/b/c/d;%mend;`
```
Non-golfed:
```
%macro a(b);
  &b=tranwrd(&b,put(i,1.),repeat('A0'x,i));
%mend;
%macro b(z);
length a b c d$99;
if mod(&z,2)then do;
  a='992__3__';
  b='\7/1|1|1/|1|4/3|2/1\0__0/1|4|';
  c='0\1/\1/2|1|0/0|1|--1|4|--/3\1/2|--2|';
  d='1\/1\/3|1|/1|1|__2\__1|__|4\/3|__1_|_';
end;
else do;
  a='992__3__2__65__1___';
  b='1/\1/\3|1|\1|1|4/3|1|4/\3|4|';
  c='0/1\/1\2|1|0\0|1|--1|4|--\3/__\2|--2|';
  d='/7\1|1|1\|1|__2\__1|2\1/3\1|4|';
end;
do i=0to 9;
  %a(a)
  %a(b)
  %a(c)
  %a(d)
end;
put a/b/c/d;
%mend;
```
Tests:
```
data a;
  %b(1)
  %b(2)
  %b(0)
  %b(35)
run;
                       __    __
\        /  |  |  /|  |     /    |   /  \ __ /  |     |
 \  /\  /   |  | / |  |--  |     |--/    \  /   |--   |
  \/  \/    |  |/  |  |__   \__  |__|     \/    |__  _|_
                       __    __   __             __  ___
  /\  /\    |  |\  |  |     /    |  |     /\    |     |
 /  \/  \   |  | \ |  |--  |     |--\    /__\   |--   |
/        \  |  |  \|  |__   \__  |   \  /    \  |     |
                       __    __   __             __  ___
  /\  /\    |  |\  |  |     /    |  |     /\    |     |
 /  \/  \   |  | \ |  |--  |     |--\    /__\   |--   |
/        \  |  |  \|  |__   \__  |   \  /    \  |     |
                       __    __
\        /  |  |  /|  |     /    |   /  \ __ /  |     |
 \  /\  /   |  | / |  |--  |     |--/    \  /   |--   |
  \/  \/    |  |/  |  |__   \__  |__|     \/    |__  _|_
```
Could possibly save a bit of code by putting them in input blocks, but that adds the restriction that the macro can only be once per datastep which I feel violates the spirit of writing it as a macro. (And I suspect adding a prompt to get input in the datastep adds more characters).
[Answer]
# bash, 247 bytes
```
(($1%2)) && c=tail || c=head
base64 -d <<<H4sIAF/3uFUCA31Q2w3AIAj8ZwoWMLcQyS3i8JWXtWlTI6BwPA7Vz0Nunc9HhKSowlJU57qWJjBoZ/4a41o8aC4NsTBjbMgYkQDStCIrDz3AbmRuYjpzPTOGG5P9/gmKtQddFy8eMbOn4Khb7NE88ObRs+DgUez3iqrtwYPMAoWJhU/KBeJFPOCqAQAA | zcat | $c -n4
```
Strings are concatenated and gziped.
[Answer]
# PHP, 225 bytes
Ugly, brute-force solution.
```
echo str_split(gzinflate(base64_decode('dZDdDcAgCITfnYIFzC1Ecos4fOW3Nm2NgsohfIp8DrJtbB8RkkMEGktk7anhXIO6jFNpzA4Lqq2SqLs5WzKnJ4BUycjOQzXQhdScd6dmV8Rwa7rqP9/QukE9ixeGt2wpODASHoWBN0a1ggMj4fuHsuyBQcYDqfH/XrwA')),224)[$argv[1]%2];
```
I compressed then base64 encoded the concatenated strings to be displayed. The code decodes, decompresses and splits it in pieces of 224 characters. The first string is 224 characters without a trailing newline, the second is 201 characters (also no newline after it). The parity of the command line argument (`$argv[1]%2`) is used as index in the array generated by `str_split()`.
[Answer]
# Haskell, 138 bytes
```
m x=do
 h<-readFile"a"
 return$take 225.drop(225*mod x 2)<$>find((==h).hash.pack)(replicateM 425"/\\|_- ")
```
This is a bit of a hack. I am bruteforcing the SHA256 hash of the concatination of the two minecraft texts, and then splitting them apart and choosing the appropriate text based on parameter x. This is of cource very impractical and cannot be computed in real time, and there may even be collisions along the way for all I know.
Because Haskell cannot have the ASCII representation of that hash in a string, I am reading it from a file called "a", and has therefor added 32 bytes to my score.
* readFile and pack is from Data.ByteString.Char8
* hash is from Crypto.Hash.SHA256
## Explaination:
```
replicateM 425"/\\|_- "
```
Creates a list of every combination of the letters "/\|\_- " on 425 letters (the length of both minecraft texts combined)
```
find((==h).hash.pack)
```
Pick the first one that matches the hash
```
take 225.drop(225*mod x 2)
```
The first text is 225 letters long, the other one is exactly 200. 
[Answer]
# Javascript (ES6), ~~403~~ 296 bytes
(Moved from my [previous answer](https://codegolf.stackexchange.com/a/53943/42545)) Trying out a new method:
```
n=>`55555559Å9Å${n%2?`55555558556776}}5Y75Y¥Æ75786¡YAA[7ćA5Fï5¡YFéA8Y§5}\x83AEÅKÅ\x99}5§5\x999\x95`:`Q5555Q9Ý>6¡77¡}}5Y7756¡75768Y¡AA£7ćA5Fû5u¡FéAY55¡}}­EÅKÅ}G;5¡}5}`}`.replace(r=/./g,x=>(163+x.charCodeAt()).toString(6).slice(1)).replace(r,x=>' /|\\_-'[x]).match(/.{56}/g).join`
`
```
Note that there is a few unprintable character; these have been replaced with e.g. `\x83`.
The encoding itself is about 40 bytes shorter than the other, but the decoding process is more elaborate. I used the base-216 system that others have used to encode the text. For reference, here's the code I used:
```
// normal MINECRAFT
a='00000000000000000000000440000440004400000000000004400444'+
  '00130013000020023002002000001000020020000013000020000020'+
  '01003100300020020302002550020000025530000144300025500020'+
  '100000000300200200320024400034400200030010000300200000200';
// upside-down MINECRAFT
// un-comment this one to run it
/*
a='00000000000000000000000440000440000000000000000000000000'+
  '30000000010020020012002000001000020001003044010020000020'+
  '03001300100020020102002550020000025510000300100025500020'+
  '003100310000200210020024400034400244200000310000244004240';
*/
console.log(a.replace(/.../g,x=>String.fromCharCode(parseInt(b[i],6)+53)));
```
This basically takes the ASCII text (pre-converted to base 6) and triples it up on itself, changing it to base 216. 53 is then added to remove most non-printable characters.
Suggestions welcome!
---
Here's the original 403-byte code:
```
a=n=>{y=[' ','/','|','\\','_','-'],x=`55555559Å9Å${n%2?`55555555¡55Y}}eA5;5};GÝY}5}¡k;77;} 757Ĉ5G;7ć75§H5AB77Ý8ÝEÑ5H5EÅÕ`:`Q5555Q9Ý6¡k5}\u008FAA5;5}}5k5}5}Y§G77G} 757Ċ5?×7ć7;55GAAI7Ý8ÝA865GA5A`}`;b=x.split('').map(x=>x.charCodeAt(0)-53);for(c=[],i=b.length;i--;){c[i]=b[i].toString(6);while(c[i].length<3)c[i]='0'+c[i]}d=c.join('').replace(/\d/g,x=>y[x]).split('');d[56]=d[112]=d[168]=`
`;return d.join('')};
```
Using a `for` loop, a `while` loop, four variables that were only used once, and a ton of long algorithms for simple things. Boy, have I improved...
[Answer]
# Python, 312 bytes
```
def y(b):
 x=int(['4vwhclv10tuk4z18gf73aimn6zvwkrhxekphfn1lxocj9ezchd1cd1cv97p3f6k12s8hcjznnm5iq3om4vgxvugp3makgu4n3f6qxvdrtl4c0lva12hwt','8uzwdylhtrf6oqnwnck8pfxu25m5844tuo2700v3zoeuvossx1b47rnwyrmqodau3feu3spi9jydhyxvntv48vojx9iq9af78wufzn1'][b%2],36);x<<=69;s="";t=" /\\-|_\n"
 while x:s+=t[x&7];x>>=3
 print s
```
Function prints output given an int
[Answer]
# C, 321 bytes
Encoded the repetition and the character index into a string.
```
main(n,v,p,c)char**v,*p,*c;{c=" _/\\|-\n";for(p=atoi(v[1])%2?"8@8iXivs8rhththrthtPrXt`rhspiprhtPtvpshrshr`thtprpthtmhtPtmrXshr`tm`tvhsrhsrXthtrhthti`sihtitPsrXtihqtq":"8@8iXi`i8PihavhrshrsXthtshthtPrXthtPrsXtPtvprhsrhs`thtpspthtmhtPtmsXris`tm`tvr8shththsthti`siht`shrXshtPtw";*p;p++)for(n=*p/8^15;n--;)putchar(c[*p&7]);}
```
[Answer]
# Python 3, 486 ~~533~~ ~~612~~
```
r=str.replace;m,p=r(r(r('''YYYYY   __YA AYY   A___
  /\  /\YX\  X Y/YX Y/\Y| Y|
 /  \/  \   X \ X--  | Y|--\Y/__\   |--   |
/YY\  X  \XA \A|   \  /Y\  | Y| ''','X','|  |'),'Y','    '),'A','__  '),print;
if int(input())%2==0:p(m)
else:
 q,i,u=m.split('\n')[::-1],0,[[23,24,29,30],[42,43],[],[23,24,29,30,34,35,53,49,50,55]];q.insert(0,q.pop())
 while i<len(q):
  x=list(r(q[i],'_',' '))+[' ']
  for a in u[i]:x[a]='_'
  p(r(r(r(r(''.join(x),'___',''),"\\",'t'),'/',"\\"),'t','/'))
  i+=1
```
[Answer]
# [PHP](https://php.net/), 263 bytes
```
<?=strtr('3333 20220'.['2 0332 020_
2/\2/\211\113/2113/\212 1
 /2\/2\ 11 \ |1412 14\22/0\ 14 1
/32 \112\|102 \012 \2/22\12 1',
'
\32 /112/|13/212 /2\ 0 /12 1
 \2/\2/ 11 / |1412 14/22\2/ 14 1
2\/2\/211/1102 \010|3\/2102_|_'][$argn&1],[__,"  |","  ","     ","--"]);
```
[Try it online!](https://tio.run/##PY/LCsIwEEX3@YohiFFonUe68/UhTQkiYldaqsv8tus6E8Ew3CSXO2eSaZyWw3kaJ7e6zPfH0Xd@784n9Y6v9/yeNyHqAiERCrs@CFCMKkLZCSYr5sQcUUz0JsAOUJIWMEOCwp2ZXRJBUq/TACpDuyQVJj2RBpQlkiwZGhdc0gRqAktliyGB1Kr8OhiNj3@@tZtn/DrenqSI3wAq0QySXHIY@vrbNQ9Nn3PjAYo3rQJ1b1s/bPfL8nk82@vlOt6@ "PHP – Try It Online")
[Answer]
# Ruby, 290 bytes
```
$><<(gets.to_i%2<1?"xCeCdCnCcC_
c/Bc/Be|ABAAf/e|Af/Be|f|
b/cB/cBd|AbBb|A--Af|--Be/CBd|--d|
/iBAAcB|ACdBCAdBc/eBAf|":"xCeC
Bi/AAc/|Af/e|d/cBbCb/Af|
bBc/Bc/d|Ab/b|A--Af|--/eBc/d|--d|
cB/cB/e|A/AACdBCAC|fB/e|Cc_|_").gsub(?C,'__').tr(?B,?\\).gsub(?A,'c|').gsub(/[a-z]/){|e|' '*(e.ord-97)}
```
Probably a weak and improvable entry. Basically a very simple (handcrafted) compression where lowercase letters mean that many spaces (actually ord(ch) - 'A' spaces) and uppercase letters are just some common terms that saved a few bytes.
[Answer]
# [SOGL V0.12](https://github.com/dzaima/SOGLOnline), ~~72~~ 71 [bytes](https://github.com/dzaima/SOGL/blob/master/chartable.md)
```
═j;ΗD^⌡⁾yō⁶⅜┐≡¼τ~≡š┘,┼◄‚4øDqψ∫‛²′Ζdκ↓±ģ░○∙ΘΝ◄ōΞ06║⁶╗i-η}┌^JY³‘''n.2%?№↕
```
[Try it Here!](https://dzaima.github.io/SOGLOnline/?code=JXUyNTUwaiUzQiV1MDM5N0QlNUUldTIzMjEldTIwN0V5JXUwMTREJXUyMDc2JXUyMTVDJXUyNTEwJXUyMjYxJUJDJXUwM0M0JTdFJXUyMjYxJXUwMTYxJXUyNTE4JTJDJXUyNTNDJXUyNUM0JXUyMDFBNCVGOERxJXUwM0M4JXUyMjJCJXUyMDFCJUIyJXUyMDMyJXUwMzk2ZCV1MDNCQSV1MjE5MyVCMSV1MDEyMyV1MjU5MSV1MjVDQiV1MjIxOSV1MDM5OCV1MDM5RCV1MjVDNCV1MDE0RCV1MDM5RTA2JXUyNTUxJXUyMDc2JXUyNTU3aS0ldTAzQjclN0QldTI1MEMlNUVKWSVCMyV1MjAxOCUyNyUyN24uMiUyNSUzRiV1MjExNiV1MjE5NQ__,inputs=MQ__,v=0.12)
SOGLs vertical mirroring worked perfectly for this.
[Answer]
# [Canvas](https://github.com/dzaima/Canvas), 70 [bytes](https://github.com/dzaima/Canvas/blob/master/files/chartable.md)
```
Ｃ＜aT［≤＾５ｔ‽◂6Ｚｒ!ｖ↓［ｕ0F∙ＯＦ－╫＃ｔ┬ａ*７ＺfK1!&)y＠½（＋M⇵ＰV-¼G:Ｕju╋╷(╫:N‟‾)ｎ⁸２％？↕
```
[Try it here!](https://dzaima.github.io/Canvas/?u=JXVGRjIzJXVGRjFDYVQldUZGM0IldTIyNjQldUZGM0UldUZGMTUldUZGNTQldTIwM0QldTI1QzI2JXVGRjNBJXVGRjUyJTIxJXVGRjU2JXUyMTkzJXVGRjNCJXVGRjU1MEYldTIyMTkldUZGMkYldUZGMjYldUZGMEQldTI1NkIldUZGMDMldUZGNTQldTI1MkMldUZGNDEqJXVGRjE3JXVGRjNBZksxJTIxJTI2JTI5eSV1RkYyMCVCRCV1RkYwOCV1RkYwQk0ldTIxRjUldUZGMzBWLSVCQ0clM0EldUZGMzVqdSV1MjU0QiV1MjU3NyUyOCV1MjU2QiUzQU4ldTIwMUYldTIwM0UlMjkldUZGNEUldTIwNzgldUZGMTIldUZGMDUldUZGMUYldTIxOTU_,i=Mg__,v=8)
]