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

public class Main {

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

        private final byte[] buffer = new byte[1 << 16];
        private int indice = 0;
        private int limite = 0;

        private int leer() throws IOException {
            if (indice >= limite) {
                limite = flujoEntrada.read(buffer);
                indice = 0;

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

            return buffer[indice++];
        }

        int leerEntero() throws IOException {
            int simbolo;

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

            int numero = 0;

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

            return numero;
        }

        String leerCadena() throws IOException {
            StringBuilder cadenaLeida = new StringBuilder();
            int simbolo;

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

            while (simbolo > 32) {
                cadenaLeida.append((char) simbolo);
                simbolo = leer();
            }

            return cadenaLeida.toString();
        }
    }

    static int[] ordenarSufijos(int[] secuencia) {
        int tamano = secuencia.length;

        int[] sufijos = new int[tamano];
        int[] clases = new int[tamano];
        int[] auxiliar = new int[tamano];
        int[] clasesNuevas = new int[tamano];
        int[] frecuencias = new int[Math.max(tamano, 28)];

        for (int simbolo : secuencia) {
            frecuencias[simbolo]++;
        }

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

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

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

        for (int i = 1; i < tamano; i++) {
            if (secuencia[sufijos[i]] != secuencia[sufijos[i - 1]]) {
                totalClases++;
            }

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

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

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

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

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

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

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

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

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

            clasesNuevas[sufijos[0]] = 0;

            int nuevasClases = 1;

            for (int i = 1; i < tamano; i++) {
                int sufijoActual = sufijos[i];
                int sufijoAnterior = sufijos[i - 1];

                int segundaParteActual =
                    (sufijoActual + distancia) % tamano;

                int segundaParteAnterior =
                    (sufijoAnterior + distancia) % tamano;

                if (clases[sufijoActual] != clases[sufijoAnterior] ||
                    clases[segundaParteActual] !=
                    clases[segundaParteAnterior]) {

                    nuevasClases++;
                }

                clasesNuevas[sufijoActual] = nuevasClases - 1;
            }

            int[] intercambio = clases;
            clases = clasesNuevas;
            clasesNuevas = intercambio;

            totalClases = nuevasClases;

            if (totalClases == tamano) {
                break;
            }
        }

        return sufijos;
    }

    static int[] calcularLcp(int[] secuencia, int[] sufijos) {
        int tamano = secuencia.length;

        int[] rangoSufijos = new int[tamano];
        int[] prefijosComunes = new int[tamano];

        for (int i = 0; i < tamano; i++) {
            rangoSufijos[sufijos[i]] = i;
        }

        int longitudCompartida = 0;

        for (int i = 0; i < tamano; i++) {
            int rangoActual = rangoSufijos[i];

            if (rangoActual == 0) {
                longitudCompartida = 0;
                continue;
            }

            int sufijoAnterior = sufijos[rangoActual - 1];

            while (i + longitudCompartida < tamano &&
                   sufijoAnterior + longitudCompartida < tamano &&
                   secuencia[i + longitudCompartida] ==
                   secuencia[sufijoAnterior + longitudCompartida]) {

                longitudCompartida++;
            }

            prefijosComunes[rangoActual] = longitudCompartida;

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

        return prefijosComunes;
    }

    static int[] construirTexto(
        String primeraCadena,
        String segundaCadena,
        int tamanoCadena
    ) {
        int[] secuencia = new int[4 * tamanoCadena + 2];

        int inicioSegunda = 2 * tamanoCadena + 1;

        for (int indice = 0; indice < tamanoCadena; indice++) {
            int codigoPrimera =
                primeraCadena.charAt(indice) - 'a' + 2;

            int codigoSegunda =
                segundaCadena.charAt(indice) - 'a' + 2;

            secuencia[indice] = codigoPrimera;
            secuencia[indice + tamanoCadena] = codigoPrimera;

            secuencia[inicioSegunda + indice] = codigoSegunda;
            secuencia[inicioSegunda + tamanoCadena + indice] =
                codigoSegunda;
        }

        secuencia[2 * tamanoCadena] = 1;
        secuencia[4 * tamanoCadena + 1] = 0;

        return secuencia;
    }

    static long contarPares(
        int tamanoCadena,
        int[] sufijos,
        int[] prefijosComunes
    ) {
        int inicioSegunda = 2 * tamanoCadena + 1;
        int ultimoValido = -1;

        int primeraCantidad = 0;
        int segundaCantidad = 0;

        int minimoCompartido = Integer.MAX_VALUE;

        long primeraAcumulada = 0;
        long totalPares = 0;

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

            if (ultimoValido != -1 && indice > ultimoValido) {
                minimoCompartido = Math.min(
                    minimoCompartido,
                    prefijosComunes[indice]
                );
            }

            int sufijo = sufijos[indice];

            boolean esPrimera = sufijo < tamanoCadena;

            boolean esSegunda =
                sufijo >= inicioSegunda &&
                sufijo < inicioSegunda + tamanoCadena;

            if (!esPrimera && !esSegunda) {
                continue;
            }

            if (ultimoValido == -1 || minimoCompartido < tamanoCadena) {

                totalPares += primeraAcumulada * segundaCantidad;

                totalPares +=
                    (long) primeraCantidad * segundaCantidad;

                primeraAcumulada += primeraCantidad;

                primeraCantidad = 0;
                segundaCantidad = 0;
            }

            if (esPrimera) {
                primeraCantidad++;
            } else {
                segundaCantidad++;
            }

            ultimoValido = indice;
            minimoCompartido = Integer.MAX_VALUE;
        }

        totalPares += primeraAcumulada * segundaCantidad;

        totalPares +=
            (long) primeraCantidad * segundaCantidad;

        return totalPares;
    }

    static long resolver(
        int tamanoCadena,
        String primeraCadena,
        String segundaCadena
    ) {
        int[] secuencia = construirTexto(
            primeraCadena,
            segundaCadena,
            tamanoCadena
        );

        int[] sufijos = ordenarSufijos(secuencia);

        int[] prefijosComunes = calcularLcp(secuencia, sufijos);

        return contarPares(
            tamanoCadena,
            sufijos,
            prefijosComunes
        );
    }

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

        EntradaRapida lector = new EntradaRapida();

        int tamanoCadena = lector.leerEntero();

        if (tamanoCadena == -1) return;

        String primeraCadena = lector.leerCadena();
        String segundaCadena = lector.leerCadena();

        System.out.println(
            resolver(tamanoCadena, primeraCadena, segundaCadena)
        );
    }
}