Make a Bowl of Alphabet Soup 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 &quot;rotated&quot;, 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!
05AB1E, 21 bytes

Defines a program \$f : \color{purple}{\texttt{AlphabeticChar}} \rightarrow \color{purple}{\texttt{String}}\$

Code:

2AA¹k._•1ëª»*Ć,ãiDΣ•Λ


Try it online!



Breakdown:

2AA¹k._•1ëª»*Ć,ãiDΣ•Λ

2                       # &lt;length&gt;
 AA¹k._                 # &lt;filler&gt;
       •1ëª»*Ć,ãiDΣ•    # &lt;pattern&gt;
                    Λ   # 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Σ•, which is a compressed version of the big number \$2232344565666667670012122\$. Directions are denoted in the following manner:



$$
\begin{array}{l}
7 &amp; &amp; 0 &amp; &amp; 1 \\
  &amp; \nwarrow &amp; \uparrow &amp; \nearrow &amp; \\
6 &amp; \leftarrow &amp; \bullet &amp; \rightarrow &amp; 2 \\
  &amp; \swarrow &amp; \downarrow &amp; \searrow &amp; \\
5 &amp; &amp; 4 &amp; &amp; 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):


AA¹k._

 A¹k       # Find the &lt;index&gt; of the given input character in the alphabet
A   ._     # Rotate the alphabet to the left &lt;index&gt; times.


In pseudocode, this would be executed by the canvas function:

\$
\begin{array}{l}
1. &amp; \text{Write } \color{blue}{\texttt{ab}} \text{ in the direction} \rightarrow \\
2. &amp; \text{Write } \color{blue}{\texttt{bc}} \text{ in the direction} \rightarrow \\
3. &amp; \text{Write } \color{blue}{\texttt{cd}} \text{ in the direction} \searrow \\
4. &amp; \text{Write } \color{blue}{\texttt{de}} \text{ in the direction} \rightarrow \\
5. &amp; \text{Write } \color{blue}{\texttt{ef}} \text{ in the direction} \searrow \\
6. &amp; \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.