[Question]
  [
Your challenge, should you choose to accept it, is to write a program in a language of your choice that, when given a string (limited to printable ASCII) as input, outputs a new program in the same language that outputs that string *without using any characters from that string in the code.*
But this task is impossible as-is in many languages; for example, if the string to print contains every ASCII character. So instead, your submission will choose a subset of printable ASCII which is guaranteed not to be in the input. Your score will be the size of the set, with lower score being better, and shortest code length (in bytes) as a tiebreaker.
An example solution might be the following:
> 
> ## [Python](https://www.python.org), 64 bytes / score 17
> 
> 
> 
> ```
> lambda s:"print('\\"+'\\'.join([oct(ord(c))[2:]for c in s])+"')"
> 
> ```
> 
> Restricting the set `print()'\01234567`.
> 
> 
> 
Now that's enough dawdling‚Äîgo program!
## Rules / clarifications
* "Same language" includes any compiler flags used in the submission.
* The outputted program should be a full program with output on STDOUT.
  
[Answer]
# [Python](https://www.python.org), ~~121~~ 90 bytes / score 3
```
lambda s:f"ÔΩêÔΩíÔΩâÔΩéÔΩî({'+'.join('ÔΩÉÔΩàÔΩí('+'+Ôº¥ÔΩíÔΩïÔΩÖ'*ord(c)+')'for c in s)})"
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m72soLIkIz9vweI025ilpSVpuhY3o3ISc5NSEhWKrdKU3u-d8H7vpPd7O9_v7Xu_d4pGtbq2ul5Wfmaehvr7vc3v93YAZTWAYtrv92wBK5z6fm-rulZ-UYpGsqa2uqZ6Wn6RQrJCZp5CsWatphLEhv0FRZl5JRppGurq6iEZmcUK6aklxQo5-XnpikARTU2IqgULIDQA)
*-31 thanks to l4m2*
NFKC normalization! The only reserved characters are `(+)`, and everything else is done with identifiers written ÔΩâÔΩé„ÄÄÔΩÜÔΩïÔΩåÔΩåÔΩóÔΩâÔΩÑÔΩîÔΩà„ÄÄÔΩÉÔΩàÔΩÅÔΩíÔΩÅÔΩÉÔΩîÔΩÖÔΩíÔΩì.
Builds codepoints up as sums of `True`.
It feels almost possible to go down to 2... almost. Constructing the codepoints with just `()` seems maybe doable with some kind of `str`/`repr` layering, but it takes either `+` or `,=` to `print` it all on one line... and I also have half a mind to cut `print` out of the picture, but it seems like it would take `,.` to go the `open(1, 'w')` route.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~19~~ ~~11~~ 10 bytes / score 0
```
O‚Äù‚Äò·∫ãp‚Äù·ªåj‚Äù¬Æ
```
[Try it online!](https://tio.run/##y0rNyan8/9//UcPcRw0zHu7qLgCyHu7uyQJSh9b9//9fQVFJWUVVTV1DU0tbR1dP38DQyNjE1MzcwtLK2sbWzt7B0cnZxdXN3cPTy9vH188/IDAoOCQ0LDwiMio6JjYuPiExKTklNS09IzMrOyc3L7@gsKi4pLSsvKKyqrqmti6/JCO1SAEokpamkJdfopCcn1eSmV6aX1qskFFSUlBspa9fXl6uV5lfWlKalKqXnJ@rX55YkpxhX2ZbaRThWFTgmlyZngwA "Jelly ‚Äì Try It Online")
*-1 thanks to Jonathan Allan*
Encodes arbitrary strings as programs with no ASCII whatsoever, using increment spam for charcodes and unparseable nilads to both print and reset to 0.
```
O             Codepoints of the input.
 ‚Äù‚Äò·∫ã          Repeat ‚Äò (increment) that many times for each codepoint.
    p‚Äù·ªå       Append ·ªå (convert from codepoints) to each.
       j      Join on
        ‚Äù¬Æ    the register nilad (0 unless set otherwise).
```
[Answer]
# [Brain-Flak](https://github.com/DJMcMayhem/Brain-Flak), 78 bytes / score 2
```
{({}<>)<>}<>{<>(((((()()()()()){}){}){})())<>{({}[()])<>((({}[()])()))<>}{}}<>
```
The input cannot contain either of `()`.
[Try it online!](https://tio.run/##XZGxboMwEIZ3P8VVDNgS4QkQY9WtVTp0iDIYOGQUx46MSQfLz04PA20aY8lw9@v@j9@Nk4M59Fpe5jmDI97RjQheIQzmNnkWeIhVLao6sqpmLINX6wBlq6BV0snWoyvLkgUGtDL4mEYFORc5eAtSU9dIjzB62V6ShIYsB09L7I8Icdv0vuu2kV9q0ETkJlyMltpqtnY/p8YvGGANQu/sNbH/slGZSG5g@1T/40gQIZ64OAv2MO/dJOET@u788Aer/IhXe1/zynm@uRUgTUf5jej8GsZkOhqH0isYfLHIDVC69AHNPyK@M1EO4tkyhsjoMub5DbW2BXxbp7uX@dC6Hw "Brain-Flak ‚Äì Try It Online")
And readable version:
```
# Reverse the input
{({}<>)<>}
<>
# For each character...
{
    # Push '()' to alternate stack
    <>
    (((((()()()()()){}){}){})())
    <>
    # While true...
    {
        # Subtract one from the character on top of the stack
        ({}[()])
        # On the alternate stack...
        <>
        # Remove the '(' on top, and insert '()' underneath it, then put it back
        ((({}[()])()))
        <>
    }{}
}<>
```
[Answer]
# [;#+](https://github.com/ConorOBrien-Foxx/shp), subset size 2, 40 bytes
```
;;;;;~+++++++>~;~++++:>*(-(;~<#~):<#-*:)
```
[Try it online!](https://tio.run/nexus/shp#@28NAnXaEGBXB2Fa2Wlp6GpY19ko12la2Sjrallp/v/vkZqTk68Qnl@Uk6LIAAA ";#+ ‚Äì TIO Nexus") Input is terminated with a null byte. Assumes the input does not contain `;` or `#`.
## Explanation
As this is a repost of [my answer to another question from 2017](https://codegolf.stackexchange.com/a/122210/31957), you can find a detailed explanation there. On a high level, it just generates constants for `;` and `#`, and for each character in the input, the program outputs that many `;`, followed by a `#`.
;#+ being a superset of ;# allows us to reuse the code from the linked challenge without modification.
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 12 bytes, score 0
```
‚≠ÜÔº≥‚Å∫¬¥‚ÑÖ¬¥Ôº¨√ó¬¥¬∂‚ÑÖŒπ
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m70iOSOxKDk_MWfBgqWlJWm6Fjc9A4oy80o0gkuAVLpvYoGGZ15BaQmEq6GpoxCQU1qsofSopfX9njVKOgohmbmpQP6hbUC2f1FKZl5ijkamJghYLylOSi6GGrs8Wkm3LEcpdlu0kjPUxpgiQyOFpMqS1GKlWIgiAA "Charcoal ‚Äì Attempt This Online") Link is to verbose version of code. Accepts any Unicode character other than NUL and `‚ÑÖÔº¨¬∂` that the output uses (the last one being `\n` in Charcoal's code page; the resulting program can't properly print newlines, but you can use `\r` instead). Run the sample output: [Try it online!](https://tio.run/##S85ILErOT8z5//9RS@v7PWsObRsMcDC5ZdRXIyN2hrtPR0Ksjeaw4eA7evmefqFMHZuGT6oYOTXISPb3cPPtSIq9//8B "Charcoal ‚Äì Try It Online") Explanation:
```
 Ôº≥              Input string
‚≠Ü               Map over characters and join
   ¬¥‚ÑÖ¬¥Ôº¨         Literal string `‚ÑÖÔº¨`
  ‚Å∫             Concatenated with
        ¬¥¬∂      Literal string `¬∂` (bare `¬∂` would be `\n`)
       √ó        Repeated by
           Œπ    Current character
          ‚ÑÖ     Take the ordinal
                Implicitly print
```
The resulting program contains a number of strings of the form `‚ÑÖÔº¨¬∂¬∂¬∂...¬∂¬∂¬∂` each of which outputs the Unicode character with the code point given by the number of `¬∂`s.
Since the resulting programs get long quickly, here's a longer program that outputs shorter programs:
```
‚≠ÜÔº≥‚Å∫¬¥‚ÑÖ‚çò‚ÑÖŒπ‚Äùy‚Å∞¬π¬≤¬≥‚Å¥‚Åµ‚Å∂‚Å∑‚Å∏‚Åπ
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z@gKDOvRCO4BEil@yYWaHjmFZSWQLgamjoKATmlxRpKj1palXQUnBKLU6Ey/kUpmXmJORqZQCVKjxo3HNp5aNOhzY8atzxq3Pqocdujxu2PGnc8atyppAkE1v//Rys5Q22MKTIyUEiqLEktVor9r1uWAwA "Charcoal ‚Äì Try It Online") Link is to verbose version of code. Accepts any Unicode character other than NUL and `‚ÑÖ‚Å∞¬π¬≤¬≥‚Å¥‚Åµ‚Å∂‚Å∑‚Å∏‚Åπ` that the output uses, although the restriction on `\n` still applies. Run the sample output: [Try it online!](https://tio.run/##S85ILErOT8z5//9RS@ujxm2PGrcDGYd2Pmrc8KhxC1hsJ0wMJAoX2gkVOrQTVRFY4w6I5Gaw1FaQEIixBSqx@dAmmB6owk2HdsJt2AYzBkls6///AA "Charcoal ‚Äì Try It Online") Explanation: Converts the ordinals of the input characters into Charcoal's digits (which aren't printable ASCII), with `‚ÑÖ` telling the resulting program to convert them back into Unicode.
[Answer]
# [Ruby](https://www.ruby-lang.org/), ~~92~~ 50 bytes, score ~~8~~ 7
```
->e{'$><<$==""<<'+(e.bytes.map{|x|[1]*x*?+}*"<<")}
```
[Try it online!](https://tio.run/##LclLCoMwEADQvacog6BGHHCf2INYF1FGlKjYfKzfs8cuXD6edvXmW@Gzgo4oLDgPhQDgPEpjwnqzZHCU83GuZ5lXbGXv9GL/huTySrQl/DppaSH9maAKZmfNSwW0yCFWyUNsOqkNuqn/oul38jc "Ruby ‚Äì Try It Online")
### How
In Ruby, the string operator `<<` converts an integer to a codepoint, and appends the corresponding character.
Starting with the empty string, we can append all characters of the original string as numbers, and send the result to standard output (`$>`). Using `$=` (deprecated variable warning) to avoid wrapping the string in brackets, and saves 1 character.
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal) `Ds`, 67 [bitsv2](https://github.com/Vyxal/Vyncode/blob/main/README.md), 8.375 bytes, score 0
```
C\‚Ä∫*`√∏‚üá‚Ç¥`+
```
[Try it Online!](https://vyxal.pythonanywhere.com/?v=2#WyJEcz0iLCIiLCJDXFzigLoqYMO44p+H4oK0YCsiLCIiLCJBbW9uZ3VzIl0=)
Bitstring:
```
0101011101110101111010001011001000010010000000010100011110100110010
```
The set is the entire vyxal code page minus `‚üá‚Ç¥√∏‚Ä∫`. Vyxal's code page contains printable ascii in the same spots as Unicode which is very convenient.
## Explained
```
C\‚Ä∫*`√∏‚üá‚Ç¥`+¬≠‚Å°‚Äã‚Äé‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å°‚Å™‚Äè‚Äè‚Äã‚Å°‚Å†‚Å°‚Äå‚Å¢‚Äã‚Äé‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å¢‚Å™‚Äè‚Å†‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å£‚Å™‚Äè‚Å†‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å§‚Å™‚Äè‚Äè‚Äã‚Å°‚Å†‚Å°‚Äå‚Å£‚Äã‚Äé‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å¢‚Å°‚Å™‚Äè‚Å†‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å¢‚Å¢‚Å™‚Äè‚Å†‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å¢‚Å£‚Å™‚Äè‚Å†‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å¢‚Å§‚Å™‚Äè‚Å†‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å£‚Å°‚Å™‚Äè‚Å†‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å£‚Å¢‚Å™‚Äè‚Äè‚Äã‚Å°‚Å†‚Å°‚Äå‚Å§‚Äã‚Äé‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å¢‚Å¢‚Å™‚Äè‚Å†‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å¢‚Å£‚Å™‚Äè‚Äè‚Äã‚Å°‚Å†‚Å°‚Äå‚Å¢‚Å°‚Äã‚Äé‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å¢‚Å§‚Å™‚Äè‚Äè‚Äã‚Å°‚Å†‚Å°‚Äå¬≠
C           # ‚Äé‚Å°Convert to a list of Unicode code points
 \‚Ä∫*        # ‚Äé‚Å¢Repeat ‚Ä∫ per each character 
    `√∏‚üá‚Ç¥`+  # ‚Äé‚Å£And add this string 
     √∏‚üá     # ‚Äé‚Å§  Index into the vyxal code page 
       ‚Ç¥    # ‚Äé‚Å¢‚Å°  Print without a newline. This makes the top of the stack empty. 
üíé
```
Created with the help of [Luminespire](https://vyxal.github.io/Luminespire).
[Answer]
# [Java](https://en.wikipedia.org/wiki/Java_(programming_language)), 202 bytes, score 18
```
interface M{static void main(String[]a){("interface I{static void main(String[]a){System.out.print(\""+a[0].replaceAll("\\\\|\"","\\\\$0")+"\");}}").chars().forEach(c->System.out.printf("\\u%04x",c));}}
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m70kK7EsccGCpaUlaboWN09l5pWkFqUlJqcq-FYXlySWZCYrlOVnpijkJmbmaQSXFGXmpUfHJmpWayghVHriVRlcWVySmquXX1qiVwAULNGIUVLSTow2iNUrSi3IAep3zMnRUIoBghqgjA6YpWKgpKmtFKOkaV1bq6Spl5yRWFSsoamXll_kmpicoZGsa4duahrIiFJVA5MKJZ1kTZA-iI-gHtscrZSRmpOTrxCjVJ5flJMCtCkWKgUA)
Java interprets unicode escapes `\uABCD` everywhere, not only in String literals. This way, we can write a program using only the characters `\u0123456789abcdef`.
[Answer]
# Javascript with JsFuck lib, 6 restricted, 43 bytes
```
x=>JSFuck.encode(`x=>`+JSON.stringify(x),1)
```
[Answer]
# [Brainfuck](https://github.com/TryItOnline/brainfuck), 49 bytes / score 3
```
,[>>--[<+>++++++]<<[->.<]>+++.>++++[<++++>-]<.>,]
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m70yqSgxMy-tNDl7wYKlpSVpuhY3DXWi7ex0daNttO20wSDWxiZa107PJhbE1wMLAiWBwE431kbPTicWohGqf8FeJ5iROgomlgpJlSWpxQr6CsXJ-UWpCsYQRQA)
[Answer]
# [Python](https://www.python.org), 87 bytes, score 9 (ASCII only code)
*See [Unrelated String's solution](https://codegolf.stackexchange.com/questions/266359/restricted-meta-cat/266368#266368) for a lower score by using non-ascii characters*
*-4 bytes, thanks to noodle man*   
*-9 bytes, thanks to l4m2*
---
```
def f(s):print(f"exec({'+'.join('chr('+'+1'*ord(c)+')'for c in f'print({repr(s)})')})")
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m72soLIkIz9vwYKlpSVpuhY3w1NS0xTSNIo1rQqKMvNKNNKUUitSkzWq1bXV9bLyM_M01JMzijSAPG1Dda38ohSNZE1tdU31tPwihWSFzDyFNHWIvuqi1IIioDG1mupArKQJMf4WX1qahpJHak5OvkJ4flFOipImF0S9JhfYHpDh2obDG2pqjwRfDmefDld_jSQf0t63tDB1cMbL4HTVqH9GfTc8IXX8OBRDaii6edSPI9Onw8t3Q6k1owntbsJ6tQA)
encodes string using `exc()hr1+`
## Explanation
Encodes string as `exec(chr(1+...+1)+chr(1+1+...)+...)`
The executed code is `print(S)` with `S` being the string-representation of the input. The characters in the string are represented as sums of `1`'s
---
# [Python](https://www.python.org), 85 bytes, score 11
```
def f(s):print(f"exec({'+'.join(f'chr(0b{ord(c):b})'for c in f'print({repr(s)})')})")
```
[Attempt This Online!](https://ato.pxeger.com/run?1=dZFBCsIwEEVx21OEbJJQlMxO3AteQNw3TWilJCVWUIoncdON3klPY9IoJC0GsnjMn_9nkvuzvXaV0cPwOHdquX7tS6mQoie2aW2tO6qwvEhBe5KT1dHUmioiKkt50RtbUsE2xY0RZSwSqNZIkdDVW9laZ-Jq7mIWzN-LraJ4J5vGoIOxTYlZFvQsG1OCMwBwd1geIUTIPccIkIgh6vUQkdfGlMR4Tn2T6gwTK56GxsWJdr4OTKf4O_G4-fc1f1_2AQ)
encodes string using `exc()hr0b1+`
[Answer]
# JavaScript, 66 bytes, score 15
Using the restricted set `alert`\01234567`:
```
s=>"alert`"+s.replace(/./g,c=>"\\"+c.charCodeAt().toString(8))+"`"
```
Uses deprecated octal string literals and alert with a tagged template function call. I was worried that `alert` would stringify the tagged template as `[Object object]` but fortunately for me that did not happen.
I wrote this on my phone so I can‚Äôt insert a stack snippet at the moment.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), score 0 (14 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage))
```
√á'«ù√ó¬ª‚Äú‚Äù√ø‚Äù√ÖŒ≥Œπ–Ω√ß
```
Output of the output program is a list of characters.
[Try it online.](https://tio.run/##yy9OTMpM/f//cLv68bmHpx/a/ahhzqOGuYf3g4jWc5vP7byw9/Dy//8VFJWUVVTV1DU0tbR1dPX0DQyNjE1MzcwtLK2sbWzt7B0cnZxdXN3cPTy9vH18/fwDAoOCQ0LDwiMio6JjYuPiExKTklNS09IzMrOyc3Lz8gsKi4pLSsvKKyqrqmtq6xQc81IUMlKLUhWK83NTSzIy89IVcvOLUhUVDRUB)  
[Try the outputted program online.](https://tio.run/##7Zq9DYJgFEV7R3MLTSysLFyAxjGoHcDKwoqCjjgDi3wO4fu5974X@nvOARIS4HY/na@XMfZpXv88DivChNGI2YzhkOmU8Zj5nMOgy6TTqNus47DrtPO4@3wAIAQRBAnDBIJCUcGwcFwCMAWZBE3DJoJT0cnwdDyAAIQCiASMBpAIlAqYDJwOoBCkEqgUrBawGLQauBy8HoEghSKJJI0mkSiVKpksnS6hMKUyqTStNrE4tTq5PL2@QIBEgkiETIZQiFSKWIxcjmCQZJJolGyWcJh0mnicfF6BwBKJRSLLZBYKLZVaLLZcbsHgkslFo8tmFw4vnW4Q3z@wd1yZO60vbb@D6JR@H9N5ndYpHdpf0zuun/J9qTuvI9NTDhQn1ACxT/Py2F7b@/tZnuM4fg) (Feel free to remove the `J`oin in the footer to see the actual list output.)
**Explanation:**
```
√á              # Convert the (implicit) input-string to a list of codepoint-integers
 '«ù           '# Push string "«ù"
   √ó           # Convert each codepoint to a string with that many "«ù"
    ¬ª          # Join this list of strings with newline delimiter
     ‚Äú‚Äù√ø‚Äù√ÖŒ≥Œπ–Ω√ß # Push (dictionary) string "‚Äù√ø‚Äù√ÖŒ≥Œπ–Ω√ß",
               # where the `√ø` is automatically replaced with the earlier string
               # (after which the result is output implicitly)
```
```
‚Äù«ù«ù«ù...«ù«ù«ù
...
«ù«ù«ù...«ù«ù«ù‚Äù     # Push (dictionary titlecase) string with "«ù" and newlines
√ÖŒ≥             # Run-length encode it; pushing pair ["«ù","\n"] and a list of lengths
  Œπ            # Uninterleave the list of lengths into two parts
   –Ω           # Pop and leave just the first part (the lengths of the "«ù"-lines)
    √ß          # Convert each from a codepoint-integer to a character
               # (after which this list of characters is output implicitly as result)
```
Some notes:
1. `«ù` is used, since `'«ù√ó` nor `'«ù«ù` are [dictionary words](https://codegolf.stackexchange.com/a/166851/52210). But any non-ASCII character that doesn't form dictionary words would be fine here.
2. `‚Äú` and `‚Äù` are used to prevent the ASCII-quote `"`. Luckily, none of `‚Äù«ù`/`«ù«ù`/`‚Äù√Ö`/`√ÖŒ≥`/`Œ≥Œπ`/`Œπ–Ω`/`–Ω√ß` are dictionary words.
3. An approach similar to the Jelly/Vyxal answers using an increment won't work in 05AB1E, since the increment-by-1 builtin is an ASCII-character: `>`.
[Answer]
# [Ly](https://github.com/LyricLy/Ly), Length 20 / Score 4
Input cannot have 4 characters `0`&o`.
```
&ir[0u['`o,]p]"&o"&o
```
And at a high level, the code reads all input as codepoints, then converts each character to a `0` and as many "increment the top of stack" instructions as is necessary to get to the codepoint value. Then it appends `&o` to the end to print the entire stack as characters.
```
&ir                   - read input as codepoints, reverse stack
   [         ]        - loop once for each char on the stack
    0u                - push a "0" onto the stack
      [    ]          - while number is >0
       '`o            - print "`" (the increment instruction)
          ,           - decrement the top of stack
            p         - delete the loop variable from the stack
              "&o"    - push "&o" (print whole stack instruction)
                  &o  - print stack
```
[Try it online!](https://tio.run/##y6n8/18tsyjaoDRaPSFfJ7YgVkktH4j@/w/JyCxWAKKS1OIShcy8gtISPQA "Ly ‚Äì Try It Online")
[Answer]
# [Uiua](https://uiua.org), 22 [bytes](https://www.uiua.org/pad?src=U0JDUyDihpAgK0BcMOKKlwpEZWNvZGUg4oaQIOKHjOKKjy0x4pa9wrEu4o2Y4ouv4oav4oqCwq8x4qe74ouv4qe7LOKHjOKItSjihpjCrzHii68rMjU2KSAtQFwwKzEKJnAg4oqCIjggYml0IGVuY29kaW5nOlx0IiBTQkNTICLijZzih4wn4oqCQFwi4oqCXCImcC3PgFwiXCIrz4AiIOKKgitAXDDih6ExMjkiLiziiLY74oiYwqzCscKv4oy14oia4peL4oyK4oyI4oGFPeKJoDziiaQ-4omlKy3Dl8O34pe_4oG_4oKZ4oan4oal4oig4qe74paz4oeh4oqi4oeM4pmt4ouv4o2J4o2P4o2W4oqa4oqb4oqd4pah4oqU4omF4oqf4oqC4oqP4oqh4oav4oaZ4oaY4oa74per4pa94oyV4oiK4oqXL-KIp1xc4oi14omh4oi64oqe4oqg4o2l4oqV4oqc4oip4oqT4oqD4oqZ4ouF4o2Y4o2c4o2a4qyaJz_ijaPijaQh4o6L4oas4pqCzrfPgM-E4oiefl9bXXt9KCnCr0AkXCLihpB8IyIKJnAg4oqCImRlY29kZWQ6XHQiIERlY29kZSAiw43CoyfCsEBcIsKwXCImcC3DmVwiXCIrw5kiIOKKgitAXDDih6ExMjkiLiziiLY74oiYwqzCscKv4oy14oia4peL4oyK4oyI4oGFPeKJoDziiaQ-4omlKy3Dl8O34pe_4oG_4oKZ4oan4oal4oig4qe74paz4oeh4oqi4oeM4pmt4ouv4o2J4o2P4o2W4oqa4oqb4oqd4pah4oqU4omF4oqf4oqC4oqP4oqh4oav4oaZ4oaY4oa74per4pa94oyV4oiK4oqXL-KIp1xc4oi14omh4oi64oqe4oqg4o2l4oqV4oqc4oip4oqT4oqD4oqZ4ouF4o2Y4o2c4o2a4qyaJz_ijaPijaQh4o6L4oas4pqCzrfPgM-E4oiefl9bXXt9KCnCr0AkXCLihpB8IyIK), score 4
```
‚çú‚áå'‚äÇ@"‚äÇ"&p-œÄ\""+œÄ
```
[Try it!](https://www.uiua.org/pad?src=ImhlbGxvIHdvcmxkIgrijZzih4wn4oqCQCLiioIiJnAtz4BcIiIrz4AK)
restricted set is `&p-"`
this would be much easier if the implicit stack printing didn't put quotes around strings, as it stands i could not get rid of &p, either `-` or `+` for offsetting the codepoints, or `"`, `$` , or `@` and a lot of `‚äÇ`s
[Answer]
# [brainfuck](https://github.com/TryItOnline/brainfuck), 76 bytes/ score 2
```
+++++[->+++++++++<],[<+[+>+[->>+>+<<<]>>[-<<+>>]+>[<[-]>-]<[<.+.->-]<.<<]>,]
```
[Try it online!](https://tio.run/##NYxBCoBADAMf1G1fEPKR0IMrCCJ4EHx/tYedS8IQMp/tvI93v6qskdMWyCGYjG35B4Ak5YCRaRTkSU8IYeHdoicjq@Y6/gA "brainfuck ‚Äì Try It Online")
All brackets are `<>` balanced so the reordering tool should help
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 171 bytes, score 14 `main(){}prtf&+`
```
#define f(c,d)for(k=c+1;k--;)printf(#d);
n;k;g(){f(n,main)}main(c){for(;c=~getchar(g());){f(,(a){)f(c+38?-2-c:9507,if(++a))f(,if\50)g(++n);f(,(printf(&a))\51{}})}f(,(){})}
```
[Try it online!](https://tio.run/##LU1LCsIwEN17ikpBZmgCrVL8hOLWG7jpJkySWlpTCd2FePU6ATeP950hORBtW2msG70tHJAw6JYAU0dVoyYpFX7C6FcHpUG182pSA2B04MVbjx5TRiB2eKSo@w52pZcOwC1UuShAY0S@XJ0ud3mUdLu29VmMDqpKIwdM@7bGgbVHlQf/jweO@7aJKWHKNkYm2/aw87yI4rmE2ex/ "C (gcc) ‚Äì Try It Online")
[Try Generated online!](https://tio.run/##7dNBCsIwEEbh20hC6aGGQEpAi6jgovTqjtqFy9ikEaHzVg8KFZz@X@iHEFRPkkYnfkrRdZ14Yijvb798//MljbfoDuK9n@b585xdkH1MPDdzpk6s2/jmAyMEI@ucYIWQDKC1iIDU9uYld7dw@9x/L70VWyV/H2zNaBkuIQXAapEBjZAW@rYIRCHB1m99YYxYstLCiyEzNadpdeLld14vqz5CPMpw1f7@BA "C (gcc) ‚Äì Try It Online")
[Answer]
# [Julia 1.0](http://julialang.org/), 75 bytes / score 5
```
!s="¬µ()=(¬µ(¬µ)=¬µ)"*join(("('¬µ'-('$('¬µ'-i+'¬µ')'-'¬µ'))" for i=s),'¬µ')
```
[Try it online!](https://tio.run/##yyrNyUw0rPj/X7HYVunQVg1NWw0geWirpi0QK2ll5WfmaWgoaagf2qquq6GuAmFkaoMoTXVdMKWppJCWX6SQaVusqQMW@F@sYKsA1qmuoG6lXqeuyVVQlJlXkpOnUYxgKgLZaUCFqWWJORq@qSWJegWJRcWpIHGEojQNICcls7ggJ7FSA27co46VQFX/AQ "Julia 1.0 ‚Äì Try It Online")
the used ascii characters are `'()-=`. Other characters used are `¬µ` (a lot) and `√¨` to `≈ä` depending on the needed characters.
creates a function that ouputs the string by concatenating Chars, which are constructed by substracting non-ascii characters, for example `'A' == '¬µ'-116 == '¬µ'-('ƒ©'-'¬µ')`
concatenation in Julia is `*`, which can be implied in some case. That's why we create the identity function `¬µ(¬µ)=¬µ`:
`¬µ('a')¬µ('b') == ¬µ('a')*¬µ('b') == 'a'*'b' == "ab"`
[Answer]
# Google Sheets, score 13 / 92 bytes
`=let(p,join(,"=",sort("—Å–∏–º–≤–æ–ª("&code(mid(A1,sequence(1,len(A1)),1))&")&")),left(p,len(p)-1))`
Put the input in cell `A1` and the formula in `B1`.
When the input is `abc123`, the formula gives this output:
`=—Å–∏–º–≤–æ–ª(97)&—Å–∏–º–≤–æ–ª(98)&—Å–∏–º–≤–æ–ª(99)&—Å–∏–º–≤–æ–ª(49)&—Å–∏–º–≤–æ–ª(50)&—Å–∏–º–≤–æ–ª(51)`
The set of printable ASCII in the output is `0123456789()&`.
The output is a valid formula in Google Sheets in any locale, including Latin locales such as United States. When the output is evaluated as formula, its result is `abc123`.
The formula uses the equivalent of the `char()` function in Cyrillic, `—Å–∏–º–≤–æ–ª()`, whose name doesn't match any Latin letters (`console.log('—Å–∏–º–≤–æ–ª'.match(/\w/))` ‚Üí `null`).
[Answer]
# [Unary](https://esolangs.org/wiki/Unary), \$8.71412 \times 10^{420}\$ bytes, score 1
‚Ä¶Obviously, I will not be posting the full code here. Or anywhere. It is `8714123138855978699360164050596229281826476597589481446286633953212548084711579903126530450262195558539773177853879595103615733973606156395440197295886222547053888870061749608029900423204725572303716359786086331805843402197818088474380787864934634643574154692137242860845559867854533001295180659830847166956220859057004333374262038608140098168588215568980939574816997785951406147471781245309306817118354877602371834815751` bytes long. That's a lot of bytes.
Handles all characters as input but `0`, which is the only character that appears in the output. A rare case where Unary does not trivialize a challenge like this? I've had my eyes set on a non-trivial score 1 answer for a while, and Unary is a perfect candidate.
[Here is the script I used to generate the program size](https://tio.run/##lVCxbtswEJ3DryDUIrBN8iwmyFKonLp06dJuDBtYiGwLiBVBlIC2hr7dfUfFaoImQw4g7/Teu3dHdUP5@3Tqu00T5WeZCScv8jwXBScrFJLNheFkBckLC05zssIjgQucrMgo9l3d0kPdVJEOm3Zx@Sm2D3W/pP7xbi/KumdBs@MpNpNKfv/x5es36qrNPe3iUC7WtF7Ko0yr@I@XQY6iHfoo507RDIey6mAwQ@xdL66WSTnJJ9EEbFuIb0T1i7PNKV@ttq0oN7G6szmgScsmUeyxCO/24fjE@zyM9O/LEm1bdR3GjPXbs37BeYUJS@oeh@Z@jXJaBE7MjfL2tq8PVcQCP4@zH8X6TyWNtOOYnU7eGKMVaaWISJE7Z3oRGrzWGlJcOIQ7KKddCqUU38Uc3jlvwONKH1w8QxDKO8MMmkwIEAByDiSrTfIwQXsYvyEDwIVCbZx60@s89DwYFQerPYQsQnsRHCsABz4KZMEzAKPCqszCNBTJxKM06eH/eaSGV5tmVQLxrJlmAgxzDDH7gk58EhRpezxJPf1sMyGv76LeF@TCXw), and here is the corresponding Brainfuck program (formatted with newlines for readability):
```
+>,>>>>>>+++>>>+<<<<<<<<<<[>>[-]+>[-]<<[>>>[-]>[-]+>[-]<<<<<+[>-<[>>+<<-]]>>[<<+
>>-]<[>>>-<<<<[-],[++>-<[>>+<<-]]>>[<<+>>-]<[<<->>-]]<-[>>+<<-]]>>[<<+>>-]<[>>[-
]+>[-]>[-]<<<<-]>>>>>[>>+[>[<-]<[->+<]>]>[->[>]>[>]+>+[<]<[<]>]+[<[>-]>[-<+>]<]<
<<<[<+>->>>>+[>[<-]<[->+<]>]>[>]+[<]+[<[>-]>[-<+>]<]<<<<]<[->+<]>[-<+>>-<]>[-<+>
]<<[->>+<+<]>>[-<<+>>>-<]>[-<+>]<<<[->>>+<+<<]>>>>-]+++<<<<<<-<]>>>>>>>>+[>[<-]<
[->+<]>]>[+++++++++++++++++++++++++++++++++++++++++++++++.>]
```
Assumes an interpreter with dynamic memory (right-infinite) and EOF = 0 (or 0x00 manually appended to the input).
Unfortunately, even this program is obscene, since we do still have 8-bit cells. We store the unary output program as a series of 1s on the tape, which grows exponential with the input size. As a proof of concept, [you can Try it online! with input 0x02](https://tio.run/##pVPRasMwDIQ@6lfO0hcY/YjxwzYYlEIfCv3@7KSSLFnJ6tCDKLJOPjuS8nn7OF@/71@XaWqqWmAFMDOYz2/boJAvpTCVho/RdnjxBICHJQTjMB2ArBf@tmStUmc096b8DJpchLOKEGiuwaBW7Z0JDLmTjGxNDe1SGguwk8dAOKDP2@@KzafmyXFDuo6DsKEaHqrnzhGiwxg7Qo6OxbanrOQ/gmOqOcrRnsbORFd49do9WsJwlzAgW6OrjNPjdATNNvaaA9PoptCzSG5Yb5Jl15KWUpykRTQIMsFFKNgNnXwmMCiekwY8pjvyfPlB5yr8luHphnhZwz8V9T5Npx8). This outputs some debug information to show that the corresponding program in Unary is `1 010 010 100 000` (corresponding to `++.>`), which corresponds to the 5,280 0s which follow that debug information.
# Explanation
Here is my fully commented corresponding Brainfuck program:
```
[-][
  ASSUMES:
   - Dynamic Memory Tape (Right-Infinite)
   - EOF = 0x00 and/or null terminated input
  for reference, the Unary bijection:
  | > corresponds to 000
  | + corresponds to 010
  | . corresponds to 100
  our desired output is Nx'0' characters, where
  |        +   +  ...  +   .   >   +   +  ...  +   .   >  ...
  | N = 1 010 010 ... 010 100 000 010 010 ... 010 100 000 ...
  |       {ord n.0 times}         {ord n.1 times}
  assuming dynamic tape memory (but finite cell size), since we need only to output
  in unary, we may store N as a unary integer in tape size
  
  our bit to unary algorithm can be expressed on a high level:
  | for each bit:
  |   n *= 2
  |   if bit:
  |     n++
  |   end if
  | end for
  
  we need to be able to stream bits from the input not proportional to the input size
  that is, there is a large, variable number of bits corresponding to each , input
  we will try to process this character-by-character instead of reading all the input
  and generating the corresponding bit string, and iterating over that afterwords, so
  as to hopefully avoid weird tape layouts
  
  assuming some procedure for emit, our algorithm works as:
  | emit 1
  | for each input character C:
  |   while C is not 0:
  |     emit 010
  |     C -= 1
  |   end while
  |   emit 100
  |   emit 000
  | end for
  | for each bit in unary representation, output '0'
  
  however, obviously, we do not procedure calls available to us. ideally, we linearize
  our loop to be in terms of processing emitted bits:
  | C = input
  | loop:
  |   if C == 0:
  |     emit_bits = 1 0 0
  |   elsif C == 255:
  |     emit_bits = 0 0 0
  |     C = input
  |     if C is EOF:
  |       break
  |     end if
  |     C = C + 1
  |   else:
  |     emit_bits = 0 1 0
  |   end if
  |   times 3:
  |     double bitstring
  |     if cur_bit:
  |       increment bitstring
  |     end if
  |     move_bit_right
  |   end times
  |   C -= 1
  | end loop
  
  we can abuse the fact our input is guaranteed to be printable ascii and use 255 (-1)
  as a state value to get an extra 3 bits per input character
  as for implementing this algorithm, our tape layout will be:
     0: L (looping counter for break)
     1: C (input character)
     2: t0 (temp)
     3: t1 (temp)
     4: e0 (emit bit)
     5: e1 (emit bit)
     6: e2 (emit bit)
     7: t3 (3 counter)
     8: 0 (0 padding)
     9: 0 (0 sentinel)
    10: 1 (start of unary representation)
]
real code starts here
+ set L
>, get input
>> move past temps
>>> move past e0 e1 e2
> +++ set counter
> > two 0s of padding
> + emit 1
debug initial unary representation
debug++++++++++++++++++++++++++++++++++++++++++++++++.------------------------------------------------
>debug++++++++++++++++++++++++++++++++.--------------------------------<
L < << <<< <<< < return to looping counter
[
  if else algorithm with (C t0 t1) tape layout
  C>
  temp0> [-]+ temp1> [-] C<< [
    IF C NOT ZERO
    >>
    >[-]  e0 = 0
    >[-]+ e1 = 1
    >[-]  e2 = 0
    <<< <<
    
    (temp0 temp1) = (1 0) at this point always so we can reuse them
    as long as they are that way to end with
    recall our if else algorithm requires t0 to be 1 initially anyway
    C+ test for c being 255 that is negative 1
    C[  {empty else}  temp0> - C< [temp1>>+C<<-]]
    temp1>>[C<<+temp1>>-]
    temp0<[
      {if 255 sentinel}
      e1>>>-  e1 = 0
      debug++++++++++.----------
      C<<<<[-]
      input ,
      here is where we need to detect EOF and set L accordingly
      we can use the same fact to reuse t0 t1 in our if statement
      C[
        ++ increment C
        temp0>-
        C<[temp1>>+C<<-]
      ]
      temp1>>[C<<+temp1>>-]
      temp0<[
        on EOF break by setting L to 0
        L<<-
        temp0>>
      temp0-]
      + restore temp0
      C<
  
      temp0>
    temp0-]
    C<
    restoration
    C-
    temp0>+
    <
  
  temp0> - C< [temp1>> + C<< -] ] temp1>> [C<< +temp1>> -] temp0< [
    IF C ZERO
    temp0
    > temp1
    >[-]+ e0 = 1
    >[-]  e1 = 0
    >[-]  e2 = 0
    <<<<<<
    temp0>>
  temp0-]
  
  debug contents of (e0 e1 e2)
  >>   debug++++++++++++++++++++++++++++++++++++++++++++++++.------------------------------------------------
  >    debug++++++++++++++++++++++++++++++++++++++++++++++++.------------------------------------------------
  >    debug++++++++++++++++++++++++++++++++++++++++++++++++.------------------------------------------------
  <<<< temp0 debug++++++++++++++++++++++++++++++++.--------------------------------
  
  >> e0
  
  ADVANCE THE TAPE
  >>>
  [
    >> seek to 0 sentinel
    +[>[<-]<[->+<]>]> seek right to first 1 in tape
    doubling loop
    [
      - erase current 1
      >[>] navigate to right border 0
      >[>] go past rightmost 1 on copy tape to second right border 0
      +>+  add two entries
      [<] go back to first right border 0
      <[<]> navigate to start of 1 tape
    ]
    tape to start was   e0 e1 e2  1 0  {a0 a1 a2 etc}
    tape to end is      e0 e1 e2  1 0  {0  0  0  etc}  0  {a0 a0 a1 a1 a2 a2 etc}
    +[<[>-]>[-<+>]<]< seek left to 1 sentinel
    <<< seek back to e0
  
    APPEND A ONE IF E0 IS NONZERO
    [
      <+> save to temp0
      - zero out to close loop
      append a 1
      >>>> seek to 0 sentinel
      +[>[<-]<[->+<]>]> seek to first 1 in tape
      [>] seek to end
      + append 1
      [<] seek to start
      +[<[>-]>[-<+>]<]< seek to count sentinel
      <<< seek back to e0
    ]
    <[->+<] add temp0 to e0 (either computes 0 plus 1 or 1 plus 0 so its idempotent)
    > focus back on e0
  
  
    permute e0 e1 e2 to e1 e2 e0
    [-<+>>-<]>[-<+>]<<[->>+<+<] swap{@1 @2}
    >>[-<<+>>>-<]>[-<+>]<<<[->>>+<+<<] swap{@2 @3}
    > refocus e0
  
    >>> seek to count sentinel
    - decrement
  ]
  reset counter +++
  END ADVANCE THE TAPE
  <<<<<
  C<-
  L<
]
>>>>>>>> move past last data entry
+[>[<-]<[->+<]>]> skip all 0s to our unary tape
for each one on the unary representation
[
  output a 0
  +++++++++++++++++++++++++++++++++++++++++++++++.>
]
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 25 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1), score 1
[Noodle man's idea](https://codegolf.stackexchange.com/a/266437/58974) with a different implementation.
```
'¬¨iU√î¬¨¬£"¬πd¬π"i'√ÑpXc√Éq"√£¬Ω√ë¬ª
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=J6xpVdSsoyK5ZLkiaSfEcFhjw3Ei473Ruw&input=IkhlbGxvLCBXb3JsZCEi)
## Explanations
### Code
```
'¬¨iU√î¬¨¬£"¬πd¬π"i'√ÑpXc√Éq"√£¬Ω√ë¬ª     :Implicit input of string U
'¬¨i                           :Prepend to "¬¨"
   U√î                         :  Reverse U
     ¬¨                        :  Split
      ¬£                       :  Map each X
       "¬πd¬π"i                 :    Prepend to "¬πd¬π"
             '√Ñp              :      "√Ñ" repeated
                Xc            :        Codepoint of X times
                  √É           :End map
                   q"√£¬Ω√ë¬ª     :Join with "√£¬Ω√ë¬ª"
```
### Output
Coming soon
[Answer]
# [Japt](https://github.com/ETHproductions/japt), ~~25~~ ~~32~~ 29 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1), score ~~2~~ 1
```
¬©"¬∫¬∫¬ª√Ç¬Ω{'√ÑpU√åc}¬πd¬π√£¬Ω√ë{√üU¬ØJ}¬π¬¨
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=qSK6urvCvXsnxHBVzGN9uWS5473Re99Vr0p9uaw&input=IkhlbGxvLCBXb3JsKiEi)
Saved 3 bytes thanks to @Shaggy!
The only ASCII character that the output uses is `d`. I am 99% certain that there is no way to get arbitrary strings without using `d`.
I didn't think that score 1 was possible until I was looking through Japt's docs for a method that could concatenate strings or lists whose name was non-ASCII. When I wrote my first solution, I dismissed what I saw as not being usable for the purpose of creating arbitrary strings. However, when returning to this problem yesterday, I found the method `√£`.
`√£` returns all substrings of a string, optionally taking a length that the substrings must be of. But as it turns out, it also takes an optional second parameter which is prepended to the list of substrings.
This solution recursively generates the resulting program with a string literal containing the boilerplate for the connection of each letter.
The first step is `¬©`, which does short-circuiting logical AND of the input and what follows. The result is that if the input is an empty string, it is returned, otherwise the program continues execution.
Now the string literal starts. The first bit is `¬∫¬∫¬ª¬Ω√ë`, followed by an interpolation of the expression `'√ÑpU√åc` which essentially converts a character to the string `√Ñ` repeated the codepoint of the character times. Then follows the string `¬πd¬π`.
* This section creates the code to have an arbitrary character without using ASCII (except for `d`). A single character is generated using a similar technique to my previous solution by using long lines of `¬ª¬Ω√ë√Ñ√Ñ√Ñ√Ñ√Ñ√Ñ‚Ä¶√Ñ√Ñ√Ñ√Ñ¬πd¬π`, which is essentially getting the character at codepoint `1+1+1+1...+1`, plus a longwinded way to get out of using parentheses.
Next, the string `√£¬Ω√ë` is the code to prepend the rest of the string.
The rest of the string's code is generated by recursing with the last character chopped off (`√üU¬ØJ`).
Finally, the string `¬π¬¨` will join each section from a list to a string.
[Answer]
# [MetaBrainfuck](https://github.com/bsoelch/MetaBrainfuck) `-x`, 30 bytes / score 2 (`+.`)
`43{_:+}{n:n{.}+++.---256n~{.}}`
*input as program argument*
produces a Brainfuck program that prints a Brainfuck program that prints the Input, then executes that program
## Explanation
```
43{_:+}                        ## output 42 times + (`_:` discards the loop counter)
       {n:                   } ## for each character `n` in the input
          n{.}                 ## repeat `.` n times
              +++.---          ## increment by 3, print decrement by 3
                     256n~{.}  ## repeat `.` 256-n times
```
`-x` executes the generated Brainfuck program, which outputs a program that for each character `C` in the input increments `C` times prints then increments 256-C times resetting the cell back to zero.
[Brainfuck Program created for input "Test"](https://ato.pxeger.com/run?1=m70yqSgxMy-tNDl7wYKlpSVpuha3WNy1iQd6NAAgY3V1dWlh9JAGo-GCBYwGCgQMwnCAlCfQYgVWvAAA) (the output for the program will be the result of executing that Brainfuck program):
```
+++++++++++++++++++++++++++++++++++++++++++....................................................................................+++.---.................................................................................................................................................................................................................................................................................+++.---..............................................................................................................................................................................................................................................................................+++.---.................................................................................................................................................................................................................................................................+++.---............................................................................................................................................
```
Running MetaBrainfuck `-x` on the (uncommented) Brainfuck created by the output of the original program will execute the program without modification and print the input of the original program
---
# MetaBrainfuck `-x` , 24 bytes / score 3 (`+.>`)
`{43{_:+}{.}".>"{>{+}.}>}`
*input as program argument*
produces a Brainfuck program that prints a Brainfuck program that prints the Input, then executes that program
## Explanation
```
{                      }   ## for each character in the input
 43{_:+}                   ## output 42 +  ( `_:` discards the loop counter)
        {.}                ## print . char-code many times
           ".>"{     }     ## for each character C in ".>"
                >{+}.      ## output  > followed by C times + followed by a .
                      >    ## print >
```
the produced Brainfuck program then prints C times `+` followed by `.>` for each character C in the input, the `-x` flag the immediately executes that program.
[Program created for input "Test"](https://ato.pxeger.com/run?1=m70yqSgxMy-tNDl7wYKlpSVpuha3WAS0iQd6NAB2JNgPcgKJ6inSTwv_jgbAaHAM6vCAFAzQ8gFWTgAA):
```
+++++++++++++++++++++++++++++++++++++++++++....................................................................................>++++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++.....................................................................................................>++++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++...................................................................................................................>++++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++....................................................................................................................>++++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>
```
[Answer]
# [Zsh](https://www.zsh.org/), score 12, 50 bytes
Set is `01234567$'\<`.
```
for c (${(s..)1})l+="\\$[[##8]#c]"
<<<'<<<$'\'$l\'
```
[Try it online!](https://tio.run/##qyrO@J@moanxPy2/SCFZQUOlWqNYT0/TsFYzR9tWKSZGJTpaWdkiVjk5VonLxsZGHYhV1GPUVXJi1P9rcnElFidnZtpqVMco6OnV1WpC@UBDsoCGgDm1XFxpCipgJhdXallijoJSAkwgQek/AA "Zsh ‚Äì Try It Online")
Converts each character into `\[N]NN` octal, evaluated by wrapping the string in `$' '` and printed with `<<<`.
[Answer]
# [Morsecco](https://codegolf.meta.stackexchange.com/a/26119/72726): 54 bytes, score 3
Being a three-symbol language, a meta-cat automatically reaches a score of 3:
```
> echo Test | morsecco '. . . - .-. -.- .- -.-. ... .  -.- - ---  -.-. ... ---'
.  -.-.-.. --..-.- ---..-- ---.-.. -.-.  -.- - ---
> morsecco '.  -.-.-.. --..-.- ---..-- ---.-.. -.-.  -.- - ---'
Test
```
* `. .` `E`nters an `E`nter command
* `. - .-.` `R`eads from stdin (special address `T`)
* `-.- .-` `K`onverts from `¬∑T`ext
* `-.-. ...` `C`oncatenates the dot and the converted input with two spaces for multi-token input
* `. -.- - ---`  is the multi-token input for the later `K`onvert to `T`ext and `O`utput
* `-.-. ...` `C`oncatenates this to the existing code
* `---` `O`utput the code
# [Morsecco](https://codegolf.meta.stackexchange.com/a/26119/72726): ~~¬†217¬†~~ 216 bytes, score 0
Yes, we can also do a zero-score version, because morsecco accepts alternatives for it's characters:
* TAB can be used instead of whitespace
* a long dash `‚Äì` (unicode 0x2013) can be used as dash
* the middle dot `¬∑` (unicode 0x00B7) can replace the dot
Of course, this adds a lot of bytes:
```
.  -- . -- .  . . .-- . . . - .-. -.- .- -.-. ... .  -.- - ---  -.-. ... 
-- - -.-. - -.- .- . .-..... .- --.. ..
. .---. .- --.. --.
- .- . -........-..-- -- --.. --.
. -.--.--- -- --- --. ..
. -..-
-.- - . - .-- --.
```
The first line remains the same just installing an error handler to silently exit on the end of input to avoid testing for more bytes, but then we need to loop over the string, cutting one byte each time and translating it, because by now morsecco has no substitution command.
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~200 192 184 211~~ 203 bytes, score ~~17~~ 16
```
#define P;printf(
#define Q{for(k=~i;k++P"a"))P
i;k;main(j,v)unsigned**v;{for(v++;i*4<strlen(*v);i++)Q"=a==a;");}P"main(){");for(;i--;)for(j=32;j--;)Q"+=");Q";");}if(i[*v]&1<<j)Q"++;");}}P"puts(&a);}");}
```
[Try it online!](https://tio.run/##NYy5DoMwEER7voI4EvIBRY5ucZ8SqhRRCgtMtEAM4nCDkl93bKR0@2bmbZW9qsq5Y60bNDouYJzQLA2N/km5NcNEO/lF6IQoiCKMFZEHeCs0tE0tW82ML6Nrzi3saysEIL/m8zL12lBuGaAQrCRSSamAMPgUZNfZ5iEogFkGLFytvJyhDVQSIX1dkt3AhuKD22dyyvM2dGKP/adxXWaaKA8hcM7ddN8PaXwfpr4@/AA "C (gcc) ‚Äì Try It Online")
The input cannot contain `aimnpstu=+;&(){}`
This produces C programs of the form
```
a=a==a;
aa=a==a;
...
main(){
  a++;...
  aa++;...
  puts(&a);
}
```
[Try it online!](https://tio.run/##S9ZNT07@/z/RNtHWNtE6EU4jGFBWbmJmnoZmNUhA2xZEWqMzta3xSNJdizY1LKMDU5ty3WABVIY2Xi5B9cSrpJYDiNRIuUeo4n4sXBAPiSJdSBu/UoIyRFAkuICgfjJ9A2Rrg8oVCKGNwcAnTDN9@IwiTjmQKCgtKdZQS9S0rv3/HwA "C (gcc) ‚Äì Try It Online")
Thanks to @l4m2 for score -1 and the note from @NoodleMan.
Less golfed version
```
#define P;printf(
#define Q{for(k=~i;k++P"a"))P
i;k;
main(j,v)unsigned**v;{
  for(v++;i*4<strlen(*v);i++)
    Q"=a==a;");
  }
  P"main(){");
  for(;i--;)
    for(j=32;j--;)
      Q"+=");
      Q";");}
      if(i[*v]&1<<j)
        Q"++;");
      }
    }
  P"puts(&a);}");
}
```
# [C (gcc)](https://gcc.gnu.org/) for Linux x86\_64, ~~271 260 253 239~~ 226 bytes, score 8
```
#define P;printf(
unsigned*b,x;i;main(l,v)int**v;{l=asprintf(&b,"j\1X\xbazokaj\1_ËÄÄok%s^\xf\5√É",v[1]);for(b[1]=b[3]=l-21;i*4<l;b++){P"mai");for(x=++i;x--P"n"))P"=");for(x='B:5\xc7';*b P"+%d",x),*b-=x)for(;*b<x;x/=10)P";");}}
```
[Try it online!](https://tio.run/##PY3LSgMxGIX3PsUYqZ3c0FGL4N9sXLnMTqFpZTKXEhszMqPDj6VQ8NF8mb5FjCjdHc73HU4l11UV41ndtC40mYa33oX3Nj/5CINbh6ZmViA4eC1dyL0YaaKMjbD1qhz@3XMryIspngza8rPblCk/H/b7bjMZVgZbM/v@ImJcFEsKbdfnNiVlF9dL5eVVAY7dzD1YzulWk3RD/ixUnDtAKTUJhFJN1BFM7@9mBqvbKTCbacInNRFIBbNSIf1VUj9HwAtVXKYhpOFuF2N8aLzvRPbY9b4@/QE "C (gcc) ‚Äì Try It Online")
The input cannot contain `aimn=+1;`
This produces C programs of the form
```
main=1+11+...;
mainn=1+1+11+111+...;
...
```
[Try it online!](https://tio.run/##S9ZNT07@/z83MTPPVtsQDrAyqczSxk8TTZFF4iXwYDiyBgUZOMy0gRDCIxyEFIQXhTStgpPYgERFmBAagughiitMqZDuiE6JxAUtaSFDVGLDDDF4qJATLFRPMSQkDELZCQMhfEqtFEDFjENijBPGuHIDqvcpY1At@slKv6SUAcjeRidJKVL@//@XnJaTmF78X7cqtSI1ubgkMTkbAA "C (gcc) ‚Äì Try It Online")
Such programs may require the compiler flag `-zexecstack` and may not work on some Linux distributions.
Now supports strings longer than 127 bytes.
Slightly less golfed
```
#define P;printf(
unsigned*b,x;
i;
main(l,v)int**v;{
  // push 1
  // pop rax
  // mov edx, <len of string>
  // push 1
  // pop rdi
  // call L1
  // <string>
  // L1:
  // pop rsi
  // syscall
  // ret
  l=asprintf(&b,"j\1X\xbazokaj\1_ËÄÄok%s^\xf\5√É",v[1]);
  for(b[1]=b[3]=l-21;i*4<l;b++){
    P"mai");
    for(x=++i;x--P"n"))
    P"=");
    for(x='B:5\xc7';*b P"+%d",x),*b-=x)
      for(;*b<x;x/=10)
    P";");
  }
}
```
[Answer]
# [Rattle](https://github.com/DRH001/Rattle), 23 bytes, score 3
```
|II^P[gn[b"+"]`b",=">]`
```
[Try it Online!](https://www.drh001.com/rattle/?flags=&code=%7CII%5EP%5Bgn%5Bb%22%2B%22%5D%60b%22%2C%3D%22%3E%5D%60&inputs=test123)
The input cannot contain `+,=` characters.
This generates Rattle code that uses `+` to increment from 0 to the ASCII value of each character before printing the ASCII character with `,` and resetting the counter with `=`. The new code therefore only uses the characters `+,=` for a score of 3.
# Explanation
```
|                     get input
 I                    save input characters to consecutive memory slots
  I^                  get length of input
    P                 set pointer to 0
     [...]`           repeat N times (N = input length)
     
g                     get the character at the pointer
 n                    get the ASCII value of this character
  [....]`             repeat M times (M = ASCII value of the character)
   b"+"               add "+" to the print buffer
         b",="        add ",=" to the print buffer
              >       move pointer right
```
This generates code of the form `++++++++++,=++++++++,=++++,=` (where there are lots more `+` depending on the ASCII value of the input characters).
[Answer]
# [YASEPL](https://github.com/madeforlosers/YASEPL-esolang), 24 bytes / score 2
```
=b$34¬ª=a'#hashtag!~!a~!~
```
the restricted char set being `#"`. YASEPL is not capable of template strings
[Answer]
# [GolfScript](http://www.golfscript.com/golfscript/), ~~24~~ ~~22~~ ~~18~~ 17 bytes, score 4
```
{("1+"*1n@}/'](+'
```
[Try it online!](https://tio.run/##S8/PSStOLsosKPn/v1pDyVBbScswz6FWXz1WQ1v9///EpGQA "GolfScript ‚Äì Try It Online")
The restricted set is `(]1+`. I'm pretty sure this is minimal, but GolfScript is a weird language and I'm no expert on it.
This constructs an a program that looks something like:
```
1
1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1
1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1
1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+](+
```
This pushes arbitrary codepoints to the stack with `1 1+1+...1+`, using a newline as whitespace because it isn't printable. Then, `]` ends a list literal, which turns the whole stack into a list because there was no previous `[`. Finally, `(+` coerces the list of codepoints to a string by adding it to the empty input, and the result is implicitly outputted.
Here's an explanation of the generator code, which I think is probably also as short as it can get:
```
{("1+"*1n@}/¬≠‚Å°‚Äã‚Äé‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å°‚Å™‚Äè‚Å†‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å£‚Å£‚Å™‚Äè‚Å†‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å£‚Å§‚Å™‚Äè‚Äè‚Äã‚Å°‚Å†‚Å°‚Äå‚Å¢‚Äã‚Äé‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å¢‚Å™‚Äè‚Äè‚Äã‚Å°‚Å†‚Å°‚Äå‚Å£‚Äã‚Äé‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å£‚Å™‚Äè‚Å†‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å§‚Å™‚Äè‚Å†‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å¢‚Å°‚Å™‚Äè‚Å†‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å¢‚Å¢‚Å™‚Äè‚Å†‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å¢‚Å£‚Å™‚Äè‚Äè‚Äã‚Å°‚Å†‚Å°‚Äå‚Å§‚Äã‚Äé‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å¢‚Å§‚Å™‚Äè‚Å†‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å£‚Å°‚Å™‚Äè‚Äè‚Äã‚Å°‚Å†‚Å°‚Äå‚Å¢‚Å°‚Äã‚Äé‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å£‚Å¢‚Å™‚Äè‚Äè‚Äã‚Å°‚Å†‚Å°‚Äå¬≠
{         }/  # ‚Äé‚Å°For each character of the (implicit) input:
 (            # ‚Äé‚Å¢  Decrement the codepoint.
  "1+"*       # ‚Äé‚Å£  Repeat "1+" that many times.
       1n     # ‚Äé‚Å§  Push the number 1, then push a newline.
         @    # ‚Äé‚Å¢‚Å°  Move the "1+1+..." string to the top of the stack.
'](+'         # Push the string ](+ to the stack.
              # The entire stack is implicitly outputted.
üíé
```
Created with the help of [Luminespire](https://vyxal.github.io/Luminespire).
]