[Question]
  [
Whilst trying (and failing) have persuade my infant son to eat his dinner, I tried singing to him. Mid way through this song I realised the formulaic structure might lend itself well to code golfing!
The task is to write a program or function which accepts no input and produces the following text:
```
There's a hole in the bottom of the sea
There's a hole in the bottom of the sea
There's a hole, there's a hole
There's a hole in the bottom of the sea
There's a log in the hole in the bottom of the sea
There's a log in the hole in the bottom of the sea
There's a hole, there's a hole
There's a hole in the bottom of the sea
There's a bump on the log in the hole in the bottom of the sea
There's a bump on the log in the hole in the bottom of the sea
There's a hole, there's a hole
There's a hole in the bottom of the sea
There's a frog on the bump on the log in the hole in the bottom of the sea
There's a frog on the bump on the log in the hole in the bottom of the sea
There's a hole, there's a hole
There's a hole in the bottom of the sea
There's a wart on the frog on the bump on the log in the hole in the bottom of the sea
There's a wart on the frog on the bump on the log in the hole in the bottom of the sea
There's a hole, there's a hole
There's a hole in the bottom of the sea
There's a hair on the wart on the frog on the bump on the log in the hole in the bottom of the sea
There's a hair on the wart on the frog on the bump on the log in the hole in the bottom of the sea
There's a hole, there's a hole
There's a hole in the bottom of the sea
There's a fly on the hair on the wart on the frog on the bump on the log in the hole in the bottom of the sea
There's a fly on the hair on the wart on the frog on the bump on the log in the hole in the bottom of the sea
There's a hole, there's a hole
There's a hole in the bottom of the sea
There's a flea on the fly on the hair on the wart on the frog on the bump on the log in the hole in the bottom of the sea
There's a flea on the fly on the hair on the wart on the frog on the bump on the log in the hole in the bottom of the sea
There's a hole, there's a hole
There's a hole in the bottom of the sea
There's a smile on the flea on the fly on the hair on the wart on the frog on the bump on the log in the hole in the bottom of the sea
There's a smile on the flea on the fly on the hair on the wart on the frog on the bump on the log in the hole in the bottom of the sea
There's a hole, there's a hole
There's a hole in the bottom of the sea
```
Challenge rules:
* The text may be printed or returned as function output
* Each verse is separated by a single empty line
* Trailing whitespace is OK as long as it does not change the layout (so no leading whitespace or extra spaces between words)
* Trailing newlines are OK too.
* No leading newlines.
* All languages welcomed, and this is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the shortest answer in bytes for each language wins!
  
[Answer]
# [SOGL](https://github.com/dzaima/SOGLOnline), ~~103~~ ~~94~~ 93 [bytes](https://github.com/dzaima/SOGL/blob/master/chartable.md)
```
Ψ ~Δ№Q‘η¦»vζh‛←&M⁶╥7[P≈╔6≡⁸(φΔ\⅔Σ‚>≡ā⁷⁽○¹‘Ξ⁵K4s³‘⁽Bθ2n{@∑" the ”+Κ:bΚē‽:C}TPb"n@²‘+Tō, upcPøP
```
[Try it here!](https://dzaima.github.io/SOGLOnline/?code=JXUwM0E4JTIwJTdFJXUwMzk0JXUyMTE2USV1MjAxOCV1MDNCNyVBNiVCQnYldTAzQjZoJXUyMDFCJXUyMTkwJTI2TSV1MjA3NiV1MjU2NTclNUJQJXUyMjQ4JXUyNTU0NiV1MjI2MSV1MjA3OCUyOCV1MDNDNiV1MDM5NCU1QyV1MjE1NCV1MDNBMyV1MjAxQSUzRSV1MjI2MSV1MDEwMSV1MjA3NyV1MjA3RCV1MjVDQiVCOSV1MjAxOCV1MDM5RSV1MjA3NUs0cyVCMyV1MjAxOCV1MjA3REIldTAzQjgybiU3QkAldTIyMTElMjIlMjB0aGUlMjAldTIwMUQrJXUwMzlBJTNBYiV1MDM5QSV1MDExMyV1MjAzRCUzQUMlN0RUUGIlMjJuQCVCMiV1MjAxOCtUJXUwMTREJTJDJTIwdXBjUCVGOFA_,v=0.12)
```
...‘                 push "bottom of the sea" - kept for the loop, here for 
    ...‘             push "hole in log in bump on frog on wart on hair on fly on flea on smile on"
        ...‘         push "there's a "
            ⁽        uppercase the 1st letter of that
             B       save "There's a " in B
              θ      split the long data string on spaces
               2n    split in arrays of length 2
{                     for each of those:
 @∑                   join the current array with spaces - e.g. "hole in"
   " the ”+           append " the " to it
           Κ          prepend that to "bottom of the sea" (or whatever it is now)
            :         create a copy
             bΚ       prepend B to it - finishes current line
               ē‽:C}  if (E++), save a copy of that in C (for the last line)
TP                   print the current line twice
  b"...‘+            B + "hole" - "There's a hole"
         T           output that, keeping item
          ō,         output ", "
             up      print the kept item lowercased
               cP    print the contents of C
                 øP  print an empty line
```
[Answer]
# [Stax](https://github.com/tomtheisen/stax), ~~90~~ ~~87~~ 75 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax)
```
¥▌▼h4█☻■Ω1gçΔ¶Zjµ│☺X▄)/╞▄╒)¥jêLqα╧ñu┌⌂½╧ûⁿ↕O◘╔╪kl<æàbπïfuσ♪╫qΓ╪ûQ├╘Te♥Æó♣ƒE
```
[Run and debug it](https://staxlang.xyz/#p=9ddd1f6834db02feea316787ff145a6ae6b30158dc292fc6dcd5299d6a884c71e0cfa475da7fabcf96fc124f08c9d86b6c3c918562e38b6675e50dd771e2d89651c3d454650392a2059f45&i=&a=1)
Unpacked, ungolfed, and commented it looks like this.
```
`;$w]i"50h1&V~OP>F$`            compressed literal for "There's a hole in the bottom of the sea"
X                               store in register X without popping
zG                              push an empty string and jump to the target (trailing }) 
`hfUiVx}.|j~vG12])Bxk?v zF`j    split "log bump frog wart hair fly flea smile" into array of words
F                               for each word, execute the following
  i. o. i?                      (i ? " o" : " i") where i is the 0-based iteration index
  +                             concatenate to the word
  `_o9!`+                       concatenate "n the "
  G                             jump to target below, resume next foreach iteration when finished
}                               this is the target of `G`, execution resumes when finished
  As|@                          insert substring at position 10
  QQ                            peek and print with newlines twice
  x14(                          trim string to leftmost 14 characters
  q                             peek and print without newlines
  ., p                          print ", " without newline
  vP                            lowercase 14 characters and print with newline
  xP                            push value of register X, then print with newline
  zP                            print blank line
```
[Run this one](https://staxlang.xyz/#c=%09%60%3B%24w]i%2250h1%26V%7EOP%3EF%24%60++++++++%09compressed+literal+for+%22There%27s+a+hole+in+the+bottom+of+the+sea%22%0A%09X+++++++++++++++++++++++++++%09store+in+register+X+without+popping%0A%09zG++++++++++++++++++++++++++%09push+an+empty+string+and+jump+to+the+target+%28trailing+%7D%29+%0A%09%60hfUiVx%7D.%7Cj%7EvG12]%29Bxk%3Fv+zF%60j%09split+%22log+bump+frog+wart+hair+fly+flea+smile%22+into+array+of+words%0A%09F+++++++++++++++++++++++++++%09for+each+word,+execute+the+following%0A%09++i.+o.+i%3F++++++++++++++++++%09%28i+%3F+%22+o%22+%3A+%22+i%22%29+where+i+is+the+0-based+iteration+index%0A%09++%2B+++++++++++++++++++++++++%09concatenate+to+the+word%0A%09++%60_o9%21%60%2B+++++++++++++++++++%09concatenate+%22n+the+%22%0A%09++G+++++++++++++++++++++++++%09jump+to+target+below,+resume+next+foreach+iteration+when+finished%0A%09%7D+++++++++++++++++++++++++++%09this+is+the+target+of+%60G%60,+execution+resumes+when+finished%0A%09++As%7C%40++++++++++++++++++++++%09insert+substring+at+position+10%0A%09++QQ++++++++++++++++++++++++%09peek+and+print+with+newlines+twice%0A%09++x14%28++++++++++++++++++++++%09trim+string+to+leftmost+14+characters%0A%09++q+++++++++++++++++++++++++%09peek+and+print+without+newlines%0A%09++.,+p++++++++++++++++++++++%09print+%22,+%22+without+newline%0A%09++vP++++++++++++++++++++++++%09lowercase+14+characters+and+print+with+newline%0A%09++xP++++++++++++++++++++++++%09push+value+of+register+X,+then+print+with+newline%0A%09++zP++++++++++++++++++++++++%09print+blank+line&i=&a=1)
[Answer]
# Perl 5, ~~158~~ 154 bytes
```
$_="There's a bottom of the sea
";for$,(<{{hole,log}" i",{bump,frog,wart,hair,fly,flea,smile}" o"}>){s/a/a $,n the/;say$_.$_.($t||=s/.{14}/$&, \l$&
$&/r)}
```
[154 bytes](https://tio.run/##FYzRCoMgFEDf@woRaQV3uWA9tfYHe9vjIAw0A@uGOkaYvz7X4Jy3w1mlNU1KrO/oU0srT44IMqD3OBNUxGtJnBQZbRVaBsUtBI1GgsExUjJRCMN7XkFZHOEjrActJgvKbIdSgJsnI48QabyXwXHBBWGw/Le8dWJjfXVQML/vneNVqK@RsxzIy7A8Yzm3ZUzpi6ufcHHp/GiqS/0D)
[158 bytes](https://tio.run/##HY1BCsIwEEX3nmIYQlUYGwt2VesN3LkUSgpJG0g7JYlIKb26scrnLd7i8SftXZmSaGp89NrrfQAFPTsNdoTYa2g5Rh6Azd@CVjusRKyDzJfiskqRETydyHYik74y7IU9oONuy5GuS/saJjKeO3orH6lX1pNx84ZWFAbrNK0IPOLtuAQ1o2i2RayCVFKBsL9Tuab04SlaHkM63cv8XHwB)
[Answer]
# [Python 2](https://docs.python.org/2/), ~~202~~ ~~190~~ ~~187~~ ~~185~~ ~~183~~ ~~182~~ 181 bytes
```
s="bottom of the sea\n"
a="There's a "
for w in'hole log bump frog wart hair fly flea smile'.split():s=w+" %sn the "%'io'['g'in s]+s;print(a+s)*2+a+"hole, t%shole\n"%a[1:]+a+s[-30:]
```
[Try it online!](https://tio.run/##HY7LCsMgEEX3@YpBEJPalj52KfmL7tIsJqBRMCqOJeTrreniwoG7OCfu2QT/KIUGNoecwwpBQzYKSOHHswYH9jYqKUGAwBodEmxgvTDBKXBhgfm7RtCp0oYpg0GbQLu9TiHQap0SV4rO5rbradgkA07@b2Bc2CBGsQjrgSZJr5iszy1K6k4PiZIdkjNkTgfUGo7jvZ/qQ@PleeunUn4 "Python 2 – Try It Online")
Old alternatives to `'io'['g'in s]` (13 bytes): 
* 14: `'oi'[s[5]<'n']`
* 15: `'io'[len(s)>30]`, `'ioo'[len(s)%3]`, `'ooi'[len(s)%4]`, and `'io'[w[1]=='o']`
---
Saved:
* -1 byte, thanks to Jonathan Allan
* -1 byte, thanks to Rod
* -1 byte, thanks to Erik the Outgolfer
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~261~~ ~~246~~ 236 bytes
```
#define X" on the "
char*a="smile"X"flea"X"fly"X"hair"X"wart"X"frog"X"bump"X"log in the hole in the bottom of the sea\n";f(i){for(i=0;i<9;)printf("T%s%sT%1$s%2$sT%1$shole, t%1$shole\nT%1$s%3$s\n","here's a ",a+"_TH<0$\31\r"[i++],a+95);}
```
-15 bytes, Thanks to Daniel Schepler  
-10 bytes, Thanks to ceilingcat
[Try it online!](https://tio.run/##NY3BasMwEETv/QqxtalcO5A09BCc3PsBPgTqUjbKylqQpSCphFL663XlmFz2zczCjFoNSk3T45k0OxJHEN6JZEjAgzIYnvEAcWRLcARtCW/4ztcgh4wrhjRnwQ8Zp6/xkmH9IHhpMd7SXZ98Sn4UXt9cJOwdtFpy9aN9kHxYt7zftdUlsEtaQlfGMnblpojlS7GIua0R6S57t7y3RcxVDRgK9BQFCmiwhs/ubb8u@u2mD/DOdf2Rw91r1f5OI7KTeVXO5k9pi0OcVtd/ "C (gcc) – Try It Online")
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~103~~ ~~100~~ ~~99~~ ~~97~~ ~~96~~ ~~93~~ 92 bytes
Saved a byte thanks to *Kevin Cruijssen*
```
“¥ÊˆŽ bumpÑå‡îtíÁ¤†îÌea¹²“#v’T€Î's a ’s„oiN2‹èy“ÿ ÿn€€ ÿ“©“—è€‚€€í™“JDN_iDU}X14£Dl‚„, ýXõ»,®
```
[Try it online!](https://tio.run/##yy9OTMpM/f//UcOcQ0sPd51uO7pXIak0t@DwxMNLHzUsPLyu5PDaw42HljxqWHB43eGe1MRDOw9tAipWLnvUMDPkUdOaw33qxQqJCkBe8aOGefmZfkaPGnYeXlEJVHN4v8Lh/XlANUAEZIGsWAkkHjVMObwCJNowCyJ3eO2jlkVACS8Xv/hMl9DaCEOTQ4tdckDyDfN0FA7vjTi89dBunUPr/v8HAA "05AB1E – Try It Online")
**Explanation**
`“¥ÊˆŽ bumpÑå‡îtíÁ¤†îÌea¹²“#v` starts a loop over the list `["hole", "log", "bump", "frog", "wart", "hair", "fly", "flea", "smile"]`. The words are compressed using the 05AB1E dictionary.
On each we do:
```
’T€Î's a ’    # push the string "There's a "
s             # move the string from the previous iteration to the top of the stack
              # will be an empty string the first iteration since there is no input
„oiN2‹è       # push "i" for the first 2 iterations and "o" otherwise
y             # push the current word
“ÿ ÿn€€ ÿ“    # use interpolacing to create the meat of the current iteration string
              # meaning "hole in the ", "log in the hole in the " and so on
©             # store a copy in the register for the next iteration
“—è€‚€€í™“    # push the string "bottom of the sea"
JD            # join the whole line together and duplicate it
N_iDU}        # if this is the first iteration, store a copy of the line in X
X14£          # push the first 14 chars of X, which is "There's a hole"
Dl            # make a lower-case copy
‚„, ý         # join the original with the lowercase copy on ", ", forming line 3
X             # push X which is line 4
õ             # push and empty string, to create the line break between sections
»,            # join the whole section on newlines and print
®             # push the register for the next iteration
```
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), ~~194~~ ~~188~~ ~~185~~ ~~180~~ 174 bytes
```
$z=$a="in the bottom of the sea"
$b="here's a"
$h="$b hole"
echo hole log bump frog wart hair fly flea smile|%{,"T$b $_ $a"*2
$a='oi'[!$j++]+"n the $_ $a"
"T$h, t$h
T$h $z
"}
```
[Try it online!](https://tio.run/##JY7BCsIwDIbvfYoYIgO3k/e9hTcRaSUzlc5IWxlOffZat0Pg@/j/kDx04piEQyiF5p5sj/4OWRic5qwj6LBYYouGXI/CkZsEf5MeyYFoYDR8EV0Qgl7BPccHDLHSZGMGsT7CEF512EIafeDP9t3hoa7TGcjibm/q6UZ9c9zQrW1PLa5frLGpVekgk5gKQLPBbyk/ "PowerShell – Try It Online")
~~Can't quite seem to catch Python...~~
Basically, sets a few common strings to `$h`, `$a`, `$z`, and `$b`, then goes through a loop through each of the items (`hole`, `log`, ... `flea`, `smile`), each iteration outputting the appropriate verse. There's a little bit of logic with `!$j++` in the middle to account for the `in`/`on` switch that happens. Otherwise, all the strings are just left on the pipeline, and the default `Write-Output` gives us newlines for free.
*-6 bytes thanks to Arnauld.*  
*-3 bytes thanks to mazzy.*  
*-5 bytes thanks to Veskah.*  
*-6 bytes thanks to mazzy.*
[Answer]
# JavaScript (ES6), ~~201 194 189 188~~ 187 bytes
*Saved 1 byte thanks to @Shaggy*
```
_=>`14log4bump5frog5wart5hair5fly5flea5smile5`.replace(/.+?\d/g,w=>`T0${(p=w+3+p)+p}1, t01
T01432
`.replace(/\d/g,n=>`here's a |hole|bottom of the sea
|n the | i| o`.split`|`[n]),p=`2T0`)
```
[Try it online!](https://tio.run/##Tc69bsMgGIXh3VfBEKlGdv2TmNHtTXhLo0CcD5sI8yEgtaqSa3dQpgxHepdHOjfxK/zolA2fBq@wyX4791@87TRO3eW@WCYdTmwVLrBZKMek/ksDwfyiNDBeObBajJDXVfH9c62nck1@aHb/ue3X4lBYWthHW5LQtNnQtN1hn72hlzBJzODgwxNB4owa4gVDwIWgJGEG4kFk0bwyEhUJ8spbrQKP/GhOtLQ93w8Np9uIxidepfe5zCndng "JavaScript (Node.js) – Try It Online")
---
# JavaScript (ES6), 235 bytes
Simply [RegPack'ed](https://siorki.github.io/regPack.html).
```
_=>[..."Z[]^_$cdjkqvxz{}~"].reduce((p,c)=>(l=p.split(c)).join(l.pop()),`Tj{{}qq}$$}~~}dd}__}xx}cc}[[v~ frogz$}v
Z{kZz on^x flyz_v], tj]Zkq log in^{k] in^ bottom of^ seajhere's ad wartz~c fleazx$ bumpzq_ hairzd^ the] hole[ smilezcZ
Tj`)
```
[Try it online!](https://tio.run/##FY5RjoMgFEX/u4qXxmQw6bADu4p@aZBSwAqiIFDHweDWHefrJic5OVezhQXulYvfkxXy6KqDVvcGY3ytG9LSggs9zMuatrxfCfZSfLhEyN14Wd2RqRwOzqiIeFlibdWEDHbWobK8PR962/I856LI@56FyJTmdc2c56ZZdui8faciL5d6G@oEdmpX6Mxvogu5QdSkHmYw9g1qareB/A@8bIx2BNu1ECTTvfTyKwAT8MN8TDs/fcnSWsDrM7o0U@iZ8km0EHtJoLdGNhBGZWTi9eWhn@XB7RROjM8Q6s7Xxx8 "JavaScript (Node.js) – Try It Online")
[Answer]
# Bash, ~~168~~ 160 bytes
```
r="There's a bottom of the sea
";for i in {hole,log}\ in {bump,frog,wart,hair,fly,flea,smile}\ on;{
r=${r/a/a $i the};t=${r:0:14};echo "$r$r${u=$t, ${t,}
$r}";}
```
[160 bytes](https://tio.run/##HYyxCsMwDET3fIUwhi6CtNApJn/RsYtSlNjgREV2KMX4292kHDe843ETJd@ajubhWfmSgGCSnGUFmSF7hsTUGTeLQoCwQfESGaMs9fnHaV/fOKss@CHN6CkozvF7lAnTGiIfomyudDraoj31BDacz9Xlcxmuw@1eHb@8gLF6pOyjzQi2ZKyd1Wpcbe0H)
[168 bytes](https://tio.run/##HY3BCsMgEETv@YpFhF4W0kJPkfxFj7lsikbBZMtqKUX8dhvLMMzMYXgrJd@azOrhrdhLAgLP0UI4IHsLK@fMO7D7r2RpUCbPush0nW73enalM4IuGeugRRnHAqG/I29Lz7K@9xc64Q0/JBk9BUEXv6ctYdpDtFgX4MMUsE/PoLScyspI54w0EujQ8dXU1n4)
Translated from my other answer in Perl.
[Answer]
# Japt `-Rx`, ~~126~~ ~~116~~ ~~113~~ ~~112~~ ~~111~~ ~~109~~ 107 bytes
It turns out that golfing a string compression challenge while on your phone down the boozer is incredibly difficult - who'd've thunk?!
```
`T's»dâ ÈÞ­omºfdÈ a`rdS
tE8
¯E
`logn¿mpnfgnØnirnf§nf¤Úè`qÍË2ÆiAV¯E©8 iF¯E ÔqVri'oÃpW+v iSi,)UPÃc
```
[Test it](https://ethproductions.github.io/japt/?v=1.4.6&code=YFSUnCdzu2TinIIgyALerW9tumZkyAKgYWByZFMKdEU4Cq9FCmBsb2duv21wbmaeZ27YHm6VaXJuZqduZqSG2uibYHHNyzLGaUFWr0WpOCBpRq9FINRxVnJpJ2/DcFcrdiBpU2ksKVVQw2M=&input=LVJ4)
```
                                              :The first 3 lines get assigned to variables U, V & W, respectively
`...`                                         :The compressed string "There'sdadholedindthedbottomdofdthedsea"
     rdS                                      :Replace all "d"s with spaces
tE8                                           :Substring of U from 0-based index 14 (E), of length 8 (="  in the ")
¯E                                            :Slice U to index 14 (="There's a hole")
`...`                                         :The compressed string "lognbumpnfrognwartnhairnflynfleasmilent"
     qÍ                                       :Split on "n" (note that the last element is irrelevant)
       Ë                                      :Map each element at 0-based index E in array F
        2Æ                                    :  Map the range [0,2)
          iA                                  :    Insert the following in U at index 10
            V¯                                :      V sliced to index
              E©8                             :        Logical AND of E and 8 (=0 on first iteration, 8 on all others)
                  i                           :      Prepend
                   F¯E                        :        Slice F to index E
                       Ô                      :        Reverse
                        q                     :        Join with
                         Vri'o                :          Replace "i" with "o" in V
                              Ã               :  End map
                               p              :  Push
                                W+            :    W appended with
                                  v           :      W lowercased
                                    iSi,      :      Prepended with a space prepended with a comma
                                        )     :    End append
                                         UP   :    U and an empty string
                                           Ã  :End map
                                            c :Flatten
                                              :Implicitly join with newlines, trim & output
```
[Answer]
# XML, 719 673 603 514 493 486 bytes
```
<!DOCTYPE a[<!ENTITY T "There's a"><!ENTITY O " on the"><!ENTITY a " hole in the bottom of the sea
"><!ENTITY b " log in the&a;"><!ENTITY c " bump&O;&b;"><!ENTITY d " frog&O;&c;"><!ENTITY e " wart&O;&d;"><!ENTITY f " hair&O;&e;"><!ENTITY g " fly&O;&f;"><!ENTITY i " flea&O;&g;"><!ENTITY z "&T; hole, there's a hole
&T;&a;
">]><a>&T;&a;&T;&a;&z;&T;&b;&T;&b;&z;&T;&c;&T;&c;&z;&T;&d;&T;&d;&z;&T;&e;&T;&e;&z;&T;&f;&T;&f;&z;&T;&g;&T;&g;&z;&T;&i;&T;&i;&z;&T; smile&O;&i;&T; smile&O;&i;&z;</a>
```
You can "execute" it with `xmlstarlet sel -t -m '//a' -v . -n <xml_file_here>`.
This would be a lot easier if XML wasn't so verbose, but on the bright side, this is less than 25% the size of the original text.
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), 150 bytes
```
THsmile oNflea oNfly oNhair oNwart oNfrog oNbump oNlog iNE
N
$&$'¶TH
O^$`
.+
$&¶$&¶THW, tHW¶THE¶
H
here's a 
E
W iNbottom of the sea
W
hole
N
n the 
```
[Try it online!](https://tio.run/##HYwxCsMwDEV3nUJDaIaW3sLgyV0C3kodUGqDHRdHofRiPoAv5ioZ9J/04KsQh9X1DpPeUoiE2SyR3ImfpHehCL6u8OFKfgvmPX0EUY5gFBgYLsPY6qTh8RxeAPermFaPmbS9IWt7bKpV0OCp0LihQ1BgpT9n5pwwL8iecCMHFnyOJG/XU/X@Bw "Retina 0.8.2 – Try It Online") Explanation:
```
THsmile oNflea oNfly oNhair oNwart oNfrog oNbump oNlog iNE
```
Insert the last verse.
```
N
$&$'¶TH
```
Compute all the verses.
```
O^$`
```
Put the verses in the correct order.
```
.+
$&¶$&¶THW, tHW¶THE¶
```
Complete each verse and add the chorus.
```
H
here's a 
E
W iNbottom of the sea
W
hole
N
n the 
```
Expand some placeholders.
[Answer]
# [R](https://www.r-project.org/), ~~237~~ 231 bytes
```
i=" in the "
for(j in 0:8)cat(f<-c(t<-"There's a ",paste(c("log","bump","frog","wart","hair","fly","flea","smile")[j:0],collapse=" on the "),if(j)i,h<-"hole",i,b<-"bottom of the sea
"),f,t,h,", there's a ",h,"
",t,h,i,b,"
",sep="")
```
[Try it online!](https://tio.run/##PU7NCsMgDL73KSSXKaTQ4yjdW@w2drASp8VOUcfY07tUxi75fvKFL7k1fwHhn6I6EjDYmOV2yGk@K6OrtMtoZF1GuDrKdCpCC8CkSyVpJIT4AIT1tScGm7t661wZnPb5MMOnT9IMZfeBQN22ebqjiSHoVIjr469eobdyUx4dF7rIWfS4Ml9jrXEX0fZcIT1w1mJFh4CH93@NjQH6gi87L5QuAKq1Lw "R – Try It Online")
[Answer]
# PHP, ~~180~~ 178 bytes
```
foreach([hole,log,bump,frog,wart,hair,fly,flea,smile]as$w)echo$a=T.($b="here's a ").($s="$w ".io[++$i>2]."n the $s").$c="bottom of the sea
",$a,T,$b.=hole,", t$b
T$b in the $c
";
```
Run with `-nr` or [try it online](http://sandbox.onlinephpfunctions.com/code/289511f887b3999e748699801746630ffa9bb33d).
Yields warnings in PHP 7.2; to fix, put quotes around  
the array elements, `io`, `hole` and the two standalone `T`.
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~334~~ ~~328~~ ~~307~~ 299 bytes
```
char*s="here's a \0smile on the flea on the fly on the hair on the wart on the frog on the bump on the log in the hole in the bottom of the sea\n";i;k=105;a[]={0,1,1,1,1,0,1,2,2};main(j){for(;i<9;k-=11+a[i++])do{printf("T%s%s",s,s+k);}while(j++&1||!printf("T%shole, t%shole\nT%s%s\n",s,s,s,s+105));}
```
[Try it online!](https://tio.run/##TY/BDoIwDIZfZZKo4GbCTDyYyVt4Aw8Vh5vARrYZY9Bnx4GgppevTb/mb76@5HnX5QLMyiaB4IYvLQKUxbaWFUdaISc4KioOP35MKECaie9g3HfF6MvEp1vdTFz5sRxV7a@PfNLO6RrpYugsh0wFTLIyofGWQXpM2pjQsXrakM2L1SBVeI3aQpuQyf2OleuEUgypxPgYnXXbGKlcEQaHuZ3bgFhicRmx1134v8Irxgv6fM7@lvpEBLkPZGrQfJBeHGQfJvJ@170B "C (gcc) – Try It Online")
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), 166 bytes
```
($/=@(($!="There's a")X [\R,](<hole log bump frog wart hair fly flea smile>Z(<i o>[$++>1]~"n the")xx*)X"bottom of the sea
")).map:{say "$_$_$! hole, {$!.lc} hole
$0"}
```
[Try it online!](https://tio.run/##HY3RCoIwGIXvfYrfMWhLsbrpIlR6huhCMokVv03YmmyLFLFXN43Dge98N6dFq/bTxOgmOzJGw4ycJVpcORCEF1BeT3HFUmkUgjJPuL91C7Wd6SOsBykaC7Xq56IApxuF@YWlDZi8pFGU76oveYGXSHjXrXlB7sZ7o8HUiwSHIiCcJ1q0h8GJHgi9zQlh@YthoGGiHuN/BXRLxmn6AQ "Perl 6 – Try It Online")
[Answer]
# [Japt](https://github.com/ETHproductions/japt) `-R`, 142 bytes
```
`—¤clogc¿mpcfžgcØ
ÖŽrcf§cf¤acsÚè`qc
`ˆ e Þ­om  e  a`
`T”œ's a `
£W+U¯YÄ ÔËE?"io"gE<Y +`n e `:P +DÃ¸+` {V}
` ²+W+`—¤, t”œ's a —¤
{W}—¤ {V+R
```
[Try it online!](https://tio.run/##y0osKPn/P@HQ9ENLknPy05MP7c8tSE47NC89@fAMucPTDvUVAXnLgXhJYnLx4VmHVyQUJnMlHOpQODQhVeHwvENr83MVDvWDeYcWJCZwJYQcmnJojnqxQqJCAtehxeHaoYfWRx5uUTg85XC3q71SZr5SuqtNpIJ2Qh5YT4JVgIK2y@HmQzu0ExSqw2q5EhQObdIO1wY7SEehBG4YiM9VHV4LooEKtYP@/9cNAgA "Japt – Try It Online")
[Answer]
## Batch, 267 bytes
```
@echo off
set r=i
set t= There's a hole
set s=bottom of the sea
for %%w in (hole log bump frog wart hair fly flea smile)do call:c %%w
exit/b
:c
set s=%1 %r%n the %s%
echo%t:~,11%%s%
echo%t:~,11%%s%
echo%t%,%t:T=t%
echo%t%%s:~-25%
echo(
if %1==log set r=o
```
`t` contains a string repeated in the chorus, `s` contains most of the verse line, while `r` chooses between `in the` and `on the`. In the verses, only the first 11 characters of `t` is needed, while in the first chorus line the second copy of `t` has its `T` lowercased and the second chorus line reuses the last 25 characters of `s`.
[Answer]
# [Ruby](https://www.ruby-lang.org/), ~~173~~ 170 bytes
```
a="T#{["here's a hole"]*3*"%s"%[", t","
T"]+c=" in the "}bottom of the sea
"
b=a[31,39]
%w{log bump frog wart hair fly flea smile x}.map{|i|puts b,b,a;b[9]+=i+c;c[1]=?o}
```
[Try it online!](https://tio.run/##HcdBCoMwEEDRfU4xTJFCDQVxJRJ6CXchi4nEJqCNJBEr6tlT6eLD@2HRW84ksLvtEq0J5h6BwPrRoHrUDywiFhI5JOTIOlRlLxDcB5I1gKf2KfkJ/PD/aIgxZFqQrCteN4oV6z76N@hlmmEIl1YKCSy5AMO4XRmCOLnRwPd8TjTvhzvmJUXQXHNqtWxUKVzZt72slHj5M@cf "Ruby – Try It Online")
[Answer]
# [Haskell](https://www.haskell.org/), ~~243~~ 215 bytes
Reduced to 215 bytes with great help from nimi
```
c[[l n,l n,'T'#h++", "++'t'#h,l 8,""]|n<-[8,7..0]]
t#u=t:"here's a "++u
h="hole"
c=concat
l n='T'#c(drop n$map(++" on the ")(words"smile flea fly hair wart frog bump")++["log in the ",h," in the bottom of the sea"])
```
[Try it online!](https://tio.run/##NY3PasMwDIfveQqhDpJgt@y2UuY3aE/bLQtDdZ06zP@wnZbBnn2eM7aDBN9P0idN6UMZU24C3oocBgOOr9W@thvNGHJAxtpcocZ7jjh@ueftsOdPu93jODZ5s4h8QK2iahPQur00WqD2RmEjhfROUm6qUqxK2V2iD@AeLIWu6sE7yFoB9t3dx0vCZGejYDKKavsETXOEO8UMU/RXOC82YM/YgKbS/HfLNcd/OPucvQU//VJShGNfLNWpgPrz9A5hyS85Hh3cyrecDF1T2coQfgA "Haskell – Try It Online")
(Old 243 byte version is [here](https://tio.run/##NY/NSgMxEIDveYphKKySWCyIBzFvYE96WxZJY9oEk8ySTCuC776mWT0M830zMD/e1E8X47KwRu@KGyoYQOGbUXQoqg5S4oGYKQEdgb2D6gyKoBFC7o6CmtC/WG0pW8MiQtbD2/DEUt7YzUehGfKINYU2WJHCY2yDVvju2ZtQOnyZwmun0KnD4ZzmDvFaCMpPt1JWcdF2HNsedY2/Xb4drAClHHj11tw9KsTpJz/fjQ13D9vt/TQtybQPNCQz799hPvMrl5cMl@UX "Haskell – Try It Online")).
A quite straightforward solution.
```
-- main function producing a list of lines
v = concat [[
    l n,
    l n, -- second line of each verse equals to its first line
    'T' # h ++ ", " ++ 't' # h,
    l 8, -- last line of each verse is the same in all verses
    ""
  ] | n <- [8,7..0]]
-- a small helper to construct similar strings 
t # u = t : "here's a " ++ u
h = "hole"
-- construct a first line of n-th verse (with n = 8 is the first and n = 0 is the last one)
-- Every such line begins with a constant prefix followed by expanding list of nested entities
l n = 'T' # concat (
      drop n $
         map (++ " on the ") (words "smile flea fly hair wart frog bump")
         ++ ["log in the ", h, " in the bottom of the sea"]
    )
```
[Answer]
# [JavaScript (Babel Node)](https://babeljs.io/), 239 bytes
*-7 bytes from @Oliver `*.*`*
```
(x=0,r='hole0log0bump0frog0wart0hair0fly0flea0smile'.split`0`).map(a=>(t=(i="There's a ")+a+r.slice(0,x++).reverse().map((h,_)=>` ${"io"[_<x-2|0]}n the ${h}`).join``+(o=` in the bottom of the sea
`))+t+(`${k=i+"hole"}, ${k}
`)+k+o).join`
`
```
[Try it online!](https://tio.run/##LY9BasMwEEX3OYUQAUvINqLrKqfIrpRo7I4rxbLHSGrqkvrsrtp0MTDzPvPgX@EGqY9@yU0HHYZmpjfce5oTBWwDvYtdrEbX0VSuEF2I7j6mRQ@xbJ8Qs3bgox7CVxkEnSYfsGrTEny22sp2gkWAOYlshDf87DBilRgwLhWo2KbgexS6XpWSbcQbxoTi8SVcfZHmZNnxzj3xl8vz2jx969dtZtlhoW4r/iv52VolyFjmH0lHOdPEaPi7EsLBSqmyEvZ4H41X/LcK3@qiGLeSqVHRv@hgd7n/AA "JavaScript (Babel Node) – Try It Online")
[Answer]
# [Python 3](https://docs.python.org/3/), ~~213 206 198~~ 193 bytes
```
k='n the ';o=e='bottom of the sea\n';b="There's a ";h='hole'
for j in[h]+'log bump frog wart hair fly smile'.split():o=j+' '+'io'['g'in o]+k+o;print(b+o+b+o+b+h+', t'+b[1:]+h+'\n'+b+h+' i'+k+e)
```
[Try it online!](https://tio.run/##JY7NCoMwEITvfYrFyyhbCqU3Q96iN@shgWjiT1ZiSvHpra2HgZmPGZhly17iY99HjUjZO4IS7TSs5CwzSfeHqzOvCGV18fQuOaxkqFBew8vkcOkk0UAhNr5lTNKTfc8LdelwH5MyeRMSddNG6xyO/m1dppDLqhY9MAiMIGjQI0SSlkcWtaQQc2lZ@JRnXCmDbXOv21867pyYAo6Fq/b9Cw "Python 3 – Try It Online")
---
-15 bytes thanks to @Sara  
-5 bytes thanks to @ASCII-only
Probably a bit more golfable, but not much. 
[Answer]
# [Clean](https://github.com/Ourous/curated-clean-linux), 267 bytes
```
import StdEnv,Text,Data.List
t="here's a "
h="hole"
b=" in the bottom of the sea"
f=foldr((+)o\s#p="T"+t+join" on the "(reverse s)+" in the "+h+b
=join"\n"[p,p,"T"+t+h+", t"+t+h+"\nT"+t+h+b+"\n\n"])""(tl(inits["log","bump","frog","wart","hair","fly","flea","smile"]))
```
[Try it online!](https://tio.run/##PU/BbsMgDL3nK5B3WCLo/oBbd5jUw6T21vRAEmiYACNwu@Xnx2hSTbLs957es@zRaRWKx@nmNPPKhmJ9xETsSNN7uIuT/iGxV6TeDjZTQxJmnfRrZopBM1eGTkMzSGA2MJo1G5AIPUOzsqwVNEYadFNqW95hn1@ihBNw4l9oAzDcYtAmfdcp10jH/5cBn/nQyNXZBzhHEcUWnjkIRk/Uh6c2PHA1XjqAllxrg6V8BodXEDDcfKzDpJV9q0R1zMqmh@iWtddzBWRv61OXritHqi4mmSm/o3Hqmsvu41D2S1Dejhv5dIoMJl92rlYOKsblDw "Clean – Try It Online")
[Answer]
# [cQuents](https://github.com/stestoltz/cQuents), ~~238~~ 219 bytes
```
|@
#36::"T"~c1)~j\rbk));@ )~c2,Z,"T"~c1)~"hole, t"~c1)~"hole","T"~c1)~c2)~@
::"","log in the","bump"~c3,"frog"~c3,"wart"~c3,"hair"~c3,"fly"~c3,"flea"~c3,"smile"~c3
:"here's a ","hole in the bottom of the sea"," on the"
```
[Try it online!](https://tio.run/##TY3BDoIwEETv/YrNejBNehESD3jhIzwZL6UpFAVX2xJjYvrrtVgw3t7szM6ox6Rv3sX4rtmm3FcVHjGoHQ@Xs22unB9q4EEV4iRWAw0NWoD/U/gzVcFDzViqSbeBOuhv4M0caKbxnjKlwNZSl@kprc9kZG8Xd3itoGUmN/ZpIyGr0Girtw4kpMp5ehmAhrynEaj9KpdeBQLl8Rg/ "cQuents – Try It Online")
This challenge made me finally implement lists and strings in my language. This language is built for integer sequences, so it did pretty well!
## Explanation
```
:"here's a ","hole in the bottom of the sea"," on the"
    helper line: c1), c2), and c3) access the three terms in this list
::"","log in the","bump"~c3,"frog"~c3,"wart"~c3,"hair"~c3,"fly"~c3,"flea"~c3,"smile"~c3
    helper line: yields a list containing the first n terms in it, accessed with bx)
    for example, the first three terms are:
"","log in the","bump"~c3
    so b3) would yield ["","log in the","bump on the"] (~ is concatenation and c3 is " on the")
|@
#36::"T"~c1)~j\rbk));@ )~c2,Z,"T"~c1)~"hole, t"~c1)~"hole","T"~c1)~c2)~@
|@
                              join sequence on literal newline
#36::                         output first 36 terms in sequence joined together
                              following are the 4 terms in the sequence, which will cycle through 9 times (for a total of 36 terms)
"T"~c1)~j\rbk));@ )~c2,       first term
"T"~c1)~                      "T" concat "here's a " concat
        j\rbk));@ )           the first k terms of b, reversed, and joined on " "
                   ~c2,       concat "hole in the bottom of the sea"
Z,                            second term - same as previous
"T"~c1)~"hole, t"~c1)~"hole", third term
"T"~c1)~                      "T" concat "here's a " concat
        "hole, t"~c1)~"hole", "hole, t" concat "here's a " concat "hole"
"T"~c1)~c2)~@
                              fourth term - "T" concat "here's a " concat "hole on the bottom of the sea" concat newline
```
[Answer]
# [Perl 5](https://www.perl.org/), 194 bytes
*@ASCII-only shaved off 6 bytes with literal newlines and a `\l` trick I forgot about*
```
$"=" on the ";say+($b=($e="There's a ").hole,$c=" in the bottom of the sea",$/)x2,$.="$b, \l$b
$b$c
";say"$e@a[-$_..-1] in the hole$c
"x2,$.for 1..(@a=qw/smile flea fly hair wart frog bump log/)
```
[Try it online!](https://tio.run/##NYxBCsIwEEX3PcUQBmyxTa3QlQS8gDt3KpLI1BZSpyaR2ssbteLmw4f33kDO1jGiUAL4BqElEBuvp2WKRqVISuxbcrTwoEFksmVLOV4@cPeDDYfAPXAzP09a5Fhmz3WOUgk0ORwtmgQNXpK5K5C2@lDgWcqiOv0r3@yXmL2GHVRSplut7mPp@84SNJb0ZyZodedg1C5A4/gK5tEPYPlaZjEmLx5Cxzcfi10tV9XqDQ "Perl 5 – Try It Online")
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), ~~115~~ 106 bytes
```
≔There's a holeθＥＥ⁹⁺…θχ⪫⮌…⪪”↶±∧⟲!↶⁼,(_⎇ＲB↧ω⪪zθⅉＱθ`✳＆⬤⸿◧σ⁻y▷»ΣＫ▶↙⁻υＸ`SξQ6 /ι⁹Ｗq”x⁺²ιn the ⟦ιι⁺⁺θ, ↧θ⁺θ✂ι±²⁵
```
[Try it online!](https://tio.run/##TU6xagMxDN37FcJLbXChDXQomUq20JbQdCsdFKOcDb7Tne0kzte7uiOFDnqy9PyenvOYHGNs7TXn0A1afXlKdJ8BwXMkZWEy67tdCkPR7zgu9WJhF09Zb64u0sbzqCcLT4/GwpbDoD/pTCnTP3o/xlC0OnAp3AMfoXiCTFjnExBq5E7wcOpH4HpMMnG9YCrSPIY0L@N1QUJpuQ8iY8mmqjK3MCsLwRiZ1LDYq/n9HWR7@7CABJ1lQr3xhZJDyTmZPw9h9zE40qL5oA4L6dWzmP4Ys26tPZzjLw "Charcoal – Try It Online") Link is to verbose version of code. Edit: Saved 9 bytes by copying my Batch code for the last line of the chorus. Explanation:
```
≔There's a holeθ
```
Save the string `There's a hole`, which is used twice as-is, a third time in lower case, and also a fourth time but just the first 10 characters.
```
⪪”↶±∧⟲!↶⁼,(_⎇ＲB↧ω⪪zθⅉＱθ`✳＆⬤⸿◧σ⁻y▷»ΣＫ▶↙⁻υＸ`SξQ6 /ι⁹Ｗq”x
```
Split the string `bottom of the seaxhole ixlog ixbump oxfrog oxwart oxhair oxfly oxflea oxsmile o` on `x`s.
```
Ｅ⁹⁺…θχ⪫⮌…...⁺²ιn the 
```
Loop over the 9 verses, taking the first `i+2` elements of the array, reversing them, joining them with `n the`, and prefixing `There's a` to the result.
```
Ｅ...⟦ιι⁺⁺θ, ↧θ⁺θ✂ι±²⁵
```
Expand each line into a verse by duplicating the line and constructing the chorus. Each line of the verse is then implicitly printed on each own line, and each verse is implicitly separated by a blank line.
[Answer]
# [V](https://github.com/DJMcMayhem/V), 184 170 bytes
```
4iThere's a hole in the bottom of the sea
kky5w5eá,lpD5brtHj4yyGp4w8ion the 2briilog 3bibump 3bifrog 3biwart 3bihair 3bifly 3biflea 3bismile 7ñ4yykp4wd3wñ8ñÄ5jñ
```
[Try it online!](https://tio.run/##LY5BDsIgEEX3XoHN7Ny4siX2ACZ6AC8AcSrTUmmASth7EY/AGTgYNrSrefN/5mU@pbT0UGjx6ECAMhqB3uAVgjTemwlMXzeH4sDGMfLAMf9Oer5yaf19aGO8zW3oyGxX7CwtkTYvYI0kuUxzhd7uSRDWV1CC7FbpuE8UFdxE6xfsktMqH1f5swk5dTnlLx9yKuUP "V – Try It Online")
## Explanation:
* `4iThere's a hole in the bottom of the sea<\n><esc>` Insert "Theres' a hole in the bottom of the sea" 4 times.
* `kk` Move to the third line
* `y5w` copy "There's a hole"
* `5eá,` insert a comma after "There's a hole"
* `lp` paste after the comma
* `D` delete the rest of the line
* `5brt` lowercase the second T
* `Hj4yy` copy 4 lines from the second line
* `Gp` Paste everything after the first line
* `4w8ion the <esc>`(at the end of the first verse) move to first "hole" in second verse and insert "on the " 8 times
* `2briilog <esc>` move backwards to the last "on", replace the o with an i and then insert "log "
* `3bibump <esc>3bifrog <esc>3biwart <esc>3bihair <esc>3bifly <esc>3biflea <esc>3bismile <esc>` Move backwards through the line, inserting the appropriate words between each "on the"
* `7ñ4yykp4wd3wñ` execute `4yykp4wd3w` 7 times
	+ `4yykp` duplicate the verse before this one
	+ `4wd3w` move to the first word after "There's a hole" and delete 3 words
* `8ñÄ5jñ` duplicate the first line of each verse after the first (there are 8 of these to do)
[Answer]
# LaTeX, 265 ~~268~~ characters
```
\documentclass{book}\input{pgffor}\def\i{bottom of the sea}\let~\i\def\b{here's a }\def\h{hole}\def\s#1{ in}\begin{document}\foreach\x in{\h\s,log\s,bump,frog,wart,hair,fly,flea,smile}{\xdef~{\x{ on} the ~}T\b~\\T\b~\\T\b\h, t\b\h\\T\b\h\,in the \i\par}\enddocument
```
compiles into a nice PDF, with paragraph indentations and everything.
Ungolfed and commented:
```
\documentclass{book}
\input{pgffor}
\def\i{bottom of the sea}   %for re-use in the last two verses 
\let~\i                     %here I keep attaching words
\def\b{here's a }               
\def\h{hole}
\def\s#1{ in}               %this replaces the next token with "in", useful for log and hole where "in" is used instead of"on"
\begin{document}
\foreach\x in{\h\s,log\s,bump,frog,wart,hair,fly,flea,smile}{
    \xdef~{\x{ on} the ~}   %keep attaching words and on/on to ~
    T\b~\\                  %verse 1
    T\b~\\                  %verse 2
    T\b\h, t\b\h\\          %verse 3
    T\b\h\,in the \i\par    %verse 4
}
\enddocument
```
Of output:
[![enter image description here](https://i.stack.imgur.com/x028h.png)](https://i.stack.imgur.com/x028h.png)
[Answer]
# [C# (Visual C# Interactive Compiler)](http://www.mono-project.com/docs/about-mono/releases/5.0.0/#csc), 220 bytes
```
string b="There's a ",d="hole in the bottom of the sea\n",e,f;" log bump frog wart hair fly flea smile".Split().Any(s=>Write((e=b+(f=s!=""?s+(f!=""?" o":" i")+"n the "+f:s)+d)+e+b+$@"hole, there's a hole
{b+d}
")is int);
```
[Try it online!](https://tio.run/##LY5BigIxEEX3nqIsBBPSegAlOnOGEdy4SeyKXZDuSCqDiHj2NrYuPrzP58M7y@osPI5SMg8X8BYPHWVaCjjAprXYpUjAA5SOwKdSUg8pTE3InQZsqAlbhJjq@b@/QsiVbi4X6BxnCPFeQw6k50i4/rtGLkqvf4e7Ers7Zi6kFFlvVLAyt4h7qTgBQsINAqM2@BFAEzaiTasNGW8WP5Nd856@yu8@e3jTPmeoWap40dtxfAE "C# (Visual C# Interactive Compiler) – Try It Online")
-5 bytes thanks to @ASCIIOnly and -2 bytes thanks to @someone!
I have a small child and can assure you this song is equal parts catchy and annoying.
[Answer]
# [Slashalash](https://esolangs.org/wiki/Slashalash), 216 bytes
```
/V/\/\///U/\/ VS/TCVR/iBVQUtheVPUoBVOUholeVN/RASVM/ASO, tCO
SA
VL/RMSVKUlog VJUbumpPKVIUfrogPJVHUwartPIVGUhairPHVFUflyPGVEUfleaPFVDUsmilePEVC/here's aVB/nQVA/O R bottom ofQ sea
/SASMSKNKLJNJLINILHNHLGNGLFNFLENELDNDRM
```
[Try it online!](https://tio.run/##DcXLasQgFIDhfZ7CXTeF8wzmfjHGaM9ZdeOAGQOmDtGh9OnT8MP3p2CTd@m6gOD7DgBvGRn4qkjDXtKK2TtSGEta0MfgSILmhmbgZvlkuVoKwwsSoGdDE4b4ZDTi43281EQDbmd8qpF6/LVnVgN16O1@qp5a3MKf6qi576xqqcZ07MGphirw7nQfiVkq4WclDgvT7BFzjgeL28qSswUYbmYzyUmMchSDHEQve9HJTrSyFY1sRC1rPV/XPw "/// – Try It Online")
This sort of task is the one and only thing that Slashalash is reasonably good at. :D Hey, the result is shorter than C, C# or Java!
The output from this program ends in *two* trailing line breaks; hope that's not a deal-breaker.
Anyway, there's no real cleverness here. I simply identified repeated strings and defined one-character shortcuts for them, and repeated until I didn't see any more repeated strings. I did this in a more-or-less naive and greedy fashion. I did, however, intentionally define a shortcut for "smile on the flea on the ... sea", followed by "flea on the fly on the ... sea", and so forth, in order to form a chain of shortcuts. The result is that the whole sequence of new nouns is clearly visible in the code, and I find that pretty pleasing. :)
After V and U are replaced, we have the following more readable code:
```
/S/TC//R/iB//Q/ the//P/ oB//O/ hole//N/RAS//M/ASO, tCO
SA
//L/RMS//K/ log //J/ bumpPK//I/ frogPJ//H/ wartPI//G/ hairPH//F/ flyPG//E/ fleaPF//D/ smilePE//C/here's a//B/nQ//A/O R bottom ofQ sea
/SASMSKNKLJNJLINILHNHLGNGLFNFLENELDNDRM
```
]