import java.io.*;
import java.util.*;

public class Main {

    static class EntradaRapida {
        private final BufferedInputStream entrada =
            new BufferedInputStream(System.in);

        private final byte[] datos = new byte[1 << 16];
        private int pos = 0;
        private int longitud = 0;

        private int leer() throws IOException {
            if (pos >= longitud) {
                longitud = entrada.read(datos);
                pos = 0;

                if (longitud <= 0) return -1;
            }

            return datos[pos++];
        }

        String leerCadena() throws IOException {
            StringBuilder texto = new StringBuilder();
            int caracter;

            do {
                caracter = leer();
                if (caracter == -1) return null;
            } while (caracter <= 32);

            while (caracter > 32) {
                texto.append((char) caracter);
                caracter = leer();
            }

            return texto.toString();
        }

        int leerEntero() throws IOException {
            int caracter;

            do {
                caracter = leer();
                if (caracter == -1) return -1;
            } while (caracter <= 32);

            int valor = 0;

            while (caracter > 32) {
                valor = valor * 10 + caracter - '0';
                caracter = leer();
            }

            return valor;
        }
    }

    static int[] construirSufijos(int[] texto) {
        int n = texto.length;

        int[] orden = new int[n];
        int[] clase = new int[n];
        int[] desplazados = new int[n];
        int[] nuevaClase = new int[n];
        int[] conteo = new int[Math.max(n, 28)];

        for (int valor : texto) {
            conteo[valor]++;
        }

        for (int i = 1; i < 28; i++) {
            conteo[i] += conteo[i - 1];
        }

        for (int i = n - 1; i >= 0; i--) {
            orden[--conteo[texto[i]]] = i;
        }

        int clases = 1;
        clase[orden[0]] = 0;

        for (int i = 1; i < n; i++) {
            if (texto[orden[i]] != texto[orden[i - 1]]) {
                clases++;
            }

            clase[orden[i]] = clases - 1;
        }

        for (int salto = 1; salto < n; salto <<= 1) {

            for (int i = 0; i < n; i++) {
                desplazados[i] = orden[i] - salto;

                if (desplazados[i] < 0) {
                    desplazados[i] += n;
                }
            }

            Arrays.fill(conteo, 0, clases, 0);

            for (int i = 0; i < n; i++) {
                conteo[clase[desplazados[i]]]++;
            }

            for (int i = 1; i < clases; i++) {
                conteo[i] += conteo[i - 1];
            }

            for (int i = n - 1; i >= 0; i--) {
                int actual = desplazados[i];
                int grupo = clase[actual];

                orden[--conteo[grupo]] = actual;
            }

            nuevaClase[orden[0]] = 0;

            int nuevasClases = 1;

            for (int i = 1; i < n; i++) {
                int actual = orden[i];
                int anterior = orden[i - 1];

                int medioActual = (actual + salto) % n;
                int medioAnterior = (anterior + salto) % n;

                if (clase[actual] != clase[anterior] ||
                    clase[medioActual] != clase[medioAnterior]) {

                    nuevasClases++;
                }

                nuevaClase[actual] = nuevasClases - 1;
            }

            int[] temporal = clase;
            clase = nuevaClase;
            nuevaClase = temporal;

            clases = nuevasClases;

            if (clases == n) break;
        }

        return orden;
    }

    static int[] calcularLcp(int[] texto, int[] orden) {
        int n = texto.length;

        int[] rango = new int[n];
        int[] lcp = new int[n];

        for (int i = 0; i < n; i++) {
            rango[orden[i]] = i;
        }

        int comun = 0;

        for (int i = 0; i < n; i++) {
            int posicion = rango[i];

            if (posicion == 0) {
                comun = 0;
                continue;
            }

            int anterior = orden[posicion - 1];

            while (i + comun < n &&
                   anterior + comun < n &&
                   texto[i + comun] == texto[anterior + comun]) {

                comun++;
            }

            lcp[posicion] = comun;

            if (comun > 0) {
                comun--;
            }
        }

        return lcp;
    }

    static long resolver(int n, String cadenaS, String cadenaT) {

        int total = 4 * n + 2;
        int inicioT = 2 * n + 1;

        int[] texto = new int[total];

        for (int i = 0; i < n; i++) {
            int letraS = cadenaS.charAt(i) - 'a' + 2;
            int letraT = cadenaT.charAt(i) - 'a' + 2;

            texto[i] = letraS;
            texto[i + n] = letraS;

            texto[inicioT + i] = letraT;
            texto[inicioT + n + i] = letraT;
        }

        texto[2 * n] = 1;
        texto[total - 1] = 0;

        int[] orden = construirSufijos(texto);
        int[] lcp = calcularLcp(texto, orden);

        long respuesta = 0;
        long vistosS = 0;

        int cantidadS = 0;
        int cantidadT = 0;

        int anteriorValido = -1;
        int minimoComun = Integer.MAX_VALUE;

        for (int i = 0; i < total; i++) {

            if (anteriorValido != -1 && i > anteriorValido) {
                minimoComun = Math.min(minimoComun, lcp[i]);
            }

            int posicion = orden[i];

            boolean esS = posicion < n;

            boolean esT = posicion >= inicioT &&
                          posicion < inicioT + n;

            if (!esS && !esT) {
                continue;
            }

            if (anteriorValido == -1 || minimoComun < n) {

                if (anteriorValido != -1) {
                    respuesta += vistosS * cantidadT +
                                 (long) cantidadS * cantidadT;

                    vistosS += cantidadS;
                }

                cantidadS = 0;
                cantidadT = 0;
            }

            if (esS) {
                cantidadS++;
            } else {
                cantidadT++;
            }

            anteriorValido = i;
            minimoComun = Integer.MAX_VALUE;
        }

        respuesta += vistosS * cantidadT +
                     (long) cantidadS * cantidadT;

        return respuesta;
    }

    public static void main(String[] args) throws IOException {

        EntradaRapida lector = new EntradaRapida();

        int n = lector.leerEntero();

        if (n == -1) return;

        String cadenaS = lector.leerCadena();
        String cadenaT = lector.leerCadena();

        System.out.println(resolver(n, cadenaS, cadenaT));
    }
}