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

public class Main {

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

        private final byte[] buffer = new byte[1 << 16];
        private int posicion = 0;
        private int cantidad = 0;

        private int leer() throws IOException {
            if (posicion >= cantidad) {
                cantidad = entrada.read(buffer);
                posicion = 0;

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

            return buffer[posicion++];
        }

        int leerEntero() throws IOException {
            int caracter;

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

            int numero = 0;

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

            return numero;
        }

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

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

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

            return resultado.toString();
        }
    }

    static int[] construirSuffixArray(int[] texto) {
        int longitud = texto.length;

        int[] sufijos = new int[longitud];
        int[] clases = new int[longitud];
        int[] auxiliar = new int[longitud];
        int[] nuevasClases = new int[longitud];

        int maximoSimbolo = 0;

        for (int valor : texto) {
            maximoSimbolo = Math.max(maximoSimbolo, valor);
        }

        int[] frecuencias = new int[
            Math.max(longitud, maximoSimbolo + 1)
        ];

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

        for (int i = 1; i <= maximoSimbolo; i++) {
            frecuencias[i] += frecuencias[i - 1];
        }

        for (int i = longitud - 1; i >= 0; i--) {
            sufijos[--frecuencias[texto[i]]] = i;
        }

        int cantidadClases = 1;
        clases[sufijos[0]] = 0;

        for (int i = 1; i < longitud; i++) {
            if (texto[sufijos[i]] != texto[sufijos[i - 1]]) {
                cantidadClases++;
            }

            clases[sufijos[i]] = cantidadClases - 1;
        }

        for (int distancia = 1;
             distancia < longitud;
             distancia <<= 1) {

            for (int i = 0; i < longitud; i++) {
                auxiliar[i] = sufijos[i] - distancia;

                if (auxiliar[i] < 0) {
                    auxiliar[i] += longitud;
                }
            }

            Arrays.fill(frecuencias, 0, cantidadClases, 0);

            for (int i = 0; i < longitud; i++) {
                frecuencias[clases[auxiliar[i]]]++;
            }

            for (int i = 1; i < cantidadClases; i++) {
                frecuencias[i] += frecuencias[i - 1];
            }

            for (int i = longitud - 1; i >= 0; i--) {
                int indice = auxiliar[i];
                int clase = clases[indice];

                sufijos[--frecuencias[clase]] = indice;
            }

            nuevasClases[sufijos[0]] = 0;

            int totalNuevasClases = 1;

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

                int segundoActual = actual + distancia;
                int segundoAnterior = anterior + distancia;

                if (segundoActual >= longitud) {
                    segundoActual -= longitud;
                }

                if (segundoAnterior >= longitud) {
                    segundoAnterior -= longitud;
                }

                if (clases[actual] != clases[anterior] ||
                    clases[segundoActual] != clases[segundoAnterior]) {

                    totalNuevasClases++;
                }

                nuevasClases[actual] = totalNuevasClases - 1;
            }

            int[] intercambio = clases;
            clases = nuevasClases;
            nuevasClases = intercambio;

            cantidadClases = totalNuevasClases;

            if (cantidadClases == longitud) {
                break;
            }
        }

        return sufijos;
    }

    static int[] construirLCP(int[] texto, int[] sufijos) {
        int longitud = texto.length;

        int[] posiciones = new int[longitud];
        int[] lcp = new int[longitud];

        for (int i = 0; i < longitud; i++) {
            posiciones[sufijos[i]] = i;
        }

        int compartidos = 0;

        for (int i = 0; i < longitud; i++) {
            int rango = posiciones[i];

            if (rango == 0) {
                compartidos = 0;
                continue;
            }

            int anterior = sufijos[rango - 1];

            while (i + compartidos < longitud &&
                   anterior + compartidos < longitud &&
                   texto[i + compartidos] ==
                   texto[anterior + compartidos]) {

                compartidos++;
            }

            lcp[rango] = compartidos;

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

        return lcp;
    }

    static int[] construirTexto(
        String cadenaS,
        String cadenaT,
        int n
    ) {
        int[] texto = new int[4 * n + 2];

        int inicioT = 2 * n + 1;

        for (int i = 0; i < n; i++) {
            int simboloS = cadenaS.charAt(i) + 2;
            int simboloT = cadenaT.charAt(i) + 2;

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

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

        texto[2 * n] = 1;
        texto[4 * n + 1] = 0;

        return texto;
    }

    static long contarPares(
        int n,
        int[] sufijos,
        int[] lcp
    ) {
        int inicioT = 2 * n + 1;

        int grupoS = 0;
        int grupoT = 0;

        int anteriorSeleccionado = -1;
        int minimoLCP = Integer.MAX_VALUE;

        long acumuladoS = 0;
        long respuesta = 0;

        for (int i = 0; i < sufijos.length; i++) {

            if (anteriorSeleccionado != -1) {
                minimoLCP = Math.min(minimoLCP, lcp[i]);
            }

            int posicion = sufijos[i];

            boolean esS = posicion < n;

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

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

            if (anteriorSeleccionado == -1 ||
                minimoLCP < n) {

                respuesta += acumuladoS * grupoT;
                respuesta += (long) grupoS * grupoT;

                acumuladoS += grupoS;

                grupoS = 0;
                grupoT = 0;
            }

            if (esS) {
                grupoS++;
            } else {
                grupoT++;
            }

            anteriorSeleccionado = i;
            minimoLCP = Integer.MAX_VALUE;
        }

        respuesta += acumuladoS * grupoT;
        respuesta += (long) grupoS * grupoT;

        return respuesta;
    }

    static long resolver(
        int n,
        String cadenaS,
        String cadenaT
    ) {
        int[] texto = construirTexto(cadenaS, cadenaT, n);

        int[] sufijos = construirSuffixArray(texto);

        int[] lcp = construirLCP(texto, sufijos);

        return contarPares(n, sufijos, lcp);
    }

    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();

        if (cadenaS == null || cadenaT == null ||
            cadenaS.length() != n || cadenaT.length() != n) {
            return;
        }

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