Number of distinct tilings of an n X n square with free n-polyominoes The newest &quot;nice&quot; OEIS sequence, A328020, was just published a few minutes ago.

Number of distinct tilings of an n X n square with free n-polyominoes.

This sequence counts tilings up to symmetries of the square. The sequence has six terms, but I'd like to see if folks here can extend it further.
Example
For n=4 there are 22 such grids, as shown in this image from the OEIS.

Credit: Jeff Bowermaster, Illustration of A328020(4).
Challenge
Like this previous challenge, the goal of this challenge is to compute as many terms as possible in this sequence, which begins 1, 1, 2, 22, 515, 56734 and where the n-th term is the number of tilings of the n X n grid with n-polyominoes.
Run your code for as long as you'd like. The winner of this challenge will be the user who posts the most terms of the sequence, along with their code to generate it. If two users post the same number of terms, then whoever posts their last term earliest wins.
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.