[Question]
  [
My previous challenge, [Print invisible text](https://codegolf.stackexchange.com/questions/122703/print-invisible-text) was quite popular, likely due to how trivial it is.
However those more observant of you may have noticed that you're not really printing invisible text, because it's impossible to read what was inputted given only the output.
So I figured how about a *real* invisible text challenge.
Given a string consisting of only printable ASCII characters (`0x20-0x7E`), convert each character to a distinct Unicode character (in UTF-8 encoding) that is not one of the 95 printable ASCII characters (any UTF-8 character outside of the `0x20-0x7E` range)
## Input
A string of printable ASCII characters, either as a string or character array/list
## Output
The input string with each character replaced with a distinct non-printable character. Each given character must have a corresponding non-printable character that is not used as the substitute for any other character.
If you are unable to print non-printable characters, you can output the character values instead.
For example if your code replaces all lowercase `a`'s with `0x01`, you may not use `0x01` as the substitution for any other characters.
Your code must also be **deterministic**. This means that if, given the string `Hello`, all lowercase `l`'s are replaced with `0x03`, your code must also replace all lowercase `l`'s with `0x03` given any other string.
### Testcases
It's somewhat difficult to write testcases for this challenge, so I'll simply show the output as a list of hexcodes
```
input     -> output
"Hello"   -> [0x01, 0x02, 0x03, 0x03, 0x04]
"Hi!"     -> [0x01, 0x05, 0x06]
""        -> []
"   H   " -> [0x07, 0x07, 0x07, 0x01, 0x07, 0x07, 0x07]
"yo! "    -> [0x08, 0x04, 0x06, 0x07]
```
## Leaderboard
Here is a Stack Snippet to generate both a regular leaderboard and an overview of winners by language.
```
/* Configuration */
var QUESTION_ID = 123447; // Obtain this from the url
// It will be like https://XYZ.stackexchange.com/questions/QUESTION_ID/... on any question page
var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";
var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk";
var OVERRIDE_USER = 48934; // This should be the user ID of the challenge author.
/* App */
var answers = [], answers_hash, answer_ids, answer_page = 1, more_answers = true, comment_page;
function answersUrl(index) {
  return "https://api.stackexchange.com/2.2/questions/" +  QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER;
}
function commentUrl(index, answers) {
  return "https://api.stackexchange.com/2.2/answers/" + answers.join(';') + "/comments?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + COMMENT_FILTER;
}
function getAnswers() {
  jQuery.ajax({
    url: answersUrl(answer_page++),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      answers.push.apply(answers, data.items);
      answers_hash = [];
      answer_ids = [];
      data.items.forEach(function(a) {
        a.comments = [];
        var id = +a.share_link.match(/\d+/);
        answer_ids.push(id);
        answers_hash[id] = a;
      });
      if (!data.has_more) more_answers = false;
      comment_page = 1;
      getComments();
    }
  });
}
function getComments() {
  jQuery.ajax({
    url: commentUrl(comment_page++, answer_ids),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      data.items.forEach(function(c) {
        if (c.owner.user_id === OVERRIDE_USER)
          answers_hash[c.post_id].comments.push(c);
      });
      if (data.has_more) getComments();
      else if (more_answers) getAnswers();
      else process();
    }
  });  
}
getAnswers();
var SCORE_REG = /<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/;
var OVERRIDE_REG = /^Override\s*header:\s*/i;
function getAuthorName(a) {
  return a.owner.display_name;
}
function process() {
  var valid = [];
  
  answers.forEach(function(a) {
    var body = a.body;
    a.comments.forEach(function(c) {
      if(OVERRIDE_REG.test(c.body))
        body = '<h1>' + c.body.replace(OVERRIDE_REG, '') + '</h1>';
    });
    
    var match = body.match(SCORE_REG);
    if (match)
      valid.push({
        user: getAuthorName(a),
        size: +match[2],
        language: match[1],
        link: a.share_link,
      });
    
  });
  
  valid.sort(function (a, b) {
    var aB = a.size,
        bB = b.size;
    return aB - bB
  });
  var languages = {};
  var place = 1;
  var lastSize = null;
  var lastPlace = 1;
  valid.forEach(function (a) {
    if (a.size != lastSize)
      lastPlace = place;
    lastSize = a.size;
    ++place;
    
    var answer = jQuery("#answer-template").html();
    answer = answer.replace("{{PLACE}}", lastPlace + ".")
                   .replace("{{NAME}}", a.user)
                   .replace("{{LANGUAGE}}", a.language)
                   .replace("{{SIZE}}", a.size)
                   .replace("{{LINK}}", a.link);
    answer = jQuery(answer);
    jQuery("#answers").append(answer);
    var lang = a.language;
    if (/<a/.test(lang)) lang = jQuery(lang).text();
    
    languages[lang] = languages[lang] || {lang: a.language, user: a.user, size: a.size, link: a.link};
  });
  var langs = [];
  for (var lang in languages)
    if (languages.hasOwnProperty(lang))
      langs.push(languages[lang]);
  langs.sort(function (a, b) {
    if (a.lang > b.lang) return 1;
    if (a.lang < b.lang) return -1;
    return 0;
  });
  for (var i = 0; i < langs.length; ++i)
  {
    var language = jQuery("#language-template").html();
    var lang = langs[i];
    language = language.replace("{{LANGUAGE}}", lang.lang)
                       .replace("{{NAME}}", lang.user)
                       .replace("{{SIZE}}", lang.size)
                       .replace("{{LINK}}", lang.link);
    language = jQuery(language);
    jQuery("#languages").append(language);
  }
}
```
```
body { text-align: left !important}
#answer-list {
  padding: 10px;
  width: 290px;
  float: left;
}
#language-list {
  padding: 10px;
  width: 290px;
  float: left;
}
table thead {
  font-weight: bold;
}
table td {
  padding: 5px;
}
```
```
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b">
<div id="answer-list">
  <h2>Leaderboard</h2>
  <table class="answer-list">
    <thead>
      <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr>
    </thead>
    <tbody id="answers">
    </tbody>
  </table>
</div>
<div id="language-list">
  <h2>Winners by Language</h2>
  <table class="language-list">
    <thead>
      <tr><td>Language</td><td>User</td><td>Score</td></tr>
    </thead>
    <tbody id="languages">
    </tbody>
  </table>
</div>
<table style="display: none">
  <tbody id="answer-template">
    <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr>
  </tbody>
</table>
<table style="display: none">
  <tbody id="language-template">
    <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr>
  </tbody>
</table>
```
  
[Answer]
# [Whitespace](https://web.archive.org/web/20150618184706/http://compsoc.dur.ac.uk/whitespace/tutorial.php), ~~39~~ 36 bytes
```
  
   	  
 
  
 	
	 				  
	
  
 
```
[Try it online!](https://tio.run/nexus/whitespace#@8@loABECpwgCszm5OJU4AQCIJsTLMDF9f9/SWpxCQA "Whitespace – TIO Nexus")
## Explanation
```
nssn  ; label 'loop'
ssstssn ; push 4 to use as a multiplication operand
sns   ; dup 4 to use as a heap address
sns   ; dup 4 to use as a heap address
tnts  ; getchar and store at address 4
ttt   ; retrieve the value at address 4
tssn  ; multiply the character value by 4
tnss  ; putchar output the new character
nsnn  ; jmp 'loop'
```
Originally I wanted to multiply by -0 or -1 since they would be the shortest digits possible to declare in Whitespace. TIO does not differentiate between -0 and +0 so that's out. Unfortunately while the tutorial/spec is ambiguous about how to interpret a negative value as a char TIO (rightly) throws an error about the invalid argument so that also isn't an option.
The next shortest working constant is 4 so we end up performing the same basic approach as the Powershell/Pyth solutions.
---
# [Whitespace](https://web.archive.org/web/20150618184706/http://compsoc.dur.ac.uk/whitespace/tutorial.php), ~~56~~ 53 bytes - maps to tag characters
```
  
   			                 
 
  
 	
	 				   	
  
 
```
[Try it online!](https://tio.run/nexus/whitespace#@8@loABECpycnArogEsBLMnJxQmSBslzggW4uP7/L0ktLgEA "Whitespace – TIO Nexus")
## Explanation
Effectively the same approach as the previous version except this uses 0xE0000 as the constant and adds instead of multiplies. This maps the visible ASCII characters to the corresponding Unicode Tag Character (the range U+E0000-U+E007F). The intended use for this range was to indicate the language of the text in a plaintext file however that use is discouraged. This code will output valid labels if you prefix strings with a 0x01 character.
The [Unicode Standard](http://www.unicode.org/versions/Unicode9.0.0/ch23.pdf) says that characters in this range have no visible rendering so I feel this meets the spirit of the challenge better than the previous approach.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 3 bytes
```
O²Ọ
```
[Try it online!](https://tio.run/##y0rNyan8/9//0KaHu3v@//@v5AEUyFdUAgA "Jelly – Try It Online")
Squares each codepoint.
[Answer]
# [Japt](https://github.com/ETHproductions/japt), ~~5~~ 2 bytes
```
cp
```
[Try it online](https://ethproductions.github.io/japt/?v=1.4.4&code=Y3A=&input=IkhlbGxvLCBXb3JsZCEi)
---
## Explanation
```
     :Implicit input of string U
c    :Map over the character codes of the string.
p    :Square them.
     :Implicit output of result.
```
[Answer]
# [Brain-Flak](https://github.com/DJMcMayhem/Brain-Flak), 33 bytes
Includes +1 for `-c`
```
{((({}){}){}<>)<>}<>{({}<>)<>}<>
```
[Try it online!](https://tio.run/nexus/brain-flak#@1@toaFRXasJRjZ2mjZ2QLJaA8H@/19BUUlZRVVNXUNTS1tHV0/fwNDI2MTUzNzC0sraxtbO3sHRydnF1c3dw9PL28fXzz8gMCg4JDQsPCIyKjomNi4@ITEpOSU1LT0jMys7Jzcvv6CwqLiktKy8orKquqa27r9uMgA "Brain-Flak – TIO Nexus")
```
# For each character
{
  # Multiply by 4 and move to the other stack
  ((({}){}){}<>)
# End loop
<>}
# For each character on the other stack
<>{
  # Copy it back (reverse the stack)
  ({}<>)<>
# End loop
}<>
```
[Answer]
# Braingolf v0.6, 17 bytes
```
VRl1-M[R.*>v]R&@
```
Squares each char value then prints.
*-1 byte thanks to Erik the Outgolfer's squaring solution*
# Braingolf v0.7, 6 bytes [non-competing]
```
{.*}&@
```
Also squares each value then prints, but v0.7 has the "foreach" `{}` loop
[Answer]
## Mathematica, 48 bytes
```
FromCharacterCode[4Mod[Hash/@Characters@#,978]]&
```
Explanation:
```
                             Characters@#      & - Convert string to array of characters
                       Hash/@                    - Hash them all using default hash
                   Mod[                  ,978]   - apply a modulus which uniquely transforms each potential character's hash into a number
                  4                              - times by 4 to move values out of 0x20-0x7E.
FromCharacterCode[                            ]  - Convert array of numbers back to string
```
Interestingly of the two modulus options less than 1000 which changed the 96 characters into 96 unique values with modulus 978 the lowest two values were 7 then 33. Luckily times by 4 converts this to 28 and 132 which both just fall outside the visible range. If I used the other modulus of 784 then I needed to multiply by 18 to move the numbers outside the range.
Test case.
Note: extra backslashes in there as escape characters for `"` and `\`. Also character 0x7E doesn't seem to want to paste correctly.
```
Input: "!\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~"
```
Output:
[![enter image description here](https://i.stack.imgur.com/7Od25.png)](https://i.stack.imgur.com/7Od25.png)
The use of `Hash` came about as `ToCharacterCode` is really long. However hashing it was nearly as expensive. The easy mathematica way to do this would be 49 bytes:
```
FromCharacterCode[4ToCharacterCode@Characters@#]&
```
[Answer]
# [Vyxal](https://github.com/Lyxal/Vyxal) `s`, 3 bytes
```
C²C
```
[Try it Online!](http://lyxal.pythonanywhere.com?flags=s&code=C%C2%B2C&inputs=Hello&header=&footer=)
That is,
```
C   # string to character codes
²C  # square each and convert back to letters
    # the s flag joins as a single string. 
```
but if IO was a little less restrictive:
## using `K` flag, 1 byte
```
²
```
[Try it Online!](http://lyxal.pythonanywhere.com?flags=K&code=%C2%B2&inputs=Hello&header=&footer=)
Keg is weird okay. It just is.
```
    # the K flag enables Keg mode, which makes integers and characters interchangeable. It's a tribute to my first golfing language and existed before I saw this challenge
²   # square the code point of each character
    # output that as characters because K flag.
```
[Answer]
# Google Sheets, 68 bytes
```
=ArrayFormula(Join("",IfError(Char(Code(Mid(A1,Row(A:A),1))^2),"")))
```
I wanted to post this to show how awkward it is to do some basic functions in Sheets. Do you want to do an operation to every character in a cell and out the concatenated result? You're at 42 bytes before you even *act* on those characters.
```
=ArrayFormula(Join("",Mid(A1,Row(A:A),1)))
```
Otherwise, this is the same as other solutions: square the code point of each character.
[Answer]
# [CJam](https://sourceforge.net/p/cjam), ~~8~~ 5 bytes
```
l95f+
```
[Try it online!](https://tio.run/##S85KzP3/P8fSNE37//@M1JycfEUA "CJam – Try It Online")
Adds 95 to each codepoint.
[Answer]
# Pyth, 6 bytes
```
smC*4C
```
[Try it here.](http://pyth.herokuapp.com/?code=smC%2a4C&test_suite=1&test_suite_input=%22hello%21%22&debug=0)
Multiplies each codepoint by 4.
[Answer]
# PowerShell, ~~32~~ 31 Bytes
-1 Thanks to neil, `99+` to `4*`
```
[char[]]"$args"|%{[char](4*$_)}
```
multiplies 9 by each character code and prints it back.
[Answer]
# [Subleq](https://esolangs.org/wiki/Subleq) (8-bit), 11 bytes
```
-1 15 -128
2 15 -1
15 -1 9
15 15 
```
[Subleq Emulator](http://mazonka.com/subleq/online/hsqjs.cgi)
## Explanation
```
-1 15 -128 '0: input to 15:, if null exit; use -128 for exit so I can be used to add 128
           '   in the next line saving a byte
2 15 -1    '3: 15: = 15: + 128
15 -1 9    '6: output 15:
15 15      '9: 15: = 0, goto 0; final 0 is not entered saving a byte
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 4 bytes
```
ÇnçJ
```
[Try it online!](https://tio.run/##MzBNTDJM/f//cHve4eVe//9npObk5CsCAA "05AB1E – Try It Online")
Squares each codepoint.
[Answer]
# [CJam](https://sourceforge.net/p/cjam), 4 bytes
```
lWf^
```
XORs each code point with **-1**. CJam's characters are 16 bits wide, so this maps code point **n** to code point **65535 - n**.
[Try it online!](https://tio.run/##S85KzP3/Pyc8Le7/f4/UnJx8AA "CJam – Try It Online")
[Answer]
# [Decimal](//github.com/aaronryank/Decimal), 37 bytes
```
91D31030030012255D412D590D543D301291D
```
Explanation:
```
91D             ; declare jump 1
    310         ; push user input to stack
    300         ; duplicate
    300         ; duplicate
    12255D      ; push EOF to stack
    412D        ; compare top two values, pop, push result
    5 90D 5     ; if result == true, quit
    43D         ; multiply top two values, pop, push result
    301         ; print
    2           ; pop
91D             ; goto jump 1
```
[Try it online!](https://tio.run/##S0lNzsxNzPn/39LQhUsBCIwNDSC0ASptaGRkagpRYmJoBGGYKlgauCiYQgSNofoNDMG0ERfQxP//E5EAAA)
[Answer]
# [Husk](https://github.com/barbuz/Husk), 5 bytes
```
m(c□c
```
[Try it online!](https://tio.run/##yygtzv7/P1cj@dG0hcn///9X8kjNycnXUQjPL8pJUVQCAA "Husk – Try It Online")
[Answer]
# [brainfuck](https://github.com/TryItOnline/brainfuck), 12 bytes
```
,[[->-<]>.,]
```
[Try it online!](https://tio.run/##SypKzMxLK03O/v9fJzpa107XJtZOTyf2/38FxRglZRVVNXUNTS1tHV09fQNDI2MTUzNzC0sraxtbO3sHRydnF1c3dw9PL28fXz//gMCg4JDQsPCIyKjomJjYuPiExKTklNS09IzMrOyc3Lz8gsKi4pLSsvKKyqrqmto6AA "brainfuck – Try It Online")
Negate assuming latin1 output
[Answer]
# [Grok](https://github.com/AMiller42/Grok-Language), 14 bytes
```
:j
}lI_p+wYp
q
```
Modification of [this](https://codegolf.stackexchange.com/a/223339/101522) cat program. It adds 95 to every character before it gets outputted, changing the character range from `0x0A - 0x7E` to `0x7F - 0xDD`.
[Answer]
# Python 3, 40 38 bytes
```
print([chr(ord(x)*9)for x in input()])
```
[Try It Online!](https://repl.it/IY9G/0)
[Answer]
# C, 42 bytes
```
c;f(){while(~(c=getchar()))putwchar(c*c);}
```
Assumes a UTF-8 locale. Input is squared.
[Try it online!](https://tio.run/##S9ZNT07@r5yZl5xTmpKqYJOTn5yYk6qXYfc/2TpNQ7O6PCMzJ1WjTiPZNj21JDkjsUhDU1OzoLSkHMxO1krWtK79n5uYmQdUW5xaAtGu4eMc7@jjo6OkpAkyBKjCw9XHx18h3D/IxwUA)
[Answer]
# [Clean](https://clean.cs.ru.nl), 25 bytes
```
import StdEnv
```
# 
```
map((+)'~')
```
A partial function literal.
[Try it online!](https://tio.run/##S85JTcz7/z83P6U0J1UhNzEzjysztyC/qEQhuCTFNa@MK7gkEcixBUoVaGhoa6rXqWsqRKt7pObk5KvH/v//LzktJzG9@L@up89/l8q8xNzM5GIA "Clean – Try It Online")
**Realistically:**
```
f s = {# c+'~' \\ c <-: s}
```
Unboxed array comprehension over an unboxed array of the same type (`{#Char} -> {#Char}`). Clean will be able to determine that the uniqueness is transferrable (`!u:{#Char} -> u:{#Char}`), and that the size is the same as the input size. This means that if you pass a `*String`, every character will be destructively updated with the corresponding one in the output, meaning no memory allocation or movement is done and the graph node is fully reused.
[Try it online!](https://tio.run/##S85JTcz7/z83P6U0J1UhNzEzjysztyC/qEQhuCTFNa@MK02hWMFWoVpZIVlbvU5dISZGIVnBRtdKobiWK7gkEajOViFNQckjNScnX@n//3/JaTmJ6cX/dT19/rtU5iXmZiYXAwA "Clean – Try It Online")
[Answer]
# [Erlang (escript)](http://erlang.org/doc/man/escript.html), 18 bytes
One of the rare cases that Erlang is ever competitive.
```
f(X)->[I*I||I<-X].
```
[Try it online!](https://tio.run/##Sy3KScxL100tTi7KLCj5z/U/TSNCU9cu2lPLs6bG00Y3Ilbvf25iZp5GdCxQmEsBCDLzrdLKizJLUjXSNJSAfA8gVtLU1AGK5@VoaOpgKvJIzcnJByrFq6gyX1EBZBx@kzIVQWrwKwKrQFGk9x8A "Erlang (escript) – Try It Online")
# Explanation
```
f(X)-> % Function taking a single string as input
[I*I|| % Square the code-point ...
I<-X]. % ... for every character taken from the string
```
[Answer]
# [Kotlin](https://kotlinlang.org), 25 bytes
Subtract **99** from each character value. This ends up moving space to FFBD (as Kotlin uses UTF-16) and most of the ASCII set to control characters and unreadable garbage. 
```
{fold(""){s,c->s+(c-99)}}
```
[Try it online!](https://tio.run/##ZY7BbsIwDIbvPIWVC4mgEZMmJJBgBy4g7cb2AIGmk7fgRK1Bk6o@e3E26AH@i2V/9v/7J3JA6i8uANIFGzwEv4Q910hfVhso1rcGVn1bxVBqpUzbTI/FupnoY7FYmK7rqzPBySHJQTsCUfZj/8uwgtq78h3JC3tbglIDlzzBQ6rO@@aPJgnkQFrY08CeXLqFZCFbjjtibaT@f6pf5mbgWTa5cs@uZv06hfFs/EA5fqbk641r5MeMOvsdkT7udgqUMaOu3/oQ4hU "Kotlin – Try It Online")
[Answer]
# [Duocentehexaquinquagesimal](https://esolangs.org/wiki/Duocentehexaquinquagesimal), 5 bytes
```
SYÍ’ü
```
[Try it online!](https://tio.run/##S0oszvifnFhiYxPzqGGRXbx1cWqKgm6mgrphsXWcNVDIWl0hXsHILq80x7qkqDQPqDRVQbdY11Ah3jo1OSNfQTdPQR2oLOnQMuPDW5yP7stQsrPR1tXTiY5VetSw0Evdzg6isEY/v6BEP784MSkzFUopxNslWYOFk4oSM/PSSpOzESyFpP/BkYd7HzXMPLznP9CC/x6pOTn5AA)
[Answer]
# [Python 3](https://docs.python.org/3/), 47 bytes
```
lambda x:''.join(chr(y-32+(y>63)*98)for y in x)
```
Input must be bytes. I know this doesn't win, I'm posting it because the output could fit into an 8-bit ascii extension.
[Try it online!](https://tio.run/##DcHJDYAgEADAVvi5eIVI4pVoJX7wQDG6GOTBVo/OPOQPizLqYYqXuudVsdAnSXlag7AcDqiQVQY01pKnXcu1dYyYQRZ4fJxBDxpm8tsLTuG@gQiVyEVoNP/FDw "Python 3 – Try It Online")
[Answer]
# [Thunno](https://github.com/Thunno/Thunno) `J`, 4 bytes
(Actually \$ 4 \log\_{256}(96) \approx \$ 3.29 bytes but the leaderboard doesn't take decimals)
```
O2^C
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m72sJKM0Ly9_abSSl1LsgqWlJWm6Fkv8jeKcIUyoyIK1Hqk5Ofk6CuH5RTkpihBBAA)
#### Explanation
```
O     # Ordinals of the input
 2^   # Square each ordinal
   C  # Convert back to characters
      # J flag joins the list
```
]