#include<bits/stdc++.h>
using namespace std;
bool st;
namespace _wrk{;
ostream& operator<<(ostream &w,__int128 p){
	static char buf[45];
	auto *c=buf;
	if(p<0){
		w<<'-';
		p=-p;
	}
	if(p==0){
		w<<'0';
	}else{
		while(p){
			(*c++)=(p%10+'0');
			p/=10;
		}
		c--;
		while(1){
			w<<(*c);
			if(c==buf)break;
			c--;
		}
	}
	return w;
}
istream& operator>>(istream &w,__int128 &p){
	static bool mask;
	mask=0;
	while(isspace(w.peek())){
		w.get();
	}
	if(w.peek()=='-'){
		mask=1;
		w.get();
		if(!isdigit(w.peek())){
			w.putback('-');
			return w;
		}
	}
	p=0;
	while(isdigit(w.peek())){
		char c=w.get();
		p=p*10+(c-'0');
	}
	if(mask)p=-p;
	return w;
}
template<int mod>
struct modint{
	int num;
	const static __uint128_t brt=((__uint128_t)(1)<<(64))/mod;
	modint(){
		num=0;
	}
	modint(int x){
		num=x%mod;
	}
	modint(long long x){
		num=x%mod;
	}
	modint<mod>operator=(int x){
		num=x%mod;
		return (*this);
	}
	modint<mod>operator=(long long x){
		num=x%mod;
		return (*this);
	}
	modint<mod>operator=(modint<mod>x){
		num=x.num;
		return (*this);
	}
	modint<mod> operator+(modint<mod> c)const{
		long long x=num+c.num;
		return x>=mod?x-mod:x;
	}
	modint<mod> operator-(modint<mod> c)const{
		long long x=num-c.num;
		return x<0?x+mod:x;
	}
	modint<mod>operator*(modint<mod>c)const{
		long long x=(long long)num*c.num;
		x=x-mod*(brt*x>>64);
		while(x>=mod)x-=mod;
		return x;
	}
	modint<mod>fpof(long long x)const{
		if(x<0)return inv().fpof(-x);
		if(x==0)return 1;
		auto c=((*this)*(*this)).fpof(x/2);
		if(x&1)return c*(*this);
		else return c;
	}
	struct modint_pow{
		int pf;
		modint_pow(int x){
			pf=x;
		}
		modint_pow(modint<mod> x){
			pf=x.num;
		}
		modint_pow operator+(modint_pow x){
			return pf+x.pf;
		}
	};
	modint_pow operator*(){
		return modint_pow(num);
	}
	modint<mod> operator*(modint_pow x){
		return (*this).fpof(x.pf);
	}
	modint<mod>inv()const{
		return fpof(mod-2);
	}
	modint<mod>operator/(modint<mod>c){
		return (*this)*c.inv();
	}
	operator int(){
		return num;
	}

	modint<mod>operator+=(modint<mod> c){
		return (*this)=(*this)+c;
	}
	modint<mod>operator-=(modint<mod> c){
		return (*this)=(*this)-c;
	}
	modint<mod>operator*=(modint<mod> c){
		return (*this)=(*this)*c;
	}
	modint<mod>operator/=(modint<mod> c){
		return (*this)=(*this)/c;
	}
	modint<mod>operator-(){
		return mod-num;
	}
	friend ostream& operator<<(ostream &w,modint<mod>&&x){
		w<<x.num;
		return w;
	}
	friend istream& operator>>(istream &w,modint<mod>&x){
		w>>x.num;
		x.num%=mod;
		return w;

	}
	bool operator==(modint<mod>x){
		return num==x.num;
	}

};

#define int long long

template<class type,int N>
struct matrix{
	type a[N+2][N+2];
	int n;
	type* operator[](int pos){
		return a[pos];
	}
	matrix<type,N> operator*(matrix<type,N>b){
		matrix<type,N>ans;
		ans.n=n;
		for(int i=1;i<=n;i++){
			for(int j=1;j<=n;j++){
				for(int k=1;k<=n;k++){
					ans[i][j]+=a[i][k]*b[k][j];
				}
			}
		}
		return ans;
	}
};
template<class type>
type fp(type a,int b){
	if(b==0)return type();
	if(b==1)return a;
	type w=fp(a*a,b/2);
	if(b%2)return w*a;
	return w;
}
template<int N>
struct yw_int_array{
	struct three21bit{
		int a:21;
		int b:21;
		int c:21;
	}a[N/3+2];
	struct ref{
		three21bit& s;
		char type;
		operator int(){
			if(type==0)return s.a;
			if(type==1)return s.b;
			return s.c;
		}
		ref& operator=(int x){
			if(type==0)s.a=x;
			else if(type==1)s.b=x;
			else s.c=x;
			return (*this);
		}
	};
	ref operator[](int pos){
		char w=pos%3;
		return {a[pos/3],(char)w};
	}
};
template<class type,int N>
struct backup_array{
	type name[N+5];
	vector<vector<pair<int,int>>>cc;
	void new_array(){
		cc.push_back(vector<pair<int,int>>());
	}
	backup_array(){
		cc.resize(1);
	}
	struct x{
		int id;
		type* name;
		vector<vector<pair<int,int>>> &cc;
		operator type(){
			return name[id];
		}
		type operator=(type w){
			cc.back().push_back({id,name[id]});
			name[id]=w;
			return w;
		}
	};
	x operator[](int pos){
		return {pos,name,cc};
	}
	void backup(){
		reverse(cc.back().begin(),cc.back().end());
		for(auto &x:cc.back()){
			name[x.first]=x.second;
		}
		cc.pop_back();
	}
};
template<class type,int N>
struct Math{
	type jc[N+5],inv[N+5],invjc[N+5];
	Math(){
		jc[0]=jc[1]=inv[1]=invjc[1]=invjc[0]=1;
		for(int i=2;i<=N;i++){
			jc[i]=jc[i-1]*type(i);
		}
		invjc[N]=type(1)/jc[N];
		for(int i=N-1;i>=2;i--){
			invjc[i]=invjc[i+1]*type(i+1);
		}
		for(int i=1;i<=N;i++){
			inv[i]=invjc[i]*jc[i-1];
		}
	}
	type binom(int a,int b){
		return jc[a]*invjc[b]*invjc[a-b];
	}
	type catalan(int n){
		return binom(2*n,n)/type(n+1);
	}
};
template<class type,int num,int maxnum>
struct pows{
	type w[maxnum+5];
	pows(){
		w[0]=type(1);
		for(int i=1;i<=maxnum;i++)w[i]=w[i-1]*type(num);
	}
	type operator[](int pos){
		return w[pos];
	}
};
namespace hashing{
	constexpr static int N=5000006;//5e6
	constexpr static int count=1;
	constexpr static int mods[count]={1000000007};
	constexpr static int bases[count]={37};
	constexpr static char start='a';
	int hash_base[count][N+5];
	void init(){
		for(int i=0;i<count;i++){
			hash_base[i][0]=1;
			for(int j=1;j<=N+2;j++){
				hash_base[i][j]=hash_base[i][j-1]*bases[i]%mods[i];
			}
		}
	}
	struct hash{
		int size;
		int has[count];
	};
	bool operator==(const hash&a,const hash&b){
		if(a.size!=b.size)return 0;
		for(int i=0;i<count;i++){
			if(a.has[i]!=b.has[i])return 0;
		}
		return 1;
	}
	hash operator+(const hash&a,const hash&b){
		hash res;
		res.size=a.size+b.size;
		for(int i=0;i<count;i++){
			res.has[i]=(a.has[i]*hash_base[i][b.size]%mods[i]+b.has[i])%mods[i];
		}
		return res;
	}
	hash operator*(const hash&a,int b){
		if(!b)return {};
		if(b==1)return a;
		auto c=(a+a)*(b/2);
		if(b&1)return c+a;
		return c;
	}
	struct hashing_base{
		int p[count][N+5];
		int n;
		void init(const string&c,int l,int r){
			n=r-l+1;
			for(int i=0;i<count;i++){
				int cnt=1;
				for(int j=l;j<=r;j++){
					p[i][cnt]=(p[i][cnt-1]*bases[i]+(c[j]-'a'))%mods[i];
					cnt++;
				}
			}
		}
		void init(const string&c){
			init(c,0,(int)c.size()-1);
		}
		hash substr(int l,int r){
			hash res;
			res.size=r-l+1;
			for(int i=0;i<count;i++){
				res.has[i]=(p[i][r]-p[i][l-1]*hash_base[i][r-l+1]%mods[i]+mods[i])%mods[i];
			}
			return res;
		}
		hash operator[](int pos){
			return substr(pos,pos);
		}
		hash operator[](pair<int,int>pos){
			return substr(pos.first,pos.second);
		}
	};

};
#ifdef use_seg_tree
template<class type,class laz_type,int len>
struct segment_tree{
	type a[len<<2];
	laz_type laz[len<<2];
	void pushup(int now){
		PUSHUP_VALUE
	}
	void pushdown(int now,int l,int r){
		PUSHDOWN_VALUE
	}
	void build(int now,int l,int r){
		if(l+1==r){
			FIRST_VALUE
			return;
		}
		LAZ_CLEAR
		int mid=(l+r)>>1;
		build(now<<1,l,mid);
		build(now<<1|1,mid,r);
		pushup(now);
	}
	void do1(int now,int l,int r,int L,int R,...){
		if(l+1!=r)pushdown(now,l,r);
		if(R<=l||r<=L)return;
		if(L<=l&&r<=R){
			FULL_BLOCK_VALUE
			return;
		}
		int mid=(l+r)>>1;
		do1(now<<1,l,mid,L,R,...);
		do1(now<<1|1,mid,r,L,R,...);
		pushup(now);
	}
	void do1_one(int now,int l,int r,int p,...){
		if(l+1!=r)pushdown(now,l,r);
		if(l+1==r){
			DO1_VALUE
			return;
		}
		int mid=(l+r)>>1;
		if(p<mid)do1_one(now<<1,l,mid,p,...);
		else do1_one(now<<1|1,mid,r,p,...);
		pushup(now);
	}
	type qu1(int now,int l,int r,int L,int R){
		if(l+1!=r)pushdown(now,l,r);
		if(R<=l||r<=L)return BASE_VALUE
		if(L<=l&&r<=R)return a[now];
		int mid=(l+r)>>1;
		return RETURN_VALVE qu1(now<<1,l,mid,L,R)+qu1(now<<1|1,mid,r,L,R);
	}
	type qu1_one(int now,int l,int r,int p){
		if(l+1!=r)pushdown(now,l,r);
		if(l+1==r)return a[now];
		int mid=(l+r)>>1;
		if(p<mid)return qu1_one(now<<1,l,mid,p);
		else return qu1_one(now<<1|1,mid,r,p);

	}
};
#endif
//#define mod 998244353
//#define mint modint<mod>
//pows<mint,2,10000007>tp;note the size
//Math<mint,1000006>math;
//vector<int>g[1000006]
using hashing::hashing_base;
using hashing::hash;
hashing_base w1,w2;
vector<int>ca[1003][1003];
vector<int>va[1003];
int dp[707][707];
bool ma[707][707];
struct fr{
	int typ;
	int toa,tob;
	int lea,leb;
	int fl,fr;
}z[707][707];
void ct(int a,int b,int c,int d,int e,int f){
	int len=f-e+1;
	if(dp[a][b]>dp[c][d]+len+1){
		z[a][b].typ=0;
		z[a][b].toa=c;
		z[a][b].tob=d;
		z[a][b].lea=e;
		z[a][b].leb=f;
		dp[a][b]=dp[c][d]+len+1;
	}
}
int pr[707][707];
int prp[707][707];
vector<vector<int>>ff[707];
vector<int>tc[707][707];
signed main(){
	ios::sync_with_stdio(false);
	cin.tie(0);cout.tie(0);
	string s,t;
//	int l1=500,l2=300;
	cin>>s>>t;
	
	if(s.size()<2){
		cout<<s; 
		return 0;
	}
	w1.init(s);
	w2.init(t);
	int n=s.size(),m=t.size();
	s='$'+s;
	t='$'+t;
	unordered_map<int,pair<list<int>,vector<int>>>zc[707];
	for(int l=1;l<=n;l++){
		for(int r=l;r<=n;r++){
			auto c=w1.substr(l,r);
			zc[r-l+1][c.has[0]].first.push_back(l);
		}
	}
	for(int l=1;l<=m;l++){
		for(int r=l;r<=m;r++){
			auto c=w2.substr(l,r);
			zc[r-l+1][c.has[0]].second.push_back(l);
		}
	}
	for(int i=1;i<=max(n,m);i++){
		vector<int>w;
		int cnt=0;
		for(auto &x:zc[i]){
			if(x.second.first.size()==0){
				w.push_back(x.first);
			}else if(x.second.second.size()==0){
				cnt++;
				if(cnt>=2)w.push_back(x.first);
			}
		}
		for(auto p:w)zc[i].erase(p);
	}
	for(int i=1;i<=max(n,m);i++){
		for(auto &x:zc[i]){
			ff[i].push_back(x.second.second);
			for(auto p:x.second.first){
				if(p>=2){
					tc[p-2][i].push_back(ff[i].size()-1);
				}
			}
		}
	}
	memset(dp,0x3f,sizeof(dp));
	dp[0][0]=0;
	z[0][0].typ=-1;
	bool x=1;
	for(int i=1;i<=n;i++){
		if(i>m||s[i]!=t[i])x=0;
		int to=i;
		if(!x)to=m+1;
		dp[i][to]=i;
		z[i][to].typ=-1;
	}
	for(int i=0;i<=n;i++){
		for(int j=m;j>=0;j--){
			if(dp[i][j]>dp[i][j+1]){
				z[i][j].typ=1;
			}
			dp[i][j]=min(dp[i][j],dp[i][j+1]);
		}
		for(int j=0;j<=m+1;j++){
			pr[i][j]=dp[i][j];
			prp[i][j]=i;
			if(i&&pr[i][j]>pr[i-1][j]){
				pr[i][j]=pr[i-1][j];
				prp[i][j]=prp[i-1][j];
			}
		}
		int cnt=0;
		for(int len=1;len<=n;len++){
			for(auto x:tc[i][len]){
				auto &ca=ff[len][x];
				cnt++;
				int fl=i+2;
				int fr=fl+len-1;
				for(int w=0;w<ca.size();w++){
					cnt++;
					if(w==0)ct(fr,ca[w]+len-1,prp[i][0],0,fl,fr);
					else{
						ct(fr,ca[w]+len-1,prp[i][ca[w-1]],ca[w-1],fl,fr);
					}
				}
				int h=0;
				if(ca.size())h=ca.back();
				ct(fr,m+1,prp[i][h],h,fl,fr);
			}
//			for(auto &x:zc[len]){
//						cnt++; 
//				for(auto m:b1)cerr<<m<<' ';
//				for(auto m:ca)cerr<<m<<'!';
//				cerr<<endl;
//				while(b1.size()&&b1.front()<i+2)b1.pop_front();
//				if(b1.size()&&b1.front()==i+2){
//				}
//			}
		}
		cerr<<i<<' '<<cnt<<endl;
			
		
//		for(int j=0;j<=m+1;j++){
//			cerr<<dp[i][j]<<' ';
//		}
//		cerr<<endl;
	}
	int masu=0;
	while(masu<m&&masu<n&&s[s.size()-1-masu]==t[t.size()-1-masu])masu++;
	int ans=min(n,masu+2);
	int fa=-1,fb=-1,wc=-1;
	for(int i=0;i<=masu;i++){
		for(int p=0;p<n-i-1;p++){
			if(ans>dp[p][m+1-i]+i+1){
				fa=p;
				fb=m+1-i;	
				wc=i;
				ans=dp[p][m+1-i]+i+1;
			}
			ans=min(ans,dp[p][m+1-i]+i+1);
		}
	}
//	cerr<<ans<<endl;
	if(ans==n){
		for(int i=1;i<=n;i++)cout<<s[i];
	}else if(ans==masu+2){
		string buf="";
		for(int k=1;k<=masu+1;k++){
			buf+=s[s.size()-k];
		}
		buf+='*';
		reverse(buf.begin(),buf.end());
		cout<<buf;
	}else{
		int na1=fa,na2=fb;
		string buf="";
		for(int k=1;k<=wc;k++){
			buf+=s[s.size()-k];
		}
		buf+="*";
		while(1){
			if(z[na1][na2].typ==-1){
				for(int i=na1;i>=1;i--){
					buf+=s[i];
				}
				break;
			}else if(z[na1][na2].typ==0){
				for(int x=z[na1][na2].leb;x>=z[na1][na2].lea;x--){
					buf+=s[x];
				}
				buf+='*';
				auto c=z[na1][na2];
				na1=c.toa,na2=c.tob;
			}else{
				na2++;
			}
//			cerr<<na1<<' '<<na2<<endl;
		}
		reverse(buf.begin(),buf.end());
		cout<<buf;
		
	}
	return 0;
}
}
bool en;
signed main(){
	#ifdef LOCAL_WRK
	cerr<<"[Static Memory : "<<fixed<<((&st)-(&en))/1048576.0<<"MB]"<<endl;
	#endif
	_wrk::hashing::init();
	   return _wrk::main();
}