Numbers with multiple runs of ones Task

Find the set of numbers such that the binary representation contains two or more runs of 1 separated by at least one 0.

For example, the for the numbers that are 4 bits long:

 0 0000        (no ones)
 1 0001        (only one run)
 2 0010        (only one run)
 3 0011        (only one run)
 4 0100        (only one run)
 5 0101 Valid
 6 0110        (only one run)
 7 0111        (only one run)
 8 1000        (only one run)
 9 1001 Valid
10 1010 Valid
11 1011 Valid
12 1100        (only one run)
13 1101 Valid
14 1110        (only one run)
15 1111        (only one run)


Input

An integer provided to the application via some input in the range 3 .. 32.  This represents the maximum number of bits to count up to.

The input of n indicates that the numbers 0 .. 2n-1 need to be examined. 

Output

A delimited (your choice) list of all numbers meeting the criteria. The numbers are to be presented in numeric order.  An extra trailing delimiter is acceptable.  Data structure enclosures (e.g. [] and similar) are also acceptable.

Example

Input: 3
Output: 5

Input: 4
Output: 5, 9, 10, 11, 13

Input: 5
Output: 5, 9, 10, 11, 13, 17, 18, 19, 20, 21, 22, 23, 25, 26, 27, 29


This is code-golf - the answer with the least amount of bytes wins.
Python, 48

lambda n:[i for i in range(2**n)if'01'in bin(i)]

I had been vastly overthinking this. We just need to check if the binary expansion contains '01'.
For there to be two runs of ones, the one on the right must be preceded by a 0. If there's only one run, there won't be any leading 0's, so that won't happen.

Old answer:
lambda n:[i for i in range(2**n)if len(set(bin(i).split('0')))&gt;2]

The Python binary representation works very nicely here. A binary number is written like bin(9)=='0b10110'. Splitting at '0' results in a list of

Empty strings to the left of the initial 0, between any two consecutive 0's, and to the right of any final 0
The letter b followed by one or more leading ones
Runs of 1's that are not leading

The first two categories always exist, but the last one only exists if there is a run one 1's that doesn't contain the leading '1', and so only if there's more than one run of 1's. So, it suffices to check if the list contains more than 2 distinct elements.
Python 3.5 saves 2 chars by unpacking {*_} in place of set(_).