Cat, Quine, Hello World Write a cat program, a quine, and a Hello World in the same language such that when two specific programs of the three are concatenated in a certain order, you get the third program. It does not matter which program is the first, second, and third are as long as all three types are represented once each.
e.g. if \$A\$ is a cat and \$B\$ is a quine then \$AB\$ is Hello World. Alternatively, if \$A\$ is Hello World and \$B\$ is a cat then \$AB\$ is a quine. You only need to make one permutation of the possible 6 work.
For completeness of explanation:

A cat program outputs the input exactly
A quine is a program that outputs its own source code
A hello world program outputs the string &quot;Hello World!&quot;

Rules, Scoring, Formatting

Shortest code wins. Scoring goes by the length of the concatenated program, i.e. the longest of the three.
Standard rules and loopholes apply.
The hello world program and quine might possibly receive input. You must output the appropriate text regardless of what is given as input.
Programs may output a trailing newline.
You can treat all three programs as if they are surrounded by your language's function closure (please specify the name of your implicit argument in this case) or main function boilerplate if that is required for your solution to work. Use the same convention for all three programs. The quine should not contain the boilerplate in this case.

Format the header of your answer like this:

&lt;first type&gt; + &lt;second type&gt; = &lt;third type&gt;, &lt;language&gt;, &lt;score&gt;

or

&lt;language&gt;, &lt;first type&gt; + &lt;second type&gt; = &lt;third type&gt;, &lt;score&gt;
Python 3, Hello World + Quine = Cat, 129 bytes

Hello World:
import os,atexit as a
p=print
a.register(p,&quot;Hello World!&quot;)
def print(_):
 p(input())
 os._exit(0)

Quine:
s='s=%r;print(s%%s)';print(s%s)

Cat:
import os,atexit as a
p=print
a.register(p,&quot;Hello World!&quot;)
def print(_):
 p(input())
 os._exit(0)
s='s=%r;print(s%%s)';print(s%s)

atexit lets you define cleanup steps that will run when your program exits &quot;normally&quot;. In this case, I register the print function (renamed p) with the argument &quot;Hello World!&quot;, so it will print that string when the program ends.
I then redefine print to become a cat function. Normally, this would cause the program to print its input and &quot;Hello World!&quot;, but os._exit() is an &quot;abnormal&quot; exit that bypasses the cleanup steps.
Now that print has been redefined, the Quine simply calls this cat function and the program abruptly exits. If the Quine doesn't exist, then the program exits normally, printing &quot;Hello World!&quot; in the process.
The final program doesn't work on TIO, but it works for me running Python 3.7.3 on MacOS.