import java.math.BigInteger;
import java.util.ArrayList;
import java.util.List;

public class Euler524 {
    static int sumPrefix(int[] bit, int idx) {
        int sum = 0;
        for (idx++; idx > 0; idx -= idx & -idx)
            sum += bit[idx];
        return sum;
    }

    static void add(int[] bit, int idx, int delta) {
        for (idx++; idx < bit.length; idx += idx & -idx)
            bit[idx] += delta;
    }

    static long firstSortStepsFast(int[] perm) {
        int n = perm.length;
        if (n <= 1)
            return 0;
        int[] pos = new int[n + 1];
        for (int i = 0; i < n; i++)
            pos[perm[i]] = i;

        int[] insertionPos = new int[n + 1];
        int[] bit = new int[n + 1];
        add(bit, pos[1], 1);

        for (int v = 2; v <= n; v++) {
            insertionPos[v] = sumPrefix(bit, pos[v]) + 1;
            add(bit, pos[v], 1);
        }

        long steps = 0;
        long B = 1L;
        for (int m = 1; m < n; m++) {
            int p = insertionPos[m + 1];
            long lowMask = (p == 1) ? 0L : ((1L << (p - 1)) - 1L);
            long suffix = B & ~lowMask;
            steps += suffix;
            B = (B & lowMask) | (1L << (p - 1));
        }
        return steps;
    }

    static BigInteger lexIndex1BasedBig(int[] perm) {
        int n = perm.length;
        BigInteger[] fact = new BigInteger[n + 1];
        fact[0] = BigInteger.ONE;
        fact[1] = BigInteger.ONE;
        for (int i = 2; i <= n; i++)
            fact[i] = fact[i - 1].multiply(BigInteger.valueOf(i));

        List<Integer> rem = new ArrayList<>();
        for (int i = 1; i <= n; i++)
            rem.add(i);

        BigInteger rank = BigInteger.ONE;
        for (int i = 0; i < n; i++) {
            int index = 0;
            while (rem.get(index) < perm[i])
                index++;

            BigInteger addRank = BigInteger.valueOf(index).multiply(fact[n - 1 - i]);
            rank = rank.add(addRank);
            rem.remove(index);
        }
        return rank;
    }

    public static void main(String[] args) {
        int[] best = {
                1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
                16, 17, 18, 19, 20, 21, 22, 23, 24, 26, 25, 27, 28, 30, 32,
                34, 36, 38, 40, 39, 42, 45, 43, 41, 37, 35, 33, 31, 29, 44
        };

        if (firstSortStepsFast(best) != 8916100448256L) {
            throw new RuntimeException("Validation failed");
        }

        System.out.println(lexIndex1BasedBig(best).toString());
    }
}