#include <bits/stdc++.h>
using namespace std;

#ifdef YUCHIKIDEBUG
  #define dump(x)  cerr << #x << " = " << (x) << endl;
  #define debug(x) cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" << " " << __FUNCTION__ << endl;
#else
  #define dump(x) ;
  #define debug(x) ;
#endif // YUCHIKIDEBUG

#define int long long
#define pb push_back
#define pf push_front
#define mp make_pair
#define vi vector<int>
#define vvi vector<vi>

#define _overload3(_1,_2,_3,name,...) name
#define _rep(i,n) repi(i,0,n)
#define repi(i,a,b) for(int i=(int)(a);i<(int)(b);++i)
#define rep(...) _overload3(__VA_ARGS__,repi,_rep,)(__VA_ARGS__)
#define _repr(i,n) repir(i,n,0)
#define repir(i,a,b) for(int i=(int)(a);i>=(int)(b);--i)
#define repr(...) _overload3(__VA_ARGS__,repir,_repr,)(__VA_ARGS__)
#define all(x) (x).begin(),(x).end()
#define CINV(x,n) rep(temporary_index,n){int cinvtemp; cin >> cinvtemp; x.push_back(cinvtemp); }
#define READV(x,n) rep(temporary_index,n){int cinvtemp; cin >> cinvtemp; x[temporary_index] = cinvtemp; }
#define READMATRIX(x,m,n) rep(temp_matrix,m){READV(x[temp_matrix],n);}
#define REV(x) reverse(all(x))
#define SORT(x) sort(all(x))

template<class ARG>
inline void put(ARG x) { cout << x << endl; }

inline int sqr(int x) { return x * x; }
inline int sqrti(int x) { return (int) sqrt(x); }
inline vi divisors(int x) {
  vi divs = {1};
  rep (i, 2, x) {
    if (x % i == 0) divs.push_back(i);
  }
  return divs;
}
inline vector<pair<int, int>> divpairs (int x) {
  vector<pair<int, int>> divs;
  rep (i, 1, x + 1) {
    if (x % i == 0) divs.push_back(make_pair (i, x / i));
  }
  return divs;
}

/// return the first i in [lb .. ub) where pred(i) holds.
/// if none of the above i satisfies pred, ub is returned.
template <class Predicate>
inline int bin_search(int lb, int ub, Predicate pred) { // return the first i where pred(i) holds.
  while(lb + 1 < ub) {
    int mid = (lb + ub) / 2;
    if (pred(mid)) {
      ub = mid;
    } else {
      lb = mid;
    }
  }
  return pred(lb) ? lb : ub;
}

inline vector<int> to_digits(int i) {
  vector<int> digits;
  while(i >= 10) {
    digits.push_back(i % 10);
    i /= 10;
  }
  digits.push_back(i);

  reverse(digits.begin(), digits.end());
  return digits;
}

template<class T> using matrix = vector<vector<T>>; 

template<class T>
matrix<T> make_matrix(int R, int C, T value) {
  return matrix<T>(R, vector<T>(C, value));
}

template<class T, class F>
inline vector<T> operator >> (vector<T> &v, F f) {
  return f(v);
}
template<class T, class S, class F>
inline vector<S> map(F f, const vector<T> &v) {
  vector<S> res(v.size());
  transform(v.begin(), v.end(), res.begin, f);
  return res;
}

template<class T, class F>
inline vector<T> filter(F f, const vector<T> &v) {
  vector<T> res;
  copy_if(v.begin(), v.end(), back_inserter(res), f);
  return res;
}

template<class T, class S, class F>
inline S fold(F f, S initial, const vector<T> &v) {
  return accumulate(v.begin(), v.end(), initial, f);
}



const long long MAXN = 1e6;
const long long MOD = 1e9+7;
const long long INF = __LONG_LONG_MAX__ / 2;
const double eps = DBL_MIN * 10;

using address = pair<int, int>;

inline int pow(int i, int n) { return (int)pow(i + eps, n); }


template<class T>
inline T& at(matrix<T> &m, address addr) {
  return m[addr.first][addr.second]; 
}
template<class T>
inline pair<T, T> operator + (pair<T, T> t1, pair<T, T> t2) {
  return make_pair(t1.first + t2.first, t1.second + t2.second);
}

template<class T>
inline pair<T, T> operator - (pair<T, T> t1, pair<T, T> t2) {
  return make_pair(t1.first - t2.first, t1.second - t2.second);
}

template<class T>
inline pair<T, T> operator * (pair<T, T> t1, pair<T, T> t2) {
  return make_pair(t1.first * t2.first, t1.second * t2.second);
}

template<class T>
inline pair<T, T> operator * (T t, pair<T, T> t2) {
  return make_pair(t + t2.first, t+ t2.second);
}

signed main() {
  string s, t;
  cin >> s >> t;
  sort(s.begin(), s.end());
  sort(t.begin(), t.end(), greater<char>());
  if ( s < t ) {
    cout << "Yes" << endl;
  } else {
    cout << "No" << endl;
  }
  return 0;
}


Measured memory_bytes: 256