Problem:
Score : 200 points

Problem Statement

You are given string S and T consisting of lowercase English letters.

Determine if S equals T after rotation.

That is, determine if S equals T after the following operation is performed some number of times:

Operation: Let S = S_1 S_2 ... S_{|S|}. Change S to S_{|S|} S_1 S_2 ... S_{|S|-1}.

Here, |X| denotes the length of the string X.

Constraints

2 \leq |S| \leq 100

|S| = |T|

S and T consist of lowercase English letters.

Input

Input is given from Standard Input in the following format:

S
T

Output

If S equals T after rotation, print Yes; if it does not, print No.

Sample Input 1

kyoto
tokyo

Sample Output 1

Yes

In the first operation, kyoto becomes okyot.

In the second operation, okyot becomes tokyo.

Sample Input 2

abc
arc

Sample Output 2

No

abc does not equal arc after any number of operations.

Sample Input 3

aaaaaaaaaaaaaaab
aaaaaaaaaaaaaaab

Sample Output 3

Yes

Solution in Java8 (OpenJDK 1.8.0) (judge verdict: Wrong Answer)

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

public class Main {

  char[] s, t;

  public void input() {
    String str = Console.nextLine();
    s = str.toCharArray();
    str = Console.nextLine();
    t = str.toCharArray();
  }

  public void process() {
    if (s.length == t.length) {
      boolean flag = true;
      for (int i = 0; i < s.length; i++) {
        while (i < s.length && s[i] != t[0]) {
          i++;
        }
        int k = i + 1;
        if (k >= s.length) {
          break;
        }
        for (int j = 1; j < t.length && k != i; j++, k++) {
          if (k == s.length) {
            k = 0;
          }
          if (s[k] != t[j]) {
            flag = false;
          }
        }
        if (flag) {
          System.out.print("Yes");
          return;
        }
      }
    }
    System.out.print("No");
  }

  public static void main(String[] args) {
    new Main().run();
  }

  public void run() {
    input();
    process();
  }

  static class Console {

    private final BufferedReader bf;
    private StringTokenizer tokenizer;
    private static final Console instance;

    static {
      instance = new Console();
    }

    public Console() {
      bf = new BufferedReader(new InputStreamReader(System.in));
    }

    public static String nextLine() {
      try {
        return instance.bf.readLine();
      } catch (IOException e) {
        e.printStackTrace();
        return null;
      }
    }

    public static StringTokenizer nextTokenizer() {
      return new StringTokenizer(nextLine());
    }

    public static String next() {
      if (instance.tokenizer == null || !instance.tokenizer.hasMoreTokens()) {
        instance.tokenizer = nextTokenizer();
      }
      return instance.tokenizer.nextToken();
    }

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

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

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

  }
}