ASCII Pumpkin Carving Today is Halloween and it's time to carve some pumpkins!

   &amp;
((^.^))


Given an input integer, string, list of integers, etc., output the corresponding pumpkin. The input will always be of the form Stem, Eyes, Mouth, Width. For example, 2331 would be a valid input.

The pumpkin takes the form:

   S
((EME))


where S is the stem, E are the eyes, M is the mouth, and the parens form the body.

Definitions

Stem:
0 for a curl &amp;
1 for a straight |
2 for a slant left \
3 for a slant right /  

Eyes:
0 for angled ^
1 for small dots .
2 for medium dots o
3 for large dots O  

Mouth:
0 for angled v
1 for small dot .
2 for medium dot o
3 for large dot O  

Width:
0 for a skinny pumpkin (only one pair of parens)
1 for a fat pumpkin (two pairs of parens)

Examples

0011
   &amp;
((^.^))

3100
   /
 (.v.)

2331
   \
((OOO))

1200
   |
 (ovo)


Rules


Input/output can be given by any convenient method.
You can print it to STDOUT or return it as a function result.
Either a full program or a function are acceptable.
Any amount of extraneous whitespace is permitted, provided the characters line up appropriately.
You must use the numbering and ordering of the pumpkin carvings as they are described above.
Standard loopholes are forbidden.
This is code-golf so all usual golfing rules apply, and the shortest code (in bytes) wins.
Add++, 56 bytes

L,"&amp;|\/^.oOv.oO ((("4$Tz£:BF"("+@32C3*$+Bh$2D-1A:1+")"*J


Try it online!

Add++ is not the best at string manipulation challenges

How it works

We create an lambda function that takes a single argument - a list of integers - and outputs the final pumpkin. 

L,                    - Define our function. Takes in a four element list e.g. [0 0 1 1]
                                                       STACK = [[0 0 1 1]]
  "&amp;|\/^.oOv.oO ((("  - Push this string               STACK = [[0 0 1 1] '&amp;|\/^.oOv.oO (((']
  4$T                 - Split it into 4 pieces         STACK = [[0 0 1 1] ['&amp;|\/' '^.oO' 'v.oO' ' (((']
  z                   - Zip the lists together         STACK = [[['&amp;|\\/' 0] ['^.oO' 0] ['v.oO' 1] [' (((' 1]]]
  £:                  - Index into each string         STACK = [['&amp;' '^' '.' '(']]
  BF                  - Flatten the stack              STACK = ['&amp;' '^' '.' '(']
  "("+                - Append a "(" to last element   STACK = ['&amp;' '^' '.' '((']
  @                   - Reverse stack                  STACK = ['((' '.' '^' '&amp;']
  32C3*$+             - Prepend 3 spaces to stalk      STACK = ['((' '.' '^' '   &amp;']
  Bh                  - Output stack with newline      STACK = ['((' '.' '^']
  $2D                 - Push from under                STACK = ['((' '^' '.' '^']
  -1A:1+              - Add one the the last argument  STACK = ['((' '^' '.' '^' 2]
  ")"*                - Repeat ")" that many times     STACK = ['((' '^' '.' '^' '))']
  J                   - Join together                  STACK = ['((^.^))']
                      - Implicitly output