[Question]
  [
I recently created a new language called `;#` (pronounced "Semicolon Hash") which only has two commands:
`;` add one to the accumulator
`#` modulo the accumulator by 127, convert to ASCII character and output **without** a newline. After this, reset the accumulator to 0. Yes, 127 is correct.
Any other character is ignored. It has no effect on the accumulator and should do nothing.
Your task is to create an interpreter for this powerful language!
It should be either a full program or a function that will take a `;#` program as input and produce the correct output.
## Examples
```
Output: Hello, World!
Program: ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
Output: ;#
Program: ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
Output: 2 d{
Program: ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;hafh;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;f;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;###ffh#h#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ffea;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#au###h;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;h;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;o
Output: Fizz Buzz output
Program: link below
Output: !
Program: ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
```
[Fizz Buzz up to 100](https://pastebin.com/5dPxcsu2)
  
[Answer]
# [Python 3](https://docs.python.org/3/), ~~69~~ 68 bytes
*-1 byte thanks to @WheatWizard*
```
i=0
for c in input():
 i+=c==';'
 if'#'==c:print(end=chr(i%127));i=0
```
[Try it online!](https://tio.run/nexus/python3#@59pa8CVll@kkKyQmQdEBaUlGppWXAqZ2rbJtrbq1upAZpq6srqtbbJVQVFmXolGal6KbXJGkUamqqGRuaamNdCA//@tqQSUrekB6GPLsLeMVPuUB8r1gzpURlMZuZYoAwA "Python 3 – TIO Nexus")
[Answer]
## JavaScript (ES6), ~~76~~ ~~82~~ 80 bytes
```
s=>s.replace(/./g,c=>c=='#'?String.fromCharCode(a%(a=127)):(a+=(c==';'),''),a=0)
```
### Demo
```
let f =
s=>s.replace(/./g,c=>c=='#'?String.fromCharCode(a%(a=127)):(a+=(c==';'),''),a=0)
console.log(JSON.stringify(f(";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#")))
console.log(JSON.stringify(f(";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#")))
console.log(JSON.stringify(f(";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;hafh;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;f;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;###ffh#h#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ffea;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#au###h;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;h;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;o")))
console.log(JSON.stringify(f(";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#")))
```
### Recursive version, ~~82~~ 77 bytes
*Saved 5 bytes thanks to Neil*
This one is likely to crash for large inputs such as the Fizz Buzz example.
```
f=([c,...s],a=0)=>c?c=='#'?String.fromCharCode(a%127)+f(s):f(s,a+(c==';')):""
```
[Answer]
# Java 8, 100 bytes
```
s->{int i=0;for(byte b:s.getBytes()){if(b==59)i++;if(b==35){System.out.print((char)(i%127));i=0;}}};
```
[Try it online!](https://tio.run/nexus/java-openjdk#7ZpNS8NAFEX3/RUPByFDMfiBiMa60LUrl@IijUkdaZKSTAQp@e21Iu4EEWyTmTnZJCXJ3KHv3PveIqZc1Y2V1/QtjTtrlnHRVZk1dRXf1VXblXmTTLJl2rZyn5pqPRFZdfOlyaS1qd2e3mrzLOX2VvRgG1MtHp8k1Z@PiXwvcP1150YKmW3ao5u1qayY2XFS1E00f7e5zK/aeJHb2@11G2m9NkU0n83OL7WZTpOvH2fnev3w3tq8jOvOxqvtijaKspe00ZE5PDm90Dr5XLPv@2QjUsRpluUrGx0kfz3Uj5f7efuXFXd87E9ppNJqiPfH8EdQebwaSMX@o@iAE7bVCWlHKqewNoD89773LgiUIUrTZDzOkIE0SRLQZGAGGCzuT8WUA4JAGXiM0AA8jhMMDiZjlwXQEKVpO84MDGr8gmQIUDI5Qwv@Dtrfw8kCaOCRQjNwp3J8ewIju9j6EJqgGaI03cbvJBlOljwBUEZomMHlvlVMuaEJmoGHCW3A71DB45DihjKYhihN/3FpclBOaJIkoMksDTBYHIsPqwymgQcLLcGpyvGtCpjsaPcDyQJoiNK0He/zZFBlUgVMGarBBqP7WTHljCyABh4pNAPvowWbA4tL4sAaojSNyLERQrkiS54AKNM1zOByXD4ScWANPF5oDHuUPtDJRKSf9JsP)
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 18 bytes
```
®è'; %# d}'# ë ¯J
```
There's an unprintable \x7f char after `%#`. [Test it online!](http://ethproductions.github.io/japt/?v=1.4.4&code=rugnOyAlI38gZH0nIyDrIK9K&input=Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Izs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7IyI=)
### How it works
```
®   è'; %#   d}'# ë ¯  J
mZ{Zè'; %127 d}'# ë s0,J
                         // Implicit: operate on input string
mZ{           }'#        // Split the input at '#'s, and map each item Z to
   Zè';                  //   the number of semicolons in Z,
        %127             //   mod 127,
             d           //   turned into a character.
m              '#        // Rejoin the list on '#'. At this point the Hello, World! example
                         // would be "H#e#l#l#o#,# #W#o#r#l#d#!#" plus an null byte.
                  ë      // Take every other character. Eliminates the unnecessary '#'s. 
                    ¯J   // Slice off the trailing byte (could be anything if there are
                         // semicolons after the last '#').
                         // Implicit: output result of last expression
```
[Answer]
# [Retina](https://github.com/m-ender/retina), ~~336~~ ~~63~~ ~~67~~ ~~65~~ ~~66~~ ~~62~~ 59 bytes
```
T`;#-ÿ`¯_
;{127}|;+$
(^|¯)
¯
+T`-~`_-`[^¯]
T\`¯`
```
[Try it online!](https://tio.run/##7ZqxTgJREEXzpHu/MRYQsgU2FttRkNivDQo8CwsbC0IH4iftJ5isH7byASbGhN33ZuZQGAvxbJhz70zB/vXw9v7S902qJVTfXyl07S7Wx8Xd/cepnt/GON2eunYWQuzamzhvUqjOaTepPtPT9vK3mxCb59S1qe9XD@t1vXy8/PjnS379dZx3//EfB36NRyoULTneX8IHweTJqpOJXWPoiOM76pS0kskJ0UaQaz/36ECk9IhmyRjukExMmgQ1OZgRhojbmZgoACKl8xphARiuEwKOJqVjEdQjmrWj5mCQ8oF0CFJyOWML@Xad73xYBHVeKSwDPZPjuyc4MsSj52Cipkc028Z2k@TD0icIygmNM6Tc2sREBxM1nZcJa8B2qZBxTNFBRlOPaPaPpstBVDBpEtTklkYYIk7E85LR1HmxsBJUTY7vqqDJQE@fCYugHtGsHfN9kpVMq6ApRzXaEHSbExM1WAR1XiksA/PVQsyRRRMcWT2iWUTKTgjRgqVPEJTrGmdIOSkvBI6szuuFxTAi@gc "Retina – Try It Online")
Readable version using *hypothetical* escape syntax:
```
T`;#\x01-ÿ`\x01¯_
;{127}|;+$
(^|¯)\x01\x01
¯\x02
+T`\x01-~`_\x03-\x7f`[^\x01¯]\x01
T\`¯`
```
Does not print NUL bytes, because TIO doesn't allow them in the source code. ~~Also prints an extra newline at the end, but I guess it can't do otherwise.~~ Trailing newline suppressed thanks to [@Leo](https://codegolf.stackexchange.com/users/62393/leo).
-273 (!) bytes thanks to [@ETHproductions](https://codegolf.stackexchange.com/users/42545/ethproductions).
-2 bytes thanks to [@ovs](https://codegolf.stackexchange.com/users/64121/ovs).
-3 bytes thanks to [@Neil](https://codegolf.stackexchange.com/users/17602/neil). Check out their wonderful [34-byte solution](https://codegolf.stackexchange.com/a/122006/69074).
[Answer]
# Ruby, ~~41~~ ~~35~~ 34 characters
(~~40~~ ~~34~~ 33 characters code + 1 character command line option)
```
gsub(/.*?#/){putc$&.count ?;%127}
```
Thanks to:
* [Jordan](https://codegolf.stackexchange.com/users/11261/jordan) for suggesting to use `putc` to not need explicit conversion with `.chr` (6 characters)
* [Kirill L.](https://codegolf.stackexchange.com/users/78274/kirill-l) for finding the unnecessary parenthesis (1 character)
Sample run:
```
bash-4.4$ ruby -ne 'gsub(/.*?#/){putc$&.count ?;%127}' < '2d{.;#' | od -tad1
0000000    2  etb    d  nul  nul  nul  nul    {  nul  nul  nul
          50   23  100    0    0    0    0  123    0    0    0
0000013
```
[Try it online!](https://tio.run/##KypNqvz/P724NElDX0/LXllfs7qgtCRZRU0vOb80r0TB3lrV0Mi89v9/ayoBZWt6APrYMuwtI9U@5YFy/aAOldFURq4lyv/yC0oy8/OK/@vmAQA "Ruby – Try It Online")
[Answer]
# [Python](https://docs.python.org/), 65 bytes
This is a golf of [this](https://codegolf.stackexchange.com/a/121926/56656) earlier answer.
```
lambda t:''.join(chr(x.count(';')%127)for x in t.split('#')[:-1])
```
[Try it online! Python2](https://tio.run/nexus/python2#S7ON@Z@TmJuUkqhQYqWurpeVn5mnkZxRpFGhl5xfmleioW6trqlqaGSumZZfpFChkJmnUKJXXJCTCZRRVteMttI1jNX8X1CUmVeikKahZE0loGxND0AfW4a9ZaTapzxQrh/UoTKaysi1RFlJ8z8A "Python 2 – TIO Nexus")
[Try it online! Python3](https://tio.run/nexus/python3#S7ON@Z@TmJuUkqhQYqWurpeVn5mnkZxRpFGhl5xfmleioW6trqlqaGSumZZfpFChkJmnUKJXXJCTCZRRVteMttI1jNX8X1CUCVSapqFkTSWgbE0PQB9bhr1lpNqnPFCuH9ShMprKyLVEWUlT8z8A "Python 3 – TIO Nexus")
## Explanation
This is a pretty straightforward answer we determine how many `;`s are between each `#` and print the `chr` mod 127. The only thing that might be a little bit strange is the `[:-1]`. We need to drop the last group because there will be no `#` after it.
For example 
```
;;#;;;;#;;;;;#;;;
```
Will be split into
```
[';;',';;;;',';;;;;',';;;']
```
But we don't want the last `;;;` because there is no `#` after it to print the value.
[Answer]
# [><>](https://esolangs.org/wiki/Fish), 35 bytes
```
>i:0(?;:'#'=?v';'=?0
^   [0o%'␡'l~<
```
[Try it online!](https://tio.run/nexus/fish#@2@XaWWgYW9tpa6sbmtfpm4NJA244hQUFKIN8lXV69Vz6mz@/7ce5EAZAA "><> – TIO Nexus") Replace `␡` with 0x7F, `^?`, or "delete".
## Main loop
```
>i:0(?;:'#'=?v      
^            <
```
This takes a character of input (`i`), checks if its less than zero i.e. EOF (`:0(`) and terminates the program if it is (`?;`). Otherwise, check if the input is equal to `#` (`:'#'=`). If it is, branch down and restart the loop (`?v` ... `^ ... <`).
## Counter logic
```
              ';'=?0
              
```
Check if the input is equal to `;` (`';'=`). If it is, push a `0`. Otherwise, do nothing. This restarts the main loop.
## Printing logic
```
>       '#'=?v      
^   [0o%'␡'l~<
```
When the input character is `#`, pop the input off the stack (`~`), get the number of members on the stack (`l`), push 127 (`'␡'`), and take the modulus (`%`). Then, output it as a character (`o`) and start a new stack (`[0`). This "zeroes" out the counter. Then, the loop restarts.
[Answer]
# Python 3, 69 Bytes
Improved, thanks to @Wheat Wizard, @Uriel
```
print(''.join(chr(s.count(';')%127)for s in input().split('#')[:-1]))
```
[Answer]
# [Röda](https://github.com/fergusq/roda), ~~44~~ ~~39~~ 38 bytes
*5 bytes saved thanks to @fergusq*
```
{(_/`#`)|{|d|d~="[^;]",""chr #d%127}_}
```
[Try it online!](https://tio.run/##K8pPSfyfFvO/WiNeP0E5QbOmuialJqXOVik6zjpWSUdJKTmjSEE5RdXQyLw2vvZ/bmJmXjVXQWlOjkIiV2KdbQJXgk5CAld0YmxNGlftf2sESLSmBChb0wPQx5Zhbxmp9ikPlOsHdaiMpjJyLVEGAA "Röda – Try It Online")
Anonymous function that takes the input from the stream.
---
If other characters do not have to be ignored, I get this:
### [Röda](https://github.com/fergusq/roda), 20 bytes
```
{(_/`#`)|chr #_%127}
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 13 bytes
```
ṣ”#Ṗċ€”;%127Ọ
```
[Try it online!](https://tio.run/nexus/jelly#7doxbgJRDEXRxVgsIGlSsLkobVKnS5U2G0C02ciwkQkLQEKRmPnf9qGigTvC9z27YF1O35fXr1hOn7/vl7ef6/vj4en5ZTl/rOt6/O8rbr7d59N3vnHj136kSdEx4vMz/BAmL6tNJvaIoROnd9SVdJLJhWgT5NHPvTuQlB3RlkzhDhnE1CTUdDATRsTrTCwSAEnZvEYsgMJ1IuA0mR1L0I5oayfNwRDzA3UIKV3ObJHv1vkehyVo80qxDPJMzn9POLLFo49gUrMj2rap3STjsPqEoE5ozkh5tYlFDiY1m5eJNVC7VGScKTnINO2Itn8yXQ6RgqlJqOmWJoyIi/hYMk2bF4uVkGpy/qtCk42efhCWoB3R1k75PhlK1io0dVTTRtBrTizSYAnavFIsg/LVIuZkyQQna0e0RZTshIgsWH1CUNc1Z6RcyieBk7V5vVgMO6L/AA "Jelly – TIO Nexus")
### How it works
```
ṣ”#Ṗċ€”;%127Ọ  Main link. Argument: s (string)
ṣ”#            Split s at hashes.
   Ṗ           Pop; remove the last chunk.
    ċ€”;       Count the semicola in each chunk.
        %127   Take the counts modulo 127.
            Ọ  Unordinal; cast integers to characters.
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~16~~ ~~15~~ 14 bytes
Code:
```
'#¡¨ʒ';¢127%ç?
```
Explanation:
```
'#¡              # Split on hashtags
   ¨             # Remove the last element
    ʒ            # For each element (actually a hacky way, since this is a filter)
     ';¢         #   Count the number of occurences of ';'
        127%     #   Modulo by 127
            ç    #   Convert to char
             ?   #   Pop and print without a newline
```
Uses the **05AB1E**-encoding. [Try it online!](https://tio.run/nexus/05ab1e#@6@ufGjhoRVllerWhxYZGpmrHl5u//@/NZWAsjU9AH1sGfaWkWqf8kC5flCHymgqI9cSZQA "05AB1E – TIO Nexus")
[Answer]
# x86 machine code on MS-DOS - 29 bytes
```
00000000  31 d2 b4 01 cd 21 73 01  c3 3c 3b 75 06 42 80 fa  |1....!s..<;u.B..|
00000010  7f 74 ed 3c 23 75 eb b4  02 cd 21 eb e3           |.t.<#u....!..|
0000001d
```
Commented assembly:
```
bits 16
org 100h
start:
    xor dx,dx       ; reset dx (used as accumulator)
readch:
    mov ah,1
    int 21h         ; read character
    jnc semicolon
    ret             ; quit if EOF
semicolon:
    cmp al,';'      ; is it a semicolon?
    jne hash        ; if not, skip to next check
    inc dx          ; increment accumulator
    cmp dl,127      ; if we get to 127, reset it; this saves us the
    je start        ; hassle to perform the modulo when handling #
hash:
    cmp al,'#'      ; is it a hash?
    jne readch      ; if not, skip back to character read
    mov ah,2        ; print dl (it was choosen as accumulator exactly
    int 21h         ; because it's the easiest register to print)
    jmp start       ; reset the accumulator and go on reading
```
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), ~~34~~ 32 bytes
```
T`;#\x00-\xFF`\x7F\x00_
\+T`\x7Eo`\x00-\x7F_`\x7F[^\x7F]|\x7F$
```
[Try it online!](https://tio.run/##K0otycxL/P8/JMFamUH38P6EeoZ4rhjtkIS6/AQG3fr4hProuPrYmnqV//@tSQbKpGvJSEzLIF1XGl3cRoYlysppaRnKGXSxjIxgS0tNJF1XIhl6lBNLgWGRMTiDgQxn5QMA "Retina 0.8.2 – Try It Online") Includes test case. Edit: Saved 2 bytes with some help from @MartinEnder. Now uses TIO link with null byte support thanks to @Deadcode. Note: Code includes unprintables, which I have replaced with hex escapes in the post. Explanation: The first line cleans up the input: `;` is changed to `\x7F`, `#` to `\x00` and everything else is deleted. Then whenever we see an `\x7F` that is not before another `\x7F`, we delete it and cyclically increment the code of any next character. This is iterated until there are no more `\x7F` characters left.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~25~~ ~~21~~ 19 bytes
-2 bytes thanks to Adnan
```
Îvy';Q+y'#Qi127%ç?0
```
Explanation:
```
Î                       Initialise stack with 0 and then push input
 v                      For each character
  y';Q+                 If equal to ';', then increment top of stack
       y'#Qi            If equal to '#', then
            127%        Modulo top of stack with 127
                ç       Convert to character
                 ?      Print without newline
                  0     Push a 0 to initialise the stack for the next print
```
[Try it online!](https://tio.run/nexus/05ab1e#@3@4r6xS3TpQu1JdOTDT0Mhc9fBye4P//62pBJSt6QHoY8uwt4xU@5QHyvWDOlRGUxm5ligDAA)
[Answer]
## R, 97 90 86 84 bytes
A function:
```
function(s)for(i in utf8ToInt(s)){F=F+(i==59);if(i==35){cat(intToUtf8(F%%127));F=0}}
```
When R starts, `F` is defined as `FALSE` (numeric `0`).
Ungolfed:
```
function (s)
    for (i in utf8ToInt(s)) {
        F = F + (i == 59)
        if (i == 35) {
            cat(intToUtf8(F%%127))
            F = 0
        }
    }
```
[Answer]
# Plain TeX, 156 bytes
```
\newcount\a\def\;{\advance\a by 1\ifnum\a=127\a=0\fi}\def\#{\message{\the\a}\a=0}\catcode`;=13\catcode35=13\let;=\;\let#=\#\loop\read16 to\>\>\iftrue\repeat
```
**Readable**
```
\newcount\a
\def\;{
  \advance\a by 1
  \ifnum \a=127 \a=0 \fi
}
\def\#{
  \message{\the\a}
  \a=0
}
\catcode`;=13
\catcode35=13
\let;=\;
\let#=\#
\loop
  \read16 to \> \>
  \iftrue \repeat
```
[Answer]
# Python, 82 bytes
```
lambda t:''.join(chr(len([g for g in x if g==';'])%127)for x in t.split('#')[:-1])
```
[Answer]
# [;#+](https://github.com/ConorOBrien-Foxx/shp), 59 bytes
```
;;;;;~+++++++>~;~++++:>*(~<:-+!(<-;->(;))::<+-::!(<#>)-:-*)
```
[Try it online!](https://tio.run/nexus/shp#@28NAnXaEGBXB2Fa2Wlp1NlY6WoratjoWuvaaVhralpZ2WjrWlkBRZTtNHWtdLU0//@3phJQtqYHoI8tw94yUu1THijXD@pQGU1l5FqizAAA ";#+ – TIO Nexus") Input is terminated with a null byte.
## Explanation
The generation is the same as from my [Generate ;# code answer](https://codegolf.stackexchange.com/a/122210/31957). The only difference here is is the iteration.
### Iteration
```
*(~<:-+!(<-;->(;))::<+-::!(<#>)-:-*)
*(                                *)   take input while != 0
  ~                                    swap
   <                                   read value from memory (;)
    :                                  move forward to the accumulator memory spot (AMS)
     -                                 flip Δ
      +                                subtract two accumulators into A
       !                               flip A (0 -> 1, else -> 0)
        (     (;))                     if A is nonzero, or, if A == ';'
         <                             read from AMS
          -;-                          increment
             >                         write to AMS
                  ::                   move to cell 0 (#)
                    <                  read value from memory (#)
                     +                 subtract two accumulators into A
                      -                flip Δ
                       ::              move to AMS
                         !(   )        if A == '#'
                           <           read from AMS
                            #          output mod 127, and clear
                             >         write to AMS
                               -:-     move back to initial cell
```
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 58 bytes
```
a;f(char*s){a+=*s^35?*s==59:-putchar(a%127);a=*s&&f(s+1);}
```
[Try it online!](https://tio.run/nexus/c-gcc#7Z3NasJAFIXXzVNILpWJ4sIWKW2QvogUhjZDXDSVRlfis1vtE2iMmZ/7zTYOZ5z7nXPvIpCjLZ35rO3vpC32drqctB/Pi/dJu1wuXt9mm932/MzYx/nTS1Ha0@Px2Jl2Oi/Kw1G@KrduqlFbbUwxOv22NfmqWTWz81o1eZFl62Y7@rbrxhTZPntwJi97WlIOsYZRSV7sWj3xdfqgbwXKuopIXpTZw39Mlbem0CV/qQe9DjdXW1dfv8uFWlUR52qpPVjkomtzlb1@l@2wR@zudBd1mNfQ4Vg/N5tDbkJRegd5OEQ9miEMafGxP4SLoPJ4VUnF@ig64Oi2OiEdSeUEawNI3@ceXBAoNUrTZBLOEE@aJAloMjADDBZPp2ISgSBQKo8RGkDCcYLBwSR0WQDVKE3biWZgkPAFyRCgZHKGFvyt2t/@ZAFUeaTQDOKpHO@ewMg9ju5DEzQ1StNt0k4Sf7LkCYAyQsMMLk@tYhKHJmgqDxPaQNqhgschJQ5lMNUoTf@JaXKQKDRJEtBklgYYLI7F/SqDqfJgoSVEVTneVQGTO53ekyyAapSm7SSfJ16VSRUwZagGG4yeZsUkGlkAVR4pNIPkowWbA0tM4sCqUZpGFNkIIbHIkicAynQNM7gclwciDqzK44XGMKB0jx9WHe7Ah@Mf "C (gcc) – TIO Nexus") (Hint: click **▼ Footer** to collapse it.)
[Answer]
# [MATL](https://github.com/lmendo/MATL), 29 bytes
```
';#'&mXz!"@o?T}vn127\c&YD]]vx
```
Input is a string enclosed in single quotes.
[Try it online!](https://tio.run/nexus/matl#@69urayulhtRpajkkG8fUluWZ2hkHpOsFukSG1tW8f@/ujWVgLI1PQB9bBn2lpFqn/JAuX5Qh8poKiPXEmV1AA "MATL – TIO Nexus")
The FizzBuzz program is too long for the online interpreters; see it working offline in this gif:
[![enter image description here](https://i.stack.imgur.com/4BtDy.gif)](https://i.stack.imgur.com/4BtDy.gif)
### Explanation
The accumulator value is implemented as the number of elements in the stack. This makes the program slower than if the accumulator value was a single number in the stack, it but saves a few bytes.
```
';#'       % Push this string
&m         % Input string (implicit). Pushes row vector array of the same size with 
           % entries 1, 2 or 0 for chars equal to ';', '#' or others, respectively
Xz         % Remove zeros. Gives a column vector
!          % Transpose into a row vector
"          % For each entry
  @        %   Push current entry
  o?       %   If odd
    T      %     Push true. This increases the accumulator (number of stack elements)
  }        %   Else
    v      %     Concatenate stack into a column vector
    n      %     Number of elements
    127\   %     Modulo 127
    c      %     Convert to char
    &YD    %     Display immediately without newline
  ]        %   End
]          % End
vx         % Concatenate stack and delete. This avoids implicit display
```
[Answer]
## Perl, 25 bytes
```
$_=chr(y%;%%%127)x/#/
```
Run with `perl -043pe` (counted as 4 bytes, since `perl -e` is standard).
Explanation: `-043` sets the line-terminator to `#` (ASCII 043). `-p` iterates over the input “lines” (actually #-delimited strings, now). `y%;%%` counts the number of `;` in each “line”. `x/#/` makes sure that we don’t print an extra character for programs that don’t end in a # (like the third testcase). `%127` should be fairly obvious. `$_=` is the usual boilerplate.
[Answer]
## CJam, 27 bytes
```
0q{";#"#") 127%co0 "S/=~}%;
```
Explanation:
```
0                            e# Push 0
 q                           e# Push the input
  {                          e# For each character in the input:
   ";#"#                     e#   Index of character in ";#", -1 if not found
        ") 127%co0 "S/       e#   Push this string, split on spaces
                      =      e#   Array access (-1 is the last element)
                       ~     e#   Execute as CJam code. ")" increments the accumulator,
                             e#     and "127%co0" preforms modulo by 127, converts to character, pops and outputs, and then pushes 0.
                        }%   e# End for
                          ;  e# Delete the accumulator
```
## Alternative Solution, 18 bytes
```
q'#/);{';e=127%c}%
```
Explanation:
```
q                   e# Read the whole input
 '#/                e# Split on '#'
    );              e# Delete the last element
      {             e# For each element:
       ';e=         e#   Count number of ';' in string
           127%     e#   Modulo by 127
               c    e#   Convert to character code
                }%  e# End for
```
[Answer]
# Brainfuck, 135 bytes
```
+[>+>>,>+++++[<------->-]<[<+>>++++[<------>-]<[<->[-]]<[>>>+<<<-]<->>[-]]<<[>>>--[>>+<<--]>[>->+<[>]>[<+>-]<<[<]>-]>[-]>.[-]<<<<<<-]<]
```
## Ungolfed
```
Memory layout
0   1   2   3   4   5   6   7
1   f1  f2  in  tmp acc d   acc%d   
flag1 indicates hash
flag2 indicates semicolon
+[      infinite loop
    >+      set flag1
    >>,     input
    >+++++[<------->-]<     subtract 35 (hash)
    [       not hash
        <+> set flag2
        >++++[<------>-]<   subtract 24 more (semicolon)
        [   not semicolon
            <-> clear flag2
            [-] clear input
        ]
        <   goto flag2
        [   semicolon
            >>>+<<<-    inc acc and clear flag2
        ]
        <-  clear flag1
        >>[-]   clear input
    ]
    <<      goto flag1
    [       hash
        >>>--[>>+<<--]> set d 127 and goto acc
        [>->+<[>]>[<+>-]<<[<]>-]    mod
        >[-]>       clear d and goto acc%d 
        .[-]        print and clear result
        <<<<<<- clear flag1
    ]
<]
```
[Answer]
# F#, ~~79~~ ~~91~~ 93 bytes
```
let rec r a=function|[]->()|';'::t->r(a+1)t|'#'::t->printf"%c"(char(a%127));r 0 t|_::y->r a y
```
## Ungolfed
```
let rec run acc = function
    | [] -> ()
    | ';'::xs ->
        run (acc + 1) xs
    | '#'::xs ->
        printf "%c" (char(acc % 127))
        run 0 xs
    | x::xs -> run acc xs
```
[Try it online!](https://tio.run/##7VTBisMgEL3nKwalRFmytL0UDOsX9NbjsiwSFAOttmZyKPjvWUt@YCNtE0rnNujjPd7MPNNVJ@/8MBw1QtANBFBfpncNtt7F759KMh7LuhQCKxmY@thwjCUd@3NoHRqyaghrrEqvq812x3kdYA0Yf4W4JgwouA6kvlPR@hn1HJaXJ5vKR@dSv2hX3luWS0JJESWwFGfQunOPUEm4ZRMbOyHhFlvQ6Qukfwd9@US/bzvkvCjGbHOEFOTBRsymMmNKVhk7HWWWukGUGmOpneEc/2Wb0Wo6SmVgqOqTF3aZNmTI8tknNfwB "F# (Mono) – Try It Online")
Edit: Was treating any other char than ';' as '#'. Changed it so that it's ignoring invalid chars.
# Alternative
# F#, ~~107~~ 104 bytes
```
let r i=
 let a=ref 0
 [for c in i do c|>function|';'->a:=!a+1|'#'->printf"%c"(!a%127|>char);a:=0|_->()]
```
Use of reference cell saves 3 bytes
## Ungolfed
```
let run i =
    let a = ref 0;
    [for c in i do
        match c with
        | ';' -> a := !a + 1
        | '#' ->
            printf "%c" (char(!a % 127))
            a := 0
        |_->()
    ]
```
[Try it online](https://tio.run/##7ZTdCsIwDIXv@xSxZWwig@mNYFlfRERCXWhBW6nzru9eJ76AK/4MMVcp9PAlp0npUp@88ykdux4C2JbBPcM2dAQNgy35ABqsAwsHDzoqujrdW@9iKcta4aad4WIZSzEczsG6nniheTXDYrlaR6UNhrkcbjVxX6tqvktcviiE/ER8hvLzsLE88a3qJ@3Kf8pyIYKzqCAw9vijHOeMv7mr1yAz/DNIZryKpvq2QhAZYb6wKE/ZRh2OV2GGRuB18MJM04aMsvxjP9IN "F# (Mono) – Try It Online")
[Answer]
# Processing.js (Khanacademy version), 118 bytes
```
var n="",a=0;for(var i=0;i<n.length;i++){if(n[i]===";"){a++;}if(n[i]==="#"){println(String.fromCharCode(a%127));a=0;}}
```
[Try it online!](https://www.khanacademy.org/computer-programming/new-program/6510279169736704)
As the version of processing used does not have any input methods input is placed in n.
[Answer]
# [Labyrinth](https://github.com/m-ender/labyrinth), ~~61~~ 47 bytes
```
_36},)@
;    {
; 42_-
"#-  1
_ ; 72
_ ) %
"""".
```
[Try it online!](https://tio.run/##y0lMqizKzCvJ@P8/3tisVkfTgctaAQiqgZSJUbwul5KyroKCIVe8grWCuRGQ0lRQ5VICAr3//61JBsqka8lITMsgXVcaXdxGhiXKymlpGcoZdLGMjGBLS00kXVciGXqUE0uBYZExOIOBDGflAwA "Labyrinth – Try It Online")
## Explanation
[![color coded image of the solution code](https://i.stack.imgur.com/nqyCF.png)](https://i.stack.imgur.com/nqyCF.png)
Code execution begins in the top left corner and the first semicolon discards an implicit zero off the stack and continues to the right.
### Orange
* `_36` pushes 36 onto the stack. This is for comparing the input with `#`
* `}` moves the top of the stack to the secondary stack
* `,` pushes the integer value of the character on the stack
* `)` increments the stack (if it's the end of the input, this will make the stack 0 and the flow of the program will proceed to the `@` and exit)
* `{` moves the top of the secondary stack to the top of the primary stack
* `-` pop y, pop x, push x - y. This is for comparing the input with `#` (35 in ascii). If the input was `#` the code will continue to the purple section (because the top of the stack is 0 the IP continues in the direction it was moving before), otherwise it will continue to the green section.
### Purple
* `127` push 127 to the stack
* `%` pop x, pop y, push x%y
* `.` pop the top of the stack (the accumulator) and output as a character
From here the gray code takes us to the top left corner of the program with nothing on the stack.
### Green
* `_24` push 24 onto the stack
* `-` pop x, pop y, push x-y. 24 is the difference between `#` and `;` so this checks if the input was `;`. If it was `;` the code continues straight towards the `)`. Otherwise it will turn to the `#` which pushes the height of the stack (always a positive number, forcing the program to turn right at the next intersection and miss the code which increments the accumulator)
* `;` discard the top of the stack
* `)` increment the top of the stack which is either an implicit zero or it is a previously incremented zero acting as the accumulator for output
From here the gray code takes us to the top left corner of the program with the stack with only the accumulator on it.
### Gray
Quotes are no-ops, `_` pushes a 0 to the stack, and `;` discards the top of the stack. All of this is just code to force the control-flow in the right way and discarding anything extra from the top of the stack.
[Answer]
# Awk, 57 bytes
`BEGIN{RS="#"}RT=="#"{printf("%c",gsub(";","")%127)}`
Explanation:
* `BEGIN{RS="#"}`: make `#` record delimeter
* `RT=="#"`: ignore the record without ending `#`
* `gsub(";","")%127`: count `;` and mod 127
* `printf("%c",_)`: print as ASCII
[Answer]
# [Perl 5](https://www.perl.org/) with `-043paF(?!^);`, 17 bytes
Golfed down a bit by [dom-hastings](https://codegolf.stackexchange.com/users/9365/dom-hastings)
```
$_=/#/&&chr@F%127
```
[Try it online!](https://tio.run/##K0gtyjH9/18l3lZfWV9NLTmjyMFN1dDI/P9/a5KBMulaMhLTMkjXlUYXt5FhibJyWlqGcgZdLCMj2NJSE0nXlUiGHuXEUmBYZAzOYCDDWfn/8gtKMvPziv/rGpgYFyS6adgrxmlaAwA "Perl 5 – Try It Online")
[Answer]
# [Vyxal](https://github.com/Lyxal/Vyxal), 10 / 20 bytes
There's two main schools of thought for interpreting `;#`:
* Go through every command and apply it **(Iterative)**
* Split the program into strings of `;`, then count and output. **(Split 'n Count)**
Here's both!
---
# Iterative, 20 bytes
```
0$(\;n=ß›\#n=[₇‹%C₴0
```
[Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=0%24%28%5C%3Bn%3D%C3%9F%E2%80%BA%5C%23n%3D%5B%E2%82%87%E2%80%B9%25C%E2%82%B40&inputs=%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3Bq%3B%3B%3B%3B%3B%3Bw%3B%3B%3B%3B%3B%3Be%3B%3B%3B%3Br%3B%3B%3B%3B%3B%3B%3B%3Bt%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3By%3B%3B%3B%3B%3B%3B%23%3B%3B%3B%3B%3B%3B%3B%3Bu%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3Bi%3B%3Bo%3B%3B%3B%3B%3B%3B%3Bp%3B%3B%3B%3B%3B%3B%3Ba%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3Bs%3B%3B%3B%3B%3B%3B%3Bd%3Bf%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3Bgg%3B%3B%3B%3B%3B%3B%3B%3B%3Bh%3B%3B%3B%3B%3B%3B%3B%3B%23%3B%3B%3B%3Bjkl%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%23%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%23%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%23%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%23%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%23%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%23%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%23%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%23%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%23%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%23%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%3B%23&header=&footer=)
Explanation:
```
                      # Implicit input
0$                    # Initialize accumulator at the bottom of the stack
  (                   # For each command in the program
   \;n=ß              # If command = ';':
        ›             #  Increment accumulator
         \#n=[        # If command = '#':
              ₇‹%     #  Accumulator % 127
                 C    #  Convert accumulator to character
                  ₴   #  Print accumulator w/o newline
                   0  #  Reset accumulator
```
---
]