text:
How many ways can given subsequence occur in given sequence?
Let me know if this task has already been posed. I haven't found it when I looked.

Input

master sequence \$\ X = x_1\dots x_n\$: sequence of characters, eg. \$\rm international\$
subsequence \$\ Y = y_1\dots y_m\$: sequence of characters, eg. \$\rm intl\$

Output
Number of possible mappings \$\mu: [1\dots m] \rightarrow [1\dots n]\$ of positions in subsequence to positions in the master sequence, such that for all \$j\in[1\ldots m]\$:

\$y_j = x_{\mu(j)}\$, viz. an occurrence of a character in the subsequence maps to an occurrence of the same character in the master sequence

\$\forall\ i \lt j:\ \mu(i) \lt \mu(j)\$, viz. the mapping preserves mutual position of character occurrences.

In the example above, there are 3 possible mappings:

\$\rm\underline{int}ernationa\underline{l}\$
\$\rm\underline{in}terna\underline{t}iona\underline{l}\$
\$\rm\underline{i}nter\underline{n}a\underline{t}iona\underline{l}\$

Rules
Lowest average asymptotic time complexity with respect to \$n+m\$ wins.
If it helps you, you can assume the input is a sequence of bytes (values 0-255).

Test cases
master sequence, subsequence -> number of possible mappings
international, intl -> 3
aaabbb, ab -> 9
aaabbb, aabb -> 9
only one, onl -> 1
none, en -> 0

@Don Thousand please stop rewriting x to X.

Note that in your own question, $X$ refers to the master sequence.

Could a better measure be O(m + alphabetSize)?

Some test cases: "aaabbb", "ab" and "aaabbb", "aabb" should both return 9, maybe add some for 0 and 1 mappings.

@DonThousand note that in my question I state $X = x_1\dots x_n$.

@JonathanAllan I don't know. If you think it's better then maybe it is; I haven't really thought about it thoroughly.

Done, remove the last one if you think it's unnecessary.

Ruby, \$\mathcal{O}(nm)\$
I think I got the analysis for this right. Should be \$\mathcal{O}(nm)\$ because for each of the \$n\$ characters in the master sequence, it goes through at most \$m\$ steps to check each character of the subsequence (if they are all the same character). It's also optimized to try to be \$\Omega(n+m)\$ best case complexity, which occurs if all the characters in the subsequence are unique.
def submap master, sub
  subIndex = Hash.new{ |hash, key| hash[key] = [] }

  sub.chars.map.with_index do |c, i|
    subIndex[c] << i
  end

  subCount = [0] * sub.length

  master.chars do |c|
    indices = subIndex[c]
    indices.reverse_each do |i|
      subCount[i] += i > 0 ? subCount[i-1] : 1
    end
  end
  return subCount[-1]
end

Try it online!
Explanation
Define the function \$f(X_i,Y_j)\$ as the number of occurrences of the subsequence \$Y_j=y_1...y_j\$ in the sequence \$X_i=x_1...x_i\$. In this situation, it can be shown that
$$f(X_i,Y_j)=\begin{cases}
f(X_{i-1},Y_j) & \text{if } x_i\ne y_j,i > 1\\
0 & \text{if } x_i\ne y_j, i=1\\
f(X_{i-1},Y_j)+f(X_{i-1},Y_{j-1}) & \text{if } x_i=y_j,j > 1\\
\sum_{k=1}^i [x_k = y_j] & \text{if }j=1
\end{cases}$$
That is, if the subsequence is 1 character long, count how many there are in the master sequence. If \$x_i=y_j\$, add the number of times the subsequence \$Y_{j-1}\$ occurred previously in \$X_{i-1}\$, as that is the number of times you can find this subsequence using this specific position \$x_i\$. Otherwise, ignore the character and only look at the sequence before \$x_i\$, that is, \$X_{i-1}\$.
With that, we write our code.
def submap master, sub
  # Minor optimization: Map the characters to indices. This way, we don't have
  # to go through the subsequence every time, which gives the best case scenario
  # a complexity of O(n+m) if all characters in Y are unique.
  subIndex = Hash.new{ |hash, key| hash[key] = [] }
                                        # Initialize hash with default value []
  sub.chars.map.with_index do |c, i|    # For each character in Y
    subIndex[c] << i                    # Add the index to the hash for that char.
  end

  subCount = [0] * sub.length           # Initialize the previous results f(X, Y_j).

  master.chars do |c|                   # For each character in X
    indices = subIndex[c]               # Look up the indices for that character
    indices.reverse_each do |i|         # For each index (in reverse order)
      subCount[i] += i > 0 ? subCount[i-1] : 1
                                        # Increment f(X, Y_j) by f(X, Y_{j-1}).
    end
  end
  return subCount[-1]                   # Return f(X, Y_m).
end

I'd suggest subIndex[c].reverse_each {|index| ...}.

@kyrill Made the change. Obviously this doesn't affect complexity but it is nice for readability :)

Python 3, \$O(n^m)\$
def submappings(master, sub):
  if len(sub) == 0:
    return 1
  count = 0
  for i, c in enumerate(master[:len(master)-len(sub)+1]):
    if c == sub[0]:
      count += submappings(master[i+1:], sub[1:])
  return count

Try it online!
For each character in the subsequence, it looks through (what's left of) the master sequence for it, and moves onto the next one, counting how many combinations there are.
I've made a version that also counts the number of comparisons.
def submappings(master, sub):
  if len(sub) == 0:
    return 1, 0
  count, ops = 0, 0
  for i, c in enumerate(master[:len(master)-len(sub)+1]):
    ops += 1
    if c == sub[0]:
      rec = submappings(master[i+1:], sub[1:])
      count += rec[0]
      ops += rec[1]
  return count, ops

Try it online!

As a small optimization, you can only enumerate master[:-len(sub)+1]. As a slightly more advanced optimization, you can go up to the last occurence of sub[0] in master (cf. str.rfind). Even that is not optimal, but it's a pretty cheap and efficient heuristic in most cases I'd say.

I don't think using str.rfind will improve it on average, it will just look from behind instead of from the front, still searching the whole string. Good idea to only enumerate while the substring fits, though. I don't think it will change the asymptotic complexity though.

No, it's just a heuristic so the asymptotic complexity remains unchanged. With str.rfind I had in mind the efficient implementation of search for a character in string. I would guess it's implemented in C using strchr or something similar, which uses SIMD instructions, so it would be much faster than doing the same thing in Python. Probably wouldn't make a huge difference though.

@OP What's the best time-complexity you've found? It may be possible that this is close to the best possible.

Your algorithm is the only one I've thought about, with the mentioned heuristics. Essentially $\Pi_{x=n-m}^{n} x$, so $O(n^m)$.

It should be possible to improve on this. It often compares the same letters more than once.

Sure, one thing I thought about is creating for each character of substring a list of its admissible positions in the master string. Then create some sort of index which for each admissible position $i$ of a substring character in the master string points into the list of admissible positions of the next character, such that the position it points to is the nearest one after $i$. Although I'm not sure how expensive would it be to build such an index.

It seems like it would be something like $O(nm^2)$

I'm convinced it can be done in $O(mn)$ with some memoization / bottom-up approach (basically starting from the end). This is pretty much a textbook dynamic programming problem.


text:
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.

Would [tag:code-bowling] be an appropriate tag?

Do all of the characters removed have to be contiguous?

@JoKing what is your reasoning for removing the whitespace rule? Also yes, the word set was perhaps a poor choice.

I feel like Lenguage could do well here

@pppery no, as long as long as a program can be constructed that outputs Hello, World by deleting characters, it's not irreducible. I'm going to edit the main post.

@JoKing well considering these programs are potentially going to be quite large, I thought it good for people to be able to format it without care of causing it to break the irreducibility rule. But I may be able to be convinced otherwise.

@JoKing it "not counting" just means that if the only thing that can be removed without your program breaking is whitespace, then it counts as irreducible. If someone can abuse that rule then honestly I'd be interested in seeing how.

Why Unary is banned? This question would be [tag:code-golf] in Unary like languages. And it is almost impossible to post an answer in such languages: Since it is hard to prove the answer fit the requirement.

@tsh interesting point about it actually being code golf, I didn't think of that. Still the shortest unary hello world I've seen is unimaginably large, so it'd just be the clear winner with no competition.

Related challenge

I feel like the post should at least ask for a detailed explanation of why the code can have no sub-sequence which would output the string.

I'm impressed. A [tag:code-bowling] that actually works and doesn't need to impose restrictions like "number of different ascii bytes" (that inherently have a maximum score).

I don't think it makes a difference, but, for precisely that reason, I removed the whitespace rule.

And now this is the first [tag:code-bowling] where the winning score involves double-arrow notation.

Related. This one doesn't enforce irreducible code, but instead lets people golf others' answer and has two scoreboards for bowlers and golfers. (It's 5 years old so has some weird I/O requirements, but other than that it was a cool concept on its own.)

If the program is written in Whitespace, then removing said whitespace will break the program.

What about a program that contains all π decimals in which we search for the Cobol program that displays the string (since π is supposed to contain all possible bytes sequences). Would that be considered reducible (since π could be calculated)? If no, nothing beats ∞ :-)

@RingØ if I understand you correctly, you could snip off all the digits of pi you didn't need, and just leave the program behind, so it would be reducible.

@Bubbler Not just double arrow notation, but arrows on numbers that are already pretty large (the python answer uses a 31 digit number and arrows).

A bit late but maybe it's worth a comment - it can actually be proven that for a fixed language, this question has bounded score - if not, that means we can indefinitely make larger and larger strings (programs) none of which is a subsequence of another, and that contradicts Higman's lemma. You can find a nice proof in my Math SE question (and answer).

Now switch it to code golf and watch all the contestants scramble to update their answers :p

@acupoftea That's amazing! I wonder if it would be possible to find such programs.

Is there any need to consider substitutions when considering whether a code is reduceable or not? For example if a code uses an arithmic operation to generate an ascii character, do we need to ensure the equation cant be replaced with a simpler equation, or just ensure that components of the equation cant be removed without affecting output?

@T3RROR if you mean something like you can't use 1+1 because 2 is shorter, then no, you do not need to worry about that.

It'd be interesting if the program had to finish executing in an hour for a reasonable input since all the answers can't even fit on all the computers on the planet's storage. Maybe, I'm a little philosophical, but none of these programs exist. Plus, people make coding errors all the time. There's no way to verify they give the correct answer.

@user974006 You can at least verify Bgil Midol's Python answer or my Jelly 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}\$ 0s. 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

Congratulations, you're the first one to beat Unary (which, based on the best golfed Brainfxxk answer, would score around 1e65).

Could you perhaps make this bigger by forming the numbers you are using in some creative ways?

The length is 5.332885e+165. APL beats you.

@EmbodimentofIgnorance: As written in the explanatory text of this answer, "that number at the start" is shorthand for a lot of zeros followed by a !.  My comment drastically reduces the number of zeros and also removes some of the following characters.  The string consisting of N zeros is a substring of the string consisting of M zeros if N is less than M.  As I wrote, my comment's N is over 100 orders of magnitude smaller than this answer's M.

An explanation of how this is irreducible would be appreciated

When I tested it, it produced the score mentioned and the program.

:_ Is needed to terminate the integer scan

That's a weird feature in a golfing language

What programming language is the generator even written in? And why can this not be reduced?

@FabianRöling I believe the generator was written in Python 3

@JoKing I've added an explanation

@FabianRöling explanation added.

The muliply by the character is needed to convert the chunks back to their original number

Let us continue this discussion in chat.

Where's the explanation? Also how did you come up with the exact correct number?

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 code-golf 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.

This is the first answer I've seen on here with a score measured with up-arrow notation.

@Skyler We once had this challenge to generate big numbers in limited code size.

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!

+1 for simply using Malbolge in an actual programming competition.

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.

What about -9 -> ~9? Or mabye -0xf?

@tsh Huh, good ideas. Couldn't it be made pretty much arbitrary with -ord('.')? Up to the max size of strings

Good idea... So, using ~ord('') instead would made this program 111411x large?

int(''.join(reversed("123-"))) may be simplified to int(''.join(reversed("1-"))).

This looks easy to considerably reduce, unless I missed something.

The first link seems to generate just decimal digits, not a useful Python program. That output is your n?

@Grimy Oops, how about functools.reduce(int.__mul__,b)?

@aschepler As I said at the top, it prints the actual code for smaller programs, for example if you replace the input with ~9

@JoKing: Here's a fun reduction.

@A.Rex Should be fixed now. it shouldn't be possible to rename those variables with also removing the getstate call.

Still easy to reduce: int.__pow__ can be pow.

@Grimmy Ah, I didn't realise pow was it's own function unlike int.__mul__

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\$ 1s.
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).

@Bubbler yeah, that edit was stupid, I should've thought about it more (both times). Thanks for pointing the flaw out. Do you think this approach is salvageable? Should I delete the post and make a new one when I come up with the save or is it ok to keep it wrong and edit?

The rule of thumb here is to delete the answer, (hopefully) edit the post with your corrected answer, and then undelete it.

Well, this does make things harder to crack. I did find by random experimentation that decode('utf-8') can be reduced to just decode(), though, for what that's worth. Try it online!

Code point may go up to 65535. So, in theory, v you can have up to 65535 byte program, although at that point we might have greater chance that there are some program that works. I think using functions such as Loader's Derive function(one of the fastest growing computable "function") could work, although to make sure we might need to check somewhere around 142444900 programs (assuming 950 byte Loader's Derive+inverse function+other stuff), although >70% would be eliminated immediately because of invalid characters very early, let alone defining and keeping the inverse function.

I will go ahead and make one.

@Naruyoko I think that it's still statistically obvious that none of the reduced programs will even decode to utf-8 (that's what exec uses). But we can free ourselves from thinking about it by adding tab as the first character of code (I'll edit that in). Anyway, I don't know the etiquette here but I'd feel kind of weird if you just used my template to make an answer with Loader's Derive - given that code for it is already available this doesn't feel like a big enough contribution. "Golf the highest number in under 65535 bytes" isn't a good contest when you see other people's answers (imho).

I am not thinking about using template, just saying. It is possible.

Your template allows extension such as (D^5735816763073854918203775149089(5735816763073854918203775149089)+1862) bytes by having ord("˶") as the execed string length and Q set to D^5735816763073854918203775149089(5735816763073854918203775149089) 1s and the encoded string the following:

11311426421362617380125799467978163712983077848426057017191828211470651780733349876670698413966239941436838707844109862830385924901261117085029071218299364673575412006512519034601265310928364596480879882223322792572355060475857997011047766693249314587162884331184274249038940454676605433717249471883945595800587563665908403640049046154615807391972286161420960038383990903294062480911394693498117255598819985420753962028631666773207272707938768272312831271789007357933511277195243040687127475347823920387361100284771345913202440983842002283454911401975510

618887994890376168725461955371416686690589219945134341444915074040054797723395896744346248318572919963134518810410495907201553772244085330049311414301814990241779972919104901520047841524149473741055263408140283035715392161889157949020772198345011060580435278249400218914501847816207661994090363720505140390439089770117459713966674689798786435845272625001585434559768645115626996771645595868302961535714536681618293134093760128545780061932298065674888370411486512274255947465832302478219650877961624706651760274012911571218958547483817798797958935645837372988110310956992263886822513947162653845623

047176560618434906051672758590672555157029061874117392122401166263568868909674404656899148017849944176058061644745627821551575842451612608038966911863613390686979193686098924696712127806738799197754337392696843771208524738028753165070946054811585171305781231179885343629309731495889006619479188144969668944261859858355563527788496672442239393139255743440607407148168775683844510037241162052533425645881777892002947456717654723389507770827737916847275149109026596891288774215661564429349878918039442792019081404408255635189717628232194096794397810

40086825979353952976038274736687686061983943936142004912343791676795478925975393744045802091935449340672827363019521506215995689

Note that you can probably encode the massive number in binary representation by having 0b followed by the same number but in base 2.

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.

How about removing n, and instead decrementing a until it reaches 0, and then back up again to a-1 and down etc... The string would basically look like "eo l![...]drW,lH".

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.

Obligatory "replace a with some multi-byte unicode character" -- 10138 bytes

On second thought this can probably be reduced by changing the puts section of the eval to $><<, since each of those characters has a lower byte code.

I'm getting a compile error. What version did you test this on? bignum too big to convert into long (RangeError)

It might have worked when I first posted it, December 2019, but I'm not even sure.

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.

alert("Hello, World!") is shorter, and has less of each type of character: (format is # of [], # of (), # of +, # of !): (6696, 1248, 5770, 3197) and (6317, 1180, 5438, 3015) respectively for console.log and for alert

I believe convert (function d(){return function l() {return function r(){return function o() {return function W(){return function e() {return function H(){console.log(H.name+e.name+l.name+l.name+o.name+', '+W.name+o.name+r.name+l.name+d.name+'!')}}}}}}}()()()()()()()) to JSFuck would be longer. But I cannot prove it fit the requirement.

@EmbodimentofIgnorance would alert typically be counted as an output? It doesn't work on TIO.

I've seen other answers use alert before, so I believe it is a valid output format

Excellent find! I am using this generator for all of my production code.

@tsh I believe that code are reduced to (function l(){return function o(){return function e(){return function H(){console.log(H.name+e.name+l.name+l.name+o.name+', World!')}}}}}}})()()()()

Not sure why this was given 500 reputation XD, but thanks!

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 -1s. 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:

Divisible by 4
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).
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.
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.

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.

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.

The trailing semi-colon can be removed. Apart from that I can't think of anything to remove, so +1 from me. :)

You have JSFuck as input to your code in the TIO link

For the top one, simply deleting entire if(...) does work, so it's invalid.

Easily reducible.

Can't you reduce System.Numerics.BigInteger to int?

There are so many ways to reduce the second. (I thought of using System.Numerics.BigInteger.Abs.) I don't think it's a good approach to this challenge.

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

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.

Mathematica, 1010128433 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 10128433 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 x2, 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).

Can this be reduced by removing the 0 from 10 and decreasing the number of a?

@emanresuA It cannot - Hyperfactorial[0] is 1, and Hyperfactorial[1] is 1. This means the by removing the 0 from 10, the base 'collapses' to 1. If the decoding base is less than 114, it cannot decode the "W" for "World". So removing the 0, with any number big or small of a's, would never output Hello, World!

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.

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.

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

Yours is missing a comma in the output, and is not irreducible because I can remove _1 and a bunch of chars in the literal at once to get the same string. This should work instead. (This is how to get the literal correctly)

I think ³!¤ (100!) works as an irreducible base.

Hmm earlier I tried without the _1 and it have gibberish... I got the number by doing “Hello World!’

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

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!

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/

sort: votes