A string s of length n can be encrypted by the following algorithm:

  * iterate over all divisors of n in decreasing order (i.e. from n to 1), 
  * for each divisor d, reverse the substring s[1 ... d] (i.e. the substring which starts at position 1 and ends at position d). 



For example, the above algorithm applied to the string s="codeforces" leads to the following changes: "codeforces" → "secrofedoc" → "orcesfedoc" → "rocesfedoc" → "rocesfedoc" (obviously, the last reverse operation doesn't change the string because d=1).

You are given the encrypted string t. Your task is to decrypt this string, i.e., to find a string s such that the above algorithm results in string t. It can be proven that this string s always exists and is unique.

Input

The first line of input consists of a single integer n (1 ≤ n ≤ 100) — the length of the string t. The second line of input consists of the string t. The length of t is n, and it consists only of lowercase Latin letters.

Output

Print a string s such that the above algorithm results in t.

Examples

Input

10
rocesfedoc


Output

codeforces


Input

16
plmaetwoxesisiht


Output

thisisexampletwo


Input

1
z


Output

z

Note

The first example is described in the problem statement.
import java.io.*;
import java.util.*;

public class Main {

  private static PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
  private static Lib l = new Lib();

  /**
   * Reversing Encryption
   * https://codeforces.com/problemset/problem/999/B
   */
  public static void main(String[] args) {

    final int len = l.nextInt();
    final String encrypted = l.nextLine();
    StringBuilder decrypted = new StringBuilder(encrypted);
    for (int i = 2; i <= len; i++) {
      if (len % i == 0) {
        StringBuilder prefix = new StringBuilder(decrypted.subSequence(0, i));
        prefix.reverse();
        decrypted.replace(0, i, prefix.toString());
      }
    }
    out.println(decrypted);

    out.close();
  }

  public static class Lib {
    BufferedReader br;
    StringTokenizer st;

    public Lib() {
      br = new BufferedReader(new InputStreamReader(System.in));
    }

    private String next() {
      while (st == null || !st.hasMoreElements()) {
        try {
          st = new StringTokenizer(br.readLine());
        } catch (IOException e) {
          e.printStackTrace();
        }
      }
      return st.nextToken();
    }

    int nextInt() {
      return Integer.parseInt(next());
    }

    long[] nextLongArr(int size) {
      long[] a = new long[size];
      for (int i = 0; i < size; i++) {
        a[i] = nextInt();
      }
      return a;
    }

    long nextLong() {
      return Long.parseLong(next());
    }

    double nextDouble() {
      return Double.parseDouble(next());
    }

    String nextLine() {
      String str = "";
      try {
        str = br.readLine();
      } catch (IOException e) {
        e.printStackTrace();
      }
      return str;
    }

    void shuffle(long[] arr) {
      int n = arr.length;
      Random rnd = new Random();
      for (int i = 0; i < n; ++i) {
        long tmp = arr[i];
        int randomPos = i + rnd.nextInt(n - i);
        arr[i] = arr[randomPos];
        arr[randomPos] = tmp;
      }
    }

    void sort(long[] arr) {
      // mitigate quicksort's worst case
      shuffle(arr);
      Arrays.sort(arr);
    }
  }
}