Print Polyglot Pieces Typically, polyglots are constructed in such a manner that each language can ignore parts of the code that are present for other languages, by wrapping them in string literals, using comment syntax, or other similar tricks.

Your goal is to write a polyglot where the output for each language is the code from the polyglot that produces that output. Specifically, the output must be constructed from the polyglot code with only deletions, and it must be a quine in the given language.

Rules


Only proper quines are allowed (no reading the source code, no taking input, output must be to STDOUT or closest alternative if STDOUT is not an option, and the programs must consist of more than just literals that are implicitly printed).
Since different languages can use different encodings, the raw bytes are what matters here. For example, if language A uses UTF-8 and language B uses CP437, the (hex) code C3 88 46 47 would be ÈFG for language A and ├êFG for language B.
All outputs must be distinct (again, comparing raw bytes). This avoids complications with trying to restrict minor language versions - if two languages use the same part of the code to do the same thing, you can't claim them both.


If you have two languages A and B such that XY is a valid output in both, but YZ is also valid in B, you may choose XY as the output for A and YZ as the output for B, so you can claim both of them in your score (but you can't claim XY for both languages because of the above rule).

All outputs must be as short as possible. For example, if your code was print('foo')#something, for Python 3 (ignoring the fact that the output is not correct), the code you would need to output would be print('foo'), and print('foo')# would not be allowed. If there are multiple strings of equal (minimal) length that produce correct output, you may choose any one of them.
Submissions must be polyglots in at least 2 languages.
Your score will be given by (number of programming languages with distinct outputs)**3/(total byte size of polyglot). The highest score wins. In the event that two submissions achieve the same score, the submission that reached that score first will win.
GolfScript + CJam + Fission 2 + Jelly, 4 languages, 24 bytes, score 2.667
Let's start with the hex dump:
00000000:  3322 3024 700a 2721 2b4f 5222 0a3c 3024 700a 6523 7fff cccc

For GolfScript, CJam and Fission 2, we interpret this in some ASCII-compatible single-byte encoding like ISO 8859-1 (the exact encoding doesn't really matter, because the languages only define operators for ASCII characters anyway):
3&quot;0$p
'!+OR&quot;
&lt;0$p
e#&lt;DEL&gt;ÿÌÌ

Where &lt;DEL&gt; is the control character 0x7f.
In Jelly, this is assumed to be in Jelly's own code page, where it looks like this instead:
3&quot;0$p½'!+OR&quot;½&lt;0$p½e#¶”ṘṘ

GolfScript
The e on the last line is an unknown variable and # comments out the remainder of the line, so this prints
&quot;0$p&quot;
0$p

with a trailing linefeed. This is the GolfScript/CJam polyglot version of the standard quine:
&quot;.p&quot;
.p

Try the polyglot. | Try the quine.
CJam
Here, e# comments out the last line, so almost identically, this prints
&quot;0$p&quot;
0$p

without a trailing linefeed.
Try the polyglot | Try the quine.
Fission
Fission only sees the second line which is the standard Fission quine, so it prints
'!+OR&quot;

I can't provide an online link for the polyglot here, because TIO sends the file to Fission as UTF-8, but Fission reads the source byte by byte, which makes the last line too long. However, I've tested this locally with an ISO 8859-1 encoded file (in which the last line has the same length as the second), to confirm that this works.
Try the quine.
Jelly
The pilcrow is an alias for linefeeds in Jelly, so the source is equivalent to:
3&quot;0$p½'!+OR&quot;½&lt;0$p½e#
”ṘṘ

All but the last line of a Jelly program are &quot;helper links&quot; (i.e. functions) which can be ignored unless they are called, provided they are syntactically valid. This is actually the reason the 3 comes first in the CJam and GolfScript programs, because otherwise the &quot; can't be parsed in Jelly.
Otherwise, since the function isn't called, the program is equivalent to only its second line, which is the standard Jelly quine.
Try the polyglot. | Try the quine.