[Question]
  [
## The task
In this challenge, your task is to write three programs that form a kind of mutual quine-like system.
Let's call the programs `A`, `B` and `C`.
If one of the programs is given the source of another program as input, it shall output the source of the third program.
For example, if `A` is given `B` as input, it outputs `C`.
If the programs are given their own source as input, they shall output the three strings `"three"`, `"mutual"`, and `"quines"` (without quotes).
In all cases, they may output one additional trailing newline.
For any other inputs, the programs may do anything, including crash.
## Example
For example, suppose that the source codes of `A`, `B` and `C` are `aSdf`, `ghJk` and `zxcV`.
Then the programs should behave as follows.
```
Source Input  Output
--------------------
aSdf   aSdf   three
aSdf   ghJk   zxcV
aSdf   zxcV   ghJk
ghJk   aSdf   zxcV
ghJk   ghJk   mutual
ghJk   zxcV   aSdf
zxcV   aSdf   ghJk
zxcV   ghJk   aSdf
zxcV   zxcV   quines
```
## Rules and scoring
The solutions `A`, `B` and `C` can be either functions or full programs, but they must be completely independent: **no** shared code is allowed.
[Standard loopholes](http://meta.codegolf.stackexchange.com/questions/1061/loopholes-that-are-forbidden-by-default) and [quine rules](http://meta.codegolf.stackexchange.com/questions/4877/what-counts-as-a-proper-quine) apply, so the programs can't access their own source codes in any way.
Your score is the combined byte count of `A`, `B` and `C`, lower score being better.
  
[Answer]
# CJam, ~~165~~ ~~147~~ ~~114~~ ~~108~~ 99 bytes
```
2 _ri^_q+@"quinesmutualthree"6/=?
```
```
1 _ri^_q+@"quinesmutualthree"6/=?
```
```
3 _ri^_q+@"quinesmutualthree"6/=?
```
*Thanks to @MartinBüttner for a suggestion that helped save 48 bytes!*
Try it online in the [CJam interpreter](http://cjam.aditsu.net/#code=2%20_ri%5E_q%2B%40%22quinesmutualthree%226%2F%3D%3F&input=2%20_ri%5E_q%2B%40%22quinesmutualthree%226%2F%3D%3F).
### Verification
```
$ cat A
2 _ri^_q+@"quinesmutualthree"6/=?
$ cat B
1 _ri^_q+@"quinesmutualthree"6/=?
$ cat C
3 _ri^_q+@"quinesmutualthree"6/=?
$ 
$ cjam A < A
three
$ cjam A < B
3 _ri^_q+@"quinesmutualthree"6/=?
$ cjam A < C
1 _ri^_q+@"quinesmutualthree"6/=?
$ 
$ cjam B < A
3 _ri^_q+@"quinesmutualthree"6/=?
$ cjam B < B
mutual
$ cjam B < C
2 _ri^_q+@"quinesmutualthree"6/=?
$ 
$ cjam C < A
1 _ri^_q+@"quinesmutualthree"6/=?
$ cjam C < B
2 _ri^_q+@"quinesmutualthree"6/=?
$ cjam C < C
quines
```
### Idea
The set **{0, 1, 2, 3}** is a group under the operation **^** (binary exclusive OR), where each element is its own inverse.
If all three programs are identical except for the the first character (an element of **{0, 1, 2, 3}**), we can distinguish and print them easily:
* We start by XORing the digit at the beginning of the source code and the input.
* If the result is in **0**, source and input match.
Thus, we print one of the three words, selected by this common digit.
* If the result is not **0**, it is the element of **{1, 2, 3}** that is neither in the source nor in the input.
Thus, we prints it, followed by the rest of the input.
### How it works
```
2                                  e# Push the number N on the stack.
  _                                e# Push a copy.
    r                              e# Read a token from STDIN, i.e., the input up
                                   e# to and excluding the next whitespace char.
     i                             e# Cast to integer.
      ^                            e# XOR it with the copy of N. Result: X
       _                           e# Push a copy of the result.
        q+                         e# Append the rest of the input.
          @                        e# Rotate N on top of the stack.
           "quinesmutualthree"6/   e# Push ["quines" "mutual" "three"].
                                =  e# Select the word at index N.
                                 ? e# If X is non-zero, select the modified input;
                                   e# otherwise, select the word.
```
]