[Question]
  [
## Rules
Given an ISO3166-1-Alpha-2 country code your task is to decide on the traffic direction for that country:
* Input will be a valid country code (valid as in it's an element of the two lists provided)
* Input may be a list of two characters instead of a string if it helps
* You may choose to take input in lowercase
* You will choose one value, say for *right* (your choice) and will output that value iff the traffic in that country is right-handed and anything else in the other case
* You only have to handle country codes that are contained in one of these lists:
These are all countries where traffic is left-handed:
```
['AI', 'AG', 'AU', 'BS', 'BD', 'BB', 'BM', 'BT', 'BW', 'VG', 'BN', 'KY', 'CX', 'CC', 'CK', 'CY', 'DM', 'FK', 'FJ', 'GD', 'GG', 'GY', 'HK', 'IN', 'ID', 'IE', 'IM', 'JM', 'JP', 'JE', 'KE', 'KI', 'LS', 'MO', 'MW', 'MY', 'MV', 'MT', 'MU', 'MS', 'MZ', 'NA', 'NR', 'NP', 'NZ', 'NU', 'NF', 'PK', 'PG', 'PN', 'SH', 'KN', 'LC', 'VC', 'WS', 'SC', 'SG', 'SB', 'SO', 'ZA', 'GS', 'LK', 'SR', 'SZ', 'TH', 'TL', 'TK', 'TO', 'TT', 'TC', 'TV', 'UG', 'GB', 'TZ', 'VI', 'ZM', 'ZW']
```
And here are all countries where traffic is right-handed:
```
['AF', 'AX', 'AL', 'DZ', 'AS', 'AD', 'AO', 'AQ', 'AR', 'AM', 'AW', 'AT', 'AZ', 'BH', 'BY', 'BE', 'BZ', 'BJ', 'BO', 'BA', 'BV', 'BR', 'IO', 'BG', 'BF', 'BI', 'CV', 'KH', 'CM', 'CA', 'CF', 'TD', 'CL', 'CN', 'CO', 'KM', 'CG', 'CR', 'CI', 'HR', 'CU', 'CW', 'CZ', 'KP', 'CD', 'DK', 'DJ', 'DO', 'EC', 'EG', 'SV', 'GQ', 'ER', 'EE', 'ET', 'FO', 'FI', 'FR', 'GF', 'PF', 'TF', 'GA', 'GM', 'GE', 'DE', 'GH', 'GI', 'GR', 'GL', 'GP', 'GU', 'GT', 'GW', 'GN', 'HT', 'HM', 'VA', 'HN', 'HU', 'IS', 'IR', 'IQ', 'IL', 'IT', 'JO', 'KZ', 'KW', 'KG', 'LA', 'LV', 'LB', 'LR', 'LY', 'LI', 'LT', 'LU', 'MG', 'ML', 'MH', 'MQ', 'MR', 'YT', 'MX', 'FM', 'MC', 'MN', 'ME', 'MA', 'MM', 'NL', 'NC', 'NI', 'NG', 'NE', 'MP', 'NO', 'OM', 'PW', 'PA', 'PY', 'PE', 'PH', 'PL', 'PT', 'PR', 'QA', 'KR', 'MD', 'RE', 'RO', 'RU', 'RW', 'BL', 'MF', 'PM', 'SM', 'ST', 'SA', 'SN', 'RS', 'SL', 'BQ', 'SX', 'SK', 'SI', 'SS', 'ES', 'PS', 'SD', 'SJ', 'SE', 'CH', 'SY', 'TW', 'TJ', 'MK', 'TG', 'TN', 'TR', 'TM', 'UA', 'AE', 'UM', 'US', 'UY', 'UZ', 'VU', 'VE', 'VN', 'WF', 'EH', 'YE']
```
---
For completeness sake, [here](https://pastebin.com/8Gs3ukHr)'s a CSV file that contains all the values along with the country names.
## Testcases
Assuming you chose to output `L` for left-handed traffic, here are some valid test cases:
```
'PY' -> 'python'
'PN' -> 'L'
'CN' -> 33
'GY' -> 'L'
```
**Note:** There is a small chance that I missed a country or that there's a wrong classification and I will not change the specs because that might invalidate answers. If I made a mistake I sincerely apologize, please don't take offense!
  
[Answer]
# [Python 2](https://docs.python.org/2/), ~~145~~ ~~136~~ ~~112~~ 109 bytes
```
'TTHSZWMSGSONPKNZMWVIDFKELSCYJPNFJMTVCXBNRBWSHKYAUGGYBTLCCKIMVGBSBBMZAINAGDMOBDIEJEMYMUNUPGSRLKTKTOTCTZ'.find
```
[Try it online!](https://tio.run/##VZQ9b9swEIb3/gp1cgK0Bdrdg0hJFMUPMyIlRWo7BAmMBjCcwMjSX@82zw1FlxcCeffec8ezX3@//Xo5f7se9z@uu1L6vC0hm3yIycUtLLNtOtf6rNchxW4IZdb3Ko5qyb1b68mYVRWvtbNhNiorFbbaxto04aAa2w5tWMMUp2Ty6F1x5VB02XZfjs/np@ul2lffd3W3@1Tt6nvUv2uz8Z3RBj2gd@iIBnRBC0qW6tEVbVE5H1B8VI3OKG5Wzg0Kj7LvqolxeGoqanI1MQU2DbOOKD5OInHT@GvcevmeUMg1bC7xjVvjUGgb3FqN4pbhMcyhxa2lx5YJdMR31Oq4NXAmoUUN/AZCQ26DGno05BrJpS8Dm4HZUMVAbui356THbca5l3PiLS9oZcIwWzwtWYPMSiaAp6NHj4@nU69QHDxv6iH0OHiqBLICzoEuArUCWSuRge3q4AzMM8AZ6D1QMXAb8YnERGpF/KNEMo0I@YH4BHnCIUGYiEyQJNwSDAmeOyId34EXH4kf8RzpaMRTSUfygtTKorhlfDJdjMw5E6/oPdNvZpcyXWRiWjRJPNUzm5Zh0DBnuigwFG4DPoU5FCoW@As8EyQ1DpOc4D/hM/G@M33NxMw4LPTVUnFtdz8/nOTPANiaUjVJCjMFrGIdFEUUY1BgzvLDxdhRVjMAzTNq8DXnDbkdJx3NGZwNDoaYnluLm@XWAm7JHURZhIFzJyqLCW3gMQNsAc/AOgdZRllbiWQ8kRFGhhplxeScyCgrAFWCM8GWGZ7j29PpjC7yvHxn@dtgbhmqTf4AiPGyINTNVCx4FlapyLOTVSAveBZ6mWRiOBd5ZCawMZ9t@fukH14vz@e36uF0ujnePN5W@331@Wt1fLlUj9XzubrcVg/np3/XH/@/Pt1e/wA "Python 2 – Try It Online")
Outputs `-1` for right-handed traffic. ~~The string is autogenerated with [this Retina script](https://tio.run/##JZA7DsIwEER7n8JFJPMTEnCCBIgJiUOETQIhQVBQ0FAgSu4O@Ll5snZnZ8f7ur8fz9v3e@7OXa8mvRCXTySkGF/lYDocTEdD6dHNpJDRIppFc/kXqzhTE6liDQ@eiYUrmEADHWw8a/RJ6ZmfPJdHuIQ5pL5iNqWSbj01zhoHjWZDN8Mto5utIbPbwApSzwNJXpDW7CDZDJ6mhmQ2/MsEZetZxnAPcS5DHWWZelakqshZkc1u2Mu74Kc1bHC2vC16y90sqVp2aTQFnpa9lo0OT1dAuo4pR3KHp@Mvh3AxnB2zNRdouU/bqP4H).~~ Thanks to [totallyhuman](https://codegolf.stackexchange.com/users/68615/totallyhuman) for the 9 bytes shorter lookup string. I was able to get 24 bytes more off through [AdmBorkBork](https://codegolf.stackexchange.com/users/42963/admborkbork) suggestion.  
Got the lookup string 3 bytes shorter using a python script.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 61 bytes
*Many thanks to [@Mr.Xcoder](https://codegolf.stackexchange.com/users/59487/mr-xcoder) for helping me putting this together*  
*Saved 1 byte thanks to [@JonathanAllan](https://codegolf.stackexchange.com/users/53748/jonathan-allan)*
Returns `0` for right-handed or `1` for left-handed.
```
“ŒỴ¬Ʋ>r¤dị|®ædHẇ⁸ɗH^CŒ³ẇPḷgȤƲȥƓƑ®Ƭṅḅ4ṛḟṄ’ḃ⁴+\
Oḅ⁹×6%⁽£€%566e¢
```
[Try it online!](https://tio.run/##AYIAff9qZWxsef//4oCcxZLhu7TCrMayPnLCpGThu4t8wq7DpmRI4bqH4oG4yZdIXkPFksKz4bqHUOG4t2fIpMayyKXGk8aRwq7GrOG5heG4hTThuZvhuJ/huYTigJnhuIPigbQrXApP4biF4oG5w5c2JeKBvcKj4oKsJTU2NmXCov///1RL "Jelly – Try It Online")
### How?
We convert each country code to an integer **N** by parsing it as base-256 and apply the following hash function, which is collision-free for left-handed vs right-handed traffic:
```
((N * 6) MOD 1513) MOD 566
```
This leads to the following list of values for left-handed traffic:
```
[   8,  14,  27,  37,  52,  60,  62,  68,  71,  84,  85,  88, 103, 105, 114, 119, 135,
  166, 167, 180, 187, 190, 195, 196, 202, 207, 208, 211, 214, 225, 226, 229, 232, 255,
  256, 262, 285, 301, 302, 303, 304, 309, 322, 325, 327, 337, 357, 369, 370, 381, 393,
  401, 408, 413, 420, 430, 453, 467, 473, 478, 492, 503, 509, 513, 516, 527, 528, 541,
  546, 547, 556, 562 ] (72 entries)
```
The average difference between two consecutive entries is close to 8. We delta-encode the list with increments in the range [1...16]. It means that whenever an increment is greater than 16, we need to insert an intermediate value on an unused slot (we have to make sure that it's not hit by right-handed traffic). But the hash function was chosen in such a way that we only have to do that for a few positions. This gives:
```
[  8,  6, 13, 10, 15,  8,  2,  6,  3, 13,  1,  3, 15,  2,  9,  5, 16, 15, 16,  1, 13,
   7,  3,  5,  1,  6,  5,  1,  3,  3, 11,  1,  3,  3, 16,  7,  1,  6, 16,  7, 16,  1,
   1,  1,  5, 13,  3,  2, 10, 16,  4, 12,  1, 11, 12,  8,  7,  5,  7, 10, 16,  7, 14,
   6,  5, 14, 11,  6,  4,  3, 11,  1, 13,  5,  1,  9,  6 ] (77 entries)
```
We convert this list from bijective base-16 to the following integer:
```
274705197430389746738026977757328941544772847257562272094076195694133371689429679543810871702
```
which becomes `“ŒỴ¬Ʋ>r¤dị|®ædHẇ⁸ɗH^CŒ³ẇPḷgȤƲȥƓƑ®Ƭṅḅ4ṛḟṄ’` in Jelly's base-250 encoding.
The first link rebuilds the original list from this integer and the second one tests whether it contains the hash of the input.
```
“ŒỴ¬Ʋ>r¤dị|®ædHẇ⁸ɗH^CŒ³ẇPḷgȤƲȥƓƑ®Ƭṅḅ4ṛḟṄ’ḃ⁴+\      - 1st link: takes no input
“ŒỴ¬Ʋ>r¤dị|®ædHẇ⁸ɗH^CŒ³ẇPḷgȤƲȥƓƑ®Ƭṅḅ4ṛḟṄ’          - our big integer
                                         ḃ⁴        - convert it to bijective base-16
                                           +\      - apply delta-decoding
Oḅ⁹×6%⁽£€%566e¢                  - 2nd link: takes the country code  -> e.g. 'GB'
O                                - get ASCII codes                   -> [71, 66]
 ḅ⁹                              - convert from base-256 to integer  -> 18242
   ×6                            - multiply by 6                     -> 109452
     %⁽£€                        - modulo 1513                       -> 516
         %566                    - modulo 566                        -> 516
             e                   - look for it in the decoded list,
              ¢                  - using the first link as a nilad   -> 1
```
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), ~~161~~ 148 bytes
```
"$args"-match'A[GIU]|B[BDMNSTW]|[CFHW][CJKSXY]|DM|G[BDGSY]|[IJ][DEMNP]|K[EINY]|L[CKS]|M[OS-WYZ]|N[AFP-Z]|P[GKN]|S[BCGHORZ]|T[CHKLOTVZ]|UG|V[CGI]|Z.'
```
[Try it online!](https://tio.run/##DclNCoMwEEDhu0ghK3sHjTrGmCiNP9VhFlKkLiwtWuhm7p5m9/He5/1bj3Nb99376LIczzOKX8v3sYkEQfXEKaaZsa4biVEW5UgoK@3uE3FmGMIEF4yqIsxyY1tijbmyodUotSM22Lh4nGZii0nRxgEtgrbEDlMJZXMLpUNZ6rrphuAeeEAJini@Cu@9SED8AQ "PowerShell – Try It Online")
~~Naïve~~ regex pattern matching. Outputs `True` for left-handed and `False` for right-handed.
*Saved 13 bytes thanks to mercator golfing the regex.*
[Answer]
# [Haskell](https://www.haskell.org/), 137 bytes
*-5 bytes thanks to ovs.*
```
import Data.List
(`isInfixOf`"MSOBTVGBSBBMZAINAGDMOAUGGYBDBWSHKYBNRJPNFJMVCKIMTLCCXLSCYFKEVIDIEJELSGSOLKNZMWMYMUPKNPGSRNUTKTOTCTZSZWTTH")
```
[Try it online!](https://tio.run/##ZZVRb5swFIXf9ytQtIdNWvcP@mAbMARMXGxIwzSpqE1W1DStEibt32fNd6u@NFKOkH3vuefca8PjeHra7vfn8/T8@nKck3Scx5/1dJq/7K6/3U2n8rCb/q12dwsXVjr2Vget3aDKRtnUrVRn7Uaneh2KaqObdumbfOl6U5Uu1sbc1sFs8irry7TMllkdbFjVVTO4tdu4zleNt6FtuljFVTRxCMM6xmLx/fw8Tofk@kvy9ttv57f/bk6S6@TXQpWLH8lCWbC7oA5gCmrQgRFcX7AnXjcXrDYXNLegASuQ9ZTcnJV8eUELs4XBElOwW8JWsltmILlLQQ@yXgmivEatW4Foc3C6HkSzw5eTyOGCjQJbEOZG1ols8gt6VHl0erSFgro81zjtwTXMgedAfKBvAVUDtSwxNZyBuoGKEc5Yg@xGsiLKI5wRL510DOZIbk8HBvozrBe/Ge/ld5z@PM4yXqwohqMokpKqkKNotqKgugGRpqBUtFMhRJGlEatpsGYIWtYZrIZHY1cjWcNWyrocGfRohBtiKjgNFQ25hpiINoNmQ8sNPJVEwmbgN7AV8swADcoN2irGa2BLaXCK2hS2jAZnMjT0WPqQwZbhMaMDOfE5tXJ2rRwTUQtaGTUKLbkpaPFoybWSiy@LNotmSxWLcovfgpUCth7mQtaJL5lgKR1GcwlnSdZSeiUdgLPCYw1PjdOao1TDUDPTWq4UDLVcGrIczA4XjlqOrI1cL05Xjk5HPx06Hd4dFR27DTwNMQ21GvgbiZSLiPIV8R7lHgaPQk@kR4mHzaPBo@eGyIpnx8Rb4ls4Wxy1cGpxJBOkVhCELcATcNHK5SZe4z3gN8hVxkUgJgO9xFM9cNICGgyaAy4iGiK7Ti49fYhUjOiP6OlQomDoZAX@Dp5OXgP46onpYVjjK6PiJnt/Mbx9AB5ePl4Rr8fpMCdfk/Hw8IbP42uye/8qXF0l94/b@6dk2iXjfp/Mx7/bT2kvx48sedl8StuN@9P2/B8 "Haskell – Try It Online")
Generated the original string by hand.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~82~~ 68 bytes
Outputs **1** for left-traffic and **0** for right-traffic.
```
.•6uγ)₅₄вwÔívtÎĆ–≠5βI·{!ÅÇΔ›íÕ(1.€ò“Ñ¦_£äß₂Ë‹ûÚм2±rrÇQ=ÅÔζ)B†š¢¡ε•så
```
[Try it online!](https://tio.run/##AYkAdv8wNWFiMWX//y7igKI2dc6zKeKCheKChNCyd8OUw612dMOOxIbigJPiiaA1zrJJwrd7IcOFw4fOlOKAusOtw5UoMS7igqzDsuKAnMORwqZfwqPDpMOf4oKCw4vigLnDu8Oa0LwywrFycsOHUT3DhcOUzrYpQuKAoMWhwqLCoc614oCic8Ol//96dw "05AB1E – Try It Online")
or as a [Test Suite](https://tio.run/##JZBPSwJRFMW/irmZhJAMbBG0cDTH0Zlp6j3HmogoaNfKypA2w5BJBEFkmwhS@7PKRUZFf0CYW9vBz/C@yOQ7s/nxuPfcc8@7s9ntncxu1GjuRWnh9ecPw9eU8FvCPxkPj6hDg8YBXfyeCu9KnHWz4VAPPo6nqEXtsCO8LxrQ9XQmLfxnGgrvli6Dp63gnh7oTvg@nQvvk77pZvwzF7zU69ReWZxMdsL3lCq87l8v6Ae98G2ydZ8eo2aSRgsJGiVnog0lpyszCSWngVVJlYEFUAVNkIM1SQd61ZKsrEvm18A8WAFRL2C2iEqxLKnBWYODBk0JXR1uOrr6EojZckwbRL0SE8kNpDWXQWQz4Wk6IDKb@JcZK11JKweugnC24jqUVlHSRiobOW1kYyXsxdvATx2wBmeGN4Oe4W4MqVzs0qAx4Mmwl2Ejhyc3QHQ5pjiSc3hy/KUaXwzOHLMOLuDiPm5N2fwH)
Uses the string generated by [totallyhuman](https://codegolf.stackexchange.com/a/152644/47066) and improved by [ovs](https://codegolf.stackexchange.com/a/152642/47066)
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 76 bytes
```
.•B6L>õKвΩ~#ëΓnĀÿι–öß/çÄ¸’Û´äηÅÚ‚zÄ¨e÷ö#YʒƒʒjªêKΩoúö‰Öe¡₄Æ∞¤iY¥•#vySANèì})åZ
```
[Try it online!](https://tio.run/##AY8AcP8wNWFiMWX//y7igKJCNkw@w7VL0LLOqX4jw6vOk27EgMO/zrnigJPDtsOfL8Onw4TCuOKAmcObwrTDpM63w4XDmuKAmnrDhMKoZcO3w7YjWcqSxpLKkmrCqsOqS86pb8O6w7bigLDDlmXCoeKChMOG4oiewqRpWcKl4oCiI3Z5U0FOw6jDrH0pw6Va//96dw "05AB1E – Try It Online")
---
```
.•B6L>õKвΩ~#ëΓnĀÿι–öß/çÄ¸’Û´äηÅÚ‚zÄ¨e÷ö#YʒƒʒjªêKΩoúö‰Öe¡₄Æ∞¤iY¥•
```
Outputs the following string:
```
GIU BDMNSTW CKXY M  JK BDGSY K DEMN EMP EINY CKS OSTUVWYZA FPRUZ  GKN   BCGHORZ CHKLOTVZ G CGI S   AMW
```
If I split that on spaces, and interleave the alphabet into each string, it results in all the states that drive on the left side.
---
1 for left, 0 for right; Emigna's is better, but this felt different enough to post :).
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 69 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
ẇ“h¦¤$>Xø3¬I_°Ḷd⁺+ç*p¢7"FU]#x⁹ĿAxḷŻbCȦ]$ḣẒẓST¬ȥ¬ṆṠ®æ÷©#ḄS#MĠỤ4ɱ5’ṃØA¤
```
A monadic link taking a list of characters and returning `1` if left (`0` if right).
**[Try it online!](https://tio.run/##AYQAe/9qZWxsef//4bqH4oCcaMKmwqQkPljDuDPCrElfwrDhuLZk4oG6K8OnKnDCojciRlVdI3jigbnEv0F44bi3xbtiQ8imXSThuKPhupLhupNTVMKsyKXCrOG5huG5oMKuw6bDt8KpI@G4hFMjTcSg4bukNMmxNeKAmeG5g8OYQcKk////R0I "Jelly – Try It Online")**
**How?**
Uses the method as implemented [totallyhuman](https://codegolf.stackexchange.com/a/152644/47066) / [ovs](https://codegolf.stackexchange.com/a/152642/47066).
```
ẇ“ ... ’ṃØA¤ - Link: list of characters
           ¤ - nilad followed by link(s) as a nilad:
 “ ... ’     -   base 250 number = 19752831477605543488091668410027486265612829758468833715947215534967455540194888181580207621675010690833131726534873382634884974263558670694315853304
         ØA  -   list of characters = "ABCDEFGHIJKLMNPQRSUVWXZ"
        ṃ    -   base decompress = "MSOBTVGBSBBNZAINAGDMOAUGGYBDBWSHKYBNRJPNFJMVCKIMTLCCXLSCYFKEVIDIEJELSGSOLKOZMWMYMUPKNPGSRNUTKTOTCUZTZWTTH"
ẇ            - is a sublist of?
```
---
Also, what I did independently came in at **72 bytes**:
```
“¦w/ḳœBẒḂṡẏ,©ḷĿdẎq⁸4ṙ^|ṂỌʋ:vkɱF#ẊṠµd¤w,ḋhn|ȯ24ɦm|×ỵ’ṃ©ØAO0;I<0œṗ®ṭ€"ØAẎċ
```
Also a monadic link taking a list of characters and returning `1` if left (`0` if right).
**[Try it online!](https://tio.run/##AZEAbv9qZWxsef//4oCcwqZ3L@G4s8WTQuG6kuG4guG5oeG6jyzCqeG4t8S/ZOG6jnHigbg04bmZXnzhuYLhu4zKizp2a8mxRiPhuorhuaDCtWTCpHcs4biLaG58yK8yNMmmbXzDl@G7teKAmeG5g8Kpw5hBTzA7STwwxZPhuZfCruG5reKCrCLDmEHhuo7Ei////0dC "Jelly – Try It Online")**
**How?**
```
“ ... ’ṃ©ØAO0;I<0œṗ®ṭ€"ØAẎċ - Link: list of characters
“ ... ’                     - base 250 number = 20449742094039418439524274048234013619715377161457577389098927787850535557806494274193349238496252074719534810320317229
         ØA                 - list of characters = "ABCDEFGHIJKLMNPQRSUVWXZ"
       ṃ                    - base decompress = "GIUBDMNSTWCKXYMKJKBDGSYKDEMNEMPEINYCKSOSTUVXZZAFPRVZHGKNDCBCGHOSZCHKLOTWZGCGIASCBAMW"
        ©                   - copy to register
           O                - cast to ordinals = [71,73,85,66,68,77,78,83,84,87,67,75,88,89,77,75,74,75,66,68,71,83,89,75,68,69,77,78,69,77,80,69,73,78,89,67,75,83,79,83,84,85,86,88,90,90,65,70,80,82,86,90,72,71,75,78,68,67,66,67,71,72,79,83,90,67,72,75,76,79,84,87,90,71,67,71,73,65,83,67,66,65,77,87]
            0               - literal zero
             ;              - concatenate = [0,71,73,85,66,68,77,78,83,84,87,67,75,88,89,77,75,74,75,66,68,71,83,89,75,68,69,77,78,69,77,80,69,73,78,89,67,75,83,79,83,84,85,86,88,90,90,65,70,80,82,86,90,72,71,75,78,68,67,66,67,71,72,79,83,90,67,72,75,76,79,84,87,90,71,67,71,73,65,83,67,66,65,77,87]
              I             - incremental differences = [71,2,12,-19,2,9,1,5,1,3,-20,8,13,1,-12,-2,-1,1,-9,2,3,12,6,-14,-7,1,8,1,-9,8,3,-11,4,5,11,-22,8,8,-4,4,1,1,1,2,2,0,-25,5,10,2,4,4,-18,-1,4,3,-10,-1,-1,1,4,1,7,4,7,-23,5,3,1,3,5,3,3,-19,-4,4,2,-8,18,-16,-1,-1,12,10]
                0           - literal zero
               <            - less than (vectorises) = [0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,1,1,0,1,0,0,0,0,1,1,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,1,0,0,1,1,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,1,0,1,1,1,0,0]
                   ®        - recall from register = "GIUBDMNSTWCKXYMKJKBDGSYKDEMNEMPEINYCKSOSTUVXZZAFPRVZHGKNDCBCGHOSZCHKLOTWZGCGIASCBAMW"
                 œṗ         - partition at truthy indexes = ["GIU","BDMNSTW","CKXY","M","K","JK","BDGSY","K","DEMN","EMP","EINY","CKS","OSTUVXZZ","AFPRVZ","H","GKN","D","C","BCGHOSZ","CHKLOTWZ","G","CGI","AS","C","B","AMW"]
                       ØA   - list of characters = "ABCDEFGHIJKLMNPQRSUVWXZ"
                      "     - zip with:
                    ṭ€      -   tack for €ach = [["AG","AI","AU"],["BB","BD","BM","BN","BS","BT","BW"],["CC","CK","CX","CY"],["DM"],["EK"],["FJ","FK"],["GB","GD","GG","GS","GY"],["HK"],["ID","IE","IM","IN"],["JE","JM","JP"],["KE","KI","KN","KY"],["LC","LK","LS"],["MO","MS","MT","MU","MV","MX","MZ","MZ"],["NA","NF","NP","NR","NV","NZ"],["OH"],["PG","PK","PN"],["QD"],["RC"],["SB","SC","SG","SH","SO","SS","SZ"],["TC","TH","TK","TL","TO","TT","TW","TZ"],["UG"],["VC","VG","VI"],["WA","WS"],["XC"],["YB"],["ZA","ZM","ZW"]]
                         Ẏ  - tighten = ["AG","AI","AU","BB","BD","BM","BN","BS","BT","BW","CC","CK","CX","CY","DM","EK","FJ","FK","GB","GD","GG","GS","GY","HK","ID","IE","IM","IN","JE","JM","JP","KE","KI","KN","KY","LC","LK","LS","MO","MS","MT","MU","MV","MX","MZ","MZ","NA","NF","NP","NR","NV","NZ","OH","PG","PK","PN","QD","RC","SB","SC","SG","SH","SO","SS","SZ","TC","TH","TK","TL","TO","TT","TW","TZ","UG","VC","VG","VI","WA","WS","XC","YB","ZA","ZM","ZW"]
                            - ...this is the left list plus EK, OH, QC, RC, WA, XC, and YB
                            -    (which are not in the right list)
                          ċ - count
```
[Answer]
# Befunge, ~~155~~ ~~152~~ ~~147~~ 146 bytes
```
~48*%10p~20pv
\"`"`"A"+61p>:2g:48*%10g-!20g61g-!#@*#,_\1+:"O"#@`#._
NzBSgCLVStBGiIJknAVGPSuStAKvfCFHPLttBDIJzBIPkMStJn{NsBLMWgBMtAMnMtBMzcKCGmMNSt
```
[Try it online!](http://befunge.tryitonline.net/#code=fjQ4KiUxMHB+MjBwdgpcImAiYCJBIis2MXA+OjJnOjQ4KiUxMGctITIwZzYxZy0hI0AqIyxfXDErOiJPIiNAYCMuXwpOekJTZ0NMVlN0QkdpSUprbkFWR1BTdVN0QUt2ZkNGSFBMdHRCRElKekJJUGtNU3RKbntOc0JMTVdnQk10QU1uTXRCTXpjS0NHbU1OU3Q&input=Wlc)
Outputs `80` for a right-handed country, and anything else indicates a left-handed country.
**Explanation**
The bottom line of the code contains a representation of all the left-handed countries. This is a list of the first characters of the country codes, grouped by their second character. The end of each group is marked by lowercasing the last character in the group.
So for example the first group, `Nz`, represents `NA` and `ZA`. The second group, `BSg`, represents `BB`, `SB`, and `GB`. There is one group for each letter in the alphabet, except for the letter `Q` (no left-hand country codes end in `Q`). That empty group is represented by the character `{`, since that obviously won't match any valid country code.
To determine whether a given country code matches one of these entries, we iterate through the list checking whether any of the characters in the list match the first character of our input (mod 32 to account for the case), and also that the corresponding group, matches the second character of the input. The group character start as `A`, and is incremented every time we encounter a lowercase letter in the list.
We exit when we find a match, outputting the last character value on the stack (which will be the first character of the country code - possibly lowercase). Otherwise we'll exit when we've iterated through the whole list, in which case we will output the last number on the stack, which is always 80.
[Answer]
# Windows Batch, ~~289~~ ~~279~~ ~~199~~ ~~193~~ ~~181~~ ~~130~~ 118 bytes
```
@echo TTHSZWMSGSONPKNZMWVIDFKELSCYJPNFJMTVCXBNRBWSHKYAUGGYBTLCCKIMVGBSBBMZAINAGDMOBDIEJEMYMUNUPGSRLKTKTOTCTZ|find "%1"
```
Outputs the ovs' string for left-hand traffic, else outputs nothing.
**Note:** I noticed if the input *contains* any country code in the list above, it will still output L. However, this does not violate the challenge rule as OP mentioned only country codes need to be handled.
---
Explanation:
```
@echo TTHSZ...OTCTZ            :: List all country code.(compressed by ovs)
                   |           :: Pipe the result to the find command.
                    find "%1"  :: Find the first argument in the country code list,
                               :: and output the ovs string if found.
                               :: By default, FIND returns the piped string when
                               :: a match is found.
```
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~181~~ ~~169~~ 165 bytes
```
f(x){x=strstr("AIAUBSBDBBMBTBWVGBNKYCXCCKCYDMFKFJGDGGYHKINIDIEIMJMJPJEKELSMOMWMYMVMTMUMZNANRNPNZNUNFPKPGPNSHKNLCVCWSSCSGSOZAGSLKSRSZTHTLTKTOTTCTVUGTZVIZMZW",x)?:82;}
```
[Try it online!](https://tio.run/##fcwxa8MwEAXgPb8iCAI2JEun0lCKJduyLN9Z5M5yJbIUQ0qGmpJmMIT8dtfQuXm84cEHb9h9DsM8n5IpvU2vP9fL0kRkJuskyVxKkCx7ryXaoN6VsirkUNqy1rnWobIGTW4KAzXUri5s0RC00EMADwwdRMzwgA4jdlg667RDqiw2yqueSJGmNmaaGksHilxxw5ZbZsW@0xy9iRB7sZ3St5fnp/19/vo4j0m6uq3WS74v5/F6SsRmOI5iu16WCyJN9/8hPkD1CPXf7X3@BQ "C (gcc) – Try It Online")
[Answer]
# [Python 2](https://docs.python.org/2/), 144 bytes
```
lambda l:l[1]in'GIU,BDMNSTW,CKXY,M,,JK,BDGSY,K,DEMN,EMP,EINY,CKS,OSTUVWYZ,AFPRUZ,,GKN,,,BCGHORZ,CHKLOTVZ,G,CGI,S,,,AMW'.split(',')[ord(l[0])-65]
```
**[Try it online!](https://tio.run/##VZVBj9owEIXv/IpoL4DkVm2l9lBpD4lJnJDYeGMnLKEcqLaoSBQQSw/99Vv4vIdkD09Zz8yb92accP53/X06fnmrC5X76DFaj@NsLKJx/AxWd5x1PDtwBi7AJ7AGNbgEPUhVkoMrMAXD@RyEJ4nBFoStCOcKRE9S3FGSU8Ip6SipleR4tEk0SwPCU4ZM2CT8ErY8PDcgyiXaSsszbLMSRO0MtlSCsDn0KOaQwpbiMWUCGfkZvTKiCp02qAUV@hUKFbUzUOFRUatCLb4U2hSaFV0UyhV@c05y2FqY83BOfsEGizBhNBdwFlTNw6zCBOAs8VjBU@G0SkAYKnZaobCCoaKLpkrDrHGh6aWpWpGpuV0ZOjXz1OjUeNd01EQNPIYcQy8DvwmZTMOgfEG@RbmFwaLQkmlRYmGzaLDoeSKz5Fmz8Zr8Gs4aRzWcSXAUNkgvFxA2B4/DRc2cHfkJ3h1@HXfJ4cKRk4I25NPdcdMcGiSaHS48GjxRDY9nDp6OHv0ePQ1KYhiacAJ/A0/Dflt8teS0MCzxldJxlY43oyrN3r8H9IlRHd/qRtH73zjhNiToTuiUwJXQL2EuybJfIdmjRL9kJnLVj890/78Mt1nZP1P0VPRUKFN0UwOefFBTkF3gtkBnYfrxOZE5kbntR0oiJd5LvJWDPhV@KvxUrh/R3B@NNh3ufHg7eI8029RsRHf9OsP2DNsw4XazW0O1GeRa/Fu624Ejx5Qc6lz4UoW7hCoHoxtweXI9WT7cL@6vp8LjwKPdD@oa2FvZP2vDWdE/Ww6m0@GyY@Ld8nbbRrvHH2@H7Z@fL9vo8P2w/rzZH29fv0YkM22cXwpZPq@EFmJe3o6UW4lSzFJtRKqtSAuzuiU4sXC@aZerTsSZrZtOCFUaIUQiVb6oOyHzslr4thNKSFUIdwvFt018fD0f9tfJWIyn69PlZXJYf9pMP3z7unnbvr7@ulyj7eEw2U2qabQ7XaIq2h@j@8sxHfXCx9M12k3qkFLfU/hBnY5G58v@eL2V74/nv9fJdDp9e4iLh/8 "Python 2 – Try It Online")**
Prints `True` for left, `False` for right.
[Answer]
# [Retina](https://github.com/m-ender/retina), ~~150~~ 117 bytes
```
$
MSOBTVGBSBBMZAINAGDMOAUGGYBDBWSHKYBNRJPNFJMVCKIMTLCCXLSCYFKEVIDIEJELSGSOLKNZMWMYMUPKNPGSRNUTKTOTCTZSZWTTH
^(..).*\1
```
[Try it online!](https://tio.run/##BcHBDoIwDADQ@75DE/RA4ifQAWVs7RZawC3G6MGDFw/G/5/vfV@/9@dZjw0@6sGQRNANQQCodI477Cl2K2KGHnaZfAZe5sTjTJv1jjRYew1i8@iHzfVumIcgKDF4LrRTpjV5TigLr@o1qtUiZVedzL1p21N7vl1qTdkkNpYN5j8 "Retina – Try It Online")
[Answer]
# Excel VBA, 118 Bytes
Anonymous VBE immediate window function that takes input from cell `[A1]` and outputs `0` if the country is right-handed
```
?InStr(1,"TTHSZWMSGSONPKNZMWVIDFKELSCYJPNFJMTVCXBNRBWSHKYAUGGYBTLCCKIMVGBSBBMZAINAGDMOBDIEJEMYMUNUPGSRLKTKTOTCTZ",[A1])
```
uses [ovs' string](https://codegolf.stackexchange.com/a/152642/61846)
[Answer]
# Japt, ~~126~~ ~~100~~ 97 bytes
Uses ~~totallyhuman's~~ [ovs' lookup string](https://codegolf.stackexchange.com/a/152642/58974). Takes input in lowercase and outputs `false` for RHD or `true` otherwise.
```
`tszwmsgspknzmwvidfkelscyjpnfjmtvcxbnrbw¢kyauggybtlc×Svgbsbbmzaagd¶b¹ejemymunupgsrlktktctz`øU
```
[Try it](https://ethproductions.github.io/japt/?v=1.4.5&code=YHSQc3p3bXNnc41wa256bXd2aWRma2Vsc2N5anBuZmptdHZjeGJucmJ3omt5YXVnZ3lidGxj11N2Z2JzYmJtemGIYWdktmK5ZWplbXltdW51cGdzcmxrdGuRdGN0emD4VQ==&input=ImllIg==)
Everything between the backticks is the lookup string lowercased and compressed and `ø` checks if it contains the input, `U`.
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), ~~60~~ ~~57~~ ~~55~~ ~~50~~ ~~47~~ ~~46~~ 44 bytes
```
00000000: 736d 406a 4322 579f 235e 804c c3eb 6f49  sm@jC"W.#^.L..oI
00000010: aee5 1f3d be3d 4e13 f326 1934 a181 a210  ...=.=N..&.4....
00000020: 7158 3f94 2232 2f43 5164 5336            qX?."2/CQdS6
```
[Run online](https://pyth.herokuapp.com/?code=sm%40jC%22W%C2%9F%23%5E%C2%80L%C3%83%C3%ABoI%C2%AE%C3%A5%1F%3D%C2%BE%3DN%13%C3%B3%26%194%C2%A1%C2%81%C2%A2%10qX%3F%C2%94%222%2FCQdS6&test_suite=1&test_suite_input=%27AI%27%0A%27AG%27%0A%27AU%27%0A%27BS%27%0A%27BD%27%0A%27BB%27%0A%27AF%27%0A%27AX%27%0A%27AL%27%0A%27DZ%27%0A%27AS%27%0A%27AD%27)
Takes the input as an uppercase quoted string (`'AI'`). Returns `3` for left and non-`3` for right.
### How it works
```
sm@jC"…"2/CQdS6
 m           S6   map for d in [1, …, 6]:
     "…"            string literal
    C               convert to integer from base 256
   j    2           digits in base 2
  @                 wrapping index at:
           Q          input string
          C           convert to integer from base 256
         /  d         integer division by d
s                 sum
```
### Generating the magic string
```
import binascii
import z3
n, k, c = 239, 6, 3
a = [z3.Bool('a{}'.format(i)) for i in range(n)]
def f(s0, s1):
    return z3.Sum([z3.If(a[(ord(s0) * 256 + ord(s1)) // j % n], 1, 0) for j in range(1, k + 1)]) == c
solver = z3.Solver()
solver.add(a[0])
for s0, s1 in ['AI', 'AG', 'AU', 'BS', 'BD', 'BB', 'BM', 'BT', 'BW', 'VG', 'BN', 'KY', 'CX', 'CC', 'CK', 'CY', 'DM', 'FK', 'FJ', 'GD', 'GG', 'GY', 'HK', 'IN', 'ID', 'IE', 'IM', 'JM', 'JP', 'JE', 'KE', 'KI', 'LS', 'MO', 'MW', 'MY', 'MV', 'MT', 'MU', 'MS', 'MZ', 'NA', 'NR', 'NP', 'NZ', 'NU', 'NF', 'PK', 'PG', 'PN', 'SH', 'KN', 'LC', 'VC', 'WS', 'SC', 'SG', 'SB', 'SO', 'ZA', 'GS', 'LK', 'SR', 'SZ', 'TH', 'TL', 'TK', 'TO', 'TT', 'TC', 'TV', 'UG', 'GB', 'TZ', 'VI', 'ZM', 'ZW']:
    solver.add(f(s0, s1))
for s0, s1 in ['AF', 'AX', 'AL', 'DZ', 'AS', 'AD', 'AO', 'AQ', 'AR', 'AM', 'AW', 'AT', 'AZ', 'BH', 'BY', 'BE', 'BZ', 'BJ', 'BO', 'BA', 'BV', 'BR', 'IO', 'BG', 'BF', 'BI', 'CV', 'KH', 'CM', 'CA', 'CF', 'TD', 'CL', 'CN', 'CO', 'KM', 'CG', 'CR', 'CI', 'HR', 'CU', 'CW', 'CZ', 'KP', 'CD', 'DK', 'DJ', 'DO', 'EC', 'EG', 'SV', 'GQ', 'ER', 'EE', 'ET', 'FO', 'FI', 'FR', 'GF', 'PF', 'TF', 'GA', 'GM', 'GE', 'DE', 'GH', 'GI', 'GR', 'GL', 'GP', 'GU', 'GT', 'GW', 'GN', 'HT', 'HM', 'VA', 'HN', 'HU', 'IS', 'IR', 'IQ', 'IL', 'IT', 'JO', 'KZ', 'KW', 'KG', 'LA', 'LV', 'LB', 'LR', 'LY', 'LI', 'LT', 'LU', 'MG', 'ML', 'MH', 'MQ', 'MR', 'YT', 'MX', 'FM', 'MC', 'MN', 'ME', 'MA', 'MM', 'NL', 'NC', 'NI', 'NG', 'NE', 'MP', 'NO', 'OM', 'PW', 'PA', 'PY', 'PE', 'PH', 'PL', 'PT', 'PR', 'QA', 'KR', 'MD', 'RE', 'RO', 'RU', 'RW', 'BL', 'MF', 'PM', 'SM', 'ST', 'SA', 'SN', 'RS', 'SL', 'BQ', 'SX', 'SK', 'SI', 'SS', 'ES', 'PS', 'SD', 'SJ', 'SE', 'CH', 'SY', 'TW', 'TJ', 'MK', 'TG', 'TN', 'TR', 'TM', 'UA', 'AE', 'UM', 'US', 'UY', 'UZ', 'VU', 'VE', 'VN', 'WF', 'EH', 'YE']:
    solver.add(z3.Not(f(s0, s1)))
res = solver.check()
print(res)
if res == z3.sat:
    m = solver.model()
    print('n={} k={} c={} a={!r}'.format(n, k, c, binascii.unhexlify('{:0{}x}'.format(
        int(''.join('01'[z3.is_true(m[x])] for x in a), 2), n // 8 * 2))))
```
[Answer]
# sed, ~~148+1~~ ~~145+1~~ ~~143+1~~ 142+1 bytes
One extra byte for `-r` flag (POSIX extended regexes).
Outputs empty string for left-handed traffic, original country code for the right-handed traffic.
```
s/A[GIU]|B[BDMNSTW]|C[CXY]|DM|FJ|G[BDGSY]|I[DEMN]|J[^O]|K[EINY]|L[CS]|M[OS-WYZ]|N[AFP-Z]|P[GN]|S[BCGHORZ]|T[CHLOTVZ]|UG|V[CGI]|WS|Z.|[^DMS]K//
```
Example:
```
$ echo -e 'PY\nPN\nCN\nGY' | sed -re 's/A[GIU]|B[BDMNSTW]|C[CXY]|DM|FJ|G[BDGSY]|I[DEMN]|J[^O]|K[EINY]|L[CS]|M[OS-WYZ]|N[AFP-Z]|P[GN]|S[BCGHORZ]|T[CHLOTVZ]|UG|V[CGI]|WS|Z.|[^DMS]K//'
PY
CN
$
```
Explained edit history:
```
148 s/A[GIU]|B[BDMNSTW]|C[CKXY]|DM|F[JK]|G[BDGSY]|HK|I[DEMN]|J[EMP]|K[EINY]|L[CKS]|M[OSTUVWYZ]|N[AFPRUZ]|P[GKN]|S[BCGHORZ]|T[CHKLOTVZ]|UG|V[CGI]|WS|Z.//
    naïve regexp; the only optimization here is 'Z.'
145 s/A[GIU]|B[BDMNSTW]|C[CKXY]|DM|F[JK]|G[BDGSY]|HK|I[DEMN]|J[EMP]|K[EINY]|L[CKS]|M[OS-WYZ]|N[AFP-Z]|P[GKN]|S[BCGHORZ]|T[CHKLOTVZ]|UG|V[CGI]|WS|Z.//
    M[OSTUVWYZ] → M[OS-WYZ]
    N[AFPRUZ] → N[AFP-Z]
    the replacements can match inexistent coutries, which is totally fine
143 s/A[GIU]|B[BDMNSTW]|C[CXY]|DM|FJ|G[BDGSY]|I[DEMN]|J[EMP]|K[EINY]|L[CS]|M[OS-WYZ]|N[AFP-Z]|P[GN]|S[BCGHORZ]|T[CHLOTVZ]|UG|V[CGI]|WS|Z.|[^DMS]K//
    |[^DMS]K (which also matches impossible country codes) allows these changes:
    C[CKXY] → C[CXY]
    F[JK] → FJ
    |HK → ∅
    L[CKS] → L[CS]
    P[GKN] → P[GN]
    T[CHKLOTVZ] → T[CHLOTVZ]
142 s/A[GIU]|B[BDMNSTW]|C[CXY]|DM|FJ|G[BDGSY]|I[DEMN]|J[^O]|K[EINY]|L[CS]|M[OS-WYZ]|N[AFP-Z]|P[GN]|S[BCGHORZ]|T[CHLOTVZ]|UG|V[CGI]|WS|Z.|[^DMS]K//
    J[EMP] → J[^O] (thanks @Neil)
```
## sed, ~~158+1~~ ~~155+1~~ ~~153+1~~ 152+1 bytes, non-empty answer
Slight variation of the previous one. Returns `L` for left-handed traffic.
```
s/[GIU]|B[BDMNSTW]|C[CXY]|DM|FJ|G[BDGSY]|I[DEMN]|J[^O]|K[EINY]|L[CS]|M[OS-WYZ]|N[AFP-Z]|P[GN]|S[BCGHORZ]|T[CHLOTVZ]|UG|V[CGI]|WS|Z.|[^DMS]K/&L/;s/^..//
```
[Answer]
# [APL (Dyalog)](https://www.dyalog.com/), 108 bytes
```
1∊⍷∘'TTHSZWMSGSONPKNZMWVIDFKELSCYJPNFJMTVCXBNRBWSHKYAUGGYBTLCCKIMVGBSBBMZAINAGDMOBDIEJEMYMUNUPGSRLKTKTOTCTZ'
```
[Try it online!](https://tio.run/##vZPBbtQwFEX38xXZBaSyYMvOdhInk9jjxk6mk91Q2qpSaRHTLhBiiyqkkdggseEzKv5nfmRozpPgD9hcOfZ99937HG8/3Lx692l7c3d1PL4@PH477H8fHn/mKdVxWrto48qH1k9uPTZF1ZZdNJtl8NXSpdGcad/rdazbjRqs3ejUGdM2brQ6au0m1XhlC7fSRVMuS7dxgx@CjX3XpjatkklTfjwe9r8yt72@zS4fbs/vr@9usxe7h7fvr3e75/XLxeIyO3z9nv1/Z4vF7Cxd7O4vPv71tlhcYefzYf90kr/J8pPD/sfl88eXf/TsfLu72D0zc9XkM1pwmFFHsAA16MAErmcc4Ws/Y7uZ0ZyBBmxB9gtqK3aq5YwWZYuChVNz2qDWcNqUILVLwQCy3wrivMOtW4F4c2i6EcSzI5cT5jSjV2APouxlH6avZgy4CvgMeIs1fVl3JB3BNcqRdYQfmVvE1UQvC6dDM9I30jGhmTqQ00RVwnlCM5FlkImhnKgdmcDEfCayK5wr7kKhWcBUdFfMVqGvTkGcKBSUKNBXUaXxppmnZuZa9rlHjY4mncahRq2RfflD8KPxaeC0aBo6GmoNnIQ3g2fDhA06rTBRM@gb1GpZc18G5wZvLbdpUCuYZ4HbArWSeZZyR/ixzKFErSRjyQQq@BW9Kk6t/BXiFrRyszi01BagJaOl1kotuSzeLJ4tXSzOLXlrdmrURpRr2YffcIONTBjPDZoNVUuZlUwAzZaMHTodSTv@nA6Fjjvt5AWh0Mkbocqh7Ejh6OWo2shr4u@q8OmYp8OnI7ujo@PUo@PheHp59L0w5d3hfAU/4DygEHAYYAacBNQCHgJ@TmG2rB033sPv0exJ1KOpJZHcIL2iIGoRnUiKXt4yfE32SN4oL5cUEU4JBuHTPfKnRTwYPEdSJDwkTp28ceaQ6Jjwn/Az4EShMMgO@gM6g7x6co1wRhTW5CrpuCnzPw "APL (Dyalog Unicode) – Try It Online")
Using the lookup string by ovs.
Left-handed traffic = `1`.  
Right-handed traffic = `0`.
[Answer]
# Javascript (ES6), ~~118~~ 116 bytes
Saved 2 bytes thanks to @Craig Ayre
```
s=>"SZAINAGGDMOAUGBBSCCKIMWSHKYLSBMVGSGYBDBTHBWBNRMZMTLCXSRTVCYPNFKNPKEFJMYVIDIEJPGJEMUNZWMSONULKTKTOTTCTZ".match(s)
```
Returns `null` for right-handed traffic
## Test Cases
```
f=s=>"SZAINAGGDMOAUGBBSCCKIMWSHKYLSBMVGSGYBDBTHBWBNRMZMTLCXSRTVCYPNFKNPKEFJMYVIDIEJPGJEMUNZWMSONULKTKTOTTCTZ".match(s)
console.log("AI,AG,AU,BS,BD,BB,BM,BT,BW,VG,BN,KY,CX,CC,CK,CY,DM,FK,FJ,GD,GG,GY,HK,IN,ID,IE,IM,JM,JP,JE,KE,KI,LS,MO,MW,MY,MV,MT,MU,MS,MZ,NA,NR,NP,NZ,NU,NF,PK,PG,PN,SH,KN,LC,VC,WS,SC,SG,SB,SO,ZA,GS,LK,SR,SZ,TH,TL,TK,TO,TT,TC,TV,UG,GB,TZ,VI,ZM,ZW".split`,`.every(s=>f(s)!=null))
console.log("AF,AX,AL,DZ,AS,AD,AO,AQ,AR,AM,AW,AT,AZ,BH,BY,BE,BZ,BJ,BO,BA,BV,BR,IO,BG,BF,BI,CV,KH,CM,CA,CF,TD,CL,CN,CO,KM,CG,CR,CI,HR,CU,CW,CZ,KP,CD,DK,DJ,DO,EC,EG,SV,GQ,ER,EE,ET,FO,FI,FR,GF,PF,TF,GA,GM,GE,DE,GH,GI,GR,GL,GP,GU,GT,GW,GN,HT,HM,VA,HN,HU,IS,IR,IQ,IL,IT,JO,KZ,KW,KG,LA,LV,LB,LR,LY,LI,LT,LU,MG,ML,MH,MQ,MR,YT,MX,FM,MC,MN,ME,MA,MM,NL,NC,NI,NG,NE,MP,NO,OM,PW,PA,PY,PE,PH,PL,PT,PR,QA,KR,MD,RE,RO,RU,RW,BL,MF,PM,SM,ST,SA,SN,RS,SL,BQ,SX,SK,SI,SS,ES,PS,SD,SJ,SE,CH,SY,TW,TJ,MK,TG,TN,TR,TM,UA,AE,UM,US,UY,UZ,VU,VE,VN,WF,EH,YE".split`,`.every(s=>f(s)==null))
```
[Answer]
**K, 105 bytes**
For information about K/Q languages see code.kx.com
Use: Country-code (2-char string, example "XY") after 
```
in[;+\-48+5h$"62<729151368=1>a1A23<6<C181A83?45;488F411112115:235Q43r141738353135247F42Tl<:"]@26/:-65+5h$
```
Generates `1b` (Left-handed traffic) or `0b` (not Left-handed traffic)
Explanation:
* `5h$"XX"` generates ascii codes for each char of the 2-char string (country-code), Example `5h$"TB"` generates 84 66
* `-65+integerList` substract 65 to each integer in the list. Example `-65+5h$"TB"` generates 19 1
* `26/:integerList` computes integer equivalent to that list as digits in 26-base. Example `26/:-65+5h$"TB"` generates 495 (country-code as integer)
* `in[;listOfCountryCodesAsIntegers]@x` returns boolean value (1b = true, 0b = false). True if x is in the list
* `+\-48+5h$"62<729151368=1>a1A23<6<C181A83?45;488F411112115:235Q43r141738353135247F42Tl<:"` calculates list of integers for each country code with Left-handed traffic
	+ `"62<729151368=1>a1A23<6<C181A83?45;488F411112115:235Q43r141738353135247F42Tl<:"` is the 'distance string' (distance between each pair of integer-country-codes in ascending order, codified as char). Distance n is codified as ascii char 48+n
	+ `-48+5h$".."` calculates ascii value of each char in string ".." and recover original distance as ascii-code - 48. The result is the list of distances
	+ `+\integerList` calculates partial summation of items from the list -> absolute integer-country-codes from distances between codes.
NOTES.-
* Returns `0b` for any non-left-handed country-code, including not valid country codes
* We can save a char reformatting the code, but requires to write country-code "XX" inside the code (i don't know if it's valid, but i'm quite sure it's not elegant) 
`in[26/:-65+5h$"XX";+\-48+5h$"..."]`
[Answer]
# Vim, ~~117~~ ~~109~~ 108 keystrokes
```
oSZAINAGGDMOAUGBBSCCKIMWSHKYLSBMVGSGYBDBTHBWBNRMZMTLCXSRTVCYPNFKNPKEFJMYVIDIEJPGJEMUNZWMSONULKTKTOTTCTZ␛kg*D
```
[Try it online!](https://tio.run/##PY/BToMwGIDvPMWfhkjign2BuYSW0kFpIWsBIV5wVLfIRkQ2TYzv4N2380Vwp12/7/Dle2rfd7Pd7gZAmiFYwfO@t3fT5@SMtu3AH8HvACGgsFwCy6J50E0Qq4DzUGZBwQnRlIpYVnot6lQTWXLNaxISsyYVURvZSJPSB70xJa1zFQmVCxYlsi7jMGZJzhMmC9VUUmeqSIURJjOGmubv5/f15TacL0mH3iP3i2J8Ydj1Hq33jZzz/gD@CVSmGKDFcRgPbQ8uReAtPt686wXcrAB39oyPp753tu10NfM/) (replace `SE` in the header with the country code)
`␛` is the escape key. The program prints the following text for right-handed traffic:
```
SZAINAGGDMOAUGBBSCCKIMWSHKYLSBMVGSGYBDBTHBWBNRMZMTLCXSRTVCYPNFKNPKEFJMYVIDIEJPGJEMUNZWMSONULKTKTOTTCTZ
```
## Explanation
```
oSZAINA...OTTCTZ␛ Input the lookup-string on a new line
kg*D              Delete the everything after the last occurence of the country code
                   on the same line
```
[Answer]
# [MY-BASIC](https://github.com/paladin-t/my_basic), 162 bytes
Anonymous Function that takes input as an unwrapped string (that is, without parenthesis) and outputs to the console
```
Input"",x$,
For y=0 To 100
z=z+(Mid("TTHSZWMSGSONPKNZMWVIDFKELSCYJPNFJMTVCXBNRBWSHKYAUGGYBTLCCKIMVGBSBBMZAINAGDMOBDIEJEMYMUNUPGSRLKTKTOTCTZ",y,2)=x$)
Next
Print z
```
Returns `0` for right-handed and `1` for left-handed traffic, [try it online!](https://tio.run/##BcFND0MwGADgu1/RNA5kltjuDlpU1Vuyvhi3fR0cxmKW4M/b87zX4/327R/7LofPb6bUW2zPSsaJrIFPcCQn37e2YDs40D8dipiargEjTKFLpTtoahklKs4Nb7NSJxlgza9MX1hjUtWGlRAtw5xzJaEWzDAGXSh1KCIoWCTjLIYWKl2VwlxyhQoL5NhRb/XObrDYrqVfy2yVUz/MZNt3xD8 "MY-BASIC – Try It Online")
[Answer]
# [Yabasic](http://www.yabasic.de), 127 bytes
Anonymous function that takes input as an unwrapped string (no `"..."`) and outputs `0` if the Country is right-handed and `1` if the country is left handed.
```
Input""A$
?InStr("TTHSZWMSGSONPKNZMWVIDFKELSCYJPNFJMTVCXBNRBWSHKYAUGGYBTLCCKIMVGBSBBMZAINAGDMOBDIEJEMYMUNUPGSRLKTKTOTCTZ",A$)>0
```
[Try it online!](https://tio.run/##BcG9DsIgEADg3ccgHTRx8Ak0HLQU6FHSu/7AVp1cGqN18Onx@37rff08H6XY7fXdhZDV4WY32t9HwdxSnpEM9SH6kHGerG583ZFKLobGIU9qgTDATK1PcjQmAXdKeYuTAQLALG2QRmMP2tauxoRjGKOhofPsuWfFWZxldbpeSqH8Bw "Yabasic – Try It Online")
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~115~~ 107 bytes
```
f(short*x){x=!wcschr(L"䥁䝁啁卂䑂䉂䵂呂坂䝖乂奋塃䍃䭃奃䵄䭆䩆䑇䝇奇䭈义䑉䕉䵉䵊偊䕊䕋䥋卌位坍奍噍呍啍卍婍䅎剎偎婎啎䙎䭐䝐乐䡓之䍌䍖南䍓䝓䉓体䅚升䭌剓婓䡔䱔䭔佔呔䍔噔䝕䉇婔䥖䵚坚",*x);}
```
[Try it online!](https://tio.run/##dY@xasJQGIX3PoUNFJJin0A6dGkp@AhdSorVobaoUEEcclNNr/oHw72xKNzBIUOGDA4ZMuRtzv8c6YWuFc5wDh@Hw/FvXn2/aXruuP8@mlxPvdn09vLTH/v9kdt1kAUwAacBk0AiIAVKwYlgI2B2qARnaz6GoBBFyFmI8gvFEvkSSQQTcRah@EYlkUikEqXVioMVUqs1bJc2qIkNcUa8J06IU2IizgmLmGXMQcx5zGmMfYxiC7NFtcVRoVrDdmnH9ANSMApSoVZYHJjs6Ial4lzhqHHSKDRqzYkGad5rmBQy4lwj26E8sDk4bXu8M28Gw0nr7XkwdL3ZxcfIpp7rXL08DZ22NXf3jtfyOv@Ax3Pg4Rzo/oF58ws "C (gcc) – Try It Online")
Returns `0` if left handed. -4 thanks to @JonathanFrech
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal) `r`, 65 bytes
```
⇩«°ǎ+₃∧M⋏⁼•¼¾E⇧M∪∵IḞ½ð∷⅛ḃxṀ⌊ż‹←∵o8ƒ₈£…₌⌈⋏L⟑₇₌±M…uġεƛǏ∆%zKɾ\@(L-«c
```
[Try it Online!](https://lyxal.pythonanywhere.com?flags=r&code=%E2%87%A9%C2%AB%C2%B0%C7%8E%2B%E2%82%83%E2%88%A7M%E2%8B%8F%E2%81%BC%E2%80%A2%C2%BC%C2%BEE%E2%87%A7M%E2%88%AA%E2%88%B5I%E1%B8%9E%C2%BD%C3%B0%E2%88%B7%E2%85%9B%E1%B8%83x%E1%B9%80%E2%8C%8A%C5%BC%E2%80%B9%E2%86%90%E2%88%B5o8%C6%92%E2%82%88%C2%A3%E2%80%A6%E2%82%8C%E2%8C%88%E2%8B%8FL%E2%9F%91%E2%82%87%E2%82%8C%C2%B1M%E2%80%A6u%C4%A1%CE%B5%C6%9B%C7%8F%E2%88%86%25zK%C9%BE%5C%40%28L-%C2%ABc&inputs=AU&header=&footer=)
]