[Question]
  [
You are trapped in this 5x5 labyrinth - each room is labelled from 1 to 25 and the exit is in room 1.
[![enter image description here](https://i.stack.imgur.com/3pa3s.png)](https://i.stack.imgur.com/3pa3s.png)
You are given as input the room you are currently in. Your task is to output the shortest sequence of moves (north, east, south, west) needed to reach room 1.
Moves can be output in any format you wish (list, string, array...) as long as you use the characters `n,w,e,s`.
**Here are all the test cases:**
```
1 => empty string/list
2 => w
3 => ww
4 => swwnw
5 => wswwnw
6 => seenwnw
7 => nw
8 => wnw
9 => wwnw
10 => swwnwnw
11 => eenwnw
12 => enwnw
13 => nwnw
14 => wnwnw
15 => wwnwnw
16 => enenwnw
17 => nenwnw
18 => wnenwnw
19 => nwnwnw
20 => wnwnwnw
21 => nenenwnw
22 => enwnenwnw
23 => nwnenwnw
24 => wnwnenwnw
25 => nwnwnwnw
```
Shortest answer in bytes wins!
  
[Answer]
# [Python 2](https://docs.python.org/2/), 64 bytes
```
def f(n):d=0x1211252b5375>>2*n-4&3;print"nwes"[d];f(n+d*3+d%2-5)
```
[Try it online!](https://tio.run/##JcvRCoIwFIDha/cUQyicJrSzVqDkXa/QTXRhbSshzuS4SJ9@mV3@8P39FJ4eIUZjHXcZisoct6MEKUHDTauDbhrIsdytVd1ThyHFjx3Si7nWsy5MrgqzglKL6Dxx5B1yavFhM7mBvahYskwsCTTN8S@Ov1ewxI532wd@bl9veyLytJB2GOIX "Python 2 – Try It Online")
A function that prints one direction per line, terminating with error. 
The constant `0x1211252b5375` encodes in base 4 the direction `d` we travel from each room number as a number 0 through 3. The extraction digit `>>2*n-4&3` is also designed to give a negative shift error when `n=1`, terminating the code. We update the room number `n` via an offset that's computed from the direction `d` as `d*3+d%2-5`, which maps:
```
d   d*3+d%2-5
0  -> -5
1  -> -1
2  ->  1
3  ->  5 
```
[Answer]
# [Python 2](https://docs.python.org/2/), ~~95~~ 93 bytes
```
f=lambda n:n>1and Q[n]+f(n+[-5,5,1,-1]['nsew'.find(Q[n])])or''
Q='  wwswsnwwseenwwenwnwnenwn'
```
[Try it online!](https://tio.run/##FcpBCsMgEIXhdXOK2Y0SUzCQLgLJHbKWLCxqO9COQQPS01vD4/9W7/id78hjrWH52O/TWeCZV23ZwWZ474Pg3gyTmpRWg94NcvYF74HYiesgdxkTYrctCFBKLpmb3jdbbZdYQ0xAQAzJ8ssLrcaHnLvbkYhPIAVBkKx/ "Python 2 – Try It Online")
Could shave off ~~3~~ 2 bytes if 0-indexed room labeling is allowed.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~30~~ 29 bytes
*-1 byte thanks to a miraculous coincidence with prime numbers*
```
[Ð#•θzƶ‰`Ó•4вsè<DˆØ·5-+}'‹™¯è
```
[Try it online!](https://tio.run/##AU4Asf9vc2FiaWX/MjVFTj8iIC0@ICI/Tv9bw5Aj4oCizrh6xrbigLBgw5PigKI00LJzw6g8RMuGw5jCtzUtK30n4oC54oSiwq/DqP8swrQpXP8 "05AB1E – Try It Online")
```
[                      }    # infinite loop:
 Ð                          #  triplicate the room number (initially, the input)
  #                         #  break if room number == 1
   •θzƶ‰`Ó•4в               #  compressed list 202232302231102210202010
             sè             #  use the room number to index into that list
               <            #  decrement
                Dˆ          #  add a copy to the global array
                  Ø         #  nth prime (-1 => 0, 0 => 2, 1 => 3, 2 => 5)
                   ·        #  double
                    5-      #  subtract 5
                      +     #  add that to the room number
'‹™                         # dictionary string "western"
   ¯                        # push the global array
    è                       # index (wraps around, so -1 => n, 0 => w, 1 => e, 2 => s)
```
[Answer]
# [Ruby](https://www.ruby-lang.org/), ~~72~~ 62 bytes
```
f=->n{n<2?'':' en  sw'[x=4*18139004[n]+6*4267088[n]-5]+f[n+x]}
```
[Try it online!](https://tio.run/##DcdBDsIgEADAr@xtLQgBpJUaqw/Z7EETuUkaa@Oatm9H5zav@f6tNQ/mUpZyDlfEE8KjAEwfJBmi8skfeuciFdadiqE7upT@MS3rTEULb3XnrQ1tY5@3cVllhXF@T0CyzyTMCsEAbvUH "Ruby – Try It Online")
### How?
The trick here is to use 2 constants to build the next step for each cell, then recursively solve the problem.
The 2 constants 18139004 and 4267088 are binary strings giving the direction of the next move, by extracting a single bit from both for each cell, we can get:
```
"n" = 4*0+6*0-5 = -5
"w" = 4*1+6*0-5 = -1
"e" = 4*0+6*1-5 = +1
"s" = 4*1+6*1-5 = +5
```
Easier than shifting around and masking a single big binary number IMHO.
When we get the direction, we extract the corresponding letter from the string " en sw":
```
  1   5
  |   |
" en  sw"
   |   |
  -5  -1
```
And proceed recursively on the cell [n+x]
[Answer]
# JavaScript (ES7), ~~62~~ 58 bytes
Port of [xnor's answer](https://codegolf.stackexchange.com/a/192952/58563).
```
f=n=>--n?"nwes"[d=79459389361621/4**n&3]+f(n+d*3+d%2-4):''
```
[Try it online!](https://tio.run/##DYxRC4IwFEbf@xUXobZ5meGmltrqR/QYPQynUcidqNRD9NvXHj44HA7fy77t0s3PaZXkXR/CYMicpaRLQp9@SW7OHOqirPWx1lVeqXxfpCnt9B0HTuhSjW6rZCEaxsLgZ05gIG@B4GRAlREQBXw3AJ2nxY99NvoHjxUCYyKbrLuudl65EtEk0MQhxGch2s0v/AE "JavaScript (Node.js) – Try It Online")
[Answer]
# Perl 5 (`-n`), 94 bytes
-5 bytes thanks to Grimy
```
@A=map/./g,__wwswsnwwseenwwenwnwnenwn;%H=(n,-5,s=>5,e,1,w,-1);$_+=$H{$,=$A[$_]},say$,until$_<2
```
[TIO](https://tio.run/##FcRBCsIwEEDRy4ygOGlNIKs60u668QQioYsghToNnUoo4tUdI5//Ulwmr9p29BxSXdUPDCFnycLFGIvl0t9m19Oe0XgUuniMaDGjsYcGwpGgfwMSdDcI9w/KsAG@eB0nCGen6tx3Tus4s6hhNVdfnewP)
[Answer]
# [Perl 5](https://www.perl.org/), 79 bytes
```
say$,while$_+={n,-5,s=>5,e,1,w,-1}->{$,=substr _wwwswsnwwseenwwenwnwnenwn,$_,1}
```
[Try it online!](https://tio.run/##FcRBCoMwEEbhq7jIzn9KE8gy3sAzhBYGKkgUJzKU4NWdpjzet/OxRjN5fR30s6zs8phaAUVImiIYHgryF03NIcn5lnoMWVVFpXSZu/3eX7gMf5mFcG97XbYiRsVojo@n/wE "Perl 5 – Try It Online")
[Answer]
# JavaScript, ~~80~~ ~~73~~ 71 bytes
Adapted from [Chas' Python solution](https://codegolf.stackexchange.com/a/192950/58974) so please `+1` him, too.
```
f=n=>--n?(d=" wwswsnwwseenwwenwnwnenwn"[n])+f(n+~~{n:-4,s:6,e:2}[d]):``
```
[Try it Online!](https://tio.run/##FctBCsIwEIXhq4SsMkwjUtRFavQgpdDSJKKUiXTEBMRePUYe/7d7j@k98bzeny9N0flSgiV70ZquylkpUuLEVPW@Wqv7K3saAIMi3LYPGX1o2Jwab9pv7wYw41hCXFW2@y4jnttjB3MkjovfLfGmMkphhaz/DFB@)
1 byte saved thanks to [Arnauld](https://codegolf.stackexchange.com/users/58563/arnauld).
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), ~~43~~ 40 bytes
```
ＮθＷ⊖θ«≔Ｉ§”)“⊞x⟧∧⎚⁵2”ιι§nwesι≧⁺⁻⁺﹪ι²×³ι⁵θ
```
[Try it online!](https://tio.run/##RU5BCsIwEDy3rwg9baAePOilp6KXHqxF/EBslzbQpjWbGEF8e0y0IMsMw8zOsu0gdDuL0ftKLdbUdrqhhjsvUjfIERkcsdU4oTLYBZuzV5qURLJXUJpKdfiEjJwjRyowYuCAMJGznEkeUaRJo6Uy8JUnsfxOXGQ/GGhGSzm7ygkJzhoOsw2LGeHarrEXBmHLg/7H6NZ4F/3479v7vd88xg8 "Charcoal – Try It Online") Link is to verbose version of code. Based on both @ChasBrown's and @xnor's answers. Explanation:
```
Ｎθ
```
Input the room.
```
Ｗ⊖θ«
```
Set the loop variable `i` to one less than the room number and repeat while it is non-zero.
```
«≔Ｉ§”)“⊞x⟧∧⎚⁵2”ιι
```
Extract the direction from the compressed string `0113130113220112010102010`. (The leading `0` is just a filler digit.)
```
§nwesι
```
Print the direction.
```
≧⁺⁻⁺﹪ι²×³ι⁵θ
```
Use @xnor's formula to calculate the new room number.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~30~~ 29 bytes
```
“þ&ƊĿñ÷°e’b6Ḥ_5Ż⁸+ị¥ƬI‘ị“®ȯẹ»
```
[Try it online!](https://tio.run/##AVsApP9qZWxsef//4oCcw74mxorEv8Oxw7fCsGXigJliNuG4pF81xbvigbgr4buLwqXGrEnigJjhu4vigJzCrsiv4bq5wrv/O@KAnCAtPiDigJ07w4cKMjXDh@KCrFn/ "Jelly – Try It Online")
A monadic link taking the starting cell and returning a string with the directions.
I love the fact that Jelly’s dictionary has a word like ‘Kennesaw’ (a city northwest of Atlanta, Georgia), used here because indexing into it with `[5, 1, -5, -1] + 1` gives `nesw`!
## Explanation
```
“þ...e’                    | Base-250 integer 1962789844189344852  
       b6                  | Convert to base 6 (2, 2, 5, 2, 5, 0, 2, 2, 5, 3, 3, 0, 2, 2, 3, 0, 2, 0, 2, 0, 3, 0, 2, 0)
         Ḥ                 | Double
          _5               | Subtract 5
            Ż              | Prepend 0
             ⁸  ¥Ƭ         | Using this as the right argument and the original link argument as the left argument, loop the following as a dyad until there is no change, collecting up results
              +            | - Add the left argument to:
               ị           |   - The left argument indexed into the right argument
                  I        | Differences between consecutive numbers
                   ‘       | Increment by 1
                    ị“®ȯẹ» | Index into "Kennesaw"
```
[Answer]
# [PHP](https://php.net/), 110 bytes
A solution which isn't a port of [Chas Brown's great answer](https://codegolf.stackexchange.com/a/192950/81663) or [xnor's great answer](https://codegolf.stackexchange.com/a/192952/81663). I know this is longer but I wanted to have a different solution!
```
for($n=$argn;$n>1;$n=ord($s[$n*2+1])%30)echo($s='0000w<w sEw"s)n w%w&s-e*e+n&w+w,e/n*w/n,w1n.e5n0w5n2')[$n*2];
```
[Try it online!](https://tio.run/##RY7NDoIwEITvPMWGFKFU5MdwKsWTvoRyMFqFy7ahJnswvrq1cHEOu5PJ7pexo/XdwY42ih5mhoxNoKCWEHanoGkXJwSHdwRB@jYaiJebHmK5Ruw6PzH8sEn6QMgYqjWSDPs6DGXme8bcmWHeiHrgyb7iCyZkKq2CqCNwR4odR6CENq7QuRa4IUFbXWJOJW6pxp1usaIWm5SvrEH6f6MLhjYf37RfY1@TQeeL0w8 "PHP – Try It Online")
I have created a mapping string which has 2 characters for every cell in the board. First character for each cell is a move (n/e/s/w) or `0` and the second character's ASCII code mod 30 will return another cell number which we should follow its move in recursive mode until we get to exit cell (`cell < 2`).
For example for input of 8:
* 2 characters for cell `8` are: `w%`
* It means print `w` and continue with moves for cell of `%`
* ASCII code of `%` is 37 which mod 30 will be 7, so next cell to follow is `7`.
* 2 characters for cell `7` are: `n`  (last character is space, ASCII code = 32)
* It means print `n` and continue with moves for cell of 32 mod 30 which is `2`.
* 2 characters for cell `2` are: `w<` (last character ASCII code = 60)
* It means print `w` and continue with moves for cell of 60 mod 30 which is `0`.
* If cell number is less than `2`, loop stops!
* Final printed result: `wnw`
---
# [PHP](https://php.net/), 75 bytes
This version is written by [Grimy](https://codegolf.stackexchange.com/users/6484/grimy), it is 35 bytes shorter than my original answer because he/she is smarter! Grimy's comment: *"4 \* 25 < 256, so you only need 1 byte per cell, not 2"*
```
for($n=$argn;$n=ord("0\0~f;6o4R:s%ql&rup*@^tIDbx"[$n%25]);)echo news[$n%4];
```
[Try it online!](https://tio.run/##K8go@G9jX5BRwMWVll@koKGSqWCrYGitAKRtbBWMTEEsbW1NhWouBSBITc7IV1ACqbFTULIGC6kkFqXnAfWoZFr/B5qgoZJnCxayBjLyi1I0lAxiDOrSrM3yTYKsilULc9SKSgu0HOJKPF2SKpSiVfJUjUxjNa01wSbnpZYXg4RMYq3/I6yLyQNaVfvfyPRffkFJZn5e8X9dNwA "PHP – Try It Online")
---
# [PHP](https://php.net/), 71 bytes
This port of [Arnauld's answer](https://codegolf.stackexchange.com/a/192961/81663) which is port of [xnor's answer](https://codegolf.stackexchange.com/a/192952/81663), but as a loop instead of recursive function, since it turns out to be shorter in PHP.
```
for($n=$argn;--$n;$n+=$d*3+$d%2-4)echo nwes[$d=79459389361621/4**$n&3];
```
[Try it online!](https://tio.run/##RU1LDoIwFNxzihfyNNCmMbSANqW68xLqwggKm9cGTFwYr24tbJzNTCbz8b0PzcH3PknuboQMB7BQGIjcWJDVrDjP4Z1ARHfrHaRzZg@pWSy8jg@KHRxMiAsZkl0sIwSSQeIWW6Y4tispynwZoFc3nbC1W11WWu20qotaFpuSMaS1upjwvzpTvPkEWX2dfw6OpiCOPw "PHP – Try It Online")
[Answer]
# [C (clang)](http://clang.llvm.org/), 81 bytes
```
v;f(p){p-1&&putchar(v="00wwswsnwwseenwwenwnwnenwn"[p])+f(p+=v%5?6-v%8:v%2?5:-5);}
```
[Try it online!](https://tio.run/##FYvRCoMgGIXvfYofwVCcUIFj5FwPsu0iWi5hc2JlF9GzO@NwvnP4f04v@k/n3ilFZahnmxdVUfhl7scu0KhxWa7rtE4ucxgys7MO4rt/Mp5HXEci27OI5NJEUreyEZKpPVk3w7ezjjLYkPkFehwsaKiUvepaKs4t2xD4kB8GKH448hI3wCfLFAJDj9hRGOYlOChzT38 "C (clang) – Try It Online")
Thanks to @Tommylee2k suggestion -8!
+ recursive call
# [C (clang)](http://clang.llvm.org/), 90 bytes
```
v;f(p){for(char*l="00wwswsnwwseenwwenwnwnenwn";p-1;p+=v%5?6-v%8:v%2?5:-5)putchar(v=l[p]);}
```
[Try it online!](https://tio.run/##FY1RC4MgFIXf/RUXQdA1oQLHyLl@yLaHaLmE5sTKHqLf7pTL/c7hHji35/3U2U@MQWrq2K5/nvZj50@TwmW5bfM228RhSEybJhNLxyvpChWIaC88kGsTSN2Khgvm1iUX0KCmh3sxeURjF/h2xlIGO8oP8sGAgkqam6qFLArDdgTOp0ADxU9L3vwO@GyYRKBplgP5YVm9hTL5@Ac "C (clang) – Try It Online")
Similar to all not compressed solutions.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), ~~45~~ 43 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
õ?[Ð#.•DUo¢ê`Ω÷‰₂¡)R€ûK•¦sè©?Ž₁9₂в6-'€Ã®kè+
```
Port of [*@ChasBrown*'s Python 2 answer](https://codegolf.stackexchange.com/a/192950/52210).
[Try it online](https://tio.run/##yy9OTMpM/f//8Fb76MMTlPUeNSxyCc0/tOjwqoRzKw9vf9Sw4VFT06GFmkGPmtYc3u0NlD60rPjwikMr7Y/ufdTUaAmUvbDJTFcdJN18aF324RXa//8bAgA) or [verify all test cases](https://tio.run/##yy9OTMpM/W9k6upnr6Sga6egZO/3//BW@@jDE5T1HjUscgnNP7To8KqEcysPb3/UsOFRU9OhhZpBj5rWHN7tDZQ@tKz48IpDK@2P7n3U1GgJlL2wyUxXHSTdfGhd9uEV2v9rD22z/w8A).
**Explanation:**
```
õ?               # Output an empty string
                 # (to overwrite the implicit output if the input is 1)
[                # Start an infinite loop:
 Ð               #  Triplicate the top of the stack
                 #  (which is the (implicit) input in the first iteration)
  #              #  If it's exactly 1: stop the infinite loop
  .•DUo¢ê`Ω÷‰₂¡)R€ûK•
                 #  Push compressed string "a  wwswsnwwseenwwenwnwnenwn"
   ¦             #  Remove the first character
    sè           #  Swap to get the number, and use it to index into the string
      ©          #  Store it in variable `®` (without popping)
       ?         #  Print it without trailing newline
  Ž₁9            #  Push compressed integer 22449
     ₂в          #  Convert to base-26 as list: [1,7,5,11]
       6-        #  Subtract 6 from each: [-5,1,-1,5]
         '€Ã    '#  Push dictionary string "news"
            ®k   #  Get the index in this string of character `®`
              è  #  And use that to index into the integer-list
               + #  And add it to the originally triplicated integer
```
[See this 05AB1E tip of mine (all four sections)](https://codegolf.stackexchange.com/a/166851/52210) to understand why `.•DUo¢ê`Ω÷‰₂¡)R€ûK•` is `"a wwswsnwwseenwwenwnwnenwn"`; `Ž₁9` is `22449`; `Ž₁9₂в` is `[1,7,5,11]`; and `'€Ã` is `"news"`.
[Answer]
# [Bash](https://www.gnu.org/software/bash/), 120 bytes
```
S=__wwswsnwwseenwwenwnwnenwn
N=n-5w-1s05e01
for((i=$1;$i>1;i+=$j)){ d=${S:$i:1};j=${N:`expr index $N $d`:2};printf $d; }
```
[Try it online!](https://tio.run/##FcdBCoMwEAXQvafIYhZKEZyCXSTEI2TjAbQlkY6LVJJCBMnZp1M@//H/65nfzLNdllJyyVEMQZRK/jbOxn4sPeZhDAM22ye1LVlAAzShoZuFvesu5S1cswbSWM0u2@k1nEdSFH04FTgFftX3ao5E8bvJM6oyMz5@ "Bash – Try It Online")
I toyed for a while with trying to bit-pack the string as nibbles, but the decoding would require more characters than the number saved.
### How it works:
```
S=__wwswsnwwseenwwenwnwnenwn
```
String $S holds a single character (n,w,s,e) for each room showing which direction to take to move one room towards the exit, skipping rooms 0 and 1.
```
N=n-5w-1s05e01
```
String $N has the delta to add to/subtract from the current room number for each direction change (n: -5, w: -1, s: +5, e: +1)
```
for((i=$1;$i>1;i+=$j)){ d=${S:$i:1};j=${N:`expr index $N $d`:2};printf $d; }
```
Start with $i equal to the room number given on the command line ($1). Assign the character at index $i in string $S to $d. Retrieve the delta value from $N for the direction to take to the next room, assigning it to $j.
Print the next direction to take in $d.
Add/subtract the delta in $j to/from $i.
Loop until we leave room #2 (while $i>1).
[Answer]
# [Stax](https://github.com/tomtheisen/stax), 31 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax)
```
α-J╒Θ▀╣ô¥$v╞||T←]┬yΣ╨z§£sU╕τR"┌
```
[Run and debug it](https://staxlang.xyz/#p=e02d4ad5e9dfb9939d2476c67c7c541b5dc279e4d07a159c7355b8e75222da&i=1%0A2%0A3%0A4%0A5%0A6%0A7%0A8%0A9%0A10%0A11%0A12%0A13%0A14%0A15%0A16%0A17%0A18%0A19%0A20%0A21%0A22%0A23%0A24%0A25&a=1&m=2)
[Answer]
# [Kotlin](https://kotlinlang.org), 112 bytes
```
val d="  113130113220112010102010"
fun p(r:Int):String=if(r>1)"nwes"[d[r]-'0']+p("046:"[d[r]-'0']-'5'+r)
else ""
```
[Try it online!](https://tio.run/##hVbvbxo5EP3OXzFFlQIKWbIkJA26RKp6Va8fqjtdK51OUT@YxcBeFpvaXght@rfn3oz3B3DVNdGytud5Zjx@ft4HG4rcPA@H9MZpFfSM5tZRWOaeMjvTtLDFnLKlKgptFnrSAXAZwtpPhkO2sznxQWUP@hEoQJLMroZfhunN6ObymuFvfabWGi41FWq6c7kJyxfUYdPftiTlYHNqvUbo3MTI48dxi6UzhmqVLclZuyLYYdNICLk6DKQULI3GpMyMkRxIP@aBgXAoc9JE4p2etX91@5QNT3BCNMJzgfYl3mN6qmeconvwjjOu8Fxj6BWeG3pKz@OMp2M03tGQIkaKGOkFHsRIfxojvQIKMdJXaN8gwZ/GGKV4EGOEGKNLtPdjHK1eYhAZfm3R0LHvD7ZmkW@0IcWlXJdBiisV3UU7Q7PSOW1CsQMm4Yngj/IPXH9sjC1DNZGxfmld0D6Q119KbTJNdk4ru9Geegam5QA77cNAsJiK/hbwPhmtZ9hwOHQtFbCtwH2Q6ZkyNNV1OGy8Mjvm8koFSXab@yWje0UO/@QDyLUYYA1O7ZIk6fMaC2sW/AaeoaWPtAWxncqCdp7MYDvQAy9xf9OoD9cIh0NwsrBMee3lnKR0e0d6tQ67KtqQQ7NlxJYtty6kJc1Lbvrt1khvLIameyVGrU3Vv@Z@bL4SZGzfRHexA0bWHquBmFHjJJU82u5FdFr1Liu/VXdcu676V3FuOzum1ParvNqBm9p97I/OmwDVQFp5aKaMmgTboTrJdqRJtB0at6HMlnjoY008ZfxWOybIdIcB8ML4F0L5t49rSAhIFncLFogP72uO0UfRRXCbkbPc6Szk1kzoq3ZWTBV7rdHSZdYKi8M22oXWrFFw6XQECcMT@gTNY6ja2HzmaaXD0s5ApKLw5NWGc5Fck85GFW1wuqUutCG9SC/O8Tsa4RcP/vm3e7imeWniJDlBoXRGlhaXykicw8azry6BeNYT@lPjjHsYGLgqUUWctBkvVWpU@2aR8EGrGZwxslCr6UwhbQBo7Wymve@xxwm9N6E/oY@x0LedDnSHMOP9vFUYlg/UDomsrNOsA7iMQo1Ue3XAklhCErHlc5IYdEdpPzqWCX9huo4C1s6c7ohLwUnw1jbguOPNuT8oh1w6LZTlrnVYUQf3lsVe81sv9J5jBPTlNLBbxrFPYVATKjnIWBUeNmsy3Mwm4EfCubgdG91imSwY92URfO2ia0DC7n2T3D1n//ns5Pzk82ldmGr6J1RQPVRqB1dSbZZc1PYQOc8XpROZbQuylRt8o4tDKEqA5S5svdC2Slt9iPyHKRVd6FlCb1SRlQWvlm@NA2TcGMsXB7MCPMwUy3Q8JkfYQFtbFjhJFu4jXI4RvdPhKNV9lY9fFXun4wDKJ7jeQgHNsRHt5EPwLtfFrF6/nc89M9DKJhr9eJREPGuvZ9V3UFtcvmcPkPs3LvtjYv/YJ84o60sd3Mt9dTZmQv@3AszEAZ2lDd3ncDqg9IgBldHnX3UUtHE9dpSlxX2a7I3VErA31D2/vJr8mKNnJ@OTU@72G3n4HTEcLvKoBnL1hvZ7D0fF2Brako1pLF8iU91yTGC68HXK3SiXHxQK2khl@yVcf/9GKVsB1VNu4Sf0mj8ffok6dtenb@LlVxWUFGZfdKvFyz6xWq2wgfIZ8VHHU61rqd5o0VoJj49pBsYPDsh7ZPCz3AO3/6v@ork9NxGljQne5vOeu0v7tTDcu0oN1r16H@qhWPx@h0uE4jxLTf@olsBas7be59MiktSj3H5dqF08LRWdhL5chjyc@L3LhYvPa@vFw4yKp0kyGvc7kSPQzML0ui@j9eW3dcT1v3f7ne/sm8v//C8 "Kotlin – Try It Online")
]