[Question]
  [
For this challenge, an ASCII art quilt will be a block of text 24 characters wide and 18 lines tall, containing the characters `=-<>/\` in a quilt-like pattern that is horizontally and vertically symmetrical.
Example quilt:
```
========================
------------------------
//\\//\\\//\/\\///\\//\\
<<><<>>>>><<>><<<<<>><>>
/\\/\\\\/\/\/\/\////\//\
------------------------
/\/////\\///\\\//\\\\\/\
\///\/\/\\\\////\/\/\\\/
\///\/\/\\\\////\/\/\\\/
/\\\/\/\////\\\\/\/\///\
/\\\/\/\////\\\\/\/\///\
\/\\\\\//\\\///\\/////\/
------------------------
\//\////\/\/\/\/\\\\/\\/
<<><<>>>>><<>><<<<<>><>>
\\//\\///\\/\//\\\//\\//
------------------------
========================
```
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 `<` and `>`.
* 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 `<` and `>`.
* 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 `<>` 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.
  
[Answer]
# CJam, ~~61~~ ~~60~~ ~~58~~ ~~55~~ ~~54~~ ~~52~~ 51 bytes
Shortened a bit with some help from Sp3000 and Optimizer.
```
"=-/</-///"{C*1{"<\/>"%1$W%\_W%er}:F~+mrC<1FN}%s3F(
```
[Test it here.](http://cjam.aditsu.net/#code=%22%3D-%2F%3C%2F-%2F%2F%2F%22%7BC*1%7B%22%3C%5C%2F%3E%22%251%24W%25%5C_W%25er%7D%3AF~%2BmrC%3C1FN%7D%25s3F()
## 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:
```
{"<\/>"%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:
```
"<\/>"            "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 < and >.";
       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 <\/> or <> 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:
```
"=-/</-///"                            "This string encodes the 9 different line types.
                                        Note that for the /\ and <> 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
                                        <>.";
                       +mr             "Add the two halves together and shuffle them.";
                          C<           "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 < and >.
                                        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.
[Answer]
# Python 3, ~~257~~ ~~229~~ ~~192~~ ~~185~~ ~~176~~ ~~149~~ 143 bytes
```
from random import*
k,*L=80703,
while k:s=eval("''"+".join(sample('--==<>\/'[k%4*2:][:2],2))"*12);L=[s]+L+[s[::(-1)**k]];k//=4
*_,=map(print,L)
```
With help from @xnor, we've finally caught up with JS!
Sample output:
```
========================
------------------------
///////////\/\\\\\\\\\\\
>><<<>><<<><><>>><<>>><<
/\/\\/\/\\/\/\//\/\//\/\
------------------------
//\\////\\/\/\//\\\\//\\
/////\\\/\/\/\/\///\\\\\
/\\//\\/////\\\\\//\\//\
\//\\//\\\\\/////\\//\\/
\\\\\///\/\/\/\/\\\/////
\\//\\\\//\/\/\\////\\//
------------------------
\/\//\/\//\/\/\\/\/\\/\/
>><<<>><<<><><>>><<>>><<
\\\\\\\\\\\/\///////////
------------------------
========================
```
## Explanation
*(Slightly outdated, will update later)*
`"444046402"` encodes the rows, with each digit referring to the starting index of the relevant 2-char substring of `'--==\/<>'`. Each individual row is built inside-out via repeated shuffling of the two chars (using `sample(...,2)`, since `random.shuffle` is unfortunately in-place) and string joining. 
A simplified example of what the expansion might look like for the fourth row is:
```
''.join(['<','>']).join(['>','<']).join(['>','<']).join(['<','>']).join(['>','<'])
```
which would yield `><>><><<><`:
```
               ''
    <>         .join(['<','>'])
   >  <        .join(['>','<'])
  >    <       .join(['>','<'])
 <      >      .join(['<','>'])
>        <     .join(['>','<'])
```
The overall quilt is also built inside-out, as construction begins with the 9th/10th rows, working outward. To do this we start with an empty list `L`, which we add rows to the front and back of as we go via
```
L=[s]+L+[[s,s[::-1]][n<"5"]]
```
The `n<"5"` condition is to check whether we have a row consisting of `><`, in which case we append an identical row to the back, otherwise its reverse.
Finally, `*_,=` is to force the evaluation of `map` so printing occurs, and is just a shorter way to do `print("\n".join(L))`.
For a long time I had the function
```
g=lambda s:s.translate({60:62,62:60,92:47,47:92})
```
which takes a string and converts `/\><` to `\/<>` respectively, but I've finally managed to get rid of it :)
[Answer]
# Python 2, 300 bytes
This program uses `join, lambda, replace, sample, import` and other verbose functions, so it will not be winning any golf awards.
```
from random import*
f=lambda a,b,t:t.replace(a,'*').replace(b,a).replace('*',b)
k=lambda a:''.join(sample(a*12,12))
c='-'*24
e=k('<>')
h=e+f('<','>',e[::-1])
j=[d+f('/','\\',d[::-1])for d in[k('\\/')for i in'quilt']]
g=['='*24,c,j[0],h,j[1],c]+j[2:]
print'\n'.join(g+[f('/','\\',d)for d in g[::-1]])
```
The code before the auto-golfer got hold of it:
```
from random import *
change = lambda a,b,t: t.replace(a,'*').replace(b,a).replace('*',b)
pick = lambda a: ''.join(sample(a*12, 12))
innerline = '-' * 24
line4h = pick('<>')
line4 = line4h + change('<', '>', line4h[::-1])
diag = [d + change('/', '\\', d[::-1]) for d in [pick('\\/') for i in 'quilt']]
quilt = ['='*24, innerline, diag[0], line4, diag[1], innerline] + diag[2:]
print '\n'.join(quilt + [change('/', '\\', d) for d in quilt[::-1]])
```
A sample output:
```
========================
------------------------
\\\\/\////\\//\\\\/\////
<><<>>>><><><><><<<<>><>
/\\\\////\\\///\\\\////\
------------------------
\\\\//\///\\//\\\/\\////
//\//\\\\/\/\/\////\\/\\
\/\\\\/\//\/\/\\/\////\/
/\////\/\\/\/\//\/\\\\/\
\\/\\////\/\/\/\\\\//\//
////\\/\\\//\\///\//\\\\
------------------------
\////\\\\///\\\////\\\\/
<><<>>>><><><><><<<<>><>
////\/\\\\//\\////\/\\\\
------------------------
========================
```
[Answer]
# APL (~~53~~ 58)
It's not *quite* as symmetrical as I thought it was, unfortunately. Fix cost me 5 characters and now I'm out of the running.
```
L←+,3-⌽⋄'==--/\<><'[↑(732451451260688⊤⍨18/8)+L{L?12⍴2}¨⍳9]
```
Explanation:
* `L←+,3-⌽`: L is a function that returns its argument followed by 3 - the reverse of its argument
* `L{L?12⍴2}¨⍳9`: generate 9 lines of 12 random values from [1,2] plus their reverse, then the reverse of those 9 lines
* `732451451260688⊤⍨18/8`: generate the list `0 2 4 6 4 2 4 4 4 4 4 4 2 4 _7_ 4 2 0` (that's where the damn asymmetricality is)
* `+`: for each line, add the corresponding number to each value
* `↑`: format as matrix
* `'==--/\<><'[`...`]`: for each of the numbers in the matrix, select the character from the string at that position
Output:
```
========================
------------------------
///////\\///\\\//\\\\\\\
<<><<><><<<<>>>><><>><>>
\\\\\//\/\\\///\/\\/////
------------------------
/\///\\/\/\/\/\/\//\\\/\
\////////\//\\/\\\\\\\\/
\\/\\\//\///\\\/\\///\//
//\///\\/\\\///\//\\\/\\
/\\\\\\\\/\\//\////////\
\/\\\//\/\/\/\/\/\\///\/
------------------------
/////\\/\///\\\/\//\\\\\
<<><<><><<<<>>>><><>><>>
\\\\\\\//\\\///\\///////
------------------------
========================
```
[Answer]
# PHP, 408, 407, 402, 387, 379 bytes
I am not a good golfer, but this problem sounded fun so I gave it a try.
```
<?$a=str_replace;$b=str_repeat;function a($l,$a,$b){while(strlen($s)<$l){$s.=rand(0,1)?$a:$b;}return$s;}$c=[$b('=',12),$b('-',12),a(12,'/','\\'),a(12,'<','>'),a(12,'/','\\'),$b('-',12)];while(count($c)<9){$c[]=a(12,'/','\\');}for($d=9;$d--;){$c[$d].=strrev($a(['/','<','\\','>',1,2],[1,2,'/','<','\\','>'],$c[$d]));$c[]=$a(['/','\\',1],[1,'/','\\'],$c[$d]);}echo implode("
",$c);
```
Ungolfed code
```
<?php
    
    function randomString($length, $a, $b) {
        $string = '';
        while(strlen($string) < $length) {
            $string .= rand(0, 1) ? $a : $b;
        }
        return $string;
    }
    
    if(isset($argv[1])) {
        srand(intval($argv[1]));
    }
    
    $lines = [
        str_repeat('=', 12),
        str_repeat('-', 12),
        randomString(12, '/', '\\'),
        randomString(12, '<', '>'),
        randomString(12, '/', '\\'),
        str_repeat('-', 12)
    ];
    while(count($lines) < 9) {
        $lines[] = randomString(12, '/', '\\');
    }
    
    for($index = count($lines); $index--;) {
        $lines[$index] .= strrev(str_replace(['/', '<', '\\', '>', 1, 2], [1, 2, '/', '<', '\\', '>'], $lines[$index]));
        $lines[] = str_replace(['/', '\\', 1], [1, '/', '\\'], $lines[$index]);
    }
    
    echo implode("\n", $lines) . "\n";
    
?>
```
The ungolfed version has a little bonus: You can pass it an integer to seed `rand()` and get the same quilt each time for a seed:
```
php quilt.php 48937
```
This results, for example, in this beautiful, hand woven quilt:
```
========================
------------------------
/\\\////\\\/\///\\\\///\
><>><>><<<><><>>><<><<><
/\\\///\//\/\/\\/\\\///\
------------------------
/\\/\\\/\\/\/\//\///\//\
/\\\\/\//\\/\//\\/\////\
\/\\/\/\////\\\\/\/\//\/
/\//\/\/\\\\////\/\/\\/\
\////\/\\//\/\\//\/\\\\/
\//\///\//\/\/\\/\\\/\\/
------------------------
\///\\\/\\/\/\//\///\\\/
><>><>><<<><><>>><<><<><
\///\\\\///\/\\\////\\\/
------------------------
========================
```
**Edit**: Turns out my first version did not return a correct quilt. So I fixed it. Funny enough, the fix is even shorter.
[Answer]
# JavaScript (ES6) 169 ~~195 201~~
**Edit** 6 bytes saved thx @nderscore. Beware, the newline inside backquotes is significant and counted.
**Edit2** simplified row building, no need of `reverse` and `concat`
```
F=(o='')=>[...z='/\\/-/<\\-='].map((c,i,_,y=[z,'\\/\\-\\>/-='],q=[for(_ of-z+z)Math.random(Q=k=>q.map(v=>r=y[v^!k][i]+r+y[v^k][i],r='')&&r+`
`)*2])=>o=Q()+o+Q(i!=5))&&o
```
*Run snippet to test* (in Firefox) 
```
F=(o='')=>[...z='/\\/-/<\\-='].map((c,i,_,y=[z,'\\/\\-\\>/-='],q=[for(_ of-z+z)Math.random(Q=k=>q.map(v=>r=y[v^!k][i]+r+y[v^k][i],r='')&&r+`
`)*2])=>o=Q()+o+Q(i!=5))&&o
Q.innerHTML=F()
```
```
<pre id=Q style='font-size:9px;line-height:9px'>
```
[Answer]
# Ruby, 162 155
I like this one because it made me learn to abuse backslashes in both string literals and `String#tr`. The code isn't terribly clever otherwise, just compact.
```
a='/\\'
b='\\\/'
t=Array.new(9){x=''
12.times{x+=a[rand(2)]}
x+x.reverse.tr(a,b)}
t[0]=?=*24
t[1]=t[5]=?-*24
t[3].tr!a,'<>'
puts t,((t.reverse*'
').tr a,b)
```
[Answer]
# Pyth, 57 ~~59 61~~
```
J"\<>/"K"\/"L+b_mXdK_Kbjbym+d_XdJ_JmsmOk12[\=\-K-JKK\-KKK
J"\<>/"K"\/"jbu++HGXHK_Km+d_XdJ_JmsmOk12[KKK\-K-JKK\-\=)Y
```
Thanks a lot to @Jakube for coming up with these 57 byte versions.
Algorithm very similar to Martin's. (Revised) Explanation to come.
[Try it online](https://pyth.herokuapp.com/?code=J%22%5C%3C%3E%2F%22K%22%5C%2F%22L%2Bb_mXdK_Kbjbym%2Bd_XdJ_JmsmOk12%5B%5C%3D%5C-K-JKK%5C-KKK&debug=0)
Explanation:
```
=G"\<>/"                            : Set G to be the string "\<>/"
K"\/"                               : Set K to be the string "\/"
Jm+d_XdG_GmsmOk12[\=\-K"<>"K\-KKK;  : Set J to be the top half of the carpet
                 [\=\-K"<>"K\-KKK;  : Make a list of possible chars for each row
          msmOk12                   : for each element of that list,
                                    : make a list of 12 randomly chosen characters
                                    : from it, then join them
Jm+d_XdG_G                          : for each element of that list,
                                    : make a new list with the old element,
                                    : and its horizontal reflection
jb+J_mXdK_KJ                        : Print the whole carpet
     mXdK_KJ                        : For each element of J make its vertical reflection
```
[Answer]
# J, ~~56~~ 54 bytes
```
'=/\<>--></\'{~(-,|.)0,(3(2})8$5,3#1)+(,1-|.)"1?8 12$2
```
Usage:
```
   '=/\<>--></\'{~(-,|.)0,(3(2})8$5,3#1)+(,1-|.)"1?8 12$2
========================
------------------------
///\\\\/\///\\\/\////\\\
><<><><>><>><<><<><><>><
\\/\//\\/\//\\/\//\\/\//
------------------------
\/\/\//////\/\\\\\\/\/\/
/\/\\//\//\\//\\/\\//\/\
//\\\\/////\/\\\\\////\\
\\////\\\\\/\/////\\\\//
\/\//\\/\\//\\//\//\\/\/
/\/\/\\\\\\/\//////\/\/\
------------------------
//\/\\//\/\\//\/\\//\/\\
><<><><>><>><<><<><><>><
\\\////\/\\\///\/\\\\///
------------------------
========================
```
1 byte thanks to @FUZxxl.
Explanation coming soon.
[Try it online here.](http://tryj.tk/)
[Answer]
# Python 295 287 227 bytes
Not that great but I'll post it anyway:
```
from random import*
m,d=[],dict(zip("\/<>=-","/\><=-"))
v=lambda w:[d[x]for x in w]
for e in '=-/>/-///':f=[choice([e,d[e]])for x in[0]*12];t=''.join(f+v(f[::-1]));print t;m+=''.join(e=='/'and v(t)or t),
print'\n'.join(m[::-1])
```
If you want an explanation just ask me.
[Answer]
# Javascript (*ES7 Draft*) 174 168 146
Some inspiration taken from @edc65
Edit: Thanks to edc65 for some ideas to optimize building of rows.
```
F=(o='')=>[for(i of'555357531')(z=[for(_ of c='==--/\\<>golf')Math.random(r=x=>z.reduce((s,y)=>c[w=i^y^x]+s+c[w^1],'')+`
`)*2],o=r()+o+r(i<7))]&&o
```
---
**Demonstration: (*Firefox only*)**
```
F=(o='')=>[for(i of'555357531')(z=[for(_ of c='==--/\\<>golf')Math.random(r=x=>z.reduce((s,y)=>c[w=i^y^x]+s+c[w^1],'')+`
`)*2],o=r()+o+r(i<7))]&&o
document.write('<pre>' + F() + '</pre>');
```
---
**Commented:**
```
// define function, initialize output to ''
F = (o = '') =>
    // loop through character indexes of first 9 lines
    [
        for (i of '555357531')(
            // build array of 12 random 0/1's, initialize character list
            z = [
                for (_ of c = '==--/\\<>golf')
                    Math.random(
                        // define function for generating lines
                        // if x is true, opposite line is generated
                        r = x =>
                            z.reduce(
                                (s, y) => 
                                    c[w = i ^ y ^ x] + s + c[w ^ 1],
                                ''
                            ) + `\n`
                    ) * 2
            ],
            // build new lines and wrap output in them
            // x true in the second line for indexes < 7 (not character '>')
            o = r() + o + r(i < 7)
        )
    ]
    // return output
    && o
```
[Answer]
## Pharo 4, 236
```
|s i f v h|s:='====----/\/\/<><<>'.f:=[:c|s at:(s indexOf:c)+i].v:=#(),'=-/</-///'collect:[:c|h:=(String new:12)collect:[:x|i:=2atRandom.f value:c].i:=1.h,(h reverse collect:f)].i:=3.String cr join:v,(v reverse collect:[:k|k collect:f])
```
or formatted normally:
```
|s i f v h|
s:='====----/\/\/<><<>'.
f:=[:c|s at:(s indexOf:c)+i].
v:=#() , '=-/</-///'
  collect:[:c|
    h:=(String new:12)collect:[:x|i:=2atRandom.f value:c].
    i:=1.
    h,(h reverse collect:f)].
i:=3.
String cr join:v,(v reverse collect:[:k|k collect:f])
```
Explanation:
The string `s:='====----/\/\/<><<>'` together with the block `f:=[:c|s at:(s indexOf:c)+i]` are here both for tossing the characters and for reversing the patterns...
* For i=1, it performs horizontal reversion (`/` <-> `\` , `<` <-> `>` ).
* For i=3, it performs vertical reversion (`/` <-> `\`)
* For i=1 or 2 atRandom, it toss among `/` or `\`, `<` or `>`
`'=-/</-///'` encodes the character type `c` that will feed the block `f` for the 9 first lines.
`#() , '=-/</-///'` is a concatenation trick for transforming the String into an Array and thus collecting into an Array.
The rest is simple concatenation after applying the horizontal/vertical symetry.
```
========================
------------------------
\\/\/\\\\/\/\/\////\/\//
>>>><><><>><><<><><><<<<
\/\/\//\///\/\\\/\\/\/\/
------------------------
/\//\/\/////\\\\\/\/\\/\
\\//\//\\\/\/\///\\/\\//
////\\/\/\//\\/\/\//\\\\
\\\\//\/\/\\//\/\/\\////
//\\/\\///\/\/\\\//\//\\
\/\\/\/\\\\\/////\/\//\/
------------------------
/\/\/\\/\\\/\///\//\/\/\
>>>><><><>><><<><><><<<<
//\/\////\/\/\/\\\\/\/\\
------------------------
========================
```
[Answer]
## Squeak 4.X, 247
```
|r s h m n p|s:='==--/\<>'.r:=(1<<108)atRandom.h:=''.m:=0.(16to:0by:-2),(0to:16by:2)do:[:i|n:=3bitAnd:28266>>i.p:=0.(11to:0by:-1),(0to:11)do:[:j|h:=h,(s at:n*2+1+(r-1>>(6*i+j)+(101>>(3-n*4+m+p))bitAnd:1)).j=0and:[p:=1]].i=0and:[m:=2].h:=h,#[13]].h
```
Or formatted:
```
|r s h m n p|
s:='==--/\<>'.
r:=(1<<108)atRandom.
h:=''.
m:=0.
(16to:0by:-2),(0to:16by:2) do:[:i|
  n:=3 bitAnd: 28266>>i.
  p:=0.
  (11to:0 by:-1),(0to:11) do:[:j|
    "h:=h,(s at:n*2+1+((r-1bitAt:6*i+j+1)bitXor:(101bitAt:3-n*4+m+p))). <- originally"
    h:=h,(s at:n*2+1+(r-1>>(6*i+j)+(101>>(3-n*4+m+p))bitAnd:1)).
    j=0and:[p:=1]].
  i=0and:[m:=2].
  h:=h,#[13]].
h
```
Explanations:
`s:='==--/\<>'.` obviously encodes the four posible pairs.
`r:=(1<<108)atRandom.` toss 108 bits (in a LargeInteger) for 9 rows\*12 columns (we toss the == and -- unecessarily but performance is not our problem).
`h:=''`is the string where we will concatenate (Schlemiel painter because a Stream would be too costly in characters).
`(16to:0by:-2),(0to:16by:2)do:[:i|` is iterating on the rows (\*2)
`(11to:0by:-1),(0to:11) do:[:j|` is iterating on the columns
`28266` is a magic number encoding the pair to be used on first 9 lines.  
It is the bit pattern `00 01 10 11 10 01 10 10 10`, where 00 encodes '==', 01 '--', 10 '/\' and 11 '<>'.
`101` is a magic number encoding the horizontal and vertical reversion.  
It is the bit pattern `0000 0000 0110 1010`, encoding when to reverse (1) or not (0) the first (0) or second (1) character of each pair '==' '--' '/\' and '<>', for the vertical symetry and horizontal symetry.
`n:=3 bitAnd: 28266>>i` gives the encoding of character pair for row i/2 (0 for '==', 1 for '--', 2 for '/\' and 3 for '<>').
`(r-1 bitAt: 6*i+j+1)` pick the random bit for row i/2 column j (1 is the rank of lowest bit thus we have a +1, k atRandom toss in interval [1,k] thus we have a -1).
`(101 bitAt: 3-n*4+m+p)` pick the reversal bit: (3-n)\*4 is the offset for the group of 4 bits corresponding to the pair code n, m is the vertical reversion offset (0 for first 9, 2 for last 9 rows), p is the horizontal reversion offset (0 for first 12, 1 for last 12 columns)+1 because low bit rank is 1.
`bitXor:` performs the reversion (it answer an offset 0 or 1), and `s at:2*n+1+bitXor_offset` pick the right character in s.
But `(A>>a)+(B>>b) bitAnd: 1` costs less bytes than `(A bitAt:a+1)bitXor:(B bitAt:b+1)`thus the bitXor was rewritten and offset +1 on p is gone...
`h,#[13]` is an ugly squeakism, we can concatenate a String with a ByteArray (containing code for carriage return).
```
========================
------------------------
/\/\\\/\//\/\/\\/\///\/\
><>><<>>>><<>><<<<>><<><
////\\////\\//\\\\//\\\\
------------------------
/\\\/\\/\\//\\//\//\///\
\/\\/\//////\\\\\\/\//\/
\\\//\\\////\\\\///\\///
///\\///\\\\////\\\//\\\
/\//\/\\\\\\//////\/\\/\
\///\//\//\\//\\/\\/\\\/
------------------------
\\\\//\\\\//\\////\\////
><>><<>>>><<>><<<<>><<><
\/\///\/\\/\/\//\/\\\/\/
------------------------
========================
```
]