[Question]
  [
March 13 is recognized as [National Jewel Day](http://www.nationaldaycalendar.com/2017/03/12/362971/), which is the theme of this challenge. So, given an integer `n` where `n` is greater than 0, create an ASCII jewel. For example:
```
n = 1          n = 2             n = 3
                                       ______
                     ____             /      \
 __                 /    \            \      /
/  \                \    /             \    /
\  /                 \  /               \  /
 \/                   \/                 \/
```
The bottom is defined as the very bottom of the jewel to the highest pair of of `\/`. The rest is the top. For the above example where `n = 1`:
```
Bottom: \  /    Top:   __
         \/           /  \
```
As you can see, the bottom is made of `n + 1` layers of `\/` with `(1 * lines from the bottom) * 2` spaces in between with a maximum of `n` lines from the bottom of the jewel. If we take the second jewel (`n = 2`), we can see that:
```
 ____
/    \      
\    /  2 (or n) layers from the bottom with 1*2*2 or 4 spaces in between \/
 \  /   1 layer from the bottom with 1*1*2 or 2 spaces in between \/
  \/    The bottom (0 layers) with 1*0*2 spaces or 0 spaces in between \/
```
The top is made of one pair of `/\` with `n*2` spaces in between with `n*2` underscores on top.
**Rules**
* Must be able to take in any nonzero positive integers as user input
* Must create a jewel with the specs defined above (restated here):
	+ The top is made of one pair of `/\` with `n*2` spaces in between with `n*2` underscores on top.
	+ The bottom is made of `n + 1` layers of `\/` with `(1 * lines from the bottom) * 2` spaces in between with a maximum of `n` lines from the bottom of the jewel.
* Trailing newlines after the jewel, or trailing spaces on each line are allowed.
* No standard loopholes allowed
**Winning Criteria**
Least bytes wins!
  
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 17 bytes
Code:
```
ＮβＧ←β_↙↙¹→↘⁺β¹‖Ｍ→
```
Explanation:
```
Ｎβ                      # Place the input into β
   Ｇ←β_                 # Draw a line of length β with _ as the filling character
        ↙                # Move the cursor one down and one left
         ↙¹              # Draw a line from the cursor position to one position ↙
           →             # Move the cursor 1 to the right
             ⁺β¹         # Add one to the input and..
            ↘            # Create a line pointing ↘, with the size calculated above
                ‖Ｍ→     # Mirror to the right
```
A *very neat* command is `‖Ｍ`, which also automatically mirrors `/` into `\`.
Uses the [**Charcoal** encoding](https://github.com/somebody1234/Charcoal/wiki/Code-page). 
[Try it online!](https://tio.run/nexus/charcoal#@/9@z7pzm97vWf6obcK5TfGP2mYC0aGdj9omPWqb8ahx17lNQE7DtPd71gKF/v83BgA "Charcoal – TIO Nexus")
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~27~~ 20 bytes
```
ƒN·ð×…\ÿ/}Â¹·'_×)R.c
```
[Try it online!](https://tio.run/nexus/05ab1e#ASMA3P//xpJOwrfDsMOX4oCmXMO/L33DgsK5wrcnX8OXKVIuY///Mw "05AB1E – TIO Nexus")
**Explanation**
```
ƒ                      # for N in range[0 ... n]
 N·ð×                  # push N*2 spaces
     …\ÿ/              # push the string "\ÿ/" with "ÿ" replaced by the spaces 
         }             # end loop
          Â            # push a reversed copy of the top of the stack 
                       # (the largest row of the bottom of the diamond)
           ¹·'_×       # push input*2 underscores
                )      # wrap the stack in a list
                 R     # reverse the list
                  .c   # join the list on newlines, padding each row to equal length
```
[Answer]
# Python 2, 101 98 95 bytes
```
lambda n:'\n'.join([' '+'__'*n,'/'+'  '*n+'\\']+[' '*i+'\\'+'  '*(n-i)+'/'for i in range(n+1)])
```
[Try it Online!](https://tio.run/nexus/python2#RcpLCgIxEIThvafoXaWnfTC6EzyJGYaIRlq0ZgjeP0ZF3H3FX/kQ6z09Tuck3CMS69vkDEcIDOOIjktsGkUaDTFisHfs/DO@IXDlau2XpyIuTimJ10ug9TponYvzKTn0uvhx@@dO6ws)
Anonymous function that takes in a positive integer and returns a string
# Python 3.6, 92 bytes (Thanks to Ben Frankel)
```
lambda n:f' {"__"*n}\n/{"  "*n}\\\n'+'\n'.join(' '*i+'\\'+'  '*(n-i)+'/'for i in range(n+1))
```
I couldn't find an online interpreter for this version, but it is a bit shorter due to f-strings in v3.6
[Answer]
# PHP, 123 Bytes
```
echo($s=str_pad)(" ",$z=1+2*$a=$argv[1],_).$s("\n/",$z+1," ")."\\\n";for($i=0;$i<=$a;)echo$s($s("",$i)."\\",$z-$i++)."/\n";
```
## 143 Bytes first version
```
for(;$i<3+$a=$argv[1];$i++)echo 1-$i?str_pad("",$i?$i-2:1):"/",str_pad($i>1?"\\":"",$i<2?2*$a:2*($a-$i+2)+1,$i?" ":_),$i<2?$i?"\\":"":"/","\n";
```
[Try it here!](https://tio.run/nexus/php#NYzNDoMgEIRfxWz2AK6mYb2ttDxIaQzpn1wqoU1fn6Kmx29mvrEuzak8lqxGjHYgDEcM@fk9m0sNiPT9Oi@N6TG69ydPKdwUQFcJY89itMABun@D8WQceA@ybSw7bjEItwpDfSDWZFYXGpBJ74sVd2O7Av@CsZQy/AA)
[Answer]
# [V](https://github.com/DJMcMayhem/V), ~~28~~ ~~27~~ 26 bytes
*1 bytes saved thanks to @DJMcMayhem by using `>` instead of `É`*
```
Ài__<esc>É ÙÒ r/Á\Ùr\$r/òÙlxx>
```
`<esc>` is `0x1b`
[Try it online!](https://tio.run/nexus/v#@3@4ITM@Xvpwp8LhmYcnKRTpH26MOTyzKEYFyNp0eGZORYXd////jQE "V – TIO Nexus")
Hexdump:
```
00000000: c069 5f5f 1bc9 20d9 d220 722f c15c d972  .i__.. .. r/.\.r
00000010: 5c24 722f f2d9 6c78 783e                 \$r/..lxx>
```
### Explanation
Top:
```
Ài__<esc>              " Write argument times __
É<space>               " Prepend a space to the line
Ù                      " Duplicate line below cursor, cursor also moves down
Ò<space>               " Replace every character with a space
r/                     " Change the first character in the line to a /
Á\                     " Append a \ to the end of the line
```
Bottom:
```
Ù                      " Duplicate
r\                     " Change the first character in the line to a \
$r/                    " Replace the last character with a /
ò                      " Until a breaking error occurs do:
  Ù                    "  Duplicate
  lxx                  "  Remove 2 middle characters (spaces)
  >                    "  Indent by one space (implicit ending >)
                       " Implicit ending ò
```
[Answer]
# [Röda](https://github.com/fergusq/roda), 71 bytes
```
f n{a=" ";[a,"__"*n,"
/",a*2*n,`\
`];seq n,0|[a*(n-_),`\`,a*2*_1,"/
"]}
```
[Try it online!](https://tio.run/nexus/roda#Hcq7CoNAEEbhOv9TDFPFZYKuxksQn8TI7hQRUjgQUqrPvord4eOkmWzVgYn7UYVDYGfCyFnUlWfGN@LU/z8/Mim2Ud3dHiE7OV5D8MI5eNrTol@jFbeZKuzJo0SFJ2o0aNHhBV8c "Röda – TIO Nexus")
[Answer]
## JavaScript (ES6), 80 bytes
```
f=
n=>` ${"_".repeat(n*2)}
/${s=" ".repeat(n)}${s}\\`+s.replace(/|/g,"\n$`\\$'$'/")
```
```
<input type=number oninput=o.textContent=f(this.value)><pre id=o>
```
[Answer]
# C, 131 bytes
```
i;f(n){for(printf(" ",i=0);i++<n*2;)printf("_");for(printf("\n/%*c\n",n*2+1,92,i=0);i++<n+1;)printf("%*c%*c\n",i,92,(n-i)*2+3,47);}
```
[Try it online!](https://tio.run/nexus/c-gcc#TctBCsIwEEDRdXOKEhBmkkhNI4iM3iQgRQjMwqkEd6VnjxEqzfq/X5gSCC5pzvDOLJ8EuteO7ycktvYmZiT8h4dGamGU4WCeUbSrzHp3HZvR@n2saoP8QyBHxnoEd74graWi/jWxAKpFdQkCklrLFw)
[Answer]
# Python 3, ~~107~~ 105 Bytes
```
n,s=int(input())," "
print(s+n*"__","/"+n*2*s+"\\",*[i*s+"\\"+2*(n-i)*s+"/"for i in range(n+1)],sep="\n")
```
Takes an int from Stdin
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), 76, 74 bytes
```
param($n)" "+'_'*2*$n;"/$(' '*$n*2)\";$n..0|%{' '*($n-$_)+"\$(' '*$_*2)/"}
```
Note: the online example contains a bit of wrapping as a demonstration. Place in a PoSH function or script to execute.
[Try it online!](https://tio.run/nexus/powershell#LcpBCoAgEEDRq8gwZSqpCa08Soq4apVELcuzT0btPp9HmI/1XGzU@qsp3t3VX3s@8jZgEcBA8cSlk1g8GBw44y2lEwE8Fq1t8@9reMQkFITfpGYM1MowVSKyND8 "PowerShell – TIO Nexus")
[Answer]
# [MATL](https://github.com/lmendo/MATL/), 34 bytes
```
QE:qgOO(t~E3O(GQXy3*tPgEhv'_/\ 'w)
```
Try it at [MATL Online!](https://matl.io/?code=QE%3AqgOO%28t%7EE3O%28GQXy3%2atPgEhv%27_%2F%5C+%27w%29&inputs=3&version=19.8.0)
### Explanation
```
QE:qg   % Create array [0 1 1 ... 1 1] of size2*(n+1)
OO(     % Turns last 1 into a 0: [0 1 1 ... 1 0]
t~      % Duplicate and negate: [1 0 0 ... 0 1]
E3O(    % Multiply by 2, turn last 2 into 3: [2 0 0 ... 0 3]
GQXy    % Push identity matrix of size n+1
3*      % Multiply by 3
tPgE    % Duplicate, flip, turn 3 into 2
h       % Concatenate the two matrices horizontally
v       % Concatenate all arrays vertically into a matrix
'_/\ '  % Push this string
w)      % Index (modular, 1-based) with the matrix into the string. Implicitly display
```
[Answer]
# Pyth, 44 Bytes
```
+" "*Q"__"++\/**2Qd\\jm+++*d\ \\**2-Qd\ \/hQ
```
[try it!](https://pyth.herokuapp.com/?code=%2B%22+%22%2aQ%22__%22%2B%2B%5C%2F%2a%2a2Qd%5C%5Cjm%2B%2B%2B%2ad%5C+%5C%5C%2a%2a2-Qd%5C+%5C%2FhQ&test_suite=1&test_suite_input=1%0A2%0A3%0A4%0A5%0A6&debug=0)
### explanation
The code consists of 3 parts:
```
+" "*Q"__"               # pretty straightforward " "+input()*"__"
++\/**2Qd\\              # d is defined as " ":  "/"+2*input()*d+"\"
jm+++*d\ \\**2-Qd\ \/hQ  # The third part is a bit more complex so I'll explain it further:
jm                   hQ  # Map some lambda function onto range(input()+1) and join the result on newlines
  +++*d\ \\**2-Qd\ \/    # Here d is the lambda argument (so I can't use it for spaces -.-) 
  +++*d\ \\**2-Qd\ \/    # In Python: d*" "+"\\"+2*(Q-d)*" "+"/"
```
[Answer]
# Python3, 104 bytes
```
n=int(input());print(" "+"__"*n+"\n/"+"  "*n+"\\")
for i in range(n+1):print(" "*i+"\\"+"  "*(n-i)+"/")
```
The program takes an integer from STDIN and returns the jewel into STDOUT.
[Answer]
# [Pip](https://github.com/dloscutoff/pip), 43 bytes
42 bytes of code, +1 for `-n` flag.
```
Ps.'_Xa*2P"/\"JsXa*2sX_.'\.sXa-_X2.'/M,a+1
```
Takes input as a command-line argument. [Try it online!](https://tio.run/nexus/pip#@x9QrKceH5GoZRSgpB@j5FUMYhZHxOupx@gB2brxEUZ66vq@Oonahv///9fN@28CAA "Pip – TIO Nexus")
### Explanation
Constructs the first two lines separately, then the rest of the jewel with a map operation:
```
Ps.'_Xa*2
      a*2  Cmdline arg, times 2
   '_X     That many underscore characters
 s.        Concatenated to a space character
P          Print (with newline)
P"/\"JsXa*2
        a*2  Cmdline arg, times 2
      sX     That many space characters
 "/\"J       Join the string "/\" with the above as the separator
P            Print (with newline)
sX_.'\.sXa-_X2.'/M,a+1
                  ,a+1  Numbers from 0 up to and including a
                 M      Map the following lambda function:
sX_                      Space, repeated (fn arg) times
   .'\                   Concatenate \
      .                  Concatenate:
       sXa-_              Space, repeated (a - (fn arg)) times
            X2            repeated twice
              .'/        Concatenate /
                         Print result list, newline separated (implicit, -n flag)
```
### Another solution
Also 42+1 bytes, this time with the `-l` flag:
```
Ys.tAL'_.sX2+,a.0(yALRVyRXD1-_)R0'\R1'/ZDs
```
[TIO](https://tio.run/nexus/pip#@x9ZrFfi6KMer1ccYaStk6hnoFHp6BMUVhkU4WKoG68ZZKAeE2Sorh/lUvz//3/dnP8mAA)
[Answer]
# Pyth, 38 bytes
```
j[*yQ\_j*yQpd"/\\"jm+*\ dj*\ y-Qd"\/"h
```
[Answer]
# C, 115 bytes
```
#define p printf(
i;j;f(n){for(p" ");i++<n;p"__"));for(p"\n/%*c",2*n+1,92);j<=n;p"\n%*c%*c",++j,92,n*2-j*2+3,47));}
```
[Try it online!](https://tio.run/nexus/c-clang#JY1BCsIwEEX3OcUQEWYyETEKRabepFBEG0jAaSjuSs8eo27f@49fd88pJp2gQFmSviOaJFkiKq1xXrBYsCSJuVcpdhwtkfz5oMe9e1gfnPLJXwNJ7m/f0aCN/xRzbsKrC4fsAp/9pWv5Zkw7gtc9KRKsBgAidiQGtlo/ "C (clang) – TIO Nexus")
# C, 123 bytes
Though the challenge doesn't require it, at the expense of 8 bytes the function can be made reusable (the first solution saves 8 bytes by relying on the implicit initialization of global variables).
```
#define p printf(
i;f(n){for(i=0,p" ");i++<n;p"__"));for(i=0,p"\n/%*c\n",2*n+1,92);i<=n;p"%*c%*c\n",++i,92,n*2-i*2+3,47));}
```
[Try it online!](https://tio.run/nexus/c-clang#RY3BCsIwEETv@YolImSzEW0qlJL2TwpFtIE9uA3FW@m3xxQVb495w0w@PKbIMkGCtLC8olEcohFc47wY7i8uadAYmKiTkPQ4asTwd4Ocj/Y@iHbeClWu9aXb9Xu15F9FxEU4sf7E1lPtrk0Z2ZQqh/C8sRiEVQFANBWGD/gf1DtsOb8B "C (clang) – TIO Nexus")
[Answer]
## Batch, 152 bytes
```
@set s=
@for /l %%i in (1,1,%1)do @call set s=  %%s%%
@echo  %s: =_%
@echo /%s%\
@set s=\%s%/
:l
@echo %s%
@if %s:~-2%==/ set s=%s:\  = \%&goto l
```
Tests:
```
n = 1
 __
/  \
\  /
 \/
n = 2
 ____
/    \
\    /
 \  /
  \/
n = 3
 ______
/      \
\      /
 \    /
  \  /
   \/
```
[Answer]
**C#, 187 bytes**
I'm sure there is a more compact solution out there but this is my first attempt:
```
var a=" "+new string('_',2*n)+"\n/"+new string(' ',2*n)+"\\\n";for(int i=n;i>0;i--){a+=new string(' ',n-i)+"\\"+new string(' ',2*i)+"/\n";}a+=new string(' ',n)+"\\/";Console.Write(a);
```
[Try it online..](https://dotnetfiddle.net/19IOXF)
[Answer]
## JavaScript (ES6), 93 bytes
```
n=>(` 0
/2\\`+`
1\\4/`.repeat(k=++n)).replace(/\d/g,c=>' _'[+!+c].repeat(c&1?k-n-2:+c+--n*2))
```
### Demo
```
let f =
n=>(` 0
/2\\`+`
1\\4/`.repeat(k=++n)).replace(/\d/g,c=>' _'[+!+c].repeat(c&1?k-n-2:+c+--n*2))
console.log(f(1))
console.log(f(2))
console.log(f(3))
```
[Answer]
# [dc](https://www.gnu.org/software/bc/manual/dc-1.05/html_mono/dc.html), 121 bytes
```
?d1+sa2*sb32P[0sq[lvPlq1+dsqlj>h]shlj0<h]srlbsj95svlrx2607Plbsj32svlrx[\]p0sd[ldsjlrx92Plbsjlrxlb2-sb[/]pld1+dsdla>k]dskx
```
[Try it online!](https://tio.run/nexus/dc#HcxBCoMwFATQ@1TE@KWKUOwVsk@zSPyFED@tcUC8eNdpdDXzGJj85LaCoxt8R9ooJCO7ltRWjCRxChZBonqU3MQjjnfssh3Uq0Gf7uiyedlVgY0wYuFI11iaeKrhTWNX4fOTxU2LZSxHzoP6fb717Obw/gM "dc – TIO Nexus")
[Answer]
#  Perl 5 109 94 + 1 (for flag -p) = 95 Bytes
[Try it Online!](https://tio.run/nexus/perl5#U1YsSC3KUdAt@K@SY6sSr2VkzaVSbKukoKSnFK9UoZKjpxSTpw/kKEA5MTF5SiAlerZgoXiQEERaQyVHF2SApp6SPlBRWn6RgoGenkq8NVdBUWZeiUrx//@GBgA)
```
$l=$_*2;$s=" "."_"x$l."\n/"." "x$l."\\\n";$s.=" "x$_."\\"." "x($l-$_*2)."/\n"for 0..$_;print$s
```
Can be run like so:
```
perl -p <name of file> <<< n
```
**Ungolfed**
```
$l=$_*2;
$s=" "."_"x$l."\n/"." "x$l."\\\n";
$s.=" "x$_."\\"." "x($l-$_*2)."/\n"for 0..$_;
print$s
```
**Explanation**
```
#Sets $l to twice the value of the input 'n'
$l=$_*2;  
#Top 2 rows of jewel adding $l underscores then newline  
#followed by '/' and $l spaces.  The '\\\n' is an escaped '\' and a newline
$s=" "."_"x$l."\n/"." "x$l."\\\n";
#The meat of the jewel generation.  It contains a for-loop
#that iterates from 0 to $_ (the input value 'n')
#The loop uses its iterator value ($_ (which overrides the outer $_))
#to determine how many leading spaces it needs to apply.
#Then it adds a '\' with '\\' followed by $l-$_*2 number of spaces
#(the inside of the jewel).  Again, while under the umbrella of the for-loop,
#the $_ refers to the iterator value of the for-loop.
#After the inner spaces, it goes on to add in the '/' and a new line
$s.=" "x$_."\\"." "x($l-$_*2)."/\n"for 0..$_;
#Lastly, it prints the compiled Scalar value $s.  (In Perl, Strings are Scalar values or references
print$s
```
[Answer]
# [Vyxal](https://github.com/Lyxal/Vyxal), 29 bytes
```
ð₴d\_*,\/₴d\\꘍,›(n\\꘍₴nεd\/꘍,
```
[Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=%C3%B0%E2%82%B4d%5C_*%2C%5C%2F%E2%82%B4d%5C%5C%EA%98%8D%2C%E2%80%BA%28n%5C%5C%EA%98%8D%E2%82%B4n%CE%B5d%5C%2F%EA%98%8D%2C&inputs=3&header=&footer=)
```
=== The top ===
ð₴d\_*,
ð       # ' '
 ₴      # Print without newline
  d     # (implicit input) doubled
   \_*  # That many underscores
      , # Output with newline
=== Line 2 ===
\/₴d\\꘍,
\/       # Forward slash
  ₴      # Print without newline
   d     # (implicit input) doubled
    \\꘍  # That many spaces, plus a backslash
       , # Output with newline
=== The rest ===
›(             # (implicit input) incremented times do...
  n            # Iteration number...
   \\꘍         # ...spaces plus a backslash
      ₴        # Print without newline
       nε      # Difference of iteration number and (implicit input)
         d.    # Doubled
          \/꘍  # That many spaces, plus a forward slash
             , # Output with newline
```
[Answer]
# [Canvas](https://github.com/dzaima/Canvas), 12 [bytes](https://github.com/dzaima/Canvas/blob/master/files/chartable.md)
```
_× ；＋/∔⁸╵＼∔║
```
[Try it here!](https://dzaima.github.io/Canvas/?u=XyVENyUyMCV1RkYxQiV1RkYwQi8ldTIyMTQldTIwNzgldTI1NzUldUZGM0MldTIyMTQldTI1NTE_,i=NQ__,v=8)
right tool for the job.
]