# Question
Title: I Rot-13 the source code, you Rot-19 the output!
This is alternate of a rip-off of a rip-off of a rip-off of a rip-off of a rip-off of a rip-off. Go upvote those!

Your task, if you accept it, is to write a program/function that outputs/returns its input/args. But again, The tricky part is that if I `rot-13` your source code, the output must be returned `rot-19`.

Your code will be only rotated *once*.

## Examples

Let's say your source code is `ABC` and the input is `xyz`.

Code `ABC` should return `xyz`.

Code `NOP`(*rotated*) should return `-./` (**Rot-19**).

## Details

* If your language has a custom codepage, apply rot13 to the bytes in the printable ASCII range in your code, and do not modify the rest. The input and output will be in pure printable ASCII.
* The input only contains ASCII character.
* use printable ASCII table for rotating
* rot-13 means to forward 13 positions in ASCII table
* Same applied to rot-19, which forward 19 positions instead.

## Rules

* Input can be taken in any convenient format.
* Output can be in any convenient format as well.
* Standard Loopholes are forbidden.

## scoring

This is code-golf so the answer with the fewest amount of bytes wins.

## Extra scoring rule

If there's somehow, a *non-esolang* appeared as a valid answer, it may considered as a better answer.

Example: `python`, `C++`, `java script` etc.

## If you are confused with Rot

Here is a encoder to get some idea with.

~~Use full ACSII Table for this question’s requirement.~~
**Use printable ASCII Table (33 ~126) for rotation!**

* `Space` are 32 in ASCII, which count as unprintable!

# Answer
# JavaScript (Node.js), 50 bytes

```
a=>01+"$25hYYXeya=>z!`TcyV01yV~$'zv,'|&&z|xx-$"&&a

```

Try it online!

Both versions are a function which takes a string as input and returns a string.

ROT13 code:

```
nJK=>8/1?Buffer(nJK).map(c=>(c-14)%94+33)+'':1/33n

```

## Explanation

Hides tricky characters used in the ROT19 logic inside a string. The quotes map to `/` characters so it's just a matter of finding where to put them to make it work.
> 10 votes

# Answer
# 05AB1E, ~~11~~ 9 bytes

*-2 thanks to ovs.*

```
žD¦7$,!R‡

```

Try it online!

```
žD¦7$,!R‡  # full program
     ,     # output...
    $      # input

```

# =BNO\>R, ~~11~~ 9 bytes

```
žQ¦D19._‡

```

a!( v# |{yv{r.

```
žQ¦D19._‡  # full program
        ‡  # push...
           # implicit input...
        ‡  # with each...
žQ         # ASCII character...
  ¦        # excluding the first...
        ‡  # replaced by corresponding character in...
žQ D       # ASCII characters...
  ¦        # excluding the first...
      ._   # rotated...
    19     # literal...
      ._   # characters to the left
           # implicit output

```
> 4 votes

# Answer
# GolfScript, 8 bytes

```
#.n$,p

```

Try it online!

Try it online!(rot13)
> 4 votes

# Answer
# Python 3.8 (pre-release), 75 bytes

Comment still do the trick quiet well :).

```
t=print(input())
#.ce\agyxx!]b\ayNV[eyybeWy\z~$'zv,'|&&zYbe \ \a \achgyzPzz

```

Try it online!

```
#J}!v{#5v{}$#566
0;print(''.join([chr((ord(i)-14)%94+33)for i in input()]))

```

a!( v# |{yv{r.
> 3 votes

# Answer
# Charcoal, 96 bytes

```
⭆Ｓ§Φγμ⁺Σ+&+⌕Φγμι

```

Try it online! After ROT13, this becomes:

```
⭆Ｓ§Φγμ⁺Σ838⌕Φγμι

```

Try it online! Explanation:

```
 Ｓ                  Input string
⭆                   Map over characters and join
        838         Literal string `+&+` or `838`
       Σ            Digital sum i.e. 0 or 19
      ⁺             Plus
           ⌕        Index of
               ι    Current character in
             γ      ASCII characters
            Φ       Filtered where
              μ     Current index is non-zero
  §                 Index into
    γ               ASCII characters
   Φ                Filtered where
     μ              Current index is non-zero
                    Implicitly print

```
> 1 votes

# Answer
# Pxem, Filename: 60 bytes + Content: 0 bytes = 60 bytes.

* Filename (escaped): `.w.o.i.c\001.+.a.d!md!T!j!b!\\!V !k!V\177!lG!|Q!vr!|KK!TKK!T!V\001!|!T`
    + Actual: `.w.o.i.c.+.a.d!md!T!j!b!\!V !k!V!lG!|Q!vr!|KK!TKK!T!V!|!T`
* Content: empty.

## With comments

See also: Simple cat program

```
XX.z
# pasted cat program
.a.w.o.i.c\001.+.aXX.z
# exit
.a.dXX.z
# these literals are ignored
.a!md!T!j!b!\\!V !k!V\177!lG!|Q!vr!|KK!TKK!T!V\001!|!T

```

Try it online!

## \]'rz.

* Filename (escaped): `;&;|;v;p\001;8;n;q.zq.a.w.o.i.c .x.c\177.yT.+^.%!.+XX.aXX.a.c\001.+.a`
    + Actual: `;&;|;v;p;8;n;q.zq.a.w.o.i.c .x.c.yT.+^.%!.+XX.aXX.a.c.+.a`
* Content: empty.

### With comments

```
XX.z
# they are just literals but discarded later
.aXX;&;|;v;p\001;8;n;q.z
# while size<2||pop!=0; do push 'q'; done
.a.zq.aXX.z
# while empty||pop!=0; do
.a.wXX.z
  # if ! empty; then putchar pop; fi
  .a.oXX.z
  # push getchar; dup; push 32;
  # while size<2||pop<pop; do
  .a.i.c .xXX.z
    # dup; push 127; while size<2||pop>pop; do
    .a.c\177.yXX.z
      # push 84; push pop+pop;
      # push 94;
      # push ((x=pop)<(y=pop))?y%x:x%y
      .aT.+^.%XX.z
      # push 33; push pop+pop;
      .a!.+XX.z
    # push X; push X; done (* idiom for BREAK statement *)
    .aXX.aXX.z
  # push X; push X; done
  .aXX.aXX.z
# dup; push 1; push pop+pop; done
.a.c\001.+.a

```

a!( v# |{yv{r.
> 1 votes

---
Tags: code-golf, string, source-layout, encryption
---