[Question]
  [
# Challenge
The goal is to output `Buffalo buffalo Buffalo buffalo buffalo buffalo Buffalo buffalo`.
[Context](https://en.wikipedia.org/wiki/Buffalo_buffalo_Buffalo_buffalo_buffalo_buffalo_Buffalo_buffalo). (Maybe another interesting challenge could be printing all of the [other examples](https://en.wikipedia.org/wiki/List_of_linguistic_example_sentences#Lexical_ambiguity)? This would probably use similar logic but involve either a function or just a for loop.)
# Rule(s)
1. You cannot output anything other than the string with correct casing and spacing. Trailing new lines are allowed, trailing spaces are not.
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so fewest bytes win!
  
[Answer]
# [Buffalo](https://bfalo.com/), ~~2711~~ ~~2571~~ ~~2517~~ ~~2447~~ ~~2279~~ 2183 bytes
*It takes 304 buffalo to produce 8 buffalo?!* Yep, you herd that right.
```
BuffaloBuffaloBuffaloBuffaloBuffaloBuffalo(buffaloBuffaloBuffaloBuffaloBuffaloBuffaloBuffaloBuffalo(buffaloBuffaloBuffaloBuffaloBuffaloBuffaloBuffaloBuffaloBuffaloBuffalo(buffaloBuffaloBuffaloBuffaloBuffaloBuffalobuffaloBuffaloBuffaloBuffaloBuffaloBuffaloBuffaloBuffalobuffaloBuffaloBuffaloBuffaloBuffaloBuffaloBuffaloBuffalobuffaloBuffaloBuffaloBuffaloBuffaloBuffaloBuffaloBuffalobuffaloBuffaloBuffaloBuffaloBuffaloBuffaloBuffaloBuffalobuffaloBuffaloBuffaloBuffaloBuffaloBuffaloBuffaloBuffalobuffaloBuffaloBuffaloBuffaloBuffalobuffaloBuffalobuffaloBuffalobuffaloBuffalobuffaloBuffalobuffaloBuffalobuffaloBuffalobuffalobuffalobuffalo)buffaloBuffalobuffalobuffalobuffaloBuffaloBuffaloBuffalobuffaloBuffalobuffalobuffalobuffaloBuffalobuffalobuffaloBuffalobuffaloBuffalobuffaloBuffalobuffaloBuffalobuffaloBuffalobuffalobuffalobuffalo)Buffalobuffalobuffalobuffalo)buffaloBuffalobuffaloBuffalobuffaloBuffaloBuffaloBuffaloBuffaloBuffaloBuffaloBuffalo.buffaloBuffalo.buffaloBuffaloBuffaloBuffaloBuffaloBuffaloBuffaloBuffalo..buffaloBuffalobuffalobuffalobuffalobuffalo.buffaloBuffalo.buffaloBuffaloBuffaloBuffaloBuffaloBuffaloBuffaloBuffalo.buffaloBuffalobuffalobuffalobuffalobuffalobuffalobuffalobuffalobuffalo.BuffalobuffaloBuffalobuffaloBuffalobuffaloBuffaloBuffalo.BuffalobuffaloBuffalobuffalo.buffaloBuffalo..buffaloBuffalobuffalobuffalo.buffaloBuffalo.buffaloBuffalo.buffaloBuffalo.BuffalobuffaloBuffalobuffaloBuffalobuffaloBuffalobuffaloBuffalobuffaloBuffalobuffalo.buffaloBuffalo.buffaloBuffalo..buffaloBuffalo.buffaloBuffalo.buffaloBuffalo.buffaloBuffalo.buffaloBuffaloBuffaloBuffaloBuffaloBuffaloBuffaloBuffalo(BuffalobuffaloBuffalobuffaloBuffalobuffaloBuffalobuffaloBuffaloBuffalo.BuffalobuffaloBuffalobuffalo.buffaloBuffalo..buffaloBuffalobuffalobuffalo.buffaloBuffalo.buffaloBuffalo.buffaloBuffalo.buffaloBuffalobuffalobuffalo)BuffalobuffaloBuffalobuffaloBuffalobuffaloBuffalobuffaloBuffalobuffaloBuffalobuffaloBuffalobuffalo.buffaloBuffalo.buffaloBuffalo..buffaloBuffalo.buffaloBuffalo.buffaloBuffalo.buffaloBuffalo.BuffalobuffaloBuffalobuffaloBuffalobuffaloBuffaloBuffalo.BuffalobuffaloBuffalobuffalo.buffaloBuffalo..buffaloBuffalobuffalobuffalo.buffaloBuffalo.buffaloBuffalo.
```
[Try it online!](https://tio.run/##7Vlbb@M2Fn73r2CnRi1NHDst0H2I47TJTNIam9qDXHZQBIFBybRNjCxpJSpOtuvfPnt40V2U5Exmb6geYok8PPzO/ZDx1/7nk5/8td8Zvn3beYvOo@USOx66wu4KTVxGAj8g8Bd9@PVDhxP8jQQh9Vx0NPhefL/HLiUO@oU@uuQZrRnzj4fDFWXryBrY3ma4WIkZQXtFbeKGZIEidwEs2ZqgMx/b8KNm@gn7HwZHyOAEb9TUG3MEHJ69CG3wM3I9hqKQAAsaoiV1CCJPNvEZoi6CXX2HYtcmaAs4xDaKyQBY/K5YeBbDQI2B3oevZZYOYSYAK3G22@0AC6ADL1gNHUkUDq8m7y6mNxeHAFaQ37kOCUMUkL9HNAAxrWeEfcBiYwsQOniLvADhVUBgjnkc6zagjLqrPgq9JdvigACXBQ1ZQK2I5RQVIwN5swSgKuyiN2c3aHLzBp2f3Uxu@sDj4@T219ndLfp4dn19Nr2dXNyg2TV6N5u@n9xOZlP4ukRn09/RXyfT931EQE2wDXkCWwN@AEm5CsmC6@uGkByApScBhT6x6ZLaIJe7ivCKoJX3SAIXxEE@CTY05IYMAd4CuDh0QxlmYqQk1EBo72eHup@QepTmLe6M3I8081WOxgkl1AxhKxMOO7aDQQEqCDLu3/mj0@HceJAItmAmsqQuqMHbEHAhN2TYZaGaHIpfMYpu5@9mv/12Mb1FY9RLPnqjHMn53eXl2dVsfvfucnJ9o0gLg5olV7OPF9f5BWKoQA7e8OFOMZbvBYKr2ezD/Pzil8lUEqXfVYQX0/cZMvgCoqKG5sz7BFpWn/Hoz48YgiAIIAS7igKB0j2bYu7QDjg3j0bfA//hYROTuAvuMhQc59kneUX7gceIzVcnHMdyC6MTO0xInOXxcYWmT4uU/OmFzy7DTz0@3VPu0EsozL6WrbJGM1OrBdPYZs3cBrV8sqZt5mU08xLWb@ZkZjiJN7PCScB4qwBv6rxEkXAP5Dk7FLkjHrSIyDg44IUFhzyhr@O1Wi@JF4@RGzlOBSpuHgj7ClA898KGXUWSB2VHQUBc5kDitxl9JEgRQarfkI0X6BEpQi2gkP6DVMGhkKRWsLArKKCyPQGHjQUjEER4seAZXZSfELIfCVsgEXzG6Icf/1IBI7e20liSotJWodpaYtECUERxCFc6jcflDmqdRpLkgYRktQH7ZOwkyeJ63KCamGcdtKWDV7U5TxAUYD2HjGzAtSAFoiyDMgS5ugaADMAaAJIgD0BkTbD7Qi1HDJoUhJeMSA8TZVCU7zywyIJKmrDUOe@CWNGqCpHleQ6B/qUrKEBO2EtoIVR7E6jYiMKbfm@5dAyII1JhjrkoW0FkMzAuW3uLIg7IHHiTRHU@G8WzeZzJJOgkClz06NFFFbRl5NocdhaE0U1TT6/XT@FDMQiJzJJ/JFmzy/vbw9OYRhKPitMi9yWMTTm/K6sCUgFhl8J/6lSh3OQTeQ6bJU08MxU23cYQTFJnLYpHl8j4RtCYmVEhWW5hbipbjFQz1dcSFKp9M6Go33oyWZH182mlbaCBCpojMFOr7lL7ClXGapjDOceZc8VIvfbRkVnyhXx@gFQarMA1snN9xVbvJ3Ey0HjJPr4QszJKni3r3RVxV3BEG/P4c4ibIJWzcXbjDxw7eDJIKJLOESSHhpD3G10xxl0p70tiuLwTH72P@5WH7F6xb@ZWnuYxFz1WdchwmuNpKDu6KzMOIwtgzPlJFc58Ban7qIitjw6zUEw0Ho/B@EVBE9g53Z7mFFBawJ/vvkNdwCIqI0@kdKMQlpAdFaGYlSgyDilluH/QB7MmqDUNZvHJNpyxENoFZuWMOSoN78oy7SVPwSc7LbbMq1qUh1EZhQy@ooPl3ypCOqnhZ47zCmGdZWdoilamWToqp6l8jydSm3HUT6Z5D1qd3zLVpWI2AWbkzKXPdcmCNiVRtTm3omOTbZIH54@0QyKLwsINfQLFGaK4/1O16iZ0GUo1H9fERVaAXXvNuw8Y9OD84nieH/OBR9xx5bq1uItWzawEQR6xE4kjNGaCirPphYi4i6KNJSpuaY5pVQYi6eRm1F2QJ86T88uya@EeRtoZqhagnwqv6XlEBlNmK@YWKAJGVwLiXoXU@wmoJ3KT3cx44uCgMjuFW8qgkkANjVfcS/oHfTb7Fl2B@OicrKhbSWDjkFS0AcfaXJTIoV4OKpxYBkfIb6tiqP2U/nuzXww2kw@PtHtaUEM/jWolvIjt2ygftDDHHe1Wwoyxqb8Zx8bW6TdfdrM54j7m8pCWPdTwKD@XmhrVku86bRiV00tijVjzI71gO0RA9gbc5Ikyo3eJGXYQCQIvOEZ3LnnyZXD10KB8BTOAYVFfeqZeyJ3O3F7E/Ig1G1v2vHpHJvbaQ/Y6KNkt75oP5kv9Ut2/NSMtdPtN3pntiu81PB6a3K1BaB7f9RQHB@iU37b82OjVP3EqdNy45agV4EwhlblZd2aqPiOZZv02yqR7emU72wgArS2T1pvCiNS8oWpHTqkmOoT02sIi2sUZO8UA/oft8i2y9g1Cgeb432fmFwfg4SE6gbrSwthHfwbf/olRG34v0/v/QTAtyBJHDqtpDXMGqOpTH9DBuEWjV9/s7KpuPNILxyoDi1rfO4EW6JR3JOLCdl6s/H1xF2vy9uRkKEhH@zJSVv5yTnGbVs8nowndEVpcsr7oCrntLXH@GldcAGiO1sVDVfkcnDLh90yh71CWvSDuVIV7PF1x6MrdvMW8@dWbOsPwq5c1Dqo8pnCtMRhLUv39R3plqL/l0J/7xYVEfNrfdVyyrfhvvnFycqLi/LOabfFjWK1JX2nhi9m8dMM/1xVIXvUr/2O2oGmP0Gqe@ypC7C/hF5pwYNV97sFn0EI865X3bL9lLZy9bXfeYmFRyFqw9Ropfn6NYGrYcj@Ar2Rf4wtF@w@bqY6T@fXT49e06H@9KT6rfsQcff4X "PHP ‚Äì Try It Online")
Link is to a Buffalo interpreter written in PHP (the header is copied from [GitHub](https://github.com/bfalo/buffalo-lang/blob/master/interpreters/PHP/BuffaloInterpreter.php)). You can also copy-and-paste the code above into the [official online interpreter](https://bfalo.com/#showcase).
Buffalo is a cell-based language like brainfuck or COW. It has seven instructions:
* `Buffalobuffalo` and `buffaloBuffalo` move the pointer to the left and right, respectively,
* `BuffaloBuffalo` and `buffalobuffalo` increment and decrement the current cell value, respectively,
* `(` and `)` begin and end loops, and
* `.` outputs the ASCII character corresponding to the current cell value.
Aiming to get the ASCII codes of `Bufalo`  into successive cells, we first do a coarse initialisation using three nested loops. A correction is then applied to each cell (outside the loops) as necessary. The selected iteration counts (3 for the outer and middle loops and 4 for the inner loop) are apparently [optimal](https://tio.run/##hVRNb9swDD3Pv@KtBtakdb1@3ApkQ7dTD90OuwwIgkG26VaJLbn6SJcl@e0Z5bhulg4pgQhi/B5FkY8yPltsNjHupJK1r6F8nZGBLqEbMsJJrSwMPXppqIDTuCeHmx9fb2@R64JsQB5/8aWoNI4hFSOsz3OyVs4JOVWVjSJD1lfOYoTlGjFmtIC0EMaIReBXWjew8g/ZBHNRefrna58HH@iVs1HJcc4@DfJEDbFEnpaFnA/UMDX8ucA6urv5yYiryyi6TH3j9ID/GKLQWMkVgsU7t5Suv6VU0J7dNp8I2GdPVwe5tSyKip7JwMUefbY6QJZKvRwcrOYrSJxg2vmK/Zr9WefP2D@HLMNmhIuQmKgq/WRRaoNGc/0zWUnXlnDqrYN70u0B4TzrSBThi3swRFEXM8a3Pj1RFPJ18y03/6VbW1ZHdpzQWCaYJphNDkb8aH3mjMi34bm7rUzavHeE1Yc9HSEopxdZmi0c2bQWTVvWbBW9G3fgYA1jy3GWQE0S7Fq8V@d3wGOLNbxmOGPmCVSCmnnxfkMZbBjyyJAaexYH2VhZbKG2z2XS7UgV/6tHo3laeFvrOdXEwsZAabcVuVT33BptiVfhoPPcm5ASzckskAtLw936vNz/khMc2NRIVdDvJVYiAZciX0HgfRDMGqcsFp7HnKfsfJi8qsqbgbJDgfZnoFNqIHzm3zWu8LbFvVREtVOdpwdSXA4y2@eBt9IUu0f1quuem3Evxwl32EXPvdiubVdqGeaqw6ft28PKkupXtgh35rKlZSWcI5VaXw8@XIvMDvmJabjhOPreOFlzjjsTMUK8fA7Hz9yAYw3XR5vNXw "Ruby ‚Äì Try It Online"). The ASCII code for the lowercase `b` does not get its own cell; rather, we generate it on the fly in the `a` cell.
Once the ASCII codes have been generated, the output is printed character-by-character as `Buffalo buffalo Buffalo (buffalo )Buffalo buffalo`, where the segment in parentheses represents a loop that runs 3 times.
[Answer]
# [Bash](https://www.gnu.org/software/bash/), 28 bytes
```
echo {B,b,B,b,b,b,B,b}uffalo
```
[Try it online!](https://tio.run/##S0oszvj/PzU5I1@h2kknSQeEkyB0bWlaWmJO/v//AA "Bash ‚Äì Try It Online")
[Brace expansion (Bash Reference Manual)](https://www.gnu.org/software/bash/manual/html_node/Brace-Expansion.html)
Same length, slightly more interesting:
```
echo {B,b,B,b{,,},B,b}uffalo
```
[Answer]
# [Python 2](https://docs.python.org/2/), 36 bytes
```
for c in'BbBbbbBb':print c+'uffalo',
```
[Try it online!](https://tio.run/##K6gsycjPM/r/Py2/SCFZITNP3SnJKSkJiNWtCooy80oUkrXVS9PSEnPy1XX@/wcA "Python 2 ‚Äì Try It Online")
Relies on the Python 2 print magic that automagically adds a space before a printed object [if it thinks it's not at the beginning of a line](https://docs.python.org/2.7/reference/simple_stmts.html#the-print-statement).
## [Python 2](https://docs.python.org/2/) (anagol), 36 bytes
```
print'uffalo '.join('BbBbbb'*2)[:63]
```
[Try it online!](https://tio.run/##K6gsycjPM/r/v6AoM69EvTQtLTEnX0FdLys/M09D3SnJKSkpSV3LSDPaysw49v9/AA "Python 2 ‚Äì Try It Online")
A trivial modification of the [anagol solution](http://golf.shinh.org/reveal.rb?Buffalo/kt3k_1265291869&py) is the same length.
## [Python 3](https://docs.python.org/3/), 38 bytes
```
print(*[x+'uffalo'for x in'BbBbbbBb'])
```
[Try it online!](https://tio.run/##K6gsycjPM/7/v6AoM69EQyu6Qlu9NC0tMSdfPS2/SKFCITNP3SnJKSkJiNVjNf//BwA "Python 3 ‚Äì Try It Online")
## [Python 3](https://docs.python.org/3/), 41 bytes
```
print(*map("{}uffalo".format,'BbBbbbBb'))
```
[Try it online!](https://tio.run/##K6gsycjPM/7/v6AoM69EQys3sUBDqbq2NC0tMSdfSS8tvyg3sURH3SnJKSkJiNU1Nf//BwA "Python 3 ‚Äì Try It Online")
[Answer]
# [Husk](https://github.com/barbuz/Husk), 14 bytes
```
wM?Im_·∏ã162¬®·∏Ç=F
```
[Try it online!](https://tio.run/##yygtzv7/v9zX3jM3/uGObkMzo0MrHu5osnX7/x8A "Husk ‚Äì Try It Online")
This was a simple challenge but fun :)
### Explanation
```
wM?Im_·∏ã162¬®·∏Ç=F
          ¬®·∏Ç=F    Taking the compressed string "Buffalo" (uppercase B)
 M                For each digit in    
      ·∏ã162         the binary digits of 162 ([1,0,1,0,0,0,1,0]):
  ?               if the digit is 1
   I               return the string itself
                  if the digit is 0
    m_             convert each character to lowercase
w                 Join all strings with spaces
```
[Answer]
# [Perl 5](https://www.perl.org/), 32 bytes
```
@_=<{,b,B,b}uffalo>;say"B@_ b@_"
```
[Try it online!](https://tio.run/##K0gtyjH9/98h3tamWidJx0knqbY0LS0xJ9/OujixUsnJIV4hySFe6f//f/kFJZn5ecX/dX1N9QwMDQA "Perl 5 ‚Äì Try It Online")
Beats the best anagol answer by one byte:
```
@_=($_=Buffalo,lc)x2,print"@_ \l@_." # Mithran
@_=<{,b,B,b}uffalo>;print"B@_ b@_."  # Sisyphus
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 13 bytes
*Inspired by [@Leo's](https://codegolf.stackexchange.com/users/62393/leo) [answer](https://codegolf.stackexchange.com/a/218298/94066), so make sure to upvote him!* and me too please ;)
```
∆µzbŒµ'¬±ÀÜsi‚Ñ¢]√∞√Ω
```
[Try it online!](https://tio.run/##AR8A4P9vc2FiaWX//8a1emLOtSfCscuGc2nihKJdw7DDvf// "05AB1E ‚Äì Try It Online")
```
∆µzbŒµ'¬±ÀÜsi‚Ñ¢]√∞√Ω  # full program
            √Ω  # join...
    '¬±ÀÜ        # "buffalo"...
   Œµ           # for map over all digits of...
∆µz             # 162...
  b            # in binary...
         ‚Ñ¢     # in title case...
        i      # if...
       s       # current digit in...
   Œµ           # map over all digits of...
∆µz             # 162...
  b            # in binary...
        i      # is 1...
           √∞   # by spaces
          ]    # exit if statement and map
               # implicit output
```
# Boring, trivial alternative, 64 bytes
```
"Buffalo buffalo Buffalo buffalo buffalo buffalo Buffalo buffalo
```
[Try it online!](https://tio.run/##yy9OTMpM/f9fyak0LS0xJ18hCUqj85Pwy///DwA "05AB1E ‚Äì Try It Online")
```
"...  # full program
"...  # literal
      # implicit output
```
**EDIT**: I have stood unbeaten for three months... Brownie points to anyone who outgolfs me.\* Oh, and possibly some rep if I like your answer. ;)
\*Just to clarify, outgolfs in any language will be accepted. It doesn't have to be 05AB1E.
[Answer]
# [V (vim)](https://github.com/DJMcMayhem/V), 20 bytes
```
8ibuffalo <esc>xbb~5b~0~
```
[Try it online!](https://tio.run/##K/v/3yIzqTQtLTEnX0G6IimpzjSpzqDu/38A "V (vim) ‚Äì Try It Online")
* `8ibuffalo <esc>`, write "buffalo " 8 times. cursor at end of line.
* `x` remove current character (the space at end of line).
* `bb` move to the 2nd words beginning from cursor (move left).
* `~` toggle letter case, and also move cursor 1 char right.
* `5b~` move to the 5th words beginning from cursor (move left). And toggle case.
* `0~` move to line beginning. And toggle case.
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), 25 bytes
```
BbBbbbBb
.
$&uffalo 
 $
```
[Try it online!](https://tio.run/##K0otycxL/P@fyynJKSkJiLn0uFTUStPSEnPyFbgUVLj@/wcA "Retina 0.8.2 ‚Äì Try It Online") Explanation:
```
BbBbbbBb
```
Insert the `b`s in the correct capitalisation.
```
.
$&uffalo 
```
Expand the buffalo (buffaloes?).
```
 $
```
Remove the trailing space.
[Answer]
# [R](https://www.r-project.org/), ~~40~~ 39 bytes
*Edit: -1 byte thanks to Dingus*
```
cat(c('buffalo','Buffalo')[1+!21%%1:8])
```
[Try it online!](https://tio.run/##K/r/PzmxRCNZQz2pNC0tMSdfXUfdCcrSjDbUVjQyVFU1tLKI1fz/HwA "R ‚Äì Try It Online")
Chooses whether to output 'buffalo' or 'Buffalo' by indexing with the vector `2 1 2 1 1 1 2 1`, which is constructed as the zero values of `21` modulo each of `1...8`, plus one.
Sadly, trying to recycle the 'uffalo' is significantly longer ([54 bytes](https://tio.run/##K/r/PzmxRKMgsbgkVaM4OTFPQ0ddXVNHvTQtLTEnX12nOLXAFiigyeXElQTGSVD6/38A)) due to [R](https://www.r-project.org/)'s somewhat cumbersome string-manipulation functions (*Edit after reading the 'Anarchy Golf' link: still longer, but can be done in [46 bytes](http://golf.shinh.org/reveal.rb?Buffalo/pooq_1265963786&r)*)
[Answer]
# TI-BASIC, 47 bytes
```
"uffalo
Ans+" b"+Ans
Ans+" B"+Ans
"B"+Ans+" b"+Ans
```
Builds the sentence up in chunks to eliminate the need for string variables which are two byte tokens; Ans is always a single byte even when it holds a string. The strategy also minimizes use of the lowercase letters as they are two byte tokens. The final line is automatically output and you can scroll left-right for the full sentence.
[Answer]
## LabVIEW, 20 bytes
[![LabVIEW code (masked to 0)](https://i.stack.imgur.com/teu8L.png)](https://i.stack.imgur.com/teu8L.png)
[![LabVIEW code (masked to nonzero)](https://i.stack.imgur.com/PTOnP.png)](https://i.stack.imgur.com/PTOnP.png)
Graphical languages are harder to count, so here's my attempt:
* 1 byte loop termination
* 1 byte for the loop
* 1 byte for the integer we encode the capitalization in
* 6 bytes for the 'uffalo' string
* 1 byte for the mask we apply to the integer encoding
* 1 byte for the case structure
* 1 byte for the AND
* 1 byte for the left shift function
* 2 bytes for the capital and noncapital letters in the case structure
* 1 byte for the concatenate string function
* 2 bytes for format string spec
* 1 byte for the delimiter (space)
* 1 byte for the array to spreadsheet string function
And yes, how'd you know about my EE degree?
[Answer]
## Batch, ~~50~~ 49 bytes
```
@set s=B_b_B_b_b_b_B_buffalo
@echo %s:_=uffalo %
```
Batch's string handling is so poor it's golfier to explicitly include the last "buffalo" rather than trying to trim the trailing space at the end.
[Answer]
# JavaScript (ES6), 46 bytes
Builds the string recursively and in reverse order.
```
f=n=>(n>6?'':f(-~n)+' ')+"bB"[n&n!=3]+'uffalo'
```
[Try it online!](https://tio.run/##y0osSyxOLsosKNHNy09J/f8/zTbP1k4jz87MXl3dKk1Dty5PU1tdQV1TWynJSSk6Ty1P0dY4Vlu9NC0tMSdf/X9yfl5xfk6qXk5@ukaahqbmfwA "JavaScript (Node.js) ‚Äì Try It Online")
### Alternate version
```
f=n=>(n>6?'':f(-~n)+' ')+"bB"[25/n&1]+'uffalo'
```
[Try it online!](https://tio.run/##y0osSyxOLsosKNHNy09J/f8/zTbP1k4jz87MXl3dKk1Dty5PU1tdQV1TWynJSSnayFQ/T80wVlu9NC0tMSdf/X9yfl5xfk6qXk5@ukaahqbmfwA "JavaScript (Node.js) ‚Äì Try It Online")
### Commented
```
f = n =>             // f is a recursive function taking a counter n,
                     // which is initially undefined (zero'ish)
  ( n > 6 ?          // if n is greater than 6 (last iteration):
      ''             //   append nothing
    :                // else:
      f(-~n)         //   append the result of a recursive call with n + 1
      + ' '          //   followed by a space
  )                  //
  + "bB"[n & n != 3] // append "B" if n is odd and not equal to 3,
                     // or "b" otherwise
  + 'uffalo'         // append "uffalo"
```
[Answer]
## x86-16 machine code, ~~43~~ ~~42~~ 41 bytes
* -1 byte thanks to @CodyGray.
* -1 byte thanks to @640KB.
```
0BED:0100  BA 19 01 BE 22 01 B4 09-B1 07 CD 21 AC A2 19 01   ...."......!....
0BED:0110  E2 F8 C6 44 F7 24 CD 21-C3 42 75 66 66 61 6C 6F   ...D.$.!.Buffalo
0BED:0120  20 24 62 42 62 62 62 42-62                         $bBbbbBb
```
Instruction listing (nasm syntax):
```
    org 100h      ;           | Execution of .COM files start at CS:0100
    mov dx, msg   ; BA 1B 01  | DX = offset of "Buffalo $" (for INT 21H)
    mov si, buf   ; BE 24 01  | SI = Address of "bBbbbBb"  (for LODSB)
    mov ah, 09h   ; B4 09     | AH = Opcode code INT 21H   (Output string up to '$')
    mov cl, 7     ; B1 07     | CX = 7 (we want to iterate 7 times before the last 'Buffalo')
loop:
    int 21h       ; CD 21     | Output string at msg
    lodsb         ; AC        | AX = [SI], ++SI
    mov byte [msg], al
                  ; A2 1B 01  | Set the first character of msg as the current character at buf
    loop loop     ; E2 F8     | Jump to tag 'loop' while CX >= 0
    mov byte [si - 9], "$"
                  ; C6 44 F7 24 | (After loop) Replace the last space with a '$'
    int 21h       ; CD 21     | Print the last 'buffalo'
    ret           ; C3        | Exit to DOS
msg:    db "Buffalo $"
buf:    db "bBbbbBb"
```
## Example run
```
C:\test>debug code.com
-g
Buffalo buffalo Buffalo buffalo buffalo buffalo Buffalo buffalo
Program terminated normally
```
[Answer]
# [JavaScript (V8)](https://v8.dev/), 43 bytes
```
write(a=`B${b='uffalo'} b`+b,a,c='b'+b,c,a)
```
[Try it online!](https://tio.run/##y0osSyxOLsosKNEts/j/v7wosyRVI9E2wUmlOslWvTQtLTEnX71WISlBO0knUSfZVj1JHchK1knU/P8fAA "JavaScript (V8) ‚Äì Try It Online")
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~62~~ 61 bytes
Realised the 61 byte version was not compliant (outputted a space at the end). Reverted and updated it to be.
-1 byte thanks to [Arnauld](https://codegolf.stackexchange.com/users/58563/arnauld)
```
f(n){for(n=8;n--;)printf("%cuffalo%s","bBbbbBbB"[n]," "+!n);}
```
[Try it online!](https://tio.run/##DcNBCoAgEADAc76iFoRdynsgXfxGdFBhQ6g1rE7R262BiWaNsVZGoYdzQZlGK8ZYOkqSixF0vJn9lvUJAwQXwt/BLMsALfSdkH3r7pMgqUc1jGTVWz8 "C (gcc) ‚Äì Try It Online")
[Answer]
# [Haskell](https://www.haskell.org/), 30 bytes
```
init$"BbBbbbBb">>=(:"uffalo ")
```
[Try it online!](https://tio.run/##y0gszk7Nyfn/v9g2My@zREXJKckpKQmIlezsbDWslErT0hJz8hWUNP/nJmbmKVhZKXj6K2hocoF5tgoFpSXBJUU@eQrF/wE "Haskell ‚Äì Try It Online")
(Cf. [Are objects in Haskell valid if there is no input?](https://codegolf.meta.stackexchange.com/questions/12924/are-objects-in-haskell-valid-if-there-is-no-input/12945#12945))
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 16 bytes
```
Ôº¶‚çò¬π‚Å∂¬≤bB¬´Œπuffalo‚Üí
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z8tv0hBwymxODW4pCgzL13D0MxIR0EpyUlJU1OhmoszAChYopGpaQ1jKpWmpSXm5CuBRHzzy1I1rIIy0zNKgNza////65blAAA "Charcoal ‚Äì Try It Online") Link is to verbose version of code. Explanation:
```
Ôº¶‚çò¬π‚Å∂¬≤bB¬´
```
Convert 162 to base 2, but use `b` for 0 and `B` for 1, and loop over the "digits".
```
Œπ
```
Print the `b` or `B`.
```
uffalo
```
Print the rest of the buffalo.
```
‚Üí
```
Prepare to leave a space before the next `b`, if any.
[Answer]
# [Perl 5](https://www.perl.org/), 38 bytes
```
$,=$";say$_=Buffalo,lc,$_,(lc)x3,$_,lc
```
[Try it online!](https://tio.run/##K0gtyjH9/19Fx1ZFybo4sVIl3tapNC0tMSdfJydZRyVeRyMnWbPCGMTKSf7//19@QUlmfl7xf11fUz0DQwMA "Perl 5 ‚Äì Try It Online")
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 45 bytes
```
_=>[...'BbBbbbBb'].map(x=>x+'uffalo').join` `
```
[Try it online!](https://tio.run/##DcNbCoAgEADAq/SnEu0N7MNrROQjDcVcyQpvvzUwybymuSvWeyq4ewqSNjkvAMCUVdb@2QqnqbzLuY/sCcFkZAISxqIHTQ5Lw@wh48EDF4I@ "JavaScript (Node.js) ‚Äì Try It Online")
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), ~~39~~ 36 bytes
```
''+('BbBbbbBb'|% t*y|%{$_+'uffalo'})
```
[Try it online!](https://tio.run/##K8gvTy0qzkjNyfn/X11dW0PdKckpKQmI1WtUFUq0KmtUq1XitdVL09ISc/LVazX//wcA "PowerShell ‚Äì Try It Online")
-3 bytes thanks to @mazzy!
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 63 bytes
-2 bytes thanks to @Arnauld
```
n=7;f(){printf("%cuffalo%c","bBbbbBbB"[n],9+!n),n--?f():(n=7);}
```
[Try it online!](https://tio.run/##S9ZNT07@r5yZl5xTmpKqYFNckpKZr5dh9z/P1tw6TUOzuqAoM68kTUNJNbk0LS0xJ181WUlHKckpKQmInZSi82J1LLUV8zR18nR17YHqrTSAGjWta/8DdSnkJmbmaWgqVHNxKQABUNYazAATRaklpUV5CgbWXLX/AQ "C (gcc) ‚Äì Try It Online")
Could have been shorter if it wasn't for the reusability rule killing recursive functions.
[Answer]
# Julia, 42 bytes
```
join(collect("BbBbbbBb").*"uffalo ")[1:63]
```
Very similar to what was done with Python above.
[Answer]
# [Whispers v2](https://github.com/cairdcoinheringaahing/Whispers), ~~86~~ 79 bytes
```
> "Buffalo buffalo Buffalo buffalo buffalo buffalo Buffalo buffalo"
>> Output 1
```
[Try it online!](https://tio.run/##K8/ILC5ILSo2@v/fTkHJqTQtLTEnXyEJSqPzk/DLK3HZ2Sn4l5YUlJYoGP7/DwA "Whispers v2 ‚Äì Try It Online")
Well, this is embarrassing...
The first line alone could even be enough, as a function returning the string
For something a bit more interesting, here's my previous solution:
# [Whispers v2](https://github.com/cairdcoinheringaahing/Whispers), 86 bytes
```
> "Buffalo "
> "buffalo "
>> 1+2
>> 3+3
>> 2+2
>> 5+3
>> 4+6
> 63
>> 7·∂†8
>> Output 9
```
[Try it online!](https://tio.run/##K8/ILC5ILSo2@v/fTkHJqTQtLTEnX0GJC8hJQnDsFAy1jUCUsbYxiDKC8EwhPBNtM6B6MzDb/OG2BRYghn9pSUFpiYLl//8A "Whispers v2 ‚Äì Try It Online")
First approach to the [language of the month](https://codegolf.meta.stackexchange.com/q/20698/62393) for me :) It looks like building the string by manually concatenating pieces is the best approach in Whispers.
### Explanation
Whispers starts the execution from the last line of the program, and then follows references from there. Any number in a line starting with `>>`  refers to the result of the corresponding line, while numbers in lines starting with `>`  have their normal value. We can only have a single operation per line (hence why so many lines).
Most lines here simply concatenate two strings, while line 9 takes the first `63` characters from the string in line 7, which is all except for the trailing space. It should be pretty easy to read, but here's the value computed by each line:
```
> "Buffalo "        1:"Buffalo "
> "buffalo "        2:"buffalo "
>> 1+2              3:"Buffalo buffalo "
>> 3+3              4:"Buffalo buffalo Buffalo buffalo "
>> 2+2              5:"buffalo buffalo "
>> 5+3              6:"buffalo buffalo Buffalo buffalo "
>> 4+6              7:"Buffalo buffalo Buffalo buffalo buffalo buffalo Buffalo buffalo "
> 63                8:63
>> 7·∂†8              9:"Buffalo buffalo Buffalo buffalo buffalo buffalo Buffalo buffalo"
>> Output 9         10:prints out line 9
```
[Answer]
# TeX, 34 bytes
`\def~{uffalo }B~b~B~b~b~b~B~b~\bye`
[Answer]
# `awk`, 22- or 41-bytes. basic approach is 41-bytes:
```
echo Buffalo | 
```
> 
> 
> ```
> mawk 'NF+=sub("  ",OFS=" "tolower($2=$4=$1)" ")'       
> 
> ```
> 
> 
```
Buffalo buffalo Buffalo buffalo buffalo buffalo Buffalo buffalo
```
but if we're going with the entirely hard-coded approach, that can massively cut it down to just 22-bytes (and that's already inclusive of the single quotes for `OFS`) :
```
echo BbBbbbBb | 
```
> 
> 
> ```
> mawk NF++ FS= OFS='uffalo '
> 
> ```
> 
> 
```
Buffalo buffalo Buffalo buffalo buffalo buffalo Buffalo buffalo 
```
Trivia tidbit - if we view `"B"`'s as `"1"`'s and `"b"`'s as `"0"`'s,
then the requirement would appear 10100010, while its decimal form can be reached via either
> 
> 
> ```
>   2 * ( 3 ^ 4 )
>                 or
>   3  *  6 * 9 
> 
> ```
> 
> 
[Answer]
# [Mathematica](https://reference.wolfram.com/language/), 54 bytes
```
Print@@Riffle[#<>"uffalo"&/@Characters@"BbBbbbBb"," "]
```
[Try it online!](https://tio.run/##y00syUjNTSzJTE78/z@gKDOvxMEhKDMtLSc1WtnGTqk0LS0xJ19JTd/BOSOxKDG5JLWo2EHJKckpKQmIlXSUFJRi//8HAA "Wolfram Language (Mathematica) ‚Äì Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 15 bytes
```
162B·ªã‚Äú¬¢O·ªä‚Äú¬¶»Ø√∏¬ªK
```
[Try it online!](https://tio.run/##y0rNyan8/9/QzMjp4e7uRw1zDi3yf7i7C8RYdmL94R2Hdnv//w8A "Jelly ‚Äì Try It Online")
(Alternatively, `162B·ªã‚Äú¬¢O·ªä¬ª,≈íl¬§K`)
I might be doing something wrong if this comes out two bytes shorter than title-casing dynamically...:
# [Jelly](https://github.com/DennisMitchell/jelly), 17 bytes
```
≈ít‚Åπ¬°
162B‚Äú¬¶»Ø√∏¬ª√ß‚±ÆK
```
[Try it online!](https://tio.run/##AScA2P9qZWxsef//xZJ04oG5wqEKMTYyQuKAnMKmyK/DuMK7w6fisa5L//8 "Jelly ‚Äì Try It Online")
[Answer]
# APL+WIN, 21 bytes
```
'BbBbbbBb',¬®‚äÇ'uffalo'
```
[Try it online! Thanks to Dyalog Classic](https://tio.run/##SyzI0U2pTMzJT9dNzkksLs5M/v@ob6qvz6O2CcZcQJanP5BlyPWooz3tv7pTklNSEhCr6xxa8airSb00LQ2oU/0/UPZ/GgA "APL (Dyalog Classic) ‚Äì Try It Online")
This could be shortened to 5 bytes if the two strings were given as input rather than being hard coded.
[Answer]
# [Whispers v2](https://github.com/cairdcoinheringaahing/Whispers), 98 bytes
```
> 81
> 2
>> 1‚ä•2
> "Buffalo "
> "buffalo "
> "buffalo"
>> If L 4 5
>> Each 7 3
>> 8+6
>> Output 9
```
[Try it online!](https://tio.run/##K8/ILC5ILSo2@v/fTsHCkMtOwYjLzk7B8FHXUiBDQcmpNC0tMSdfQQnEScLCUQIp90xT8FEwUTAFsV0TkzMUzBWMQWwLbTMQ5V9aUlBaomD5//9/3RAA "Whispers v2 ‚Äì Try It Online")
]