Core is based on two arithmetic combinators. First one is to negate any number, second one is memory cell. Items on belt are counted. Each inserter that puts items on belt is connected by green wire to memory cell and gives pulsed hand content. This way when inserter puts new item on belt, total count of this particular item is increased. To prevent item overflow, this inserter also contains enable condition. Since green wire is connected to memory cell, circuit signal can be used to drop items only if there are not enough of them.
Every inserter that grabs from sushi belt is set to pulse hand content to red wire. This is then inverted and fed into memory cell to update total belt content.
In my example, total belt capacity is around 740 items. Because of limits set on inserters, there should be no more than 670 items. This prevents belt stopping because of item overflow.
In above example, all initial items go from infinity chests (please use editor when stamping bp). They could however go from another sushi belt with ores and intermediate items. Transfer inserters could then be connected to two different networks: by green wire to "add content" to target memory cell, and by red wire to "remove content" from source memory cell. Since it is possible to setup pulsed read content on belt, same principle can be achieved when belt goes from one "counted" network to another counted network: every pulse would increment item count in target "belt network" and decrement item count in source "belt network".
I guess this is not how you should play factorio: single belt with every assembler attached to it
