#include <bits/stdc++.h>
using namespace std;

int main()
{
    random_device rd;
    mt19937 rng(rd());
    uniform_int_distribution<int> k(1, 114514);

    int arr[10];
    for (int i=0; i < 10; i++)
        arr[i] = k(rng);

    int j = *arr;
    for (int &x : arr)
        cout << x << ' ';
    cout << '\n';

    sort(arr, arr+10);

    for (int &x : arr)
        cout << x << ' ';
    cout << '\n';
    int l = 0, r = 10;
    while (l < r)
    {
        int m = (l + r) / 2;
        if (arr[m] > j)
            r = m;
        else if (arr[m] < j)
            l = m+1;
        else
        {
            cout << m;
            _exit(0);
        }
    }
}

#include <bits/stdc++.h>
using namespace std;

int main()
{
    random_device rd;
    mt19937 rng(rd());
    uniform_int_distribution<int> k(1, 114514);

    int arr[10];
    for (int i=0; i < 10; i++)
        arr[i] = k(rng);

    for (int &x : arr)
        cout << x << ' ';
    cout << '\n';

    for (int i=0, k=0; i < 10; k = ++i)
    {
        for (int j=i+1; j < 10; j++)
            k = (arr[j] > arr[k]? j : k);
        swap(arr[i], arr[k]);
    }
    for (int &x : arr)
        cout << x << ' ';
}

#include <bits/stdc++.h>
using namespace std;
 
vector <vector <char>> saves(8, vector <char> (8));
unordered_map <int, int> pieces;
int ans = 0;
 
bool check_valid(int y, int x) {
 
    if(saves[y][x] != '*') {
 
        for (int i=0; i < y; i++) {
            if (pieces[i] - x == i - y)
                return false;
 
            if (pieces[i] == x)
                return false;
            
            if (pieces[i] + i == x + y)
                return false;
 
        }
 
        return true;
    }
    else
        return false;
}
 
void solution(int row) {
 
    if (row == 8) {
 
        ans++;
        return;
    }
    
    for (int i=0; i < 8; i++) {
 
        if (!check_valid(row, i)) 
            continue;
            
        pieces[row] = i;
 
        solution(row + 1);
 
        pieces.erase(row);
    }
 
}
 
signed main() {
 
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
 
    for (int i=0; i < 8; i++) 
        for (auto &x : saves[i])
            cin >> x;
 
    solution(0);
    
    cout << ans;
    
    return 0;
}

#include <bits/stdc++.h>
using namespace std;
 
static int dy[8] = {1, 2, 2, 1, -1, -2, -2, -1};
static int dx[8] = {-2, -1, 1, 2, -2, -1, 1, 2};
static int grid[8][8];
bool notoutofbound(int i, int j)
{
    return i >= 0 && i < 8 && j >= 0 && j < 8;
}
int degree(int i, int j)
{
    int cnt = 0;
    for (int k = 0; k < 8; ++k)
    {
        int row = i + dy[k], col = j + dx[k];
        if (notoutofbound(row, col) && grid[row][col] == 0)
            ++cnt;
    }
    return cnt;
}
void backtrack(int i, int j, int cnt)
{
    if (cnt == 64)
    {
        for (int i=0; i < 8; ++i)
            for (int j=0; j < 8; ++j)
                cout << grid[i][j] << " \n"[j == 7];
        exit(0);
    }
    vector<tuple<int, int, int>> candidate;
    for (int v=0; v < 8; ++v)
    {
        int row = i + dy[v], col = j + dx[v];
        if (notoutofbound(row, col) && grid[row][col] == 0)
            candidate.emplace_back(degree(row, col), row, col);
    }
    sort(candidate.begin(), candidate.end());
    ++cnt;
    for (auto &[c, a, b] : candidate)
    {
        grid[a][b] = cnt;
        backtrack(a, b, cnt);
        grid[a][b] = 0;
    }
}
int main()
{
    int y, x; cin >> y >> x;
    grid[--x][--y] = 1;
    backtrack(x, y, 1);
}

constant_search(arr, n, k)
	j = choice()
    if (k == arr[j])
    	return j
    else
        return 0
    

#include <bits/stdc++.h>
using namespace std;

vector<vector<int>> grid;
vector<int> min_tour;
int minc = 1e9 + 114514 + 1919810;
int cost(vector<int> &tour, int a, int b)
{
    return grid[tour[a]][tour[b]];
}

void sa(vector<vector<int>> g, int n, double temp, double rate)
{
    random_device rd;
    mt19937 rng(rd());
    uniform_int_distribution<int> picknode(0, n-1);

    vector<int> prev;
    for (int i=0; i < n; i++)
        prev.push_back(i);
    shuffle(prev.begin(), prev.end(), rng);

    int prevc = g[prev.back()][prev[0]];
    for (int i=1; i < prev.size(); i++)
        prevc += g[prev[i-1]][prev[i]];

    while ( (temp *= rate )> 1.919810)
    {
        int i = picknode(rng), j = picknode(rng);
        if (abs(i-j) < 3) continue;
        if (i > j) swap(i, j);

        int curc = prevc;
        // ~ a i b ~ c j d ~
        int a = (i-1+n)%n, b = (i+1+n)%n, c = (j-1+n)%n, d = (j+1+n)%n;
        curc -= (cost(prev, a, i) + cost(prev, i, b) + cost(prev, c, j) + cost(prev, j, d));
        curc += (cost(prev, a, j) + cost(prev, j, b) + cost(prev, c, i) + cost(prev, i, d));

        int delta = curc - prevc;
        if (delta <= 0 || exp((double)-delta/temp) > uniform_real_distribution<double>(0, 1)(rng))
            swap(prev[i], prev[j]), prevc = curc;

        if (prevc < minc)
            min_tour = prev, minc = prevc;
    }
}
int main()
{
    double temp = 1e3;
    double rate = 0.80632090761 * 1.234;
    int n, q;
    cin >> n >> q;
    grid.resize(n);
    for (auto &x : grid)
        x.resize(n);
    random_device rs;
    mt19937 rg(rs());
    uniform_int_distribution<int> gr(1,234);
    for (int i=0; i < n; i++)
        for (int j=0; j < n; j++)
            grid[i][j] = (i == j? 0 : gr(rg));

    for (int i=0; i < n; i++)
        for (int j=0; j < n; j++)
            cerr << grid[i][j] << " \n"[j == n-1];
    cout << "------------------------------------------\n";
    while (q--)
    {
        cout << q+1 << "th query\n" << "============================" << '\n';
        sa(grid, n, temp, rate);
        cout << minc << '\n';
        for (int &x : min_tour)
            cout << x << " \n"[x == min_tour.back()];
    }
}