[Question]
  [
## Description
The Gameboy stores tiles as 2 bit-per-pixel 8x8 images, thus 16 bytes. Every two bytes is a complete row with all of the Low-bits of each pixel in the first byte, and all of the High-bits of each pixel in the second.
## Input
Input will be exactly 16 bytes, received through [Standard IO](https://codegolf.meta.stackexchange.com/questions/2447/default-for-code-golf-input-output-methods) in one of the following forms:
* Array of bytes or strings
* 16 byte string
Per the Standard IO, these may be in a language convenient form (Deliminated string, on the stack, etc.)
## Output
An image, Rendered or Saved, of the Gameboy Tile.
Scale and Aspect Ratio of each pixel is not fixed.
Each 2 bit colour of the Pallet may be anything so long as the Manhattan Distance of the RGB256 representation is atleast 48. Eg. `#FFFFFF, #AAAAAA, #555555, #000000`. Traditionally, although not a requirement, `00` is the lightest colour, and `11` is the darkest.
## Examples
`[FF, 00, 7E, FF, 85, 81, 89, 83, 93, 85, A5, 8B, C9, 97, 7E, FF]`
[![A Pokemon Window](https://i.stack.imgur.com/xpqR1.png)](https://i.stack.imgur.com/xpqR1.png)
`[7C, 7C, 00, C6, C6, 00, 00, FE, C6, C6, 00, C6, C6, 00, 00, 00]`
[![The letter A](https://i.stack.imgur.com/tHeTg.png)](https://i.stack.imgur.com/tHeTg.png)
## Final Notes
* [Standard Loopholes](http://meta.codegolf.stackexchange.com/questions/1061/loopholes-that-are-forbidden-by-default) apply
* An online demo, and more in-depth explanation of the implementation can be found [HERE](https://www.huderlem.com/demos/gameboy2bpp.html)
* This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so fewest bytes wins! (The Gameboy only had 65536 bytes of Address Space, after all!)
* Have Fun!
  
[Answer]
# Gameboy machine code, 257 bytes
```
00000000  f0 44 fe 90 38 fa 3e e4  e0 47 21 90 81 1a 22 13  |.D..8.>..G!...".|
00000010  1a 22 13 1a 22 13 1a 22  13 1a 22 13 1a 22 13 1a  |."..".."..".."..|
00000020  22 13 1a 22 13 1a 22 13  1a 22 13 1a 22 13 1a 22  |".."..".."..".."|
00000030  13 1a 22 13 1a 22 13 1a  22 13 1a 22 18 fe 00 00  |..".."..".."....|
00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
*
000000d0  00 00 00 00 00 00 00 00  ff 00 7e ff 85 81 89 83  |..........~.....|
000000e0  93 85 a5 8b c9 97 7e ff  00 00 00 00 00 00 00 00  |......~.........|
000000f0  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
00000100  c7                                                |.|
00000101
```
Generated by this RGBASM assembly:
```
DEF rLY EQU $ff44
DEF rBGP EQU $ff47
SECTION "0",ROM0[0]
WaitVBlank:
    ldh a, [rLY]
    cp 144
    jr c, WaitVBlank
    ld a, %11100100    ; set background palette
    ldh [rBGP], a
    ld hl, $8190    ; override the tile data for the (R) icon
    REPT 15
        ld a, [de]
        ld [hli], a
        inc de
    ENDR
    ld a, [de]
    ld [hli], a
    jr @
SECTION "Input Data",ROM0[$d8]
DB $ff, $00, $7e, $ff, $85, $81, $89, $83, $93, $85, $a5, $8b, $c9, $97, $7e, $ff
SECTION "Entrypoint",ROM0[$100]
    rst 0    ; jump to reset vector 0
```
You can compile this code with rgbds: `rgbasm tile.asm -o - | rgblink - -o tile.gb`.
A gameboy ROM is usually at least 16K, so some emulators don't support this, but sameboy executes it with no problem. The entrypoint of the ROM, after the boot ROM executed is 0x100, so I don't think it can be any smaller.
As per the IO rules, [Assembly programs may read input from some specified memory location](https://codegolf.meta.stackexchange.com/a/8510), in this case `0xd8`, which is conveniently the value of the `de` register when the boot ROM exits.
[Answer]
# [J](http://jsoftware.com/), 41 bytes
```
load'viewmat'
[:viewmat 2#._2|:@|.\#:@dfh
```
[Try it online - fails because TIO can't run viewmat](https://tio.run/##NYrLCoJAAEX3fsUVF7OZBh@UzUBgRi7btkiRIWfSHgoqPUD69UmpFgfOPdyz4bbwsoUtOCHm2siC3Cv1uMmeWHrFDuK34Dss9wcRDSx1RFTo0uxihr1CLy8KsoZsW/lCo1GqJ7q@repTZ6lj2UAj95GlIKAEM/YGSRIK16UItxSTL@cj3ggfCSh48G3rqccUm7Hz8P8n5gM "J ‚Äì Try It Online")
[Working link that outputs a matrix of integers 0 thru 3](https://tio.run/##NY1BC4IwAIXv@xXPPIxgDTXKNghMyVN06NJFkVFbVqCgHgqkv74m0eGDx8fjvYcVngzLtScFpWTGqcFWgoIhgHQsOLLTIbeRz6tolMnIC18mV1PbOSHHlOOsMainhmqguk690RrU@oV@6O7NrSf6UrcwqCKUxbRL3eQHNM/dQ8AQ7xmmvFk5QodwLBnE8ud2k08ZMudF/O9T@wU "J ‚Äì Try It Online")
Takes input as an array of hex strings.
* Convert each hex string to a binary number
* Take then in rows of two, reverse and transpose and convert back decimal
* View the resulting matrix as an image
Image produced when running the function locally:
[![enter image description here](https://i.stack.imgur.com/zVB7l.png)](https://i.stack.imgur.com/zVB7l.png)
[Answer]
# [MATL](https://github.com/lmendo/MATL), 13 bytes
```
8&B1L&Y)E+1YG
```
Inputs an array of bytes, and displays an image. The image consists of grey colours where `00` corresponds to black and `11` to white.
Try it at [MATL Online](https://matl.io/?code=8%26B1L%26Y%29E%2B1YG&inputs=%5B255+++0+++126+++255+++133+++129+++137+++131+++147+++133+++165+++139+++201+++151+++126+++255%5D&version=22.7.4)!
### How it works
```
8&B    % Implicit input: 1√ó16 array. Convert to binary with 8 bits.
       % Gives a 16√ó8 array
1L     % Push [1 2 j]. As an index, this is interpreted as 1:2:end 
&Y)    % Two-ouput row indexing. This gives an 8√ó8 subarray with the
       % indicated rows, and an 8√ó8 subarray with the remaining rows
E      % Multiply by 2, element-wise
+      % Add. This gives an 8√ó8 array with possible values 0, 1, 2, 3
1YG    % Display as an image with scaled colors, using the default
       % grey colormap
```
[Answer]
# Shell + [rgbds](https://rgbds.gbdev.io/) devkit, 16 bytes
```
rgbgfx -r1 -o- -
```
Takes raw bytes from stdin and outputs a png on stdout. rgbgfx is the graphics conversion program from the RGBDS Gameboy Development Kit, intended to convert PNGs to Gameboy tile data, and vice-versa.
[Answer]
# [R](https://www.r-project.org), 65 bytes
```
\(a)image(t((b=outer(rev(a),2^(7:0),`%/%`)%%2)[!1:0,]+2*b[!0:1]))
```
[Don't attempt This Online](https://ato.pxeger.com/run?1=m72waMGiNNulpSVpuhY3HWM0EjUzcxPTUzVKNDSSbPNLS1KLNIpSy4DCOkZxGuZWBpo6Car6qgmaqqpGmtGKhlYGOrHaRlpJ0YoGVoaxmpoQgxZAKSgNAA); instead, [Try it at rdrr.io with graphical output](https://rdrr.io/snippets/embed/?code=f%3D%0Afunction(a)image(t((b%3Douter(rev(a)%2C2%5E(7%3A0)%2C%60%25%2F%25%60)%25%252)%5B!1%3A0%2C%5D%2B2*b%5B!0%3A1%5D))%0A%0A%0Ab%3Dc(124%2C%20124%2C%20%20%200%2C%20198%2C%20198%2C%20%20%200%2C%20%20%200%2C%20254%2C%20198%2C%20198%2C%20%20%200%2C%20198%2C%20198%2C%20%20%200%2C%20%20%200%2C%20%20%200)%0Af(b)%0Ab%3Dc(255%2C%20%20%200%2C%20126%2C%20255%2C%20133%2C%20129%2C%20137%2C%20131%2C%20147%2C%20133%2C%20165%2C%20139%2C%20201%2C%20151%2C%20126%2C%20255)%0Af(b)%0A) (uses `function` instead of `\` due to older version of R installed at rdrr.io).
Note that this could be 7 bytes shorter by omitting the `image()` call and outputting a [matrix of bytes](https://codegolf.meta.stackexchange.com/a/9100/95126), but R has good graphical output so it seems more in the spirit of the challenge to actually draw the image.
[Answer]
# [QBasic](https://en.wikipedia.org/wiki/QBasic), ~~100~~ 96 bytes
```
SCREEN 7
FOR r=0TO 7
INPUT a
INPUT b
FOR c=0TO 7
PSET(7-c,r),a\2^c MOD 2+(1AND b\2^c)*3
NEXT c,r
```
You can try it on [Archive.org](https://archive.org/details/msdos_qbasic_megapack). Input the bytes one at a time as decimal integers (0 to 255). The image is displayed in the upper left corner of the screen, overwriting the `?` prompt from the first `INPUT` statement. Each "pixel" is 2x2. The colors are:
* Black: rgb(0,0,0)
* Blue: rgb(0,0,170)
* Cyan: rgb(0,170,170)
* Red: rgb(170,0,0)
[![Example run of the golfed code](https://i.stack.imgur.com/NECdb.png)](https://i.stack.imgur.com/NECdb.png)
### Ungolfed
With a less golfy formula for computing the color code, and drawing each pixel as a filled box rather than a single point, it turns out we can reproduce the grayscale images in the OP exactly.
```
SCREEN 7
' Each point in screen mode 7 is 2x2 pixels, so we draw 15x15 boxes to match
' the 30x30 pixel boxes in OP's image
size = 15
FOR row = 0 TO 7
  INPUT lowbits
  INPUT highbits
  FOR col = 0 TO 7
    place = 2 ^ (7 - col)
    lowbit = (lowbits \ place) AND 1
    highbit = (highbits \ place) AND 1
    ' 00 = color 15, white
    ' 01 = color 7, light gray
    ' 10 = color 8, dark gray
    ' 00 = color 0, black
    colorcode = 15 - lowbit * 8 - highbit * 7
    ' Compute top and left coordinates of the box based on row and column
    ' (with the left shifted over to avoid drawing over the inputs)
    top = row * size
    left = 60 + col * size
    ' Draw the box using the LINE command with the BF (box filled) option
    LINE (left, top)-(left + size - 1, top + size - 1), colorcode, BF
  NEXT col
NEXT row
```
[![Example run of the ungolfed code](https://i.stack.imgur.com/EWYih.png)](https://i.stack.imgur.com/EWYih.png)
[Answer]
# [Japt](https://github.com/ETHproductions/japt) [`-R`](https://codegolf.meta.stackexchange.com/a/14339/), ~~17 25~~ 23 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
```
m¬§√πT8 √≤ ¬Æy√ç¬∏√Éi"P2 8 8 3
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&flags=LVI&header=cSIsICIgbW5H&code=baT5VDgg8iCuec24w2kiUDIgOCA4IDM&input=IjdDLCA3QywgMDAsIEM2LCBDNiwgMDAsIDAwLCBGRSwgQzYsIEM2LCAwMCwgQzYsIEM2LCAwMCwgMDAsIDAwIgotUg)
Saved two bytes thanks to Shaggy
Previously, this answer outputted a string using differently shaded unicode characters to represent the different colors, but as OP has clarified that this is not allowed, it now outputs a [Plain PGM](https://netpbm.sourceforge.net/doc/pgm.html#plainpgm) file.
Takes input as byte array and outputs a string representing a PGM file.
```
m¬§√πT8 √≤ ¬Æy√ç¬∏√Éi"P2 8 8 3  : implicit input of byte array
m¬§                       : convert each byte to binary
  √πT8                    : left-pad each binary string with 0s
      √≤ ¬Æ                : map each pair of lines to:
         y√ç              :   transpose the pair, map each two-char string to a number
           ¬∏             :   join by spaces
            √É            : end map
             i"P2 8 8 3  : prepend the start of a PGM file
                         : -R join by newlines
```
[![enter image description here](https://i.stack.imgur.com/S8kV4.png)](https://i.stack.imgur.com/S8kV4.png)
## [Japt](https://github.com/ETHproductions/japt) [`-R`](https://codegolf.meta.stackexchange.com/a/14339/), 11 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
Outputs a [matrix of bytes](https://codegolf.meta.stackexchange.com/a/9100/58563).
```
m¬§√πT8 √≤ ¬Æy√ç
```
[Answer]
# JavaScript (ES6), 79 bytes
Expects a list of bytes and outputs [a matrix of RGB tuples](https://codegolf.meta.stackexchange.com/a/9104/58563), using the greenish palette `00C000`, `008000`, `004000`, `000000`.
```
a=>(v=[...'01234567']).map(y=>v.map(x=>[0,~a[y*2]<<x>>1&64|~a[y-~y]<<x&128,0]))
```
[Try it online!](https://tio.run/##dY9fC4IwFMXf@xQ95Qxdc@Y/cEKJfomxh2EahTnJEIXwq1vbHgyqlx/3nnO4h3vlPe@K@6V92I04lXNFZk4S0BMKITSQg9295wcGM@GNt2AkSa@GgSQUWWDidNxiFsfDxsHhU672NLItlgr2fHOHLcRMcy5E04m6hLU4gwpQNOS5tUYDQpJBJqmV0FN0FCNFVzJyF/egM0fJVGWi4PPOu3D1VRikKpIutam/UCuaefbb/ZdH6sMX "JavaScript (Node.js) ‚Äì Try It Online")
## 73 bytes
Outputs [a matrix of bytes](https://codegolf.meta.stackexchange.com/a/9100/58563).
```
a=>(v=[...'01234567']).map(y=>v.map(x=>~a[y*2]<<x>>1&64|~a[y-~y]<<x&128))
```
[Try it online!](https://tio.run/##dc3dCoIwHAXw@56iK90ix/ycghuU6EuIF8M0ClPJkAnhq682Lwyqmx/j/A87Vz7yobxf@ofVdqdK1lRyysBIc4SQiW3H9fyAmAVEN96DibJRPwRlM8@nnVPEsWDMNgLvqQJrnlRi2E4IoSy7duiaCjXdGdQgxyLL9lssMFaSVLkkoa@1tZHWVUbuej0snaMy0Z2IfP5TQLj5GiSJriTrbBKsLslilv6@/utj/B6ULw "JavaScript (Node.js) ‚Äì Try It Online")
## Rendering
```
f=
a=>(v=[...'01234567']).map(y=>v.map(x=>[0,~a[y*2]<<x>>1&64|~a[y-~y]<<x&128,0]))
F = (id, a) => { m = f(a); m.forEach(r => r.forEach(rgb => { div = document.createElement('div'); div.style.backgroundColor = '#' + rgb.map(v => v.toString(16).padStart(2, '0')).join(''); document.getElementById(id).appendChild(div); })) }
F('b0', [0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0xFF])
F('b1', [0xFF, 0x00, 0x7E, 0xFF, 0x85, 0x81, 0x89, 0x83, 0x93, 0x85, 0xA5, 0x8B, 0xC9, 0x97, 0x7E, 0xFF])
F('b2', [0x7C, 0x7C, 0x00, 0xC6, 0xC6, 0x00, 0x00, 0xFE, 0xC6, 0xC6, 0x00, 0xC6, 0xC6, 0x00, 0x00, 0x00])
F('b3', [0xFF, 0xFF, 0xFF, 0x81, 0xC3, 0x81, 0xDF, 0x85, 0xDF, 0x85, 0xFF, 0xBD, 0xFF, 0x81, 0xFF, 0xFF])
```
```
.box { float:left; margin-right:16px; width:128px; height:128px; } .box div { float:left; width:16px; height:16px; }
```
```
<div id="b0" class="box"></div><div id="b1" class="box"></div><div id="b2" class="box"></div><div id="b3" class="box"></div>
```
[Answer]
# C, ~~108~~ ~~105~~ ~~95~~ ~~93~~ ~~89~~ 85 bytes
```
b;main(j){for(puts("P5 8 8 3");j=j-1?:read(0,&b,2)*4;b+=b)putchar(3^b>>14&2^b>>7&1);}
```
[Try it online!](https://tio.run/##hY7dasJAEIXvfYpDLsKuunZjbJO4/qAhuW2fQNjdqGmgjcQIAeuzx1ks2LsyZ9gzh@HbKfS57K1usVhk7zl@YC1ER13jaFqI3qgv/fnNKn491A07Xdoz8z5eEVOFHlfVshLBet7sdcHk2DfjKR/OlBktDaddW@qGhTuzWgUzf@reyA@4uvX012Cwt2UNL88hJaIMZGICB4gTxCGS0I0bSrZIEyTRY8ejG7uugGggTuQnL@7OR6bgkL/cKAWJ0OmbExlSnj3Hv7mU/3P7Ow "Dash ‚Äì Try It Online")
Reads raw bytes from `stdin` and outputs an image in the [PGM format](https://netpbm.sourceforge.net/doc/pgm.html#format) to `stdout`.
-17! thanks to @c--
[Answer]
# [K (ngn/k)](https://codeberg.org/ngn/k), 44 bytes
```
`0:"P2 8 8 3"
2/+,/+'0N 2#-8#'+(8#0),2\.0:`
```
Takes input as a space separated list of integers. Outputs a plain pgm to stdout.
Colors are inverted from the example.
[Answer]
# [Nibbles](http://golfscript.com/nibbles/index.html), 20.5 bytes (41 nibbles)
```
"P2 8 8 3 ".`/~.$``@hex:1$>>/$!@@~++
```
Input is an array of hex strings; output is a [plain PGM](https://netpbm.sourceforge.net/doc/pgm.html) image file (inspired by [pan's answer](https://codegolf.stackexchange.com/a/257943/95126)).
```
"P2 8 8 3 "                 # prepend the string "P2 8 8 3 " onto:
    .                       # map over
     $                      # the input:
            :1$             #   prepend a '1'
         hex                #   then get the hex value
      ``@                   #   convert to bits
 `/                         # get chunks of 2
.                           # and map over these:
                 /$         #   fold across each chunk of 2
                   !@@      #   zipping-together the 2 elements
                      ~+    #   by adding together
                        +   #     the first elements added to themselves
                            #     and the second elements
               >>           #   and remove the first element     
```
[![enter image description here](https://i.stack.imgur.com/U2xx9.png)](https://i.stack.imgur.com/U2xx9.png)
[![enter image description here](https://i.stack.imgur.com/89xaf.png)](https://i.stack.imgur.com/89xaf.png)
---
Note that if output as a [matrix of bytes](https://codegolf.meta.stackexchange.com/a/9100/95126) would be valid, we could drop the initial `"P2 8 8 3 "` header for the plain PGM format, for just 13 bytes.
[Answer]
# JavaScript, 105 bytes
```
v=>{for(i=0;i<8;++i)for(j=0;j<8;++j)window['c'+i+(7-j)].className='wldb'[2*(b=n=>v[2*i+n]>>j&1)(0)+b(1)]}
```
Try it:
```
f=v=>{for(i=0;i<8;++i)for(j=0;j<8;++j)window['c'+i+(7-j)].className='wldb'[2*(b=n=>v[2*i+n]>>j&1)(0)+b(1)]}
button.addEventListener('click', _=>f(input.value.split` `.map(x=>+('0x'+x))));
```
```
.f {
  border: 1px solid black;
  width: fit-content;
}
.r {
  display: flex;
}
[id^="c"] {
  width: 40px;
  height: 40px;
  background-color: lightblue;
}
input {
  width: 320px;
}
.w {
  background-color: #fff;
}
.l {
  background-color: #555;
}
.d {
  background-color: #aaa;
}
.b {
  background-color: #000;
}
```
```
<input id="input" value="7C 7C 00 C6 C6 00 00 FE C6 C6 00 C6 C6 00 00 00">
<button id='button'>Draw</button>
<br><br>
<div class="f">
<div class="r">
  <div id="c00"></div><div id="c01"></div><div id="c02"></div><div id="c03"></div><div id="c04"></div><div id="c05"></div><div id="c06"></div><div id="c07"></div>
</div>
<div class="r">
  <div id="c10"></div><div id="c11"></div><div id="c12"></div><div id="c13"></div><div id="c14"></div><div id="c15"></div><div id="c16"></div><div id="c17"></div>
</div>
<div class="r">
  <div id="c20"></div><div id="c21"></div><div id="c22"></div><div id="c23"></div><div id="c24"></div><div id="c25"></div><div id="c26"></div><div id="c27"></div>
</div>
<div class="r">
  <div id="c30"></div><div id="c31"></div><div id="c32"></div><div id="c33"></div><div id="c34"></div><div id="c35"></div><div id="c36"></div><div id="c37"></div>
</div>
<div class="r">
  <div id="c40"></div><div id="c41"></div><div id="c42"></div><div id="c43"></div><div id="c44"></div><div id="c45"></div><div id="c46"></div><div id="c47"></div>
</div>
<div class="r">
  <div id="c50"></div><div id="c51"></div><div id="c52"></div><div id="c53"></div><div id="c54"></div><div id="c55"></div><div id="c56"></div><div id="c57"></div>
</div>
<div class="r">
  <div id="c60"></div><div id="c61"></div><div id="c62"></div><div id="c63"></div><div id="c64"></div><div id="c65"></div><div id="c66"></div><div id="c67"></div>
</div>
<div class="r">
  <div id="c70"></div><div id="c71"></div><div id="c72"></div><div id="c73"></div><div id="c74"></div><div id="c75"></div><div id="c76"></div><div id="c77"></div>
</div>
</div>
```
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 36 bytes
```
Ôº•Ôº•‚Å∏‚ÆåÔº•¬≤‚Ü®‚ÜßÔº≥¬π‚Å∂‚Æå‚≠Ü‚Å∏¬ß‚ñë‚ñí‚ñì‚ñà‚Ü®¬≤Ôπ™√∑ŒπÔº∏¬≤Œª¬≤
```
[Try it online!](https://tio.run/##TY3BCoIwGIBfZXiasMCUUOmkleBBkDyKh6GjBkNlTfMRulbgA/oia5tE/bDv8O/j@@sr5nWHmZQ5p62AGe5h0TMqYNr2g4A2Aq56ZzISfiOwEMq6aClAIBJp25AJWsv8XObXMr@X@WEhEGNlughkXTOwToXEkY60IfBboaqYd3fCtcVsc2OdvZRl6UxJgoAzOY6mf9JcN8HOcGsYGnqaoff7jVYn1jwYJ/T/O1UlNyP7AA "Charcoal ‚Äì Try It Online") Link is to verbose version of code. Now uses @Arnauld's output characters. Explanation:
```
  ‚Å∏                             Literal integer `8`
 Ôº•                              Map over implicit range
     ¬≤                          Literal integer `2`
    Ôº•                           Map over implicit range
        Ôº≥                       Next input hex digit pair
       ‚Üß                        Lowercased
      ‚Ü®  ¬π‚Å∂                     Converted from base `16`
   ‚Æå                            Reversed
Ôº•                               Map over each pair of hex values
             ‚Å∏                  Literal integer `8`
            ‚≠Ü                   Map over implicit range and join
               ‚ñë‚ñí‚ñì‚ñà             Literal string
              ¬ß                 Indexed by
                       Œπ        Current pair
                      √∑         Vectorised divided by
                         ¬≤      Literal integer `2`
                        Ôº∏       Raised to power
                          Œª     Current value
                     Ôπ™     ¬≤    Vectorised modulo `2`
                   ‚Ü®¬≤           Converted from base `2`
           ‚Æå                    Reversed
                                Implicitly print
```
Note that the deverbosifier on TIO erroneously uselessly quotes the special characters inside `‚Äùy` and `‚Äù`; this is not actually necessary for correct operation of the program.
32 bytes by taking the input bytes with `0x` prefix using the newer version of Charcoal on ATO:
```
Ôº•Ôº•‚Å∏‚ÆåÔº•¬≤ÔºÆ‚Æå‚≠Ü‚Å∏¬ß‚ñë‚ñí‚ñì‚ñà‚Ü®¬≤Ôπ™√∑ŒπÔº∏¬≤Œª¬≤
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m70iOSOxKDk_MWfBgqWlJWm6FjcnBRRl5pVo-CYWgLGFjkJQallqUXEqmGuko-CZV1Ba4leam5RapKEJBAgFwSVArelQXY4lnnkpqRUaSo-mTXw0bdKjaZMfTetQ0lFwSgSqBBrjm59SmpOv4ZlX4pJZlpmSqpGpoxCQXw40FCiZAzLWSBMCrJcUJyUXQ923PFpJtyxHKfamv0GFm5uCQYWBAZAwd1WAci1MQYQhiLAEEcZAwtIYJuEIlnUCEs4gWUtzhF6I8QA "Charcoal ‚Äì Attempt This Online") Link is to verbose version of code.
[Answer]
# [C (GCC)](https://gcc.gnu.org), ~~110~~ ~~109~~ 93 bytes
*-16 bytes thanks to [@c--](https://codegolf.stackexchange.com/users/112488/c)*
```
m;main(h){for(;m=m/2?:read(!puts(""),&h,2)*64;)printf("[%dm [m",(h&m?39:99)+(h>>8&m?1:8));}
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m700OT49OXnBgqWlJWm6Fjdjc61zEzPzNDI0q9PyizSsc21z9Y3srYpSE1M0FAtKS4o1lJQ0ddQydIw0tcxMrDULijLzStI0lKSjVVNyFaSjc5V0NDLUcu2NLa0sLTW1NTLs7CyAXEMrC01N61qIJVC7FtzU0S930tY3CXfKjPQPyUgM96mMStHWN66wcPRNcnd0dNGuKI50BGEgsIVoAgA)
Takes the input as a binary array from `stdin`, outputs spaces with different ANSI-colored background.
If the input is longer than 16 bytes, it continues displaying 8-pixel rows (which is incidentally useful for testing).
[Answer]
# [Befunge-with-graphics](https://github.com/Jachdich/befunge-with-graphics), 149 bytes
Takes raw bytes from stdin and creates a window which displays the result.
```
99*:sfcu88803v
v_v#!:-1\~<+p<
$ >       ^
>802p>:2%\2/\01p\:2%\2/\01g2*+3\-89+5v
$    ^$p20_v#:-1g20-1g30\xg30g20f::**<
^$p30_v#:$ <
v-1z<u<
>  #^_@
```
Test case:  
[![Output image](https://i.stack.imgur.com/psx42.png)](https://i.stack.imgur.com/psx42.png)
[Answer]
# SAS
# 136 - ascii art in Log
This solution uses the idea from Charcoal language with help of special characters: `" ‚ñë‚ñí‚ñì"` of "gradient dots", it is 11 bytes, the firs symbol is a space.
The Code:
```
data;input(a b)(:hex2.)@@;do x=1to 8;c=ksubstr(" ‚ñë‚ñí‚ñì",1+2*char(put(a,binary8.),x)+char(put(b,binary8.),x),1);put c+(-1)@;end;put;cards;;
```
Input goes between last two semicolons as a string e.g., `FF 00 7E FF 85 81 89 83 93 85 A5 8B C9 97 7E FF`
It allows to use multiple strings at once, so if there are any other test cases I gladly add then to display.
In human readable form it looks like:
```
data;
  input (a b) (:hex2.) @@;
  do x = 1 to 8;
    c = ksubstr(" ‚ñë‚ñí‚ñì"
               ,1 + 2*char(put(a, binary8.), x) + char(put(b, binary8.), x)
               ,1);
    put c +(-1) @;
  end;
  put;
cards;
FF 00 7E FF 85 81 89 83 93 85 A5 8B C9 97 7E FF
7C 7C 00 C6 C6 00 00 FE C6 C6 00 C6 C6 00 00 00
;
```
In the log you will see:
```
‚ñí‚ñí‚ñí‚ñí‚ñí‚ñí‚ñí‚ñí
‚ñë‚ñì‚ñì‚ñì‚ñì‚ñì‚ñì‚ñë
‚ñì    ‚ñí ‚ñì
‚ñì   ‚ñí ‚ñë‚ñì
‚ñì  ‚ñí ‚ñë‚ñí‚ñì
‚ñì ‚ñí ‚ñë‚ñí‚ñë‚ñì
‚ñì‚ñí ‚ñë‚ñí‚ñë‚ñë‚ñì
‚ñë‚ñì‚ñì‚ñì‚ñì‚ñì‚ñì‚ñë
 ‚ñì‚ñì‚ñì‚ñì‚ñì  
‚ñë‚ñë   ‚ñë‚ñë 
‚ñí‚ñí   ‚ñí‚ñí 
‚ñë‚ñë‚ñë‚ñë‚ñë‚ñë‚ñë 
‚ñì‚ñì   ‚ñì‚ñì 
‚ñë‚ñë   ‚ñë‚ñë 
‚ñí‚ñí   ‚ñí‚ñí 
        
```
# 180 = 113+67 - heatmap
Since SAS at its origin stand for Statistical Analysis System let's use "three dimensional" histogram i.e. [HeatMap](https://en.wikipedia.org/wiki/Heat_map)
The code
* part 1)
```
data;input(a b)(:hex2.)@@;y+(-1);do x=1to 8;c=2*char(put(a,binary8.),x)+char(put(b,binary8.),x);output;end;cards;
```
* part 2)
```
;proc sgplot;heatmap x=x y=y/colorresponse=c nxbins=8 nybins=8;run;
```
Input goes between past 1) and 2) as a string e.g., `FF 00 7E FF 85 81 89 83 93 85 A5 8B C9 97 7E FF`
Human readable form looks like:
```
data;
  input (a b) (:hex2.) @@;
  y + (-1);
  do x = 1 to 8;
    c = 2*char(put(a, binary8.), x) + char(put(b, binary8.), x);
    output;
  end;
cards;
FF 00 7E FF 85 81 89 83 93 85 A5 8B C9 97 7E FF
;
proc sgplot;
  heatmap x=x y=y / 
    colorresponse=c nxbins=8 nybins=8
  ;
run;
```
The `sgplot` procedure uses its default setup and the output looks like:
[![enter image description here](https://i.stack.imgur.com/pm7GD.png)](https://i.stack.imgur.com/pm7GD.png)
Wit some "polishing"
```
proc sgplot noautolegend;
  heatmap x=x y=y / 
    colorresponse=c nxbins=8 nybins=8 
    colormodel=(lightgrey black);
  xaxis display=none;
  yaxis display=none;
run;
```
the output looks like:
[![enter image description here](https://i.stack.imgur.com/LzQEC.png)](https://i.stack.imgur.com/LzQEC.png)
and
[![enter image description here](https://i.stack.imgur.com/jUVwO.png)](https://i.stack.imgur.com/jUVwO.png)
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), ~~26~~ 21 bytes
```
b·πÖv·πÖ2·∫áv‚à©vvB883f‚ÄõP2pp‚Åã
```
[Try it Online!](https://vyxal.pythonanywhere.com/?v=2#WyIiLCLijIhIIiwiYuG5hXbhuYUy4bqHduKIqXZ2Qjg4M2bigJtQMnBw4oGLIiwiIiwiN0MgN0MgMDAgQzYgQzYgMDAgMDAgRkUgQzYgQzYgMDAgQzYgQzYgMDAgMDAgMDAiXQ==)
Uses roughly the same method as my Japt answer. I have tried a lot of different things but I can't find a 20-byter. With Vyncode this is 17 bytes but I'm not the biggest fan of that.
Takes input as a list of bytes, outputs a Plain PGM file.
Explanation:
```
b·πÖv·πÖ2·∫áv‚à©vvB883f‚ÄõP2pp‚Åã¬≠‚Å°‚Äã‚Äé‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å°‚Å™‚Äè‚Äè‚Äã‚Å°‚Å†‚Å°‚Äå‚Å¢‚Äã‚Äé‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å¢‚Å™‚Äè‚Å†‚Å™‚Å™‚Å†‚Å™‚Å™‚Äè‚Äã‚Å°‚Å†‚Å°‚Äå‚Å£‚Äã‚Äé‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å£‚Å™‚Äè‚Å†‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å§‚Å™‚Äè‚Äè‚Äã‚Å°‚Å†‚Å°‚Äå‚Å§‚Äã‚Äé‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å¢‚Å°‚Å™‚Äè‚Å†‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å¢‚Å¢‚Å™‚Äè‚Äè‚Äã‚Å°‚Å†‚Å°‚Äå‚Å¢‚Å°‚Äã‚Äé‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å¢‚Å£‚Å™‚Äè‚Å†‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å¢‚Å§‚Å™‚Äè‚Äè‚Äã‚Å°‚Å†‚Å°‚Äå‚Å¢‚Å¢‚Äã‚Äé‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å£‚Å°‚Å™‚Äè‚Å†‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å£‚Å¢‚Å™‚Äè‚Å†‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å£‚Å£‚Å™‚Äè‚Äè‚Äã‚Å°‚Å†‚Å°‚Äå‚Å¢‚Å£‚Äã‚Äé‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å£‚Å§‚Å™‚Äè‚Å†‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å§‚Å°‚Å™‚Äè‚Å†‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å§‚Å¢‚Å™‚Äè‚Å†‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å§‚Å£‚Å™‚Äè‚Äè‚Äã‚Å°‚Å†‚Å°‚Äå‚Å¢‚Å§‚Äã‚Äé‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å§‚Å§‚Å™‚Äè‚Å†‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å¢‚Å°‚Å°‚Å™‚Äè‚Å†‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å¢‚Å°‚Å¢‚Å™‚Äè‚Äè‚Äã‚Å°‚Å†‚Å°‚Äå‚Å£‚Å°‚Äã‚Äé‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å¢‚Å°‚Å£‚Å™‚Äè‚Äè‚Äã‚Å°‚Å†‚Å°‚Äå‚Å£‚Å¢‚Äã‚Äé‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å¢‚Å°‚Å§‚Å™‚Äè‚Å†‚Å™‚Å™‚Äè‚Äã‚Å°‚Å†‚Å°‚Äå‚Å£‚Å£‚Äã‚Äé‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å¢‚Å¢‚Å°‚Å™‚Äè‚Äè‚Äã‚Å°‚Å†‚Å°‚Äå¬≠
b                      # ‚Äé‚Å°Convert to list of binary digits
 ·πÖ                     # ‚Äé‚Å¢join each to a string
  v·πÖ                   # ‚Äé‚Å£pad each binary string to length 8 with zeroes
    2·∫á                 # ‚Äé‚Å§chunks of length 2
      v‚à©               # ‚Äé‚Å¢‚Å°transpose each pair to a list of two-bit binary strings
        vvB            # ‚Äé‚Å¢‚Å¢convert each from binary
           883f        # ‚Äé‚Å¢‚Å£digits of 883
               ‚ÄõP2     # ‚Äé‚Å¢‚Å§string literal ‚ÄúP2‚Äù
                  p    # ‚Äé‚Å£‚Å°prepend this to digit list
                   p   # ‚Äé‚Å£‚Å¢prepend this header to the matrix
                    ‚Åã  # ‚Äé‚Å£‚Å£join each item on spaces and then join the items on newlines
üíé
```
Created with the help of [Luminespire](https://vyxal.github.io/Luminespire).
[Answer]
# [Go](https://go.dev), ~~304~~ 302 bytes
```
import(."image";c"image/color";d"image/draw";p"image/png";."os")
func f(s[]byte){N,S,R,D,P:=NewUniform,d.Src,Rect,d.Draw,Point{0,0}
T:=NewGray(R(0,0,8,8))
for i:=0;i<8;i++{for l,h,j:=s[2*i],s[2*i+1],0;j<8;j++{D(T,R(j,i,j+1,i+1),N(c.Gray{255-85*(h&128>>6+l&128>>7)}),P,S)
h*=2
l*=2}}
p.Encode(Stdout,T)}
```
[Attempt This Online!](https://ato.pxeger.com/run?1=TZDPboJAEMbTK09BODS7MtIFQ0UpJm3V3owBezIe6AK6FFiCmGoIT9KLadJbX6h9mi5g0l5-8-_Ll5l5_9jy81fu01d_G8qpz7LPQxn1rZ8rjaU5L0qkKSwVM8WmXXJDecILxQ4uZVD4b4qdX6o82yq2pvC9gqXokFE5Qvv15uVUhrhagAcuTGE5dhbh23PGIl6kEGheQcENaSnSqTCDJWdZWREgtbRqpU-Ff0IuEh2wwMLCmRcyGzvEZneWzVS1ahoJ7CAeO_u10WMbaIOqb4DYsRDFQjRFK3BRDAxiVQcxxLBAVGvcK8M0-5bZQ7tr3bAmk1s16ZIhrjEswcPSrucYUiJQ11KuzTLKgxB5ZcAPJaxw3b3t-9Qe3fwRYbmSItQdX5HjfA4yORLScDhr2HUss6XectRy0HA0-Jved5qHho-tZjT871Nj6bLA-dzFXw)
Prints the bytes of a PNG to STDOUT.
* -2 bytes by @The Thonnu
### Slightly-Ungolfed Explanation
```
import(."image";c"image/color";d"image/draw";p"image/png";."os")
func f(s[]byte){
N,S,R,D,P:=NewUniform,d.Src,Rect,d.Draw,Point{0,0}
                                      // various variables
T:=NewGray(R(0,0,8,8))                // new 8-bit grayscale, 8x8px
for i:=0;i<8;i++{                     // for each row...
l,h:=s[2*i],s[2*i+1]                  // get the bytes for that row
for j:=0;j<8;j++{                     // for each pixel...
C:=c.Gray{255-85*(h&128>>6+l&128>>7)} // calculate the color.
                                      // yields an inverted color, so `255-x` is needed.
D(T,R(j,i,j+1,i+1),N(C),P,S)          // draw the pixel to the tile
h<<=1;l<<=1}}                         // shift the bytes left to get the next pixel.
p.Encode(Stdout,T)}                   // print the PNG to STDOUT
```
[Answer]
# [Thunno](https://github.com/Thunno/Thunno) `N`, \$ 30 \log\_{256}(96) \approx \$ 24.69 bytes
```
b8zK2ApeZt.JBA_sjE"P2 8 8 3"ZN
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m72sJKM0Ly9_abSSn1LsciUdBaWoTI-lpSVpuhb7kiyqvI0cC1KjSvS8nBzji7NclQKMFCyA0Fgpyg-iaAGUuumgZO6sowDCBgY6Cs5mEAxig7CbK6oYuryBgRLEIAA)
Port of ~~Jacob~~ *noodle man*'s Japt answer.
*-3 characters thanks to noodle man*
#### Explanation
```
b           # Convert each number in the (implicit) input list to binary
 8zK        # Fill each with zeros to length 8
    2Ap     # Split the list into pairs
       e    # Map over this list of pairs:
        Zt  #  Transpose the pair
.J          #  And join each inner list into a string
  B         #  Convert each string from binary
   A_sj     #  And join this list of strings by spaces
       E    # (End map)
"..."ZN     # Prepend the string "P2 8 8 3"
            # Implicit output, joined on newlines
```
[Answer]
# Python, ~~526 524 483 471 470 454~~ 447 bytes
I'm a `turtle` veteran. For fast results, use `speed(0)`. Uses the given pallet.
```
def g(l,x=range(8)):
 r=[int(i,16)for i in l];j=[[r[i+1],r[i]]for i in range(0,16,2)]
 for i in x:j[i]=["".join([bin(j[i][0])[2:].zfill(8).replace(" ","0")[k],bin(j[i][1])[2:].zfill(8).replace(" ","0")[k]])for k in x]
 for i in x:
  for l in x:j[i][l]=int(j[i][l],2);j[i][l]="#"+"FA50"[j[i][l]]*6
 for i in j:
  for k in i:seth(0);color(k);begin_fill();exec('fd(9);rt(90);'*4);end_fill();fd(9)
  pu();goto(0,ycor()-9);pd();ht()
from turtle import*
```
Test case 1:  
[![enter image description here](https://i.stack.imgur.com/HrsZa.png)](https://i.stack.imgur.com/HrsZa.png)
Test case 2:  
[![enter image description here](https://i.stack.imgur.com/QcMMA.png)](https://i.stack.imgur.com/QcMMA.png)
[Answer]
## Clojure, 316 bytes
```
(fn[i](doto(Frame.)(.add(proxy[Panel][](paint[g](dotimes[r 8](dotimes[c 8](.setColor g(((mapv(fn[[l h]](mapv #(Color.({0 0xFFFFFF 1 0xAAAAAA 2 5592405 3 0}(Long/parseLong(str % %2)2)))h l))(partition 2(map #(clojure.pprint/cl-format nil "~8,'0b"%)i)))r)c))(.fillRect g(* c 9)(* r 9)9 9)))))).pack(.setVisible true)))
```
Inputs:
1. `[0xFF, 0x00, 0x7E, 0xFF, 0x85, 0x81, 0x89, 0x83, 0x93, 0x85, 0xA5, 0x8B, 0xC9, 0x97, 0x7E, 0xFF]`
2. `[0x7C, 0x7C, 0x00, 0xC6, 0xC6, 0x00, 0x00, 0xFE, 0xC6, 0xC6, 0x00, 0xC6, 0xC6, 0x00, 0x00, 0x00]`
Outputs:
[![enter image description here](https://i.stack.imgur.com/SEUlr.png)](https://i.stack.imgur.com/SEUlr.png)
[Answer]
# Postscript 245 168
Images in Postscript can have 2 bits per pixel, or, more specifically, 2 bits per color component and 1 component (e.g. Grayscale) per sample. However, interpreter expects bytes in data source to constitute a continuous bit stream, not low bits here, high bits there. We'll have to zip bits from each two bytes:
```
currentpagedevice /PageSize get aload pop scale
<FF 00 7E FF 85 81 89 83 93 85 A5 8B C9 97 7E FF>
% 16 byte string on stack here
{not} forall                % 16 bytes
8 8 2 [8 0 0 8 0 0]
{                           % consume by pairs (a, b)
    0                       % accumulator (x)
    0 1 7 {                 % a b x s
        dup dup             % a b x s s s
        1 exch bitshift     % a b x s s m
        dup 5 index and     % a b x s s m bm
        4 1 roll            % a b x bm s s m
            6 index and     % a b x bm s s am
        exch bitshift       % a b x bm s ax
        3 1 roll            % a b x ax bm s
        1 add bitshift      % a b x ax bx
        or or               % a b x
    } for
    3 1 roll pop pop        % x
    dup  256 idiv
    exch 255 and            % 2 bytes
    2 string dup 0 5 -1 roll put
             dup 1 4 -1 roll put
}
image
```
I'll use "16 byte string already on stack" for simplicity as allowed in the OP, though it could have been read from file (e.g. STDIN) or command line. I think it's OK for program size byte count to begin after 1st comment, and then stripped of insignificant whitespace it would be:
```
{not}forall 8 8 2[8 0 0 8 0 0]{0 0 1 7{dup dup 1 exch bitshift dup 5 index and 4 1 roll 6 index and exch bitshift 3 1 roll 1 add bitshift or or}for 3 1 roll pop pop dup 256 idiv exch 255 and 2 string dup 0 5 -1 roll put dup 1 4 -1 roll put}image
```
The very 1st line was not included in count as it just serves to produce more "pleasing" output. Command (`gs` in Linux)
```
gswin64c -q -g200x200 source.ps
```
(again, image size on command line is only for better looking square tile, instead of scaled non-proportionately to A4 (or Letter) default page).
[![enter image description here](https://i.stack.imgur.com/0DwnI.png)](https://i.stack.imgur.com/0DwnI.png)
For golfing purposes, long repeatedly used operators could be re-defined as short-named procedures, or entire source compactly written as binary tokens, though result would be not very readable. I have better idea: to produce the same output, let's draw not one 2 ppx image, but **three** 1 ppx image masks to paint with 0.33, 0.66 and 1.0 ink, respectively. Then, e.g., if a bit is set in low-bits byte and I paint this pixel with light-gray, it won't interfere with painting later in dark-gray and/or black (if bit is set in high-bits byte).
```
currentpagedevice /PageSize get aload pop scale
<FF 00 7E FF 85 81 89 83 93 85 A5 8B C9 97 7E FF>
% 16 byte string on stack here
{} forall
16 -1 9 { 
    dup index
    exch 1 sub index 
    and
} for
23 -1 16 { 
    -1 roll 
} for
24 -8 roll 
2 -1 0 {
    3 div setgray
    8 8 true [8 0 0 8 0 0]
    { 1 string dup 0 4 -1 roll put }
    imagemask
} for
```
I.e.:
```
{}forall 16 -1 9{dup index exch 1 sub index and}for 23 -1 16{-1 roll}for 24 -8 roll 2 -1 0{3 div setgray 8 8 true[8 0 0 8 0 0]{1 string dup 0 4 3 roll put}imagemask}for
```
There is bytes moving around stack instead of bits juggling, which is significantly less cumbersome, and shorter.
[Answer]
# [Ruby](https://www.ruby-lang.org/), 101 bytes
Returns the lines of a PGM file. I'm sure that `each_slice` could be golfed out but I don't feel like it. Could be a byte shorter by removing the splat before `a.map` but I don't like returning a ragged array.
```
->a{["P2 8 8 3",*a.map{("%08b"%_1).chars}.each_slice(2).map{_1.transpose.map{|x|x.join.to_i 2}*" "}]}
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m72kqDSpcsEiN9ulpSVpuhY3U3XtEqujlQKMFCyA0FhJRytRLzexoFpDSdXAIklJNd5QUy85I7GouFYvNTE5I744JzM5VcNIE6wo3lCvpCgxr7ggvzgVLFBTUVOhl5WfmadXkh-fqWBUq6WkoFQbWwu1LKOgtKRYwS062qDCzU1HwaDCwABEmruCSIiIhSmYNASTlmDSGERaGiNkHSFqnECkM1iNpTmyObGxEPsWLIDQAA)
[Answer]
# [Thunno 2](https://github.com/Thunno/Thunno2) `N`, 22 [bytes](https://github.com/Thunno/Thunno2/blob/main/docs/codepage.md)
```
·∏É8·πõ2·∫áƒ±·π¨‚Ç¨J·∏Ç;883`P2∆§∆§√∞»∑j
```
[Try it online!](https://Not-Thonnu.github.io/run#aGVhZGVyPU9IJmNvZGU9JUUxJUI4JTgzOCVFMSVCOSU5QjIlRTElQkElODclQzQlQjElRTElQjklQUMlRTIlODIlQUNKJUUxJUI4JTgyJTNCODgzJTYwUDIlQzYlQTQlQzYlQTQlQzMlQjAlQzglQjdqJmZvb3Rlcj0maW5wdXQ9N0MlMjA3QyUyMDAwJTIwQzYlMjBDNiUyMDAwJTIwMDAlMjBGRSUyMEM2JTIwQzYlMjAwMCUyMEM2JTIwQzYlMjAwMCUyMDAwJTIwMDAmZmxhZ3M9Tg==)
Port of noodle man's Japt answer.
#### Explanation
```
·∏É8·πõ2·∫áƒ±·π¨‚Ç¨J·∏Ç;883`P2∆§∆§√∞»∑j  # Implicit input
·∏É8·πõ                     # Convert each to binary and pad with zeros to length 8
   2·∫áƒ±    ;             # To each chunk of 2:
      ·π¨‚Ç¨J               #  Transpose and join each
         ·∏Ç              #  Then convert back from binary
           883          # Push 883
              `P2∆§      # Prepend "P2"
                  ∆§     # And prepend this header
                   √∞»∑j  # Join each inner list on spaces
                        # Implicit output, joined on newlines 
```
]