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

public class Main {

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

        private final byte[] datos = new byte[65536];
        private int actual = 0;
        private int disponible = 0;

        private int obtener() throws IOException {
            if (actual == disponible) {
                disponible = entrada.read(datos);
                actual = 0;

                if (disponible == -1) return -1;
            }

            return datos[actual++];
        }

        int entero() throws IOException {
            int c;

            do {
                c = obtener();
                if (c == -1) return -1;
            } while (c <= 32);

            int valor = 0;

            while (c > 32) {
                valor = valor * 10 + c - 48;
                c = obtener();
            }

            return valor;
        }

        String cadena() throws IOException {
            StringBuilder sb = new StringBuilder();
            int c;

            do {
                c = obtener();
                if (c == -1) return null;
            } while (c <= 32);

            while (c > 32) {
                sb.append((char) c);
                c = obtener();
            }

            return sb.toString();
        }
    }

    static int[] crearOrden(int[] datos) {
        int n = datos.length;

        int[] orden = new int[n];
        int[] clase = new int[n];
        int[] temporal = new int[n];
        int[] siguienteClase = new int[n];

        int mayor = 0;

        for (int x : datos) {
            if (x > mayor) mayor = x;
        }

        int[] cuenta = new int[Math.max(n, mayor + 1)];

        for (int x : datos) {
            cuenta[x]++;
        }

        for (int i = 1; i <= mayor; i++) {
            cuenta[i] += cuenta[i - 1];
        }

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

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

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

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

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

            for (int i = 0; i < n; i++) {
                int p = orden[i] - salto;
                temporal[i] = p < 0 ? p + n : p;
            }

            Arrays.fill(cuenta, 0, grupos, 0);

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

            for (int i = 1; i < grupos; i++) {
                cuenta[i] += cuenta[i - 1];
            }

            for (int i = n - 1; i >= 0; i--) {
                int p = temporal[i];
                orden[--cuenta[clase[p]]] = p;
            }

            siguienteClase[orden[0]] = 0;

            int nuevosGrupos = 1;

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

                int a2 = a + salto;
                int b2 = b + salto;

                if (a2 >= n) a2 -= n;
                if (b2 >= n) b2 -= n;

                if (clase[a] != clase[b] ||
                    clase[a2] != clase[b2]) {
                    nuevosGrupos++;
                }

                siguienteClase[a] = nuevosGrupos - 1;
            }

            int[] cambio = clase;
            clase = siguienteClase;
            siguienteClase = cambio;

            grupos = nuevosGrupos;

            if (grupos == n) break;
        }

        return orden;
    }

    static int[] obtenerLCP(int[] datos, int[] orden) {
        int n = datos.length;

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

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

        int k = 0;

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

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

            int anterior = orden[posicion - 1];

            while (i + k < n &&
                   anterior + k < n &&
                   datos[i + k] == datos[anterior + k]) {
                k++;
            }

            comun[posicion] = k;

            if (k > 0) k--;
        }

        return comun;
    }

    static int[] unirCadenas(String s, String t, int n) {
        int[] resultado = new int[4 * n + 2];

        int baseT = 2 * n + 1;

        for (int i = 0; i < n; i++) {
            int x = s.charAt(i) + 2;
            int y = t.charAt(i) + 2;

            resultado[i] = x;
            resultado[i + n] = x;

            resultado[baseT + i] = y;
            resultado[baseT + n + i] = y;
        }

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

        return resultado;
    }

    static long calcularRespuesta(
        int n,
        int[] orden,
        int[] comun
    ) {
        int baseT = 2 * n + 1;

        int cantidadS = 0;
        int cantidadT = 0;

        int ultimo = -1;
        int minimo = Integer.MAX_VALUE;

        long anterioresS = 0;
        long resultado = 0;

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

            if (ultimo != -1) {
                minimo = Math.min(minimo, comun[i]);
            }

            int p = orden[i];

            boolean perteneceS = p < n;

            boolean perteneceT =
                p >= baseT && p < baseT + n;

            if (!perteneceS && !perteneceT) {
                continue;
            }

            if (ultimo == -1 || minimo < n) {

                resultado += anterioresS * cantidadT;
                resultado += (long) cantidadS * cantidadT;

                anterioresS += cantidadS;

                cantidadS = 0;
                cantidadT = 0;
            }

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

            ultimo = i;
            minimo = Integer.MAX_VALUE;
        }

        resultado += anterioresS * cantidadT;
        resultado += (long) cantidadS * cantidadT;

        return resultado;
    }

    static long ejecutar(int n, String s, String t) {
        int[] texto = unirCadenas(s, t, n);

        int[] orden = crearOrden(texto);

        int[] comun = obtenerLCP(texto, orden);

        return calcularRespuesta(n, orden, comun);
    }

    public static void main(String[] args) throws IOException {
        Lector entrada = new Lector();

        int n = entrada.entero();

        if (n < 1) return;

        String s = entrada.cadena();
        String t = entrada.cadena();

        if (s == null || t == null ||
            s.length() != n || t.length() != n) {
            return;
        }

        System.out.println(ejecutar(n, s, t));
    }
}