[Question]
  [
Let's use augmented reality to hunt small creatures hidden in source-code. Write a quine program that outputs its own code source, except for 5 consecutive characters that will be modified and that will display a *PCG-mon* : `(^_^)`
The 5 consecutive characters can be positioned anywhere in the source code (from position `0` to `n-5`, `n` being the source code length). The source code must have a minimum length of 5 characters. The string `(^_^)` or any of its substring of length >=2 must not appear in initial source code, only in output.
Example of valid submission:
* source code `my source code`, output `my (^_^)e code`
Invalid:
* source code `(^_^) copy;`, output `(^_^) (^_^)`
## Winning criteria
The shortest code in bytes wins.
  
[Answer]
# Javascript ES6, 44 bytes
```
$=_=>`$=(\^\_\^\)${($+'').slice(5)};$()`;$()
```
Output:
```
$=(^_^)=(\^\_\^\)${($+'').slice(5)};$()`;$()
```
Still working on golfing, but it works for now.
[Answer]
# Vim, ~~33~~, 27 keystrokes
```
qqqqqS(<C-v>94_<C-v>94)q@q<esc>hh"qPq@q
```
Note that `<C-v>` means ctrl+v, and is byte `0x16` and `<esc>` is the escape character, and is byte `0x1B`.
This just uses a slightly modified version of my [Golf you a quine for great good!](https://codegolf.stackexchange.com/a/92774/31716) answer.
Outputs:
```
(^_^)S(^V94_^V94)q@q^[hh"qPq@q
```
This is valid since `^V` is the way vim represents `<C-v>` and `^[` is the way vim represents `<esc>`.
The basic idea, is just to input the text `(^_^)` by its code points so we can avoid putting those characters in the source code. In insert mode, `<C-v>number` will insert the ASCII character of "number". However, since the challenge says:
> 
> The string `(^_^)` or any of its substring of length >=2 must not appear in initial source code, only in output.
> 
> 
> 
This answer abuses the "substring" rule by only entering the codepoints of the `^` characters, and entering `(`, `_`, and `)` directly.
Here's a gif that lets you see this solution in action, and puts the source code and output side by side for comparison:
[![enter image description here](https://i.stack.imgur.com/CUmKB.gif)](https://i.stack.imgur.com/CUmKB.gif)
[Answer]
## [CJam](http://sourceforge.net/projects/cjam/), ~~13~~ 11 bytes
```
"(_)"
_p'^*
```
[Online interpreter](http://cjam.aditsu.net/#code=%22(_)%22%0A_p'%5E*) *(-2 bytes thanks to @MartinEnder)*.
```
"(_)"             Push string
      _p          Duplicate and print repr with newline
        '^*       Join string with '^'
```
[Answer]
# Python, ~~115~~ ~~111~~ 107 bytes
```
def f():s='def f():s=%r;print s%%s.replace(s[:5],"^".join("(_)"))';print s%s.replace(s[:5],"^".join("(_)"))
```
Call `f()` and the output is:
```
def f():s='(^_^)():s=%r;print s%%s.replace(s[:5],"^".join("(_)"))';print s%s.replace(s[:5],"^".join("(_)"))
```
Inspired in part by [this answer to a similar question](https://codegolf.stackexchange.com/a/44925).
[Answer]
## CJAM, 16 15 bytes
Try it [here](http://cjam.aditsu.net/#code=%7B%22%5E(_)%22(*%7D_~sss).
```
{"^(_)"(*}_~sss
```
[Answer]
# Go (golang), 131 bytes
This challenge must have an answer in Go!
```
package main;import"fmt";func main(){a:="package main;import\"fmt\";func(%c_%[1]c)(){a:=%q;fmt.Printf(a,94,a)}";fmt.Printf(a,94,a)}
```
[Try it online!](https://play.golang.org/p/5900Og5Etr)
[Answer]
# JavaScript (ES6), 91 bytes
There's already a JavaScript answer, but there's not a non-source-reading JS answer:
```
a="a=%s;co%s.log(a,uneval(a),`(${'^'}_${'^'})`)";console.log(a,uneval(a),`(${'^'}_${'^'})`)
```
This is based on my non-source-reading answer to [Golf you a quine for great good!](https://codegolf.stackexchange.com/a/92449/42545). Outputs
```
a="a=%s;co%s.log(a,uneval(a),`(${'^'}_${'^'})`)";co(^_^).log(a,uneval(a),`(${'^'}_${'^'})`)
```
This can easily be modified by moving around the second `%s` in the string. For example,
```
a="a=%s;console.log(a,uneval(a),`($%s_${'^'})`)";console.log(a,uneval(a),`(${'^'}_${'^'})`)
```
outputs
```
a="a=%s;console.log(a,uneval(a),`($%s_${'^'})`)";console.log(a,uneval(a),`($(^_^)_${'^'})`)
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 22 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
“4094959441b³ỌØV”ṘVabc
```
Available at **[TryItOnline](http://jelly.tryitonline.net/#code=4oCcNDA5NDk1OTQ0MWLCs-G7jMOYVuKAneG5mFZhYmM&input=)**
Uses the built-in [payload capable](http://meta.codegolf.stackexchange.com/a/4924/53748) quine `“ØV”ṘV`  
The `abc` on the end is just filler to be replaced  
`b³` converts the integer into base 100, resulting in `[40,94,95,94,41]`  
`Ọ` casts to characters, resulting in `(^_^)`  
So the whole result is `“4094959441b³ỌØV”(^_^)`
[Answer]
# C# 5.0, 715 bytes
I know, this is huge. Just wanted to add a C# solution.
```
/*^()_*/using System.CodeDom;namespace System{class P{static void Main(){var b="/*^()_*/using System.CodeDom;namespace System{{class P{{static void Main(){{var b={0};var f=new string(new[]{{b[3],b[2],b[5],b[2],b[4]}});var w=new IO.StringWriter();CodeDom.Compiler.CodeDomProvider.CreateProvider(\"CSharp\").GenerateCodeFromExpression(new CodePrimitiveExpression(b),w,null);Console.WriteLine(b.Replace(\"[4]}}}}}}}}\",f),w);Console.ReadKey();}}}}}}";var f=new string(new[]{b[3],b[2],b[5],b[2],b[4]});var w=new IO.StringWriter();CodeDom.Compiler.CodeDomProvider.CreateProvider("CSharp").GenerateCodeFromExpression(new CodePrimitiveExpression(b),w,null);Console.WriteLine(b.Replace("[4]}}}}",f),w);Console.ReadKey();}}}
```
The output is:
```
/*^()_*/using System.CodeDom;namespace System{class P{static void Main(){var b="/*^()_*/using System.CodeDom;namespace System{{class P{{static void Main(){{var b={0};var f=new string(new[]{{b[3],b[2],b[5],b[2],b[4]}});var w=new IO.StringWriter();CodeDom.Compiler.CodeDomProvider.CreateProvider(\"CSharp\").GenerateCodeFromExpression(new CodePrimitiveExpression(b),w,null);Console.WriteLine(b.Replace(\"[4]}}}}}}}}\",f),w);Console.ReadKey();}}}}}}";var f=new string(new[]{b[3],b[2],b[5],b[2],b[4]});var w=new IO.StringWriter();CodeDom.Compiler.CodeDomProvider.CreateProvider("CSharp").GenerateCodeFromExpression(new CodePrimitiveExpression(b),w,null);Console.WriteLine(b.Replace("(^_^)}}",f),w);Console.ReadKey();}}}
```
Available [at Ideone.com](http://ideone.com/nj0xwb)
[Answer]
# [MATL](http://github.com/lmendo/MATL), 14 bytes
```
')_`_*i't&Dwqh
```
Produces the output `')_`_*i'(^_^)h`.
[Try it online!](http://matl.tryitonline.net/#code=JylfYF8qaSd0JkR3cWg&input=)
### Explanation
```
')_`_*i'  % Push this string
t&D       % Duplicate and get string representation (i.e. enclose with quotes)
w         % Swap
q         % Subtract 1. Transforms ')_`_*i' into the code points of '(^_^)h'
h         % Concatenate. Automatically casts code points to chars. Implicitly display
```
[Answer]
# Bash, 178 bytes
```
Q='#(8_8)
printf "Q=\47"
echo -n "$Q"|sed -r "s~(_|\()8~\1^~g"
echo -e "\x27"
tail<<<"$Q" -n4'
printf "Q=\47"
echo -n "$Q"|sed -r "s~(_|\()8~\1^~g"
echo -e "\x27"
tail<<<"$Q" -n4
```
Pfff, I am not good at quines :/ Any suggestion to golf it more is more than welcome! :-)
]