This is a bit similar to this dust covered entry but I'm hoping my spin on it makes it unique enough. Not been able to find anything dissuading me from posting this but there is quite the sea out there.

Anyway! The challenge:

Your code receives a string of characters; It converts this into an ASCII-art style version of the same string, but with a catch.

# Input transformation

• The only characters to be supported are A-Z and 0-9
• Lower case letters are transformed into uppercase
• Anything else is silently removed

# Character drawing

• Each "pixel" of the enlarged font is drawn from the input string
• The n'th pixel is equal to the n'th character in the input string. If n is greater than the length of the input string, wrap around back to the beginning
• Individual letters are drawn left-to-right, top-to-bottom
• Subsequent letters pick up their "pixel character" index from where the last letter left off (e.g. with an input length of 10, if the first letter had 9 pixels, the second letter's first pixel will be drawn with the 10th input character, the second pixel will be drawn with the 1st input character)
• Each letter is drawn in a 5x5 grid, fully padded with spaces. You can find the font you are to use pre-rendered for you in this pastebin or a bit further down in this post
• Every letter is drawn on the same line, so the total number of line breaks in your output will be 4
• Every letter is seperated by 2 columns of spaces

# The font

000
0  00
0 0 0
00  0
000

111
1
1
1
11111

2222
2
222
2
22222

3333
3
333
3
3333

44
4 4
44444
4
4

55555
5
5555
5
5555

6666
6
6666
6   6
666

77777
7
7
7
7

888
8   8
888
8   8
888

999
9   9
9999
9
9999

AAA
A   A
AAAAA
A   A
A   A

BBBB
B   B
BBBB
B   B
BBBB

CCCC
C
C
C
CCCC

DDDD
D   D
D   D
D   D
DDDD

EEEEE
E
EEE
E
EEEEE

FFFFF
F
FFF
F
F

GGGG
G
G  GG
G   G
GGGG

H   H
H   H
HHHHH
H   H
H   H

IIIII
I
I
I
IIIII

JJJJJ
J
J
J
JJ

K   K
K  K
KKK
K  K
K   K

L
L
L
L
LLLLL

M   M
MM MM
M M M
M   M
M   M

N   N
NN  N
N N N
N  NN
N   N

OOO
O   O
O   O
O   O
OOO

PPPP
P   P
PPPP
P
P

QQ
Q  Q
Q QQ
Q  Q
QQ Q

RRRR
R   R
RRRR
R  R
R   R

SSSS
S
SSS
S
SSSS

TTTTT
T
T
T
T

U   U
U   U
U   U
U   U
UUU

V   V
V   V
V V
V V
V

W   W
W   W
W W W
WW WW
W   W

X   X
X X
X
X X
X   X

Y   Y
Y Y
Y
Y
Y

ZZZZZ
Z
Z
Z
ZZZZZ

Yes I know the 4 and Q are ugly

# An example

Input

0123456789

Output

012   567    6789   0123     34   45678   9012  34567   234    567
3  45    8        0      4   5 6   9      3          8  5   6  8   9
6 7 8    9     123     567  78901  0123   4567      9    789    0123
90  1    0    4          8     2       4  8   9    0    0   1      4
234   12345  56789  9012      3   5678    012    1      234   5678

# Another example

Input

a3 B'2

Output

A3B   B2A3   2A3B   2A3B
2   A      B  2   A      2
3B2A3    2A3  3B2A    A3B
B   2      B  3   B  2
A   3  2A3B   2A3B   A3B2A

Standard loopholes are forbidden. Code golf so no green tick will be given.

• I'd suggest guaranteeing that the input will only contain [A-Z\d] - I don't think filtering invalid characters adds anything to the challenge. – Shaggy Jun 14 '18 at 10:36
• @Shaggy Perhaps. But by the same token I don't think it removes anything from the challenge – Scoots Jun 14 '18 at 10:40
• related – Laikoni Jun 14 '18 at 11:21
• Related. – Dom Hastings Jun 14 '18 at 12:19
• What about THREE leading spaces? Surely you'll not allow that! – Magic Octopus Urn Jun 15 '18 at 10:14

# Python 2, 413 411 373 364 352 345 bytes

-1 byte thanks to Kevin Cruijssen.
-9 bytes thanks to Jo King.
-1 byte thanks to Lynn.

Data string contains unprintables, escaped version below.

k=list(filter(str.isalnum,input()))
q=range(5);o=['']*5;r=k*25;d=0
for c in'uM<LxSe#ye>El4NpD@$gh> I,m]aB>e, ]?kFL yglxV!  %w832wGj%uT{Hr*K,*[P\n6.&ED#T }^ DLI&p7f\d*lG!FacG\rz?!A':d*=126;d+=ord(c)-1 for c in k: for i in q: for y in q+[999]*2:o[i]+=d>>int(c,36)*25+i*5+y&1and r.pop(0)or' ' print'\n'.join(o).upper() Try it online! As each character has 25 pixels it can be easily encoded in 25 bits. The base 126 number 'uM\x04<L\x10x\x14Se#ye\x0f>El4NpD@$\tgh>\x1d\x10\x15I,\x0em]a\x0e\x03B>e\x15,\x0c]\x03?kFL\x01\x0byglxV!\x18\x16\x0c\x0b\x10\x0b%w832wGj%uT{Hr*K,*[P\n6.&ED#T\x0c}^\x1c\x0fD\x17LI&p7\x17f\\d*\x01l\x1bG\x12!Fac\x05\x08\x0eG\rz?!\x1aA' encodes all chars, the 0 is encoded by the least significant 25 bits, the 1 by the next 25 bits and the Z is encoded by the 25 most significant bits. A single character is encoded in the following order:

00 01 02 03 04
05 06 07 08 09
10 11 12 13 14
15 16 17 18 19
20 21 22 23 24

(00 is the least significant bit, 25 the most significant one)

Spaces are encoded by a zero, non-spaces by a one. Example:

77777      11111
7      00001
7   =>  00010  => (0001000100010001000011111)
7        00100
7         01000

## Ungolfed

k = list(filter(str.isalnum,input()))  # keep only alphanumeric characters of the input
o = ['']*5   # this list contains the output, initially 5 empty lines
r = k * 25   # make a copy of the input 25-times the length, these chars will be used for the pixels
data = 0
#  data encoded in base 126

Try it online!

### Character encoding

Characters are encoded upside-down and converted to a custom base-80 with an offset of 4, using the ASCII range [35..114].

Values 35 to 79 are directly mapped to the corresponding ASCII character, while values 0 to 34 are mapped to characters 80 to 114. This allows to decode by just taking the ASCII code modulo 80.

For instance, 'F' is encoded as "RZW[":

....#     00001
....#     00001
..### --> 00111 --> 0000100001001110000111111 --[decimal]--> 1088575 --[-4]--> 1088571
....#     00001
#####     11111

floor(1088571 / 80**3)        = 2    --> (( 2 + 45) mod 80) + 35 = 82  --> 'R'
floor(1088571 / 80**2) mod 80 = 10   --> ((10 + 45) mod 80) + 35 = 90  --> 'Z'
floor(1088571 / 80)    mod 80 = 7    --> (( 7 + 45) mod 80) + 35 = 87  --> 'W'
1088571                mod 80 = 11   --> ((11 + 45) mod 80) + 35 = 91  --> '['

Starting with i = v = 4, it is decoded back to a 25-bit integer by doing:

Buffer("RZW[").map(c => v += c % 80 * 80 ** --i)

In the full code, we actually process an unbounded slice() of the encoded stream, which means that we are likely to iterate significantly more than 4 times. This is not a problem because all iterations with i < 0 will only affect the decimal part of the result, which is ignored anyway by the bitwise operations that immediately follow.

Try it online!

• Can you replace toUpperCase with the i flag in the RegEx? – Shaggy Jun 15 '18 at 11:11
• @Shaggy That would let the lowercase characters unchanged in the output, which I think is not allowed. – Arnauld Jun 15 '18 at 11:13
• Ah, looks like you're right, I'd missed that. Best update my own solution! – Shaggy Jun 15 '18 at 11:15
• Could you save a byte by matching [A-Z\d] instead of [A-Z0-9]? – Scoots Jun 15 '18 at 11:43

# C (gcc), 792 690 bytes

#define S strlen
#define V v[1][i]
#define A putchar(32);
#define F(x)(((G(x,0)*92+G(x,1))*92+G(x,2))*92+G(x,3))*92+G(x,4))
#define G(x,y)(f[(x-(x<58?48:55))*5+y]-35)
i,j,l;main(c,v)char**v;{l=S(v[c=1]);char*x[l],t[l+1],*p=t,*f="$dKqK&>%Q3&Rms&RYXg#gAB/&b_R/$n>Pw&]?vO$cbu+$ccG#$csC+&X7sS$n0w[&X+={&b^%s&b^$W$n3qS%(4\\_&^Bjg&^Bj/%(Pec$xx%S%+L/%*jjw$cel7&X7oS$NWLO&X7u3$n.U+&^BhG%(')k%'|*/%(+:'%%UO;%%U=K&]{+";*x=t;for(;i<l;i++){V>96?V-=32:V;(V>47)&(V<58)|(V>64)&(V<91)?*(p++)=V:V;}*p=0;for(;c<S(t);)x[c++]=((__builtin_popcount(F(t[c-1])+x[c-1]-t)%S(t))+t;for(c=6;--c;){for(i=0;i<S(t);i++){for(j=5,l=1<<c*5+3;j--;)if((l>>=1)&F(t[i]){putchar(*x[i]++);!*x[i]?x[i]=t:x;}else A A A}puts(p);}}

Try it online!

Managed to squeeze this under 800 with some variable reuse. Opted to store the font as an array of ints, as although storing it as one long string looked like an attractive idea so many of the 8-bit chunks of the font weren't a nice convenient ASCII character that the escape codes were taking up more characters than the int array did.

Edit: Got under 700 by switching to a string encoding after all - somewhat inspired by many of the other responses here I cobbled together a base-92 representation using (most of) the printable ASCII characters. The representation does include backslashes which need an extra to be escaped but that only happens once in the font.

Other than that there isn't much that's too flashy going on - the input (consisting of the first command-line argument) is copied into a stack array, minus any characters that aren't in the font and with lowercase letters replaced with their uppercase versions, what "pixel" character each full letter starts on is computed (using __builtin_popcount has a painfully long name but was still better than any method of counting on bits I could think of), and then the printing goes through line by line. The compiler of course outputs several times the program length in warnings.

Somewhat degolfed below for your viewing pleasure:

//The defines are listed here for reference. Some are replaced in the below code but I still use F() because it's long.
#define S strlen
#define V v[1][i]
#define A putchar(32);
#define F(x)(((G(x,0)*92+G(x,1))*92+G(x,2))*92+G(x,3))*92+G(x,4))  //How to lookup a font character given an input char x
#define G(x,y)(f[(x-(x<58?48:55))*5+y]-35)                         //Used for looking up the individual parts of a character font
i, j, l;                                           // Declaring some int variables for later use.
main(c,v) char**v; {                               // Declaring afterwards lets us have the int arg default without declaring it
l = strlen(v[c=1]);                              // Using l as a local variable to shorten S(v[1]) and also giving c an initial value here where there was a spare 1, saving a character over writing the full c=1 init in a later for loop.
char t[l+1], *p=t, *x[l];                        // Declaring char arrays and char*s and char* arrays. t is oversized if there are any invalid characters in the input, but that's not important for golfing.
char *f="$dKqK&>%Q3&Rms&RYXg#gAB/&b_R/$n>Pw&]?vO$cbu+$ccG#$csC+&X7sS$n0w[&X+={&b^%s&b^$W$n3qS%(4\\_&^Bjg&^Bj/%(Pec$xx%S%+L/%*jjw$cel7&X7oS$NWLO&X7u3$n.U+&^BhG%(')k%'|*/%(+:'%%UO;%%U=K&]{+";      // The font, encoded base-92 with 5 characters to a letter in the order 0123456789ABCDEF... etc.
*x=t;                                            // The first character's "pixels" will start at the beginning of the valid input.
for(; i<strlen(l); i++){                         // Speaking of which, now validate the input.
v[1][i] > 96 ? v[1][i] -= 32 : v[1][i];        // Change lowercase characters to uppercase. If they aren't actually lowercase characters but have ascii value >96, they won't end up valid after this either and will be edited out on the next line. The false case does nothing, but since with the macro it is one character using the ternary operator saves a character over an if statement even though that case ends up redundant.
(v[1][i]>47)&(v[1][i]<58)|(v[1][i]>64)&(v[1][i]<91)?*(p++)=v[1][i]:v[1][i];        // If the character is now either a numeral or an uppercase letter, set the next spot in the t array by way of the pointer p and then increment said pointer.
}
*p=0;                                            // Add the null terminator to the t array, our validated input string.
for(;c<strlen(t);) {                             // Now find out at what index each letter should start getting "pixels" from.
x[c++] = ((__builtin_popcount(F(t[c-1])+x[c-1]-t)%strlen(t))+t;          // Use the builtin to get the number of on bits/pixels in the previous letter, then add that to the previous letter's starting pixel and take the modulus strlen() of the valid string.
}
for(c=6; --c;){                                  // Now start the actual printing. For each line...
for(i=0; i<strlen(t); i++){                    // For each letter...
for(j=5, l=1<<c*5+3; j--;) {                 // For each pixel of the 5 on this line...
if((l>>=1) & F(t[i]) {                     // If it is on...
putchar(*x[i]++);                        // Print it and increment the pixel-fetching pointer for this letter.
!*x[i]?x[i]=t:x;                         // If said pointer hit the end of the valid input go back to the beginning.
} else {
putchar(32);                             // If it is an off pixel, print a space.
}
}
putchar(32);                                 // After a letter, print two spaces.
putchar(32);
}
puts(p);                                       // This is the cheapest way in character count I could come up with to output a newline. p currently points to the end of t, so it is an empty string and puts just adds a newline.
}
}

# Excel VBA, 816 bytes

An anonymous VBE immediate window function that takes input from range [A1] and outputs to the console.

As far as I am aware, this is the first VBA answer to use base64 compression.

For i=1To[Len(A1)]:c=Mid(UCase([A1]),i,1):y=y &IIf(c Like"[0-9A-Z]",c,""):Next:l=Len(y):Set d=New MSXML2.DOMDocument:Set d=d.createElement("b64"):d.DataType="bin.base64":d.Text="HxHxCSEqRkVUjLvGSJSK0cUYIyGEfB8cfFH66Ju0kkHoo3cxRhdnzTHGuuOHEMIouYyYEPI/IeTH+GN8ccIHIYf/Qw6/jzH6ByF8PvroY/zR+fCic9FFh4gI30UPnw8efiG+Mj6c4D90wX9CCHe5Tgc=":b=d.nodeTypedValue:For i=0To 112:k=Right("00000" &Evaluate("=Dec2Bin("&b(i)&")"),8)&k:Next:For i=1To 5:For j=1To l:c=UCase(Mid(y,j,1)):Z=c Like"[0-9]":s=s &IIf(c Like"[A-Z]",Mid(k,IIf(Z,1,25*(Asc(c)-55)+5*i),5)&" ",IIf(Z,Mid(k,25*(Asc(c)-48)+5*i,5)&" ","")):Next:s=Replace(Replace(s,0," "),1,"#") &vbLf:Next:Do:i=InStr(1+(g*l+h)*6+g,s,"#"):p=(p-e)Mod l:e=i<(g*l+h+1)*6+g:s=IIf(e,Left(s,i-1)&Replace(s,"#",Mid(y,p+1,1),i,1),s):g=g-(0=e):h=h-(g>4):g=g Mod 5:Loop While InStr(1,s,"#"):?s

Note: This answer depends on the Microsoft XML, v3.0 VBA reference

### Example I/O

[A1]="'0123456789"
For i=1To[Len(A1)]:c=Mid(UCase([A1]),i,1):y=y &IIf(c Like"[0-9A-Z]",c,""):Next:l=Len(y):Set d=New MSXML2.DOMDocument:Set d=d.createElement("b64"):d.DataType="bin.base64":d.Text="HxHxCSEqRkVUjLvGSJSK0cUYIyGEfB8cfFH66Ju0kkHoo3cxRhdnzTHGuuOHEMIouYyYEPI/IeTH+GN8ccIHIYf/Qw6/jzH6ByF8PvroY/zR+fCic9FFh4gI30UPnw8efiG+Mj6c4D90wX9CCHe5Tgc=":b=d.nodeTypedValue:For i=0To 112:k=Right("00000" &Evaluate("=Dec2Bin("&b(i)&")"),8)&k:Next:For i=1To 5:For j=1To l:c=UCase(Mid(y,j,1)):Z=c Like"[0-9]":s=s &IIf(c Like"[A-Z]",Mid(k,IIf(Z,1,25*(Asc(c)-55)+5*i),5)&" ",IIf(Z,Mid(k,25*(Asc(c)-48)+5*i,5)&" ","")):Next:s=Replace(Replace(s,0," "),1,"#") &vbLf:Next:Do:i=InStr(1+(g*l+h)*6+g,s,"#"):p=(p-e)Mod l:e=i<(g*l+h+1)*6+g:s=IIf(e,Left(s,i-1)&Replace(s,"#",Mid(y,p+1,1),i,1),s):g=g-(0=e):h=h-(g>4):g=g Mod 5:Loop While i<InStrRev(s,"#"):?s
012  567   6789  0123    34  45678  9012 34567  234   567
3  45   8       0     4  5 6  9     3         8 5   6 8   9
6 7 8   9    123    567 78901 0123  4567     9   789   0123
90  1   0   4         8    2      4 8   9   0   0   1     4
234  12345 56789 9012     3  5678   012   1     234  5678

### Ungolfed and Explained

The major part of this solution storing the large font as a base 64 string. This is done by first converting the font to binary, where 1 represents an on pixel and 0 represents an off pixel. For example, for 0, this is represented as

###     01110
#  ##    10011
0 -> # # # -> 10101 --> 0111010011101011100101110
##  #    11001
###     01110

With this approach, the alphanumerics can then be represented as

0: 0111010011101011100101110    1: 1110000100001000010011111
2: 1111000001011101000011111    3: 1111000001001110000111110
4: 0011001010111110001000010    5: 1111110000111100000111110
6: 0111110000111101000101110    7: 1111100001000100010001000
8: 0111010001011101000101110    9: 0111010001011110000111110
A: 0111010001111111000110001    B: 1111010001111101000111110
C: 0111110000100001000001111    D: 1111010001100011000111110
E: 1111110000111001000011111    F: 1111110000111001000010000
G: 0111110000100111000101111    H: 1000110001111111000110001
I: 1111100100001000010011111    J: 1111100100001000010011000
K: 1000110010111001001010001    L: 1000010000100001000011111
M: 1000111011101011000110001    N: 1000111001101011001110001
O: 0111010001100011000101110    P: 1111010001111101000010000
Q: 0110010010101101001001101    R: 1111010001111101001010001
S: 0111110000011100000111110    T: 1111100100001000010000100
U: 1000110001100011000101110    V: 1000110001010100101000100
W: 1000110001101011101110001    X: 1000101010001000101010001
Y: 1000101010001000010000100    Z: 1111100010001000100011111

These segments were concatenated and converted to MSXML base 64, rendering

HxHxCSEqRkVUjLvGSJSK0cUYIyGEfB8cfFH66Ju0kkHoo3cxRhdnzTHGuuOHEMIouYyYEPI/IeTH+GN8ccIHIYf/Qw6/jzH6ByF8PvroY/zR+fCic9FFh4gI30UPnw8efiG+Mj6c4D90wX9CCHe5Tgc=

The subroutine below takes this, back converts to binary, and uses this a reference from which to build an output string, line by line, grabbing first the top 5 pixels of each character, then the second row and so on until the string is constructed.

The subroutine then iterates over the output string and replaces the 'on' pixels with characters from the input string.

''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
''
''  Embiggen Function
''
''  @Title  :   Embiggen
''  @Author :   Taylor Scott
''  @Date   :   15 June 2018
''  @Desc   :   Function that takes input, value, and outputs a string in which
''              value has been filtered to alphnumerics only, each char is then
''              scaled up to a 5x5 ASCII art, and each 'pixel' is replaced with
''              a char from value. Replacement occurs letter by letter, line by
''              line
''
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
Function EMBIGGEN(ByVal value As String) As String

Dim DOM         As New MSXML2.DOMDocument, _
bytes()     As Byte

Dim isNum       As Boolean, _
found       As Boolean, _
index       As Integer, _
length      As Integer, _
line        As Integer, _
letter      As Integer, _
pos         As Integer, _
alphanum    As String, _
char        As String, _
filValue    As String, _
outValue    As String

''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
''
''  Filter input
''
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
For letter = 1 To Len(value) Step 1             ''  Iterate Accross Value
Let char = Mid$(UCase(value), letter, 1) '' Take the nth char '' If the char is alphnumeric, append it to a filtered input string Let filValue = filValue & IIf(char Like "[0-9A-Z]", char, "") Next letter Let length = Len(filValue) '' store length of filValue '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' '' '' Convert Constant from Base 64 to Byte Array '' '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' With DOM.createElement("b64") '' Construct b64 DOM object Let .DataType = "bin.base64" '' define type of object '' Input constructed constant string shown above Let .Text = "HxHxCSEqRkVUjLvGSJSK0cUYIyGEfB8cfFH66Ju0kkHoo3cxRhdnz" & _ "THGuuOHEMIouYyYEPI/IeTH+GN8ccIHIYf/Qw6/jzH6ByF8PvroY/" & _ "zR+fCic9FFh4gI30UPnw8efiG+Mj6c4D90wX9CCHe5Tgc=" Let bytes = .nodeTypedValue '' Pass resulting bytes to array End With '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' '' '' Convert Byte Array to Byte String '' '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' For index = 0 To 112 Step 1 '' convert each byte to binary, fill left with 0s and prepend Let alphanum = _ Right("00000" & Evaluate("=Dec2Bin(" & bytes(index) & ")"), 8) & _ alphanum Next index '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' '' '' Construct Embiggened Binary String of Input Value '' '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' For line = 1 To 5 Step 1 '' iterate across lines For letter = 1 To length Step 1 '' iterate across letters '' take the corresponding letter from Let char = UCase(Mid(filValue, letter, 1)) If char Like "[0-9]" Then '' if it is a number, '' Add the 5 bit corresponding to number at line Let outValue = outValue & _ Mid$(alphanum, 25 * Val(char) + 5 * line, 5) & " "
ElseIf char Like "[A-Z]" Then   '' if it is a letter,
''  Add the 5 bits corresponding to letter at line
Let outValue = outValue & _
Mid$(alphanum, 25 * (Asc(char) - 55) + 5 * line, 5) & " " End If Next letter Let outValue = outValue & IIf(line < 5, vbLf, "") Next line Let outValue = Replace(Replace(outValue, 0, " "), 1, "#") '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' '' '' Replace #s with Input Value '' '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' Let pos = 0 '' Reset position in filValue Let line = 0 '' Reset line index Let letter = 0 '' Reset letter index Do '' Find the index of the first # starting at line and letter Let index = _ InStr(1 + (line * length + letter) * 6 + line, outValue, "#") '' Iterate position in filValue if a # is found in that letter & line Let pos = (pos - found) Mod length '' check to see if found index is in the correct letter Let found = index < (line * length + letter + 1) * 6 + line '' iff so, replace that # with letter in filValue corresponding to pos Let outValue = IIf(found, _ Left(outValue, index - 1) & _ Replace(outValue, "#", Mid(filValue, pos + 1, 1), index, 1), _ outValue) '' if not found, them iterate line Let line = line - (found = False) '' iterate letter every five iterations of line Let letter = letter - (line > 4) '' Ensure that line between 0 and 4 (inc) Let line = line Mod 5 '' Loop while there are '#'s in outValue Loop While InStr(1, outValue, "#") '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' '' '' Output '' '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' Let EMBIGGEN = outValue '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' '' '' Clean Up '' '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' Set DOM = Nothoing End Function # K (ngn/k), 230 231 bytes (+1 byte after a change in the language impl) f:{{x,'" ",/:y}/(#s;5;5)#@[(#c)#"";i;:;(#i:&c:,/(36 25#4_,/+2\a)s)#`c$b s:((b:(48+!10),65+!26)?x-32*(96<x)&x<123)^0N]}

Try it online!

where a is a quoted string literal that encodes the font. K sees strings as sequences of bytes, so a program containing such a literal is valid, but it can't be run on TIO, as its HTML form tries to interpret it as UTF-8 and messes it up.

The byte count is calculated as:

• 119 reported by TIO

• -2 for naming the function f:

• -1 for the placeholder a

• 2 for a pair of quotes ""

• 113 for the length of the string literal a which doesn't contain any chars that require escaping