[Question]
  [
(Inspired by [this question](https://codegolf.stackexchange.com/q/80961/41505))
# Objective
Your task is to write a program or function to print an ASCII version of the Stack Overflow logo to STDOUT
```
 \|/
(-)
(-)
(-)
(-)
```
Your program should take two inputs, referred to here as H and N.
The height of the stack "container" (the parentheses) is determined by H. The number of items in the stack is determined by N. If N>H, the stack will "overflow".
# Input/Output
H will determine the height of the containers
For example:
H=1:
```
( )
```
H=2:
```
( )
( )
```
H=3:
```
( )
( )
( )
```
H will always be at least 1
N will determine how many items are in the stack. The following examples are all H = 2:
N=0
```
( )
( )
```
N=1
```
( )
(-)
```
N=2
```
(-)
(-)
```
N=3
```
 \
(-)
(-)
```
N=4
```
 \|
(-)
(-)
```
N=5
```
 \|/
(-)
(-)
```
N=6
```
 \|/
(-)-
(-)
```
N=7
```
 \|/
(-)-
(-)-
```
N will never be more than `2H+3` (In other words, the stack will never go through the ground).
# Rules
* No Standard Loopholes.
* Your program must not produce any errors.
* All test cases must pass.
* You can input H and N any way you want.
* I seriously doubt that your language has a built-in for this.
* Each line may optionally have an extra space at the end. A blank line above a stack where N <= H is optional, as is a trailing newline.
* This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so shortest code in bytes wins!
# Test Cases
In addition to all of the H=2 test cases from the Input/Output section, all of the following test cases must pass:
H=1, N=1
```
(-)
```
H=1, N=5
```
 \|/
(-)-
```
H=4, N=7
```
 \|/
(-)
(-)
(-)
(-)
```
H=5, N=0
```
( )
( )
( )
( )
( )
```
## 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=81167,OVERRIDE_USER=41505;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=jQuery(o).text()),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;
```
```
body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;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]
# Pyth, ~~43~~ ~~41~~ 40 bytes
```
<" \|/"g#0hK-QJEVJs[\(?<N_Kd\-\)*<N-K3\-
```
[Try it online.](http://pyth.herokuapp.com/?code=%3C%22%20%5C%7C%2F%22g%230hK-QJEVJs%5B%5C(%3F%3CN_Kd%5C-%5C)*%3CN-K3%5C-&input=7%0A4&test_suite_input=0%0A2%0A1%0A2%0A2%0A2%0A3%0A2%0A4%0A2%0A5%0A2%0A6%0A2%0A7%0A2&debug=0&input_size=2) [Test suite.](http://pyth.herokuapp.com/?code=%3C%22%20%5C%7C%2F%22g%230hK-QJEVJs%5B%5C(%3F%3CN_Kd%5C-%5C)*%3CN-K3%5C-&test_suite=1&test_suite_input=0%0A2%0A1%0A2%0A2%0A2%0A3%0A2%0A4%0A2%0A5%0A2%0A6%0A2%0A7%0A2%0A1%0A1%0A5%0A1%0A7%0A4%0A0%0A5&debug=0&input_size=2)
First pass, quick and dirty. Input to STDIN as `N\nH`.
### Explanation
1. Save the second input (height) to `J` (`JE`), and subtract it from the first input (the number of items). (`-QJE`)
2. Save the difference (number of overflowing items) to `K`. (`K-QJE`)
3. Add 1 to the number. (`hK-QJE`)
4. Take `max(0, previous)`. This is required as negative numbers would break the next step. (`g#0hK-QJE`)
5. Take at most that many letters from the string `" \|/"` to get the first line and print. (`<" \|/"g#0hK-QJE`)
6. Loop `N` over `range(0, J)`. (`VJ`) For each `N` print the concatenation of the following: (`s[`)
	* `"("` (`\(`)
	* `" "` if there are at least `N+1` free spaces in the stack (`<N_K`), `"-"` otherwise. (`?<N_Kd\-`)
	* `")"` (`\)`)
	* `"-"` if there are at least `N+4` overflowing pieces in the stack (`<N-K3`), `""` otherwise. (`*<N-K3\-`)
[Answer]
## JavaScript (ES6), ~~105~~ 102 bytes
@Edit: Saved 3 bytes thanks to @PatrickRoberts.
```
f=
(n,h)=>` \\|/`.substr(0,n+1-h)+[...Array(h)].map((_,i)=>`
(${i+n<h?` `:`-`})${i+h+3<n?`-`:``}`).join``
;
```
```
<div oninput=o.textContent=f(+n.value,+h.value)>n<input id=n type=number min=0 value=0>h<input id=h type=number min=0 value=0><pre id=o>
```
[Answer]
# JavaScript (ES6), ~~126~~ ~~122~~ 112 bytes
```
h=>n=>' \\|/'.substr(0,(o=n-h)+1)+`
( )`[r='repeat'](0>-o?0:-o)+`
(-)-`[r](o=0>o-3?0:o-3)+`
(-)`[r](n<h-o?n:h-o)
```
## Test
```
f=h=>n=>' \\|/'.substr(0,(o=n-h)+1)+`
( )`[r='repeat'](0>-o?0:-o)+`
(-)-`[r](o=0>o-3?0:o-3)+`
(-)`[r](n<h-o?n:h-o)
document.write(`<pre>${[[2,0],[2,1],[2,2],[2,3],[2,4],[2,5],[2,6],[2,7],[1,1],[1,5],[4,7],[5,0]].map(a=>f(a.shift())(a.shift())).join`
`}</pre>`)
```
## Alternate Test (if your browser does not support ES6)
See the test on [Babeljs.io](https://babeljs.io/repl/#?evaluate=false&presets=es2015-loose&code=f%3Dh%3D%3En%3D%3E'%20%5C%5C%7C%2F'.substr(0%2C(o%3Dn-h)%2B1)%2B%60%0D%0A(%20)%60%5Br%3D'repeat'%5D(0%3E-o%3F0%3A-o)%2B%60%0D%0A(-)-%60%5Br%5D(o%3D0%3Eo-3%3F0%3Ao-3)%2B%60%0D%0A(-)%60%5Br%5D(n%3Ch-o%3Fn%3Ah-o)%0D%0Adocument.write(%60%3Cpre%3E%24%7B%5B%5B2%2C0%5D%2C%5B2%2C1%5D%2C%5B2%2C2%5D%2C%5B2%2C3%5D%2C%5B2%2C4%5D%2C%5B2%2C5%5D%2C%5B2%2C6%5D%2C%5B2%2C7%5D%2C%5B1%2C1%5D%2C%5B1%2C5%5D%2C%5B4%2C7%5D%2C%5B5%2C0%5D%5D.map(a%3D%3Ef(a.shift())(a.shift())).join%60%0D%0A%0D%0A%60%7D%3C%2Fpre%3E%60)) and check "evaluate".
## Interesting alternate approach at 136 bytes
```
h=>n=>' \\|/'.substr(0,(o=n-h)+1)+`
( )${0>-o?0:-o}
(-)-${o=0>o-3?0:o-3}
(-)${n<h-o?n:h-o}`.replace(/(\n.*)(\d+)/g,(_,s,r)=>s.repeat(r))
```
This moves the repeat amounts into the template string and uses a regexp and replace to inject the repeating groups. Unfortunately the signature for `.replace()` is just too long.
[Answer]
## C++14 (lambda function), 196
Saved 1 byte thanks to Quentin.
Saved 2 bytes thanks to Adam Martin.
```
#include<iostream>
using namespace std;[](int h,int n){auto s=" \\|/( ) (-) (-)-"s;int t=max(min(n-h,3),0);n-=t;cout<<s.substr(0,t+1)+'\n';for(;h;h--)n-=t=n>h?2:h<=n,cout<<s.substr(4+4*t,4)+'\n';}
```
The function itself takes 157 bytes.
See it in action [here](http://coliru.stacked-crooked.com/a/e29ab94fad2ff5ab).
Ungolfed version:
```
[](int h, int n) {
    auto s = " \\|/( ) (-) (-)-"s;
    int t = max(min(n - h, 3), 0);
    n -= t;
    cout << s.substr(0, t + 1) + '\n';
    for(; h; h--) {
        if (n > h) t = 2;
        else if (h > n) t = 0;
        else t = 1;
        n -= t;
        cout << s.substr(4 + 4 * t, 4) + '\n';
    }
};
```
[Answer]
## CJam, 57 bytes
```
Sri:X'(*+X),W%X)X')*+X),X))f+]zN*X5*,X'-*_"\|/"\++ri<S+er
```
[Test it here.](http://cjam.aditsu.net/#code=Sri%3AX'(*%2BX)%2CW%25X)X')*%2BX)%2CX))f%2B%5DzN*X5*%2CX'-*_%22%5C%7C%2F%22%5C%2B%2Bri%3CS%2Ber&input=4%207)
Could definitely use some improvement. The idea is to build a grid where the `-\|/-` cells are replaced with consecutive integers, e.g.
```
 345
(2)6
(1)7
(0)8
```
And then to replace them with the correct characters (potentially spaces) at the end.
[Answer]
# Python 2, ~~101~~ ~~100~~ 98 bytes
```
def f(h,n):
 print" \|/"[:max(0,n-h+1)]
 for i in range(h):print("(-)","( )")[h-i>n]+"-"*(n>i+h+3)
```
[Answer]
# JavaScript (ES6), ~~87~~ 80 bytes
```
F=(h,n)=>h?F(h-1,n-1)+`
(${n>0?'-':' '})${n>2*h+2?'-':''}`:' \\|/'.substr(0,n+1)
```
Uses recursion to create the output string from the bottom up.
**EDIT**: Thanks to [@Neil](https://codegolf.stackexchange.com/users/17602/neil) for shaving 7 bytes off from 87 bytes
## Original
```
(h,n)=>(E=s=>h--?E(`
(${n>0?'-':' '})${--n>2*h+3?'-':''}`+s):` \\|/`.substr(0,n+1)+s)``
```
## Test snippet:
```
F=(h,n)=>h?F(h-1,n-1)+`
(${n>0?'-':' '})${n>2*h+2?'-':''}`:' \\|/'.substr(0,n+1)
h.oninput = n.oninput = () => output.innerHTML = F(+h.value, +n.value);
```
```
<label>h <input type="number" min="0" value="0" id="h" /></label>
<label>n <input type="number" min="0" value="0" id="n" /></label>
<hr />
<pre id="output"></pre>
```
[Answer]
# JavaScript (ES6), ~~149~~ ~~139~~ 137 bytes
```
h=>n=>` ${[(g=(j,m=1)=>` -\\|/`[(j<n)*m])(h,2),g(h+1,3),g(h+2,4)].join``}${[...Array(h)].map((_,i)=>`
(${g(h-i-1)})${g(h+i+3)}`).join``}`
```
I liked @MartinEnder's idea about indexing the `-\|/` characters and I wanted to see how it would fare in ES6. Apparently I didn't do so well. Trying to figure out if this could be improved using `for...of`.
### Edits
* I managed to remove regexp and the call to `.replace`, moving the indexing directly into `g()` instead.
* I accidentally counted `f=` in the second byte count
## Test
```
f=h=>n=>` ${[(g=(j,m=1)=>` -\\|/`[(j<n)*m])(h,2),g(h+1,3),g(h+2,4)].join``}${[...Array(h)].map((_,i)=>`
(${g(h-i-1)})${g(h+i+3)}`).join``}`
document.write(`<pre>${[[2,0],[2,1],[2,2],[2,3],[2,4],[2,5],[2,6],[2,7],[1,1],[1,5],[4,7],[5,0]].map(a=>f(a.shift())(a.shift())).join`
`}</pre>`)
```
[Answer]
# Java, 186 177 bytes
```
void f(int h,int n){for(int i=0;i<h+1;i++)System.out.print((i>0?"(":" ")+(i>0?n>h-i-2?"-":" ":n>h+0?"\\":" ")+(i>0?")":n>h+1?"|":" ")+(i>0?n>h+2+i?"-":" ":n>h+2?"/":" ")+"\n");}
```
**Ungolfed** [try online](http://ideone.com/tItYmf)
```
String f(int h, int n)
{
    String s=" ";
    s+=n>h+0?"\\":" ";
    s+=n>h+1? "|":" ";
    s+=n>h+2? "/":" ";
    s+="\n";
    for(int i=0; i<h; i++)
    {
        s+="(";
        s+=n>h-i-1?"-":" ";
        s+=")";
        s+=n>h+3+i?"-":" ";
        s+="\n";
    }
    return s;
}
```
[Answer]
# Excel, 131 bytes
Input taken as a tuple, Height `H` in `A1`, `N` in `B1`. Cell containing formula needs to have Text Wrapping turned on. Suggest using a Mono-spaced font.
```
=LEFT(" \|/",MAX(0,B1-A1+1))&"
"&REPT("(-)-
",MAX(0,B1-A1-3))&REPT("( )
",MAX(0,A1-B1))&REPT("(-)
",A1-MAX(0,B1-A1-3)-MAX(0,A1-B1))
```
[Answer]
# C++11, ~~155~~ ~~148~~ 145 bytes
```
void f(int h,int n){cout<<string{" \\|/",max(min(3,n-h),0)+1}<<'\n';for(int i=0;i<h;++i)cout<<(h-i<=n?"(-)":"( )")<<(i<max(n-h-3,0)?"-\n":"\n");}
```
**Ungolfed**:
```
void f(int h,int n)
{
  cout << string{" \\|/", max(min(3, n-h), 0) + 1} << '\n';
  for(int i=0; i<h; ++i)
    cout << (h-i <= n ? "(-)" : "( )") << (i < max(n-h-3,0) ? "-\n" : "\n");
}
```
**Usage**:
```
#include <iostream>
#include <string>
using namespace std;
void f(int h,int n){cout<<string{" \\|/",max(min(3,n-h),0)+1}<<'\n';for(int i=0;i<h;++i)cout<<(h-i<=n?"(-)":"( )")<<(i<max(n-h-3,0)?"-\n":"\n");}
int main()
{
  int h,n;
  cin >> h >> n;
  f(h, n);
}
```
[Answer]
# [Vyxal](https://github.com/Lyxal/Vyxal), 34 bytes
```
ð₴-0∴`\|/`Ẏ,(\(₴¹n->\)-2↳3¹+n+⁰<-,
```
[Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=%C3%B0%E2%82%B4-0%E2%88%B4%60%5C%7C%2F%60%E1%BA%8E%2C%28%5C%28%E2%82%B4%C2%B9n-%3E%5C%29-2%E2%86%B33%C2%B9%2Bn%2B%E2%81%B0%3C-%2C&inputs=3%0A7&header=&footer=)
```
ð₴                                 # Output a space
  -                                # Difference
   0∴                              # or 0 if diff. is negative
     `\|/`                         # String literal
          Ẏ,                       # First (max(N - H, 0)) letters
            (                      # Height times do...
             \(₴                   # Output a (
                ¹n-                # The difference of (iteration number) and (height)
                   >               # Is greater than (N)
                    \)-            # That many -s before a )
                       2↳          # Justified to the right, so space if not empty
                         3¹+       # 3 + (Height)
                            n+     # Plus iteration number
                              ⁰<   # Is less than (N)
                                -  # That many -s appended to the previous string
                                 , # Output with trailing newline.
```
[Answer]
# Python 3, ~~134~~ ~~121~~ ~~118~~ 111 bytes
```
def f(h,n):print('\|/'[:max(0,n-h)]+'\n'+'\n'.join('(-)-'if h<n-x-3else('(-)','( )')[x+n<h] for x in range(h)))
```
Test it here: <https://repl.it/CYL1/0>
Un-golfed:
```
def f(h,n):
  top=['\|/'[:max(0,n-h)]]
  stack=['( )'if x+n<h else'(-)'for x in range(h)]
  overflow=top+stack
  v=n-3
  while v>h:
      overflow[h-v]+='-' #add side overflow
      v-=1
  print('\n'.join(overflow))
```
~~I'd like to have added the side overflow to the list comprehension, but I couldn't squeeze it in, so I had to go with the while loop.~~ Saved 13 bytes!
[Answer]
# [Perl 5](https://www.perl.org/), 91 bytes
```
say((' \|/'=~/./g)[0..-($a=<>)+($b=<>)]);say$b<=$a-$_?'( )':'(-)'.'-'x($b-2>$a+$_)for 1..$a
```
[Try it online!](https://tio.run/##FcpBCsIwEADAu6/IYWF3KbtJhFy0qS/wBSolBRWhmNJ6sFB8urGe5jLDdexDKVOaidCcF4vxY9Xe@eRUhSDFuuGKoPt74f0aoasjJIH2gGQYd0jCqCj4XptsG0gVtHzLo/GqkEoJG@@/eXg98nMqcgzqvPsB "Perl 5 – Try It Online")
[Answer]
# [Pip](https://github.com/dloscutoff/pip), 50 bytes
```
Ps.(0Xa."\|/")@<bDC0Fi,aP"()"WV"- "@[b<a-ib<a+4+i]
```
[Try it online!](https://tio.run/##K8gs@P8/oFhPwyAiUU8ppkZfSdPBJsnF2cAtUycxQElDUyk8TElXQckhOskmUTcTSGibaGfG/v//3@S/BQA "Pip – Try It Online")
Ugh, this is too long... don't know how to shorten it any more, though. Cyclical indexing, which is usually helpful, cost extra bytes this time.
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), ~~109~~ ~~108~~ 104 bytes
```
param($n,$h)-join" \|/"[0..(($d=$n-$h),0)[$d-lt0]]
1..$h|%{("( )","(-)")[$h-$_-lt$n]+"-"*($h+$_+2-lt$n)}
```
[Try it online!](https://tio.run/##HcpBCsIwEEDRvacIwwgzJhNjF@48SQ2l0EKUmJYquGh79jG4/e/P03dc3mnMWXXul/5FWBwmluf0KGDu2xna4D0RDjcsUsUFbnGQ/AkxHi7eY9qOKwEZBgckDJWTYFcPLNGCwIkwWexs80@8q@rVND8 "PowerShell – Try It Online")
Lost a lot on expensive indexing but still decent-ish. I'm not sure my index math is optimal however. Stole some logic from the other answers to save a byte. Also remembered precedence to pop some parens for -4 bytes.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), 45 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
-U…( )¸¹иε²N›ið'-:]RεX4-N@i'-«]" \|/"XdX*>£š»
```
Can definitely be golfed.. Not too happy about it in its current form tbh.
[Try it online](https://tio.run/##AUkAtv9vc2FiaWX//y1V4oCmKCApwrjCudC4zrXCsk7igLppw7AnLTpdUs61WDQtTkBpJy3Cq10iIFx8LyJYZFgqPsKjxaHCu///Mwo4) or [verify all test cases](https://tio.run/##yy9OTMpM/V9WqVMZlBB2aGXkf93QRw3LNBQ0D@2IvLDj3NZD6/weNezKPLxBXdeqtjbo3NYIE10/h0x13UOra2uVFGJq9JUiUiK07A4tPrrw0O7/Ooe22f@PjjbUMYjViTYGk0Y6hmDSGEyagkkzIGkIFjcEi5jomANJU7B6Ux1DiGaL2FgA).
**Explanation:**
```
-                # Subtract the 2nd (implicit) input `n` from the 1st (implicit) input `h`
                 #  i.e. `h`=3, `n`=8 → 5
 U               # Pop and store it in variable `X`
…( )             # Push string "( )"
    ¸            # Wrap it into a list: ["( )"]
     ¹и          # Repeat it the first input (`h`) amount of times
                 #  i.e. 3 → ["( )","( )","( )"]
ε                # Map each to:
 ²N›i            #  If the second input `n` is larger than the map-index N:
                 #    i.e. `n`=8 >= N=0 → 1 (truthy)
     ð'-:       '#   Replace the space with a "-"
                 #    i.e. "( )" → "(-)"
]                # Close both the if and map
 R               # Reverse the list
ε                # Map each to:
 X4-N@i          #  If `X` minus 4 is larger than or equal to the map-index N:
                 #     i.e. `X`=5 and N=0 → 5-4 >= 0 → 1 (truthy)
                 #     i.e. `X`=5 and N=2 → 5-4 >= 2 → 0 (falsey)
       '-«      '#   Append a "-"
]                # Close both the if and map
 " \|/"          # Push String " \|/"
       Xd        # Check if `X` is 0 or positive (0 if negative, 1 if 0 or positive)
                 #  i.e. `X`=5 → 1 (truthy)
         X*      # Multiply it by `X`
                 #  i.e. 1 * 5 → 5
           >     # Increase it by 1
                 #  i.e. 5 → 6
            £    # Take that many character of the string " \|/"
                 #  i.e. 6 → " \|/"
             š   # Prepend it to the list
                 #  i.e. ["(-)-","(-)-","(-)"] and " \|/" → [" \|/","(-)-","(-)-","(-)"]
              »  # Join the list by newlines (and output implicitly)
                 #  i.e. [" \|/","(-)-","(-)-","(-)"] → " \|/\n(-)-\n(-)-\n(-)"
```
]