[Question]
  [
## Task
You're in charge of making a compass, of sorts.
Imagine your source code as the compass "needle" where running at different orientations produces distinct output.
Supported source code orientations are North, East, South, and West.
## Example
Let's say you have source code:
```
ABCD
 J K
WXYZ
```
We'll consider this the North orientation, rotating 90 degrees clockwise points us to the East:
```
W A
XJB
Y C
ZKD
```
rotating again points South:
```
ZYXW
K J 
DCBA
```
and finally, the last rotation to the West:
```
DKZ
C Y
BJX
A W
```
When ran, each of the above code examples should output a single, distinct [printable ASCII](http://en.wikipedia.org/wiki/ASCII#ASCII_printable_characters) character of your choosing.
## Notes
Your code shall take no input.
Empty spaces or new lines do not collapse/disappear when rotating.
Leading/trailing new lines are okay in output.
Answers may be whole programs or functions, thus output to STDOUT or return the function result.
Standard [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") rules apply; shortest answer in bytes wins!
  
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 2 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
*2
```
**[Try it online!](https://tio.run/##y0rNyan8/1/L6P9/AA "Jelly – Try It Online")**
Note that the main entry for a Jelly program is its last link, where any newline character will split links), neither of the two-line programs actually access their top link.
The four full programs, all of which implicitly print their result, are:
[North](https://tio.run/##y0rNyan8/1/L6P9/AA "Jelly – Try It Online"):
```
*2   -> (implicit) zero raised to the power of 2 = 0
```
[East](https://tio.run/##y0rNyan8/1@Ly@j/fwA "Jelly – Try It Online"):
```
*
2    -> literal 2 = 2
```
[South](https://tio.run/##y0rNyan8/99I6/9/AA "Jelly – Try It Online"):
```
2*   -> two raised to the power of (implicit) 2 = 4
```
[West](https://tio.run/##y0rNyan8/9@IS@v/fwA "Jelly – Try It Online"):
```
2
*    -> (implicit) zero raised to the power of (implicit) zero = 1
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt), ~~3~~ 2 bytes
```
gy
```
Somehow, *somehow*, I found an extremely hacky 2-byte solution...
---
[North](http://ethproductions.github.io/japt/?v=1.4.5&code=Z3k=&input=) outputs `0`:
```
gy
```
Since there's no implicit input, it defaults to `0`. `g` on a number returns the sign of the number regardless of its arguments (`"y"` in this case).
---
[East](http://ethproductions.github.io/japt/?v=1.4.5&code=Zwp5&input=) outputs `2`:
```
g
y
```
In a multi-line program, the first line sets the input to its result. This is basically a no-op, since `g` on `0` is `0`. Then `y` returns the GCD of `0` and... since it's missing an argument, it defaults to `2` (thanks, [@Oliver](https://chat.stackexchange.com/transcript/message/39035566#39035566)!). This gives `2` as the output.
---
[South](http://ethproductions.github.io/japt/?v=1.4.5&code=eWc=&input=) outputs `g`:
```
yg
```
`y`, as before, is GCD. Since **gcd(0, x)** is **x** for any value, `y` on `0` takes the liberty of just returning its argument. In this case, the argument is `"g"`, which is the result.
---
[West](http://ethproductions.github.io/japt/?v=1.4.5&code=eQpn&input=) outputs `1`:
```
y
g
```
`y` on 0, as before, returns `2`. This is then passed to `g`, which (as already discussed) is the sign function on numbers. Therefore, the result is `1`.
[Answer]
# [Java (OpenJDK 8)](http://openjdk.java.net/), ~~7309~~ ~~4421~~ 855 bytes
-2888 bytes thanks to Leaky Nun  
-3566 bytes thanks to Wheat Wizard 
```
//i/////////////////////////////////////////////////////////////
//n//////////////////////////////////////////////////////////////////
interface M{static void main(String[]a){System.out.println(0);}}/////
//e//}};)2(nltnirp.tuo.metsyS{)a][gnirtS(niam diov citats{M ecafretni
//r//////////////////////////////////////////////////////////////////
//f}/////////////////////////////////////////////////////////////////
//a}//
//c;//
//e)//
// 3//
//M(//
//{n//
//sl//
//tt//
//an//
//ti//
//ir//
//cp//
// .//
//vt//
//ou//
//io//
//d.//
// m//
//me//
//at//
//is//
//ny//
//(S//
//S{//
//t)//
//ra//
//i]//
//n[//
//gg//
//[n//
//]i//
//ar//
//)t//
//{S//
//S(//
//yn//
//si//
//ta//
//em//
//m //
//.d//
//oi//
//uo//
//tv//
//. //
//pc//
//ri//
//it//
//na//
//tt//
//ls//
//n{//
//(M//
//1 //
//)e//
//;c//
//}a//
//}f//
///r//
///e//
 //t//
 //n//
 //i//
```
[Try it online!](https://tio.run/##rZI9boUwEIR7TuHSLoLzU3IGKkpEYYFBfgEbmQUJIZ@dkB0ipX/PzSetZ2dnDQ@zmbcwW//ovs9Ta6efOZnWXj99MufJxt60VpTHQoZcK7bgOjEZ52VF0fmhbow6qn0hO@VhpXy@ijR6@a6KlP6yWK1TKtSn9CN5F@ec1pBPlpa9OpRp6uEqUiW9M5PoXNhE665py1EK25o@2qvpcokv2EjrPr3CxSRGW2A/xRBfjFIyDs9YRgYR@lAkx3ARLjPac8YGZVghCYwOd2JiTBZmULoFH3xnyIpRHRiEZNFA2UBZM4aBUSNSg0gGkRSsj9sMG@33RlASPO0dSTDyDuEhWRGeNtxBMreIdD8BBnnz/5XGeyPsIEvGB9oVdi/gktCXeoZG@N//LbvUBHjgmneePw "Java (OpenJDK 8) – Try It Online")
[Old version](https://tio.run/##pZgxboQwFET7PYVLKAKbpOQMVJSIwgKDvAGD4IOELM5OkH2E5xJpn8yf@TNoP/rQX/Ni3Kf7u@88tzk7rzx3FGGdmLXXrVGl30SLbdUx205N2rqkktW6oW506qtzEzNl8y7Z8jyU0SXvtLiucAujwImIlSCKgOgJIg0ITRC/AdESRMLH6QKCENQYECVBSEB4/iIbQdiAEIJYuS8WfossICxXBLlz59aaA@Lgs5gJYuLjNAHRcUXQOLeAmAji5Aav@Dh9bDOe4AlB6ICoCKLhy17zQhy4Io4rEuN34PFb8zVruMHRjsRmT7kinitS8R05efyiZld8zTr@rWV5/MZCzAji4IUYx7kTQssVsXwWcdkXbvCV3wLF78bj13NFyoAYubXQixje7NGd39wXKMH7gCh4IV58nNdVpD@JG8XZdclkn7PJyHZWPtVNPTwPpUqc1ZPq7Hyo1oqWzZfKtLpfzfOjF/znIbYZOk9e3Pc/ "Java (OpenJDK 8) – Try It Online")
Straightforward aproach with comments wrapping the code^2 square, this can be done in pretty much any language.  
a (more readable) example in python
```
##p#####
# r  2 #
print 1#
# n  t #
# t  n #
#4 tnirp
# 3  r #
#####p##
```
[Answer]
# [Brain-Flak](https://github.com/DJMcMayhem/Brain-Flak), 33 bytes
```
##)(##))()()  ((
((  ))##    ()##
```
[Try it online!](https://tio.run/##SypKzMzTTctJzP7/X1lZUwOINTWAUEFBQ4NLQ0NBQVNTWVkBCDSA9H8NDU1NoChYBZiAcFDF/gMA "Brain-Flak – Try It Online")
# [Brain-Flak](https://github.com/DJMcMayhem/Brain-Flak), 33 bytes
```
##)     ## #
(( ))#)())()
  # ( (
```
[Try it online!](https://tio.run/##SypKzMzTTctJzP7/X1lZUwEElJUVlLk0NBQ0NZU1NTSBiAsopqChoPH/PwA "Brain-Flak – Try It Online")
# [Brain-Flak](https://github.com/DJMcMayhem/Brain-Flak), 36 bytes
```
#)##     ## #
  (())#)())()
 #   ( (
```
[Try it online!](https://tio.run/##SypKzMzTTctJzP7/X1lTWVkBBICUMpeCgoaGpqayJpDQ0ORSAMloKGj8/w8A "Brain-Flak – Try It Online")
# [Brain-Flak](https://github.com/DJMcMayhem/Brain-Flak), 38 bytes
```
######  (#
(()()())#))((
       #(  ##
```
[Try it online!](https://tio.run/##SypKzMzTTctJzP7/XxkMFBQ0lLk0NDRBUFNZU1NDg0sBApQ1gFj5/38A "Brain-Flak – Try It Online")
# [Brain-Flak](https://github.com/DJMcMayhem/Brain-Flak), 41 bytes
```
##(#####(#
(()()())#
##))()((
####((#)#)#
```
[Try it online!](https://tio.run/##SypKzMzTTctJzP7/X1lZQxkENJS5NDQ0QVBTWVOZS1lZE8TR4ALLaSiDBP//BwA "Brain-Flak – Try It Online")
[Answer]
# [Alice](https://github.com/m-ender/alice), 17 bytes
```
1/ 3<
vPo</
5} @<
```
Outputs `1`. [Try it online!](https://tio.run/##S8zJTE79/99QX8HYhqssIN9Gn8u0VsHB5v9/AA "Alice – Try It Online")
```
5v1
}P/
 o 
@<3
</<
```
Outputs `x`. [Try it online!](https://tio.run/##S8zJTE79/9@0zJCrNkCfSyFfgcvBxpjLRt/m/38A "Alice – Try It Online")
```
<@ }5
/<oPv
<3 /1
```
Outputs `5`. [Try it online!](https://tio.run/##S8zJTE79/9/GQaHWlEvfJj@gjMvGWEHf8P9/AA "Alice – Try It Online")
```
</<
3<@
 o 
/P}
1v5
```
Outputs `3`. [Try it online!](https://tio.run/##S8zJTE79/99G34bL2MaBSyFfgUs/oJbLsMz0/38A "Alice – Try It Online")
[Answer]
# Befunge, ~~17~~ 13 bytes
I thought Befunge would be fun for a geometrical problem. There is a trivial 4x4 solution akin to others here (I need 3 commands) but I managed a bit better.
*Edit: forgot about newlines*
*Edit 2: realized I could create a cat*
*Edit 3: the cat is dead*
```
2v3
@.v
.  
1@.
```
RIP kitty :<
```
1.@ 2
^._.^
3 @.4
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~5~~ 3 bytes
```
Y'X
```
[North](https://tio.run/##MzBNTDJM/f8/Uj3i/38A), [East](https://tio.run/##MzBNTDJM/f8/kkudK@L/fwA), [South](https://tio.run/##MzBNTDJM/f8/Qj3y/38A), [West](https://tio.run/##MzBNTDJM/f8/gkudK/L/fwA)
[Answer]
# [Lost](https://github.com/Wheatwizard/Lost), 45 bytes
```
v////v1//v(((
\(((%>2@0>%(((\
  (((v//3v////v
```
[Try it online!](https://tio.run/##y8kvLvn/v0wfCMoMgVhDQ4MrBkio2hk5GNipAlkxXAoKQAqoxBii7P///7qBAA "Lost – Try It Online")
To recap the gimmick of lost from the esolangs wiki:
> 
> Lost is a 2-Dimensional language where the instruction pointer starts at a random location, moving in a random direction. Despite this, Lost is still capable of creating completely deterministic programs.
> 
> 
> 
So at first glace, Lost is perhaps not the ideal language for this challenge because of its incredible fragility.
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 283 279 209 bytes
```
/////////)pm//
/////////;ua//
main(){//}ti//
puts("N"//sn//
);}///////((//
//////////")//
///"//////W{//
///E//////"///
//)"//////////
//((///////};)
//ns//"S"(stup
//it}//{)(niam
//au;/////////
//mp)/////////
```
[Try it online!](https://tio.run/##Tc0tDgQhDAVgP8eoasXmHQA9dsyK1QQxQUBIAEU4O9sM81f3pe@17rM7NwaukRSA5aapVhmsjywN6MUrUy2ZaSMgR6WYfqaZ312QTNLkr02u5xYHhZ7CMk8c040oY9bglziXmpS@6KsmHL0NSlvNuxuS3BzjDw "C (gcc) – Try It Online")
Same old comment trick here, but at least, in C this doesn't get **huuuge** ;)
* -4, thanks to [ETHproductions](https://codegolf.stackexchange.com/users/42545/ethproductions)!
* fixed `W` direction and -70 (!) bytes thanks to comments by [ETHproductions](https://codegolf.stackexchange.com/users/42545/ethproductions)
[Answer]
# [Starry](https://esolangs.org/wiki/Starry), 34 bytes
```
  zz  
  +   
   .  
    + 
      
```
Or with spaces shown as hyphens so you can see them:
```
--zz--
--+---
---.--
----+-
------
```
[Try it online!](https://tio.run/##Ky5JLCqq/P9fQaGqSkGBS0FBWwFMKehBKCAfTCko/P8PAA "Starry – Try It Online")
The commands in Starry are `+`, `.` and some other things, and what they do is determined by how many spaces there are before them: a `+` with *n* spaces pushes *n*−5 to the stack, and `.` with an even number of spaces prints it. The `z`s and newlines are ignored entirely.
There are 6 spaces before the first `+` so it pushes 6−5 = 1, and the `.` prints it.
And the rotations:
```
-----
-----
---+z
--.-z
-+---
-----
```
[Try it online!](https://tio.run/##Ky5JLCqq/P9fAQS44KR2FZDUUwCS2nDx//8B "Starry – Try It Online") This prints "8".
```
------
-+----
--.---
---+--
--zz--
```
[Try it online!](https://tio.run/##Ky5JLCqq/P9fAQy4FLQhlIIehALxgVRVlYLC//8A "Starry – Try It Online") This prints "2".
```
-----
---+-
z-.--
z+---
-----
-----
```
[Try it online!](https://tio.run/##Ky5JLCqq/P9fAQS4gFhbgatKQQ/IrtKGisDI//8B "Starry – Try It Online") And this prints "3".
[Answer]
## [Labyrinth](https://github.com/m-ender/labyrinth), 9 bytes
```
!
2@2
 !)
```
Prints `0`. [Try it online!](https://tio.run/##y0lMqizKzCvJ@P9fkcvIwYhLQVHz/38A "Labyrinth – Try It Online")
```
 2)
 @!
!2
```
Prints `3`. [Try it online!](https://tio.run/##y0lMqizKzCvJ@P9fwUiTS8FBkUvR6P9/AA "Labyrinth – Try It Online")
```
)!
2@2
  !
```
Prints `1`. [Try it online!](https://tio.run/##y0lMqizKzCvJ@P9fU5HLyMGIS0FB8f9/AA "Labyrinth – Try It Online")
```
 2!
!@
)2
```
Prints `2`. [Try it online!](https://tio.run/##y0lMqizKzCvJ@P9fwUiRS9GBS9Po/38A "Labyrinth – Try It Online")
### Explanation
Each program starts at the first non-space in reading order (i.e. either the top left or top centre character), moving east. For the first program:
```
!   Print an implicit zero.
    The IP can't move east, so it moves south instead.
2   Push a 2.
    The IP can't keep going south, so it turns east instead.
@   Terminate the program.
```
For the second program:
```
2   Push a 2.
)   Increment it to 3.
    The IP can't keep going east, so it turns south instead.
!   Print the 3.
    The IP can't keep going south, so it turns west instead.
@   Terminate the program.
```
For the third program:
```
)   Increment an implicit zero to 1.
!   Print the 1.
    The IP can't keep going east, so it turns south instead.
@   Terminate the program.
```
For the fourth program:
```
2   Push a 2.
!   Print the 2.
    The IP can't keep going east, so it turns back around to move west.
2   Push another 2.
    The IP can't keep going west, so it turns south instead.
@   Terminate the program.
```
[Answer]
## [Wumpus](https://github.com/m-ender/wumpus), 7 bytes
```
O@$
)))
```
Prints `0`. [Try it online!](https://tio.run/##Ky/NLSgt/v/f30GFS1NT8/9/AA "Wumpus – Try It Online")
```
)O
)@
)$
```
Prints `1`. [Try it online!](https://tio.run/##Ky/NLSgt/v9f059L04FLU@X/fwA "Wumpus – Try It Online")
```
)))
$@O
```
Prints `3`. [Try it online!](https://tio.run/##Ky/NLSgt/v9fU1OTS8XB//9/AA "Wumpus – Try It Online")
```
$)
@)
O)
```
Prints `2`. [Try it online!](https://tio.run/##Ky/NLSgt/v9fRZPLQZPLX/P/fwA "Wumpus – Try It Online")
### Explanation
The first program is easy enough: `O` prints an implicit zero and `@` terminates the program.
Starting at the second program, we need to look at the triangular grid layout to understand the control flow:
[![enter image description here](https://i.stack.imgur.com/dMQB9.png)](https://i.stack.imgur.com/dMQB9.png)
```
)   Increment an implicit zero to 1.
O   Print the 1.
))  Two irrelevant increments.
@   Terminate the program.
```
For the third program:
[![enter image description here](https://i.stack.imgur.com/jCi2j.png)](https://i.stack.imgur.com/jCi2j.png)
```
))) Increment an implicit zero to 3.
O   Print the 3.
@   Terminate the program.
```
The fourth one is where it gets really funky. Dashed lines indicate cells that aren't executed because they are skipped by the `$`:
[![enter image description here](https://i.stack.imgur.com/zH5yt.png)](https://i.stack.imgur.com/zH5yt.png)
```
$   Skip the ).
$   Skip the @.
))  Increment an implicit zero to 2.
O   Print the 2.
))  Two irrelevant increments.
@   Terminate the program.
```
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), ~~20~~ 11 bytes
```
#4#
1#3
#2#
```
Abuses comments (`#`) like crazy, and the fact that a single number placed onto the pipeline gets output as-is. The above prints `1`. [Try it online!](https://tio.run/##K8gvTy0qzkjNyfn/X9lEmctQ2ZhL2Uj5/38A "PowerShell – Try It Online")
From here, you can easily see that each rotation yields only one number that's on the "left" of the comments, and so there's only one number that will be output per rotation.
*Saved 9 bytes thanks to [Wheat Wizard](https://codegolf.stackexchange.com/users/56656/wheat-wizard)!*
[Answer]
# [dc](https://www.gnu.org/software/bc/manual/dc-1.05/html_mono/dc.html), 9 bytes
```
 1
2p3
 4
```
[Try it online!](https://tio.run/##S0n@/1/BkMuowJhLweT/fwA "dc – Try It Online")
I think its obviousness is part of the charm.
[Answer]
# [Cardinal](https://www.esolangs.org/wiki/Cardinal), ~~20 17 12~~ 11 bytes
```
.$
Z%"
+$v
```
[Try it online!](https://tio.run/##S04sSsnMS8z5/19PhStKVYlLW6WM6/9/AA "Cardinal – Try It Online")
All this time and no-one answered in Cardinal? This first one outputs `0`.
### East
```
 +Z.
 $%$
 v"
```
[Try it online!](https://tio.run/##S04sSsnMS8z5/19BO0qPS0FFVYVLoUzp/38A "Cardinal – Try It Online")
Outputs `1`.
### South
```
v$+
"%Z
 $.
```
[Try it online!](https://tio.run/##S04sSsnMS8z5/5@rTEWbS0k1iktBRe//fwA "Cardinal – Try It Online")
Outputs a space.
### West
```
 "v
$%$
.Z+
```
[Try it online!](https://tio.run/##S04sSsnMS8z5/19BqYxLRVWFSy9K@/9/AA "Cardinal – Try It Online")
Outputs `v`.
[Answer]
## Batch, 90 bytes
```
 :: :::@:
:&s ohce@
:e   : c:
      :h:
:o     o:
:h:
:c :   w:
@echo n&:
:@::: ::
```
Batch doesn't really have a comment character. For whole-line comments, `:` works, as it introduces a label, but I still need something to terminate the `echo` command while being a no-op when reversed. `&:` seems to work, which is all I need here, but it really confuses Batch, erroring out if I don't put a `:` before the `@` on the next line, and also somehow forgetting to print a newline.
[Answer]
# JavaScript (ES6), 86 bytes
Outputs 0 for North, 1 for East, 2 for South, and 3 for West.
```
////  _//
////  =//
_=>0//>//
  ////1//
  // //
//3////
//>//2>=_
//=  ////
//_  ////
```
```
const source =
`////  _//
////  =//
_=>0//>//
  ////3//
  // //
//1////
//>//2>=_
//=  ////
//_  ////`;
function rotateTextCW(text) {
  const lines = text.split("\n");
  const maxLineLength = lines
    .map(line => line.length)
    .reduce((max, len) => Math.max(len, max), 0);
  const paddedLines = lines.map(line => line.padEnd(maxLineLength));
  const charGrid = paddedLines.map(line => line.split(""));
  const rotatedGrid = [...new Array(maxLineLength)]
    .map(v => new Array(charGrid.length));
  for (let i = 0; i < charGrid.length; i++) {
    for (let j = 0; j < charGrid[i].length; j++) {
      rotatedGrid[j][charGrid.length - i - 1] = charGrid[i][j];
    }
  }
  return rotatedGrid
    .map(chars => chars.join("").trimRight())
    .join("\n");
}
const orientations = ["North", "East", "South", "West"];
let rotatedSource = source;
let markup = "";
orientations.forEach(orientation => {
  const code = `<pre>${rotatedSource}</pre>`;
  const result = `<code>${eval(rotatedSource)()}</code>`;
  const row = `
    <td>${orientation}</td>
    <td>${code}</td>
    <td>${result}</td>`;
  markup += `<tr>${row}</tr>`;
  rotatedSource = rotateTextCW(rotatedSource);
});
document.querySelector("table tr:first-child")
  .parentNode
  .innerHTML += markup;
```
```
<link href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/css/bootstrap.min.css" rel="stylesheet" />
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<script src="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/js/bootstrap.min.js"></script>
<div class="container">
  <table class="table table-striped table-responsive">
    <tr>
      <th>Orientation</th>
      <th>Source</th>
      <th>Result</th>
    </tr>
  </table>
</div>
```
[Answer]
# MATLAB, ~~29 17 5~~ 11 bytes
Having realised that the question called for single ASCII characters not just a distinct output, here is a MATLAB approach which will do just that:
```
%4%
1%3
%2%
```
This will implicitly print 1, 2, 3, or 4 depending on the rotation.
[Answer]
# [SOGL V0.12](https://github.com/dzaima/SOGL), 4 [bytes](https://github.com/dzaima/SOGL/blob/master/chartable.md)
```
5H
I
```
Outputs `1`, [Try it Here!](https://dzaima.github.io/SOGLOnline/?code=NUglMEFJ)
```
I5
 H
```
Outputs `H`, [Try it Here!](https://dzaima.github.io/SOGLOnline/?code=STUlMEElMjBI)
```
 I
H5
```
Outputs `5`, [Try it Here!](https://dzaima.github.io/SOGLOnline/?code=JTIwSSUwQUg1)
```
H
5I
```
Outputs `6`, [Try it Here!](https://dzaima.github.io/SOGLOnline/?code=SCUwQTVJ)
[Answer]
# [MATL](https://github.com/lmendo/MATL), 11 bytes
```
HxI
xFx
TxK
```
[Try it online!](https://tio.run/##y00syfn/36PCk6vCrYIrpML7/38A "MATL – Try It Online")
Let's get this started in MATL. The main challenge is that MATL just fails if a function requires input if the stack is empty. Perhaps something clever with modifiers like `X`, `Y`, `Z` and `&` could make for something shorter, but I couldn't find a suitable combination.
Explanation: all characters push a single integer on the stack, and `x` removes all of them but the last.
[Answer]
## Perl, 49 bytes
**48 bytes code + 1 for `-p`.**
Assumes empty input which TIO doesn't support, so a newline is added in its place and not used. Prints [N](https://tio.run/##K0gtyjH9/19ZQRkIuJSDbRXiVbiUrRXClbkUVOJt/YBi8QrxQNJWQQVIugKFlYGK///n@pdfUJKZn1f8X7cAAA), [E](https://tio.run/##K0gtyjH9/19ZRUFZAQi4lOOV/ZSVFZS5lBXCbeNVQCK2CvEKCsrKXArB1irxtq5AKZACIP7/n@tffkFJZn5e8X/dAgA), [S](https://tio.run/##FYkhDoBADAR9X7HJ1iJRpBKLQSCrECQXrgHeTyljJpmJ/WpjJggSAoAzBVTYL4dTuJhrPW6YKOqwtWIBZsrb4zn6eecQHw), [W](https://tio.run/##K0gtyjH9/19BWVkZhLmUXW3jVayDFbiAfIV4BVtlLgUFlXjbcAWgFFCBn3I8SERBQVlBRfn/f65/@QUlmfl5xf91CwA).
```
# ####
#S= _$
#; W#
 $_=N#
#_ _#
#= $#
#E#
 ## #
```
[Try it online!](https://tio.run/##K0gtyjH9/19ZQRkIuJSDbRXiVbiUrRXClbkUVOJt/YBi8QrxQNJWQQVIugKFlYGK///n@pdfUJKZn1f8X7cAAA "Perl 5 – Try It Online")
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 120 bytes
I had hoped for more synergy between the variants.
```
//}=)f8 ///
// c{(7 ///
   ;rr; //}
        ;c=
78; /// r{)
f(r /// r(f
){r /// ;38
=c;
}// ;rr;
/// 9({c //
/// 6f)=}//
```
[North](https://tio.run/##Jc0xCsMwDAXQuTqFCBQkaNBQaFyEb9KlCBQy1BTTzfjsru1oevqCL1t3s9ZEamQPKCIgglZom0ZEzVm76/ActQhbGJlgLgxO@TQ5cDmt9wDRFOpwL4ARPqkYzgeCD@fYj@1IP/y8j0QMBS7f3Hen5WqvtNzQibl3tD8 "C (gcc) – Try It Online")
[East](https://tio.run/##NYzBCgIxDETP5ivCgpCASw6CWwn9Ey8SyLIHixRvpd/era6d0xuGNzavZq2J1Mi@IIqAiFihMFhzVkSsgP@oRbjdtc@CuTA45YPJgcvBugSIpkOB@vX6kfw@Ea9UbHBwjlWkbemDr@eWiKHA6Z17d5rO9kjTBZ2YFWrbAQ "C (gcc) – Try It Online")
[South](https://tio.run/##Nc2xCgMxCAbguT6FHBQUWhwKvRTJm3QpguWGhhK6hTx7LslRp89fVLu@zVoTqZH9jiICImiFHtOIqDlrdx2epRYh3EYmmAuDUz5MDlwOa1ghmv5XoI5sHOoe85WK4fwlGJxjn7ct/fDz2hIxFDh9c@@dlrM903JBJ2aF2nY "C (gcc) – Try It Online")
[West](https://tio.run/##NYzBCgIxDETP5ivCgpCASw6CWwn9Ey8SyLIHixRvpd/era6d0xuGNzavZq2J1MgeEEVARKzQdbDmrIhYAf9RixAW7bNgLgxO@WBy4HKw3m8QTYcC9ev1I/l9IgYqNnhxjlWkbemDr@eWiKHA6Z17d5rO9kjTBZ2YFWrbAQ "C (gcc) – Try It Online")
[Answer]
# [MathGolf](https://github.com/maxbergmark/mathgolf/blob/master/math_golf.txt), 11 [bytes](https://github.com/maxbergmark/mathgolf/blob/master/code_page.py)
```
Þ2Þ
3 1
Þ0Þ
```
A bit boring, but since MathGolf implicitly outputs the entire stack joined together, I'm not sure if something shorter is possible here..
[Default](https://tio.run/##y00syUjPz0n7///wPKPD87iMFQy5Ds8zODzv/38A); [rotated once clockwise](https://tio.run/##y00syUjPz0n7///wPOPD87gMFIy4Ds8zPDzv/38A); [rotated two times clockwise](https://tio.run/##y00syUjPz0n7///wPIPD87gMFYy5Ds8zOjzv/38A); [rotated three times clockwise](https://tio.run/##y00syUjPz0n7///wPMPD87iMFAy4Ds8zPjzv/38A).
**Explanation:**
* `0123`: These push the digit to the stack
* : This pushes a space character to the stack
* `Þ`: This empties the stack except for the top value
And in the end the entire stack joined together is output implicitly as result.
[Answer]
# [brainfuck](https://github.com/TryItOnline/brainfuck), 72 bytes
```
++
+++++++++++++++++++++++++++++++++.+++++++++++++++++++++++++++++++++
+
```
[Try it online!](https://tio.run/##SypKzMxLK03O/v9fW5tLmxDQI6iCS/v/fwA "brainfuck – Try It Online")  
[Try it rotated once!](https://tio.run/##SypKzMxLK03O/v9fW1ubSwGMaYn0aGw@CP3/DwA "brainfuck – Try It Online")  
[Try it rotated twice!](https://tio.run/##SypKzMxLK03O/v9fgWKgzaVNCOgRVMFFuTO0//8HAA "brainfuck – Try It Online")  
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 69 bytes
```
 _=>0//
/*    *_
/      =
1      >
>      3
=      /
_*    */
 //2>=_
```
[Try it online!](https://tio.run/##JczLCoAgEIXh/TzFLFWo6bIeX0XEJApRSen1LfRffYvDue1ri3uuXKeYDt9ciqViRm5oWC9EQAr/lAHCHsM6oEEP7MADBGaMCZBo02z6Xwp@DukUWUjZPg "JavaScript (Node.js) – Try It Online")
This approach should work for any language with C-style comments.
[Answer]
# [MAWP](https://esolangs.org/wiki/MAWP), 5 bytes
## North: 3
```
2M:
2
```
[Try it!](https://8dion8.github.io/MAWP/v1.1?code=2M%3A%0A2&input=)
## East: 4
```
22
 M
 :
```
[Try it!](https://8dion8.github.io/MAWP/v1.1?code=2M%3A%0A2&input=)
## South: 2
```
  2
:M2
```
[Try it!](https://8dion8.github.io/MAWP/v1.1?code=2M%3A%0A2&input=)
## West: 1
```
:
M
22
```
[Try it!](https://8dion8.github.io/MAWP/v1.1?code=2M%3A%0A2&input=)
The existing 1 in the stack is very convenient here.
[Answer]
# [Python 2](https://docs.python.org/2/), 71 bytes
```
##p#####
# r  2 #
print 1#
# n  t #
# t  n #
#4 tnirp
# 3  r #
#####p##
```
[Try it online!](https://tio.run/##bY5RDoAgDEP/OUWTnYDBoeQHCdmPp8ehMCW6r6aU15ZDtj1za0SF@jlCBRjkSk1Z4LuTAUEXAtUqIiSnWtQJ0Lw6/ZTgHkWI4y1Yev6fxLuDR6u/QGOHWxdFS4ffRWwd/rvoDQoGir8gbyBeQa2d)
Big thanks to [this answer!](https://codegolf.stackexchange.com/questions/137588/cardinal-code-challenge/137618#137618)
Note I **did not** copy it directly, but actually had a program in mind and golfed it with this.
]