[Question]
  [
This is what we'll call a bowl of alphabet soup - a roughly circular ascii-art shape with the 26 uppercase English letters (A-Z) arranged clockwise to form the perimeter:
```
   XYZABC
 VW      DE
U          F
T          G
S          H
 RQ      JI
   PONMLK
```
Write a program that takes in a single letter character, A-Z, and outputs that same bowl of alphabet soup "rotated", so to speak, so the input letter appears where the `A` does in the example above and the rest of the alphabet cycles fully around clockwise.
So the output for input `A` would be that same original bowl of alphabet soup.
And the output for input `B` would be this one:
```
   YZABCD
 WX      EF
V          G
U          H
T          I
 SR      KJ
   QPONML
```
Likewise the output for `H` would be:
```
   EFGHIJ
 CD      KL
B          M
A          N
Z          O
 YX      QP
   WVUTSR
```
Or for `Z`:
```
   WXYZAB
 UV      CD
T          E
S          F
R          G
 QP      IH
   ONMLKJ
```
This needs to work for all 26 letters, A through Z.
### Details:
* You can assume the only input will be a single letter, A through Z.
* If convenient you may use lowercase a-z for input and/or output, you can even mix and match lower and uppercase.
* The alphabet order must cycle clockwise, not counter-clockwise.
* You must use spaces, not something else, to indent and fill the soup bowl.
* There may be leading or trailing newlines or spaces in the output as long as the soup bowl is arranged properly.
* Note that the bowl shape is 12 characters wide by 7 tall to make it appear roughly circular as text. Your bowls need to be the same shape.
**This is code golf so the shortest code wins!**
  
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 21 bytes
Defines a program \$f : \color{purple}{\texttt{AlphabeticChar}} \rightarrow \color{purple}{\texttt{String}}\$
### Code:
```
2AA¹k._•1ëª»*Ć,ãiDΣ•Λ
```
[Try it online!](https://tio.run/##yy9OTMpM/f/fyNHx0M5svfhHDYsMD68@tOrQbq0jbTqHF2e6nFsMFDs3@///DAA "05AB1E – Try It Online")
  
### Breakdown:
```
2AA¹k._•1ëª»*Ć,ãiDΣ•Λ
2                       # <length>
 AA¹k._                 # <filler>
       •1ëª»*Ć,ãiDΣ•    # <pattern>
                    Λ   # Invoke the canvas function.
```
  
### Explanation:
The **canvas** (`Λ`) in this particular context works as a function with the following signature:
$$
\mathsf{\Lambda} : \left(\texttt{length}: \color{purple}{\texttt{Nat}},\ \texttt{filler}: \color{purple}{\texttt{String}},\ \texttt{pattern}: \color{purple}{\texttt{Nat}}\right) \rightarrow \color{purple}{\texttt{String}}
$$
The \$\texttt{pattern}\$ parameter is in this situation a number defining the directions. In the code, this number is represented as [`•1ëª»*Ć,ãiDΣ•`](https://tio.run/##yy9OTMpM/f//UcMiw8OrD606tFvrSJvO4cWZLucWA8X@/wcA), which is a compressed version of the big number \$2232344565666667670012122\$. Directions are denoted in the following manner:
  
$$
\begin{array}{l}
7 & & 0 & & 1 \\
 & \nwarrow & \uparrow & \nearrow & \\
6 & \leftarrow & \bullet & \rightarrow & 2 \\
 & \swarrow & \downarrow & \searrow & \\
5 & & 4 & & 3
\end{array}
$$
  
This means that the big number represents the following pattern of directions:
$$
[\rightarrow, \rightarrow, \searrow, \rightarrow, \searrow, \downarrow, \downarrow, \swarrow, \leftarrow, \swarrow, \leftarrow, \leftarrow, \leftarrow, \leftarrow, \leftarrow, \nwarrow, \leftarrow, \nwarrow, \uparrow, \uparrow, \nearrow, \rightarrow, \nearrow, \rightarrow, \rightarrow]
$$
With this signature context, the canvas iterates through the \$\texttt{pattern}\$ list and writes \$\texttt{length}\$ characters from the \$\texttt{filler}\$ in the current direction.
The \$\texttt{length}\$ is specified in the code as \$2\$ (at the beginning of the code). For the \$\texttt{filler}\$, we need a rotated version of the alphabet such that it starts with the given input. That is done with the following code ([try it here](https://tio.run/##yy9OTMpM/f/f0fHQzmy9@P//MwA)):
```
**AA¹k.\_**
 A¹k       # Find the ***<index>*** of the given input character in the alphabet
A   ._     # Rotate the alphabet to the left ***<index>*** times.
```
In pseudocode, this would be executed by the canvas function:
\$
\begin{array}{l}
1. & \text{Write } \color{blue}{\texttt{ab}} \text{ in the direction} \rightarrow \\
2. & \text{Write } \color{blue}{\texttt{bc}} \text{ in the direction} \rightarrow \\
3. & \text{Write } \color{blue}{\texttt{cd}} \text{ in the direction} \searrow \\
4. & \text{Write } \color{blue}{\texttt{de}} \text{ in the direction} \rightarrow \\
5. & \text{Write } \color{blue}{\texttt{ef}} \text{ in the direction} \searrow \\
6. & \text{Write } \color{blue}{\texttt{fg}} \text{ in the direction} \downarrow \\
\dots
\end{array}
\$
Lastly, you can see that the filler argument is 'rotated' \$\texttt{length} - 1\$ times to the right, meaning that the canvas would iterate through the following (cycled and therefore infinite) list:
$$
[\color{blue}{\texttt{ab}}, \color{blue}{\texttt{bc}}, \color{blue}{\texttt{cd}}, \color{blue}{\texttt{de}}, \color{blue}{\texttt{ef}}, \color{blue}{\texttt{fg}}, \color{blue}{\texttt{gh}}, \color{blue}{\texttt{hi}}, \color{blue}{\texttt{ij}}, \color{blue}{\texttt{jk}}, ... 
$$
Which results in the desired alphabet soup ascii-art shape.
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), 100 bytes
```
{"2XYZABC
 VW5DE
U9F
T9G
S9H
 RQ5JI
2PONMLK".trans(/\S/=>{(try ' 'x$/+1)||chr ($/.ord+.ord)%26+65})}
```
[Try it online!](https://tio.run/##K0gtyjH7n1upoJamYKvwv1rJKCIyytHJmUshLNzUxZUr1NKNK8TSnSvY0oNLISjQ1MuTyyjA38/Xx1tJr6QoMa9YQz8mWN/WrlqjpKhSQV1BvUJFX9tQs6YmOaNIQUNFXy@/KEUbRGiqGplpm5nWatb@t@YqTqxUSNNQd1TXhLOdkNhRQPZ/AA "Perl 6 – Try It Online")
Replaces all letters in the string with their shifted counterparts, while replacing digits with the number of spaces they represent plus one.
### Explanation
```
{                                                            }# Anonymous code block
 "...".trans(/\S/=>{                                       }) # Translate non-whitespace
                    (try ' 'x$/+1)      # If digits, the amount of spaces plus one
                                  ||chr ($/.ord+.ord)%26+64  # Else the shifted letter
```
[Answer]
# [Ruby](https://www.ruby-lang.org/), 107 bytes
```
->n{a=(0..6).map{' '*11}
(?A..?Z).map{|i|j,k=(1i**((i.ord-n.ord-6)/6.5)).rect;a[3.5*k+=1][5.2*j+6]=i}
a*$/}
```
[Try it online!](https://tio.run/##KypNqvyfZvtf1y6vOtFWw0BPz0xTLzexoFpdQV3L0LCWS8PeUU/PPgoiWJNZk6WTbathmKmlpaGRqZdflKKbBybNNPXN9Ew1NfWKUpNLrBOjjfVMtbK1bQ1jo031jLSytM1ibTNruRK1VPRr/xeUlhQrpEXbO8b@BwA "Ruby – Try It Online")
Improved syntax `"i".to_c` -> `1i` (Suggested by Jordan)
Changed coordinate system so 0 degrees is at right instead of top. This enables `0.5` -> `6`
Adjusted multipliers of `j` and `k` for shortness
Rather than print output `puts a`, concatenate array elements and return a string `a*$/`
# [Ruby](https://www.ruby-lang.org/), 119 bytes
```
->n{a=(0..6).map{' '*11}
(?A..?Z).map{|i|j,k=("i".to_c**((i.ord-n.ord+0.5)/6.5)).rect;a[3.5-j*3.3][6+k*5.17]=i}
puts a}
```
Uses a complex number raised to a power to map to an ellipse. A complete turn is 26, so each quadrant is 6.5.
This approach relies on the required output resembling an ellipse sufficiently that a valid mapping can be achieved.
[Try it online!](https://tio.run/##JcjBDoIgGADgu0/hvAgYfzIHHRo5XyPGGplu6FJHeGjKs1Oty3f43Hp/x15Gepk2I1EJIDA8zbLlaU4YCwmqG4D6@s/d7sNhlCizGfj51hKCkIXZPej0syiB46P4gsF1rT8bVQGnA6mg0koUI@HATlrakCyrf6UmxF7VjY4f "Ruby – Try It Online")
[Answer]
# [MATL](https://github.com/lmendo/MATL), 49 bytes
```
7I8*32tvB[1b]&Zvc2Y2j7+_YSy&f7-w4-_Z;YPE\,&S])yg(
```
What a mess. But it was fun writing. There's even an arctangent involved.
[**Try it online!**](https://tio.run/##y00syfn/39zTQsvYqKTMKdowKVYtqizZKNIoy1w7PjK4Ui3NXLfcRDc@yjoywDVGRy04VrMyXeP//wwA)
### Explanation
The code
```
7I8*32tvB
```
creates an array of numbers and converts them to binary. This gives the zero-one matrix
```
0 0 0 1 1 1
0 1 1 0 0 0
1 0 0 0 0 0
1 0 0 0 0 0
```
which is the top left quadrant of a matrix specfying the positions of the letters. 
```
[1b]&Zv
```
reflects that quadrant vertically without repeating the last row, and horizontally repeating the last column to produce the full matrix:
```
0 0 0 1 1 1 1 1 1 0 0 0
0 1 1 0 0 0 0 0 0 1 1 0
1 0 0 0 0 0 0 0 0 0 0 1
1 0 0 0 0 0 0 0 0 0 0 1
1 0 0 0 0 0 0 0 0 0 0 1
0 1 1 0 0 0 0 0 0 1 1 0
0 0 0 1 1 1 1 1 1 0 0 0
```
We now have a mask with the positions. The code
```
c
```
converts this to char, because the final result will be a char matrix. Character 0 is displayed as space, and the nonzero entries will be written with the appropriate letters.
```
2Y2
```
pushes the string `'abc···xyz'`, which contains the 26 letters. This string needs to be circularly shifted as per the input. To do that,
```
j7+_YS
```
reads the input letter, adds 7 to its ASCII code, and negates the result. For input `'a'` this gives −104, which is a multiple of 26, so circularly shifting by this amount will do nothing. If the input is `b` this gives −105, which shifts the string 1 step to the left to produce `'bcd···yza'`; etc.
The next step is to define the order in which the shifted string will be written into the nonzero entries of the matrix. To this end,
```
y&f
```
creates a copy of the matrix and pushes two vectors containing the 1-based row and column positions of the nonzeros. Then
```
7-w4-_
```
subtracts 7 from the latter, brings the former to top, substracts 4 from it, and negates it. The 7 and 4 specify an origin of coordinates, so that the angles of the position vectors of the nonzero entries with respect to that origin define the desired order.
```
Z;YPE\
```
computes the two-argument arctangent modulo 2\*pi to produce those angles. Now the smallest angle, which is 0, corresponds to the entry where the first letter should go, and the rest advance counter-clockwise.
```
,&S])
```
rearranges the letters in the string according to those angles, so that when the letters are written into the nonzero entries of the matrix in column-major order (down, then across) the result will be correct. This is done by
```
yg(
```
For example, if the input is `'a'` the string was not circularly shifted:
```
abcdefghijklmnopqrstuvwxyz
```
The rearranging as per the angles transforms this into
```
utsvrwqxpyoznamblckdjeifgh
```
so that `'u'` will correctly go to the first (in column-major order) nonzero entry, which is (3,1) in matrix notation; `'t'` will go to (4,1), `'s'` to (5,1); `'v'` to (2,2) etc:
```
   ······   
 v·      ·· 
u          ·
t          ·
s          ·
 ··      ·· 
   ······   
```
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 33 bytes
```
ＧＨ→→↘→↘↓↓77←←←←↖←↖↑↑↗→↗→→²✂⁺αα⌕αＳ
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z8gP6cyPT/PIz8nJ79cwyooMz2jREcBTrvkl@fhEwOxEZQ5FPukppXgokILcPBDCxAEupWYIlDaSEchOCczOVUjIKe0WCNRRyFRU0fBLTMvBcT2zCsoLQkuKcrMS9fQBALr//89/uuW5QAA "Charcoal – Try It Online") Link is to verbose version of code. Explanation:
```
ＧＨ
```
Trace a path.
```
→→↘→↘↓↓77←←←←↖←↖↑↑↗→↗→→
```
Outline the bowl. Each `7` expands to `↙←`.
```
²
```
Move one character at a time (this API overlaps each line's ends with the next).
```
✂⁺αα⌕αＳ
```
Draw using the doubled alphabet, but starting at the position of the input character.
[Answer]
# [Python 2](https://docs.python.org/2/), 129 bytes
```
lambda x:''.join((i,chr((ord(x)+ord(i))%26+65),' '*5)[ord(i)/46]for i in'''   XYZABC
 VW] DE
U]]F
T]]G
S]]H
 RQ] JI
   PONMLK''')
```
[Try it online!](https://tio.run/##JYvJCsIwFADv@Yp3kZfYolBsD4KHuu/7ru9QLaURTUqoUL8@VjwNDDPZJ0@18mzSutpn9LrFERRNxNpDS8W5dO@p4VybmBfC@UEKUfECJ/CFi4BVX1z@tt4IKNEGJEiFiABwPJ3DdofB/kDQ7bEdUZ9tiQZsQzRksF4RjEesDJeL@Ww6KSdhMyNVDgmXKnvnXAiLIX4B "Python 2 – Try It Online")
[Answer]
# [R](https://www.r-project.org/), 139 122 bytes
-17 bytes thanks to Giuseppe
```
u=utf8ToInt;`*`=rep;o=c(' '*12,'
')*7;o[u("  &3@LKWVUTSRDC5(")]=LETTERS[(13:38+u(scan(,'')))%%26+1];cat(o,sep='')
```
Explanation:
```
o=rep(c(rep(' ',12),'
'),7) 
```
Builds an empty box of spaces
```
u(" &3@LKWVUTSRDC5(")
```
is a set of indices for letter positions corresponding to:
```
c(7:9,23,24,38,51,64,76,75,87:82,68,67,53,40,27,15,16,4:6)
```
[TIO](https://tio.run/##K/r/v9S2tCTNIiTfM6/EOkErwbYotcA63zZZQ11BXcvQSEedS11Ty9w6P7pUQ4mdg1NcQs3Ywcc7PCw0JDjIxdlUQ5pfgIWVTUkz1tbHNSTENSg4WsPQ2MrYQrtUozg5MU9DR11dU1NTVdXITNsw1jo5sUQjX6c4tcAWKPzf8T8A)
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), ~~121~~ 119 bytes
*Saved 2 bytes thanks to @tsh*
```
c=>`2XYZABC
0VW5DE
U9F
T9G
S9H
0RQ5JI
2PONMLK`.replace(/./g,x=>''.padEnd(+x+1)||(B=Buffer)([65+([a,b]=B(c+x),a+b)%26]))
```
[Try it online!](https://tio.run/##bchLC4IwAADg@/5HuDFTExQ8LHBl7/c7RXDNLQpR0QoP/ffVOfqO3529WM2rW/lo50UqlCSKk25in86hT3vAOhydfgD23gDsvCHYeiNgbdbOZAzs1XIxn00ToxJlxriApmFe9YZ0Nc0oWRrkKcQN7qD3G1JCn1KKCsHIdTCMmH6JCYUcN0hn@IJathsjpHiR10UmjKy4Qgk1X0MI/Bz9c6M/F35PfQA "JavaScript (Node.js) – Try It Online")
## How?
This code abuses `Buffer` to extract the ASCII codes of the template letter \$x\$ and input letter \$c\$ and convert them back into the target letter.
### Example with \$c=\$`"H"` and \$x=\$`"B"`
```
// extracting the ASCII codes
Buffer(c + x) → Buffer("HB") → <Buffer 48 42>
// assigning them to variables
[a, b] = Buffer(c + x) → a = 0x48 (72) and b = 0x42 (66)
// computing the ASCII code of the target letter
65 + ((a + b) % 26) → 65 + (138 % 26) → 65 + 8 → 73
// turning it back into a character
Buffer([73]) → <Buffer 49> → implicitly coerced to "I" by replace()
```
[Answer]
# APL+WIN, 72 bytes
Prompts for character
```
m←7 12⍴' '⋄n←(7⍴2)⊤v,⌽v←(⍳3)/28 34 65⋄((,n)/,m)←(22+s⍳⎕)⌽s←⎕av[65+⍳26]⋄m
```
[Try it online!Coutesy of Dyalog Classic](https://tio.run/##SyzI0U2pTMzJT9dNzkksLs5M/v@ob6qvz6O2CcZcjzra0/7nApnmCoZGj3q3qCuoP@puyQMKaJgDuUaaj7qWlOk86tlbBhJ61LvZWFPfyELB2ETBzBSoUENDJ09TXydXEyRrZKRdDFQBNFwTqKEYKARkJpZFm5lqA4WNzGKBGnL/A238n8alHqUOAA "APL (Dyalog Classic) – Try It Online")
[Answer]
# [R](https://www.r-project.org/), 218 197 bytes
-21 bytes thanks to Giuseppe
```
function(t,l=letters,`*`=rep,s=" ",n="
",`~`=`[`,r=c(l~l>=t,l))cat(s*3,r~24:26,r~1:3,n,s,r~22:23,q<-s*6,r~4:5,n,r~21,u<-s*10,r~6,n,r~20,u,r~7,n,r~19,u,r~8,n,s,r~17:18,q,r~10:9,n,s*3,r~16:11,sep='')
```
[Try it online!](https://tio.run/##dY89DoMwDEZ3ToFYAshIGCg/EelF2iEIUVEpCpCEpQNXpwmt1C5M9vee7Dhq78Q8dnpaZ79N/P2xyt48JxkaEEwMxgxKA485U8MMmgV@AJIFXgB844zfOCjWh2ITV2YHoqjvTKjjHNSWFTQrbUWagwTtSEazHJY20bETBb1YYTHC6himNpQflMJqS3UEbI5Qf7dgRbGGxXUpbRw8nsOSIoIeZkZI9PtTSDoSee4qcpe2@xP9mRjPhDgT5ky87C1v "R – Try It Online")
Ungolfed:
```
alphasoup <- function(startlet){
  startnum <- which(l == startlet)
  rotatedletters <- c(letters[startnum:26], letters[1:(startnum -1)])[1:26]
  cat('   ',rotatedletters[24:26],rotatedletters[1:3], '\n ', 
      rotatedletters[22:23], s6 <- '      ', rotatedletters[4:5], '\n',
      rotatedletters[21], s10 <- rep(' ', 10), rotatedletters[6], '\n',
      rotatedletters[20], s10, rotatedletters[7], '\n',
      rotatedletters[19], s10, rotatedletters[8], '\n ',
      rotatedletters[17:18], s6, rotatedletters[10:9], '\n   ',
      rotatedletters[16:11],
      sep = '')
}
```
Created rotated letter vector and uses `cat` to fill out rim of bowl with that vector.
[Answer]
# Java 11, 134 bytes
```
c->"2XYZABC_0VW5DE_U9F_T9G_S9H_0RQ5JI_2PONMLK".chars().forEach(i->System.out.print(i<59?" ".repeat(i-47):(char)(i>90?10:(c+i)%26+65)))
```
[Try it online.](https://tio.run/##XY9rS8MwFIa/71ccCtKE0VCLndRpx9TpvKxe6l0kxCxz2bq2JNlAZL@9prWf/HLgPefw8jwLtmHeYrqseMa0hgmT@U8HQOZGqBnjApI6AmwKOQWO@Jwp4Lhvd9uOHdowIzkkkMMRVNyLneDl9W14fEL9p@fwdEQfozP6EJ3TNBpT//4uvLygwe1NMrm@ckhdphEms0KNGJ8j6cXptzZiRYq1IaWyEEgehtHAAYcoUQpms7e3jw8aDoxkHPmDXd/GrsQ7Qa/bCzHGVb8mK9efmSVrARv8lZVDqbG9X@8fwPCfWU44csdu4wTwHyDLUXtp/oZu676tfgE)
**136 bytes version** with potential to be golfed?
```
c->"2XYZABC_0VW5DE_U9F_T9G_S9H_0RQ5JI_2PONMLK".chars().forEach(i->System.out.printf("%"+(i<59?i-47:"")+"c",i>90?10:i<59?32:(c+i)%26+65))
```
[Try it online.](https://tio.run/##XY/bToNAEIbv@xSTTRp2gxBEqYEqTdXWeige8GzMZt2C3UqXBrZNjOmz44JceTPJzD/5830LtmHWYvZV8YyVJUyZkD8dACFVUqSMJxDVK8AmFzPgmM9ZAZz09W3b0aNUTAkOEUg4gopbIXKfX16HxyfUeXzyTkf0wR/Te/@Mxv6EOne33sU5dW@uo@nVJbLrshITO82LEeNzLKww/i5VsrTztbJXhYZIMeoiE4tDzx8Ia/8gQIiYiKMdEfrOYNcJmmTPDTA3Bem6PbPnEVL1a7bV@iPTbC1iI7DUejhWuvnz7R0Y@XOTNsfGxGisAP4jZBK3SfM3NFr7bfUL)
**Explanation (of the first answer)**
```
c->                          // Method with character parameter and no return-type
  "2XYZABC_0VW5DE_U9F_T9G_S9H_0RQ5JI_2PONMLK"
                             //  Template-String
    .chars().forEach(i->     //  Loop over the unicode values of its characters:
    System.out.print(        //   Print:
     i<59?                   //    If the value is below 59 (so a digit character):
      " ".repeat(i-47)       //     Repeat a space that digit + 1 amount of times
     :(char)(i>90?           //    Else-if the value is above 90 (an underscore character):
              10             //     Print a newline
             :               //    Else:
              (c+i)          //     Add the current value and the input together
                   %26       //     Take modulo-26 of it to get the index in the alphabet
                      +65))) //     And add 65 to make it an uppercase letter
```
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 258 bytes
```
(t[x_]:=Table[" ",x];w=RotateRight[Alphabet[],4-LetterNumber@#];j=Join;a[x_,y_]:=j[{w[[x]]},t@10,{w[[y]]}];b[m_,n_]:=j[t@1,w[[m;;m+1]],t@6,w[[n;;n+1]],t@1];""<>#&/@{j[t@3,w[[1;;6]]],b[25,7],a[24,9],a[23,10],a[22,11],Reverse@b[12,20],j[t@3,w[[19;;14;;-1]]]})&
```
[Try it online!](https://tio.run/##RY3RSsNAEEV/JWyhKE5pN42VdhqJryIioW/DUHZlSVK6qcTRppR@@7qpgk9zD@dyxxupnTfSvJtQ5eFGqN/yKt8Yu3ekEgU94zEvD2LElU1VCz3tP2pjnRBDNnlxIq57/fLWdcWIcZc/H5oWTVyB0zC0o/ORqGe@gBR6BgOdIjFa8ltofztRQRQe0d9p5lhdDNwitn@sGZVaP47G0@I89OeD14gLjtpSeg8PDIbSDJbXOwc9u4YUtGYo3bfrPl1hSaeQRvO/sUTUGeIk/uHL7Ti8dU0rybRIKlJGcQg/ "Wolfram Language (Mathematica) – Try It Online")
[Answer]
## Haskell, 127 bytes
```
("cXYZABC aVWfDE UjF TjG SjH aRQfJI cPONMLK">>=).(?)
t?c|c>'Z'=' '<$['a'..c]|c<'!'="\n"|t<'B'=[c]|c>'Y'=t?'@'|1<2=pred t?succ c
```
[Try it online!](https://tio.run/##bci5bsJAFAXQnq@4WEgXilhKao8NZCHsCUsSDClGDybBGGPhofO3M4gaTnn@dbHbpKkzauXqnvws4lb7Gfrr27y8Yp68YZZ0ME3eoSefpteFfIxHw0HfC0PV8OtRo2IjKSVkTEUwqC2p6fvyW0rAKpW3yrzSBmxTLa8ZckFlIzZZPgZPKj9u1rBRcRKBuL3eZlBYHyoA8pOd2uMgQw0GbPH2OncupjuLSfVf4R4kzy8 "Haskell – Try It Online")
Each character in the encoded string is decoded by function `?` into a string:
```
t?c                             -- 't' is the starting char,
                                -- 'c' the char from the encoded string
   |c>'Z'=' '<$['a'..c]         -- if 'c' is a lowercase letter, return some spaces
                                -- 'a': one, 'b': two, etc
   |c<'!'="\n"                  -- if 'c' is a space, return a newline
   |t<'B'=[c]                   -- if 't' is the letter A, return 'c'
   |c>'Y'=t?'@'                 -- wrap around Z
   |1<2=pred t?succ c           -- else the result is the same as starting one letter
                                -- earlier (pred t) but looking at the successor of 'c'
```
[Answer]
# [Kotlin](https://kotlinlang.org), ~~148~~ ~~146~~ 145 bytes
Removed extra parentheses for -2  
Replaced raw string for -1
```
{l:Char->"2XYZABC 0VW5DE U9F T9G S9H 0RQ5JI 2PONMLK".map{c->if(c>'@')((c-'A'+(l-'A'))%26+65).toChar()
else if(c>' ')" ".repeat(c-'/')
else '\n'}}
```
[Try it online!](https://tio.run/##lVdZc9s2EH7Xr9hq2kqaWPIR2409jafybedwfMWJmz5AJCSiJgkGAC0rHv/2dBcASUhOHqrJxAK557e730J30qQi/768DHuKM8NjGEsFJhEaIhlzmMh0DFHC0pTnE77dQsHEmEJvLy/Te3o90IZFd/wBpVBkEMls@evy6qvVV@svSfwdu@PAYFdOU5BjGKZFwkbcwKUsixYJXJEz/DdNmIEp76QpROgPdUZeh1U6GnWgj2@ULCdJOoNIqKhMmQKmIyH6TKFMwgoOU2ESTIPD2iaURcFVxDSHg3ySCp1Ayo3hSkN32L/tAVOKIo8hSmV0NxUoaCThkFkLqCwyjvLbNlz8fPp8O9zds4ePN2A/@wd0vIb6c2hTa85HdL5szsdW/eLcnU5PvOkPZ@/fvX1jHd0oYQi5QsmJYhQL4mMQTUQrx@daYDbc50I1UizCb0uASS0By2OQpSlKo52mZhn/CaJtJQ3Vvr2EZ8pdF5zduQMCIHK0UvlhCCZTVC2uuH09hFi6mOjEH1hWYFhsJO@5jYKeKq4N@aXvte9oFqWoOC5TrCTDkuZBCQYWg0sXgUvEtqYLZghTWaYxjHiQnFRiInKW/jhLZ3DoA3pmcTe0iN0oc17X25Z73x5uPrmCHdj6flyo7/VCfYP6uwJfXrjTm1Nv@twW3Dp6K@64a775@I7ryOqADg6Pjk@cib19b/EtHXcbh@9sus35PZ1vm/OZVf/s8zn/4E3ffLy@urywjs6U9X9bu72xjW8P1z51B0uQ58FCn1ucLhZwQncelWNv2rb9acMHOeexplacSnVnwyBKwGH2o4tdjjhZGoDbAantc8NEqutg4bMskUhwUrQuM49qjp3m6j0VaG/EF@fouV0bJnKgzO95LnhuYIaGMzaDEmuVyqnnFtb/FrQTNv4yHlwZl6wKxcLRBmTiwQ5GxkyUOAv2XPNU7fcqHBepYhTMSu0np5mVJcglPsQBwgz6wQgFSFg9ilgXLOLaqWiJxJZg/sBTMoN4izymHCmeMUFEsFmSoKEKA8PpJxBGhByLyQYtDoU1oO85n@JfnG586DxWBOE7m2nMHAWZnndBm6AmZKQ@hCSd1X7fS@MnnpSsvON71Fpda0gQ@Ung9hrN4A@kTEpDYrS4iITxDPajFQKGP5gBwaWsbdeGpDty/WNpxjoczK2uZlV6ytSJVIY4z76Zilz/YhUOHgpElrZsmUdGyJxoKmXZKGZuZeH2zBB/PWihBOWPyOmu681t2MP8evC61SIsaM6MssCPGzisFSQvAj6Tqqp3paF4keI5dnIMYqRMV22sGFDJapFKxUtaOwPbkk5phYDZovTJue2@SgUDQiQVq0qPgiyOCZwNmAme4mhvYj9U4gbXT@pMBxX0WWmX44TX1jOqYIz6Rvrl8rUUCp/I8VhzLOBe4tpnrGRWJ86mlSma0v4qdFOJ47AOtpUpvJfUIihQqdjgMfMamRHHYe0N7Pv2mrsFwMrHm439A7jeOoSrrSO43DqGlYvzjdMTWHPLvO0U6IORw2OTI/R3WvU7dHjiMm7e0ywE1xdPUaEKi/@lwRaY9RF3U/GNK2xYlK8AwT@hykj6q1FUKkWz3vhzlwYVSmue8ojuhYapCQ@EBzCM7S7NQnEjUSjxpjIZl2lpy28nv4pm0QfeDsp0zvRlIsamujnQuxFeMef92LfVRc7RqZ/vxlCoIXMsJk3EoB5bZ992Ow1dKB3EcsEzvMogGTFCK@Gaa39bmTOPnPEcUJ8y3meJY2jgQx3biGtEPDleNvHiUiiOg8cp0ljENeXMJU503XSUGEO3cbcDnb86vVazbbvNy35n2HnhmYS@93q/BYL0Wdt8sbnRGxhJNNPtzbXmGRXV7Rrxwy61nDDXmhPfj0RGC@1on1uNUKHbWelYIoffobPlvq70bG0nPOeKee4PdTKWzxYWTFBRP/ENXLTmnmMGc5i1oT1AG/hrKARvufNTQKYcEnbPK44kmvO9ODepNY/MhxN47nzJO/DUcr@aMJt6SWC3IwfUv0jq32NuS2Qo28Xp1NswxM05@9OthZ0ePFLIdLV0GwbNBEAGxOl2O8A99eBrp/P36vqrf@j/zX9gdX0DdykutO@P6TZ1R3/n//Af0t5j1N8R4260Qw2KXem70TfiYuf5MpE41iYsiCuEfU9oPT19t8Ee4iRxhrepQmotRsF1zq9QcFvOpRYLjS0yC/hFU/Y0jn5AqJcwtMGgc9shGKk6BYJq0rzbJme/@pXcdp1jVYOJwNXtLfWq1rLqjUxv3uaX3Fp68rTQenLNjT/N/wM "Kotlin – Try It Online")
[Answer]
# [C# (Visual C# Interactive Compiler)](http://www.mono-project.com/docs/about-mono/releases/5.0.0/#csc), ~~126~~ 118 bytes
```
n=>$@"   XYZABC
 VW{"",6}DE
U {"",9}F
T {"",9}G
S {"",9}H
 RQ{"",6}JI
   PONMLK".Select(b=>b<65?b:(char)((b+n)%26+65))
```
Saved 8 bytes thanks to @someone. Yes, that's actually his username.
[Try it online!](https://tio.run/##LY3JCsIwAETv@YpQlCa0ehAsaJu4L3XXqlVvTUg1oBHSepJ@e1xP85iF4VmFZ9IMH4oH/JJoNxyox03ohF3F16A0JUYRWmpbEMLD8dTp9gDcx0/Lcr2iPwA7@MFGMQTbP41A9KcxgJv1rzkJwXu/Wi7ms6lVjcRV8BwxQlng1VusiT5fGCHmKFyueY5Xx9j4IL3rbwIlsTu2LwNin97iODjWMhczqQTKci3Vudq7K57kKEUSY@wD8wI "C# (Visual C# Interactive Compiler) – Try It Online")
[Answer]
# TSQL query, 238 bytes
```
DECLARE @y char='G'
,@ char(91)=3;WITH C as(SELECT'5585877636333330301125255'z,8a,ascii(@y)x
UNION ALL
SELECT stuff(z,1,1,''),a+left(z,1)/3*13+left(z,1)%3-14,(x+14)%26+65FROM
C WHERE''<z)SELECT
@=stuff(stuff(@,a,1,char(x)),1+a/13*13,1,char(13))FROM
C PRINT @
```
The test link for this answer broke the line breaks and excluded the spaces. I have replaced the spaces with period and replaced char(13) with char(13)+char(10) in order to show a readable result.
**[Try it online](https://data.stackexchange.com/stackoverflow/query/1015541/make-a-bowl-of-alphabet-soup)**
Ungolfed:
```
DECLARE @y char='G'
-- @ is the string being printed last. 
-- @ is populated with 3 to save a byte
-- the number 3 gets replaced later
-- (this could have been any 1 digit value), 
-- @ is automatically filled with spaces, because
-- it is declared as a char(x) and assigned a value
,@ char(91)=3;
-- recursive query
WITH C as
(
-- z string containing digits for the direction of next letter
-- z should not contain 4 because it will point to same position.
-- values in z 0,1,2,3,4,5,6,7,8 can logally convert to 
-- (-1,-1),(-1,0),(-1,1),(0,-1),(0,0),(0,1),(1,-1),(1,0),(1,1)
-- a is the starting position
  SELECT'5585877636333330301125255'z,8a,ascii(@y)x
  UNION ALL
-- stuff remove first character from the z string
-- a calculate next position of the next letter
-- x cycle the input letter
  SELECT stuff(z,1,1,''),a+left(z,1)/3*13+left(z,1)%3-14,(x+14)%26+65
-- repeat recursive until long string is empty
  FROM C
  WHERE''<z
)
SELECT
-- 1st stuff replace the character to created the start of a 
--   logical line in the string @ this is where 3 gets overwritten
-- 2nd stuff replaces a character(space if coded correct) 
--  with the letter at the calculated position.
  @=stuff(stuff(@,a,1,char(x)),1+a/13*13,1,char(13))
FROM C
PRINT @
```
[Answer]
# C(GCC) ~~286~~ 270 bytes
-12 bytes ceilingcat
Not exactly the shortest golf, but it works
```
#define r(a)(a+c)%26+65
#define R(a)for(i=10;i;a[--i]>32?a[i]=r(a[i]):0);
i;f(c){char T[]="   XYZABC\n",E[]="VW      DE\n",F[]="RQ      JI\n",B[]="   PONMLK";R(T)R(E)R(F)R(B)printf("%s %s%c%*c\n%c%*c\n%c%*c\n %s%s",T,E,r(85),11,r(70),r(84),11,r(71),r(83),11,r(72),F,B);}
```
[Try it online!](https://tio.run/##VY9bS8QwEIXf@yuGSNiMm0LbvSiGKlZbUNfLluKt24cQN5oHo7T7tuxvr8lqHxw4nDkfnIFR4btSfX/wttbGrqFlEpkcK6TJfDyfBQMvHddfLTNpHAkjZB2GpjmdJGeyNk3qWs7wJEIRGKGZwq36kC1UdZMSAHh@eT3PLlaW8NyTxyfYz2XuUeFRufxF11ceZX@9h/u728UNESWrsGS5U@GU4Xdr7EYzQjugHVX0UK3sf/O8I7ziOW/Z8Qx5HLvlKEIfp0OM93EyxAR5wTMUu96dh09pLEPYBgCajZYj99uu/wE "C (gcc) – Try It Online")
[Answer]
# [PHP](https://php.net/), ~~236~~ ~~229~~ 226 bytes
```
<?=($a=ord(file_get_contents('php://stdin'))-65)?preg_replace_callback('~\w~',function($m)use($a){return chr((ord($m[0])-65+$a)%26+65);},'   XYZABC
 VW      DE
U          F
T          G
S          H
 RQ      JI
   PONMLK'):'';
```
[Try it online!](https://tio.run/##RY3JCsIwAETv@YocKklQqQh6qIq47/u@UWqMtljTkKZ4EP312iroHIYZBt4IW4RhsVzCmlXy5AmfHZeZF6ZM6nHFuPIxErYwdN1XJ4cjQtL5HCkLyS6mZMK1KDOp5bpHi14xeu3vL5Q6B5wqx@NYu5HAZxGZPCRTgeSQ2hLj@Ea77TKHmJWM1kQ2n4yohWcKQQjXm22lWgNwuYIf1RtgAX9qgvm/tMDsX9oATiff2O2AyMej4aDfQ8RAqBCGzTc "PHP – Try It Online")
Pre-golf:
```
<?php
$adjust = ord(file_get_contents('php://stdin')) - 65;
echo preg_replace_callback('~\w~', function($match) use ($adjust) {
    $new = ord($match[0]) - 65;
    $new = ($new + $adjust) % 26;
    $new += 65;
    return chr($new);
}, '   XYZABC
 VW      DE
U          F
T          G
S          H
 RQ      JI
   PONMLK');
```
Explanation:
Using `ord` we convert to an integer between 0 and 255. A is 65 and Z is 90.  
Using this knowledge, we take the input and reduce it by 65 so we have an adjustment value.  
We then iterate over all characters, call `ord` on them, reduce them by 65, increase them by our adjustment value. Using modulo we loop back down to 0 if they exceed 26.  
We then increase them by 65 again and convert them back into letters with `chr`.
Sadly php://stdin can only be interogated once, so we need to pass the input into the function in our loop, preventing us from saving bytes on `use($a)` and having to declare a variable outside the function stops us from cleanly using the `<?=` echo method - we have to wrap everything in a giant ternary.
[Answer]
# Javascript (V8), 316 bytes
```
function a(b){n="abcdefghijklmnopqrstuvwxyz".split(b);n=b+n[1]+n[0],console.log(`   ${n[23]+n[24]+n[25]+n[0]+n[1]+n[2]}\n ${n[21]+n[22]}      ${n[3]+n[4]}\n${n[20]}          ${n[5]}\n${n[19]}          ${n[6]}\n${n[18]}          ${n[7]}\n ${n[17]+n[16]}      ${n[9]+n[8]}\n   ${n[15]+n[14]+n[13]+n[12]+n[11]+n[10]}`)}
```
[Try it online](https://tio.run/##bY/RCoIwFIbve4ohgUolzqyU6ElKcJqZtc5MzUrx2W0eMULaxYF93z/OvwsrWR5mSVosSqc9PSAsEgGEaYFet7BTWBAeo1N8Ti5XfgOR3rO8eJTP17tSjDzlSSGDW9gFM9hTTw7Tm4cCcsEjg4tY8wkh0xr21rKTlo1z1QeHJ5bXHKBP9XcJCJ6O4UO7i2DCHNzgV4Oi7litv8oZq813J91gkfXvTrdDDkZ6QLEyxfoUG1ELJxamspSvT9pm8vt1pqlc1fUxO/5hlWTtBw)
First time trying code golf out. Appreciate any tips / feedback.
Original code before minifying:
```
function a(b){
    var c = ("abcdefghijklmnopqrstuvwxyz").split(b);
    c = b+c[1]+c[0]
    console.log(`   ${c[23]+c[24]+c[25]+c[0]+c[1]+c[2]}\n ${c[21]+c[22]}      ${c[3]+c[4]}\n${c[20]}          ${c[5]}\n${c[19]}          ${c[6]}\n${c[18]}          ${c[7]}\n ${c[17]+c[16]}      ${c[9]+c[8]}\n   ${c[15]+c[14]+c[13]+c[12]+c[11]+c[10]}`)
}
```
[Answer]
# [Red](http://www.red-lang.org), 139 bytes
```
func[a][foreach c{   XYZABC
 VW      DE
U          F
T          G
S          H
 RQ      JI
   PONMLK}[if c > sp[c: c + a % 26 + 65]prin c]]
```
[Try it online!](https://tio.run/##K0pN@R@UmhIdy5Vm9T@tNC85OjE2Oi2/KDUxOUMhuVpBQSEiMsrRyZlLISxcAQxcXLlCFeDAjSsEwXHnCkZwPLgUggIhTC9PLiAZ4O/n6@NdG52ZppCsYKdQXBCdbAVkaSskKqgqGJkBGWamsQVFmXkKybGx/9MUlJWclLhA/BKFnDQuEN8DjR@l9B8A "Red – Try It Online")
A really naive solution.
[Answer]
# [Perl 5](https://www.perl.org/) `-p`, 110 bytes
```
$b=/A/?Z:chr(-1+ord);$_=eval("'2XYZABC
 VW5DE
U9F
T9G
S9H
 RQ5JI
2PONMLK'=~y/A-Z/$_-ZA-$b/r");s/\d/$".$"x$&/eg
```
[Try it online!](https://tio.run/##K0gtyjH9/18lyVbfUd8@yio5o0hD11A7vyhF01ol3ja1LDFHQ0ndKCIyytHJmUshLNzUxZUr1NKNK8TSnSvY0oNLISjQ1MuTyyjA38/Xx1vdtq5S31E3Sl8lXjfKUVclSb9ISdO6WD8mRV9FSU9FqUJFTT81/f9/x3/5BSWZ@XnF/3ULAA "Perl 5 – Try It Online")
[Answer]
# [APL (Dyalog Classic)](https://www.dyalog.com/), 50 bytes
```
⎕a@((-⎕a⍳⍞)⌽∪⌊.5+{3 5.5×1-2 1○○⍵÷¯19}¨⍳38)⊢7 12⍴''
```
[Try it online!](https://tio.run/##VY9LT8JAFIX3/RWzuxAtsRDiYyUoUN7v566B1BAbawobQ9gZRGCILgwrXbAyblwoISFxA//k/hG8Uxoapk3mfu2cc@Zo94bcetAM80ZuGlqn025ucfrWNnHwciLh8EkXqF16PLLYkf8g//Di5A@HXzgZ@YJHvQAL@oKbmSL7mYKzsXj5YrNcfyvn/fUnKQJnXhzNT5niR/4LsCXXLfKpQi7Q1ymoB8dAtkAJFg0LwOGI/i6JmxbowJC/s66ltfQ71jUZbVJXyOgoPs8tGnXkqwvQtbZB@hV9t3D8COYt9CUIAx1@BcZYvREKX13TAPRUa8xekajACtuvGGHZRZWw5GJcaIuFHSQTthVj@Vw2k04JZwnUfV4kGlPjCSfPDhaalMCw65gmDLmYIWy4mBXaunPXfM7Jq1bKJfsSlNfY51VroqGTV3YqUe5hgwhh0cUoYeGwvcjZlVWdPNEuaTf5Bw "APL (Dyalog Classic) – Try It Online")
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~200~~ ~~198~~ 197 bytes
-3 bytes thanks to ceilingcat.
```
x,z;f(c){char*y,t[27],i=0;for(c-=46;i<14;t[13+i++]=(c-i)%26+65)t[i]=(c+i)%26+65;for(i=-4;++i<4;printf("%*.*s%*.*s\n",3273>>x*3&7,x?:1,y,z,x?:1,y+2*!i+z))z="--*%"[x=abs(i)]-34,y=t+x+(x>2)+13*(i>0);}
```
[Try it online!](https://tio.run/##bc1RS8MwFAXgZ/crZqAuNzeRtaktmKWiT/sN1j7UQLf7YB1thLRjv73Woi@yl8Phg8Nx6uDcNAU5moY7OLtj3YlB@jLJK0l2a5rPjjtl08zQLk6NL2ONhFjZWQmiJMPsAXxJP4B/sKzIqtQg0i41p45a33AWiXvRL/HWMqmTXBdFEPoul@HpMZaDHH8LJuKWcAQYLVNKRKwMtn7vOUGldCoH6zEgD0UCGGvBqdiCuUzzyfqjppbD6ry6afjmeQNmffryPWfzIZgFX67h/hq@/sfL9A0 "C (gcc) – Try It Online")
[Answer]
# [PHP](https://php.net/), 131 bytes
```
for(;$s='2YZABCD
 WX5EF
V9G
U9H
T9I
 SR5KJ
2QPONML'[$i++];)echo$s<A?$s<'0'?$s:str_pad('',$s+1,' '):chr(65+(ord($s)+ord($argn))%26);
```
[Try it online!](https://tio.run/##HcXbCoIwGADg@z2FF4t/YwYlKHgIsYMdLDufiRCt9MaNzedvSTffJ0qhg1C0vrkkPlYDsK63aDgaI@N8sScxOrlTdHRn6ODOkbHf2ckCWdvNOl0t4Y4rxh4@feUlxyqIwhboQZunGvkUWUEATKxY3wQDqJeXkjg2I1wWBCvK/mfyU1PasRzqa51@uWgqXivdjX8 "PHP – Try It Online")
]