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 Rust (1.42.0) (judge verdict: Wrong Answer)

// -*- coding:utf-8-unix -*-

#[macro_use]
extern crate lazy_static;
extern crate num_bigint; // 0.2.2
extern crate num_traits; // 0.2.8
use num_bigint::BigInt;
use num_traits::Pow;
use petgraph::algo::dijkstra;
use petgraph::Directed;

// use proconio::derive_readable;
use proconio::fastout;
use proconio::input;
// use std::convert::TryInto;
use ascii::{AsciiChar, AsciiString};
use itertools::concat;
use lazy_static::lazy_static;
use libm::*;
use petgraph::Graph;
use std::cmp::*;
use std::collections::{BinaryHeap, HashMap, HashSet, VecDeque};
use std::io::*;
use std::ops::Range;
use std::str::FromStr;
use std::sync::Mutex;
use superslice::*;

pub fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char)
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

// lazy_static! {
//     static ref H: Mutex<Vec<i32>> = Mutex::default();
//     static ref W: Mutex<Vec<i32>> = Mutex::default();
// }

//abc079-D
// #[fastout]
fn main() {
    input![s: String, t: String];

    let s = AsciiString::from_str(&s[..]).unwrap();
    let t = AsciiString::from_str(&t[..]).unwrap();

    let mut s_map = HashMap::new();
    let mut t_map = HashMap::new();

    for s_char in s.chars() {
        let e = s_map.entry(s_char).or_insert(0);
        *e += 1;
    }

    for t_char in t.chars() {
        let e = t_map.entry(t_char).or_insert(0);
        *e += 1;
    }

    if s_map.keys().len() == 26 {
        //sortして同じだったらOK
        let mut s: Vec<_> = s.chars().collect();
        let mut t: Vec<_> = t.chars().collect();
        s.sort();
        t.sort();
        if s != t {
            println!("No");
        } else {
            println!("Yes");
        }
        return;
    }

    // let mut s_items: Vec<_> = s_map.iter().collect();
    // let mut t_items: Vec<_> = s_map.iter().collect();

    let alphabets: HashSet<_> = AsciiString::from_str("abcdefghijklmnopqrstuvwxyz")
        .unwrap()
        .chars()
        .collect();

    let s_alphabets: HashSet<_> = s.chars().collect();

    let not_used_alphabets: HashSet<_> = alphabets.difference(&s_alphabets).collect();

    let mut s = s;

    for i in 0..s.len() {
        if s[i] == t[i] {
            continue;
        }

        if not_used_alphabets.contains(&t[i]) {
            s[i] = t[i];
        }
    }

    let mut s: Vec<_> = s.chars().collect();
    let mut t: Vec<_> = t.chars().collect();
    s.sort();
    t.sort();
    if s != t {
        println!("No");
    } else {
        println!("Yes");
    }
    return;

    // println!("{}", ans);
}

// let mut values = VALUES.lock().unwrap();
// values.extend_from_slice(&[1, 2, 3, 4]);
// assert_eq!(&*values, &[1, 2, 3, 4]);