Make an interweaving quine Your task is to create a program that, when run, returns itself as output (this is known as a quine). However, this quine must, when it is copied n times, returns the quine, but with each of its characters duplicated in place n times, where n is a positive integer.

If your original program is Derp:

Derp -&gt; Derp (must return itself as output to be a quine)

DerpDerp -&gt; DDeerrpp
(the "Derp" is copied twice, so each character in the output has to be copied twice)

DerpDerpDerp -&gt; DDDeeerrrppp
etc. etc.


Keep in mind you're allowed to have whitespace in your "base" program, but they are counted when "interweaving". Say your program is

Derp 
{newline}


(The newline signifies a trailing newline, and there's an extra space after the Derp). When duplicated to become

Derp 
Derp 
{newline}


You must output

DDeerrpp  
{newline}
{newline}


Keep in mind that there's 2 extra spaces after the DDeerrpp.

Rules and Specs:


Your program must contain at least two distinct characters (which implies that your code must be at least 2 bytes long).
Standard quine rules apply.


This is code-golf, so shortest code in bytes wins!
Fission, 6 bytes

'!+OR"


Try it online! Try two copies! Try three!

Explanation

This is just the Fission standard quine. It happens to work for this challenge, because Fission has explicit entry points into the program. In particular, by duplicating the program, we add another R which adds another atom (instruction pointer). Since the source code is toroidal, the effective code being executed doesn't change otherwise — to each atom, the code still looks the same locally. However, the atoms are executed in lock step, so that the things they print are interleaved and we get an additional copy of each character in the output.

For completeness' sake I'll just shortly reiterate how the program itself works. Regardless of whether we repeat the program or not (e.g. '!+OR"'!+OR"'!+OR"), each atom sees the following code:

R"'!+OR"'!+O


The " toggles string printing mode, so that the program starts by printing '!+OR directly to STDOUT, which is all of the quine except the quote. Then '! sets the atom's mass to the character code of !, + increments it, which gives ", and O prints it while simultaneously destroying the atom. The program then terminates, because there are no atoms left.