Mutually Exclusive Quines Your challenge is simple. Write two programs that share no characters which output each other.

Example

Two programs P and Q are mutually exclusive quines if:


P outputs Q
Q outputs P
There is no character c which belongs to both P and Q
Each program P and Q are proper quines


This counts empty quines and quines that read their own (or the other's) source code as invalid.



More rules


The shortest combined length of these programs wins. That is, size(P) + size(Q) is your score, and the lowest score wins.
Both programs are in the same language
Each program may be a full program or function, and they need not be the same.


For example, P may be a full program and Q may be a function.



Verification

This Try it online! snippet here can verify whether or not two programs are mutually exclusive. The inputs are put in the first two arguments.
>&lt;>, Score: 41+41 = 82

Edit: both contained a 3. Fixed

'd3*}&gt;a!o-!&lt;&lt;8:5@lI55&gt;@z:5ll55&gt;&gt;q:&gt;|q::|,


and

"r00gr40g44++bb+0p64++?b6+0.22&#23;#e&#23;W4s )Z&#29;


Try it online! (swap the lines to get the other output) With verification this time!

&gt;&lt;&gt; is an especially hard language to use here, as there is only one way to output characters, the command o. Fortunately, we can use the put command to place an o in the source code during execution, like in my Programming in a Pristine World answer.

This one took a lot of trial and error. I started off with the two mutually exclusive programs:

'd3*}&gt;N!o-!&lt;&lt;data


and

"r00gr40g8+X0pN+?Y0.data


Each one transforms itself and its data by N, the first one subtracting and the second adding. It then outputs this in reverse. The point is that the data after each program is the other program in reverse, shifted by N. (X is the cell number where the program needs to put the o and Y is the cell where the pointer loops back to. ? is where the o is put).

Both follow the same structure, represented in different ways. They run a string literal over the entire code, adding it to the stack. They recreate the string literal command they used and put it at the bottom of the stack. They loop over the stack, adding/subtracting N to each character and printing them.

The first program uses ' as the string literal, and the simple d3*} to create the value 39 and push it to the bottom of the stack. The second uses " as the string literal with the same function. It reverses the stack, gets the character at cell 0,0 and reverses the stack again. It then gets the value at cell 4,0 (g) and adds 8 to it to get o and puts that at X.

Both programs use a different method of looping. The first program uses the skip command (!) to run only half the instructions while going left, reverses direction and runs the other half. The second uses the jump command (.) to skip backwards to the start of the loop at cell Y. Both of these run until there are no more items on the stack and the program errors.

I ran into a number of problems with most of the lower values of N, because shifting one character would turn it into another character essential for that program (and therefore couldn't be used as data for the other program) or two characters from the two programs would shift into the same character. For example:


++1 = , = --1
.+2 = 0
* = --3
g+4 = k =  o-4


etc.

Eventually I got to 10 (a), where I was able to avoid these issues. There might be a shorter version where the shifts are reversed, and the first program is adding N while the second subtracts it. This might be worse off though, as the first program is generally on the lower end of the ASCII scale, so subtracting is better to avoid conflicts.