#include <fstream>
#include <iostream>
#include <algorithm>
#include <iterator>
#include <vector>
#include <bitset>
#include <cmath>
#include <cassert>

using namespace std;

static constexpr size_t maxN()
{
    return 14;
}

int vQueenPositions[maxN()];

int primaryDiagonalIndexes[maxN()][maxN()];
int secondaryDiagonalIndexes[maxN()][maxN()];

bitset<maxN()> columns;
bitset<2 * maxN() + 2> primaryDiagonals;
bitset<2 * maxN() + 2> secondaryDiagonals;

int numSol = 0;

fstream fout("damesah.out", fstream::out);

static void solveQueens(int n, int numQueens)
{
    if (numQueens == n)
    {
        if (numSol ==  0)
        {
            for (int i=0; i<numQueens; ++i)
            {
                fout << vQueenPositions[i] + 1 << " ";
            }
            fout << std::endl;
        }
        numSol ++;
        return;
    }

    //int i = numQueens - 1;
    for (int j=0; j<n; ++j)
    {
        /*bool isSafe = true;
        for (int p=0; p<numQueens; ++p)
        {
            if (vQueenPositions[p] == j || abs(p - numQueens) == abs(vQueenPositions[p] - j))
            {
                isSafe = false;
                break;
            }
        }
        
        if (isSafe)
        {
            vQueenPositions[numQueens] = j;
            solveQueens(n, numQueens + 1);
            vQueenPositions[numQueens] = 0;
        }*/

        if (not columns[j] and not primaryDiagonals[primaryDiagonalIndexes[numQueens][j]] and not secondaryDiagonals[secondaryDiagonalIndexes[numQueens][j]])
        {
            vQueenPositions[numQueens] = j;

            columns[j] = true;
            primaryDiagonals[primaryDiagonalIndexes[numQueens][j]] = true;
            secondaryDiagonals[secondaryDiagonalIndexes[numQueens][j]] = true;

            solveQueens(n, numQueens + 1);

            columns[j] = false;
            primaryDiagonals[primaryDiagonalIndexes[numQueens][j]] = false;
            secondaryDiagonals[secondaryDiagonalIndexes[numQueens][j]] = false;
        }
    }
}

int main()
{
    fstream fin("damesah.in", fstream::in);
    
    for (int i=0; i<maxN(); ++i)
    {
        for (int j=i; j<maxN(); ++j)
        {
            primaryDiagonalIndexes[i][j] = j - i;
            secondaryDiagonalIndexes[i][maxN() - j - 1] = primaryDiagonalIndexes[i][j];
        }
    }
    
    for (int i=1; i<maxN(); ++i)
    {
        for (int j=i-1; j>=0; --j)
        {
            primaryDiagonalIndexes[i][j] = maxN() + i - j + 1;
            secondaryDiagonalIndexes[i][maxN() - j - 1] = primaryDiagonalIndexes[i][j];
        }
    }
    
    /*for (int i=0; i<maxN(); ++i)
    {
        for (int j=0; j<maxN(); ++j)
        {
            //cout << primaryDiagonalIndexes[i][j] << " ";
            cout << secondaryDiagonalIndexes[i][j] << " ";
        }
        cout << endl;
    }*/
    
    int n;
    fin >> n;
    //cout << n << std::endl;
    
    solveQueens(n, 0);
    fout << numSol << std::endl;
    
    return 0;
}