anchor.diff:            All this hell can be avoided by encapsulating a modifier in a block like `.block_mod`.
   
             Indeed using global modifiers makes the resultant code less. However if you measure the real difference in bytes it usually does not
  -          seam that big. Especially if you are using CSS optimizator which can combine selectors.
  +          seem that big. Especially if you are using CSS optimizator which can combine selectors.
  
positive.code:           </div>
            ```
  
            If you are already having `.button.active` selector in code, the specifity of your redefining `.header .button` would be exactly
            the same as the specifity of modifier combined selector which makes you dependent on the order of the CSS rules
            declared. Whereas in case of using a prefixed modifier you can always be sure that the cascade selector `.header .button` will
            overwrite the `.button_active` modifier.
  
            This makes life easier especially for mantainable projects.
  
            The third point is that looking at the `<div class="block block_mod">` markup you can clearly see the block structure. It is easy
            to recognize that we are having a block and its modifier and there is no different interpretations here. Unfortunately a grasp onto
            `<div class="block mod">` code does not give such information. Depending on what are the exact CSS classes sometimes it is impossible
            to recognize if we are having a block and a modifier or a mix of 2 blocks here. This might be even more confusing if the names of the
            entities are complex or contracted/abbreviated (which sometimes happens in big projects).<br/>
            Clear understandting of a block structure especially helps in looking for corresponsing code on a file system.
  
            You will also appreciate `.block_mod` practice when refactoring and use global search over all your project files. Imagine the
            same looking for not-prefixed `.mod` and all the HTML pieces it might be.
  
negative.code:             display: none;
            }
            ```
            Both block and modifier selectors have the same specificity. As modifier declaration goes after the block, it redefines the CSS
            properties. These styles belong to block and are stored in the block file. Thus, independently on how the resultant CSS is built
            from source, you will always have them in this order and be sure that redefining happens.
  
            In the case of global modifier, its properties can be redefined by the blocks if they follow modifiers in code:
  