[Question]
  [
# Please note: *this is a* [restricted-source](/questions/tagged/restricted-source "show questions tagged 'restricted-source'") *challenge — see details below!*
Each natural number \$n\$ has 10 *faces*: its decimal representations in bases \$1\$ through to \$10\$. For example, the 10 faces of \$12\$ are \$[111111111111, 1100, 110, 30, 22, 20, 15, 14, 13, 12]\$, and the 10 faces of \$4\$ are \$[1111, 100, 11, 10, 4, 4, 4, 4, 4, 4]\$
We can then say that two numbers *face* each other \$n\$ times if they share \$n\$ faces, counting duplicate faces repeatedly. For instance \$12\$ and \$4\$ do *not* share a face as no number is in both of their list of faces, whereas \$6\$ and \$11\$ do:
* \$\text{faces}(6) = [111111, 110, 20, 12, 11, 10, 6, 6, 6, 6]\$
* \$\text{faces}(11) = [11111111111, 1011, 102, 23, 21, 15, 14, 13, 12, 11]\$
Both \$11\$ and \$12\$ are in both lists, so \$6\$ and \$11\$ share 2 faces, and so face each other twice.
Finally, we will say that any pair of numbers has a *closeness*, which is defined as the number of times the two numbers face each other. So far we already have:
* \$\text{closeness}(12, 4) = 0\$
* \$\text{closeness}(6, 11) = 2\$
Notice that \$\text{closeness}(1, 1)\$ is \$100\$ because all 100 possible pairs of \$1\$'s faces are equal i.e. duplicate faces count multiple times.
Your task is, given two natural numbers \$a\$ and \$b\$, output \$\text{closeness}(a, b)\$. You may take input and output in [any convenient method or format](https://codegolf.meta.stackexchange.com/questions/2447/default-for-code-golf-input-output-methods).
However, **your program must only consist of pairs of characters that face each other**. In order to determine if a pair of characters face each other, take their code points \$(m, n)\$ in whatever code page you are using to score your program, then, if \$\text{closeness}(m, n) \ne 0\$, then that pair of characters faces each other and can be in your program. This applies to all *overlapping* pairs in your program. So if your code is `abcd`, then `ab`, `bc` and `cd` must all be pairs that face each other.
You may use any *pre-existing* code page to score your answer, but it must have existed before this challenge was posted.
For instance, none of the pairs of letters in `print` (`pr`, `ri`, `in` and `nt`) face each other, so your code cannot contain any of those pairs of characters. However, all the pairs in `(p b>` (`(p`, `p` ,  `b` and `b>`) do face each other, so your code may contain them. [Here](https://pastebin.com/HcPBpddJ) is a newline-separated list of printable ASCII pairs that face each other for reference, [this](https://pastebin.com/2rugjawG) (Thanks to [@Kevin Cruijssen](https://codegolf.stackexchange.com/users/52210/kevin-cruijssen)) is a list of all pairs of integers between \$0\$ and \$255\$ which face each other, and [this](https://tio.run/##AT0Awv9qZWxsef//YuKxruKBteG4jCk9w74vRlMKOTVwYCszMcOHxofhu4wK4bmhMmXigqzColD///8iKHAgYj4i) is a Jelly program which verifies that a given string complies with the rules, according to Unicode encoding. It does take 10-15 seconds to run, so be patient with it.
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the shortest code in bytes wins
## Test cases
```
a, b => closeness(a, b)
24, 35 => 1
10, 15 => 0
50, 11 => 0
18, 12 => 3
16, 15 => 2
 1,  1 => 100
12, 10 => 5
30, 18 => 2
 6,  6 => 22
20,  4 => 0
 3, 35 => 0
23,  3 => 0
```
Here is a list of \$\text{closeness}(a, b)\$ for all pairs \$\{(a, b) \:|\: 1 \le a \le 50, 1 \le b \le 50\}\$, where the \$n\$-th element of the \$m\$-th row is the result for \$\text{closeness}(m, n)\$:
```
[100, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[0, 66, 2, 2, 2, 2, 2, 2, 2, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[0, 2, 52, 2, 2, 2, 3, 2, 2, 2, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0]
[0, 2, 2, 40, 2, 2, 2, 2, 3, 2, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0]
[0, 2, 2, 2, 30, 3, 3, 3, 3, 4, 2, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]
[0, 2, 2, 2, 3, 22, 3, 4, 3, 4, 2, 3, 0, 1, 0, 1, 0, 1, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0]
[0, 2, 3, 2, 3, 3, 16, 4, 5, 4, 4, 2, 3, 0, 1, 0, 1, 0, 1, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0]
[0, 2, 2, 2, 3, 4, 4, 12, 4, 6, 3, 4, 1, 2, 0, 2, 0, 2, 0, 2, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[0, 2, 2, 3, 3, 3, 5, 4, 10, 5, 5, 3, 3, 1, 1, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0]
[0, 2, 2, 2, 4, 4, 4, 6, 5, 10, 4, 5, 2, 3, 0, 2, 1, 2, 0, 2, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]
[0, 1, 1, 1, 2, 2, 4, 3, 5, 4, 10, 4, 5, 2, 3, 0, 2, 1, 2, 0, 2, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[0, 0, 0, 0, 1, 3, 2, 4, 3, 5, 4, 10, 3, 4, 2, 2, 0, 3, 0, 3, 1, 1, 0, 1, 0, 0, 1, 0, 0, 2, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0]
[0, 0, 1, 0, 0, 0, 3, 1, 3, 2, 5, 3, 10, 3, 4, 2, 2, 0, 3, 0, 3, 1, 1, 0, 1, 0, 0, 1, 0, 0, 2, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 1, 0, 2, 1, 3, 2, 4, 3, 10, 2, 4, 1, 3, 0, 4, 0, 3, 1, 1, 0, 1, 0, 0, 1, 0, 0, 2, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0]
[0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 3, 2, 4, 2, 10, 2, 3, 2, 2, 0, 4, 0, 1, 3, 0, 0, 2, 0, 0, 2, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0]
[0, 0, 0, 1, 0, 1, 0, 2, 1, 2, 0, 2, 2, 4, 2, 10, 1, 3, 1, 3, 0, 3, 0, 1, 3, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0]
[0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 2, 0, 2, 1, 3, 1, 10, 1, 3, 1, 3, 0, 3, 0, 1, 3, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2]
[0, 0, 0, 0, 0, 1, 0, 2, 0, 2, 1, 3, 0, 3, 2, 3, 1, 10, 0, 3, 2, 2, 0, 3, 0, 0, 3, 0, 0, 2, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]
[0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 2, 0, 3, 0, 2, 1, 3, 0, 10, 0, 3, 2, 2, 0, 3, 0, 0, 3, 0, 0, 2, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 2, 0, 2, 0, 2, 0, 3, 0, 4, 0, 3, 1, 3, 0, 10, 0, 3, 1, 3, 0, 2, 0, 1, 1, 1, 0, 2, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0]
[0, 0, 1, 0, 0, 0, 2, 0, 1, 0, 2, 1, 3, 0, 4, 0, 3, 2, 3, 0, 10, 0, 2, 2, 2, 0, 2, 0, 1, 2, 1, 0, 2, 0, 0, 1, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 3, 0, 3, 0, 2, 2, 3, 0, 10, 0, 2, 2, 2, 0, 2, 0, 1, 2, 1, 0, 2, 0, 0, 1, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 1, 0, 3, 0, 2, 1, 2, 0, 10, 0, 2, 2, 2, 0, 2, 0, 1, 2, 1, 0, 2, 0, 0, 1, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 3, 1, 0, 3, 0, 3, 2, 2, 0, 10, 0, 1, 2, 2, 0, 2, 0, 2, 1, 0, 1, 2, 0, 0, 0, 3, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0]
[0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 3, 1, 0, 3, 0, 2, 2, 2, 0, 10, 0, 1, 2, 1, 0, 2, 0, 1, 1, 0, 2, 1, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0]
[0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 3, 0, 0, 2, 0, 2, 2, 1, 0, 10, 0, 1, 2, 1, 0, 2, 0, 1, 1, 0, 2, 1, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2]
[0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 2, 0, 0, 3, 0, 0, 2, 0, 2, 2, 1, 0, 10, 0, 0, 3, 1, 0, 2, 0, 1, 1, 0, 2, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 3, 1, 0, 2, 0, 2, 2, 1, 0, 10, 0, 0, 2, 2, 0, 1, 0, 2, 0, 0, 1, 3, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 2, 0, 1, 2, 0, 0, 10, 0, 0, 2, 2, 0, 1, 0, 2, 0, 0, 1, 3, 0, 0, 0, 1, 0, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 2, 0, 0, 2, 0, 0, 2, 0, 1, 2, 1, 0, 2, 0, 1, 3, 0, 0, 10, 0, 0, 2, 1, 1, 1, 0, 1, 0, 1, 0, 3, 0, 0, 1, 0, 0, 0, 0, 1]
[0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 2, 0, 0, 1, 0, 0, 2, 0, 1, 2, 1, 0, 2, 0, 1, 2, 0, 0, 10, 0, 0, 2, 1, 1, 1, 0, 1, 0, 1, 0, 3, 0, 0, 1, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 1, 1, 0, 2, 0, 1, 2, 2, 0, 2, 0, 2, 2, 0, 0, 10, 0, 0, 1, 2, 1, 0, 0, 2, 0, 1, 0, 2, 0, 0, 1, 0, 0, 1]
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 2, 0, 1, 1, 1, 0, 2, 0, 2, 2, 0, 0, 10, 0, 0, 1, 2, 1, 0, 0, 2, 0, 1, 0, 2, 0, 0, 1, 0, 0]
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 2, 0, 0, 1, 1, 0, 1, 0, 1, 2, 0, 0, 10, 0, 0, 1, 2, 1, 0, 0, 2, 0, 1, 0, 2, 0, 0, 1, 0]
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 0, 10, 0, 0, 1, 1, 2, 0, 0, 1, 0, 2, 0, 0, 1, 0, 2]
[0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 1, 1, 0, 0, 2, 2, 0, 1, 2, 0, 1, 1, 2, 1, 0, 0, 10, 0, 0, 0, 2, 1, 0, 0, 1, 0, 1, 0, 0, 2, 0]
[0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 1, 1, 0, 0, 1, 2, 0, 0, 2, 0, 1, 1, 2, 1, 0, 0, 10, 0, 0, 0, 2, 1, 0, 0, 1, 0, 1, 0, 0, 2]
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 2, 0, 0, 1, 0, 0, 1, 2, 1, 0, 0, 10, 0, 0, 0, 2, 1, 0, 0, 1, 0, 1, 0, 0]
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 10, 0, 0, 0, 2, 1, 0, 0, 1, 0, 1, 0]
[0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 3, 1, 1, 0, 2, 0, 0, 2, 2, 0, 0, 0, 10, 0, 0, 0, 1, 2, 0, 0, 0, 0, 2]
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 3, 0, 1, 0, 2, 0, 0, 1, 2, 0, 0, 0, 10, 0, 0, 0, 1, 2, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 2, 0, 0, 0, 3, 0, 1, 0, 2, 0, 0, 1, 2, 0, 0, 0, 10, 0, 0, 0, 1, 1, 1, 0, 0]
[0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 3, 0, 1, 0, 1, 0, 0, 1, 2, 0, 0, 0, 10, 0, 0, 0, 1, 1, 1, 0]
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 2, 0, 1, 0, 1, 0, 0, 1, 1, 0, 0, 0, 10, 0, 0, 0, 1, 1, 1]
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 2, 0, 2, 0, 1, 0, 0, 2, 1, 0, 0, 0, 10, 0, 0, 0, 0, 2]
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 2, 0, 1, 0, 1, 0, 0, 2, 1, 0, 0, 0, 10, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 1, 0, 0, 0, 10, 0, 0, 0]
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 10, 0, 0]
[0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 2, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 10, 0]
[0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 2, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 1, 0, 1, 0, 0, 2, 0, 2, 0, 0, 2, 0, 0, 0, 1, 2, 0, 0, 0, 0, 10]
```
  
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~37~~ 27 bytes
```
b ȷ2½RJÞ©¤µ€$ p /Aµ~E)UCCTL
```
[Try it online!](https://tio.run/##ATIAzf9qZWxsef//YiDItzLCvVJKw57CqcKkwrXigqwkIHAgL0HCtX5FKVVDQ1RM////NiwxMQ "Jelly – Try It Online")
A monadic link that takes a pair of integers as its argument and returns the closeness as an integer. When run as a full program implicitly prints the result. 
Note encoding is using the Jelly codepage (available at [Jelly](https://github.com/DennisMitchell/jelly)); byte count and neighbouring pair closeness both reflect this. 
[This TIO link](https://tio.run/##y0rNyan8/z9J4cR2o0N7g7wOzzu08tCSQ1sfNa1RUShQ0Hc8tLXOVTPU2TnE5//RSQ93zrB@1DBHQddO4VHDXOtDm8tUuJAFDs/wyny0cd2jhpmH249t4nq4c6HR4XagUZH//ysRY4USAA "Jelly – Try It Online") has a footer that breaks the program itself into overlapping pairs, converts each to the codepoints in the Jelly code page and then calls the code itself on each pair. The code section actually isn’t used; it actually evaluates the copy of the code seen in the argument.
A (possibly) minimal implementation of the closeness algorithm without the code restriction would be 9 bytes `bⱮ€⁵ŒpE€S`, so there’s effectively a 18 byte cost to ensuring all pairs are close.
[Test using version of OP’s link](https://tio.run/##y0rNyan8/z/p0cZ1jxq3PtzRo2l7eJ@@WzDXw50LjQ7P8MoESQBRw8zD7Y@a1jzcteD///9KSQonthsd2hvkdXjeoZWHlhzaCpRSUShQ0Hc8tLXOVTPU2TnERwkA)
[Verification of closeness](https://tio.run/##nZS/SgNBEMb7PEUKG2HBmdnL9RJsxEq0CgERbCSFrY0QG9/CykawDTZqcWl8Dl/k3NuZ/b8Xomz2ktzd99v5Zmb39ma1uu/76@n3O3Wf56fb5@61e@k2P49vB9O76dFxt3k4Obyczy/Oeg1q@3W1fTLPhs/6o@8XkwUCqH@PpZosQLWtomzgX/SkZk6nI33OwHE9qQZUzECvKVVY0xsZGCWPJnGwg5DoFZHVsl7Le25SxT86vbZTK2yNdmbmnoR0/UGGJhWqtX/QKuJZeAp6Nj4sjWC@ZhyODEjqgeEar9/Y0RqpIQwu2AFFcWCWP/HPizDDx7AXgfXulk4JXIdBpe3EyAVfyekdVgtlsL8PIV7fFSnEgWB/oFU3NULQByjaF4mbEPyeYAKzXC9QqsckWZ6AYguko3Q9/lBmR2DhLkLNv1OCdLUlgHehJdFZ/LkL8KW3S44QUn3c6nHKIwIKVpourz8lVXQECgSSGPjFIv40i9q7GCOU@piC0guhqjlhTO8I2hNc8pAfCiHvPyi2mI5iyAhY9k@dEGojB7sn1PMXjm3aRTAPav4rx5S4KAnj@csJ6AkoUWF1/0NyWFPUVRQRZAPBcrL8BQ) of every pair between 1 and 30 using the data from the question (will print 1 if all match).
## Explanation
Code explained below. I’ve omitted the spaces since they are ignored here. I’ve indicated steps that are only there because of the code restriction in square brackets. Note many of these aren’t no-ops, but they do not change the final result. 
```
           $              | [Following as a monad]
         µ€               | - For each integer in input:
b       ¤                 | - Convert to each of the following bases:
 ȷ2                       |   - 100
   ½                      |   - Square root
    R                     |   - Range
     JÞ©                  |   [- Sort by sequence along each list]
            p/            | Reduce using Cartesian product
              A           | [Absolute]
               µ          | Start a new monadic chain
                  )       | For each sublist:
                ~         | [- Bitwise not]
                 E        | - Check whether equal
                   U      | [Reverse]
                    C     | [1 minus this]
                     C    | [1 minus this]
                      T   | Convert to list of indices for each positive entry
                       L  | Length
```
Finally, [here’s a handy TIO link](https://tio.run/##FVLpUlMxGP3vU6DijhsKKu64srjjgitbQRABARfcprcsxRZU2hlaVKBAW0YpSAu0SW4tM8m9mZa3OHmRGv4k@ZLzLTnntDna2/vy@QYVX1KumDLWQEa2FJeUgiSFu7maR0Smrka/VNrpQuWcsH2gQR0W86hei5QzCNPLV6RHeqo2812x2s3N@auio9fR4ujuKdPn8r5eR09Ba0dBY2eTo6u@xaEvJ@30JrJNGRme5Ml8Ps9n@Cyf42Ee4VH@m8f4El/j//i6Rokh4RbfxZgIiKDtE1NiWkTFvFi24tmUiIuUILZfZAq2btteuGPnrt179u4r2n/g4KHDxUeOlpQeO36i7OSp02fOnjtffuHipctXrlZUVlVfu37j5q3bd2ru3rv/oPbho8dPnj6rq29obHI0tzxvbXvR/rKjs@tVd0/v6zdv3/W9//Dx02c95jKnPMFXlLGqiVJGUhkpZRBlUGUwZZjKSCvjn/6RNKRbUzIm/TKoiZWTMixjMpEN5/xyOBeQvlwoF5UTuXguISMboVx6wyUXN7zZCFgIZEBLAEZAwjA9IAktBagLdAjmCOgP0FnQGMwwaAZsGOYqmC8bBXFZGu2xxkGmLF1m1lq21kGdoAPZJdBxLRxoCPQP2BCYB@yrbYLNgAyCjIJRkIjWEmQFJAXaD@qGOQr6E3QOdJHPiwGwLzDXwPzZeZB@S2O9VgBk2tJF5mzdyAAdzP4FDYBOgM6ALoC5wbxg3@w0X@Cm9os2kbaENsB/) to generate the pairs of integers 0-255 as well as characters in any codepage. The link as provided will give the pairs for Jelly, but you can change the argument for any other code page provided the characters exist in Unicode. They should be provided as a single string from 0 to 255. [Example for 05AB1E](https://tio.run/##Dc/XUlNhGIXhc68iKvaOggpW7IAdC1ZaQDACCpbY5s8GQmiWJCodktACCKTt7FRmvpUdZ2Tmn3gJ@W4k5my9s46eFqPJZM7l6ti3wsoyW0JZbXBTYVFxVlPR21hJs0jWVOWfcj1ekI0NUKAiH9UsxsvMncYOQ3Orob6twdhe22QsIZXFRGkul/sz8dcufdIvAzIoQ1KVYamRmvFntEw8k/inSId0ymEZkR7p5b5ptvWzbYhtk6xYWFFY6WKlm5UeVqyGzVu2FmzbvmPnrt179u7bf@DgocLDR4qKjx47XlJ64uSp02fOlp07f@HipctXyisqr167fuPmrdtVd@7eu1/94OGjx0@e1tTW1TcYG5ueNbc8N71obWt/@aqj8/Wbt@/M7z98/PQ5Hcpj5BiL0bSdxSSLORbTLFwbVhZren5FdHvKqifSakqwGGYxkofnkSzcLBwsnBvj3O3WXSyiuiPVqyd1LWUhF7nJQzM0S3M0TwvkpUVaomUZoxVapTXykZ8CFKQQqRQmjSIUpRjFKUFJWoeABQq60I0eWNELG/rQjwEMYghf8BXf8B12OODED/zELwxjBKMYwzgmMIkpTMMFNzyYwSzmMI8FeLGIJSzjN1awijX44EcAQYSgIgwNEUQRQxwJJLH@Hw), without the preceding integer bit (just characters). 
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), ~~59~~ ~~52~~ ~~51~~ 43 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
εηθA~TLTBB™ÿćV9yΓиΓdJRzzªh}¯``ðð~V¢ 2
D//wO
```
Ok, that took a while.. Did it by trial-and-error, but I have the feeling that creating a brute-force program would have been more time-efficient now that I'm finally done.. But, it works!
-9 bytes thanks to *@Grimy*.
Uses the [05AB1E encoding](https://github.com/Adriandmen/05AB1E/wiki/Codepage); the characters map to [these `0..255` values](https://tio.run/##yy9OTMpM/f//6L4jbYcnBGcf3vH/PwA).
[Try it online](https://tio.run/##AUoAtf9vc2FiaWX//861zrfOuEF@VExUQkLihKLDv8SHVjl5zpPQuM6TZEpSenrCqmh9wq9gYMOww7B@VsKiIDIKRC8vd0///1s2LDExXQ) or [verify all test cases](https://tio.run/##yy9OTMpM/V9Waa@k8KhtkoKSfeX/c1vPbT@3w7EuxCfEyelRy6LD@4@0h1lWnpt8Yce5ySleQVVVh1Zl1B5an5BweMPhDXVhhxYpGHG56OuX@/8/vF7nf3S0mY6hYaxOtJGJjrEpkDY00DEE0aYGEHFDCx1DIxBtBhE31AGLGukYGgBpY6AqCyBtpmMGMsNAxwQkCDHJCEiDKJA5sQA) or [verify the program itself](https://tio.run/##yy9OTMpM/a/0/9zWc9vP7XCsC/EJcXJ61LKI80h7mGXluckXdpybnOIVVFV1aFVG7aH1CQmHNxzeUBd2aJGCEZeLvn65/3@lQ8sOrTi0Up1T/fB@K9tD2@wP73nUMKus0l5J4VHbJAUl@6P7jrRVBme7wAUOrdMLO7xe5z8A).
**Explanation:**
The base program I started with was 12 bytes, which was either [`εTLBćy×š}`¢O`](https://tio.run/##yy9OTMpM/f//3NYQH6cj7ZWHpx9dWJtwaJH////RZjqGhrEA) or [`vyTLBćy×š}¢O`](https://tio.run/##yy9OTMpM/f@/rDLEx@lIe@Xh6UcX1h5a5P//f7SZjqFhLAA).
Here an explanation of the first base program (second is similar, but with a loop instead of map):
```
ε         # Map both values in the (implicit) input-pair to:
 TL       #  Push a list in the range [1,10]
   B      #  Convert the current value to each of these [1,10] bases
    ć     #  Extract head; pop and push remainder-list and first item separated to the stack
     y    #  Push the current value again
      ×   #  Repeat the "1" that many times
       š  #  And prepend it back to the list
}`        # After the map: push both lists separated to the stack
  ¢       # Count for each value in the second list how many times it occurs in the first list
   O      # And sum those counts together
          # (after which the result is output implicitly)
```
Note that the `ćy×š` is to fix the base-1 conversions, since in 05AB1E any number converted to base-1 would result in a single `1` instead of \$n\$ consecutive `1`s.
That was the easy part.. I then had to add no-ops to comply to the challenge rules.. I've first created a list of all unique pairs of the `0..255` values (since the one in the challenge description is incorrect I noticed..). And then used [this helper program I created](https://tio.run/##TZw5DgUxUoavMhkJwfNWy0GQkEYEIBEQEUxMygG4AxIXICUBEgKuNNC1/H9F75NflV3trVy2u//xT3/7d//w93/@i//99z//1f/@@3//x3/985/@89/@6X/@5a//81///Oc//nH/5R/O3/zlH77fW7@vfqV@tX6tfr1@169hfXAqh1M5nMrhVA6ncjiVw@kczshhnYLdKQeZ91@vs9NOcahnRrdMuGXCLRNumXDLhNsm3Dbhg1Zdrbs75XTKba3b@cjtAjofQz4/lPEig1dmvTLrlVmvzHpt1muzPtgNrbM7k9Myp/96rS6vC4D6jzkGSVkhZYWUFdJWSFshbcUHt0EaWnu31mm4rfVaWE4X3X85ywrSMkfLHG1ztM3RNke732i3nnY1fdDqu7VOw22t18LaKY4iRmEhZWWQtUHWBlkbZG2QdUVZV5R1RVlX1AethRIEWtn5vv@QwX6R5m2AtwHeBngb4G2Ad9V4W@JdR9515F1H3n3@Ays4rXVbWDpnaWGDGT9YtgV5R3Hr1@YGbdABXZCAqGtNWX9ByGVD4@DfA92HtDQ5CPkZbfnRwDNKSYEFsxfMXjB7dU0HKchA3pS1HYRcNjQO/j3QfUgTASE/oy2/YSBLqWI2zN4we8PsjXrfMHujtjfM3qj3j5BLPcBGC@zuOx9daDykKdIMGg6q@SANpA0vlQ4e4OABDh7goAUO6h3OJQi5VNWc7vpB1nSgcZDfhcZDmiLNoOGgmkvSVNrwUgm@Z8H5BCnImqotLh7g4gEu2uJiNHzkTQcaB2kXGg9lKNIM5NBdi5jT0XqwGl4qyEDeVA3wYPWD1Q896KEHfQS5g9Iu/r0oQyBn@Neg4bBgbfxdXnkJrIY3C/KmUhHUusBqQbcRdBtBtxGMAOnp8yOBrkGuJs7AqiWFNfBmH5U1cGxBB/RAAoJu9QFFd1bMjYq5UTEjKmfE8IOZCg8WtED894K06UDjQK7a1jDRGawxTHmGKc8wYximPEMv/dwzculpMBwpU2U8QJYD1xe0QQf0QNZ0oHEgdy7Imx7kHnIWbVLoGnQNpTlyWT8Irs1UoYnZRBv@MOiALkhABvKmbKEg5HKge6B7IXch90iQU6QpcnHoVn8PXEQasYR2Z2tu@MugC3ogBXlT5Qi/GoRc6rFWD4iPLuQu5B7KeJBT/KvW5NBdP6jU9B/IApcidVcNwJ8GPZCArOlAox5ro9022m3jsXaPsQ1fHAS5hzIe5BT/qjc5dP00rR@Uyz0EsuilSN1VF/C3QQJSkDcdaNQDHrTgabcQZCDoXshdyD2U8SCn@Dfdx0cOXb9N6wfltfD/YtFLkbqrLuCPgxRkTdWW8NFBB/RAyOVCo1rwti/8SPCvIBdDmkEj55gdoSqUF60uXxnIchaz2iUA3x1kIG@qJoQ/D7ogASGXC42LXARpAl1DWs6d@3FuCYR2txcj4MBLNea1SwBOPcibqsEEDSZ4HEGDCR5H0DcRE3/0kIsgTaBrSDNpKmccuAai6HLRgZdqzKtCma14CMTFQQf0QAIykDddaDzkUq2j7bk/MsiVbw5cxE2BjbIr9t0GI7GACLogynlTDRLDIDE4qo@QVnVu7Zw/Uuga5MyayiUnMnVBvYLfwIOsKhDejmfAEiLogSBXz@AYEI6Z7FtWQPchrarcO8D9SKFrkDNvWr9LZOqCem2ABB5ktVPg/PoZDhYMQQ8kIGjkcx0sIoKg8fDvg65AV6HhkKs1ROAmnoHQqjFwFsxdMBdLgoMlQZA3ZTMcLA6CoPHw74OuQFeh4ZCrcRy4iWcgtCqMPxvmIsQ@cPUfVe3C1R@4@iDIPcg9yKX7/0jxr@JfRS6ONIdGjefAzdTDVAHWCjxwI9ddtXrwYAi9D1z8R9UO3B@Giw@C3IPcg1y6/Y/qwbinjKXAwQIgCBrlRQI3Uw@UamH@YS3MAzcs2tUSFw928WAIzj@qtoOTDxIQ5B7kHuRyCfBRPRgC@yDk4kgrpxm4mHqYeqBVa/NzsTYP3DBpl50PT/bwZAjggw7ogaDxIPcg9yAnSKsne2g8bAMcBP@He@CH@wCBh6nVIrGlgaz2DyXtA7Vd40jwPIJuKWgzQZthC@CjB7l6HmwLfJTxxEeGnA0a3VKCIONw1yDwoMTaOQtUCFS8EVi9R2G7oucpWkUxa2DDIAhyNU9jE@GjDBo@MuRs0Oi2UMQPh3sMgQcl1qZZoEKgQonA6h8G2w19y9AChr6F7YUgyNWkjS2Hj6oFDLZj8@FwoyER2rWYCTwocT3KKgQqSgis8cut/uN4DEeXcjQGNuUP9hiCIFeTOfYdDvbqD/YdDvcYEqGzNgUOylk0bSkEds6L99dmXnj0C48eBLkHuQc5gVz6@48UaQYNg4ZBrtYxiUzN@r1cDgTSyNoGDDQIVGhzF54Cjv7C0QddEOQe5ARyuQz4SJFm0DBoGORqcCcytSqaq4RAGrmyFwcaBCqiuRtPgZVAkDVlNwq6IGhU@@yOWS5WBx8Z5Az5OTRqjZaIvGt1EEjLFguq6OVurNzugenw9UHeVJ3soFEQ9n9UjXLahVz4/48Mcob8HBp90hyIvGuRFkjLFgtaBoFaxV2E7JfnyRcjBd48SEDQqPq/PeNeePiPHLk45HokBKK8daBUE1Qgs18G2fJ@F645aIEeSEHeJNCoWn89zV447iDoOnJ2aDg0eiA8RF6Xfj3wEh9lWdJyCOwaSnDNQRskIGuq5xH0J7jwIG1S6Cp0HTk7NBwaPToEUdilgw@8xEdZlrQcArvGF9x10AEpyJvqeRSdDG49yJoUugpdR84ODYdGDxllF6TTD7zER1mWtBwCuwYdXPhFWP9RtY@hv8Gtf1S9AA7@o1woXuPVDQb4gZup9xAVyLzaTkNMc@GZLwL2j6q2ca7@UbUkvPXl0XriSHXgZuq9RAOOzBw2VTzy4Icf4u6Psgs8HJ0/ROBB2mRIy@Z@PE5PxP/lBwI3UzfVcjYMZPGLJSyHyRVGBqYPfHDAD3H4R9kLHo7QHyLyhy38h8P0j7I/PB6rJ15gXdJZWPElUq3u4yyEhYEGO5cDK1gMTD/4NsxHXP5RdpMg/KtIyy4YhLTqOomH@ICLspt4qPaYyvKXwdDNIiokfDytfwf2I/z@qHrU6UnlIfx@OEkPQlr3qMOGOAggHp1y4CYeqj2msvyVXv8xak88wJxiHmLrIAF5k@Jfxb/Vc2@vkIKsqTvXZZNwSz5wQatHCUPzRObwKEvzNovYVW1xv@1HzFTssgdpUz3U68VrkDXViHm9dgrypn6mx3bixvyj9w7cTD2LSLVHWZrS7fQQ2gY@ClSjY6/94S7aR/V4uJYW5E0GXYdcPwnvrQVu4hm4iQqsehbEtC@uGhhwQaCHkcJo7LJ/VBWBa2wf1TSg6HK42/YUserjPbfATTybeIgGFAqw1F2tqohrA6v2cb/tYdf94VA/CP/W2Dd0KetF06NPDlxM3cSy2bC@TXSgUIClducxxLMPt9we9tYfDu@D8G@NcsfY9l4OPTrqQObdfsNpqGM7MTAXsYFCAZba3SQwL2f@2tIgbVL8q/hX8a/h37qR@evFaRA0qsITLxEZ1dlH4CHeH5FqOe8LY@8P69RHGIbLwoOsdhYfZTUE4V/Fv4Z/s@cHMQ0a1R6Jj4iM6gAk8BDvIlItXYEw/JaFox9hJC4bD7Lbf3xUbbPxIDh@F0TYgv33IKZBo5tmw3skIqNyJIGHeDeRajk/CoNx2Tj/EcblcnoqDdImQ5ohLQeGYG9d6LsD949IgXuIl4hcyycII26Jg3jkUMG33J41BVe3BU5ZuB0udL@BexEfsGy57AgXC@9Ag8BmZnXsIQ@3oXFf@6Mahty2DqxHeZjuEgVYBjy24ENkH2jIoTsl97VFemr7yEi3qUaSYNmSiP@74QRzW6IQFVg1xH3qRKo5Uru3CWJ1UUxpCgsVo14xRBSr3kT8362pWPUKr3snGjBjEuFudCLVHKnd3xTRtyDi/MhI0lTjwViZhlWG0LkJr4YLL7cJz5kD30CqPao5UjfzrXhaEH9@ZCRtKrfgrEzHkkLo1IS3wIWX14SnyIFloLPhHatYYaQqzsEbF/TCBoUL@8hI1pSTo/5QmcrtYaW3Um4PK0@LA9OqRBRa@5OBjsxqRAemv1M4pI@M5E3phnShBpX7vUrfo9zvVZ4KB5ZVC00cKJR1ZLY3BHZ6L0XIqNisVbgS5bat0mkot20TH1AoKxCo2DCQOez0NYpIT7HRqnALyi1XpS9QbrkmClAoKxCokC6QOdS@jCJAU2yXKj2AcudUGXUpd04TFSiUFQhUAKbcRA1Mx6GIoRR7ncp5P9GAiwKHAtUID/48MF1joFwiZet5GUQpd0MDq5LgBBSblkonkOjARYFDgWomwWpQ6QQCyy5B7BrosKBi18BDrFrE3K/YfQySpvICgdWpuSeZqMBD2UvZGjR0CIHCIoQ5OMzaPxSxDzFdtcIPfOQkbapZNrDGgmFZkmjAw9RL2RprdA6BQjWlrKO0iocCmW9tTyl8wkdOsqaecZ0jyFnJjtVM4GHqpWz1PofXDRSqKWUdpVVMFMh868De4B8@ymnGfph@jYGN8TZR4IFW2RX4KPCopkxVyNZEGFhvjP0Q3dvCnJNowOyhxjtCgRnNBuYICHwUeFRTCNRcGFgvqy1sb9nGrJPowHoLbWMpEphDI/EBHwUe1RQCNRsGVlVv7EHZwbQSWC/bHfScwFwKBGY3TxTgo8CjmkKgprvAqt@DrQq7mC0SL7Da7WLUBW4K5ILCGBcEVi/hazOJzMEgsFlahb/2aAN31IzOwHjylUiBerWQoUFg9RK@BRMoTDVgbUkZr8Uab54Y98KME7/xuMq4@k804GVqdRhhYwk8qfEGqwm2mIyXWY1XSIx7W8ap3XjGZON9TsV6IvAytfqOsoUU64lAA9YUGVh9kndBjHtVxhnbeEPEuHAPvJStwWBYVCUy1YA13QVWR@RFDuPek3H2NV7vMC7IAy9lq6c6u4bDSwcasOczxyLTedST6MB6NZQL7cA3kALC1HRXgYbMKqAOzJp0Hs0kbuCmQHYC51o68QEfU4VqMlId6BComDowK9V5MTLxADcF6nXbjWVlogAfU4Vq9QYuN2kCHQIVNgdWVfMSY@IFbgrkuHBebUxU4GOqUC0XQs6dmECHQEXGgVXrvG@Y@ICbAtWwvIWYaMDHVKFaLsYCc50Q6BCo6TWwav3RhocRG7gpUDXJC4OJDnxMFapV/@UlhECHwGYRtUx0oQ2CweucUwOrJrmuDpSBzEwHModcs7lw8ApCWOfCONGAm6lVfVwjB8pAAepA5pArMY@JFAIVpToXuYkO3EytOuN61/nSX2CVFgi1WpQFbghUdOrOWYN7GIHVEblKdb6WF1hFBEKtll@BGwIVZf3/8o@vf/7mS@jcNk@WwTZkXMC1yEpu3cXXOH/jHfEf97CTZbANGVdwLaCSW3dj3CbXy57JI/0KWSYb2YauM72WR8VK7pf8DwZrcpd70E2Tr5JlspNt6DrTK6ArNnK98vnjBnGxkNuGiy6bXC8z/7hcTJaRriPdqNuvsybLYCfXS6i/N@zhCjH5jPS2gevFZB1slEd/4Clscr3m/pNRFpeCyWekd1lcGCbrYKM8@gPPTJNfpesoi2u@5DPSuyyuAJN1sFEefYCHncn1WvzPxvjl6WNy9z0bZXHVl6yDfeRTL@P/bLQ1TyyTez7xMcZ5mlhs5C6Xq75kHewjH2f@GIM8gUyuOWdxmZd812An1@v4@dWPwT50nXl2H0t@5JqLFpd2yfUJisWLOcVK1sE@dJ15dh9LFnLNaYtruOJHviO9v@mxEWYky49sg53593jPr3Js8h7p1cfWGTZwtzT5jvTq/8lOlkW2wc78y6sl95dRDgLG5Opv6w4buHeafEd69cn8KsZv8CYbGXXC7dbkxXzwJZcxH643bOD2afId6TUu8nsXQ7fexM9vXpBRJ2NuXDx1S94jveaB@ARE2yCcNxY3S5N7vMiwQbg2yK9ZkFEnwrlr8WQteQ/5rn9ugRY7uceOjnKV64f8hgUZ9aCcuxZPzJL3kO86tzFv2Bi/NsaOjXKN64pgI7e/SFby/g0ueR/zho8x4mOM@CjLuZYINsqgzp1rhvzqxCL3p3O4x1h8yW@k19jcDI@TdeTj5C53j/lz8@AqufzFXqPcsT7cPHNKrrGwGROv8X2DZCf3mmSPuXTzbCq5/MXeo9yxbgx@I736/97j2fnhgWQn49nH/Bm8mX8FqGufUe5YNwa/kV79f5/x7PwiQLKT8exjzgzezL@i0pWv4OtgI7@RXv1/3/Hsl2uJYCfj2S99aL7Yz/wrFF35trwNdvIb6TUWNuPcZCfjeR99aHB/MErGR58YzBYbWYe8Mx15CufbzZB2bR7jJ8tkJ9d6YDNAXfleug42cs1Rm0fvyTK4@@f4DE2@HW6DnXyp2zHO9jEPjK/BBHffY7SZ3Hk657o9Ys/g/joVTzOSZXD1qzNizMOrWmu8Yp18qYuvd/F4IlkG97e0Rox5eG9qjTehky9124ceHj0ky@Dqk2fEkuMt5ORL@fZBh0cJyTLZyNUnz4gTkynfc11wtenhgUCyTHZy9ckzYr1kyvc8Ftxt@jiOkp2sI10NDJsf5@3gPdL3kO/25QXXNd49LXZwz8PBnY/glD6525S3Ttd4EzS51snjtdDkzkfpW/N90WprXgVd473M5Fpbjpc0k/ubcEY/NV7ZXMfHeOFLksm1PhxvTCZ3Pk6/Ey8k1rgI1slC7s@0/bjWvdwYTy4/Ei8F1lgI1slKrjVbvDm4JlOm/UK@rqdknWzkWoPFi3xrMmV6/r9jTAXrZCfXPkC8V7cmU6ZOgNcd@yeXJ27JFVtdbgon1zr8jn2Py@Ox5IqDLg/IksvX3LF3cXmWlVw@6/I0K7n8yB37D5cHT2u8CVXs4J4bg@8eXOljb@Ha6D/G9ckdvunyWGmN15mKK33sFVwf/ce53rjDH10eE63xDlJxfbZv9PN8/2ewU6Z9RPCmTM/hb/idN/p5voozuPpAvoxzyZsyHVO/4Wve6Of5UoyTq2/kazGP3B843IyLH4/AV76S8iP7ZAP3/B9c81Jwrc0ej7RXvBJS/TbYyd3WyUqueemNeDnevbDBTu72fTw3Tu7POI44N958sMFO7nXFGz7i8dZPcteVsg8/3rtZb8Sbb/iFx1s4a7ydsOJdABvsZPSH4Qseb8WsuJNvg52Mdh9z/uPNlJWX3wdX@8b192pfGXO78HbhylvmRq55IO6Z/5jec7jw4t@SsY@U7OT@ICbv6S0Z@zx5q/o32Mg1P8jYh8mbz2uwk2vsy9gnydvJm9yf4HycH2Ts/eYN4UOueTi45gEZe7Z5S/eS@8OeyjEuY39Vxl6B8JvMyf0p0LE@l7EvKiPel/E5ZBlzoIy1t444PdnJa6T3Bz7H/Kb8mGCxk2se0zF3Kb/Il9wfF@VVzeQaa8rP2iX3J0h5szK5xlRccqx20bH/lvcgS/exLZSnoMn9wVJhH9YR3ylPLJNrnlEdMiNeUx31ppxP1IbMiMXURr0Z5w31ITNiK/VRb875wUZ8lOzk6s82Ypzg/mTq2Fs2vmyRfAZXvzW@5pB8BpevMb5@UPzIZ6SXH8nLP2@wkM9I78@3ypAR1mHwGenVb/P6jA428hnp1W/zqosNdvIZ6dVvbeytBd/B1Vd97H0F1zzpYz8quOZDH3tEzk9XLR/7Ns7vPS0feynB1e4@9j2Cq63jCL6ePY/ji5XPmEfkxcbnSq6Pxfp4Fkcb7TwX3uT@iOvCsyTXV@bijLW@pPfjnLDj3LO@Sffj2N8/fgdq//i9pB1nc/WxyjwvK3sMc@CO86OyJ850yoY4Z6lyV8Xmf/N/) to get all characters in the 05AB1E encoding facing the character I've input in the header (you may want to collapse the Input section on TIO in this helper program).
As for the resulting program and how I (and *@Grimy*) have made the no-ops:
```
ε           # Map both numbers in the (implicit) input-pair to:
 η          #  Pop and push a list of prefixes of the number
 θ          #  Pop and push the last prefix (the number itself)
 A          #  Push the lowercase alphabet "abcdefghijklmnopqrstuvwxyz"
 ~          #  Bitwise-OR the number and alphabet (results in the number)
  T         #  Push 10
   L        #  Pop and push a list in the range [1,10]
    TB      #  Convert each to base-10 (they'll remain the same)
    B       #  Convert the current value to each of these [1,10] bases
      ™     #  Titlecase each number (does nothing on integers)
      ÿ     #  String interpolation (does nothing outside of a string)
      ć     #  Extract head; pop and push the remainder-list and first item separated to the stack
       V    #  Pop this 1, and save it in variable `Y`
       9    #  Push 9
       y    #  Push the current value
        Γ   #  Actual no-op; this character is unbound as any builtin
        и   #  Repeat the 9 the value amount of times as list
            #  (alternative for the `×`, since the builtins facing `×` were useless;
            #   this does mean I need an additional join `J` though)
         Γ  #  Actual unbound no-op again
         d  #  Check for each 9 if its non-negative; which is truthy, so they'll become 1s
         J  #  Join the list of 1s together to a string
          R #  Reverse this string of 1s (no change)
          z #  Take 1 divided by this number
          z #  And do it again so we're back at this number again
          ª #  Append it back to the list
          h #  Transform all values to hexadecimal (since we only care about equality,
            #  it doesn't matter the numbers are now hexadecimal strings
            #  - except for a weird bug where the string `"3E#"` equals `3`..)
}           # Close the map
 ¯          # Push the global array (empty by default)
 `          # Push its content (nothing) to the stack
 `          # Push the inner lists we just mapped separated to the stack
  ðð        # Push two space characters
  ~         # Bitwise-OR between the two space characters
  V         # Pop and store it in variable `Y`
  ¢         # Count for each value in the second list how many times it occurs in the first list
     2      # Push a 2
    \nD     # Duplicate this 2
    //      # Divide the 2 by 2, and then each count by 1 (so they remain the same)
    w       # Another unbound no-op
       O    # And sum all counts together
            # (after which the result is output implicitly)
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 27 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
5+5ɓz2z2b ð€Z<Ƈp /*6EE¹?ƇTL
```
A full program accepting a pair of integers which prints the closeness integer.
**[Try it online!](https://tio.run/##ATQAy/9qZWxsef//NSs1yZN6MnoyYiDDsOKCrFo8xodwIC8qNkVFwrk/xodUTP///1sxMCwgMTJd "Jelly – Try It Online")**
Or see the [50 by 50 grid](https://tio.run/##ATYAyf9qZWxsef//NSs1yZN6MnoyYiDDsOKCrFo8xodwIC8qNkVFwrk/xodUTP81MCzDh8Klw75gR/8 "Jelly – Try It Online") (takes ~30s when not cached)
For verification, the bytes used (in hexadecimal) are:
```
35 2B 35 9B 7A 32 7A 32 62 20 18 0C 5A 3C 90 70 20 2F 2A 36 45 45 81 3F 90 54 4C
```
...which, as a list of integers, is:
```
[53, 43, 53, 155, 122, 50, 122, 50, 98, 32, 24, 12, 90, 60, 144, 112, 32, 47, 42, 54, 69, 69, 129, 63, 144, 84, 76]
```
### How?
```
5+5ɓz2z2b ð€Z<Ƈp /*6EE¹?ƇTL - Main Link: list of (two) integers, [a, b]
5+5                         - five plus five -> ten
   ɓ      ð€                - for €ach n in [1..10] do f([a, b], n):
    z2                      -   transpose [a, b] with filler two -> [[a,b]]
      z2                    -   transpose that with filler two -> [[a],[b]]
        b                   -   convert that to base n (vectorises) [[[xs]],[[ys]]]
            Z               - transpose -> [[[xs],[ys]]]
              Ƈ             - filter keep if:
             <              -   less than [a, b] (always true so filter is a no-op)
                 /          - reduce by:
               p            -   Cartesian product (get all pairs of wrapped representations)
                  *6        - raise to the sixth power (vectorises)
                        Ƈ   - filter keep those for which:
                       ?    -   if...
                      ¹     -   ...condition: identity
                    E       -   ...then: all equal?
                     E      -   ...else: all equal?
                         T  - truthy indexes
                          L - length
```
---
Combining the start of [Nick Kennedy's](https://codegolf.stackexchange.com/a/196386/53748) and the end of mine gives us a joint **26 byte** answer!:
```
b ȷ2½RJÞ©¤µ€$ p /*6EE¹?ƇTL
```
**[Try it online!](https://tio.run/##ATYAyf9qZWxsef//YiDItzLCvVJKw57CqcKkwrXigqwkIHAgLyo2RUXCuT/Gh1RM////WzEwLCAxMl0 "Jelly – Try It Online")**
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 60 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
```
Ë5A $$ óKS{3N=DVNìN=KDV)q-2
DU=CgM=U)UxPÈ4C=Mg493)UCè¶r4 $$P
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=yzVBCSQkIPNLU3szTj1EVk7sTj1LRFYpcS0yCkRVPUNnTT1VKVV4UMg0Qz1NZzQ5MylVQ%2bi2cjQgJCRQ&input=WzEyLDEwXQ)
I used [this program](https://tio.run/##jVRbT9RAFH5uf8VYo86Ete5CNBEEVIKERBMDRB6Eh9kysk1qd9NpsUZIEO/gBW/xURS84/1@fZjzT@SH4JlOt4v4YrJpds71O993Zjy505P@@noi/XCSDJ@WsTjpjog0dofEZBLwqD9tREJKvx7KLnuKR8Qn3WQwRDefGKn3hxOU5fawkcTowzyRukd47NWEpH6J7Hfo2uwc66W9nWuz83Rsoo2tzS5M07Fw2mXMydNlQ3g@D7CAox6oh2pZrahH6rF6op6qZ@q5eqFW1Sv1Wr1Rb9U79V59UB/VJ/VZfVFf1Tf1Xf1QP9UvmIWzMAfn4DxcgItwCS7DFZiHBbgK1@A63IBFuAm34DbcgbtwD@7DEjyAh7AMK/AIHsMTeArP4Dm8gFV4Ca/gNbyBt/AO3sMH@Aif4DN8ga/wDb7DD6fNN7i9Go8korat/jA5KSJeDYQ7xMNJQcul9t17mG25ozURCYqz9RD87iOVPWWyfTvZonPdQdlXD@OoHlCqzyxgZHqaYHA3qXQUf/e2jOUsIOfL1cncD2WRrRsOi0B4MR0Q8SHuCZlTzIOg7z/Q/ptsn6hHgns1QjNZCUexjd6MnLEtXRurYVnuDkT1pCGPt4@7w4mH2ZL0YmTsHsW@gm70H@NBIhjpJBT9rPB05J7j5fEu29IzkSl9xupmQuyEjtHIjwV1ziDqGazhlEi/9HhD0CyYadBWgVoDrGrMLQCVjQALYjqNnCwby/JPkIIFim2ZeyA8TasF5XlYjiXvb0C2Rq66h7mMKWMak2XN2PqXZRz2Q6Evz4xtD7bU2CfjCK9iDyk6Yy1Nb1VEWb9IxEkUkn/0q5T0ajTVS/WyjdQPcoRgkkskZaab6dAkLKPYYzretoxLT@jxmHruSH04s1C9GEOiESAi6oyFTsn5vTjv/G2NUQU0X9lkjoz52t9mYqxLzoaVy0BvuhQpQ4EcfDicNrMpKWnT5wUH1Uo3AMw0z0fLB28xV9JLSCI@4acZiVra7JTdKEZyUkNxipgSdEdlR6lJe1eTGIyTSaBfOcdB46maHwiS80t6SNksRBGUO7aZxojbePQe5K5d3cbXla1FjqIZNbO@Dqv4dG7F6ds7cOQ/ "C# (Visual C# Interactive Compiler) – Try It Online") to find facing pairs. This program is Japt-specific, as it filters out characters Japt doesn't use. To use, enter any characters in the input section, and it will find all valid Japt characters that face them. To include control characters in the input, input `《number》` into the input section. To include control characters in the list of facing characters, prepend `。` before the character, like `。#`.
This challenge is made much more difficult by the fact that there are many characters in the ISO-8859-1 codepage (Japt's default) that are unused in Japt, and cause syntax errors if they are not part of a string. Additionally, since calls to functions must be closed with , `)`, or `¹`, many functions are off limits. The code only contains calls to 8 functions total.
Here is the equivalent Javascript code:
```
U = U.m(function(D, E, F) { return (D, 5, A ).ó(function(K, S) { return (3, N = D, V, N.ì(N = K, D, V)).q("-", 2) }) });
(D, U = C.g(M = U)), U.x(function(P, X, Y, Z) { return (X, 4, C = M.g(493)), U, C.è("===".r(4), P) })
```
As you can see, there are many assignments made to different variables, because very few variables face a function. The Cartesian product function (`ï`) is locked, since every character `ï` faces is an unprintable that results in a syntax error in Japt.
A thing to note is that when values are chained together not like `DU` or `5A`, only the value at the end is used, but only if the values are not arguments to a function. The values before are essentially no-ops.
```
Ë5A $$ óKS{3N=DVNìN=KDV)q-2
Ë //Map each variable D in the input
 5A //A is the variable for 10
 \t$$ //Tab (a no-op) followed by $$, followed by a single space
 //Everything between 2 dollar signs is 
 //injected into the transpiled JavaScript 
 //literally. In this case, we inject nothing
 //Space is not a no-op in Japt, it acts like parentheses
 ó //Range, 0-9
 //Map each in the range through the following function
 KS{ //An "old-style" function, taking in parameters K and S
 //K = current #, S = index (ignored)
 //Obsolete nowadays, replaced by '@','\_','È',and 'Ï'
 3N=D //Assign N to D
 V //No-op variable
 NìN=KDV //Convert N to base K array, the last two variables are
 //ignored in the function call. Luckily, if 0 
 //is passed as the base, it returns base-10 digits
 //Though 's' is much more handy as it returns a string,
 //It only accepts bases 2-36
 )q-2 //Join the base-K array with '-' (2 is a no-op)
 //Newline - assign the result of the previous to U
DU=CgM=U)UxPÈ4C=Mg493)UCè¶r4 $$P
   C                             //12
    g                            //Index into (wrapping)
     M=U)                        //U, essentially getting first element, also assign U to M
DU=                              //Assign that to U 
                             
         Ux                      //Map everything in U to the following function, then sum 
           PÈ                    //Function w/ parameters 'P','X','Y','Z'
             4C=Mg493)           //Assign C to M[1] (indices are wrapping)
                         ¶r4     //Replace all "4" strings in "===" with ""
                      UCè    $$P //No. of elements in C that "===" (equals) P
                             
```
]