[Question]
  [
[NATO phonetic alphabet](https://en.wikipedia.org/wiki/NATO_phonetic_alphabet) is a spelling alphabet that associate to each of the 26 letters of the English alphabet one word (table below) that is easy to understand over the radio or telephone. For example, if you want to communicate the word `CAT` over the telephone, you do the following spelling:
`CHARLIE ALFA TANGO`
But what if you are unsure if the spelling was understood correctly? Well, you do the spelling of the spelling:
`CHARLIE HOTEL ALFA ROMEO LIMA INDIA ECHO ALFA LIMA FOXTROT ALFA TANGO ALFA NOVEMBER GOLF OSCAR`
But now you are worry that the spelling of the spelling was not understood correctly, so you cannot help yourself but doing the spelling of the spelling of the spelling:
`CHARLIE HOTEL ALFA ROMEO LIMA INDIA ECHO HOTEL OSCAR TANGO ECHO LIMA ALFA LIMA FOXTROT ALFA ROMEO OSCAR MIKE ECHO OSCAR LIMA INDIA MIKE ALFA INDIA NOVEMBER DELTA INDIA ALFA ECHO CHARLIE HOTEL OSCAR ALFA LIMA FOXTROT ALFA LIMA INDIA MIKE ALFA FOXTROT OSCAR XRAY TANGO ROMEO OSCAR TANGO ALFA LIMA FOXTROT ALFA TANGO ALFA NOVEMBER GOLF OSCAR ALFA LIMA FOXTROT ALFA NOVEMBER OSCAR VICTOR ECHO MIKE BRAVO ECHO ROMEO GOLF OSCAR LIMA FOXTROT OSCAR SIERRA CHARLIE ALFA ROMEO`
**Challenge:** Write a function that takes as input a word and returns as output the number of letters of the 100th iteration of NATO spelling. Examples:
```
MOUSE -> 11668858751132191916987463577721689732389027026909488644164954259977441
CAT -> 6687458044694950536360209564249657173012108297161498990598780221215929
DOG -> 5743990806374053537155626521337271734138853592111922508028602345135998
```
**Notes:**
* Whitespaces do not count. Only letters do.
* Both uppercase and lowercase letters are fine (including combinations of uppercase and lowercase).
* If you want to use a programming language without support for large integers, returning the result modulo `2^32` is fine too.
* The result must be an exact integer, not an approximation (like floating point).
* The first iteration of `CAT` is `CHARLIE ALFA TANGO` (`CAT` is the 0th iteration).
# Big Note:
If your program stores the spelling string, there's no way it is not going to run out of memory: the 100th iteration of `MOUSE` requires more than `10^70` bytes; the whole data on the Internet is estimated to be below `10^30` bytes.
**NATO spelling Table:**
```
A -> ALFA
B -> BRAVO
C -> CHARLIE
D -> DELTA
E -> ECHO
F -> FOXTROT
G -> GOLF
H -> HOTEL
I -> INDIA
J -> JULIETT
K -> KILO
L -> LIMA
M -> MIKE
N -> NOVEMBER
O -> OSCAR
P -> PAPA
Q -> QUEBEC
R -> ROMEO
S -> SIERRA
T -> TANGO
U -> UNIFORM
V -> VICTOR
W -> WHISKEY
X -> XRAY
Y -> YANKEE
Z -> ZULU
```
  
[Answer]
## [SageMath](https://www.sagemath.org/), ~~260~~ ~~255~~ ~~253~~ ~~247~~ ~~246~~ ~~241~~ ~~236~~ ~~234~~ ~~233~~ 231 bytes
```
m=map
f=lambda w:sum(vector(m(w.count,m(chr,(65..90))))*(matrix(26,m([sum(ZZ([*m(ord,'v8^x$ 2??&:#Jd;2Nv&=4-wB/yY$4I"o^_bufTTZ fn"U(J1W:ZRYG=/p,ZTRn[RHJA$jbGn-ul2zeVJ')],92).digits(27)[:i])for i in(0..111)].count,(0..675)))+1)^100)
```
This constructs the transition matrix
```
[2 1 1 1 0 0 0 0 1 0 0 1 0 0 1 2 0 0 1 1 0 0 0 1 1 0]
[0 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0]
[0 0 1 0 1 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 1 0 0 0 0]
[0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]
[0 0 1 1 1 0 0 1 0 1 0 0 1 2 0 0 2 1 1 0 0 0 1 0 2 0]
[1 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0]
[0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0]
[0 0 1 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0]
[0 0 1 0 0 0 0 0 2 1 1 1 1 0 0 0 0 0 1 0 1 1 1 0 0 0]
[0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]
[0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 1 0 1 0]
[1 0 1 1 0 0 1 1 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1]
[0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 1 0 0 1 0 0 0 0 0]
[0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 1 1 0 0 0 1 0]
[0 1 0 0 1 2 1 1 0 0 1 0 0 1 1 0 0 2 0 1 1 1 0 0 0 0]
[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 2 0 0 0 0 0 0 0 0 0 0]
[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0]
[0 1 1 0 0 1 0 0 0 0 0 0 0 1 1 0 0 1 2 0 1 1 0 1 0 0]
[0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 1 0 0 0]
[0 0 0 1 0 2 0 1 0 2 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0]
[0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 2]
[0 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0]
[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0]
[0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0]
[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0]
[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1]
```
and raises it to the 100th power, then multiplies the matrix by the column vector representing the letter-frequencies of the input word, and finally computes the 1-norm.
It’s not the shortest entry, but it is fairly efficient: it takes about 4 ms to compute `f("MOUSE")` on my computer:
```
sage: %time f("MOUSE")
CPU times: user 4.11 ms, sys: 25 µs, total: 4.13 ms
Wall time: 4.14 ms
11668858751132191916987463577721689732389027026909488644164954259977441
```
This can almost certainly be shortened further. I bet there’s a more concise way to represent the matrix. (*See the third and fifth edits below…*)
---
**edit** (255): It’s shorter to use `sum(v)` than `v.norm(1)` to compute the 1-norm of a vector.
**edit** (253): We can pass a generator object to the `vector()` constructor, rather than a list, saving a `[]` pair.
**edit** (247): Use a more efficient string representation of the data, grouping the codewords into threes and representing each of the three with a different section of the ascii range: so the three words in a group are represented by characters from the ranges 33–58, 59–84, and 85–110 respectively.
**edit** (246): Changing the start of the ascii range we’re using from 33 to 39 means that none of the characters in the string need to be escaped, which saves one character since previously there was an escaped backslash `\\`. This has the pleasing side-effect that one codeword in three is now in plain text.
**edit** (241): Represent the matrix with a string in a completely different way: using a base-95 encoding of the lengths of the gaps between consecutive 1's, when the matrix is read by columns. In order to make the column-first order work without extra code, I’ve transposed everything, so now it’s multiplying a *row* vector by the 100th power of the *transposed* transition matrix.
The encoded list of numbers is:
```
[5, 6, 15, 14, 3, 4, 5, 4, 3, 1, 3, 6, 9, 4, 7, 8, 9, 5, 7, 26, 0, 3, 2, 0, 4, 8, 6, 3, 16, 7, 3, 5, 7, 3, 5, 5, 17, 4, 3, 8, 0, 1, 14, 3, 3, 12, 8, 4, 18, 4, 2, 17, 3, 0, 8, 2, 3, 4, 5, 2, 15, 1, 8, 0, 15, 12, 1, 2, 0, 16, 10, 8, 2, 0, 12, 4, 4, 9, 0, 9, 6, 7, 1, 17, 3, 4, 1, 1, 3, 11, 6, 6, 3, 2, 11, 3, 1, 2, 8, 6, 2, 17, 7, 2, 4, 0, 6, 3, 24, 9, 0]
```
This list is treated as a sequence of digits in base 27, for encoding purposes.
Where there is a `2` in the (transition matrix minus the identity), we represent that by a `0` in this list. After all, what is a two but a pair of ones at zero distance from each other?
Sadly this version is a few milliseconds slower – but we are playing golf, after all, not racing.
**edit** (236): Use a slightly different base-95 encoding that allows for a terser decoder, taking advantage of the fact that the integer constructor `ZZ(digits, base)` doesn’t mind if some of the digits are ≥ base. So we use digits in the printable range (32–126), even though the base is 95. The final (most significant) digit is 5, which therefore cannot be subject to this treatment, so we add it separately.
One could save an additional character by inserting a literal `^E` character at the end of the string and removing the `,5` following it, but surely one must maintain *some* decorum.
**edit** (234): It turns out that using base 92, rather than 95, means the encoded string consists entirely of printable ascii characters that do not need to be escaped.
**edit** (233): `map(w.count,map(chr,(65..90)))` is one character shorter than `w.count(chr(c))for c in(65..90)`.
**edit** (231): Now we’re using the `map` function four times, it’s worth abbreviating.
[Answer]
# [Julia 1.0](http://julialang.org/), ~~223~~ ~~218~~ 214 bytes
actually finishes by storing already computed values in a dictionnary
function name is `>`, for example `>("MOUSE")`
```
t=Dict()
>(s,n=99)=sum(x->big(get!(()->n<0||split("LFA RAVO HARLIE ELTA CHO OXTROT OLF OTEL NDIA ULIETT ILO IMA IKE OVEMBER SCAR APA UEBEC OMEO IERRA ANGO NIFORM ICTOR HISKEY RAY ANKEE ULU")[x-'@']x>n-1,t,x=>n)),s)
```
[Try it online!](https://tio.run/##LZDdatswGIbPfRXfTCESOKD/nzF7UxOlMXGi4ThlpevBfrLikLmldiEHvYyxo15dbyRTukoHH9L36Hkl7R737Td6OB6HfNr@GBBOCtRnXW4tzvvH3@gwLr63t@h2O7xDCI@L7gN5eurv9@2A0mrmoHaXAeaurkoPvmocTOYBwpemDg2Eagah8RWspqWDTUSaBsoqQLl0UC48hEu/PPc1rCeuBvc5Mv7cTyAsfWR8XTtwq4sAq3IW6iWUkybUMC/XC38Vc69ic@F99G5SfH0Yjz6Nbg5FN6bZkB3yosM46/ExGbb90EMO1wnEkS7DZu1TyAugVCljpNGSUs6ojVNZo4XiUmvNqDJWc8aNJUwTpiyxwhglBFXCSsGktVrHVfbfO3FNGmv0RqsW0hAhlI0kkVxxRRixUgkmrJKaak4oo8Qwq6miwhpriYzZhjAWG9Iy@6adhos3rdSCR8wQxbWIUsk1lVIxJRnlXLOTVVAeX8TjeUqpZUxGnJkYzoWkcdua5CZJft09AGqzHYa2g9fvec26f2i7Yd@hHeQ5FKjF8BFGL89/RvD@VP@OMkjhrP06nG4DZ@iE4BQn2@4nJMfjPw "Julia 1.0 – Try It Online")
Ungolfed version:
```
dict = Dict()
function f(str, n=100)
    c = big(0)
    for x in str
        # if (x,n) is not in dict, execute the function below (in do...end) and store the result in dict
        c += get!(dict, (x,n)) do
            if n < 1
                true
            else
                words = split("LFA RAVO HARLIE ELTA CHO OXTROT OLF OTEL
NDIA ULIETT ILO IMA IKE OVEMBER SCAR APA UEBEC OMEO IERRA ANGO NIFORM
ICTOR HISKEY RAY ANKEE ULU")
                word = x * words[x - ('A'-1)]
                f(word, n-1)
            end
        end
    end
    return c
end
```
[Try it online!](https://tio.run/##bZPNTttAEMfvfoppihS7Dcj7vVs1rUxYwCJhK2NQEeUAiUMdRTZyHJEHqXrq0/VF0tmERqJ0fBjvzM//mZ31zpbz8o6s1utgUo5b6MMRujAKgumyGrdlXcE0XLRND6o@ieMoALQxYvflQ/i8nNYNrKCsALlgE/H2FsophKteFUG5gKpuPeFr9KBYFeNlW0D7vYBdmftiXj9B6KH64OCgqCYR3FUTFK2bLdoUi@V8J7MrNIb3fXgo2jfhVn1TM0KVHeENm6ngI5AXQW9tsyxeBIv5onhFPdXNZIHbXjzOyzbsDI8TyJIrB6dJNkwt2GGewODUgfuaZy4HNzwGl9thcH6UJnCJSJ5DOnSQjhJIzyy4Kzs6tBlcDJIMki/I2EM7ADeyyNgsSyA5P3Fwnh67bBSkg9xlcJpenNlrrHuNyTNrUfeyE/23Vex0Be@2Xd@sYB/CbtLdJ9HtK3oaegiPF7Mvx1BNgn/f//qmaJdNBePAB9ZBWyxaP5ybTbIzcpcXtgP9T0CIlFoLrQQhjBKDjzRaccmEUooSqY1ilGkTUxVTaWLDtZacE8mN4FQYoxSuelvdQZJ30KMuqioudMy5NEjGgkkmYxobITnlRgpFFIsJJbGmRhFJuNHGxAJr65hSTAhDzbPskTt5lhWKM8R0LJniKCqYIkJIKgUljCnqVTlhuCOG3xNCDKUCcaqxOOOCYNjo4BYvD16JsOzNIv@3bsazqfXYlFU7r8IZ9Ps4@TKCz9D9/etHFz54/7Pbgw7sld9a3w3shR6J8IhxzBCs138A "Julia 1.0 – Try It Online")
## Shorter but non-finishing version:
# [Julia 1.0](http://julialang.org/), 188 bytes
same approach but no storing of already computed results
```
>(s,n=99)=sum(x->big(n<0||split("LFA RAVO HARLIE ELTA CHO OXTROT OLF OTEL NDIA ULIETT ILO IMA IKE OVEMBER SCAR APA UEBEC OMEO IERRA ANGO NIFORM ICTOR HISKEY RAY ANKEE ULU")[x-'@']x>n-1),s)
```
[Try it online!](https://tio.run/##LZBNbtswEIX3OsVACGAJsAH@kxNUbhmHjgXLZiDLQYM0izZNCxmuGkQO4EWOUXTV0/Ui7tgNuRiS7/F75Gxetu1nvj8cxlk/7ArEvOhffmT70fhL@z3r3rHX1/5p2@6ytJp6qP1NhJmvqzJAqBoPk1mE@LGpYwOxmkJsQgXLy9LDmixNA2UVoVx4KOcB4k1YXIQaVhNfg78mT7gIE4iLQJ5Q1x788irCspzGegHlpIk1zMrVPNxS7i2J8xCIu07zu/1o8GFwvx93I54P@/yQ7B77XQ8F3CVAI13E9SqkUIyBc2Oc085qzqXgSNOgs8pIba0V3Di0UkiHTFgmDDJUzhmluFGoldCI1tJu@J878U1KlbhEtUo7ppRBcjItjTRMMNRGCYVGW24l44IzJ9BywxU6RKYp2zEhSNAo8A17Ga/esNoqSTbHjLSKoFparrURRgsupRVHquKSfiTpPucchdBkF47CpdKcjtEl90ny7eczZO1wk0Pbwak9p6wHalI7tqf103Pb7bZdtoGiIOE9DP7@@TWA82P9PRhCCmftp93xWXD2kObJY/cVksPhHw "Julia 1.0 – Try It Online") (depth 8 so that it can finish)
[Answer]
# [R](https://www.r-project.org/), ~~260~~ ~~259~~ ~~236~~ ~~235~~ 232 bytes
*Edit: -3 bytes thanks to Robin Ryder, and -23 bytes using a version of [Arnauld's trick](https://codegolf.stackexchange.com/a/215441/95126) of dropping the first letter of each word*
```
a=scan(,'')
lfa ravo harlie elta cho oxtrot olf otel ndia uliett ilo ima ike ovember scar apa uebec omeo ierra ango niform ictor hiskey ray ankee ulu
v=!!1:26
f=function(w)sum(v[utf8ToInt(w)-96])%%2^32
for(i in 0:99)v=v+sapply(a,f)
```
[Try it online!](https://tio.run/##JY3BasMwEETv@oqNIUSiKbQphDjgD@i9t9LCRlnFwpLWyCu1/npX0Nsw83iTtw2HxWLSx8PBqOAQMlaGEXPwBBQEwY4M/CuZBTg4YKEA6e4RSkNEwAcGHxH8RMCV4o0yNGUGnBtDN7LAkRpDOSNgejAk7zhH8FY4w@iXidb2u7ZxImreolQddrvX6@ms3OBKsuI56R@zlKjrZxF3@eD3JK157s9fZr8/fb@dVJNqDz7By7XvTR3q04LzHFaNR2c2pzuL0hnVQuSy0H@886Mz2x8 "R – Try It Online")
Function `f` that returns output modulo `2^32` (as allowed by rules) to stay within range of integer accuracy in [R](https://www.r-project.org/).
```
a=scan(,'')                 # fill vector a with
alfa bravo charlie...       # NATO phonetic alphabet
                            # (need a newline to stop filling vector)
v=rep(1,26)                 # initialize vector v of values with 1s
f=function(w)               # f = function to calculate value of a word
  sum(v[                    # sum of elements of v at indices given by 
    utf8ToInt(w)-96])       # utf8 values of letters, minus 96,
    %%2^32                  # modulo 2^32
for(i in 1:100)             # now perform 100 iterations of
  v=                        # updating v with 
    sapply(a,f)             # the value of each word in a, 
                            # calculated with the current v 
```
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), ~~133~~ 130 bytes
```
Ｆ¹⁰⁰≔Ｅ⪪”$±ＤuaＢ``ＩＹ″²÷⸿↓⪪∧⮌9Ｐπx¦⸿Ｓ1lＪ｜#←¹Ｆι´³Ａs¦L₂≕⬤m⍘Ｍ▶⭆dω{ⅈ⊟Ｃ0cO\⟦；⊟⁼`→<¬ＵＰνρＬ⊖¦N↷jOh⧴0r↨J9α➙n\²`⟧ＪξＵL≕φ5u”¶ΣＥκ∨¬ι§θ⌕αμθＩΣＥＳ§θ⌕αι
```
[Try it online!](https://tio.run/##bY@xbsIwEIb3PoWVyZFSic5MJlyIGzumtkOh8hJBS6OGA4Kp@vbpiYqtHmzd99//Sd5@tsP22Pbj@HEcGH@aTFImLpduj1y3J@5OfRd5IlQhAs6sWJmAeSmskhBwDsoThrwkWpi1t8YHXBhVBCyNBxVQ1nNJK88NFTyFlVS0q6QmqGVFktqsQM/ABjQuF/QsxZLClwZmkAe0RgM1nARrCXtRL2hsalkYqwOuZO4NlV5L6SrYBFxbQfdG1BWQ/K1RTZKxJGCSZsxdD7dPfWXMDLw@Rt4RFVHi7v2HnzNWdLjjbcYO6e1k7JxOH5ZDh5Hn7SXyu0Di6RpdpGDP/zd0f4bpOGrTOBgfv/tf "Charcoal – Try It Online") Link is to verbose version of code. Explanation:
```
Ｆ¹⁰⁰
```
Loop 100 times.
```
≔Ｅ⪪”...”¶ΣＥκ∨¬ι§θ⌕αμθ
```
Calculate the cost of each letter in each word of the NATO phonetic alphabet using `1` on the first pass and the previous cost for that letter on subsequent passes.
```
ＩΣＥＳ§θ⌕αι
```
Print the total cost of all the letters in the input word.
[Answer]
# [Perl 5](https://www.perl.org/), ~~279~~ 222 bytes
```
sub f{my($c,$_,$n)=(0,@_,100);$c+=$d{$_,$n}//=$n<1||f($_.(LFA,RAVO,HARLIE,ELTA,CHO,OXTROT,OLF,OTEL,NDIA,ULIETT,ILO,IMA,IKE,OVEMBER,SCAR,APA,UEBEC,OMEO,IERRA,ANGO,NIFORM,ICTOR,HISKEY,RAY,ANKEE,ULU)[-65+ord],$n-1)for/./g;$c}
```
[Try it online!](https://tio.run/##XVJra@JAFP2eXxFKoIZe67wfdVNM7ViDsbPEWLZIEVqtCFsVtcsW6293b7KFhZ35MNxzzpxz57GZb3/K5ssGl9P7bh6W893@6mq43s7bQVU/LxfL1b4dvH2EnT1ySSOcDP145MLkOjynVCljpNGSUs6oxams0UJxqbVmVBmrOePGEqYJU5ZYYYwSgiphpWDSWq2xOn@CIPw3Jt20xKUKQHstpCFCKItbiOSKK8KIlUowYZXUVHNCGSWGWU0VFdZYSyQ2YQhjSEjL7P/@t/7uy19qwVFviOJaoLvkmkqpmJKMcq5ZZS8oxzNyNKKUWsYkypnBLriQFGFrzp/CuB28rreN@o7iQ5329tGIlqsNRPPfmzjpRNP2FxxGi/U@ea3Z@C@43DUqsNbCWUWEzeZ1LQx/7cIKPkPpMZitV/NpFbJcLdqn3ftz@Hqogl4gmkK0ipMGgc4UKCFxO3q5SKLZoSaOrVYSrb7Rz0/MnV428l4KRfrgoZ8WeebA5WUK3b4H/6MsfAk@74EvXQ73t1kKY5SUJWS5h2yYQjZw4B/c8MYVMOqmBaTfUeNuXBf80KHGFUUK6f2dh/us54shZN3SF9DPRgP3iLmPSA6cQ99xPGkqebHezp6wyyaN8RZbl60FNn88neqfFuB3CPDJ/gA "Perl 5 (cperl) – Try It Online")
...which is a translation of the Julia answer from @MarcMush
My own approach was 279 bytes:
[Try it online!](https://tio.run/##HZDBboJAEIbvPoWHpbZlhPbQgxIOI466cXGbdTHVi7HGKgkiEWxiyL566eL1n@@f@TLF4Zp9NI1zCs@7omZbeDe@5x@Dn8v1WUwQFK4kzFAJTkBCI0QzCfJLK6lBiglITQIWY46QWERr4EICjxH4nECuKB6RgmWECvDTMjSiCGRMliGlEHAxlbDgE6li4JGWCmZ8Oae1vbu2wzmR3Zu81Oe7sw/Y3goa17VuLPP9EOGhysqaZa5rwtrZG9OKv3neYPAo5YFFgOU1ezJuyE4165nXttAzbWThLqLnbTaB/YCTG7YNy9u5@7vLbofSOTVNLJMldSLUnbGc/l2KKr3kZdOPRVpWw2FSpVlbsMF3ekzzqukX2T8 "Perl 5 – Try It Online")
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), ~~257 248~~ 244 bytes
The case of the input string doesn't matter. Returns a BigInt.
```
f=(s,C=(n=100,A="XLfaRavoHarlieEltaChoOxtrotOlfOtelNdiaUliettIloImaIkeOvemberScarApaUebecOmeoIerraAngoNiformIctorHiskeyRayAnkeeUlu".match(/.[a-z]*/g)).map(_=>1n),g=s=>Buffer(s).reduce((t,c)=>t+C[c&31],0n))=>n--?f(s,A.map((w,i)=>C[i]+g(w))):g(s)
```
[Try it online!](https://tio.run/##bc9RS8MwFAXgd39GHyRxbbfim5BJrcMVdIHNgjCG3GU3XVyalDTtnH@@Cz6Kj@c7cOB8wQCdcKr1ibEHHEfJSBcXjBiWzWZxzqKPVwlrGOwSnFa40B6Ko@Xf3lnPteQe9eqgoAqd96W2ZQPlCfmAzR7dRoDLW6hwj4I3aEt0DnJT25WS1jWl8NYtVXfCyxouuTkhVrqP0ga8OJJpuoXkZ3c3rSkN1JJPNs8MjWvWsflTLyU60tHU4aEXSIiPBWVzPym24vY@28UzQ0M2SfIow6P8d4GcYxWw2KrdpCZnSulDHTZGYU1nNaba1kSS6I1Xm0VE6c0fL/L3f/SZvwQdrw "JavaScript (Node.js) – Try It Online")
### Commented
The array `A[]` consists of all NATO words without the leading letter and with an extra dummy entry at index 0:
```
A = "XLfaRavoHarlieEltaCho...AnkeeUlu".match(/.[a-z]*/g)
// -> [ "X", "Lfa", "Ravo", "Harlie", "Elta", "Cho", ..., "Ankee", "Ulu" ]
```
Main function:
```
f = (                 // f is a recursive function taking:
  s,                  //   s = input string
  C = (               //   C[] = array of letter costs, initially
                      //         filled with 1n (BigInt literal)
    n = 100,          //   n = number of iterations
    A = ...           //   A[] = NATO dictionary (as defined above)
  ).map(_ => 1n),     //
  g = s =>            //   g = helper function taking a string s
    Buffer(s)         //
    .reduce((t, c) => //     for each character c in s:
      t + C[c & 31],  //       add the cost of this character to t
      0n              //       starting with t = 0
    )                 //     end of reduce()
) =>                  //
  n-- ?               // decrement n; if it was not equal to 0:
    f(                //   do a recursive call:
      s,              //     pass s unchanged
      A.map((w, i) => //     for each entry w at position i in A[]:
        C[i] +        //       get the cost of the leading letter
        g(w)          //       add the cost of the other letters
      )               //     end of map()
    )                 //   end of recursive call
  :                   // else:
    g(s)              //   stop the recursion and return g(s)
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~93~~ 86 bytes
Takes input in lowercase.
-7 bytes thanks to [Kevin Cruijssen](https://codegolf.stackexchange.com/users/52210/kevin-cruijssen)!!
```
тFA.•_7R₆"9~úCĆ~'ÍΩ₃M¿jŽ×Øûå…{×}ζ¥ny†–År{è˜dÉ4sK%<0•“ÿ¼¯¤œ®ÈŠˆƒ‹Š™—……ÍÐ—¼°µ†¸šÉµ“#{‡]g
```
[Try it online!](https://tio.run/##yy9OTMpM/f/f3M1R71HDonjzoEdNbUqWdYd3OR9pq1M/3Htu5aOmZt9D@7OO7j08/fCMw7sPL33UsKz68PTac9sOLc2rfNSw4FHD5MOtRdWHV5yek3K406TYW9XGAGjWo4Y5h/cf2nNo/aElRycfWne44@iC023HJj1q2Hl0waMWoPQUoEFAdLj38AQgB6hyw6GtQOMO7Ti68HAniDlHufpRw8LY9P//kxNLAA "05AB1E – Try It Online") with 7 iterations.
**Commented:**
```
                    # implicit input: the starting word
т                   # push 100
 F         ]        # loop that many times:
  A                 #   push the alphabet "abc ... xyz"
   .•8Á ... Ôò•     #   push compressed alphabet string "alfa bravo foxtrot juliett kilo lima papa romeo tango whiskey xray yankee zulu"
      “ ¼¯ .. Éµ“   #   push compressed dictionary string "charlie delta echo golf hotel india mike november oscar quebec sierra uniform victor"
       ÿ            #   with the other string concatenated to the front
        #           #   split on spaces
         {          #   sort the words
          ‡         #   transliterate: replace each character of the alphabet with the word at same index in the current string
                    #     a->alfa, b->bravo, ..., z->zulu
            g       # after the loop: take the length
```
[Answer]
# [Python 2](https://docs.python.org/2/), ~~292~~ 276 bytes
This is a little longer than the other Python answer, but finishes instantly.
```
w=[input()]+'LFA RAVO HARLIE ELTA CHO OXTROT OLF OTEL NDIA ULIETT ILO IMA IKE OVEMBER SCAR APA UEBEC OMEO IERRA ANGO NIFORM ICTOR HISKEY RAY ANKEE ULU'.split()
s=[1]+[0]*26
exec"s=[i and v+sum(j*c.count(chr(i+64))for j,c in zip(s,w))for i,v in enumerate(s)];"*101
print sum(s)
```
[Try it online!](https://tio.run/##JY5Na8JAGITv/orBSz4RI8VL8bCmr81i4pZ1lYrkIGmKK3UT8qFt/3y60uszDzNT/3TnysyG4b44alP3nevlgZOuGCTbCyRMppxAqWKIEwHxrqRQEOkKQlGKzQtn2FlFKfBUgGcMfE0Qe8qWJLGNmQR7sw4tKYbIyDokJQPbvAps@ErIDDxWQiLh2zUd7O7Bhmsi27tzJm39pe2pUbs4RnlwnOb@bD4qv8tibInGyXzgFrT91b34xaSoetO5xblxdTB/8rzPqsElLKANfnXttuH9n@nw9mCl6a9lc@pKt/Xy57EfTaNR3WjT4VHYesPgxEw5fw "Python 2 – Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~79~~ 77 bytes
```
“¡þƓẠı$1ƇẆÇ£ėƬỵ⁸ŀƘṣHỌŻ×²ıÞṆ]q1@ƒḳ0JñỴngṙƑ§ƥỵ⁼@¬TQñɱ⁼=Œ¬⁴RȦȧ¡⁸ƒƈẈ»ŒlḲị@OFµȷ2¡L
```
[Try it online!](https://tio.run/##AaYAWf9qZWxsef//4oCcwqHDvsaT4bqgxLEkMcaH4bqGw4fCo8SXxqzhu7XigbjFgMaY4bmjSOG7jMW7w5fCssSxw57huYZdcTFAxpLhuLMwSsOx4bu0bmfhuZnGkcKnxqXhu7XigbxAwqxUUcOxybHigbw9xZLCrOKBtFLIpsinwqHigbjGksaI4bqIwrvFkmzhuLLhu4tAT0bCtci3MsKhTP///yJjYXQi "Jelly – Try It Online")
This times out on TIO, but [Try it online!](https://tio.run/##AaQAW/9qZWxsef//4oCcwqHDvsaT4bqgxLEkMcaH4bqGw4fCo8SXxqzhu7XigbjFgMaY4bmjSOG7jMW7w5fCssSxw57huYZdcTFAxpLhuLMwSsOx4bu0bmfhuZnGkcKnxqXhu7XigbxAwqxUUcOxybHigbw9xZLCrOKBtFLIpsinwqHigbjGksaI4bqIwrvFkmzhuLLhu4tAT0bCtTnCoUz///8iY2F0Ig) with only 9 iterations
Takes input in lowercase
-2 bytes [thanks to](https://codegolf.stackexchange.com/questions/215436/nato-phonetic-spelling-can-take-long/215440?noredirect=1#comment503461_215440) [Unrelated String](https://codegolf.stackexchange.com/users/85334/unrelated-string)
## How it works
```
“¡þƓ...ƒƈẈ»ŒlḲị@OFµȷ2¡L - Main link. Takes a string S on the left
                  µȷ2¡  - Do 100 times, updating the left argument each time, starting with S:
“¡þƓ...ƒƈẈ»             -   The compressed string "India Juliett kilo mail Mike November Oscar papa Quebec Romeo sierra tango uniform Victor whiskey rayx Yankee Zulu alfa bravo Charlie delta echo foxtrot golf hotel"
           Œl           -   Lowercase
             Ḳ          -   Split on spaces
                O       -   Get the char code of each character in the left argument
              ị@        -   1-based, modular index into the list of phonetic spellings
                 F      -   Flatten
                      L - Length
```
[Answer]
# [Husk](https://github.com/barbuz/Husk), ~~98~~ ~~95~~ 94 bytes
*Edit: -3 bytes thanks to caird coinheringaahing*
```
L!100¡ṁS:o!₁c
w¨nḋ?ẏ_₇↑₇Ø¹Ṁ≥ÏΣ⁶Ḃ€żẎ,Ä₄ βże⁶ŻθŻ₂»Żβ∞Ξ⌈¬¹¢»ÿ¿k»aΨ₈2≡≥⁷_⁷‡@ƒΨ▼«± ¦τaċ‼₀xt►Φ₀lf₀£t
```
[Try it online!](https://tio.run/##DYyxisJAFEX7/Qrtrex2G/0AOz9AgiiCooWRtUweYY0oihZiJURRhE1jit0kExBejOX4DXN/ZJziHg4cuL3JuK91o/zJgUrc5teoDHLbH998Hap4UVPpugWa4WdjmO85UYmD@TlfyxPcPxUTKCwyla4quQfySjIqso4phZBxIUDEwmgE/yAPWPoccsJHFvmd730WlryC/CrmgfmE@98ygxPUn1sTdhn/8q3El5dnPRZwMpAztbFL5cXYoGvAJ1tr3bbsNw "Husk – Try It Online") (but with only 9 iterations)
Unfortunately [TIO](https://tio.run/##DYyxisJAFEX7/Qrtrex2G/0AOz9AgiiCooWRtUweYY0oihZiJURRhE1jit0kExBejOX4DXN/ZJziHg4cuL3JuK91o/zJgUrc5teoDHLbH998Hap4UVPpugWa4WdjmO85UYmD@TlfyxPcPxUTKCwyla4quQfySjIqso4phZBxIUDEwmgE/yAPWPoccsJHFvmd730WlryC/CrmgfmE@98ygxPUn1sTdhn/8q3El5dnPRZwMpAztbFL5cXYoGvAJ1tr3bbsNw "Husk – Try It Online") errors with a 'stack overflow' at the 10th iteration, but the program/algorithm should run if provided with a (substantially) larger stack. Remove the initial `L` to check the actual string at each iteration [like this](https://tio.run/##Hc5BasJAFMbxvafQGwgtbryBVxCE4sKiiIhKA10lxaoTqWgg7iIyVQJZNS3tOAaEF9vl8wzvXWScuv/9P77H0aBjTOkOtnRweyX23GbhCWJSPn7w3GdvUuXXJaSkF7DHiOei280XKNn9JuXliTUY1Tm0@foe036RZ7t2GdIar8VlWsGA1Ia0oMP4N@Mwe8bPywxjh0NN@i0/kYpQwg6PmLH7g0HD2tv0CyTwVfwHwn7IT2cf3v9WPWdoS9yDxKAFCSl5Do0xzYfhFQ).
```
L                   # get the length of
 !100               # the 100th element of
     ¡              # repeatedly applying this function:
      ṁȯ            # map & concatenate
        !₁          # each element of ₁ (see below) at index of
          c         # codepoint of each character of input
          
                    # function ₁:
w                   # split on whitespace
 ¨ḋα⌋...«ḣĖ         # compressed string:
                    # "india juliett kilo ... foxtrot golf hotel"
```
[Answer]
# [Python 3](https://docs.python.org/3/), ~~286~~ \$\cdots\$ ~~238~~ 214 bytes
Saved a whopping ~~44~~ ~~48~~ 72! bytes thanks to [Jitse](https://codegolf.stackexchange.com/users/87681/jitse)!!!
```
f=lambda s,n=100:n and sum(f(c+"LFA RAVO HARLIE ELTA CHO OXTROT OLF OTEL NDIA ULIETT ILO IMA IKE OVEMBER SCAR APA UEBEC OMEO IERRA ANGO NIFORM ICTOR HISKEY RAY ANKEE ULU".split()[ord(c)-65],n-1)for c in s)or len(s)
```
[Try it online!](https://tio.run/##TVFta9swEP6eX3HkS2zmDp3eVcjATZXG5EXDdcpKV0bmODQsdULsQrfS356dw2CVBLrTPfc8d6fD7/ZpX4vTaTPcrZ5/rlfQJPUQGbusYVWvoXl5jjZR@ak/G6eQp3cBJmk@yzz4WZHCaBIgfCvyUECYjSEUfgaL6yyFJUGKArJZgGyeQjb1EO78/MrncDtKc0i/EsZf@RGEuSeMz/MU0sVNgEU2DvkcslERcphkt1N/T7r3FJx6T7zL/ufmsNu2UfywP66jMr7Q6jGpLzDe7I9QwraGJiZrV9VRE5/aqmkbGELUn4flre8n0B@lRXddh5t@3KteD1XZVusOgqi1tcoahSg4OtraWSO1UMYYjto6I7iwjnHDuHbMSWu1lKilU5Ir54whLwGiMVJZJqV2FGJKaKEZZ05pyaXTyqARDDkyy51BjdJZ55giMcs4p4By3CWgjBT0bpkWRhKLEgaV0lwrjkIY3tFIFFSzoAREdJwrgnNLakIqpGdn/zf5A1nXp7TUBVoqlBvthDOaLGG6VvhH8DDiOkE6Mu6VT1X5qzp26YPvL9zIcpDA2UIxiHvd7Nuk6qb/Z3uIzlNP4INufNkDWt1XbKI2PjuH47Zuo83grX2Hiy/w1rzD2z@dh2o4bB7fB/HpLw "Python 3 – Try It Online")
Times out on TIO and is still running on my laptop. ~~Will post my running time when it finishes.~~ As [Arnauld](https://codegolf.stackexchange.com/users/58563/arnauld) correctly predicted, it tried to melt my computer into a wormhole but it valiantly defended itself with a `MemoryError`! :))) Have added smaller (\$1\$ iteration and \$10\$ iterations) testcases to check that it does indeed work in theory.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 85 bytes
```
ċⱮØA
Çæ×“¢ị⁼Ɱ4ɦȷ3æ⁷ŀṣ⁶LṬⱮGṾxƬḟṬƊÆUFṡẉ⁴lṂṃȷỵḥṘ¤ʠḟẠṅṫSæßṠdċṣçẓẊẆPḲDṂƑĠṆṾ⁼Ɓ»ŒuḲÇ€æ*ȷ2¤FS
```
[Try it online!](https://tio.run/##HU69TsJQFN59jI7GSX0BIsKigaQyuOtiupLoxoVYAp3QQQYTq0IZaEw0antuDUNPaQpv8d0XuR5dTvKd7/fq0vNurC0C8/7G09oODzniB9N7zF@QBUb9yP9wE1XJAUdGJese6NWo7xNQLEwTtLouY6RPgssx@50G6Bl6ZNSnB@qDBlWC7AvpHDTNZ9vwT6pD0C1o6UqVGMOLIpBUXkDfQ4@h/TbSj7rYy0khUl9KZEip8mx91xWKh6Yfc7RbJfv5rOHaf3xurXPa6rjHzp5zVDuTW281nV8 "Jelly – Try It Online")
I couldn't figure out how to compress the matrix itself better than the dictionary could, so this probably can't get shorter than caird's solution, but I figured it's worth posting anyways since it's considerably faster. There might still be a bit of room to golf, though, since I was already able to knock a byte off by manually fiddling with the uncompressed string.
```
ċⱮØA    Monadic helper link, convert string to letter frequencies:
 Ɱ      for each element of
  ØA    "ABCDEFGHIJKLMNOPQRSTUVWXYZ",
ċ       count how many times it occurs in the argument.
Çæ×“...»ŒuḲÇ€æ*ȷ2¤FS    Main link:
 æ×                     matrix multiply
Ç                       the input's letter frequencies
                 ¤      by:
   “...»                "alfa bravo Charlie delta echo foxtrot golf hotel India Juliett kilo mail Mike November Oscar papa Quebec Romeo sierra tango uniform Victor whiskey rayx Yankee Zulu"
        Œu              uppercased
          Ḳ             and split on spaces,
           Ç€           with each word converted to letter frequencies
             æ*ȷ2       and the resulting matrix multiplied by itself 100 times.
                  F     Flatten the resulting vector
                   S    and return its sum.
```
[Answer]
# [Icon](https://github.com/gtownsend/icon), ~~379~~ ~~354~~ 351 bytes
```
procedure f(s)
v:=list(26,0)
b:=[]
"ALFA BRAVO CHARLIE DELTA ECHO FOXTROT GOLF HOTEL INDIA JULIETT KILO LIMA MIKE NOVEMBER OSCAR PAPA QUEBEC ROMEO SIERRA TANGO UNIFORM VICTOR WHISKEY XRAY YANKEE ZULU "?while put(b,tab(upto(" ")))&move(1)
v[ord(!s)-64]+:=1&\z;|1\100&{t:=list(26,0)
t[ord(!b[i:=1to*v])-64]+:=v[i]&\z
v:=t}&\z;(s:=0)+:=!v&\z
return s
end
```
[Try it online!](https://tio.run/##VZBPb4JAEMXvfIqRg9ltbQJN48HGNCsushVYuy5WixxE15TEgoEV03@f3WKbJu0c5jDv9yZ5L1sX@em0L4u12hxKBVtUYaPu9XdZpdF1t2NhI@3148Qwie8SGAgy4@B4RPiMwpD6kgB1PA4un0vBJYy474LHJfWBhUNG4D5qSClhzHwOPgsIBGxMIeQzGgyoAD51iIAJmRB4iOiAOiB4QDlMGRWCgCThiEMUMpeLAGbMkVzAo8emY7qAuSALWJBwTCk8RX4E5t3xOdsp2B80Sjt6laLDXhfIBBNj3H4paoXsJl5clBvUqvBV9ya57PXt9vLt9sNe2pbVftf/susfNI2zBtPFRZ38muo4SxrfuSv9eX6Aql7fwo3Sqs/3UulDmUNlqHzzp9@XVZYjbEAzqlblKxzLTCu0Ra3YDHg0pWbHdIhs9pCPzATjb/8X "Icon – Try It Online")
[Answer]
# [C (gcc)](https://gcc.gnu.org/) (`-lgmp`), ~~464~~ ~~456~~ 452 bytes
* -8 by using `mpz_array_init()`
* -4 by @ceilingcat
As C doesn't have a native bignum library, I'm using [GMP](https://gmplib.org/). To speed up the calculations, I memoize each stage of the computation.
```
#import<gmp.h>
*l[]={"ALFA","BRAVO","CHARLIE","DELTA","ECHO","FOXTROT","GOLF","HOTEL","INDIA","JULIETT","KILO","LIMA","MIKE","NOVEMBER","OSCAR","PAPA","QUEBEC","ROMEO","SIERRA","TANGO","UNIFORM","VICTOR","WHISKEY","XRAY","YANKEE","ZULU"};mpz_t t[2600];g(i,s,o,v,j)char*s;mpz_t*v,o;{for(;*s;mpz_add(o,o,*v))v=t+i*26+(j=*s++-65),mpz_sgn(*v)?:i?g(i-1,l[j],*v):mpz_set_ui(*v,strlen(l[j]));}f(s,o)mpz_t o;{mpz_init(o);mpz_array_init(*t,2600,512);g(99,s,o);}
```
[Try it online!](https://tio.run/##XVJhj5pAEP3Or9jQXLOL2HgmZ3LH6QW5VTlBrgj27qwxFNBbg2BYtGmNf712Rpo07ad5vHnvzewucXMdx@fzB7HdFWV1v97uPr33FC2bL7pH1XQGpqqrfd@ceVCtkek7Ngf0yJ0AO9waYWPgvQS@FwAaes4AysgLuAPVnjzaqHsKwRegYGw76HBsF3nXHmPcxJtxt899gN7UMrE@m88o@BzyPrcA@J7L0Ti1ue9jJzAnQyTCiT3wfBfQzLYCD71fRvZ0zF8BvfgmlldzMuY46C10QvVkbHc/lxWp5u1Oq7Uw1lToUi/0g75h8XtUarIWaAe9MI6roqTGHypKElqAUjswduhWDaG1Ow266Wqy0Wh2bpiOIrnOKQge7sQDJDev9Wy@WaDl7tJNq@VegECXVZmlOcUuY8ZpRWEHVm8GYxGIXFS0YPXosox@1IxW6bi4fnPdZrD87S1uDwnwiHmc7ZOU3MsqEQU@5D9UJr4hp4i8IttI5PRQiISRo0IInpvAKQHWK8TFPq8MBb4vF0BkHOUrql5tpaqTj5L1WgZZlWlKJasTQAgnqH3MuBDwMy13JUxDoyTdHrl6S77mEPCfEEfGWRqV9C97Uk5n1wunXLHMQHn0hr/iVRat5bmZQe65@f03 "C (gcc) – Try It Online")
[Answer]
# [Java (OpenJDK 8)](http://openjdk.java.net/), 397 392 bytes
```
String[]A=new String[26];char i=123,k;int S(String X){for(;--i>96;)A[i-97]=i+"lfa ravo harlie elta cho oxtrot olf otel ndia uliett ilo ima ike ovember scar apa uebec omeo ierra ango niform ictor hiskey ray ankee ulu".split(" ")[i-97];for(char d:X.toCharArray())i+=U(d<96?d+32:d,100);return i-96;}int U(int c,int i){if(i==-1)return 1;k=0;for(char d:A[c-97].toCharArray())k+=U(d,i-1);return k;}
```
[Try it online!](https://tio.run/##XZBPa@MwEMXP8acYfJKI7eYPpJtqvYvprdCTt1AIOSiy0kwtS0aW3YaQz54dp1lYehlJzHvvN6N3OcjUtdq@V/Wl7XcGFSgjuw6eJVo4wd3dE0ngRwKlcR/aw6B9h84msFzADkMUTW62LshAx@CwgobMrAwe7VuWZSA5nKLJpDx2QTeZ60PWUiswqz@uHMazksWqCH9izkU0OUeXL/NmW@Sj6PZarLZCHaQHzOeLZVILCoHyBoJXfto7z0Sa4q/1SvBig@n6fpvjNDZ7CV4ODshsUIM2QYI6OHCfwbsAzuzBBW3AViihJ0kIgMYBNhKw1uAG3exo@04RXbak0TutwDWaNNp7CdK@ObBIEzSAKjgPB@xqfSTukZq11pTbx1nXGgwshph/jSfGma9LVQ@vWXCPdC0o8Mg4x2n@wqqf69XvarpcPFTJfDbjwuvQewvkXonz@AMvbKwqGSvyE@4Z5nk65zfhXNT57H9MsVEj@RusvsISJOM/RC3Ol/PlLw "Java (OpenJDK 8) – Try It Online")
Input is a String. **Outputs in 32 bit cap** (rules weren't entirely clear on if it's required, as BigInteger does exist in Java). It takes in unimaginable time to complete, but here's a faster solution that loads comparably instant:
# [Java (OpenJDK 8)](http://openjdk.java.net/), 511 506 bytes
```
String[]A=new String[26];Integer[][]B=new Integer[26][];int i=-1,j;int S(String X){for(;i++<25;)A[i]=(char)(i+97)+"lfa ravo harlie elta cho oxtrot olf otel ndia uliett ilo ima ike ovember scar apa uebec omeo ierra ango niform ictor hiskey ray ankee ulu".split(" ")[i];for(;i-->0;)B[i]=new Integer[101];for(char d:X.toCharArray())i+=U(d<96?d+32:d,100);return i;}int U(int c,int i){if(i==-1)return 1;j=97;if(B[c-j][i]==null){B[c-j][i]=0;for(char d:A[c-j].toCharArray())B[c-j][i]+=U(d,i-1);}return B[c-j][i];}
```
[Try it online!](https://tio.run/##XVBdj9owEHyGX7HKk62EHHDqXTlfWkGlSq3UJ3rSSVEeTGJgg2Mjx6FFKL@dbkJ6PfXFHzOzO7NbypOc2KMyZXG4HpuNxhxyLesafkg0cIG7u@8kgY8RfJW1Vw5OytVoTQT3c9igH49HQ1ntpafrZLGAiorZ2js0uziOQXK4jEej9Zk6VLFtfHwkyjOjfvU@jMdrFuTL/c@AczEetePrrTjNlkknGn7zh0x8M17tlEuzNFv13F@AyDQT1BYwmcyisn@uhxTwyi9b65jAMHyefxB8mWKWsHwvHWcYLh55GOitBCdPFgjUqEBpLyHfW7C/vbMerN6C9UqDKVBCQxJPXtoCVhLwoMCeVLWhFdW5dCCPpFEblYOtFGmUcxKk2VkwSEkqwNxbB3usD@pMvmciD0pR3yaI66NGzwIIOMUUt@CTyaep4Ksu9/uxZ9PZTdHNAsXTa@ztF3ouye/MOMcweWHF8@LhcxHez5@KaDadcuGUb5wBFG23pRfWnXnUL49fcMswoR3yQTUTZbJ4FASv0nxSZl2ExDRa88s/YPo@xLKH/0vypu0TRUgGoh0s3jjRXtvrHw "Java (OpenJDK 8) – Try It Online")
edit: Found a shortcut for .toLowerCase() for both
]