Problem:
Score : 300 points

Problem Statement

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

You can perform the following operation on S any number of times:

Operation: Choose two distinct lowercase English letters c_1 and c_2, then replace every occurrence of c_1 with c_2, and every occurrence of c_2 with c_1.

Determine if S and T can be made equal by performing the operation zero or more times.

Constraints

1 \leq |S| \leq 2 \times 10^5

|S| = |T|

S and T consists of lowercase English letters.

Input

Input is given from Standard Input in the following format:

S
T

Output

If S and T can be made equal, print Yes; otherwise, print No.

Sample Input 1

azzel
apple

Sample Output 1

Yes

azzel can be changed to apple, as follows:

Choose e as c_1 and l as c_2. azzel becomes azzle.

Choose z as c_1 and p as c_2. azzle becomes apple.

Sample Input 2

chokudai
redcoder

Sample Output 2

No

No sequences of operation can change chokudai to redcoder.

Sample Input 3

abcdefghijklmnopqrstuvwxyz
ibyhqfrekavclxjstdwgpzmonu

Sample Output 3

Yes

Solution in C# (Mono 4.6.2.0) (judge verdict: Accepted)

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;

class Program
{
    static string S, T;

    public static void Main(string[] args)
    {
        S = Input.NextString();
        T = Input.NextString();

        var CountS = new List<int>[26];
        var CountT = new List<int>[26];

        foreach (var i in Enumerable.Range(0, 26))
        {
            CountS[i] = new List<int>();
            CountT[i] = new List<int>();
        }
        for (int i = 0; i < S.Length; i++)
        {
            CountS[S[i] - 'a'].Add(i);
            CountT[T[i] - 'a'].Add(i);
        }

        var comp = new Comp();

        Array.Sort(CountS, comp);
        Array.Sort(CountT, comp);

        for (int i = 0; i < 26; i++)
        {
            var f = AEquals(CountS[i], CountT[i]);
            if (!f)
            {
                Console.WriteLine("No");
                return;
            }

        }

        Console.WriteLine("Yes");
        return;
    }

    static bool AEquals(List<int> x, List<int> y)
    {
        if (x.Count != y.Count)
            return false;

        for (int i = 0; i < x.Count; i++)
        {
            if (x[i] != y[i])
                return false;
        }

        return true;
    }

    class Comp : IComparer<List<int>>
    {
        public int Compare(List<int> x, List<int> y)
        {
            int ix = 0;
            int iy = 0;

            while (true)
            {
                if (x.Count <= ix && y.Count <= iy)
                    return 0;
                if (x.Count <= ix)
                    return 1;
                if (y.Count <= iy)
                    return -1;

                var cx = x[ix++];
                var cy = y[iy++];
                if (cx != cy)
                    return cx - cy;
            }
        }
    }
}

public static class Input
{
    private static Queue<string> q = new Queue<string>();
    private static void Confirm() { if (q.Count == 0) foreach (var s in Console.ReadLine().Split(' ')) q.Enqueue(s); }
    public static int NextInt() { Confirm(); return int.Parse(q.Dequeue()); }
    public static long NextLong() { Confirm(); return long.Parse(q.Dequeue()); }
    public static string NextString() { Confirm(); return q.Dequeue(); }
    public static double NextDouble() { Confirm(); return double.Parse(q.Dequeue()); }
    public static int[] LineInt() { return Console.ReadLine().Split(' ').Select(int.Parse).ToArray(); }
    public static long[] LineLong() { return Console.ReadLine().Split(' ').Select(long.Parse).ToArray(); }
    public static string[] LineString() { return Console.ReadLine().Split(' ').ToArray(); }
    public static double[] LineDouble() { return Console.ReadLine().Split(' ').Select(double.Parse).ToArray(); }
}