[Question]
  [
## Or *Fix American Kennel Club's database*
As covered by the recent [video by Matt Parker](https://www.youtube.com/watch?v=jMxoGqsmk5Y), the American Kennel Club *permits thirty-seven (37) dogs of each breed to be assigned the same name* ([source](https://www.akc.org/register/information/naming-of-dog/)), because of a database restriction for Roman numeral length.
Given an integer, your task is to output the length of its Roman representation.
## Rules
* Your input will be an integer in the range 1-3899.
* Conversion to Roman is performed using the [standard subtractive notation](https://en.wikipedia.org/wiki/Roman_numerals#Standard_form) (so `4=IV`, `9=IX`, `95=XCV`, `99=XCIX`).
* This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), the usual rules apply.
## Test-cases
```
input  output
1      1
2      2
3      3
4      2
5      1
6      2
9      2
10     1
37     6
38     7
95     3
99     4
288    10
2022   6
3089   9
3899   11
```
  
[Answer]
# [Python 2](https://docs.python.org/2/), 44 bytes
```
f=lambda x:x and 5739180/5**(x%10)%5+f(x/10)
```
[Attempt This Online!](https://ato.pxeger.com/run?1=NY5NCsIwGESvkk0hrSPNjzH5Cl7AK4iLSAkWNC0lQjyLm27EM3kbs6i7xzDzmNdneqbrGNWyvB8pbN0X4XDz90vvWe4y87FnxmqSTrSmaXiupKgrswk8t4XWzTGMM8tsiOwkoaCxg8EeFg4EKaAtdEEDIijnoIQqLeGoxETnbpqHmHhx1qvx_-YH)
The magic number `5739180` encodes the list `[2, 4, 3, 2, 1, 2, 3, 2, 1, 0]` in base 5, which correspond to the Roman numeral lengths for the decimal digits 9 to 0. `5**(x%10)%5` extracts the `x%10`th base-5 digit, and the rest is a recursive function to compute the sum per decimal digit of `x`.
[Answer]
# JavaScript (ES6), 37 bytes
```
f=n=>n&&+"0123212342"[n%10]+f(n/10|0)
```
[Try it online!](https://tio.run/##ddDBCsIwDAbgu09RBo6NoUvSbmsP80XEw5ibKKMVJ5589ypoB1ZyyOkjyZ9cukc397fz9b6x7jh4P7a23dk0LRJAkvQuRcnerhEOxZjZEuEJue@dnd00bCd3ysYMhRB5LspS4OpXaBGKRC4iI1FsT8XuqdkewwoCN002QepYdJAm3lNx9xgTRMXf0TokgJiAiIkA2nzE/IUzX0H0Lw "JavaScript (Node.js) – Try It Online")
### How?
In standard subtractive notation, the lengths of the digits are the same for units, tens, hundreds and thousands (up to 3000). So we can just recursively compute the total length.
```
   | units | tens | 100's | 1000's | length
---+-------+------+-------+--------+--------
 0 | -     | -    | -     | -      |   0
 1 | I     | X    | C     | M      |   1
 2 | II    | XX   | CC    | MM     |   2
 3 | III   | XXX  | CCC   | MMM    |   3
 4 | IV    | XL   | CD    |        |   2
 5 | V     | L    | D     |        |   1
 6 | VI    | LX   | DC    |        |   2
 7 | VII   | LXX  | DCC   |        |   3
 8 | VIII  | LXXX | DCCC  |        |   4
 9 | IX    | XC   | CM    |        |   2
```
---
# JavaScript (ES6), 40 bytes
This is an attempt to find a short formula instead of a lookup table. But it's still longer.
```
f=n=>n&&f(n/10|0)+(30%(n%=10)&171/n^n%4)
```
[Try it online!](https://tio.run/##ddDPCsIwDAbwu0/Ry0aLaJN2f9rDfBRhzE2UkYoTT757PWgHVnL@kXxfcu2f/TLcL7fHjsJpjHHqqDtQWU6SNMIL1FZaKCQVHYIqsUVNRyoqFYdAS5jH/RzOcpIohFBKaC1w8ytmFZOJXcVmUrEzNZvTsDOeFQRum22TNLm4JG2eU3P3eJ@kyr/jXGoAOYExTAVw/iP@r5z/CmJ8Aw "JavaScript (Node.js) – Try It Online")
### 36 bytes
It does come out shorter if we can take the input as a list of digits:
```
a=>a.map(n=>t+=30%n&171/n^n%4,t=0)|t
```
[Try it online!](https://tio.run/##fdDLDoIwEAXQvV/BBgNxhD54dVF@xNSkQTQabIk0rvz3aggxQLXdnsyd27nJpxyax7U3e6VPrT1zK3ktk7vsI8Vrs@MUhWqLS5yqowozMBzFL2MbrQbdtUmnL9E5OmARjC@OgzQN8GbFZMFkzXTBdM2Zfzr37y7808zPGJDwhFMoZ1y4XM24dHZDLjz/ZsBmnDlHhWqMn6oh1xEQIOJvN/QJYBOzH9WBfRlj@wY "JavaScript (Node.js) – Try It Online")
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), 3 bytes
```
øṘL
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyIiLCIiLCLDuOG5mEwiLCIiLCI5NSJd)
I love it when there's built-ins for things like this.
## Explained
```
øṘL
øṘ  # Convert input to Roman numerals
  L # and return the length of that.
```
[Answer]
# [Python 2](https://docs.python.org/2/), 41 bytes
Uses [@Arnauld's idea](https://codegolf.stackexchange.com/a/246364/88546) of computing the length of each decimal digit separately. A magic hash in the form `x**a%b%5` seems to work well.
```
f=lambda n:n and(n%10)**24%8684%5+f(n/10)
```
[Try it online!](https://tio.run/##NYzRCoMwDEXf8xV5EdTJ1taqVei3jA4nFjQWp8i@3nVV85LLPSdx36WfSOx7pwczvlqD1BAaamOKOEvSVMhIlUpGxa2L6eGrfevt8EbeAFpyGU7r4lDjaFxsaclwNtvTg3WJk/vHDdbvBNDNHmLnFZeg1uFq5xiGgziCgPwIOcirKS6nvJr6CpydKK9CKCFXIVRQF@ef@rAlCBUYZyCYEIfN1J/W/ixonP8A "Python 2 – Try It Online")
Other magic:
```
lambda n:sum(7125144/ord(c)%5for c in`n`)   # 41
f=lambda n:n and(n%5+n/5%2>>n%5/4)+f(n/10)  # 42 (has actual strategy)
```
# [Python 2](https://docs.python.org/2/), 41 bytes
Alternatively, the same length, but who doesn't love a little magic `hash`?
```
lambda n:sum(hash(c+'WQDE')%5for c in`n`)
```
[Try it online!](https://tio.run/##NYzLCoMwEEX38xWzKRoqxSS@wV37AV11U6jpQyJoDD6Qfr1NE53NXO45M/o7yV6xtS7vayu651ugKsa586UYpf86erfr@eKRQ1z3A76wUZWqyLrIpv0gLcAUOsB@njSW2AntN2oKcBDLw4B58slp1G1jNgHUg4FYG0UTLEt7tVK0Q4G5wIC7wCHam3h3kr3J90DDDfHUhgR4ZkMKebz9yZ0dAcssoyGwkDFnh9mf5ubMapT@AA "Python 2 – Try It Online")
The little C script below finds all possible 4-byte long suffixes to seed the hash, and takes roughly a second to complete. Interestingly, out of the 12 valid solutions, `'WQDE'` is the only one with all uppercase characters. If you think about it, the chances of this occurrence are only `26^4/127^4 ~ 0.176%`!
```
// https://github.com/python/cpython/blob/v2.7/Objects/stringobject.c#L1263
#include <stdio.h>
#include <time.h>
int py_mod(long long x, int m) { int ret = x % m; return ret >= 0 ? ret : ret + m; }
const long long h[10] = {6144036912055440, 6272037681056595, 6400038450057750, 6528039219058905, 6656039988060060, 6784040757061215, 6912041526062370, 7040042295063525, 7168043064064680, 7296043833065835};
long long h0[10], h1[10], h2[10];
int main() {
    clock_t sclock = clock();
    for (int c0 = 1; c0 < 128; c0++) {
        for (int i0 = 0; i0 < 10; i0++) h0[i0] = (h[i0] ^ c0) * 1000003;
        for (int c1 = 1; c1 < 128; c1++) {
            for (int i1 = 0; i1 < 10; i1++) h1[i1] = (h0[i1] ^ c1) * 1000003;
            for (int c2 = 1; c2 < 128; c2++) {
                for (int i2 = 0; i2 < 10; i2++) h2[i2] = (h1[i2] ^ c2) * 1000003 ^ 5;
                for (int c3 = 1; c3 < 128; c3++) {
                    if (py_mod(h2[0] ^ c3, 5) != 0) continue;
                    if (py_mod(h2[1] ^ c3, 5) != 1) continue;
                    if (py_mod(h2[2] ^ c3, 5) != 2) continue;
                    if (py_mod(h2[3] ^ c3, 5) != 3) continue;
                    if (py_mod(h2[4] ^ c3, 5) != 2) continue;
                    if (py_mod(h2[5] ^ c3, 5) != 1) continue;
                    if (py_mod(h2[6] ^ c3, 5) != 2) continue;
                    if (py_mod(h2[7] ^ c3, 5) != 3) continue;
                    if (py_mod(h2[8] ^ c3, 5) != 4) continue;
                    if (py_mod(h2[9] ^ c3, 5) != 2) continue;
                    printf("found: (%d,%d,%d,%d) [%c%c%c%c]\n",
                        c0, c1, c2, c3, c0, c1, c2, c3);
                }
            }
        }
    }
    printf("Time elapsed: %.3fs\n", (double) (clock() - sclock) / CLOCKS_PER_SEC);
    return 0;
}
```
[Answer]
# Excel, 15 bytes
```
=LEN(ROMAN(A1))
```
It feels like a rare win to use an Excel built-in for a programming challenge.
[![Screenshot](https://i.stack.imgur.com/yUlyL.png)](https://i.stack.imgur.com/yUlyL.png)
[Answer]
# [Ruby](https://www.ruby-lang.org/), ~~39~~ 37 bytes
```
->n{n.digits.sum{|x|x%5>3?2:x/5+x%5}}
```
[Try it online!](https://tio.run/##JYtNDoIwGET3nqIbjcax9odCPxPwIIaFxmBYQIhIrAHOXkvZTN68zLyHx89XuT8V7djyZ/2qPz3vh2ac3OS2ptBXdXFncww8z75j3/wmoaCRwCAFQQroDNqCDIigrIUSKiyEpaCJSt7cu/2uOmyW93JnCkzHXHmFFCyLPglVxE6BZOn/ "Ruby – Try It Online")
Thanks dingledooper for -2 bytes (pointing out that 37 and 39 are two different numbers, which I didn't realize)
[Answer]
# x86-64 machine code, 27 bytes
```
97 31 C9 67 8D 71 05 99 F7 F6 F6 C2 04 D1 D8 74 02 D1 EA 11 D1 85 C0 75 EE 91 C3
```
[Try it online!](https://tio.run/##XVLBbuIwED3HXzGbFWoCpqKh7ZKw9NLzXva0EnAwtpO4Mg4bh64B8evNjkNo1VqKo3lv/OaNx3y3Gxect@13ZbjeCwk/bSNUdVs@kU@QVpuvWK1M4TEiXSNrA@FzCCdlGsgjv7N4fibMbiGC32FEbgtdbZiGnORZ4HhZgBSKgmSOBK6qQXJH/UYCLRlIi9wSw9HDmugs4OIvCYR69QQJGmkbEJrCPQlqXnsRCnckeDmCJYEtEREdYrOACd5rC9ef7NK7wi/mCJr0dvgVrWVD4hDiOSG@kS1T5tJRXXAKvGQ1DIcYvMbkRACXJx0sYELh4H/zd9TX48xKu1wjcbqjkFCYonEKDxQeKaRoE49Nf@A3wxDRFLFkhkEySXz2ZJZ6Mk3PF90cb6vzc8w@9OOO8muHc2nyKBwoGD/BQK1MSOFIcSrHOL4oXFNW5hfjpTISeCVkFva0@@hBVHC6ZsNgkvxBrcMiivbGqsJI0d3GMM7jpRuN1jhx@FcqLSE6wDcUcc/TLyUhQl@bA/qOO2Puyu8bLxXdrMxND@EY9vis0MmZtO0bzzUrbDvePt7jhg9rgYpS/wc "C++ (gcc) – Try It Online")
Following the standard calling convention for Unix-like systems (from the System V AMD64 ABI), this takes a number in EDI and returns a number in EAX.
In assembly:
```
f:  xchg edi, eax     # Exchange the input number into EAX.
    xor ecx, ecx      # Set ECX to 0. ECX will hold the running total.
    lea esi, [ecx+5]  # Set ESI to 5.
l:  cdq           # Sign-extend, setting up for the next instruction.
    div esi       # Divide by 5, putting the quotient in EAX and the remainder in EDX.
    test dl, 4    # Set flags based on the bitwise AND of the low byte of EDX with 4.
                  #  This makes the zero flag (ZF) 1 iff the remainder is not 4.
                  #  Also, the carry flag (CF) becomes 0.
    rcr eax, 1    # Rotate EAX together with CF right by 1.
                  #  With CF being 0, this halves EAX, putting the remainder into CF.
                  #  This also leaves ZF unchanged.
    jz s          # Jump, to skip one instruction, if ZF is 1.
    shr edx, 1    # (For remainder 4) Shift EDX right by 1,
                  #  changing it from 4 to 2 and making CF 0.
s:  adc ecx, edx  # Add EDX+CF to the total in ECX.
    test eax, eax # Set flags based on EAX.
    jnz l         # If it's not zero, jump back to repeat.
    xchg ecx, eax # Exchange the total from ECX into EAX.
    ret           # Return.
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jellylanguage), 13 bytes
```
D‘ị“ȤɱȯẎ’DU¤S
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m700KzUnp3LBgqWlJWm6FrtdHjXMeLi7-1HDnBNLTm48sf7hrr5HDTNdQg8tCV5SnJRcDFW3LFrJ2EIpFsoDAA)
```
D               digits
 ‘              add 1 to each (because Jelly uses 1-based indexing)
  ị        ¤    index into:
   “ȤɱȯẎ’         compressed integer 2432123210
         D        digits
          U       reversed
            S   sum
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 10 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
“Mḅṗʋ’D⁸ṃS
```
A monadic Link that accepts a positive integer and yields the Roman numeral count as a positive integer.
**[Try it online!](https://tio.run/##ASMA3P9qZWxsef//4oCcTeG4heG5l8qL4oCZROKBuOG5g1P///8xOA "Jelly – Try It Online")**
### How?
```
“Mḅṗʋ’D⁸ṃS - Link: positive integer, N
“Mḅṗʋ’     - base 250 integer = 1232123420
      D    - to decimal -> X = [1,2,3,2,1,2,3,4,2,0]
       ⁸   - N
        ṃ  - base-decompress using X as the the new digits [1,...,9,0]
         S - sum
```
---
Note that `“Mḅṗʋ’D` saves one byte over using the pattern of the lengths themselves with `3,4R;0j2`  
i.e. `[3,4] -> [[1,2,3],[1,2,3,4]] -> [[1,2,3],[1,2,3,4],0] -> [1,2,3,2,1,2,3,4,2,0]`.
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 26 bytes
```
StringLength@*RomanNumeral
```
[Try it online!](https://tio.run/##y00syUjNTSzJTE78n2b7P7ikKDMv3Sc1L70kw0ErKD83Mc@vNDe1KDHnfwBQpiRaWdcuzUE5Vq0uODkxr66ay1CHy0iHy1iHy0SHy1SHy0yHy1KHy9AAKGQOxBZALlDUEihmZAHkGBkYgVQbWFiCJC0tuWr/AwA "Wolfram Language (Mathematica) – Try It Online")
More built-ins.
[Answer]
# [R](https://www.r-project.org), ~~30~~ 29 bytes
```
\(n)nchar(paste(as.roman(n)))
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m72waMGSNAUb3aWlJWm6FntjNPI085IzEos0ChKLS1I1Eov1ivJzE_OAwpqaEDU3TYoTCwpyKjWSNQytzHQsdQwNdIzNdYwtdCxNdSwtdYwsLHSMDIyMdIwNLCyBwpaWmjppUL0LFkBoAA)
Convert to `roman`, use `paste` to convert to `character`, then find the number of characters.
-1 thanks to pajonk.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), 3 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
.Xg
```
[Try it online](https://tio.run/##yy9OTMpM/f9fLyL9/39jC0tLAA) or [verify all test cases](https://tio.run/##yy9OTMpM/V9Waa@k8KhtkoKSfeV/vYj0/zr/ow11jHSMdUx0THXMdCx1DA10jM11jC10LE11LC11jCwsdIwMjIAqDCwsgcKWlrEA).
Without Roman-numeral builtin (**10 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)**):
```
•’λåK•RÅвO
```
[Try it online](https://tio.run/##yy9OTMpM/f//UcOiRw0zz@0@vNQbyAw63Hphk////8YWlpYA) or [verify all test cases](https://tio.run/##yy9OTMpM/V9Waa@k8KhtkoKSfeX/Rw2LHjXMPLf78FJvIDPocOuFTf7/df5HG@oY6RjrmOiY6pjpWOoYGugYm@sYW@hYmupYWuoYWVjoGBkYAVUYWFgChS0tYwE).
**Explanation:**
```
.X          # Convert the (implicit) input-integer to a Roman-numeral string
  g         # Pop and push its length
            # (after which the result is output implicitly)
•’λåK•      # Push compressed integer 2432123210
      R     # Reverse it: 0123212342
       Åв   # Convert the (implicit) input-integer to custom-base "0123212342";
            # basically convert the integer to base-length as list (base-10 in
            # this case), and index the base-values into the string
         O  # Sum the list together
            # (after which the result is output implicitly)
```
[See this 05AB1E tip of mine (section *How to compress large integers?*)](https://codegolf.stackexchange.com/a/166851/52210) to understand why `•’λåK•` is `2432123210`.
[Answer]
# [Factor](https://factorcode.org/) + `roman`, 17 bytes
```
[ >roman length ]
```
[Try it online!](https://tio.run/##VdC5CgIxEAbgPk8xvoDk2CNRsBUbG7ESi7DEA3azMRsLEZ89SpIFZ7qPmfkn5KK7MPp4POz22xU4b0J4OX@3Afw4aAuTeTyN7cwEa0LeBH7FINUCWCKfyRPFTJFY4W6NdxvcVZiMomHRFjaZsrDNuzW6q1RhlR8pZYmi2ZTz/ywqVaIq0SqTMfIh8QSb/Bm9sddwg3MctINl/AI "Factor – Try It Online")
Non-builtin version:
# [Factor](https://factorcode.org/) + `math.unicode`, 56 bytes
```
[ >dec 48 v-n [ 5 /mod [ 3 > 2 rot ] keep + ? ] map Σ ]
```
Port of @GB's [Ruby answer](https://codegolf.stackexchange.com/a/246367/97916).
[![enter image description here](https://i.stack.imgur.com/oXeOl.gif)](https://i.stack.imgur.com/oXeOl.gif)
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), 10 bytes
(without roman numeral builtin)
```
»ḣ₈ɖ¢»fṘτ∑
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyIiLCIiLCLCu+G4o+KCiMmWwqLCu2bhuZjPhOKIkSIsIiIsIjM4OTkiXQ==) or [Verify all the test cases](https://vyxal.pythonanywhere.com/#WyIiLCLGmyIsIsK74bij4oKIyZbCosK7ZuG5mM+E4oiRIiwiO1rGm2AgPT4gYGo74oGLIiwiWzEsMiwzLDQsNSw2LDksMTAsMzcsMzgsOTUsOTksMjg4LDIwMjIsMzA4OSwzODk5XSJd)
## How?
```
»ḣ₈ɖ¢»fṘτ∑
»ḣ₈ɖ¢»      # Push compressed integer 2432123210
      f     # Convert to list of digits: [2, 4, 3, 2, 1, 2, 3, 2, 1, 0]
       Ṙ    # Reverse
        τ   # Convert the (implicit) input to this custom base
         ∑  # Summate
```
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), 19 bytes
```
T`d`0-321-42
.
$*
1
```
[Try it online!](https://tio.run/##DcqxCYAwEEDR/s@hIEIkuSR6N4ELOEAELWwsxP1P28d7zve6d@@HtfnWjhZDlhSKMNGNJPeEkClUZowUyQtZsYoZoopE@UdU@9nsAw "Retina 0.8.2 – Try It Online") Link includes test cases. Explanation:
```
T`d`0-321-42
```
Translate the digits `0-9` into the digits `0123212342`.
```
.
$*
```
Convert to unary.
```
1
```
Take the sum and convert to decimal.
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 14 bytes
```
ＩΣ⭆Ｓ§”)⊞⎚mS”Ｉι
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z@gKDOvRMM5sbhEI7g0VyO4BMhP900s0PDMKygtgXA1NHUUHEs881JSKzSUDAyNjI2A2MRISUcBrC9TEwys//83NrCw/K9blgMA "Charcoal – Try It Online") Link is to verbose version of code. Explanation:
```
   Ｓ            Input string
  ⭆             Map over characters and join
     ”)⊞⎚mS”    Compressed string `0123212342`
    §           Indexed by
             ι  Current character
            Ｉ   Cast to integer
 Σ              Take the sum
Ｉ               Cast to string
                Implicitly print
```
The `Sum` of a string of digits (as distinct from an array of digit characters) is the sum of all the integer values of the digits, which saves having to cast them back to integer manually.
[Answer]
# [Python 3](https://docs.python.org/3/), 49 bytes
Port of @Arnauld's JS answer.
```
f=lambda n:n and int('0123212342'[n%10])+f(n//10)
```
[Try it online!](https://tio.run/##FY3BCsIwEAXvfsVepAk@aLJpNVvwS0oPkRIUdFtKD/XrYzzMZRiY9bs/Fw2l5Ps7fR5zIh2Uks700t00znPgSsfNqGfvJnvJRtvWO1vystFRMxo9GAEdelwh8A7hhhAhPUTAMYId18JFqVpkGk5E6/YfZHNYW34 "Python 3 – Try It Online")
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), 17 bytes
```
s@L_j5739180 5jQT
```
[Test suite](http://pythtemp.herokuapp.com/?code=s%40L_j5739180+5jQT&test_suite=1&test_suite_input=1%0A2%0A3%0A4%0A5%0A6%0A9%0A10%0A37%0A38%0A95%0A99%0A288%0A2022%0A3089%0A3899&debug=0)
##### Explanation:
```
s@L_j5739180 5jQT | Full program
------------------+------------------------------------
  L           jQT | Map over each digit d of the input:
 @L               |  Get the dth element of the list
   _j5739180 5    |   [0, 1, 2, 3, 2, 1, 2, 3, 4, 2]
s                 | Sum the resulting list
```
[Answer]
# [Stax](https://github.com/tomtheisen/stax), 10 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax)
```
ì¿≥Θu^Z6ê)
```
[Run and debug it](https://staxlang.xyz/#p=8da8f2e9755e5a368829&i=%221%22%0A%222%22%0A%223%22%0A%224%22%0A%225%22%0A%226%22%0A%229%22%0A%2210%22%0A%2237%22%0A%2238%22%0A%2295%22%0A%2299%22%0A%22288%22%0A%222022%22%0A%223089%22%0A%223899%22&a=1&m=2)
]