[Question]
  [
## Background
The Zundoko Kiyoshi function originates from [this tweet](https://twitter.com/kumiromilk/status/707437861881180160) by kumiromilk. Translated from Japanese, it reads roughly as follows:
> 
> The test for my Java lecture had a problem that said "Implement and describe your own function". I made it continuously output either "zun" or "doko" randomly; if the sequence "zun", "zun", "zun", "zun", "doko" appears, it outputs "ki-yo-shi!" and terminates. Then I got full marks and earned a unit.
> 
> 
> 
This is in reference to Kiyoshi Hikawa's song Kiyoshi no Zundoko Bushi: when he sings the aforementioned line, the crowd cheers "ki-yo-shi!" in response.
## Task
Write a program or function that takes no input and replicates the behavior outlined in the tweet:
* Repeatedly output either `zun` or `doko`, choosing uniformly randomly each time.
* If the sequence `["zun", "zun", "zun", "zun", "doko"]` appears in the output, output `ki-yo-shi!` and halt.
Example output:
```
doko
zun
zun
doko
doko
zun
zun
zun
zun
zun
doko
ki-yo-shi!
```
## Rules
* This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so shortest answer in bytes wins.
* Your output can be a list of strings, or each string printed with some delimiter.
* Your output has to be non-deterministic.
  
[Answer]
# JavaScript (ES6), 72 bytes
```
f=x=>x%17^2?['doko ','zun '][j=Math.random()*2|0]+f(x<<7|j):'ki-yo-shi!'
```
[Try it online!](https://tio.run/##y0osSyxOLsosKNHNy09J/f8/zbbC1q5C1dA8zsg@Wj0lPztfQV1Hvao0T0E9NjrL1jexJEOvKDEvJT9XQ1PLqMYgVjtNo8LGxrwmS9NKPTtTtzJftzgjU1H9f3J@XnF@TqpeTn66RpqGpoK2gnpMnromF4Ximv8B "JavaScript (Node.js) – Try It Online")
### How?
We keep track of the last 5 words in a 32-bit integer stored in \$x\$ (which is initially undefined). At each iteration, we left-shift it by 7 positions and set the LSB to \$0\$ for *doko* or \$1\$ for *zun*.
The sequence *zun, zun, zun, zun, doko* results in:
```
x = **1**000000**1**000000**1**000000**1**000000**0**
```
or \$270549120\$ in decimal, which is the only value for which we have \$x\equiv 2\pmod{17}\$, as shown [in this table](https://tio.run/##fZDNasMwEITveoo5pETCsUhdSghxeusT5FgKUS01dbEl4wgjcP3s7sr9IS0mc9FIs/q0q3fVqXPRlo1PrdNmHAtnz64ysnInvkSjvDetxQe@ZUKjrDb6N/kS5doUZa2q6GuncbvBUrA/tPRHSXpdyZwnGnt1La@xx3qHGjnuMlqTRKBnQJjOyTxJKV9KS9taenfwbWlPPBOyUfrgVev5/Qpr8SwJ9qiKN95h/zDdDshzbKj/ThDmsnUWZzwCi57AQxxx0Yd5eLaN9OF/yUXFdkojjAfc0EeJ2bJMDEd6V7BhHD8B). This is our halt condition.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~54~~ ~~50~~ 44 ~~43~~ ~~42~~ ~~39~~ 37 bytes
```
[.•BΓßb¥•#TΩDˆè¯J30bÅ¿#}"ki-yo-shi!"»
```
[Try it online!](https://tio.run/##yy9OTMpM/f8/Wu9RwyKnc5MPz086tBTIVA45t9LldNvhFYfWexkbJB1uPbRfuVYpO1O3Ml@3OCNTUenQ7v//AQ) 
~~I doubt string compression is going to help here. Prove me wrong.~~ It did help. -5 thanks to @Kevin
Forgive me, Adnan, for writing such a long program.
## Explained (old)
```
[1ÝΩ
```
First of all, we start an infinite loop, generate the range `[0, 1]` and pick a random object from that list. 
```
D
```
We then duplicates that random number for later use. 
```
.•BΓßb¥•#
```
Next, we push the compressed string "doko zun" and split it upon spaces.
```
sè,
```
Then, we swap that splitted string and the randomly generated number from earlier and index the string at that position. `,` prints the word to STDOUT.
```
ˆ¯5.£J
```
Here's where the fun begins. After the indexing and printing, we are left with the original random number on the stack. We append it to the global array and then push the global array to obtain the last 5 items from the list. This will be a string of 1s and 0s. The joining is simply to mould the list into a single string. 
```
30b
```
We then convert the number 30 into its binary representation: 11110. This represents four zuns followed by a doko, as that's the order they appear in the compressed string from earlier. 
```
Q#]
```
Then, we check to see if the last 5 items (which we joined into a string) is equal to the binary of 30. If it is, the infinite loop will stop, moving on to the next step. Otherwise, the above steps are repeated again. 
```
"ki-yo-shi!",
```
At this stage, the loop has finished, meaning all that is left to do is print the required end string. 
[Answer]
# [C#](https://docs.microsoft.com/en-us/dotnet/csharp/), ~~347~~ ~~255~~ ~~170~~ ~~119~~ ~~115~~ 92 Bytes
```
for(int k=3;k!=1;Write(k%2<1?"zun ":"doko "))k=k<<7^new Random().Next(2);Write("ki-yo-shi!")
```
# Explanation
```
// Only every 7th bit changes
// k is set to three so that the code won't terminate until
// at least 5 shifts have occured
// Terminate when k is one
// so that every 7th bit matches 00001
for(int k=3;k!=1;){
    k=k<<7;
    // Shift the bits in k
    k=k^new Random().Next(2);
    // Set the last bit to random value
    Write(k%2<1?"zun ":"doko ")
    // Output zun or doko based on last bit 
//zun = 0, doko = 1. kiyoshi = 00001
}
//we only get here if we have 00001
Write("ki-yo-shi!")
```
[Try it online!](https://tio.run/##Sy7WTS7O/P8/Lb9IIzOvRCHb1tg6W9HW0Dq8KLMkVSNb1cjG0F6pqjRPQclKKSU/O19BSVMz2zbbxsY8Li@1XCEoMS8lP1dDU88vtaJEw0gTqk8pO1O3Ml@3OCNTUUnz/38A "C# (Visual C# Interactive Compiler) – Try It Online")
~~Added a TIO link and also saved almost 100 bytes :) (Not counting the `class Program` + `static void Main()` declarations and also implied `using System`).~~
~~My friends and I went back and forth with what I had originally and ended up with this. Basically cut the bytes in half. You can potentially run out of memory in the rare scenario that you never get a kiyoshi but whatever.~~
Thanks to Kevin and monicareinstate in the comments, this is now 119 bytes. Using the interactive compiler instead you can put functions outside of the main function and it implies `using`. 
Last edit: we got this to 92 bytes! Can't even believe it given how verbose C# is.
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), 44 ~~42~~ ~~40~~ 38 bytes
```
Wn30i>5Y2%2>"dzoukno"eaYO2;"ki-yo-shi!
```
[Try it online!](https://tio.run/##K6gsyfj/PzzP2CDTzjTSSNXITimlKr80Oy9fKTUx0t/IWik7U7cyX7c4I1Px/38A "Pyth – Try It Online")
**Approach**: Repeatedly generate a random number from the set {0, 1} using `O2`. Store that number in the array `Y` and use it to index into the string `"dzoukno"` (which is `"zun"` and `"doko"` interleaved). Once the last five elements of `Y` are `[1,1,1,1,0]`, break the loop and print `"ki-yo-shi!"`.
[Answer]
# [K4](https://kx.com/download/), ~~56~~ ~~48~~ ~~47~~ 46 bytes
**Solution:**
```
{x,1?$`zun`doko}/[75-2/:<-5#;()],,"ki-yo-shi!"
```
**Example:**
```
q)k){x,1?$`zun`doko}/[75-2/:<-5#;()],,"ki-yo-shi!"
"doko"
"zun"
"doko"
"doko"
"doko"
"doko"
"doko"
"doko"
"doko"
"zun"
"zun"
"zun"
"zun"
"zun"
"zun"
"doko"
"ki-yo-shi!"
```
**Explanation:**
Generate `zun` or `doko` and append to a list whilst the distinct set of the last 5 elements aren't `zun zun zun zun doko`, and add `ki-yo-shi!` to the end.
Indices to order `zun zun zun zun doko` ascending are `4 0 1 2 3`. Converted from base-2 yields 75. Other combinations will not yield the same result.
```
{x,1?$`zun`doko}/[75-2/:<-5#;()],,"ki-yo-shi!" / solution
                                 ,"ki-yo-shi!" / 1-item list of "ki-yo-shi!"
                                ,              / append to
{              }/[          ;  ]               / {function}/[while;starting value]
                             ()                / empty list
                         -5#                   / take last 5 elements
                        <                      / indices to sort ascending
                     2/:                       / convert from base 2
                  75-                          / subtract from 75
     $`zun`doko                                / string ($) -> ("zun";"doko")
   1?                                          / choose (?) 1 item from domain ("zun";"doko")
 x,                                            / append to input
```
**Extra:**
* **[K (oK) TIO](https://tio.run/##y9bNz/7/X6O6QsfQXiWhqjQvISU/O79WP9rcVNdI30bXVNlaQzNWU0dHKTtTtzJftzgjU1Hp/38A "K (oK) – Try It Online")** for **47 bytes** as we need an extra set of brackets but can drop a colon...
[Answer]
# [Python 2](https://docs.python.org/2/), ~~102 101 97 95 92~~ 91 bytes
*-3 bytes thanks to @dingledooper !*  
*Thanks @JhynjhiruuRekrap for reminding that Python source code can include unprintable characters!*  
*Thanks @xnor for saving 1 byte!*
```
import os
s=1
while~s%32:s+=s-(os.urandom(1)>"");print"dzoukno"[~s%2::2]
print"ki-yo-shi!"
```
[Try it online!](https://tio.run/##K6gsycjPM/r/PzO3IL@oRCG/mKvY1pCrPCMzJ7WuWNXYyKpY27ZYVyO/WK@0KDEvJT9Xw1DTTqleSdO6oCgzr0QppSq/NDsvXykaqNrIysoolgsinp2pW5mvW5yRqaj0/z8A "Python 2 – Try It Online")
Stores the history as bits in the integer s, where 0,1 corresponds to "zun" and "doko". Each time, shift `s` by 1, then subtract the new bit. Stops when the lowest 5 bits of s are 11111, aka `~s%32 == 0`.
Generates a random 0 or 1 by generating a random byte, then checking if the byte is more than 127.
```
 os.urandom(1)>"{unprintable DEL character}"
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 36 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
2Xµị“zun“doko”Ṅȧ;ɼḄß“ki-yo-shi!”%?32
```
A full program which takes no input and prints as it runs.
**[Try it online!](https://tio.run/##y0rNyan8/98o4tDWh7u7HzXMqSrNA5Ip@dn5jxrmPtzZcmK59ck9D3e0HJ4PFM7O1K3M1y3OyFQESqraGxv9/w8A "Jelly – Try It Online")**
### How?
```
2Xµị“zun“doko”Ṅȧ;ɼḄß“ki-yo-shi!”%?32 - Main Link (no arguments)
2                                    - literal two
 X                                   - random number in [1..x] -> z = 1 or 2
  µ                                  - start a new monadic chain, f(z)
    “zun“doko”                       - list of strings = ["zun", "doko"]
   ị                                 - index into -> v = "zun" or "doko"
              Ṅ                      - print v and a newline and yield v
               ȧ                     - (v) logical AND (z) -> z 
                 ɼ                   - recall from the register (initially 0), apply
                                     -     the following and store the result back
                                     -     into the register:
                ;                    -   concatenate
                  Ḅ                  - convert from base-2 (e.g. [0,2,1,1,1,1,2] -> 96
                                     -     since 0×2⁶+2×2⁵+1×2⁴+1×2³+2×2²+1×2¹+2×2°=96)
                                 ?   - if...
                                % 32 - ...condition: modulo 32 (is non-zero)
                   ß                 - ...then: call this Link again (Main Link)
                    “ki-yo-shi!”     - ...else: string "ki-yo-shi!"
                                     - implicit print
```
[Answer]
# [APL (Dyalog Classic)](https://www.dyalog.com/), 54 bytes
```
({⍵⌷'zun' 'doko'}¨⍪∘?∘2⍣{1 1 1 1 2≡¯5↑⍺}⍬)'ki-yo-shi!'
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT9dNzkksLs5M/v@ooz39v0b1o96tj3q2q1eV5qkrqKfkZ@er1x5a8ah31aOOGfZAbPSod3G1oQIEGj3qXHhovemjtomPenfVPupdo6menalbma9bnJGpqA4y8X86VzoA "APL (Dyalog Classic) – Try It Online")
## Explanation
```
({⍵⌷'zun' 'doko'}¨⍪∘?∘2 {1 1 1 1 2≡¯5↑⍺} )'ki-yo-shi!'
                                        ⍬              ⍝ Start with an empty list
                       ⍣                               ⍝ Do this until the condition turns true:
                  ⍪∘?∘2                                ⍝ Append a random number in [1..2]
                        {1 1 1 1 2≡¯5↑⍺}               ⍝ Condition: The list ends in "1 1 1 1 2"
                 ¨                                     ⍝ For every item in this list:
 {⍵⌷'zun' 'doko'}                                      ⍝ 1-Index into the list ['zun','doko']
(                                        )'ki-yo-shi!' ⍝ After that: Append the string 'ki-yo-shi!'
                                                       ⍝ To the end of the output list
```
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), 67 bytes
```
do{random($a=,'zun'*4+'doko')-ov +o}until("$o"-match$a)'ki-yo-shi!'
```
[Try it online!](https://tio.run/##BcFbCoAgEAXQrVQI08u/flvMkIKSesOsqGjt0zkbLpt3Z0MQMXgzJ4PYKp5Heo5E/TSQwQrqNM5qwHek4kPbKDQ6clmc4o5Wr2/o3fmaRH4 "PowerShell – Try It Online")
Unrolled:
```
do{
    $array=,'zun'*4+'doko'          # 'zun','zun','zun','zun','doko'
    random $array -OutVariable +out # choose one element from the array randomly. 'doko' may appear in 20% of cases. it's still random.
                                    # output a result to the output channel (console by default) AND to the variable $out.
                                    # '+out' means adding to $out instead of replacing of $out
                                    # see https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_commonparameters
}until("$out" -match $array)        # powershell casts the $array to a string implicitly
'ki-yo-shi!'
```
[Answer]
# [Retina](https://github.com/m-ender/retina/wiki/The-Language), 50 bytes
```
/(n¶.+){4}o$/^+?(`\z
zun¶
)`\z
doko¶
\z
ki-yo-shi!
```
[Try it online!](https://tio.run/##K0otycxLNPz/X18j79A2PW3NapPafBX9OG17jYSYKq6qUqAolyaImZKfnQ9kA1nZmbqV@brFGZmK//8DAA "Retina – Try It Online") Explanation:
```
/(n¶.+){4}o$/^+
```
Repeat until the buffer ends with 4 lines ending with `n` and a line ending in `o`. Note that the `$` anchor works like `\Z` or `¶?\z`, so I don't need to match the trailing newline explicitly.
```
?(`
)`
```
Execute one of the inner stages chosen randomly.
```
\z
zun¶
\z
doko¶
```
Append either `zun` or `doko`. Note that I can't use `$` here as I only want to match the very end and the `$` would match before the final newline as well as after it.
```
\z
ki-yo-shi!
```
Finally append `ki-yo-shi!`.
[Answer]
My first attempt at a golf, and using a language not remotely suited for golfing, no less! ~~I can't think of any ways to shrink this~~ because Lua is a verbose, spacey language. But I still love her anyways.
I should give a heads-up: when the Lua interpreter starts, its pRNG seed seems to always default to the same value (rather than polling `/dev/random` or something), so running it once will always provide the same result. TIO, therefore, creates the same output repeatedly. [This will change when 5.4 is released](https://www.lua.org/work/doc/manual.html#8.2).
Credits to manatwork for a 22% reduction over four changes.
# [Lua](https://www.lua.org/), ~~132~~ ~~123~~ ~~107~~ ~~104~~ 103 bytes
```
z=0repeat if math.random(2)<2then print"zun"z=z+1 else w=z>3z=0print"doko"end until w print"ki-yo-shi!"
```
[Try it online!](https://tio.run/##LctRCoMwDADQq2T9coji3O/qXQrNaLCmUlOKuXw30O/Hi8W1pnbKuKMToC9sTsKYHfu0dfPzM0tAhj0Ti9HCRq32L8B4IFSry/t/L/RpTQbZQ2GhCPU@Kw1nGo5AD9PaDw "Lua – Try It Online")
Explanation, because why not?
```
z=0                           --set a variable to count consecutive "zun"s
repeat                        --loop until we hit the target circumstance
    if math.random(2)<2 then  --pick 1 or 2: 1 = "zun", 2 = "doko"
        print"zun"            --print "zun"
        z=z+1                 --increment the "zun" counter
    else                      --when the pRNG lands 2
        w=z>3                 --after 4 consecutive "zun"s, w will be false
        z=0                   --reset the counter
        print"doko"           --print doko
    end
until w                       --loop kills when w is defined (as true)
                              --execution only gets here if we succeed...
print"ki-yo-shi!"             --...so print "ki-yo-shi!" and halt
```
[Answer]
# [Ruby](https://www.ruby-lang.org/), ~~71...59~~ 57 bytes
*-4 bytes thanks to @ValueInk!*
```
$/+=p %w[zun doko].sample until$/=~/n.{9}d/;p'ki-yo-shi!'
```
[Try it online!](https://tio.run/##KypNqvz/X0Vf27ZAQbU8uqo0TyElPzs/Vq84MbcgJ1WhNK8kM0dF37ZOP0@v2rI2Rd@6QD07U7cyX7c4I1NR/f9/AA "Ruby – Try It Online")
Stores output history by appending `zun` or `doko` to the string `$/` (the predefined input record separator). Halts when the string contains an `n`, followed by exactly 9 characters, followed by a `d`. This can only occur when the string ends with `zu**n**zunzunzun**d**oko`.
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~104~~ \$\cdots\$ ~~96~~ 91 bytes
Saved 2 bytes thanks to [Arnauld](https://codegolf.stackexchange.com/users/58563/arnauld)!!! 
Saved a byte thanks to [tsh](https://codegolf.stackexchange.com/users/44718/tsh)!!! 
Saved 5 bytes thanks to [ceilingcat](https://codegolf.stackexchange.com/users/52904/ceilingcat)!!! 
```
f(m){srand(time(0));for(m=3;m%32-1;m+=m+puts(rand()%2?"doko":"zun")-4);puts("ki-yo-shi!");}
```
[Try it online!](https://tio.run/##bY7LCoMwEEX3fkUaECaEgNV206n0R7oRHzXYJKKR0orfnkaxtovezTCcw@Xm4pbnzlWg2Nh3mS7ASlVCxBhWpgOVJqjCJBZ7VDxVvB1sD4vGwvhCC9MYeqKvQVMmDgwXTBspnkb0tdxRhpNTmdTAyBgQn7lUakskSUmE/pzJEQnn8iPMmQXrhXUKbqCCn6ftvFcBFX9y9YO@5qOW9xJ841a5wimY3Bs "C (gcc) – Try It Online")
**How**
\$m\$ stores a history of what's randomly been printed over time in its bits, the least-significant bit storing the most recent. A bit in \$m\$ at time \$t\$ is set to:
$$
m\_t = \left\{
\begin{array}{ll}
 0 & \text{zun} \\
 1 & \text{doko}
\end{array}
\right.
$$
When the binary pattern \$00001\_2\$ occurs in the least-significant \$5\$ bits of \$m\$ the sequence \$(\text{zun}, \text{zun}, \text{zun}, \text{zun}, \text{doko})\$ has just appeared. \$m\$ is initialised to \$11\_2\$ so, at the beginning, it appears as though \$(\text{doko},\text{doko})\$ has just occurred forcing at least \$5\$ spins before \$00001\_2\$ can occur.
[Answer]
# [Python 2](https://docs.python.org/2/), 94 bytes
```
from random import*
s=""
while"zo">s[-21::19]:s+=choice(["zun,","doko,"])
print s+"ki-yo-shi!"
```
[Try it online!](https://tio.run/##DcU7DoMwEAXA3qcgryLBLqCLJbgIooj4yCvAa3mNEFzeYZoJV3Lsm5yXyHsRf356oj1wTB8lLaBOR9uMm9FJb5ra2vo7WKna0TGNc9njPryGxsQrawxvFSL5VEiFlczFRhy9kPMf "Python 2 – Try It Online")
This is an improvement based on an older version of [Surculose Sputum's answer](https://codegolf.stackexchange.com/a/204458/20260).
The idea is to identify the ending sequence in the comma-separated string by checking that the 21st and 2nd characters from the end are `z` and `o` respectively.
```
...,zun,zun,zun,zun,doko,
    ^                  ^
    z                  o
```
This is the only ending that satisfies this. To get a `z` in the 21st-to-last position, the last five words must be exactly four `zun,` and one `doko,`, since their lengths of 4 and 5 can add up to 21 only as `4*4+5`. Then, the one `doko,` must be at the end to get `o` in the second-to-last position. Moreover, because `zo` is the largest string that could be made here, we can check inequality with `<` rather than `!=`, saving a byte.
It would be shorter to use `urandom` similarly to [Surculose Sputum's new answer](https://codegolf.stackexchange.com/a/204458/20260).
[Answer]
# [Julia 1.0](http://julialang.org/), 92 bytes
A simple recursive implementation. `i` keeps track of how often "zun" has occured.
```
f(i=0)=(r=rand(1:2);println([:zun,:doko][r]);r>1 ? i>3 ? print("ki-yo-shi!") : f() : f(i+1))
```
[Try it online!](https://tio.run/##JcxBDkAwEEDRq5TVTJAou0rrIGLRRMTQtDJIcPkSNm/18@fDkZVnjCOQLlEDa7Z@AKkqbFYmvzsPnboPn6shLKHvuMeGjRStIFO/fhGkCxVXKLaJkhSFEiP8UiYR3znGBw "Julia 1.0 – Try It Online")
[Answer]
# Java 10, ~~148~~ ~~141~~ ~~137~~ ~~136~~ ~~125~~ ~~123~~ ~~112~~ ~~110~~ 107 bytes
```
v->{var r="";for(int k=3;k!=1;r+=k%2<1?"zun/":"doko/")k=k<<7^(int)(Math.random()*2);return r+"ki-yo-shi!";}
```
Golfed version of [the approach that *@loohhoo* used in her C# answer](https://codegolf.stackexchange.com/a/204466/52210).  
-4 bytes thanks to *@ceilingcat*.  
An additional -11 bytes from *@loohhoo*'s new approach (after I helped her golf it a bit), so make sure to upvote her if you haven't already!  
Uses `/` instead of newlines as delimiter.
[Try it online.](https://tio.run/##LY9NasMwEEb3OcVEEJAa7JB0Eais5gTJptBNaWEqO40iWwojWZAGn92VqTcD88N8710xYXGt7ahbDAGOaNxjAWBcbOiMuoHT1AK8RTLuBzR/96aGJGSeDotcQsRoNJzAgYIxFa@PhASkGJNnTzw/AquepV2qraS1sqtdtT2w395t2AurvfUbJqyyVbX/mo4FP2K8lISu9h0XTzshqYk9OaA1s6a4@yJczJLJYZRT/K3/bnP8TJEmuC478H/ej09AMQvcQ2y60vexvOVV5K7U3PVtK2aXYfwD)
**Explanation:**
```
v->{                      // Method with empty unused parameter and String return-type
  var r="";               //  Result-String, starting empty
  for(int k=3;            //  Bit-mask integer
      k!=1;               //  Loop as long as `k` is not 1 yet:
      ;                   //    After every iteration:
       r+=k%2<1?          //     If `k` is even:
           "zun/"         //      Append "zun" and a "/" to the result
          :               //     Else (`k` is odd):
           "doko/")       //      Append "doko" and a "/" to the result
    k=                    //    Change `k` to:
      k<<7                //     First bit-wise left-shift it by 7
      ^(int)(Math.random()*2);
                          //     And then bitwise-XOR it with a random 0 or 1
  return r                //  Return the result-String
          +"ki-yo-shi!";} //  appended with "ki-yo-shi!"
```
[Answer]
# [Zsh](https://www.zsh.org/), 83 bytes
```
>zun>doko
49744()<<<ki-yo-shi!>>*
*(){`sum<<<$@`||$@ `ls|shuf -n1|tee -a *`}
z* * *
```
[Try it online!](https://tio.run/##qyrO@P/frqo0zy4lPzufy8TS3MREQ9PGxiY7U7cyX7c4I1PRzk6LS0tDszqhuDQXKKHikFBTo@KgkJBTXFOcUZqmoJtnWFOSmqqgm6iglVDLVaWlAIT/kxNLFIDG/gcA "Zsh – Try It Online")
Outputs to the files named `zun` and `doko` (both should be identical).
* `>zun>doko` - create the files `zun` and `doko`
* `49744()` - define a function called `49744`
	+ `<<<ki-yo-shi!` - output `ki-yo-shi!`
	+ `>>*` - append to all files
* `*(){}` - define a function with the names of all the files in the current directory (i.e. `zun` and `doko`)
	+ `sum<<<$@` - take the checksum of the arguments
	+ ```` - try to execute that as a command
		- the checksum of `zun zun zun doko` is `49744`, which is defined as a command. All other combinations are not.
	+ `||` - if that fails (i.e. the arguments are not `zun zun zun doko`):
		- `ls` - list all files in the current directory
		- `shuf -n1` - pick one item at random
		- `tee -a *` - append to all the files in the current directory, as well as being captured by the ````
		- ```` - then pass that as the last argument to:
			* `$@` - execute the arguments: the first argument is the command to execute, the remaining ones are passed as arguments. Since the first argument is always either `zun` or `doko`, this actually recurses, passing all but the first argument, with the new random string appended.
* `z* * *` - initial recursive call - call the function with the name "all files that start with `z`" (i.e. `zun`),
	+ `* *` - with the arguments "all files" and "all files" (i.e. `doko zun doko zun`)
[Answer]
# VBScript, 257 bytes
```
Randomize():z="zun,":d="doko,":Do:a=a&Array(z,d)(Round(Rnd())):Loop While UBound(Split(a,","))<5:Do:a=Split(a,","):a(0)="a":a=Replace(Join(a,",")&Array(z,d)(Round(Rnd())),"a,",e):MsgBox a:Loop While Not Cbool(Instr(a,"zun,zun,zun,doko,")):MsgBox"ki-yo-shi!"
```
[Answer]
# [Raku](http://raku.org/), 61 bytes
```
(<doko zun>[{^2 .pick}...{:2[@_]%32==30}],'ki-yo-shi!')».say
```
[Try it online!](https://tio.run/##K0gtyjH7/1/DJiU/O1@hqjTPLro6zkhBryAzObtWT0@v2soo2iE@VtXYyNbW2KA2Vkc9O1O3Ml@3OCNTUV3z0G694sTK//8B "Perl 6 – Try It Online")
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 38 bytes
```
Ｗ›⁴⌕✂υ±⁵Ｌυ¹doko⊞υ‽⪪dokozun⁴υki-yo-shi!
```
[Try it online!](https://tio.run/##NYtBCsIwEEX3nmLMagLJQqir7nUjUuwJQjo0Q2NS0kTRy8couPjw4L1vnUk2Gl/r07EnwHMikylhp@DEYcLRsyUsCq40N4FHqeBCYc4OS8NDm5jiUoSUEoayuW97M2GKdxxXzxl/@l2CUNC1qN8NiUNu7z@JhfUr6s3xXsi@1qof/gM "Charcoal – Try It Online") Link is to verbose version of code. Explanation:
```
Ｗ›⁴⌕✂υ±⁵Ｌυ¹doko
```
Repeat until the string `doko` is the last of the last 5 strings in the initially empty list (thus the first four must all be `zun`)...
```
⊞υ‽⪪dokozun⁴
```
... split the string `dokozun` into substrings of length at most 4 and push one randomly to the list.
```
υki-yo-shi!
```
Output the list and `ki-yo-shi!`. (Charcoal automatically outputs each list element on its own line.)
[Answer]
# [Wolfram Language](https://www.wolfram.com/language/), 109 bytes
```
Join[NestWhile[#~Join~{RandomChoice@{z,d}}&,{},#[[-5;;]]=!={z,z,z,z,d}&]/.z->"zun"/.d->"doko",{"ki-yo-shi!"}]
```
[Try it online!](https://tio.run/##JcixCoMwFEDRb/EJTolOncQidOsgbZcOIUMwgTxs8qDGoQnx11NLucvlOBWscSrgrMp9QxPG2xt9EOVK6MVk1vC0@DKi3n@wp4fymtzFEs5mTJHpnBuWMquF4Ke@l3KohoP/6dzIro38DHHz0LX6OE0LAUuwIP8QXy1WkGWR5Qs "Wolfram Language (Mathematica) – Try It Online")
Pretty straightforward: randomly appends `z` or `d` to a list until the last five elements match `{z,z,z,z,d}`, converts each to the proper string, then appends `"ki-yo-shi!"`.
[Answer]
# [R](https://tio.run/#R) ~~161~~ ~~143~~ 69 bytes
An initial & fairly clumsy attempt at a code golf challenge involving text!, and defining 
`b=c("doko","zun")` 
as a header.
`for(i in -3:which(apply(matrix((a<-sample(0:1,2e5,r=T))[outer(1:5,1:1e5,"+")],5)*2^(0:4),2,sum)==15)[1])cat(b[1+a[i+5]],"\n")
cat("ki-yo-shi!")`
[Try it online!](https://tio.run/##FY7LDoIwEADvfgXuaVeWxKK9NPYvvNWaVMTQ8CgpEMWfx3qdTDITt4euEJ6hDcDwXQag7RUi@swPWXFS78ZXDbpx7Fbs3Rz9B9Fdisn1Y1fjUQkua8lRX4lMWOY6olCShRKJQg5kWdKhvCfzTFzytPSktZBkhKXKzfgwInfG59Jahluq7/4UWl@soZgav08/2w8 "R – Try It Online")
Using the original Japanese characters with
`b=c("ドコ","ズン")`
and
`cat("キヨシ!")`
brings the score down to 137 bytes...
> 
> A better alternative to using `cat(` would be appreciated as the
>  `,"\n"` part wastes 5 bytes for a `newline` command.
> 
> 
> 
A different approach reducing the count
```
e=0
while(e<1){x=rt(1,1)<0)
cat(b[1+x],"\n")
e=e*x-x+(!x&-3>e)}
cat(a)
```
when adding
```
a="ki-yo-shi!"
```
to the header.
[Try it online!](https://tio.run/##K/qfZJusoZSSn52vpKNUVZqnpGmdaKuUnalbma9bnJGpqPQ/1daAqzwjMydVI9XGULO6wraoRMNQx1DTxoArObFEIynaULsiVkcpBqiVK9U2VatCt0JbQ7FCTdfYLlWzFqwmUfP/fwA "R – Try It Online")
[Answer]
# [ThumbGolf](https://github.com/easyaspi314/thumbgolf), 53 bytes
Machine code (little endian pairs):
```
2100 de78 0840 bf2c a008 a009 4149 de00
de3a f001 011f 291e d1f3 a001 de00 4770
696b 792d 2d6f 6873 2169 000a 757a 006e
6f64 6f6b 00
```
Commented assembly:
```
        // Include ThumbGolf wrapper macros
        .include "thumbgolf.inc"
        .globl main
        .thumb_func
main:
        // Set our counter bitmask to zero
        movs    r1, #0
.Lloop:
        // Store a 32-bit random integer into r0.
        rand    r0
        // Using lsrs, test the lowest bit.
        lsrs    r0, r0, #1
        // Set up an IT block, checking the carry flag set from lsrs
        ite     cs
          // If the lowest bit was 1, set r0 to "zun"
          adrcs r0, .Lzun
          // Otherwise, set it to "doko"
          adrcc r0, .Ldoko
        // Add to the bitmask using adcs.
        // r1 = r1 * 2 + (rand() & 1)
        adcs    r1, r1
        // Print the string in r0
        puts    r0
        // Print a newline. We could technically put the newline in the strings
        // themselves for a THEORETICALLY identical byte count, but the true
        // reason for this (and the main reason I added this instruction) is to
        // make it so the string literals are aligned, preventing wide ADR.
        putspc  '\n'
        // Mask the lowest 5 bits using wide AND
        and     r1, r1, #0b11111
        // 0b11110 means zun zun zun zun doko, loop while it is not that
        cmp     r1, #0b11110
        bne     .Lloop
.Lloop.end:
        // Print "ki-yo-shi!"
        adr     r0, .Lkiyoshi
        puts    r0
        // Return
        bx      lr
        // These string literals are very carefully placed so that they are
        // all 4 byte aligned. That is the only reason for the trailing newline:
        // it makes kiyoshi an even multiple of 4 bytes.
.Lkiyoshi:
        .asciz "ki-yo-shi!\n"   // 12 bytes (aligned)
.Lzun:
        .asciz "zun"            // 4 bytes (aligned)
.Ldoko:
        .asciz "doko"           // 5 bytes (aligned)
```
Output is to stdout.
It wasn't easy figuring out how to align my string literals, but it was definitely worth it.
Note that I created [ThumbGolf](https://github.com/easyaspi314/thumbgolf) after this question was submitted.
[Answer]
# [Pxem](https://esolangs.org/wiki/Pxem), 66 bytes (filename).
Unprintables are as a backslash followed by its code point in three-digit octal.
```
\001.t.z\002.r.wzun.p.m\001.+.t\001o.r.ao.zdok.p.m\004.xki-yo-shi!.p.d.a\001.tXX.a.a
```
## With comments
```
XX.z
# heap: 1 as counter
.a\001.t.zXX.z
  # choosing either zun or doko
  .a\002.r.wXX.z
    .azun.pXX.z
    # increment counter
    .a.m\001.+.tXX.z
    # push o for next dot-z and get out
    .a\001o.r.aXX.z
  # if empty; then push o and get in
  # else pop it and ignore next block
  .ao.zXX.z
    # reusing the o
    .adok.pXX.z
    # print kiyoshi and exit if counter is >4
    .a.m\004.xki-yo-shi!.p.d.aXX.z
    # else reset counter to 1
    .a\001.tXX.aXX.z
# pop a garbage of an o if any
.a.a
```
[Try it online!](https://tio.run/##fVdrV@JIE/7ur2iykXQTcmlERWJ0GPR12FVGHdfjaNATSNBgSFgSFA3sX5@3upMImZ0zniPpp6q67n17jp5@/IFqeo0ifQfRhor2dre2bbqzs1PbCEJMcAm5g6cQiQlVoqdlLfSdg3KNGIwVOkhpBUh5iWd0EU@R0o6Qdacrez0k3VlBpSctHqfuBKnEiNwYKe7MmI3t6Bnpeq1muPNJOI3RafuhdXpqtg0cv01c9OjGgzAYlsscDcLx2A4ccqA57osWzHwf1Q7KtFzOJp@3rr6YgogzOaRMcgWcRcSEfeTmMh0oSyE3@3e3c/Pw7erIrOn6Vk48//qtc3P6/aH99fLyuH1lUuMOCWLyufXty8P18eW3ztduE3SgXrnMAwrRJIy8eYrkz6n07X@F3fHMt2MXRU9cNJzEMHwNp0408b24XLZ9z46Q8ogkSLMsiJ@EpWRK7CuVy92/T0/bZ0dmk6vHzJRjRE/eMOZZdRCTywhpqf4gAjIRZZaD0HBfbB8JJTS0/cgVFgsgcUVcdr6IXAdJkTbX3jQjgp93TeLT31GPySLgGwMoNheXhuEU@3bf9U0BjBokAS9xuMBci3Zf3xG1pNkyxL7RNTQr4Pgc9N6rqhVomtFvGcsUqpTWRG2iGXGGG3oBUkpFLVzh3b0CpBTEgzV2owCpvi1q3hp7qwD3gPuwBkH3YAV3dguQUpCO1hzdKkBKwfTLGnunAKkOYQ7XPNELkOoQprtme68AKa2L2nRNea0AKQXx1zX2bgHSGhibr7EbBUhrYPttjb1XgLQGxt7XsqQXIdiy1xzfLkBKIQ3xmu56AVIdbI3XsrJbgFQHW86a8kYB1qEC8hoE08oKbgG3tAbBEXENgqVNBpdSulwckq4Bje9cWnLCunduONCoJ2yOhVWLWNgK2K9asYioWVtWzaIaSEWaWoG2nuc7Xaqq6RtiKdHuXudv77bT00pJ1@j7oHBpvMGq0JBmaHf3GZc1k6ghRyvoUAIkZebv7j9Ve2AXPMB36RBcqH1CzIWnTCalI7UCLO5Zah3imXA3Ra3KqH1wAcqUAColEYxa2sToXwA1Fat@AgUfgs6HoKMd5YIFsZyT5aE5NcQkNfcJMdWwF3Bp1MopcYunVix1gWMFd0h571Ucpi2erlEgJJ6fXhqsxlk2iE14JdPg7HTWErxtXnyoVLlv8UWxJnk@vkBmjlqQl3lWXJ7ZVd7S/Jxkmvh/6krqSVb1X02U8r10rR6aN8z2S1OwqEASHgi@m4SB9zCIXobuNB7LJXFT6TFpi2JiaI@pDGtHK6FVa8lY59iiGc9e9yia9bHA6iFU2exDGAtN2Jyr3CxZZgaL8r8TPhK1/tS1nzmAsrWw4IfhBAVhjMZ2PHjygkcBRD/CBe0ycx8TrQ9OYkoId7PECXoKRAD/5GCTAwpAIkuBbPz4X7d1dmxKlq5TNVbf4VtTp@rr@yxQJ@qYk2U1Zt8Q6Haovjvhc8aqq/NnT3kL4XrilYDmqHaq5@ZGtVVb2mh/7V4dd6/MjY2BHblw9HFrAvIChCtaZVGxLH17t0LSi46kMQYXkeCmYxhuZA82JlMviIcfcxevA6QMgP1jaA5nwSD2wsBCRjQdmNLn45NON4mmcB@BY9F1yBLOyKEgneMjkny7e67@hUnPPDJg2JPljHmMSTJ149k0QCUZBDLynysyEA9oRv5rRWZaMupVgcrMKDTn3eBLklyaIMLtKoqRSV5mAjPcJkkapWDB32YoVNsZ7wRfVm8/dMMFy/cC90A/FPWmkrv0JTUgUoM32D3vXhn6TBBIgYRS0k/m/2bmZ4GZm2zhs8wddLYQBnYMuWZ3Ny9GucUJhPv65PkuLkH2SPiRNBglQFksZvgGGBk1wJ3qdfWo6pME1iSfklybIGD4pu8Gj/ETviYGu98YnX3fIDOMj0xwPIqn@Loqy50q9PW/Ag9CODyS641mfZssM@0e2DzHJytzD/is2q7eVr@T5MwU1Icm6sL6sZHjDrwxXMggMvfRncJ3MosFo23CXOMWbpzcA4M7Wd/db5fL7f3tBuEr0gBa@1/hvn63td0TYTO5Net1pZ1NThctiOBGOo3WIQdt09yqkSQVgYtx7AUzd8nSy0Tb@/UGyBxs7xJGSo2vzKaayXcTfyeordQbBquTcY5vK9/zQAd5ts/x1Sr8KKfefJTlBQowql6TpGPq3NDI5C0K6R6xpqyOFKVnXrOqMNTpcWJHlnscj3p5rqcri5BFzBcaqbBS56ZeVyvhJyfm@KLKTZRgabF8lgBd8Da4Ni/2mWA28Tqb8fbbGQe/mPH@YZ1N4daVlQdx7v0TrENzRR8D/ZltPfBGOMeMmXP62IbEpX37J2vbc2wfwkTZZkE3b7LgjdWir5hUqVWwva@TCqsKfPPk/fOzslG2Bm6y6PCo4hPoBrAhqJtwOqjQaUIT3bpTuCt5L14Ee53AmoAl3z4cHfiHo02/6W@Omnys8THUYpnuhOCWqfeg5uyp8PM@OiCClHk2xOlr4kMk27eFRchPGjM9b9IzHq5QcP6wN5syDZ7pYjCDkSMhCSnDWn4wwZXkHJcJe9DkRlzehOlpl0DD8UZ8lmVDlkf7mG2NrNkghWk6RxmEATF@7RyLwHF9F553UDRoYa6yY0Jjw6axD9NlmrYy3/A7XKNMob/TrVhOMWzURriwX5/hOY3YscGetXAVGiD@9J2xLg/H7EkHxOl/iKunuFNHSrdeEFgs8ASely14rnpO1Y29sVudDCaz6kv0bjjwMCWLtad8/bdP@UVsez7cTutrWWY35KTBrin8LiQtMGiwrADJ6Q1bqdH6br2xtVNvkEUfEgb5g6NSyMOF7dcUMUYizh/vrcuTh7PWzWLB59f1vR2i1RRaQ4QgKdut@2YfiTo5AJidFH2jbwrC8rh7lBOWElrM7ekjRN@Zo6x48x//Bw "ksh – Try It Online")
[Answer]
# [Ly](https://github.com/LyricLy/Ly), 96 bytes
```
"ki-oy-shi!">"okod">"nuz">666661[p09?5Gfps[p<0]p<0&:p[o](10)opl[p>0]p>l:rp&s&+lr2=fp*[<<<&o;]p1]
```
[Try it online!](https://tio.run/##y6n8/18pO1M3v1K3OCNTUclOKT87PwVI5ZVWKdmZgYBhdIGBpb2pe1pBcXSBjUEsEKtZFUTnx2oYGmjmF@REF9gBBe1yrIoK1IrVtHOKjGzTCrSibWxs1PKtYwsMY///BwA "Ly – Try It Online")
This code uses 4 stacks, one for each of the output lines, and one holding `0|1` indicators of the last 4 output choices (picked using random numbers). Then it writes the `ki-oy-shi!` line and exits if the sum of the choices (and last choice) show that the exit pattern was generated.
```
"ki-oy-shi!">"okod">"nuz">       # Push the strings onto separate stacks
66666                            # Initialize the stack to a "not done" state
1[p    ...code...    1]          # An infinite loop pattern
09?5Gfp                          # Pushes 0|1 on the stack randomly
       s                         # Save the choice on the backup stack
        [p<0]p<                  # Shift 1 or 2 stacks, depending on random choice
               0&:p              # Duplicate the stack with a 0 sep, pop the top 0
                   [o](10)op     # Print one copy of the stack, plus LF, pop the 0
l[p>0]p>                         # Restore random choice, shift back 1 or 2 stacks
        l:                       # Restore random choice, duplicate it on stack
          rp                     # Reverse the stack, delete top (remove oldest choice)
            &s&+l                # Save stack, sum the choices, restore stack
                 r2=fp           # Reverse stack to move sum on top, compare to 2
                      *          # Combine with latest choice, if 1 we are done
                       [<<<&o;]  # Time to go, switch stacks, print and exit 
                               p # Delete the test results from the stack, then loop...
```
[Answer]
# [Vyxal](https://github.com/Lyxal/Vyxal) `o`, 36 bytes
```
{₀℅:£J:5NȯB30≠«ǎ⌈8τ«½¥i,|}`ki-yo-∪Ǎ!
```
[Try it Online!](http://lyxal.pythonanywhere.com?flags=o&code=%7B%E2%82%80%E2%84%85%3A%C2%A3J%3A5N%C8%AFB30%E2%89%A0%C2%AB%C7%8E%E2%8C%888%CF%84%C2%AB%C2%BD%C2%A5i%2C%7C%7D%60ki-yo-%E2%88%AA%C7%8D!&inputs=&header=&footer=)
-7 thanks to lyxal.
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), 51 bytes
```
(⌷∘'zun' 'doko'¨⍪∘?∘2⍣{(2,⍨4/1)≡¯5↑⍺}⍬)'ki-yo-shi!'
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///qKM9/b/Go57tjzpmqFeV5qkrqKfkZ@erH1rxqHcVUMweiI0e9S6u1jDSedS7wkTfUPNR58JD600ftU181Lur9lHvGk317Ezdynzd4oxMRXWQgf/TudIB "APL (Dyalog Unicode) – Try It Online")
Slight improvement on the other solution, since the account is deleted.
[Answer]
# [Knight](https://github.com/knight-lang/knight-lang), 54 bytes
```
;=aF;W-30;O I=x%R2"zun""doko"=a%+x*2a 32xO"ki-yo-shi!"
```
[Try it online!](https://tio.run/##rVnrU9tIEv9s/xWDUtga2U5kwVVt2cgUyUKKOgJZSC4fwBeELGNVZMknyTyWcP96rrvnoZFtcrd7ywfLmunHrx/T3WPC3m0Y/ngVp2GynER7RTmJs9ezUdNcSeKb2lJYPi6iFaI8Tm9rS2U8FzSTaBqnEUsSlmTpLX009eqn088fWL96vfh0zrzq9R8H52y3ej06fcd@qV7PP7N@RXx0cmHQnn4@MUg/n344uPi7XXBm40eL/bv/N653Dy5ArdgMZ0HOHF4xmFSAVYsYjdhutXd6@AU3U9gki74z/L63t0KDaogGzQSaJOFIWKN5e3Z2QkT4sU9GDtA2A8j5e0EA/AbWuyBZRpxfpmPebJIdEJXLsX9uHZ4d2T@GfnA0/NLbcYdn7Nh/2D73rN@XqWVNsm@Z5QfbnQfHC9iO93BmfYt7j1mvmMVb1g8OzNZQyHNAYBTMmY@Sh80mqF8EeRHZnD01G3FasnjYbMAqQekyZ7pMQ1gh5hDey/miWyzSS2/sP7ld9xlkNGIQR/TwdHHhzRsUHy/Y/Swuo2IRhFGzAd@TyIZ1YLcFjC6zrsqr9Gp6lbOn58uxzQevLE5QGvGU2Rqtz9qv2pwJEWp1C1avUljudMQK4GxESRGZC88CTjiLwm9smuUsXc5voryQeJgdF5P4Ni6VVNCO5vS72iLxdFjfZR3mSOSdDmc91nbboAKRxpzlUbnMU6aSR7BR/gxXMdwFeRzcJJFCASCS7D7K7RD0KSDs@3emwIX0FpIjvra5dE@8wfTY73chRr5eXkGHx1GmLZCkk@XCxpAy6dMeg7d1wKI4FEKagHHVbleYrLYIGjCDBRoUAyFQTOA7IFsERcnKWQTCgrwEYhkAR3kUAxpytESBNc7Yi2Dhs88p0I3KGQQfU7eMsxRgY8a6Y4AWKo8Uy8UCHc5VVqkV0/1m/oHbDWejDJXKixTyGAobZq5ELrzyqa1Pv1g4wgUscgMsbghTJRnVRWGqjbgRapAkWWjvut0@RwNxWRtBBqbLJAnyR9PQKj7nRng@tjUyUij5l@kKN6noowpZFDZZenD49t31b1snv54ZBptib@KNcr11uVs1we@PL16QWEY5iQzSCfvXMlCvKPbOVLGzrkI44H1b@@J4gy@IebfOXKd5plKZL1OM0FAWZ6fMClvVSjoAkNplHDLavVlOL73dscQhAt2i8qABFAs4VuXUBlKwfztJJpaqO9ScuihkVQAcCi1AtD2hv0a3x/o7dTvReMzFfWaV@TKyIAf1OqYkrE8DqCC4YWFmWZUT0E60XfYncsfXt1mWwM5N3QMv2lqZ9TODnD9ukQnzZg1mghjTvxQjJG2ZJYltQu0ytwsd4k9ATtcgYxf@cPDxtIu9WCQavB5f9l3XhXQCU@BVvRXx79HXkuFjaOSoYS16AN66@OHR547fVy0dKxx2dXzQpyceO0BwdHxy6LApFMdhQ6e21IdlOAwW3SRKaQIwfKXGJ@EzOHcvOWOVEXsTtjZsOHZMswT04j3yxRCaSoybum6E88VKBMhJ8bgqIeimeIxqivu4DGe2A55Zm7bAR0z@hdin2gftAUMtgsBHh@K8BlWYt8goKV5OjLWU5UPqwhUFjaVljq2LJtPLMX@q0gwGKKrtQvE5KK7LzqHi2bzlPkzxr6L8CJQgVfjoNioTGCrtFsWyhRHCFjmJUz6Mp7ZN8cSBIJzliKULecq5CLPvDjdihQenMUDoOxT6xOSI1UA6ZKjwopNk7axQvq3sEfR65121g5ymizXNNdBgNkD@@YtsEaW2obhr5RaNCoDKn4tOCfnoe@7uL7QuhwtbTCRTgD5Bo2CEg5Tt4nwH5DA70BvqANUqvWxYZB2fRiE8sUDJpbtBDukiV6MEx2eeObNUbqws@Q0siR5gjMPTvmbnVi3qdHfYwkq2Rniylh6gJan7xSD/tT2Qc@KGRNaVT3Yg65TGYht7EFdNaDTa5dVguVYOFesFDYf2doGM9cOwzgzuhNHH1AuVlFsVqdrA9hIFqRT7UguTPcuMgKwt0gtnlRfwYIiLDzpNxLPmOtZq0YWr10PSsRhzr2jcbihY26@dAvDY8MaZOmq5AX9ZFir6OifErCcAdTQgqpNQL7EkY2oZ4RHTdKMebXF7RWqY@5nKJU/EHOdfOgwiAESFy3jKfWWlxzenahiU6iGnzn6nchNX31EWh2m0S89S1ghpV28tO41sx1G9jlcwOVV0NnhhtT1v8IOz5gcR101emG8wzSEa3xRCDNCDbKqQfvsKLnlINOz1SJ50FLXM1UALj5a10//mp455s9kx2z9l2t7M9E/yZs0gcXWgNc@0cijdLrzus15/1cvEAhHow3Hr9eGo9WtM3p/k2oNyuYnH95GF4AyYXHF1KCgA3siVMfA4jTGOT3Fprh4U2iReuDtQ4UUU8B2vErMoj9oFSzOYreOkjFN2HzyCP9kkg7tqGd1GOfAssjRKyzjA2wWc8IzdR2wW3EVAKAUhecnmQbqEtHp8jato5Q1GAlxDnimWSYk/JpByXQgVSc@kUSprvqvzaZIV8SjvZUr3ZSCabK9G5dK9PUiwZz6C1ekkiSbsuoJ9raU84TcxsBlKKmNGKKzXU@@cyBuS1DGgP@v6uEdJvNIQsRjW6qVfr5b7zCwKe@bxQNaB/L2uxQTBPqsNkLTYZUaVRBmu4FSt2BP9AWm3fOhCxnQ0gsOKqZVNsgGbR/NwgWmWstH1/v9ryugvMGWkTNnaYIsvbZGm7L/sfaF1A2Tc3mc1Ak9TeKqxbm3CWb1o81RFMgVoeK2qLKItm3rGvskpa4nm//6/8MsiZIjR/MP2wKSujb@rtH5Vjevbf/iCo2be6oaDdI3aLUeXQqJBiWO/xm2USeRAik5HswnIX8A88WuYOYDWrGPmTCPZjuvTPJIa/PveYMdwy3txlfCNyatjNqb1u1MqLyRdfRZ2aoPuhXD0itDhaiv0NrXCHa7nA09z79LifxmUEBg@MRShvhToMcmcmTywELV2@jg80eAg8l9s0oMoOvIkgPZJNA2gSIJlavKMU9iMJ/TjUhCW0Kba22EbZ1Fc4eyF2y0K0z0QpkT5A8M8iFMcYlmQ34ZdEuo48P2O489YdO/Ef//YLqGpX@@ef/wH)
Uses the bitmask setup.
```
# Initialize with FALSE. We will coerce it to
# Number later, just get some form of 0.
; = mask FALSE
# loop while mask != 30
; WHILE( - 30
          # chaining ftw
          ; OUTPUT 
             : IF (= x % RAND 2){"zun"}{"doko"}
          # mask = ((mask << 1) | x) % 32
          : = mask % (+ x (* 2 mask)) 32
        ) {
    : NOP # we use "x" in the golfed code.
}
: OUTPUT "ki-yo-shi!"
```
]