Buildings made from cubes In this fastest-code challenge, you are provided with a set of \$n\$ identical blocks and need to determine how many unique buildings can be constructed with them. Buildings must satisfy the following rules:


No overhangs - each block must either be on the ground or supported by one or more blocks directly underneath it.
All blocks must be aligned to a unit-sized grid.
All blocks in a building must be connected to at least one other block by at least one face, and the blocks must form a single connected unit.
Buildings are not unique if they can be mapped to another building  by reflection or rotation in the X/Y plane.


e.g. These are the same:





If a building is rotated between horizontal and vertical, that does result in a different building


e.g. These are different:

A building with two storeys each of two rooms:


A building with one storey containing 4 rooms:


The challenge is to determine how many different house designs are possible using a given number of cubes. Input and output are both a single integer (using any standard method). 

Clearly for 1 cube, only 1 design is possible. For 2 cubes, 2 designs are possible (lying down and standing up). For 3 cubes, there are 4 possibilities, and for 4 cubes there are 12 (see images below; please note the colours are just for display to make it easier to see the individual cubes, but don’t have any significance beyond that).



The first 8 terms are:

n  | output
1  | 1
2  | 2
3  | 4
4  | 12
5  | 35
6  | 129
7  | 495
8  | 2101


Draft sequence on OEIS. 

This is fastest-code. The winning entry is the one that can determine the number of buildings for the highest value of \$n\$. If more than one answer can calculate the result for the same \$n\$ within 10 minutes, the one that is fastest for that value wins. This will be tested on an 8th generation Core i7 with 16 GB RAM running Ubuntu 19.10. There must therefore be a freely available interpreter or compiler for any code posted. Default loopholes and IO rules apply.

Cube images generated using usecubes.

Sandbox link
JavaScript (Node.js), \$N=10\$ in 4m02s1
1: on an Intel Code i7, 7th Gen
This only includes some trivial optimizations and is therefore quite inefficient. It does at least confirm the results listed in the challenge.
function build(n) {
  let layer = [],
      cube = new Set,
      count = 0,
      x, y;

  for(y = 0; y &lt; n; y++) {
    for(layer[y] = [], x = 0; x &lt; n; x++) {
      layer[y][x] = 0;
    }
  }

  function fill(k, alignTop) {
    let x, y;

    if(k == 0) {
      if(!cube.has(layer + '')) {
        let transf;

        count++;

        cube.add(layer + '');
        cube.add((transf = rotate(n, layer)) + '');
        cube.add((transf = rotate(n, transf)) + '');
        cube.add((transf = rotate(n, transf)) + '');

        cube.add((transf = mirror(layer)) + '');
        cube.add((transf = rotate(n, transf)) + '');
        cube.add((transf = rotate(n, transf)) + '');
        cube.add((transf = rotate(n, transf)) + '');
      }
      return;
    }

    let y0;

    for(y0 = 0; !layer[y0].some(v =&gt; v); y0++) {}

    for(y = Math.max(0, y0 - 1); y &lt; n; y++) {
      for(x = 0; x &lt; n; x++) {
        if(
          !layer[y][x] &amp;&amp; (
            (y &amp;&amp; layer[y - 1][x]) ||
            (y &lt; n - 1 &amp;&amp; layer[y + 1][x]) ||
            (x &amp;&amp; layer[y][x - 1]) ||
            (x &lt; n - 1 &amp;&amp; layer[y][x + 1])
          )
        ) {
          for(let i = 1; i &lt;= (alignTop ? k : k - y0 - 1); i++) {
            layer[y][x] = i;
            fill(k - i, alignTop || !y);
            layer[y][x] = 0;
          }
        }
      }
    }
  }

  for(y = 0; y &lt; n; y++) {
    for(let i = 1; i &lt;= n - y; i++) {
      layer[y][0] = i;
      fill(n - i, !y);
      layer[y][0] = 0;
    }
  }

  return count;
}

function rotate(n, layer) {
  let rot = [],
      x, y;

  for(y = 0; y &lt; n; y++) {
    for(rot[y] = [], x = 0; x &lt; n; x++) {
      rot[y][x] = layer[n - x - 1][y];
    }
  }
  return align(rot);
}

function mirror(layer) {
  return align([...layer].reverse());
}

function align(layer) {
  while(!layer[0].some(v =&gt; v)) {
    let s = layer.shift();
    layer = [...layer, s];
  }
  while(!layer[0].some((_, y) =&gt; layer[y][0])) {
    layer = layer.map(r =&gt; {
      return [...r.slice(1), 0];
    });
  }
  return layer;
}

Try it online! (up to \$N=8\$)
Output
N = 1 --&gt; 1
time: 10.352ms
N = 2 --&gt; 2
time: 0.935ms
N = 3 --&gt; 4
time: 0.877ms
N = 4 --&gt; 12
time: 2.530ms
N = 5 --&gt; 35
time: 9.060ms
N = 6 --&gt; 129
time: 33.333ms
N = 7 --&gt; 495
time: 157.160ms
N = 8 --&gt; 2101
time: 1559.707ms
N = 9 --&gt; 9154
time: 18555.900ms
N = 10 --&gt; 41356
time: 242855.989ms