int G[N][N];
for (int i = 1; i <= m; ++i) {
    int a, b;
    cin >> a >> b;
    G[a][b] = 1;
    // G[b][a] = 1;
}

for (int i = 1; i <= m; ++i) {
    int a, b, w;
    cin >> a >> b >> w;
    G[a][b] = w;
    // G[b][a] = w;
}

vector<int> v[N];
for (int i = 0; i < m; ++i) {
    int a, b;
    cin >> a >> b;
    v[a].push_back(b);
}

vector<pair<int,int>> v[N];
for (int i = 0; i < m; ++i) {
    int a, b, w;
    cin >> a >> b >> w;
    v[a].push_back(make_pair(b, w));
    v[b].push_back(make_pair(a, w));
}

bool visited[N];
vector<int> v[N];

void dfs(int x) {
    visited[x] = 1;
    for (auto i : v[x]) if (!visited[i]) {
    	// do something
        dfs(i);
    }
}

bool visited[N];
int color[N];
vector<int> v[N];

void dfs(int x, int color) {
    vistited[x] = 1;
    col[x] = color;
    bool ok = 1;
    for (auto i:v[x]) {
        if (!visited[i]) dfs(i, 1 - color);
    }
}
//最後統計color為1 與為 0各有多少
//比較多的就是答案

vector<int> v[N];
bool visited[N];
queue<int> q;

q.push(1);
visited[1] = 1;
while (q.size()) {
    int u = q.front();
    q.pop();
    for (auto i:v[u]) if (!visited[i]) {
    	visited[i] = 1;
        q.push(i);
    }
}

int dis[N];

queue<int> q;
q.push(1);
dis[1] = 0;
visited[1] = 1;
while (q.size()) {
    int u = q.front();
    q.pop();
    for (auto i:v[u]) if (!visited[i]) {
    	visited[i] = 1;
        dis[i] = dis[u] + 1;
        q.push(i);
    }
}

int dis[N];

queue<int> q;
q.push(1);
dis[1] = 0;
visited[1] = 1;
while (q.size()) {
    int u = q.top();
    q.pop();
    for (auto i:v[u]) if (!visited[i]) {
    	visited[i] = 1;
        dis[i] = dis[u] + x;
        q.push(i);
    }
}

#define mk make_pair
using pi = pair<int,int>;
priority_queue<pi, vector<pi>, greater<pi>> pq;

for (int i = 2; i <= n; ++i) d[i] = 1e9;
pq.push(mk(0, 1)); //

while( pq.size() ) {
    pi u = pq.top();
    pq.pop();
    if (d[u.second] != u.first) continue;
    
    for (auto i:v[u.second]) {
    	if (d[i.first] > u.first + i.second) {
            d[i.first] = u.first + i.second;
            pq.push(mk( d[i.first], i.first ));
        }
    }
}

bool inque[N];

queue<int> q;
q.push(1);
inque[1] = 1;

while( q.size() ) {
    int u = q.front();
    q.pop();
    inque[u] = 0;
    
    for (auto i:v[u]) if ( d[i.first] > d[u] + i.second ) {
        d[i.first] = d[u] + i.second;
        if ( !inque[i.first] ) {
            inque[i.first] = 1;
            q.push(i.first);
        }
    }
}

int cnt[N];

bool SPFA() {
    while( q.size() ) {
        int u = q.front();
        q.pop();
        inque[u] = 0;

        for (auto i:v[u]) if ( d[i.first] > d[u] + i.second ) {
            if ( ++cnt[i.first] >= n ) return false;
            d[i.first] = d[u] + i.second;
            if ( !inque[i.first] ) {
                inque[i.first] = 1;
                q.push(i.first);
            }
        }
        return true;
    }
}
	

for (int i = 1; i <= n; ++i)
    for (int j = 1; j <= n; ++j) {
    	if (G[i][j] == 0) dp[i][j] = 1e9;
        else dp[i][j] = G[i][j];
    }

for (int k = 1; k <= n; ++k)
    for (int i = 1; i <= n; ++i)
    	for (int j = 1; j <= n; ++j)
            dp[i][j] = min( 
            	dp[i][j], 
                dp[i][k] + dp[k][j] 
            );

void dfs(int x, int p) {
    cout << x << endl;
    dfs(l[x], x);
    dfs(r[x], x);
}

void dfs(int x, int p) {
    dfs(l[x], x);
    cout << x << endl;
    dfs(r[x], x);
}

void dfs(int x, int p) {
    dfs(l[x], x);
    dfs(r[x], x);
    cout << x << endl;
}

queue<int> q;
q.push(1);
while(q.size()) {
    int u = q.front();
    q.pop();
    cout << u << endl;
    q.push(l[u]);
    q.push(r[u]);
}

cin >> input;
sort(input.begin(), input.end());
cout << input;

#define mk make_pair
#define F first
#define S second
vector<pair<int, pair<int,int>>>G;
for (int i = 1; i <= m; ++i) {
    int a, b, w;
    cin >> a >> b >> w;
    G.pb(mk(w, mk(a, b)));
}
sort(G.begin(), G.end());
for (auto i:G) if (!same(i.S.F, i.S.S)) {
    unite(i.S.F, i.S.S);
    ans += i.F;
}

inline int prim() {
    int ans = 0;
    visited[1] = 1;
    pq.push(make_pair(0, 1));
    while (pq.size()) {
        pi u = pq.top();
        pq.pop();
        if (visited[u.second]) continue;
        visited[u.second] = 1;
        ans += u.first;
        for (auto i:v[u.second]) {
            pq.push(i.second , i.first);
            // second代 表 邊 權、 first代 表 連 到 的 點
        }
    }
    return ans;
}

int n, m, deg[1000009];
vector <int> s, ans, v[1000009], u[1000009];
//u是相反的邊
vector <int> TopologicalSort() {
    for (int i = 1; i <= n; ++i) {
        if (deg[i] == 0) s.push_back(i);
        deg[i] = v[i].size();
    }
    while (s.size()) {
        ans.push_back(s.back());
        s.pop_back();

        for (auto i:u[ans.back()]) {
            deg[i]--;
            if (!deg[i]) s.push_back(i);
        }
    }
    return ans;
}

vector <int> v[1000009];
bitset <1000009> visited;
int col[1000009];

inline bool dfs(int x, int color) {
    bool isBip = 1;
    col[x] = color;
    visited[x] = 1;
    for (auto i:v[x]) {
        if (visited[i] && col[i] == col[x]) return false;
        if (!visited[i]) isBip &= dfs(i, color^1);
    }
    return isBip;
}

vector<int> v[N];
int cnt = 0;
// n 是點數
for (int i = 1; i <= n; ++i) {
    cnt += (v[i].size() % 2);
}
if (cnt == 2) cout << "歐拉路徑";
else if (cnt == 0) cout << "歐拉迴路";
else cout << "NO";

set<pair<int,int>> k;
vector<int> v[N];
void dfs(int x)
{
    for(auto i:v[x]) if(k.find({i,x}) != k.end())
    {
        k.erase(k.find({i,x}));
        k.erase(k.find({x,i}));
        dfs(i);
    }
    ans.push_back(x);
}

set<int> s[N];
set<pair<int,int>> k;

void dfs(int x) {
    for(auto i:s[x]) if(k.find({i, x}) != k.end()) {
        k.erase(k.find({i,x}));
        k.erase(k.find({x,i}));
        dfs(i);
    }
    ans.push_back(x);
}

vector<int> g[N];
int ve, leng;

void dfs(int x, int p, int s) {
    for(auto i : g[x]) {
        if(i.first == p) continue;
        dfs(i.first, x, s + i.second);
    }
    if( leng < s ) {
        ve = x;
        leng = s;
    }
}

dfs(1, -1, 0);
leng = -1;
dfs(ve, -1, 0);
cout << leng << '\n';

for(int i = 0; i < m; i++) {
    cin >> a >> b;
    g[a][b] = 1;
}
for(int k = 1; k <= n; k++)
    for(int i = 1; i <= n; i++)
        for(int j = 1; j <= n; j++)
            g[i][j] = min(g[i][j],g[i][k]+g[k][j]);
            
int ans = INF;
for(int i = 1; i <= n; i++) ans = min(ans,g[i][i]);
if(ans == INF) cout << 0 << '\n';
else cout << ans << '\n';

void solve(string a, string b) {
	int x = find(b.begin(), b.end(), a[0]) - b.begin();
	int y = int(b.size())-x-1;
	if(x > 0) solve(a.substr(1, x), b.substr(0, x));
	if(y > 0) solve(a.substr(x + 1, y), b.substr(x + 1, y));
	cout << a[0]; //根
}

signed main() {
	string a, b;
	while(cin >> a >> b) {
		solve(a, b);
		cout << '\n';
	}
	return 0;
}

int dis[N];

queue<int> q;
q.push(1);
dis[1] = 0;

while (q.size()) {
    int u = q.front();
    q.pop();
    for (auto i:v[u]) if (!visited[i]) {
    	visited[i] = 1;
        dis[i] = dis[u] + 1;
        q.push(i);
    }
}

int dis[N];
deque<int> d;
d.push_back(1);
dis[1] = 0;

while (q.size()) {
    int u = d.front();
    d.pop_front();
    for (auto i:v[u]) {
        if (visited[i]) continue;
        visited[i] = 1;
        if (i.second == 1) {
            d.push_back(i.first);
            dis[i.first] = dis[u] + 1;
        } else {
            d.push_front(i.first);
            dis[i.first] = dis[u];
        }
    }
}