AS>но вот в комментах написать, что это просто набросок и настоящая реализация так не должна работать, имхо, стОило.

AS>VC6
AS>23384774
AS>43100993
AS>VC7.1
AS>17996589
AS>20148363
AS>

AS>    lea    edx, DWORD PTR [eax-1]
AS>    mov    ebx, edx
AS>    shr    ebx, 24                    ; 00000018H
AS>    movzx    ebx, BYTE PTR _ones[ebx]
AS>    lea    esi, DWORD PTR [eax-2]
AS>    mov    DWORD PTR tv1199[esp+48], esi
AS>    shr    esi, 24                    ; 00000018H
AS>    movzx    esi, BYTE PTR _ones[esi]
AS>    add    esi, ebx
AS>    lea    ecx, DWORD PTR [eax+1]
AS>    mov    ebx, ecx
AS>    shr    ebx, 24                    ; 00000018H
AS>    movzx    ebx, BYTE PTR _ones[ebx]
AS>    add    esi, ebx
AS>    lea    ebx, DWORD PTR [eax-2]
AS>    and    ebx, 255                ; 000000ffH
AS>    movzx    ebx, BYTE PTR _ones[ebx]
AS>    add    esi, ebx
AS>    lea    ebx, DWORD PTR [eax-1]
AS>    and    ebx, 255                ; 000000ffH
AS>    movzx    ebx, BYTE PTR _ones[ebx]
AS>    add    esi, ebx
AS>    mov    ebx, eax
AS>    shr    ebx, 24                    ; 00000018H
AS>    movzx    ebx, BYTE PTR _ones[ebx]
AS>    add    esi, ebx
AS>    movzx    ebx, ah
AS>    movzx    ebx, BYTE PTR _ones[ebx]
AS>    add    esi, ebx
AS>    movzx    ebx, BYTE PTR tv1023[esp+50]
AS>    movzx    ebx, BYTE PTR _ones[ebx]
AS>    add    esi, ebx
AS>    movzx    ebx, ch
AS>    movzx    ebx, BYTE PTR _ones[ebx]
AS>    mov    DWORD PTR tv1192[esp+48], edx
AS>    add    esi, ebx
AS>    movzx    edx, dh
AS>    movzx    edx, BYTE PTR _ones[edx]
AS>    mov    DWORD PTR tv1180[esp+48], ecx
AS>    movzx    ebx, BYTE PTR tv1180[esp+50]
AS>    movzx    ebx, BYTE PTR _ones[ebx]
AS>    add    esi, ebx
AS>    add    esi, edx
AS>    movzx    edx, BYTE PTR tv1192[esp+50]
AS>    movzx    edx, BYTE PTR _ones[edx]
AS>    add    esi, edx
AS>    movzx    edx, BYTE PTR tv1199[esp+49]
AS>    movzx    edx, BYTE PTR _ones[edx]
AS>    add    esi, edx
AS>    movzx    edx, BYTE PTR tv1199[esp+50]
AS>    movzx    edx, BYTE PTR _ones[edx]
AS>    and    ecx, 255                ; 000000ffH
AS>    movzx    ecx, BYTE PTR _ones[ecx]
AS>    add    esi, edx
AS>    mov    edx, eax
AS>    add    esi, ecx
AS>    and    edx, 255                ; 000000ffH
AS>    movzx    ecx, BYTE PTR _ones[edx]
AS>

movzx ebp, al
movzx edx, BYTE PTR ?ones$0@@4QBEB[ebp]
mov ebp, eax
shr ebp, 8
and ebp, 255
movzx ebp, BYTE PTR ?ones$0@@4QBEB[ebp]
add edx, ebp
mov ebp, eax
shr ebp, 16
and ebp, 255
movzx ebp, BYTE PTR ?ones$0@@4QBEB[ebp]
add edx, ebp
mov ebp, eax
shr ebp, 24
movzx ebp, BYTE PTR ?ones$0@@4QBEB[ebp]
lea ebx, DWORD PTR [edx+ebp]

template <int nCount>
struct EnumConstHelper
{
    template <class T>
    struct Dummy
    {
        enum {value = T::value};
    };
};

template <>
struct EnumConstHelper<0>
{
    template <class T>
    struct Dummy
    {
        enum {value = 0};
    };
};


template <class T, int nVal>
struct EnumConst
{
    template <int nCount>
    struct EnumConstImpl
    {
        enum {value = ((nVal << ((nCount - 1)*CHAR_BIT)) | EnumConstHelper<nCount-1>::Dummy<EnumConstImpl<nCount - 1> >::value)};
    };
    enum {value = EnumConstImpl<sizeof(T)>::value};
};


template <int iLevel>
struct CountBitsImpl
{
    template <class T>
    static unsigned DoCount(T X)
    {
        X = CountBitsImpl<iLevel - 1>::DoCount(X);
        return X + (X >> (1 << (iLevel))) ;
    }
};


template <>
struct CountBitsImpl<0>
{
    template <class T>
    static unsigned DoCount(T X)
    {
        return X - ( (X >> 1) & EnumConst<T, 0x55>::value);
    }
};

template <>
struct CountBitsImpl<1>
{
    template <class T>
    static unsigned DoCount(T X)
    {
        X = CountBitsImpl<0>::DoCount(X);
        return (X & EnumConst<T, 0x33>::value) + ((X >> 2) & EnumConst<T, 0x33>::value);
    }
};

template <>
struct CountBitsImpl<2>
{
    template <class T>
    static unsigned DoCount(T X)
    {
        X = CountBitsImpl<1>::DoCount(X);
        return (X + (X >> 4)) & EnumConst<T, 0x0F>::value;
    }
};


template <int nVal>
struct CountLevelImpl
{
    enum {value = CountLevelImpl<nVal/2>::value + 1};
};

template <>
struct CountLevelImpl<0>
{
    enum {value = 0};
};

template <int nVal>
struct CountLevel
{
    enum {value = CountLevelImpl<nVal>::value  - 1};
};

template <>
struct CountLevel<0>
{
};


template <class T>
unsigned CountBits(T X)
{
    return CountBitsImpl<CountLevel<sizeof(T)*CHAR_BIT>::value - 1>::DoCount(X) & (((unsigned)-1) >> (sizeof(int)*CHAR_BIT - CountLevel<sizeof(LONGLONG)*CHAR_BIT>::value));
};