[Question]
  [
Draw this Ascii coffee cup:
```
  o
       o
    o
 __________
/          \__
|   J      |  \
|    A     |  |
|     V    |  |
|      A   |__/
\__________/
```
Brownie points for coffee-script or java :)
Shortest code in bytes, function or program, trailing newline or white space is acceptable, drink up!
  
[Answer]
## JavaScript (ES6), ~~110~~ 104 bytes
*Saved 4 bytes thanks to edc65*
```
let f =
_=>`1o
6o
3o
 9
/44\\__
|2J5|1\\
|3A4|1|
|4V3|1|
|5A2|__/
\\9/`.replace(/\d/g,n=>' _'[n>>3].repeat(++n))
console.log(f())
```
### How it works
The compression of the original ASCII art is achieved by replacing all sequences of 2 to 10 consecutive spaces and the two sequences of 10 consecutive underscores with a single digit:
* Each sequence of `N` consecutive spaces is encoded with the digit `N-1`.
* The underscore sequences are encoded with a `9`.
We use `N-1` rather than `N` so that we never have to use more than one digit. Hence the need for `++n` when decoding.
The expression `n>>3` (bitwise shift to the right) equals 0 for `n = 1` to `n = 7` and equals 1 for `n = 8` (not used) and `n = 9`. Therefore, `' _'[n>>3]` gives an underscore for `9`, and a space for all other encountered values.
The only special case is the sequence of 10 consecutive spaces just above "JAVA". Encoding it with a `9` would conflict with the underscore sequences. So we need to split it into two sequences of 5 spaces, encoded as `44`.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~67~~ 64 bytes
-2 bytes thanks to Dennis (1. remove redundant `”`, and 2. replace transpose and run-length decode, `ZŒṙ`, with reduce by element repetition, `x/`.)
```
“Ñṁ{xGgṭḷVỤɲ8ṿfƬT9Ɱ¹=qṀS“$<(ƇỤ08ØÑḌṃṘX6~cuc8HṗḞ2’Dx/ị“ ¶_/\|JAVo
```
**[Try it online!](https://tio.run/nexus/jelly#AXUAiv//4oCcw5HhuYF7eEdn4bmt4bi3VuG7pMmyOOG5v2bGrFQ54rGuwrk9ceG5gFPigJwkPCjGh@G7pDA4w5jDkeG4jOG5g@G5mFg2fmN1YzhI4bmX4bieMuKAmURaxZLhuZnhu4vigJwgCl8vXHxKQVZv4oCd//8)**
### How?
`“...“...’` is a list of two base-250 compressed numbers:
```
[1021021021332411532617161526181616261916162618163425334, 2117114111551155121131612111415121115141211161312111551]
```
`D` converts to decimal to yield two lists of digits:
```
[[1, 0, 2, 1, 0, 2, 1, 0, 2, 1, 3, 3, 2, 4, 1, 1, 5, 3, 2, 6, 1, 7, 1, 6, 1, 5, 2, 6, 1, 8, 1, 6, 1, 6, 2, 6, 1, 9, 1, 6, 1, 6, 2, 6, 1, 8, 1, 6, 3, 4, 2, 5, 3, 3, 4], [2, 1, 1, 7, 1, 1, 4, 1, 1, 1, 5, 5, 1, 1, 5, 5, 1, 2, 1, 1, 3, 1, 6, 1, 2, 1, 1, 1, 4, 1, 5, 1, 2, 1, 1, 1, 5, 1, 4, 1, 2, 1, 1, 1, 6, 1, 3, 1, 2, 1, 1, 1, 5, 5, 1]]
```
`x/` reduces by element repetition to give one list of digits (repeating the number from the first list by the corresponding value of the other):
```
[1, 1, 0, 2, 1, 1, 1, 1, 1, 1, 1, 0, 2, 1, 1, 1, 1, 0, 2, 1, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 2, 4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 3, 3, 2, 6, 1, 1, 1, 7, 1, 1, 1, 1, 1, 1, 6, 1, 1, 5, 2, 6, 1, 1, 1, 1, 8, 1, 1, 1, 1, 1, 6, 1, 1, 6, 2, 6, 1, 1, 1, 1, 1, 9, 1, 1, 1, 1, 6, 1, 1, 6, 2, 6, 1, 1, 1, 1, 1, 1, 8, 1, 1, 1, 6, 3, 3, 4, 2, 5, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4]
```
`ị` instructs to index into the list of the right, one based and modularly (0 indexes into the rightmost item). The list on the right,  `¶_/\|JAVo`, is simply the character used in the required order where the pilcrow, `¶`, is the same code-point as a linefeed. The closing partner of `“` is not required as this is the end of the program:
```
[' ', ' ', 'o', '\n', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 'o', '\n', ' ', ' ', ' ', ' ', 'o', '\n', ' ', '_', '_', '_', '_', '_', '_', '_', '_', '_', '_', '\n', '/', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '\\', '_', '_', '\n', '|', ' ', ' ', ' ', 'J', ' ', ' ', ' ', ' ', ' ', ' ', '|', ' ', ' ', '\\', '\n', '|', ' ', ' ', ' ', ' ', 'A', ' ', ' ', ' ', ' ', ' ', '|', ' ', ' ', '|', '\n', '|', ' ', ' ', ' ', ' ', ' ', 'V', ' ', ' ', ' ', ' ', '|', ' ', ' ', '|', '\n', '|', ' ', ' ', ' ', ' ', ' ', ' ', 'A', ' ', ' ', ' ', '|', '_', '_', '/', '\n', '\\', '_', '_', '_', '_', '_', '_', '_', '_', '_', '_', '/']
```
Jelly performs an implicit print of this list, which, since it contains characters, prints as if it were a string:
```
  o
       o
    o
 __________
/          \__
|   J      |  \
|    A     |  |
|     V    |  |
|      A   |__/
\__________/
```
[Answer]
# CoffeeScript ES6, 214 180 bytes
```
r="replace";" 1o0n0 6o0n0 3o0n0 _9n0/0 9b0_1n0|0 2J0 5|0 1b0n0|0 3A 4|0 1|0n0|0 4V0 3|0 1|0n0|0 5A0 2|0_1/0n0b0_9/0"[r](/\d/g,(a,b,c)->c[b-1].repeat(a))[r](/n/g,"\n")[r](/b/g,"\\")
```
# CoffeeScript, 135 bytes with hardcoding
```
f=()->"""  o
       o
    o
 __________
/          \__
|   J      |  \\
|    A     |  |
|     V    |  |
|      A   |__/
\__________/"""
```
[Answer]
# [PowerShell](https://github.com/PowerShell/PowerShell), ~~136~~ ~~124~~ ~~123~~ 105 bytes
```
"""2o
7o
4o
 $(($a='_'*10))
/55\__
|3J6|2\
|4A5|2|
|5V4|2|
|6A3|__/
\$a/"""-replace'(\d)','$(" "*$1)'|iex
```
[Try it online!](https://tio.run/nexus/powershell#@6@kpGSUz2Wez2WSz6WgoqGhkmirHq@uZWigqcmlb2oaEx/PVWPsZVZjFMNVY@JoWmNUw1VjGmYCps0cjWvi4/W5YlQS9YHm6BalFuQkJqeqa8SkaKrrqKtoKCkoaakYaqrXZKZW/P8PAA "PowerShell – TIO Nexus")
*Thanks to @briantist for finding the shorter `-replace` method that I knew was there somewhere.*
This takes the string with numbers in place of the requisite number of spaces. We then regex `-replace` the digits with a script expression `$(" "*$1)`. So, for example, the first line of the string will be `$(" "*2)o`, the second will be `$(" "*7)o` and so on. Because of the triple-quoting, this is left as a string on the pipeline. We dump that to `iex` (short for `Invoke-Expression` and similar to `eval`), which processes the script expressions and leaves the resulting multi-line string on the pipeline. Output is implicit.
[Answer]
# Python 2, ~~174~~ ~~172~~ ~~171~~ 167 bytes
No hard-coding.  
No Base-64 encoding.  
No Regex.
```
k=' '
q='_'*10
print'\n'.join([k*i+'o'for i in 2,7,4]+[k+q]+['/'+k*10+'\\__']+['|'+k*s+'JAVA'[s-3]+k*(9-s)+'|'+' _'[s==6]*2+'\\||/'[s-3]for s in 3,4,5,6]+['\\'+q+'/'])
```
Saved 2 bytes by externalizing `'_'*10` and by exploiting Python's conversion of `True -> 1` and `False -> 0`.  
Saved 1 byte by removing unnecessary whitespace.  
Saved 4 bytes thanks to @TuukkaX! 
[Answer]
## [GNU sed](https://en.wikipedia.org/wiki/Sed), ~~113~~ 112 bytes
```
s:$:  o@SS o@S o@ UU@/SSS \\__@|SJSS|  \\@|S AS  |  |@|S  VS |  |@|SSAS|__/@\\UU/:
s:S:   :g
y:@:\n:
s:U:_____:g
```
Basic encoding, it stores 3 spaces as `S`, `\n` as `@` and 5 underlines as `U`. I'll keep trying combinations to find something shorter.
[**Try it online!**](https://tio.run/nexus/sed#NYyhDoBADEM9X1GBP181LLYZaskkDgSK5P792AmWtHmvYuPhSuA2aVYF7tZUGpFpXbvUUVKITUBJn4xDP2tTz2wW4d64PFS9BM/lpTGuuThzHs8xPg)
The trivial solution of printing the string directly is given below. It has 136 bytes, resulting in a compression of 18 %, using the encoding scheme above.
```
c\  o\
       o\
    o\
 __________\
/          \\__\
|   J      |  \\\
|    A     |  |\
|     V    |  |\
|      A   |__/\
\\__________/
```
[**Try it online!**](https://tio.run/nexus/sed#@58co6CQH8OlAAFQFoiKh4MYLn0FOIiJAQnUAFleEIEakBhERMERJlIDFVAIQxcAq6mJj9eP4QIZBQP6//8DAA)
[Answer]
# [Python 2](https://docs.python.org/2/), ~~128~~ 127 bytes
-1 byte thanks to Rod (use multiplication of tuple `('_'*10,)` to avoid a declaration).
```
print''.join('0'<c<':'and' '*int(c)or c for c in'''2o
7o
4o
 %s
/ 9\__
|3J6|2\\
|4A5|2|
|5V4|2|
|6A3|__/
\%s/'''%(('_'*10,)*2))
```
**[Try it online!](https://tio.run/nexus/python2#HYuxCsMgGAb3/ylc5FMpNTUmpSVL1j5AJ0GKpWAGLUnH/91tyHI3HNe@ay4/4LzUXBQ6TGnCHa/yhoDZk0q6riKJz8FcALhK10q@kpAbWXELMRL3j5FdCMR@Htgx8fD0h8e55xgtBbnZfZZKIcJcupM2TuvW/g)**
*Note:* that double backslash *is* needed before the line feed.
Everything between the `'''` and `'''` is a single string, the two `%s` are formatters which get replaced by the content of the trailing `%(...)` tuple, which in turn contains two copies of `'_'*10` via the tuple multiplication `(...)*2`. The `'_'*10` performs string multiplication to yield `'__________'`.
The code traverses the characters, `c`, of that whole string using `for c in '''...` and creates a new string by joining (`join(...)`)  
*either* the number of spaces identified by `c`, `int(c)`, if `c` is a digit  
*or* `c` itself  
- being a digit is identified by `'0'<c<':'` to save over `c.isdigit()`.
[Answer]
# Java 8, 294 289 248 bytes
Golfed:
```
()->{String s="";for(char c:"\u026F\n\u076F\n\u046F\n __________\n/\u0A5C__\n|\u034A\u067C\u025C\n|\u0441\u057C\u027C\n|\u0556\u047C\u027C\n|\u0641\u037C__/\n\\__________/".toCharArray()){for(int i=0;i<c>>8;++i)s+=' ';s+=(char)(c&255);}return s;}
```
In the spirit of [kolmogorov-complexity](/questions/tagged/kolmogorov-complexity "show questions tagged 'kolmogorov-complexity'"), this does not hard-code the string to output. Instead, it makes use of the fact that there are many cases of multiple spaces followed by a printable character. It encodes the number of spaces that precede a character in the high-order byte of the character, with the actual ASCII character in the low-order byte.
Ungolfed:
```
import java.util.function.*;
public class DrinkYourMorningCoffee {
  public static void main(String[] args) {
    System.out.println(f(
    () -> {
      String s = "";
      for (char c : "\u026F\n\u076F\n\u046F\n __________\n/\u0A5C__\n|\u034A\u067C\u025C\n|\u0441\u057C\u027C\n|\u0556\u047C\u027C\n|\u0641\u037C__/\n\\__________/".toCharArray()) {
        for (int i = 0; i < c >> 8; ++i) {
          s += ' ';
        }
        s += (char) (c & 255);
      }
      return s;
    }
    ));
  }
  private static String f(Supplier<String> s) {
    return s.get();
  }
}
```
[Answer]
# MATL, ~~87~~ ~~86~~ ~~83~~ ~~82~~ 78 bytes
```
[TIH][IAC]111Z?c'(ty!(OWM4J4gW{lm> >bw8ch|.FU2W"@\#2Dj!NQDeIMZ'F'_ /|\JAV'Za7e
```
This solution breaks the coffee into two pieces: the "bubbles" and the mug. To create the bubbles, we create a sparse matrix with 111 located at three locations and convert it to a character array
```
[TIH][IAC]111Z?c
```
For the mug component, we rely upon string compression
```
'(ty!(OWM4J4gW{lm> >bw8ch|.FU2W"@\#2Dj!NQDeIMZ'F'_ /|\JAV'Za7e
```
Both components are printed to the output and a newline is automatically placed between the components
Try it at [**MATL Online**](https://matl.io/?code=%5BTIH%5D%5BIAC%5D111Z%3Fc%27%28ty%21%28OWM4J4gW%7Blm%3E+%3Ebw8ch%7C.FU2W%22%40%5C%232Dj%21NQDeIMZ%27F%27_+%2F%7C%5CJAV%27Za7e&inputs=&version=19.8.0)
[Answer]
# [SOGL](https://github.com/dzaima/SOGL), 48 [bytes](https://github.com/dzaima/SOGL/blob/master/chartable.md)
```
mγmλ⁶…Jcēņ▒&↓¡℮štΥ{ιE‽▼⅛÷εγ╝Ξ∫$■⌡πθ&χF׀▼ΡQ7L↓F¶‘
```
Explanation:
SOGL has built-in string compression and one of the things it has is a char dictionary compression. Even better, it has a boxstring compression type where the only chars available are " /\|\_-\n". So the whole program is a string encased in "‘ (the " is implicit).
The string I gave the compressor are (escaped):
```
"  o\n       o\n    o\n ",
"__________",
"\n/          \\__\n|   ",
"J",
"      |  \\\n|    ",
"A",
"     |  |\n|     ",
"V",
"    |  |\n|      ",
"A",
"   |__/\n\\",
"__________",
"/"
```
[Answer]
# Befunge, ~~158~~ ~~105~~ 101 bytes
```
<v"XaXXXNYXNY77777'XXXXX2_TXQXX0XZTXDXX0X^TXXRX0X^TXXDX07]27777#"p29+55
:<_@#:,g2/+55,g2%+55
\JV/|_Ao
```
[Try it online!](http://befunge.tryitonline.net/#code=PHYiWGFYWFhOWVhOWTc3Nzc3J1hYWFhYMl9UWFFYWDBYWlRYRFhYMFheVFhYUlgwWF5UWFhEWDA3XTI3Nzc3IyJwMjkrNTUKOjxfQCM6LGcyLys1NSxnMiUrNTUKXEpWL3xfQW8&input=)
The characters in the string are first encoded as indices into a lookup table of the ten possible values. The indices are then grouped into pairs, each pair being combined into a single number (i1 + i2\*10) in the range 0 to 99. By carefully choosing the order of the lookup table, we can guarantee that those values will always be valid ASCII characters which can be represented in a string literal.
This is a breakdown of the code itself:
![Source code with execution paths highlighted](https://i.stack.imgur.com/nm8j5.png)
![*](https://i.stack.imgur.com/jmV4j.png) We start by initialising the last element of the lookup table with a newline character (ASCII 10).  
![*](https://i.stack.imgur.com/z4eIY.png) We then use a string literal to push the encoded content onto the stack.  
![*](https://i.stack.imgur.com/RFUim.png) Finally we loop over the values of the stack, decoding and outputting two characters at a time.  
![*](https://i.stack.imgur.com/BX1CZ.png) The last line hold the lookup table: the 9th element is an implied space, and the 10th (newline) is set manually, as explained earlier.
[Answer]
# [Retina](https://github.com/m-ender/retina), 71 bytes
Differently from [my other answer](https://codegolf.stackexchange.com/a/111344/62393), this one was written by hand.
```
2o¶6o¶3o¶1=¶/55\__¶|3J6|2\¶|4A5|2|¶|5V4|2|¶|6A3|__/¶\=/
=
10$*_
\d
$* 
```
(there's a trailing space at the end)
[Try it online!](https://tio.run/nexus/retina#@89llH9omxkQGwOxoe2hbfqmpjHx8Ye21Rh7mdUYxQAZJo6mNUY1QIZpmAmEYeZoXBMfr39oW4ytPpctl6GBilY8V0wKl4qWwv//AA "Retina – TIO Nexus")
The principle is still having a "compressed" string from which the cup of coffee can be reconstructed by substitutions. Trying different substitutions it turned out that the only ones worth doing are:
* `=` turns into `__________` (10 underscores)
* any digit turns into that number of spaces
[Answer]
# Common Lisp, ~~125~~ ~~123~~ ~~122~~ ~~120~~ 114 bytes
```
(format t"~3@{~vto
~} ~10@{_~}
/~11t\\__
|   J~11t|  \\
~2@{|~5t~a~11t|  |
~}|~7tA   |__/
\\~10{_~}/"2 7 4'A" V"1)
```
I saved 6 bytes, using idea of just putting enters in string instead of `~&`s.
Ideas for improvement welcomed.
[Answer]
# Python3, 206 bytes
```
print('  o\n'+7*' '+'o\n'+4*' '+'o\n'+' '+10*'_'+'\n'+'/'+10*' '+'\__\n'+'|'+3*' '+'J'+6*' '+'|  \\\n'+'|'+4*' '+'A'+5*' '+'|  |\n'+'|'+5*' '+'V'+4*' '+'|  |\n'+'|'+6*' '+'A'+3*' '+'|__/\n'+'\\'+10*'_'+'/') 
```
[Answer]
# Pyth, 80 bytes
```
r"  o
7 o
4 o
 10_
/10 \__
|3 J6 |  \\
|4 A5 |  |
|5 V4 |  |
|6 A3 |__/
\\10_/"9
```
[Online interpreter available here.](http://pyth.herokuapp.com/?code=r%22++o%0A7+o%0A4+o%0A+10_%0A%2F10+%5C__%0A%7C3+J6+%7C++%5C%5C%0A%7C4+A5+%7C++%7C%0A%7C5+V4+%7C++%7C%0A%7C6+A3+%7C__%2F%0A%5C%5C10_%2F%229&debug=0)
Simple run-length decoding.
[Answer]
# C - 179
Solution with extensive use of format string:
```
void f(){printf("%1$3c\n%1$8c\n%1$5c\n%2$11s\n/%3$13s\n|%4$4c%5$7c%6$3c\n|%7$5c%5$6c%5$3c\n|%8$6c%5$5c%5$3c\n|%7$7c%5$4c__/\n\\%2$s/\n",'o',"__________","\\__",74,'|',92,65,86);}
```
Here is a more readable version:
```
void f() {
  printf("%1$3c\n"
         "%1$8c\n"
         "%1$5c\n"
         "%2$11s\n"
         "/%3$13s\n"
         "|%4$4c%5$7c%6$3c\n"
         "|%7$5c%5$6c%5$3c\n"
         "|%8$6c%5$5c%5$3c\n"
         "|%7$7c%5$4c__/\n"
         "\\%2$s/\n"
         'o',"__________","\\__",'J','|','\','A','V');
}
```
[Answer]
# [Retina](https://github.com/m-ender/retina), 99 bytes
This solution was generated automatically using [this](https://codegolf.stackexchange.com/a/108853/62393) script.
```
0 0o¶ 1¶/32\__¶4 J24\¶|3A 34|¶| 3V34|¶|2A   |__/¶\1/
4
|  
3
    
2
      
1
__________
0
  o¶    
```
(there are trailing spaces on many lines)
This works by using numbers 1,2,3,4 in place of some character sequences that are repeated in the target string and then substituting them back.
I know it could be golfed more by tweaking this code or completely changing approach, but since the kolmogorov meta-golf challenge had quite a disappointing outcome I wanted to try using my script on a real challenge.
[Try it online!](https://tio.run/nexus/retina#PYyxDcAwCAR7pvgNbAMLuM0AqSwxQhZgLgZgMYckUq750xW/qaNfGRgZTXiZZSgO1pXhMiHqJZDzE54A3KxlrNFIyQESqgjid0oG2Q/1qs9/sfcN "Retina – TIO Nexus")
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), 96 bytes
```
"2o
7o
4o
 0
/55\__
|3J6|2\
|4A5|2|
|5V4|2|
|6A3|__/
\0/"-replace'\d',{' '*"$_"+(,'_')["$_"]*10}
```
[Try it online!](https://tio.run/##K8gvTy0qzkjNyfn/X8kon8s8n8skn0vBgEvf1DQmPp6rxtjLrMYohqvGxNG0xqiGq8Y0zARMmzka18TH63PFGOgr6RalFuQkJqeqx6So61SrK6hrKanEK2lr6KjHq2tGg9ixWoYGtf//AwA "PowerShell – Try It Online")
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 62 bytes
```
≔\||||α”{“‽!⭆hi¿ü” ×_¹⁰↓× ⁵¦ __↑/||\← __↓α←”|⁻⎚}”↑⁺α/Ｍ⁴¦²↘JAVA
```
[Try it online!](https://tio.run/##S85ILErOT8z5//9R55SYGiA4t/FRw9zqRw1zHjXsVXy0ti0j89D@w3uAYgqHp8cf2vmoccOjtsmHpys8atx6aJlCfPyjton6NTUxj9omgDmTgfrbJgCV1zxq3P2ob1YtkAlU8qhx17mN@u/3rH3UuOXQskObHrXN8HIMc/z/HwA "Charcoal – Try It Online")
# Pure `”~”` compression, 62 bytes
```
”~∨]S⁶Ｇ⌈↖Ｌ⌈ＬＴＦＪＳ‖j∕⍘c⊗l⁶D⍘2Ｓ∧⦃﹪�⎚º}ερＫＭ✳AV³α；≕～FＹ|◧:¶d⮌rt；↶≕Xê
```
[Try it online!](https://tio.run/##FcpNCoJQGIXhPTVsFkQbCKJJA7FBhBBIwwolkFtYMzX6G2rYD4QlGJ8ENrc9nA18S7heJ4cXnqOPNFOfaIaUsE4LiMugCztliuAKOD7TTYVaphdTyBQzJbD8MYSHzU7HOjDUv626UYuIEC45i/mbY7svPvPy/beZrkx3HJNWr0jKJ9MBK4/zc4cpmyGImkU6xMM1p7U4qcL@L5ayAg "Charcoal – Try It Online")
[Answer]
## Python 3.6
 *(non-competing)*
Here's my attempt at Huffman encoding. It's definitely golfable further if anyone wants to take up the idea.
```
from bitarray import bitarray as b
a=b()
a.frombytes(bytes.fromhex('ca7fca7e53b6db6db664ffc6d9ae1fd6335e2fad1af83d68d7e2e9b218db6db6db20'))
print(''.join(a.decode({k:b(v)for k,v in zip(" _|\no/\\AJV","1 011 010 0011 00101 00100 00011 00010 00001 00000".split())})))
```
The literal could be compressed further still by converting to base64 or other, and the Huffman tree could be optimized to yield a shorter bitarray still.
[Answer]
# GameMaker Language, 138 bytes
```
show_message("  o#       o#    o# __________#/          \__#|   J      |  \#|    A     |  |#|     V    |  |#|      A   |__/#\__________/")
```
[Answer]
# C, 141 Bytes
```
f(){printf("  o\n%7co\n    o\n __________\n/%11c__\n|   J%6c|  \\\n|    A     |  |\n|%6c    |  |\n|%7c   |__/\n\\__________/",0,92,0,86,65);}
```
### Usage
```
main(){f();}
```
## Easy Solution, 148 Bytes:
```
w(){puts("  o\n       o\n    o\n __________\n/          \\__\n|   J      |  \\\n|    A     |  |\n|     V    |  |\n|      A   |__/\n\\__________/");}
```
[Answer]
# PHP, 116 bytes
```
for(;$c="1o
6o
3o
 9
/44\\__
|2J5|1\\
|3A4|1|
|4V3|1|
|5A2|__/
\\9/"[$i++];)echo$c>0?str_repeat(" _"[$c>8],$c+1):$c;
```
This looks a lot like [Arnauld´s answer](https://codegolf.stackexchange.com/a/111154/55735) - and does pretty much the same. Run with `-r`.
[Answer]
# zsh, 86 bytes
```
printf "^_<8b>^H^@^@^@^@^@^B^CSPÈçR^@^A^P^CJÆÃ^A<97>¾^B^\Ä^@¹5@Ú^KÂ^E2cÀ|^EG^X¿^FÂW^HCæÃTÔÄÇësÅÀ^L^Fq^@<92>}ý^?{^@^@^@"|zcat
```
Explanation: that string is the gzip-compressed java cup ascii art. I use `printf`, because with `echo`, `zcat` prints a warning, and `echo -e` is one character longer. It doesn't work with `bash` or `sh`, because they think it's a binary file. Since you can't effectively paste that output from the browser, [here](https://0x0.st/JSy.sh)'s a usable file.
[Answer]
# Java 9 / JShell, 299 bytes
```
()->{String s="";BigInteger b=new BigInteger("43ljxwxunmd9l9jcb3w0rylqzbs62sy1zk7gak5836c2lv5t36ej6682n2pyucm7gkm9bkfbn4ttn0gltbscvbttifvtdfetxorj6mmy3mt6r3",36);while(!b.equals(BigInteger.ZERO)){int x=b.intValue()&0x3ff;for(int i=0;i<x>>7;i++)s+=' ';s+=(char)(x&0x7f);b=b.shiftRight(10);}return s;}
```
Ungolfed:
```
() -> {
    String s = "";
    BigInteger b = new BigInteger(
        "43ljxwxunmd9l9jcb3w0rylqzbs62sy1zk7gak5836c2lv5t36ej6682n2pyucm7gkm9bkfbn4ttn0gltbscvbttifvtdfetxorj6mmy3mt6r3",
        36);
    while (!b.equals(BigInteger.ZERO)) { 
        int x = b.intValue() & 0x3ff;
        for (int i = 0; i < x >> 7; i++) s+=' ';
        s += (char)(x&0x7f);
        b = b.shiftRight(10);
    }
    return s;
}
```
Usage in JShell:
```
Supplier<String> golf = <lambda expression>
System.out.println(golf.get())
```
Encodes each character as ten bits consisting of a count of the number of spaces before the character in the high three bits following by the code point in the low seven bits.
(Since there are only three bits for the count it can't represent more than seven consecutive spaces, and there are ten spaces at one point in the string. These are encoded as a count of six, followed by a space, and then a count of three followed by the next character.)
Sadly, it loses to this trivial 140-byte Java solution:
```
()->"  o\n       o\n    o\n __________\n/          \\__\n|   J      |  \\\n|    A     |  |\n|     V    |  |\n|      A   |__/\n\\__________/"
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 85 bytes
```
•1d'uì[_ÍpH»Ð]jŠ$ÿ{É˜ß|ªpå±W¾Ö:ÞjÇ&@è$´Öàˆå]Á¢šBg¦ï&-ã¥ønØ7Ñà'?•9B8ÝJ"o _/\|JAV"‡15ô»
```
[Try it online!](https://tio.run/nexus/05ab1e#AYIAff//4oCiMWQndcOsW1/DjXBIwrvDkF1qxaAkw797w4nLnMOffMKqcMOlwrFXwr7DljrDnmrDhyZAw6gkwrTDlsOgy4bDpV3DgcKixaFCZ8Kmw68mLcOjwqXDuG7DmDfDkcOgJz/igKI5QjjDnUoibyBfL1x8SkFWIuKAoTE1w7TCu/// "05AB1E – TIO Nexus")
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), ~~67~~ 65 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
'oƵ®Sú»•BÇÉι!т³ÂSˆtTóV”PHAëdÀāåΘý”å.@=Ø₂)øUqrÖ½ñ*•“_ |
\/AVJ“ÅвJ»
```
Pretty straight-forward approach which most likely has room for improvement.
[Try it online.](https://tio.run/##AXQAi/9vc2FiaWX//ydvxrXCrlPDusK74oCiQsOHw4nOuSHRgsKzw4JTy4Z0VMOzVuKAnVBIQcOrZMOAxIHDpc6Yw73igJ3DpS5APcOY4oKCKcO4VXFyw5bCvcOxKuKAouKAnF8gfApcL0FWSuKAnMOF0LJKwrv//w)
**Explanation:**
```
'o            '# Push an "o"
  Ƶ®           # Push compressed integer 274
    S          # Convert it to a list of digits: [2,7,4]
     ú         # Prepend that many leading spaces to the "o": ["  o","       o","   o"]
      »        # Join them by newlines: "  o\n       o\n   o"
•BÇÉι!т³ÂSˆtTóV”PHAëdÀāåΘý”å.@=Ø₂)øUqrÖ½ñ*•
               # Push compressed integer 21514733101393053622421734761651860518184887728386739717403046550918945532453802933506348033205129
 “_ |\n\/AVJ“  # Push string "_ |\n\/AVJ"
  Åв           # Convert the integer to base-"_ |\n\/AVJ"
               # (builtin for converting to base string-length, and index those into the string)
    J          # Join the characters to a single string
     »         # And join the two strings on the stack by a newline
               # (after which the result is output implicitly as result)
```
[See this 05AB1E tip of mine (section *How to compress large integers?*)](https://codegolf.stackexchange.com/a/166851/52210) to understand why `Ƶ®` is `274` and `•BÇÉι!т³ÂSˆtTóV”PHAëdÀāåΘý”å.@=Ø₂)øUqrÖ½ñ*•` is `21514733101393053622421734761651860518184887728386739717403046550918945532453802933506348033205129`.
[Answer]
# [Vyxal](https://github.com/Lyxal/Vyxal), 108 bytes
```
`274`ƛI\o꘍,;_ð\_₀*+,\/₀꘍`\__`+,\|3꘍\J6꘍\|ðd\\Wṅ,\|4꘍\A5꘍`| `m++,\|5꘍\V4꘍`| `m++,\|6꘍\A3꘍`|__/`++,\\\_₀*\/++,
```
[Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=%60274%60%C6%9BI%5Co%EA%98%8D%2C%3B_%C3%B0%5C_%E2%82%80*%2B%2C%5C%2F%E2%82%80%EA%98%8D%60%5C__%60%2B%2C%5C%7C3%EA%98%8D%5CJ6%EA%98%8D%5C%7C%C3%B0d%5C%5CW%E1%B9%85%2C%5C%7C4%EA%98%8D%5CA5%EA%98%8D%60%7C%20%60m%2B%2B%2C%5C%7C5%EA%98%8D%5CV4%EA%98%8D%60%7C%20%60m%2B%2B%2C%5C%7C6%EA%98%8D%5CA3%EA%98%8D%60%7C__%2F%60%2B%2B%2C%5C%5C%5C_%E2%82%80*%5C%2F%2B%2B%2C&inputs=&header=&footer=)
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 65 bytes
```
'oƵ®Sú»•BÇÉι₆₅8á·ŸˆE©/LнDË9Ï0³†₃þC¤ā¸·Í¨z©´Kˆι₃BÄ•"_ 
/\|JAV"ÅвJ»
```
[Try it online!](https://tio.run/##AXgAh/9vc2FiaWX//ydvxrXCrlPDusK74oCiQsOHw4nOueKChuKChTjDocK3xbjLhkXCqS9M0L1Ew4s5w48wwrPigKDigoPDvkPCpMSBwrjCt8ONwqh6wqnCtEvLhs654oKDQsOE4oCiIl8gCi9cfEpBViLDhdCySsK7//8 "05AB1E – Try It Online")
# Pure `Åв` compression (compressing the bubbles too), 67 bytes
```
•5m™ÔćtвÃÔηŒćõ»θpøàÄqŠZ₂rÓ¢γβÞĆ?úËÄÌUöÉн%Cñí₄‡±ÁkÆùi•"o 
_/\|JAV"Åв
```
[Try it online!](https://tio.run/##AX0Agv9vc2FiaWX//@KAojVt4oSiw5TEh3TQssODw5TOt8WSxIfDtcK7zrhww7jDoMOEccWgWuKCgnLDk8KizrPOssOexIY/w7rDi8OEw4xVw7bDidC9JUPDscOt4oKE4oChwrHDgWvDhsO5aeKAoiJvIApfL1x8SkFWIsOF0LL//w "05AB1E – Try It Online") Outputs as a list of characters.
# `Λ` canvas, 109 bytes
```
'oƵ®Sú»6…/||º4Λ12„\_`5×«º2Λ2„/|0Λ4„|_º2Λ4„/|º0Λ4„\ º6Λ4'|4Λ5'|0Λ4ð2Λ4„ _º6Λ2'\0Λ2ð6ΛT'_6Λ3…_  4Λ4ð2Λ4'îáu3.Λ»
```
[Try it online!](https://tio.run/##yy9OTMpM/f9fPf/Y1kPrgg/vOrTb7FHDMv2amkO7TM7NNjR61DAvJj7B9PD0Q6sP7TI6NxskoF9jcG62CZBREw8WMwGLHdoFFY1ROLTLDMhUrwGaYKoOVnx4A1SdQjxY0kg9BihsdHgDkB2iHg8kjYHWxisomMAVqx9ed3hhqbHeudmHdv//DwA "05AB1E – Try It Online")
[Answer]
# [Canvas](https://github.com/dzaima/Canvas), 59 bytes
```
？Eα)⁶^↑^jo↕ｊα◂9Ｓ⁷YNＵ>AｇＸ↷ＵＥ╬ｑ\ｄ7ｆ²ｔ}ＭøＱ＃║Ｍ<Y5２ｄｐc３Ｉ‰０Ｃ5Ｇ９－‟
```
[Try it online!](https://dzaima.github.io/Canvas/?u=JXVGRjFGRSV1MDNCMSUyOSV1MjA3NiU1RSV1MjE5MSU1RWpvJXUyMTk1JXVGRjRBJXUwM0IxJXUyNUMyOSV1RkYzMyV1MjA3N1lOJXVGRjM1JTNFQSV1RkY0NyV1RkYzOCV1MjFCNyV1RkYzNSV1RkYyNSV1MjU2QyV1RkY1MSU1QyV1RkY0NDcldUZGNDYlQjIldUZGNTQlN0QldUZGMkQlRjgldUZGMzEldUZGMDMldTI1NTEldUZGMkQlM0NZNSV1RkYxMiV1RkY0NCV1RkY1MGMldUZGMTMldUZGMjkldTIwMzAldUZGMTAldUZGMjM1JXVGRjI3JXVGRjE5JXVGRjBEJXUyMDFG)
]