#include <bits/stdc++.h>
using namespace std;
#define     all(x) x.begin(),x.end()
#define     ff first
#define     ss second
#define     ll long long
#define     ld long double
#define     pb push_back
#define     endl "\n"
#define     MOD 1000000007
#define     INF 1e18
#define     mod 998244353
#define     REP(i,n) for(ll i=0;i<(n);i++)
#define     FOR(i,a,b) for(ll i=(a);i<=(b);i++)
#define     FORD(i,a,b) for(ll i=(a);i>=(b);i--)
#define     BLOCK 555
mt19937     rng(chrono::steady_clock::now().time_since_epoch().count());

typedef     vector <ll> vll;
typedef     vector <pair<ll,ll>> vp;
typedef     vector<vector<ll> >vvll;


/*      author:- Indrajit Sen
        Institution:- Jalpaiguri Government Engineering College
        id:- @Is97, @indra1997
                                                                */
                                                                

                                                            


// log(y) power calculation
ll power_mod(ll x, ll y, ll m){
    ll arr = 1;
    x%=m;
    while(y){
        if(y&1){
            arr=(arr*x)%m;
        }
        y>>=1;
        x=(x*x)%m;
    }
    return arr;
}

ll power(ll x, ll y){
    ll arr = 1;
    while(y){
        if(y&1){
            arr*=x;
        }
        y>>=1;
        x = x*x;
    }
    return arr;
}


ll mod_inv(ll x,ll m){
    return power_mod(x,m-2,m);
}

int randomGenerator(int limit){ 
    
        random_device rd; 
        mt19937 gen(rd()); 
        uniform_int_distribution<> dis(1, limit);

    return dis(gen);
}

// customized hash function for lowering the collision in UNORDERED_MAP
struct custom_hash {
    static uint64_t splitmix64(uint64_t x) {
       
        x += 0x9e3779b97f4a7c15;
        x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
        x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
        return x ^ (x >> 31);
    }
 
    size_t operator()(uint64_t x) const {
        static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
        return splitmix64(x + FIXED_RANDOM);
    }
};
 
 

bool comp(const pair<ll,pair<ll,ll>> &a, const pair<ll,pair<ll,ll>> &b) { 
    if(a.ff == b.ff){

        return (a.second < b.second); 
    }
    return (a.ff < b.ff); 
} 

struct hash_pair { 
    template <class T1, class T2> 
    size_t operator()(const pair<T1, T2>& p) const
    { 
        auto hash1 = hash<T1>{}(p.first); 
        auto hash2 = hash<T2>{}(p.second); 
        return hash1 ^ hash2; 
    } 
};

bool isPalindrome(string s){
    bool flag = true;
    for(int i=0;i<s.length()/2;i++){
        if(s[i]!=s[s.length()-i-1]){
            flag = false;
            break;
        }
    }
    return flag;
}
string s1,s2;
ll n1,n2;
ll dp[3002][3002];

ll recur(ll i1, ll i2){
    if(i1==n1){
        return 0;
    }
    if(i2==n2){
        return 0;
    }
    ll &ans = dp[i1][i2];
    if(ans!=-1){
        return ans;
    }
    if(s1[i1]==s2[i2]){
        ans = 1+recur(i1+1,i2+1);
    }
    else{
        ans = max(recur(i1+1,i2), recur(i1,i2+1));
    }
    return ans;
}

void print_seq(ll i1,ll i2){
    if(i1==n1 or i2==n2){
        return ;
    }
    if(s1[i1]==s2[i2]){
        cout<<s1[i1];
        print_seq(i1+1,i2+1);
    }
    else{
        ll ans = recur(i1,i2);
        if(ans == recur(i1+1,i2)){
            print_seq(i1+1,i2);
        }
        else{
            print_seq(i1,i2+1);
        }
    }
}

void solve(){
    
    cin>>s1>>s2;
    n1 = s1.length();
    n2 = s2.length();
    memset(dp,-1,sizeof(dp));
    ll len = recur(0,0);
    // cout<<len<<endl;
    print_seq(0,0);
}


int main(){
    
    ios_base::sync_with_stdio(false); 
    cin.tie(NULL);

    solve();

    return 0;
}

Measured memory_bytes: 71040