[Question]
  [
in my country we have a children's song which goes like this:
```
Priletela muha na zid, muha na zid, muha na zid.
Priletela muha na zid,
muha na zid.
Pralatala maha na zad, maha na zad, maha na zad.
Pralatala maha na zad,
maha na zad.
Preletele mehe ne zed, mehe ne zed, mehe ne zed.
Preletele mehe ne zed,
mehe ne zed.
Prilitili mihi ni zid, mihi ni zid, mihi ni zid.
Prilitili mihi ni zid,
mihi ni zid.
Prolotolo moho no zod, moho no zod, moho no zod.
Prolotolo moho no zod,
moho no zod.
Prulutulu muhu nu zud, muhu nu zud, muhu nu zud.
Prulutulu muhu nu zud,
muhu nu zud.
```
As you can see, it contains a bit of redundant information. So I was wondering if it could be compressed a bit.
This is code golf — shortest code wins.
  
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~54~~ 52 bytes
Thanks to [Kevin Cruijssen](https://codegolf.stackexchange.com/users/52210/kevin-cruijssen) for -2 bytes!
```
T"ÿ, 0, 0.
ÿ,
0.
"T.•ý‹¨ΣªßˆTδ}vØ#•.ª'x¡‡žMv=žMyÞ‡}?
```
[Try it online!](https://tio.run/##yy9OTMpM/f8/ROnwfh0FAyDS4wKyuICUUojeo4ZFh/c@ath5aMW5xYdWHZ5/ui3k3JbassMzlIEyeodWqVccWvioYeHRfb5ltkCi8vA8IK/W/v9/AA "05AB1E – Try It Online")
**Commented**:
```
T                         # push 10
 "ÿ, 0, 0.\nÿ,\n0.\n"     # push string literal "10, 0, 0.\n10,\n0.\n"
  T                       # push 10 again
   .•ý‹¨ΣªßˆTδ}vØ#•       # push compressed string "priletela xmuha na zid"
    .ª                    # sentence case => "Priletela xmuha na zid"
      ‛x¡                 # split on 'x'  => ["Priletela ", "muha na zid"]
         ‡                # replace every digit of 10 with the corresponding list entry in the string literal
                          # this is the first verse
          žM              # push the vowels "aeiou"
            v      }      # for y in vowels:
             =            #   print the last verse without removing it from the stack
              žM          #   push the vowels
                yÞ        #   the infinite list of the vowel y
                  ‡       #   replace every vowel with y
                    ?     # print the last verse without a trailing newline
```
---
more obfuscated and a lot slower 52-byter:
```
•nöðrb•ØTz… ,
«ÅвJT.•ý‹¨ΣªßˆTδ}vØ#•.ª'x¡‡žMv=žMyÞ‡}?
```
[Don’t try it online!](https://tio.run/##yy9OTMpM/f//UcOivMPbDm8oSgKyDs8IqXrUsExBh@vQ6sOtFzZ5heiBRPc@ath5aMW5xYdWHZ5/ui3k3JbassMzlIEyeodWqVccWvioYeHRfb5ltkCi8vA8IK/W/v9/AA "05AB1E – Try It Online")
```
•nöðrb•              # push compressed integer 211262272027
       Ø             # push the 211262272028th prime 5996494318979 (slow)
        Tz           # push 1/10
          … ,\n      # push string " ,\n"
               «     # concatenate to "0.1 ,\n"
                Åв   # convert the prime into that custom base
                  J  # join from list of chars into a string
                     # this generates the same string as T"ÿ, 0, 0.\nÿ,\n0.\n" above
```
[Answer]
# [Ruby 2.7](https://www.ruby-lang.org/), ~~110~~ ~~105~~ 104 bytes
*Saved five bytes, thanks to [Dingus](https://codegolf.stackexchange.com/users/92901/dingus)!*  
*Saved a byte using [Arnauld's finding](https://codegolf.stackexchange.com/a/216416/83605).*
```
puts z="#{y="Priletela #{$x='muha na zid'},"} #$x, #$x.
#{y}
#$x.","aeiou".chars.map{z.gsub /[aeiu]/,_1}
```
[Try it online!](https://tio.run/##FYpNCoYgFAD3neLxDNqIncA7tI8WLz8poT@0B6V5dr/aDAMznse7lIPPAFGjSLfGzrvFnnYhEKm@dLPyTLARRPdrssQMor7kB1W9f64@Q4lkHaMyM/mgVjrSY56opsAjtP3bdh5aaXIpfw "Ruby – Try It Online")
TIO uses an older version of Ruby, whereas in Ruby 2.7, we've numbered parameters, which saves two bytes.
[Answer]
# JavaScript (ES6), ~~121~~ 120 bytes
```
_=>["$&",..."aeiou"].map(v=>`${p=`Priletela ${q='muha na zid'},`} ${q}, ${q}.
${p}
${q}.`.replace(/[aeiu]/g,v)).join`
`
```
[Try it online!](https://tio.run/##HYxLDoMgFEXnrMIQUyGhzxXgGjo3prwoWgwCfgc1rJ1aJzcnJzl3xAPXdjFhezrf6dTL9JZVTfMHFQBAURu/0wYmDOyQlcrPINVrMVZv2mKWn7Mspv2DmcPsa7oiChX/Nop7gVxBJDcqWHSw2GpW1tft3pSDODiH0RunCFGp9W71VoP1A@sZ5@kH "JavaScript (Node.js) – Try It Online")
### Commented
```
_ =>                            // anonymous function ignoring its input
 [                              //
    "$&",                       // 1st stanza: use "$&" to leave the vowels unchanged
    ..."aeiou"                  // next ones: force all vowels to "a", "e", ..., "u"
  ]                             //
  .map(v =>                     // for each replacement pattern v:
    `${                         //   build the stanza template
      p = `Priletela ${         //     by defining p = "Priletela muha na zid,"
        q = 'muha na zid'       //     and q = "muha na zid"
      },`                       //
    } ${q}, ${q}.\n${p}\n${q}.` //     and using them to build the other parts
    .replace(                   //   update the template:
      /[aeiu]/g,                //     replace each vowel ...
      v                         //     ... with the replacement pattern
                                //     NB: there's no "o" in the template
    )                           //   end of replace()
  ).join`\n\n`                  // join with two line-feeds
```
[Answer]
# [Python 2](https://docs.python.org/2/), 122 bytes
```
s="Priletela muha na zid,"
v="aeiou_"
for x in v:
 w=s[10:-1]+".\n";print s,s[10:],w+s+"\n"+w
 for y in v:s=s.replace(y,x)
```
[Try it online!](https://tio.run/##dZHBbsMgDIbvfgqL06ZkaN2xU96h962arM0VSASiAE2Tl88g7aFI4eDDb32fLcMwB@Xsx7r6TpxGbTiwIeyjIrSEi/5rBVw7Qaxd/BFwcSPeUFu8HgGnzn8d3o9vh3Mj5LcVn8OobUDfbu1zOzW@EanfTIBZnO@i77wceTD0yy9ze3td1/3F1SBhX4CCSRAZCpQhevQpD6oEWRGgYBLE22rGnhWjZVw4D6oEWRGgYLaDdEiFvVYarX4cXQmyIkDBJMgZF1Jh75RD63BxeVAlyIoABZOgaGJIlR8/oo24xPsH7QZZEeCZ@Qc "Python 2 – Try It Online")
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), ~~146~~ 134 bytes
```
w="muha na zid";a="Priletela ";s=""<>{a,w,", ",w,", ",w,".
",a,w,",
",w,"."};c=Characters@"aeiou";s<>(StringReplace["
"<>s,c->#]&/@c)
```
[Try it online!](https://tio.run/##TYxBCsIwEEX3OUUYQRRSPUCaUPACoktxMcTBBJJakikFxbPHQDeuHv/xeQnZU0IODmtdDKTZoxxRvsMDNBo45xCJKaIEXQxAbz@oFgVKwh8OAtSqxbrhq505eczomHIZACm85pbo7e7KOYzPC00RHd1AiBYtynV2c98eB7evtXZTu/AP "Wolfram Language (Mathematica) – Try It Online")
[Answer]
# [Bash](https://www.gnu.org/software/bash/) + sed, 98 bytes
```
sed -ney/{%/\\n,eiu/aaa,a/e,e/i,i/o,o/u}/\;p<<<"${x=Priletela ${y=muha na zid}}, $y, $y.%$x,%$y.%"
```
[Try it online!](https://tio.run/##FcXBCYAwDADAVYK0v2gGsO7gAP1EDBjQKmrBWjp7xcdxE19LrZfM0AZJlC15H1A0EjMjk6CQotKOO8VCvj@cc43JzzCeusotK4PJadjiwhAYXp1LQTDp11nzoP1vav0A "Bash – Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 62 bytes
```
3,2µ“muha na zid”Wẋjị⁾ ¶ṭ”,Ɗ⁶;“!b^ṙzḳ“)»j)Y
ØẹµØẹW;y¢)¢W¤;j⁾¶¶
```
[Try it online!](https://tio.run/##y0rNyan8/99Yx@jQ1kcNc3JLMxIV8hIVqjJTHjXMDX@4qzvr4e7uR437FA5te7hzLVBM51jXo8Zt1kC1iklxD3fOrHq4YzOQo3lod5ZmJNfhGQ937Ty0FUyFW1ceWqR5aFH4oSXWWUAjDm07tO3/fwA "Jelly – Try It Online")
## Explanation
```
3,2µ“muha na zid”Wẋjị⁾ ¶ṭ”,Ɗ⁶;“!b^ṙzḳ“)»j)Y   Auxiliary niladic link
3,2                                           [3, 2]
   µ                                     )    For each:
    “muha na zid”W                              ["muha na zid"]
                  ẋ                             Repeat that many times
                   j       Ɗ                    Join with:
                    ị⁾ ¶                          Index with the number into " \n"
                        ṭ”,                       Append that to ","
                            ⁶;                  Prepend a space
                              “!b^ṙzḳ“)»j       Join ["Priletela", "."] with this
                                          Y   Join with a newline
ØẹµØẹW;y¢)¢W¤;j⁾¶¶   Main niladic link
Øẹ                   "aeiou"
  µ      )           For each:
   ØẹW                 ["aeiou"]
      ;                Append the vowel
       y¢              Translate the result of the previous link with this table
          ¢W¤;       Prepend list with result of previous link
              j⁾¶¶   Join with double newlines
```
[Answer]
# [Red](http://www.red-lang.org), 150 bytes
```
e: rejoin[a:"Priletela "b:"muha na zid"c:", "b c b d:".^/"a b c"^/"b d]v:
charset w:"aeiou"foreach u w[print e parse e[any[change v u | skip]]]print e
```
[Try it online!](https://tio.run/##LYvBCsIwEAXvfsVjz6L3/QrxGiJsk9VGaxLSpkXx32MEb8MwU9S3s3pjmzKK3lOIRphOJUy66CSggelZR0EUvIMnx7TvEg4DPNPhciTp6KhDN3blnRulzLpgYxINqdI1FRU3omIzuYS4QJF/DdRIfJk@xJti7cEH8yNka@2/a@0L "Red – Try It Online")
[Answer]
For a start, this is my attempt in Javascript:
# [JavaScript (Node.js)](https://nodejs.org), 184 bytes
```
a='aeiou'
x='muha na zid'
y='Priletela'
z=`${y} ${x}, ${x}, ${x}.\n${y} ${x},\n${x}.`
console.log([z].concat(a.split('').map(e=>z.replace(new RegExp('['+a+']', "g"), e))).join('\n\n'))
```
[Try it online!](https://tio.run/##TYhLCoMwFAD3niKI8BK0uUG66750q4IPfdhITIKfViOe3dpVuxlmpsMXjvWg/XSxrqHjQAVI2s0QLQr6@YnMIgu6gWhVcB@0oYkMQhRUlWzrzpJt2bM/ysL@/tfPVUW1s6MzJI1reR5KeXaNE0c5eqMnDiBkj56TugY5kDdYE7f0Zg9qb4vnkEOKKZSQsbiNRcZICCE7py2HwhYWhDiODw "JavaScript (Node.js) – Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 58 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
I feel like `”u”aØẹe?ṙ1Øẹ,y` could be golfed
```
”u”aØẹe?ṙ1Øẹ,y
820Dṃ“!b^ṙzḳ“¢ʋỴM$ƊEⱮ/¥ɦ8»K€YF”.0,48¦ÇƬj⁾¶¶
```
**[Try it online!](https://tio.run/##y0rNyan8//9Rw9xSIE48POPhrp2p9g93zjQEM3UquSyMDFwe7mx@1DBHMSkOKFH1cMdmIOfQolPdD3dv8VU51uX6aOM6/UNLTy6zOLTb@1HTmkg3oFF6BjomFoeWHW4/tibrUeO@Q9sObfv/HwA "Jelly – Try It Online")**
[Answer]
# [Perl 5](https://www.perl.org/) (`-0777p`), 91 bytes
```
s//Priletela muha na zid/;/ /;$_.=", $', $'.
$_,
$'.
";for$i(a,e,i,o,u){say;s/[aeiou]/$i/g}
```
[Try it online!](https://tio.run/##FcWxCsIwEADQvV8RSkCFa64OJUPwE4TuIuXAqAexCUkzVPHXPenweMnnMIgUxDFz8IsPpF71SWom9eYbOlTo9GROLSi925hGT9Bst@4es@Y9gQeGCPXwKbS6ghfyHOsVNePjK/KLaeE4F@nOg@mP0vXW2vQH "Perl 5 – Try It Online")
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 84 bytes
```
.•bKÜ2TÐhrŒ°•'b.•[÷‚rµ₃•™:'c.•AΩJεмF‚•:…fgj…,.
‡DžMŽh’‡1'a‡D'a'e‡D'e'i‡D'i'o‡D'o'u‡»
```
[Try it online!](https://tio.run/##yy9OTMpM/f9f71HDoiTvw3OMQg5PyCg6OunQBqCAehJIOPrw9kcNs4oObX3U1AzkPmpZZKWeDJJwPLfS69zWC3vcgNJArtWjhmVp6VlAUkeP61HDQpej@3yP7s141DATyDFUTwQJqSeqp4LpVPVMMJ2png@m89VLgfSh3f//AwA "05AB1E – Try It Online")
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~154~~ ~~152~~ 146 bytes
I wrote nonprintables that won't show up on SE in hex using `<kbd>`.
```
i,p[]=L"muha na zid`0x00`Priletela ";main(){for(;i<48;p["`0x14``0x12``0x10``0x0e``0x09``0x06``0x03``0x01`"[i%8]]="aeiou"[i++/8])i%8?:printf("%S%S, %2$S, %2$S.\n%1$S%2$S,\n%2$S.\n\n",p+12,p);}
```
[Try it online!](https://tio.run/##S9ZNT07@/z9TpyA61tZHKbc0I1EhL1GhKjOFIaAoMye1JDUnUUHJOjcxM09Dszotv0jDOtPGxMK6IFpJREiAj5ONmVEpOlPVIjbWVikxNTO/FMjT1ta3iNUECtpbFRRl5pWkaSipBqsG6yioGqlASb2YPFVDlWCwAJAJEYnJU9Ip0DY00inQtK79/x8A "C (gcc) – Try It Online")
```
#include <stdio.h>
int main(void)
{
    // These are merged together with a raw null byte in the golfed code.
    // I set them to wchar_t (L"") solely because of implicit int, cuz screw
    // Windows and its UTF-16. :P
    char pril[] = "Priletela"; // golfed code has trailing space
    char muha[] = "muha na zid";
    // The golfed code does a different loop pattern where it does one big
    // loop which replaces a char each iteration and prints when i%8==0.
    // However, that is difficult to follow.
    for (int i = 0; i < 6; i++) {
        // Note: golfed code doesn't use positionals on the first two arguments,
        // and it uses %S because they are wchar_t strings.
        //
        // Priletela muha na zid, muha na zid, muha na zid.
        // %1$s      %2$s       , %2$s       , %2$s       .\n
        // Priletela muha na zid,
        // %1$s      %2$s       ,\n
        // muha na zid.
        // %2$s       .\n\n
        printf("%1$s %2$s, %2$s, %2$s.\n%1$s %2$s,\n%2$s\n\n", pril, muha);
        // Replace the vowels one by one.
        // The golfed version loops 8 times since it is one string.
        for (int j = 0; j < 4; j++) {
            // Nope, never y.
            const char vowels[] = "aeiou";
            // Vowel indexes. This is encoded in a binary string in the golfed
            // code, and it is one array because the strings are merged.
            const int pril_lut[] = { 2, 4, 6, 8 };
            const int muha_lut[] = { 1, 3, 6, 9 };
            pril[pril_lut[j]] = vowels[i];
            muha[muha_lut[j]] = vowels[i];
        }
    }
}
```
~~Unless we find a way to kill the printf string, I don't see any other options to make this smaller.~~ I have clearly been proven wrong more than once. :P
-2 bytes thanks to ceilingcat for better variable declaration and looping backwards.
-6 bytes thanks to gastropner for ~~making me eat my words~~ combining the two for loops.
[Answer]
# [Vim](https://www.vim.org/), 95 bytes
```
iPriletela<esc>3a muha na zid,<esc>r.Ypo<esc>k7f r
k4f Dk4YGoaeiou<esc>:s/./&<C-r>0/g
5Gqrx:,+2s/[aeiu]/<C-r>"/g
2jq4@r
```
[Try it online!](https://tio.run/##K/v/PzOgKDMntSQ1J9EmtTjZzjhRIbc0I1EhL1GhKjNFByxWpBdZkA9mZZunKRRxZZukKbhkm0S65yemZuaXgmWsivX19NVsnHWL7Az007lM3QuLKqx0tI2K9aOBikpj9cFSSkApo6xCE4ei////65YBAA "V (vim) – Try It Online")
This approach leaves two blank lines at the end of the song. If that's not acceptable, add `Vkd` to the end for +3 bytes: [Try it online!](https://tio.run/##K/v/PzOgKDMntSQ1J9EmtTjZzjhRIbc0I1EhL1GhKjNFByxWpBdZkA9mZZunKRRxZZukKbhkm0S65yemZuaXgmWsivX19NVsnHWL7Az007lM3QuLKqx0tI2K9aOBikpj9cFSSkApo6xCE4eisOyU////65YBAA)
### Explanation
```
iPriletela<esc>3a muha na zid,<esc>r.
```
Insert `Priletela`; then append three copies of  `muha na zid,` and replace the last comma with a period.
```
Ypo<esc>
```
Duplicate the line and insert a blank line below the second copy.
```
k7f r<cr>k4f D
```
Replace the seventh space on the second line with a newline. Go back up to the second line and delete from the fourth space to the end of the line. We now have the first verse of the song.
```
k4YGoaeiou<esc>
```
Go up to the first line and yank all four lines. Then insert `aeiou` after the last line.
```
:s/./&<C-r>0/g
```
Replace each letter of `aeiou` with itself followed by the yanked lyrics.
```
5Gqr
```
Go to line 5 (the start of the second verse) and begin recording into macro `r`.
```
x
```
Delete the first character, which is the `a` prepended to the verse.
```
:,+2s/[aeiu]/<C-r>"/g
```
Within this line and the next two (i.e. this verse), replace any of `aeiu` with the character we just deleted.
```
2jq
```
Go down two lines to the start of the next verse. Stop recording the macro.
```
4@r
```
Run the macro four more times, converting the four remaining verses.
[Answer]
# PHP 8, ~~170~~ 166 bytes
This is [the JavaScript solution of @jgosar](/a/216412/40534) rewritten in PHP and improved.
```
$a='aeiou';$x='muha na zid';$y="Priletela $x,";echo implode("
",array_merge([$z="$y $x, $x.
$y
$x."],array_map(fn($e)=>preg_replace("/[$a]/",$e,$z),str_split($a))));
```
The code is not wrapped on multiple lines for readability but because this way a real newline character embedded in a string uses only one byte vs. two bytes used by the escape sequence `\n`.
[Try it online!](https://tio.run/##NYxRCoMwEET/c4oQFowQ6gFs2iv0X0SWujWBqEtUMF4@TT86MAw8HsOOc74/2bEAtBWSX4@qhdNW8@FQLigvPxaQrHpFH2ingBJOo1p6u1X6mcM6klZCKIMxYhpmihPpDi6rIP3U0puAJMqo/i8h68@igWr74EjTEIkDvstR0wH2jTJABq7abHscNg5@14B1SZvzFw)
[Answer]
# [Retina](https://github.com/m-ender/retina/wiki/The-Language), 70 bytes
```
Pm, m, m.¶Pm,¶m.¶
P
Priletela 
m
muha na zid
~(K`vaeiou
L$`.
\T`vo`$&
```
[Try it online!](https://tio.run/##K0otycxLNPz/nysgV0cBhPQObQMyD20DMbgCuAKKMnNSS1JzEhW4crlySzMSFfISFaoyU7jqNLwTyhJTM/NLuXxUEvS4YkISyvITVNT@/wcA "Retina – Try It Online") Explanation:
```
Pm, m, m.¶Pm,¶m.¶
```
Insert placeholders for the first verse.
```
P
Priletela 
m
muha na zid
```
Expand the placeholders.
```
~(`
```
Compose and execute a Retina script.
```
K`vaeiou
```
Create a list of transliteration targets.
```
L$`.
\T`vo`$&
```
Expand each target into a transliteration command that transliterates vowels into the given target and outputs the verse after the transliteration. The resulting script is as follows:
```
\T`vo`v
\T`vo`a
\T`vo`e
\T`vo`i
\T`vo`o
\T`vo`u
```
Here the `v` represents the vowels `aeiou`. The `o` on its own usually means "insert the other set", however this has no effect on the transliteration as the vowels are already present. The exception is the `T`vo`o` command, where the presence of `o` on both sides causes it to be treated as a literal, although this does not affect the expansion either.
[Answer]
# [Lua](https://www.lua.org/), 150 bytes
Just because Lua doesn't get enough love.
```
a='aeiou'for i=0,5 do print((('pm, m, m.\npm,\nm.\n'):gsub('p','Priletela '):gsub('m','muha 
na zid'):gsub('['..(i>0 and a or'_')..']',a:sub(i,i))))end
```
:gsub():gsub():gsub() :-)
[Answer]
# [Java (JDK)](http://jdk.java.net/), 161 bytes
```
v->{for(var s:"$0,a,e,i,o,u".split(","))System.out.print(s.format("%s%s, %2$s, %2$s.%n%1$s%2$s,%n%2$s.%n%n","Priletela ","muha na zid").replaceAll("[aeiu]",s));}
```
[Try it online!](https://tio.run/##LY5Ba8MwDIXv/RXCJBAP12w7Llth7Dw26LH0oLpO58yxgyUHtpLfnnmhF0nve9JDPU647c/fixvGmBj6onVm53WXg2EXg75rN8YjEbyjC3DdAIz55J0BYuTSpujOMBSv2XNy4XI4AqYLyXUV4C0GyoNNzx@n3hreQQcvsEzb3bWLqZkwAT2J6l6hssqpqLLQNHrHjVBCyv0PsR10zKzHEs4N6XI2YLFrqklB/Vjdqq5D/VDRCsp4I6HEfCbnLVuPUMSQvxACwq87C6mTHT0a@@p9Iw5oXT4KRVK289Ku33cajbEjNyF7L//ZvJmXPw "Java (JDK) – Try It Online")
## Credits
* -1 byte thanks to [Kevin Cruijssen](https://codegolf.stackexchange.com/users/52210/kevin-cruijssen)
[Answer]
# PHP 7.4, 164 bytes
This is the same as [my solution for PHP 8](/a/216420/40534) but it does not surround the value of `$a` (`aeiou`) in apostrophes or quotes and saves 2 bytes. This exploits the fact that before PHP 8, the undefined constants were reported as warning and converted to strings. This behaviour changed in PHP 8, they are now reported as errors and the code does not work any more.
```
$a=aeiou;$x='muha na zid';$y="Priletela $x,";echo implode("
",array_merge([$z="$y $x, $x.
$y
$x."],array_map(fn($e)=>preg_replace("/[$a]/",$e,$z),str_split($a))));
```
In order to hide the warnings, the option `-d error_reporting=0` needs to be added to the command line (or set in `php.ini`).
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), 76 bytes
```
Ac." zMzÊ(ºZ¾þXGÈ-gÚe¿P"\qJ", "K+\.b
=s[GHJHJHKGH\,bHK)V=d"aeiou":G++\[d\]N
```
[Try it online!](https://tio.run/##K6gsyfj/3zFZT0mhyrfqcJfGoV1Rh/Yd3hfhfrhDN53j8KzUQ/sDlGIKvZR0FJS8tWP0krhsi6PdPbyA0NvdI0YnycNbM8w2RSkxNTO/VMnKXVs7JjolJtbv/38A "Pyth – Try It Online")
---
Python 3.8 translation:
```
import re
b = "\n"
[G, H] = "Priletela qmuha na zid".split("q")
J = ", "
K = "." + b
print(G := "".join([G,H,J,H,J,H,K,G,H,",",b,H,K]))
for N in (d := "aeiou"):
    print(re.sub("[" + d + "]", N, G))
```
[Answer]
# [Python 3.8 (pre-release)](https://docs.python.org/3.8/), 138 bytes
```
s="Priletela muha na zid, "
v="aeiou_"
n='\n'
print(n.join([[s+s[10:]+(w:=s[10:-2]+n)+s+n+w,[s:=s.replace(y,x)for y in v]][0]for x in v]))
```
[Try it online!](https://tio.run/##dZFNasMwEEb3OsXgTWzkirTdlIDv0L1riminWEUeGVlKYl/elZwsasgsBvSG943@xjn0jl7fRr@uU1O8e2MxoNUwxF4DaVjMdw2FODeFRuPiZyGoOXzQQYzeUChJ/TpDZdtOcmqfj6dOlpdTsy2fXjpJlZwkyUvdTqmrPI5Wf2E519fqx3mYwRCcu649dhmvN6yqdWUOwoESjwNi5yRJWx10lvS9r/MgBhQTEDsnSbhtjTBgj0AIC@ZBDCgmIHbOdiETUsFgegNk7pdmQDEBsXOS5KwLqWBwvQNysLg8iAHFBMTOSVK0MaTKjx@BIizx9kEPQTEB8d/5Aw "Python 3.8 (pre-release) – Try It Online")
Modified version of [answer by xnor](https://codegolf.stackexchange.com/a/216441/100510) using list comprehension. It is not shorter, but it has fewer lines, so I thought I'd post it.
[Answer]
# [Vyxal](https://github.com/Lyxal/Vyxal) `j`, 68 bytes
```
1→a`10, 0, 0.
10,
0.`₀
«ƛ&…-∪⋎5wµ\Ė⌊ɾ≤«¡\x€Ŀ£¥kV⇩(←a›→a ¥nkV⇩←a iV)W
```
[Try it Online!](http://lyxal.pythonanywhere.com?flags=j&code=1%E2%86%92a%6010%2C%200%2C%200.%0A10%2C%0A0.%60%E2%82%80%0A%C2%AB%C6%9B%26%E2%80%A6-%E2%88%AA%E2%8B%8E5w%C2%B5%5C%C4%96%E2%8C%8A%C9%BE%E2%89%A4%C2%AB%C2%A1%5Cx%E2%82%AC%C4%BF%C2%A3%C2%A5kV%E2%87%A9%28%E2%86%90a%E2%80%BA%E2%86%92a%20%C2%A5nkV%E2%87%A9%E2%86%90a%20iV%29W&inputs=&header=&footer=)
[Answer]
# JavaScript, 137 bytes
```
o="";for(v of ["$&",..."aeiou"])for(c of`12, 2, 2.
12,
2.
`)o+=+c?[,"Priletela ","muha na zid"][c].replace(/[aeiu]/g,v):c;console.log(o)
```
[Try it Online!](https://tio.run/##FYzLCoMwEEX3fkUYSjGYRtplRfoL3YeAYRxtSnQkPhb9@TTChXPgwP26w60Y/bLdZu4pJW4BmoFjeQgehIHLFZTWGhx53sHKM2FO3f2hxDldZCsyik5y1Vb4Mgre0QfaKDgBCqb948TsxM/3YA1aHWkJDqmsTX7dbT2qQz6xQZ5XDqQDjyXLlP4)
## Explanation:
```
o="";                              // Define o
  for(v of ["$&",..."aeiou"])      // Repeat for each vowel + $& 
                                      being the RegExp returned value.
    for(c of`12, 2, 2.             // Numeric values will be replaced later on
    12,  
    2. 
      
    `)
      o+=                          // Add at the end of o...
        +c?                        // ...if c is numeric (NaN being falsey):
          [,"Priletela ",          // replace it by the index of the array...
          "muha na zid"][c]
            .replace(/[aeiu]/g,v)  // ...and replace every vowel by the current 
                                      vovel (or $& which doesn't affect it)
              :c;                  // otherwise, add c
                console.log(o)     // Finally, output o
```
]