[Question]
  [
Frustration is a solitaire card game which is played by calling out the sequence:
“Ace”, “Two”, “Three”, ... , "Nine", "Ten", “Jack”, “Queen”, “King”, “Ace”, “Two”, etc.
With each call, you simultaneously flip over a card from a shuffled deck of 52 cards. You win the game if you get through the entire deck without ever calling out the rank of the card being flipped over.
### Challenge
Given a string or list of characters representing an ordered deck of cards, return "Truthy" if the deck is a winning *Frustration* configuration, and return "Falsy" otherwise
### Input
Input will be a single string (or a list of characters, or a list of codepoints) consisting solely of the following 13 characters (you may choose to take the letters as uppercase or lowercase):
```
A 2 3 4 5 6 7 8 9 T J Q K
```
Each character will be repeated 4 times in the input. An example of a valid input is:
```
A23456789TJQKA23456789TJQKA23456789TJQKA23456789TJQK
```
You may assume that the input is always valid (ie. it will contain exactly 52 characters and the 13 characters mentioned above will be repeated exactly 4 times each)
### Output
Output one of two distinct "Truthy" and "Falsy" values. The values you choose **must** be consistent (ie. different "Truthy" inputs must produce the same "Truthy" output and different "Falsy" inputs must produce the same "Falsy" output)
### Examples
The input `KA23456789TJQKA23456789TJQKA23456789TJQKA23456789TJQ` would be a winning *Frustration* configuration (hence a "Truthy" input) because none of the cards in the sequence match the name called out when flipping that card over.
The input `2K3A456789TJQKA23456789TJQKA23456789TJQKA23456789TJQ` would **not** be a winning *Frustration* configuration (hence a "Falsy" input) because the 3rd card flipped over matches the name called out when flipping it (`3`).
### Test Cases (one per line)
**Truthy**
```
KA23456789TJQKA23456789TJQKA23456789TJQKA23456789TJQ
2A2A2AKQKQK3Q456789345678934567893456789A2JJJJTQKTTT
KQJT98675432AKQJT98675432AKQJT98675432AKQJT98675432A
55667987TAQK8TAQK8TAQK8TAQK325476979965432JJJJ234234
JAK3TTJAK3TT33KAA2456789456789456789222456789JJQQQKQ
```
**Falsy**
```
A23456789TJQKA23456789TJQKA23456789TJQKA23456789TJQK
2A2A2AKQKQKQ3456789345678934567893456789A2JJJJTQKTTT
KQJT98765432AKQJT98765432AKQJT98765432AKQJT98765432A
8TAQK8TAQK8TAQK8TAQK234567999765432JJJJ2342345566797
JAK3TTJAK3TT33KAA2456789456789456789222456789JJQQQQK
```
### Scoring
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"). Shortest answer in bytes wins
  
[Answer]
# [Python 2](https://docs.python.org/2/), ~~45~~ 42 bytes
*-5 bytes thanks to @ovs*
```
lambda s:all(map(cmp,s,'A23456789TJQK'*4))
```
[Try it online!](https://tio.run/##nZBNa8MwDIbv/hW5NR291Io/VNjBV@sk8HEwvI/SQJKZNqPs12cO3iEdhXW1zGskW/jVk77Gw8cgp/3j09TF/uUtVqdd7Lq6j6l@7dPmtFk5CY3SxmLwTKuHZr2ezoe2e6@2O1GlYzuM1b4@xvNzO6TPsc7XdNFyWyKkm4M4B3Apw7XDSZ9XYAohCGIf0GqjGph7b0qEUlobtCY4JnspIFVjNBpEPb@df8oe8xbeEYRQFICck8XOUqX8KXrPnAcRd3CgJQiG/4EwejHun4mwVwgUK4hofhEo1MwdIJi@AQ "Python 2 – Try It Online")
[Answer]
# [Perl 5](https://www.perl.org/) -p, 29 bytes
```
$_^="A23456789TJQK"x4;$_=/\0/
```
[Try it online!](https://tio.run/##nZA9CwIxDIb3/ozDVZTm2jTIDV2bKZBRdHIQRA918Ndbe9ThTgQ/mvKWJC198/S788HlPNtuuiZaaJ3HQJqEm1u7mm27xXq5yJknre8SY@MQLCVAahneHdGmslRYVQ1LUgoeXQvD268S45z3SAE1CoepgHUtekIiP9wdfioeyzYpMqhWBeAYbbUzVmufxZREyiDG/AGCxyQEfiOBfjTvx8SENwiqFSLCFwQVG/5BQvh@6q/70/GS54f@AQ "Perl 5 – Try It Online")
Perl allows XOR on strings, how awesome is that?!
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 14 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
QṢ“ṡ=2E’œ?ṁn⁸Ạ
```
A monadic Link accepting a list of characters which yields `0` or `1`.
**[Try it online!](https://tio.run/##y0rNyan8/z/w4c5FjxrmPNy50NbI9VHDzKOT7R/ubMx71Ljj4a4F////93L0Ng4JgZDGxt6OjkYmpmbmFpbIpJERVNDLKxAIvAE "Jelly – Try It Online")**
### How?
```
QṢ“ṡ=2E’œ?ṁn⁸Ạ - Link: list of characters, D
Q              - de-duplicate D
 Ṣ             - sort
  “ṡ=2E’       - base 250 integer = 3,832,012,820
        œ?     - nth permutation
          ṁ    - mould like (D)
           n   - not equal? (vectorises):
            ⁸  -   chain's left argument, D
             Ạ - all?
```
[Answer]
# [Bash](https://www.gnu.org/software/bash/) + Core utilities, 48 bytes
```
egrep "`echo \([^A ][^{{2..9},T,J,Q,K} ]\){4}`"
```
[Try the test cases online!](https://tio.run/##nVBdS8MwFH3Pr7gUHxTrBkmbNDAnedCH5EECedsHq2tYB107qlOh9rfXdHVYZeBcbjjhHu69Ofc8xc9ps4xfYAzbsliV8QZGI@/@8cFr7Kq0W/AWdpkWML2czAXMJvOqwoMBr33jS1/7qobZ9KoK6oWHGteF0DLdFAnsrt8P8xB6S9eZhdLGCWTr3CKApHAAsJ98k4N30fJwOwbvm@@4DxgMD8LGw8S@DvNdlvWq7vbjctsogUkQUhZxI/WJCcKiDaVdEN3R5NgjsHTHaGWMQUpLwyPKwoC0vSclKAwpZTxiRmgV/QSCw4BRzjinbW37k9PoLpJCEWM6JEQJgTs5fcT4i5RSa7cIOsMH1TdCk/8ZwWhv3T8TFB1xoJPCOWe/HOhcY2cY4Xb6BA "Bash – Try It Online")
Input is on stdin.
Output is the exit code: `0` for truthy, `1` for falsy.
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), 57 bytes
```
([^A][^2][^3][^4][^5][^6][^7][^8][^9][^T][^J][^Q][^K]){4}
```
[Try it online!](https://tio.run/##nZA9CwIxDIb3/g/hXJu2acZOQjMFssmJDg4uDuIm/vYzpQ6nHPjR9HlLQkuT93K8ns6HaTVs9tOw3ZVxu/MGGMGIRjLQyAYZalRDDB7Xt3CfJi4eQkyYSat8mThfWrBYgPQyLB3FV1sqrKqOpSrlhDFAe/tV4mJMCSmjFuH8KuBjwERIlNrd9pP1aNvVwqDaFYBL8b2duXr/LNYqYoO4P3zguRECvxmBaTbux8TlBQd6K0SEbw501/API4Qf "Retina 0.8.2 – Try It Online") Link includes test cases. Explanation: Simply matches a string of 52 bytes that doesn't match the specified character at each given position.
[Answer]
# [Haskell](https://www.haskell.org/), 37 bytes
```
and.zipWith(/=)(cycle"A23456789TJQK")
```
[Try it online!](https://tio.run/##pZA9a8MwEED3/gphMiRDG5Csr8GDVt10cJCli3HixtR1TZOl@fFRZNQhFikNjU6cOHF6nN6@Przv@j601Wuoh@3LqRs33XG/XFerZfPd9LvCcVFKpY0lj1CswkfdDaxi288nxsavbjiyBWtZAbO@@4pijuBuCsAYAlOTuHU47uMiBCLKEICerFFalmIi3VVkCCmV0tZocghmngSXpVZWW6uml9MU8TdxZwjvQBClLAQ4x9Pg15nzn0vvEeOXM8Q/bMLvOlE8olOrK2l/FhnC3PCYhrbW6sxjcq8f1hldhHPT9vXbITw343gB "Haskell – Try It Online")
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 19 bytes
-2 bytes thanks to EdgyNerd,
-1 byte thanks to Grimmy.
```
'A8L>"TJQK"JJ4×ø€Ëà
```
[Try it online!](https://tio.run/##yy9OTMpM/f9f3dHCx04pxCvQW8nLy@Tw9MM7HjWtOdx9eMH//96ORsYmpmbmFpYgaeI4AA "05AB1E – Try It Online")
[Answer]
## JavaScript (ES6), 48 bytes
With the input being a string:  
`t=>![...t].some((v,i)=>"A23456789TJQK"[i%13]==v)`
With the input as an array of char it's down to 43 bytes:  
`t=>!t.some((v,i)=>"A23456789TJQK"[i%13]==v)`
```
var f=
t=>![...t].some((v,i)=>"A23456789TJQK"[i%13]==v);
[
"KA23456789TJQKA23456789TJQKA23456789TJQKA23456789TJQ",
"2A2A2AKQKQK3Q456789345678934567893456789A2JJJJTQKTTT",
"KQJT98675432AKQJT98675432AKQJT98675432AKQJT98675432A",
"55667987TAQK8TAQK8TAQK8TAQK325476979965432JJJJ234234",
"JAK3TTJAK3TT33KAA2456789456789456789222456789JJQQQKQ"
].map(v=>console.log(v,f(v)));
[
"A23456789TJQKA23456789TJQKA23456789TJQKA23456789TJQK",
"2A2A2AKQKQKQ3456789345678934567893456789A2JJJJTQKTTT",
"KQJT98765432AKQJT98765432AKQJT98765432AKQJT98765432A",
"8TAQK8TAQK8TAQK8TAQK234567999765432JJJJ2342345566797",
"JAK3TTJAK3TT33KAA2456789456789456789222456789JJQQQQK"
].map(v=>console.log(v,f(v)));
```
[Answer]
# [Java (JDK)](http://jdk.java.net/), 63 bytes
```
s->s.matches("A23456789TJQK".repeat(4).replaceAll(".","[^$0]"))
```
[Try it online!](https://tio.run/##nVBfa8IwEH/3UxxlQjs0jMY2jW5CXxsGC@ZNHGS1dXW1lSYKY/jZs9TuQYcwZy65y/2/@63lXg7Xyw9TbLZ1o2FtdbTTRYnyXZXqoq7Q/aSXllIpeJZFBV89gO3urSxSUFpqK/Z1sYSN9bkz3RTVar4A2ayUdwwFeGmyZZFKnT127ink8GTUcKrQRur0PVOuE/t4FIQkoiLhzEFNts2kdkde@ytlmsVl6TrIGTjz17uHheN5ZnKsndeNu5cN6Ezp8VlXgNmn0tkG1TuNtravzl2nr8bQV/3KGRwzBpCjVrot87yu5KHXvoMx7Gyo6xTjxy0xbgnzzowvidhP7BGcCSEM44mgUUiCEW5zr1JMEIQhoRERMWfROcN@MCIhJZSGbWzbyc5or0lihoXoOMYsjv1unFPu@z/GJOHcLmJuwIGdAsHx/4Ag4cm6fyomuoBANwqllPxCoEON3AAEZ98 "Java (JDK) – Try It Online")
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 58 bytes
```
Inner[Equal,#,Characters[#<>#<>#<>#&@"A23456789TJQK"],Or]&
```
[Try it online!](https://tio.run/##nZBNawIxEIbv@RXLCp4WCsnmC7UYiocmhzY4tyWHIGtd0KVN4@/fZomHtQi1ZoY3vEOGzDwnHw/tycdu54d9sRpe@74Nzebr7I/VrHo5@OB3sQ3fzWz5fMn5ulSY1JRxIUFbU7rqLbj58B66Pjb74mldTPq2MZU/tp/HLjYlMled9xmE1RjGpiA2l8mtS2GdDlgDAMhYDVIwTmsy9t5lEKWMcSk4KGvEtRBMa84kl5KNb8ef0owpkVaGAGQlxCiF8zhTxfhS1NratAh6gIOZgrDkfyA4m6z7p0HiBoE8ipSS/yKQqfEHQKSdSufcYvgB "Wolfram Language (Mathematica) – Try It Online") Pure function. Takes a list of characters as input and returns `True` or `False` as output. Note that this function checks for losing configurations (since `Equal` and `Or` are shorter than `Unequal` and `And`), so `False` is the truthy value and `True` is the falsy value.
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), 44 bytes[SBCS](https://en.wikipedia.org/wiki/SBCS)
```
{A T J Q K←10+¯9 0 1 2 3⋄~∨/(13|⍳52)=13|⍎¨⍵}
```
[Try it online!](https://tio.run/##nZC7TsMwFIb3PMXZCgOitmM7Hhi82pMlv0AECR0qtSLJUHEZEEKoKBULIwtiyMYAvEAexS@SOgSJgCL14mP99jnysX9/8Xx6dLaIp7PzprmUYEGBAe3unxCgMSCvGBBxj3c37qE6PkDkypUfFB@efO9WdeXKr@smBd8Be/cHgStfwE4SyC@KfLKAPMlyOI2zJINZkc@LHFDgVs/@2rSuANzy1pVv9Ttyy9cQKHbl50hLTELKeCSsMlsmWLahjQ9iuioZWiRWflijrbXaKCsixmlI2tatEkoZ4yLiVhod/RWCaciZ4EKw9mj7jjfop5KaWNspIVpK3HnpK8Y/RaWM8b8Y/YJM42k2xHG8ieMeGHWPoyE7ceSsR2tjEg0A7HwIIfg/gB10vjtHo0fNGg "APL (Dyalog Unicode) – Try It Online")
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 19 bytes
```
⬤θ¬⁼ι§⁺⪫…²χωTJQKA⊖κ
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z@gKDOvRMMxJ0ejUEfBL79Ew7WwNDGnWCNTR8GxxDMvJbVCIyCntFjDKz8zTyMoMS89VcNIR8HQQFNHoRyIlUK8Ar0dlYAsl9TkotTc1LyS1BSNbE0wsP7/3zvQK8TSwtzM1MTYyJFIzn/dshwA "Charcoal – Try It Online") Link is to verbose version of code. Outputs a Charcoal boolean; `-` for truthy, nothing for falsy. Explanation:
```
 θ                  Input string
⬤                   All characters satisfy
    ι               Current character
  ¬⁼                Not equal to
        …²χ         Digits from 2 to 9
       ⪫   ω        Joined together
      ⁺     TJQKA   Suffixed with picture cards
     §              Indexed by
                 ⊖κ Current index incremented
```
[Answer]
# [Perl 5](https://www.perl.org/), 36 bytes
```
sub f{('A23456789TJQK'x4^pop)!~/\0/}
```
[Try it online!](https://tio.run/##1ZZBa4MwFMfvfoqsCFVw1CWamIpjuRp2COQ4NtiWdkKrrra0pe2@ukt0h3YU1u2UJfLkvTz1F/n/IbVazOK2bVbPYLLzhgyiKMYkoTIXfLiJHuuq9q8@Rg/h6NCuGgWkapbj8X21UKkz34K7pc6z97UH/t1w@MlmL0vAjTX4kJnJhZ5I9IDo3I3BXA8puJTSInwuckkTTOIImV1clFiEH8cYE5oQyQRPTgOCcUQwJZRiQ23@vlaQvizCzxlHUvYRIc4Y7MVyHCH8Kua5EFpmFuH/wbkchDZaV6BLrRtaZl2Cjwz6Y2IRfnLGs71QKKXkm2d7nxOL8H9vXau076fO@q2YKa87Ovg7B4D51nOLsg5ctan9rKlnxYvqVoMwgGnXANxptcwmXZ@/34emWjSeqXaPBQOzAq5vu8aB/sjBea1K9WReU5TTtP0E "Perl 5 – Try It Online")
`'A23456789TJQK' x 4` results in the 52 byte string of `A23456789TJQK` repeated four times.
This string is bitwise XOR-ed (operator `^`) by the equal length input string from `pop`.
Any equal byte (char) at the same positions in the two strings results in a null-byte from xor.
And `!~` (not regex-match) returns true if no null-byte `\0` exists. Otherwise false.
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 64 bytes
```
i;f(char*s){for(i=0;i<52&&s[i]-"A23456789TJQK"[i++%13];);i-=52;}
```
Outputs zero for truthy and non-zero for falsy.
[Try it online!](https://tio.run/##pVNbT8IwFH7fr2hKICsXxZatqwNNHzRxfSr2RZEYMpg0wWEYGJHw22fHCA6DkeBpc27p157z5TRsvIRhmmo/ssPxYFZN0Cqazmzdafq67eBKJenpfgNyTFqOSz2mAilgT9dq5QvS95GvGx0H@@u0pONwshiOQDuZD/X0bHxllYajSMcjwLtd/vB8f/d4Y38gYCf6czSNjHu@9Yzba/YRsiwdz8HrQMf2@1QPkbWygJGsLFDV8dtinvT6oAPydCZQ7NV1XADr33jMsyWkWUTmJ8ghw3FgREmhlCrihQwU81zqtEh2zVFBEe84rkuZRxWXwttXBDst6jLKmJvBsvdNE2YX8QEXRKlcEyI4x3m9RY3xNhkEUppOi/gT6BO/8CfJyfxRt8DSn0ER7x0gLq@VMUZ/EJeTTf/H367/tW9t7Oa3mLnVZjKbvjHt4sDnY4tMvlZDu3ffZgYR2bCcPMWwDqLtMfPTELgG8HYwSZYQXAKoZov5eAmRb63TLw "C (gcc) – Try It Online")
[Answer]
# [J](http://jsoftware.com/), 26 bytes
```
1 e.(52$'A23456789TJQK')&=
```
[Try it online!](https://tio.run/##nZA9awMxDIZ3/QoRSi4HrUmk81fCDabQwe7i4rWUUnKUUuiQLPn1V7vucAmBprGs10hIWHo@xploBuzX2OAtLnGd/U7g/dPjw7jCrVhIumkccSeVNjb5GJp23o8twL4Xi@eNeKG2tC0hHFVdFgC5YiFm41jTfO5x5PNJMaSUIESfrFFadlx6LwpASqW0NTq5GMyxMMlOK6utVaW2/JRnzBe8C5xSVebgHNVxpkr0m/Q@xrwItLB9e//CYbbCPcDw@rk7nKC6glSYoor8P1RaTYD8GYA5w6iOYq3VJ4wqV30FqrzTBNUPp/Eb "J – Try It Online")
0 is truthy, 1 is falsy.
Straightforward as possible, posted mostly as a straw man because I thought it was interesting that there didn't seem to be a trick to compress 'A23456789TJQK' that was shorter than the literal.
[Answer]
# [K (oK)](https://github.com/JohnEarnest/ok), 24 bytes
```
~|/(52#"A23456789TJQK")=
```
[Try it online!](https://tio.run/##nZKxCgIxDIZ3H6MO6iBqc20aQbBrMwXyBA4uDr6A3KufKXXwRPC8pKSkzU@Tj96299swXI/9Y7cOfumyhy5ETKRF2G1Ow6Havtqlv55Xa8ejkmmJWzifq7OYg7QL@LZlX8xUWFVNxlKUUsTQQVVPSkwWQoxICTULp3EAHzqMhESxVtfXrFNbJiuZQbVFAM7Zt6beo/evw1JEbByTzSDCYyQC/yLB@Db4z8Rk6QuL1hAR4QeLxg9nIan/ZjE8AQ "K (oK) – Try It Online")
* `(52#"A23456789TJQK")` build the frustration sequence
* `(...)=` compare it to the input
* `~|/` do none (i.e. not any) match?
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), ~~24~~ 20 bytes
```
!sqV*X1"ATJQK"jkr2T4
```
[Try it online!](https://tio.run/##K6gsyfj/X7G4MEwrwlDJMcQr0FspK7vIKMTk/38lL0dv45AQCGls7O3oaGRiamZuYYlMGhlBBb28AoHAWwkA "Pyth – Try It Online")
* `X1"ATJQK"jkr2T` Construct the string "A23456789TJQK". Inserting the range 2-9 at position 1 of "ATJQK" is one byte shorter than using the full string literal
* `* ... 4` Duplicate that string 4 times
* `V` Vectorize the above string and the input string as inputs to the following function:
	+ `q` (arg1) == (arg2)
* `!s` Return true if the result sums to 0 (ie. none of the cards from the input match the above string)
[Answer]
# [GolfScript](http://www.golfscript.com/golfscript/), 29 bytes
```
"A23456789TJQK"4*]zip{1/~=},!
```
[Try it online!](https://tio.run/##S8/PSStOLsosKPn/X8nRyNjE1MzcwjLEK9BbyUQrtiqzoNpQv862Vkfx/38vR2/jkBAIaWzs7ehoBFGMTBoZQQW9vAKBwBsA "GolfScript – Try It Online")
```
"A23456789TJQK"4*               # Push this string repeted 4 times
                 ]zip           # Zip the input and the previous string
                     {    },    # Find all elements that pass this test
                      1/        # Divide in groups of 1      "XY" -> ["X" "Y"]
                        ~=      # Are they equal?
                            !   # Is it an empty array?
```
Outputs `1` for truthy and `0` for falsy.
[Answer]
# [Japt](https://github.com/ETHproductions/japt) [`-e`](https://codegolf.meta.stackexchange.com/a/14339/), 16 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
```
kVg"tjqk"i9õ ¬ha
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&flags=LWU&code=a1ZnInRqcWsiaTn1IKxoYQ&input=IktBMjM0NTY3ODlUSlFLQTIzNDU2Nzg5VEpRS0EyMzQ1Njc4OVRKUUtBMjM0NTY3ODlUSlEi)
[Answer]
# x86 machine code, ~~33~~ 32 bytes
Replace `xx xx xx xx` with the address of `.Llut`.
Machine code:
```
00000034: bb xx xx xx xx 6a 34 59 89 c8 d4 0d d7 ae 74 02  .....j4Y......t.
00000044: e2 f6 c3 41 4b 51 4a 54 39 38 37 36 35 34 33 32  ...AKQJT98765432
```
Commented assembly:
```
        .intel_syntax noprefix
        .section .text
        .globl frustration
        // Input: EDI: 52 byte string to test
        // Clobbers: EAX, ECX, EBX, EDI
        // Output: ECX: Zero for true, non-zero for false
frustration:
        // Load the lookup table into EBX.
        mov     ebx, offset .Llut
        // Set ECX to 52 for our loop iterator
        push    52
        pop     ecx
.Lloop:
        // Copy ECX to EAX
        mov     eax, ecx
        // Convert to the LUT index. Read the .Llut comment before
        // questioning my math. ;)
        //
        // AL = AL % 13, AH = AH / 13
        aam     13
        // Load the corresponding card rank into AL.
        // AL = EBX[AL]
        xlatb
        // Compare to the byte in EDI, increment EDI
        scas    al, byte ptr [edi]
        // If it was equal, return. ECX will be nonzero.
        // Note that loopne wouldn't work: it decrements first, so it
        // won't work for the last card. :(
        je      .Lfalse
        // Loop for 52 iterations
        loop    .Lloop
        // At this point, ECX is zero from the loop, our "truthy" value
.Lfalse:
        ret
.Llut:
        // We store our LUT in a slightly unsual order.
        // This is because we are looping from 52->0, and using
        // the index mod 13 to get the index. However, we read
        // forwards, and we decrement AFTER the modulo.
        //
        // This means we need to reverse, then rotate one byte.
        //  0  52  0
        //  1  51 12
        //  2  50 11
        // ....
        // 12  40  1
        .ascii "AKQJT98765432"
```
[Try it online!](https://tio.run/##rVZtb9s2EP6uX3EQFmwDFCWWYzv2sAJamiKxjRVuNaxYWxSURNlaJFIlqdjuj292pGyZqo0i2CYbpHm6e3gvz5EmUtIyLrbnyyR5eoLd4@dM0eKT3DJFNsB4JWiWb5z2taSJyjkDX9GNOoiXBY8LyEQtlSBaoX11cQH3rKrVBG5f3k9gEEC8VRRQL2dLUBwUlcrWvkGomAqJBuE7D25v9PCbHl7e23qva9XA3rybwF9UcMi4ACVq6qHf7PzLXpSRQlLH8m1iw8w5SUGtKBScP9QVKBIXFDALXO/qt6olfzQzjTce8CyTVIE/L@qO729RiP7osDBQvTmvhUauIFcUd@eiVa9qudLzIDiIUM/skWwcxEazjqs3vNru4TE3x64RdE3bdmzYIxXKJBqDnP8RYWwp3fjwhu4CN1FAwsuSMgUxRbepDfG5xgph2nS9yi2URK18@OVnS8XWDufwqx7OoNf3ILzTqzu4wFWrRUhpZktkFyLhQlBZcZbqHRMiUhCEPTQ1Cef@0W5Yp/fh/GMr3xRExd0klBURdJ8EQ8CcaUJ5OCeCmshtfsmESONq4TXqlRLwnqb5xw6xMywrrFGVfq61qqCqFsw3RVrnRYHZ1FzUVOy4/TtHSLUiynCDUVjzukjZjwjGxcNEo6Z055eELBdSeSA5ym2UNd9bNNTXJCZSmZT5MPmp1f2b7tp03vRCJ@vIOW2NfG0oipWWrYahrrHUvzqZR06tcomcxbqYNgVcNU0neLlvqcozLeBiX6rV1oVHUtTU2TlyYDcmzjE87BD@T31OIBsNRENdICCLfLlSxRZqJjHrwEVKRSe9kXYMvzFNSC0xuxR0@bU7mlLGv0Fw/uLSA8JSqCVKbXvtu@kSbK0UaaqJs6TqIPfhjq8pNpansQV2km2O6VxjCWSDjgptLSF8Fd2@MTiIXBcdVhxFUFLCpLZnlKbaB6G3lHi@IQADwRVBGnHWMLqTAbjUBwtOHWEPhT3oBR0hag0uodezhT4@9rqHSlcIeVDyiUzyHNxwtphG4@vRcHDVD9yn44vCNTeFj7XCvqap67lk43pnleDLOFfScfySJEiaH6Lbt5G@Fo6PtTRvT9xediB12RyWQeb0Jl2/voD7AZFcJzi8SAi2Iz6n7qj9UWyfnZ1Ddb97fGxCvm/izyu86FT2yY7slPHev0b9cFamaYMpsZOwcj5lael8e/GWJGeOHibHe6T5sSw@7NvkHcCdhUH/ajAcXY@j6eKZC/cYJgj1Z7bAT3/RKPZPTWEwxSdazKIoOgHT0Go40rQKn7k4ATMYDIcjpGcULmbX3aEfDK5Gw/FoPDbc1d5gZPg9ATMNZ/0oasZ@fxaGQROEPQbBTjidLhYY/gmYf5Hh2fdTvOj/1xQ3nRs@c3EC5vpEbpsAxuPx6JvcNvUY/S8ptnPT/nOymN3KrA7Q94xj9@TxyXEm4fwFnKUfmOs8fU2ygizl03nZD/4B "Assembly (gcc, x64, Linux) – Try It Online")
The function takes the string pointer in `edi` and returns, in `ecx`, either zero for a win, or non-zero for a loss.
Doesn't follow standard calling convention.
I finally found a good use for both `aam` and `xlatb`, I feel accomplished.
See the comments for details.
This could use 2 fewer bytes on 16-bit, but that is solely because the LUT address is 2 bytes smaller. No fancy 16-bit tricks, so I'll leave it at x86 because it is easily testable on TIO.
I'd love to trim down this LUT a bit, but I'm not currently sure how. The LUT is 13 bytes plus a 5 byte `mov`, making more than half of the code.
]