title: Biggest Irreducible Hello World

text:
# Question
Title: Biggest Irreducible Hello World
Create a program that outputs `Hello, World!`

The winner is the source code that is the biggest, subject to the constraint that it is *irreducible*

For this challenge, *irreducible* means there does not exist a program that outputs `Hello, World!` that can be constructed by removing characters from the original program.

For example

```
console.log(`Hello, ` + `World!`);

```

can have the the bracketed characters removed

```
console.log(`Hello, [` + `]World!`)[;] -> console.log(`Hello, World!`)

```

And it will still output `Hello, World`, so it is not irreducible.

**Extra Rules**:

* ~~Whitespace is ignored with regards to both irreducibility and size.~~
* Unary or anything that operates in a similar fashion (I'll make this more clear if I have to) is banned.

# Answer
# Keg, \\$3.3 \times 10^{8912898}\\$ bytes

```
...÷⅍+ℤ,(|⅍+)ℤ,(|⅍+)ℤ,(|⅍+)ℤ,(|⅍+)ℤ,⅍+ℤ,⅍+ℤ,⅍+ℤ,(|⅍+)ℤ,(|⅍+)ℤ,(|⅍+)ℤ,(|⅍+)ℤ,⅍+ℤ,

```

*Program as seen in the raw editor*

So where that `...` is, replace it with \\$3.3 * 10^{8912898}\\$ `0`s. Then, add a `!` after those 0s. This splits the number into chunks of length  through concatenation and then outputs the corresponding ascii character.

I owe a special thanks to @JoKing for helping me generate a truly irreducible score... it took me a while to understand it, but it got there in the end.

## Why can't this be reduced?

* Remove any of the leading 0s, and then it has the wrong number at the start, meaning that the wrong letters will be printed
* Remove any of the `÷⅍+ℤ,(|⅍+)ℤ,(|⅍+)ℤ,(|⅍+)ℤ,(|⅍+)ℤ,⅍+ℤ,⅍+ℤ,⅍+ℤ,(|⅍+)ℤ,(|⅍+)ℤ,(|⅍+)ℤ,(|⅍+)ℤ,⅍+ℤ,` part, and the chunking will go wrong.

Score calculation: https://chat.stackexchange.com/transcript/message/52895760#52895760
> 50 votes

# Answer
# APL (Dyalog Unicode), \\$ \approx (10 \uparrow)^{625} 10.024549 \gg 10 \uparrow \uparrow 626 \\$ bytes

```
⎕UCS(13⌿*⌿2+|⊃⎕RL⊣⎕RL←⍪⍨1)⊤≢⍬⍬⍬...

```

The exact byte count is

$$ \text{byte count before zilde} + \text{byte count of single zilde} \times \text{length of zilde chain} \\ = 52 + 3 \times (72x^{12} + 101x^{11} + 108x^{10} + 108x^9 + \\ 111x^8 + 44x^7 + 32x^6 + 87x^5 + 111x^4 + 114x^3 + 108x^2 + 100x + 33) $$ where $$ x = \text{power tower of (} 2 + \text{abs(internal state of Mersenne twister with seed 1))} $$

At the end of the power tower is $$ 1338723255 \uparrow (1025549142 \uparrow (1187976951 \uparrow (683638953 \uparrow 1197707996))) \\ \approx 10^{10^{10^{10^{10^{10.02454898892586}}}}} = (10 \uparrow)^5 10.02454898892586 $$

### How it works

```
⎕UCS(13⌿*⌿2+|⊃⎕RL⊣⎕RL←⍪⍨1)⊤≢⍬⍬⍬...
                      ⍪⍨1  ⍝ 1 1
                  ⎕RL←     ⍝ Set RNG to Mersenne twister with seed 1
             ⊃⎕RL⊣         ⍝ Query the internal state,
                           ⍝   a vector of 625 integers starting with 0 0 1
          2+|              ⍝ 2+abs(above)
        *⌿                 ⍝ RTL reduce with exponentiation
     13⌿                   ⍝ 13 copies of it

```

`⎕UCS(13⌿ .. )⊤≢⍬⍬⍬...` part is classic. Without going through `⎕RL`, the highest single number you can get is `*⌿2+⍪⍨1`, which is `3*3` or 27. The only other system function that can be made from `⎕RL` is `⎕R`, which doesn't work with numbers (it's PCRE replace function).

---

# Previous answers

### APL (Dyalog Unicode), ≈ \\$ 10^{10^{10^{10^{10^{10^{10^{10^{8.56784}}}}}}}} \\$ bytes

```
⎕UCS(13⌿*⌿9⌿9)⊤≢⍬⍬⍬...

```

The exact byte count is

$$ \text{byte count before zilde} + \text{byte count of single zilde} \times \text{length of zilde chain} \\ = 28 + 3 \times (72x^{12} + 101x^{11} + 108x^{10} + 108x^9 + \\ 111x^8 + 44x^7 + 32x^6 + 87x^5 + 111x^4 + 114x^3 + 108x^2 + 100x + 33) $$ where $$ x = 9^{9^{9^{9^{9^{9^{9^{9^{9}}}}}}}} $$

`13⌿*⌿9⌿9` does this: make 9 copies of 9, reduce it by power (RTL), and again make 13 copies of it. Since we need 13 digits (to convert to 13-character string), we can't touch `13⌿`. The only operator that contributes to making a number higher than 114 is `*` (power), so we can't remove it either. If any char is removed from `9⌿9`, we simply get a 9 or 99. If  of `*⌿` is removed, the `*` becomes "power of e" instead, so `⎕UCS` will error out.

---

### APL (Dyalog Unicode), ≈ 1.6198e1175 bytes

```
⎕UCS≢¨⊆⍨(1129⍴11)⊤≢⍬⍬⍬...

```

No TIO this time. The trailing section contains exactly **53993507850758146386142744333468571550524632618191311756757485604204265568989694819322874649587028378175296725206816716551117407353231278417177118257863382844631479973422921647480947817133933420316923525318614797726155835511430816083805415403840314027172595512518082931013938879825791513465541135540380972893540597585182649169086261680393824120050960955555779401997457521829600791475089390923918230965201076266924917726191938715916934581792969501864553539221144133166874835664827114498421480824828796840502396309900816750358227125625773629167173751259375816861525751727161646360849365621299142542955252895691416097697138666219891143191120795244088895226859387434190840571233858421367397012295189969102957711871947102112735851782580022907564984257273029144801079437982463987025764736538779486298171952179565363242464045693851301934849205024515654449551352138803030923347653267563857979066215774822906142655781986485757538363542188567283809498107727208952982783066735317822771494040957372930876073109323855643561468444882121936718611178126143503679181305866975597866998548105699612159571516074201535860599366981549403015140492393925783660483338575307748583670119709554797435941** zilde symbols. Still no whitespace.

### How it works

```
⎕UCS≢¨⊆⍨(1129⍴11)⊤≢⍬⍬⍬...
                  ≢  ⍝ Length
        (1129⍴11)⊤   ⍝ Convert to 1129 base-11 digits
                     ⍝ which gives 1 1 1 1 .. 2 1 1 1 .. 2 1 1 1 ..
      ⊆⍨             ⍝ Chunkify at 2's as starting position,
                     ⍝ including the leading chunk of ones
    ≢¨               ⍝ Length of each chunk
⎕UCS                 ⍝ Convert codepoints to string

```

The "chunked unary" encoding requires at least 1129 digits, and can't contain zero digits in order to be exactly 1129 digits. The base 11 was carefully chosen to avoid cracks using lower bases.

---

### APL (Dyalog Unicode), 1169882994796837103436970021 ≈ 1.17e27 bytes

```
⎕UCS(13⍴115)⊤≢⍬⍬⍬⍬⍬⍬⍬⍬⍬⍬⍬⍬⍬⍬⍬⍬⍬⍬⍬⍬⍬⍬⍬⍬⍬⍬⍬⍬⍬⍬⍬⍬⍬⍬⍬⍬⍬⍬⍬⍬⍬⍬⍬⍬⍬⍬⍬⍬⍬⍬⍬⍬⍬⍬⍬...

```

Try it online!

The trailing section contains exactly **389960998265612367812323333** zilde  symbols. There's no whitespace.

### How it works

`⎕UCS` converts from Unicode codepoints to characters. You don't get any string without it.

does the only numerical calculation in this program. What it does is, take a single number on its right and convert into the base on its left. Since we want an array of length 13, length-13 array is required on its left side. Since the largest digit value we will need is 114, I chose base 115 to tightly fit the requirements of left side of .

The right side of  is `≢⍬⍬⍬⍬⍬⍬...`, which computes the length  of the array containing exactly 389960998265612367812323333 s.  is an empty numeric vector, so you can't get any meaningful number from it, other than the length of the vector.

Finally, a comment about the byte count. In challenges, we use SBCS to count the APL symbols as one byte each. But the default source encoding is actually UTF-8, making APL symbols take 2 or 3 bytes.
> 43 votes

# Answer
# Malbolge, 265 bytes

Malbolge is too concise to win this competition.

```
('BA@?>=<;:9876543210/.-,+*)('&%$#"!~}|{zyxwvutsrqponmlkjihgfedcba`_^A\[ZYXWVUTSRQPONMLKJIHGFEDCBA@?>=<;:9876543210/.-,+*)('&%$#"!~}|{zyxwvutsrqponmlkjihgfedcba`_^]\[ZYXWVUTSRQPONMLKJIHGFEDC<$#9]=<;:9y1U/432+ONo'&+$Hi!~}$#z@xw|uzs9Zpunsrk1RQgfe+iba'Hdcb[!_XW{[TSRvc

```

Try it online!
> 31 votes

# Answer
# Python 3, ~~44619 8.13\*1011515~~ ~\\$10^{10^{5749}}\\$ bytes

The program itself is rather too large to fit ~~in the observable universe~~ on Stack Overflow, so this is a link to a program that can generate it... if you change the rather large number generator to a `~9` instead.

Try it online!

This can certainly be longer, but I'm going to post it now since I'm not 100% sure this is irreducible. It is basically made up of several irreducible components stacked together.

This relies mostly on a very large number `n`, generated by the state of the Mersenne twister with the seed `8` reduced by ~~multiplication~~ exponentation, i.e `~functools.reduce(pow,b)`, where `b` is taken from:

```
import functools
from random import *
seed(8)
d=getstate()
a,b,c=d

```

First, it execs the reverse of a very long string, separated by n waste bytes in the form:

```
exec("a...b...c...d"[::~n])

```

You can't remove the `.`s, unless you also remove the `[::~n]` reversing the string. If you remove the `.`s and the `[::~n]` then the resulting program won't really work since it is backwards, and the only `print` part is at the end, so no output without that.

The next portion looks like:

```
print(''.join([chr(len(...)), n ''s, chr(len(...)))][::~n]))

```

Similarly, you can't remove the `''`s without also taking out the `[::~n]`. You also can't reduce `chr(len([0]+[0]+...+[0]))` and still get the character you want, nor can I find anyway of modifying it with the `''`s to still get the character as well as another list item.

Please point any mistakes I have made or any ways you can think of to reduce this.
> 27 votes

# Answer
# JavaScript, 9007199254741154 bytes

```
n=0
a=Number.MAX_SAFE_INTEGER-1
b="Hlo, world![...]e"
console.log(`${b[n]}${b[a]}${b[++n]}${b[n]}${b[++n]}${b[++n]}${b[++n]}${b[++n]}${b[++n]}${b[++n]}${b[++n]}${b[++n]}${b[++n]}`)

```

Where `[...]` is \\$2^{52}-14\\$ `?` characters.

The -1 is needed since strings cannot be longer than \\$2^{52}-1\\$ characters.

`a` cannot be reduced to a smaller number other than `1`, which would not work since the `e` in the string cannot be put that early in the string than the `!`.

The `console.log` cannot be reduced, since none of the characters are needed in the string "Hello, world!".

Overall, there's no way to get the character `e` without going past the `!` in the string, and there's no way to get a number bigger than 11 other than `a`.

This could probably be improved by using `charAt`, but I'm not confident that couldn't be reduced in some way and it would not change the order of magnitude.
> 15 votes

# Answer
# Python 3, more than \\$X\\$ with \\$X=I \uparrow^{I\uparrow^I I} I\\$ with \\$I=5735816763073854918203775149089\\$

The code is obtained by replacing the `...` in the following code template with \\$X\\$ `1`s.

```
Q=...
exec((762032390336888825205597926747277417487750831511159354629396897028305422383809626318366885737257014369722764755200848545489986725226445234793373668671810533881138176176448303759321782505578156778007890400705523398552371012795706771315225018503248709400507137379430210053109689578295520735219645943760052105586918960055263333607993034635218854740823639508170672552847248741914750040981085688131560558606928438081257071207856256012302413393203594650299912375359565857111459962764512316315869934115819878468802797551498049081777877631940391679271936869727271355722250026194813663937402797387251113215482921743182358788283759577057493220552247028564950916113993279648626087865361138353729963114793860621704499349445249742987180001965672667483449648323146579902833012079301328244612376274244962633770509185016854868366255206566065732320472204953606291770458667922914208019769351151138241745701181139210).to_bytes(ord("ŵ"),"big"))

```

Shortened version if you don't want to/can't scroll that far

```
Q=...
exec((762...digits...210).to_bytes(ord("ŵ"),"big"))

```

## Why it prints `Hello, World!`

The expression passed to `exec` evaluates to the string

```
def arrows(a, n, b):
    if n == 1:
        return a**b
    if b == 0:
        return 1
    return arrows(a, n - 1, arrows(a, n, b - 1))

def fast_function(n):
    return arrows(n, arrows(n, n, n), n)

def inverse(n):
    i = 1
    while True:
        if fast_function(i) == n:
            return i
        i += 1

print(inverse(len(str(Q))).to_bytes(13, 'big').decode())

```

How? The big pile of digits in the original code is just this string but we interpret the bit sequence given by its ASCII encoding as a binary representation of a number (this is obtained using `int.from_bytes(...,'big')`, `'big'` for endianness). Then we get the string by the inverse method `.to_bytes(length,'big')`. We use a trick to meet the requirements and instead of having the length in decimal we use `ord("ŵ")` which evaluates to `373` because that's the Unicode codepoint of `ŵ`.

`arrows` computes \\$A \uparrow^N B\\$ using a formula from Wikipedia.

The number \\$I\\$ is given by `int.from_bytes(b'Hello, World!', 'big')`. This way, `Hello, World!` is encoded in that very long string of ones. Then we decode this string by inverting the function with which it was defined.

## Why it's irreducible

It's not very a formal proof, but I think it works. The fact that my code structure is very simple helps.

To print `Hello, World!` we need to call some sort of printing function. Clearly, the only hope for that is by the `exec` function. The doc says that `exec` must take a string or a code object. Well, actually we are passing a `bytes` object which also works. If it didn't work, we could just use `.decode('ascii')`, but because `bytes` work this would make a reduction possible. So to obtain such an object (byte, code or string) we will need to use either the quotation marks or the `to_bytes` method. There's only a few options with quotation marks and none of them work. So we must use `to_bytes`. Because we encoded the string length as `ord("ŵ")`, any change to the parameters of `to_bytes` will break the program. So we must change the big integer that encodes our code. It's statistically obvious, but if you want you can also computationally check that if we delete any single character or a pair or a triplet of characters from it, we will get garbage, and for sure not a working code that prints `Hello, World!`. If we delete 4 or more characters, we will get an integer more than 256 times smaller. Because we interpret that with the same length (`ord("ŵ")`), we will get a null byte, and `exec` will throw `ValueError: source code string cannot contain null bytes`.

## Extra

Code for generating answers:

```
code=b'''
<insert code to be executed>
'''
print('Q=...')
print('exec(('+str(int.from_bytes(code,"big"))+').to_bytes(ord("'+chr(len(code))+'"),"big"))')

```

Note that `chr(len(code))` won't always exist (especially for very long codes), so this answer doesn't easily generalize to any very fast function. In my opinion if someone comes up with a way to do it for any code this question will be ultimately "solved" (edit: actually, Higman's lemma implies that the score on this question is bounded, so this is impossible).
> 15 votes

# Answer
# Ruby, ~~1862 ...~~ 1.3\*1056 bytes

```
eval (""*33425716343835650854570646632771294442636521632690315021).size.digits(999).map(&:chr).join

```

Don't try it online!

Packed the whole program into a single base-999 number (1 digit for each character).

Decode, convert to ascii characters, join and evaluate.
> 9 votes

# Answer
# JavaScript, 24855 bytes

```
[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]](([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(+(+!+[]+[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+[!+[]+!+[]]+[+[]])+[])[+!+[]]+(![]+[])[!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(+![]+[![]]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]]+(![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]]+([]+[])[(![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(!![]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]()[+!+[]+[!+[]+!+[]]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]((!![]+[])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+!+[]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+!+[]]]+([][[]]+[])[+[]]+([][[]]+[])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(+(!+[]+!+[]+[+!+[]]+[+!+[]]))[(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(+![]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(+![]+[![]]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]]](!+[]+!+[]+!+[]+[+!+[]])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]])()([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]((!![]+[])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+!+[]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+!+[]]]+(!![]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(+(!+[]+!+[]+[+!+[]]+[+!+[]]))[(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(+![]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(+![]+[![]]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]]](!+[]+!+[]+!+[]+[+!+[]])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]])()(([]+[])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+[]])[+[]]+(!+[]+!+[]+!+[]+!+[]+[!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]])+[])+(!![]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+[[]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]]([[]])+[]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+!+[]]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]((!![]+[])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+!+[]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+!+[]]]+([][[]]+[])[+[]]+([][[]]+[])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(+(!+[]+!+[]+[+!+[]]+[+!+[]]))[(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(+![]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(+![]+[![]]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]]](!+[]+!+[]+!+[]+[+!+[]])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]])()([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]((!![]+[])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+!+[]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+!+[]]]+(!![]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(+(!+[]+!+[]+[+!+[]]+[+!+[]]))[(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(+![]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(+![]+[![]]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]]](!+[]+!+[]+!+[]+[+!+[]])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]])()(([]+[])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+[]])[+[]]+(!+[]+!+[]+!+[]+!+[]+!+[]+[!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]])+[])+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+([][[]]+[])[!+[]+!+[]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]((!![]+[])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+!+[]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+!+[]]]+([][[]]+[])[+[]]+([][[]]+[])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(+(!+[]+!+[]+[+!+[]]+[+!+[]]))[(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(+![]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(+![]+[![]]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]]](!+[]+!+[]+!+[]+[+!+[]])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]])()([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]((!![]+[])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+!+[]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+!+[]]]+(!![]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(+(!+[]+!+[]+[+!+[]]+[+!+[]]))[(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(+![]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(+![]+[![]]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]]](!+[]+!+[]+!+[]+[+!+[]])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]])()(([]+[])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+[]])[+[]]+(!+[]+!+[]+[+!+[]])+[])+([]+[])[(![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(!![]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]()[+!+[]+[!+[]+!+[]]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]])()

```

Try it online!

This was made using jsfuck.com with the input `console.log("Hello, World!")`. This is the smallest program I could make. Smallest because, due to the fact that there's only 6 characters, I'm afraid that a bigger one could easily remove characters to come up with a smaller one.
> 8 votes

# Answer
# Runic Enchantments, ~~12186~~ 15596231 bytes

```
_/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\
^+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"
"n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+
z""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
"+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n+n
n"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+"+
\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\k@

```

Try it online!

Above code generates only an `H` and operates as a platform by which modifications are made in order to achieve the listed score. Previous explanation in edit history.

Further?

Further.

```
"̌ * " +᷾ "̌ + . ᷾.
. . . . * . . .
n . . . " . . .
. . . . 1 . . .
. . . . ? . . .
͐. . + . " * " n̂
" * " n̂ n͐ + . .

```

This pattern is not reducible (ignore the spaces, they are used to align things so that the modifier characters are visible, as they don't combine with non-alpha characters; `.` are NOP code points that can be subject to alteration). See this tio for a version without and this one for full accurate placement with spaces.

The pattern uses 74 bytes to represent `-4`, or 18.5 bytes per `-1` (up from the baseline 7 bytes). And we need *a lot* of `-1`s. 117704 of them to be precise.

Proof of irreducibility:

* No entire rows can be removed, the `1?` lines appear to be, but due to the duplicated `"` (one above, one below), this will result in the string `*n͐` being multiplied against the next value on the stack, which (as the string is first) is not a valid action. the `n..."` row can't be removed along with those two, as the `n` is needed in the leftmost column
* There is no 8-way contiguous vertical collection of `.` that can be removed (reducing pattern width), as the lower right corner is inaccessible and no other `.` exist on the bottom row.
* Directional change characters can't be removed without bypassing the needed number of `-1` operations. The closest we can get is changing the bottom row to `"*"n+..`, but this would only be viable if the initial value `"rb"n` (9141) minus the desired character was both:
    1. Divisible by 4
    2. Constructable from the available bytes (`e`: `2260`/`"inch"`, `!`: `2277`/`"failure"`, the rest are not divisible by 4)
* *Or* if "rb" can be reduced to either "r" or "b" without adversely affecting the output (note that `"r "` and `" b"` are not valid and will produce a `-1` instead of a positive value). Given a vertical arrangement of the setup and output sequences and the ability to place these bytes such that this is prevented, this will not be possible.
    + Six rows need to be prevented from wholesale deletion (partial deletion results in `"r."` or `".b"` where `.` is a non-empty byte)
    + Putting `rb` and `k$` on paired rows
    + entry and terminator each on their own rows
    + A reflector on the top row above a `^` entry point protects the top row
    + Any row with the `"` around `rb` is automatically protected, as these bytes need to remain

Thus, the entry column is `_^"rb"n͐`, the output/reset between letters is two columns, `̌.."rb"!͐` / `᷾..$k..̂.`, and the last column (aligning `k$` with the initial `rb`) is `..;$k.̂.` (executed bottom to top).

The two columns allow the code to bloat slightly, adding seven more `.` positions over keeping input and reset on a single column (`k$"rb"ǹ`) as well as an additional (more expensive) .

This represents code entry, one copy of the pattern, one output, and final output (a newline) and termination. Not the extra `!` needed on the last iteration of the pattern so that flow is correctly handled (this costs a measly 13\*3 bytes; along with 7\*4 bytes at the end of rows that we can't enforce not being removed).

Finally, replace all `.` and `*` with  (or other four-byte codepoint).

<sub>I've done my best to accurately account for the overhead increases and costs after computing the raw pattern's byte sum, but I recognize I may be off by a small amount.</sub>

### Ohgodwhy; it gets bigger

I *believe* this is irreducible.

```
DL.....DL..
R."p"...U..
..RD....D.L
.U.L"̌a"L.RU
RDU.\..../.
U.L...DL\.D
..ULUL...DL
...ULUL.D.L
....U...LRU
>.0....U../@
."R"h"D.R+U
.t...DL.UL.
."..D/..≠.D
.RU/LU..L.?
R.D....RU.n
U"z"᷾.R5URU.
..R:l͍U..U.L

```

Try it online!
Sequence `>.0` simply to set the stack to contain an initial value (and should be considered `...`)

All the `UDLR/\` would be replaced by their 2-byte modifier counterparts and every cell not otherwise filled with a command is given a 4-byte unicode character. This works out to (I think) 647 bytes to generate a single -1. On top of that, our initial value rises from `"rb"n` (9141) to 914,100,000 by making each initial letter get constructed from `"rb"nYC`. As `YC` occupy space, they would irreparably damage the redirection pattern.

*Roughly* speaking (accurate overhead between letters not verified, but we're talking about a few dozen bytes at most), this works out to a **score of 7,688,494,370,086 (7.6 trillion).**

Breaking this would require finding a way to bypass the maze of pointer redirections without (a) breaking the pattern--as a large number of the paths redirect away an infinite loop or an invalid command--and still (b) generating a 5 character long string prior to hitting the `n`, due to a `:l͍5≠?` jump check. It costs a few bytes to make this check (11 bytes lost), but reinforces the durability of the pattern.

The string `pathz` was chosen as a 5-character long sequence where every right-truncated string ("p", "pa", "pat", "path") was present in the word dictionary (meaning that when calling `n` on it, a positive value will be generated), forcing the program to trace out a meandering route to pick up each letter before hitting the `"z"` to get a string *not* in the dictionary. This can still be improved as `paths` is also present in the dictionary (leading to a 6-length string `pathsz`), but at this point I'm starting to look for something that will increase the byte count exponentially and searching the word dictionary for longer strings with the desired characteristics is tedious.
> 8 votes

# Answer
# 05AB1E, ~\\$ 2.5 * 10^{1777} \\$ bytes

The program starts with

```
0>>>

```

and ends with

```
>>>₃!B

```

The middle part contains only `>`s. The total number of `>` characters is:

```
25098162498309588141154755713074390728103069770760074052238917714173876569868691148634176042549175869030448613081100685727537868105068700724415925612269913808499593749918259101545058124654299723726788764334516211684517256948150101180347289022916451558063426031977347451784256897939400652192236258404382348291844743098281742132582049622009384267074810165806373625784728505734586204138892008754810475549403699039426186131241703961770535892728517146019084030050442530148258880465488890083243702565168936069732829928523360052189688531653618029376719759781260232103800093423138357627776562507740948193791067875062805362373001178316850530206611655698994809536157618843298702262299360918288261564223252149018550707768612220426942031389689583329954564583964489539401022510402195332590853218889942437696056695694081344105843161388328303942196356740993490866574068963912863542108279785861191372068053541704843746894440836367259040196995776642457675255580282220480198375934046309922417713428449142775746485165498609097611793368868901625760889393125891944629947649779133088521446313250650588664709735304384247130277354954932511616598273575895960608533708122096438984165676161316003824004917770330565834832795106416101932812692556113632137070814564345428247405370236327568550073970242283021250795797947677972536187886102436517154778645480506007742084298028704070794564223287823038090829494405820111266559120056874535142759744222946196301541177968199011163222223586545099389340200154682693649402549469667375585074560462157985842615966304441485063393013230239088187979990342162755440071831240592907396920570963455610552369098113994760814140693782610141274535146253381742786984559554283939414217235549169221491345428712601180598448294078655886898659207237704837686666199040000000000000000000095

```

Try it online! (using an integer literal instead of all the `>`s, since the full version obviously isn't gonna fit on TIO). Or try the code that generated this number.

Proof of validity:

* `B` is the only operator in the source that can return a string, thus it cannot be removed.
* `B` on an empty stack returns an empty string, and on a single-element stack it returns `10`. So we absolutely need two elements on the stack. Since `0` and  are the only operators in the source that increase the size of the stack, neither can be removed.
* If `!` was removed, the resulting program would look like `0 (some number of '>'s) ₃B`. This converts the number of `>`s to base 95. Since `!` is not a base-95 digit in 05AB1E, this cannot produce the string `Hello, World!`. Thus `!` cannot be removed.
* Since neither `0`, , `!`, nor `B` can be removed, the program is guaranteed to look like `0 (some number of '>'s) ₃!B`. This converts the number of `>`s to base 95! (where `!` means factorial). This is an injective operation: only one number will yield `Hello, World!` when converted to base 95!. Thus, the number of `>`s cannot be altered.
> 8 votes

# Answer
# C# (Visual C# Interactive Compiler), 10658 bytes

Try it online!

C# allows unicode escapes in identifiers, and I decided to take full advantage of the fact here.

Non-escaped code:

```
Write(String.Join(String.Empty,(String.Empty+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'¥'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'¥'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'¥'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'¥'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'¥'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'¥'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'¥'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'¥'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'¥'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'¥'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'¥'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'¥'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö'+'Ö').Split('¥').Select(l=>(Char)l.Length)))

```

The program creates a string of `ÖÖÖÖ...¥ÖÖÖÖ......` (`...` are placeholders) and splits it along `¥`. For each resulting string in the array, it takes the length of the section and casts it into a character.
> 5 votes

# Answer
# Wren, 1220 bytes

Finally found a use of Wren's verbose syntax!

~~I'm pretty surprised that none of those answers use the perfect byte-waster log.~~ The eclipses are things that are too long for this program.

```
["...","...","...",...].each{|i|System.write(String.fromCodePoint(i.count))}

```

Try it online!

## Explanation

```
["...","...","...",...] // Those constants too long for this program
.each{|i|} // Each, the perfect byte-waster!
System.write() // Verbose output to STDOUT...
String.fromCodePoint() // Convert to code points
i.count // Length of i

```
> 5 votes

# Answer
# Golfscript, 144,202,216,216,222,088,064,174,222,228,216,200,081 bytes

```
"...",`3/{~2/}%''+

```

where ... is replaced by 144202216216222088064174222228216200066 0's

### Explanation:

```
"...",`                  Count 0's and convert to string
       3/{   }%          Map over each group of 3 digits:
          ~2/                Divide by 2
               ''+           Convert ascii codepoints to string

```

The ascii codepoints for "Hello, World!" are as follows:

```
072 101 108 108 111 044 032 087 111 114 108 100 033

```

Concatenating them together isn't enough to be able to access them by splitting them into threes because the integer would be interpreted as 72101... rather than 072101..., meaning that splitting it into threes would yield 721 as the first codepoint instead of 072. To remedy this, I doubled it and then divided each individual codepoint by 2 after they're separated out. This has the added bonus of nearly doubling the length of the code.
> 4 votes

# Answer
# Mathematica, 10<sup>10<sup>128433</sup></sup> at least 10↑↑11.29 bytes

```
FromCharacterCode[StringLength["aaaa...aaaa"]~IntegerDigits~Nest[Hyperfactorial, 10, 9]]

```

old:

```
 FromCharacterCode[StringLength["aaaa...aaaa"]~IntegerDigits~Hyperfactorial[Hyperfactorial[3]]]

```

Where "aaaa...aaaa" is `FromDigits[ToCharacterCode["Hello, World!"], Hyperfactorial[Hyperfactorial[3]]]` a's long. That's about 10<sup>128433</sup> digits long. The key here is that the "W" is character code 114, which means the base of the number can't even drop below 114, or the code won't output properly. I believe `Hyperfactorial` to be the fastest growing function, with `Hyperfactorial[3] = 108` and `Hyperfactorial[4] = 27648`, meaning that nesting 2 Hyperfactorial is the maximum number, and any attempt to reduce it will drop the base below 114.

Edit: This is not the biggest answer, `Nest[Hyperfactorial, 10, 9]` as a base would be bigger, as it cannot be reduced to a number greater than 114. Sadly, I'm not at the level to even start getting close bounds, so lets go with a very poor lower bound, which would still be a valid score.

`Ω(Log10[Hyperfactorial[x]])` is `x`, where `Ω` is lower bound notation. It's really closer to x<sup>2</sup>, but compared to the power of logerithms, they may as well be the same. This means that Hyperfactorial nested 9 times is at minimum (10)↑↑(10). The number of characters is 10 to this power, so (10)↑↑(11).
> 4 votes

# Answer
# 05AB1E, 5,697,476,345,285,646,822,141,672,875,833 bytes

```
….g257B

```

The  is actually 1,424,369,086,321,411,705,535,418,218,957 `…aaa`'s.

## Explanation

```
…       # Push 1,424,369,086,321,411,705,535,418,218,957 things
 .g     # and count how many things there are on the stack
   257B # then convert it to base 257

```

I think `…aaa` is the longest irreducible literal possible, so I use it here.
> 3 votes

# Answer
## Charcoal, ~~4022948789620328394911726~~ 144202216216222088064174222228216200073 bytes

```
↑Ｅ↨Ｌ´´...´´φ℅ι

```

Explanation: `´´...´´` represents a string literal of length 72101108108111044032087111114108100033. However, `´` is the quote character in Charcoal, so it needs to be doubled in order to quote itself, thus requiring 144202216216222088064174222228216200066 `´`s. The length is then converted to base 1000 using the predefined variable that contains 1000, and the values are then converted to their Unicode character values. However, the result is still an array, so the  is used to output the characters correctly.
> 2 votes

# Answer
# Jelly, ~~17,502,248,526,741,541,454,928,712,794~~ \\$3.14 * 10^{1896}\\$ bytes

```
³!¤“...”LbỌ

```

Try it online!

No, I did not force TIO to execute that many bytes of code :) I hardcoded the value in. See the TIO link for the exact number of characters.

```
³!¤“...”LbỌ - Main niladic link
   “...”    - The real meat of the program. a very long string of characters. See the TIO link for the exact number of characters
        L   - Takes the length of the string
³!¤      b  - Convert from base 10 to base 100!
          Ọ - Turn the array into a string

```

Irreducible because:

* If you omit a character in the literal, the resultant number will be wrong
* If you change ³!¤, the base conversion will be incorrect
* If you omit any other byte, the program will either not print "Hello, World!" or do strange things

Funny that Jelly is a golfing language, and yet you can make such a long irreducible program for the simplest of things.

EDIT: Thanks @Bubbler for fixing my output format and adding some bytes EDIT: Fixed the score
> 2 votes

# Answer
# naz, ~~2308~~ 4548 bytes

```
[encoded data, 4548 characters]

```

**Explanation**

This commit adds the `n` command to naz, which negates the value of a specific variable.

For each character in the string `Hello, World!`, the above program follows the following steps:

* Subtract 1 from the register 127 times.
* Store the resulting value of -127 in variable 1.
* Negate variable 1, and set the register to the new value.
* Subtract 1 enough times to reach the ASCII value of the character, then output it.
* Multiply the register by 0 and store the resulting value of 0 in variable 1.

I *believe* this is irreducible because of the following (but I'd love to be proven wrong):

* Removing any one number or any one letter will create a broken instruction and throw an error.
* Removing any instance of `1s` will result in an incorrect character being output.
* Removing any instance of `1o` will result in a character being omitted from the output.
* Removing any instance of `0m` will eventually result in an incorrect or completely invalid output value.
* Removing any instance of `2x` will either result in an invalid output value or allow the value in the register to go out of bounds, unless you remove the first instance, in which case an error will be thrown because the variable will be used before its value is first declared.
* Removing any instance of `1v` will throw the error `improper use of opcode 2`.
* Removing any instance of `1n` will allow the value in the register to go out of bounds.

The previous 2308-byte solution:

```
1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1o0m1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1o0m1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1o0m1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1o0m1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1o0m1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1o0m1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1o0m1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1o0m1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1o0m1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1o0m1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1o0m1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1o0m1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1o

```
> 1 votes

# Answer
# BrainF\***, 2992 bytes

```
-{184}.-{227}.-{249}>+{254}[+<.>]<-{253}.+{189}.+{244}.-{201}.-{232}.-{253}.+{250}.+{248}.+{189}.

```

Where `w{n}` means `w` repeated `n` times. BF is cyclical mod 256, so instead of going "up" 72 to get to "H", you can go "down" 184 to get there. `-{227}` just adds 29 to get to "e", and so on with these basic building blocks, except for the double "ll". I made a counter set to -2 (254), then add 1 both times to run the output (`.`) twice.

Full program:

```
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------.-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------.--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------->++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++[+<.>]<-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------.+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------.----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------.-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------.++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.

```

Try It Online!
> 1 votes

---
Tags: hello-world, code-bowling
---


title: Making Sandwiches

text:
# Question
Title: Making Sandwiches
# Introduction

Bob runs a deli. His deli serves sandwiches to its customers. However, it is a bit unusual. At Bob's deli, instead of telling Bob what they want, customers show Bob an ASCII art drawing of their sandwich. Bob must find the pattern in their sandwich so he knows what ingredients to prepare. However, Bob does not like picking out patterns. He wants you to write a program to help him do that.

# Challenge

You must write a function which, given the filling of a sandwich, will output a list of ingredients for Bob to prepare. You must find the pattern of ingredients in the filling, then output that pattern.

* Input will be a string. It will never be empty, and it will only contain printable ASCII characters (characters 32 to 255). If your language has no method of input, input can be taken in the form of command line arguments or stored in a variable.
* Output must be a string. If your language has no method of output (or you are running a function, not a full program) you may output through return code or through a variable.

# Example I/O

* `Input: |&|&|&|&`
`Output: |&`
* `Input: :&|:&|:&|`
`Output: :&|`
* `Input: ((&|((&|((&|((&|`
`Output: ((&|`

# Rules

This is , so shortest answer wins!

# Answer
# Python, 28 bytes

```
lambda s:s[:(s+s).find(s,1)]

```

Try it online!

The length of the output is the first nonzero position starting from which `s` can be found in the doubled `s+s`.

For example:

```
s   = abcabcabc

s+s = abcabcabcabcabcabc
         abcabcabc
         ^
         s starting at position 3 (zero-indexed)

```

---

**46 bytes**

```
f=lambda s,p='':p*(s+p==p+s)or f(s[1:],p+s[0])

```

Try it online!
> 25 votes

# Answer
# 05AB1E, 3 bytes

```
η¢Ï

```

Try it online!

```
η     # prefixes of the input
 ¢    # count the number of occurences of each one within the input
  Ï   # filter the input, keeping only indices where the above is 1

```

Prefixes that stop short of the last repetition of the pattern can be found multiple times in the input, offset by a pattern-length. Thus, this ends up keeping only the last repetition of the pattern.
> 7 votes

# Answer
# Jelly, 5 bytes

```
Ḋ;wḣ@

```

Try it online!

A slightly modified version of xnor's answer. Method: Given **S**, concatenates **Swithout the first character** with **S**, then finds the index of **S** in this new string, then takes the head.
> 6 votes

# Answer
# JavaScript (ES6), 25 bytes

```
s=>/(.+?)\1*$/.exec(s)[1]

```

Try it online!

### Regular expression

```
   +-------> 1st (and only) capturing group: 1 or more character(s), non greedily
   |   +---> reference to the capturing group, repeated 0 to N times
  _|_  | +-> end of string
 /   \/ \|
/(.+?)\1*$/

```
> 4 votes

# Answer
# , ~~22~~ 15 bytes

```
{.~1+]i.~#$&><\

```

Try it online!

No regex solution:

```
{.~                      NB. take from the input this many chars:
    1 +                  NB. 1 plus...
          i.~            NB. the first index of...
        ]                NB. the input in this list:
                    <\   NB. every prefix of the input...
                $&>      NB. cyclically repeated to...
              #          NB. the size of the input.

```

---

I could shave off two more bytes using a xnor's wholly different approach, but for the sake of variety I'll leave my original as the answer:

```
{.~1{]I.@E.,~

```

Try it online!
> 4 votes

# Answer
# Icon, 50 bytes

```
procedure f(s)
return s[1:1+find(s,s[2:0]||s)]
end

```

Try it online!

An Icon port of xnor's Python solution. Don't forget to upvote his answer!
> 3 votes

# Answer
# Perl 5 (`-p`), 15 bytes

```
s/(.+?)\1*$/$1/

```

Try it online!
> 3 votes

# Answer
# C (clang), 72 bytes

```
f(char*s){int n=1,p=1;while(s[p]|p%n)s[p]^s[p%n]?p=++n:++p;puts(s+p-n);}

```

Try it online!

**Explanation:**

The algorithm is a simple brute force search, checking whether the entire string is a repetition of a pattern of length n=1,2,3,…. The non-golfed implementation could be as follows:

```
void f(char* s)
{
    // try pattern length=1,2,3…
    for (int n = 1; ; n++)
    {
        // loop over the string (until null terminator) to see if
        // it's a repetition of the pattern
        int p = n;
        for (; s[p]; p++)
        {
            if (s[p] != s[p%n])
            {
                // not a repeating pattern
                break;
            }
        }

        if (!s[p]) {
            // we've reached the end of the string, so it seems to be
            // a repeating pattern… but it's not a valid solution
            // if the pattern is cut off in the middle ("cutoff case"):
            // e.g. abc-abc-abc-ab
            if (p % n == 0)
            {
                // print and return: we can simply output the *last*
                // occurrence of the pattern, because it is followed
                // by the null terminator
                puts(s + p - n);
                return;
            }
        }
    }
}

```

The golfed version is doing this in a single loop:

```
f(char* s)
{
    int n=1,p=1;
    while (s[p]|p%n)
        // more verbosely, s[p] || (p%n != 0)
        // - Loop while we haven't reached the null terminator.
        // - If we have, keep going if p is not a multiple of n
        //   (i.e. in the cutoff case).
    {
        s[p]^s[p%n]?p=++n:++p;
            // more verbosely,
            // if (s[p] != s[p%n]) { n++; p = n; } else { p++; }
            // - If the pattern is not repeating, increment the pattern
            //   length n and start over. This also applies in the cutoff
            //   case; in that case s[p] is the null terminator.
            // - Otherwise increment p and continue checking the string.
    }
    puts(s+p-n);
}

```
> 3 votes

# Answer
# Perl 6, 16 bytes

```
{m/(.+?))>$0+$/}

```

Try it online!

Standard regex solution, finding a non-greedy match that repeats for the whole string
> 2 votes

# Answer
# Jelly, 6 bytes

```
sJEƇḢḢ

```

A monadic Link accepting a list of characters which yields a list of characters.

**Try it online!**

### How?

```
sJEƇḢḢ - Link: list of characters, S
 J     - range of length (S) = [1,2,3,...,length(s)]
s      - (S) split into chunks (of each of these sizes)
   Ƈ   - filter keep those for which:
  E    -   all equal?
    Ḣ  - head
     Ḣ - head

```
> 2 votes

# Answer
# Retina, 12 bytes

```
(.*?)\1*$
$1

```

Try it online!
> 2 votes

# Answer
# Red, 51 bytes

```
func[s][copy/part t: append copy s s find next t s]

```

Try it online!

A Red port of xnor's Python solution. Don't forget to upvote his answer!

## Using `parse`:

# Red, 71 bytes

```
func[s][n: 0 until[n: n + 1 parse s[copy t n skip any t]]copy/part s n]

```

Try it online!
> 2 votes

# Answer
# 05AB1E, 6 bytes

```
η.ΔKõQ

```

Try it online or verify all test cases.

Or alternatively:

```
«¦sk>£

```

Try it online or verify all test cases.

**Explanation:**

```
η       # Get the prefixes of the (implicit) input-string
 .Δ     # Get the first prefix which is truthy for:
   K    #  Remove all occurrences of this substring in the (implicit) input-string
    õQ  #  And check if what remains is an empty string
        # (after which the found prefix is output implicitly as result)

«       # Append the (implicit) input-string with itself
 ¦      # Remove the first character
  sk    # Get the (0-based) index of the input-string in the earlier created string
    >   # Increase this by 1 to make it a 1-based index
     £  # And only leave that amount of leading characters from the (implicit) input-string
        # (after which this is output implicitly as result)

```
> 2 votes

# Answer
# Python 3, 46 bytes

```
lambda s:re.match(r"(.+?)\1*$",s)[1]
import re

```

Try it online!
> 1 votes

# Answer
# Ruby `-p`, 18 bytes

```
~/(.+?)\1*$/
$_=$1

```

Try it online!
> 1 votes

# Answer
# Japt, 7 bytes

```
¯ÒU²ÅbU

```

Try it

```
¯ÒU²ÅbU     :Implicit input of string U
¯           :Slice to 0-based index
 Ò          :  Bitwise increment
  U²        :    Duplicate U
    Å       :    Slice off the first character
     bU     :    First index of U

```

# Alternative/Original

Since posted by Aztecco.

```
ã æ@¶îX

```

Try it

```
ã æ@¶îX     :Implicit input of string U
ã           :Substrings
  æ         :First element that returns true
   @        :When passed through the following function as X
    ¶       :  Test U for equality with
     îX     :  X repeated to length of U

```
> 1 votes

# Answer
# Japt, 7 bytes

```
ã f@¥îX

```

Try it

```
U.ã(). // all substrings
f( // filtered by..
function(X, Y, Z) { return U == U.î(X) }) // item repeated till input.length == input

```
> 1 votes

# Answer
# SimpleTemplate 0.62, 184 bytes

Yeah ... This is a very long one ...

It highlights the weaknesses of that specific version (check below for version 0.72).

```
{@setI 0}{@setC""}{@setA argv.0}{@do}{@setO"{@setc A.",I,"}"}{@callimplode intoO O}{@evalO}{@setC C,c}{@callimplode intoC C}{@incI}{@callstr_replace intoR C,"",A}{@untilR is""}{@echoC}

```

This is a huge mess, here's the ungolfed one:

```
{@set index 0}
{@set chars ""}
{@set arg argv.0}

{@do}
    {@set code "{@set char arg.", index, "}"}
    {@call implode into code code}
    {@eval code}
    {@set chars chars, char}
    {@call implode into chars chars}

    {@inc by 1 index}
    {@call str_replace into result chars, "", arg}
{@until result is equal to ""}

{@echo chars}

```

Yes, those 5 lines inside the `{@do}` only do 2 things:

1. Get the character at the position of the `index` value.
2. Add the character into the variable `chars`, as a string.

You can test the golfed and ungolfed versions on http://sandbox.onlinephpfunctions.com/code/7f2065a193d2bd0920cc3a4523e4b0ebf7a72644

---

---

**Version 0.72**, 112 bytes

This non-competitive version uses new features I've developed today, to allow me to do more with the language.

First, here's the code:

```
{@setX}{@setC""}{@do}{@setC"#{C}#{argv.0.[X]}"}{@incX}{@callstr_replace intoR C,"",argv.0}{@untilR is""}{@echoC}

```

It looks like a mess! Lets clear it up:

```
{@set index 0}
{@set chars ""}

{@do}
    {@set chars "#{chars}#{argv.0.[index]}"} {@// NEW IN 0.72}
    {@inc by 1 index}
    {@call str_replace into result chars, "", argv.0}
{@until result is equal to ""}

{@echo chars}

```

Most of this has been explained in other answers, so, I will focus on this line: `{@set chars "#{chars}#{argv.0.[index]}"}`.

This showcases 2 new features in the language and a bugfix:

* Now you can get a value from an array based on the value of a variable
* Now there's string interpolation, where `"#{chars}"` will interpret the `chars` variable and the result is a single string. Before, you would have to do `{@set chars chars, value2, ...}`, which makes an array instead of a string.
* Previously, you could only access 1 member of an array/string. Currently, you can access as many deep in as you want. This meant that `{@echo argv.0.0}` would need to be written as `{@set arg argv.0}{@echo arg.0}`.

The line `{@set chars "#{chars}#{argv.0.[index]}"}` replaces the previously mentioned lines inside the `{@do}`.

You can try this on http://sandbox.onlinephpfunctions.com/code/e2ab3d10c8224ee475cf4d4ca94fef7896ae2764
> 1 votes

# Answer
# Brachylog, 3 bytes

```
ġ≡ᵛ

```

Try it online!

```
ġ      Split the input into substrings of equal length
 ≡ᵛ    such that each substring is the output.

```
> 1 votes

# Answer
# GolfScript, 10 bytes

```
..2*1>\?)<

```

Try it online!

## Explanation

```
.          # Make a copy of the initial input
 .2*       # Make another copy that has a double length
    1>     # Trunctuate the copy to without the first item
      \    # Swap the copy to below
       ?   # Find the index of the input
        )  # Increment the index
         < # Slice the input so that the whole section emerges

```
> 1 votes

# Answer
# Husk, 6 bytes

```
↑¹€tD¹

```

Try it online! Yet another port of xnor's answer.
> 1 votes

# Answer
# Vyxal, 6 bytes

```
dḢ?ḟ›Ẏ

```

Try it Online!

Yet another port of xnor's answer
> 1 votes

# Answer
# Charcoal, 10 bytes

```
…θ§⌕Ａ⁺θθθ¹

```

Try it online! Link is to verbose version of code. Adaptation of @xnor's answer. Explanation:

```
     ⁺θθ    Duplicate the input
   ⌕Ａ   θ   Find all indices of the input
  §      ¹  Skip the first index, which is always zero
…θ          Truncate the input to that length
            Implicitly print

```
> 0 votes

# Answer
# Wren, 37 bytes

Basically a port.

```
Fn.new{|a|a[0..(a+a).indexOf(a,1)-1]}

```

Try it online!
> 0 votes

# Answer
# R, 33 ~~36~~ bytes

```
sub("(.+?)\\1*$","\\1",scan(,""))

```

Try it online
> 0 votes

---
Tags: code-golf, string, pattern-matching
---


title: Expand a matrix goo-ily

text:
# Question
Title: Expand a matrix goo-ily
## Input

An \\$m\\$ by \\$n\\$ binary matrix, with \\$m\\$ and \\$n\\$ both at least 2.

Think of the ones as gobs of melted cheese, which stretch as we expand the matrix horizontally and vertically.

More precisely...

## Output

A \\$2m-1\\$ by \\$2n-1\\$ binary matrix, constructed as follows...

First insert rows of zeros between the rows, and insert columns of zeros between the columns. For example, consider the input:

```
0 1 1
1 0 1
1 0 0

```

After we insert the zeros:

```
0 0 1 0 1
0 0 0 0 0
1 0 0 0 1
0 0 0 0 0
1 0 0 0 0

```

To make it extra clear what we're doing, here is the same matrix with the *new* zeros visualized as `#`:

```
0 # 1 # 1
# # # # #
1 # 0 # 1
# # # # #
1 # 0 # 0

```

Now, for each new `0` (or `#` in our visualization), if is between two ones (horizontally, vertically, or diagonally), convert it to a 1:

```
0 # 1 1 1
# 1 # 1 1
1 # 0 # 1
1 # # # #
1 # 0 # 0

```

Or, exiting our visualization and converting `#` back to `0`:

```
0 0 1 1 1
0 1 0 1 1
1 0 0 0 1
1 0 0 0 0
1 0 0 0 0

```

And that is the actual, final result you return.

## Rules

* This is code golf with standard site rules
* You may take input in any reasonable format (array of arrays, built-in matrix type, single flat list, etc)
    + With one exception: you may not take a list of the coordinates of the ones.
    + This exception applies to the output as well: you must output all of the zeros and ones in some reasonable form.
* You may optionally take \\$m\\$ and \\$n\\$ as a second argument
* You can do I/O using images, so long as there is a 1-1 mapping with the matrix entries.

## Brownie Points

* Solution using images for I/O.
* J solution under 47 bytes.

## Test Cases

```
1 0
0 1
->
1 0 0
0 1 0
0 0 1

1 1
0 1
->
1 1 1
0 1 1
0 0 1

1 1
1 1
->
1 1 1
1 1 1
1 1 1

1 1
0 0
->
1 1 1
0 0 0
0 0 0

1 1 0 1 0 1
1 0 0 1 0 0
0 1 0 0 1 0
0 1 0 0 1 1
1 0 1 0 0 0
->
1 1 1 0 0 0 1 0 0 0 1
1 1 0 0 0 0 1 0 0 0 0
1 0 0 0 0 0 1 0 0 0 0
0 1 0 0 0 0 0 1 0 0 0
0 0 1 0 0 0 0 0 1 0 0
0 0 1 0 0 0 0 0 1 1 0
0 0 1 0 0 0 0 0 1 1 1
0 1 0 1 0 0 0 0 0 0 0
1 0 0 0 1 0 0 0 0 0 0

```

# Answer
# Jelly, 15 bytes

```
żḢS€E?ƝẎ)Z$⁺Ạ€€

```

A monadic Link that accepts a list of lists of `1`s and `0`s and yields a list of lists of `1s` and `0`s.

**Try it online!** Or see the test-suite.

### How?

The basic idea is to insert a value, `f(left,right)`, between each neighbouring pair, `[left,right]`, of each row then to transpose, and then to repeat the same thing again (insert values, transpose).

In order to handle the diagonal requirement, we must have an `f(left,right)` that maintains the necessary information between the steps. That is, when neighbours are not equal we need to remember which one was a one during the first pass and have those values work for us during the second pass.

The code below implements `f(left,right)` as "if `left` equals `right` then yield `left` else yield the sum of each of `[left,right]`" (`ḢS€E?`). This means that the first pass can yield `[1,0]` or `[0,1]` (to be treated as `0`s in the end) in addition to `0` and `1`, and the second pass can then yield `[1,1]` too (to be treated as a `1` in the end).

```
żḢS€E?ƝẎ)Z$⁺Ạ€€ - Link: list of list of 1s and 0s, M
          $⁺    - do this twice - f(Current=M):
        )       -     for each Row in Current:
      Ɲ         -       for neighbouring pairs of elements in Row:
     ?          -         if...
    E           -         ...condition: equal?
 Ḣ              -         ...then: head
                             first pass: [0,0]->0
                                         [1,1]->1
                                              second pass: [  0  ,  0  ]->  0
                                                           [  1  ,  1  ]->  1
                                                           [[1,0],[1,0]]->[1,0]
                                                           [[0,1],[0,1]]->[0,1]
  S€            -         ...else: sum each
                             first pass: [0,1]->[0,1]
                                         [1,0]->[1,0]
                                              second pass: [  0  ,  1  ]->[0,1]
                                                           [  0  ,[0,1]]->[0,1]
                                                           [  0  ,[1,0]]->[0,1]
                                                           [  1  ,  0  ]->[1,0]
                                                           [  1  ,[0,1]]->[1,1]
                                                           [  1  ,[1,0]]->[1,1]
                                                           [[0,1],  0  ]->[1,0]
                                                           [[0,1],  1  ]->[1,1]
                                                           [[0,1],[1,0]]->[1,1]
                                                           [[1,0],  0  ]->[1,0]
                                                           [[1,0],  1  ]->[1,1]
                                                           [[1,0],[0,1]]->[1,1]
ż               -       zip Curent and those together
       Ẏ        -       tighten (flattens by one level, to counter the zip)
         Z      -     transpose
            Ạ€€ - all? for each element in each row
                  0->0  1->1  [0,1]->0  [1,0]->0  [1,1]->1

```

---

Implementing `f(left,right)` as a hash function, with Jelly's  built-in, I've only found a 16:

```
ż⁽7&,14ḥ$ƝẎ)Z$⁺Ḃ

```
> 3 votes

# Answer
# Python 3 with numpy, ~~97~~ 70 bytes

```
lambda m:abs(diff(diff(kron(m,1j**eye(2))),1,0))>=2
from numpy import*

```

Try it online!

The basic idea is this: Expand each element into a 2-by-2 block, then look at each 2-by-2 square (overlapping) in the resulting matrix; each square should correspond to a 1 iff it contains a pair of diagonally opposite 1s.

The implementation works a bit differently. `kron` expands each 1 into `1j**eye(2)`, which is \\$ \begin{array}{|c|c|} \hline i & 1 \\ \hline 1 & i \\ \hline \end{array} \\$, and taking `diff` in both directions is equivalent to a sum with multipliers \\$ \begin{array}{|c|c|} \hline 1 & -1 \\ \hline -1 & 1 \\ \hline \end{array} \\$ on each 2-by-2 square (overlapping). Then, each square contains two diagonally opposite nonzero values iff its result has real or imaginary component at least 2 in absolute value, which with integer components is equivalent to its own absolute value being at least 2.
> 8 votes

# Answer
# 05AB1E, ~~45~~ ~~38~~ ~~19~~ 16 bytes

```
2F€Dø€ü2}εε`RøPà

```

-19 bytes porting *@m90*'s Python answer, so make sure to upvote him/her as well!
-3 bytes thanks to *@m90*.

Try it online or verify all test cases or try it online with step-by-step debug lines.

**Explanation:**

```
2F       # Loop 2 times:
  €D     #  Duplicate each value in the current list
  ø      #  Zip/transpose; swapping rows/columns
   €     #  For each inner list:
    ü2   #   Create overlapping pairs
}        # Close the loop
         # (we now have overlapping 2x2 blocks of the input-matrix after that has been
         # expanded to 2x2 for each individual value)
 ε       # Map over each list of blocks:
  ε      #  Map over each 2x2 block:
   `     #   Pop and push both pairs separated to the stack
         #    STACK: [[a,b],[c,d]] → [a,b] and [c,d]
    R    #   Reverse the top pair
         #    STACK: [a,b] and [d,c]
     ø   #   Create pairs of these two pairs
         #    STACK: [[a,d],[b,c]]
      P  #   Take the product of each inner pair to check if both are 1
         #    STACK: [a*d,b*c]
       à #   Take the maximum to check if either was truthy
         #   (so whether the diagonal or anti-diagonal of the 2x2 block were both 1s)

```

---

**Original ~~45~~ 38 bytes answer:**

```
2Føε0ìSĆ]2Fø€ü3}εε2FøíÐÅsˆÅ\ˆ}¯ειPà}à´

```

Try it online or verify all test cases or try it online with step-by-step debug lines.

**Explanation:**

Step 1: Surround each value with 0s (including a border of 0s around the entire matrix, unlike the challenge description):

```
2F         # Loop 2 times:
  ø        #  Zip/transpose; swapping rows/columns
           #  (which will use the implicit input-matrix in the first iteration)
   ε       #  Map over each inner list:
    0ì     #   Prepend a 0 in front of each digit
      S    #   Then convert it to a flattened list of digits
       Ć   #   Enclose; append its own head (for the trailing border of 0s)
]          # Close both the inner map and outer loop

```

Step 2: Create overlapping 3x3 blocks of this matrix:

```
2F         # Loop 2 times again:
  ø        #  Zip/transpose; swapping rows/columns
   €       #  For each inner list:
    ü3     #   Create overlapping triplets
}          # Close the loop

```

Step 3: Transform each 3x3 block to a quartet of triplets of its middle row; middle column; main diagonal; and main anti-diagonal:

```
ε          # Map over each list of blocks:
 ε         #  Map over each 3x3 block:
  2F       #   Loop 2 times:
    øí     #    Rotate the 3x3 block 90 degrees clockwise:
    ø      #     Zip/transpose; swapping rows/columns
     í     #     Reverse each inner row
      Ð    #    Triplicate this 3x3 block
       Ås  #    Pop one, and push its middle row
         ˆ #    Pop and add this triplet to the global array
       Å\ˆ #    Do the same for the main diagonal
   }¯      #   After the loop: push the global array

```

Step 4: Check if either the middle is already 1, or if any sides of a middle row/column/diagonal/anti-diagonal are both 1:

```
  ε        #   Map over the list of triplets:
   ι       #    Uninterleave it from [a,b,c] to [[a,c],[b]]
    P      #    Take the product of each inner list: [a*c,b]
     à     #    Pop and push the maximum
  }à       #   After the map: pop and push the maximum
    ´      #   And clear the global array
           # (after which the result is output implicitly)

```
> 6 votes

# Answer
# PARI/GP, 82 bytes

```
m->matrix(2*#m~-1,2*#m-1,x,y,m[i=x++\2,j=y++\2]*m[k=i+x%2,l=j+y%2]||m[i,l]*m[k,j])
```

Attempt This Online!
> 4 votes

# Answer
# Octave, 45 bytes

A port of @m90's Python (NumPy) answer.

```
@(m)abs(diff(diff(kron(m,[i,1;1,i])),1,2))>=2

```

Try it online!

---

# Octave, 70 bytes

-5 bytes thanks to @Luis Mendo.

```
@(m)(n=kron(m,e(2)))(i=1:end-1,j=1:end-1)&n(i+1,j+1)|n(i,j+1)&n(i+1,j)

```

Try it online!

## how

Takes `m = [0 1 1; 1 0 1; 1 0 0]` as an example:

```
octave:1> m = [0 1 1; 1 0 1; 1 0 0]
m =

   0   1   1
   1   0   1
   1   0   0

octave:2> n = kron(m,e(2))    # Repeats each element by 2x2
n =

   0   0   1   1   1   1
   0   0   1   1   1   1
   1   1   0   0   1   1
   1   1   0   0   1   1
   1   1   0   0   0   0
   1   1   0   0   0   0

octave:3> n11 = n(1:end - 1, 1:end - 1)
n11 =

   0   0   1   1   1
   0   0   1   1   1
   1   1   0   0   1
   1   1   0   0   1
   1   1   0   0   0

octave:4> n12 = n(1:end - 1, 2:end)
n12 =

   0   1   1   1   1
   0   1   1   1   1
   1   0   0   1   1
   1   0   0   1   1
   1   0   0   0   0

octave:5> n21 = n(2:end, 1:end - 1)
n21 =

   0   0   1   1   1
   1   1   0   0   1
   1   1   0   0   1
   1   1   0   0   0
   1   1   0   0   0

octave:6> n22 = n(2:end, 2:end)
n22 =

   0   1   1   1   1
   1   0   0   1   1
   1   0   0   1   1
   1   0   0   0   0
   1   0   0   0   0

octave:7> (n11 & n22) | (n12 & n21)
ans =

  0  0  1  1  1
  0  1  0  1  1
  1  0  0  0  1
  1  0  0  0  0
  1  0  0  0  0

```
> 4 votes

# Answer
# Charcoal, 35 bytes

```
ＷＳ⊞υιＥ⊖⊗Ｌυ⭆⊖⊗Ｌθ⌈Ｅ²⌊Ｅ²§§υ⊘⁺ιπ⊘⁺λ¬⁼νπ

```

Try it online! Link is to verbose version of code. Takes I/O as a list of newline-terminated strings of `0`s and `1`s. Explanation:

```
ＷＳ⊞υι

```

Input the binary matrix.

```
Ｅ⊖⊗Ｌυ⭆⊖⊗Ｌθ⌈Ｅ²⌊Ｅ²§§υ⊘⁺ιπ⊘⁺λ¬⁼νπ

```

Loop over the dimensions of the expanded matrix, calculating the positions of the possible adjacent `1`s, and for each output `1` if one pair of positions is both `1`. This is equivalent to the following operations, starting with:

```
WX
YZ

```

This first gets expanded by duplication, i.e.

```
ABC WWX
DEF=WWX
GHI YYZ

```

Then for each position in the grid, two pairs of cells are checked: the cell itself and the one diagonally below right, and the cells below and to the right:

```
A -> AE | BD = WW | WW = W
B -> BF | CE = WX | XW = WX
D -> DH | EG = WY | WY = WY
E -> EI | FH = WZ | XY as desired

```
> 2 votes

# Answer
# Pip `-xP`, 25 bytes

```
{MX B*R_MPaZb}MP_WV_MaWVa

```

Attempt This Online!

### Explanation

Port of Neil's Charcoal answer.

```
{MX B*R_MPaZb}MP_WV_MaWVa
                     a     First command-line input (eval'd as list due to -x flag)
                      WVa  Weave with itself (double each row)
                    M      Map to each row:
                _WV_         Weave with itself (double each column)
{            }MP           Map to each pair of rows:
          aZb                Zip the two rows together
        MP                   Map to each pair of [upper lower] pairs (i.e. 2x2 submatrix):
      R_                       Reverse the first pair
    B*                         Multiply itemwise by the second pair
 MX                            Maximum (1 if either product is 1, 0 otherwise)

```
> 2 votes

---
Tags: code-golf, binary-matrix
---