[Question]
  [
# The task:
Output a value for `x`, where `a mod x = b` for two given values `a,b`.
# Assumption
* `a` and `b` will always be positive integers
* There won't always be a solution for `x`
* If multiple solutions exist, output at least one of them.
* If there aren't any solutions, output nothing or some indication that no solutions exist.
* Built-ins are allowed (not as fun as other mathematical approaches)
* Outputs are always integers
# Examples
```
A, B >> POSSIBLE OUTPUTS
5, 2 >> 3
9, 4 >> 5
8, 2 >> 3, 6
6, 6 >> 7, (ANY NUMBER > 6)
8, 7 >> NO SOLUTION
2, 4 >> NO SOLUTION
8, 5 >> NO SOLUTION
10,1 >> 3, 9
```
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so lowest bytes wins.
  
[Answer]
# [JavaScript](https://babeljs.io/), ~~28~~ ~~27~~ ~~26~~ ~~24~~ 23 bytes
```
a=>b=>(a-=b)?a>b&&a:b+1
```
[Try it online!](https://tio.run/nexus/javascript-babel-node#S7f9n2hrl2Rrp5Goa5ukaZ9ol6SmlmiVpG34Pzk/rzg/J1UvJz9dI13DVFNDwUhT05oLVdgSKGyCKWyBXbUZUNgMu2pzTGEj7GYbGmhqGAKF/wMA "JavaScript (Babel Node) – TIO Nexus")
`false` indicates no solution.
-1 thanks [@Arnauld](https://codegolf.stackexchange.com/users/58563/arnauld)
[Answer]
# [MATL](https://github.com/lmendo/MATL), 6 bytes
```
tQ:\=f
```
[Try it online!](https://tio.run/nexus/matl#@18SaBVjm/b/vwWXEQA "MATL – TIO Nexus") Or [verify all test cases](https://tio.run/nexus/matl#S/hfEmgVY5v2X83FJeS/KZcRlyWXCZcFkDYDQgsucyALxDflMjTgMgQA).
### Explanation
Consider inputs `8`, `2` as an example.
```
t    % Implicit input. Duplicate                STACK: 8, 8
Q    % Add 1                                    STACK: 8, 9
:    % Range                                    STACK: 8, [1 2 3 4 5 6 7 8 9]
\    % Modulo                                   STACK: [0 0 2 0 3 2 1 0 8]
=    % Implicit input. Equality comparison      STACK: [0 0 1 0 0 1 0 0 0]
f    % Indices of nonzeros. Implicit display    STACK: [3 6]
```
[Answer]
# [Python 2](https://docs.python.org/2/), ~~40~~ 34 bytes
-6 bytes thanks to Bubbler
```
lambda a,b:[(a==b)*-~a,a-b][a>b*2]
```
[Try it online!](https://tio.run/##TY1BDoIwEEX3nGISNy0OUVpahAQvgl1MBSKJFkJY4Mar1zbExMX/b17@Yub3@pic8ENz80962Y6A0NYto6axPM0@hJRZ09LVpsL4YVrCDhZGBy1TKDgCq7CIuOymUe9WRojfpiLyM@a7FtzUCczL6FYYWHjJkwP029zf176rQcIJVIhEHbo8htr@IrGKl/8C "Python 2 – Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 5 bytes
```
‘R⁸%i
```
Returns the minimal valid **x** or **0** is there is none.
[Try it online!](https://tio.run/nexus/jelly#@/@oYUbQo8Ydqpn/Dy/Xf9S0JvL//2hTHQWjWB2FaEsdBRMQbQHlm@komEH55iDaCCFvCqINDXQUDGMB "Jelly – TIO Nexus")
[Answer]
# Groovy, 48 bytes (using built-in):
```
{a,b->Eval.me(a+"g").modInverse(Eval.me(b+"g"))}
```
---
`Eval.me(...+"g")` - Affixes "g" to the input, making it a BigInteger.
`modInverse(...)` - Performs the inverse modulo operation.
---
# Java 8, 70 bytes
```
{a,b->return BigInteger.valueOf(a).modInverse(BigInteger.valueOf(b));}
```
[Answer]
# [R](https://www.r-project.org/), ~~33~~ 28 bytes
```
pryr::f(match(b,a%%1:(a+1)))
```
[Try it online!](https://tio.run/nexus/r#S7P9n1aal1ySmZ@nkaiTpJmbWJKcoZGkk6iqamilkahtqKn5P03DVMdIkytNw1LHBERZQHhmOmYQnjmIMoLJmYIoQwMdQ83/AA "R – TIO Nexus")
-4 bytes thanks to Jarko Dubbeldam.
-1 byte thanks to Giuseppe.
Returns `NA` if there is no solution. TIO doesn't have the pryr library installed, so the code at that link uses `function(a,b)` instead.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~11~~ 10 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
³%_⁴
r‘ÇÐḟ
```
A full program taking the two positive integers, `a` and `b`, and printing a list of the integer solutions between `min(a,b)+1` and `max(a,b)+1` inclusive.
**[Try it online!](https://tio.run/nexus/jelly#ARoA5f//wrMlX@KBtApy4oCYw4fDkOG4n////zj/Mg)**
[Answer]
## Mathematica 36 Bytes
```
a_±b_:=Select[Range[9a],a~Mod~#==b&]
```
Input:
```
5 ± 2
9 ± 4
8 ± 2
6 ± 6
8 ± 7
2 ± 4
8 ± 5
10 ± 1
```
Output:
```
{3}
{5}
{3, 6}
{7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, \
25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, \
42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54}
{}
{}
{}
{3, 9}
```
[Answer]
# [Haskell](https://www.haskell.org/), 33 bytes
Crashes with `code.hs: out of memory (requested ??? bytes)` if there is no solution (times out on TIO before that):
```
a!b=[x|x<-[b+1..],mod(a-b)x<1]!!0
```
[Try it online!](https://tio.run/##HYyxDoIwGIR3nuJgglgJGDVKgMXJRCdHQsxfaIQIrWlrYPDdsbrcfXe5XEfmKYZhWcjnRTV/5nxd8VUaxzUbVRvSmkdznta@nywj9RIFRnpd7whfb3uz@iIR46GcTEq3JnIw9FIYFHmOh7AnJa2Q1mDqhBYeftuKGK/dUaNkQ/YXA4aAcRagLB2YTk0IQy2oBSHLcJY2go9/waN62WHjHbH1Ds732HtpgvQL "Haskell – Try It Online")
Thanks at [Ørjan Johansen](https://codegolf.stackexchange.com/users/66041/%c3%98rjan-johansen?tab=profile) for spotting a mistake!
[Answer]
# [C# (Mono C# compiler)](http://www.mono-project.com/docs/about-mono/languages/csharp/), ~~57 56~~ 26 bytes
Port of Rod's [Python answer.](https://codegolf.stackexchange.com/a/120912/82859)
Thanks to W W for -1 byte.
HUGE thanks to Kevin Cruijssen for -30 bytes.
```
a=>b=>a-b>b?a-b:a==b?a+1:0
```
[Try it online!](https://tio.run/##fY2xCsIwFEX3fkXGBKO0xVZtqQ5CJzs5OKc1yIP2BfpSQUq/PRpwNC73XjgcbkfrwaBxEwE@2PVFVg9l1ysi1sxklYWOAVpWc59K@mzFPGo7jcjVuj224vSpgquq8nOVFHG5OBd95aeBO2sUIBdzdDZIpteb2whWXwA1r3kmUyHKn@ggtyG0D1u5zMPWLoTSf19ZCCWxTDxbosW9AQ "C# (Mono C# compiler) – Try It Online")
[Answer]
# Pyth, 16 bytes
```
hhx!0mqeQ%hQdShh
```
[Try it online!](http://pyth.herokuapp.com/?code=hhx%210mqeQ%25hQdShh&debug=0)
[All test cases](http://pyth.herokuapp.com/?code=hhx%210mqeQ%25hQdShh&test_suite=1&test_suite_input=%5B5%2C+2%5D%0A%5B9%2C+4%5D%0A%5B8%2C+2%5D%0A%5B6%2C+6%5D%0A%5B8%2C+7%5D%0A%5B2%2C+4%5D%0A%5B8%2C+5%5D%0A%5B10%2C+1%5D&debug=0)
Takes input as `[a, b]`, errors if no solution found. Will revise if erroring isn't allowed.
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), 19 bytes
```
A←{(⍳⍵+1)/⍨⍺=⍵|⍨⍳⍵+1}
```
[Try it online!](https://tio.run/nexus/apl-dyalog#@@/4qG1Ctcaj3s2PerdqG2rqP@pd8ah3ly2QVwNmQsRr//@vftQ3FagWyNVRf9Q2SV1Hw@hRVzOQq@moYAhh1R5aofGoq8lUwUhTB8SwVDCBMCxgImYKZjARcwjDCKHGFMIwNFAw1AQA "APL (Dyalog Unicode) – TIO Nexus")
Golfing in progress...
[Answer]
# Mathematica, 28 bytes
```
Which[#>2#2,#-#2,#==#2,#+1]&
```
[Answer]
# PHP>=7.1, 51 Bytes
```
for([,$a,$b]=$argv;++$x<2*$a;)$a%$x!=$b?:print$x._;
```
[Online Version](http://sandbox.onlinephpfunctions.com/code/9b7ef707279c3b1e85c55023a15bb1312ec5600d)
[Answer]
# Axiom, ~~147~~ 128 bytes
```
g(a:PI,c:PI):Union(List PI,Stream INT)==(a<c=>[];r:=a-c;r=0=>expand((a+1..)::UniversalSegment INT);[b for b in divisors(r)|b>c])
```
ungolf it and test
```
--a%b=c return all possible b
f(a:PI,c:PI):Union(List PI, Stream INT)==
    a<c=>[]
    r:=a-c
    r=0=>expand((a+1..)::UniversalSegment INT)
    [b  for b in divisors(r)|b>c]
(3) -> [[i,j,g(i,j)] for i in [5,9,8,6,8,2,8,10] for j in [2,4,2,6,7,4,5,1]]
   (3)
   [[5,2,[3]], [9,4,[5]], [8,2,[3,6]], [6,6,[7,8,9,10,11,12,13,14,15,16,...]],
    [8,7,[]], [2,4,[]], [8,5,[]], [10,1,[3,9]]]
                                                      Type: List List Any
```
This would find all the solution even the infinite set solution...
[Answer]
# [Pip](https://github.com/dloscutoff/pip), 9 bytes
```
a%,a+2@?b
```
Takes the two numbers as command-line arguments. Outputs the smallest solution, or nil if no solution exists. [Try it online!](https://tio.run/##K8gs@F/9P1FVJ1HbyME@6X@tgm@oQjSXQrSpglEskLJUMAFRFhCemYIZhGcOooxgcqYgytBAwTCWK/b/f90AAA "Pip – Try It Online")
### Explanation
```
           a, b are cmdline args (implicit)
  ,a+2     Range from 0 up to but not including a+2
a%         Take a mod each of those numbers
           (Note that a%0 returns nil; it emits a warning, but only if warnings are turned on)
      @?b  Find the index of the first occurrence of b in this list, or nil if it doesn't occur
           Autoprint (implicit)
```
For example, with input of `8` and `2`:
```
   a+2   10
  ,      [0 1 2 3 4 5 6 7 8 9]
a%       [() 0 0 2 0 3 2 1 0 8]
```
The 0-based index of the first occurrence of `2` in this list is `3`, which is our solution.
[Answer]
# [J](http://jsoftware.com/), 14 bytes
```
(->]){-,~=*1+]
```
[Try it online!](https://tio.run/##PUy7DcMgFOzfFKc0NgQsQwz@SLjIAFnAooDChSewFMWrE/QK63Tf4o7y6NDsCEsDhd@CHpWl1WsUX62uIM0zFkGfd4etTSFkIfWVVNI5bmnN0sbisMPSXHWgibOv6jmPZO/dkemrGS4D8ecLDh4jTsaM8w8 "J – Try It Online")
Translation of [Rod's Python 2 solution](https://codegolf.stackexchange.com/a/120912/78410).
### How it works
The rare cases where a J code can be directly translated into Python.
```
(->]){-,~=*1+]  <=>  [(a==b)*(1+b),a-b][a-b>b]
         =*1+]        (a==b)*(1+b)
      -,~            [            ,a-b]
     {                                 [     ]
(->])                                   a-b>b
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 13 bytes
```
UµV ?U>V©U:ÒV
```
[Try it online!](https://ethproductions.github.io/japt/?v=1.4.6&code=VbVWID9VPlapVTrSVg==&input=OCAz)
Translation of [eush77's JS solution](https://codegolf.stackexchange.com/a/120913/78410).
The code is just `(U-=V)?U>V&&U:-~V` when transpiled to JS, where `U` and `V` are the two input values.
[Answer]
# [Ruby](https://www.ruby-lang.org/), 31 bytes
```
->a,b{(1..a+1).find{|x|a%x==b}}
```
[Try it online!](https://tio.run/##KypNqvyfZvtf1y5RJ6law1BPL1HbUFMvLTMvpbqmoiZRtcLWNqm29j9IxkJTLzexACRcoJAWbaFTEVv7HwA "Ruby – Try It Online")
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 7 bytes
(Eventually) Outputs `undefined` if there's no solution.
```
@%X¥V}a
```
[Try it here](https://ethproductions.github.io/japt/?v=1.4.6&code=QCVYpVZ9YQ==&input=NQoy)
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), 23 bytes
```
{grep $^a%*==$^b,^$a+2}
```
[Try it online!](https://tio.run/##K0gtyjH7n1upoJamYPu/Or0otUBBJS5RVcvWViUuSSdOJVHbqPZ/cWKlQpqGqY6CkWadkoKdnYKxkjUXRNBSR8EEKmgKF7RAUqlgBhc201EwgwqbI6s1hwr6@SsE@/uEhnj6@8GljRDmY5MG6jbFI21ooGMId4ilkvV/AA "Perl 6 – Try It Online")
Anonymous code block that returns a list of possible values from `2` up to `a+1`
[Answer]
# [ORK](https://github.com/TryItOnline/ork), 566 bytes
```
When this program starts:
I have a inputter called I
I have a number called a
I have a number called b
I is to read a
I is to read b
I have a mathematician called M
M's first operand is a
M's second operand is b
M is to subtract
I have a number called n
n is M's result
M's first operand is b
M's second operand is n
M is to compare
I have a scribe called W
If M says it's less then W is to write n
If M says it's less then W is to write "\n"
M's second operand is a
M is to compare
If M says it's equal then W is to write a
If M says it's equal then W is to write a
```
[Try it online!](https://tio.run/##jZCxbsMwDER3fQWRJXPG9g88ePbShVKYWqhMOSSVIF/vymlSp2gMZBFA3t07Qlm@pqnricH6qDBK/hQcQA3F9N010OOJACHyWMxIIGBKtIdmkbgMfhFwTfBVqA2WQQh/fA@jX2IDWk/1iSEi39Ota7cKhyhqkEcS5P0cx@taKeQ6P@y9a290Ld4Eg62dxY5n54wR0pLseZFfKeLfopCHEYWWHg0SPd17OtccoAXFi0K0ykqkNTf/fHcjnCUaVeKLxs0Hb1auwv9X/WXSsWB6BsXXndP05nbf "ORK – Try It Online")
**O**bjects **R** **K**ool. Luckily, however, I didn't need to use any (besides the built-in ones) for this task.
[Answer]
## F#, 40 bytes
```
let m a b=Seq.find(fun x->a%x=b){1..a+1}
```
[Try it online!](https://tio.run/##ZZBBC4IwGIbv/YqXYKCkkpJWlN46F3QUD7NcDGrVXGFUv32tBWL13Z4978b7jdX@5igrrfeVwgEUZbquzgHjYuuwi0DjZ5Q0aenewyCgg/Cp8/lCKHlbHblQWdGz9ygXoHJ3RdqDmdyJPUTuzAKcqYdRC5OuSTwkLYRDD2E3N24h@nkhdmeFpUeGd12uKgnb90S5hJ99ombe9ShSsFpZ9yVKI2qx/ReNEfYz2tOTNOsygT7hIARkaRKE902mQena2FC/AA)
Pretty straight-forward. Throws a `System.Collections.Generic.KeyNotFoundException` if no solution can be found.
You could also modify it to `Seq.tryFind`, which will return an `int option`, with `None` if no solution could be found.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), 7 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
>Lʒ¹s%Q
```
[Try it online](https://tio.run/##yy9OTMpM/f/fzufUpEM7i1UD//@34DICAA) or [verify all test cases](https://tio.run/##MzBNTDJM/V9Waa@k8KhtkoKSfWVC6KGV/@18Tk06tK5YNSLwf63O/@hoUx2jWB2FaEsdExBlAeGZ6ZhBeOYgyggmZwqiDA10DGNjAQ).
**Explanation:**
```
>          # First (implicit) input + 1
 L         # Create a range [1, n]
  ʒ        # Filter; only keep elements where:
   ¹s%     #  The first input modulo this value
      Q    #  Equals the second (implicit) input
```
[Answer]
# Java 8, 26 bytes
```
a->b->a-b>b?a-b:a==b?a+1:0
```
[Port of *@Epicness*' C# answer](https://codegolf.stackexchange.com/a/173141/52210), after I golfed it a bit more.
[Try it online.](https://tio.run/##nY67DoJAEEV7vmJKNspGiPhm7UwsrCiNxfAyi@tCZCAxxm/HNaKtaDM5yZzce3Ns0MmTUxsrrCrYodQ3C6AiJBlDbr68Jql4VuuYZKH5poPVVlN6TC/DflIHQkAGQYuOiByBTiSitbkLDAIDA3cxapeWqS/rSJn6bkVTyATOZpkd0kXq4/6A7DkSILxWlJ55URMvzYeUtjOOZamuts868BhbfpPnb3ncQ579kjxhH/ghedpD9v7a7PeQ3dHbdl/23bq3Dw)
[Answer]
# [><>](https://esolangs.org/wiki/Fish), 21 bytes
Same trick as most posted solutions. First, we prepare all necessary values on the stack and then check the comparisons.
```
::r::{-:{)?nr=?!;1+n;
```
[Try it online!](https://tio.run/##S8sszvj/38qqyMqqWteqWtM@r8jWXtHaUDvP@v///7plCoYGYBIA "><> – Try It Online")
[Answer]
# [Whispers v2](https://github.com/cairdcoinheringaahing/Whispers), 128 bytes
```
> Input
> Input
>> 1²
>> (3]
>> 1%L
>> L=2
>> Each 5 4
>> Each 6 7
>> L⋅R
>> Each 9 4 8
> {0}
>> {10}
>> 12∖11
>> Output 13
```
[Try it online!](https://tio.run/##K8/ILC5ILSo2@v/fTsEzr6C0hAtO2ykYHtoEojSMY8E8VR8Q5WNrBKJcE5MzFEwVTOBsMwVzsPSj7tYguKClgomCBdDIaoNakFi1IYQ2NHrUMc3QEMT0Ly0B2qZgaPz/vwWXOQA "Whispers v2 – Try It Online")
Returns a set of all possible solutions, and the empty set (i.e. \$\emptyset\$) when no solution exists.
## How it works
Unsurprisingly, it works almost identically to most other answers: it generates a list of numbers and checks each one for inverse modulus with the argument.
If you're familiar with how Whispers' program structure works, feel free to skip ahead to the horizontal line. If not: essentially, Whispers works on a line-by-line reference system, starting on the final line. Each line is classed as one of two options. Either it is a **nilad line**, or it is a **operator line**.
Nilad lines start with `>`, such as `> Input` or `> {0}` and return the exact value represented on that line i.e `> {0}` returns the set \$\{0\}\$. `> Input` returns the next line of STDIN, evaluated if possible.
Operator lines start with `>>`, such as `>> 1²` or `>> (3]` and denote running an operator on one or more values. Here, the numbers used do not reference those explicit numbers, instead they reference the value on that line. For example, `²` is the square command (\$n \to n^2\$), so `>> 1²` does not return the value \$1^2\$, instead it returns the square of line **1**, which, in this case, is the first input.
Usually, operator lines only work using numbers as references, yet you may have noticed the lines `>> L=2` and `>> L⋅R`. These two values, `L` and `R`, are used in conjunction with `Each` statements. `Each` statements work by taking two or three arguments, again as numerical references. The first argument (e.g. `5`) is a reference to an operator line used a function, and the rest of the arguments are arrays. We then iterate the function over the array, where the `L` and `R` in the function represent the current element(s) in the arrays being iterated over. As an example:
Let \$A = [1, 2, 3, 4]\$, \$B = [4, 3, 2, 1]\$ and \$f(x, y) = x + y\$. Assuming we are running the following code:
```
> [1, 2, 3, 4]
> [4, 3, 2, 1]
>> L+R
>> Each 3 1 2
```
We then get a demonstration of how `Each` statements work. First, when working with two arrays, we zip them to form \$C = [(1, 4), (2, 3), (3, 2), (4, 1)]\$ then map \$f(x, y)\$ over each pair, forming our final array \$D = [f(1, 4), f(2, 3), f(3, 2), f(4, 1)] = [5, 5, 5, 5]\$
[Try it online!](https://tio.run/##K8/ILC5ILSo2@v/fTiHaUEfBSEfBWEfBJJYLyDUBs4EihkCunYKPdhCIck1MzlAwVjBUMPoP5PmXlhSUliiY/AcA "Whispers v2 – Try It Online")
---
**How *this* code works**
Working counter-intuitively to how Whispers works, we start from the first two lines:
```
> Input
> Input
```
This collects our two inputs, lets say \$x\$ and \$y\$, and stores them in lines **1** and **2** respectively. We then store \$x^2\$ on line **3** and create a range \$A := [1 ... x^2]\$ on line **4**. Next, we jump to the section
```
>> 1%L
>> L=2
>> Each 5 4
>> Each 6 7
```
The first thing executed here is line **7**, `>> Each 5 4`, which iterates line **5** over line **4**. This yields the array \$B := [i \: \% \: x \: | \: i \in A]\$, where \$a \: \% \: b\$ is defined as the [modulus](https://en.wikipedia.org/wiki/Modulo_operation) of \$a\$ and \$b\$.
We then execute line **8**, `>> Each 6 7`, which iterates line **6** over \$B\$, yielding an array \$C := [(i \: \% \: x) = y \: | \: i \in A]\$.
For the inputs \$x = 5, y = 2\$, we have \$A = [1, 2, 3, ..., 23, 24, 25]\$, \$B = [0, 1, 2, 1, 0, 5, 5, ..., 5, 5]\$ and \$C = [0, 0, 1, 0, 0, ..., 0, 0]\$
We then jump down to
```
>> L⋅R
>> Each 9 4 8
```
which is our example of a dyadic `Each` statement. Here, our function is line **9** i.e `>> L⋅R` and our two arrays are \$A\$ and \$C\$. We multiply each element in \$A\$ with it's corresponding element in \$C\$, which yields an array, \$E\$, where each element works from the following relationship:
$$E\_i =
\begin{cases}
0 & C\_i = 0 \\
A\_i & C\_i = 1
\end{cases}$$
We then end up with an array consisting of \$0\$s and the inverse moduli of \$x\$ and \$y\$. In order to remove the \$0\$s, we convert this array to a set (`>> {10}`), then take the set difference between this set and \$\{0\}\$, yielding, then outputting, our final result.
[Answer]
**C#, 53 bytes (83 with function heading)**
```
static int F(int a, int b){
    for(int i=1;i<=a+1;i++){if(a%i==b)return i;}return 0;
}
```
[Try It Online](https://tio.run/nexus/cs-mono#fY0xC8IwEIX3/oosQkKDtMVWJWYSOtnJwTmtqRzUBJJUkJDfXm3Rzbi8u3cf795oQd3Q@WmdvLOkG4S1qPGJdcJBh0A5VONZBV1MS/zUa7OcgOcMDlyk75GmxEOPxQo4b4mRbjQKAQufLWNT@P58aLiiRoDCxCdHrawe5PpiwMkTKIlrXNKCEPYT7ekmhnbxVEWreGobQ8W/rjKG8ozmMwtJmF4)
First try at codegolf. Probably not the best language to use, nor the most efficient coding.
]