[Question]
  [
# Introduction
Cacti come in various different sizes, shapes and colors. However, the most iconic cactus and must-have in every Western has to be the [saguaro](https://en.wikipedia.org/wiki/Saguaro). Important features are its size and arms, which have defined the stereotypical cactus appearance. 
Your task is to bring the saguaro in the ASCII world. However, -- as in the real world -- no saguaro is like another, so your program has to be able to generate saguaros with varying arm configurations.
# An example saguaro
> 
> * Input: `[0b10, 0b11]` (`[2, 3]` in decimal, input length of `2`)
> 
> 
> 
```
     _     
    / \    
 _  | |    
/ \ | |    
| | | |    
\ \_| |    
 \__  |    
    \ |    
 _  | |  _ 
/ \ | | / \
| | | | | |
\ \_| |_/ /
 \__   __/ 
    \ /    
    | |    
    | |    
```
# Specifications
A saguaro always has a base and a top, with variable amounts of stem in between. The stem parts can have no arms, an arm on the right, one on the left or two arms. 
Saguaro growth patterns are given as an input list containing two-bit values. `00` means no arms, `01` an arm on the right, `10` an arm on the left and `11` two arms (all in binary). The input list's length determines the saguaro's height. 
Saguaro sections look like the following. Cactus parts are surrounded by octothorps, `#`, for clarity which shall not be printed.  
A saguaro's height is always equal to `4+6*k` characters for nonnegative integers `k`.
```
#############
#     _     # Saguaro top
#    / \    #
#############
# _  | |  _ # Stem, both arms
#/ \ | | / \# Stem id: 11
#| | | | | |#
#\ \_| |_/ /#
# \__   __/ #
#    \ /    #
#############
# _  | |    # Stem, left arm
#/ \ | |    # Stem id: 10
#| | | |    #
#\ \_| |    #
# \__  |    #
#    \ |    #
#############
#    | |  _ # Stem, right arm
#    | | / \# Stem id: 01
#    | | | |#
#    | |_/ /#
#    |  __/ #
#    | /    #
#############
#    | |    # Stem, no arms
#    | |    # Stem id: 00
#    | |    #
#    | |    #
#    | |    #
#    | |    #
#############
#    | |    # Saguaro base
#    | |    #
#############
```
# Input
As previously said, the input consists of a list of two-bit values (`0, 1, 2, 3` in decimal). It can be given in any reasonable format. The list's first element corresponds to the saguaro's highest stem part, the second element to its second highest stem part, etc.  
If you want, you can require the input list's length as an additional input. Please specify it in your answer if you do so.
# Output
Your output ASCII saguaro should be built using the exact stem parts as described above. Trailing spaces on a line and trailing new lines are ignored; you may print more, fewer or as many as specified above.
# Rules
* Standard [loopholes](https://codegolf.meta.stackexchange.com/q/1061/73111) apply
* This being [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), a program's byte count should be minimal
# Test cases
> 
> * An outlier. Input: `[0b01, 0b00, 0b01, 0b11]`
> 
> 
> 
```
     _     
    / \    
    | |  _ 
    | | / \
    | | | |
    | |_/ /
    |  __/ 
    | /    
    | |    
    | |    
    | |    
    | |    
    | |    
    | |    
    | |  _ 
    | | / \
    | | | |
    | |_/ /
    |  __/ 
    | /    
 _  | |  _ 
/ \ | | / \
| | | | | |
\ \_| |_/ /
 \__   __/ 
    \ /    
    | |    
    | |    
```
---
> 
> * Alternating arms. Input: `[0b10, 0b01, 0b10]`
> 
> 
> 
```
     _     
    / \    
 _  | |    
/ \ | |    
| | | |    
\ \_| |    
 \__  |    
    \ |    
    | |  _ 
    | | / \
    | | | |
    | |_/ /
    |  __/ 
    | /    
 _  | |    
/ \ | |    
| | | |    
\ \_| |    
 \__  |    
    \ |    
    | |    
    | |    
```
---
> 
> * An abundance of arms. Input: `[0b11, 0b11]`
> 
> 
> 
```
     _     
    / \    
 _  | |  _ 
/ \ | | / \
| | | | | |
\ \_| |_/ /
 \__   __/ 
    \ /    
 _  | |  _ 
/ \ | | / \
| | | | | |
\ \_| |_/ /
 \__   __/ 
    \ /    
    | |    
    | |    
```
---
> 
> * No arms, also known as a spear. Input: `[0b00]`
> 
> 
> 
```
     _     
    / \    
    | |    
    | |    
    | |    
    | |    
    | |    
    | |    
    | |    
    | |    
```
---
> 
> * No body, some call it a young cactus. Input: `[]`
> 
> 
> 
```
     _     
    / \    
    | |    
    | |    
```
---
  
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), ~~50~~ 49 bytes
```
↘_\¶/Ｆ²«Ｊ¹¦²Ｆθ¿﹪÷Ｉκ⁺¹ι²”{➙∧⊟≕δaL7ＹF¬⊕ρ↥↖_K”↓⁶↓²‖Ｔ
```
[Try it online!](https://tio.run/##VY4xC8IwFIRn@yuOTglUais46KiLglBKx0AoNbXBmGib1sH622Oqi/Ie78Edx3dVU7aVKZVzWSu1JeudeehcnhsbIeSMMR2HdBPUpgVJKZ7B7NBfb4UhSYTUG7OPc6eQNcjRnHplyF7bnRzkSZBt2VlyoREy1XdTRFI65Si@tHAEONMjYkyoEX784zFipsG5v35DCqE6gZ@GEVYT/E/51MlFrURli7bUna92JV58OZcslqmbD@oN "Charcoal – Try It Online") Link is to verbose version of code. Explanation:
```
↘_\¶/
```
Draw the top.
```
Ｆ²«
```
Loop over each side.
```
Ｊ¹¦²
```
Jump to just under the right side of the top.
```
Ｆθ
```
Loop over each stem part.
```
¿﹪÷Ｉκ⁺¹ι²
```
Test whether there is an arm.
```
”{➙∧⊟≕δaL7ＹF¬⊕ρ↥↖_K”
```
If so print an arm.
```
↓⁶
```
Otherwise just print a vertical line.
```
↓²
```
After printing the stem, print the base.
```
‖Ｔ
```
Reflect ready to draw the other side. Once both sides are drawn, the sides are then reflected back into their final position.
[Answer]
# JavaScript (ES6), 210 bytes
I spent far too long on another solution before realising there was a better way, which didn't leave me as much time as I would've liked to work on this.
```
a=>`     _
    / \\`+a.map(([x,y])=>`
 1  | |  2
3 5 | | 4 6
7 7 | | 8 8
5 51| |24 4
 511${`| `[x]} ${`| `[y]}224
    ${`|\\`[x]} `.replace(/\d/g,m=>` _/\\|`[m%2?x*-~m/2:y*m/2])+`|/`[y],s=`
    | |`).join``+s+s
```
---
## Try it
```
o.innerText=(f=
a=>`     _
    / \\`+a.map(([x,y])=>`
 1  | |  2
3 5 | | 4 6
7 7 | | 8 8
5 51| |24 4
 511${"| "[x]} ${"| "[y]}224
    ${"|\\"[x]} `.replace(/\d/g,m=>` _/\\|`[m%2?x*-~m/2:y*m/2])+"|/"[y],s=`
    | |`).join``+s+s
)(i.value=["11","10","01","00"]);oninput=_=>o.innerText=f(i.value.split`,`)
```
```
<input id=i><pre id=o>
```
[Answer]
# [Python 2](https://docs.python.org/2/), 189 bytes
```
lambda l:'     _\n    / \\\n'+'\n'.join(('    |',' /|\  _   \  \|\_    __ |||| \\'[j::6])[i/2]+' '+('|','|||| /   __  /|/_ _   /  \|/'[j::6])[i%2]for i in l for j in range(6))+'\n    | |'*2
```
[Try it online!](https://tio.run/##RU7RCsIwDPyVvEhaN6xW2EPBL1lGmei0Y2ZjzAeh/17T@uA9XC4kd9zy2Z4z2zRcKE3963rrYXIIGZ44DwNExFih0GGcAytV7hFrBBNJHmWTQZF88XmIArFhOzrXdLoNxnYVAlYKs62cze9VIowvESZHmL9nZ7thXiFAYJggyzHLtefHXTVa50aliFTZ27SsgTcYVODlvSmtkzrVcKxB@Ky/ "Python 2 – Try It Online")
[Answer]
# [Python 2](https://docs.python.org/2/), ~~256~~ ~~253...205~~ ~~203~~ 199 bytes
```
r=[('     _',''),('/','\ ')]
for a in input()+[0]:r+=zip(*[['|'*6,'_|    |_,,/|  \/  |\,,||  ||  ||,,\| _\/_ |/,,\ ____ /,,\/'[i::2].split(',')][2-i&a>0]for i in 0,1])
for l in r[:-4]:print'%5s %s'%l
```
[Try it online!](https://tio.run/##JY7BDgIhDETvfkUva0GrwEY9kOiPACF6MJJsVsKuBw3/vhadtJPXQzOT3/PjOfbLUs5OIDRFJERJAhWDB5RhdX8WuEIaefJrFnLrdLBle/6kLDbOYcXNiTDW9l4jkWLyitkTVeb/EvkK0asIVTFDZEEjhS5Z24f9lIc0C46VwfW7tL5edGjZqWVrMkH@qgztLM7uDsHmksYZu@ME3YTdsCxO34wmfdM/M2zGhC8 "Python 2 – Try It Online")
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), 235 bytes
```
param($a)'     _
    / \'
($a|%{((,'1|'*6),('1|  _
1| / \
1|2
1|_/ /
1 __/ 
1/'),(' _ 2
/ \2
| |2
\ \_| |
 \__  |
    \ |'),(' _ 2  _
/ \2 / \
| |22
\ \_| |_/ /
 \__   __/
    \ /'))[$_]})-replace1,'    | '-replace2,' | |'
,'    | |'*2
```
[Try it online!](https://tio.run/##PU9BDgIhDLz3FT2sAQwGwcSz/xBDiCHxsMbNevAgvh2n6G4TOs0wM4Xp8Srz81bGsbUpz/muh2wUSyWS7jgqAlk3b62t8lVtj8ZqDKJAhwAQcJJjR54TkLxTouLEgaAIVBmayDFhIEBiQVTkukolUtQ9VByrpWf/bLLg78QScx7S5WN2c5nGfC3e9sdXVgsTwCBA0XKDH4TW2knvrbfBHswX "PowerShell – Try It Online")
PowerShell doesn't have a `map` or `zip` or a real easy way to reverse strings, so we're left with something else -- simple replacements of repeated sections.
The first two lines take input as an array of integers and output the top of the cactus. Then we loop through `$a` and select into an array of four strings based on the current value. Those strings are left on the pipeline and then we use our `-replace` to fill in the appropriate spots. We then put the bottom of the cactus onto the pipeline as well.
Everything is gathered from the pipeline and an implicit `Write-Output` happens at program completion, inserting a newline between every element.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~76~~ 75 bytes
```
„ _…/ \‚4ú»,v6F'|4ú"_ |/\"•Aö¡Èèj{^ë•5вèJ5ôNè©‚y1›èð'|®∞2äθ‚yÉèJ,}}„| 4úû=,
```
[Try it online!](https://tio.run/##MzBNTDJM/f//UcM8hfhHDcv0FWIeNcwyObzr0G6dMjM39RogUyleoUY/RulRwyLHw9sOLTzccXhFVnXc4dVAAdMLmw6v8DI9vMXv8IpDK4E6Kw0fNew6vOLwBvWaQ@sedcwzOrzk3A6Q@OFOoEKd2lqgRTUKQEMP77bV@f/fyNjAEAA "05AB1E – Try It Online")
[Answer]
# [Java (OpenJDK 8)](http://openjdk.java.net/), ~~626~~ ~~566~~ ~~499~~ ~~466~~ ~~398~~ ~~312~~ ~~310~~ 308 bytes
Can be golfed a tonne
```
a->{String r=" |,",g="    |",n="     _,    / \\,";boolean j,k;for(int e:a)n+=((k=e>1)?" _  |":g)+((j=e%2>0)?" |  _,":r)+(k?"/ \\ |":g)+(j?" | / \\,":r)+(k?"| | |":g)+(j?" | | |,":r)+(k?"\\ \\_|":g)+(j?" |_/ /,":r)+(k?" \\__ ":g)+(j?"  __/,":r)+(k?"    \\":g)+(j?" /,":r);return(n+g+r+g+r).replace(",","\n");}
```
[Try it online!](https://tio.run/##VZFNi4MwEIbv/oohsJCgtftxq6u97W1PPdYiqU0lahOJsUup/nZ3UpXuDuSD95mZhHdKfuUr3QhVnqpRXhptLJSohZ2VdXjuVG6lVuHXfIk8r@mOtcwhr3nbwjeXCu4eYLSWW9SXzE@p7P4QwM4aqYoEFMQw8lVynwQwMYE@IEGBJ0ZPAjXdIAvcvoY0DUh01LoWXEEZVNFZG4pdQWw4U35MaRWL5I1tCWSuwaZgPqVlLF7ek1en9q4X2RiUqy1xDZes8kGnJxbeo/IP9@5/C8XaNM3@8mwN6yd3NIMnhiz7SzHS9EknFBlhO6Oo8gvfuMVCI5qa54ISdIakirBoGF0x@u6O2fvZ6quWJ7jgBOjk6f4A3BQtmwfiYndrrbiEurNhgym2xtdC3jT1jSrxA48Z3T8GxqJHyeAN4y8 "Java (OpenJDK 8) – Try It Online")
[Answer]
# [SOGL V0.12](https://github.com/dzaima/SOGL), ~~56~~ ~~54~~ 53 [bytes](https://github.com/dzaima/SOGL/blob/master/chartable.md)
```
5⁷yΙ‚‘∑≡`a#¾‘O.{@.2%i»¹{"⁸G‘6∙;?X"j1>ζ╔²i[n¹‘5n}┼±↔}O
```
[Try it Here!](https://dzaima.github.io/SOGLOnline/?code=NSV1MjA3N3kldTAzOTkldTIwMUEldTIwMTgldTIyMTEldTIyNjElNjBhJTIzJUJFJXUyMDE4Ty4lN0JALjIlMjVpJUJCJUI5JTdCJTIyJXUyMDc4RyV1MjAxODYldTIyMTklM0IlM0ZYJTIyajElM0UldTAzQjYldTI1NTQlQjJpJTVCbiVCOSV1MjAxODVuJTdEJXUyNTNDJUIxJXUyMTk0JTdETw__,inputs=NCUwQTAlMEExJTBBMiUwQTM_)
Explanation:
```
..‘                   push the ending part - "    | |\n    | |"
   ..‘O               output the starting part - "     _ \n    / \"
       .{             input times do
         @              push a space
          .2%           push input%2
             i»         push floor(prevInput/2)
               ¹        wrap the two in an array
                        
{                   }   for each of the two numbers
 "..‘                     push "|    " - base stem
     6∙                   multiply vertically 6 times
       ;?       }         if the current item iterating over is truthy (i.e. != 0)
         X                  remove ToS - the regular stem - from the stack 
          "..‘              push "|  _ | / \| | ||_/ / __/ /    " - stem with an arm
              5n            split it into line lengths of 5
                 ┼        add that horizontally to the space pushed earlier (or whatever it's become)
                  ±↔      reverse ToS - the stem currently - horizontally
                     O  output the array of the current part
```
]