[Question]
  [
Inspired by [Does the start equal the end](https://codegolf.stackexchange.com/questions/120434/does-the-start-equal-the-end)
Given a string `s` and an integer `n`, output a truthy/falsey as to whether the `n`th char in `s` equals the `n`th from the end char in `s`.
# Input
A non-empty string and an integer. You can use 0-based indexing or 1-based indexing. The integer is guaranteed to be valid based on the string. For example, if the string is "supercalifragalistic123", the integer can be from 1 to 23 for 1-based indexing, and 0 to 22 for 0-based indexing. Please note that `n` can be larger than half the length of `s`.
Input is limited to printable ASCII.
# Output
A truthy/falsey value based on whether the `n`th value in `s` equals the `n`th from last value in `s`.
Please note that the last char is in position 0 for 0-based indexing and position 1 for 1-based indexing. Think of it as comparing the string to its reverse.
# Test Cases
0-indexed
```
"1", 0         Truthy 1 == 1
"abc", 1       Truthy b == b
"aaaaaaa", 3   Truthy a == a
"[][]", 1      Falsey ] != [
"[][]", 0      Falsey [ != ]
"ppqqpq", 2    Truthy q == q
"ababab", 5    Falsey a != b
"12345", 0     Falsey 1 != 5
"letter", 1    Truthy e == e
"zxywv", 3     Falsey w != x
```
1-indexed
```
"1", 1         Truthy 1 == 1
"abc", 2       Truthy b == b
"aaaaaaa", 4   Truthy a == a
"[][]", 2      Falsey ] != [
"[][]", 1      Falsey [ != ]
"ppqqpq", 3    Truthy q == q
"ababab", 6    Falsey a != b
"12345", 1     Falsey 1 != 5
"letter", 2    Truthy e == e
"zxywv", 4     Falsey w != x
```
  
[Answer]
# JavaScript (ES6), 26 bytes
```
s=>n=>s[n]==s.substr(~n,1)
```
Alternatively:
```
s=>n=>s[n]==s.slice(~n)[0]
```
This one almost works, but fails when `n == 0` (because `s.slice(-1,0) == ""`):
```
s=>n=>s[n]==s.slice(~n,-n)
```
Another 26-byte solution that [@RickHitchcock](https://codegolf.stackexchange.com/users/42260/rick-hitchcock) pointed out:
```
s=>n=>s[n]==s[s.length+~n]
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~5~~  4 bytes
```
=UƓị
```
[Try it online!](https://tio.run/nexus/jelly#@28bemzyw93d//8b/1cqKCgsLChUAgA)
There should be no shorter answers in Jelly. An program would need comparison, reversal/negation, an index call, and a byte for control flow (`Ɠ` in this case), which adds up to four bytes.
**How it works**
```
 =UƓị 
       - (implicit) input string
 =     - equals (vectorizing by characters because a string is a charlist)
  U    - the reversed string
    ị  - get the element at the index of:
   Ɠ   - the input index
```
*-1 byte thanks to @ais523, using `Ɠ`*
[Answer]
# [MATL](https://github.com/lmendo/MATL), 5 bytes
```
tP=w)
```
[Try it online!](https://tio.run/nexus/matl#@18SYFuu@f@/ukdqTmq@OpcRAA "MATL – TIO Nexus")
Explanation:
```
t   % Duplicate the input
Stack:
    ['ppqqpq' 'ppqqpq']
P   % Reverse the top element of the stack
Stack:
    ['ppqqpq' 'qpqqpp']
=   % Equals. Push an array of the indices that are equal
Stack:
    [[0 1 1 1 1 0]]
w   % Swap the top two elements
Stack:
    [[0 1 1 1 1 0], 3]
)   % Grab the a'th element of b 
```
[Answer]
# [Octave](https://www.gnu.org/software/octave/), 22 bytes
```
@(s,n)s(n)==s(end-n+1)
```
[Try it online!](https://tio.run/##Xc/LDoIwEAXQvV8xkpjQiCTl4a6JK7/AXdNFwRIXplJAHv587QAKYbrsyb0zr7yRrbIFC8PQXvw60KT2NWGs9pW@n/SRElv4HvUCoASmOQDcqnfzGIACY0B3DsgsdyQiG5AhyEYwjUMJWQGJQCLggot/hANX@azVAAL2DPgK0A3gCASCsjSmNI7EBMHcYLDBTDvic/9nsg6QGDDuSKM4SX8VC6AIUgRP1TSqmrdcjlBYoRB8@qFrpxvXCR0m9PYL "Octave – Try It Online")
Or the same bytecount:
```
@(s,n)s(n)==flip(s)(n)
```
[Try it online!](https://tio.run/##Xc/LCoMwEAXQfb9iKhQMiBAf3QW66hd0J1lEibQgbWKsj/68zRhbg8kmkMO9M6@qE72caxbH8XwJTfQkJnwSxurmoUJD7Huuw4AGEVAC7pwAbu27u09AgTGgBwtEWVmSkB0oEZQLcMeijHhAIBAICl7wf4QFV9EYOQGHI4PCA3QHCgQcgVJaK21JShCsDRobtJsRr/0/Ez9AYMAyI03SLP9VbIAiyBE0sutku065LSGxQiL4jNPQux39hAETxvkL)
**Explanation:**
It's quite straight forward. The first one takes a string `s` and an integer `n` as inputs and checks the n'th element `s(n)` against the "last-n+1" element for equality.
The second one checks the n'th element `s(n)` against the n'th element of `s` reversed. 
[Answer]
# [Python](https://docs.python.org/), ~~24~~ 22 bytes
*-2 bytes thanks to Adnan.*
```
lambda s,n:s[n]==s[~n]
```
[Try it online!](https://tio.run/nexus/python2#S7ON@Z@TmJuUkqhQrJNnVRydF2trWxxdlxf7v6AoM69EIU1D3VBdR8FAkwvOT0xKBooYIotAAFDUGEk0OjY6Fk0hVAjZtIKCwsKCQqCgEYoVIAgUNEUSNDQyNjFF052TWlKSWoRmS1VFZXkZ2DH/AQ "Python 2 – TIO Nexus")
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~7~~ 5 bytes
-2 bytes thanks to [Adnan](https://codegolf.stackexchange.com/users/34388/adnan)
```
ÂøsèË
```
[Try it online!](https://tio.run/nexus/05ab1e#@3@46fCO4sMrDnf//19QUFhYUMhlBAA "05AB1E – TIO Nexus") or [Try all tests](https://tio.run/nexus/05ab1e#K6tMKP5/uOnwjuLDKw53/69UOrzfSsklvdje0KxY1@3wBvtanf/R0eqG6joGsTrR6olJyeo6hmAWBKjrGIN40bHRsVAJCBOsuqCgsLCgUF3HCKIVBNV1TEEcQyNjE1OoqpzUkpLUIqjuqorK8jKQobEA "05AB1E – TIO Nexus")
```
Â     # Add a reversed copy on top of the original string
 ø    # Zip
  sè  # Extract the nth element
    Ë # Check if they are equal
```
[Try it online!](https://tio.run/nexus/05ab1e#@3@46fCO4sMrDnf//19QUFhYUMhlBAA "05AB1E – TIO Nexus")
[Answer]
## Haskell, 22 bytes
```
s#n=s!!n==reverse s!!n
```
0-basd. Usage example: `"letter" # 1` -> `True`.
[Try it online!](https://tio.run/##y0gszk7Nyfn/v1g5z7ZYUTHP1rYotSy1qDhVAcT7n5uYmadgq1BQlJlXoqCioJSTWlKSWqSkoKxg@B8A "Haskell – Try It Online")
[Answer]
# [Alice](https://github.com/m-ender/alice), 24 bytes
```
/t.~e?/-mom
\I!RtI&1n;@/
```
[Try it online!](https://tio.run/##S8zJTE79/1@/RK8u1V5fNzc/lyvGUzGoxFPNMM/aQf///4KCwsKCQi5jAA "Alice – Try It Online")
Input consists of the string on one line, and the number on the second line. Output is `Jabberwocky` if the characters are the same, and nothing otherwise.
### Explanation
This program is mostly in ordinal mode, with one command in cardinal mode. Linearized, the program is as follows:
```
I.ReI&1m;mt!~t?&-no
I  % Input first line
   % STACK: ["ppqqpq"]
.  % Duplicate top of stack
   % STACK: ["ppqqpq", "ppqqpq"]
R  % Reverse top of stack
   % STACK: ["ppqqpq", "qpqqpp"]
e  % Push empty string
   % STACK: ["ppqqpq", "qpqqpp", ""]
I  % Input next line
   % STACK: ["ppqqpq", "qpqqpp", "", "3"]
&  % (cardinal mode) Pop stack and repeat next command that many times
   % STACK: ["ppqqpq", "qpqqpp", ""], ITERATOR: [3]
1  % Append "1" to top of stack
   % STACK: ["ppqqpq", "qpqqpp", "111"]
m  % Truncate so the top two strings on the stack have the same length
   % STACK: ["ppqqpq", "qpq", "111"]
;  % Discard top of stack
   % STACK: ["ppqqpq", "qpq"]
m  % Truncate again
   % STACK: ["ppq", "qpq"]
t  % Extract last character
   % STACK: ["ppq", "qp", "q"]
!  % Move top of stack to tape
   % STACK: ["ppq", "qp"]
~  % Swap
   % STACK: ["qp", "ppq"]
t  % Extract last character
   % STACK: ["qp", "pp", "q"]
?  % Copy data from tape onto top of stack
   % STACK: ["qp', "pp", "q", "q"]
&  % Iterator: effectively a no-op in ordinal mode when the top of the stack is a 1-character string
   % STACK: ["qp", "pp", "q"], ITERATOR: ["q"]
-  % Remove occurrences: here, result is "" iff the characters are equal
   % STACK: ["qp", "pp", ""]
n  % Logical Not (for a consistent truthy value)
   % STACK: ["qp", "pp", "Jabberwocky"]
o  % Output top of stack
```
[Answer]
# Java 8, ~~43~~ 42 bytes
```
s->n->s.charAt(n)==s.charAt(s.length()+~n)
```
[Try it here.](https://tio.run/##lZA9T8MwEIb3/IpTp1g0FmnpFBIJBiQGpo5RBtc1qYNjO/ElEFD56yFVQxAspD4P9/XovbuCtSwwVuhi/9LL0poaoRhytEGp6HOjOUqj6cPoRB5XzDl4@vAAHDKUHL5rt1uspc6XP4lHjSIX9RLujVGC6SQBDjH0Lkh0kDjKD6y@Q1@TOJ4CR5XQOR58cvWpSR8NOsO3zU4NUqNia@QeSia1f5ZMM2DkNBHAtnMoSmoapHYoodI@p8xa1fmLcEFG95qQ6N92tuMTEM4Czm@C1nOgNEuzy2R@EbM2sbaqbDUxq3nbn2xiNnOYcLW@2Vw2mhKIor7sAO9v3Wv798pH79h/AQ)
[Answer]
# [Cubix](https://github.com/ETHproductions/cubix), 22 bytes
```
[[email protected]](/cdn-cgi/l/email-protection)):tBvpptc?1.\O0
```
1-indexed, takes input as `index`,`string`, separated by a space.
[Try it online](https://ethproductions.github.io/cubix/?code=Li5ALklBcCk6dEJ2cHB0Yz8xLlxPMA==&input=MiBsZXR0ZXI=&speed=5)
Cubified
```
    . .
    @ .
I A p ) : t B v
p p t c ? 1 . \
    O 0
    . .
```
### Explanation
This is mostly linear. The main logic is
```
IAp):tBpptc
IA           Get the first input as an int and the rest as a string.
  p):        Move the index to the top of the stack, increment it, and copy it.
     t       Look up the appropriate character in the string.
      Bpp    Reverse the stack and put the index and character back on top.
         t   Look up the appropriate character in the reversed string.
          c  XOR the two characters.
```
We then branch with `?` to `O`utput `1` if the result is 0 and `0` otherwise.
[Answer]
# [V](https://github.com/DJMcMayhem/V), ~~26, 16~~, 13 bytes
```
ä$Àñã2xñVpøˆ±
```
[Try it online!](https://tio.run/##K/v///ASlcMNhzceXmxUcXhjWMHhHYc6Dm38/z8xCQT/mwEA "V – Try It Online")
Hexdump:
```
00000000: e424 c0f1 e332 78f1 5670 f888 b1         .$...2x.Vp...
```
1 indexed.
Explanation:
```
ä$                  " Duplicate this line horizontally
  Àñ   ñ            " Arg1 times...
    ã               "   Move to the center of this line
     2x             "   And delete two characters
        V           " Select this whole line
         p          " And replace it with the last pair of characters we deleted
          ø         " Count the number of matches of the following regex...
           <0x88>   "   Any character
                 ±  "   Followed by itself
```
For reference, my original answer was:
```
Àñx$x|ñxv$hhpÓ¨.©±/1
ñllS0
```
[Try it online!](https://tio.run/nexus/v#@3@44fDGCpWKGiBZppKRUXB48qEVeodWHtqob8h1eGNOTrDB//8eqTmp@f8NAQ "V – TIO Nexus") (0 indexed)
Hexdump:
```
00000000: c0f1 7824 787c f178 7624 6868 70d3 a82e  ..x$x|.xv$hhp...
00000010: a9b1 2f31 0af1 6c6c 5330                 ../1..llS0
```
[Answer]
# C#, ~~28~~ 27 bytes
```
s=>n=>s[n]==s[s.Length+~n];
```
*Saved a byte thanks to @KevinCruijssen.*
Compiles to a `Func<string, Func<int, bool>>`.
[Answer]
# [CJam](https://sourceforge.net/p/cjam), 8 bytes
```
l~_W%.==
```
[Try it online!](https://tio.run/##S85KzP3/P6cuPlxVz9b2/39DBaWc1JKS1CIlAA "CJam – Try It Online")
0-indexed index goes first.
[Answer]
## R 51 bytes
```
function(s,n){s=el(strsplit(s,''));s[n]==rev(s)[n]}
```
Anonymous function, uses 1-based indexing
[Answer]
## Ruby, ~~22~~  ~~20~~ 18 bytes
```
->s,n{s[n]==s[~n]}
```
[Answer]
## Clojure, 27 bytes
```
#(nth(map =(reverse %)%)%2)
```
Wow, this was shorter than I expected.
[Answer]
# [APL (Dyalog)](https://www.dyalog.com/), ~~10~~ 5 [bytes](https://codegolf.meta.stackexchange.com/a/9429/74163)
```
⊃=⊃∘⌽
```
This is a tacit function, which needs to be assigned a name such as `f←⊃=⊃∘⌽`, and then called as `int f string`.
Thanks to @Adám for a whopping 5 bytes.
### How it works:
```
⊃=⊃∘⌽  ⍝ Main function; tacit. 
       ⍝ Inputs are ⍺ = 1 (left) and ⍵ = 'abca' (right).
⊃      ⍝ ⍺⊃⍵, meaning 'pick the ⍺-th element of ⍵'
 =     ⍝ Compare to
    ⌽  ⍝ ⌽⍵, meaning 'invert ⍵'
  ⊃    ⍝ Again, ⍺⊃⍵, but:
   ∘   ⍝ Compose. This turns ⌽ into the right argument for ⊃,
       ⍝ which becomes 'pick the ⍺-th element from ⌽(the inverse of)⍵'
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT/8PBGmP2iY86mq2BeJHHTMe9ezlMlFIU1DPSS0pSS1SBwA "APL (Dyalog Unicode) – Try It Online")
The 22 byte answer was edited out. If you want to see it, check the revision history.
[Answer]
# [C# (Visual C# Interactive Compiler)](http://www.mono-project.com/docs/about-mono/releases/5.0.0/#csc), 20 bytes
I don't have enough reputation to comment on [TheLethalCoder's answer](https://codegolf.stackexchange.com/a/123932/110384), but in C# 8 you can save some more bytes.
```
s=>n=>s[n]==s[^++n];
```
[Try it online!](https://tio.run/##fY89D4IwEIZ3f0XDRAMaAZmwXUyc3B2amkhTTBNyBVo//3ytymh7N12eJ3fvCbMURrn9FcTW2EnBJUffQYHNUat1TynqEHGGUCDUMOCEGHbKMuCN22kwuper46SsPCiQaZcmRYLTNcbN4i89t8LzIsx/5Z0q6DDOeHTJLIRTDMM4DqNXykjQT3ulDipFWW3q6J1eWiunaNbX43m/ze@6Nw "C# (Visual C# Interactive Compiler) – Try It Online")
[Answer]
# [J](http://jsoftware.com/), ~~6~~ 5 bytes
```
{]=|.
```
[Try it online!](https://tio.run/##y/qfVqxga6VgoADE/6tjbWv0/mtyKekpqKfZWqkr6CjUWimkFXNxpSZn5CsYKtgCcZqCemJSsjpCyBgkVFBQWFhQqA5VaQBTGR0bHauOJmZoZGxiqv4fAA "J – Try It Online")
*-4 bytes thanks to FrownyFrog for `{(=|.)`*
See original answer explanation -- idea is similar enough, but this is accomplished with a dyadic hook whose right verb is itself a monadic hook.
[Try it online!](https://tio.run/##y/qfVqxga6VgoADE/6s1bGv0NP9rcinpKain2VqpK@go1FoppBVzcaUmZ@QrGCrYAnGagnpiUrI6QsgYJFRQUFhYUKgOVWkAUxkdGx2rjiZmaGRsYqr@HwA "J – Try It Online")
### original answer (10 bytes)
```
{=/@(,:|.)
```
`,:|.` right arg on top of reverse right arg
`=/` are they elementwise equal?
`{` take from that boolean list the index indicated by the left arg
[Try it online!](https://tio.run/##y/qfVqxga6VgoADE/6tt9R00dKxq9DT/a3Ip6Smop9laqSvoKNRaKaQVc3GlJmfkKxgq2AJxmoJ6YlKyOkLIGCRUUFBYWFCoDlVpAFMZHRsdq44mZmhkbGKq/h8A "J – Try It Online")
[Answer]
# Mathematica, 34 Bytes
```
s=StringTake;s[#,{#2}]==s[#,{-#2}]&
```
[Answer]
# [Perl 6](https://perl6.org), 27 bytes
```
{[eq] $^a.comb[$^b,*-1-$b]}
```
[Test it](https://tio.run/nexus/perl6#VZBbcoIwGIXfs4q/Gab1EhnR2gcR7VNX4BtgJ0BsnQG5BFTq6GLadbgml2ATwKhhhjD5zjk5PwVnsHnTfRNFJTz7ccDAuuxtlrqgLajux5FnawuPdHpGT/Pcw0XI3nPGc7AgXK0Zb7X1iCbjPQKIxlxuAOfTLz6f/uCovrQJz7PV@msqbHpnVqleyEu1a5N4ueQsl8wJutWZrU0yxouwOpxnRf5dutJ1MMXrqNIIdJWbwEyZCGifJjqgQkw3F2VNlIR0Dd2quYmWcdYM0ZtCy6nDiFMHEYftEubnLCBOwLjfBjnUioP8Oa1GW0vbBJQWpFbcecEGJtCH66rLgwGWBQbC1PMFNh6hJ6EnYL2EYHiDVEKKsO3a7s36QUPOSnDhyQJbwf4DtCV0EU6SNE1SgQd3d6YyNpWF5CPg6M5JpVMUMgbD15HKbaAh4QjhkOU5y66VmlgmYxnCP7tyu2kGUc6tdO7@AQ "Perl 6 – TIO Nexus")
```
{ # bare block lambda with two placeholder parameters ｢$a｣ and ｢$b｣
  [eq]        # reduce using string equality operator
    $^a       # declare first positional parameter
    .comb\    # split that into individual characters
    [         # index into that sequence
      $^b,    # declare and use second parameter
      *-1-$b  # closure that subtracts one and the 
              # second parameter of the outer block
              # (｢*｣ is the parameter of this closure)
    ]
}
```
[Answer]
# PHP>=7.1, 36 Bytes
```
[,$t,$p]=$argv;echo$t[$p]==$t[~+$p];
```
[Online Version](http://sandbox.onlinephpfunctions.com/code/bed3d1ef5870c0d0d552b4fc84367a13df071303)
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), ~~8~~ 7 bytes
```
q@zQ@_z
```
With the input reversed: first the index, then the string. It is 0-indexed.
# Explanations:
```
q@zQ@_z
 @zQ        Get the nth (Qth) character
     _z     Reverse the string
    @       Get the nth character of the reversed string. Implicit input of the index
q           Test equality
```
[Try it online!](https://pyth.herokuapp.com/?code=q%40zQ%40_z&input=2%0Appqqpq&debug=0)
[Answer]
# Lua, 46 bytes
```
function f(s,n)return s:byte(n)==s:byte(-n)end
```
[Try it online!](https://tio.run/##bc7NCoMwDAfwu09RPLWgBz@2w8CrT7CbeKguMkGyfqTb3Mt3HQpzsuQSfoT8Mznp/eCwp/GGbOA2QWGAnEFmT91MwFFU1TqmKAAvPk3Z2Ti6zozAEuulBRspMyLxgcdZnLBMiC/Irg@U/9BSgcstK6W10kGLrU5ABGY9EYXwWk4W/oc3bdPuw1bb/fTpoMetZnlRHvarr@f8uC@f@jc)
[Answer]
# C, ~~36~~ 35 bytes
```
#define f(s,n)s[n]==s[strlen(s)+~n]
```
Uses 0-based indexing, naturally.
[Try it online!](https://tio.run/##S9ZNT07@/185JTUtMy9VIU2jWCdPszg6L9bWtji6uKQoJzVPo1hT11A3L/Z/bmJmnoYmVzWXAhAUFGXmlaRpKKmmxOQp6QAZ4fk5hvnhSjqGmprW@FUYgVTU/gcA)
[Answer]
# [Factor](https://factorcode.org/), 24 bytes
```
[ 2dup nth -rot nth* = ]
```
[Try it online!](https://tio.run/##S0tMLskv@h8a7OnnbqWQnVqUl5qjUJxaWJqal5xajGDppVaUFCUWKxQUpZaUVBYUZeaVKFhzcRkqKEXHRscq/Y9WMEopLVDIK8lQ0C3KLwExtBRsFWL/Jyfm5Cjo/QcA "Factor – Try It Online")
## Explanation
`nth*` is like `nth` except it indexes from the back; if `0 nth` is the first element, `0 nth*` is the last.
```
             ! 1 "[][]"
2dup         ! 1 "[][]" 1 "[][]"
nth          ! 1 "[][]" 93
-rot         ! 93 1 "[][]"
nth*         ! 93 91
=            ! f
```
[Answer]
# [Thunno](https://github.com/Thunno/Thunno), \$ 8 \log\_{256}(96) \approx \$ 6.58 bytes
```
Drz.=sAI
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m72sJKM0Ly9_wYKlpSVpuhYrXIqq9GyLHT0hXKjoghUFBYWFBYVcRhA-AA)
0-indexed. Change `AI` to `AH` if you want it to be 1-indexed.
#### Explanation
```
Drz.=sAI  # Implicit input
Dr        # Duplicate and reverse
  z.=     # Zipped equality
     sAI  # Swap and index in
          # Implicit output
```
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), 4 bytes
```
fḂ=i
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyIiLCIiLCJm4biCPWkiLCIiLCJwcHFxcHFcbjIiXQ==)
#### Explanation
```
fḂ=i  # Implicit input
f     # Flatten into a list of characters
 Ḃ    # Bifurcate: duplicate and reverse
  =   # Are they equal (vectorises)
   i  # Index in
      # Implicit output
```
[Answer]
## ZSH, 32
```
f(){read s n;[ $s[n] = $s[-n] ]}
```
[Try it online!](https://tio.run/##JYqxDoIwAET3fsWFEKKDiQV0oY5uDsbNNB0QSiAhpQUiivjttZW74S53bx5qW222n17mJQaojCMcuBI4@dy5Ir52qptWwiMZyg6MsSC8na@Xe4AFFaIIsqg7UCzL2vaeU9JaCkryR4GY5KuQEi64cMM/KNHaGG2QOMwbR0LjJD24p5XjKHtHzq/39ET6Aw "Zsh – Try It Online")
[Answer]
# [Japt](https://github.com/ETHproductions/japt), ~~10 9~~ 8 bytes
```
gV ¥Ug~V
```
[Try it online!](https://tio.run/nexus/japt#@58epnBoaWh6Xdj//0qJScmJSjoKRgA "Japt – TIO Nexus")
]