[Question]
  [
A shape is [chiral](https://en.wikipedia.org/wiki/Chirality) if no amount of rotation can make it look like it's mirror image. In this puzzle we will be writing chiral computer programs.
For this puzzle we will think of a program as a rectangular matrix of characters. As such all solutions to this challenge must be rectangular (that is all lines must be of the same length). We can rotate these programs in quarter turn increments. For example the program
```
The quickish fish
    lept deftly  
  rightwards     
```
When rotated a quarter turn clockwise looks like
```
  T
  h
r e
i  
glq
heu
tpi
wtc
a k
rdi
des
sfh
 t 
 lf
 yi
  s
  h
```
We can also reflect these programs. Here is the same program reflected over a vertical axis:
```
hsif hsikciuq ehT
  yltfed tpel    
    sdrawthgir   
```
A chiral program is a program that when rotated any number of times will always output "`left`". However when reflected produces a program that outputs "`right`" no matter how many times it is rotated.
Your task is to write a chiral program in as few bytes as possible.
### Additional Rules
* Output is not-case sensitive but should be consistent. (e.g. You may output "`LEFT`" and "`rIgHt`" but this casing must be consistent under rotations)
* Lines are to be split either on a newline or a newline and a linefeed.
* Your program must be a rectangle, you can pad it with spaces or comments but each line must have the same length.
* You may optionally have a trailing newline (or newline and linefeed) on all of your programs if you wish.
  
[Answer]
# [Pascal (FPC)](https://www.freepascal.org/), ~~2161~~ ~~755~~ 349 bytes
```
///////bw(,,),(wb///////
///////er'''e''re///////
begin//girgtnflig//nigeb
write//itih'dteti//etirw
('le'//ne'' .''en//'ir'(
,'ft'//////////////'hg',
)end.////////////// 't',
,'t' //////////////.dne)
,'gh'//////////////'tf',
('ri'//ne''. ''en//'el'(
write//itetd'hiti//etirw
begin//gilfntgrig//nigeb
///////er''e'''re///////
///////bw(,),,(wb///////
```
[Try left](https://tio.run/##XVDLCsQgDLz7Fd7Ggqvf1Ee0AZHiBvr53cB2W7s5KGQyM8ls43seyytt83HEb027837wbp/Ohjl/agAIaPQDJspcY8zcstRUOMdYOdNk9saiUyy8YhESVrZw241DIeiUytigasoGNzjjkQTxUVgzvBmoLuEJWIgCXl/7BMJSaVAgr/9SkpTh0Pg0D/Y0p6Lm17okC1a@170OLKlKbveBXSSq1kXShTj4LsTj@AA "Pascal (FPC) – Try It Online")
[Try right](https://tio.run/##XVBJDsMgDLzzCm5DJApvymKIJYQiainPTx01zVIfQPIstmfp32NfXmkZty1@a1id77x363A0zPFTAwhAox8wUOYaY@aSquTGOcbKmQazNhZl6SMTZhZWtXBbjUNjKEt9glU7VYMKnPHIM@KjIAleAYF9AmGq1JmO6hSegFXurkjybzVnBRwKHcNtOIZz0@Hnujxj0p3Pdc8DW5aaynXgLZI9kyuSW4ia4hXitn0A "Pascal (FPC) – Try It Online")
@tsh motivated me to try again when I saw his program (in comment) and here it is!
---
Previous one with 755 bytes:
```
 begin write('left')end.// 
/e .dne)'thgir'(etirw nigeb
/g                        e
.i                       .g
dn                       di
n                        nn
ew                       e 
)r                       )w
'i                       'r
tt                       ti
fe                       ht
e(                       ge
l'                       i(
'r                       r'
(i                       'l
eg                       (e
th                       ef
it                       tt
r'                       i'
w)                       r)
 e                       we
nn                        n
id                       nd
g.                       i.
e                        g/
begin write('right')end. e/
 //.dne)'tfel'(etirw nigeb 
```
[Try left](https://tio.run/##dZIxjkMhDET7OYU7Q7FwpiQYviWEImKJ4/9t0qQYt6/w83jej8/rMf/6@3Xf8rThS872sKTTemi21UqtgmpS2rKscQ3fmix8H1k@7Ik6hIyhOEFloC3CmoMhWQt22DpB3oTlA2UuuhFBWDi6EXYFLBE2DFMJ8wRlnluRqOeEsayTIS6WS4fT@wKbeipOZp4ZwnI5hsUfCG8MNYzCXArYOhkVP9XdPq5vd8UqpNZvd7vNn@rKff8D "Pascal (FPC) – Try It Online")
[Try right](https://tio.run/##dZIxjkMhDET7OYU7Q7FwpiQYviVkRSwSx/@7RZoU4/ZJ5nmY9@P39Zg//f26b6m1tLCsu9vUZNvXkfBhT8HThoec5duSLh/X1mzRiliFCZlRMQphXuCNsGiIYEsDwh48hpMJWxlLmYvCN2F7Y1@EWYcNwpIhOWE6oYt5Kib1TLDEsjZ0lsv1fwO9z6HUcyEzz3xgh@Ui4N8XaAw2R2EuZaCyrMVQTT7dvYavr/JCvso7rX@6W6vc9x8 "Pascal (FPC) – Try It Online")
If you saw my previous submission, just forget it :)
All rotations for both left and right programs are the same.
[Answer]
# [Klein (000)](https://github.com/Wheatwizard/Klein), ~~109~~ 87 bytes
```
."left"@\.
\"right"..
@"thgir">.
..@"tfel"\
\"left"@..
.>"right"@
.."thgir"\
.\@"tfel".
```
[Try it online!](https://tio.run/##Lcq7CcAwDAXAXmO8Pg9NYJw91PpHTArj/RVBXB7cM8t43YlZ6kY2imGN1jdIydi9jYVEIQO1TFiE/0ZgOjlHONmEdi7dXVX9uj8 "Klein – Try It Online")
Should be possible to get a shorter version of this answer so good luck!
This answer is inspired by spirals. In particular the idea is two interlocked spirals, one for left and one for right. It has two fold symmetry, So we can check the following programs to know it works:
## Quarter turn
```
...\.@\.
\.>"."""
@""l@trl
"tre"hie
thiftggf
fggtfiht
eih"ert"
lrt@l""@
""".">.\
.\@.\...
```
[Try it online!](https://tio.run/##DczBDcQwCATAP2XsPytXEHF98MU2CsrDon8uBcw86fF2kzSqUYw3CEAUSK2TgjqOHS61Y9ZaU@ZaNWOXeGz4KUie0gRUPkncNKHpN5LdPcbo6/cH "Klein – Try It Online")
## Mirrored
```
.\@.\...
""".">.\
lrt@l""@
eih"ert"
fggtfiht
thiftggf
"tre"hie
@""l@trl
\.>"."""
...\.@\.
```
[Try it online!](https://tio.run/##DczBDcQwCATAP2XsPytXEHF98MU2CsrDon8uBcw86fF205RGUgAQN03ylCag4rHhpyBzrZqxS2rHrLWmoI5jh4sCqXVSjPfnAfkuoxq7e4zR1@8P "Klein – Try It Online")
## Mirrored and Quarter turn
```
.\@"tfel".
.."thgir"\
.>"right"@
\"left"@..
..@"tfel"\
@"thgir">.
\"right"..
."left"@\.
```
[Try it online!](https://tio.run/##Lcq7DcAgDAXA3mO8Pk9MgMgebvkpVgrE/g4odFfcY7m/7tSEWbKBQmK22gdUGDF6bRNJFJbLAnc4VyWdGrnCX3c4V@nuIQS/7g8 "Klein – Try It Online")
[Answer]
# [Klein (000)](https://github.com/Wheatwizard/Klein), ~~27~~ 25 bytes
```
\(("right"@/
\(("left"@!\
```
[Try it online!](https://tio.run/##y85Jzcz7/z9GQ0OpKDM9o0TJQZ8LxMlJTQOyFWP@//9vYGDwX9cRAA "Klein – Try It Online") [Rotated once!](https://tio.run/##y85Jzcz7/z8mhktDA4SUlLhyirhSM7nS0rlKMriUSrgclLgUHbhi9P///29gYPBf1xEA) [Rotated twice!](https://tio.run/##y85Jzcz7/z9G0UGpJC01R0lDI4ZLH8jOSM8sAnH@//9vYGDwX9cRAA) [Rotated three times!](https://tio.run/##y85Jzcz7/18/hstBkUvJgatEiSujhCs9jSszlasoh0tJiUtDA4RiYv7//29gYPBf1xEA)
And flipped: [Try it online!](https://tio.run/##y85Jzcz7/1/fQakkIz2zSElDI4YrRhHIS0vNAXH@//9vYGDwX9cRAA) [Rotated once!](https://tio.run/##y85Jzcz7/z9Gn0vRgctBiUuphKskgystnSs1kyuniEtJiUtDA4RiYv7//29gYPBf1xEA) [Rotated twice!](https://tio.run/##y85Jzcz7/z9GQ0MpJzWtRMlBMYYLxCnKTM8A8vT///9vYGDwX9cRAA) [Rotated thrice!](https://tio.run/##y85Jzcz7/z8mhktDA4SUlLiKcrgyU7nS07gySrhKlLiUHLgcFLn0Y/7//29gYPBf1xEA)
The only one that gave me a bit of trouble was the flipped and rotated once, which looks like:
```
\/
!@
@"
"t
th
fg
ei
lr
""
((
((
\\
```
This is the only reason for the two sets of `((`.
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), ~~1481~~ ~~599~~ ~~505~~ ~~461~~ ~~341~~ ~~305~~ 271 bytes
```
/g+///g/g"c.c"g/
g=//////=rolol=g
"left"///inone/+
console//gsgsf//
.log(g)//ho(ot//
console//tlgl"//
"right"//"e)e//g
g=//////////////
//////////////=g
g//e)e"//"thgir"
//"lglt//elosnoc
//to(oh//)g(gol.
//fsgsg//elosnoc
+/enoni///"tfel"
g=lolor=//////=g
/g"c.c"g/g///+g/
```
## Mirrored
```
/g"c.c"g/g///+g/
g=lolor=//////=g
+/enoni///"tfel"
//fsgsg//elosnoc
//to(oh//)g(gol.
//"lglt//elosnoc
g//e)e"//"thgir"
//////////////=g
g=//////////////
"right"//"e)e//g
console//tlgl"//
.log(g)//ho(ot//
console//gsgsf//
"left"///inone/+
g=//////=rolol=g
/g+///g/g"c.c"g/
```
[Try it online!](https://tio.run/##lVLNbtwgEL7zFAjlYNcbJofeXOch2qPjxpZ3zLJiwQKyjdTm2beD7XUSJRslXAaG@X6GYd8du9B7PcZr67Z4OnaeD7ziv6LXVknf/WlPoAoAUKBEL3uhgKkKplV5Z5ypFBMGhygoo62zCAXrnQ3OIKGCCgMAk8apTOUAO5e5SIm1IhplCMqE12qXSATmCbiqnBd7fSRZBUC1CRJ3SntBFYLYiB6NC9b1lIiktwPISd0ZSYmBHKnnigKQPGtIJAMaQbLUk/PVqrL2TSgoFJxa6XE0XY8Z/L6z/@7sFaiNEHnJ2PBg@6id5QftvfNZyPlfxj3GB295eMbVBGwKgj1Wt48yjEbHNtEe0QfMcrl32rYtMT694PQudhEXzjQoQ4MKC5q15SpUSylNfdM08tCNWXa10Xl1a@bD/WafDvW@qXWTv5WcY2JL0vcRDyOpDCXtqSfaLp0NZA6@ncc4jXeqoPTL3PQsg/M8S4Y14W9KCj/4dwpFMbXymiMpEoa/YeGrm@Uh1toncgJfURE/JwYueEFlBcWoDxg2nL7C9dwgbsX7Lj7rFo@d@bBgiwbJgyqXTV9@0uSXDM4juezv4v179i5OgJ9/x3ox89JkaDSn/w "JavaScript (Node.js) – Try It Online")
### (Please see the TIO Link for all test cases, including mirrored version)
### Although further golfed, size `22x22 -> 21x21` on credit of @JoKing!
Size ~~38x38~~ ~~24x24~~ ~~22x22~~ ~~21x21~~ ~~18x18~~ ~~17x17~~ 16x16, 4-fold symmetry.
Here comes a question -- is it possible to have 15x15 or smaller for JS? It seems that what I need at least is the comment separator between two sub-blocks and at the edge, so at least 7+2+2+5=16 lines?
[Answer]
# [Klein (211)](https://github.com/Wheatwizard/Klein), 37 bytes
```
!\"left"@"thgir"\!
!/............../!
```
This has a different program for each rotation.
## Explanation
Note that each of these programs is padded to a square with no-ops before execution
### No change
```
!\"left"@"thgir"\!
!/............../!
```
[Try it online!](https://tio.run/##y85Jzcz7/18xRiknNa1EyUGpJCM9s0gpRpFLUV8PBegr/v//38jQ8L@uIwA "Klein – Try It Online")
`!` makes execution jump over the `\` and `"left"@` loads the string `"left"` into the stack and terminates the program printing the stack
### Quarter turn
```
!!...IP->
\/
".
r.
i.
g.
h.
t.
".
@.
".
t.
f.
e.
l.
".
\/
!!
^
|
P
I
```
[Try it online!](https://tio.run/##y85Jzcz7/19RkStGn0tJj6tIjytTjytdjytDj6tEDyTiACaB7DQ9rlQ9rhwwF6hYUfH///@6jv@NDA0B)
Execution runs off the top right corner of the square, continues in the bottom left corner and once again `!\"left"@` prints `"left`.
### Half turn
```
                ^
                |
                P
                I
!/............../!
!\"right"@"tfel"\!
..................
..................
..................
..................
..................
..................
..................
..................
..................
..................
..................
..................
................^.
................|.
IP->............P.
................I.
```
[Try it online!](https://tio.run/##y85Jzcz7/19RXw8F6CtyKcYoFWWmZ5QoOSiVpKXmKMUo/v//X9fxv5GhIQA)
Here, the execution path exits from the North side, re-enters through the West side, exits again from the East Before entering in the south. `\` bounces the path into `"left"@` to print it.
### Three-quarter turn
```
!!..IP->
/\
."
.l
.e
.f
.t
."
.@
."
.t
.h
.g
.i
.r
."
/\
!!
^
|
I
P
```
[Try it online](https://tio.run/##y85Jzcz7/19RkUs/hktPiUsvh0svlUsvjUuvBMx1AJNAdgaXXjqXXiaXXhFIBKhYUfH///@6jv@NDA0B)
Execution exits from the top right corner then re-enters in the bottom left. Once again the mirrors `/\` redirect the path into `"left"@` to print it.
### Reflection
```
!\"right"@"tfel"\!
!/............../!
```
This is essentialy the same as for left in all rotations.
[Answer]
# [Canvas](https://github.com/dzaima/Canvas), ~~109~~ ~~89~~ 71 [bytes](https://github.com/dzaima/Canvas/blob/master/files/chartable.md)
```
（tfel⁸（（
（h（right
⁸g   q（f
li    re
er    il
f（    g⁸
thgir（h（
（（⁸left（
```
[Try it here](https://dzaima.github.io/Canvas/?u=JXVGRjA4dGZlbCV1MjA3OCV1RkYwOCV1RkYwOCUwQSV1RkYwOGgldUZGMDhyaWdodCUwQSV1MjA3OGclMjAlMjAlMjBxJXVGRjA4ZiUwQWxpJTIwJTIwJTIwJTIwcmUlMEFlciUyMCUyMCUyMCUyMGlsJTBBZiV1RkYwOCUyMCUyMCUyMCUyMGcldTIwNzglMEF0aGdpciV1RkYwOGgldUZGMDglMEEldUZGMDgldUZGMDgldTIwNzhsZWZ0JXVGRjA4,v=8) | [Try reversed!](https://dzaima.github.io/Canvas/?u=JXVGRjA4JXVGRjA4JXUyMDc4bGVmdCV1RkYwOCUwQXRoZ2lyJXVGRjA4aCV1RkYwOCUwQWYldUZGMDglMjAlMjAlMjAlMjBnJXUyMDc4JTBBZXIlMjAlMjAlMjAlMjBpbCUwQWxpJTIwJTIwJTIwJTIwcmUlMEEldTIwNzhnJTIwJTIwJTIwJTIwJXVGRjA4ZiUwQSV1RkYwOGgldUZGMDhyaWdodCUwQSV1RkYwOHRmZWwldTIwNzgldUZGMDgldUZGMDg_,v=8) Those are the only two possible programs, as the program is rotationally symmetric.
Made in [this](https://dzaima.github.io/Canvas/?u=JXVGRjM3SSV1RkYwMyV1RkYxOCV1RkYxOCUyMCV1MjU0QiV1RkYxQSV1RkYxMyV1MjdGMyV1RkY0RSV1RkYxQSV1RkYxMiV1MjdGMyV1RkY0RXJlc3VsdC52YWx1ZSUzRHAucCV1RkYwMyV1RkY1RA__,i=JTIwJTBBJTBBJTBBJTBBJTBBJTBBJTIwJTIwJXVGRjA4cmlnaHQlMEEldUZGMDh0ZmVsJXUyMDc4JXVGRjA4,v=8).
[Answer]
# [Gol><>](https://github.com/Sp3000/Golfish), 23 bytes
```
\"thgir"H /
\"tfel"H.9\
```
[Try it online!](https://tio.run/##S8/PScsszvj/P0apJCM9s0jJQ0GfC8hOS81R8tCzjPn/HwA "Gol><> – Try It Online")
This is the same format as [my Klein answer](https://codegolf.stackexchange.com/a/172024/76162), but 2 bytes shorter. Maybe there's another 2D language out there that can golf those last 2 bytes off... But for now, this is as short as it gets.
[Answer]
# [Ruby](https://www.ruby-lang.org/), 131 bytes
```
#######:$:#
:right#l>r#
$><<###e<i#
:left##f<g#
####   t#h#
#t##   ##t#
#h#t   ####
#g<f##tfel:
#i<e###<<>$
#r>l#thgir:
#:$:#######
```
[Try it online!](https://tio.run/##JY1LCgAhDEP3PYUQTyHFwwz4A1els5jTO1Gz6esjEHufby3cpJggyUbrjpkNErMqfdFBP0t1oGqD7HIIwdHJfhi8wt8Pg9y0UtYyk2BooVPNUWB5wnsbRr8Xb9b6AQ "Ruby – Try It Online")
[Answer]
# [Hexagony](https://github.com/m-ender/hexagony), 98 bytes
```
\[[email protected]](/cdn-cgi/l/email-protection);./r.
.)@.;...;.
ll..)gt.;$
;.i<;;;i);
e;@.)@e;.l
.;e;d.g|.|
rt/;t.;)g\
@f.#l.;..r
\.;\.;i\.i
```
[Try it online!](https://tio.run/##FYwxCsQgFAX7f41sYzM5wNvCg9gE4hpBNiAWCXh3Y2CmG@aI15bO/z1GwNPEWjGcRzC1UsClhj4m8ldSdrIoP5soiqGondTpVtuqWboUzP9YyvuoFtAkB/IYDw "Hexagony – Try It Online") | [Rotated 90°](https://tio.run/##DckxCkIxEEXRfrahzTT3L@BZzEKmEYwxEBRCCoW/95j2nFf53uvn/VsrY1DUSeM5Jbpj4ijRiLC8bLoBRp8Pl2vuhVBF1qRaNPcmfqrBYVDBpWFt5Nl1hbX@ "Hexagony – Try It Online") | [Rotated 180°](https://tio.run/##FYwxCsQgFAX7f41sYzM5wNvCg9gE4hpBNiAWCXh3Y2DKmTnitaXzf4@RCVmEiVUQZeHnLSQnmtZWrdMTu6KwgqJ3eEWTy5K@GdlnmslBKTb79zEdo66o4QljPA "Hexagony – Try It Online") | [Rotated 270°](https://tio.run/##DckxCkIxEEXRfrahzTT3L@BZzEKmEYwxEBRCCoW/95j2nFf53uvn/VsLrupnjmZDcqhgBzSdThpMlSo1E1UByKZc/pidvdyQLmkRtCjHXrxvmk8s6SqMyLX@ "Hexagony – Try It Online")  
[Reversed](https://tio.run/##FYsxCsQgFAX7f41sYzM5wNvCg9gE4hpBNiAWCXh3Y@BNNfOOeG3p/N9jUFfU8ARDMPEO@4iWHJRiclnSNyMrKE7rFa3TE7uisJDcrLW2avX9l4Wft0zIIsyN8QA "Hexagony – Try It Online") | [Rotated 90° & Reversed](https://tio.run/##FckxCgIxEIbRfq6hTZpvD/BbzEGmEYzZQHAhpFhh7x5j@96ez2c5Pt85g6ZM9zBSQxpvzJ3qeUMGPBbewoaS0ms0TBT5iv8O5SJV26DqSoR1KUGBtXe1K3qd8wc "Hexagony – Try It Online") | [Rotated 180° & Reversed](https://tio.run/##FYsxCsQgFAX7f41sYzM5wNvCg9gE4hpBNiAWCXh3Y@BNNfOOeG3p/N9jBDSXA9n8j6UgqFbbqoZcCoaidlKnW5TH@SiKifyVlJ2sFHBp1h@b9v1PLOBpYq2M8QA "Hexagony – Try It Online") | [Rotated 270° & Reversed](https://tio.run/##HckxCgIxEIbRfq6hzTTfHuC3mINMIxizgaAQUijs3eNi@95ePvf6fn3XaiOPrisYVHBpWOKHGmzWpFo0zxUQqsjo8@FyTcuLxI3/biUaEcZzntgdyxgUdXKtHw "Hexagony – Try It Online")
Hexagony was kind of fun for this challenge, because a rotation or a reversal can drastically change the actual program. Each Rotation/Reversal is its own unique program. Some of the program execution paths are much more interesting than others. 
I will admit that coming up with this took longer than it probably should have. I am pretty sure a shorter answer can be done in Hexagony, so good luck!
[Answer]
# [APL (dzaima/APL)](https://github.com/dzaima/APL), 181 bytes
The program has rotational symmetry so only two cases need to be checked
---
## Left
```
⍝⍝⍝⍝⍝⍝⍝  t⎕t⍝
t←'lef'⍝ ←←←⍝
⎕←t,     't'⍝
t←'righ'⍝r,l⍝
   ⍝     i e⍝
 ⍝ '     g f⍝
⍝' h     h '⍝
⍝f g     t ⍝ 
⍝e i     ⍝   
⍝l,r⍝'hgir'←t
⍝'t'     ,t←⎕
⍝←←← ⍝'fel'←t
⍝t⎕t  ⍝⍝⍝⍝⍝⍝⍝
```
[Try it online!](https://tio.run/##ZY87DgIxDER7TuHOTThUJPKTjIQiVxyAbhEN5V4uFwkes0qzlgvneTyaxIdcb8/Y7nHOse3nJtLx/qpNFx2vD0vKDGzz0bYxhU0aCMXKS91bqXj1IGC2dUurRskJ3uykUHavbWeqTirxQbJtUep6kGQOtPxAJHTc1tI6I4076d87II2lBFvJccs5yVL7T93y3HP@AA "APL (dzaima/APL) – Try It Online")
## Right
```
⍝t⎕t  ⍝⍝⍝⍝⍝⍝⍝
⍝←←← ⍝'fel'←t
⍝'t'     ,t←⎕
⍝l,r⍝'hgir'←t
⍝e i     ⍝   
⍝f g     t ⍝ 
⍝' h     h '⍝
 ⍝ '     g f⍝
   ⍝     i e⍝
t←'righ'⍝r,l⍝
⎕←t,     't'⍝
t←'lef'⍝ ←←←⍝
⍝⍝⍝⍝⍝⍝⍝  t⎕t⍝
```
[Try it online!](https://tio.run/##ZZA5DgMhDEX7nMKdG3IopLBJRIqQqzlAuqA0lLncXIT4ezQ0gywwz98L@Fe9PzZfnn7O/fOTvQ8hUu9qNxzv72GQcAyV1RdEWJiwnEDQB1h1DZGcSlu6QMV06uoOEikZEWNWi7KRTIy@xo/qiaKRM5@0WgBBV24lZWQ0V23ePtDVmU7nW7oaIi60XnO@7mI6FX5EvTn/ "APL (dzaima/APL) – Try It Online")
## Explanation
This is my first APL program so it is pretty simple. It only uses one trick that I think is interesting.
If we start by stripping away all the comments we get the following programs
**Left**
```
t←'lef'
⎕←t,     't'
t←'righ'
```
**Right**
```
t←'righ'
⎕←t,     't'
t←'lef'
```
Starting from the left program we do three things.
1. Assign `'lef'` to the variable `t`
2. Print the variable `t` and the letter `'t'`
3. Assign `'righ'` to the variable `t`
Now because it is the mirror the right program does these three steps but in the opposite order. This means that we print `'left'` for the left program and `'right'` for the right program.
The one trick here is that the `'t'` actually comes from a rotated copy of the code. If you look at the third colum of our code you will see that it is `'t'`. We reuse this `'t'` in the rotated versions to append the `t` that is needed.
[Answer]
# [Alice](https://github.com/m-ender/alice), 25 bytes
```
}/"regttoo {
{/"lifh""@@{
```
Left: [Normal](https://tio.run/##S8zJTE79/79WX6koNb2kJD9foZqrWl8pJzMtQ0nJwaH6/38A "Alice – Try It Online"), [1/4 turn clockwise](https://tio.run/##S8zJTE79/7@6lktfn0tJiSuniCszlSstnSujhEsJiPK5HIBIgau6@v9/AA "Alice – Try It Online"), [1/2 turn](https://tio.run/##S8zJTE79/7/awUFJKSMtM0dJv5qrWiE/v6QkPbVISb/2/38A "Alice – Try It Online"), [1/4 turn counterclockwise](https://tio.run/##S8zJTE79/79WX6koNb2kJD9foZqrWl8pJzMtQ0nJwaH6/38A "Alice – Try It Online")
Right: reflect across [horizontal axis](https://tio.run/##S8zJTE79/79aIT@/pCQ9tUhJv5ar2sFBSSkjLTNHSb/6/38A "Alice – Try It Online"), [down-right diagonal](https://tio.run/##S8zJTE79/7@2mktfn0tJiasohys1kys9jaskg6tEiSsfiBy4FBy4qqv//wcA "Alice – Try It Online"), [vertical axis](https://tio.run/##S8zJTE79/79aXyknMy1DScnBoZqrVl@pKDW9pCQ/X6H6/38A "Alice – Try It Online"), [up-right diagonal](https://tio.run/##S8zJTE79/7@6mstBgcshn0sJiEq4Mkq40tK5MlO5coq4lJS49PW5qmv//wcA "Alice – Try It Online")
## Explanation
This program has three parts. The first part is the three `{`s and one `}` on the corners. The `{` turn the IP left until it reaches the `}`, at which point it turns right. In the reflected version, the IP goes along the top row in the original program. In the original version, turning right will immediately hit the adjacent `{`, pointing the IP along the bottom row in the original program.
Next are the two slashes in the second column. If the program is horizontally oriented, either type of slash would simply change to ordinal mode, sending the IP in the same left/right direction it was already going. If the program is vertically oriented, the IP bounces around quite a bit more, but making them both forward slashes gives the same end result. (Two backslashes would give the opposite result, and one of each would create an infinite loop.)
The rest of the program is straightforward. The IP in ordinal mode bounces diagonally, so either `"left"o@` or `"right"o@` will be run depending on how this section was entered.
[Answer]
# [Haskell](https://www.haskell.org/), ~~461~~ 379 bytes
*82 bytes saved by [Ørjan Johansen](https://codegolf.stackexchange.com/users/66041/%c3%98rjan-johansen)*
```
--_----------mppr--
-- ----------a  l--
rl=p  p--   niam= _
p m="left"-- n==p--
p a="right"++ "" --
main  =putStr rl --
--n +r       =iep--
-- -+t       pgf---
-- -"S       uht---
-- "tt       tt" --
---thu       S"- --
---fgp       t+- --
--pei=       r+ n--
-- lr rtStup=  niam
-- "" ++"thgir"=a p
--p==n --"tfel"=m p
_ =main   --p  p=lr
--l  a---------- --
--rppm----------_--
```
[Try it online!](https://tio.run/##RdDLrcQgDAXQfaq48hZRgqtIARELkqAxyOI59Wc8A/Pi5cH4d6a/Vxa57xi3@B9Vtce4xIjHEiBuXVgB9SeglVQZ26KoTJJ3I@fG7K9uiamX4zQKAUReaampNID1stU6uuDboyF0jOCSdfYNNk2PPU6jddp12jSyX54ZjXrRzmvaSnHafugvL0zTXHhaD2ijnvhcPt2lPNb79iCEQHYepRMn6Ocvc/MqZHsW4uq2gcd6zp8DsXTPEyA9Jxx9u2p9zK9@328 "Haskell – Try It Online")
Since this one has 4-fold symmetry you only need to test the mirror:
```
--rppm----------_--
--l  a---------- --
_ =main   --p  p=lr
--p==n --"tfel"=m p
-- "" ++"thgir"=a p
-- lr rtStup=  niam
--pei=       r+ n--
---fgp       t+- --
---thu       S"- --
-- "tt       tt" --
-- -"S       uht---
-- -+t       pgf---
--n +r       =iep--
main  =putStr rl --
p a="right"++ "" --
p m="left"-- n==p--
rl=p  p--   niam= _
-- ----------a  l--
--_----------mppr--
```
[Try it online!](https://tio.run/##RdBBrsQgCAbg/ZziD1vDEThFD9C4sK0ZNcRHz99HrTPDji8g4BH/3qmU62LuqpW/sTK/mAsQfwa3FVJjboAnCqiU7nUq0hzItlRIKtQNRAiB7NhzJ4mPlY5ui50qQMux3r0pezKiB7Qxl7ddp1kYc93sOKctNA1k9qkzmsa0TDsP42nhU6f79lhD6NMkJ3V7DhM9fUPfs9zvKaJQz/thFMJ90rAqVNJm5C83kbu3F7m/w@E5TLCOud@IQBlz159V1c58Xf8 "Haskell – Try It Online")
This is a start. It is far from ideal, but there are a few interesting things going on here. Haskell is a certainly an interesting language for this challenge. I look forward to an answer that beats this be it mine or someone else's. 
[Answer]
# [Python 2](https://docs.python.org/2/), 209 bytes (14 x 14)
Normal (left):
```
##########sps#
s="left"##=r=#
print s###"i"#
s="right"#rnl#
####      ite#
###"      g f#
#"#t      hst#
#tsh      t#"#
#f g      "###
#eti      ####
#lnr#"thgir"=s
#"i"###s tnirp
#=r=##"tfel"=s
#sps##########
```
[Try it online!](https://tio.run/##PY5LCkQxCAT3niLoDWaf4@QjBCeomzl9xmfg9a4opXv/fH7lcw69sW0EVnG17khUtRJsZfFiYZExrfKYoVUWwfNVMuwtES@O0gOR/OI0D3SbFz0MUI@rTHQFNueLlLhECX0OVqwG2R4LiwvrhtwWureV9ln@5pw/ "Python 2 – Try It Online")
Reflected (right):
```
#sps##########
#=r=##"tfel"=s
#"i"###s tnirp
#lnr#"thgir"=s
#eti      ####
#f g      "###
#tsh      t#"#
#"#t      hst#
###"      g f#
####      ite#
s="right"#rnl#
print s###"i"#
s="left"##=r=#
##########sps#
```
[Try it online!](https://tio.run/##Rc9LDgQhCATQvacw1A1673H8kBjHAJs5vaOS9LB7VAzl/Fr7jGct6FS8E5AkAWQld0oaQEx7rdEGywzoQ3bYKstNs3G8429LrE66NG1OA20SzNnUNvcVZ43lEk62jKCJhGszgoyOMIWHxdPz9Dlpz2WHt2341z9/WesH "Python 2 – Try It Online")
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), 55 bytes
```
####‛‛#
‛⟑ǒ#¬⟑#
‛¬ẋ#ẋǒ#
#######
#ǒẋ#ẋ¬‛
#⟑¬#ǒ⟑‛
#‛‛####
```
[Try it Online!](https://lyxal.pythonanywhere.com?flags=&code=%23%23%23%23%E2%80%9B%E2%80%9B%23%0A%E2%80%9B%E2%9F%91%C7%92%23%C2%AC%E2%9F%91%23%0A%E2%80%9B%C2%AC%E1%BA%8B%23%E1%BA%8B%C7%92%23%0A%23%23%23%23%23%23%23%0A%23%C7%92%E1%BA%8B%23%E1%BA%8B%C2%AC%E2%80%9B%0A%23%E2%9F%91%C2%AC%23%C7%92%E2%9F%91%E2%80%9B%0A%23%E2%80%9B%E2%80%9B%23%23%23%23&inputs=&header=&footer=) | [Try it flipped](https://lyxal.pythonanywhere.com?flags=&code=%23%E2%80%9B%E2%80%9B%23%23%23%23%0A%23%E2%9F%91%C2%AC%23%C7%92%E2%9F%91%E2%80%9B%0A%23%C7%92%E1%BA%8B%23%E1%BA%8B%C2%AC%E2%80%9B%0A%23%23%23%23%23%23%23%0A%E2%80%9B%C2%AC%E1%BA%8B%23%E1%BA%8B%C7%92%23%0A%E2%80%9B%E2%9F%91%C7%92%23%C2%AC%E2%9F%91%23%0A%23%23%23%23%E2%80%9B%E2%80%9B%23&inputs=&header=&footer=)
The code is rotationally symetrical.
[Answer]
# [Prolog (SWI)](http://www.swi-prolog.org), ~~649~~ 188 bytes
### Unflipped, Unrotated
```
:-%    l :%r     %-:
write(%e%-(i %(etirw
left).%f.weg%.)right
%      t)rth.      %
%      )tiit)      %
%      .htr)t      %
right).%gew.f%.)left
write(% i(-%e%(etirw
:-%     r%: l    %-:
```
[Try it online!](https://tio.run/##XY5LCgUhDAT3niKbgFmYA3ifqAFhHnkBj@84HzeTVdOQrvrZ0Y@a/kPnzAlhXYeMdgXAlMMwdYkomKICRnG1EboUJ8bCQyoymdbm4X4GcDJv/GTcJbmq06fk5ka@y3tkjVYZXNboxdh00JiWwkt/PcEwL9nHc84T "Prolog (SWI) – Try It Online")
### Unflipped, Rotated
```
:wr%%%lw:
-ri   er-
%ig   fi%
 th   tt 
 et   )e 
 ()   .( 
 %.   %% 
  %.)tfel
right).% 
%(etirw-:
:-write(%
 %.)thgir
left).%  
 %%   .% 
 (.   )( 
 e)   re 
 tl   it 
%ie   gi%
-rf   hr-
:wt%%%tw:
```
[Try it online!](https://tio.run/##Hc4xCkQxCATQ3lOkEZIi/wC5j0mEwC6u4PGz4@8eIjPztc/5rP4LvXeEMfOJQd20lCLWiXVBU5mKb8i9UBGHmkC1QU@F@IGYIbD5lEOma3t7cOMqrhZ90Ohh6lKZ3re91OjIfN8yhTMvU2rmtUyW7LBs8wMpFrAKtLCq24Q2lo5wrPcY9/4B "Prolog (SWI) – Try It Online")
### Flipped, Unrotated
```
:-%     r%: l    %-:
write(% i(-%e%(etirw
right).%gew.f%.)left
%      .htr)t      %
%      )tiit)      %
%      t)rth.      %
left).%f.weg%.)right
write(%e%-(i %(etirw
:-%    l :%r     %-:
```
[Try it online!](https://tio.run/##XY5BCsUgDET3niKbgFmYA3ifqAGhJT/g8f21rZtmNTzIvDnt6EdNv6Fz5oSwzjBDXwFTDsPUJSJoTCgYxdVGMK3NibHK4IJMXYqH5xm4uZE/GTckV3X6QCfzxhuujquy8JB6Vd6KbRdMUWHb350dMhq8O@f8Aw "Prolog (SWI) – Try It Online")
## Flipped, Rotated
```
:wl%%%rw:
-re   ir-
%if   gi%
 tt   ht 
 e)   te 
 (.   )( 
 %%   .% 
left).%  
 %.)thgir
:-write(%
%(etirw-:
right).% 
  %.)tfel
 %.   %% 
 ()   .( 
 er   )e 
 ti   lt 
%ig   ei%
-rh   fr-
:wt%%%tw:
```
[Try it online!](https://tio.run/##Hc5BCkUhCAXQuatwItSgFtB@rITgPfxCy@/f3uwg6r2vP@sZ5bftnLaXiPhuVFyZ2byQWIeGCXEENIOJNUOhUKpQTpAIVIVpaY8M3FnNMYc5tbLdQpOQJA3zXRq5jfktEn@LXde9wBe5s3Qz6v2sfjNuWhi00EBsQIpWxSfU0bTtQPvY7Zw/ "Prolog (SWI) – Try It Online")
[Answer]
# [Prolog (SWI)](http://www.swi-prolog.org), ~~239~~ ~~223~~ ~~209~~ 181 bytes
```
%%%%%%%  l:r%
right).% e-i%
:-write(%fwg%
left).%  trh%
  %      )it%
 %(      .t)%
%.e%     %e.%
%)t.      (%
%ti)      %
%hrt  %.)tfel
%gwf%(etirw-:
%i-e %.)thgir
%r:l  %%%%%%%
```
[Try it online!](https://tio.run/##JYpBCgQhDATveYWXBnPQB/ifqAFhlmzA57vZsS7povKxZz2jfLeeg0tKqxnIdEzniiRFQa1sU5eMvgdoSX9TcpuglGL9YfUw5GvVGYQqN0JqGHu9MYe48pXY0zxuZe@yCGN3ZHG1XRpBi7xpDjWCtRWfl3PODw "Prolog (SWI) – Try It Online")
Since the program has 4 fold symmetry you only need to check the mirror:
```
%r:l  %%%%%%%
%i-e %.)thgir
%gwf%(etirw-:
%hrt  %.)tfel
%ti)      %  
%)t.      (% 
%.e%     %e.%
 %(      .t)%
  %      )it%
left).%  trh%
:-write(%fwg%
right).% e-i%
%%%%%%%  l:r%
```
[Try it online!](https://tio.run/##JY5BCgQhDATveUUuDXrQB/ifqAFhhmzA57syqVt1Xfq1Zz2j/LaeA2uLGQFBizBq9jnUCGN3JHG1XRphmvMXuyyCa@YPMBOy17CEa1UQSSqIkSJVz9c4Emd10JLuud7FbYJa2aYuCX0PkOmYX5Si91nAvJrhnD8 "Prolog (SWI) – Try It Online")
[Answer]
# [Clean](https://github.com/Ourous/curated-clean-linux), ~~1331~~ 1055 bytes
*-276 bytes thanks to [Ørjan Johansen](https://codegolf.stackexchange.com/users/66041/%C3%98rjan-johansen)*
```
// ////////////;/;/////////// //
// ////////////S/S/////////// //
  module m////mtmt////m eludom  
//o///////////=a=a///////////o//
//d///////////"r"r///////////d//
//u///////////tttt///////////u//
//l///////////f#h#///////////l//
//e///////////emgm///////////e//
// ///////////loio/////////// //
//m///////////"drd///////////m//
//////////////=u"u//////////////
//////////////ml=l//////////////
//////////////#eme//////////////
////////////// =#=//////////////
;Start#module= 0   #m="left"=m//
//m="thgir"=m#   0=eludom#tratS;
;Start#module=0   #m="right"=m//
//m="tfel"=m#   0 =eludom#tratS;
//////////////=#= //////////////
//////////////eme#//////////////
//////////////l=lm//////////////
//////////////u"u=//////////////
//m///////////drd"///////////m//
// ///////////oiol/////////// //
//e///////////mgme///////////e//
//l///////////#h#f///////////l//
//u///////////tttt///////////u//
//d///////////r"r"///////////d//
//o///////////a=a=///////////o//
  module m////tmtm////m eludom  
// ///////////S/S//////////// //
// ///////////;/;//////////// //
```
[Try "left" online!](https://tio.run/##hVNNa8MwDL3nVwj73Kb3osEYhR32cegPGG7jNAErLq4N@/eZmlKq2FsmH2LJT4otvXcwl24cjybCE9C6P7rKfp99iPDytnv@@Hr9fN9h7c@xPjprhuqxrQ/9wDuCFV1gNUSgal2btU9xHOsaamFbXg/joyoD7HnNAQDkm@Qs0DVCkeL0BetS4wmAK3iRggaNcP30i0ZEVFBBuM0ESCIS2YSbJoATkVZ3WrhuAlgRsXQi6RbPdL73RR9kimqCvDNNAGmYVJpHMgA5dIsAbckuAgA1ZoDtPpoQ9W0gCBsA0ITK2TYqvF2S3did@sC@5uMN3uakYzBxv80q3AuE/tTNKrTW3QtAViHrg0ZYfAW/Ui8CuE@0COBOYwGQKTwrVQxL3oqn7Ypxy@YzX2xBGJnCjGsLyv1LWkkhZr0qaC9JyLrBTDhz6bHyqJAe/KndX9Q9V//16Ac "Bash – Try It Online")
[Try "right" online!](https://tio.run/##hVPBasMwDL3nK0R8bt178WCMwg7ddugHDLdxmoAVF1eG/X2mpbSVY8jkQyz5WZGl94722o3jyRK8AK77k6/czyVEgrf97vXz@/3rY2d0uJA@eWeH6rnVx37gHcIKr7AaCLBaa7sOicZRa9BP2/ISxkdVDjjwmgEAMDTJO8C/CCFNXwTnUxMQgDMEccUaa4Qbpl80IhLrWAu3mQBJRIhNuGkCeBFRnWqF6yeAExE8o3Rd8czQB1/0AWVVsZFF4gSQlupk8sgM4I3HRYBDpxYBRhkoAGhqap2vDSoA2IC5jUFRtHTYVtsD2UjqNjGzYYjiG7E/d8RXHhm6cx/vKRYzwD2Fd@0jQ8YQrnLxFcplsygByJ1a7gP3uuyDcGueVjEs2TrP8y7GnTGEGVMQRlbVMucKyv1LWlkVsz4WtJdVsW7sTDi59Fh5VEgvY0iu3lLdM/3z0S8 "Bash – Try It Online")
This was difficult for many reasons:
* Clean *requires* a file header `module <filename>` be present at the start, *and only the start* of the file. Unfortunately, this means that for the rotations of the mirrored program to be valid it also has to appear at the bottom of the file. To make this worse, `module ..` is invalid for global, `let .. in`, `where ..` and `with ..` definitions; and the token `module` appearing if it hasn't been defined causes an error.
* Both block comments and line comments nest: `/* /* */` leaves one level of comment open, and so does `/* // */` (as well as commenting the rest of the line out).
* The same function can be defined multiple times, but only directly after itself.
Fortunately, we *can* define `module` as something in a `#..` (let-before) expression, which is all we need. Because Clean doesn't type-check alternatives that are never used (and a variety of other equally unused things), the requisite second definition of `Start` can be complete garbage. This allows us to use the second `Start` to consume the module header at the bottom of the file because Clean treats `m module m` as calling the function `m` on `module` and `m` (which since we've defined `module` and `m`, doesn't cause an error). It doesn't matter that `m` is a string and not a function, because the `Start` alternative never gets type-checked.
This is easier to see if you look at it through the compiler's eyes:
```
module m;
Start#module=0#m="left"=m;
Start#module=0#m="right"=m module m
```
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), 341 bytes
```
Ẹw"thgir"∧"left"wẸ
w"              "w
"                "
t                t
f                h
e                g
l                i
"                r
∧                "
"                ∧
r                "
i                l
g                e
h                f
t                t
"                "
w"              "w
Ẹw"tfel"∧"right"wẸ
```
[Try it online!](https://tio.run/##bdDBCcMwDAXQ@5@iaIRu1ARbMggKwmCyQTbpCiHbtIs4pj5Fto6Pjy39xV6rbPrmZ63f8yiUhZPRb/@QhpipNEShx22owEkzZE8Z0ZMgeGKopzQ@b2grjX8OuZaCjbnkScGeAsRTnB01OX1SUC8zBv13aYmll1nrBQ "Brachylog – Try It Online")
[!enilno ti yrT](https://tio.run/##jdDBCcMwDAXQ@5@iaIRs1BRbMggKwmCyQTbJCiHbtIs4pjlV9iECXx7G1v@zPV@y6JunWj/HXijHoPRdN7LEkqk0RKHH31CBk2bInjLEUwR7CkieFNY/3/3YlkQ7N24a1FNC8MSInmQUahB9UNBVpnCyX5sa4lVmrSc)
Takes advantage of Brachylog taking the main predicate to be the one on the first line and not much caring about the other lines beyond requiring that they can compile. Unreflected, it prints an empty string followed by "left" on the same line, and reflected it prints an empty string followed by "right" on the same line. I'm tempted to think there might be a way to make a (usefully) non-square version using `ṇ`, but that might be plenty tricky without trying to make it work differently under reflection.
[Answer]
# [Ruby](https://www.ruby-lang.org/), 181 bytes
```
#########tpt#
t=:left##=u=#
puts t###:t:#
t=:right#rsl#
####     i e#
###t     gtf#
#t#h     h#t#
#ftg     t###
#e i     ####
#lsr#thgir:=t
#:t:###t stup
#=u=##tfel:=t
#tpt#########
```
[Try it online!](https://tio.run/##NY5LCgAhDEP3PYWQWwheZsAfuJAaF3N6xxYmqz5C0uh@3nPwi5MQpjhyIZB2gszNFS4gMrqnvTZC14BYJJh6yE50qiyXiObU7iUorE7WJMg3YYLTWAq22jUmiv@xpsU9xTeAJQ/3bN@vcz4 "Ruby – Try It Online")
This is a port of Curtis Bechtel's Python answer to Ruby, golfed a little more.
Actually, his Python program is a polyglot and runs on Ruby too, so my first answer was a copy-paste of it, but it seemed unfair. So I wrote a script that generates a new answer starting from a base script. You can try it here:
[Build your own](https://tio.run/##dY/NDsIgDIDvPMWSLbJJhibOixlPYjygQTeDkxT2qz77BEVjNPYApd/XpkC97ceO5TmnWsnSBNFsDF@BDFtJsTc2U7XRgfE1KA@FCUeOUM86euIqnqx2BQedUAO80uqshS8fz2WV@BxEI0CLBA22yz@@Ucv6fwhJFsdzShePeZcrv3ZrviG9PW7EgewNWgdw4AI7gWReWXwqZLkhg@u2sx//k88Lp2mKkWi4DOQ0miEETL6WehrwI4IVxzs)
[Answer]
# [05AB1E (legacy)](https://github.com/Adriandmen/05AB1E/wiki/Commands), ~~89~~ 55 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
'…¸q©ƒ'
ƒ     …
©     ¸
q     q
¸     ©
…     ƒ
'ƒ©q¸…'
```
Very basic approach. Outputs in full lowercase.
[Try it online](https://tio.run/##MzBNTDJM/f9f/VHDskM7Cg@tPDZJnevYJAUQAApxHVoJZh7awVUIZhRyHdoBEVnJBZQHM49N4lI/NunQysJDO4BC6v//AwA) or [try it online reflected](https://tio.run/##MzBNTDJM/f9f/dikQysLD@141LBMnQtIKIDAsUlch3aAWYdWchWCGYVch1ZCRHZwHZsEZgFVc6kDiUM7Cg@tPDZJ/f9/AA) (each rotation is the same).
**Explanation:**
```
'…¸   '# Push the dictionary string "left" to the stack
   q   # Stop the program (and output the top of the stack implicitly)
       # Everything else after it is ignored
```
Reversed:
```
'ƒ©   '# Push the dictionary string "right" to the stack
   q   # Stop the program (and output the top of the stack implicitly)
       # Everything else after it is ignored
```
[See this 05AB1E tip of mine (section *How to use the dictionary?*)](https://codegolf.stackexchange.com/a/166851/52210) to understand why `'…¸` is `"left"` and `'ƒ©` is `"right"`.
[Answer]
# [Stax](https://github.com/tomtheisen/stax), 131 bytes
```
 .Cq"tfel" 
""`KT?`qC".
lC       `C
eq       Kq
f`       T"
t?       ?t
"T       `f
qK       qe
C`       Cl
."Cq`?TK`""
 "left"qC. 
```
[Run and debug it](https://staxlang.xyz/#c=+.Cq%22tfel%22+%0A%22%22%60KT%3F%60qC%22.%0AlC+++++++%60C%0Aeq+++++++Kq%0Af%60+++++++T%22%0At%3F+++++++%3Ft%0A%22T+++++++%60f%0AqK+++++++qe%0AC%60+++++++Cl%0A.%22Cq%60%3FTK%60%22%22%0A+%22left%22qC.+&i=&a=1)
This is the "right" variant.
[Answer]
## Batch, ~~438~~ 321 bytes
```
:::::::::::::@@@:
@echo left&: eee:
@exit/b&:    cxc:
@echo right&:hih:
:  :         oto:
:: &          / :
:& t         rbl:
:t h         i&e:
:f:g         g:f:
:e&i         h t:
:lbr         t &:
: /          & ::
:oto         :  :
:hih:&thgir ohce@
:cxc    :&b/tixe@
:eee :&tfel ohce@
:@@@:::::::::::::
```
Explanation: A `:` is used to indicate a label, which is as good as a comment, so as the program has rotational symmetry the only difference between the two versions is which of the `@` lines is first, in which case either `left` or `right` is output before the script exits.
I did try creatively overlapping the rotated lines with each other but my attempt actually ended up with a larger grid.
Edit: Saved 117 bytes thanks to @ØrjanJohansen.
[Answer]
# [Runic Enchantments](https://github.com/Draco18s/RunicEnchantments/tree/Console), 116 bytes
```
> \ !U\L
 ...@.. 
 \.R""" 
 @""trl 
 "lrhie 
 teiggf 
 ffgiht 
 ethrt" 
 l"t""@ 
 " "R.\ 
 .\@.@. 
DR\!!/R 
     !! 
```
[Try it online!](https://tio.run/##Fcw9CsUwDAPgPaewdQC/G5QMHTsFunkr@YPQIbjnz3M0fQih@b39WesgJb71CiQiUYQCqSQAjgjYHA6M2Xp2WO61FkcptTdzZGvT9njAgLjHhCTqEI3@SOFMyvxL3uww01p/ "Runic Enchantments – Try It Online")
[And reversed](https://tio.run/##Jcw7CkMxDETR3quQZgHKDoKKlK8ypFMX/AOTwuit35HJVKe4zLq/47P3ZW8mo2ciIRURSgQgiwXmckADZfQ1EaitjeIB76PVemJf3UtAAccMmGTQiUVF7RzmB7PlVyJm@m/vHw "Runic Enchantments – Try It Online")
Not exactly a port, but utilized [Post Left Garf Hunter's Klein 000 answer](https://codegolf.stackexchange.com/a/172011/47990) as a starting point, given the typical near-compatibility of the two languages (most commands are the same and the edge wrapping in Runic is identical to Klein 000). The only issue was that Klein IPs always start from the top left and Runic's do not. As such the `.` are all part of the original code and still treated as NOP by Runic, while the  are NOPs I had to add as part of controlling the flow.
Prints `"left"` in all 4 rotations and `"right"` when mirrored (and in all four rotations thereof). Two middle columns were completely unused after my modifications, so I was able to remove them.
In theory a rotation with lots of trailing whitespace could be used for a lower byte count (eg. [this variant](https://tio.run/##PYu5DYAwDAB7TxF7ALMBckFJZYnOHconRRRRmN@kiLj27vr71Nv9BGNqMQ0SY0W4mHrNZRDLhoBCo@TaSRkhsC4nOK@1BbNpbIYpNmKFPfwc7h8 "Runic Enchantments – Try It Online")), however the spaces are needed to correctly rotate the structure using external tools and so I included them.
Below variants contain the unused chunks that were removed, but are otherwise identical:
[All four lefts](https://tio.run/##TZE9jsQgDIV7n8J2P84NRhSTVFQodO5W@UGKtkDs@bOGRUuoDMbPz5/zz3f6um@PjwMqfG17YacSCKJwTsdZWNxEQI7LeaTMQQjBizhel9mz2o2U/bys7EQiAkrohY6qZhdF1ZpT09m3iyUgvEfvD8Lr9bIXRfIU1dtXERWTtCrzw8LMFjpm70q@LOQrz3ymzcKypWU9jt3CfT/WJZ3Fwq2cPOdSyy4uzjO7WoamFaS7aT0QPkEpEk3mqjsi@rNk1v7PGzAMRtWYYh9HFPDByHLxwchyg5HNRg9GQJOTXigRKAxGCs/9@D8/ZqzvC8NE5lrDx0Zpk@ighYMWN1ql0iqN1llp7Y3WUWltjVaqtK5GKw9aPGhh7VEX4jXalmxX7/v@BQ "Runic Enchantments – Try It Online"). Outputs `leftleftleftleft` (the fact that all four can be run like this is coincidence).
[Right 1](https://tio.run/##Jc0rDgMxDARQnlPYPoB7g8qguygo2mVmVX5SVBC5508dddAjMzO/n/5eK@qNEUHhGYBBWJkZAhARU2J1jmkSicSZe6NjDnKWWq@zZ3Na6@dVS9k1mwc1y04himI0nMrJ12DXeD@I7ov0QLxR0ysAIvyz1g8 "Runic Enchantments – Try It Online"), [Right 2](https://tio.run/##TY07CsMwEET7PcVqDjC5QdgidqVK2N12wR@BSSGU8ysyGJzphse8Kd9Pfremf4kSEt1Q1@UAXcLDiLpvuYCzaGBCydteYaE3RxzGCUZG0Zk0TOMQ4Seza5aoou56KbtTE3Esa3f4yV73@7O1Hw "Runic Enchantments – Try It Online"), [Right 3](https://tio.run/##Jc07DsMwDAPQPaeQeAD1BoWGJpMnI9m0Ff4BQQfDPb@rpJzeQrJ/P@09J/3DTMsrGh/Mj0gLiamYqDhBEEQx54mhAVBnGhVrH3DmXPat1eEcqW17KfmqnX1FbcmpQNDRT6dJ9DVcNZH7wS@eZMSBDwtz/gA "Runic Enchantments – Try It Online"), [Right 4](https://tio.run/##TYw7CsMwEET7PcVqDjC5QdgidqVK2N12wR@BSSGU8ysyDiGvGx7zyvuVn63d9cdDRemGui4HmFScxLGsFep@uoSSt73CgkpwxGGcYOSsEknDNA4Rfrre2LdckNjXzO@Ndgu9eSXNmYJE/aO1Dw "Runic Enchantments – Try It Online")
[Answer]
# [Gol><>](https://github.com/Sp3000/Golfish), 342 bytes
```
 8A_          _A8 
9       ""       9
A       LR       A
_       EI       _
        FG        
        TH        
        "T        
         "        
 "TFEL" HH"RIGHT" 
 "THGIR"HH "LEFT" 
        "         
        T"        
        HT        
        GF        
_       IE       _
A       RL       A
9       ""       9
 8A_          _A8  
```
Wow! That took longer than I expected, halfway through I realized the reflection was *vertically*, not horizontally like I had been coding for! I'm pretty sure that this works, but if I made a mistake please let me know. This can most likely be golfed a ridiculous amount more, I just took an extreme brute force method to do so. The shape itself is actually a square, it is technically symmetric, except on across the x-axis, so when it flips, it returns "RIGHT" instead!!!
The character that made this program possible is the 'A', which allows for teleportation to the beginning of a certain line!
[Try it online!](https://tio.run/##bZA7CsQwDER7n0LMKZLShW0ZXBn36fKBQIrcHweCpV1Wq2r0YCRmtutcj3vvnSa/kM7iJ3LzWIAhZueHKnUI78QVsnidXIlJlKLGBqEZRPggtBgKiBk1J254EadcwUwoIb7o1/f1EQax/ZiiIgmUgwaS2LVo7D/l2Aqp9wc "Gol><> – Try It Online")
]