Draw a Random ASCII Art Quilt For this challenge, an ASCII art quilt will be a block of text 24 characters wide and 18 lines tall, containing the characters =-&lt;&gt;/\ in a quilt-like pattern that is horizontally and vertically symmetrical.
Example quilt:
========================
------------------------
//\\//\\\//\/\\///\\//\\
&lt;&lt;&gt;&lt;&lt;&gt;&gt;&gt;&gt;&gt;&lt;&lt;&gt;&gt;&lt;&lt;&lt;&lt;&lt;&gt;&gt;&lt;&gt;&gt;
/\\/\\\\/\/\/\/\////\//\
------------------------
/\/////\\///\\\//\\\\\/\
\///\/\/\\\\////\/\/\\\/
\///\/\/\\\\////\/\/\\\/
/\\\/\/\////\\\\/\/\///\
/\\\/\/\////\\\\/\/\///\
\/\\\\\//\\\///\\/////\/
------------------------
\//\////\/\/\/\/\\\\/\\/
&lt;&lt;&gt;&lt;&lt;&gt;&gt;&gt;&gt;&gt;&lt;&lt;&gt;&gt;&lt;&lt;&lt;&lt;&lt;&gt;&gt;&lt;&gt;&gt;
\\//\\///\\/\//\\\//\\//
------------------------
========================

All quilts have the same form:

They are always 24 by 18.
The top line (line 1) and bottom line (line 18) are = all the way across.
Lines 2, 6, 13 and 17 are - all the way across.
Lines 4 and 15 are the same random horizontally symmetric pattern of &lt; and &gt;.
All other lines (3, 5, 7, 8, 9, 10, 11, 12, 14, 16) are filled with / and \ in a completely random way such that the entire quilt remains horizontally and vertically symmetric.

Notice that when folding the quilt exactly in half, either vertically or horizontally, the shapes of the characters exactly match up. Don't get this confused with the characters themselves matching up. e.g. line 3 and line 16 are not identical, they are vertical mirror images.
Challenge
Write a program or function that will print or return a random ASCII art quilt.
Due to the many hardcoded lines and the symmetry, the only real randomness comes from the first 12 characters on lines 3, 4, 5, 7, 8, 9:

The first 12 characters on line 4 should be able to be any length 12 string of the characters &lt; and &gt;.
The first 12 characters on lines 3, 5, 7, 8, 9 should be able to be any length 12 string of the characters / and \ (independent of each other).
These random strings are then mirrored accordingly to make the entire quilt.

The shortest answer in bytes wins. Tiebreaker is earlier post.
You may use pseudorandom number generators. (No, you don't need to prove that all 12 char string of &lt;&gt; or /\ can be generated with you language's PRNG.)
The output may optionally contain a trailing newline, but no trailing spaces or other characters besides what's necessary for the quilt.
CJam, 61 60 58 55 54 52 51 bytes

Shortened a bit with some help from Sp3000 and Optimizer.

"=-/&lt;/-///"{C*1{"&lt;\/&gt;"%1$W%\_W%er}:F~+mrC&lt;1FN}%s3F(


Test it here.

Explanation

As usual with these symmetric ASCII art challenges, I'm generating one quadrant and then expand it to the full thing by two appropriate mirroring operations.

For this explanation I should start with the function F, which I'm defining somewhere along the way, because it's used in three places for three different things:

{"&lt;\/&gt;"%1$W%\_W%er}:F


This expects an integer on the top of the stack, and a string beneath that. Its purpose is to reverse the string and also swap some characters, to get the mirroring right. The integer is either 1 or 3 and indicates whether (1) both brackets and slashes should be swapped or (3) only brackets should be swapped. Here is how it works:

"&lt;\/&gt;"            "Push a string with all four relevant characters.";
      %           "% applied to a string and an integer N (in any order) selects every
                   Nth character, starting from the first. So with N = 1 this just
                   leaves the string unchanged, but with N = 3 it returns a string
                   containing only &lt; and &gt;.";
       1$         "Copy the string we want to mirror.";
         W%       "% also takes negative arguments. Giving it -1 reverses the string.";
           \_     "Swap the two strings and duplicate the &lt;\/&gt; or &lt;&gt; string.";
             W%   "Reverse that one. Due to the symmetry of this string, we'll now
                   have the characters to be swapped at corresponding indices.";
               er "Perform element-wise transliteration on the reversed input string
                   to complete the mirroring operation.";


Now for the rest of the code:

"=-/&lt;/-///"                            "This string encodes the 9 different line types.
                                        Note that for the /\ and &lt;&gt; lines we only use
                                        one of the characters. This idea is due to
                                        Sp3000. Thanks! :)";
           {                   }%      "Map this block onto the characters.";
            C*                         "Repeat the character 12 times, turning it into
                                        a string.";
              1{...}:F~                "Define and call F on the resulting string. The
                                        reversal doesn't do anything, but the character
                                        swapping creates strings containing both \/ and
                                        &lt;&gt;.";
                       +mr             "Add the two halves together and shuffle them.";
                          C&lt;           "Truncate to 12 characters. We've now got our
                                        random half-lines.";
                            1F         "Call F again to mirror the half-line.";
                              N        "Push a newline.";
                                 s     "Join all those separate strings together by
                                        converting the array to a string.";
                                  3F   "Perform one more mirroring operation on the
                                        half-quilt, but this time only swap &lt; and &gt;.
                                        This yields the correct full quilt, except
                                        there are two newlines in the centre.";
                                    (  "This slices the leading newline off the second
                                        half and pushes it onto the stack.";


The two halves and that single newline are then printed automatically at the end of the program.