[Question]
  [
Given two nonempty arrays of natural numbers \$a\$ and \$b\$, return the shortest nonempty array of pairs of natural numbers \$q\$ such that the sequence of first elements of \$q\$ consists of a whole number of repeated copies of \$a\$, and the sequence of second elements of \$q\$ consists of a whole number of repeated copies of \$b\$.
When \$a\$ and \$b\$ have the same length, this acts like a zip, but when the lengths of \$a\$ and \$b\$ are coprime, this acts like a Cartesian product.
You can use any reasonable input and output format for arrays (pointers, lists, space-separated strings, strings of char codes, etc.)
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the shortest valid answer (measured in bytes) wins.
## Test Cases
```
[1],          [2]       -> [(1, 2)]
[1, 2],       [3]       -> [(1, 3), (2, 3)]
[1, 2],       [3, 4]    -> [(1, 3), (2, 4)]
[1, 2, 3, 4], [5, 6]    -> [(1, 5), (2, 6), (3, 5), (4, 6)]
[5, 5, 5],    [5, 5, 5] -> [(5, 5), (5, 5), (5, 5)]
[5, 5],       [5, 5, 5] -> [(5, 5), (5, 5), (5, 5), (5, 5), (5, 5), (5, 5)]
[1, 2, 3, 4], [1, 2, 3, 4, 5, 6] ->
    [(1, 1), (2, 2), (3, 3), (4, 4),
     (1, 5), (2, 6), (3, 1), (4, 2),
     (1, 3), (2, 4), (3, 5), (4, 6)]
```
  
[Answer]
# [J](http://jsoftware.com/), ~~14~~ 13 bytes
```
,./@($&>~*./)
```
[Try it online!](https://tio.run/##dY9NCsIwEIX3PcVDim2lTc3kZ9GiCIIrV15BLOLGG3j1OFOTakUJGV6G703e3MJCFQM2HQrUWKPj2yjsT8dDqFW7K/Pl9rFSbRWqLLucr3eUGoQcXCs0nTx7kQN3dCQoEgYsTMKIQSMg/QbtDJSnoBRRG1EnqAcDrCz828QWNjppDSyT0YxG9@Ic5PRjdcIZPhH03@AHxtPT9imzliCEcQJ/ZzELp6VHmHb7HzipKbgPTw "J – Try It Online")
*-1 byte thanks to Bubbler*
This answer takes the two lists as its left arg, and the two list lengths as its right arg.
* `($&>~*./)` is a dyadic hook which applies gcd between the two right arg lengths `*./` and the reshapes the two left arg lists `$` to that length after opening them `&>`. At this point they'll be the same length so boxing is no longer needed.
* `[:,./` so now we can just zip them `,.`
---
## original answer taking the lists directly
## [J](http://jsoftware.com/), ~~17~~ 16 bytes
```
(*.&#$[),.*.&#$]
```
[Try it online!](https://tio.run/##dY49C8IwEIb3/ooXLbaRNpjLxxBwEpycXMVJLMXF/z/FS7wWK0pI7sjzHPc@0ko3A/YRDTrsEPn2Gofz6Zjard6s64vqdGmuSVXV/TY@0RoQavCr0EeuA0gICbHgxgomFuwvwX0KcKI4UXxWAphw5xBmmVUe8AgyYMuAL9yXM7yr8PDFl9RMkUzeR3mfzfscFhlM/iPM0f/mmjrOl14 "J – Try It Online")
* `*.&#` is the gcd `*.` after taking length `#` of both args
It turns out to be shorter to repeat this phrase than to remain DRY.
* `,.` is zip and and `$` is shape. So we shape the left arg `[` by the gcd of the list lengths, do the same to the right arg `]`, and zip them.
[Answer]
# [C (clang)](http://clang.llvm.org/), ~~70~~ 68 bytes
```
i;f(*a,*b,x,y){for(i=0;printf("(%d,%d)",a[i%x],b[i%y]),++i%x+i%y;);}
```
[Try it online!](https://tio.run/##hZDdboMwDIXveQqrVaVk9X5ICL1g2@VeguWCFLpF6mjVUmldxbN3TgiMdpMmBNjHn53jLG@X66J@O59ttmI3Bd4Y/MQjP602O2afHrLtztbNik3YrMRZySdY5Hb2qdHQ76g5zueU0nvMeNaep7Zerg9lBY/7prSbu/fnKJqW1crWFbywAg2HfmAOE05HkoZ7@1VtKOT3ISKC96q5UHm2PTR7NgH9WlN/FJEIH4WtGYdTBC4r4lzDE5ziFsGEWLRZ5AzEaGIeBU4EDoUjQyYDKdCIgZQXZMgkJoGVaOTAJgOLjiA@KArTwCdokoFXfZUeR1/kHa/QqIFPh7qj0990iiYd6EXvBgSCRPCGfokICqF3t0CzcP27qjnsanjIovacxxpyoeH2GRhtRuXcdZMoNTg1JxkkZ24g16MyTddXQDIA3emEueNHg5TnUs6kjxMXux7ljaquoYt8i/LY6NvD/5N/947MIeTXF/WzUOyNCm9UeqMJ7xZA6FZAV4p9SfDxHVzs9g0 "C (clang) – Try It Online")
Takes input as pointer to `a` and `b` and the lengths, prints `q` to std out.
We use the modulo of an iterator by the data lengths e.g. `i % x` and `i % y` to access data, when both modules are equal to 0 , `i` is LCM and the function terminates.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 7 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
ṁ€æl/}Z
```
A dyadic Link accepting a list of the two lists on the left and a list of their respective lengths on the right which yields a lists of lists.  
(A monadic Link accepting only the left argument costs 8 bytes, `ṁ€Ẉæl/$Z`)
**[Try it online!](https://tio.run/##y0rNyan8///hzsZHTWsOL8vRr436//9/dLShjoKRjoKxjoJJrI4CEk9HwVRHwSw29n@0CYgGAA "Jelly – Try It Online")** Or see the [test-suite](https://tio.run/##y0rNyan8///hzsZHTWsOL8vRr436f3j5w10dRyc93DlDM/L//@joaMNYHQU4iDaKjeXSAQrqKBjBxaONsQrqKJggxHUUwHwdhWhTHQUziDiQBUIQLXAeXAphFIoUqmkIHlgNyORYAA "Jelly – Try It Online").
### How?
```
ṁ€æl/}Z - Link: list of lists [a, b], list [length(a), length(b)]
     }  - use the right argument as the left argument of:
    /   -   reduce by:
  æl    -     least common multiple (i.e. LCM(length(a), length(b))
 €      - for each list in the left argument (i.e. for x in [a,b]):
ṁ       -   mould like (i.e. repeat x cyclically until its length is the calculated LCM)
      Z - transpose
```
[Answer]
# [R](https://www.r-project.org/), ~~69~~ ~~60~~ ~~54~~ 51 bytes
```
function(a,b,x,y)cbind(rep(a,y/sum(!(1:x*y)%%x)),b)
```
[Try it online!](https://tio.run/##JYpBCoAgFAX3ncIWgj9ehGUtpMtkJbTIohL09Ca1GYZhrmTZWLNkvZuf7XBigkFApNlsbhHXeuYSm9vvohRShyoS54EIhpLNYYDUCgMUFfa7e3SEX1pCl5Fe "R – Try It Online")
Loosely based on [my answer to this question](https://codegolf.stackexchange.com/a/143726/67312). Takes `a`,`b`, and the lengths as `x` and `y`, respectively.
Returns a two-column matrix.
Thanks to [Robin Ryder](https://codegolf.stackexchange.com/users/86301/robin-ryder) for [saving 4 bytes](https://tio.run/##K/qfpmCjq/A/rTQvuSQzP08jUSdJp0KnUqfQ1tCqQqtSMzkpMy9Foyi1ACiTm5mnURitWKiqWhGrqV@hqZOk@T9Nw9DKTMfQykTHTMdEkysNrNRUx1hTB8Iw0tQxBhL/AQ), and then another 3.
Relies on the identity \$xy=GCD(x,y)\cdot LCM(x,y)\$; repeats `a` by \$y/GCD(x,y)\$ times to get it to the LCM length, and `cbind` automatically recycles `b` accordingly.
[Answer]
# [J](http://jsoftware.com/), 8 bytes
```
*.&#$&>;
```
[Try it online!](https://tio.run/##hY@9DoIwGEV3nuJGCYKBxv7AUKODJk7GwZW4qKBxcXLz3evXAg0iiWna3rbnJLcPM2GzGiuNGVIsoGlmDNvjfmfmLJqG0XppcNgwBLE7l0nKXDgFSXCtzq@blcvqcn8GdkH81hwCIWhNkGk0UJzyBDVS4SnRUhIUZA@1OpFynFQ/pITyqGrR3KIF6I2SQjGQSCExR@FF6cS8x@Vu1M3uuWKUG1K8q8xtD2F7SNtD4asbt3cC/mt/@naJepsP "J – Try It Online")
Takes two vectors as left/right args and gives a two-row matrix where each column represents a pair. If you insist a two-column matrix, prepend `[:|:` to the code, which is still shorter than [previous J answer](https://codegolf.stackexchange.com/a/197934/78410).
### How it works
```
*.&#$&>;  NB. Tacit function; left=vector 1, right=vector 2
       ;  NB. Nested 2-item vector of two vectors
    $&>   NB. Disclose each and recycle to the length of...
*.&#      NB. LCM of the lengths
          NB. Two disclosed vectors automatically form a 2-row matrix
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), 7 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
€g.¿δ∍ø
```
Takes the input as a pair of lists of integers.
[Try it online](https://tio.run/##yy9OTMpM/f//UdOadL1D@89tedTRe3jH///R0YY6CkY6CsY6CiaxOgpIPB0FUx0Fs9hYAA) or [verify all test cases](https://tio.run/##yy9OTMpM/V@m5JlXUFpipaBkX6nDpeRfWgLjufx/1LQmXe/Q/nNbHnX0Ht7xX@fQNvv/0dHRhrE60UaxsToKQKaOEZBjjMLRMYFzdUAcnWhTHTOIkKkOEIIFQDRMCFUAoQ3K0gFrjwUA).
**Explanation:**
```
€g       # Get the length of each inner list in the (implicit) input-pair of lists
  .¿     # Take the Least Common Multiple for the two values in this pair of lengths
    δ∍   # Extend both inner list in the (implicit) input-pair of lists to this length
      ø  # Then zip/transpose the (now equal-length) list of lists, swapping rows/columns
         # (after which the result is output implicitly)
```
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), ~~39~~ ~~36~~ 25 bytes
*-3 bytes thanks to Jo King*
```
{zip $_>>[^[lcm]($_)X%*]}
```
[Try it online!](https://tio.run/##K0gtyjH7n1upoJamYPu/uiqzQEEl3s4uOi46Jzk3VkMlXjNCVSu29n9xYqVCGlBKIS2/iEtDw1BHU0dBw0hHU1MHzFMwAvGNMfgKJggRHQUwHyhuqqNgBhEHskAIKghmwsUxBFENQfDAaoAG/gcA "Perl 6 – Try It Online")
### Explanation
```
{                       }  # Anonymous block
     $_>>[             ]   # Index into both input arrays
          ^[lcm]($_)       # Range [0,lcm)
                    X%*    # modulo array size
 zip  # Zip
```
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~85~~ 76 bytes
```
n;z(a,i,j)int*a;{for(n=0;a[n*2+i+j]=a[n%i],a[n+++n+i+j]=a[n%j+i],n%i+n%j;);}
```
[Try it online!](https://tio.run/##bZHdcoIwEIXveYpIx5nErBVsbevE9EWUC0DUMHQtFKczMjw73YD4V2824ezhy@YkHm/juHkyGGeHdbL4Kddm/7z7dK6VzER3UmFwayXHYMmO3NYRMLt0Vaiu9RUa5MKpHNbKBlJgqD11@g6XvucFuvJhCi/wCjN4g3f4gDl4tWJGz3tj9M9oDameWcNkYrQdQTAaLEuQh8L2bqRI9KjcolpYbaXNvmDcjoQLo1BKQQYMdEjlrp2e29IEOjoZjjwHulaL/6ZYyg13Q82HaxfCpRe0OmrfLr87kyWMW/RAe@Jsh85M9OAGI1YYdaToMSl6SIoeknLtnghGpleMvGeQxFjV/0HHEkwwF6zBFukTE6WeqtbJzIbxAec4NuNUDH1PXMZYYXcWYzXVIikPBTJ69LpBdeRhmxc5R6GqKN82Xrr@aCpptDb6oQm6QCRetJRiB2pJ2iqh6qb5Aw "C (gcc) – Try It Online")
Thanks to [ceilingcat](https://codegolf.stackexchange.com/users/52904/ceilingcat) for reduction 85->76 bytes.
The code above is golfed so that all the information is stored in a single integer array, which saves 2 bytes; the logic though is the same as previously with three arrays. 
[Try code with three arrays online](https://tio.run/##bZHdcoIwEIXv8xQrHWcSiRXs/6TpiyAXCaLGoVEQxxkZXr10E6q11psNe86ZbzchGy@zrMtWqgKVxFGUyibmU/7AH/kTf@Yv/JW/8agVxEf0v8jZKp3lTVSMrcHwNQcrI9EdKWvmm6ZM7GiaSpXYoUkFdmEY2lRq7NepaA8rU@QUvRB7Jtruztis2M/z9109N5v71Qe5VAqjr6TK2KWTyGTi5h/NlvrNRhyuT@f3lQnit/1UxlJGGgJednu7T0mxY4DwIrdUMQHrv5JmLoc3RA7AFneoFzRQkg7nAVdJlHrfytgd/opA8QXSgYzYOc77MD5IHz/pbGZ1T9K3SfomSd8klTL4IUQXhPJEQAmgOeVxKKIYBNwFXAljJNpQToVPglkAHeDviiP2O35m@xkALdYqr/eVBRzXEtJ9ZYtCLXfd@PAN) this code has less bytes, but the arrays are global so that information is not directly passed in or out of function.
# How
description of algorithm with ungolfed code or at least less golfed code.
setup (see online code)
* `a[],b[]` input data - `q[]` output data
* `i,j` length of `a,b`
* `n` loop counter
```
do{                              }while(n%i+n%j);}
 // open loop that ends when counter mod i and j =0
   q[n*2]=a[n%i];
 // q[0,2,4...]=a[0,1,2...]   
                 q[n+++n]=b[n%j];
 // q[1,3,5...]=b[0,1,2...]  and increase loop counter 
```
In the golfing process all the data input and output was put into a single `int` array. The first `i` members are the contents of `a`, the next `j` members are the contents of `b` and the remainder of the array is filled with zeroes so that when `q` is calculated it can be placed directly after the `b` items in the same array the first zero in the array indicates `q` end. This use of a single integer array for data input and output saves 2 bytes. OP has indicated that this approach is acceptable for this challenge. 
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), 35 bytes
```
{$^a <<,<<flat $^b xx($a lcm$b)/$b}
```
[Try it online!](https://tio.run/##ZYxBCoMwFET3nmIWH0ngQ9FWV@lVlKQ0q4iiLgy2Z48xLZUizGLeY5jhObo6dB65xT2s1GgoxUpZp2dQY7AsgjTcoyMjL2TeYdIeFi9qYfsxE6JgyRAlS8mJUO58PTFuh2Ekjr5i1B8f256vTPXnT/L/5KC0iYdhAw "Perl 6 – Try It Online")
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 21 bytes
```
≔¹ηＷ⊙θ﹪ηＬκ≦⊕ηＩＥηＥθ§λκ
```
[Try it online!](https://tio.run/##TY07D8IwEIN3fsWNV@kYeC6dIqZKVGKPMkRN1ESEa0nD69eHFBjwYlnyZ3dOx27QIWcxTb5nXBG4ql48nA8WUPALrwTtYG5hQEdwtNwnh@eqCFo9/qiGu2gvlpM1X/4UPSc86Clhac3kbGVKpIaNfWIg@IxUdc5SynK7JtgQbBXBXyLYEeyVUnl5D28 "Charcoal – Try It Online") Link is to verbose version of code. Takes input as an array of arrays and outputs as a double-spaced list of pairs. Explanation:
```
≔¹ηＷ⊙θ﹪ηＬκ≦⊕η
```
Count up from 1 until the LCM of the lengths of the arrays has been reached. (This O(n²) but even O(n) would cost 3 bytes.)
```
ＩＥηＥθ§λκ
```
Map over the implicit range and cyclically index both arrays.
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 42 bytes
```
Thread@PadRight[#,{2,LCM@@(Length/@#)},#]&
```
[Try it online!](https://tio.run/##bYw9C4MwGIR3f8VBQFp4i2g/NkugqwUp3SRDqNE46CDZQn57GkNLLS3ccPfccaM0Wo3SDA/pO5T@rmclW17L9jb02jSMbEHV5cr5plJTb3TG2dYRE6mv52EKA@zO6BomBFJkPIG1NncEWzhHCULMCcUC9j@AcFgzQiShORJO7yb4RS8c7ar5g7@vPimuwq3zTw "Wolfram Language (Mathematica) – Try It Online")
[Answer]
# [Python 3.8 (pre-release)](https://docs.python.org/3.8/), ~~78~~ 76 bytes
-2 bytes thanks to Noodle9
```
lambda a,b:zip((x:=len(b))//(g:=math.gcd(y:=len(a),x))*a,y//g*b)
import math
```
[Try it online!](https://tio.run/##jY5BCsIwEEX3PcUsZyQ0aFWk0JOoi4m17UCahjRC6@Vjih5A@PAW//H5fo3D5KqLD6mDBm7J8mhaBlamfotHXOrGPh0aIq2xr5uR41D2jxbXb8GkFqIdq1XrfmeokNFPIcLmJc6TV3ERhaCbAgiIy/GviFTO3krmvTB/WYUPm2NljtghK8iXKO3hABUcix/hBOcP "Python 3.8 (pre-release) – Try It Online")
[Answer]
# [APL (Dyalog Extended)](https://github.com/abrudz/dyalog-apl-extended), 9 bytes
```
,¨/∧⍥≢⍴¨⍮
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT9dNrShJzUtJTfn/X@fQCv1HHcsf9S591LnoUe@WQyse9a77n/aobcKj3r5HfVM9/R91NR9ab/yobSKQFxzkDCRDPDyD/6snqiukKagnqXOpJyaBmclgZjKYnZKaBuGlgLmpaekZmVnqXAA "APL (Dyalog Extended) – Try It Online")
Takes two input strings as left and right arguments respectively. Being able to take lengths as separate arguments doesn't really help.
### How it works
```
,¨/∧⍥≢⍴¨⍮  ⍝ left: string a, right: string b
        ⍮  ⍝ 2-item nested array of [a, b]
      ⍴¨   ⍝ Reshape (by cycling elements) each of [a, b] to the length of...
   ∧⍥≢     ⍝   LCM of lengths of a and b
,¨/        ⍝ Reduce by "pair up element-wise"
```
[Answer]
# JavaScript (ES6), ~~77 68 64~~ 58 bytes
*Saved 6 bytes thanks to @AZTECCO*
Takes input as `(a, b, a_length, b_length)`.
```
(a,b,n,N)=>(g=i=>[[a[i%n],b[i%N]],...++i%n+i%N?g(i):[]])``
```
[Try it online!](https://tio.run/##hZFbDoIwEEX/XUV/TNo4QvqADxN0B2xg0kR8EYwBI8btYysTkYdhQnO5LZx2bq/ZK6uPj@L@XJfV6dxckoZncIASUpFseZ4UyRYxw2JZWjg4Sa2FIAhWKzfjRrrLeSE2aK3Y75tjVdbV7RzcqpxfOEoL7Fuofl1bEpgUgoUhQ@7elbCLIcLNfv9DPUaoPkILYFx5nUMBMwOa8icYo8w0yn3QIjACFg9Qpo@KCBV71eSN9yO0g/mn5fVdW9qfjNARoXo6iewan0CqOeQ/nQmmc589fUifprtgJAWjKBhNwRivE8FJWle03t3RKNjmDQ "JavaScript (Node.js) – Try It Online")
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), 15 bytes
```
{l×↙X}ᵛḃ₁g,?zbᵐ
```
[Try it online!](https://tio.run/##SypKTM6ozMlPN/pfXa6koGunoFRu/6htw6Ompoe7Omsfbp3wvzrn8PRHbTMjgJzZD3c0P2pqTNexr0oCSf2Pjo42jNVRiDaKBZHRhjoKRiCGMRpXR8EEIaKjAOYDuaY6CmYQcSALhKCCYCZcHEMQ1RAED6wGaGAsAA "Brachylog – Try It Online")
Initially, I thought "it's funny, Brachylog has a cycling zip builtin but I don't think I'll need it", but my various attempts at `j` and `z₂`-based solutions have simply refused to terminate on test cases where the second list is longer than the first.
```
{    }ᵛ            For each element of the input,
 l                 the length
  ×                multiplied by
   ↙X              something
{    }ᵛ            comes out to the same value.
       ḃ₁          Convert that value to unary,
         g         wrap it in a list,
          ,?       append the elements of the input,
            z      cycling zip,
             bᵐ    and remove the first element from each element of the result.
```
Note that [`{×↙Xℕ₁}ᵛ` calculates LCM](https://codegolf.stackexchange.com/a/185353/85334), but the `ℕ₁` constraint isn't necessary in this case because `z` fails if any element of its input is empty (since it can't be cycled).
[Answer]
# [Perl 5](https://www.perl.org/), 104 bytes
```
sub f{($A,$B,%s)=@_;map[$$A[$$_[0]],$$B[$$_[1]]],grep!$s{$$\_[0],$$_[1]}++,map[$_%@$A,$_%@$B],0..@$A*@$B}
```
[Try it online!](https://tio.run/##fZBRb5swEMff/Sm81hXQHCGQkKphqUi01731LUUWpYbSBsywozWK8tkzH2RJW221ZPjf3e/Of7sR7To8HNTmkeY7my2ALeFKOfOYR1XarBhbmM1XoyQBxpad9hMTFK1ovjG164vQ5/eDAXRd/CrGUfhbJjAaDk14bfT@cPmsdaNmnpfJJ1HIdT5UOs1exVv2nNaFGGay8n5thNKlrJXn397cjm68LG21UGVau@uscmXu6t/STds23SqyUYLeG342@ylbEZFqS2MDazqnaAW3atal9sBLoFcr944mg1P4UHvwIsvasuD7j8X94i4iuWztboqzI9SsamuzFNgjxOKtMY/DeHTMx4XU87yvOn2yVDaOsy8ovcDnoF1kgQWmzwHscKAjzfqSxMM@khal1v9Ic/yePMlacHRe1kVEOMcLcU784xAa0PMyz@BDQMzu4/HnmkkEMH4HwOQfwAQB6GohTD8CIQJT7DRqAlMSQogS0aPo0S74@yGn0lfUp8/ZxVEAuulc@OgiQBdjdNEhZ2c@5gJ6us7Z7eEP "Perl 5 – Try It Online")
Slightly ungolfed:
```
sub f {
  ($A,$B,%s) = @_;                #input A and B, %s is the "seen" dictionary
  map [$$A[$$_[0]], $$B[$$_[1]]], #convert indexes to values from input A and B, return that.
  grep !$s{$$\_[0],$$_[1]}++,      #filter out index pairs seen before
  map [$_%@$A,$_%@$B],            #make array of pairs where 1st elem is
                                  #...index of A and 2nd is index of B, 
                                  #...but modulo their size respectively
  0..@$A*@$B                      #loop from 0 to size_of_A * size_of_B
}
```
[Answer]
# [Ruby](https://www.ruby-lang.org/), 52 bytes
```
->x,y{a=x.size;a/=g=a.gcd b=y.size;(x*b/=g).zip y*a}
```
[Try it online!](https://tio.run/##KypNqvyfZhvzX9euQqeyOtG2Qq84syrVOlHfNt02US89OUUhybYSIqZRoZUEFNbUq8osUKjUSqz9X6CQFh1tqKNgFKujAAHRxjoKJrGxXHAZHQWwiI5CtKmOghl2GQRPRwGi6j8A "Ruby – Try It Online")
]