using System;
using System.Collections.Generic;
using System.Text;
using System.Collections.Generic;
using static System.Math;
using System.Linq;
using static System.Array;
using System.Collections;

namespace DivideChocolate
{
    class Program
    {
        static void Main(string[] args)
        {
            var S = Console.ReadLine();
            var T = Console.ReadLine();

            var flg = true;
            for (int i = 0; i < S.Length; i++)
            {
                if(S[i] != T[i])
                {
                    flg = false;
                    break;
                }
            }
            if (flg)
            {
                Console.WriteLine("Yes");
            }
            else
            {
                Console.WriteLine("No");
                
            }
            
        }

        //static List<string> Solve(string inp,long depth,List<string> tmp,bool[] usen)
        //{
        //    var ans = long.MaxValue;
        //    List<string> ans2 = new List<string>();
        //    if (inp == last)
        //    {
        //        if (depth == 0) tmp.Add(last);
        //        return tmp;
        //    }

        //    for (int i = 0; i < N+1; i++)
        //    {
        //        if (!usen[i])
        //        {
        //            var count = 0;
        //            for (int j = 0; j < inp.Length; j++)
        //            {
        //                if (inp[j] != S[i][j]) count++;
        //            }
        //            if (count == 1)
        //            {
        //                var k = new List<string>(tmp);
        //                k.Add(S[i]);
        //                var c = new bool[N+1];
        //                Array.Copy(usen,c,N+1);
        //                c[i] = true;
        //                var tmp3 = Solve(S[i], depth + 1,k,c);
        //                if (tmp3.Contains(last) && ans > tmp3.Count())
        //                {
        //                    ans = tmp3.Count();
        //                    ans2 = tmp3;
        //                }
                        
        //            }
        //        }
        //    }
        //    return ans2;
        //}

        static void Swap<T>(ref T a, ref T b)
        {
            var tmp = a;
            a = b;
            b = tmp;
        }

    }


    public class PriorityQueue<T> : IEnumerable<T>
    {
        private readonly List<T> _data = new List<T>();
        private readonly IComparer<T> _comparer;
        private readonly bool _isDescending;

        public PriorityQueue(IComparer<T> comparer, bool isDescending = true)
        {
            _comparer = comparer;
            _isDescending = isDescending;
        }

        public PriorityQueue(Comparison<T> comparison, bool isDescending = true)
            : this(Comparer<T>.Create(comparison), isDescending)
        {
        }

        public PriorityQueue(bool isDescending = true)
            : this(Comparer<T>.Default, isDescending)
        {
        }

        public void Enqueue(T item)
        {
            _data.Add(item);
            var childIndex = _data.Count - 1;
            while (childIndex > 0)
            {
                var parentIndex = (childIndex - 1) / 2;
                if (Compare(_data[childIndex], _data[parentIndex]) >= 0)
                    break;
                Swap(childIndex, parentIndex);
                childIndex = parentIndex;
            }
        }

        public T Dequeue()
        {
            var lastIndex = _data.Count - 1;
            var firstItem = _data[0];
            _data[0] = _data[lastIndex];
            _data.RemoveAt(lastIndex--);
            var parentIndex = 0;
            while (true)
            {
                var childIndex = parentIndex * 2 + 1;
                if (childIndex > lastIndex)
                    break;
                var rightChild = childIndex + 1;
                if (rightChild <= lastIndex && Compare(_data[rightChild], _data[childIndex]) < 0)
                    childIndex = rightChild;
                if (Compare(_data[parentIndex], _data[childIndex]) <= 0)
                    break;
                Swap(parentIndex, childIndex);
                parentIndex = childIndex;
            }
            return firstItem;
        }

        public T Peek()
        {
            return _data[0];
        }

        private void Swap(int a, int b)
        {
            var tmp = _data[a];
            _data[a] = _data[b];
            _data[b] = tmp;
        }

        private int Compare(T a, T b)
        {
            return _isDescending ? _comparer.Compare(b, a) : _comparer.Compare(a, b);
        }

        public int Count => _data.Count;

        public IEnumerator<T> GetEnumerator()
        {
            return _data.GetEnumerator();
        }

        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
    }


}


Measured memory_bytes: 25876