#define g21 0x55555555ul // = 0101_0101_0101_0101_0101_0101_0101_0101
        #define g22 0x33333333ul // = 0011_0011_0011_0011_0011_0011_0011_0011
        #define g23 0x0f0f0f0ful // = 0000_1111_0000_1111_0000_1111_0000_1111

        v = (v & g21) + ((v >> 1) & g21);
        v = (v & g22) + ((v >> 2) & g22);
        v = (v + (v >> 4)) & g23;
        return (v + (v >> 8) + (v >> 16) + (v >> 24)) & 0x3f;

Подсчёт количества ненулевых бит в числе v за log2(v) проходов (на примере 8-битного числа): 
    v = (v & 0x55) + ((v >> 1) & 0x55);
    v = (v & 0x33) + ((v >> 2) & 0x33);
    return (v & 0x0f) + ((v >> 4) & 0x0f); 

Число разбивается на группы бит одной длины (сперва по одному биту). Затем значения соседних пар одновременно складываются и сохраняются в новых группах в два раза большей длины до тех пор, пока не будут сложены половинки числа. 
Поскольку длина суммы двух чисел равна длине большего числа с битом для переноса, поэтому для каждой группы в маске групп достаточно иметь единиц не больше номера шага (то есть 1+log2 от длины группы). Hапример, для подсчёта единичных бит в 32-битном числе (с оптимизацией): 

#define g21 0x55555555ul // = 0101_0101_0101_0101_0101_0101_0101_0101
#define g22 0x33333333ul // = 0011_0011_0011_0011_0011_0011_0011_0011
#define g23 0x0f0f0f0ful // = 0000_1111_0000_1111_0000_1111_0000_1111

v = (v & g21) + ((v >gt; 1) & g21);
v = (v & g22) + ((v >gt; 2) & g22);
v = (v + (v >gt; 4)) & g23;
return (v + (v >gt; 8) + (v >gt; 16) + (v >gt; 24)) & 0x3f;

Для сокращения количества шагов можно суммировать тройки и т.д.: 
#define g31 0x49249249ul // = 0100_1001_0010_0100_1001_0010_0100_1001
#define g32 0x381c0e07ul // = 0011_1000_0001_1100_0000_1110_0000_0111

v = (v & g31) + ((v >> 1) & g31) + ((v >> 2) & g31);
v = ((v + (v >> 3)) & g32) + ((v >> 6) & g32);
return (v + (v >> 9) + (v >> 18) + (v >> 27)) & 0x3f;

int nbits4[16] = { 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4 };

........

while(......) {
  result += nbits4[ x & 0xF ];
  x >>= 4;
}

mov ecx, 0
clc

shr eax, 1
@@loop:
    adc ecx, 0
    shr eax, 1
jnz @@loop
adc ecx, 0

#include <iostream.h>

int count(int eax);
#pragma aux count parm nomemory [eax] = \
        "mov ecx, 0             "\
        "clc                    "\
        "shr eax, 1             "\
        "@@loop:                "\
        "    adc ecx, 0         "\
        "    shr eax, 1         "\
        "jnz @@loop             "\
        "adc ecx, 0             "\
        modify nomemory exact [eax ecx] \
        value [ecx];

void main(void) {
    int value;
    do {
        cin >> value;
        cout << count(value) << endl;
    } while(value);
};

    v = (v & 0x55) + ((v >> 1) & 0x55);
    v = (v & 0x33) + ((v >> 2) & 0x33);
    return (v & 0x0f) + ((v >> 4) & 0x0f);

число -        abcd efgh = 01101011

Разбиваем на группы по 2 бита =>
Первая маска   0101 0101


Проверяем единицы в каждом четном бите (6-4-2-0)
|01|01| |01|01|
&
|ab|cd| |ef|gh|
 01 00   00 01
= 
b=1 d=0 f=0 h=1            (v & 0x55)
 
Сдвиг на пол-группы
Проверяем единицы в каждом нечетном бите (7-5-3-1) 
|01|01| |01|01|          
&
| a|bc| |de|fg|h
=
a=0 c=1 e=1 g=1            (v >> 1) & 0x55

После сложения получим количество единичных битов в каждой группе

Новое значение числа:
|a+b|c+d|e+f|g+h|
  1   1   1   2

|01|01| |01|10|            v = (v & 0x55) + ((v >> 1) & 0x55);


Теперь разбиваем на группы по 4 бита =>
Вторая маска   0011 0011

аналогично 

|0011| |0011|
&
|0101| |0110|
=
 0001   0010               (v & 0x33)

и со сдвигом на пол-группы

|0011| |0011|
&
|  01| |0101|10            (v >> 2) & 0x33
=
 0001   0001

После сложения получим количество единичных битов в каждой группе

 0001 0010
+
 0001 0001
=
 0010 0011                 v = (v & 0x33) + ((v >> 2) & 0x33);

(2 бита в первой иетраде и 3 во второй)

А всего значит 2+3 = 5 установленных битов

0010 + 0011 = 0101 // (v & 0x0f) + ((v >> 4) & 0x0f); 

И все!

Эти маски просто разбивает число на группы по сколько-то бит

UgN>    v = (v & 0x55) + ((v >> 1) & 0x55);
UgN>    v = (v & 0x33) + ((v >> 2) & 0x33);
UgN>    return (v & 0x0f) + ((v >> 4) & 0x0f); 
UgN>

return (v + (v >> 4)) & 0x0f;