#include <iostream>
#include <vector>
#include <numeric>
#include <algorithm>

using namespace std;

bool is_connected(const vector<vector<int>>& g, int n) {
    if (n == 0) return true;
    vector<bool> vis(n, false);
    vector<int> q;
    q.push_back(0);
    vis[0] = true;
    int head = 0;
    while (head < q.size()) {
        int u = q[head++];
        for (int v = 0; v < n; ++v) {
            if (g[u][v] && !vis[v]) {
                vis[v] = true;
                q.push_back(v);
            } } } return q.size() == n; }

bool every_edge_in_triangle(const vector<vector<int>>& g, int n) {
    for (int i = 0; i < n; ++i) {
        for (int j = i + 1; j < n; ++j) {
            if (g[i][j]) {
                bool in_triangle = false;
                for (int k = 0; k < n; ++k) {
                    if (i != k && j != k && g[i][k] && g[j][k]) {
                        in_triangle = true;
                        break;
                    }
                }
                if (!in_triangle) return false;
            }
        }
    }
    return true;
}

bool are_isomorphic(const vector<vector<int>>& g1, const vector<vector<int>>& g2, int n) {
    vector<int> p(n);
    iota(p.begin(), p.end(), 0);
    do {
        bool match = true;
        for (int i = 0; i < n && match; ++i) {
            for (int j = 0; j < n && match; ++j) {
                if (g1[i][j] != g2[p[i]][p[j]]) {
                    match = false;
                }
            }
        }
        if (match) return true;
    } while (next_permutation(p.begin(), p.end()));
    return false;
}

void count_graphs(int n) {
    int max_edges = n * (n - 1) / 2;
    vector<pair<int, int>> edge_list;
    for (int i = 0; i < n; ++i) {
        for (int j = i + 1; j < n; ++j) {
            edge_list.push_back({i, j});
        }
    }
    vector<vector<vector<int>>> valid_graphs;
    long long total_combinations = 1LL << max_edges;
    for (long long mask = 0; mask < total_combinations; ++mask) {
        vector<vector<int>> g(n, vector<int>(n, 0));
        for (int e = 0; e < max_edges; ++e) {
            if ((mask >> e) & 1) {
                int u = edge_list[e].first;
                int v = edge_list[e].second;
                g[u][v] = g[v][u] = 1;
            }
        }
        if (!is_connected(g, n)) continue;
        if (!every_edge_in_triangle(g, n)) continue;
        bool is_new = true;
        for (const auto& vg : valid_graphs) {
            if (are_isomorphic(g, vg, n)) {
                is_new = false;
                break;
            }
        }
        if (is_new) {
            valid_graphs.push_back(g);
        }
    }
    cout << "N=" << n << ": " << valid_graphs.size() << "\n";
}