[Question]
  [
## Introduction
In our recent effort to collect catalogues of shortest solutions for standard programming exercises, here is PPCG's first ever vanilla FizzBuzz challenge. If you wish to see other catalogue challenges, there is ["Hello World!"](https://codegolf.stackexchange.com/questions/55422/hello-world) and ["Is this number a prime?"](https://codegolf.stackexchange.com/questions/57617/is-this-number-a-prime).
## Challenge
Write a program that prints the decimal numbers from 1 to 100 inclusive. But for multiples of three print “Fizz” instead of the number and for the multiples of five print “Buzz”. For numbers which are multiples of both three and five print “FizzBuzz”.
## Output
The output will be a list of numbers (and Fizzes, Buzzes and FizzBuzzes) separated by a newline (either `\n` or `\r\n`). A trailing newline is acceptable, but a leading newline is not. Apart from your choice of newline, the output should look exactly like this:
```
1
2
Fizz
4
Buzz
Fizz
7
8
Fizz
Buzz
11
Fizz
13
14
FizzBuzz
16
17
Fizz
19
Buzz
Fizz
22
23
Fizz
Buzz
26
Fizz
28
29
FizzBuzz
31
32
Fizz
34
Buzz
Fizz
37
38
Fizz
Buzz
41
Fizz
43
44
FizzBuzz
46
47
Fizz
49
Buzz
Fizz
52
53
Fizz
Buzz
56
Fizz
58
59
FizzBuzz
61
62
Fizz
64
Buzz
Fizz
67
68
Fizz
Buzz
71
Fizz
73
74
FizzBuzz
76
77
Fizz
79
Buzz
Fizz
82
83
Fizz
Buzz
86
Fizz
88
89
FizzBuzz
91
92
Fizz
94
Buzz
Fizz
97
98
Fizz
Buzz
```
The only exception to this rule is constant output of your language's interpreter that cannot be suppressed, such as a greeting, ANSI color codes or indentation.
## Further Rules
* This is not about finding the language with the shortest approach for playing FizzBuzz, this is about finding the shortest approach in every language. Therefore, no answer will be marked as accepted.
* Submissions are scored in bytes in an appropriate preexisting encoding, usually (but not necessarily) UTF-8. Some languages, like Folders, are a bit tricky to score--if in doubt, please ask on Meta.
* Nothing can be printed to STDERR.
* Feel free to use a language (or language version) even if it's newer than this challenge. If anyone wants to abuse this by creating a language where the empty program generates FizzBuzz output, then congrats for paving the way for a very boring answer.
Note that there must be an interpreter so the submission can be tested. It is allowed (and even encouraged) to write this interpreter yourself for a previously unimplemented language.
* If your language of choice is a trivial variant of another (potentially more popular) language which already has an answer (think BASIC or SQL dialects, Unix shells or trivial Brainfuck derivatives like Alphuck and ???), consider adding a note to the existing answer that the same or a very similar solution is also the shortest in the other language.
* Because the output is fixed, you may hardcode the output (but this may not be the shortest option).
* You may use preexisting solutions, as long as you credit the original author of the program.
* Standard loopholes are otherwise disallowed.
As a side note, please don't downvote boring (but valid) answers in languages where there is not much to golf; these are still useful to this question as it tries to compile a catalogue as complete as possible. However, do primarily upvote answers in languages where the authors actually had to put effort into golfing the code.
## Catalogue
```
var QUESTION_ID=58615;var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";var COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk";var OVERRIDE_USER=30525;var answers=[],answers_hash,answer_ids,answer_page=1,more_answers=true,comment_page;function answersUrl(index){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+index+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(index,answers){return"https://api.stackexchange.com/2.2/answers/"+answers.join(';')+"/comments?page="+index+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:true,success:function(data){answers.push.apply(answers,data.items);answers_hash=[];answer_ids=[];data.items.forEach(function(a){a.comments=[];var id=+a.share_link.match(/\d+/);answer_ids.push(id);answers_hash[id]=a});if(!data.has_more)more_answers=false;comment_page=1;getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:true,success:function(data){data.items.forEach(function(c){if(c.owner.user_id===OVERRIDE_USER)answers_hash[c.post_id].comments.push(c)});if(data.has_more)getComments();else if(more_answers)getAnswers();else process()}})}getAnswers();var SCORE_REG=/<h\d>\s*([^\n,<]*(?:<(?:[^\n>]*>[^\n<]*<\/[^\n>]*>)[^\n,<]*)*),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/;var OVERRIDE_REG=/^Override\s*header:\s*/i;function getAuthorName(a){return a.owner.display_name}function process(){var valid=[];answers.forEach(function(a){var body=a.body;a.comments.forEach(function(c){if(OVERRIDE_REG.test(c.body))body='<h1>'+c.body.replace(OVERRIDE_REG,'')+'</h1>'});var match=body.match(SCORE_REG);if(match)valid.push({user:getAuthorName(a),size:+match[2],language:match[1],link:a.share_link,});else console.log(body)});valid.sort(function(a,b){var aB=a.size,bB=b.size;return aB-bB});var languages={};var place=1;var lastSize=null;var lastPlace=1;valid.forEach(function(a){if(a.size!=lastSize)lastPlace=place;lastSize=a.size;++place;var answer=jQuery("#answer-template").html();answer=answer.replace("{{PLACE}}",lastPlace+".").replace("{{NAME}}",a.user).replace("{{LANGUAGE}}",a.language).replace("{{SIZE}}",a.size).replace("{{LINK}}",a.link);answer=jQuery(answer);jQuery("#answers").append(answer);var lang=a.language;lang=jQuery('<a>'+lang+'</a>').text();languages[lang]=languages[lang]||{lang:a.language,lang_raw:lang.toLowerCase(),user:a.user,size:a.size,link:a.link}});var langs=[];for(var lang in languages)if(languages.hasOwnProperty(lang))langs.push(languages[lang]);langs.sort(function(a,b){if(a.lang_raw>b.lang_raw)return 1;if(a.lang_raw<b.lang_raw)return-1;return 0});for(var i=0;i<langs.length;++i){var language=jQuery("#language-template").html();var lang=langs[i];language=language.replace("{{LANGUAGE}}",lang.lang).replace("{{NAME}}",lang.user).replace("{{SIZE}}",lang.size).replace("{{LINK}}",lang.link);language=jQuery(language);jQuery("#languages").append(language)}}
```
```
body{text-align:left!important}#answer-list{padding:10px;width:290px;float:left}#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}
```
```
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="language-list"> <h2>Shortest Solution by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr> </thead> <tbody id="languages"> </tbody> </table> </div> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr> </thead> <tbody id="answers"> </tbody> </table> </div> <table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr> </tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr> </tbody> </table>
```
  
[Answer]
# [Hexagony](https://github.com/mbuettner/hexagony), 91 bytes
Thanks for the bounty :)
Wow, I would never have imagined I could beat [Martin’s Hexagony solution](https://codegolf.stackexchange.com/a/63344/34718).
But—who would have thunk it—I got it done. After several days of failure because I neither had the Hexagony colorer nor the [EsotericIDE](https://github.com/Timwi/EsotericIDE) to check my solution. I got several aspects of the specification wrong, so I produced a few wrong “solutions” just using pen and paper and a text editor.
Well, finally I overcame my laziness and cloned both repositories, downloaded VisualStudio and compiled them. Wow, what useful tools they are! As you can see, I am far from being someone you’d call a programmer (I mean, come on! I didn’t even have VisualStudio installed, and have pretty much no clue about how to compile a program) ;)
It still took me a while to find a working solution, and it is quite crammed and chaotic, but here it is in all its glory:
Fizzbuzz in a size 6 hexagon:
```
3}1"$.!$>)}g4_.{$'))\<$\.\.@\}F\$/;z;u;<%<_>_..$>B/<>}))'%<>{>;e"-</_%;\/{}/>.\;.z;i;..>(('
```
Hexagonal layout:
```
      3 } 1 " $ .
     ! $ > ) } g 4
    _ . { $ ' ) ) \
   < $ \ . \ . @ \ }
  F \ $ / ; z ; u ; <
 % < _ > _ . . $ > B /
  < > } ) ) ' % < > {
   > ; e " - < / _ %
    ; \ / { } / > .
     \ ; . z ; i ;
      . . > ( ( '
```
And the beautiful rendition, thanks to Timwi’s [Hexagony Colorer](https://github.com/Timwi/HexagonyColorer):
[![Colorized Hexagony FizzBuzz solution](https://i.stack.imgur.com/g4OgJ.png)](https://i.stack.imgur.com/g4OgJ.png)
So, here is a 110 seconds long GIF animation at 2 fps, showing the program flow during the first 6 numbers `1, 2, Fizz, 4, Buzz, Fizz`, the first 220 ticks of the program (click on the image for the full size):
[![enter image description here](https://i.stack.imgur.com/Ciu3j.gif)](https://i.stack.imgur.com/Ciu3j.gif)
My goodness, thanks to the Natron compositing software the animation of the pointer was still tedious to create, but manageable. Saving 260 images of the memory was less amusing. Unfortunately EsotericIDE can’t do that automatically. Anyways, enjoy the animation!
After all, once you wrap your head around the memory model and the rather counterintuitive wrapping of paths that cross the borders of the hexagon, Hexagony is not that hard to work with. But golfing it can be a pain in the butt. ;)
It was fun!
[Answer]
# [Python 2](https://docs.python.org/2/), 56 bytes
```
i=0;exec"print i%3/2*'Fizz'+i%5/4*'Buzz'or-~i;i+=1;"*100
```
[Try it online!](https://tio.run/##K6gsycjPM/r/P9PWwDq1IjVZqaAoM69EIVPVWN9IS90ts6pKXTtT1VTfREvdqRTIyS/Srcu0ztS2NbRW0jI0MPj/HwA "Python 2 – Try It Online")
[Answer]
# [Labyrinth](http://esolangs.org/wiki/Labyrinth), 94 bytes
```
"):_1
\ } 01/3%70.105
" :   @ "     .
"  =";_""..:221
+  _
"! 5%66.117
_:= "     .
="*{"..:221
```
Sub-100! This was a fun one.
## Explanation
Let's start with a brief primer on Labyrinth – feel free to skip this if you're already familiar with the basics:
* Labyrinth has two stacks – a main stack and an auxiliary stack. Both stacks have an infinite number of zeroes at the bottom, e.g. `+` on an empty stack adds two zeroes, thus pushing zero.
* Control flow in Labyrinth is decided by junctions, which look at the top of the stack to determine where to go next. Negative means turn left, zero means go straight ahead and positive means turn right... but if we hit a wall then we reverse direction. For example, if only straight ahead and turn left are possible but the top of the stack is positive, then since we can't turn right we turn left instead.
* Digits in Labyrinth pop `x` and push `10*x + <digit>`, which makes it easy to build up large numbers. However, this means that we need an instruction to push 0 in order to start a new number, which is `_` in Labyrinth.
Now let's get to the actual code!
[![enter image description here](https://i.stack.imgur.com/o3HrUm.png)](https://i.stack.imgur.com/o3HrUm.png)
### Red
Execution starts from the `"` in the top-left corner, which is a NOP. Next is `)`, which increments the top of the stack, pushing 1 on the first pass and incrementing `n` on every following pass.
Next we duplicate `n` with `:`. Since `n` is positive, we turn right, executing `}` (shift top of main stack to auxiliary) and `:`. We hit a dead end, so we turn around and execute `}` and `:` once more, leaving the stacks like
```
Main [ n n | n n ] Aux
```
Once again, `n` is positive and we turn right, executing `_101/` which divides `n` by 101. If `n` is 101 then `n/101 = 1` and we turn into the `@`, which terminates the program. Otherwise, our current situation is
```
Main [ n 0 | n n ] Aux
```
### Orange 1 (mod 3)
`3` turns the top zero into a 3 (`10*0 + 3 = 3`) and `%` performs a modulo. If `n%3` is positive, we turn right into the yellow `"`. Otherwise we perform `70.105.122:..`, which outputs `Fizz`. Note that we don't need to push new zeroes with `_` since `n%3` was zero in this case, so we can exploit the infinite zeroes at the bottom of the stack. Both paths meet up again at light blue.
### Light blue
The top of the stack is currently `n%3`, which could be positive, so the `_;` just pushes a zero and immediately pops it to make sure we go straight ahead, instead of turning into the `@`. We then use `=` to swap the tops of the main and auxiliary stacks, giving:
```
Main [ n | n%3 n ] Aux
```
### Orange 2 (mod 5)
This is a similar situation to before, except that `66.117.122:..` outputs `Buzz` if `n%5` is zero.
### Dark blue
The previous section leaves the stacks like
```
Main [ n%5 | n%3 n ] Aux
```
`{` shifts the `n%3` back to the main stack and `*` multiplies the two modulos.
If either modulo is zero, the product is zero so we go straight into yellow. `=` swaps the top of the stacks and `_` pushes a zero to make sure we go straight ahead, giving
```
Main [ n 0 | 0 ] Aux
```
Otherwise, if both modulos are nonzero, then the product is nonzero and we turn right into green. `=` swaps the tops of the stacks, giving
```
Main [ n | (n%5)*(n%3) ] Aux
```
after which we use `:` to duplicate `n`, turn right, then use `!` to output `n`.
### Purple
At this point, the main stack has either one or two items, depending on which path was taken. We need to get rid of the zero from the yellow path, and to do that we use `+`, which performs `n + 0` in some order for both cases. Finally, `\` outputs a newline and we're back at the start.
Each iteration pushes an extra `(n%5)*(n%3)` to the auxiliary stack, but otherwise we do the same thing all over again.
[Answer]
# Ruby, 50 bytes
Requires version 1.8, which seems to be popular among golfers:
```
1.upto(?d){|n|puts'FizzBuzz
'[i=n**4%-15,i+13]||n}
```
In modern Ruby, you replace `?d` with `100` for a 51-byte solution.
This seems to be the world record.
[Answer]
# Perl 5, 49 bytes
**46 bytes script + 3 bytes `-E"..."`**
Using `say` (which requires `-E"..."`) can reduce this further to 46 bytes since `say` automatically includes a newline (Thanks [@Dennis](https://codegolf.stackexchange.com/users/12012/dennis)!):
```
say'Fizz'x!($_%3).Buzz x!($_%5)||$_ for 1..100
```
---
# Perl 5, 50 bytes
```
print'Fizz'x!($_%3).Buzz x!($_%5)||$_,$/for 1..100
```
[Answer]
# [gs2](https://github.com/nooodl/gs2/), 1
```
f
```
A [quote](https://codegolf.stackexchange.com/a/55176/2537) from Mauris, the creator of gs2:
> 
> I wanted to one-up [goruby](https://stackoverflow.com/a/64124/257418)'s 1-byte `Hello, world!`, so... This prints `"1\n2\nFizz\n4\nBuzz\n..."`. :)
> 
> 
> 
**Update**: Added 27-byte [answer](https://codegolf.stackexchange.com/a/58664/2537) that doesn't use `f`.
[Answer]
# Java, 130 bytes
This is for recent Java versions (7+). In older ones you can shave some more off using the `enum` trick, but I don't think the logic gets any shorter than this (86 inside `main`).
```
class F{public static void main(String[]a){for(int i=0;i++<100;)System.out.println((i%3<1?"Fizz":"")+(i%5<1?"Buzz":i%3<1?"":i));}}
```
[Answer]
# JavaScript, 62 bytes
```
for(i=0;++i<101;console.log(i%5?f||i:f+'Buzz'))f=i%3?'':'Fizz'
```
I think I this is the shortest Javascript solution now.
[Answer]
## ArnoldC, 842 bytes
```
IT'S SHOWTIME
HEY CHRISTMAS TREE a
YOU SET US UP 100
HEY CHRISTMAS TREE b
YOU SET US UP 0
HEY CHRISTMAS TREE r
YOU SET US UP 0
STICK AROUND a
GET TO THE CHOPPER b
HERE IS MY INVITATION 101
GET DOWN a
ENOUGH TALK
GET TO THE CHOPPER r
HERE IS MY INVITATION b
I LET HIM GO 15
ENOUGH TALK
BECAUSE I'M GOING TO SAY PLEASE r
GET TO THE CHOPPER r
HERE IS MY INVITATION b
I LET HIM GO 3
ENOUGH TALK
BECAUSE I'M GOING TO SAY PLEASE r
GET TO THE CHOPPER r
HERE IS MY INVITATION b
I LET HIM GO 5
ENOUGH TALK
BECAUSE I'M GOING TO SAY PLEASE r
TALK TO THE HAND b
BULLSHIT
TALK TO THE HAND "Buzz"
YOU HAVE NO RESPECT FOR LOGIC
BULLSHIT
TALK TO THE HAND "Fizz"
YOU HAVE NO RESPECT FOR LOGIC
BULLSHIT
TALK TO THE HAND "FizzBuzz"
YOU HAVE NO RESPECT FOR LOGIC
GET TO THE CHOPPER a
HERE IS MY INVITATION a
GET DOWN 1
ENOUGH TALK
CHILL
YOU HAVE BEEN TERMINATED
```
First try at golfing, I think this is as bad as it gets (both language and golfing).
[Answer]
# Pyth, 30
```
VS100|+*!%N3"Fizz"*!%N5"Buzz"N
```
[Try it here](http://pyth.herokuapp.com/?code=VS100%7C%2B%2a%21%25N3%22Fizz%22%2a%21%25N5%22Buzz%22N&debug=0)
### Explanation:
```
VS100|+*!%N3"Fizz"*!%N5"Buzz"N
VS100                            : for N in range(1,101)
     |                           : logical short-circuiting or
      +*!%N3"Fizz"               : add "Fizz" * not(N % 3)
                                 : Since not gives True/False this is either "" or "Fizz"
                  *!%N5"Buzz"    : Same but with 5 and Buzz
                             N   : Otherwise N
                                 : The output of the | is implicitly printed with a newline
```
[Answer]
## [Retina](https://github.com/m-ender/retina/wiki/The-Language), ~~317~~ ~~139~~ ~~134~~ ~~132~~ ~~70~~ ~~63~~ ~~60~~ 55 bytes
```
.100{`^
_
*\(a`(___)+
Fi;$&
\b(_{5})+$
Bu;
;_*
zz
'_&`.
```
[Try it online!](https://tio.run/##K0otycxLNPz/X8/QwKA6IY4rnksrRiMxQSM@Pl5Tm8st01pFjSsmSSO@2rRWU1uFy6nUmss6XourqopLPV4tQe//fwA "Retina – Try It Online")
## Explanation
```
.100{`^
_
```
The `.` is the global silent flag which turns off implicit output at the end of the program. `100{` wraps the rest of the program in a loop which is executed for 100 iterations. Finally, the stage itself just inserts a `_` at the beginning of the string, which effectively increments a unary loop counter.
```
*\(a`(___)+
Fi;$&
```
More configuration. `*\(` wraps the remainder of the program in a group, prints its result with a trailing linefeed, but also puts the entire group in a dry run, which means that its result will be discarded after printing, so that our loop counter isn't actually modified. `a` is a custom regex modifier which anchors the regex to the entire string (which saves a byte on using `^` and `$` explicitly).
The atomic stage itself takes care of `Fizz`. Divisibility by `3` can easily be checked in unary: just test if the number can be written as a repetition of `___`. If this is the case, we prepend `Fi;` to the string. The semicolon is so that there is still a word boundary in front of the number for the next stage. If we turned the line into `Fizz___...` the position between `z` and `_` would not be considered a boundary, because regex treats both letters and underscores as word characters. However, the semicolon also allows us to remove the `zz` duplication from `Fizz` and `Buzz`.
```
\b(_{5})+$
Bu;
```
We do the exact same for divisibility by `5` and `Bu;`, although we don't need to keep the `_`s around this time. So we would get a results like
```
_
__
Fi;___
____
Bu;
Fi;______
...
Fi;Bu;
...
```
This makes it very easy to get rid of the underscores only in those lines which contain `Fizz`, while also filling in the `zz`s:
```
;_*
zz
```
That is, we turn each semicolon into `zz` but we also consume all the `_`s right after it. At this point we're done with FizzBuzz in unary. But the challenge wants decimal output.
```
'_&`.
```
`&` indicates a conditional: this stage is only executed if the string contains an underscore. Therefore, `Fizz`, `Buzz` and `FizzBuzz` iterations are left untouched. In all other iterations (i.e. those which are neither divisible by 3 nor 5), we just count the number of characters, converting the result to decimal.
[Answer]
## brainfuck, 206 bytes
```
++>+++++>>>>>++++++++++[>+>>+>>+>+<<<[++++<-<]<,<,-<-<++<++++[<++>++++++>]++>>]>
[+[[<<]<[>>]+++<[<.<.<..[>]]<<-[>>>[,>>[<]>[--.++<<]>]]+++++<[+[-----.++++<<]>>+
..<-[>]]<[->>,>+>>>->->.>]<<]<[>+<<<,<->>>+]<]
```
Formatted:
```
++>+++++>>>>>
++++++++++[>+>>+>>+>+<<<[++++<-<]<,<,-<-<++<++++[<++>++++++>]++>>]
>
[
  +
  [
    [<<]
    <[>>]
    +++<
    [
      Fizz
      <.<.<..
      [>]
    ]
    <<-
    [
      >>>
      [
        ,>>[<]
        >[--.++<<]
        >
      ]
    ]
    +++++<
    [
      Buzz
      +[-----.++++<<]
      >>+..
      <-
      [>]
    ]
    <[->>,>+>>>->->.>]
    <<
  ]
  <[>+< <<,<->>>+]
  <
]
```
[Try it online](https://tio.run/##PU7bCQMxDBvIjwmEFjH@6B0USqEfhc6fyjlaOQFHkWwd79vjdf@cz7XMaAMO7I@imH0MQA2FQMPhoUavrcLPbuyZ0SyrgoTFYQyFnMpiNxCiWa4LSSNSCnXde4b2iItNXx@0zDHJW0H6RGKokn1tmXiOmPCNXusL)
The memory layout is
```
0 a 122 105 70 b f 0 t d1 s d2 c d 10 0
```
where `f` cycles by 3, `b` cycles by 5, `d1` is ones digit, `d2` is tens digit, `s` is a flag for whether to print tens digit, `d` cycles by 10, `c` is copy space for `d`, `t` is working space that holds 0 or junk data or a flag for not-divisible-by-3, and `a` determines program termination by offsetting the pointer after Buzz has been printed 20 times.
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), `j`, 65 bits1, ~~18~~ ~~17~~ ~~14~~ ~~12~~ ~~11~~ 8.125 [bytes](https://github.com/Vyxal/Vyncode/blob/main/README.md)
```
₁ƛ₍₃₅kF½*∑∴
```
[Try it Online! (link is to bitstring)](https://vyxal.pythonanywhere.com/?v=1#WyJqISIsIiIsIjExMDAwMDEwMTEwMTExMDAwMTAwMDAxMDExMTEwMDEwMDEwMDEwMTExMTAwMDExMDExMDAxMDAxMTExMDAxMDAwIiwiIiwiIl0=)
I refuse to be beaten by Arn, Ash and Fig. I absolutely will not be beaten by any of those languages. Vyxal forever lads.
And yes, that really *is* 8.125 bytes. [We have a fractional byte encoding system now](https://github.com/Vyxal/Vyncode). The 65-bit bitstring can be found at the online link.
The program is presented as SBCS for convenience.
## Explained
```
₁ƛ₍₃₅kF½*∑∴
₁           # Push 100 to the stack
 ƛ          # Over the range [1, 100], map: (we'll call the argument n)
  ₍₃₅       #   [n % 3 == 0, n % 5 == 0] (call this X)
     kF     #   "FizzBuzz"
       ½    #   ["Fizz", "Buzz"] # halve the string - split into two equal pieces
        *∑  #   sum(X * ↑)
          ∴ #   max(↑, n)
            # The -j flag joins on newlines before outputting
```
If you want it flagless:
## [Vyxal](https://github.com/Vyxal/Vyxal), 12 bytes
```
₁⟑₍₃₅kF½*∑∴,
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyIiLCIiLCLigoHin5Higo3igoPigoVrRsK9KuKIkeKItCwiLCIiLCIiXQ==)
See how inconsequential flags are?
## [Vyxal](https://github.com/Vyxal/Vyxal), 17 bytes
```
₁⟑35fḊ`₴ḟȦ↑`½*∑∴,
```
No questionable built-ins, no flags, just plain legitimate fizzbuzz.
[Try it Online!](https://vyxal.pythonanywhere.com/#WyIiLCIiLCLigoHin5EzNWbhuIpg4oK04bifyKbihpFgwr0q4oiR4oi0LCIsIiIsIiJd)
[Answer]
# Perl 5, 45 bytes
```
say((Fizz)[$_%3].(Buzz)[$_%5]or$_)for+1..100
```
Requires the `-E` option, counted as one. This must be run from the command line, i.e.:
```
perl -Esay((Fizz)[$_%3].(Buzz)[$_%5]or$_)for+1..100
```
Quotes around the command are unnecessary, if one avoids using spaces, or any other characters which can act as command line separators (`|`, `<`, `>`, `&`, etc.).
---
# Perl 5, 48 bytes
```
print+(Fizz)[$_%3].(Buzz)[$_%5]||$_,$/for 1..100
```
If command line options are counted as one each, `-l` would save one byte (by replacing `$/`). By [Classic Perlgolf Rules](http://thospel.home.xs4all.nl/golf/rules.html), however, this would count 3: one for the `-`, one for the `l`, and one for the necessary space.
[Answer]
# [beeswax](http://esolangs.org/wiki/Beeswax), ~~104~~ ~~89~~ 81 bytes
Denser packing allowed for cutting off 8 more bytes.
**Shortest solution (81 bytes), same program flow, different packing.**
```
p?@<
p?{@b'gA<
p@`zzuB`d'%~5F@<f`z`<
 >~P"#"_"1F3~%'d`Fiz`b
 d;"-~@~.<
>?N@9P~0+d
```
Changing the concept enabled me to cut down the code by 15 bytes.
I wanted to get rid of the double mod 5 test in the solution, so I implemented a flag.
Short explanation:
if `n%3=0` Fizz gets printed, and the flag gets set. The flag is realized simply by pushing the top lstack value onto the gstack (instruction `f`).
If `n%5=0`, then either `n%3=0`(FizzBuzz case) or `n%3>0`(Buzz case). In both cases, Buzz gets printed, and the flag reset by popping the stack until it’s empty (instruction `?`).
Now the interesting cases:
If `n%5>0`, then either we had `n%3=0` (printing Fizz case, n must not be printed) or `n%3>0` (Fizz was not printed, so n has to be printed). Time to check the flag. This is realized by pushing the length of gstack on top of gstack (instruction `A`).
If `n%3 was 0` then the gstack length is >0.
If `n%3 was >0`, the gstack length is 0.
A simple conditional jump makes sure n gets only printed if the length of gstack was 0.
Again, after printing any of n, Fizz, and/or Buzz and the newline, the gstack gets popped twice to make sure it’s empty. gstack is either empty `[]`, which leads to `[0]` after instruction `A` (push length of gstack on gstack), or it contains one zero (`[0]`,the result of n%3), which leads to `[0 1]`, as [0] has the length 1. Popping from an empty stack does not change the stack, so it’s safe to pop twice.
If you look closer you can see that, in principle, I folded
```
>      q
d`Fizz`f>
```
into
```
<f`z`<
d`Fiz`b
```
which helps to get rid of the all the wasted space between `A` and `<` at the end of the following row in the older solution below:
```
q?{@b'gA<       p      <
```
**New concept solution (89 bytes) including animated explanation:**
```
q?@ <
 q?{@b'gA<       p      <
p?<@`zzuB`b'%~5F@<f`zziF`b'<
>N@9P~0+.~@~-";~P"#"_"1F3~%d
```
Hexagonal layout:
```
   q ? @   <
    q ? { @ b ' g A <               p             <
 p ? < @ ` z z u B ` b ' % ~ 5 F @ < f ` z z i F ` b ' <
> N @ 9 P ~ 0 + . ~ @ ~ - " ; ~ P " # " _ " 1 F 3 ~ % d
```
---
Animation of the first 326 ticks at 2 fps, with local and global stacks, and output to STDOUT.
[![beeswax FizzBuzz animation](https://i.stack.imgur.com/t04r8.gif)](https://i.stack.imgur.com/t04r8.gif)
---
For comparison, below are the path overlays of the older, more complex solution. Maybe it’s also the prettier solution, from a visual standpoint ;)
[![Program with path overlay](https://i.stack.imgur.com/0JuPe.png)](https://i.stack.imgur.com/0JuPe.png)
[Answer]
# [><>](https://esolangs.org/wiki/Fish), ~~68~~ ~~66~~ ~~65~~ ~~64~~ 63 bytes
```
1\2+2fooo o"Buzz"<
o>:::3%:?!\$5%:?!/*?n1+:aa*)?;a
o.!o"Fizz"/o
```
The only trick is to multiply remainders as a condition to number printing. That way, if one of them is 0 we won't print the number.
You can try it [here](https://suppen.no/fishlanguage).
Saved one byte thanks to Sp3000, another thanks to randomra, and a last one thanks to Jacklyn. Thanks a lot!
[Answer]
# Apple Shortcuts, 9 actions
[![enter image description here](https://i.stack.imgur.com/hp11O.jpg)](https://i.stack.imgur.com/hp11O.jpg)
This creates a loop that runs 100 times. For each loop, it gets the iteration number and modulos it by 3. We then take the result and use regex replacement to change it to “Fizz” if it is 0. Then, we take the iteration number and use regex replacement to change it to “Buzz” if it ends in 0 or 5.
At this point, we have a value that is either “Fizz” or a number, and we have a value that is either “Buzz” or a number. We combine those two values together into a single string, and use regex replacement to remove any numbers. This leaves us with one of “Fizz”, “Buzz”, “FizzBuzz”, or an empty string. Finally, we use one more regex replacement to replace an empty string with the iteration number.
The final value left at the end of each iteration is added to the repeat results, so after the loop has finished running, we simply print the list of repeat results with a “show result” action, which automatically formats the list as a bunch of newline separated values.
For those who don’t want to/don’t know how to enter this code, [here’s an iOS link](https://www.icloud.com/shortcuts/20829a2475f449d582196a19ec87e51e) that should hopefully maybe possibly work.
[Answer]
# [gs2](https://github.com/nooodl/gs2/), 28 27 (without `f`)
Hex:
```
1b 2f fe cc 04 46 69 7a 7a 09 07 42 75 7a 7a 19 06 27 2d d8 62 32 ec 99 dc 61 0a
```
Explanation:
```
1b    100
2f    range1 (1..n)
fe    m: (map rest of program)
cc    put0 (pop and store in register 0)
04    string-begin
Fizz
09    9
07    string-separator
Buzz
19    25
06    string-end-array (result: ["Fizz"+chr(9) "Buzz"+chr(25)])
27    right-uncons
2d    sqrt
d8    tuck0 (insert value of register 0 under top of stack)
62    divides
32    times (string multiplication)
ec    m5 (create block from previous 5 tokens, then call map)
99    flatten
dc    show0 (convert register 0 to string and push it)
61    logical-or
0a    newline
```
Embedding 3 and 5 into the string constant doesn't work because `\x05` ends string literals.
Note: This problem can be solved in [1 byte](https://codegolf.stackexchange.com/a/58632/2537) with gs2 using the built-in `f`.
[Answer]
# C, 74 bytes
```
main(i){for(;i<101;puts(i++%5?"":"Buzz"))printf(i%3?i%5?"%d":0:"Fizz",i);}
```
The `0` argument to `printf` instead of `""` is fishy, but seems to work on most platforms I try it on. `puts` segfaults when you try the same thing, though. Without it, you get 75 bytes.
There are 73-byte solutions that work on [anarchy golf](http://golf.shinh.org/p.rb?FizzBuzz#C), and I found one digging around in the right places on the internet, but they rely on platform-specific behavior. (As you might have guessed, it's something of the form `puts("Buzz"±...)`.)
[Answer]
# Scratch, ~~203~~ 185 bytes
[![](https://i.stack.imgur.com/zfaPv.png)](https://scratch.mit.edu/projects/85315030/#editor)
Bytes counted from the golfed [textual representation](http://scratchblocks.github.io/#when%20gf%20clicked%0Aset%5Bx%20v%5Dto%5B1%0Arepeat(100%0Aset%5By%20v%5Dto%5B%0Aif%3C((x)mod(3))%3D%5B0%0Aset%5By%20v%5Dto%5BFizz%0Aend%0Aif%3C((x)mod(5))%3D%5B0%0Aset%5By%20v%5Dto(join(y)%5BBuzz%0Aend%0Aif%3C(y)%3D%5B%0Asay(x%0Aelse%0Asay(y%0Aend%0Achange%5Bx%20v%5Dby(1%0Aend), per [this meta post](http://meta.codegolf.stackexchange.com/questions/673/golfing-from-scratch/5013#5013). Scratch is not very space-efficient.
`say` is the closest thing to a stdout Scratch has: the sprite displays a speech bubble containing whatever it is saying. In practice, a `wait n secs` block would be needed to actually read this output, but for the purposes of this challenge this code fulfills the requirements.
[Answer]
# [Jelly](http://github.com/DennisMitchell/jelly), ~~24~~ 20 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
³µ3,5ḍTị“¡Ṭ4“Ụp»ȯµ€G
```
[Try it online!](http://jelly.tryitonline.net/#code=wrPCtTMsNeG4jVThu4vigJzCoeG5rDTigJzhu6RwwrvIr8K14oKsRw&input=)
### How it works
```
³µ3,5ḍTị“¡Ṭ4“Ụp»ȯµ€G  Main link. No input.
³                     Yield 100.
 µ                    Begin a new, monadic chain.
                 µ€   Apply the preceding chain to all integers n in [1, ..., 100].
  3,5ḍ                Test n for divisibility by 3 and 5.
      T               Get all truthy indices.
                      This yields [1] (mult. of 3, not 5), [2] (mult. of 5, not 3),
                      [1, 2] (mult. of 15) or [].
        “¡Ṭ4“Ụp»      Yield ['Fizz', 'Buzz'] by indexing in a dictionary.
       ị              Retrieve the strings at the corr. indices.
                ȯ     Logical OR hook; replace an empty list with n.
                   G  Grid; join the list, separating by linefeeds.
```
[Answer]
# C, 85 bytes
```
i;main(){for(;i++<=99;printf("%s%s%.d\n",i%3?"":"Fizz",i%5?"":"Buzz",(i%3&&i%5)*i));}
```
*-2 thanks to squeamish.*
[Answer]
# Haskell, ~~84~~ 82 bytes
```
main=mapM putStrLn[show n`max`map("FizzBuzz"!!)[6-2*gcd 3n..2+gcd 5n]|n<-[1..100]]
```
The expressions work out like this:
```
 n   6-2*gcd(3,n)  2+gcd(5,n)
=============================
 1        4             3   
 2        4             3   
 3       *0             3   
 4        4             3   
 5        4            *7   
 6       *0             3   
 7        4             3   
 8        4             3   
 9       *0             3   
10        4            *7    
11        4             3    
12       *0             3    
13        4             3    
14        4             3    
15       *0            *7    
16       ...           ...
```
We use them as start and end points for slicing the string. For example, when `n == 5`, then `map("FizzBuzz"!!)[4..7] == "Buzz"`.
For non-divisible numbers, the range `[4..3]` is empty, so the result of `map` is `""`, and `max (show n)` replaces that result.
## Old 84 byte answer
```
main=mapM f[1..100]
f n|d<-drop.(*4).mod n=putStrLn$max(show n)$d 3"Fizz"++d 5"Buzz"
```
`d = drop.(*4).mod n` is key here: `d 3 "Fizz"` is `drop (n`mod`3 * 4) "Fizz"`. This is `"Fizz"` when `n `mod` 3` is 0 and `""` otherwise.
## Other stuff
I got here via this 85:
```
main=mapM putStrLn[max(show n)$drop(6-2*gcd 3n)$take(3+gcd 5n)"FizzBuzz"|n<-[1..100]]
```
Here is another interesting 85:
```
f n=cycle[show n,"Fizz","Buzz",f 3++f 5]!!div(gcd 15n)2
main=mapM(putStrLn.f)[1..100]
```
The world record is 80 bytes by henkma.
[Answer]
# CJam, 35 bytes
```
100{)_[Z5]f%:!"FizzBuzz"4/.*s\e|N}/
```
Try it online in the [CJam interpreter](http://cjam.aditsu.net/#code=100%7B)_%5BZ5%5Df%25%3A!%22FizzBuzz%224%2F.*s%5Ce%7CN%7D%2F).
### How it works
```
100{)_[Z5]f%:!"FizzBuzz"4/.*s\e|N}/
100{                             }/  For each integer I between 0 and 99:
    )_                                 Increment I and push a copy.
      [Z5]                             Push [3 5].
          f%                           Map % to push [(I+1)%3 (I+1)%5].
            :!                         Apply logical NOT to each remainder.
              "FizzBuzz"4/             Push ["Fizz" "Buzz"].
                          .*           Vectorized string repetition.
                            s\         Flatten the result and swap it with I+1.
                              e|       Logical OR; if `s' pushed an empty string,
                                       replace it with I+1.
                                N      Push a linefeed.
```
[Answer]
# C#, 128 126 125 124 bytes
```
class A{static void Main(){for(var i=0;i++<100;)System.Console.Write("{0:#}{1:;;Fizz}{2:;;Buzz}\n",i%3*i%5>0?i:0,i%3,i%5);}}
```
89 bytes without the boilerplate code around.
Done with the use of C#'s [conditional formatting](https://msdn.microsoft.com/en-us/library/0c899ak8.aspx). 
With two section separators `;`, Fizz or Buzz are printed if the value from their condition is zero.
  
Saved a total of 4 bytes thanks to @RubberDuck, @Timwi and @Riokmij.
[Answer]
# MUMPS, ~~56~~ 54 bytes
```
f i=1:1:100 w:i#5=0 "Fizz" w:i#3=0 "Buzz" w:$X<3 i w !
```
What's this `w:$X<3 i` thing, you ask? `$X` is a magic variable (an "intrinsic") that stores the horizontal position of the output cursor (as a number of characters from the left edge of the terminal). `w` is the abbreviated form of the `WRITE` command. The syntax `command:condition args` is a postconditional - "if `condition`, then do `command args`". 
So we're checking whether the output cursor has been advanced more than two characters (which would mean that at least one of `"Fizz"` or `"Buzz"` has been written to the terminal), and if not, writing `i` to the terminal. The `$X` variable - and hence, this sort of deep inseparability from the terminal - is a first-class feature of MUMPS. Yikes.
[Answer]
# PowerShell, ~~78~~ ~~68~~ ~~61~~ ~~54~~ 51 Bytes
*(-1 byte thanks to a person on Twitter that explicitly started following me just to tag me in a Tweet with a golf, because they don't use SE. I was able to improve on that with a bit more of a golf. But since it requires the new [ternary operator](https://learn.microsoft.com/en-us/powershell/scripting/whats-new/what-s-new-in-powershell-70?view=powershell-7.2) in pwsh 7, I'm leaving the old versions present lower down.)*
```
1..100|%{($x="Fizz"*!($_%3)+"Buzz"*!($_%5))?$x :$_}
```
Loops from `1` to `100`, each time constructing `$x` by exploiting implicit Boolean conversion. That is, if `$_%3` is `0`, it gets converted to `$true` with the `!`, then the `*` re-converts it to a `1` so that we add on `"Fizz"` to `$x`. We encapsulate that construction in parens, so we can re-use it as the introductory query to the ternary operator, choosing to either output `$x` or `$_`, depending on whether `$x` is present.
Normally here is where I'd link it to ***Try It Online***, but that's still on pwsh Core 6.2.3, so doesn't have the ternary operator.
---
## Pre-pwsh 7
```
1..100|%{(($t="Fizz"*!($_%3)+"Buzz"*!($_%5)),$_)[!$t]}
```
Edit: Saved 10 bytes thanks to [feersum](https://codegolf.stackexchange.com/a/58623/42963)
Edit2: Realized that with feersum's trick, I no longer need to formulate $t as a string-of-code-blocks
Edit3: Saved another 7 bytes thanks to [Danko Durbić](https://codegolf.stackexchange.com/users/1308/danko-durbi%c4%87)
Similar-ish in spirit to the stock Rosetta Code [answer](http://rosettacode.org/wiki/FizzBuzz#Concatenation_2), but golfed down quite a bit.
### Explanation
`1..100|%{...}` Create a collection of 1 through 100, then for-each object in that collection, do
`(...,$_)` create a new collection of two elements:
0) `$t=...` set the variable `$t` equal to a string;
1. `$_` our-current-number of the loop
`"Fizz"*!($_%3)` take our-current-number, mod it by 3, then NOT the result. Multiply "Fizz" by that, and add it to the string (and similar for 5). PowerShell treats any non-zero number as `$TRUE`, and thus the NOT of a non-zero number is 0, meaning that only if our-current-number is a multiple of 3 will "Fizz" get added to the string.
`[!$t]` indexes into the collection we just created, based on the value of the string `$t` -- non-empty, print it, else print our-current-number
---
### Alternatively, also 54 bytes
```
1..100|%{'Fizz'*!($_%3)+'Buzz'*!($_%5)-replace'^$',$_}
```
Thanks to [TesselatingHeckler](https://codegolf.stackexchange.com/users/571/tessellatingheckler)
Similar in concept, this uses the inline `-replace` operator and a regular expression to swap out an empty string `^$` with our-current-number. If the string is non-empty, it doesn't get swapped.
---
### Alternatively, also 54 bytes
```
1..100|%{($_,('Fizz'*!($_%3)+'Buzz'*!($_%5))|sort)[1]}
```
This is the same loop structure as above, but inside it sorts the pair (n, string), and relies on the fact that an empty string sorts before a number, but a FizzBuzz string sorts after a number. Then it indexes the second sort result.
[Answer]
# Clojure, 113 106 101 100 91 bytes
My first golf!
```
(dotimes[i 100](println(str({2'Fizz}(mod i 3))({4'Buzz}(mod i 5)({2""}(mod i 3)(inc i))))))
```
Ungolfed:
```
(dotimes [i 100] ; account for off-by-one later
  (println (str ({2 'Fizz} ; str converts symbols to strings
                 (mod i 3))
                ({4 'Buzz} ; 4 instead of 0 because of off-by-one
                 (mod i 5)
                 ({2 ""} ; shortest way to write when-not
                  (mod i 3)
                  (inc i))))))
```
[Answer]
## [Hexagony](https://github.com/mbuettner/hexagony), 112 bytes
```
d{$>){*./;\.}<._.zi...><{}.;/;$@-/=.*F;>8M'<$<..'_}....>.3'%<}'>}))'%<..._>_.'<$.....};u..}....{B.;..;.!<'..>z;/
```
After unfolding and with colour-coded execution paths:
[![enter image description here](https://i.stack.imgur.com/KIDof.png)](https://i.stack.imgur.com/KIDof.png)  
Diagram created with Timwi's [HexagonyColorer](https://github.com/Timwi/HexagonyColorer).
Finally got around to finishing this. I had written an ungolfed solution weeks ago, but wasn't entirely happy with it so I never actually golfed it. After revisiting it the other day, I found a way to simplify the ungolfed solution slightly, and while I think there might still be a better way to approach the problem in general, I decided to golf it this time. The current solution is far from optimal, and I think it should actually fit in side-length 6 instead of 7. I'll give this a go over the next days, and when I'm happy with the result will add a full explanation.
[Answer]
# [brainfuck](https://github.com/TryItOnline/brainfuck), ~~411 350 277~~ 258 bytes
Edits:
* -61 bytes by storing the values of "Fizz Buzz" as ~~"BuziF"~~ "BuziG" and redoing the number printing section.
* -71 bytes by redoing the modulo number printing section, splitting the loop counter and the number counter, and reusing the newline cell as the mod value, among other things
* -19 bytes by realising that there aren't any 0s in any FizzBuzz numbers. Also added explanation
`+[-[>+<<]>-]>--[>+>++>++>++++++>+>>>++++++[<<<]>-]<+++++[>+>+>->>->++>>>-->>>++[<<<]>>>-]>[>]+++>>[>+<<<-[<]<[>+++>+<<-.+<.<..[<]<]>>-[<<]>[.>.>..>>>>+[<]+++++<]>[>]>>[[->+>-[>+>>]>[+[-<+>]>+>>]<<<<<<]>[-<+>]>,>[>]<[>-[<+>-----]<---.,<]++++++++++>]<.<<<<,>-]`
[Try it online!](https://tio.run/##LU9RCkMhDDuQticIuUjxYxsMxmAfg53fJfXVok0bE71/b6/P8/d47z0qigNYDKVrjisdgrzKwmHhIBMZVA5zIpp4SLRYcVmALY8oLBRbUigHEpluiq6hjkpqJS2kQdugdSRSYTu7CpZejaHCCB1qntb0BTlJUxccC9pyXornW0v2iqmH7v0H "brainfuck – Try It Online")
Instead of checking if the number itself was divisible by 5 or 3 I had two counters keeping track of the modulo of the number, decrementing them for each number and printing out the corresponding word when they reached 0.
### How It Works:
```
+[-[>+<<]>-]>--  Generate the number 61
[>+>++>++>++++++>+>>>++++++[<<<]>-] Set the tape to multiples of 61
TAPE: 0 0' 61  122 122 110 61  0 0 110
           "=" "z" "z" "n" "="
<+++++[>+>+>->>->++>>>-->>>++[<<<]>>>-]>[>]+++>> Modify values by multiples of 5
TAPE: 0' 5 66  117 122 105 71  3 0 100' 0 0 10
           "B" "u" "z" "i" "G"
Some info:
  5     - Buzz counter
  "Buz" - Buzz printing
  "ziG" - Fizz printing. Modifying the G in the loop is shorter than modifying it outside
  3     - Fizz counter
  0     - This is where the Fizz|Buzz check will be located
  100   - Loop counter
  0     - Number counter. It's not worth it to reuse the loop counter as this.
  0     - Sometimes a zero is just a zero
  10    - Value as a newline and to mod the number by
  
[ Loop 100 times
  >+<<<  Increment number counter
  -[<]<  Decrement Fizz counter
  [ If Fizz counter is 0
    >+++ Reset the Fizz counter to 3
    >+<< Set the Fizz|Buzz check to true
    -.+<.<.. Print "Fizz"
  [<]<] Sync pointers
  >>-[<<]> Decrement Buzz counter
  [ If Buzz counter is 0
    .>.>.. Print "Buzz"
    >>>>+  Set the Fizz|Buzz check to true
    [<]+++++< Reset the Buzz counter to 5
  ]
  >[>]>> Go to Fizz|Buzz check
  [ If there was no Fizz or Buzz for this number
    TAPE: 3% BuziG 5% 0 Loop Num' 0 10
    [->+>-[>+>>]>[+[-<+>]>+>>]<<<<<<]  Mod the number counter by 10
    TAPE: 3% BuziG 5% 0 Loop 0' Num 10-Num%10 Num%10 Num/10
    >[-<+>] Move Num back in place
    >,>[>]< Reset 10-Num%10
    [ For both Num/10 (if it exists) and Num%10
      >-[<+>-----]<--- Add 48 to the number to turn it into the ASCII equivilent
      .,< Print and remove
    ]
    ++++++++++> Add the 10 back
  ]
  <. Print the newline
  <<<<, Remove Fizz|Buzz check
  >- Decrement Loop counter
]
```
]