[Question]
  [
Can you recover a sequence of letters from a sequence of dots and dashes? In Morse code, `x` is represented by `-..-`, but without the help of spaces, `-..---.-...` could represent `xmas`, or `dole`, or `teettteteee`, etc.
I took the lyrics from "Rudolph, the Red-Nosed Reindeer" to make the following sequence of letters:
```
youknowdasheranddancerandprancerandvixencometandcupidanddonnerandblitzenbutdoyourecallthemostfamousreindeerofallrudolphtherednosedreindeerhadaveryshinynoseandifyoueversawityouwouldevensayitglowsalloftheotherreindeerusedtolaughandcallhimnamestheyneverletpoorrudolphjoininanyreindeergamesthenonefoggychristmasevesantacametosayrudolphwithyournosesobrightwontyouguidemysleightonightthenhowthereindeerlovedhimastheyshoutedoutwithgleerudolphtherednosedreindeeryoullgodowninhistory
```
and then I converted each letter to its Morse code representation to get
```
-.-----..--.--.---.---...-.........-..--.-..-...--.-.-...-..--.-...--..-..--.-.-...-..--.-.....-..-..-.-.-.-.-----.-.--.-..-.-...-.--...-...--.-..-..----.-...-..--.-..-....-....---...-.-.....---..----.-----..-.-..-.-..-.-...-..-.....-----...-..-..------..-....-....-.-.....-.---..-..-.-...-...-...--..---.-...--.....-......-..-..-.---....-...-....-.-.....-......--...-...-..-.-.--.........-.-.---.---.....--.-......-.-.-----..-....-..-.....-.--..--.-----..-.-----..-.-..-......-.-.....--.--..---..-..---.--....-.-...-..---..-.-.....----......-..-....-.-.....-...-....-..----.-...-..---......--.-..-.-..-.-...-........---..---....-.....-.---.....-..-..-...-.--.------.-..-...--..---.-...--......------..-...-..--.-.--.-....-.-.....-.--..---....-.....-.----....-.-----.--.-.---.-......-......---.-.......-.....--.-.--.-..---.----....--.--.-...--..---.-...--......--..-....-.-----..-.-.-.---.......----....-...--.....-.------.--.-----..---...-..-...---.--....-.....--.....-----...--.....--.....-.....---.---......-....-.-.....-..-..---...-.-........--.-...-.....-.--.......---..--.-..---..--.--..-....--..-.....-...--..---.-...--.....-......-..-..-.---....-...-....-.-.....-.-.-----..-.-...-..--.----..---.---...-..........----.-.-.--
```
For reference, here are a few Morse code libraries:
```
a .- b -... c -.-. d -.. e . f ..-. g --. h .... i .. j .--- k -.- l .-.. m -- n -. o --- p .--. q --.- r .-. s ... t - u ..- v ...- w .-- x -..- y -.-- z --..
```
```
.- a -... b -.-. c -.. d . e ..-. f --. g .... h .. i .--- j -.- k .-.. l -- m -. n --- o .--. p --.- q .-. r ... s - t ..- u ...- v .-- w -..- x -.-- y --.. z
```
```
.- -... -.-. -.. . ..-. --. .... .. .--- -.- .-.. -- -. --- .--. --.- .-. ... - ..- ...- .-- -..- -.-- --..
```
Write the shortest code that takes as input the sequence of dots and dashes above and one of the Morse code libraries above, and then outputs the sequence of letters above.
**Edit 1:** Since we are ignoring [the letter spaces and word spaces that are typically used in Morse code](https://en.wikipedia.org/wiki/Morse_code#Timing), this challenge is nontrivial and significantly different from [previous challenges involving Morse code](https://codegolf.stackexchange.com/questions/tagged/morse). We are implicitly hunting for the *relative Kolmogorov complexity* of a fixed sequence of letters given the corresponding sequence of dots and dashes. This means your code only needs to run for the fixed inputs provided above, and produce the desired output provided above.
**Edit 2:** By popular request, I am relaxing the constraint on the Morse code library by providing two alternative libraries. If necessary, I am willing to add reasonable libraries in the future.
  
[Answer]
# [Python 3](https://docs.python.org/3/), ~~356, 302,~~ 299 bytes
```
import sys
S,L,N="",input().split(),int("3EED3TD7OWRVC3DD9L9NKQY0NEADDU7704EYGXWLFF2PGCR6H6ET3DRODQ4O22XAAFV5KOSWET2D2CQZOMXRQWEO7I2US8FRU5Z2CU8D73B10GEG08YUJQPZND1978359JZOEUGKHT2HXO70Z6PK59T8RMY0BBRJ1D78AZEEYBWU4N7IW1TLUN57",36)
while N:S,N=S+chr(97+L.index(sys.stdin.read((N&3)+1))),N>>2
print(S)
```
[Try it online!](https://tio.run/##pVRbj6IwFH73VxAfNhA9DYIKbLKTqK066oByGZS3zWoiyaxj1Mnu/HqXIrSnOm8rUk97rt93Tj1@XvbvB/t6zX8f308X7fx5bkTtRdv/0Wy288Px46Ib5Hx8y4vfYn/RmzZj1I6pE6Th68im1Ft4/ny1MX02oDRxHLPLNpN1uhiPreVkFPanfRbbNAzoqhtY1nowGL/25kGUstii1miVBS/rcJWywHm2ksgdh0kvs0aJSx172DEnbGK6m2S2WmY@7XiOa/e8WRawZDKfxtZ0HThm1l/Oe17shi8bczgMZx3quIOMsc0wTbq@85x24kXi95xm2@4bjT/7/G2n@d@jAmHU@rU/6Z7TWpD8sN391Qvw5HzZ5gdy2v3c6rr/zTZaHcMw2v7Tk9U4njgBkXG9EtCAEFIswBeiFU8pAhf4vvgCcCsoBG7JZY0fEbgZlgqtjMKduVQqebzSEbgVaXAJuMR9yk358nz1p1LejkoJ8CkBkDtVQyovqJ8yFYhwN2uRTmSpzO5SV0tlXsUHYV7BIMoifGs9ygBqXFFxrRABJEqEWFIkrEFEu4tYFSCVUMOuI2DmEX2INVGqLLNqWo1bIYAoFYAon9QwUIlSJanC0FQoog6lSRLkA/9E6ZRkBOEVmUBAwhN3T7zSPjF68NjIrzKClKD2RHyLYoHgIzy3gOKAcgseypT8ye5I3ATVg6YKZG2AaBN8yO4R5FbPt3oq4QCGeHc/lTslBxATiZsoJwYQRjSb/3dd1Fkmcs7Jl/9P9SRyzT8 "Python 3 ‚Äì Try It Online")
Takes the library followed by a newline followed by the morsecode from the standard input.
The library used is `.- -... -.-. -.. . ..-. --. .... .. .--- -.- .-.. -- -. --- .--. --.- .-. ... - ..- ...- .-- -..- -.-- --..`
## Explanation:
The majority of the code is a precalculated number of morse widths.
A morse caracter in the library is between 1 and 4 dihs and dahs long. In the number i store this as two bits of information.
To recall this number i & it with 3 and shift the result over by two bits.
I then read the number of dihs and dahs from the standard input and lookup in the library what the offset of that caracter is from "a". Then repeat and print.
I think the best way to shave of bytes will be to store the number more compactly.
---
Edit: removed 54 bytes by changing the library format, and storing the number as base36 following the suggestions of A Rex and Chas Brown
---
Edit: -3 bytes for removing redundant parameter from str.split() - Chas Brown
[Answer]
# [APL (Dyalog Extended)](https://github.com/abrudz/dyalog-apl-extended), ~~189~~ 188 [bytes](https://codegolf.meta.stackexchange.com/a/9429/43319 "When can APL characters be counted as 1 byte each?")[SBCS](https://github.com/abrudz/SBCS ".dyalog files using a single byte character set")
Full program. Prompts for the Morse code. Doesn't need the library. Requires `‚éïIO‚Üê0`
`‚åä‚åÇmorse‚çû‚äÇ‚ç®‚àä1‚Üë‚ç®¬®1+4‚ä§'‚ç≥√∑+‚â†√≠‚çÄ√∑<√≠‚àß‚óã√ë>√•/‚àß‚à®√™√Æ‚àò√ü‚àß√§√±‚çÄ‚óã‚â†√®[*‚å∑‚à®[√Æ‚â†‚àá√®‚äÇ√ò√Æ‚äÉ‚çÄ[‚å∑√â√§√Ø\‚àò‚àß‚Üë√¶=√≠√•‚åø‚àß‚à®√´√§√ñ‚åø√™/‚â§‚åä‚àò[√Ö‚Üì√ñ√Ø‚óã+√ú√∑‚â•‚Üì‚â§‚â•>‚å∑‚àò√°‚äÉ‚Üë√ú‚ç≥‚ä£[‚åø-√ò‚Üë√§/‚àß‚àß‚â†‚â†√ë√≠√≠+√ü√ú+-‚óã√©‚Üì‚Üì‚â•‚â•√ó‚àß‚Üë**‚ç®‚Üë}‚àß‚ç®‚â•√ß‚çÄ‚àß}√ó‚çÄ√Ä√´√ß‚çÄ√ò‚ç®‚àß‚àò[√ó/‚àò√Ö‚àß~‚â•‚óã√´√¢‚äÇ√•‚à®‚â•√Ä√§√®?'‚ç≥‚ç®125‚Üì‚éïAV`
[Try it online!](https://tio.run/##pVSxbhNBEO3zFXRIPs0aI@ggiJKKjsY0kWzRBGIBBRRBVlCOu8OOsFBiFxYJ4OOORCZCFC4jMX8yP2JmfLe7s3Y6zvbd7s7sm/feznmntwudtzu7e8@g@@Z190Wn21nS0fGjxxR/urVFyYfekgYZDQ6e77181aXhF8oOaFhSkrUoHvHob9mK7lA2u0nDP7iIKD3DOQ37uLjHz6Sg8UccbWPelHFS4jn@omSCpzzFGf7mTM6QTWW7QYMFp7Q5Iz3jylhyLZzwNHvPeW0OY8qbLp8ygsDFI/xxH@eY0@Cqhr/g@AlP8bxJ6UyYJ5M2HlL8GU/wkktFOMUFpTmvSEKab6@qTvCrVGHEKeug7DtXuwKcyMqs4l4IKyY64orzCE9xGoGo@ylQgpbzF8cVsUZDTIpH@zLlEUcK0ZoU@5zC9vSZqqxwCXGzWPEcN4XJIU/fCRyDX@A3MSFnbYLRZ3nlA7Gad7Vu35W6R8cPnyzZruWN1dXbAgNyGX5U3@rHc2OvOlgtrUagVw2An4URU@8C@1mVAgdXZbtyrkqdtla6vtXpNT649FqGCW5ur42rChDiOsY24AC8SqXYW@SywaGtIdYEfBCsbIugnVf2KdccVU@zPjSrOzDABAzA0TdWhqLoQ94qLS2U4ngEh@RFbvhvgpPyjii9rhI4Sbrj1o0Pjs@1Hmwe5HUVwY/A7lR@O7Jg9JLuW1A4ELwFGzS9f/50vG6j@KiuAs8NlG3OD396Rm2z/R2uejmgJa69n8E75RtQG6kP0XcMKI2qN//vdQl72fg@N9f@P9lOlMg/ "APL (Dyalog Extended) ‚Äì Try It Online")
`‚éïAV`‚ÄÉthe **A**tomic **V**ector (the character set)
`125‚Üì`‚ÄÉdrop the first 125
`'`‚Ä¶`'‚ç≥‚ç®`‚ÄÉthe indices in that of these characters
`4‚ä§`‚ÄÉTo-base four
`1+`‚ÄÉincrement
This gives us the length of each Morse letter.
`¬®`‚ÄÉfor each of those lengths:
‚ÄÉ`1‚Üë‚ç®`‚ÄÉtake that many elements from 1, padding with zeros when needed
`‚àä`‚ÄÉ**œµ**nlist (flatten)
`‚äÇ‚ç®`‚ÄÉuse that as a mask indicating partition-beginnings to **c**ut the following:
`‚çû`‚ÄÉprompt for Morse code
`‚åÇmorse`‚ÄÉconvert from Morse code to uppercase text
`‚åä`‚ÄÉlowercase
[Answer]
# [APL (Dyalog) + dfns](https://www.dyalog.com/) + [Jelly's dictionary](https://github.com/DennisMitchell/jellylanguage/blob/master/jelly/dictionary.py), ~~181~~ 175 (172üêå) [bytes](https://codegolf.meta.stackexchange.com/a/9429/43319 "When can APL characters be counted as 1 byte each?")[SBCS](https://github.com/abrudz/SBCS ".dyalog files using a single byte character set")
Full program. Requires `‚éïIO‚Üê0` and `‚éïAV` redefinition. Doesn't use the challenge's Morse code library.
```
M‚Üê‚àä‚àòmorse¬®D‚ãÑC‚Üê‚àä(7‚ç¥51)‚ä§246‚ä•5 17‚ç¥¬Ø7+‚éïAV‚ç≥'k%a√è‚çµF√æf√Ö‚çµ√¨√Ü‚å∂√°‚â•√•3¬∂c√í‚ç∫\uj√º‚îÄ‚ç≥%S‚ä£√¨‚çô√í√õ√ô3√ôp`√ò,h√á√±‚äÇ‚î¥√ñ‚ç™l‚à™‚çíi1‚çµ√ç:-√Æ√†‚åΩ√¨‚â•3‚Ç¨√£(‚çùS]√ÅGXr√¶‚àáO7U√¶√Æ'
C‚Üì‚ç®‚Üê‚â¢i‚Üì‚ç®‚Üê‚â¢M‚äÉ‚ç®w‚Üê(‚äÉC)‚å∑‚àä(‚ç∏M‚ç∑‚ç®‚äÇ)¬®‚åΩ,\24‚Üëi
‚çû‚Üê819‚å∂w‚äÉD
‚Üí2
```
[Try it online!](https://tio.run/##pVRtbxtFEP4YyX8BCY0sqrNV79lnJ45NxIdiQ1XUEOSkCISL2JzX8SXXu9O91LIACUJJUzdXIBTUCIGAkiqqrCJEaSsEfMj@k/0jYe99LymfONt3uzOzz8w885yxpaPBBOvmxgm7882lFbbzZa3AVxfevvJesw7NBjRr0G6AokB7/ir3tmtKE9q1wFpbaEKr1WjxlRLcWjVg/vewNiKAVdfDOqy@2lmFMZFsAp6jGRsF6ZppO0TiCTrvSoOh4UiFLgdVSi2lzfaelKX3@@Pz8ApI0oeNjz8K733ZsXTN7Zf65ZeCgz1JYtPP@OLNi6@tSVXPsau6qWK9qmvrVWvijkyjIS9WHc0lyMLqFt4gTnWT6PqkOtBUVzMNbE9kayIpYbWXTTyANwK35EAWANgYgGoa14ntgmuCbo6JrWKHFNjuzS70QFvqLC0vjUMMqSeBQcjAgbASuI5tDa/rhAMSVcc2GVRCPM2wPBcs7DhkEIBqbiV4rBOe6Zql6dxq2aZFbH0CpRF2wDCBDIdEdcE0YOgZUXWcjUkFNj3HBcfiacsny5xDtjtlu/dCfo@Puuz2jU5kLC0y//GCUmbTX@rzTTY9XAAlMB3/ung@HDTzf5e2zmH6BfP/eH2O/jM3pJ/zJZ3N0R0@E/oTu3VIDxvHT1S6z/w/@94m/Yvd/YQfO7fKpvfpjPkHdJ9@Rw8a9MD6gN6rjOhN@hubbrO7j@m3zH@os92HLzB/X1MCXP9lRB/RH9ne33T2IsdusO0ZvV/iRK5epZ9efMemDzjHK4tX6AP6SCrwNr5m/lHQzK2fNXGzHOjAPxrzXYkvO2W29zRomPnPlpn/NIibbpePj3imSr8@z3a@0grM/4GHR2ob80PdAtvZr5/whIV6ab5WC0XIxxkLNRxvJxoOuDbmkoVirxhOc93TdFczILSF4UUOf0fi6giy3L7B/FkE0PMM8fBYc0dQ7Bb/QxNLPFZTt2Dt0gpceOsyOMT1LB7HnapOsMENFrZxIAUwhzFAJNcBOUEyCi6ZP6Jv9ON7ObliZ2QKV0i0yghlu7xHjk@h5BOmQilcFJ2mS7PEYadSx7c4PMZHaXjchpy7pWcTv5AB5XHTihNHCpB1KXScUZRGoxTtFGJcQOZESdsJgsi8QJ/AWlpqVmY8tKTvHAFyrgKUli8nbQglZq6MKrG1fCtpHbkhZU2e4V/OTSpjROg3zYTSlkTFnSY@N75UeujsIJ@XEWUrlJwU@E6LRbJoEnWLBByUewvOlJnxl00n61sW6hFUhbLakEBbykc2PVk4lug7b83aQWKLp97P3DuVCVAkUhxiphgk9Cho8/@9Lnkty5nO5ef@PyVKDDz/Ag "APL (Dyalog Unicode) ‚Äì Try It Online") - 175 byte version, running at decent speed
```
M‚Üê‚àä‚àòmorse¬®D‚ãÑC‚Üê‚àä(7‚ç¥51)‚ä§246‚ä•5 17‚ç¥¬Ø7+‚éïAV‚ç≥'k%a√è‚çµF√æf√Ö‚çµ√¨√Ü‚å∂√°‚â•√•3¬∂c√í‚ç∫\uj√º‚îÄ‚ç≥%S‚ä£√¨‚çô√í√õ‚îÄ3√ôp`√ò,h√á√±‚äÇ‚î¥√ñ‚ç™l‚à™√ßi1‚çµ√õ:-√Æ√†‚åΩ√¨‚â•3‚Ç¨√£(‚çüS]√Å√¥Xr√¶‚àáO7U√¶√Æ'
C‚Üì‚ç®‚Üê‚â¢i‚Üì‚ç®‚Üê‚â¢M‚äÉ‚ç®w‚Üê(‚äÉC)‚å∑‚àä(‚ç∏M‚ç∑‚ç®‚äÇ)¬®‚åΩ,\i
‚çû‚Üê819‚å∂w‚äÉD
‚Üí2
```
[Try it online!](https://tio.run/##pVRtb9tUFP5YKX8BCR1FTE60XCdu2jSh4sNIAA2tFKUdApEhbp2b1q1nW35ZFAESlNF1WT1QGWjTxOvoqKZoCFE2hIAPvf/k/pFy7di@1@34hJPY955z7nPOec7jYMdE/RE27fUTdvuri8ts54taga8uvHX53cYsNOrQqEGrDpoGrbkr3NuqaQ1o1SJrbb4BzWa9yVdadGvWgIXfwOoGAaz7ATZh5eX2CgyJ4hIIPMNaLyhXbdcjCk/QfkfpDyxPKXQ4qFZqai2296SsvNcbnoeXQFE@qH/0YXzvqZ5jGn6v1Cu/EB3sKgobf8oXb7z2yqpSDTy3ato6NqumsVZ1Rv6GbdXVhapn@AQ5WN/C68SrbhLTHFX7hu4btoXdkeqMFC2u9pKN@/B65FY8EAGArT7otnWNuD74Npj2kLg69kiB7d7oQBeMxfbi0uIwxlC6CliE9D2IK4Fr2DXwmkk4INFN7JJ@JcYzLCfwwcGeR/oRqOFXosca4ZmuOobJrY5rO8Q1R1DawB5YNpDBgOg@2BYMAmtaHWdjVIHNwPPBc3ja8skS55Dtjtnu3Zjf48MOu3W9PTWWFlh4NK@V2fin2bkGGx/MgxaZjn9ZOB8PmoW/KVvnMP2chb@/OkP/mRnQz/iSTmboDp8J/YHdPKAH9eMnOt1n4Z@9YJP@xe58zI@dW2HjB3TCwnt0n97ntjq957xP71Y26A36KxtvsztH9GsWPjLZ7qPn6M@GFuHefxHRx/R7tvc3nTzPsetse0IflFj43coV@gk9etulDznJywuX6UP6WCnwPr5k4WHUzc0fDXmzFAkhPBzyXYkv22W29zTqmIV/LLHwaRQ33i4fH/JUlZ5RYOG3PHKqtCGP7xTYzv7sCc9VmC3N1WqxAPkoE5HGo21PBwO@i7lcodgtxpNcCwzTNyyIbXF4kcPfVrgyoiy3rrNwMgXoBpZ8eGj4G1DsFP9DD4s81tC3YPXiMlx48xJ4xA8cHsedukmwxQ0OdnEkA7AHCcBUqn1yglQUXSp/TL/TH9@r6ZU4p6Z4hWSripDY5T1qcgqlnzgVyuCm0Vm6LEsSdip1ckvCE3yUhSdtqLlbdjb1SxlQHjerOHVkAKJLqWNBURaNMrRTiEkBwonStlMEmXmJPom1rFRRZjK0tO8cAWquApSVr6ZtSCUKl6BKbi3fSlZHbkiiyTP8q7lJCUakfrNMKGtJVtxp4nPjy6SHzg7yWRmRWKH0pMR3VixSZZOsWyThoNxbcKZMwZ@YjuhbleqRVIVEbUiiLeNDTE@VjqX6zltFO0hu8dT7mXunhABlIuUhCsUgqUdJm//vdclrWRU6V5/5/5QqMfL8Cw "APL (Dyalog Unicode) ‚Äì Try It Online") - 172 byte üêå version, taking about 20 times as long to finish (especially slow at beginning)
*-3 bytes by packing base 51 into base 246 instead of base 64 into base 256 and losing the apostrophe*
*-3 bytes by ending with an error message instead of cleanly*  
*-3 bytes by running about 20 times more slowly*
When I saw this question, I thought that the ultimate solution, the one the question was *made* for, would involve combining both the Morse code and a dictionary. I was surprised when the only submitted solutions turned out to use a table of letter boundaries. My interest was sparked; I'd take a crack at it myself.
The first step was to look for a suitable dictionary (I tried a few). Then I implemented the [first version of the algorithm](https://tinyurl.com/rudolph-C-v0-50) in C++. This enumerated all the possible words that could be at a given point, numbering them sequentially, until finding the one matching its corresponding value in an array made from running the same algorithm with the words of the song as a reference. This initial version enumerated the words in alphabetical order.
I was rather astonished to see just how ambiguous Morse code is without the inter-letter gaps. I expected it to be somewhat ambiguous, but not to the extent that it actually turns out to be! Some of the alternatives are pretty funny, too. Every time `reindeer` comes up, for example, it could also be `leech`. And the entire song can be mapped to completely different words, all the way from start to finish (gibberish, but present in the dictionary).
The dictionaries I tried turned out to be not so well-suited to the task. Either they were missing too many words, requiring them to be added to the dictionary for the algorithm to work, or they were *too* comprehensive, and the resulting array of "word choices" had elements exceeding 63, meaning it couldn't be packed into 6 bits per word.
Then it occurred to me to try [Jelly's dictionary](https://github.com/DennisMitchell/jellylanguage/blob/master/jelly/dictionary.py). It turned out to be *perfect* for this. Not every word is in the dictionary, including simple words like `a`, `names`, `games`, and `glows`, and the contractions `won't` (`wont` isn't in it either) and `you'll`, but I took advantage of the fact that there are no spaces in the output for this challenge, and cheated:
* `Blitzen` ‚Üí `blitz` `en`
* `had` `a` ‚Üí `Ha` `DA`
* `glows` `all` ‚Üí `glow` `sall`
* `names` `they` ‚Üí `Nam` `EST` `hey`
* `games` `then` ‚Üí `gamest` `hen`
* `won't` `you` ‚Üí `won` `Ty` `ou`
* `him` `as` `they` ‚Üí `Hima` `ST` `hey`
* `you'll` ‚Üí `you` `LL`
It was a spookily perfect fit for this challenge, even containing all of the proper nouns other than `Blitzen`. Another cheat was to use compound words to shrink the size of the array of word choices: `outwith` and `godown`. As result of all this, the word choice array had 116 elements in it, and with none exceeding 63, the whole thing could be packed into **87 bytes**. (This, despite the compromise of encoding `then` as `th` `en` so as not to exceed the value of 63.) Contrast this with the array of Morse codeword boundaries, which takes 119 bytes (118.5 rounded up).
But that leads to the next problem: Although the data size is considerably smaller, the code complexity is ballooned in comparison. I didn't know any golfing languages, and most of them have very limited documentation that's quite hard to use to learn from scratch.
So I worked on refining the algorithm. The next optimization was to iterate through letters [from longest Morse codeword length to shortest](https://tinyurl.com/rudolph-C-v0-61), still in C++. This actually decreased the maximum index value to 59, meaning that with arithmetic rather than bitwise packing it could use base 60 to fit in 86 bytes. (For illustrative purposes I also [ported this one to Java](https://tinyurl.com/rudolph-Java-v0-62), which was interesting... I learned a little more Java, and was surprised to see it run even faster than the C++ version, using >125% of a CPU core, even though the algorithm is inherently single-threaded. My best guess is that the hash function is multithreaded even for individual look-ups.) This data set would respond better to Huffman encoding than the previous one, though not enough to even break even.
I tried optimizing the C++ code for smaller compiled object code, evaluating if it was worthwhile to attempt hand-coding it in x86-32 assembly. It stubbornly remained way too large; the best I could do was to squeeze it in at just under 256 bytes, *not* including the data. So it wasn't worth hand-coding in asm (the letter-boundary version beats it by a huge margin).
So it seemed that the only way this algorithm would have justice done to it would be for me to learn a golfing language. Quite daunting, given that I've never used anything like these languages.
And then [Ad√°m](https://codegolf.stackexchange.com/users/43319/ad%c3%a1m) offered to teach me APL. I jumped at the chance; while APL doesn't usually win challenges where there's also a Jelly or 05AB1E contender, it tends to come pretty close, has a deep and rich past, and formed the basis of or influenced many newer languages. Heck, I knew of it as a child, and was a bit curious about it even then, but never took a crack at learning it until now.
Many thanks to Ad√°m for extensive help in teaching me various aspects of Dyalog APL and golfing down this program ‚Äì my first APL program.
I initially tried [porting the algorithm as it stood to Dyalog APL](https://tio.run/##pVTLbtNAFF3HXzELJKcqM36meamrqEKVoKCKDVJEFWKnNRg7SlyVCNhQVJrSVkCFxAqhigULJHbs2PAp/pFwr@15Jd2RNO7M3Nc5597xYBzTYDaI0/1Ffvl5@35@8sE2zOfpZBqacNB7ZAajZGoaQTTMwObUW047P/@9Zj7uH62TTWKaL73Xr4pnn03HcZT16/21Wxi7a5r52TEsdu5sPTStw@nEitPhILbi6Ik1nmUHaeKxpjWNspCOB8Nng/1waj0N43hmYbUoTQaTGRvPTMcIoHR@epaffkGLkZ@@qwdkd41E3V43SsaH2YN02h0epNEw3Iu6QTjODrpH6SToFkTuhkl3lB4mwT3cLXrIgzgucTaIu0Ech7ge8YlnE5c0iecQj7hNXLmkgSaPOPi1iddCZ/D1iA1218GV0yBt4kMmtLXx0SJugzhNiPF8cINAqIDZHI9sYDhEgwU8ffDzy5xeA84BTIt4HqRpOOWxi6GAE6LLWi3MgsAALmyhro1U0K/AYEMaOC/Q2eiN8GDdaCMpKNkkvg@OUKoNlhKPygTZ2qQg4BlcW1CMqwvLQt9iUFBjbM3FTyMJX2R7cZhl4aRj1LjuYPTl7m6ajsFY62yPSD6/lj0Bt8InP3sjIz/K6lcRRNWw2m1wlXF4iskCCEQr7osDjnYTJrBXnNbyi68QW46v8K0pDIo9DMdVfvEDR6Q8UHjbZfqtuCwsbevCvbOVBNsjQ18BnnY@/w6MRd2ybFXp7y/H0BJz4utcF9CjMOQnnxSdtTJ8wf13wA@15ntaYYQUajssgGDn82@yDDgEaRIWhk2BmUOiCiTUbX4NCle9O87P/5Teq/SUsojMwBKdBVxko@yLW/dtu3ix7Jqkev@A6dKEe44e799Ci8wFZRQ/DP6Vf@UP9ox/KmN5VKyoesoolTvdwqooyr9FKSrSld6inKhSuS2Vrh6Ve5WfCveKBtMeIpbblQpUzysQc4NIIFkqjKVEwpuKbEsZKwDSSDltnkFVXpFPUU1AlTCrpnHemgBMQ0AFfMZpKBClSUqlUtOpCBxakyTJFf2Z1impiMJXVKKCkjpxy8Jr7ROjR1cbeVNFKleURyp6C7CUqUfq3FIlD9VuwQpMqZ/sjuTNFDzKVFGJjSqyCT1k95gSxudbP5V0qEpx6X5qd0oOoCqk2kQ5MVThqMzm/10XfZaZnHN24/uJTyJa/gE). It worked, but was very slow, even when compiled; in 60 seconds it only gets up to `donner` or so. Ad√°m conferred with Marshall at Dyalog, and there wasn't really a way to speed it up any further. But it was suggested that encoding the entire dictionary in Morse code could result in a speedup. And I realized that this strategy could make for much better golf, too.
So the next stage in adapting the algorithm was to translate the entire dictionary to Morse code, and at each point in the encoded song, iterate through possible words in reverse order of their length in Morse dots+dashes (with the longest being 24). Not only is this approach far, far faster in APL (and probably many other languages), and far more concise, but even the data is more lightweight ‚Äì far more of the "word choice" array elements are `0` or `1`, the largest value is just `50`, and there are only 115 elements (the `then` no longer needed or benefited from breaking up), meaning that in languages with arbitrary-precision base conversion, it could be packed in base 51 and take up only **82 bytes**. In APL though, the overhead of implementing arbitrary-precision base conversion would override the benefit, and I stuck with packing groups of 7 elements, in base 51, into groups of 5 bytes in base 246 (as log246 517 ‚âà 4.999295), taking up **85 bytes**. This data set responds even better to Huffman encoding than the previous, but still wouldn't break even: `4 1 2 21 1 13 0 23 0 3 26 1 23 0 26 0 27 15 8 6 0 34 10 0 1 1 7 0 43 23 0 4 37 50 1 0 3 23(24üêå) 22 6 15 6 16 3 2 17 10 12 5 0 9 31 1 3 9 21 0 32 16 9 20 32 8 12 31 5 0 4 27 14 1 7 13 16 0 0(1üêå) 27 4 4 22 10 0 16 5 7 15 3 12 18 4 2 13 1 0 50 4 49 2 1 4 38 20 0 0 19 0 43 23 0 1 6 12 0 38 0`
So as it turns out, in APL it still doesn't golf well enough to beat the existing letter-boundary solutions, even if the overhead for unpacking the "word choice" array (24 bytes) and for using Dyalog Unicode instead of Extended (7 bytes) are subtracted (yielding **144 (141üêå) bytes** code+data). I still think that it might be possible to make it shorter than 129 bytes in one of the languages more specialized towards golfing, and will likely try that eventually.
Of course, with bigger source material than the song this challenge uses, this dictionary-based approach would win hands-down. Some interesting extensions to it would be: Look 2 or more words ahead, and perhaps use an [N-gram](https://en.wikipedia.org/wiki/N-gram) frequency table; Look all the way ahead, using a model of most-likely N-grams (probably would be incredibly slow).
---
## Explanation of the code
Dyalog Unicode is used, even though Dyalog Extended could save 7 bytes (4+3, as described below), because the former allows compiling for speed, whereas the latter is very slow, to the point that it would be impractical for demonstration.
On my system, this version takes about 45 (or 901üêå) seconds to finish (the first 7 seconds of this are taken converting the dictionary into Morse code). On TIO it doesn't quite finish within 60 seconds.
### Header
`‚éïIO‚Üê0` - set Index Origin to 0 (for 0-based array indexing)
`‚éïAVU[62 63 60 93 11 94]‚Üê9016 9060 9056 8838 9018 9080` - modify the default Atomic Vector to match the actual Single-Byte Character Set we're using (`¬£¬¢¬•√Ω…´¬∑` overwritten with `‚å∏‚ç§‚ç†‚äÜ‚å∫‚ç∏`, at each character's respective index within the Atomic Vector)
`'morse'‚éïCY'dfns'` - import the Dyalog APL Morse code dfn ‚Äì I decided to keep this in the header because Dyalog Extended has it by default
```
D‚Üê1(819‚å∂)'^\w+ = ''{3}|''{3}\.split\(\)$'‚éïR''‚äÉ‚éïNGET'/usr/local/lib/python3.7/site-packages/jelly/dictionary.py'1
```
Load Jelly's dictionary, and convert it to lowercase:
`‚äÉ‚éïNGET'/usr/local/lib/python3.7/site-packages/jelly/dictionary.py'1` - read the file as a set of newline-delimited lines into an array (with empty lines dropped, of which there is one)
`'^\w+ = ''{3}|''{3}\.split\(\)$'‚éïR''` - using a regex (PCRE) Replace, remove the Python code that surrounds the dictionary's two word lists (`short` and `long`), resulting in a merged list that keeps everything from `short` before everything from `long` (but is otherwise in case-insensitive alphabetical order)
`1(819‚å∂)` - convert to uppercase, so that the `morse` dfn will work on it (since it only takes/gives uppercase input/output)
`D‚Üê` - assign to the variable `D`
```
‚àáD R i;C;M;w
```
Define the tradfn `R`, taking left argument `D` (dictionary word list) and right argument `i` (the input, i.e. the song in undelimited Morse code), and having local variables `C` (word choice array), `M` (dictionary translated to Morse code), and `w` (array listing the indices into the dictionary of what the current word could be). The arguments are passed and the local variables are declared to allow the `R` to be compiled properly (see footer).
### Code
```
M‚Üê‚àä‚àòmorse¬®D‚ãÑC‚Üê‚àä(7‚ç¥51)‚ä§246‚ä•5 17‚ç¥¬Ø7+‚éïAV‚ç≥'k%a√è‚çµF√æf√Ö‚çµ√¨√Ü‚å∂√°‚â•√•3¬∂c√í‚ç∫\uj√º‚îÄ‚ç≥%S‚ä£√¨‚çô√í√õ√ô3√ôp`√ò,h√á√±‚äÇ‚î¥√ñ‚ç™l‚à™‚çíi1‚çµ√ç:-√Æ√†‚åΩ√¨‚â•3‚Ç¨√£(‚çùS]√ÅGXr√¶‚àáO7U√¶√Æ'
```
`‚àä‚àòmorse¬®D` - compose the two functions `‚àä` (Enlist - flatten / join) and `morse`, and apply the composed function to the dictionary `D`. Without the `‚àä` composed in, `morse` returns an array of Morse codewords when given an alphabetical string as input, but we need the Morse-encoded dictionary to leave out inter-letter gaps, thus the `‚àä` flattening.
`M‚Üê` - assign the result to `M`, the Morse-encoded dictionary.
`‚ãÑ` - statement separator
`'k%a√è‚çµF√æf√Ö‚çµ√¨√Ü‚å∂√°‚â•√•3¬∂c√í‚ç∫\uj√º‚îÄ‚ç≥%S‚ä£√¨‚çô√í√õ√ô3√ôp`√ò,h√á√±‚äÇ‚î¥√ñ‚ç™l‚à™‚çíi1‚çµ√ç:-√Æ√†‚åΩ√¨‚â•3‚Ç¨√£(‚çùS]√ÅGXr√¶‚àáO7U√¶√Æ'` - word choice array, packed into a string using Dyalog APL's updated SBCS. For this to work, the encoding must not contain newlines, i.e. `‚éïUCS` `10`, `12`, or `13` (`‚éïAV[2 3 5]`), and any apostrophes must be doubled (but there are none).
`‚éïAV‚ç≥` - map characters to SBCS indices (in the range 0-255) using the modified Atomic Vector.
`¬Ø7+` - add ‚àí7 to all SBCS indices. The corresponding addition of 7 was done during the encoding, to avoid occurrences of any of the three types of newlines. Due to use of base 246, this addend is quite flexible, and could range from 6 to 10 and be guaranteed to stay within range regardless of the data; thus it can be adjusted to minimize the number of apostrophes (which would each cost 1 byte, as they need to be doubled in a quoted string). As it happened, it was possible to have zero apostrophes.
`5 17‚ç¥` - arrange into a matrix for base conversion; each of the 17 columns will be converted as a unit. (In Dyalog Extended, this could be done as `5 ¬Ø1‚ç¥`.)
`246‚ä•` - base-convert the 5 values in each column that range 0-245 (base 246) into a single number ranging 0-900897818975, the top row being most significant, yielding a flat array. (But due to the nature of the underlying data, it will actually range 0-897410677850.)
`(7‚ç¥51)‚ä§` - base-convert each array element back into a column, with 7 rows, each number in the range 0-50 (base 51). (In Dyalog Extended, this could be done as `51‚ä§`. The number of rows would be autodetected, so if by a coincidence all values were less than 516, this shorthand syntax wouldn't work properly. In this case though, in would work, and would save **4 bytes**.)
`‚àä` - flatten the matrix into an array, row by row.
`C‚Üê` - assign to the variable `C`, the word choice array.
```
C‚Üì‚ç®‚Üê‚â¢i‚Üì‚ç®‚Üê‚â¢M‚äÉ‚ç®w‚Üê(‚äÉC)‚å∑‚àä(‚ç∏M‚ç∑‚ç®‚äÇ)¬®‚åΩ,\24‚Üëi
```
This is Line 2 (as referred to by the `:GoTo` at the end of the loop):
`i` - take the current value of the input (with the parts of it that have already been processed deleted)
`\24‚Üë` - truncate to 24 characters (dots+dashes). That is the length of the longest Morse encodings (`rudolph` and `christmas`). This step is omitted in the üêå version, which results in almost identical operation, but far slower; the word choice array only needs to be modified in two places (increasing the choice value by 1 at the `and` in `andifyoueversawit` and at `christmas`), meaning that at all other words, no matches for >24 dots+dashes are found in the dictionary.
`,\` - make a list of Morse subsequences starting at the beginning of this, ranging from 1 dot/dash long to 24 dots/dashes long (or maximum length, in the üêå version), from shortest to longest (e.g., at the very beginning, would be `'-' '-.' '-.-' '-.--' '-.---' '-.----' '-.-----' '-.-----.'`...`'-.-----..--.--.---.---..'`)
`‚åΩ` - reverse that list, so that it goes from longest to shortest (this way of encoding results in smaller element values for the word choice array on average)
`(‚ç∏M‚ç∑‚ç®‚äÇ)¬®` - to each item in this list, apply the function `‚ç∏M‚ç∑‚ç®‚äÇ`: `‚äÇ`=enclose one level of nesting deeper, to match the nesting of the Morse-encoded dictionary; `M‚ç∑‚ç®`=return an array the same size as the dictionary, where values of 0 mean "not found" and 1 means "found", `‚ç∏`=convert the list of `0`s and `1`s into a list of the indices of the `1`s. The result is a matrix with 24 rows (ranging from longest to shortest Morse, top to bottom), each of which contains a variable number of columns (minimum zero), listing the indices of all the words in the dictionary that match the Morse sequence from the input of the corresponding length (in alphabetical order, but with Jelly's `short` dictionary entries preceding its `long` ones).
`‚àä` - flatten this. The end result is a list of the indices of all the words in the dictionary that match any item in the list of Morse sequences from the input that range from 24 to 1 dots+dashes long, retaining the sorting of longest to shortest (and within each length, entries from Jelly's `short` come before those from its `long`, and within that, they're alphabetically ordered).
`(‚äÉC)‚å∑` - from the resulting list, take the element at the index of the current word choice (`‚äÉ`=first element of) from the word choice array `C`. Equivalent to wrapping everything to the right in `(` `)` and putting `[‚äÉC]` to the right of it, but saves 2 bytes.
`w‚Üê` - assign this (the index into the dictionary of the correct current word in the song) to the variable `w`, returning it as a result
`M‚äÉ‚ç®` - return the `w`th element of `M` (the Morse code of the current word), unwrapped. Equivalent `‚äÉM` followed by wrapping everything to the right in `[` `]`, but saves 1 byte.
`‚â¢` - return the length of the Morse code of this word (in characters, i.e. dots+dashes). If it had not been unwrapped by `‚äÉ`, the result would always be `1`.
`i‚Üì‚ç®‚Üê` - delete that many characters (the length of the word in Morse code) from the beginning of the input `i`, so that on the next iteration of the loop, the next word will be handled, and return the number of characters deleted as the result
`‚â¢` - return the length of the number of characters; since that is a scalar, it will always be `1`
`C‚Üì‚ç®‚Üê` - delete that many (1) characters from the beginning of `C`, the word choice array, so that on the next iteration of the loop, the next word choice will be ready. This saves 1 byte relative to what a separate statement (`C‚Üì‚ç®‚Üê1`) would take.
```
‚çû‚Üê819‚å∂w‚äÉD
```
`w‚äÉD` - Take the `w`th element of `D` (the current alphabetical word) and unwrap it, so that when printed, there are no spaces to its left or right. Equivalent to `‚äÉD[w]`.
`819‚å∂` - Convert to lowercase. Equivalent to `0(819‚å∂)`. (In Dyalog Extended, this could be done as `‚åä`, saving **3 bytes**.)
`‚çû‚Üê` - Print the result without a newline. In TIO, this prints to stderr.
```
‚Üí2
```
`:GoTo` Line `2` (the beginning of the loop), unconditionally. A line number is used to save the 2 bytes that defining a label (e.g. `L:`) would cost. The lack of a looping condition results in the program ending with `* Command Execution Failed: INDEX ERROR` when it tries to access the first element of an empty array (after it has successfully printed the entire song).
If running this program locally, note that the error prevents `]runtime` from working. To work around this, the program may be called with `:Trap 3`...`:Else ‚ãÑ :EndTrap` wrapping it.
The clean version, avoiding this error, would be `‚Üí2‚ä£¬®i`, meaning `:GoTo` Line 2 while `i` is not empty. This would work because `2‚ä£¬®i` returns an array of `2`s matching the length of `i`, and the `:GoTo` goes to the line number of the first value in the array, if one exists.
### Footer
`‚àá` - end the tradfn `R`
`2(400‚å∂)'R' 'morse'` - compile the user tradfn `R` and the built-in dfn `morse`. Without this, the program would run far slower.
`‚çé'D R‚çû‚ãÑ‚ç¨'` - Call tradfn `R` with dictionary `D` as its left argument and the input (`‚çû`) as its right argument. This passing of arguments is done only for speed, so that the compile can work properly (it doesn't like global variables, or directly using input). The `‚çé` and `‚ç¨` constitute a workaround Ad√°m wrote for me for the way the APLs work currently on TIO. They expect code in the input, but I wanted a clean separation between code and input.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~138~~ 135 bytes
```
·∏≤i‚±Æ‚ÄúQ¬Æ·∏É∆Å‚Åº·πá√ë1¬ø·ªå…†\∆•»•‚Åº·πô‚Å¥E≈Ä∆•≈íE√¶ ã√ò>√æ>‚Å¥√æ ã[‚Åæ∆ë]e√û·∏ç8√ü¬Æ‚±Æ»Æ√∏‚Åπ√ß√∑R?g¬Æ=,¬•ƒó¬µ@√òU~"/X√ßq¬Æ√Ü∆¨¬∞…†s·π≠·π≠?dC#ƒä?g√ë¬∂P√áH5p@ ÇE≈ì‚Åπ¬ΩG6·∏å∆ò·π™¬µ…¶8‚Ç¨(S¬¶·∏§‚Å∏·π´"·∏ü·∏¢l·πæ¬¶∆§·∏É∆≠·∫ä@‚Äô·∏É4$√Ñ·π¨k‚Åπ¬§·ªã√òa
```
[Try it online!](https://tio.run/##pVRPaxNBFP8qofbgwTdFUOnFJlCCHv2DIKgHwVLUHBRPXiRbxUJbD9GDKYgtkqSg6aJi66zVCDPN0uRbzH6RdWYyM@9N0pvZZHj7/v9@700erTQaz8tS8e8Pi29p0fxwXaSKv8yTIvmtsnXZOi/@qqOt0e7dvHvStcrtIvlRHzbz7vBtXfbGm7K9JAdLWikH4807RTLIW/dW5EfF3yzKHZHqtCep5EWSyT3580Z1VaSXz4nu8XtxUJPtWy/mFm7Lvacila/zvvg62n2msn39rT5YPnO8UV2VLXF4Ta5fvfikNl6rD9/pPOLPlUuKb@VtlX0WB6PeYrHWP3tT9BTvFAlX2Zc5xXcU/9RQ2UD08o7Bs69@bdSK5raWL8zLVyrrPzaZOupI93@/LEsGFWCM6QPMwSr6sSIYwbzrL4DxAi0YTyNXjIrBxNEaKjaLCTaSNZp8NhCMFyuNBEYyMfbF/kw9/3HGicpKQLUMAN9iC3NR4B9bCkK6iXcoF6o4t6nS7nDuLj8EdweDRUeI9XZSAeK8oWNvCAkQJUGMFAVvCNmmMroG0Agets9AmSf0EdZCq9imG5rHHRHAog4gtM88DNIimpAqCi2GEvqIhoQgZ/hn0aSQEYI3VIIAiW7cNPHR@MLqwewgT6sIKIGPJHyHZoFRFd1bIHkgugUzbSJ/OB3EzUg/ZKsAewNCW@ADp8dImN/vWItwgEKcup/RncIFpETSIeLGAMFIdvP/rku8ywz3nJ36/@Q30Vj@AQ "Jelly ‚Äì Try It Online")
A dyadic link taking the library as the left argument and the Morse code input as the right argument. Returns a Jelly string of the lyrics. The long integer that takes the majority of the code has the lengths of each Morse code character encoded within it. 
## Explanation
```
·∏≤                      | Split at spaces
 i‚±Æ              ¬§     | Find index of these in each of the following:
   ‚ÄúQ...@‚Äô             | - Base-250-encoded integer 742925387377430937422864458121941352705403867269973650879937105837755604647313120541399315429452997316260711263757137193164236124383957174543961671910365268304120327243209050996915401898167278257845227193061059012165352924148307417330452740236835399667569278751322913192633409885614815
          ·∏É4$          | - Bijevtive base 4
             √Ñ         | - Cumulative sum
              ·π¨        | - Convert to logical list with 1s at the appropriate indices
               k‚Åπ      | - Split right argument at those positions
                  ·ªã√òa  | Finally, index into lowercase letters
```
[Answer]
## Python, 487 bytes
`lambda a,b:'youknowdasheranddancerandprancerandvixencometandcupidanddonnerandblitzenbutdoyourecallthemostfamousreindeerofallrudolphtherednosedreindeerhadaveryshinynoseandifyoueversawityouwouldevensayitglowsalloftheotherreindeerusedtolaughandcallhimnamestheyneverletpoorrudolphjoininanyreindeergamesthenonefoggychristmasevesantacametosayrudolphwithyournosesobrightwontyouguidemysleightonightthenhowthereindeerlovedhimastheyshoutedoutwithgleerudolphtherednosedreindeeryoullgodowninhistory'`
Takes morse code and any of the three libraries as input, returns the text.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), ~~149~~ ~~131~~ 129 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
‚Ä¢NŒ±0Œ©¬§√®G√´‚Ñ¢j∆íƒá‚Ä∫
√ô¬æ‚ÇÇ¬∂√â¬®=Y√†f¬ß√¨[√∞E√éŒª`√∑¬°2√Ñ|~ƒÅŒî√≠¬π‚Äì4‚ÇÇ‚â†ƒÅ√≥3Tv‚ÇÅ‚Ä∞[√ñ√≤‚ÄöS¬ª‚Ä∞C√æEŒ∑FA‚Ä°Œ≥√∑¬Ø¬ø√û‚ÇÉ√¢√ñ.¬≥Œµ√ªV^√ï√ú‚ÇÑ√ö¬π√æ‚ÄòŒòV√Ö√ç√ÖŒòŒõ9m|\√ì8g8√¨&√ìiUŒ©√éQ:√á¬∫Z√ég√∂√¶‚Ä¢4–≤>¬£I#A‚Ä°
```
-18 bytes thanks to *@Deadcode*.  
-2 bytes thanks to *@Grimmy*.
Uses the complete morse-string as first input, and the lookup format as second input.
[Try it online.](https://tio.run/##pVRLa1NBFN73V1wQ3J1BtItWUChSRReCVAtaKSpoaUFcCK6K3FxTShdmYbTEKtJG6QNb@gi2tIEIc4LLwd8wfyTOuZmZcybpzvvKmTnP7ztn8ur102fzz3s9mzfvmsNLZkf/wO1b@NNWmwt/PnSXbX42gp91xxaFPsYVvX3tIa6/0Fu4O4MHk1gz7Sd4ojcuY3XxbbdiPuKePrV5fdTZ25X1bgVbV@6/sUXF5gczuIpHNl@b0m23uoGdSXNyc8LmG6blQuzr3/jNFu@wiatKt8wvbE/P4if8aosqrulT7Ni8YRrTuITvcck0zJfxl4uPsT42N4a7F7E@/8DsYO3eVVzWZ4@wNofHuOlAjf49uq6/375AeXp3eqCALuV@@k//dWsVLq/sb5USyF0FwKtUo7wXhLtMBTFc3zqmi1m82UBq//HmPj5Ecw9DJZ/oG/QiA6RxY8VBEQMwSoGYKYrWEKMNRPQFsBIC7BBBMi/oE6zFUrlM37SAOyFAJRVALF8FGKJEVjFVEloKJdaRNIlBDvGvkk4xIwJvzAQRkpy4QeKT9sXRg@FGnpcRWILgKfiOxYKSW3JuQcSB5BQMlcn8cXcYtxL1iKkCrg0EbZEP7p4SbmG@012GAxLiwPlMzhQPoCRSNpEnBgRGMZv/d1zSWVY85@rc/6cwiaQZUZCRJqMlSZm7SxFIoLV7nD0ZZBQkK@WMtigNGZaKrIxCziSVSopXOgJZqX8) (Outputs as a list of characters, so the `J` in the footer is to join it together to a single string to pretty-print.)
**Explanation:**
```
‚Ä¢NŒ±0...g√∂√¶‚Ä¢ # Push compressed integer 2178625864988239449532491166807818445418276694861550892023336765049187401437036816274840827319861935617150192366925629812414499033245212320687403711053517272798896860734190937884895522347710320033920004354990136205425279052925026955638024859428057287730519725429748232597858786841294379
   4–≤       # Converted to base-4 as list: [3,2,2,2,1,2,2,2,1,2,3,0,2,1,1,2,2,1,1,3,0,2,1,1,2,3,2,1,1,3,0,2,1,1,2,3,1,3,0,1,3,2,1,0,0,1,1,2,3,2,3,1,2,1,1,2,2,2,1,1,0,2,1,1,2,3,3,1,0,3,0,1,3,2,0,2,2,3,2,2,2,0,3,1,3,3,0,3,0,1,2,2,0,3,1,1,2,2,2,2,0,1,1,2,0,0,2,2,3,1,3,3,2,2,2,2,3,3,3,0,3,0,2,0,2,1,2,2,0,2,2,0,1,1,2,0,0,2,3,1,2,1,3,0,2,3,2,3,1,1,3,1,2,2,0,1,1,2,1,3,3,2,2,0,3,0,2,2,1,2,1,0,3,2,2,2,2,2,3,2,0,3,0,1,2,1,3,1,0,2,3,2,2,2,1,3,3,2,3,0,3,0,2,0,3,0,2,2,0,1,1,2,0,0,2,2,2,0,2,0,2,3,1,2,2,3,1,1,2,3,1,3,3,3,1,1,1,1,1,0,2,0,3,0,3,1,0,3,0,2,3,0,0,3,2,2,2,2,2,2,2,3,3,3,3,2,1,1,1,1,1,1,3,2,0,1,1,2,0,0,2,2,1,1,0,2,0,3,0,1,2,1,0,3,2,2,2,3,3,3,2,1,2,0,1,1,2,0,3,0,2,1,1,0,1,3,1,1,0,0,2,2,1,3,2,2,2,2,3,3,3,2,1,0,3,3,2,2,2,1,2,2,0,2,2,3,2,1,2,3,0,2,2,1,0,3,2,2,2,2,1,2,0,1,3,2,3,0,1,2,3,0,2,1,1,2,3,0,0,3,0,1,3,2,2,0,3,0,2,0,1,1,2,0,0,2,3,2,3,0,2,3,1,1,1,2,0,3,0,3,2,3,2,2,0,0,2,2,2,0,2,1,0,3,2,3,0,0,2,2,2,2,3,3,3,0,3,0,2,0,2,1,2,2,0,2,2,0,1,1,2,0,0,2,3,2,2,3,3,2,2,2,2,2,1,1,1,3,1,2,0,2,2,3]
     >      # Increase each value by 1
      ¬£     # Split the first (implicit) input-string into parts of that size
       I#   # Push the second input-string spit by spaces
         A  # Push the lowercase alphabet: "abcdefghijklmnopqrstuvwxyz"
          ‚Ä° # Transliterate all morse-strings in the list by the characters in the alphabet
            # (after which the resulting character-list is output implicitly)
```
[See this 05AB1E tip of mine (sections *How to compress large integers?* and *How to compress integer lists?*)](https://codegolf.stackexchange.com/a/166851/52210) to understand how the compression works.
---
Also, since I was curious what the program length would be if we wouldn't take any input and just use [the 05AB1E dictionary](https://github.com/Adriandmen/05AB1E/blob/master/lib/reading/dictionary/words.ex) to output the string, I created a program for that as well, which is **266 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)**:
```
‚Äô4∆í‚Ç¨√û√üer0‚Äì‚Ä∫r0prancer0vixen‚Ä†‚Äût0√Ø‚Ä∫id0¬•√öner0b√ô√Æ√òÀÜ‚Ç¨¬≥‚Ç¨¬∑4¬æ√é3‚Äö¬¢¬£‚Äì2‚Ç¨‚Äö‚Ç¨≈∏13‚Ä†¬æ5d2‚Äö‚Ä†a‚Äö√íshiny5‚Ç¨∆í‚Ç¨¬¨4ÀÜ√´‚Äì√¶‚Ç¨‚Ä¢4‚Ç¨√û∆í√é‚Ä¶√®‚Ç¨‚Ä¢√©¬ªs‚Ç¨≈∏‚Ç¨‚Äö3‚Ç¨¬∂2‚Äö‚Ä∫‚Ç¨‚Äû√á√á0‚Äû√í‚Äû≈°≈í√Æ‚Ç¨¬ª‚Ä†‚Ñ¢‚Ä†¬≥‚Äî‚Äπ1‚Ä¶¬Ø‚Ç¨‚Ä†‚Ç¨√Ü2∆í‚Äö‚Äö¬Ω‚Ç¨¬µ√ö∆így≈í√é¬ªÀÜ≈°¬¥‚Äπ√©‚Ç¨‚Äû‚Ä¶√®1‚Ç¨≈Ω‚Ç¨≈æ5‚Ç¨√ä¬Æ√Å¬¢¬≤t4‚Äû¬≤‚Ç¨¬Øsl≈∏¬Øo‚Ä†√¶‚Äö¬Ω‚Ç¨√ü32¬Æ≈ì‚Äû≈°‚Ç¨≈ì‚Ç¨¬ªsh‚Ç¨√Ñed‚Ç¨√Ñ‚Ç¨≈Ωg√Ø¬≥13‚Ä†¬æ5d24ll‚Äö≈ì‚Äû‚Äπ‚Ç¨‚Ä†‚Äû¬™‚Äô5√ù‚Äô‚Ç¨∆í rudolph rein√Ü√ì ‚Ç¨‚Ç¨ ‚Ç¨√Æ √Ñ√É‚Äô#:
```
[Try it online.](https://tio.run/##RVHLasJQEP2VQH8gxrjp32gTNBCiJLbU3W0rEbpwEbuoQjVaKrWVBLQPq9TFDHHjX9wfSWduhG5muDPnnDkztxlUa46d51IMzUMkb5c4xont61IMpNj6esuvehf0vnKubU@KWIpxW8eUeo6lwwuOPGrWcIgJPh5D4sOaw7cJe@yXpRjBDJ5JzKAqvShmmxLVY9hXLIMrIq5SwihoOF6nQgBlA5bmMcR3YuJcUWemMneIsC/FHF@LIi5gFyjRQr/M1K9Cd6tKY@xhT@ccUcimWYQJg3a8THfGTtZSPEjxUyJdSBUp5lmhQU5YaAS/zPjE0SGqd0igD7tjmE3hg1i4KMYoUyW2wuBsz5vgPSR4QxdYtU2CwIpl0sDNNpA2aQqtdhLHSdmAJBsoi8wfKI9Bg3td21JJidcxhfX/BU3XJQ1FJDMn8zTqjT60gk8U1UU1/9Jquq2G5tuOhyEONIbeLjlhomEX7wh6dp7nfw)
**Explanation:**
```
‚Äô4∆í‚Ç¨√û√üer0‚Äì‚Ä∫r0prancer0vixen‚Ä†‚Äût0√Ø‚Ä∫id0¬•√öner0b√ô√Æ√òÀÜ‚Ç¨¬≥‚Ç¨¬∑4¬æ√é3‚Äö¬¢¬£‚Äì2‚Ç¨‚Äö‚Ç¨≈∏13‚Ä†¬æ5d2‚Äö‚Ä†a‚Äö√íshiny5‚Ç¨∆í‚Ç¨¬¨4ÀÜ√´‚Äì√¶‚Ç¨‚Ä¢4‚Ç¨√û∆í√é‚Ä¶√®‚Ç¨‚Ä¢√©¬ªs‚Ç¨≈∏‚Ç¨‚Äö3‚Ç¨¬∂2‚Äö‚Ä∫‚Ç¨‚Äû√á√á0‚Äû√í‚Äû≈°≈í√Æ‚Ç¨¬ª‚Ä†‚Ñ¢‚Ä†¬≥‚Äî‚Äπ1‚Ä¶¬Ø‚Ç¨‚Ä†‚Ç¨√Ü2∆í‚Äö‚Äö¬Ω‚Ç¨¬µ√ö∆így≈í√é¬ªÀÜ≈°¬¥‚Äπ√©‚Ç¨‚Äû‚Ä¶√®1‚Ç¨≈Ω‚Ç¨≈æ5‚Ç¨√ä¬Æ√Å¬¢¬≤t4‚Äû¬≤‚Ç¨¬Øsl≈∏¬Øo‚Ä†√¶‚Äö¬Ω‚Ç¨√ü32¬Æ≈ì‚Äû≈°‚Ç¨≈ì‚Ç¨¬ªsh‚Ç¨√Ñed‚Ç¨√Ñ‚Ç¨≈Ωg√Ø¬≥13‚Ä†¬æ5d24ll‚Äö≈ì‚Äû‚Äπ‚Ç¨‚Ä†‚Äû¬™‚Äô
      # Push dictionary string "4knowdasher0dancer0prancer0vixencomet0cupid0donner0blitzenbutdo4recall3mostfamous2ofall13red5d2hadaveryshiny5andif4eversawit4wouldevensayitglowsallof3other2usedtolaugh0callhimnamestheyneverletpoor1joininany2gamesthenonefoggychristmasevesantacametosay1withyour5sobrightwont4guidemysleightonightthenhow32lovedhimastheyshoutedoutwithglee13red5d24llgodowninhistory"
 5√ù   # Push a list in the range [0,5]: [0,1,2,3,4,5]
   ‚Äô‚Ç¨∆í rudolph rein√Ü√ì ‚Ç¨‚Ç¨ ‚Ç¨√Æ √Ñ√É‚Äô
      # Push dictionary string "and rudolph reindeer the you nose"
  #   # Split it on spaces: ["and","rudolph","reindeer","the","you","nose"]
   :  # Replace all [0,1,2,3,4,5] with ["and","rudolph","reindeer","the","you","nose"] in the string
      # (after which the result is output implicitly)
```
See the same 05AB1E tip as linked above (but section *How to use the dictionary?* this time), to understand how the dictionary strings work.
[Answer]
# [MATLAB R2016a](https://www.mathworks.com/help/matlab/release-notes-R2016a.html), ~~290~~ ~~285~~ ~~277~~ ~~266~~ ~~245~~ ~~223~~ 219 bytes (99+119+1)
```
function r(m,d);[a,b]=ismember(mat2cell(m,1,fread(fopen('j'),474,'bit2')+3),strsplit(d));char(b+96)
```
The inputs are the Morse code sequence `m` and the dictionary `d` in the third format. The function uses a 119-byte file `j` [available here](https://www.dropbox.com/s/88x42yob0q5of78/j.bin?dl=0) that contains the lengths of the 474 Morse codewords. According to [the rules of scoring multiple files](https://codegolf.meta.stackexchange.com/questions/4933/counting-bytes-for-multi-file-programs/4934#4934), this adds an additional byte to the score.
[Answer]
# [Perl 5](https://www.perl.org/), ~~283~~ 244 bytes
```
$s=<>;$s=~s/..{$_}//+print$s=~/(.) \Q$& / for map{vec unpack('u',q{MJZDYEM98;HWE31N4>Y9:6'Y,BZYRSZ1<JI2@]ZH_(Z8H)7@V[G5*V2NC&:NZM3':XVCLCHY2@(IY>WE\5,L<XK*K^6U5+"5K(9*S^)B5CT07:JK_Q:HINCL:J=23LYEL.T,E*".U[)[`HJQ@ZJ/R.F*"6XOJK5B0X`}),$_,2}0..473
```
[Try it online!](https://tio.run/##pVT7U9pAEP5XdhhGHrIbBAMSkWFA2hAeHXwgCVakFlurIoLYB0P/dZqT5G4P/K0Bktzt7rf7fbvHZDR9MFer6OyoWDr0739nBtEiOlgaxu5kejd@EXtGnBJw2YnugAG3T1N4HE4Wr6MbmI8nw5v7eGweSz0vWo537NZahYND@6KW3Wvvl9yClYu5qYrnnpx6e0Wnnil/9uxB3DuwE/lyt//RTHYz7eqO1fZa2ZjV61abVdvNlON1t3RRuzRTzWKvkWxc5c7N3YjZiBeSp1eJilk9S@ctpzHoWHa9XW1azlEm23RrTTpL1ZIROu8n@te20yl7jnFCH5KRXO@T0zAr6d71MpGKDlKZZZpoP59drZBQXOQ/1t/1z19TeAXG9dbbG/JdQlQr3UJBFIaft1Qo4dbeMp3MErhtpA5ugXuAj9I9oEHaTcaGdpYBdVxZcWiQAIolY6wkkt4o0TYQgwKUEUPaIQJXnsnHVJOlqjKDpoW8NQFIqwBl@RTSYCUqk5KKU9OpyDq0JimSW/qT1imlCOMrM6GkxCduU3itfXL0cLuR72VE9YZhJNNbFovEt/jcIsNB7RRslan0U91RvInVw6YKVW3IZJN6qO4RCwvnW99VdJBT3Dif2plSA8iF5E1UE4OMI5vN/zsu@iyTmnN69/8pnERhGQIhfAFhhBsQe/BVrGAEBLcgwuAb@O7wHUQo3PkP@AECA@5FADyAwIZH3wvG/g48gTBOhA/BswhGmAonmAkMeAGEuYCGV7FG@Clc4ZfIi/BbgCL8EXEE/wA "Perl 5 ‚Äì Try It Online")
This corresponds to:
```
$L = <<'';                            # length bits in base64
MJZDYEM98;HWE31N4>Y9:6'Y,BZYRSZ1<JI2@]ZH_(Z8H)7@V[G5*V2NC&:NZM3':XVCLCHY2@(IY>WE\5,L<XK*K^6U5+"5K(9*S^)B5CT07:JK_Q:HINCL:J=23LYEL.T,E*".U[)[`HJQ@ZJ/R.F*"6XOJK5B0X`
$s = <>;                              # read inputs
$s =~ s/..{$_}//                      # take current length morse code from start
  + print $s=~/(.) \Q$& /             # ...and print corresponding letter
  for map vec(unpack('u',$L), $_, 2), # find morse code lengths of the letters
      0..473                          # 474 letters
```
This could perhaps be further shortened by encoding in base128 or directly in "base256". Huffman encoding the lengths could shorten the length data, but most probably enlarge the rest of the code by too much.
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), ~~145~~ 141 bytes
```
‚âî‚™™‚ÆåŒ∏¬πŒ∏Ôº¶‚Äù)‚Äú1¬ßŒºX‚Ü∂)‚üß¬∂¬ª-‚Üò3œâ‚óßi‚åä‚äû‚Å∏Ôº±9m;T‚Ä∫|Ôº¨DŒº‚Ä¶‚Ä∫ÔºØ‚¶ÑhTYÔº©O5x√∑‚Ü∂√ó‚Äπ,‚ü≤"yÔº≠LUÔº£gq.Ôº¢NÔº•2‚Å¥‚éác‚¨§œáÔºÆ¬±‚∏ø‚ÜôÔºÜ7‚üßœá‚Å∞‚ÄπÔºπs¬¥Œ£C‚Åº{9œâÔøΩPiÔºÜ‚óß√™KœÉÔº∞DfY9wi‚ü≤f[Œ¶œÑ¬≥Ôº™‚Äπ‚Ä¥V[^Ôº∑Ôº≤EŒ±F[-T^œÇ‚Äù¬ßŒ≤‚åï‚™™Œ∑ ‚≠Ü‚äïŒπ‚äüŒ∏
```
[Try it online!](https://tio.run/##pVTBbtswDL33K4ScHCAULOvYUy8DehhQrF@QJV5rIHNSxyj29x4fLYlU0p3mxA4lPj6ST3QO7/vpcN6fluXpeh3exub1chrm5kf/2U/XvvnY7lzg@2P7@PDrPLlmE7uuC3LHtgtshbAaUS3@DbxsW9mOQXD8WL0xtOJvuw5kLcMjdsQEsENcCzd7sI4C4ABgihu8vIsEIYZ1WwKAZSin6SS6E3bGtJIQmJUvKhmIhRJskph/A0pmlFTMMYlQCkK7uGJhSOCcWCCrU2ThlvkBXO4JwCSnaCGS5rIRijqzzsiOHWHLCsCHOqVINJc6AUcU@1/awSGtBBEP@Tdb9zIN49w8zc/jsf/T/Ny5b8N4TCPxvnMbt@FZeJ0Z9fZ9f2mex8PU/@7HuT82A3tezheeGFyPy0KecHn@Wb/rzWufr@Rct8Qiu@uJdFV7fIqi/JFUVOhWdElXsiTYTer0SPDETwWe2vDVo8Rmv8lANW@pODsKgXZpOlaJCpoK2w1jKkCdlNvODFZ5I59RrZSqZaZDy31XAviqAirl@9yGKVFdKpVtrW6l1FEdkjZ5p7@vTkoVMf2WTFRashN3K3x1fGX06P4gv8pIalGONHqXYsnbLTu3ZHioegvuylT99HS0b2/qMVNFWhsZ2YoeenrehOX5rne1HbIt3ryf1TulA2iFtIeoE0OmRzOb//e61LPsdc79l/9PeRLhefDk4HFYwnL8EZNgYM1fxgPgQOLEdthCGgDF4YQFwbDECT4JJKD8Qp@nvw "Charcoal ‚Äì Try It Online") Link is to verbose version of code. Edit: Saved ~~3~~ 4 bytes by using a less inconvenient library format. (Thanks to @Deadcode for pointing out that I'd pasted in the wrong version.) Explanation:
```
‚âî‚™™‚ÆåŒ∏¬πŒ∏
```
Reverse the sequence and split it into individual characters.
```
Ôº¶...
```
Loop over the characters of a compressed string which are the digits `0..3` (which compress better than `1..4` for some reason).
```
¬ßŒ≤‚åï‚™™Œ∑ ‚≠Ü‚äïŒπ‚äüŒ∏
```
For each digit, pop one more than that many characters from the sequence, concatenate them, look them up in the library split in spaces and output the desired character (using the predefined lowercase alphabet).
137 bytes with an even more convenient library format:
```
‚âî‚™™‚ÆåŒ∏¬πŒ∏Ôº¶‚Äù)‚Äú1¬ßŒºX‚Ü∂)‚üß¬∂¬ª-‚Üò3œâ‚óßi‚åä‚äû‚Å∏Ôº±9m;T‚Ä∫|Ôº¨DŒº‚Ä¶‚Ä∫ÔºØ‚¶ÑhTYÔº©O5x√∑‚Ü∂√ó‚Äπ,‚ü≤"yÔº≠LUÔº£gq.Ôº¢NÔº•2‚Å¥‚éác‚¨§œáÔºÆ¬±‚∏ø‚ÜôÔºÜ7‚üßœá‚Å∞‚ÄπÔºπs¬¥Œ£C‚Åº{9œâÔøΩPiÔºÜ‚óß√™KœÉÔº∞DfY9wi‚ü≤f[Œ¶œÑ¬≥Ôº™‚Äπ‚Ä¥V[^Ôº∑Ôº≤EŒ±F[-T^œÇ‚Äù¬ßŒ∑‚≠Ü‚äïŒπ‚äüŒ∏
```
[Try it online!](https://tio.run/##pVRNb9swDL3vVxg@OUAoWNZtPfXYw4BiPQ47ZImbZEudxPGybsN@e0ZSlEgl3WlubT@KT48forPcLMblfrG7XO5Pp@16aJ4Ou@3UfOzP/Xjqm@NsXnm8j7O7d8/7sWrq0HWd5zu0nUfkfQRBEb49mm3Ly8EzDx/RG3zL/rbrSKxFeqAVhkTsaF9LbvSQHZiAG4iT3aSLqxTABx@XeQNxkYphOt7dsTpyWg5InKgXVIyEWZLUODC@PaWMLM4Y94ggJ0Tl0hWygpBTYKZEJ7cFS8YH8VJNRJR2ci@4pSlt2kp5pj5TdFphtdQB8lGenCQVJ5WQRmD8r96Rg0vx3DyKX8@qx3E7TM399DCs@tdmM6@eJlxZf1gcmodhOfYv/TD1q2aLE/G4P@B04HV3uXyqwQFdDl/xP95ou3SJMy4xArvqANQqPU52QfrjUJDlIjuHy1GEdhVaHkIXfch0KcMVj7w3@U0EKHVzxsmRBbRKU7G2KLMhq10pSgLqhFR2UrCdN@0zXcupappyaKnuogGuyABy@i6VYVJUl7bKllaWkvMoDkmLvOm/K05KO2LqzZEgl2Qn7rrxxfHl0YPbg3wrIiiCtNP0OycLzi7ZuQWjA8VXcJOm9k9PR@t2Jh8zVaC5gWlb7oeenjPb0nyXq1oO2BKvvs/im9IBtI20h6gTA6ZGM5v/97mUs@x0zt2bv09pEslTz6vftYP6fVUvENfEIuNLNICNpXgIrwgz6hkJ5ZkpEa@jI/I30SC4ZYixyfgqAQh/i47I2kUlgi@RQ3CIq7y8Fx12HCQwe44iRHiULAifmERokqQJfxcGG2cRJfxD6mXjVRJl46dEY9Vf9Z/PFzjv/gI "Charcoal ‚Äì Try It Online") Link is to verbose version of code. Explanation:
```
‚âî‚™™‚ÆåŒ∏¬πŒ∏
```
Reverse the sequence and split it into individual characters.
```
Ôº¶...
```
Loop over the characters of a compressed string which are the digits `0..3` (which compress better than `1..4` for some reason).
```
¬ßŒ∑‚≠Ü‚äïŒπ‚äüŒ∏
```
For each digit, pop one more than that many characters from the sequence, concatenate them, look them up in the library and output the desired character.
[Answer]
# [Pyth](https://github.com/isaacg1/pyth) + [Jelly's dictionary](https://github.com/DennisMitchell/jellylanguage/blob/master/jelly/dictionary.py), ~~135~~ ~~134~~ ~~131~~ ~~130~~ 129 (126üêå) bytes[SBCS](https://en.wikipedia.org/wiki/Latin-1_Supplement_(Unicode_block))
The algorithm and data in this answer were originally implemented in [this APL answer](https://codegolf.stackexchange.com/a/197980/17216), and their explanation is there. But as implemented there, it failed in its entire purpose, which was to beat the previously lowest-scoring submission to this challenge, [Kevin Cruijssen's **129 byte** 05AB1E answer](https://codegolf.stackexchange.com/a/197652/17216). Here, it finally succeeds in its very purpose for existing, and just barely manages to beat that answer's length. I learned Pyth to do this; it was a promising choice with very good documentation. It's unclear if any of the other golfing languages would be able to implement an imperative algorithm like this in fewer bytes.
With a longer Morse code message this algorithm would win by a significantly larger margin.
```
Kcwd=bmsm@KxGkdTVjC"√™√™V√û√∏A?cUqg¬¥¬ß¬ºF¬¶e~zE¬∫√ä√∫[!√Åw¬∂uQ√•¬¥√ß√Ω¬Ω√ä*¬§jrkI√¶w√ê√≥*S.(4√°√´√å√∂√Ö√ó¬π√±p.√ëQ√êgB√™¬†"51=>zl@bJ@sxRb_._<z24Np@TJ
```
(contains C1 control characters, forbidden by HTML5, thus the above can't be copied to clipboard and is for illustration purposes only)  
[Try it online!](https://tio.run/##pVTNaxNBFMeDIJ68KB7HEEhS@waVerFGo6JiK2I19tJKyMfmq5vddZOQj4Mg2kvxUA8qePADtIV4EkvRYi/z/i/jzmZ35k3Sm7ubzZt5n7/fe7PeoFMfs6TVt8rpVMWqsoee33A66WLmCoukeWY5lWwiMc@qdrddz@b9rpVZZL7V6foOK647hUbLK4TGLMuUvLjuyHhqHYas2W6paLfTmbWEUiSeBm5EUSAanSaVSQaZ71@ISq36bos1LdseyAyu32GVRrnTcJ2iP0hlmOuTNW/XpcF5umW7Ti05Xi73KtlSq93KLffvblTyq81biWPirXiHIxyt4kf8deN6@cmzmtgTu@LPHbFjPR/eFge4hQcn1s7hi57Y767gN7GHu3goDnFrTnxt@hv3zuBO7yxu48@5xzy9ID7gF/yOr4/jPm7ie/FS/MYfHsc3p8SrFdwWm7XTN3EkPotPicsXs9eGdq60lGv3H5UKvHB1eGnhgZfLL43HwEFePPibPJNfsObxFSknW6EEdJcD6JWp4ZEXxHeYClS4ibVKp7JEZlOpo1dkHsUHZR7B4MZL@cZ6kgHMuKriWKECaJQEsaZIWYOKNhUxKkArIYYdR6DME/oIa6pUXWbUtBi3QQA3KgBVPo9hkBK1SlNFoZlQVB1GkzTIGf650SnNCMGrMoGCRCdumnijfWr0YLaRR2UELUHsSfhWxQKnW3RugcQB4xTMlKn5093RuDmph0wV6NqA0Kb40N3jxC2eb3NXwwEKcep8GmdKDyAlkjZRTwwQjGQ2/@@4mLPM9ZzzI79P8SRKzUkOTGqYXEqJBXcoghTkOngCe2nAZBAWykxuyTTSMFSwMIp0llKolPFCR5BW/K/ryQ9/ewxQsUrd2j8 "Pyth ‚Äì Try It Online") - 129 byte version, running at decent speed
```
Kcwd=bmsm@KxGkdTVjC"√™√™V√û√∏A?cUqg¬¥¬ß¬ºF¬¶e~zE¬∫√ä√∫vM√á√¨√Ω√∑¬º]¬æI/||√ä√Å√™,√òm√∏√ói]Z8¬©b¬§0√•√©'¬ΩbI√Ω>√§
lG√πUK¬Ω"51=>zl@bJ@sxRb_._zNp@TJ
```
(contains C1 control characters, forbidden by HTML5, thus the above can't be copied to clipboard and is for illustration purposes only)  
[Try it online!](https://tio.run/##pVTNaxNBFMeb9CIePDssgSTYN9aDIJbUiGhpoyKS9qANIZvdfNTNbtxNNAlF8KJg8djqyVNVGjwK1tJ4mPm/jDub2Zk3SW/ubjZv5n3@fu/Ndoe91pRk3IFbz2Udt0GedMO238vV8reJlJaJ6zsFy1omDa8ftQrlsO/mV0no9vqhT2o7frXd6VYTY1IgSl7d8UU8tU5CNr3ArnlRLv/cUgqrErshRRVpdJpsPhNnfrgiS22EQYfsup43FBmCsEecdr3XDvxaOMzmSRCiNY1awuAa3vICv5mZluqvnYLdiTrF0mD9hVPe3r1nXWAH7JCP@Xibf@End@/Ut1422U/2nZ09YN/cN6P77JR/4KcXX7H9R/w9/8En/Bc7q7A/7N3G9b29S7HyLR8v888dfsL2@ad25dktdmyzoxX@lR9nr7CJzT5u8Ak7WONHS1e9df5763KJHbKJdfNGYW3kFe3NYjR4aldpdfS4WyxvTqdAQVw0/ps9s1@8pukllbOtRAK8SwH0ytRQ6QXpnaQCFW5mrdKpLNJsLrV8SXMZH5S5hEGNl/JN9SgDmHFVxalCBdAoEWJNkbIGFW0uoixAKyGFnUbAzCP6EGuqVF2mbFqK2yCAGhWAKp@mMFCJWqWpwtBMKKoOo0ka5AL/1OiUZgThVZlAQcITN0@80T41erDYyPMygpYg9UR8q2KB4i08t4DigHEKFsrU/OnuaNwU1YOmCnRtgGhTfOjuUeSWzre5q@EAhjh3Po0zpQcQE4mbqCcGEEY0m/93XMxZpnrO6bnfp3QShWaJAhEaIpZCIvGdiCAEsY6f2F4YEBGEJDIRWyKNMEwUJIkinIWUKEW8xBGEFf0bdMU3P5oCOK7db/4D "Pyth ‚Äì Try It Online") - 126 byte üêå version, taking about 20 times as long to finish (especially slow at beginning)
## Explanation of the code
### Header
```
 $exec('
```
Anything in `$`...`$` is `eval`ed as Python code. Open an `exec` block here (since statements can't be executed in `eval`). The leading space suppresses `imp_print`.
```
def Pprint(a): print(a, end="", flush=True); return a
```
On my system, this program takes 46.4 (or 921üêå) seconds to finish, but on TIO, it is on the very edge between not finishing in 60 seconds or just barely finishing. If it didn't manage to finish, no output would be shown. If it was manually interrupted before finishing, the incomplete output would be shown ‚Äì so it appears TIO sends a SIGINT (Ctrl+C) to the process for this, but something more powerful (perhaps even SIGKILL) when reaching the 60 second limit.
By default, Python only flushes its standard output on newlines. The `-u` command line argument forces stdout (and stderr) to be unbuffered, but TIO does not provide a way to send arguments to the host Python process that spawns Pyth.
This header line redefines Pyth's `Pprint()` macro to flush its output, so that if the program does not finish within 60 seconds, the incomplete output will still be shown. It's the next best thing to `-u`.
Funnily enough, forcing each individual print to flush seems to actually make it run faster on TIO; it was able to finish in under 58 seconds with this, whereas in my tests on TIO the 134 byte version never finished without this.
```
_imp_print = imp_print;
def imp_print(a): globals()["imp_print"] = globals()["_imp_print "]; return a
```
Work around the newline inserted by TIO between the Header and Code sections, which would trigger an `imp_print()` on the first expression otherwise. Suppress only the very first `imp_print` that happens next, and then allow all subsequent ones.
```
')$
```
End the `exec` block.
```
=TrL0$exec('from jelly import dictionary') or dictionary.short + dictionary.long$
```
Import Jelly's dictionary and assign the concatenation of its short and long dictionaries, changed to all-lowercase, to the Pyth variable `T`. Equivalent to:
`from jelly import dictionary`  
`T = list(map(lambda arg:arg.lower(), dictionary.short + dictionary.long))`
### Code
```
Kcwd
```
The Morse code version of the song has already been read from input implicitly, as `z = input()`.
Read the Morse code look-up table from input. Equivalent to `K = input().split(' ')`.
```
=bmsm@KxGkdT
```
Translate Jelly's dictionary into Morse code, with the inter-letter gaps deleted. Equivalent to:  
`b = list(map(lambda d:''.join(map(lambda k:K[string.ascii_lowercase.index(k)], d)), T))`
(The outer lambda uses `d` as its argument, whereas the inner lambda automatically advances to using `k` as its argument.)
`jC"√™√™V√û√∏A?cUqg¬¥¬ß¬ºF¬¶e~zE¬∫√ä√∫[!√Åw¬∂uQ√•¬¥√ß√Ω¬Ω√ä*¬§jrkI√¶w√ê√≥*S.(4√°√´√å√∂√Ö√ó¬π√±p.√ëQ√êgB√™¬†"51`  
`jC"√™√™V√û√∏A?cUqg¬¥¬ß¬ºF¬¶e~zE¬∫√ä√∫vM√á√¨√Ω√∑¬º]¬æI/||√ä√Å√™,√òm√∏√ói]Z8¬©b¬§0√•√©'¬ΩbI√Ω>√§‚êälG√πUK¬Ω"51` üêå  
(contains C1 control characters, forbidden by HTML5, thus the above can't be copied to clipboard and is for illustration purposes only)  
Unpack the word choice array (115 elements), packed in base 51 in an **82 byte** base 256 encoded string. Luckily there happened to be no characters that needed escaping.
`C"`...`"` - convert the base 256 encoded string into an arbitrary-precision integer  
`j`...`51` - convert the base 51 integer into a list of integers
---
`V`...`=>zl@bJ@sxRb_._<z24Np@TJ`  
`V`...`=>zl@bJ@sxRb_._zNp@TJ` üêå
Main loop.
`V`... - `for N in` ...`:` - for each element `N` of the list decoded above, execute all of the following statements:
`_._<z24` - `reverse(list(map(lambda arg1:z[:arg1], range(1, 24+1))))` - make a list of Morse subsequences starting at the beginning of input (`z`), ranging from 24 to 0 dots/dashes long (from longest to shortest)  
`_._z` üêå - `reverse(list(map(lambda arg1:z[:arg1], range(1, len(z)))))` - make a list of Morse subsequences starting at the beginning of input (`z`), ranging from maximum length to 0 dots/dashes long (from longest to shortest)
`J@sxRb`...`N` - `J = sum(map(lambda arg2:index(arg2,b),` ...`), [])[N]`, where `index(arg2,b)` finds all occurrences of `arg2` in `b` - enumerate all words that match the Morse code at the current position in the input, up to 24 dots+dashes, and store this list of dictionary indices (which apply to both `b` and `T`) in `J`
`=>zl@bJ` - `z = z[len(b[J]):]` - remove the processed Morse code from the beginning of the input
`p@TJ` - `print(T[J])` - look up this word in the dictionary and print it
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), ~~¬†270¬†~~ 269 bytes
Takes input as `(string)(lookup)`, where *lookup* is in the 3rd format.
```
s=>t=>(B=Buffer)("SNB6>B5>V]@a5U)McAQ>@a/;3bRD7;2?R:1P_Sb7K@22MHO5V?O:AWZPATRV4A/VBW[0K:1PJ`Q?Fg=-ZD46TRRgC=]:1P-ZLYRgN<Z@9?H^RfCdRQPC6BTR1U;6>64UZ0MHc`=ZTSH2.cHRg4JQP<*VfRB]1b").map(n=>[0,2,4].map(i=>o+=B([97+t.split` `.indexOf(s.slice(p++,p+=n-40>>i&3))])),o=p='')&&o
```
[Try it online!](https://tio.run/##pVVtc5pAEP6eX8H4wUB1L2pQJzGHipmOk9So@JIpjq2K4pBaYYRk8u8th3C3p/lWQdy7fX2e3cO35ccydA5eEMHeX2@OLj2G1IiooZrUfHfdzUFTc6MXs2aYVWM6by2rE63ntIdGa3nTuF1Zj/VGpWndlwe/R6v6c6tS6XX71Wmzf99@tQftsTXV2zdT83VWeo5tnhbD5vctBftRr40ta9uh83gX7B8/re3Lg926a3Z/WW5nbQ0HnZo5tsqTRs2o6RO71Os6C2qPR90KcbrWVn8aDh6@TV3LnJdXOY38XQbqnhqzUrFS1OfJ0qOGX6CmOrurFyISBjsvWigL4u3Xm8@@q4Yk3HnORg0KhWJQoHvQS4bh5W81ba5pRZ8G9Ppay@f9YxgdFKrkgAD7kPjndJ@@8Zpkn1R52kokwLsEQKxkDUm9ILuSVMDDnax5Op4lNTtLnT5S8zQ@cPMUBpEe3DfTowwgx@UVZwoeQKBEiAVF3Bp4tLOIaQFCCRnsLAJmHtGHWOOlijLTpmW4JQKIVAHw8kkGA5UoVIIqDE2GwuuQmiRAXvBPpE4JRhBengk4JDxx58RL7eOjB5eN/CojCAkyT8Q3LxYI3sJzCygOSKfgokzBn@iOwE1QPWiqQNQGiDbOh@geQW7ZfMu7Ag5giGfnUzpTYgAxkbiJYmIAYUSz@X/HRZ5lIuacfPl@yiaRaXKNq6ud7/95D9jLjYDCzBSmY5ISX4kITGDr@I6dmYHCIiqJrLAtlpMZJgolicKcmZQoWbzEEZgVYYkdfx/6uw3Z@Vs1fhNH8V/MqRZNO/4D "JavaScript (Node.js) ‚Äì Try It Online")
### How?
For each character in the data string, we take the ASCII code minus \$40\$ to get a 6-bit value holding the lengths of the next 3 morse codes.
*Example:*
```
"S" --> ASCII code 83 --> 43 --> 101011 --> 10 10 11
                                             |  |  |
                                             |  |  +--> 3+1 = 4 -> -.-- (y)
                                             |  +-----> 2+1 = 3 -> ---  (o)
                                             +--------> 2+1 = 3 -> ..-  (u)
```
[Answer]
# [Python 3](https://docs.python.org/3/), 452 bytes
```
lambda a,b:''.join([chr(96+int(''.join([f'{ord(c):07b}'for c in'''ezVswP,A8BpeH	A82d
DY
po4ZqVH
Dw
,A8AMa+!ezd(a1J+/NCkuN"Rq'L
JR
dQd)>2I)8BK
3!2ssIY>Rl,StiKu]zX!6iCJ4
Go,1s(A/Qe)8BK3J
`5
\0\ a1DkA4YhA98[
R_Uv BO%d\
YHT\!%HpZ,t W
q&<sr&:
eXYBu
K#s*#lA
S">Y
|eMq$IhRw]&/TzR!-f6
IhQw:Q\CwQd*.RdcvDh3QsVBH}4];*H{"D
$9yJ$E%b
,Y>V;d>wr	N'''])[i:i+5],2))for i in range(0,2346,5)])+'tory'
```
[Try it online!](https://tio.run/##PZHdb5oAAMRTVtdWzIoMP2cNWBVQVr/Qqd1IQJqhrm7QzpUK2VBwsDpQ0BLt@rc73cNe7uFyl1x@N18vTceubacflO1M@z3WNVSjxm0cv/jlWDYxmpgu0WoULXtJ/Pem@JPj6sSEbJffjZ/xqeOiE9SycRw3NkPPhxJfKLbJAXNDiJ0css2qDvJyKjh36Htg8WJ4KIB82E/tImz8OhnRitipsdEJrdKDiqVBB3hYDTLSIhDFP4GhnpTWj0VAJ18x1W6YbHJ9@AB6A0ZrWKzqeUjsuCsz0oy6ebm0@it1c4c1IlanR599dOJUxSPYkggY/2qRGtJL/6ifKWUF1So8/MDSssm2miPwdUA6@o58DT@i3OecroCycKtgOWF@Ty3Rb@lF/r3nJuF8Oxky7mRudRCK9s@9o0ThfMaCN5kEI6f@GNeLbNeUfDVfut1I2NtpI9g1RR9uIyKgdPzd/MIFJOmTR4SHzZoIeMnTISc802oSugxEC8ITlOHBcLa17mWvcuMgJTPD@KXO@LB7MtgxVcmR1baKdZWqkuSetbVjjbqa/dMgylS1RjeoOqmSRXzpuGt8O3f3X02JgWMb1F5IcvsX "Python 3 ‚Äì Try It Online")
Same morse-ignoring, hardcoding approach as [ScoopGracie's answer](https://codegolf.stackexchange.com/a/197479/90219), but with each character's 5 LSB concatenated and re-encoded in printable ASCII (i.e. 7 free bits out of each byte).
This shortens the string from 474 to 339 bytes, not counting delimiters (which need to be multiline for the encoded string) and an escape sequence in place of a NUL byte. I also cut the string off at the last clean byte boundary (to not deal with partial bytes) so I had to hardcode the final four characters.
Then there's not-insignificant overhead for the decoding process, so it's not much shorter this way. Improvement suggestions welcome!
Using the standard library instead to compress the lyrics with `base64.b64encode(gzip.compress(...))` actually saves 2 bytes:
# [Python 3](https://docs.python.org/3/), 450 bytes
```
lambda a,b:decompress(b64decode('H4sIAAaPGF4C/3WQ0XbsIAhFv5UJRG2VkyU41n79xdzJY19cBE62WxbGt2IyWZZOykx63MXVn+pdfkQPNPH4OMZVeOegek9ftfiv6Gs4Y2F0OahWz9JgflLDsC5FWaTjjEkfjHrlCHRhhQk/40xMb+nLctG1JwEvZyAlukazeNQTo3I01GgVTxXTAoozeNjMBzYC7Kg0Ut7SkcmlKTWxSC3dyCp+Af0j9IWiRUnXQ0ifsELlRErryL2YN7L42Uidjkg4QuSDCMO8N7DdDa9eUvYJ3dppFJa2rMpuQve52Rnz3sT/KyvewuFJt6RlDBeOY4NT3a/6a3dxRa0JjBmPyKGJvv4BRj4fyNoBAAA=')).decode('ascii')
from gzip import*
from base64 import*
```
[Try it online!](https://tio.run/##NdDJjqJQAIXhfT@FO6WttAhXaDqpBbMigyCImN5c4F7mIYAU8PJ2VTq1Ocn/LU87D2lT0y/8/vdVwiqM4Qq@hX9iFDVV26G@34QM@KoYbdZH0J94Hl5UBYg72rfJe/gJqTIePM1RqVsxe2Bfs9wUL1qw5yJBZih/CtWBOs3@42HNxcTQxv1Wb9sYF/bFvByBZTxuyEIJKjg84Gxk1B4ElEJaMPUXTktwqUu9eFB86Oa5XOD82JXi0UlTu9gBcjLCba1Hg7rXPuTxMfPls4ALMm23oU/kXk1u7nR3@ab5tNwQlkBkzwnpDey1iKry7PrTVaTjWWy3PCZz7uRnjlffbTLDvayXjtx1s04FJqsDysvivEiA/bxKomH9NlkpliCHvDHQ6LhtFQ1SndE@7REdKKde6N7dnecRfTwVbWCcUhKQFQDTpeGOgXQ8OZDUcqG6zGdVG0cgODnAs9kIPM@/rwni1/fnsI@ybE38wF1TrZIla1dZ1Tbd8PO/hLBHDPi2V9tl9bDBG7Op0dvXEMTrHw "Python 3 ‚Äì Try It Online")
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), 142 bytes[SBCS](https://en.wikipedia.org/wiki/Latin-1_Supplement_(Unicode_block))
Like many of the other answers, and [my Python answer](https://codegolf.stackexchange.com/a/197732/17216), encodes the lengths of the 474 Morse codewords into **119 bytes** using base 4. Shares many similarities with [my Pyth + Jelly's dictionary answer](https://codegolf.stackexchange.com/a/198173/17216).
My primary reason for posting this answer is to show that in Pyth, apparently the 474-codeword-lengths method does *not* beat the 115-Jelly-dictionary-word-indices method!
Takes the Morse representation and library as two lines from stdin and outputs to stdout:
```
Kcwdsm@GxK<~>zddhMjC"¬¶¬¶√âir[%¬∑An√ôjR[√ì+¬®√ü1¬£Z¬°`¬≠√∫¬Ø√å¬¢√ô√ã¬µ√ö~¬¶N¬™√£√í√™~√å¬°`¬®k[UH√ç2√É¬™¬´√æU^
R1¬´√πu
z¬Ø√§√∫+):¬¶√Ü√âl1√®√àX.√ãV3¬∫
;
¬Ø√å¬¢√´√™¬•v+"4
```
(contains C1 control characters, forbidden by HTML5, thus the above can't be copied to clipboard and is for illustration purposes only)  
[Try it online!](https://tio.run/##pVTPa1NBEL6/g8eCl/Ao9CBhFqI9qZSKB4Wih0KlNCBFI7ZV22Jbf/QQQVEaEi@2UFoPotUQUkpPIvbgYeb/8rnzsjszm/Rm3svL7M7sN/N9My/rrzeXimLm4cvGxrPpW69mrjenthuNpTsrN8cvYBe71Fp@Xsf9CfxVubFKByuzddqtVLFHX2p4tIBfF/GEzvCUOtjCb/ge39IBtfEnHY41sYPdu9ino4v0ifpNH9Lh@B62n9TfzN2mj5fpHfbxmP7M3R/LZmu46@3fHqODe1vZtgf97qEPq/j50lXsVugDtZ7WqEc7847a967gWYata1mS@5j6@ONFdXyyKMABf5z/GdyDr1@7@AnOwVZpgd11ALpKPS6cgniVqUDgBtGSTrKEsKHU4RHCAz5IeKDhkoecjX6TAVJcqTg6BEBZGsYqkUSDoA0hhgLUCZF2RLDKG/mMalKqlhmaFnknArikApDyXaRhSlSXSmWppVSkjqRJSnJEf5d0ShUxfCUTCCU7ccPCJ@2T0YPRRp6XEdSCeNLoLcWCs1t2bsHgQPIWjJSp@ml3lLcz9ZipAq0NjGyih3bPmWNxvtNdpQOW4tD7mbxTOoBWSNtEnRgwHM1s/t/rks6y0zl35/4/xUlkT@YgZ0/OS7Zyf5UmsMFrf/t4DsgZJC/tnLc4DQeWjrxE4cNslU7GKw8CR7m/a@uby2urGwVA49GDrcf/AA "Pyth ‚Äì Try It Online")
## Explanation of the code
```
Kcwd
```
The Morse code version of the song has already been read from input implicitly, as `z = input()`.
Read the Morse code look-up table from input. Equivalent to `K = input().split(' ')`.
```
hMjC"¬¶¬¶√âir[%¬∑An√ôjR[√ì+¬®√ü1¬£Z¬°`¬≠√∫¬Ø√å¬¢√ô√ã¬µ√ö~¬¶N¬™√£√í√™~√å¬°`¬®k[UH√ç2√É¬™¬´√æU^
R1¬´√πu
z¬Ø√§√∫+):¬¶√Ü√âl1√®√àX.√ãV3¬∫
;
¬Ø√å¬¢√´√™¬•v+"4
```
Unpack the array that stores the Morse code width (in dots+dashes) of each letter of the song (474 elements), packed in base 4 (with 1 subtracted from each element) in an **119 byte** base 256 encoded string. Luckily there happened to be no characters that needed escaping.
`C"`...`"` - convert the base 256 encoded string into an arbitrary-precision integer  
`j`...`4` - convert the base 4 integer into a list of integers  
`hM` - add 1 to all elements
```
sm@GxK<~>zdd
```
`m` - map each element `d` of the list decoded above through the following lambda:
`~>zd` - `z = z[d:]` - remove the first `d` dots+dashes from the input (`z`), and return the previous value of `z` (let's call it `ê`)
`@GxK< êd` - `string.ascii_lowercase[K.index( ê[:d])]` - alphabetical letter decoded from the first `d` dots+dashes from the input
`s` - join the resulting list of characters into a string
[Answer]
# [Python 3](https://docs.python.org/3/), ~~265~~ ~~261~~ ~~259~~ 255 bytes
Uses the same base-256-in-a-string data-encoding method as [my other Python answer](https://codegolf.stackexchange.com/a/197731/17216), but actually uses the Morse code input. Like many of the other answers, encodes the lengths of the 474 Morse codewords into **119 bytes** using base 4. The Morse stage of the decoding is based on [steviestickman's answer](https://codegolf.stackexchange.com/a/197461/17216), with some further golfing.
Takes the Morse library and representation as two lines from stdin and outputs to stdout:
```
#coding=L1
i=int.from_bytes('√ï¬™¬æ¬∏%(¬¶#?¬™√Ü*\n√¨√â^;R2¬¥√É9;I¬™√Ünj√±¬ø¬™√ö√ëc%&√æ¬¨d√àZ    KU[√æ¬™¬¨8√á2_√û^"¬†¬£#;√ö¬∏vL¬∫¬´¬£+√ôJu√Æ6x%(¬¶#?¬™√∑¬†¬™\¬§√èr¬ÆL~XZ{M√•nX√ñ9¬©¬´'.encode('L1'),'big')
*m,I=input().split()
while i:j=i%4+1;print(end=chr(97+m.index(I[:j])));I=I[j:];i//=4
```
(contains C1 control characters, forbidden by HTML5, thus the above can't be copied to clipboard and is for illustration purposes only)  
[Try it online!](https://tio.run/##pVTNaxNBFD95MIfePIiXYIi72/RNaS3aZlk8r8aLUChNP6DJ2mxoNiFNtUXwoFCtoiLUgD0UoSqYhoIgWDxUePOHxZ3NzsybpDf3Y/J23ufv996ktdepNaPbg0Gu0qyG0aa3OJ8JvTDqsMftZmN9Y68TbNvWBB7wT9jDCzzP2/g9dw97E3x/ciXifX6w5uKLR7P4i7/E7oLrY4/v4/sI39T5T/wbfx1d4R8r@Vv8AvtV/nr56oPFciz3sD/PX81eW@fHa3h8E7/gIZ7kXH6E509K@AdPr@NJgX@@v8PP7uzKpPx3Ytdbwa/8QxvP8G3p@dIydp/h4Y2H/Bu@i5Z4N64Cf@CpxYIoxhTYVmnGcqasjXDTcjKTjSk/htfa6dgO225thfFv5mkt3AqyYbHuhfm5wozbascE2EFU9Sq1tr1wt9BgYVQNdm2/XKyvOo7j@p5frhdX3XB62psbDBhkgTEWLyAWlo3vRAQhiO/4ARBWEAvCUshZscVgaJgoskkU4SykRCniJY4grJIc4mLCL3mGr8gnr1Q53EokoLsMQH@ZGpZ6gbyTVKDCDa1VOpUlNRtJnS6peRoflHkKgxmL8pV6kgHMuKpiqVABNEqCWFOkrEFFG4mYFqCVIGHLCJR5Qh9hTZWqy0ybJnEbBDCjAlDlMwmDlKhVmioKzYSi6jCapEGO8c@MTmlGCF6VCRQkOnGjxBvtU6MH4428LCNoCaQn4VsVC4xu0bkFEgeMUzBWpuZPd0fjZqQeMlWgawNCm@JDd48RNznf5q6GAxTiyPk0zpQeQEokbaKeGCAYyWz@33ExZ5npOWeX/j/JSRSafw "Python 3 ‚Äì Try It Online") (can't use the actual Latin-1 coding header, since TIO only accepts UTF-8)  
[Try it on repl.it](https://repl.it/@Davidebyzero/Rudolph-PPCG-197455-Python-3-split-by-codeword-v1) (demonstrates the actual 255 byte source code file)
*-4 bytes by using the alias* `437` *for* `cp437`  
*-2 bytes by using* `L1` *instead of* `437`  
[Here's a Python program (TIO) to generate the full program with choice of string encoding.](https://tio.run/##dVTBjts2ED1XXzFxUEiKLSWb3XSxXuhSoAUWSHMq2sPCMGhxJHFDcQSSWq1y6j/0D/sjzozWNtpDYZsYcd68efNIeZhjR@76eDT9QD5CmMOmV7G7B3R1ld5c36bwFv5U3hnXbsE0QA6BGkg/X6VlmX6@S8EEGANqUAFih1JImtEb@NV4bOgFJmMtRK9csCoiuEMYIBKEQdUIU4cOahoMM/Bmbc1wIOU1ZD@PLVx/urv@cJ1DYqoP99BXrK9Uvn1@/Lgrw2BNzPKkIQ81GAcen9GzkuyCutrl2@QHAxWYdzewBosu6x/J66zOi7vbXV5cJUGyZaT9YY4YMpm@rNHY18hSm5nNx08/5fkmPZg2zUuNPCBmPGeesAL0yjLFKk3TFbcI/FviBL0n/1toOfmFXUuin0VMA/isbHaqzOFNBWEL/wKnvQncu@5kJuMYNniMbA@NcRhjmuBLjUOEP5Qd8RepE@sXgv/wLGHyVhqeNt9UImQrp1ziC5u3@r3j0zufGGjC4NIIE/mv8M9ff4MMlF0omckE40JUrsbL9gZC9DmgDXhpVO73tVUh7PccOdXjfi@2bBdChl@K8zxPBs9Dsp1aXDQVP5SNp/50HlJxdpkpykUsZulqzdF6leYCWK1Wp9NJ3vWbB@Zgo7L8ckWmzlgEs32qzI8366v7S8uq7nx2d7vuS@M0vmQPj9unHYu6f6geHp@2u3vz/n11w/T58XicafzqaNIqdCzHaS0@SDD4c/RsXkRgj@yRrsfBaMGRc0v2wGq@oTuMUROTeayVtfzO9BRio3oag0fRgZ4azvhRkx06BnjUjvhmn9Od0orv@hw642bJMLlpmHJ5A9RkIscTjVbzhgtqNrG1NAUmpYb5SDjPZPLyRrJqbDsRzZjO9HJogVGzE0qLcSDyJ0FPZPjvQLn5zNCewI5vV0NtO7OrJsReBS4OykVVMyISCzlRsMJOHBDtgQ7etF2cyInsdjQa@zlYlE1ysgp3R9PixGtLS8@oWadaRIaO3w3UvAhxa2Wq//OOW1jbkqaJh@DrH8nPx7KAoixLXgpZSuDPEhYSyDN/i0JQBQeClBhkqyxegUsCFhYplmhJCt9SWAiq/A4 "Python 3 ‚Äì Try It Online")
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal) `s`, 131 bytes
```
¬ª ÄAŒªT‚Äõ‚äç¬Ω‚áß·πó.‚Äπ·∫á·π°N‚Ü≥·∏¢Z¬µ·∫ä‚ÇÉr#‚â§*‚ÇÇ‚á©v«ê‚Ä†‚Å∞‚Çà{‚â¨‚àö¬¨·πñ}‚Üë≈ºP«çƒä·πÅ‚üëZU≈º«ì‚àß‚àû:YŒ≤v‚Ç¥«í‚Ä∫∆àƒñŒ≤‚Ä¢‚Äû‚Ä†G‚Ç¨
‚ÜíC‚â¨‚Åãƒ∞Íúù[‚â†‚Ç¥m‚àëE¬º y¬±‚ãé\‚Ü≤ƒä‚Äûƒ°Q ·πò‚Çç·πòQ‚àµ¬´1}w‚åä√ó+√ó‚á©e‚åä-¬®T‚Å∞…Ωo·π™·∏ä$‚Å∞+‚Ä°‚à™¬ª4œÑ‚Ä∫‚üë;·∫á‚Å∞‚åàyƒø
```
[Try it Online!](https://vyxal.pythonanywhere.com/#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)
Port of 05AB1E.
-1 byte thanks to Deadcode
[Answer]
# [Python 3](https://docs.python.org/3/), ~~381~~ ~~375~~ 372 bytes
Just like [Seb's answer](https://codegolf.stackexchange.com/a/197717/17216) and [ScoopGracie's answer](https://codegolf.stackexchange.com/a/197479/90219), gracefully takes the Morse code representation and any of the three libraries as input, blithely ignores them and gives you the output.
Takes Seb's strategy a step further, encoding the text in base 26 in an integer encoded in base 256 in a string (as opposed to Seb's which encodes in base 32 in base 128 in a string). Both of our solutions are confined by not being able to contain the bytes NUL (0x00) or CR (0x0D), which Python interprets as end-of-file and LF (0x0A), respectively, even when found in a triple-quoted raw string literal. CR+LF is also interpreted as LF. Backslash escape codes are interpreted (unless the raw prefix `r` is used). Backslash followed by any kind of newline is treated as nothing, stripping both the backslash and the newline. And the string can't end in a backslash. (So it's really sort of a slightly-less-than-base-254 masquerading with the help of luck as base 256.)
To work around this problem I had to complicate the encoding a bit. Neither ASCII-97 nor 122-ASCII, nor using base 27 instead of 26 (and optionally adding 1), avoided containing these bytes or sequences, so I settled upon adding 1 to the encoded integer before each multiplication by 26, which luckily costs only 3 bytes (compare `i//=26` to `i=i//26-1`). With significantly larger text, the luck would have to be incredible, or every NUL, CR, and `\` would have to be replaced with `\0`, `\r`, and `\\` respectively. On the other hand, with better luck, newlines might be absent altogether, meaning single-quoting could be used instead of double-quoting.
The `#coding=L1` costs 11 bytes (without this it'd be 361 bytes), but this beats the cost of using base 128 (which would take 319 bytes for the string, whereas base 256 takes **279 bytes**, and thus would cost 40 bytes instead of 11, not counting the different Python code that would be needed to decode it). An alternative coding is [`437`](https://en.wikipedia.org/wiki/Code_page_437), which would cost a further 2 bytes, since the [encoding name](https://docs.python.org/3.7/library/codecs.html#standard-encodings) is used twice. Note that the disadvantage of using `L1` instead of `437` is that ISO 8859-1 doesn't map as cleanly to UTF-8, and there may be difficulty faithfully copying and/or pasting it in some software.
This standalone program, written in the [ISO 8859-1 codepage](https://en.wikipedia.org/wiki/Latin-1_Supplement_(Unicode_block)), ignores the Morse code representation and library taken as command-line parameters, and prints the output to stdout:
```
#coding=L1
i=int.from_bytes(' √Æ√£¬∏√å√í^√´9|i√©√´M√æ¬≥\H0√Ñ√Ø;√ø√í¬∏F√à¬™√é¬©¬´|¬∞M¬ÆQcWtgU√Æ[¬°U*¬§√ü¬∫N¬®√∏A¬°:¬æ√ß¬¢√Ä√£√æ√∫/√¶√≤√™√•√°\I√ïi#vv¬≥√ú¬°\'j√Æ√êt√Ñ√≠6.√±√é√©¬§¬•Y√Æ¬≥d}fLLEX¬µ*√ÆB¬ß √ß^eleW?√ê|¬∂S¬Ø¬±[I√ª√ß√§2√Ω¬•√∞¬∞,√ºT√É¬∑0√®√ÖE√õ√ß√•\LW&uMe√ë@√ª√ç√ø`√ë3C√í√¶%2¬ø¬¨√å√Ø√Ü√ßG√å√ÆX√´[MD√òmI¬•√≠√¢√É¬Ω9t¬±¬§]#√èY√Æ8M¬∑Ck¬≠√≤¬°"J'.encode('L1'),'big')
while i:print(end=chr(i%26+97));i=i//26-1
```
(contains C1 control characters, forbidden by HTML5, thus the above can't be copied to clipboard and is for illustration purposes only)  
[Try it online!](https://tio.run/##DZH7S5NxGMWhyELBclSsRTYa9m5mm04wL4wuZrXYAqmh4bLQvW5v6Sa2DMHQ0tTQdsvJaM2Ybk5dblMpxXKDc/6w9X1@OvBcOOf5jE74PT5vc7msG/S5FK/b4mitVCyK128cGvONvByY8Mtv9ZL2BHNcxyEWucRIP@LMtk0q57jF7JSdRew7EcDio0bOMt8xxRIjKjG8dOEBPnEB2zUMIIyVWkSxhSzmJ6tRsCPXjeXziA72qPxuB3N9SDrqETqFFH/i6Ak2eXgXMUwj2Y4iM9VX1UhgjdNcV7HII3w0IcGNi9w7y22mmcRqrdPKKMKK7sr4OPbxnT8wh2StU3ot3If8wtxOVYuRuwxwCymknzOHfdcHzA7ZbF29@I04gpqT9VjGAnP3kNEyg2C/Wh6We25XMDSJP0@Rr8Gups/Kv6L3hSkzj5FGjAUUqhpU@MZ/zziDg8YKbvJzF@YYZ4Zpp63n@jus2mWGEbkjdr@y9ErNcHMnI9zQ1JlROo1fZ8Rv85zDCjMPhcxhppfZPvt9xkYwf9mKNHe4dkmcP27zYxepFzoGRYRWJOw46HyDHe4hee2xZJS9gqWsl2xNkqFBGlDckqHyvUcZlrVK@@iYYKuXvS7LoGdMr9SZW2603TIYOgRzk8nccrOpLOo/ "Python 3 ‚Äì Try It Online") (can't use the actual coding header, since TIO only accepts UTF-8)  
[Try it on repl.it](https://repl.it/@Davidebyzero/Rudolph-PPCG-197455-Python-3-ignore-input-v1) (demonstrates the actual 372 byte source code file)
*-6 bytes by using* `L1` *instead of* `cp437`  
*-3 bytes by using* `i=i//26-1` *instead of* `i=i//26^4`*, resulting in no newlines, allowing single-quoting*
[Here's a Python program (TIO) to generate the full program with choice of string encoding.](https://tio.run/##dVTNjts2ED7HTzGroqBUe5V43exivXAPBZpTmlPRHurCoMWRxIbiCCRlrXrqO/QN8yLujNd2s4cebAyH33zzzQ/VT6klvzoebddTSBCnuOh0ahdt6twToK826vvVg4Jv4DcdvPXNGmwN5BGoBvVxqcpSfXxUYCMMEQ3oCKlFCSTD6AV8sAFreobROgcpaB@dTgh@H3tIBLHXFcLYooeKessM7Kyc7fekg4H8x6GB1fvH1btVMbObd0@zmgJUYD0EPGDglDlrLnVoDr8v/yjWszcWNpDb@bL47u4e5kDB5FVx@/gwi3xhy0S7/ZQw5lJmWaF1L5ajJreLu/f3RbFQe9uoojTIRWDOtXDuGmJZW29ytfWquNncLpn6P1948XF@ZxMG7ThZppTKWELk38meoYsoEoWsosGnPFNZAT9cjypTUsNXJOwRijJg77hVglio7ZZx7ObD7M2Z9FXi7FUMnxfZdiupRAnrCIHCz7Fh7Cee5SyF6UUWHrTLz0QF3GwgruErsOps5G5VrQzAeob1ARMPjYbUD0nN8LnCPsGv2g34k8TJQpwIXvGcTOnpxXezER1r2b8Sny335ZeWV@qyRmAIo1cJRgqf4cvf/4AUmF8ZmclG62PSnsu9uBcQUyhA@nNNVO52ldMx7nZsed3hbic9WZ8IGX4NLopi1geukedvpKd2w4eyDtSdF0giLj1nivIkVgY0Z2vOAxJAlmXndZqNrXUIdn1l3VRtyO23d/fzx4eieOIEb9/e3d8uOaY4Ho8TDZ89jUbHlnN4Y6Q4MfpwsQ72WbJ2yIWbauitERx5f7rds7q/0O@HZIjJAlbaOX6dHcVU646GGJC3FzFQzTdhMOT6lgEBjSd@WpfrVhvNj22KrfWT3DC5rZny9AT1aBPbIw3OsMNHPdnUOBojk1LNfCScFzL5TCRyemhaEc2Y1nYyicioyQulw9QThbOgP8nyh0f76cLQnMGeV6amppm4jzamTkcOjtonXTEiEQs5U7DCVjog2iPtg23aNJIX2c1gDXZTdChO8vIv3C2Np068pHR0QMM69UlkbHnf0fCfEDdOqvq/3nEK5xoyNHIRvNOJwvQv)
---
If it absolutely has to be a function and not a program, then it's **382 bytes** (not counting the `#coding=L1`):
```
def R(a,b):
    s='';i=int.from_bytes('‚Ä¶'.encode('L1'),'big')
    while i:s+=chr(i%26+97);i=i//26-1
    return s
```
[Try it online!](https://tio.run/##FVL9T1IBFN1qWepmyaqZLWM5e6CEihuljvVhVjZwy3LaICvlKa8UHDxtbjYtDW0aColjkjYURCQQZaWzlO2cP4yev9zd7Z5zdu65d3hMdricDfm8XexXd2je6nq1TUWFHpMgNEsmySnr@92uode9Y7Lo0QjqU0xzAweY4zwDPQgz2TguXWCCyQkLj5G1wYe5J3Wc5k7zBHMMqBTw/KVH@MxZbJfSBz@WKxBEAknMjJcgY0H6GZYuItjXpZIHOpm2ItJZjcUziPInDtuxxYP7CGESkSYcM15yvQyrWOckN1Q85iE@1WKVm5e5d57bjDGCtQpbG4PwS5XXRkeRxQp/wItIhU14p7hflBVzqWKjnrv0MYEoYi@ZRtb@EdP9ZnNrN34jjIXy09VYwizTDxBXM46FnjJxUOy6W8DFcfx5jp1S7JZb2/hXmX1l1MAjxBBiBplinQrf@e8Fp7BfV8AtfmmFl2HGGbOZu26OYM0i0o/APYX7jbk3ZfQ3tDDAzfIqA3Jn8eucku0OvVhm/LHSpjHVzaTV8pChIcxcbUOMKa5fUeSPGmXsIvqqkgvKCnewasF@y3ukuIfIjaeCXnT2ueyiRjDXC1qd0CsNCNqiwg8OaVBUS02eGlOfw62RqgzGmsbb2pNj19YajLfqiwrdojzidqo9@WG38gAa0Wk3dWjaXU5Rd1K02vx/ "Python 3 ‚Äì Try It Online")
If it has to be a lambda, **391 bytes** (not counting the `#coding=L1`):
`lambda a,b,i=int.from_bytes('‚Ä¶'.encode('L1'),'big'):exec("global s;s=''\nwhile i:s+=chr(i%26+97);i=i//26-1")or s` - [Try it online!](https://tio.run/##FVL9T1IBFN1qWZubJatmtojh7IESKm6WMtaHWdnALctpgyw@nvoKwQFZbjQtDW2aCqlzGTYURCQQZaWzhO2cP4xev9zd7Z5zdu7ZGRkLDHk9zaVuk63ktg87XHaVXefQSSbJE9AP@LzDLxxjAdGvEVQnmOUmDjHLOUb6scZ0a1A6xxTT4xYWkLdhHrMPGznFXeM4i4woZPDchfv4yBnsVHIeYawosYwU0pgOViBnQfYxls5j2dmrCAz2MGtFrKcOi6cQ5w8cdWGbh3ewignE2lBgsuJqFaLY4AQ3FSzwCB8aEOXWRe6f5Q4TjGFdaevkMsJSzZXRUeTxjd8RQkxpE17J7hcDsrlMeYuee5xnCnEknjGLvOs9pgbM5o4@/MIaFqpP1mEJM8zeRVLFJBb6q0S32HurjItB/H6C3UrsVVs7@Ue@fWbcwGMksMoccuU6Bb7y71NO4qCxjNv81IEQ15hkwmbuvfYG6xaRYURuy9wvLL6sYri5nRFuVdcaUDyNn2fkbHcZwgqTD@Q1i8k@pq2We1wdxvTlTiSY4cYlWf64NYA9xJ/XcEF@4SaiFhy0v0aG@4ipHwl60eP0ukSNYG4StDrBIQ0K2jbxnejUqAfdXofdrfIb/SZBsHneDkluUSW1@etNziGfRqo1tNS33tAa5QI0NBharjeptV6fyl8a8cmF0Igel6lb0@X1iLr/Q6st/QM "Python 3 ‚Äì Try It Online")
If it has to be a lambda that doesn't modify any globals, **395 bytes** (not counting the `#coding=L1`):
`lambda a,b,l={'i':int.from_bytes('‚Ä¶'.encode('L1'),'big')}:exec("s=''\nwhile i:s+=chr(i%26+97);i=i//26-1",l)or l['s']` - [Try it online!](https://tio.run/##FVL/S5NxGIQiCwTLUWFGayj22XRtOsFyMvpiVsYmZInGpuW2V31rbrItS1K0NDW06ZaKaBrTzanLuTlKsVS4@8PW2y/HA889x93D9Q0Ee3ze6lyzxZHzdPY63Z2aTr1T77F8ELIwy96gocvv633pHAhKAa3QnGKK6zjAFKcZ6cAyk7WD8gVuMTls4zGyDoQw9biSY9ytG@YJIyqFPH3pIT5xEtuFDCGMBTXmsYUkJgYLkLYh9RRzFzHvalUFu1uYsiPaUo7ZM4jxBw6bsMmDe1jECKJmHDNRcL0IK1jjCNdVPOYhPhqxwo3L3DvPbcYZxara0ch5hOXSa/39yGKJ3zGOqNohXivuZ4OKuZ38GgMzDHELMcRfMIWsewhjXVZrQxt@YRkzxafLMYdJpu4joWECMx1FkkdqvZPH2UH8fobdQmSK7Y38o@y@MGbiEeJYZBrpfL0K3/j3OUexX5nHTX5uwDiXmWDcYW298RarNolhRO4qt1958qqI4ep6RrhRXGbCyVn8PKf8dpfjWGDikTKmMNrGpN32gIu9mLjaiDh3uHZFkT@qDSKDWHspZ5QIt7Fiw379G@xwD9GSJ8IgeV0@t6QV1iqh0wun3C10Q2bpveTSlgQsQji873pkj6SRzYEKi6vHr5XLTDUVtbd0dbJFNhpNNTerSvQenc@v8dhFQLTn@vxKH7SS121p1jb5vJL@P@h0uX8 "Python 3 ‚Äì Try It Online")
[Answer]
# Deadfish~, 2496 bytes
```
{{i}}{ii}ic{d}ciiiiiic{d}ciiicic{i}ddc{dd}icdddc{ii}ddc{d}dcdddc{i}iiic{dd}iiic{i}iiic{d}ccdddc{i}iiic{d}dciic{i}iiic{dd}iiic{i}iiic{d}c{i}iiciic{dd}iiic{i}iiic{d}dciic{i}iiic{dd}iiic{i}iiic{d}c{ii}ddc{d}dddc{i}iiiiic{dd}ic{i}dc{d}dc{i}iicddc{d}iic{i}iiiiic{dd}ic{i}iiic{d}cdc{ii}ddcdddddc{d}iiicdddddcdddc{i}iiic{d}cc{i}icdcc{d}ic{i}iiic{dd}iiic{i}iiic{d}cddc{i}cdddc{i}iciiiiiic{dd}dc{i}dc{d}ddc{ii}dcdc{d}ddddddc{i}ic{i}c{d}ciiiiiicdddc{d}dddcddcddc{i}icc{i}ddc{d}ddcdddc{i}ddciiciiiicic{d}ddddcdddddc{i}iiciiciiiiiicddcdc{d}dddciiiiciiiiic{d}cicc{i}iiicdddc{d}icdddddc{i}icciiiiiiciiic{dd}iiic{i}icdddciiiic{d}iic{i}iic{d}ddcdddc{i}iiic{d}dddcdc{i}ciciiiic{d}ddddcdc{i}iiiic{d}dddciiiiciiiiic{d}cicc{i}iiic{d}c{d}iiiciiicdddc{ii}ic{dd}iiic{i}iiic{i}dddcddddddc{d}dciciiiiic{i}ic{d}dciciiiic{d}ddddcddddc{i}iiic{d}ciiiiicdddc{ii}dc{d}ciiiiiic{d}ddddddc{ii}dddc{dd}iiic{i}iiicic{dd}iic{ii}iic{d}ddddc{i}iciiiiic{d}ciiiiiiciic{d}iiciiiiiic{d}ic{d}iicic{ii}dddc{dd}iiic{i}dciiiiic{dd}iic{ii}iiiic{d}ddddddc{i}ic{d}dddciiiiiciiic{i}ddcddddc{dd}iic{i}icciiic{d}ic{i}iiiic{d}ddcdddc{i}ciiiiic{d}ddcdddc{i}iiicc{d}dddciiiiciiiiic{d}cicc{i}iiiciiicddc{d}ddddcdc{i}iiiiiicdddddcdddc{d}dc{ii}c{d}ddddcic{d}iiic{i}iiic{d}cdcddc{i}iccddddciciiiicic{d}dddc{i}iic{d}iic{i}iiiicic{d}ddcdddc{ii}c{d}dc{d}ic{ii}dddc{dd}iiic{i}iiicddddddc{d}iiic{i}iiiiicddddcdcciiicciiic{dd}iiic{i}icdddciiiic{d}iiciiciiiiicddddddciiiiicdddddciiiiic{d}dddc{i}iiic{i}ic{d}iiic{d}dddciiiiciiiiic{d}cicc{i}iiic{d}dcddddddc{i}iic{d}iic{i}iiiicic{d}ddcdddc{i}dcicdc{d}icic{i}dc{d}iicc{ii}ddc{dd}ddciiiiic{i}c{d}ic{i}cic{d}iiic{d}ddc{ii}ddc{d}ddddc{ii}dddc{dd}iiic{i}iiiic{dd}iic{i}iiiciiiiiic{dd}iciicddc{i}iic{d}iic{i}iiiiicdddddciiiic{dd}iic{ii}iiiic{d}iiiciiic{dd}iiic{i}icdddciiiic{d}iic{i}iiiiic{d}ddddc{i}ic{d}ddc{ii}dddc{d}ciiiiiicdddcddddciciiiic{d}ddddc{i}iiiicddddc{d}dddc{i}iiiiiic{d}icddcic{i}iiciiic{d}iicdciiiiiiciiiiic{d}ciiiiiic{d}ddddc{i}iiiic{d}ddcdddddcic{i}ddc{i}iicddddddc{d}iiic{d}iiiciiiicddcic{i}iicdddddcdcdddddcddcic{i}iicc{d}ddcdddc{i}dcddddddc{i}dddc{i}ddcdddc{d}ddcdddc{i}iiic{d}dddciiiiciiiiic{d}cicc{i}iiicddddddciiic{i}dddc{dd}iiicdciiiiciciiiic{d}ddc{ii}ddcic{d}ddcdddc{ii}cddddddc{d}dc{i}dddciiiiiicdc{d}dddddcdc{i}iciiiiiicdciiic{d}ddddc{i}ic{d}ddcdciiiiic{d}iiicc{i}iiiciiic{dd}iiic{i}icdddciiiic{d}iic{i}iic{d}ddcdddc{i}iiic{d}dddcdc{i}ciciiiic{d}ddddcdc{i}iiiic{d}dddciiiiciiiiic{d}cicc{i}iiic{i}dddc{d}ciiiiiic{d}iccdddddc{i}ddc{d}dc{i}ic{i}ddc{d}icdddddciiiiicddddddcic{i}cicdddddciiic{i}dddc
```
Uses an alternative interpreter. [But in the ordinary one](https://tio.run/#deadfish-), you can give it input. It's not going to do anything though.
[Try it online!](https://tio.run/##xVdLb@M2EL7rV3BPkhonsFtsgQbrvTRbdIGiuRRogTQwFJKOBlFEQ5IfC0O/PeX7Jcl2Ll0hSCjOg9/MfDNUNt@6ktU/vb3B64Y1HWq/tUmCq6Jt0R0tyBra8kvTsCb7csB00wGr89sE8YfQNVqtoIZutcpaWq1n6JW2bfFMtYJ4Ng3UXWb27TY/5IYeoMsWeZJs0BL9yWqawBql15sUQS0ViuZ5pzwJDbPzYBY3UBN6yIRFfrV4TJLdinG934qqpXzd8fVfzVZ73Y14VfopC0RD9zvlXlkIr2l3mUWC5QESBF4dLDYJCI8AwpcBwg6QcpseLrNI9itqUey9bO1X9966CZHuR5AqRyk9c@7eId1fFltgIUCl9@@xENDT5jKLBL@SlusfU0hvUZrOUErMojULZhbYLEqz2JtFZha5WRzNopeLXiSSc0fljq95oV2LCBgPHMMjuuLgIY0ERAtILGi1oI0FTAtYLMBagGNBqQVlLNhrwT4WZFqQxYJcC/JYcNSCYyzotaBPXXoOU@k5vDs9L1Pp@fXd6bmbSs/LVHoOU@m5m0rPP1Pp4Ra0kjxi34dH/1theP4TcbnQA8XbjmYFxjN@kbDnGYLlfIYavt20/CJayimlb5unpsAvtBMdPVfToISKIkCfUEXrTNh79xIuuZ7YewA@CcyuCLEUw8PG5izEw5EIhAu7KSvim5Axk@uTJu2YyQ9L8WfaaB8bqYs2/Z1WFZuhv1lTkQ98AtGaLNM0n3aUxY64XABY8jSGAikMwzfPyVT7T5D2MYUIXR6j85@nhhYv417GYXLngD4vz4Ec@qWcZkNdy7jTlDjGMaxZg1ZC3hT1M804o38ZQSKLMNoD6AotZvKzIn@Yh2lsu6Kj582S4UHSMnYHVrB4DAN8YqzKTAJyVNTkdN1sroa9YNt54KWPvTS02zY1epBhweN0zsuJ9vi3/oPVz6iCHUVdSZH4uv2Qhvmw36bzqG3E54WGuJSfGbcjeZyHNjXrUOYjE0OO19/f4vdOPuhB/oU15ERTQEujz3Ie09d6V1QggBU8zR1t0LFHRYfkBw9fpzeccq9Fx4HwtOX5Bdy2@fJmiD8mMz0jrhciGv3y48efc/GaiU83kSmp9QnNjc5nrvIxHwuWXRzs/Y4264rtRYAiYBFr9lVHmotjtq/bquiY@BaMY58J@UUJMNWcuhvYOMMkM88OXTxujMtGOMiHHryBFvdAkhioUIv/k/jvbZflycj84CIxMd7ejkfo@yNAD/hIegzyMUvMV9ATwt8JVyBiBXqjJ/q9VwZE/TWvPQ7FXN0XD7TlEo/KzlpaRPZAoynhKx/qAKVoHfh6xp@NkRBi1EG/hCFhueYGUukERGVlrV2WNTCNXh2MTSxWXdh6xSEuWvUjlWyleoeTyNSBrqRyip1jMFKVGOtVGTgiYBOLyYfnAxsHcejYevISHsIz9VVngzgJ3J7e9HamgUkeqLMtTs3psBjQ2xRoXliHugXIAEVUdK8IoEvntY2tmzopOt8AUujcGY4VvjubO@fe7oydQLBHaXNGBKsPkqnLZunuTHVlfWZH1cMw3BMbZ4sFtg/DKoddplpDMV/ugqlw0KuWhlonILsjnet4HELWB5g4R6tGgklgJ4dGL@M5S3@bC@3Mj9cnj8dUF/B59jtOn41YMlwH7AakLBzYYe9QqQSB7k8fUTh5pzgPPqcgmH0yK@OY/dSM8fniiQNxl/nQSTxWfRL5Vrbc0S0DZhxisBPVHE@8yQgwMiaGbWX8EHddBcyzcQdH6qaxzWMFcdkdRdz9QOI74xLCOQ5bZ7oOxshLoaHJoO/8KazdmFLYkYXDG5PgiXp6TaRmEPTf/1IaUEySBXtVcJ8m7j2cCsSjBfZExvt/ "Python 3 ‚Äì Try It Online")
]