using System;
using System.Text;
using System.Linq;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Numerics;
using static System.Console;
using static System.Math;

namespace AtCoder
{
    public class Program
    {
        const bool IsTest = false;

        const string t1 = "azzel\napple";
        const string t2 = "chokudai\nredcoder";
        const string t3 = "abcdefghijklmnopqrstuvwxyz\nibyhqfrekavclxjstdwgpzmonu";
        const string t4 = "8 9 10\n4 5 6";
        const string t5 = "11 12 13\n4 5 6";

        public static void Main(string[] args)
        {
            if (!IsTest) {
                new Program().Solve(new ConsoleInput(Console.In));
            } else {
                new Program().Solve(new ConsoleInput(new StringReader(t1)));
                new Program().Solve(new ConsoleInput(new StringReader(t2)));
                new Program().Solve(new ConsoleInput(new StringReader(t3)));
            }
        }

        public void Solve(ConsoleInput cin)
        {
            cin.ReadLine();
            var s = cin.Read<string> ();
            cin.ReadLine();
            var t = cin.Read<string> ();
            var map = new Dictionary<int, int> ();
            var rmap = new Dictionary<int, int> ();
            if (s.Length != t.Length) {
                Console.WriteLine("No");
                return;
            }
            for (var i = 0; i < s.Length; i++) {
                var s0 = s[i];
                var t0 = t[i];
                var d = 0;
                if (map.TryGetValue(s0, out d)) {
                    if (d != t0) {
                        Console.WriteLine("No");
                        return;
                    }
                } else {
                    map[s0] = t0;
                }
                if (rmap.TryGetValue(t0, out d)) {
                    if (d != s0) {
                        Console.WriteLine("No");
                        return;
                    }
                } else {
                    rmap[t0] = s0;
                }
            }
            Console.WriteLine("Yes");
        }
    }

    public class ConsoleInput
    {
        private readonly System.IO.TextReader _stream;
        private readonly char _separator = ' ';
        private string _curLine;
        private string[] _curLineSplitted;
        private int _curItemIndex;
        public ConsoleInput(System.IO.TextReader stream, char separator = ' ')
        {
            this._separator = separator;
            this._stream = stream;
        }
        public T Read<T>()
        {
            var converter = System.ComponentModel.TypeDescriptor.GetConverter(typeof(T));
            if (converter == null) {
                throw new Exception(string.Format("TypeDescriptor.GetConverter {0}", typeof(T).Name));
            }
            return (T)converter.ConvertFromString(ReadString());
        }
        public T[] ReadArray<T>(long N)
        {
            var ret = new T[N];
            for (long i = 0; i < N; i++) {
                ret[i] = Read<T>();
            }
            return ret;
        }
        public Tuple<T> ReadLineAs<T>()
        {
            ReadLine();
            return new Tuple<T>(Read<T>());
        }
        public Tuple<T, S> ReadLineAs<T, S>()
        {
            ReadLine();
            return new Tuple<T, S>(Read<T>(), Read<S>());
        }
        public Tuple<T, S, U> ReadLineAs<T, S, U>()
        {
            ReadLine();
            return new Tuple<T, S, U>(Read<T>(), Read<S>(), Read<U>());
        }
        public Tuple<T, S, U, V> ReadLineAs<T, S, U, V>()
        {
            ReadLine();
            return new Tuple<T, S, U, V>(Read<T>(), Read<S>(), Read<U>(), Read<V>());
        }
        public Tuple<T, S, U, V, R> ReadLineAs<T, S, U, V, R>()
        {
            ReadLine();
            return new Tuple<T, S, U, V, R>(Read<T>(), Read<S>(), Read<U>(), Read<V>(), Read<R>());
        }

        public string ReadString()
        {
            return _curLineSplitted[_curItemIndex++];
        }
        public void ReadLine()
        {
            _curLine = _stream.ReadLine();
            if (_curLine == null) {
                throw new System.Exception("No more lines");
            }
            _curLineSplitted = _curLine.Split(_separator);
            _curItemIndex = 0;
        }
    }
}



Measured memory_bytes: 17504