Using binary number to merge several messages

Hello, I’m a beginner with Erlang and wanted to know if my way of merging messages using binary numbers was viable or if there was a more idiomatic way of doing it.

To be more concrete, i have written a fizzbuzz example.

start_merger() ->
    io:format("start pid: ~p~n", [self()]),
    Merger = spawn(fizzbuzz, merger, []),
    Fizz = spawn(fizzbuzz, fizz, [Merger]),
    Buzz = spawn(fizzbuzz, buzz, [Merger]),
    Multiplexer = spawn(fizzbuzz, multiplexer, [Fizz, Buzz]),    
    Merger ! {pid, Multiplexer},
    Multiplexer.

multiplexer(Fizz, Buzz) ->
    receive
        N when is_integer(N) ->
            Fizz ! {N, 2#0000},
            Buzz ! {N, 2#0000},
            multiplexer(Fizz, Buzz);
        stop -> ok
    end.

fizz(Merger) ->
    receive
        {N, 2#0000} when is_integer(N) ->
            if N rem 3 =:= 0 ->
                    Merger ! {N, 2#1010};
               true ->
                    Merger ! {N, 2#1000}
            end,
            fizz(Merger);
        Msg -> io:format("Unexpected msg received: ~w", [Msg])
    end.

buzz(Merger) ->
    receive
        {N, 2#0000} when is_integer(N) ->
            if N rem 5 =:= 0 ->
                    Merger ! {N, 2#0101};
               true ->
                    Merger ! {N, 2#0100}
            end,
            buzz(Merger);
        Msg -> io:format("Unexpected msg received: ~w~n", [Msg])
    end.

merger() ->
    receive
        {pid, Multiplexer} ->
            merger(Multiplexer);
        Msg -> io:format("Unexpected msg received: ~w~n", [Msg])
end.

merger(Multiplexer) ->
    receive
        {N, Bin} when is_integer(N) ->
            merger(Multiplexer, Bin);
        stop -> ok
    end.

merger(Multiplexer, Acc) ->
    receive
        {N, Bin} when is_integer(N) ->
            Result = Acc bor Bin,
            case Result of
                2#1110 ->
                    io:format("fizz~n", []);
                2#1101 ->
                    io:format("buzz~n", []);
                2#1111 ->
                    io:format("fizzbuzz~n", []);
                2#1100 ->
                    io:format("~B~n", [N]);
                _ ->
                    io:format("Unexpected Error")
            end,
            Multiplexer ! N+1,
            merger(Multiplexer);
        stop -> ok
    end.

For each number, multiplexer sends a tuple containing the number N and a binary representing the state of computation: the first two bits are used to say if the actor fizz (respectively buzz) have been visited.
The last two bits are used to say if fizz (respectively buzz) should be printed
Example1: 1110 means that both fizz and buzz actors have sent their msg to merger and only fizz needs to be printed
Example2: 0101 means that only buzz has sent its msg to merger (fizz has not yet sent its msg and merger is waiting in receive) and we already know that buzz will need to be printed in the end