[Question]
  [
Everyone is likely familiar with the following [song](https://en.wikipedia.org/wiki/Row,_Row,_Row_Your_Boat), which is [a musical round](https://en.wikipedia.org/wiki/Round_(music)):
[![The song.](https://i.stack.imgur.com/q5hML.png)](https://i.stack.imgur.com/q5hML.png)
# Background
Fewer people might recall trying to sing the 4-person version of this with a few friends and failing. Offsetting the lyrics of a song with different harmonious pitches is known as singing a "round" and that's what we're here to simulate today using static output. Here's an example of [someone actually performing the piece (link to audio/video, will have sound)](https://www.youtube.com/watch?v=_t5sY23P1MM). 
# The Challenge
**This challenge is to output the text as follows exactly as it follows:**
```
Row, row, row your boat,           |-----------------------------------|-----------------------------------|-----------------------------------
Gently down the stream.            |Row, row, row your boat,           |-----------------------------------|-----------------------------------
Merrily, merrily, merrily, merrily,|Gently down the stream.            |Row, row, row your boat,           |-----------------------------------
Life is but a dream.               |Merrily, merrily, merrily, merrily,|Gently down the stream.            |Row, row, row your boat,           
-----------------------------------|Life is but a dream.               |Merrily, merrily, merrily, merrily,|Gently down the stream.            
-----------------------------------|-----------------------------------|Life is but a dream.               |Merrily, merrily, merrily, merrily,
-----------------------------------|-----------------------------------|-----------------------------------|Life is but a dream.               
```
# Rules
* Trailing whitespace is acceptable, but not required, this includes newlines.
* Hyphens and bars are part of the required output, yes.
* Commas, periods, capitalization and all syntactical elements related to grammar are required.
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), the lowest byte-count code without using standard loopholes is the winner.
  
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~80~~ 77 bytes
```
“¢ã,¢ã,¢ã€žžÄ,““èî„‹€€šæ.“"merrily, "4×¨“‚ì€ˆ€³€…žâ.“'-35×Ð)€ª.B3FDÁ})øvy'|ý,
```
[Try it online!](https://tio.run/nexus/05ab1e#@/@oYc6hRYcX68CJR01rju47uu9wiw5QCogOrzi87lHDvEcNO4EyIMmFh5fpAcWVclOLijJzKnUUlEwOTz@0Aqx61mGQktNtQOLQZpD6hmVAoxaB1KvrGpsenn54giZIbpWek7Gby@HGWs3DO8oq1WsO79X5/x8A "05AB1E – TIO Nexus")
Work in progress.
[Answer]
# [V](https://github.com/DJMcMayhem/V), ~~139~~, 128 bytes
```
iLife is but a dream ±µ |4amerrily, x7b~A|Gently down the stream.±² |3arow, X5b~Ayour boat,±± |3I³µ-|3AòÄó.û-}|ò5DÎ4f|C|
```
A one-liner! (sortof :P)
[Try it online!](https://tio.run/nexus/v#@5/pk5mWqpBZrJBUWqKQqJBSlJqYq3Bo46GtCjXSJom5qUVFmTmVOgrSFeZJdY417ql5JTmVCin55XkKJRmpCsUlIPV6QPWbgOqNE4vyy4FqI0yBaivzS4sUkvITS3SAshtBsp6HNh/aqgtkODJKH950uOXwZr3Du3Vraw5vMnU53GeSVuNc8/8/AA "V – TIO Nexus")
Hexdump:
```
00000000: 694c 6966 6520 6973 2062 7574 2061 2064  iLife is but a d
00000010: 7265 616d 20b1 b520 7c1b 3461 6d65 7272  ream .. |.4amerr
00000020: 696c 792c 201b 7837 627e 417c 4765 6e74  ily, .x7b~A|Gent
00000030: 6c79 2064 6f77 6e20 7468 6520 7374 7265  ly down the stre
00000040: 616d 2eb1 b220 7c1b 3361 726f 772c 201b  am... |.3arow, .
00000050: 5835 627e 4179 6f75 7220 626f 6174 2cb1  X5b~Ayour boat,.
00000060: b120 7c1b 3349 b3b5 2d7c 1b33 4101 1bf2  . |.3I..-|.3A...
00000070: c4f3 2efb 2d7d 7cf2 3544 ce34 667c 437c  ....-}|.5D.4f|C|
```
Do I get bonus points for landing exactly on `2^7`?
This took a while to figure out. I'm hoping I can golf tons off like my keyboard ASCII art answer, but I'm not sure. We'll see. They are very similar challenges (and both very fun :D)
Originally I tried this (180):
```
3irow, ch your boat,±± ||"rCLife is but a dream.±µ ||"lD4imerrily, r||"mCGently down the stream.±² ||"gC³µ-|B"dCR³D
GRDD
MGRD
LMGR
DLMG
DDLM
³DLÍR/r
ÍG/g
ÍM/m
ÍL/l
ÍD/d
```
[Try it online!](https://tio.run/nexus/v#NYwxCoMwGEb3jFmz/DjbZmhPUAMucfEGWlMNqIEYESFX8DBWvEA8mP0Rurw3PL7vfGhrphjYu4HZjBZKU7g4rGEFz3xkE6k/CvQA5eiggMqqortj3q/ciqfulLW6nfHCeh91Sap6185QmakH1ygY3H/zvTZ1Eraw3zx7RVWSh02QNBeCZEgikUQgiUASjJIdS86pJceSclqjMk47lOS0RQlOq/P8AQ)
Which inserts this:
```
RDDD
GRDD
MGRD
LMGR
DLMG
DDLM
DDDL
```
and then does substitution to expand it out. But building it [ascii-art](/questions/tagged/ascii-art "show questions tagged 'ascii-art'") style is much shorter (and more fun TBH)
[Answer]
## Batch, ~~292~~ ~~288~~ 275 bytes
```
@set d=-------
@set "d=%d%%d%%d%%d%%d%^|
@set "m=M_ m_ m_ m_^|
@set "s=           ^|
@set "s=Life is but a dream.    %s%%m:_=errily,%Gently down the stream. %s%Row, row, row your boat,%s%%d%%d%%d%"
@for /l %%i in (1,1,6)do @call:c
:c
@echo %s:~111,146%
@set "s=%d%%s%
```
Edit: Saved 13 bytes by rewriting the code to use a version of the substring trick I used in my Retina answer. Conveniently I can loop six times and then fall through for a seventh iteration of the loop body, which means the quoting needed to output `|`s doesn't get too onerous, however I have to be careful to take the `^`s into account when selecting the substring.
[Answer]
# Python 3, ~~252~~ ~~235~~ ~~208~~ ~~206~~ 205 bytes
Alright, alright. Here's a less boring answer:
```
w=' '*11
t=["Row, row, row your boat,"+w,"Gently down the stream. "+w,"Merrily,"+" merrily,"*3,"Life is but a dream.    "+w,*['-'*35]*3]
for a in zip(*[t[z:]+t[:z]for z in range(7,3,-1)]):print(*a,sep='|')
```
**Old answer, 252 bytes:**
Boring answer, and the other Python answer is shorter, but I thought I'd try if this approach is shorter. Python 3 despite the savings in byte/string 2-3 difference because both `gzip` and `base64` are shittier in Python 2.
```
from base64 import*
from gzip import*
print(decompress(b85decode('ABzY8Fgf~I0{;ujFV|5hf)Waq`K3h)N%@H-ItmC-qe~c2OAVKMYF<fBr9w)6d7eT^Myf(_Nl|KIuATz2dxGfaW-i~<qN2>4N*#q<oQxVex|z!-Gc8pivsfXiv_v6MAqB%CkU6w=GZ!&|OJj#}Q7chW$(>wu%p_Rd3;?AKH=M}>000')).decode())
```
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), ~~224~~ ~~207~~ 202 bytes
```
$a=' '*11;0..6|%{((0..4+4+4)[($_,($_+=6),--$_,--$_|%{$_%7})]|%{("Row, row, row your boat,$a","Gently down the stream.$a ","Merrily,$(' merrily,'*3)","Life is but a dream.$a    ",('-'*35))[$_]})-join'|'}
```
[Try it online!](https://tio.run/##NYvBCoMwEER/ZZFIEo1SaWsPxXMv7aVXEYmYokVNiRGR6rfbFewuO8wybz56VKavVNOsK5EJBepF0fUQhvHsfhlDc/JxecpILvD8JOYiCPDZBBmSu5eFZxvtPPUowOwCkx4MFFpaQaQjnJvqbDNBqccObKWgt0bJNiQSMHwoY@pmEoRRaHdPvSPH6F6/FNQ9FIMFCeW/hOMIRgOkzpynJM8WHrx13dGZLuv6Aw) *(the output is wrapped if your screen isn't wide enough)*
Good grief, this array generation thing is ugly, but it saved 17 bytes, so ...
```
0..6|%{((0..4+4+4)[($_,($_+=6),--$_,--$_|%{$_%7})]
```
We loop from `0` to `6`. Each iteration, we're indexing into an array `(0,1,2,3,4,4,4)`. The indexing is based on the current digit, the current digit `+6`, that `-1`, and then *that* `-1`. Each of *those* is then fed through a loop where we modulo with `%7`. For example, if we're on `0` of the outer `0..6` loop, then these would be `0,6,5,4`, then each `%7`, so `0,6,5,4`. That's indexed into the `(0,1,2,3,4,4,4)` array, so the output is `0,4,4,4`. For input `1` we get `1,7,6,5` then `1,0,6,5` which yields `1,0,4,4`. And so on. *(things would be so much easier if we had a `.clamp` function)*
Those are one-at-a-time spit into a loop `|%{}`. Each iteration, we index into the proper spot in the song-lyrics-array, and leave that string on the pipeline. Those strings are then `-join`ed together with `|` to format the output line. Those strings are left on the pipeline and output is implicit.
*Saved some bytes thanks to Value Ink.*
[Answer]
# PHP, 191 Bytes
```
for(;$n<7;$n++)for($m=0;$m<4;)echo $m?"|":"\n",str_pad($i=["Row, row, row your boat,","Gently down the stream.",M.($t="errily,")." m$t m$t m$t","Life is but a dream."][$n-$m++],35," -"[!$i]);
```
[Try it online!](https://tio.run/nexus/php#NcvBCoJAFIXhvU9xu9yFMqMEFUEqLtvUpq1JaI444MzIOCJC725GtTg/nMWXZH3bL42xfkw6Oa5hLPA@n1S6jUkl@zjwxLM1QCrDF57wrpEPzj76svZJpjnezMTB/gKzGS1UpnQcOZ6Fdt0MtZk0uFbA6kSpIuTXyCeXorBWdjPHIEJQ5P5b5UU2AuQA1eighPrLipx0SIqxgu8OHCHEfEOyCOJleQM "PHP – TIO Nexus")
Expanded
```
for(;$n<7;$n++)
  for($m=0;$m<4;)
    echo $m?"|":"\n"
     ,str_pad($i=["Row, row, row your boat,","Gently down the stream."
       ,M.($t="errily,")." m$t m$t m$t","Life is but a dream."][$n-$m++]
       ,35," -"[!$i]);
```
[Answer]
# JavaScript (ES8), ~~285~~ ~~256~~ ~~240~~ ~~231~~ ~~229~~ ~~217~~ ~~214~~ ~~213~~ ~~211~~ ~~210~~ 206 bytes
```
_=>"0444104421043210432144324443".replace(/./g,(x,y)=>["Row, row, row your boat,","Gently down the stream.","Merrily,"+(m=" merrily,")+m+m,"Life is but a dream.","-".repeat(35)][x].padEnd(35)+`
|||`[++y&3])
```
Saved a few bytes by borrowing a trick from [Arnauld's answer](https://codegolf.stackexchange.com/a/117259/58974)
[Try it online!](https://tio.run/##Nc69bsIwFAXgnae48oBs2ZiWpGPYEEu7dI2iYuKbNMg/kWMKlvLuqVvB8knnHh3pXtSPmtowjHHjvMalq5avak9eyrJ8zewyxYMyk88FkQFHo1qkW7ntBb2LxKp9TT79TUB4AMlfA5y9ioIIckQXTQLtbw7iN8IUAyorc/OBIQwmCcKprQjYZ2TccivI@9AhDBOcrxEU6Odq8/8DqkiLN9bU90aOSh@c/ov8tJrn@VRzntZFw5bWu8kblMb3tKOMLb8)
[Answer]
# [Python 2](https://docs.python.org/2/), 199 bytes
```
w=' '
s=['-'*35]
t=['Row, row, row your boat,'+w*11,'Gently down the stream.'+w*12,'Merrily,'+' merrily,'*3,'Life is but a dream.'+w*15]
print'\n'.join(map('|'.join,zip(t+s*3,s+t+s+s,s+s+t+s,s*3+t)))
```
[Try it online!](https://tio.run/nexus/python2#RY1BD4IwDIXv/IreCmySIPHI2YtevKqHEWacYRvZShaM/x0b1Hjp@/ra1y6pRcAstmfcYNnsrhkxnnySEL4FZj8F6LwiiSKVdS1xrx0NM/Q@OaC7hkhBK1ut463Eow7BDDOvI9gfl43Eg7lpMBG6iUBB/w/x3zEYR3hxWD28cblVY46vTyOfZsxJRD4RBauIrCtJ9gQVRbEsbw "Python 2 – TIO Nexus")
---
Thanks to @mathjunkie for saving 14 bytes
[Answer]
# [CJam](https://sourceforge.net/p/cjam), ~~128~~ 122 bytes
```
"Row, row, row your boat,""gently down the stream."'M" merrily,"4*2>+"Life is but a dream."'-35*__]{35Se]}%a4*4,.m>z'|f*N*
```
[Try it online!](https://tio.run/nexus/cjam#Lcq9CoMwFAbQV/m4UIQ0dahx9QnaDu0sEvHaBoyBa0TSn2dPF5cznUz3sGnIDlJYBX2wURM9eY5TwhC2GfHFWKKw9SUVV4JnETclTUadmyNd3MhwC/o1wmLY36mqVde1n6p@cPs7WKOMLn3zLr6juqmc/w "CJam – TIO Nexus")
**Explanation**
```
"Row, row, row your boat,"  e# Push this string.
"gently down the stream."   e# Push this string.
'M                          e# Push the character 'M'.
" merrily,"4*               e# Push the string " merrily, merrily, merrily, merrily,".
2>+                         e# Remove the first two letters of it, and append it to 'M',
                            e#   fixing the capitalization.
"Life is but a dream."      e# Push this string.
'-35*__                     e# Push a string containing 35 hyphens and make two copies of it.
]                           e# Collect all these strings in an array.
{35Se]}%                    e# Pad each of them to length 35 by adding spaces to the right.
a4*                         e# Repeat the array 4 times.
4,                          e# The range [0 1 2 3].
.m>                         e# Rotate each subarray of strings rightward by the corresponding
                            e#   number in the range.
z                           e# Transpose the array.
'|f*                        e# Join the strings on each row with '|' characters.
N*                          e# Join the rows together with newlines.
```
[Answer]
# [SOGL](https://github.com/dzaima/SOGL), 83 [bytes](https://github.com/dzaima/SOGL/blob/master/chartable.md)
```
┌׀0ρMVxDrž|⁷ΨB≈π93|↑D~Νķ‰¤t╤▼ΣΗ⁶⅔¾№⁷Ζ÷│²╥Ν9°‘-”)0ΔH«‘4*jŗ"ΣΨ¬¹‘4*;+7{’⁄{»}⁽:’∞n1wpX
```
The 1st part `┌׀0ρMVxDrž|⁷ΨB≈π93|↑D~Νķ‰¤t╤▼ΣΗ⁶⅔¾№⁷Ζ÷│²╥Ν9°‘` is a compressed string resulting in
```
`life is but a dream.               |-|gently down the stream.            |row, row, row your boat,           |`
```
These are the lines reversed (since this is printing them line-by-line), with the "merrily" part cut out to be replaced in the program.  
The rest of the program:
```
...‘                                        Push the compressed string
      )0ΔH«‘                                push "merrily, "
            4*                              repeat it 4 times
              j                             take the last letter off
    -”         ŗ                            replace "-" with the merrily line
                "ΣΨ¬¹‘                      push 35 dashes with an appending "|"
                      4*                    repeat it 4 times
                        ;+                  add inverted ("---|---..."+"Life is but a dream  ...")
                                            The resulting string of above is "-----------------------------------|-----------------------------------|-----------------------------------|-----------------------------------|life is but a dream.               |merrily, merrily, merrily, merrily,|gently down the stream.            |row, row, row your boat,           |"
                          7{                repeat 7 times
                            ’⁄{»}            rotate right 35 times
                                 ⁽           uppercase the 1st letter
                                  :          duplicate
                                   ’∞n       split into parts of length 135
                                      1w     get the 1st one
                                        p    output that
                                         X   delete the splat array
```
[Answer]
# [///](https://esolangs.org/wiki////), 200 bytes
```
/_/     //&/errily,//*/ m&//+/-------//@/Row, row, row your boat, __//#/Gently down the stream.  __//$/M&***//%/Life is but a dream.___//~/+++++/@|~|~|~
#|@|~|~
$|#|@|~
%|$|#|@
~|%|$|#
~|~|%|$
~|~|~|%
```
[Try it online!](https://tio.run/nexus/slashes#LYpNCoMwEEb3OcUH/iyi7XcFd920m14gKKZUUANpRITg1a2Z9g3MPJh30BAJsqT1fhi3mtTEVJIVLz/Ihk@31vD/hc0tHp1rQw1jyIw3O4dxQ@/WGeFt8QnettMV8s75KLXWZMH78LIYPuiWgBa9RCY1O6sEm7inUVkUU3kUU0UUU3sUU6k6Te5px/EF "/// – TIO Nexus")
Simple, uses common occurrences as replacements.
[Answer]
# PHP, 179 bytes:
```
for($m="errily,";$i<28;)echo str_pad($s=["Row, row, row your boat,","Gently down the stream.","M$m m$m m$m m$m","Life is but a dream."][($i>>2)-$i%4],35," -"[!$s]),"
|||"[++$i%4];
```
**ungolfed**
```
for($i=0;$i<28;$i++)
{
    $x=$i%4;
    $y=$i>>2;
    $s=["Row, row, row your boat,",
        "Gently down the stream.",
        M.($m="errily,")." m$m m$m m$m",
        "Life is but a dream."
    ][$y-$x];
    $pad_string = $s ? " ":"-";
    $postfix = $x<3 ? "|" : "\n";
    echo str_pad($s,35,$pad_string),$postfix;
}
```
[Answer]
## JavaScript (ECMAScript 2017), ~~191~~ ~~187~~ 182 bytes
*Saved 3 bytes thanks to Shaggy*
```
f=(i=27,s=['Life is but a dream.','Merrily,'+(m=' merrily,')+m+m,'Gently down the stream.','Row, row, row your boat,'][(i>>2)-i%4]||'')=>i?s.padEnd(35,' -'[+!s])+`
|||`[i&3]+f(i-1):s
o.innerHTML = f();
```
```
<pre id=o style="font-size:10px"></pre>
```
[Answer]
**Microsoft Sql Server, 421 bytes**
```
with v as(select left(s+space(35),35)s,n from(values('Row, row, row your boat,',1),('Gently down the stream.',2),('Merrily, merrily, merrily, merrily,',3),('Life is but a dream.',4))t(s,n))select isnull(v.s,s.s)+'|'+isnull(b.s,s.s)+'|'+isnull(c.s,s.s)+'|'+isnull(d.s,s.s)from v full join v b on v.n=b.n+1 full join v c on b.n=c.n+1 full join v d on c.n=d.n+1 cross apply(select replicate('-',35)s)s order by isnull(v.n,9)
```
[Check It Online](http://rextester.com/FPHES32222)
[Answer]
# C (GCC), ~~231~~ 230 bytes
-1 byte thanks to ceilingcat!
```
#define m"errily, "
char s[7][35]={"Life is but a dream.","M"m"m"m"m"m"m"m,"Gently down the stream.","Row, row, row your boat,"};f(l,c){memset(s[4],45,'k');for(l=7;l--;)for(c=0;c<4;)printf("%-35.35s%c",s[(4+l+c++)%7],"|||\n"[c]);}
```
Pretty straightforward. First it builds the 7 lines string array, part via a macro to factorise out the "merrily" part, then the lines of dashes are filled in with a `memset`. Then the lines are printed with the adequate offset and separators.
[Try it online!](https://tio.run/nexus/c-gcc#TY3BSsQwFEX3fsXjSZmGpoPQli5i12504zZmkUkTJ5ikkmQoZTq/bq2gIBcuHDhwtvtRGxs0eNQxWrdQwDt1lhES7wVvOjFc8dkaDTbB6ZJBwhi19Eek@IL@/yg@6ZDdAuM0B8hnDSn/qa/TTCH@HizTJcJpkpnijTmqmCnJ1WufdC4TbwVtO3r4OBBmpli6oWeurhn5ATU8MPXYMvIZbcimxKJuumPTpUIhTbxsK1epqiJFLyiu6/oWkCtB2G3z0oa9spd2@FLGyfe01fM3 "C (gcc) – TIO Nexus")
[Answer]
# T-SQL, ~~296 277~~ 276 bytes
```
PRINT REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE('1|0|0|0
2|1|0|0
3|2|1|0
4|3|2|1
0|4|3|2
0|0|4|3
0|0|0|4',0,REPLICATE('-',35))
        ,1,'Row, row, row your boat,6')
        ,2,'Gently down the stream. 6')
        ,3,'M5 m5 m5 m5')
        ,4,'Life is but a dream.    6')
        ,5,'errily,')
        ,6,SPACE(11))
```
Line breaks at the beginning are part of the original string, line breaks near the end are for display purposes only, and are not counted toward the byte total.
Inspired largely by [Conrade SparklePony's answer](https://codegolf.stackexchange.com/a/117275/70172). Different technique than [Andrei Odegov's SQL answer](https://codegolf.stackexchange.com/a/117332/70172).
Pretty straight-forward multi-replacement, but a few things that help save bytes:
* SQL allows line breaks in the original string
* Using numerals instead of characters allows me to eliminate a whole bunch of single quotes
* Nested replacements (5 and 6), save me even more bytes (thanks, @t-clausen.dk)
If only I could `REPLACE` all the `REPLACE`s with something shorter. Hmm....
[Answer]
# MATLAB, 280 bytes
```
a='errily,';
z={'Row, row, row your boat,';'Gently down the stream.';['M',a,' m',a,' m',a,' m',a];'Life is but a dream.'};
z{5}(1:35)='-';
y=5*ones(7,4);
for j=1:4;z{j}(end+1:35)=' ';y(j:j+3,j)=(1:4)';end
x=z(y);
for j=1:7;fprintf('%s|%s|%s|%s\n',x{j,1},x{j,2},x{j,3},x{j,4});end
```
The cell array indexing is pretty costly, that seems like the easiest place to discard some bytes (if possible).
[Answer]
# [Retina](https://github.com/m-ender/retina), ~~153~~ 150 bytes
```
<-|>Life is but a dream.15|M!< m!>|Gently down the stream.12|Row, row, row your boat,11<|->
<(.*?)>
$1$1$1
!
errily,
-
35$*-
\d+
$* 
r!&`.{71}\|.{71}
```
[Try it online!](https://tio.run/nexus/retina#LYo9C8IwFAD39yteoIjWpBCluIQ4uuji3MGURAy0DaQpJfj87RU/OLhbbgElSJ/93aEfsZ0SGrTRmb6SNV2Ywp5pOrkhdRltmAdMD4dj@h07uoaZY/wLc5gitsEkLqUioUGtq/K40VDID8DAxei7zEHAvi5KAY3dQlEiRLa6Vc@DfDX0zbK8AQ "Retina – TIO Nexus")
I tried arbitrary run-length encoding but `$1$*$2` doesn't do what I want and repeating strings proved too tricky. Edit: Saved 2 bytes by encoding `errily,` and 1 byte by removing an unnecessary `^`.
[Answer]
# Python 2, 225 Bytes
```
w=[["-"*35]*7for _ in[0]*4]
for i in [0]*4:w[i][i:i+4]=[a.ljust(35)for a in["Row, row, row your boat,","Gently down the stream.","Merrily,"+" merrily,"*3,"Life is but a dream."]]
print "\n".join(["|".join(i)for i in zip(*w)])
```
[Try it online!](https://tio.run/nexus/python2#ZY4xC8IwFIR3f8XjTUmNXaoIgrOLLq4xQ4pRn7RJeU0JFf97rVhdXI7j7uO4IW21xgVmxcpka7gEBgLywNZfnVhKM/uLNkmT0bSh@dJstc2re9dGUazkm7QjqfEYkgKeBPrQMZTBRoUKd87HqodzSB7izUEb2dk6H5uDY6aqVzhHqL8@KxTu6eKAWii7OO6fP7wxs4bJR8CTx/weyAuNz8mR/L1@UCOyJI0chhc)
[Answer]
# [Perl 5](https://www.perl.org/), 215 bytes
```
$m='merrily,';$s=' 'x11;$l='-'x35;
@t=@s=("Row, row, row your boat,$s","Gently down the stream. $s",
       "\u$m $m $m $m","Life is but a dream.    $s",$l,$l,$l);
map{$i--;map$t[$_].="|".$s[$i++%7],0..6}1..3;print"$_\n"for@t
```
[Try it online!](https://tio.run/nexus/perl5#NYrNCsIwEIRfZQkrUUyDRdRDCPTmxZNXFak0xUDSSLJFi/rs1fozfAwzzPToNfcmRus6wRUmzYHf8lyh0zzjt/lCFaSLpMdsG64C4s@gC22EUyhJYGKCrU1DroMqXBugs4FE0ZRewmfct@jhz7tvbG3AJji1BCVU3@dbwxndl4ny5eWONsuGgLTD40Fq9mAS0w7tdDpaHcRMyuUzl3KuLtE2xPC4b1gdYkF9/wI "Perl 5 – TIO Nexus")
[Answer]
# [Swift](https://swift.org/), 416 406 405 380 ~~372~~ 307 bytes
```
var f=String.init(repeating:count:);_={[[0,4,4,4],[1,0,4,4],[2,1,0,4],[3,2,1,0],[4,3,2,1],[4,4,3,2],[4,4,4,3]].forEach{print($0.map{["Row, row, row your boat,"+f(" ",11),"Gently down the stream."+f(" ",12),"Merrily,"+f(" merrily,",3),"Life is but a dream."+f(" ",15),f("-",35)][$0]}.joined(separator:"|"))}}
```
You can try it [here](https://iswift.org/playground?Mg6U2g).
Thanks to @Mr. Xcoder for saving me 65 bytes!
[Answer]
# [Japt](https://github.com/ETHproductions/japt) [`-R`](https://codegolf.meta.stackexchange.com/a/14339/), ~~99~~ ~~95~~ ~~94~~ ~~92~~ ~~90~~ ~~89~~ 87 bytes
```
R³i`Life  ¿t a Ým.
M{34î`Îk, m`}
Gt§ Üµ e Ðpam.
Row, w, w yr ¾,`ú)·ú-
£éY Å¤q|
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&flags=LVI&code=UrNpYExpZmUgiSC/dCBhIN2EbS4KTXszNO5ggM5rLCBtYH0KR4F0pyDctSCQZSDQcGFtLgpSb3csIJ53LCCedyB5jHIgvoUsYPopt/otCqPpWSDFpHF8)
```
R³i`L...{34î`...`}...,`ú)·ú-
R                                :Newline
 ³                               :Repeat 3 times
  i                              :Prepend
   `                             :  Decompress
    L...                         :    "Life is but a dream.\nM"
        {                        :    Interpolate
         34î                     :      Repeat & slice to length 34
            `...`                :        The compressed string "errily, m"
                 }               :    End interpolation
                  ...,           :    "\nGently down the stream.\nRow, row, row your boat,"
                      `          :  End decompression
                       ú         :  Right pad each line with spaces to the length of the longest
                        )        :End prepend
                         ·       :Split on newlines
                          ú-     :Right pad each element with "-" to the length of the longest
£éY Å¤q|                         :Assign the above to U
£                                :Map each element at 0-based index Y
 éY                              :  Rotate U right Y times
    Å                            :  Slice off the first element
     ¤                           :  Slice off the first two elements
      q|                         :  Join with "|"
                                 :Implicit output, joined with newlines
```
[Answer]
# Ruby, 162 bytes
```
7.times{|i|puts (~i..~i+3).map{|j|[*[?-*35]*3,"Life is but a dream.",?M+['errily,']*4*" m","Gently down the stream.","Row, row, row your boat,"][j].ljust(35)}*?|}
```
[Answer]
# Java, 295 bytes / 272 259 bytes
with newlines every 4 columns (295b)
```
void r(){String m=" merrily,",t="-------",s="     ",e=t+t+t+t+t;String[]v={"Gently down the stream.  "+s+s, "Merrily,"+m+m+m, "Life is but a dream."+s+s+s, e, e, e, "Row, row, row your boat, "+s+s};for(int i=0;i<7;i++){for(int j=6+i;j>2+i;j--)System.out.print(v[j%7]+'|');System.out.println();}}
```
[Try it Online](https://tio.run/nexus/java-openjdk#XVA7b8MgEN7zK05IVexiW1WHZqB07VIvzRhlIA5pzjIQwdmR5fpnd079iJfcoQN9jwMOzcV5glI1KqsJq@xZrPARC@S1MiNVVCoEyLtb4/AIPoq7LXm0P2AkA6O9x6pNWEKSpXOwJAzMGCzRkvg9xWzb7RvZsU9tqWrh6K4W6Kzhft1g4YGHBFi@NOZmzAH5wpMGDHCoCRQcJ/2kHvV6WezbXRPw9wKtqz0cnKJk7tyLk/MRWgKULwLfNwI5j7sFLOUbR1F@vI41TeNtG0ibzNWUXYbHU9TsyqfNnq9/17F4JCsbxaLvbwCX@lBhMXxK0bBNczMKbbRMAE5xtxoHlIMBCVZfIR@8E2QyPx/7VX/7sy4tVHHW/w)
no newline version (259b):
```
void r(){String m=" merrily,",t="-------",s="     ",e=t+t+t+t+t;String[]v={"Gently down the stream.  "+s+s, "Merrily,"+m+m+m, "Life is but a dream."+s+s+s, e, e, e, "Row, row, row your boat, "+s+s};for(int i=0;i<28;i++)System.out.print(v[(6-i%4+i/4)%7]+'|');}
```
* Condensed 2 for loops into 1
[Try it Online](https://tio.run/nexus/java-openjdk#XVC5bsMwDN3zFYSAInZlG0WHZlDVtUu9NGOQQXGUhIYlBRLtwHD92Z1TH/FSUiCJx8dDRHN1nqBUjcpqwip7Fiv8jwXyWpkxVVQqBMi7e@PwCD6Kuy15tGcwkoHR3mPVJiwhydJZWBKGzCgs0ZL4Q8Vctts3smOf2lLVwtHdLNBFw2PcUMIDDwmwfGnMzagD8oUnDRjgUBMoOE78iT3y9fLYt7sl4B8GWld7ODhFydy5FyfnI7QEKF8Evm8Ech4vWCnfOIry43W0aRpv20DaZK6m7DrsTlGzK582e77@WceivwNc60OFxbC9osFNBzIKbbR8FU5xtxovkYMBCVbfII9iMUEm83PYr/r7r3VpoYqL/gM)
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 158 157 bytes
```
='|L=`Row, žw, žw yŒr ¾…,`+Sp11 +UV=`Gt§ Üµ e Ðpam.`+S³²²+UW=`M€Îk,`+` ´rÎk,`³+UJ=W+VX=`Life ‰ ¿t a Ý„m.`+Sp15 +UZ='-p35 +U[LZ³RVLZ²RJLZRXJLRZXJRZ²XWRZ³X]q
```
[Try it online!](https://tio.run/nexus/japt#JY29CsIwHMRf5b91SBWKOGYWSlwibUNFSIcKImItBREcFHQQRPoA6ure6qpwebAa6/LjDu6j4c5WcC2Xa5dw/4M2OOeEN46uZqPM84gFIdcD7As8yFzxIpQpmTJLFl2bQI0KFQsirofYmcvc1jThmbcSNQt8HrFQcS1m05RwInwKSsjccGgHMq9vL2LudLLeT41FjFqGlpX0RSyVL2SsfGm9iixrNVk1zRc "Japt – TIO Nexus")
[Answer]
# [Stax](https://github.com/tomtheisen/stax), 63 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax)
```
∞╖]ÇàI╨‼Çö¼fi╩╨╛Aóß╟uƒ←37qÄô.Z╛Θ6►Mûj╚#Å[░]Oá0"y╧o╙)5;V╞♥╬F¼♫t~
```
[Run and debug it](https://staxlang.xyz/#p=ecb75d808549d0138094ac6669cad0be41a2e1c7759f1b3337718e932e5abee936104d966ac8238f5bb05d4fa0302279cf6fd329353b56c603ce46ac0e747e&i=&a=1)
[Answer]
# [Perl 5](https://www.perl.org/), 163 bytes
```
say join'|',(('-'x26)x3,"Life is but a dream".$"x7,ucfirst(join$",("merrily,")x3),"Gently down the stream    ",ucfirst "row, "x3 ."your boat  ")[-$_..3-$_]for 1..7
```
[Try it online!](https://tio.run/##NYthCsIwFIOvEh6DbdCV1qHDE/hHTyAiUzusbKu0HW7g2a0tYniEkJfvqWy/DsG1Cx5Gj/k7Z0WRV/m82pRzzWivOwXtcJk8WtysagfiGc0Nm66dts4XCcuIFTQoa3W/MIpgyWinRt8vuJnXCH9XcD7BiKI/C7LmxUBzDU6LmSwupvVxUB6r7Mx5Hf3UGQvJeROCFIi3hUSDGqvoqUmFSBm/vxQf8/TajC5UhzUXUnwB "Perl 5 – Try It Online")
[Answer]
# [Runic Enchantments](https://github.com/Draco18s/RunicEnchantments/tree/Console), 292 bytes
```
B͍"-"'#*"|"3s
"Row, row, row your boat,"b" "S*q"|"3sB͍>01B10B3*1-akr@>12B01B10B2*1-akr@>13B12B01B10B1-akr@>14B13B12B01B1-akr@>10B3*14B1-r0[10B2*14B13B1-akr0[10B14B13B12B1-akr]]@
B͍"Gently down the stream."c" "S*q"|"3s
B͍"Merrily,"3" merrily,"S*q"|"3s
B͍"Life is but a dream."f" "S*q"|"3s
```
[Try it online!](https://tio.run/##VY67DoJAEEV7vmIyFiYEDA9rQ7ax0UZLQ7HAEjfyiMMSQuIv@Gl@E8LyEJvJ5My5N0N1IeOuY5832rjdmPhCvzLwUjYW0DSgLWuCqOTKwggBr@ZTa33o4LjMdZhvujZ/UHBwPTYSbyE@W@CM9uxHJ6Q7em6TcxvjozScNVlCGoVhYAw/H0WhshaSsilA3QVUigTPdxiv3tTiWRDJrLXQR8jn/c84yVSArCCqFXBIxp501dN1Xw "Runic Enchantments – Try It Online")
I don't generally do [kolmogorov-complexity](/questions/tagged/kolmogorov-complexity "show questions tagged 'kolmogorov-complexity'") challenges, but the layout was one I could work with without too much trouble. Runic does not have good ways to compress arbitrary strings, so all we have to work with are the repetitious parts.
### Explanation:
Uncompressing slightly:
```
B͍"-"'#*"|"3s
B͍"Row, row, row your boat,"b" "S*q"|"3s
B͍"Gently down the stream."c" "S*q"|"3s
B͍"Merrily,"3" merrily,"S*q"|"3s
B͍"Life is but a dream."f" "S*q"|"3s
>11B10B3*1-akr@
>12B11B10B2*1-akr@
>13B12B11B10B1-akr@
>14B13B12B11B1-akr@
>10B3*14B1-r0[10B2*14B13B1-akr0[10B14B13B12B1-akr]]@
```
First 5 lines act as functions to build each portion of the song (where the first line generates the 35 `-` for the spacer using the decimal value of `#` to save 2 bytes over `3X5+`). The return instruction is at the beginning of the line to insure that all IPs that enter a function will also *leave* the function after the same number of cycles to avoid IPs merging (resulting in missing lines of output), as programs are rectangular and empty cells are implicit.
The next four lines are responsible for printing the first four lines of the output
The fifth line then prints the last 3 lines of output. Due to all three lines needing to start with at least one stanza-spacer it is not feasible to use 3 separate IPs (as they would need delays in order to avoid merging). `>`, `y`, `@`, and a newline cost more bytes (4) than `0[...]` (3 bytes) where `...` is arbitrary instructions (ie. another line of output).
Conversely replacing `>` and `@` to use a single IP requires more bytes.
Finally, merging all five entry-point lines onto the 2nd line saves 5 bytes worth of newlines. We just have to insure that the `B͍`ranch-return instruction moves to the end of its line first, preserving the function's functionality.
]