public class Euler592 {
    static final int kHexDigits = 12;
    static final int kModBits = 4 * kHexDigits;
    static final long kMod = 1L << kModBits;
    static final long kMask = kMod - 1L;

    static final int kStepBits = 16;
    static final long kStep = 1L << kStepBits;
    static final long kMask32 = (1L << (kModBits - kStepBits)) - 1L;
    static final long kMask16 = (1L << (kModBits - 2 * kStepBits)) - 1L;

    static long mulMod(long a, long b) {
        return (a * b) & kMask;
    }

    static long powMod(long base, long exp) {
        long result = 1;
        base &= kMask;
        while (exp > 0) {
            if ((exp & 1) != 0)
                result = mulMod(result, base);
            base = mulMod(base, base);
            exp >>= 1;
        }
        return result;
    }

    static long inverseOddMod2_48(long odd) {
        long x = 1;
        for (int i = 0; i < 6; i++) {
            long ax = mulMod(odd, x);
            long twoMinusAx = (2L + kMod - ax) & kMask;
            x = mulMod(x, twoMinusAx);
        }
        return x;
    }

    static long[] oddInvTable;
    static {
        oddInvTable = new long[(int) (kStep / 2)];
        for (long r = 1; r < kStep; r += 2) {
            oddInvTable[(int) (r >> 1)] = inverseOddMod2_48(r);
        }
    }

    static long e1Mod2_32(long c) {
        if (c < 2)
            return 0;
        long a = c;
        long b = c - 1;
        if ((a & 1L) == 0) {
            a >>= 1;
        } else {
            b >>= 1;
        }
        return ((a & kMask32) * (b & kMask32)) & kMask32;
    }

    static long e2Mod2_16(long c) {
        if (c < 3)
            return 0;
        long[] f = { c, c - 1, c - 2, 3 * c - 1 };

        int twosToRemove = 3;
        for (int i = 0; i < 4; i++) {
            while (twosToRemove > 0 && (f[i] & 1L) == 0) {
                f[i] >>= 1;
                twosToRemove--;
            }
        }

        boolean dividedByThree = false;
        for (int i = 0; i < 3; i++) {
            if (f[i] % 3 == 0) {
                f[i] /= 3;
                dividedByThree = true;
                break;
            }
        }

        long res = 1;
        for (long v : f) {
            res = (res * (v & kMask16)) & kMask16;
        }
        return res;
    }

    static long classProduct(long oddResidue, long count) {
        if (count == 0)
            return 1;
        long rPow = powMod(oddResidue, count);
        long rInv = oddInvTable[(int) (oddResidue >> 1)];
        long a = mulMod(kStep, rInv);

        long poly = 1;
        poly = (poly + mulMod(a, e1Mod2_32(count))) & kMask;
        poly = (poly + mulMod(mulMod(a, a), e2Mod2_16(count))) & kMask;

        return mulMod(rPow, poly);
    }

    static long oddPrefix(long n) {
        if (n == 0)
            return 1;
        long q = n >> kStepBits;
        long rem = n & (kStep - 1);

        if (q == 0) {
            long p = 1;
            for (long r = 1; r <= rem; r += 2) {
                p = mulMod(p, r);
            }
            return p;
        }

        long p = 1;
        long qStep = (q * kStep) & kMask;
        for (long r = 1; r < kStep; r += 2) {
            p = mulMod(p, classProduct(r, q));
            if (r <= rem) {
                p = mulMod(p, (qStep + r) & kMask);
            }
        }
        return p;
    }

    static long oddFactorialPart(long n) {
        java.util.List<Long> levels = new java.util.ArrayList<>();
        for (long x = n; x > 0; x >>= 1) {
            levels.add(x);
        }

        long res = 1;
        for (long l : levels) {
            res = mulMod(res, oddPrefix(l));
        }
        return res;
    }

    static long v2Factorial(long n) {
        long e = 0;
        while (n > 0) {
            n >>= 1;
            e += n;
        }
        return e;
    }

    static long fValue(long n) {
        long oddPart = oddFactorialPart(n);
        long remTwos = v2Factorial(n) & 3L;
        return mulMod(oddPart, 1L << remTwos);
    }

    static long factorialU64(int n) {
        long f = 1;
        for (int i = 2; i <= n; i++)
            f *= i;
        return f;
    }

    public static String solve() {
        long n = factorialU64(20);
        long ans = fValue(n);
        return String.format("%012X", ans);
    }

    public static void main(String[] args) {
        System.out.println(solve());
    }
}