[Question]
  [
## Task
Given two positive integers `a`, `b` and a Unicode mathematical inequality symbol `c`, determine if `a c b` is true.
You many take the character or its Unicode codepoint for the input `c`. You may output your language's truthy/falsy values, or two distinct values for true and false respectively.
Standard [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") rules apply. The shortest code in bytes wins.
## List of symbols to support
```
Symbol  |  Hex   |  Dec   |  Name
--------+--------+--------+-------------
<       |  003C  |  60    |  Less than
=       |  003D  |  61    |  Equal to
>       |  003E  |  62    |  Greater than
≠       |  2260  |  8800  |  Not equal to
≤       |  2264  |  8804  |  Less than or equal to
≥       |  2265  |  8805  |  Greater than or equal to
≮       |  226E  |  8814  |  Not less than
≯       |  226F  |  8815  |  Not greater than
≰       |  2270  |  8816  |  Neither less than nor equal to
≱       |  2271  |  8817  |  Neither greater than nor equal to
```
The last four symbols may look broken in Chrome. They are four symbols `<>≤≥` with slash overstrike, indicating negation.
## Truthy test cases
```
1 < 2
1 = 1
2 > 1
1 ≠ 2
2 ≠ 1
1 ≤ 1
1 ≤ 2
2 ≥ 1
1 ≥ 1
2 ≮ 1
1 ≮ 1
1 ≯ 1
1 ≯ 2
2 ≰ 1
1 ≱ 2
```
## Falsy test cases
```
1 < 1
2 < 1
1 = 2
2 = 1
1 > 1
1 > 2
1 ≠ 1
2 ≤ 1
1 ≥ 2
1 ≮ 2
2 ≯ 1
1 ≰ 1
1 ≰ 2
2 ≱ 1
1 ≱ 1
```
  
[Answer]
# JavaScript (ES6), ~~58 45~~ 42 bytes
*Saved 3 bytes thanks to @Neil*
Expects the Unicode code point for \$c\$. Returns \$0\$ or \$1\$.
```
(a,c,b)=>'14353426'[c%61%9]>>(a>b?2:b>a)&1
```
[Try it online!](https://tio.run/##VVG7TsMwFN3zFVeRmsSKibAbKhViIwZ29siDYxpoVcWojhjZ@xcM7QrtL/VHQkQV@XqxzktH58ob/amd2a0/@pvOvq6GVgyZpoY2RMiUlfO7eckXaW1mCzZbKikzLZtHft9ITRI2PNQRQMygAh7TKxTArpCDnCCDy/57ivB/gpxDSFDsiJ2jL77sf7ATkN@QoLYTds6TM0mVr698UPgC4VWJIcc3oomHcDzHe9GqYO8pJCh2DsezOFJR0drdszbvmQMhwdjO2e2q2Nq3UUgScJBDCl9yfHJos9zVt4qCq7kqzPjVL3bd9U99RiiMVqkIIcMf "JavaScript (Node.js) – Try It Online")
### How?
Each comparison character is assigned a 3-bit mask describing if it should be truthy for `a > b`, `a < b` or `a == b`.
```
 char. | code | meaning                           | > | < | = | mask
-------+------+-----------------------------------+---+---+---+------
   <   |   60 | Less than                         | 0 | 1 | 0 |  2
   =   |   61 | Equal to                          | 0 | 0 | 1 |  1
   >   |   62 | Greater than                      | 1 | 0 | 0 |  4
   ≠   | 8800 | Not equal to                      | 1 | 1 | 0 |  6
   ≤   | 8804 | Less than or equal to             | 0 | 1 | 1 |  3
   ≥   | 8805 | Greater than or equal to          | 1 | 0 | 1 |  5
   ≮   | 8814 | Not less than                     | 1 | 0 | 1 |  5
   ≯   | 8815 | Not greater than                  | 0 | 1 | 1 |  3
   ≰   | 8816 | Neither less than nor equal to    | 1 | 0 | 0 |  4
   ≱   | 8817 | Neither greater than nor equal to | 0 | 1 | 0 |  2
```
We store these masks in a 8-character lookup string whose index is computed by applying two consecutive modulos to the code point:
```
 code | mod 61 | mod 9 | mask
------+--------+-------+------
   60 |   60   |   6   |  2
   61 |    0   |   0   |  1
   62 |    1   |   1   |  4
 8800 |   16   |   7   |  6
 8804 |   20   |   2   |  3
 8805 |   21   |   3   |  5
 8814 |   30   |   3   |  5
 8815 |   31   |   4   |  3
 8816 |   32   |   5   |  4
 8817 |   33   |   6   |  2
```
[Answer]
# [Python 2](https://docs.python.org/2/), 45 bytes
```
lambda a,o,b:o%83*45%555%16%6+1>>cmp(a,b)+1&1
```
[Try it online!](https://tio.run/##dZJLboMwFEXnrOJJFbVp3CqmgSIU2EgaVZCEBomfwAyiqgvoLjpIpk2ypW6E@sPHGXTEve9ePx0jVwe2Lwu7u9uU27R496FlyaNnJMFrl0V5vI0gIiWJ/dL0nh8Wjuk4jkld053RMNzkFY5IbM3oPe2aQx6XWQMBfKAl8sGdE0CBEJSLUAibi9@vby49bz6X5qjMQpqTMo40P9JQlZyVUclFGVeaqzIvn4bB6pbtDxxghSgswUa8QLmlQtgQKkGBI6jQlnKcHnU5Fk7T9DSs4nTTVJNnXY4bLtP0yqdrw0iirJlA@6XLoRYMR4NhEk7Cnu4wwhx1RHviGgk0rosux8JVR6QSsayB7RoGaQH9j52B5PYNkMkb5xNfbkW5Fc3@EYjKbentqd5VWbTZ4ZY0rMZ9cdWuLYuXIwIlgZiX86jCacGIOtRUWcowAiRbVc0TLBKLjBbfUlpahIIQaVY@5P/jBPcUltX9AQ "Python 2 – Try It Online")
Improved based on @Arnauld's answer, make sure to upvote him!
The bitmask here is a different from @Arnauld's answer because bit `0` and `1` are swapped. *As usual*, the lookup table is replaced by some cool magic numbers.
# [Python 3](https://docs.python.org/3/), ~~51 48~~ 47 bytes
```
lambda a,o,b:o%83*45%555%16%6+1>>(a>b)+(a>=b)&1
```
[Try it online!](https://tio.run/##VZJBboJAFIb3nOJt6ECdNA4KNcaZi1hjhlajCQqBYWGaHqC36EK3Va/Ui9A3M8DgBr7/vZ/JB6E4qV1@nDRb/tZk8pB@SJA0p@k892eT52nsx3Hss8RPRkyIQIo0HOGVp@ETa6rTIc2zCjh8kgWZQzKmQLgGhiA0RAh/3z@Is9l4bMLZhqkJFxtiE35NYHZztcFubjYkJtxteP3yPFXWandCgSVhsICIYIFhZBoiEBYYoIJdRgb76XmIfeHippfuKLRz0wFeh9ifcHPTO05XnreVWeVE20MXXY13j/JuIhxE7h16mfNQMXJevcHA6zbEvnAfKjKjmJegNpWC/RHaDzsC4z33wGzW6KfvGHW51s32J9CVx9L6pdwUmXzfBDWtVBm0xWW9CkMsSwo5hRTLB1kE@6Oi9qGqyPYqIEBMqyhxE@gNfVSjhAtCza9qcRuYEIbNPw "Python 3 – Try It Online")
---
# [Python 2](https://docs.python.org/2/), ~~47~~ 46 bytes
```
lambda a,o,b:(cmp(a,b)==1-o*6%43%7%3)^o*3%58%3
```
[Try it online!](https://tio.run/##dZJLbsIwFEXnWcWTqsgONRVO@EQRzkYoRQmQEik/Jc4AVV1Ad9EBTAtsqRuhjp2PGXSUe9@9fjqOXBz5Ic/s@9M238XZuwc1j8auEbHXexKk4S6AgOQk9PA2LXBAQosxOs5Hc3PqmAvTsd7ykWPOXNO5V8c0zJMKGHygJfJgPiGAWCOoEH4jbCF@v76FdN3JRJqTMlNpzsrMpPmRhqrkooxKrsrMpbkps/g0DF7W/HAUACtEYQk2EgUqLG2EDb4SFASCCm0p@@lJl33hPEzP3SpBN0w1edFlv@E6TG9iujaMKEiqAbRduuxqrDvKuok/CHu4Qw9z0hHtgasn0LiuuuwLNx2RSsS8BL6vOMQZtD/2GSS3Z4BMNoKv@QrblOum2T6CpvJY2ryU@yIJtntck4qXuC2u6rVliXJAICcQinIaFDjOOFGHqiKJOUaAZKsoRYKbxCK9xY@UlhYh5iPNypf8fxzhlsKy7n8 "Python 2 – Try It Online")
Every operation can be expressed by `(cmp(a,b)==a)^b`. For example, `a<b` iff `(cmp(a,b)==-1)^0`. We then use some dirty magic numbers to compress a and b.
# [Python 3](https://docs.python.org/3/), ~~51 49~~ 48 bytes
```
lambda a,o,b:((a<b)+(a<=b)==o*6%43%7%3)^o*3%58%3
```
[Try it online!](https://tio.run/##VZJLboMwFEXnrOJNkE1iVTHkpwizkTSNTEuUSCQgMIOo6gK6iw6SaZNsqRuhzza/TODc9y7WAZGf1T47BfVOvNapPMYfEiTLWLyiVIaxN8ariD0hstHcnQbuwg28t2wUuLOlG9Tl@RhnaQkCPklIVjCfMCBCA0eINPgIf98/iMvlZGLCxYapCVcbZib8msDt5maD3dxtmJvwsGHx5TiqqNT@jAJrwiEEn2CBY@QafIgscEAFu/QNdtPLELvCtZ9e26PQrp8O8DbE7oR7P33gdOM4O5mWvWhzaNjWRPuoaCdRD37/Dp3MZajo916dwcDrPsSu8BgqcqOYFaCSUsHhBM2HHYPxXjlgNlv003eMulzpZvMT6MpzaftSJHkq3xNasVIVtCmuq43nYVkyyBjEWD7KnB5OitmHyjw9KEqAmFZe4IbqDXtWY0REhJl/1eKOmuB59T8 "Python 3 – Try It Online")
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), ~~34~~ ~~33~~ ~~24~~ ~~23~~ 18 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
•1P42•b3ôs61%èŠ.Sè
```
-9 bytes by porting [*@ovs*' Python 3 answer](https://codegolf.stackexchange.com/a/203589/52210), so make sure to upvote him!  
-6 bytes thanks to *@Grimmy*.
Input of the character as codepoint integer. Input-order as `c,b,a`.
[Try it online](https://tio.run/##yy9OTMpM/f//UcMiwwATIyCVZHx4S7GZoerhFUcX6AUfXvH/v4WFoSmXEZchAA) or [verify all test cases](https://tio.run/##yy9OTMpM/V9Waa@k8KhtkoKSfaVyQvHh9oT/jxoWGQaYGAGpJOPDW4rNDFUPrzi6QC/48Ir/Ov@jlQwVbBSMlHSAtK2CIZA2UrAD04YKjzoXgGWMwCyY2BIkFkx2KVxsKdSMR53r4GII1nokFkzvBrjYRqg7bKBm2EBlbKFqbaF8OzhtBHcnzNYlSC4xgtsPswth/wYkFkx2I5JLDJViAQ).
**Explanation:**
```
•1P42•             # Push compressed integer 18208022
      b            # Convert it to binary 1000101011101010100010110
       3ô          # Split it in parts of size 3:
                   #  [100,"010",101,110,101,"010","001","011",0]
         s         # Take the first codepoint input
          61%      # Take modulo-61
             è     # Index it into the binary list (0-based and with wraparound)
              Š    # Triple-swap to take the next two inputs
               .S  # Compare them (-1 if a<b; 0 if a==b; 1 if a>b)
                 è # And use that to index into the triplet (where -1 is the last item)
                   # (after which the result is output implicitly)
```
[See this 05AB1E tip of mine (sections *How to compress large integers?*)](https://codegolf.stackexchange.com/a/166851/52210) to understand why `•1P42•` is `18208022`.
[Answer]
# [Python 3](https://docs.python.org/3/), ~~99~~ 82 bytes
*17 bytes saved thanks to @ovs!*
Uses the operator similarities `a<b <=> a≱b`, etc.
```
lambda a,o,b:[a<b,a>b,a<=b,a>=b,a==b,a!=b]['<≱>≰≤≯≥≮= ≠'.find(o)//2]
```
[Try it online!](https://tio.run/##XZDBioMwEIbP9SlmTzEQWszeSuKLWA8JRVboGmk92EfIW/Sg162@Ul7ENUIxk0DCfPw/M/OnfXY/pvleKpBwWW7qV18VKGaYPhdKaKby9QrpC/9I/3xJXRZEODvnzk7ODs6@nR2d/ZPg7Iscq7q5poaeTrxcKnOHHuoGigTWQzIQwAn7gITsAxzyHTLfaTfyDZE6xIjMI1bHcMy6KFYjfMeIOk9YnTd1zxbMEaFThl1kqOQYOP4CtPcQp@I4Blo0ijHFiMxznCojSXlODoqBYaDXjfvjo73VXUqTQ3uvmy7tGRBJGFSpJ0U3py81pXT5Bw "Python 3 – Try It Online")
[Answer]
# [Python 2](https://docs.python.org/2/), ~~42~~ ~~41~~ 38 bytes
Takes in as input two operands \$ a \$ and \$ b \$, and the operator \$ c \$ in codepoint form. Test cases *nicely borrowed* from @newbie.
```
lambda a,c,b:(cmp(a,b)+63)*c%1895%57&1
```
[Try it online!](https://tio.run/##dZJLbsIwFEXnWcWTKmq7uBUODVBEshGKKieQgpSfEmeAqi6gu@gApgW21I1Qf/Ixg45y77vXT8eRi73Y5pl7vYMoX@@y9znUIn6cwWQMbPbigTd1Yv/1mvA0XHPgNKLhHEdpgTkNyXAyJg/RQBUH3vSeXat9GuZJBT58oAWaw2REAflKMCkCJVwpfr@@pZzNRiNtDsY8a3M0xtPmRxtmkpMxJjkbM9HmYsz003FEWYvtXgIsEYMFuEgWmLRMCRcCIxhIBBO6WnbTgy27wrGfHttVkq6fWvJky27DuZ9e5HTlODFPqh60Wbpoa3571G8nQS/c/g4dzMFGdHuujsDiOtuyK1xsRKYR8xLEphKwy6D5sUPQ3HMHdPIm@dRXWlWuVbN5BKpyW3p7KjdFwqMNrmklStwUl/WKEFnmFHIKoSynvMC7TFBzqCqSncAIkG4VpUywSgjtLL6lJFaE/ABZltNcPtx/4xg3FIRc/wA "Python 2 – Try It Online")
---
The idea is the same as @newbie's, generating pseudorandom numbers until they match the output. The `cmp` function returns `-1`, `0`, or `1` if the left argument is less, equal to, or greater than the right argument, respectively. And also because MathJax looks nice, here is the formula in MathJax:
$$ ((((\text{cmp}(a,b) + 63) \* c) \bmod 1895) \bmod 57) \bmod 2 $$
[Answer]
# [Python 3](https://docs.python.org/3/), ~~68~~ 59 bytes
Takes the unicode code point of the operator as input.
```
lambda a,o,b:[a==b,a>b,a<=b,a>=b,a<=b,a>b,a<b,a!=b][o%61%9]
```
[Try it online!](https://tio.run/##TZIxboMwFIZ3TvE6RE5UBuy2aYowF6EMWC1KpARH4A4oygF6iw6wNsmVehH6bAfbg6Xv//1sfSAfe7WVzdNU8/dpXx3ERwVVLGORFhXnIq5yXJkB7kgDrgcuykIu1nTxVk5dfxBy3wGHE8lICuskBsI1UIRcA0P4@/5B3GySxITBhmcTRhteTPg1gdqdiw1252rD2oSbDa/nKFLtl9r2KFAQChkwggMUI9XAILdAARXsJjPo2iFENzD6dpyvQjvfBngJ0d1w9e0N2zKK6mrfedH7pdk8xuejfG5yD8x/g5MZQkXmvZxB4HUN0Q3cQkVqFGUL6rNTsGvg/mMfwXinEeALgS4GgYZ6pkhTVmIrMd@fQdHp4tjuGrWsyUlPnYHncKqXeFbi2dWZrKZ/ "Python 3 – Try It Online")
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), 50 bytes
```
{⍎('≥≤><',⍵)[⍵⍳⍨'≮≯≰≱',⍵]}
```
[Try it online! (the test cases)](https://tio.run/##SyzI0U2pTMzJT///P@1R24TqR719GuqPOpc@6lxiZ6Ou86h3q2Y0kHjUu/lR7wqgxLpHnesfdW541LkRLBlb@///o76pQJ3qIUWlJRmV6lwQbpqCuqGCjYIRCt9WwRCJb6Rgh8I3VHjUuQBFhxFYBF3NEiwi6LqWYqhZimY30CsYajBF1mMRQbdrA4aajQg16m6JOcWp6MGC6hQbNANs0aywRZO3w@AbYQQjumeXYAkQIwzvo3sN0/sbsIig69qIJUAM1QE "APL (Dyalog Unicode) – Try It Online")
Dyalog APL supports many of those operators and a simple "eval()" `⍎` will handle them as given. This answer swaps the last four which are not supported `'≮≯≰≱'` with replacements that are supported, e.g. "not less than" becomes "greater than or equal to", then "eval()"'s the resulting string. Output is 1 for true, 0 for false.
(NB. on the score: It's only 26 characters which would be competitive, however because it has `≮≯≰≱` characters in it, it does not fit in a pre-existing 8-bit APL character set so must be scored with the UTF-8 byte count instead of the number of characters).
[Answer]
# [QuadR](https://github.com/abrudz/QuadRS), 34 bytes
```
⍎⍵
≮
≯
≰
≱
≥
≤
>
<
```
[Try it online!](https://tio.run/##KyxNTCn6//9Rb9@j3q1cjzrXAfF6IN4AxBuBeCkQL@Gy47L5/99QASikYAQA "QuadR – Try It Online")
Simply replaces the redundant symbols with their simpler equivalents, and then evaluates as APL.
[Answer]
## Dyalog APL, 23 bytes.
```
⎕(⍎'=>≤≥≤><≠'[9|61|⎕])⎕
```
With [Adám](https://codegolf.stackexchange.com/users/43319/ad%c3%a1m)'s assistance. [Try it online! (the test cases)](https://tio.run/##XZHBasJAEIbveYq5rUJbTA6FgnopFARBsPYkHoKuGgjZZXdjEbwVbBWUXjwWSlHoqdVX6KPsi7SzSUw2XUj4mcz88@0fn4eXo7kfsskvHr3dtTp6@VpzHP3y7EfykYpKGxiHbtUB0Js3SIswZCMKgYQpFfQCYhlEE0gbIYikov4I2BjQL3/GTECv1bkSceQYr@0OF0G7ojdb0mjq1V6vDvhu1vXqnfRvFtfugvFBtWtIEpwxSCXg3zFIXFAOakqBuFAHj2DfPKSm21CZvbFE2CjpSfkRgPtCSUQgQCq4Uq@Xev1RTVcYV8nDQAGLUPhDKnGiDV3sR96fz2S4XwNvcIagMz9EAHRDgCBSzLzohAozybgZ3O4ebu9Br5/SaXeQjQ5ZNKNCAalnk4wn8aJjTE1WWeZZvsXFFZXKulTyU7K4knRJT8RqOifO@BxNqhrgJsqDZqZcwAiy716ii/q@pIueg1U/5I569WXVbf1d0oXP0aqfTD2Dv/NDSQv484J63t7ITRp5rWkpz7pagbcvYXsWaoFkox5Luug5lbBd8gc)
Explained:
The `⎕` are prompts for numeric input, it takes the numbers on the outsides, and the codepoint of the comparison operator in the middle. Codepoint modulo `|` 61 then 9 produces indices into the string `''[]` which pick the comparison operator to run. This maps the unsupported ones (≮ ≯ ≰ ≱) to their supported equivalents ("not less than" maps to "greater than or equal to", etc).
Code demonstrates an unusual APL feature: `1 (⍎'<') 2` where the string `'<'` evaluates `⍎` to a function which can be called in-place like any other `1 f 2` dyadic APL function call.
NB. I'm submitting this as a separate answer both because it's a different approach to my other APL answer, and because it does not contain the unsupported comparison characters in it, which means it fits in a pre-existing 8-bit APL character set, and can be scored as 1-byte-per-character instead of UTF-8 byte count, for a much lower score.
[Answer]
# [Sledgehammer](https://github.com/tkwa/Sledgehammer), 17 bytes
16.75, to be overly specific
```
⣕⢌⢲⢼⠴⢺⢟⢼⣑⣮⣊⠞⠀⢄⡕⡝⢥
```
There's no point in trying to read that, so here's the corresponding Mathematica code with a reasonable explanation:
```
ToExpression@StringReplace[ToString@FullForm@ToExpression@Input[],"ot"->"ot@"]
```
The code evaluates the expression first. Unfortunately, the `≱` operator (and a few other similar ones) is not supported, and is kept verbatim. The code then rewrites the expression into a prefix-ish form (`NotGreaterEqual[1, 1]`), and replaces `ot` with `ot@`, turning `NotGreaterEqual[1, 1]` into `Not@GreaterEqual[1, 1]`, a call of the function `Not` on the result of `GreaterEqual`. Of course, since that was a string replacement, the result is then evaluated once again.
[Answer]
# [Io](http://iolanguage.org/), 90 bytes
Port of the Python answer.
```
method(a,o,b,list(a<b,a>b,a<=b,a>=b,a==b,a!=b)at("<≱>≰≤≯≥≮= ≠"findSeq(o)/2))
```
[Try it online!](https://tio.run/##hZFNCoMwEIX3PUWaVQKBYpYl4yW67SaiUqHV/uQSuUUXuq16pVzEmkLB0oxZZAh8vDePN1UzlWQP5DhdCnNqcqZFIzJxrh6GaZUJnc5Pgf/4AX5sIePaMKqcHVNnB2dbZ3tnO2dfQJx90rKq80NxYw3fSc6nkpGECEIVnacknFzvVW3O9eYLwIPkF0gP0gD4KPyWfzO5QGFVG0Fhww5XdVj0uQxctYL6CAonHHDViLWusOgKMwMsAGCKdBVI/LLhStvIISTedri3lbaHCAobjpFDLND0Bg "Io – Try It Online")
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), 80 bytes
```
\d+
$*
≠
<>
≤|≯
<=
≥|≮
=>
≰
>
≱
<
^(1+)(<.?1\1|.?>(?!\1)|<?=>?\1$)
```
[Try it online!](https://tio.run/##PU47CsMwDN11ChVScBoIyLNsX8SUFtqhS4fSMRfILTokaz5XykVcR3a8vKf3kN7T5/l9ve/hrG4IwT8aqC6w9T9gG2notn4GNnEc4ziB2d0FdlyB4aqoqRW3jjx1rbPKnTzVHTtjnaeqDoGQUQOhQQKNNiJhjI@eFk56KJz8MetRrmJx1gfPhdP@kvUqXSxXLJ6RDSOzzajzDyl7KF06d6TMo2MpnPy1dNEf "Retina 0.8.2 – Try It Online") Link includes test suite. Takes input as `acb`, but the test suite deletes spaces to make the input more readable. Explanation:
```
\d+
$*
```
Convert to unary.
```
≠
<>
≤|≯
<=
≥|≮
=>
≰
>
≱
<
```
Replace the Unicode operators with ASCII-based logical operators. The `=>` is reversed to make the final condition golfier.
```
^(1+)(<.?1\1|.?>(?!\1)|<?=>?\1$)
```
Match the first number, then check whether one of the relations can be fulfilled.
* If the character after the first number is a `<`, then after an optional `>` or `=`, then to fulfil this relation the second number needs to equal 1 or more than the first number.
* If after an optional `<` or `=`, there is a `>` before the second number, then to fulfil this relation the second number must not be at least equal to the first number.
* If after an optional `<` there is an `=` before an optional `>`, then to fulfil this relation the second number must be equal to the first number.
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 46 bytes
```
f(a,c,b){a="14353426"[c%61%9]>>(a>b?2:b>a)&1;}
```
[Try it online!](https://tio.run/##lZNRa4MwEMff@ymC4Iglpd41id3K3AfZ9hAdboVVSuceRulnd1rjlnvqBUQTyI//XbxfvXqv675vpFO1qrKze0xAb8xGo02e69RCev9altKV1RM@VKXL7mB36Q9u38rsvFgvRXf67j5@xHK9EMfTvu0amaRvYnpW5fB@aRMlQAmbK4FKNHJeZ9nuJgPXz8SM61vMEGDRM/OakbPd5kF1fsfImk7OaX7Hy9P/nfkdm0PCIY8zJM/w7jLgMI4DHXLA7g/IvURwpD8wMRwSjvffwZL@LDuvIHmFzxtEatznF9cjCDxiORFMqWXO6OgbBu5x7uXPV2T6CoGvwPd1PIcBg2zHgTjOdIDMcoSrZLZyw60TiOOg2TNJXI1wwBJ3bAyHhGPWWZA6ixh3gLhz5S59/ws "C (gcc) – Try It Online")
Port of [Arnauld](https://codegolf.stackexchange.com/users/58563/arnauld)'s [JavaScript answer](https://codegolf.stackexchange.com/a/203591/9481).
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal) `D`, 16 bytes
```
4ɾ8813+C`≥≤><`ĿĖ
```
[Try it Online!](https://lyxal.pythonanywhere.com?flags=D&code=4%C9%BE8813%2BC%60%E2%89%A5%E2%89%A4%3E%3C%60%C4%BF%C4%96&inputs=123%2045%E2%89%B1&header=&footer=)
Luckily, Vyxal supports all but the last four characters as operations.
```
               Ė # Evaluate...
              Ŀ  # The input, with characters in...
       C         # The charcodes of
4ɾ               # 1...4
  8813+          # + 8813
              Ŀ  # Replaced...
        `≥≤><`   # with the cooresponding character
```
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 38 bytes
```
Ｎθ≔Ｉ§”←⧴LH⎚G₂ⅉυ”℅ＳηＮζ⁼§⟦‹θζ⁼θζ›θζ⟧η÷η³
```
[Try it online!](https://tio.run/##TY5NCsIwFIT3nuLR1QtE6I9ddVVUpCAquBQXsQ1tIEabpEV6A2/h2bxITKWIy49hvpmyYbq8Melcoe6d3XXXC9fYkmyWGyNqhUtmLOa2UBV/YAAQhwDJIgWAME6TCAIKe10JxSR@DUerhaqREEKh8Zp/7eD54GOL67Zj0vy8py03BlsKg29N2UQbzZkdL414Hp0UCmVXohcVx4ZC4qcy5yJ4P18Qu3kvPw "Charcoal – Try It Online") Link is to verbose version of code. Takes input as `a c b` and outputs a Charcoal boolean, i.e. `-` for true, nothing for false. Explanation:
```
Ｎθ
```
Input `a`.
```
≔Ｉ§”←⧴LH⎚G₂ⅉυ”℅Ｓη
```
Input `c` and cyclically look up its ordinal in the compressed string `__20__345___02531_` (the `_`s are arbitrary; the linked code uses spaces) and save its value.
```
Ｎζ
```
Input `b`.
```
⁼§⟦‹θζ⁼θζ›θζ⟧η÷η³
```
Make a list of the comparisons `a<b`, `a=b`, `a>b`, cyclically index using the `c` value, and negate the result if the `c` value is less than `3`.
]