[Question]
  [
Write a program or function that prints or outputs this exact text (consisting of 142 characters):
```
()()()()()()
|\3.1415926|
|:\53589793|
\::\2384626|
 \::\433832|
  \::\79502|
   \::\8841|
    \::\971|
     \::\69|
      \::\3|
       \__\|
```
Your program must take no input (except in languages where this is impossible, such as `sed`), and produce the above text (and *only* the above text) as output. A trailing newline is acceptable.
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the shortest answer (in bytes) wins.
  
[Answer]
# [MATL](http://github.com/lmendo/MATL), ~~70~~ ~~68~~ 67 bytes
```
'()'12:)l10:&<toYP43Y$51hb(!10Xy'\::\'FFhZ++'|'3$Yc'||\'3:(95'Zd'o(
```
[Try it online!](http://matl.tryitonline.net/#code=JygpJzEyOilsMTA6Jjx0b1lQNDNZJDUxaGIoITEwWHknXDo6XCdGRmhaKysnfCczJFljJ3x8XCczOig5NSdaZCdvKA&input=)
### Explanation
What a mess. But hey, there's a convolution!
The explanation will be clearer if you can *inspect the stack contents after a given statement*. To do it, just insert `X#0$%` at that point. (This means: `X#` show stack contents, `0$` don't implicitly display anything else, `%` comment out rest of the code). For example, [see the stack right after the convolution](http://matl.tryitonline.net/#code=JygpJzEyOilsMTA6Jjx0b1lQNDNZJDUxaGIoITEwWHknXDo6XCdGRmhaK1gjMCQlKyd8JzMkWWMnfHxcJzM6KDk1J1pkJ28o&input=).
```
'()'       % Push this string
12:        % Range [1 2 ... 12]
)          % Index into string (modular, 1-based): gives '()()()()()()'
l          % Push 1 (will be used later)
10:        % Range [1 2 ... 10]
&<         % All pairwise "less than" comparisons. Gives matrix with "true"
           % below the main diagonal, and the remining entries equal to "false"
to         % Duplicate. Convert to numbers (true becomes 1, false becomes 0)
YP43Y$     % Compute pi with 43 significant digits (42 decimals). Gives a string
51h        % Append last decimal, '3' (ASCII 51). This is needed to avoid rounding
b          % Bubble up the true-false matrix, to be used as logical index
(          % Fill the chars from the pi string into the 0-1 matrix, at the positions
           % indicated by the true-false matrix. Thus each 1 is replaced by a char
           % from the pi string. Entries that were 0 remain as 0. This is done in
           % columm-major order...
!          % ...so transpose to make it row-major
10Xy       % Identity matrix of size 10
'\::\'     % Push this string...
FFh        % ...and append two zeros
Z+         % 2D convolution keeping size. The identity matrix convolved with the
           % above string gives the diagonal bands with chars '\'  and ':'
+          % Add to the matrix containing the digits of pi. At each entry, only one
           % of the two matrices is nonzero
'|'        % Push this string
3$Yc       % Three-input string concatenation. This prepends the 1 (which was pushed
           % a while ago) and appends '|' to each row of the matrix. This converts
           % the matrix to char. Note that char 1 will be displayed as a space. We
           % used char 1 and not char 0 (which would be displayed as a space too)
           % because function `Yc` (`strcat`) strips  off trailing space from the
           % inputs, counting char 0 as space, but not char 1
'||\'      % Push this string
3:(        % Assign it to the first 3 entries of the matrix (column-major), that is, 
           % to the top of the first column
95         % Push ASCII for '_'
'Zd'o      % Push string 'Zd' and convert to numbers: gives [90 100]. These are the
           % (column-major) indices where the '_' char should appear in the last row
(          % Fill those chars
           % Implicitly display. (Chars 0 and 1 are displayed as space)
```
[Answer]
# Perl, 93 bytes
```
$_=bpi$=;printf'()'x6x!$`.'
%12s',F.ee x!$\--^substr"\32::\\$&|",-12while/.{$\}/g
```
Requires the command line option `-l71Mbignum=bpi`, counted as 14. The `\32` should be replaced by a literal character 26.
**Sample Usage**
```
$ perl -l71Mbignum=bpi pi-slice.pl
()()()()()()
|\3.1415926|
|:\53589793|
\::\2384626|
 \::\433832|
  \::\79502|
   \::\8841|
    \::\971|
     \::\69|
      \::\3|
       \__\|
```
---
### Perl, 111 bytes
```
$_=bpi$_*($l=($.=$_)-3);printf'()'x($./2)x!$`."
%$.s",F.ee x!$l--^substr"\32::\\$&|",-$.while/.{$l}/g
```
Parameterized version. Requires the command line option `-nMbignum=bpi`, counted as 12.
**Sample Usage**
```
$ echo 10 | perl -nMbignum=bpi pi-slice.pl
()()()()()
|\3.14159|
|:\265358|
\::\97932|
 \::\3846|
  \::\264|
   \::\33|
    \::\8|
     \__\|
$ echo 20 | perl -nMbignum=bpi pi-slice.pl
()()()()()()()()()()
|\3.141592653589793|
|:\2384626433832795|
\::\028841971693993|
 \::\75105820974944|
  \::\5923078164062|
   \::\862089986280|
    \::\34825342117|
     \::\0679821480|
      \::\865132823|
       \::\06647093|
        \::\8446095|
         \::\505822|
          \::\31725|
           \::\3594|
            \::\081|
             \::\28|
              \::\4|
               \__\|
```
[Answer]
## JavaScript (ES6), ~~187~~ 174 bytes
This is *1 byte shorter* than just displaying the plain text.
```
for(y=n=0,s=`()()()()()()
`;y<10;y++,s+=`|
`)for(x=-2;x++<9;)s+=x>y?(Math.PI+'2384626433832795028841971693')[n++]:`\\${y>8?'__':x+1|y>2?'::':'||'}\\`[y-x]||' ';console.log(s)
```
[Answer]
# [///](http://esolangs.org/wiki////), ~~129~~ 127 bytes
```
/-/\\\\//&/--::--//%/  //#/|
%//!/()()/!!!
|-3.1415926|
|:-53589793|
&2384626|
 &433832#&79502# &8841#%&971#% &69#%%&3#%% -__-|
```
[Try it online!](http://slashes.tryitonline.net/#code=Ly0vXFxcXC8vJi8tLTo6LS0vLyUvICAvLyMvfAolJS8vIS8oKSgpLyEhIQp8LTMuMTQxNTkyNnwKfDotNTM1ODk3OTN8CiYyMzg0NjI2fAogJjQzMzgzMnwKJSY3OTUwMnwKJSAmODg0MSMmOTcxIyAmNjkjJSYzIyUgLV9fLXw)
[Answer]
# Python 2, 131 bytes
```
print'()'*6+'\n|\\3.1415926|\n|:\\53589793|'
for n in 2384626,433832,79502,8841,971,69,3,'':print'%11s|'%('\%s'*2%('_:'[n<'']*2,n))
```
Joint effort between Sp3000 and Lynn. Copper saved a byte, too! [Ideone link.](https://ideone.com/JrC2Nl)
[Answer]
# Bash, 153 bytes
```
cat << _
()()()()()()
|\3.1415926|
|:\53589793|
\::\2384626|
 \::\433832|
  \::\79502|
   \::\8841|
    \::\971|
     \::\69|
      \::\3|
       \__\|
_
```
[Answer]
## Batch, 195 bytes
```
@echo ()()()()()()
@echo ^|\3.1415926^|
@echo ^|:\53589793^|
@set i=\
@for %%d in (2384626 433832 79502 8841 971 69 3)do @call:l %%d
@echo %i%__\^|
@exit/b
:l
@set i= %i%
@echo%i%::\%1^|
```
[Answer]
# Fourier, ~~196~~ 190 bytes
***New feature alert!***
## Code
```
|SaCaaSa|f|~Y0~jY(32aj^~j)|w6(40a41ai^~i)10a~N124a~W92a~S3o46a1415926oWaNaWa58a~CSa53589793oWaNaf2384626oWaNa1wf433832oWaNa2wf79502oWaNa3wf8841oWaNa4wf971oWaNa5wf69oWaNa6wf3oWaNa7wSa95aaSaWa
```
## Explanation
This program is my first demonstration of functions in Fourier:
Functions are defined like so:
```
|code goes here|f
```
The first pipe starts the function declaration. You then put the code in between the pipes. The last pipe ends the function declaration. Finally, the `f` is the variable in which the function is stored. This can be any character, as long as it isn't a reserved function.
For example, in my code, one of the function s is:
```
|SaCaaSa|f
```
Where the variable `S` stores the number 92 and `C` stores the number 58.
When called, the function outputs the following:
```
\::\
```
Since it is the most repeated thing in the pie.
Similarly, to golf down the output, I have used a loop:
```
6(40a41ai^~i)
```
Which repeats the code `40a41a` 6 times. `40a41a` on its own outputs:
```
()
```
So repeating the code six times outputs:
```
()()()()()()
```
Thereby outputting the crust of the pie.
[**Try it on FourIDE!**](https://beta-decay.github.io/editor/?code=fFNhQ2FhU2F8Znx-WTB-alkoMzJhal5-ail8dzYoNDBhNDFhaV5-aSkxMGF-TjEyNGF-VzkyYX5TM280NmExNDE1OTI2b1dhTmFXYTU4YX5DU2E1MzU4OTc5M29XYU5hZjIzODQ2MjZvV2FOYTF3ZjQzMzgzMm9XYU5hMndmNzk1MDJvV2FOYTN3Zjg4NDFvV2FOYTR3Zjk3MW9XYU5hNXdmNjlvV2FOYTZ3ZjNvV2FOYTd3U2E5NWFhU2FXYQ)
Because I haven't implemented functions in the Python interpreter, this program will not work on <http://tryitonline.net>
[Answer]
# [Turtlèd](https://github.com/Destructible-Watermelon/Turtl-d), ~~135~~ 129 bytes
(the interpreter isn't really  ~~slightly~~ buggèd (anymore :])~~, but it does not affect this program~~)
By restructuring and rewriting my program, I golfed... six bytes
And now I have to make new explanation...
Still could be shorter probs though
---
At least the best solution in this lang isn't just writing in the raw data ¯\*(ツ)*/¯
---
[Answer]
# Pyth, 89 bytes
```
J_2K+.n0."09\07´\C2\84J\01£\07Nl:?í"*"()"6Vr9Zp*dJp?!Z\|?qZ9"|:""\::"p\\p:KZ+ZN\|=+ZN=hJ)p*dJ"\__\|"
```
[Try it online!](http://pyth.herokuapp.com/?code=J_2K%2B.n0.%2209%07%C2%B4%C2%84J%01%C2%A3%07Nl%3A%3F%C3%AD%22%2a%22%28%29%226Vr9Zp%2adJp%3F%21Z%5C%7C%3FqZ9%22%7C%3A%22%22%5C%3A%3A%22p%5C%5Cp%3AKZ%2BZN%5C%7C%3D%2BZN%3DhJ%29p%2adJ%22%5C__%5C%7C%22&debug=0)
Replace `\xx` (hexadecimal) with the corresponding ASCII character if you copy/paste the code from this answer; it contains unprintable characters in the packed string which SE filters out.
### Explanation
```
J_2        Sets J to -2
  .n0      Pi; returns 3.141592653589793
  ."(...)" Packed string; returns "2384626433832795028841971693"
 +         Concatenation; returns "3.1415926535897932384626433832795028841971693"
K          Sets K to that string
*"()"6     Repetition; returns "()()()()()()", which is implicitly printed with a newline
 r9Z       Range; returns [9, 8, 7, 6, 5, 4, 3, 2, 1] (Z is initialized to 0)
V          Loop through r9Z, using N as the loop variable
  *dJ      Repetition; d is initialized to " " (returns an empty string if J <= 0)
 p         Print without a newline
  ?!Z      Ternary; if not Z
   \|      then return "|"
   ?qZ9    else, ternary; if Z == 9
    "|:"   then return "|:"
    "\::"  else, return "\::"
 p         Print without a newline
  \\       One-character string; returns "\"
 p         Print without a newline
  :KZ+ZN   Slice; returns K[Z:Z+N], not including K[Z+N]
 p         Print without a newline
 \|        One-character string; returns "|", which is implicitly printed with a newline.
 =+ZN      Adds N to Z
 =hJ       Increments J by 1
)          Ends loop
 *dJ       Repetition; d is initialized to " "
p          Print without a newline
"\__\|"    Returns "\__\|", which is implicitly printed with a newline
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 83 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
surely still quite golfabale
```
7Ḷ⁶ẋ;€“\::\”“|:\”ṭṙ7
⁾()ẋ6⁷⁾|\8ØPæp”|⁷8RUR€µ“⁾ḅ|Za"~ṅỵþȷ^ṇ⁷Ċ’Dṁ;€”|ż@¢Y⁷ø⁶ẋ7“\__\|”
```
**[TryItOnline](http://jelly.tryitonline.net/#code=N-G4tuKBtuG6izvigqzigJxcOjpc4oCd4oCcfDpc4oCd4bmt4bmZNwrigb4oKeG6izbigbfigb58XDjDmFDDpnDigJ184oG3OFJVUuKCrMK14oCc4oG-4biFfFphIn7huYXhu7XDvsi3XuG5h-KBt8SK4oCZROG5gTvigqzigJ18xbxAwqJZ4oG3w7jigbbhuos34oCcXF9fXHzigJ0&input=&args=)**
How?
```
7Ḷ⁶ẋ;€“\::\”“|:\”ṭṙ7 - Link 1, left side padding and filling
7Ḷ                   - lowered range of 7 ([0,1,2,3,4,5,6])
      “\::\”         - filling ("\::\")
  ⁶ẋ;€               - space character repeated that many times and concatenate for each
            “|:\”    - top crust edge filling ("|:\")
                 ṭ   - tack (append to the end)
                  ṙ7 - rotate to the left by 7 (move top crust filling to the top)
⁾()ẋ6⁷⁾|\8ØPæp”|⁷8RUR€µ - Main Link (divided into two for formatting)
⁾()ẋ6⁷                  - "()" repeated 6 times and a line feed
      ⁾|\               - "|\"
          ØP            - pi
         8  æp          - round to 8 significant figures (top edge of the glaze)
              ”|⁷       - "|" and a line feed
                 8R     - range of 8 ([1,2,3,4,5,6,7,8])
                   U    - reverse ([8,7,6,5,4,3,2,1])
                    R€  - range for each ([[1,2,..8],[1,2,..7],...,[1,2],[1]])
                      µ - monadic chain separation
“⁾ḅ|Za"~ṅỵþȷ^ṇ⁷Ċ’Dṁ;€”|ż@¢Y⁷ø⁶ẋ7“\__\|” - Main link (continued)
“⁾ḅ|Za"~ṅỵþȷ^ṇ⁷Ċ’                       - base 250 representation of the rest of the digits
                 D                      - decimalise (makes it a list)
                  ṁ                     - mould (into the shape of the array formed above)
                     ”|                 - "|"
                   ;€                   - concatenate for each
                         ¢              - call last link (1) as a nilad
                       ż@               - zip (with reversed operands)
                          Y⁷            - join with line feeds, and another line feed
                            ø           - niladic chain separation
                             ⁶ẋ7        - space character repeated 7 times
                                “\__\|” - "\__\|" the very bottom of the pie wedge
```
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), 105 bytes
```
'()'*6
'|\3.1415926|
|:\53589793|'
2384626,433832,79502,8841,971,69,3|%{" "*$i+++"\::\$_|"}
' '*7+'\__\|'
```
[Try it online!](https://tio.run/nexus/powershell#BcHBDcMgDADAP1NEKJEbsKKCwdjMYol3Z6g7O73b8LohcQA3ekorXSt78GmduuhQcgiVpHFlbERCFYf2d0WRVlBHQVYkv77xiOn85JyjzWnn8vgLcEAaGWwtc9j7Dw "PowerShell – TIO Nexus")
*Not sure how I never answered this challenge ... I upvoted it and several of the other answers. Oh well, better late than never?*
This puts six balanced parens as a string on the pipeline, then a literal string (saves two bytes) of the next two rows. Then, we loop through the rest of the numbers, each iteration incrementing the number of prepended spaces (`$i`) concatenated with `\::<number>|`. Finally, we create a string of the tip of the pie. Those strings are all left on the pipeline, and an implicit `Write-Output` sticks a newline between.
This is 39 bytes shorter than [just printing the pie.](https://tio.run/nexus/powershell#RcnBDYAgDEDRO1NwQy9GaAstszRhke6O0mDMP738mY7zL5jClTGTlGrBuhIQSxOwoL1rAca6TlxCAIbywtWEboeLGbPDJW3DVWXDBR@ijqGW5nwA "PowerShell – TIO Nexus")
[Answer]
# Python 2, ~~193~~ 176 bytes
```
P="3.1415926 53589793 2384626 433832 79502 8841 971 69 3".split()
f="()"*6+"\n|\%s|\n|:\%s|\n"%(P[0],P[1])
for s in range(7):f+=" "*s+"\::\\"+P[s+2]+"|\n"
print f+" "*7+"\__\|"
```
Or a shorter, more boring answer:
```
print r"""()()()()()()
|\3.1415926|
|:\53589793|
\::\2384626|
 \::\433832|
  \::\79502|
   \::\8841|
    \::\971|
     \::\69|
      \::\3|
       \__\|"""
```
[Answer]
# C# 220 213 209 208 202 201 (171\*) Bytes
\*I find this to be unoriginal and cheating
```
void F()=>Console.Write(@"()()()()()()
|\3.1415926|
|:\53589793|
\::\2384626|
 \::\433832|
  \::\79502|
   \::\8841|
    \::\971|
     \::\69|
      \::\3|
       \__\|");
```
201 Bytes:
```
void f(){var s="()()()()()()\n";for(int i=0;i<9;)s+=(i<1?"|":i<2?"|:":"\\::".PadLeft(i+1))+$"\\{new[]{3.1415926,53589793,2384626,433832,79502,8841,971,69,3}[i++]}|\n";Console.Write(s+@"       \__\|");}
```
220 bytes:
I'm sure that there is something to be golfed here
```
void f(){string s="()()()()()()\n",x="       ";for(int i=9,j=0;i>0;j+=i--)s+=(i>7?"|"+(i<9?":":"")+"\\":x.Substring(i)+@"\::\")+$"{Math.PI}32384626433832795028841971693".Substring(j,i)+"|\n";Console.Write(s+x+@"\__\|");}
```
[Answer]
# Ruby, ~~140~~ ~~138~~ 137 bytes
My solution to this problem in ruby, this is my first code golf answer :D
```
[0,2384626,433832,79502,8841,971,69,3,1].map{|n|puts n<1?"()"*6+"\n|\\3.1415926|\n|:\\53589793|":"\\#{n>1?"::\\#{n}":"__\\"}|".rjust(12)}
```
**Readable version and explanation:**
```
for n in [-1,2384626,433832,79502,8841,971,69,3,0]
  if n < 0 # n == -1
    puts "()"*6+"\n|\\3.1415926|\n|:\\53589793|"
  else
    if n > 0 # digits of pi
      puts "\\::\\#{n}|".rjust(12)
    else # edge of pie
      puts "\\__\\|".rjust(12) 
    end
  end
end
```
Nothing really clever, just using some simple loops :)
**Output:**
```
()()()()()()
|\3.1415926|
|:\53589793|
\::\2384626|
 \::\433832|
  \::\79502|
   \::\8841|
    \::\971|
     \::\69|
      \::\3|
       \__\|
```
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 31 bytes
```
×⁶()↙↓¹⁰↖↖¹⁰↓↓²↘⁸Ｍ↑__↖←¤:↗¤ＵＧPi
```
[Try it online!](https://tio.run/nexus/charcoal#@394@qPGbRqaj9pmPmqbfGjno8YNj9qmARGUORkkuulR24xHjTve71n7qG1ifDxYwYRDS6wetU0/tOT9nq3v9ywPyPz/HwA)
You may be wondering: what is this sorcery? How can you fill with `ＵＧPi`? Well, Charcoal is starting to get Wolfram Language support, in the hope that one day it can be competitive in more challenges!
## Previous, 71 bytes
```
×⁶()↙↓¹⁰↖↖¹⁰↓↓²↘⁸Ｍ↑__↖←¤:↗¤3.141592653589793238462643383279502884197169
```
[Try it online!](https://tio.run/nexus/charcoal#@394@qPGbRqaj9pmPmqbfGjno8YNj9qmARGUORkkuulR24xHjTve71n7qG1ifDxYwYRDS6wetU0/tMRYz9DE0NTSyMzU2NTC0tzS2MjYwsTMyMzE2NjC2Mjc0tTAyMLCxNDS3NDM8v9/AA "Charcoal – TIO Nexus")
## Verbose
```
Print(Multiply(6, "()"));
Move(:DownLeft)
Print(:Down, 10)
Move(:UpLeft)
Print(:UpLeft, 10)
Move(:Down)
Print(:Down, 2)
Print(:DownRight, 8)
Move(:Up)
Print("__")
Move(:UpLeft)
Move(:Left)
Fill(":")
Move(:UpRight)
Fill("3.141592653589793238462643383279502884197169")
```
Note that this is different as the deverbosifier automatically compresses strings and does not remove redundant commands.
## With compressed strings, 52 bytes
```
×⁶¦()↙↓¹⁰↖↖¹⁰↓↓²↘⁸↑__↖←¤:Ｍ↗¤”i¶∧²uτ¶R›    §Ｑ´⌈#_⮌ＰOÞ”
```
## xxd output
```
0000000: aab6 ba28 291f 14b1 b01c 1cb1 b014 14b2  ...()...........
0000010: 1eb8 125f 5f1c 11ef 3acd 1def 0469 0a01  ...__...:....i..
0000020: b275 f40a 52be 0999 9fa4 d1e0 1a23 5f86  .u..R........#_.
0000030: d04f de04                                .O..
```
[Try it online!](https://tio.run/nexus/charcoal#XY3NDoIwEITvPAXpqU3Q0G5/8Wo8SWJMPHNCadIAMRXj01elEoHbzs43M@F0t63H5cN527sXllmKMEGE7JKyG2pc7Ltne6yvniSRHB9ZSnPyAy79wo5yDnwDqzRb6LO9NZ@E/jdONqoqtN6JKt4H6xxGxYwZuyYDtpRTYZgUILRRBhhoLpnkABqYMiJnWnNqFJUGkRDCZngD "Charcoal – TIO Nexus")
[Answer]
# PHP, 170 bytes
no arbritrary precision Pi in PHP? Calculating takes much more space than Copy&Paste. Doesn´t matter that the last digit here is cut, not rounded; but in 64 bit Pi the last digit gets rounded up.
```
for(;$i<11;)echo str_pad($i?["\\__\\","|\\","|:\\","\\::\\"][$i>9?0:min(3,$i)].[3.1415926,53589793,2384626,433832,79502,8841,971,69,3][$i-1]."|
":"
",13,$i++?" ":"()",0);
```
Run with `php -r '<code>'`
**uncommented breakdown**
```
for(;$i<11;)
    echo str_pad($i?
         ["\\__\\","|\\","|:\\","\\::\\"][$i>9?0:min(3,$i)]
        .[3.1415926,53589793,2384626,433832,79502,8841,971,69,3][$i-1]
        ."|\n"
    :"\n"
    ,13,$i++?" ":"()",0);
```
[Answer]
# Python 2, ~~183~~ 171 bytes
```
p,d=[2384626,433832,79502,8841,971,69,3],"|\n"
c=("()"*6)+d[1]+"|\\"+`3.1415926`+d+"|:\\"+`53589793`+d
for x in range(7):c+=" "*x+"\\::\\"+`p[x]`+d
print c+" "*7+"\\__\\|"
```
Does't really do anything clever. Just builds up a big string then prints it out.
**EDIT**
Reduced to 171 after reading @Lynn's answer and learning. Sorry if it is wrong to (shamelessly) steal some bytes from you without you suggesting it. Please tell me if so and I will roll back the change.
**Output**
```
python pi.pie.py
()()()()()()
|\3.1415926|
|:\53589793|
\::\2384626|
 \::\433832|
  \::\79502|
   \::\8841|
    \::\971|
     \::\69|
      \::\3|
       \__\|
```
[Answer]
# [Stax](https://github.com/tomtheisen/stax), 63 bytes
```
ü?½Pi<Θ*q}ü¿▒5Ç>cdƒ±<Gw►,─ô╟▒g•iâÑ♠514Φ⌂!Ñεùáèè♂ÑD╔«dÿ47¡ô#UV•╧
```
[Run and debug online!](https://staxlang.xyz/#p=813fab50693ce92a717d81a8b135803e63649ff13c4777102cc493c7b167076983a506353134e87f21a5ee97a08a8a0ba544c9ae64983437ad9323555607cf&a=1)
Shorter than the accepted MATL answer. It would definitely be shorter if more digits were stored as the constant pi in Stax.
(What is that `Pi<0` in the code?)
## Explanation
Uses the ASCII equivalent to explain, which is
```
.()6*PVP$2ME.|\a+"|:\"a+"!RNyb2L$-!mV=223w+&O-"!{"\::\"s$+mELr"\__\"]+|>m'|+
```
Expalantion:
```
.()6*PVP$2ME.|\a+"|:\"a+
.()                           "()"
   6*P                        Print 6 times
      VP$                     First two lines of pi in the output
         2ME                  Push the two lines separately on the stack
            .|\a+             Prepend the first line with "|\"
                 "|:\"a+      Prepend the second line with "|:\"
"..."!{"\::\"s$+mELr"\__\"]+|>m'|+
"..."!                                [2384626,433832,79502,8841,971,69,3]
      {"\::\"s$+m                     Convert each element to a string and prepend "\::\"
                 ELr                  Prepend the first two lines to array
                    "\__\"]+          Append "\__\" to the converted array
                            |>        Right align text
                              m'|+    Append "|" to each array element and print
```
[Answer]
# Java 7, ~~260~~ ~~236~~ 191 bytes
```
String d(){return"()()()()()()\n|\\3.1415926|\n|:\\53589793|\n\\::\\2384626|\n \\::\\433832|\n  \\::\\79502|\n   \\::\\8841|\n    \\::\\971|\n     \\::\\69|\n      \\::\\3|\n       \\__\\|";}
```
Sigh, simply outputting the pie is shorter, even with all the escaped backslashes.. >.>  
Here is previous answer with a tiny bit of afford, although still not very generic or fancy (**236 bytes**):
```
String c(){String n="\n",p="|",q=p+n,x="\\::\\",s=" ",z=s;return"()()()()()()"+n+p+"\\"+3.1415926+q+p+":\\53589793"+q+x+2384626+q+s+x+433832+q+(z+=s)+x+79502+q+(z+=s)+x+8841+q+(z+=s)+x+971+q+(z+=s)+x+69+q+(z+=s)+x+3+q+(z+=s)+"\\__\\|";}
```
A pretty boring answer, since simply outputting the result without too much fancy things is shorter in Java than a generic approach.
**Ungolfed & test code:**
[Try it here.](https://ideone.com/FW4KmJ)
```
class M{
  static String c(){
    String n = "\n",
           p = "|",
           q = p + n,
           x = "\\::\\",
           s = " ",
           z = s;
    return "()()()()()()" + n + p + "\\" + 3.1415926 + q + p + ":\\53589793" + q + x + 2384626 + q + s
            + x + 433832 + q + (z += s) + x + 79502 + q + (z += s) + x + 8841 + q 
            + (z += s) + x + 971 + q + (z += s) + x + 69 + q + (z += s) + x + 3 + q
            + (z += s) + "\\__\\|";
  }
  public static void main(String[] a){
    System.out.println(c());
  }
}
```
**Output:**
```
()()()()()()
|\3.1415926|
|:\53589793|
\::\2384626|
 \::\433832|
  \::\79502|
   \::\8841|
    \::\971|
     \::\69|
      \::\3|
       \__\|
```
[Answer]
# Qbasic, 175 bytes
```
?"()()()()()()":?"|\3.1415926|":?"|:\53589793|":?"\::\2384626|":?" \::\433832|":?"  \::\79502|":?"   \::\8841|":?"    \::\971|":?"     \::\69|":?"      \::\3|":?"       \__\|"
```
[Answer]
# Lua, 152 Bytes
```
print[[()()()()()()
|\3.1415926|
|:\53589793|
\::\2384626|
 \::\433832|
  \::\79502|
   \::\8841|
    \::\971|
     \::\69|
      \::\3|
       \__\|]]
```
Try as I might I could not compress this pi.
Lua is just too verbose to do it, maybe a pi of greater size, but not this one.
Another solution, 186 Bytes.
```
s="()()()()()()\n|\\3.1415926|\n|:\\53589793|\n"i=0 for z in('2384626|433832|79502|8841|971|69|3|'):gmatch'.-|'do s=s..(' '):rep(i)..'\\::\\'..z.."\n"i=i+1 end print(s..'       \\__\\|')
```
Annoyingly Lua's pi isn't accurate enough to even fill the pi. :(
[Answer]
# Javascript, 172 bytes
Paste into your console to run.
```
for(y=n=0,s=`()()()()()()
`;y<10;y++,s+=`|
`)for(x=-2;x++<9;)s+=x>y(Math.PI+'2384626433832795028841971693'[n++]:`\\${y>8?'__':x+1|y>1?'::':'||'}\\`[y-x]||' ';console.log(s)
```
[Answer]
# [Deadfish~](https://github.com/TryItOnline/deadfish-), 871 bytes
```
{iiii}cicdcicdcicdcicdcicdcic{ddd}dc{{i}}{i}iiiic{ddd}ddc{dddd}dcdddddciiiciiicdddciiiiciiiic{d}iiiciiiic{{i}ddd}c{{d}}{d}ddddc{{i}}{i}iiiic{dddddd}ddddddc{iii}iiiic{dddd}icddciiciiicicddciicddddddc{{i}ddd}iiic{{d}}{d}ddddc{{i}dd}iic{ddd}ddddcc{iii}iiiic{dddd}ddciciiiiicddddciicddddciiiic{{i}ddd}c{{d}}{d}ddddc{ii}iic{iiiiii}c{ddd}ddddcc{iii}iiiic{dddd}cdcciiiiicdddddcdc{{i}ddd}iiiic{{d}}{d}ddddc{ii}iicc{iiiiii}c{ddd}ddddcc{iii}iiiic{dddd}iiiciicddddcdddddciic{{i}ddd}iiiic{{d}}{d}ddddc{ii}iiccc{iiiiii}c{ddd}ddddcc{iii}iiiic{ddd}ddddddccddddcdddc{{i}ddd}iiiiic{{d}}{d}ddddc{ii}iicccc{iiiiii}c{ddd}ddddcc{iii}iiiic{ddd}dddddcddcddddddc{{i}ddd}iiiiic{{d}}{d}ddddc{ii}iiccccc{iiiiii}c{ddd}ddddcc{iii}iiiic{dddd}iiciiic{{i}ddd}dddc{{d}}{d}ddddc{ii}iicccccc{iiiiii}c{ddd}ddddcc{iii}iiiic{dddd}dc{{i}ddd}iiic{{d}}{d}ddddc{ii}iiccccccc{iiiiii}ciiiccdddc{iii}iic{{d}}{d}ddddc
```
[Try it online!](https://tio.run/##jdJdDsMgCADgE@1QC2wZz3s0nN3xO@lmG5oYieInweLjjk96v25zDpKPgQA3YyAiI4xBzDI0NdbQZt3USXJlR0fEBJHLKxZAT0iAoqmBG9p139PK1garDnFPxpkauF/049t61i1rf7BSVqR7sObzuk0wyfp3oUsnCy4Nq9XSlm253lmvNB@hQTfsfICvfWDP3DYMWXDTbXYD6ms5vuda3tU/VahlaRqU3/Z4Zs4P "Deadfish~ – Try It Online")
Just because.
[Answer]
**JavaScript (ES6), ~~170 bytes~~ 165 bytes**
is a bit "cheated", since if run on the console, the return value would be displayed
```
v=0;("()()()()()()\n|9|:87654321".replace(/\d/g,(o)=>"\\"+(Math.PI+'2384626433832795028841971693').substr(v,o,v-=-o)+"|\n"+(o<9?" ".repeat(8-o)+(o>1?"\\::":"\\__\\|"):""))
```
After some teaking, the function looks like this(function must be called with parameter with the value 0):
```
v=>`()()()()()()
 |9 |:87654321\\__\\|`.replace(/\d/g,o=>`\\${(Math.PI+"2384626433832795028841971693").substr(v,o,v-=-o)}|
${" ".repeat(9-o)+(o<9&o>1?"\\::":"")}`)
```
If you want to call the function 167 bytes:
```
z=v=>`()()()()()()
 |9 |:87654321\\__\\|`.replace(/\d/g,o=>`\\${(Math.PI+"2384626433832795028841971693").substr(v,o,v-=-o)}|
${" ".repeat(9-o)+(o<9&o>1?"\\::":"")}`)
/*could be run like this or directly in the console*/
console.info("\n"+z(0));
```
[Answer]
# PHP, 142 bytes
Sneaky-sneaky :) `php` just prints everything out without trying to interpret them as PHP code if it does not see any `<?php ?>` pairs.
```
()()()()()()
|\3.1415926|
|:\53589793|
\::\2384626|
 \::\433832|
  \::\79502|
   \::\8841|
    \::\971|
     \::\69|
      \::\3|
       \__\|
```
[Answer]
# [Husk](https://github.com/barbuz/Husk), 76 bytes
```
`:+R' 7"¦__¦|":*"()"6§+(mo:'|t↑2)↓2m↓3z+zR¢" "Nmo`:'|+"¦::¦"Cṫ9Γ·::'.ṁs↑54İπ
```
[Try it online!](https://tio.run/##yygtzv7/P8FKO0hdwVzp0LL4@EPLapSstJQ0NJXMDi3X1sjNt1KvKXnUNtFI81HbZKNcIGFcpV0VdGiRkoKSX25@AlBaG6jRyurQMiXnhztXW56bfGi7lZW63sOdjcVAfaYmRzacb/j/HwA "Husk – Try It Online")
There's probably some interesing way to shorten this further.
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), 64 bytes
```
‛()6*15∆Iṅ\.1Ṁ½÷$‛|\p$`|:\\`p"43∆I16ȯ7ɾṘẇvṅ‛\:mvp‛\_mJJ\|vJJ12↳⁋
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyIiLCIiLCLigJsoKTYqMTXiiIZJ4bmFXFwuMeG5gMK9w7ck4oCbfFxccCRgfDpcXFxcYHBcIjQz4oiGSTE2yK83yb7huZjhuod24bmF4oCbXFw6bXZw4oCbXFxfbUpKXFx8dkpKMTLihrPigYsiLCIiLCIiXQ==)
]