Nikephoros and Polycarpus play rock-paper-scissors. The loser gets pinched (not too severely!).

Let us remind you the rules of this game. Rock-paper-scissors is played by two players. In each round the players choose one of three items independently from each other. They show the items with their hands: a rock, scissors or paper. The winner is determined by the following rules: the rock beats the scissors, the scissors beat the paper and the paper beats the rock. If the players choose the same item, the round finishes with a draw.

Nikephoros and Polycarpus have played n rounds. In each round the winner gave the loser a friendly pinch and the loser ended up with a fresh and new red spot on his body. If the round finished in a draw, the players did nothing and just played on.

Nikephoros turned out to have worked out the following strategy: before the game began, he chose some sequence of items A = (a1, a2, ..., am), and then he cyclically showed the items from this sequence, starting from the first one. Cyclically means that Nikephoros shows signs in the following order: a1, a2, ..., am, a1, a2, ..., am, a1, ... and so on. Polycarpus had a similar strategy, only he had his own sequence of items B = (b1, b2, ..., bk).

Determine the number of red spots on both players after they've played n rounds of the game. You can consider that when the game began, the boys had no red spots on them.

Input

The first line contains integer n (1 ≤ n ≤ 2·109) — the number of the game's rounds.

The second line contains sequence A as a string of m characters and the third line contains sequence B as a string of k characters (1 ≤ m, k ≤ 1000). The given lines only contain characters "R", "S" and "P". Character "R" stands for the rock, character "S" represents the scissors and "P" represents the paper.

Output

Print two space-separated integers: the numbers of red spots Nikephoros and Polycarpus have.

Examples

Input

7
RPS
RSPP


Output

3 2

Input

5
RRRRRRRR
R


Output

0 0

Note

In the first sample the game went like this:

  * R - R. Draw. 
  * P - S. Nikephoros loses. 
  * S - P. Polycarpus loses. 
  * R - P. Nikephoros loses. 
  * P - R. Polycarpus loses. 
  * S - S. Draw. 
  * R - P. Nikephoros loses. 



Thus, in total Nikephoros has 3 losses (and 3 red spots), and Polycarpus only has 2.
/**
 * Created by IntelliJ IDEA.
 * @author Andrew Porokhin, andrew.porokhin@gmail.com
 */

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.StringTokenizer;

/**
 * Problem solution for croc camp, http://codeforces.ru/blog/entry/4142
 */
public class KrokA implements Runnable {
    void solve() throws NumberFormatException, IOException {
        // TODO: Write your code here ...
        final int n = nextInt();
        final char[] strategy1 = nextToken().trim().toCharArray();
        final char[] strategy2 = nextToken().trim().toCharArray();

        final int m = strategy1.length;
        final int k = strategy2.length;

        final int sn = lcm(m, k);

//        System.out.println("lcm("+ m + "," + k + ") = " + sn);

        long f1Result = 0;
        long f2Result = 0;
        final int p;
        if (n > sn) {
            for (int i = 0; i < sn; i++) {
                int index1 = i % m;
                int index2 = i % k;
//                System.out.println(strategy1[index1] + " vs " + strategy2[index2]);
                switch (compareWin(strategy1[index1], strategy2[index2])) {
                    case 1:
                        f2Result++;
                        break;
                    case -1:
                        f1Result++;
                        break;
                }
            }
            f1Result *= n / sn;
            f2Result *= n / sn;
            p = n % sn;
        } else {
            p = n;
        }

        for (int i = 0; i < p; i++) {
            int index1 = i % m;
            int index2 = i % k;

//            System.out.println(strategy1[index1] + " vs " + strategy2[index2]);
            switch (compareWin(strategy1[index1], strategy2[index2])) {
                case 1:
                    f2Result++;
                    break;
                case -1:
                    f1Result++;
                    break;
            }
        }

        out.println(f1Result + " " + f2Result);
    }

    StringTokenizer st;
    BufferedReader in;
    PrintWriter out;

    public static void main(String[] args) {
        // Introduce thread in order to increase stack size
        new KrokA().run();
    }

    public void run() {
        try {
            in = new BufferedReader(new InputStreamReader(System.in));
            out = new PrintWriter(System.out);
            solve();
        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            out.flush();
            out.close();
        }
    }

    String nextToken() throws IOException {
        while (st == null || !st.hasMoreTokens()) {
            st = new StringTokenizer(in.readLine());
        }
        return st.nextToken();
    }

    int nextInt() throws NumberFormatException, IOException {
        return Integer.parseInt(nextToken());
    }

    long nextLong() throws NumberFormatException, IOException {
        return Long.parseLong(nextToken());
    }

    double nextDouble() throws NumberFormatException, IOException {
        return Double.parseDouble(nextToken());
    }

    static int gcd(int a, int b) {
        while (b > 0) {
            a %= b;

            final int tmp = a;
            a = b;
            b = tmp;
        }
        return a;
    }

    static int lcm(int a, int b) {
        return a / gcd(a, b) * b;
    }

    static int compareWin(char a, char b) {
        if (a == b) {
            return 0;
        } else if (a == 'R') {
            return b == 'S' ? 1 : -1;
        } else if (a == 'S') {
            return b == 'P' ? 1 : -1;
        }

        return b == 'R' ? 1 : -1;
    }

//    static class two {
//        final int a;
//        final int b;
//
//        two(int a, int b) {
//            this.a = a;
//            this.b = b;
//        }
//    }
//
//    static class triple {
//        final int a;
//        final int b;
//        final int c;
//
//        triple(int a, int b, int c) {
//            this.a = a;
//            this.b = b;
//            this.c = c;
//        }
//    }

//    static class Pair<T,V> {
//        final T a;
//        final V b;
//
//        Pair(T a, V b) {
//            this.a = a;
//            this.b = b;
//        }
//
//        Pair<T,V> setA(T newA) {
//            return new Pair<T,V>(newA, b);
//        }
//
//        Pair<T,V> setB(V newB) {
//            return new Pair<T,V>(a, newB);
//        }
//
//        @Override
//        public String toString() {
//            return "{" + a.toString() + ", " + b.toString() + "}";
//        }
//    }
}
