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

bccdb
 z
 dfdeed
 aab
 y
 abac

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Scanner;

public class Tinkoff_C {

  private static final String REGEX = " ";
  private static final Boolean DEBUG = false;
  private static final String FILE_NAME = "input.txt";


  public static void main(String[] args) throws IOException {
    Solver solver = new Solver();
    solver.readData();
    solver.solveAndPrint();
  }

  private static class Solver {

    int[] oleg;
    int[] igor;


    void readData() throws IOException {
      InputStream in = DEBUG ? new FileInputStream(FILE_NAME) : System.in;
      Scanner scanner = new Scanner(in);
      String sOleg = scanner.nextLine();
      String sIgor = scanner.nextLine();
      int n = sOleg.length();
      oleg = new int[26];
      igor = new int[26];
      for (int i = 0; i < n; i++) {
        char cOleg = sOleg.charAt(i);
        oleg[cOleg - 97]++;

        char cIgor = sIgor.charAt(i);
        igor[cIgor - 97]++;
      }
      int olegTurns = n / 2;
      if (n % 2 != 0) olegTurns++;
      update(olegTurns, oleg, true);

      int igorTurns = n / 2;
      update(igorTurns, igor, false);

      StringBuilder builder = new StringBuilder();
      boolean olegsTurn = true;
      char curOleg = 0;
      for (int i = 0; i < 26; i++) {
        if (oleg[i] > 0) {
          curOleg = ((char) i);
          break;
        }
      }
      char maxOleg = 0;
      for (int i = 25; i >= 0; i--) {
        if (oleg[i] > 0) {
          maxOleg = ((char) i);
          break;
        }
      }

      char curIgor = 25;
      for (int i = 25; i >= 0; i--) {
        if (igor[i] > 0) {
          curIgor = ((char) i);
          break;
        }
      }

      char minIgor = 0;
      for (int i = 0; i < 26; i++) {
        if (igor[i] > 0) {
          minIgor = ((char) i);
          break;
        }
      }
      boolean poddavki = curOleg >= curIgor;
      if (poddavki){
        curOleg = maxOleg;
        curIgor = minIgor;
      }

      char[] result = new char[n];
      int min = 0;
      int max = n - 1;
      int oT = 0;
      int iT = 0;
      for (int i = 0; i < n; i++) {
        if (olegsTurn) {
          char next = ((char) (curOleg + 97));
          int index;
          if (poddavki) {
            index = max--;
          }  else {
            index = min++;
          }
          result[index] = next;
          oleg[curOleg]--;
          oT++;
          if (oT <  olegTurns){
            if (poddavki) {
              curOleg = getNextIndex(oleg, curOleg, false);
            } else {
              curOleg = getNextIndex(oleg, curOleg, true);
            }
          }
        } else {
          char next = ((char) (curIgor + 97));
          int index;
          if (poddavki) {
            index = max--;
          }  else {
            index = min++;
          }
          result[index] = next;
          igor[curIgor]--;
          iT++;
          if (iT < igorTurns) {
            if (poddavki) {
              curIgor = getNextIndex(igor, curIgor, true);
            } else {
              curIgor = getNextIndex(igor, curIgor, false);
            }
          }
        }
        if (!poddavki && curOleg >= curIgor){
          poddavki = true;
          curOleg = maxOleg;
          curIgor = minIgor;
        }
        olegsTurn = !olegsTurn;
      }
      for (char c : result) {
        builder.append(c);
//        builder.append(' ');
      }
      System.out.println(builder);
    }

    private void update(int turns, int[] arr, boolean forward) {
      int c = 0;
      boolean zero = false;
      if (forward) {
        for (int i = 0; i < 26; i++) {
          if (zero) {
            arr[i] = 0;
            continue;
          }
          if (c + arr[i] >= turns) {
            arr[i] = turns - c;
            zero = true;
          } else {
            c += arr[i];
          }
        }
      } else {
        for (int i = 25; i >= 0; i--) {
          if (zero) {
            arr[i] = 0;
            continue;
          }
          if (c + arr[i] >= turns) {
            arr[i] = turns - c;
            zero = true;
          } else {
            c += arr[i];
          }
        }
      }
    }

    char getNextIndex(int[] array, char currentIndex, boolean forward) {
      while (array[currentIndex] == 0) {
        int a = forward ? +1 : -1;
        currentIndex += a;
      }
      return currentIndex;
    }

    void solveAndPrint() {

    }


    @SuppressWarnings("SameParameterValue")
    int[] splitInteger(String string, int n) {
      final String[] split = string.split(REGEX, n);
      int[] result = new int[split.length];
      for (int i = 0; i < n; ++i) {
        result[i] = Integer.parseInt(split[i]);
      }
      return result;
    }

    public int[] splitInteger(String string) {
      return splitInteger(string, 0);
    }


    @SuppressWarnings("SameParameterValue")
    long[] splitLong(String string, int n) {
      final String[] split = string.split(REGEX, n);
      long[] result = new long[split.length];
      for (int i = 0; i < n; ++i) {
        result[i] = Long.parseLong(split[i]);
      }
      return result;
    }

    public long[] splitLong(String string) {
      return splitLong(string, 0);
    }

    @SuppressWarnings("SameParameterValue")
    double[] splitDouble(String string, int n) {
      final String[] split = string.split(REGEX, n);
      double[] result = new double[split.length];
      for (int i = 0; i < n; ++i) {
        result[i] = Double.parseDouble(split[i]);
      }
      return result;
    }

    public double[] splitDouble(String string) {
      return splitDouble(string, 0);
    }

    @SuppressWarnings("SameParameterValue")
    String[] splitString(String string, int n) {
      return string.split(REGEX, n);
    }

    public String[] splitString(String string) {
      return splitString(string, 0);
    }

    public int max(int a, int b) {
      return Math.max(a, b);
    }

    public long max(long a, long b) {
      return Math.max(a, b);
    }

    public int min(int a, int b) {
      return Math.min(a, b);
    }

    public long min(long a, long b) {
      return Math.min(a, b);
    }

    public double max(double a, double b) {
      return Math.max(a, b);
    }

    public double min(double a, double b) {
      return Math.min(a, b);
    }

  }


}
