[Question]
  [
Your task is to give three different languages A, B, C, and write two different programs P and Q such that: 
P is a quine in language A, but not a quine in B nor C; 
Q is a quine in language B, but not a quine in A nor C; and 
Q concatenated after P (without any new characters added in between) is a quine in language C, but not in B nor A. 
This is codegolf, where your score is the length of the final, concatenated quine. Again, adhere to the rules of [proper quines](http://meta.codegolf.stackexchange.com/questions/4877/what-counts-as-a-proper-quine) -- no reading your source code, no empty programs etc.
  
[Answer]
# Fission + CJam + GolfScript, ~~38~~ 36 bytes
### [Fission](http://esolangs.org/wiki/Fission), 6 bytes
```
'!+OR"
```
This is one of [Martin Büttner's Fission quines](https://codegolf.stackexchange.com/a/50968). [Try it online!](http://fission.tryitonline.net/#code=JyErT1Ii&input=)
### CJam, 30 bytes
```
' {"''"@*" "+YX#<
\"0$~"N}0$~
```
The last byte is a linefeed. [Try it online!](http://cjam.tryitonline.net/#code=JyB7IicnIkAqIiAiK1lYIzwKXCIwJH4iTn0wJH4K&input=)
### GolfScript, 36 bytes
```
'!+OR"' {"''"@*" "+YX#<
\"0$~"N}0$~
```
The last byte is a linefeed. [Try it online!](http://golfscript.tryitonline.net/#code=JyErT1IiJyB7IicnIkAqIiAiK1lYIzwKXCIwJH4iTn0wJH4K&input=)
## Verification
```
$ wc -c P Q
 6 P
30 Q
36 total
$ cat P Q > P+Q
$ 
$ Fission P 2>&- | diff -qs - P
Files - and P are identical
$ cjam P 2>&- | diff -qs - P
Files - and P differ
$ golfscript P 2>&- | diff -qs - P
Files - and P differ
$ 
$ cjam Q 2>&- | diff -qs - Q
Files - and Q are identical
$ golfscript Q 2>&- | diff -qs - Q
Files - and Q differ
$ Fission Q 2>&- | diff -qs - Q
Files - and Q differ
$ 
$ golfscript P+Q 2>&- | diff -qs - P+Q
Files - and P+Q are identical
$ Fission P+Q 2>&- | diff -qs - P+Q
Files - and P+Q differ
$ cjam P+Q 2>&- | diff -qs - P+Q
Files - and P+Q differ
```
## How it works
### Fission
* `R` spawns an atom that moves right, wrapping around at the edge.
* `"` toggles printing mode. Everything up to the next `"` is printed.
* `'!` sets the atom's to the code point of '!'.
* `+` increments the atom's mass, setting it to the code point of `"`.
* `O` prints the character whose code point is the atom's mass and destroys the atom.
### CJam
```
'       e# Push a space character.
{       e# Push the following code block:
  "''"  e# Push that string.
  @*    e# Separate its characters by spaces.
  " "+  e# Append one more space.
  YX#   e# Raise 2 to the first power. Pushes 2.
  <     e# Discard all but the first two characters of the string, i.e., "' ".
  \     e# Swap the string "' " with the code block in execution.
  "0$~" e# Push that string.
  N     e# Push a linefeed.
}       e#
0$~     e# Push a copy of the code block and execute it.
```
### GolfScript
```
'!+OR"' # Push that string.
{       # Push the following code block:
  "''"  # Push that string.
  @*    # Join its characters, separating them by the first string.
  " "+  # Append a space.
  YX    # Undefined token. Does nothing.
  #<    # Comment.
  \     # Swap the string with the code block in execution.
  "0$~" # Push that string.
  N     # Undefined token. Does nothing.
}       #
0$~     # Push a copy of the code block and execute it.
```
[Answer]
# Self-modifying Brainfuck + GolfScript + CJam, ~~29~~ 27 bytes
### [Self-modifying Brainfuck](https://soulsphere.org/hacks/smbf/), 12 bytes
```
 {<[<]>[.>]}
```
Note the leading space. [Try it online!](http://smbf.tryitonline.net/#code=IHs8WzxdPlsuPl19&input=)
### GolfScript, 15 bytes
```
{So"0$~"N]}0$~
```
The last byte is a linefeed. [Try it online!](http://golfscript.tryitonline.net/#code=e1NvIjAkfiJOXX0wJH4K&input=).
### CJam, 27 bytes
```
 {<[<]>[.>]}{So"0$~"N]}0$~
```
Note the leading space. The last byte is a linefeed. [Try it online!](http://cjam.tryitonline.net/#code=IHs8WzxdPlsuPl19e1NvIjAkfiJOXX0wJH4K&input=)
## Verification
```
$ wc -c P Q
12 P
15 Q
27 total
$ cat P Q > P+Q
$ 
$ timeout 10 smbf P | diff -sq - P
Files - and P are identical
$ golfscript P | diff -sq - P
Files - and P differ
$ cjam P | diff -sq - P
Files - and P differ
$ 
$ golfscript Q | diff -sq - Q
Files - and Q are identical
$ cjam Q | diff -sq - Q
Files - and Q differ
$ timeout 10 smbf Q | diff -sq - Q
Terminated
$ 
$ cjam P+Q | diff -sq - P+Q
Files - and P+Q are identical
$ golfscript P+Q | diff -sq - P+Q
Files - and P+Q differ
$ timeout 10 smbf P+Q | diff -sq - P+Q
Terminated
```
## How it works
### Self-modifying Brainfuck
SMBF starts with its source code on the left of the data pointer.
```
<space>        (ignored)
{              (ignored)
<              Move the data pointer left.
[<]            Move the data pointer left to the next null byte.
>              Move the data pointer right.
[.>]           Print and move the data pointer right until null byte.
}              (ignored)
```
### GolfScript
```
{            # Push the following code block:
  So         # Undefined token. Does nothing.
  "0$~"      # Push that string.
  N          # Undefined token. Does nothing.
  ]          # Wrap the stack in a array. Does not affect output.
}            #
0$~          # Push a copy of the code block and execute it.
### CJam
{<[<]>[.>]} e# Push that code block.
{           e# Push the following code block:
  So        e# Print a space. Since it is printed explicitly,
            e# it will appear at the beginning of the output.
  "0$~"     e# Push that string.
  N         e# Push a linefeed.
  ]         e# Wrap the stack in a array. Does not affect output.
            e# This makes the program an infinite, empty  loop
            e# in SMBF; it would be a quine otherwise.
}           e#
0$~         e# Push a copy of the code block and execute it.
```
[Answer]
# Tcl, CJam, GolfScript, 60 + 26 = 86 112 bytes
Not golfed well.
### [Tcl](https://en.m.wikipedia.org/wiki/Tcl "Tcl"), 60 bytes
```
{puts} [{join} {{} \{ \}\]} {{puts} [{join} {{} \{ \}\]} }]
```
Based on the quine on [this page](http://wiki.tcl.tk/730). It has a trailing newline.
### CJam, 26 bytes
```
{"' '@`+n@0"L~;"0$~"N}0$~
```
It has a trailing newline.
### GolfScript, 86 bytes
```
{puts} [{join} {{} \{ \}\]} {{puts} [{join} {{} \{ \}\]} }]
{"' '@`+n@0"L~;"0$~"N}0$~
```
[Answer]
# ShapeScript + CJam + GolfScript, ~~96~~ ~~95~~ 62 bytes
### [ShapeScript](https://github.com/DennisMitchell/ShapeScript), 16 bytes
```
'"%r"@%"0?!"'0?!
```
This is the [standard ShapeScript quine](https://codegolf.stackexchange.com/a/63275). [Try it online!](http://shapescript.tryitonline.net/#code=JyIlciJAJSIwPyEiJzA_IQ==&input=)
### CJam, 46 bytes
```
];{"'\"%r\"@%\"0?!\"'0?!];"SS#~(>
\"0$~"N}0$~
```
The last byte is a linefeed. [Try it online!](http://cjam.tryitonline.net/#code=XTt7IidcIiVyXCJAJVwiMD8hXCInMD8hXTsiU1Mjfig-ClwiMCR-Ik59MCR-Cg&input=)
### GolfScript, 62 bytes
```
'"%r"@%"0?!"'0?!];{"'\"%r\"@%\"0?!\"'0?!];"SS#~(>
\"0$~"N}0$~
```
The last byte is a linefeed. Try it online on [Web GolfScript](http://golfscript.tryitonline.net/#code=JyIlciJAJSIwPyEiJzA_IV07eyInXCIlclwiQCVcIjA_IVwiJzA_IV07IlNTI34oPgpcIjAkfiJOfTAkfgo&input=).
## Verification
```
$ wc -c P Q
16 P
46 Q
62 total
$ cat P Q > P+Q
$ 
$ shapescript P 2>&- | diff -qs - P
Files - and P are identical
$ cjam P 2>&- | diff -qs - P
Files - and P differ
$ golfscript P 2>&- | diff -qs - P
Files - and P differ
$ 
$ cjam Q 2>&- | diff -qs - Q
Files - and Q are identical
$ golfscript Q 2>&- | diff -qs - Q
Files - and Q differ
$ shapescript Q 2>&- | diff -qs - Q
Files - and Q differ
$ 
$ golfscript P+Q 2>&- | diff -qs - P+Q
Files - and P+Q are identical
$ shapescript P+Q 2>&- | diff -qs - P+Q
Files - and P+Q differ
$ cjam P+Q 2>&- | diff -qs - P+Q
Files - and P+Q differ
```
## How it works
### ShapeScript
```
'       Push a string that, when evaluated, does the following.
  "%r"  Push this formatting string. %r gets replaced by a string
        representation of the corresponding argument.
  @     Swap the string that is being evaluated on top of the stack.
  %     Apply formatting to the string on top of the stack.
  "0?!" Push that string.
'
0?!     Push a copy of the previous string and evaluate it.
```
### CJam
```
];      e# Clear the stack. Stack is already clear. Does nothing.
{       e# Push the following code block:
  "'\"%r\"@%\"0?!\"'0?!];"
  SS#   e# Find the index of " " in " ". Pushes 0.
  ~(    e# Apply logical NOT and decrement. Pushes -2.
  >     e# Discard all but the two rightmost characters from the string,
        e# i.e., reduce it to "];".
  \     e# Swap the string "];" with the code block in execution.
  "0$~" e# Push that string.
  N     e# Push a linefeed.
}       e#
0$~     e# Push a copy of the code block and execute it.
```
### GolfScript
```
'"%r"@%"0?!"'
0?!     # Find the index of the number 0 in the string and apply logical NOT.
];      # Clear the stack.
{       # Push the following code block:
  "'\"%r\"@%\"0?!\"'0?!];"
  SS    # Undefined token. Does nothing.
  #~(>  # Comment.
  \     # Swap the string with the code block in execution.
  "0$~" # Push that string.
  N     # Undefined token. Does nothing.
}       #
0$~     # Push a copy of the code block and execute it.
```
]