[Question]
  [
Cut a boolean matrix in 4x2 blocks and render them as Braille characters `U+2800`...`U+28FF`.
```
[[0,1,0,0,1,0],
 [1,0,0,0,0,0],
 [1,0,0,0,1,0],
 [1,1,1,1,0,0]]
⣎⣀⠅
```
Pad with 0-s if dimensions are not multiples of 4 and 2.
```
[[0,1,0],
 [1,0,0],
 [1,1,1]]
⠮⠄
```
Usual golfing rules apply, flexible on input format. Output should either have the structure of a matrix or look like a matrix, e.g. list of strings; single string with newlines.
Hint: `chr(0x2800 + 128*b7 + 64*b6 + 32*b5 + 16*b4 + 8*b3 + 4*b2 + 2*b1 + b0)` is the dot pattern
```
b0 b3
b1 b4
b2 b5
b6 b7
```
Larger test:
```
[[0,0,1,1,1,1,0,0,0,0,0,0,0,1,1,0,0,0,0,1,1,1,0],
 [0,1,1,1,1,1,1,0,0,0,0,0,1,1,1,0,0,0,1,1,1,1,1],
 [0,1,1,0,0,1,1,1,0,0,0,1,1,1,1,0,0,1,1,0,0,0,1],
 [1,1,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,1,1,0,0,1,1],
 [1,1,0,0,0,1,1,0,0,0,0,0,0,0,1,0,0,1,1,1,0,1,0],
 [1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0],
 [1,1,0,1,1,1,1,1,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0],
 [1,1,0,1,1,1,1,1,0,0,1,1,0,0,1,0,0,1,1,1,1,1,1],
 [1,1,0,1,1,1,1,0,0,1,1,1,1,0,1,0,1,1,1,1,1,1,0],
 [1,1,0,1,0,1,1,0,1,1,0,1,1,0,1,0,0,0,0,1,1,0,0],
 [1,1,0,0,0,1,1,0,1,0,0,0,1,0,1,1,0,0,0,1,1,0,0],
 [1,1,0,0,0,1,1,0,1,0,0,0,1,0,1,1,1,0,0,1,1,0,0],
 [0,1,1,0,1,1,1,0,1,0,0,1,1,0,0,1,1,0,0,1,1,0,0],
 [0,1,1,1,1,1,0,0,1,1,1,1,1,0,0,1,1,0,1,1,1,0,0],
 [0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,0,1,1,1,1,0]]
⣰⠟⠻⣦⠀⠠⠾⡇⢠⡞⢛⡆
⣿⢠⣬⣥⠄⣀⠀⡇⢈⣻⣈⡀
⣿⠘⢹⡇⡞⠙⡇⣧⡉⢹⡏⠀
⠘⠷⠟⠁⠳⠾⠃⠘⠇⠾⠧⠀
```
  
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~31~~ 30 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
sz0Z
ç€2ZF€ç€8Zœ?@€€-36Ḅ+⁽$ṁỌY
```
**[Try it online!](https://tio.run/##y0rNyan8/7@4yiCK6/DyR01rjKLcgCSYaRF1dLK9A5ABRLrGZg93tGg/atyr8nBn48PdPZH///@PjjbQMdAxhEIDFIgsApWP1eFSiEaoR9WDzIfLI@nApQbVLogOdLtR3YUsaoihA5tPkO2G@QNTHboOJLOQdODyPRoLqw5UlxugmoZFB2o4YdiOosNAxxALiRaKWMPKEMnlGOFIlA5DDB3I7jDEFms4dGD62xDFXlQdBmjxgM5DCr3YWAA "Jelly – Try It Online")**
### How?
```
sz0Z - Link 1, split & right-pad with zeros: list, items; number, chunkSize
s    - split items into chunks of length chunkSize
 z0  - transpose with filler zero
   Z - transpose
ç€2ZF€ç€8Zœ?@€€-36Ḅ+⁽$ṁỌY - Main link: list of lists of numbers (1s & 0s), M
ç€2                       - call the last link (1) as a dyad for €ach (left=M, right=2)
                          -  ((left,right) bits read left-right then top-bottom)
   Z                      - transpose the resulting list of lists of lists
                          -  ((left, right) bits read top-bottom then left-right)
    F€                    - flatten €ach
      ç€8                 - call the last link (1) as a dyad for €ach (left=^, right=8)
         Z                - transpose the resulting list of lists of lists
                          -  ("blocks" each and all read left-right top-to bottom)
               -36        - literal -36
             €€           - for €ach (block-wise row) for €ach (block)
          œ?@             -   lexicographical permutation with reversed arguments
                          -    (get the permutation at index -36 (modular) in a list of
                          -     all permutations of the indexes sorted lexicographically.
                          -     That is the 8!-36 = 40284th - equivalently the values at
                          -     indexes [8,7,6,4,2,5,3,1])
                  Ḅ       - convert from binary list to integer (vectorises)
                    ⁽$ṁ   - base 250 literal = 10240
                   +      - add
                       Ọ  - cast to character (vectorises)
                        Y - join with newlines
                          - implicit print
```
[Answer]
# Mathematica, ~~126~~ ~~110~~ ~~97~~ 90
```
FromCharacterCode[10240+ListCorrelate[2^{{0,3},{1,4},{2,5},{6,7}},#,1,0][[;;;;4,;;;;2]]]&
```
---
This solution takes advantage of [`ListCorrelate`](http://reference.wolfram.com/language/ref/ListCorrelate.html) to [convolve a (reversed) kernel over a matrix](https://en.wikipedia.org/wiki/Kernel_(image_processing)#Convolution), which is essentially a sliding matrix multiplication (or dot product). See a visual explanation [here](https://mathematica.stackexchange.com/questions/64925/how-do-i-understand-listcorrelatecontains-k-l-k-r-when-it-works-for-2-di?noredirect=1&lq=1). Padding is done by using `0` as the fourth argument. In the following example, we expect the result to match the hint above:
```
ListCorrelate[
  2^{{0, 3}, {1, 4}, {2, 5}, {6, 7}},
  {{b0, b3}, {b1, b4}, {b2, b5}, {b6, b7}}
]
(* returns {{b0 + 2 b1 + 4 b2 + 8 b3 + 16 b4 + 32 b5 + 64 b6 + 128 b7}} *)
```
Note that `ListConvolve` is not any shorter, since the third argument would be `-1`.
Since this applies the kernel at every position of the matrix, we just need to extract the elements in every fourth row and second column. We use shorthands for [`Span`](http://reference.wolfram.com/language/ref/Span.html) and [`Part`](http://reference.wolfram.com/language/ref/Part.html): `[[;;;;4,;;;;2]]`.
Helpfully, [`FromCharacterCode`](http://reference.wolfram.com/language/ref/FromCharacterCode.html) can take a matrix of character codes and return a list of strings.
---
This solution returns a list of strings, which is one of the allowed output formats. Simply prepend `Column@` for the output to “look like a matrix.”
---
You can play around with this in a free online Mathematica notebook. [Go here](https://develop.open.wolframcloud.com/app/), click Create a New Notebook, wait a moment, paste in this code, then press `shift+enter`.
```
m1={{0,1,0,0,1,0},{1,0,0,0,0,0},{1,0,0,0,1,0},{1,1,1,1,0,0}};
m2={{0,1,0},{1,0,0},{1,1,1}};
m3={{0,0,1,1,1,1,0,0,0,0,0,0,0,1,1,0,0,0,0,1,1,1,0},{0,1,1,1,1,1,1,0,0,0,0,0,1,1,1,0,0,0,1,1,1,1,1},{0,1,1,0,0,1,1,1,0,0,0,1,1,1,1,0,0,1,1,0,0,0,1},{1,1,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,1,1,0,0,1,1},{1,1,0,0,0,1,1,0,0,0,0,0,0,0,1,0,0,1,1,1,0,1,0},{1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0},{1,1,0,1,1,1,1,1,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0},{1,1,0,1,1,1,1,1,0,0,1,1,0,0,1,0,0,1,1,1,1,1,1},{1,1,0,1,1,1,1,0,0,1,1,1,1,0,1,0,1,1,1,1,1,1,0},{1,1,0,1,0,1,1,0,1,1,0,1,1,0,1,0,0,0,0,1,1,0,0},{1,1,0,0,0,1,1,0,1,0,0,0,1,0,1,1,0,0,0,1,1,0,0},{1,1,0,0,0,1,1,0,1,0,0,0,1,0,1,1,1,0,0,1,1,0,0},{0,1,1,0,1,1,1,0,1,0,0,1,1,0,0,1,1,0,0,1,1,0,0},{0,1,1,1,1,1,0,0,1,1,1,1,1,0,0,1,1,0,1,1,1,0,0},{0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,0,1,1,1,1,0}};
MatrixToBraille := Column@
  FromCharacterCode[10240+ListCorrelate[2^{{0,3},{1,4},{2,5},{6,7}},#,1,0][[;;;;4,;;;;2]]]&
MatrixToBraille/@{m1,m2,m3}
```
Then you should see this:
> 
> ![](https://i.stack.imgur.com/Gm4YA.png)
> 
> 
> 
[Answer]
# JavaScript ES7 ~~210~~ ~~207~~ ~~201~~ ~~200~~ ~~198~~ ~~194~~ ~~185~~ 183 bytes
```
a=>eval('for(y=0,c="";A=a[y];y+=4,c+=`\n`)for(x=0;A[x]+1;x+=2)c+=String.fromCharCode(10240+eval("for(N=k=0;k<6;k++)N+=(g=(X,Y=3)=>(a[Y+y]||0)[X+x]|0)(k>2,k%3)*2**k")|g(0)+g(1)*2<<6)')
```
4 bytes saved thanks to ngn
3 bytes saved thanks to Luke
# How it works
I'm going to split the code up into parts and speak about them separately:
```
for(y=x=0, c=""; a[y]; x+=2)
    !((a[y] || [])[x]+1) && (y+=4,x=0,c+=`\n`)
```
This is where every variable gets declared. `x` and `y` is the position of the "cursor" (the upper left edge of the current braille character). The x coordinate increases by 2 every iteration, and it stops, when there's no row with the index `y` (a[x] returns `undefined` if it doesn't exist, which gets converted to false).
There are multiple tricks in the second row. `(a[y] || [])[x]` ensures that looking up the value at the `(x, y)` position doesn't throw an error. The `&&` is the usual and operator, and it only checks the right side of the expression, if the left was true. This can be translated to
```
if (!((a[y] || [])[x] + 1)) 
    y+=4,x=0,c+=`\n`
```
The next part:
```
c+=String.fromCharCode(10240+eval("for(N=k=0;k<6;k++)N+=(g=(x,y)=>(a[y]||[])[x]||0)(~~(k/3)+x,k%3+y)*2**k,N")+g(x,y+3)*64+g(x+1,y+3)*128)
```
`String.fromCharCode` simply converts the passed number to a unicode character with the same character code. The expression in the parentheses calculates the index of the Braille character:
```
for(N=k=0;k<6;k++)N+=(g=(x,y)=>(a[y]||[])[x]||0)(~~(k/3)+x,k%3+y)*2**k
```
Goes through the position in the
```
1 4
2 5
3 6
```
order, multiplies the values at those positions with 2i, where i is the index and adds them together. The
```
g=(x,y)=>(a[y]||[])[x]||0
```
part declares a lambda function called `g`, which given an `x` and `y` coordinate returns either the value at the `(x, y)` position or 0 if the position lies outside the bounds of the array.
```
+g(x,y+3)*64+g(x+1,y+3)*128
```
This part adds up the last two positions with the correct weights using the function defined a bit earlier.
Last but not least, the
```
a=>eval('...')
```
part has 2 functions. It defines an anonymous lambda and ensures, that the for loop doesn't cause any problems (a single line lambda such as this one can't contain a single for loop only, an evaluation circumvents this).
[Answer]
# Dyalog APL, ~~133~~ ~~122~~ ~~114~~ ~~112~~ ~~101~~ ~~100~~ ~~98~~ ~~95~~ ~~94~~ ~~93~~ ~~90~~ ~~88~~ 86 bytes
Assumes `⎕IO←0`
```
{C⍴{⎕UCS 10240+2⊥(∊S⌷⍨⍵+⍳¨A)[⍎¨⍕76531420]}¨(,b)/,⍳⍴b←{0 0≡A|⍵}¨⍳⍴S←⍵↑⍨A×C←⌈(⍴⍵)÷A←4 2}
```
-~~8~~ ~~9~~ 12 bytes thanks to @Adám in chat
-2 bytes thanks to @ngn
[Try it online!](https://tio.run/##RU87CsJAEO33FFsmuOLko9YhELCyCKIgFopgI2grmlaiuKKFWFsI6VXSx5vMReKLwcjA7vvMm9kdL@f16Wo8X8zynI@XTpe3JxKij8uVLdZPUpYiVZ4loor/9bLAxQBJRzpV8pdGCSECuGsf5hrLen4oLbJdqtm8vxsc70M@pKwT1q8a60eWeOaQ9TGDcGm3mo7l2jSKssRQE7Oh0IFBk2IiSeLdzdsgGBXdhRHCAOftGRO999Uv@CE2YEE236n3/aMdCTwFMJD9Cg1Enn8A)
## How (input is `⍵`)?
* `A←4 2`, store the vector `4 2` in variable `A`
* `(⍴⍵)÷`, the dimensions of `⍵` divided by `A`
* `⌈`, ceiling
* `C←`, stored in `C`
* `A×`, multiplied by `A`
* `⍵↑⍨`, fit `⍵` to those dimensions
* `S←`, stored in `S`
* `⍳⍴`, indexes of `S`
* `{0 0≡A|⍵}¨`, `1` where the top left of a cell is, `0` everywhere else
* `(,b)/,⍳⍴b←`, truthy indexes
* `{⎕UCS 10240+2⊥(∊S⌷⍨⍵+⍳¨A)[⍎¨⍕76531420]}¨`, turn each element into braille
* `C⍴`, reshape the dimensions to `C`
[Answer]
# JavaScript, 136 bytes
```
a=>(b=a.map(x=>[]),a.map((l,i)=>l.map((c,j)=>b[i>>2][j>>1]|=c<<'01263457'[i%4+j*4%8])),b.map(l=>l.map(c=>String.fromCharCode(10240+c))))
```
Thanks to [ngn](https://codegolf.stackexchange.com/users/24908/ngn), using bit shifts save 4 bytes.
[Answer]
# [Python 2](https://docs.python.org/2/) + [drawille](https://github.com/asciimoo/drawille), ~~141~~ ~~125~~ ~~120~~ 116 bytes
Saved 16 bytes thanks to ngn and L3viathan
Saved 5 bytes thanks to L3viathan
Saved 4 bytes thanks to ngn
```
from drawille import*
def a(d,c=Canvas(),e=enumerate):[c.set(j,i)for i,x in e(d)for j,y in e(x)if y];print c.frame()
```
[Try it online!](https://tio.run/##Jcc7DsIwDADQnVN4jFHUgRHUiWMgBiuxhavmIzeU5vRBgre92tur5MsYYiVBNProujJoqsXa@RRZgFz0Yb5T3mlz6Hnm/E5s1BivjzBt3NziFaUYqD9AM7CLvy6@/3ugCvTnrZrmBmESo8QOx/gC "Python 2 – Try It Online")
tio does not have drawille installed so it does not work
[Answer]
# [APL (Dyalog)](https://www.dyalog.com/), ~~57~~ 54 bytes\*
-3 thanks to OP. Prompts for Boolean matrix. Prints character matrix.
```
1↓⎕UCS{2⊥40,⌽(,⍉3↑⍵),⊢⌿⍵}⌺(2 2⍴4 2)⊢0⍪⍣3⍪∘0⍣3⊢⎕,0
```
[Try it online!](https://tio.run/##jVLBSsQwEL33K3LchQhJW39Abx7qYfFUeihskUKpy@4KStlrraUpihS86EERxKt6EWTBT5kfqW123SZpCjKQzmTmvZl5qT@L9qaXfnR2WkN2dTD3wygKagrpHZTVyeEkMSF/sQmG4nuEgV1bkN4C@xxjyJ@gWDfuCoqvkYlMYB82MsfNPQH2BuzZaj/ZPeFuU11WmLRNDCe4WEJ6k7RUZXU0OXYgyxNgj6ufV2DvLScC9oDmgT9FcVOMHBSFcbBA/gKF8ex8WW8H5VTINlyXYIoJ5qeHDeRuIm5S3OU31uY9Q6Kz/ug6YAdRi@k@ryZYIBRMvNnmOVdXL2PEeJcXEEM1ci@6m1c3x1YGLDEqCN0mYm9RRjJgPS4BMbS94mkR8uREZtMgZJ163SUEwVRzKipqtRJ@MNzT8V8I2kOIc1Ddqw0g@ntTqa@MIMo7qJGgnuf9Ag "APL (Dyalog Unicode) – Try It Online")
`⎕,0` append a zero on right (ignored if even number of columns)
`⊢` yield that (to separate `3` and `⎕`)
`⍪∘0⍣3` append zeros on bottom thrice (because `⌺` drops partial windows)
`0⍪⍣3` stack zeros on top thrice (because `⌺` starts in the top left corner)
`⊢` yield that (separates the parenthesis and the `0`)
`{`…`}⌺(2 2⍴4 2)` on each 4-row 2-column window, with 4-row vertical and 2 row horizontal step:
 `⊢⌿⍵` last row (lit. vertical right reduction); `[b6,b7]`
 `(`…`),` prepend:
  `3↑` take three rows; `[[b0,b3],[b1,b4],[b2,b5]]`
  `⍉` transpose; `[[b0,b1,b2],[b3,b4,b5]]`
  `,` ravel; `[b0,b1,b2,b3,b4,b5]`
 now we have `[b0,b1,b2,b3,b4,b5,b6,b7]`
 `⌽` reverse; `[b7,b6,b5,b4,b3,b2,b1,b0]`
 `40,` prepend 40 (for 40×29 = 10240); `[40,b7,b6,b5,b4,b3,b2,b1,b0]`
 `2⊥` evaluate as base-2 (binary)
`⎕UCS` convert to character
`1↓` drop the first row (all-zero because of `⌺`'s padding)
---
\* In Classic, counting `⌺` as `⎕U233A`.
[Answer]
# [Haskell](https://www.haskell.org/), 145 bytes
```
(a!b)c=take b$c++repeat a
r([]:_)=[]
r l=['⠀'..]!!(sum.zipWith(*)[1,8,2,16,4,32,64,128]$l>>=0!2):r(drop 2<$>l)
b[]=[]
b s=r(([]!4)s):b(drop 4s)
```
[Try it online!](https://tio.run/##jZPPaoQwEMbvPsUIwibdIImVZZHGe8899BBCiVvblc26EvXSUx@lz9YXsS6VbRIVSiDkz/zmm/lCjqo9lVoP7xf9BjwAEIISStg0qDPsk@lejggRf4AL2fvbvY2sBblqE@LLu6XZp2yOLHVjq996mQf6iJXMRtYs8FbLiFs9ddMtIa5bM30XoYQtzJ6Xy44xq/qZm/9D2ByxS2FLz7eGzJtnjrKHUO89/J3loZSQZUI81p2UA1JhgQ@8U6cSiuiw3ZqyKVUHKjBIyOwFcyEDA5qLzffX5yaOZRiitj/HH1XzXHVHdIdHW/YkIWxHUnKfkF1KWLKXkc5zTsMEZwa9mksDyUOUaxwUQl5TFtByg0aJMMUtzorfmLTFw1lVNXBATd89dSbua13VZYsBFXD9u3j4AQ "Haskell – Try It Online")
[Answer]
# [Python 3](https://docs.python.org/3/), ~~168~~ ~~165~~ 161 bytes
```
def f(m):
 while m:
  r,m,s=[*zip(*m)],m[4:],''
  while r:s+=chr(10240+sum(q<<int(w)for(q,w)in zip((r[0]+(0,)*3)[:4]+(r+[()])[1],'01263457')));r=r[2:]
  print(s)
```
[Try it online!](https://tio.run/##nVTNboMwDL7zFNyalBzslm0SKw/QZ4g4bUNFGv0Jnart5RmFDuLYcJgQKMH@/DmfHZ@/r4fTcdu27x9lXKpaZ1F8O1SfH3HdrWJnatPkdv1TndW61oWpbZoVZrXqbIOby5okfzs4hbBJIWm@anXZ7arjVd10eXLqYm66Osb3AMpZKBIFRq@32mZpt3aJVbrQFruYgJvnbfr0stJav7rc2U1WdDRndw/W6HafWwsGDZj@W5gotsOuf8h@sg/P3V5EUan2OoqGiN1ijDhhJ9SMP/bRh@8fF3p/0H/6aODZkfiDh5Kynrx8f8oT6oCyl48fswIhvpSdnxWEZwxYH/agGsg0YNwLWUmKw8gRVoRnJPcMkpfmOtofWfFKh/7jH3IOKX@kSnldAkJ3ANPa50BBnbCetK8oP1cBSQUh6GyYqTqSmmOgi8y6dCchPDHRkZyS3DFkPMjuKQrq8btMquepx/MAVllkCOkktHuAcYCICDsN2dThCFhE0MyDjhMQyzOPcgCbfMBVFLWitxT/gUCGANaTQdVmEPPzEYUJBkEdwp0/ux/93/4C "Python 3 – Try It Online")
[Answer]
# [Python 3](https://docs.python.org/3/), 169 bytes
```
a=[]
y=0
for l in eval(input()):
 y-=1;a+=y%4//3*[-~len(l)//2*[10240]];x=0
 for v in l:a[-1][x//2]|=v<<(6429374>>y%4*6+x%2*3&7);x+=1
for l in a:print(*map(chr,l),sep='')
```
[Try it online!](https://tio.run/##nZLfaoMwFMbvfYrcdE38g4lKS7Xpi4RchOGokFmxThTGXt3Zweg0J1kpnAuN5/zO5/elGbvzpU6nSXEhvZFT7@3SIo2qGpW90riqm48OE5J7aIw4K1TAx00Wx6kvoi9d1liTOE58wWiSUSmLYSagG6K/IXSuRMSkGOYe@cn74xHvsuSQ7rPTacb4u2DYJH76sifFEHB2363ypq3qDvvvqsGv5zbUJLyWDd9uyTQJQUM0F/tTFCrz071fhkisGCDJPF/0LzCPTIDKfjA2teB/mQ0MxrjtMRX/euOYs2HW2xaYR4yGX10Y0AYKLrRiwIysotcYuhwyH@BAXUkxwwZrps9gGIwx9TP3ZfsH4/CXQVoNDLXcFdvhOkQpvwE "Python 3 – Try It Online")
[Answer]
# [APL (Dyalog)](https://www.dyalog.com/), 53 bytes
```
4 2∘{⎕ucs 2⊥40⍪(⍎¨⍕76531420)∘.⊃,¨⍺∘↑¨↓∘⍵¨⍺∘×¨⍳⌈⍺÷⍨⍴⍵}
```
[Try it online!](https://tio.run/##jVLLSsNAFN3nK2apMMpMm@o/uIgLlyGLYFMJhLSYFpTQlRBCcIoiRTe6E8StiuDS/sn9kXjzaDOTTEAuDPdxzrmPxJ0FB@NrN5he5LBa@1NI7lg@wZeYZADpU4zZxXmEfvZqMhDveyBWv28g1sdHoyE3B2wfUYeQ3dAi@4MBJPfoJg@FK7622c1j4X3AbYrx5hsERp9YX@aWdzXHhjHysNnJ2akFaRaDeFlWDMQQEM/k0nPHJEQwsUjgh15E3Ij44WwxzyekECGmYduMcspo@TrUIHYVlabETb2you4YtdBwK9RQGnAD46MSx6gkIpmcqeulSoNXOXK8q0uMPozai@8m1c1Rr04VxRZDt4ncWz4d67GOlsTo277laRnq5ExV0zDUO3W6KwxGueZtXVF7K@mnop07/ovBOwx5Dq77aj2M7t5c6asyWOs7tCPpeo7zBw "APL (Dyalog Unicode) – Try It Online")
[Answer]
# [Perl 5](https://www.perl.org/), 164 bytes
163 bytes of code + 1 flag `-p`
```
@a=eval}{for(;$r<@a;$r+=4){for($c=0;$c<@{$a[0]};$c+=2){$n="0b";map$n.=0|$a[$r+3][$c+$_],1,0;for$y(1,0){map$n.=0|$a[$r+$_][$c+$y],2,1,0}$\.=chr 0x2800+oct$n}$\.=$/}
```
[Try it online!](https://tio.run/##jZH/SsMwEMdfRcb90dKsXqoDoQv0BXyCGiSWicJsSx3iqH11462TevkxkEC43H3u1zf9bthvrK2M2n2Y/TQ@d0NSwrCtDN2Zuk1nDzQKS2i21QimRj2RnakiHaFVK3xalW@mhzZX@EVhSrvRNQHwqIUUWFIBOCZkpaPHETGDRy2KEzrBQ66al@EKP4s7xKxrDtDOTrierE1qFEjc@aBzuOc3rkX9R7sZ/L3EF/4S4fY58X5XdyLulR4f24D3Pc8fUj7PKi38pZ09K8K7E6NbK@BdbYLOjEchI7enXEQfySYOtPsHLz2eTyBjfxTlw22l05Pz6Onuv5hiOv3u@sNr177b9f0mR4l23f8A "Perl 5 – Try It Online")
Takes each row comma separated on one line.
]