[Question]
  [
Just because the [reverse](https://codegolf.stackexchange.com/q/193315/78410) and [palindrome](https://codegolf.stackexchange.com/q/221209/78410) were not too challenging individually :)
Write a program (full program or function) that satisfies the following: given a string input,
* the program *as-is* outputs the input string unchanged.
* the program *reversed* outputs the input string reversed.
* the program *palindromized* outputs the input string palindromized.
* the program *reversed and then palindromized* outputs the input string reversed and then palindromized.
In this challenge, *palindromize* is defined as "concatenate the reverse on the right" (`lambda s: s + s[::-1]` in Python).
For example, if your code is `abc`, when given `"xyz"` as input,
* `abc` should output `"xyz"`.
* `cba` should output `"zyx"`.
* `abccba` should output `"xyzzyx"`.
* `cbaabc` should output `"zyxxyz"`.
You may assume that the input string is nonempty and entirely consists of printable ASCII (32-126, no newlines).
Standard [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") rules apply. The shortest code in bytes wins.
  
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), 3 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
?R\
```
* `?R\` - [Try it online.](https://tio.run/##yy9OTMpM/f/fPijm//@KyioA)
* `\R?` - [.enilno ti yrT](https://tio.run/##yy9OTMpM/f8/Jsj@//@KyioA)
* `?R\\R?` - [Try it online..enilno ti yrT](https://tio.run/##yy9OTMpM/f/fPigmJsj@//@KyioA)
* `\R??R\` - [.enilno ti yrTTry it online.](https://tio.run/##yy9OTMpM/f8/JsjePijm//@KyioA)
**Explanation:**
```
?      # Output the (implicit) input-string (without trailing newline)
 R     # Reverse the (implicit) input-string
  \    # Discard it from the stack
       # (don't output anything implicitly, since we already had an explicit print)
```
```
\      # No-op to discard the top of the stack
 R     # Reverse the (implicit) input-string
  ?    # Pop and output this reversed input
       # (don't output anything implicitly, since we already had an explicit print)
```
```
?R\    # Same as the first program above, outputting the input as is
   \R? # Same as the second program above, outputting the input reversed
```
```
\R?    # Outputs the input reversed
   ?R\ # Outputs the input as is
```
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 3 bytes
```
θ⮌ω
```
[Try it online!](https://tio.run/##S85ILErOT8z5///cjkfres53whkA "Charcoal – Try It Online") Reversed:
```
ω⮌θ
```
[Try it online!](https://tio.run/##S85ILErOT8z5//9856N1Ped2/P9/bgeQcb4TAA "Charcoal – Try It Online") Palindromised:
```
θ⮌ωω⮌θ
```
[Try it online!](https://tio.run/##S85ILErOT8z5///cjkfres53nu8EUud2wPkA "Charcoal – Try It Online") Palindomised Reversed:
```
ω⮌θθ⮌ω
```
[Try it online!](https://tio.run/##S85ILErOT8z5//9856N1Ped2nNsBpM53/v8PZQAA "Charcoal – Try It Online") Explanation:
```
θ
```
Print the input.
```
⮌ω
```
Print the reverse of the empty string.
Reversed explanation:
```
ω
```
Print the empty string.
```
⮌θ
```
Print the reverse of the input.
Palindromised and reversed palindromised follow trivially.
[Answer]
# JavaScript, 70 bytes
```
(x=>x.at?x:y=>y+z(y))//)y+)y(z>=y:``nioj.)(esrever.]x...[?ta.x>=x=z(
```
[Try it online!](https://tio.run/##XVDLbsIwELznK1b0wJqUjbhSOaivL@iRImGlBjmN7Mh2ohjEt6dOk6gqe/KMZ3dmtxStcIVVtV9r8yX7D2@VPlNtjTc@1JKEBw6nRhdeGQ3I4HqDLIOTKL5hFD8InySF0c6DM40t5H0DZKs@wY7nXZy267aB5yG9YGAsy1hIWcBLzsP2eNTKlMRQOitbaenQEdF@5wV1Oe/4BZN@lcGNvBmNkZGrK@Vx@amX8V2pQuLmEdYbRqVReuSf5nC20TGZA57DNYFYA20qSZU5o4u6e062ooofuHh@eX17X7Aouf1NGyK6Ydd9TDkufqCJxTnAr300xlEQ0QAm1YSmo6Xwn54NUph7@x8 "JavaScript (Node.js) – Try It Online")
[Answer]
# [Python](https://www.python.org), 51 bytes
*-2 bytes, thanks to tsh*   
*-2 bytes, thanks to Jakque*
```
s=input()#)]1-::[s=dne(tnirp
print(end=s)#)(tupni=s
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m72soLIkIz9vwYrUioIiWyUlpaWlJWm6FjeNi20z8wpKSzQ0lTVjDXWtrKKLbVPyUjVK8jKLCrgKijLzSjRS81Jsi4HyGiWlBXmZtsVQrROBpkQbWukaxnJxgc1QsFXIScxNSklUiAfaYKWgFBEZpcTFlVqRmqwBslYTap4mkli0FcgAbDLa-KUhMtoo5kIctmABhAYA)
---
# [Python](https://www.python.org), 55 bytes
```
def f(s):#
 print(end=s)#)]1-::[s=dne(tnirp 
#:)s(f fed
```
*function accepting string as argument*
[Attempt This Online!](https://ato.pxeger.com/run?1=m72soLIkIz9vwYrUioIiWyUlpaWlJWm6FjfNU1LTFNI0ijWtlLkUCooy80o0UvNSbIs1lTVjDXWtrKKLbVPyUjVK8jKLChS4lK00izWA6lNToNqnAU2KNrTSNYzl4kqtSE3WABmvyZWmoRQRGaWkyQUxURMhF20FUoxPhTZxyiAqtLHbB3HdggUQGgA)
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), 3 bytes
```
₴Ḃ_
```
[Try!](https://vyxal.pythonanywhere.com/?v=2#WyIiLCIiLCLigrThuIJfIiwiIiwiYWJjIl0=)
[!yrT](https://vyxal.pythonanywhere.com/?v=2#WyIiLCIiLCJf4biC4oK0IiwiIiwiYWJjIl0=)
[Try!!yrT](https://vyxal.pythonanywhere.com/?v=2#WyIiLCIiLCLigrThuIJfX+G4guKCtCIsIiIsImFiYyJd)
[!yrTTry!](https://vyxal.pythonanywhere.com/?v=2#WyIiLCIiLCJf4biC4oK04oK04biCXyIsIiIsImFiYyJd)
> 
> +1 very hard
> 
> 
> 
You uh sure about that?
## Explained
```
₴Ḃ_­⁡​‎‎⁪⁡⁪⁠⁪⁡⁪‏‏​⁡⁠⁡‌⁢​‎‏​⁢⁠⁡‌­
₴    # ‎⁡Print without newline
# ‎⁢The rest has no impact
💎
```
```
_Ḃ₴­⁡​‎⁪⁪⁠‎⁪⁡⁪⁠⁪⁢⁪‏⁠‎⁪⁡⁪⁠⁪⁣⁪‏‏​⁡⁠⁡‌­
 Ḃ₴  # ‎⁡Print the reverse of the input
💎
```
```
₴Ḃ__Ḃ₴­⁡​‎‎⁪⁡⁪⁠⁪⁡⁪‏⁠⁪⁪⁠⁪⁪‏​⁡⁠⁡‌⁢​‎‎⁪⁡⁪⁠⁪⁢⁡⁪‏⁠‎⁪⁡⁪⁠⁪⁢⁢⁪‏‏​⁡⁠⁡‌­
₴       # ‎⁡Print the normal input
    Ḃ₴  # ‎⁢Print the reverse
💎
```
```
_Ḃ₴₴Ḃ_­⁡​‎‎⁪⁡⁪⁠⁪⁢⁪‏⁠‎⁪⁡⁪⁠⁪⁣⁪‏‏​⁡⁠⁡‌⁢​‎‎⁪⁡⁪⁠⁪⁤⁪‏‏​⁡⁠⁡‌­
 Ḃ₴     # ‎⁡Print reversed input
   ₴    # ‎⁢And then normal input
💎
```
Created with the help of [Luminespire](https://vyxal.github.io/Luminespire).
[Answer]
# [R](https://www.r-project.org), ~~92~~ ~~88~~ 86 bytes
*Edit: -2 bytes thanks to [Jakque's comment](https://codegolf.stackexchange.com/questions/265514/i-revpal-the-source-code-you-revpal-the-input#comment579581_265522)*
```
x=utf8ToInt(scan(,''))#)))x(ver(8ftUoTtni(tac
cat(intToUtf8(x))#))'',(nacs(tnIoT8ftu=x
```
[Attempt This Online!](https://ato.pxeger.com/run?1=nZGxasMwEIbpqsdwB9-BDKWTofUDZHcyZTmE0hpUyUgXIzL0RbK4Qx8qfZrKcnALSSntpB_p_-6_Ox3f_HiqAvvOPjU9BdZ3EBRZkEUh7QvF5h6lcsZQH3RTbG2B73veVfVpE5sk6tatLJ-RskS8RcQIg_ZQ73jtWrYdMCmhiKGz3Lp1giBmY1lKsKQCsF25Nvn3TZyrf9y8ej2c2_rC0h18C83PKU_0ZC68Cg6P1YVZTiUOE5PEdSw7rqAoEyeEHshATz5oYB15WVo2ybwhxIdp3KzFszbG_YgtU_6ZXJr_T-av8PwN4zifnw)
Full program that reads input from and outputs to the R console.
Note that the program(s) should be saved to a file & run in R using `source("myprog.r")`: copy-pasting into a REPL environment will result in incorrect parsing of the input (the program will try to read it's own lines!).  
The header/footer in the "Attempt This Online" link mimic this behaviour, instead of the default of running code in a REPL setting.
---
# [R](https://www.r-project.org), ~~118~~ 115 bytes
```
if(!exists('f'))f=\(x)c();body(f)[T<-T+1]=parse(t='x')#)')x(ver'=t(esrap=]1+T-<T[)f(ydob;)(c)x(\=f))'f'(stsixe!(fi
```
[Attempt This Online!](https://ato.pxeger.com/run?1=zZOxTsMwEIYHNj-Fq0j4Tk2Gbkit3yJb0yFNztRS6li2g1JehSUMvAYPwQZPg9WIIgZQlSLBZOl0_-_7_rMfHt3wrI3tgqQGfHDeNjqA2FHTtCIVAvGpCyq7efVawYx67YMHoWJdyQJ6rACX27Y-gMJ1vsry-WIjbek8QZCiF5igwB7uyAkZgLwrrdws5nm2yteo4FC32yVCFVsKqRCjcRzC655moDQbr367ekl4Z6pdaW6p5lVbE69JaUOeq1gPujVccckdhc4ZfsT5FLCqDKDgWMVUFEaknqyMaIwlURNn8-fbfvQzt4_IbEIo0SG2HJPpp4TyI44tG21q1-71_flMX0TTwS7d9n_L8vQ0JoV6Ul__Vr6Xwv7BSr_Pd_zawzCe7w)
Code that defines a function, `f`, that accepts an input of a vector of characters and returns it unchanged.  
Reversed code defines `f` to return its input reversed, palindromized code defines `f` to return it palindromized, and reverse-palindromized code defines `f` to return it reverse-palindromized.  
It's not completely straightforward to amend an already-complete R function definition, but it can be achieved (as here) by assigning directly into the function `body` if the function already `exists`.
[Answer]
# [Bash](https://www.gnu.org/software/bash/), 17 bytes
```
rev $1 # 1$ tac
```
[Try it online!](https://tio.run/##S0oszvifmpyRr6Cbp6CemJScoq5gp1Dxn6sotUxBxVBBWcFQRaEkMZkLrIgrObEELlqWWoSp6n8FAA "Bash – Try It Online")
[Answer]
# C# Interactive Compiler, ~~80~~ 77 bytes
Based on [*@bsoelch*'s Python answer](https://codegolf.stackexchange.com/a/265522/52210).  
-3 bytes implicitly thanks to [the suggested golf of *@Jakque* on the ported Python answer](https://codegolf.stackexchange.com/questions/265514/i-revpal-the-source-code-you-revpal-the-input/265518#comment579581_265522).
```
var s=ReadLine();//;))(yarrAoT.)(esreveR.s(etirW
Write(s);//;)(eniLdaeR=s rav
```
[Try it online.](https://tio.run/##JcohDoAwDAVQzykmO8E4AEHgpxaS6WZ8UQNJuyyMyw/B06/YXEzGaKzOtgQ@o1wgvy7L6j11Vt3vI3iCKRpSMEIVzVNWqSD7I@GSeDLSZk65jfH09wM)
```
var s=ReadLine();//;)s(etirW
Write(s.Reverse().ToArray());//;)(eniLdaeR=s rav
```
[.enilno ti yrT](https://tio.run/##JcoxCoAwDAXQ3VN0TAf1AMXBvVMRnIP9QxaFRIp6@Sg4v7dZv5m4N9ZgUwHXLDsopnFM0Qin6NqtKifIhoIGtU@H5ZhV@ab4R8IuuTLKZEG5uV/38wI)
```
var s=ReadLine();//;))(yarrAoT.)(esreveR.s(etirW
Write(s);//;)(eniLdaeR=s ravvar s=ReadLine();//;)s(etirW
Write(s.Reverse().ToArray());//;)(eniLdaeR=s rav
```
[Try it online..enilno ti yrT](https://tio.run/##bcwxCoBADETR3lNYJoXrAcTC3moRrIOmSKMwkcX18qtgJ9bz5y3eLG6lJEHtfVRZR9uUuGvbjpmyAMM@BSZ1aNIYnPQwzNUMO5T8DUk3G1fR2HsNSb/Y5xjiw8GfNUz7AEgm/sVKOfN1Aw)
```
var s=ReadLine();//;)s(etirW
Write(s.Reverse().ToArray());//;)(eniLdaeR=s ravvar s=ReadLine();//;))(yarrAoT.)(esreveR.s(etirW
Write(s);//;)(eniLdaeR=s rav
```
[.enilno ti yrTTry it online.](https://tio.run/##bc0xCoAwEETR3lNYbgrjAcTC3ioI1kvcYhuFWQnGy8eAnVjP5020LpqWkhitjUF4m3UXckPfD85ITsXarNBTyHyQJLC6@uWYAM7k3pBk13ljCaO14PSLOcoMTMfia26oVPCfg1@slCvfDw)
**Explanation:**
`//` is a single-line comment and everything after it are no-ops. So if we'll ignore those comments, all four of the REPL-programs will:
1. Start with `var s=ReadLine();`: Read the input as string into variable `s`
2. 1. `Write(s);`: Write string `s` to the output-buffer
	2. `Write(s.Reverse().ToArray());`: Reverse string `s` to a reversed character-iteratator (`Enumerable.ReverseIterator<char>`); then convert it to a character-array (`char[]`); then write all characters in this character-array separately to the output-buffer
	3. `Write(s);Write(s.Reverse().ToArray());`: 1 and 2 combined
	4. `Write(s.Reverse().ToArray());Write(s);`: 2 and 1 combined
3. After which the output-buffer is output implicitly as single string without trailing newline
[Answer]
# [Pip](https://github.com/dloscutoff/pip), 11 10 bytes
```
.:a  aR.
```
This answer exploits the fact that `.a` does nothing significant, whereas `a.b` is concatenation.
[Attempt This Online!](https://ato.pxeger.com/run?1=m724ILNgwYKlpSVpuharuPSsEhUUEoP0uCACUPHl0UqJSclKsVAuAA)
```
[\n].:a  aR.[\n]­⁡​‎‎⁪⁡⁪⁠⁪⁡⁪‏⁠‎⁪⁡⁪⁠⁪⁢⁪‏⁠‎⁪⁡⁪⁠⁪⁣⁪‏⁠‎⁪⁡⁪⁠⁪⁤⁪‏⁠‎⁪⁡⁪⁠⁪⁣⁤⁪‏⁠‎⁪⁡⁪⁠⁪⁤⁡⁪‏⁠‎⁪⁡⁪⁠⁪⁤⁢⁪‏⁠‎⁪⁡⁪⁠⁪⁤⁣⁪‏‏​⁡⁠⁡‌⁢​‎‎⁪⁡⁪⁠⁪⁢⁡⁪‏⁠‎⁪⁡⁪⁠⁪⁢⁢⁪‏‏​⁡⁠⁡‌⁣​‎‎⁪⁡⁪⁠⁪⁢⁣⁪‏⁠‎⁪⁡⁪⁠⁪⁢⁤⁪‏‏​⁡⁠⁡‌⁤​‎‎⁪⁡⁪⁠⁪⁣⁡⁪‏⁠‎⁪⁡⁪⁠⁪⁣⁢⁪‏⁠‎⁪⁡⁪⁠⁪⁣⁣⁪‏‏​⁡⁠⁡‌­
[\n]        [\n]  # ‎⁡Newlines for Palindormize/Reverse Palindromize
    .:a           # -, Push input (`:` lowers precedence for Reverse Palindromize)
                  # ‎⁣Comment ("  "), ignore the following characters
         aR.      #
💎
```
[Reversed:](https://ato.pxeger.com/run?1=m724ILNgwYKlpSVpuharuPSCEhUUEq30uCACUPHl0UqJSclKsVAuAA)
```
[\n].Ra  a:.[\n]­⁡​‎‎­⁡​‎‎⁪⁡⁪⁠⁪⁢⁡⁪‏⁠‎⁪⁡⁪⁠⁪⁢⁢⁪‏⁠‎⁪⁡⁪⁠⁪⁢⁣⁪‏⁠‎⁪⁡⁪⁠⁪⁢⁤⁪‏⁠‎⁪⁡⁪⁠⁪⁣⁡⁪‏⁠⁪⁪‏​⁡⁠⁡‌⁢​‎‎⁪⁡⁪⁠⁪⁣⁢⁪‏⁠‎⁪⁡⁪⁠⁪⁣⁣⁪‏⁠‎⁪⁡⁪⁠⁪⁣⁤⁪‏⁠‎⁪⁡⁪⁠⁪⁤⁡⁪‏‏​⁡⁠⁡‌­
    .Ra           # ‎⁡-, Push input reversed
         a:.      # ‎⁢Comment
💎
```
[Palindromized:](https://ato.pxeger.com/run?1=m724ILNgwYKlpSVpuhZbuPSsEhUUEoP0uLj0gkAsKz0uiBRUxfJopcSkZKVYKBcA)
```
[\n].:a  aR.[\n][\n].Ra  a:.[\n]­⁡​‎‎⁪⁡⁪⁠⁪⁢⁡⁪‏⁠‎⁪⁡⁪⁠⁪⁢⁢⁪‏⁠⁪⁪⁠⁪⁪‏​⁡⁠⁡‌⁢​‎‎⁪⁡⁪⁠⁪⁢⁢⁢⁪‏⁠‎⁪⁡⁪⁠⁪⁢⁢⁣⁪‏⁠‎⁪⁡⁪⁠⁪⁢⁢⁤⁪‏⁠‎⁪⁡⁪⁠⁪⁢⁣⁡⁪‏⁠‎⁪⁡⁪⁠⁪⁢⁣⁢⁪‏‏​⁡⁠⁡‌⁣​‎‎⁪⁡⁪⁠⁪⁢⁣⁪‏⁠‎⁪⁡⁪⁠⁪⁢⁤⁪‏⁠‎⁪⁡⁪⁠⁪⁣⁡⁪‏⁠‎⁪⁡⁪⁠⁪⁣⁢⁪‏⁠‎⁪⁡⁪⁠⁪⁣⁣⁪‏⁠‎⁪⁡⁪⁠⁪⁢⁣⁣⁪‏⁠‎⁪⁡⁪⁠⁪⁢⁣⁤⁪‏⁠‎⁪⁡⁪⁠⁪⁢⁤⁡⁪‏⁠‎⁪⁡⁪⁠⁪⁢⁤⁢⁪‏‏​⁡⁠⁡‌­
    .:a                           # ‎⁡-, Push input
                    .Ra           # ‎⁢Concatenate with input reversed
         aR.             a:.      # ‎⁣Comment
💎
```
[Reverse Palindromized](https://ato.pxeger.com/run?1=m724ILNgwYKlpSVpuhZbuPSCEhUUEq30uLj0rECsID0uiBRUxfJopcSkZKVYKBcA)
```
[\n\.Ra  a:.[\n][\n].:a  aR.[\n]­⁡​‎‎⁪⁡⁪⁠⁪⁢⁡⁪‏⁠‎⁪⁡⁪⁠⁪⁢⁢⁪‏⁠‎⁪⁡⁪⁠⁪⁢⁣⁪‏⁠‎⁪⁡⁪⁠⁪⁢⁤⁪‏⁠‎⁪⁡⁪⁠⁪⁣⁡⁪‏‏​⁡⁠⁡‌⁢​‎‎⁪⁡⁪⁠⁪⁢⁢⁢⁪‏⁠‎⁪⁡⁪⁠⁪⁢⁢⁣⁪‏‏​⁡⁠⁡‌⁣​‎‎⁪⁡⁪⁠⁪⁣⁢⁪‏⁠‎⁪⁡⁪⁠⁪⁣⁣⁪‏⁠‎⁪⁡⁪⁠⁪⁣⁤⁪‏⁠‎⁪⁡⁪⁠⁪⁤⁡⁪‏⁠‎⁪⁡⁪⁠⁪⁢⁢⁤⁪‏⁠‎⁪⁡⁪⁠⁪⁢⁣⁡⁪‏⁠‎⁪⁡⁪⁠⁪⁢⁣⁢⁪‏⁠‎⁪⁡⁪⁠⁪⁢⁣⁣⁪‏⁠‎⁪⁡⁪⁠⁪⁢⁣⁤⁪‏⁠‎⁪⁡⁪⁠⁪⁢⁤⁡⁪‏⁠‎⁪⁡⁪⁠⁪⁢⁤⁢⁪‏‏​⁡⁠⁡‌­
    .Ra                           # ‎⁡-, Push input reversed
                    .:a           # ‎⁢Concatenate with input, ":" groups it as .(Ra).a rather than .R(a.a)
         a:.             aR.      # ‎⁣Comment
💎
```
[Answer]
# [PHP](https://php.net/) -F, 31 bytes
```
echo$argn;#;)ngra$(verrts ohce
```
[Try it online!](https://tio.run/##K8go@G9jXwAkU5Mz8lUSi9LzrJWtNfPSixJVNMpSi4pKihXyM5JTuf7/r6is@pdfUJKZn1f8X9cNAA "PHP – Try It Online")
```
echo strrev($argn);#;ngra$ohce
```
[Reversed version](https://tio.run/##K8go@G9jXwAkuVKTM/IVikuKilLLNFQSi9LzNK2VrfPSixJV8jOSU///r6is@pdfUJKZn1f8X9cNAA)
```
echo$argn;#;)ngra$(verrts ohce
echo strrev($argn);#;ngra$ohce
```
[Palindromed version](https://tio.run/##K8go@G9jXwAkU5Mz8lUSi9LzrJWtNfPSixJVNMpSi4pKihXyM5JTubi4QAoUikuKilLLNMAKNYEqwQpBCv7/r6is@pdfUJKZn1f8X9cNAA)
```
echo strrev($argn);#;ngra$ohce
echo$argn;#;)ngra$(verrts ohce
```
[Reversed and Palindromed version](https://tio.run/##K8go@G9jXwAkuVKTM/IVikuKilLLNFQSi9LzNK2VrfPSixJV8jOSU8HSYGGgqCZYWKMstaiopFgBLP3/f0Vl1b/8gpLM/Lzi/7puAA)
Actually, [my answer to the palindrome question](https://codegolf.stackexchange.com/a/221251/90841) will work here too, because it uses 2 separate `echo` for the palindrome parts ;) Notice the new line at the end which is necessary because of the comment trick. Actually saved one byte here using `#` as comment
]