bcdef
abbbc
 z
y
 reddit
abcdef
 abc
aaa
 y
z
 cbxz
aaaa

bccdb
 z
 dfdeed
 aab
 y
 abac

// includes {{{
#include<iostream>
#include<iomanip>
#include<algorithm>
#include<vector>
#include<stack>
#include<queue>
#include<map>
#include<set>
#include<tuple>
#include<cmath>
#include<random>
#include<cassert>
#include<bitset>
#include<cstdlib>
// #include<deque>
// #include<multiset>
// #include<cstring>
// #include<bits/stdc++.h>
// }}}
using namespace std;
using ll = long long;

// accum1D, range1D, range1Dloop {{{
#include <cassert>
#include <vector>
using loop1d_int = long long;
template < class T >
void accum1D(T &a, int n) {
  for(int i = 1; i < n; i++) a[i] += a[i - 1];
}
template < class T >
void accum1D(std::vector< T > &a) {
  accum1D(a, a.size());
}
template < class T, int N >
void accum1D(T a[N]) {
  accum1D(a, N);
}

template < class T >
auto range1D(const T &a, int l, int r, int n) {
  if(r >= n) r = n - 1;
  auto res(a[r]);
  if(l - 1 >= 0) res -= a[l - 1];
  return res;
}
template < class T >
auto range1D(std::vector< T > &a, int l, int r) {
  return range1D(a, l, r, a.size());
}
template < class T, int N >
auto range1D(T a[N], int l, int r) {
  return range1D(a, l, r, N);
}

template < class T >
auto range1Dloop(const T &a, loop1d_int tl, loop1d_int r, int n) {
  using V = typename std::remove_reference< decltype(a[0]) >::type;
  V res(0);
  if(tl > r) return res;
  assert(n >= 1);
  loop1d_int l = tl % n;
  if(l < 0) l += n;
  r += l - tl;
  loop1d_int gr = r / n;
  if(gr == 0) {
    res += range1D< T >(a, l, r, n);
  } else {
    res += range1D< T >(a, l, n - 1, n);
    res += range1D< T >(a, 0, r % n, n);
    res += range1D< T >(a, 0, n - 1, n) * (gr - 1);
  }
  return res;
}
template < class T >
T range1Dloop(std::vector< T > &a, loop1d_int l, loop1d_int r) {
  return range1Dloop(a, l, r, a.size());
}
template < class T, int N >
T range1Dloop(T a[N], loop1d_int l, loop1d_int r) {
  return range1Dloop(a, l, r, N);
}
// }}}


int main() {
  std::ios::sync_with_stdio(false), std::cin.tie(0);
  string s, t;
  cin >> s >> t;
  int n = s.size();

  // random_device rnd;
  // mt19937 mt(rnd());
  // uniform_int_distribution<int> rd(0, 25);
  // s = t = "";
  // n = 999;
  // for(int i = 0; i < n; i++) s += 'a' + rd(mt);
  // for(int i = 0; i < n; i++) t += 'a' + rd(mt);

  sort(begin(s), end(s));
  sort(rbegin(t), rend(t));

  int n1 = (n + 1) / 2;
  int n2 = n - n1;

  s = s.substr(0, n1);
  t = t.substr(0, n2);

  vector<int> c1(26), c2(26);

  for(auto c : s) c1[c-'a']++;
  for(auto c : t) c2[c-'a']++;

  string ans;

  int sw = 0;
  for(int i = 0; i < n; i++) {
    int sel = -1;
    vector<int> c1sum, c2sum;
    c1sum = c1, c2sum = c2;
    accum1D(c1sum);
    accum1D(c2sum);
    int sw2 = 0;
    for(int k = 0; k < 26; k++) {
      if(!c1[k] and !c2[k]) continue;
      if(c1[k]) {
        c1[k]--;
        sel = k;
        sw2 = 1;
        break;
      } else {
        if(!range1D(c2sum, k + 1, 25)) {
          c2[k]--;
          sel = k;
          break;
        }
      }
      assert(k != 25);
    }
    assert(sel != -1);
    ans += 'a' + (sw ? 25 - sel : sel);

    if(sw2) {
      sw = 1 - sw;
      reverse(begin(c1), end(c1));
      reverse(begin(c2), end(c2));
      swap(c1, c2);
    }
  }

  cout << ans << endl;

  return 0;
}

	  	  	     	 	 		  				  		 	