Number of distinct tilings of an n X n square with free n-polyominoes
C, 7 terms

The seventh term is 19846102. (The first six are 1, 1, 2, 22, 515, 56734, as stated in the question).

#include &lt;stdio.h&gt;
#include &lt;string.h&gt;
#include &lt;stdint.h&gt;

#define N 7
#define ctz __builtin_ctzl

typedef uint64_t u64;

static u64 board[N*N] = { 0 };
static u64 adjacency_matrix[N*N] = { 0 };
static u64 count = 0;

static u64 check_symmetry()
{
    static const u64 symmetries[7][3] = {
        { 0,     +N, +1 },
        { N-1,   -1, +N },
        { N-1,   +N, -1 },
        { N*N-1, -1, -N },
        { N*N-1, -N, -1 },
        { N*N-N, +1, -N },
        { N*N-N, -N, +1 },
    };

    int order[N];

    for (u64 i = 0; i &lt; 7; ++i) {
        u64 start = symmetries[i][0];
        u64 dcol = symmetries[i][1];
        u64 drow = symmetries[i][2];
        memset(order, 0xFF, N*sizeof(int));

        for (u64 row = 0, col = 0; col &lt; N || (col = 0, ++row &lt; N); ++col) {
            u64 base = board[col + N*row];
            u64 symmetry = board[start + dcol*col + drow*row];
            u64 lex = 0;

            while (order[lex] != symmetry &amp;&amp; order[lex] != -1)
                ++lex;
            order[lex] = symmetry;

            if (lex &lt; base)
                return 0;

            if (base &lt; lex)
                break;
        }
    }

    return 1;
} 

static void recurse(u64 mino, u64 cell, u64 occupied, u64 adjacent, u64 forbidden)
{
    if (cell &gt;= N) {
        ++mino;

        if (mino == N) {
            count += check_symmetry();
            return;
        }

        u64 next = ctz(~occupied);
        board[next] = mino;
        recurse(mino, 1, occupied | 1ul &lt;&lt; next, adjacency_matrix[next], 0);
        return;
    }

    adjacent &amp;= ~occupied &amp; ~forbidden;
    while (adjacent) {
        u64 next = ctz(adjacent);
        adjacent &amp;= ~(1ul &lt;&lt; next);
        forbidden |= 1ul &lt;&lt; next;
        board[next] = mino;
        recurse(mino, cell + 1, occupied | 1ul &lt;&lt; next, adjacent | adjacency_matrix[next], forbidden);
    }
}

int main(void)
{
    for (u64 i = 0; i &lt; N*N; ++i) {
        if (i % N)
            adjacency_matrix[i] |= 1ul &lt;&lt; (i - 1);
        if (i / N)
            adjacency_matrix[i] |= 1ul &lt;&lt; (i - N);
        if (i % N != N - 1)
            adjacency_matrix[i] |= 1ul &lt;&lt; (i + 1);
        if (i / N != N - 1)
            adjacency_matrix[i] |= 1ul &lt;&lt; (i + N);
    }

    recurse(0, 2, 3, 4 | 3 &lt;&lt; N, 0);
    printf("%ld\n", count);
}


Try it online! (for N=6, since N=7 would time out.)

On my machine, N=6 took 0.171s, and N=7 took 2m23s. N=8 would take a few weeks.