Codegolf the sequence of distance-3 Hamming Codewords (A075926) Codegolf the hamming code (with distance equals 3)! 

The sequence looks like this: 0, 7, 25, 30, 42, 45, 51, 52, 75, 76, 82, 85, 97, 102, 120, 127, 385, 390, 408, 415, 427, 428, 434, 437, 458, 461, 467, 468, 480, 487, 505, 510, 642, 645, 667, 668, 680...

Task

Given n output the first n items in OEIS sequence A075926. Your program should work for any integer n where 0 &lt;= n &lt; 2^15. This sequence is known as the sequence of hamming codewords with distance being 3. 

Rules:


Post both an ungolfed version of your code (or an explatation), and the golfed version, so that other people can understand how it works
If your program is written in a language with a compiler, specify which compiler and the compiler settings you used. Non-standard language features are allowed as long as it compiles with the compiler you specified, and the compiler was created prior to this question 


Sequence Definition:
Given a distance 3 hamming codeword k, the variants of k are k itself, and any nonnegative integer that can be produced by flipping one of k's bits. The nth hamming codeword is the smallest nonnegative integer that doesn't share a variant with any preceeding distance 3 hamming codeword. Here are the first twenty d-3 hamming codewords in binary:


  0,
  111,
  11001,
  11110,
  101010,
  101101,
  110011,
  110100,
  1001011,
  1001100,
  1010010,
  1010101,
  1100001,
  1100110,
  1111000,
  1111111,
  110000001,
  110000110,
  110011000,
  110011111,
  110101011


Ungolfed C++ code to produce sequence:

//Flips the nth bit
size_t flipN(size_t val, int bit) {
    return val ^ (1ull &lt;&lt; bit);
}
void Hamming(size_t n) {
    int bits_to_use = 20;
    //This vector keeps track of which numbers are crossed off
    //As either hamming codewords or their variants.
    std::vector&lt;bool&gt; vect(1ull &lt;&lt; bits_to_use, false);
    size_t pos = 0;
    size_t val = 0;
    while(val &lt;= n) {
        //Checks to see that pos hasn't been crossed off
        if(vect[pos]) goto loopend;
        for(int i=0; i &lt; bits_to_use; ++i)
        {
            if(vect[flipN(pos, i)]) goto loopend;
            //Checks to see that none of the variants
            //of pos have been crossed off
        }
        //If both those conditions are satisfied, output pos
        //As the next hamming codeword
        cout &lt;&lt; pos &lt;&lt; endl;
        //Here we cross off all the variants
        vect[pos] = true;
        for(int i=0; i &lt; bits_to_use; ++i)
        {
            vect[flipN(pos, i)] = true;
        }
        ++val;
        loopend:
        ++pos;
    }
}
Python 2, 98 97 bytes

-1 byte thanks to Mr. Xcoder


x=input()
l=[]
i=0
while len(l)&lt;x:s=any(bin(i^n).count('1')&lt;3for n in l);i+=s;l+=[i]*-~-s
print l


Try it online!

Straightforward implementation, using xor to calculate the hamming distance.
The inner loop is equivalent to :

if any(bin(i^n).count('1')&lt;3 for n in l):
   i+=1
else:
   l.append(i)