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

bccdb
 z
 dfdeed
 aab
 y
 abac

import javax.print.attribute.standard.MediaPrintableArea;
import java.io.*;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.math.RoundingMode;
import java.util.*;

/**
 * Created by Firеfly on 1/1/2017.
 */
public class Task {
    public static void main(String[] args) throws IOException {
        Emaxx emaxx = new Emaxx();
    }
}


class Emaxx {
    FScanner fs;
    PrintWriter pw;
    int n, m;
    ArrayList<Integer>[] graph;
    int[] comp;
    LinkedList<Pair> qoue;
    Emaxx() throws IOException {
        fs = new FScanner(new InputStreamReader(System.in));
        // pw = new PrintWriter(new FileWriter("arithnumbers.out"));
        //  fs = new FScanner(new FileReader("C:\\Users\\Firеfly\\Desktop\\New Text Document.txt"));
        //     fs = new FScanner(new FileReader("input.txt"));;
        //       pw = new PrintWriter("output.txt");
        PrintWriter pw = new PrintWriter(System.out);
        char[] mas11 = fs.nextLine().toCharArray();
        char[] mas22 = fs.nextLine().toCharArray();
        char[] mas = new char[mas11.length];
        int n = mas11.length;
        ArrayList<Character> mas1 = new ArrayList<>(), mas2 = new ArrayList<>();
        for (int i = 0; i<n; i++)
        {
            mas1.add(mas11[i]);
            mas2.add(mas22[i]);
        }
        Collections.sort(mas1, new Comparator<Character>() {
            @Override
            public int compare(Character o1, Character o2) {
                return Integer.compare((char) o1, (char) o2);
            }
        });
        Collections.sort(mas2, new Comparator<Character>() {
            @Override
            public int compare(Character o1, Character o2) {
                return Integer.compare((char) o1, (char) o2);
            }
        });
        int f = 0;
        int l = mas11.length-1;
        int dead = mas11.length/2;
        int g = 0;
        int p = n-1;
        for (int i = 0; i<n; i++) {
            if (mas1.get(f)<mas2.get(l) || (p-g)%2 == 0) {
                mas[g++] = mas1.get(f);
            } else {
                mas[p--] = mas1.get(f);
            }
            if (f == dead)
                break;
            f++;
            if (mas2.get(l)>mas1.get(f) || (p-g)%2 == 0) {
                mas[g++] = mas2.get(l);
                            } else {
                mas[p--] = mas2.get(l);
                            }

            if (l == dead)
                break;
            l--;
        }
        for (int i = 0; i<n; i++)
            pw.print(mas[i]);
        pw.close();
    }

    double round(double number, int scale) {
        int pow = 10;
        for (int i = 1; i < scale; i++)
            pow *= 10;
        double tmp = number * pow;
        return (double) (int) ((tmp - (int) tmp) >= 0.5 ? tmp + 1 : tmp) / pow;
    }

    int gcd(int a, int b) {
        if (b == 0)
            return a;
        else return gcd(b, a%b);
    }
}
class Tree1 {
    int[] t;
    int n;
    Tree1(ArrayList<Pair> a) {
        n = a.size();
        t = new int[n*4];
        build(a, 1, 0, n-1);
    }
    void build (ArrayList<Pair> a, int v, int tl, int tr) {
        if (tl == tr)
            t[v] = a.get(tl).x;
        else {
            int tm = (tl + tr) / 2;
            build (a, v*2, tl, tm);
            build (a, v*2+1, tm+1, tr);
            t[v] = Math.max(t[v*2], t[v*2+1]);
        }
    }
    int sum (int v, int tl, int tr, int l, int r) {
        if (l > r)
            return 0;
        if (l == tl && r == tr)
            return t[v];
        int tm = (tl + tr) / 2;
        return Math.max(sum (v*2, tl, tm, l, Math.min(r,tm))
                , sum (v*2+1, tm+1, tr, Math.max(l,tm+1), r));
    }
    void update (int v, int tl, int tr, int pos, int new_val) {
        if (tl == tr)
            t[v] = new_val;
        else {
            int tm = (tl + tr) / 2;
            if (pos <= tm)
                update (v*2, tl, tm, pos, new_val);
            else
                update (v*2+1, tm+1, tr, pos, new_val);
            t[v] = Math.max(t[v*2], t[v*2+1]);
        }
    }

}
class FScanner {
    BufferedReader br;
    StringTokenizer st;
    FScanner(InputStreamReader isr) {
        br = new BufferedReader(isr);
    }

    FScanner(FileReader fr) {
        br = new BufferedReader(fr);
    }

    String nextToken() throws IOException{
        while (st == null || !st.hasMoreTokens()) {
            String s = br.readLine();
            if (s == null)
                return null;
            st = new StringTokenizer(s);
        }
        return st.nextToken();
    }

    int nextInt() throws IOException {
        return Integer.parseInt(nextToken());
    }

    long nextLong() throws IOException {
        return Long.parseLong(nextToken());
    }

    double nextDouble() throws IOException {
        return Double.parseDouble(nextToken());
    }

    String nextLine() throws IOException {
        return br.readLine();
    }

    char nextChar() throws IOException {
        return (char) br.read();
    }
}

class Pair implements Comparable<Pair>{
    int x, y;
    boolean used;
    Pair(int x1, int y1) {x = x1; y = y1;}

    @Override
    public int compareTo(Pair o) {
        return Integer.compare(y, o.y);
    }
}