[Question]
  [
# Objective
Given an ASCII string, decide whether it is a valid C integer literal.
# C integer literal
A C integer literal consists of:
* One of:
	+ `0` followed by **zero or more** octal digits (`0`–`7`)
	+ A nonzero decimal digit followed by **zero or more** decimal digits (`0`–`9`)
	+ `0X` or `0x`, followed by **one or more** hexadecimal digits (`0`–`9`, `A`–`F`, and `a`–`f`)
* optionally followed by one of:
	+ One of `U` or `u`, which are the "unsigned" suffixes
	+ One of `L`, `l`, `LL`, or `ll`, which are the "long" and "long long" suffixes
	+ Any combination of the above, in any order.
Note that there can be arbitrarily many digits, even though C doesn't support arbitrary-length integers. Likewise, even if the literal with `l` and co would overflow the `long` type or co, it is still considered a valid literal.
Also note that there must **not** be a leading plus or minus sign, for it is not considered to be a part of the literal.
# Rules
* It is implementation-defined to accept leading or trailing whitespaces.
* Non-ASCII string falls in *don't care* situation.
# Examples
## Truthy
* `0`
* `007`
* `42u`
* `42lu`
* `42UL`
* `19827489765981697847893769837689346573uLL` (Digits can be arbitrarily many even if it wouldn't fit the `unsigned long long` type)
* `0x8f6aa032838467beee3939428l` (So can to the `long` type)
* `0XCa0` (You can mix cases)
## Falsy
* `08` (Non-octal digit)
* `0x` (A digit must follow `X` or `x`)
* `-42` (Leading signature isn't a part of the literal)
* `42Ll` (Only `LL` or `ll` is valid for the `long long` type)
* `42LLLL` (Redundant type specifier)
* `42Uu` (Redundant type specifier)
* `42Ulu` (Redundant type specifier)
* `42lul` (Redundant type specifier)
* `42H` (Invalid type specifier)
* `0b1110010000100100001` (Valid C++, but not valid C)
* `Hello`
* Empty string
# Ungolfed solution
## Haskell
Doesn't recognize leading or trailing whitespaces.
Returns `()` on success. Monadic failure otherwise.
```
import Text.ParserCombinators.ReadP
decideCIntegerLit :: ReadP ()
decideCIntegerLit = do
    choice [
        do
            '0' <- get
            munch (flip elem "01234567"),
        do
            satisfy (flip elem "123456789")
            munch (flip elem "0123456789"),
        do
            '0' <- get
            satisfy (flip elem "Xx")
            munch1 (flip elem "0123456789ABCDEFabcdef")
        ]
    let unsigned = satisfy (flip elem "Uu")
    let long = string "l" +++ string "L" +++ string "ll" +++ string "LL"
    (unsigned >> long >> return ()) +++ (optional long >> optional unsigned)
    eof
```
  
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), ~~60~~ 59 bytes
```
i`^(0[0-7]*|0x[\da-f]+|[1-9]\d*)(u)?(l)?(?-i:\3?)(?(2)|u?)$
```
[Try it online!](https://tio.run/##JY1Pa8MwDMXv/hwb2B0G@U8taRcfdlgPuQ4GSUZd6kLArFAW6CHfPVNaofeTEOK9W/2bfsv6qj@P63T80dCDxXG3wL0fzsVexreld5bH4bwzejZZN1G20/sQstFZe7PM2bysqwIFgCr6WdQ2fHXKMXmMxJj2TC4xUkTigIlJIFtMewxz1ym40yWVAsFToJjwVGsNHDh6agq@P4rYk3wpG714d22D1JbzCGvP3O1@UHByzgFIP/Cc6lBbu/4D "Retina 0.8.2 – Try It Online") Link includes test cases. Edit: Saved 1 byte thanks to @FryAmTheEggMan. Explanation:
```
i`
```
Match case-insensitively.
```
^(0[0-7]*|0x[\da-f]+|[1-9]\d*)
```
Start with either octal, hex or decimal.
```
(u)?
```
Optional unsigned specifier.
```
(l)?
```
Optional length specifier.
```
(?-i:\3?)
```
Optionally repeat the length specifier case sensitively.
```
(?(2)|u?)$
```
If no unsigned specifier yet, then another chance for an optional specifier, before the end of the literal.
[Answer]
# [Perl 5](https://www.perl.org/) `-p`, ~~65~~ 61 bytes
*@NahuelFouilleul shaved 4 bytes*
```
$_=/^(0[0-7]*|0x\p{Hex}+|[1-9]\d*)(u?l?l?|l?l?u?)$/i*!/lL|Ll/
```
[Try it online!](https://tio.run/##hVJta9swEP7uX3FjhcnJHMsvsSXKKCNfMnBXGHQU2m4osZxq3CRjS1tCs79eT3a2L/3Q6uXRSffccfegVna4HPoYFrM4Pu/F4Rzewg/XW3iQnYTGdLBF0Sl7ANOAfZCgdOssCF2DcXY0R46VvVV6txjOvn@IvxF6S6Pyfnak@7v2cS33f@bH2yTi93f1LCTuAv08juAuwrNYzd7EWB0rjIeBBpSWQZ46v3GE6ypIOEvLnPGyWHKWFLxkecl4VhacefBWXizLzFVVQPesKYSgWcoylhflRkqZ8YznKcOA3qyET8@AfDY6MlsrEGq1Uzb0cUA@ni7wc@y9MYjmN9yAb20fBlGeAqmkqH2L0KudFtZ5cVSv33kloBWd/a8OKis7gaEvvUIgVxoPUFVjHkQfAL8Eqvok2cg2PuEE9tDKKcgPIF9k7XQttJ3eoW/lVjVKdiPj2r3ix1cI6PBlwhrIJ30q9LmTbpIkodSvCU4nkK8TeTWfv4eN/xHa2H@NrsJgLb2WT6a1yuh@iC6XCx82RC3@BQ "Perl 5 – Try It Online")
[Answer]
# Java 8 / Scala polyglot, ~~89~~ 79 bytes
```
s->s.matches("(?!.*(Ll|lL))(?i)(0[0-7]*|[1-9]\\d*|0x[\\da-f]+)(u?l?l?|l?l?u?)")
```
-10 bytes thanks to *@NahuelFouilleul*
[Try it online in Java 8.](https://tio.run/##PVKxbtswEN3zFVdOoh0JpESLZILWQ5YMajoEBQo4HiiaTuXScmBSqYvY3@6StBxIeHe8e7r3dOBGvat8s/pz1lY5B99V13/cAHS9N/u10gae4hHgR7sx2oPOnv2@61/B4ftQP90EcF75TsMT9PD17PJvrtgqr38bl6Fs/qWYZI092gbjbN7hjCxIzpeT44LmcvnyspocyWERosrXyynOhrkNzzHCMMcIn@@jwtvQ2qAwCr3vuhVsg9HRy2IJCl9crnf7q0FvnH9QzsAd9OYvXKkfiKBbRAgPyMohIrUplD@b2Pn1oBLjINa1UqQqRSVYzVtjTCUryUphQ5tKUXImJK9nUtBacsG4kBWvpQgQMlbPeDU0cSS6BUREmhkgZ2VSa@wlNIkT1EcToxk7XPqP8buWUkpIeBNcYqg/Gmt30UxDk/WDage9SgOueUyL@D@UFCw2aFlZNqujkcgJx5GtQ1oQgk44bRLg@Z/zZlvsBl@8hd1522fXnU7RHaBpX@jPCh6vw@n8Hw)  
[Try it online in Scala](https://tio.run/##NVFNb8MgDL33VzBO0I8IEhqgUhptu/SQnapJk9oeaErWTizpGjJVWvfbMyCdQO/Z2NgP3JbKqL7Zf@jSghd1qoG@Wl0fWvB4Pv@MAPhWBlQLsLaXU/0OsiV4ahqjVQ2yvs2WbfSpbHnULYIof4jGqDA3U2CM8hNGZENmfDe@behM7rbbw/hGrhvHalbtJhh1uXHr5qHLMcT90Mzq1rYgA2v9hSCBU0gId8jiziM1geLXwkfenlXIuIoqVYoksUgES/lea53IRLJYGBemUsScCcnTuRQ0lVwwLmTCUykcOIulc550hS8JpwASEWo6mLE4dCvMQEXIcd3vIu5iTDfEV/7enlJKiNsBBnbnK21M48UUNEi/qn1XHkKBf9ubkX8PJRHzARonhs1TL8TnOPeeXTozIgRiN6DwX1HVXLQqj8j6EZ3drKypnTMBcAGgowpZjPHot/8D) (except with `=>` instead of `->` - thanks to *@TomerShetah*).
**Explanation:**
```
s->           // Method with String parameter and boolean return-type
  s.matches(  //  Check whether the input-string matches the regex
    "(?!.*(Ll|lL))(?i)(0[0-7]*|[1-9]\\d*|0x[\\da-f]+)(u?l?l?|l?l?u?)")
```
*Regex explanation:*
In Java, the [`String#matches`](https://docs.oracle.com/en/java/javase/14/docs/api/java.base/java/lang/String.html#matches(java.lang.String)) method implicitly adds a leading and trailing `^...$` to match the entire string, so the regex is:
```
^(?!.*(Ll|lL))(?i)(0[0-7]*|[1-9]\d*|0x[\da-f]+)(u?l?l?|l?l?u?)$
```
```
 (?!         )     # The string should NOT match:
^   .*             #   Any amount of leading characters
      (     )      #   Followed by:
       Ll          #    "Ll"
         |lL       #    Or "lL"
                   # (Since the `?!` is a negative lookahead, it acts loose from the
                   #  rest of the regex below)
 (?i)              # Using case-insensitivity,
^    (             # the string should start with:       
       0           #   A 0
        [0-7]*     #   Followed by zero or more digits in the range [0,7]
      |            #  OR:
       [1-9]       #   A digit in the range [1,9]
            \d*    #   Followed by zero or more digits
      |            #  OR:
       0x          #   A "0x"
         [     ]+  #   Followed by one or more of:
          \d       #    Digits
            a-f    #    Or letters in the range ['a','f'] 
     )(            # And with nothing in between,
              )$   # the string should end with:
        u?         #   An optional "u"
          l?l?     #   Followed by no, one, or two "l"
       |           #  OR:
        l?l?       #   No, one, or two "l"
            u?     #   Followed by an optional "u"
```
[Answer]
# [C# (.NET Core)](https://www.microsoft.com/net/core/platform), 197 191 bytes
@nwellnhof shaved 6bytes:
```
using c=System.Console;class P{static void Main(){c.WriteLine(System.Text.RegularExpressions.Regex.IsMatch(c.ReadLine(),@"^(?!.*(Ll|lL))(?i)(0[0-7]*|[1-9]\d*|0x[\da-f]+)(u?l?l?|l?l?u?)$"));}}
```
Original:
```
using c=System.Console;using System.Text.RegularExpressions;class P{static void Main(){c.WriteLine(Regex.IsMatch(c.ReadLine(),@"^(?!.*(Ll|lL))(?i)(0[0-7]*|[1-9]\d*|0x[\da-f]+)(u?l?l?|l?l?u?)$"));}}
```
[Try it online!](https://tio.run/##LYxdC4JAFET/ikUPey0X@4CICIPoIVCICnowg2W92cKm4V1jI/vtZhEDA3PgjCRPFiU2TUUqzxy52D/J4I2vipwKjXOpBZGzfZERRknnUajUiYTKGbwkP5bKYKhyZH/rgNbwHWaVFuXa3kskUu3RF6HlG4qEkVcm2y3SnweDZffMgg53WahrHQKwQAHzY9@bJm4dD71Zckrd2rfxKRXeJekDqwLdpv5WFUCvCzB/v5vGt6Px5AM "C# (.NET Core) – Try It Online")
[Answer]
# [Python 3](https://docs.python.org/3/), 103 bytes
```
import re;re.compile("^(0[0-7]*|[1-9]\d*|0[xX][\dA-Fa-f]+)([uU](L|l|LL|ll)?|(L|l|LL|ll)[uU]?)?$").match
```
[Try it online!](https://tio.run/##XY5da8MgFIavl18RZBfaLUWjjdoxwhiMXuS2ULAO0tbQgPkgTUYH@e9ZvrovkPc9@p7jecrP@lzktEuzsqhqtzJO8mw@YgsBAD@PT5VZHousTK2B4B1ihT2uF60intT706LF6rrTan968d5iL9EPCKpmq2HU2jbqxaKw/XUZshCF9wAts7g@nrt@lyJkrZGTFJV7cdPcVQCDRxdgzAdjfjOZnX0bDU6k8DkTkgcrKUgguWBcSMoDKXrpKxasOG2isRlfRRLEMaa@oIIF/GCMoZJK5gs75rvXGAO9du7KKs1rmMALQs4fIjH9M6jH/IkksrNPW3q0G6L9Zp5bNuP4gRCCcX9GmXwINsbaYij@M3Rf "Python 3 – Try It Online")
just a basic regex, probably very suboptimal
returns a match object for truthy and None for falsy; input may not contain surrounding whitespace
-3 bytes thanks to Digital Trauma (on my Retina answer)  
-1 byte thanks to FryAmTheEggman (on my Retina answer)  
-3 bytes thanks to pxeger
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), 73 bytes
```
^(0[0-7]*|[1-9]\d*|0[xX][\dA-Fa-f]+)([uU](L|l|LL|ll)?|(L|l|LL|ll)[uU]?)?$
```
[Try it online!](https://tio.run/##K0otycxL/P8/TsMg2kDXPFarJtpQ1zI2JkWrxiC6IiI2OibFUdctUTctVltTI7o0NFbDpyanxgdI5Gja1yBxQHL2mvYq//8bVFikmSUmGhgbWRhbmJiZJ6WmphpbGluaGFnkAAA "Retina 0.8.2 – Try It Online")
Just the same regex I used. First time using Retina, I'm sure this can be optimized with some Retina golf things!
-3 bytes thanks to Digital Trauma  
-1 byte thanks to FryAmTheEggman
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 76 bytes
```
≔⊟Φ³¬⌕↧θ…0xιη≔✂↧θη⁻ＬθＬ⊟Φ⪪”{“↧←；⭆δa”¶⁼ι↧…⮌θＬι¹ζ›∧⁺Ｌζ¬⊖η⬤ζ№Ｅ∨×⁸ηχ⍘λφι∨№θLl№θlL
```
[Try it online!](https://tio.run/##XVBNb4MwDL3vVyBORmJSu1II6ol1Hxe6oXXHXhD1SiQ3tCHpNv48cyga0yLZsi0/v/dS1aWumpL6PmtbeVBQNCd4kmRQwyL0XhrDndpD3nyirsoW4RyE3vq7IlzXvOrPvvzQk4F7oVcHq5vxzpZkhf9gdehtpLIt5KgOph5mY/mHdnsiacDfKUvk0k6R5SDLRDz1GfR4tiW1IBn@SzBpesML6pFyPH8VOGicc3Sss9BSGXjWWDrSjD0WNEnrgqv5B6w0HlEZ3EM94DMi6PgLGsvwTXmCVw3v8ogtCPcBTDDjdM@StoYpDkCh9@GAcoDz9hV6Zjc5OTdTT7nvRK76fp6KuyQSaRIvUzGP00REiUgXSZwKTlxF8TJZ2Dzvby/0Aw "Charcoal – Try It Online") Link is to verbose version of code. Explanation:
```
≔⊟Φ³¬⌕↧θ…0xιη
```
Find the length of the longest prefix of `0x` in the lowercased input.
```
≔✂↧θη⁻ＬθＬ⊟Φ⪪”{“↧←；⭆δa”¶⁼ι↧…⮌θＬι¹ζ
```
Slice off the prefix and also check for a lowercase suffix of `ull`, `ul`, `llu` or `lu`, and if so then slice that off as well.
```
›...∨№θLl№θlL
```
The original input must not contain `Ll` or `lL`.
```
∧⁺Ｌζ¬⊖η
```
The sliced string must not be empty unless the prefix was `0`.
```
⬤ζ№Ｅ∨×⁸ηχ⍘λφι
```
Convert the prefix length to `10`, `8` or `16` appropriately, then take that many base 62 digits and check that all of the remaining lowercased characters are one of those digits.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), ~~63~~ ~~61~~ 62 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
„Uuõª„LLæDl«âDí«JéRʒÅ¿}нõ.;Ðć_ilDć'xQiA6£мÐþQë\7ÝKõQë\þQ}sõÊ*
```
This isn't too easy without regexes.. :/ Can definitely be golfed a bit more, though.
+1 byte as bug-fix for inputs like `"u"`, `"l"`, `"LL"`, etc. (thanks for noticing *@Neil*)
[Try it online](https://tio.run/##yy9OTMpM/f//UcO80NLDWw@tAjJ8fA4vc8k5tPrwIpfDaw@t9jq8MujUpMOth/bXXth7eKue9eEJLkfa4zNzgKR6RWCmo9mhxRf2HJ5weF/g4dUx5ofneh/eCmIB@bXFh7ce7tL6/9@gwiLNLDHRwNjIwtjCxMw8KTU11djS2NLEyKLUxwcA) or [verify all test cases](https://tio.run/##NU/LSgMxFP2Vko0gdUgmaR64KOIsis6mQkFQkZk6QiHQRYm0i4IbLbgq3etCQahFd7PzAbldueo39EfGJK0Qzj3JOffek/4gy3tFdTNqotr6flZDzVFi59X69qljoLRvjqQpvCbaLuA5gXe7OIL5ye/Mfgzgzv6MV19QRvsJTJeTy55OlpOdYbt3wO3L6hOm8N2GxbmAx2MoPXP38QBKeNit6tUZwqiOMBYOWWw8Eh1K3Em9cnqYBcdQXvMswzSWVDIu8qIoqKKKxVI7mSgZCyaV4A0lCVdCMiEVFVxJB44x3hDUpH4kqtcQlmGmgz0Wh22p3pQ0eNz2bYhtGG02esv35YQQjN0JsKnuvVVo3fdhUhKiD7PcdK/CgH/uaeT/Q3DEvEBiqlmD@yDe465bd9fRCHurt/nGEMwYdPEH).
**Explanation:**
```
„Uu                 # Push string "Uu"
   õª               # Convert it to a list of characters, and append an empty string:
                    #  ["U","u",""]
     „LL            # Push string "LL"
        æ           # Take its powerset: ["","L","L","LL"]
         Dl         # Create a lowercase copy: ["","l","l","ll"]
           «        # Merge the lists together: ["","L","L","LL","","l","l","ll"]
            â       # Create all possible pairs of these two lists
             Dí     # Create a copy with each pair reversed
               «    # Merge the list of pairs together
                J   # Join each pair together to a single string
                 éR # Sort it by length in descending order
```
We now have the list:
```
["llu","LLu","llU","LLU","ull","uLL","Ull","ULL","ll","LL","lu","lu","Lu","Lu","lU","lU","LU","LU","ll","LL","ul","ul","uL","uL","Ul","Ul","UL","UL","l","l","L","L","u","u","U","U","l","l","L","L","u","u","U","U","","","",""]
```
```
ʒ                   # Filter this list by:
 Å¿                 #  Where the (implicit) input ends with this string
}н                  # After the filter: only leave the first (longest) one
  õ.;               # And remove the first occurrence of this in the (implicit) input
ÐD                  # Triplicate + duplicate (so there are 4 copies on the stack now)
  ć                 # Extract head; pop and push remainder-string and first character
                    # separated to the stack
   _i               # If this first character is a 0:
     l              #  Convert the remainder-string to lowercase
      D             #  Duplicate it †¹
       ć            #  Extract head again
        'xQi       '#  If it's equal to "x":
            A       #   Push the lowercase alphabet
             6£     #   Only leave the first 6 characters: "abcdef"
               м    #   Remove all those characters from the string
                Ð   #   Triplicate it †²
                 þ  #   Only keep all digits in the copy
                  Q #   And check that the two are still the same
                    #   (thus it's a non-negative integer without decimal .0s)
          ë         #  Else:
           \        #   Discard the remainder-string
            7Ý      #   Push list [0,1,2,3,4,5,6,7]
              K     #   Remove all those digits
               õQ   #   Check what remains is an empty string
   ë                # Else:
    \               #  Discard the remainder-string
     þ              #  Only keep all digits
      Q             #  And check that the two are still the same
                    #  (thus it's a non-negative integer without decimal .0s)
   }s               # After the if-else: Swap the two values on the stack
                    # (this will get the remaining copy of †² for "0x" cases,
                    #  or the remaining copy of †¹ for other cases)
     õÊ             # Check that this is NOT an empty string
       *            # And check that both are truthy
                    # (after which the result is output implicitly)
```
[Answer]
# [AWK](https://www.gnu.org/software/gawk/manual/gawk.html), 86 bytes
```
{print/^(0[0-7]*|[1-9][0-9]*|0[xX][0-9A-Fa-f]+)([uU](L|l|LL|ll)?|(L|l|LL|ll)[uU]?)?$/}
```
[Try it online!](https://tio.run/##TY1fS8MwFMXf8ylKmdA6427@LLl5sYgge8jrYNBVSF0LYlBRiwO7z15vuj14yf3l5J5wT/h5nX4/Pl/evvss3@dXX/s843dZfpMt4HRxVk8F1MBtcz3WgruGtCMN9XE363v@GHjfLMuiHrZN4cc4ekIsq/HfI3lVWS1Wp2kCBmCZlgN1TNh6JhxKq9FZs3YojLOoLTpljUMCKW3WVg3eMzhib0IAJVGhNrbtuk455bTEyGD3EGg90i/GtaTdPiZQpZw5LJ5z03zDoBVCANCZcb7ZpovxnTFxK5nwImWGdng@xOEP "AWK – Try It Online")
Simply prints truthy or falsey depending on whether or not the input line matches the regex. Doesn't accept leading or trailing whitespaces.
[Answer]
# [Elixir](https://elixir-lang.org/), 74 bytes
```
&(&1=~~r/^(0[0-7]*|[1-9]\d*|0x[\da-f]+)(u?l?l?|l?l?u?)?$/i&&!(&1=~~r/Ll/))
```
[Try it online!](https://tio.run/##S83JrMgs@p9m@19NQ83Qtq6uSD9OwyDaQNc8Vqsm2lDXMjYmRavGoCI6JiVRNy1WW1Oj1D4HCGtARKm9pr2KfqaamiJMr0@Ovqbmf09/vYLSkmKFND0NIDM9taRYyU5J879BRUpqYkpSamqaj08pAA "Elixir – Try It Online")
[Answer]
# JavaScript (ES6), ~~77~~ 76 bytes
*Saved 1 byte thanks to @l4m2*
```
s=>/^(0x[\da-f]+|0[0-7]*|[1-9]\d*)(u?l?l?|l?l?u?)$/i.test(s)>/Ll|lL/.test(s)
```
[Try it online!](https://tio.run/##dZBdS8MwFIbv/RlDaDvpmjRZPi62XQiyi1wqCG2FbE11cmhlaWVC/3uNE0HxjIQ3yZOTj/d9te/W74@Htz5tu9pNzWryq3X2FJNTUdY2baqbkRQkldV8LGiqq7KeJ/GwgdDGLxk2yXV2WPTO97FP1pmBEUz2s572Xes7cAvonuOouD8O/ctHFSVXv3kTz8gs@c@IRCjPB5QCjh8MgqlWueRKS7HUigotFZdKMym0ChJmXCwlGwx2lpxUI6wlLFdMcSF3zjmmmea5Aqz88daezf3ZiMq2uLPg0SgU@ioCU56jng3g2KCGQkYXooNLSeP3b7F/7yilhIR@lu8Rqds6gA7hAU2f "JavaScript (Node.js) – Try It Online")
### How?
The first regex is case-insensitive. The only invalid patterns that cannot be filtered out that way are `"Ll"` and `"lL"`. So we use a 2nd case-sensitive regex to take care of them.
[Answer]
# [Haskell](https://www.haskell.org/), 169 bytes
```
import Data.Char
s!p=s>""&&dropWhile p s`elem`do u<-["","u","U"];l<-"":words"L l LL ll";[u++l,l++u]
f('0':x:s)|elem x"xX"=s!isHexDigit|1<2=(x:s)!isOctDigit
f s=s!isDigit
```
[Try it online!](https://tio.run/##ZVFda9swFH3Pr7i9D22CmyB/1JbzMRgtIw@GPYyyQglUnaVaTLGFJW0e9L9n127KBhW@x9bR8T1HUiPcT2nM6aSPtus93AkvVreN6Gfuwu7cJ8TLy7rv7PdGGwkW3JM08vhUdxC2y0fEawxU93jYmO0Scf2762uHFRioCAxuHkMUmWsTReEwU/MrdrUe1m7xOnaBAYcH3LkL7fZyuNMv2r/G22Q3HxVEfv3hJ3KmwE2qaXY6Ct3CDupuBmCkB98H3/whZvIGZMBYDlkSqMwI9xXEJU@KjJdFflPyOC8LnhW8TIu85AT0leU3RRooMxu4yoVgacJTnuXFs5QyLdMyS7gB9nArGJ59lTBO/u/LyZhqgGWWkG1lRqAxRphymLdII78H9hzHMWP0TPD2hj1dRocQRUCHe3h3GvertPGyh3nb@ZVanHf9LrD/BOocjJZs8N98D/hlJKCVL8LrX9KtATdge92OnT/IbOf0B5klmVbQBmNgrtooUpYiNLI9/1y1gJ9pzUvnHVjhnKxXCHJqGHoJ88XpLw "Haskell – Try It Online")
]