#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>

#define SIZE 10000
#define MAXDEG 4

/* Parameter:
   - N: Anzahl der Knoten im Graph (numeriert von 0 bis N-1)
   - g: Der Graph: Fuer jeden Knoten (maximal SIZE Stueck) folgt
        eine Liste der Knoten, die ueber eine direkte Verbindung zu
	erreichen sind. Die Liste wird durch -1 abgeschlossen, d.h.
	jeder Knoten kann hier nur MAXDEG-1 direkte Nachbarn haben.
   - dist: Hier wird fuer jeden Knoten die Entfernung von Knoten 0
           zurueckgeliefert. -1 entspricht einem nicht von 0 aus
	   erreichbaren Knoten.
   - src: Hier wird fuer jeden Knoten der Vorgaengerknoten auf dem
        kuerzesten Weg von 0 zum Knoten selbst zurueckgeliefert.
	0 und von 0 aus nicht erreichbare Knoten haben den Vorgaenger -1.
 */

void BFS (int N, int g[SIZE][MAXDEG], int dist[SIZE], int src[SIZE])
{
	int q[SIZE];
	int front=0, tail=0;
	int x;
	assert (N <= SIZE);
	assert (0 < N);
	/* dist und src initialisieren. */
	for (x=0; x<N; ++x) {
		dist[x] = -1;
		src[x] = -1;
	}
	/* Knoten Null (mit Abstand 0) in die Queue packen. */
	q[tail++] = 0;
	dist[0] = 0;
	/* Solange iterieren, wie es noch Knoten gibt, die nicht ausgewaehlt
	 * wurden: */
	while (front < tail) {
		/* Den naechsten Knoten (vorne aus der Queue) auswaehlen */
		int t = q[front++];
		assert (dist[t] >= 0);
		/* Die Nachbarn des ausgewaehlten Knoten durchehen. */
		for (x=0; g[t][x] >= 0; ++x) {
			/* Von t (dem ausgewaehlten Knoten) geht eine
			 * direkte Verbindung zu dst. */
			int dst = g[t][x];
			if (dist[dst] >= 0)
				continue;
			/* Knoten dst noch nicht entdeckt: Abstand
			 * zuweisen und hinten in die Queue packen. */
			dist[dst] = dist[t]+1;
			assert (tail < SIZE);
			q[tail++] = dst;
			/* dst wurde von t aus entdeckt. */
			src[dst] = t;
		}
	}
}

int g[SIZE][MAXDEG];
int dist[SIZE];
int src[SIZE];

/* i1 (x-Richtung im Rechteck) und i2 (y-Richtung) in eine
 * Knotennummer umrechnen. */
#define COMBINE(I1,I2) ((I2)*n1+(I1))
/* Und die Rueckrichtung. */
#define I1(X) ((X)%n1)
#define I2(X) ((X)/n1)

/* Den String str umdrehen ABC => CBA */
void reverse (char * str)
{
	int i=0, j=strlen(str)-1;
	while (i < j) {
		char tmp = str[i];
		str[i] = str[j];
		str[j] = tmp;
		i++;
		j--;
	}
}

int main ()
{
	char s1[100];
	char s2[100];
	char scs[200];
	char lcs[200];
	int n1, n2, N;
	int i1, i2;
	int cur;
	int i, kscs, klcs;
	if (scanf ("%s %s", s1, s2) != 2) {
		fprintf (stderr, "Bad input\n");
		return 1;
	}
	n1 = 1+strlen (s1);
	n2 = 1+strlen (s2);
	N = n1*n2;
	/* Graph aufbauen */
	for (i=0; i<N; ++i) {
		int i1 = I1(i);
		int i2 = I2(i);
		int k=0;
		if ((i1+1 < n1) && (i2+1 < n2) && (s1[i1] == s2[i2])) {
			g[i][k++] = COMBINE(i1+1,i2+1);
		}
		if (i2+1 < n2) {
			g[i][k++] = COMBINE(i1,i2+1);
		}
		if (i1+1 < n1) {
			g[i][k++] = COMBINE(i1+1,i2);
		}
		g[i][k] = -1;
	}
	/* Breitensuche durchfuehren. */
	BFS(N,g,dist,src);
	/* Weg von 0 zu N-1 rekonstruieren. */
	cur = N-1;
	i1 = I1(cur);
	i2 = I2(cur);
	kscs = 0;
	klcs = 0;
	while (src[cur] >= 0) {
		int ni1 = I1(src[cur]);
		int ni2 = I2(src[cur]);
		if (i1 > ni1) {
			scs[kscs++] = s1[ni1];
			if (i2 > ni2) {
				lcs[klcs++] = s1[ni1];
			}
		} else {
			scs[kscs++] = s2[ni2];
		}
		cur = src[cur];
		i1 = ni1;
		i2 = ni2;
	}
	scs[kscs] = 0;
	lcs[klcs] = 0;
	reverse (scs);
	reverse (lcs);
	printf ("%s %s\n", scs, lcs);
	return 0;
}