We're aiming to prove ResPlicate TC by simulating a tag system.

In ResPlicate, each command is a pair of numbers followed by some
data: the first number in the pair specifies the length of the data,
the second number specifies how many copies of it to make, with the
copies pushed onto the end of the queue from which the commands are
taken.  Each command runs in turn; the data is part of the command, so
the next command starts at the end of the data.

In a tag system, each command is a single datum that indexes a lookup
table; the contents of the lookup table are pushed onto the end of the
queue from which commands are taken.  Then the next ''n'' commands are
skipped, for some constant ''n'' that depends on the program.

The only real difficulty in simulating a tag system in ResPlicate is
that we don't have an external lookup table to copy information from,
so we have to embed it into the commands somehow.  Because one command
can produce multiple commands' worth of output, we may need to
generate multiple copies of the lookup table in the output.
Fortunately, ResPlicate is entirely capable of copying large chunks of
data.

Thus, we aim to implement each tag command in ResPlicate as a header,
followed by a number of copies of the lookup table (called the
"alphabet").  The number can depend on the command.  This combination
has to push a sequence of headers and alphabets when run, then skip
''n'' commands.  For the skip to work correctly, it's simplest to
ensure that all commands have the same length, so we can simply make 0
copies of that length in order to skip a command.

In order to cause the alphabets to run differently in different
situations, we need to communicate information to them somehow.  The
obvious (and probably only) way to do this in ResPlicate is to start
running from a different point in the alphabet; to accomplish this,
the headers merely need to give a count of 0, and varying lengths.

Then, each starting position in the alphabet needs to be able to do
the following (assuming that the alphabet is in a sufficiently large
block of alphabets, and it's known how many alphabets follows it):
output a header and move to a particular place in the next block;
output a sequence of alphabets and move to a particular place in the
next block; skip to the start of the next-but-''n'' tag command.
Almost all of this is trivial; the only difficult bit is to be able to
move to a particular place in the next block after outputting a
sequence of alphabets, that varies on the starting position in the
current alphabet; if we try to output the alphabets directly, we'll
always end up in the same position, and so lose our ability to control
what happens next.

The solution is to note that because we have knowledge of what command
we're processing in the header, and knowledge of what command we just
processed when skipping to the next-but-''n'' tag command, we can have
arbitrary padding at the start and end of the sequence of alphabets
(so long as it's a consistent length).  Thus, so long as we always
allow one extra copy, we can misalign the alphabets and copy it; we'll
still get the required number of alphabets, with the misaligned
section counting as padding, and crucially, the IP is left in a
different place each time depending on the alignment, meaning that
there's no issue keeping track of what command we're processing.  We
still need to ensure that the start-padding and end-padding has the
same length for each tag command, but we can simply add arbitrary
padding there the same way that we add headers (it's simplest to use
repeated copies of the same number, because that can be represented
compactly in ResPlicate).

One nice feature, not required for the construction but there's no
reason not to use anyway, is that although we can skip forwards to an
arbitrary place in the next alphabet, there's never a reason to;
because each use of an alphabet leaves the IP immediately after its
data (which is a whole number of alphabets for an alphabet inclusion,
or literal data for other sorts of inclusion), we can just literally
write all the alphabet uses in order, with no skips but the large skip
at the end of each use.  This makes the structure of the alphabet
exactly match the structure of the lookup table from the tag system.