[Question]
  [
Task is pretty simple. Your program should take a number `N` from `1` to `20` and draw the following ASCII art.   
When `N=1`:
```
_____
| | |
| | |
| | |
| | |
| | |
| | |
| | |
|_|_|
\   /
 \-/
  v
```
When `N=2`:
```
_______
|  |  |
|  |  |
|  |  |
|  |  |
|  |  |
|  |  |
|  |  |
|  |  |
|  |  |
|  |  |
|  |  |
|  |  |
|  |  |
|  |  |
|  |  |
|__|__|
\     /
 \---/
  \ /
   v
```
When `N=3`:
```
_________
|   |   |
|   |   |
|   |   |
|   |   |
|   |   |
|   |   |
|   |   |
|   |   |
|   |   |
|   |   |
|   |   |
|   |   |
|   |   |
|   |   |
|   |   |
|   |   |
|   |   |
|   |   |
|   |   |
|   |   |
|   |   |
|   |   |
|   |   |
|___|___|
\       /
 \-----/
  \   /
   \ /
    v
```
And etc. Trailing spaces are allowed.
This is a code-golf challenge so the shortest solution wins.
  
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 30 bytes
```
Ｎθ×_θ↑×⁸θ←×_⊕θ↓_↓×⁸θ↘¹Ｐ⊕θ↘θv‖Ｂ
```
[Try it online!](https://tio.run/##S85ILErOT8z5/98zr6C0xK80Nym1SKNQ05oroCgzr0QjJDM3tVhDKV5JR6FQEy5qFVqgowCRskCV8ElNK4FJgXV55iUXpeam5pWkpgCNRVLpkl@ep6MAVIMuhNVckFRQZnoG0HBDoKhvaU5JZgFYCs0CbDoQ3lEqA1kXlJqWk5pc4lRaUpJalJZTqaFp/f@/8X/dshwA "Charcoal – Try It Online") Link is to verbose version of code. Explanation:
```
Ｎθ
```
Input `n`.
```
×_θ
```
Print the `n` `_`s near the bottom left of the pencil.
```
↑×⁸θ
```
Print the `3n` `|`s up the middle of the pencil.
```
←×_⊕θ↓_
```
Print the left half of the `_`s at the top of the pencil.
```
↓×⁸θ
```
Print the left `3n` `|`s of the pencil.
```
↘¹
```
Print the first `\` at the bottom left of the pencil.
```
Ｐ⊕θ
```
Print the left half of the `-`s near the bottom of the pencil without moving the cursor.
```
↘θ
```
Print the rest of the `\`s at the bottom left of the pencil.
```
v
```
Print the `v` at the bottom of the pencil.
```
‖Ｂ
```
Reflect to complete the pencil.
[Answer]
# [Zsh](https://www.zsh.org/), 175 bytes
```
x=\|${(l:n=$1:)}
x+=$x\|
<<<${x//?/_}
repeat n\*8-1 <<<$x
<<<${x// /_}
q=\\${(l:n*2+1:)}/
<<<$q
q=${q// /-}
repeat n q=${${q/?\///}/\\?/ \\}&&<<<$q&&q=${q//-/ }
<<<${q/\\*/ v}
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m724qjhjwYKlpSVpuhY311fYxtSoVGvkWOXZqhhaadZyVWjbqlTE1HDZ2NioVFfo69vrx9dyFaUWpCaWKOTFaFnoGiqApCrgChRACgptY2IgxmgZaYPM0QfLFwIlVKoLQYp0EaYogARBwvYx-vr6tfoxMfb6CjExtWpqYD1qalBNuvoKtRBrCoFqtPQVymohzoa6fnG0USyUCQA)
30 bytes spent on the line on the tip :(  
[Attempt This Online!](https://ato.pxeger.com/run?1=m724qjhjwYKlpSVpuhY3J1bYxtSoVGvkWOXZqhhaadZyVWjbqlTE1HDZ2NioVFfo69vrx9dyFaUWpCaWKOTFaFnoGiqApCrgChRACgptY2IgxmgZaYPM0Yfr0YZoKFRTK7RVqVapLtS3j9HX16_Vj4mx11eIiamFmFQI5Gvpl9VCHAZ13-Joo1goEwA)
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), 44 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
Ì'_×'|IúRĆI8*.Dð'_:'\I>úRηRεNið'-:]`\'v).º.c
```
[Try it online](https://tio.run/##yy9OTMpM/f//cI96/OHp6jWeh3cFHWnztNDSczm8QT3eSj3G0w4odG570LmtfplAIV2r2IQY9TJNvUO79JL//zcGAA) or [verify all test cases](https://tio.run/##yy9OTMpM/W/iquSZV1BaYqWgZO@nw6XkX1oC4en4Kf0/3KMef3i6eo3f4V1BR9r8LLT0XA5vUI@3Uo/xswMKndsedG6rXyZQSNcqNiFGvUxT79AuveT/SnphOoe22f8HAA).
**Explanation:**
```
Ì         # Increase the (implicit) input by 2
 '_×     '# Push a string with that many amount of "_"
'|       '# Push "|"
  Iú      # Pad it with the input amount of leading spaces
    R     # Reverse the string, so the spaces are trailing
     Ć    # Enclose; append its own head "|"
I8*       # Push the input, and multiply it by 8
   .D     # Duplicate the string that many times on the stack
ð'_:     '# On the top copy, replace all spaces with "_"
'\       '# Push "\"
  I>ú     # Pad it with the input+1 amount of leading spaces
     R    # Reverse the string, so the spaces are trailing
      η   # Pop and push a list of its prefixes
       R  # Reverse this list of prefixes
 ε        # Map over each string:
  Ni      #  If the 0-based map-index is 1 (so the second string):
    ð'-: '#   Replace all spaces with "-"
 ]        # Close both the if-statement and map
  `       # Pop and push all values separated to the stack
   \      # Discard the top copy (the loose "\")
    'v   '# Push a "v" instead
)         # Wrap all strings on the stack into a list
 .º       # Mirror each line with overlapping center
   .c     # Pad leading spaces to centralize everything, and join by newlines
          # (after which the result is output implicitly)
```
[Answer]
# [brainfuck](https://github.com/TryItOnline/brainfuck), 573 bytes
```
[>+<-]>[>+>+<<-]>>[<+<+>>-]>>>++++++++++[>++++++++++>+<<-]>-----...<<<<<[>>>>>.<<<<<-]>>>>>>.<<<++++++[->+++++>+++++<<]>++>-<<<<<<[>++++++++>+<<-]>>[<<+>>-]<-[-<[->>+>+>+<<<<]>>[<<+>>-]>>>>.<<[>.<-]>>.<<<[>>.<<-]>>>.>.<<<<<<]>>>>[<<+++<+>>>-]>.<<<-<<<[>+>>>+>+<<<<<-]>>>>[<.>-]>>.<[<<.>>-]>.>.<[>>+<<-](>>------<<)<++++[<++++>-]<-<---.<[>>+>>+<<<<-]<[<+<+>>-]<[>++>++<<-]>->+[>>>>.<<<<-]>>.>>>.<.<<--<.<<[>>>.<<<-]>>>++.>>>.<<<<<<<<[>+>+<<-]>[<+>-]>-[<<[>+>>+<<<-]>[<+>-]>[<+>>->>>++<<<<-]<[>+<-]>>+[>>>>.<<<<-]>.>>-[>.<-]<.>>>.<<<<<[<+>-]<-]<<+[>>>>>>>.<<<<<<<-]>>>>>>>>>.
```
[Try it online!](https://tio.run/##XZFRCgJRCEW3U4iuQO5GpI8Kggj6CFr/5FVnmvLjjb7n1aNzeZ3vz9v7@ljkx5aAuJ6Qn3ToIVxcALr4JsbOn0ylmZnTArT2SzrRqBWjpLmf0oH6KP/qJkEDuIZ6SsnGN@q2x2kQeTCwZrDpboPilRfFQR2FfNFuDKyVBzrc0OVSY53OAM12QE@d8mONFnUWq3MblYkumZfbLmtKyCwOEtu2qlsFZFe33qWtSCK2LXagu0rWJp7GTCK@v47qW/qVpf/0X2/O2Dv0b5@uwTvv7B3B@nN5tSwf "brainfuck – Try It Online")
Hi, this is my first doing code-golf challenge.
yeah, I think it can be shorter if It has a better variable position arrangement and better ways of creating "\_", "|", " ", "/", "", "-", "v", "\n", but I think I will try to figure it out later.
[Answer]
# [Ruby](https://www.ruby-lang.org/), ~~127~~ 110 bytes
```
->n{puts ?_*(n*2+3),(-8*n..n).map{|i|a=i*i<2?" -_"[i]:S=" ";i<0?[?|]*3*a*=n:S*i+?\\+a*(n-i<<1|1)+?/},S*-~n+?v}
```
[Try it online!](https://tio.run/##DcxBDoIwEADAu68gPcGWVqEXg637CI6lIfXQZA9uiIqJofj16jxgHuvtU5Ir6srbsr6eFc5QM/TSNG2tzsBac6Pvcdky5egIyPYoKjULT2EYnajEhewJPeYABiI4HkYgidMk439SZG2Xu0bicW9HUF@W@N5L8l04JG9C@QE "Ruby – Try It Online")
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), 89 bytes
```
d3+\-*,λ\|?n*J\|Jʁ,;→8*‹(ð←†)\-←†\\?d›IJ\/J,ð\\J?d‹\-*J\/J,?‹(n›I\\J?nd-?‹+IJ\/J,)?›I\vJ,
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyIiLCIiLCJkMytcXC0qLM67XFx8P24qSlxcfErKgSw74oaSOCrigLkow7DihpDigKApXFwt4oaQ4oCgXFxcXD9k4oC6SUpcXC9KLMOwXFxcXEo/ZOKAuVxcLSpKXFwvSiw/4oC5KG7igLpJXFxcXEo/bmQtP+KAuStJSlxcL0osKT/igLpJXFx2SiwiLCIiLCIzIl0=)
## Explanation
```
d3+\-*,    Print 2n + 3 dashes
λ                Lambda to print:
 \|              Pipe joined with
   ?n*J;         A string (arg) n times joined with
        \|J      Another pipe
            ʁ,→  Palindromised (and set lambda to anon. var)
8*‹(ð←†)         Loop 8*n - 1 times, call the lambda passing a space as arg
\-←†             Call same lambda with dash as arg
\\?d›IJ\/J,      Print \, n*2+1 spaces, and /
ð\\J?d‹\-*J\/J,  Print space, \, n*2-1 dashes, and /
?‹(n›I\\J?nd-?‹+IJ\/J,)    Loop through n-1 with loop index i
   n›I\\J                  Pad n+1 spaces and /
         ?nd-?‹+IJ         Append i-n*2+i-1 spaces
                  \/J,     Append \/ and print
?›I\vJ,                    Print v padded with n+1 spaces
```
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), ~~304 bytes~~ 296 bytes
```
x=n=>{p="repeat",u=1,h="\\",o=["|","|","|"],r=o.join(" "[p](n))+"\n",s=o.join("_"[p](n)),e=["-"[p](2*n+3)];for(e.push(r[p](8*n-1)+s),e.push([h,"/"].join(" "[p](2*n+1))),e.push(" "+h+"-"[p](2*n-1)+"/");u<n;)e.push(" "[p](1+u)+h+" "[p](2*n-2*u++-1)+"/");return e.push(" "[p](n+1)+"V"),e.join("\n")}
```
[Try it online!](https://tio.run/##VY9Bj8IgFIT/inknXh@tafdi0mV/hpe2MY3LWo15ECjGRP3tFdSt8cCBmflm4NCfer91ezvmbH71NJ0Vq5@LVeC01f0IMqhSDgraFqRRDVxBvk4nnTLFwexZwAIa2wlGJGgZpJ@Nzb8hdYTzx63KmL6wq/@ME7qwwQ/CJX2VcV4i@Zh9qs0gYQndx0aCS8Q5E2Ua6N2cGiKEdfjmGt@hZJcUMIXnprzKAtGMOD0Gx4tPKM0RrCEtPh8Sf4i3aWvYm6MujmYnzqJCnO4 "JavaScript (Node.js) – Try It Online")
This is my first try at code golfing so it's a very simplistic attempt. The long version would be:
```
var x=(n) => {
  // Set some utility variables
  let i = 1
  let space = ' '
  let backslash = '\\'
  let repeat = 'repeat'
  let pipes = ['|', '|', '|']
  let segment = pipes.join(space[repeat](n)) + '\n'
  let lastsegment = pipes.join("_"[repeat](n))
  
  // Create the first line of dashes, the body with the last segment and the first line of the tip
  let pencil = ["-"[repeat](n * 2 + 3), segment[repeat](8 * n - 1) + lastsegment, [backslash, "/"].join(space[repeat](n * 2 + 1))]
  // Create the dashed tip line and the rest of the empty tip in a loop
  for(pencil.push(space+backslash+"-"[repeat](2*n-1)+"/");i<n;){
    pencil.push(space[repeat](1+i)+backslash+space[repeat](2*n-2*i++-1)+"/")
  }
  // Add the tip, join the array and return
  pencil.push(space[repeat](n + 1) + "V")
  return pencil.join("\n")
}
```
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 211 bytes
```
#define F(N,I)for(I=N;I>0;I--)
#define P(C)putchar(C);
i,j;main(c,v){F(2*c+3,i)P(95)P(10)F(8*c,i){F(2,v){P('|')F(c,j)P(i<2?95:32)}P('|')P(10)}F(c+1,i){P(92)F(2*i-1,j)P(i^c?32:45)P(47)P(10)F(c-i+2,j)P(32)}P('v')}
```
[Try it online!](https://tio.run/##VY/NbsIwEITvPMVKPWAXh58E1EJKOVRCygVx6LmScTaJUWJHtpNWann21Amlai@r1cx8s1oR5EJ03V2KmVQIe3JgCc20Icn2ECfP8zgJAjq62UfyQuvGiYIbv8Ujyc5xxaUigrX0c0/CezGJmKRHsl75sZjTPXm8F17pzT5zJOOvsVcFO/uAfAp369UmCunlagzMxduTRQ/5npD2tTJYXIE3sYvCzbJvXz7cTohATsLB/2lqx/TSzWawl8Y6cLJCEDpFyHXp/8in8FogqKY6oQGdATd5U6FyFqSFxmIK3ILzEan8t8yvusmLQWl52WDPeM3if1IagyW2XLkpJGqI4wev6hLhhKV@ZxACT1PppFa8/MNyg1Bz2x8mUv1mwOmhpDY6N7wCxf0f0lksMwpWQ4EGGahtNO26EKJv "C (gcc) – Try It Online")
This is my first time code golfing.
The number of arguments is used as the input, though the value of those arguments is irrelevant. In the example on Try it online, 2 additional arguments are passed (in addition to the program name itself) so here, n=3.
The main obfuscations used are
* define macros for printing characters and for loops
* replacing character literals with their decimal encoding (where it saved characters)
* the use of `main()`'s argument variables for temporary storage
* and, naturally, the removal of white-space.
I decided to have all `for` loops run backwards as it ends up using slightly fewer symbols overall due to the loop used for aligning the tip of the pencil.
[Answer]
# [Python 3.8 (pre-release)](https://docs.python.org/3.8/), 155 bytes
```
lambda n:'_'*(2*n+3)+f'\n|{(" "*n+"|")*2}'*(8*n-1)+f'\n|{("_"*n+"|")*2}\n'+'\n'.join(' '*i+('v'*(i>n)or f'\\{" -"[i==1]*(2*n-2*i+1)}/')for i in range(n+2))
```
[Try it online!](https://tio.run/##TY3BCsIwEETvfkXIZXcTqiS9iFB/xEipaDSi2xKKIG2/va6C6G1m3gzTPftLy@W6y3Oswnxr7odjo3gDNRj0hm1JNkLgcUCttHg9ajJ@Ero2XLgfrf9oYLASw/LaJkZQYJJFeMgobZnarGQUBq0KvUtV5fafq8JLy9G0AopSSSqxyg2fT8jWE81dTtxjREe0@Op3/gI "Python 3.8 (pre-release) – Try It Online")
Sorry... can't shorten no more.
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), 134 bytes
inspired by [Zaelin Goodman](https://codegolf.stackexchange.com/a/243232/80745).
```
param($n),'__'+,'| '*(8*$n-1)+'|_'|%{,$_[0]*3-join("$($_[1])"*$n)}
0..$n|%{' '*$_+"\$((' ','-')[$_-eq1]*(2*$n+1-2*$_))/"}
' '*++$n+'v'
```
[Try it online!](https://tio.run/##FctLDsIwDATQfU@BIiPb@ZSmbLhLiawuKgEq6QcJFrRnD2blmdHzPH2G9XUbxrGUuV/7J0FmjyLoPG4HtHSxkENkh5vgdvx6kK5J9hwe0z2TAdIeExtVvFdNXUNWhfoJ4swViDR7DMgdSBiWmCy1il0MeoT5ZPbqz53TEd9YSml/ "PowerShell – Try It Online")
[Answer]
# JavaScript (ES6), 143 bytes
```
n=>'_'[R='repeat'](w=n*2+3)+(g=x=>x<0?`
|${s=' _'[+!++x][R](n)}|${s}|`+g(x):`
`+' '[R](x)+(x>n?'v':`\\${' -'[+!~-x][R](w-++x*2)}/`+g(x)))(-8*n)
```
[Try it online!](https://tio.run/##ZcxNCoMwEIbhvaewIEzGkP7opkijd3Cr0kgbpUWiqGhA7dVTxVXp9v3mmXc@5N2jfTU9U/VTmoIbxUO4QxJzaGUj8x4yMnLletRHSkqueahv50hYszN1HOz1lB4o1VkSZ0ThsuVlFrQkGgNhCQo2bJNetQ5VBAMEIk2dCWy20Q/b6cjWJ66Hy2m3iIRdXYXmUauuruSxqktSkAui9Vu8v@Ijmi8 "JavaScript (Node.js) – Try It Online")
[Answer]
# [C++ (gcc)](https://gcc.gnu.org/), ~~252~~ ~~245~~ 241 bytes
```
#import<iostream>
#define g(i,n)for(int i=0;i<n;++i)
#define c std::cout<<
int f(int n){g(i,2*n+3)c'_';c'\n';g(i,8*n){g(j,2){c'|';g(k,n)c" _"[i==8*n-1];}c"|\n";}g(i,n+2){g(j,i)c' ';if(i+~n){c'\\';g(j,n-~n-i-i)c" -"[i==1];c"/\n";}else c'v';}}
```
[Try it online!](https://tio.run/##fY9BboMwEEX3nMJyFsYxVhuyqWLTi5QqiiYQTVIGBE42xLk6td2q3VT1ct6fN98wDPoEsCwr7IZ@dBb7yY3NoXvNVsemRWrYKceCZNuPOZJjWD0btGSUQvkTATa5424H/dVZm8VYm8Ik57hdrkltJYi9MCBqEiYOX9aJnotSziDucXgJd4CzPX/Dqgpcb96NB36viRufaqjyaweDjQmD4Yx6UBTUdTScC9IP0qgxinQSBQnwp@RoPqZQVtyE8X6JBbsDUi6zOWPhtflGmt@fMGtZavsNy//g9m/ol08 "C++ (gcc) – Try It Online")
* *7 bytes saved thanks to ceilingcat*
* *4 bytes saved thanks to ceilingcat*
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 205 bytes
```
n=>[(g=([[f,...d]])=>d.join((r=(n,c=' ')=>c.repeat(n+!~n))(n,f)))`____`,r(8*n-1,g` |||
`)+g`_|||`,g` \\ /`,(i=0,G=([[b,e,f]])=>r(++i)+b+r(2*(n-i)+1,f)+e)`\\/-`,...Array(n-1).fill`\\/`.map(G),G`v `].join`
`
```
[Try it online!](https://tio.run/##ZY/BboNADETvfIV7ip1dNqXqoRLdSD3xERDFBBZERL1ogyJVpf11uuRaXzx6I3nG1/pe35owTHMqvnVr4@U2wwR2FXsssbdYlp02xrSnE9lja65@EMRgUXRjd7CLsDHBTa6eUdTTrxBFqyMiPsdhHfBtL2mme4ZlWRIm1fM5Kt5IVcGBNQ72WRdb1EU73T2SAio1kLqogC97lDTqLJ5VjriqDilvnT5CqL@il5HphnHcDDaf9YQF6YLvwKdHXU54zZOk8wFwdDMIWMjyuN4tvOaglBB8JxBn@96Pzoy@R6H8H5sijfhn/QM "JavaScript (Node.js) – Try It Online")
The core of this solution lies in the ~~ab~~use of template parameters and tags in some internal functions:
* `r(n,c)` is just `c.repeat(n)`, except `n` changes to `0` if it's `-1`, and `c` defaults to a space.
* `g([[f,...d]])` joins `d` with `r(n,f)`.
* `G([[b,e,f]])` is similar to `g` but adds increasing padding on each iteration (for the pencil tip).
ES6 destructuring in function parameters allows for the use of template strings in place of comma separated character arguments, like this:
```
const f1 = (a,b,c) => [c,b+a];
const f2 = ([[a,b,c]]) => [c,b+a];
console.log(f1('a','b','c')) // -> ['c', 'ba']
console.log(f2`abc`)         // -> ['c', 'ba']
```
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell) (Version <=6), 139 bytes
```
param($n)'_'*(2*$n+3)
,($b=('|'+' '*$n)*2+'|')*(8*$n-1)
$b|% *ce ' '"_"
0..$n|%{' '*$_+"\$((' ','-')[$_-eq1]*(2*$n+1-2*$_))/"}
' '*++$n+'v'
```
[Try it online!](https://tio.run/##LYzBCsIwEETv@YoQtuxu0lQTL178EpXQSsBDjbWCHqzfHlfxNDOPx0zXZ57v5zyOtU793F8ICmNCS9FCcRtWLcGwI1zQoUZhbKOTxZa2snxgBcPSaHvKWgSTjFp3HZSlef385MwBiKS36JH3kHy@heP/P3iJxLwyb/XVnROID6y1xg8 "PowerShell – Try It Online")
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell) (Version >=7), 140 bytes
```
param($n)'_'*(2*$n+3)
,($b=('|'+' '*$n)*2+'|')*(8*$n-1)
$b|% *ace ' '"_"
0..$n|%{' '*$_+"\$((' ','-')[$_-eq1]*(2*$n+1-2*$_))/"}
' '*++$n+'v'
```
[Try it online!](https://tio.run/##LY3BCsIwEETv@YoStuxutqkmXrz4JSqhlYCHWmsFPVi/Pa7iaWYeM8x0feb5fs7DUMrUzd2FYGRM6Cg6GGXDpiHod4QLClaojF0UTexoq8kHNtAvdeW6U660YZM167aFcalfv0ESewAi9Q165D0kn2/h@D8IXiUxr@zbfOsiCvGBpZT4AQ "PowerShell – Try It Online")
[Answer]
# [Perl 5](https://www.perl.org/) + `-M5.10.0 -n`, 127 bytes
```
//;say for"_"x($'*2+3),($_=join$"x$_,qw(|)x3)x(8*$'-1),y/ /_/r,(map$"x$_.v92.($_-1?$":'-')x(2*($'-$_)+1)."/",0..$')
,$"x$'." v"
```
[Try it online!](https://dom111.github.io/code-sandbox/#eyJsYW5nIjoid2VicGVybC01LjI4LjEiLCJjb2RlIjoiLy87c2F5IGZvclwiX1wieCgkJyoyKzMpLCgkXz1qb2luJFwieCRfLHF3KHwpeDMpeCg4KiQnLTEpLHkvIC9fL3IsKG1hcCRcIngkXy52OTIuKCRfLTE/JFwiOictJyl4KDIqKCQnLSRfKSsxKS5cIi9cIiwwLi4kJylcbiwkXCJ4JCcuXCIgdlwiIiwiYXJncyI6Ii1NNS4xMC4wXG4tbiIsImlucHV0IjoiMVxuMlxuM1xuMTAifQ==)
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), ~~40~~ 37 bytes
```
⇧\_*\|?꘍Ǐ?8*Ḋ\_Ḟ\\?›꘍¦Ṙ1‡\-Ḟ¨M÷_\vWøṗ
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyIiLCIiLCLih6dcXF8qXFx8P+qYjcePPzgq4biKXFxf4bieXFxcXD/igLrqmI3CpuG5mDHigKFcXC3huJ7CqE3Dt19cXHZXw7jhuZciLCIiLCIzIl0=)
## How?
```
⇧\_*\|?꘍Ǐ?8*Ḋ\_Ḟ\\?›꘍¦Ṙ1w‡\-Ḟ¨M÷_\vWøṗ
⇧                                       # Push input + 2
 \_*                                    # Push that many underscores
    \|                                  # Push "|"
      ?꘍                                # Append the input amount of spaces
        Ǐ                               # Append its own head, aka "|"
         ?8*                            # Push input * 8
            Ḋ                           # Duplicate the string that many times
             \_Ḟ                        # On the top string, replace all spaces with "_"
                \\                      # Push a backslash
                  ?›꘍                   # Append input+1 spaces
                     ¦                  # Pop and push its prefixes
                      Ṙ                 # Reverse
                       1‡\-Ḟ¨M          # On the second string, replace all spaces with a hyphen
                              ÷_        # Push each item of that to the stack, and discard the top one (a backslash)
                                \v      # Push "v"
                                  W     # Wrap everything on the stack into a list
                                   øṗ   # Palindromise everything, center, and join by newlines
```
*-2 bytes thanks to emanresu A*
]