#include <bits/stdc++.h>
 
using namespace std;
 
void __print(int x) {cerr << x;}
void __print(long x) {cerr << x;}
void __print(long long x) {cerr << x;}
void __print(unsigned x) {cerr << x;}
void __print(unsigned long x) {cerr << x;}
void __print(unsigned long long x) {cerr << x;}
void __print(float x) {cerr << x;}
void __print(double x) {cerr << x;}
void __print(long double x) {cerr << x;}
void __print(char x) {cerr << '\'' << x << '\'';}
void __print(const char *x) {cerr << '\"' << x << '\"';}
void __print(const string &x) {cerr << '\"' << x << '\"';}
void __print(bool x) {cerr << (x ? "true" : "false");}
 
template<typename T, typename V>
void __print(const pair<T, V> &x) {cerr << '{'; __print(x.first); cerr << ','; __print(x.second); cerr << '}';}
template<typename T>
void __print(const T &x) {int f = 0; cerr << '{'; for (auto &i: x) cerr << (f++ ? "," : ""), __print(i); cerr << "}";}
void _print() {cerr << "]\n";}
template <typename T, typename... V>
void _print(T t, V... v) {__print(t); if (sizeof...(v)) cerr << ", "; _print(v...);}
#ifndef ONLINE_JUDGE
#define debug(x...) cerr << "[" << #x << "] = ["; _print(x)
#else
#define debug(x...)
#endif
#define all(x) x.begin(),x.end()
 
typedef long long ll;
using vi = vector<int>;
using vll = vector<ll>;
using pi = pair<int,int>;
using vpi = vector<pi>;
using vb = vector<bool>;
using vvi = vector<vector<int>>;
using vvll = vector<vector<long long>>;
using vvb = vector<vb>;
 
#include <ext/pb_ds/assoc_container.hpp> //required
#include <ext/pb_ds/tree_policy.hpp> //required
using namespace __gnu_pbds; //required 
using namespace std;
template <typename T> using ordered_set =  tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
 
struct custom_hash {
    static uint64_t splitmix64(uint64_t x) {
        // http://xorshift.di.unimi.it/splitmix64.c
        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);
    }
};
 
struct HASH{
  size_t operator()(const pair<int,int>&x)const{
    return hash<long long>()(((long long)x.first)^(((long long)x.second)<<32));
  }
};
 
 
 
struct ordered_multiset{
    ordered_multiset() {}
    ordered_set<pair<int,size_t>> os;
    size_t size = 0;
 
    void insert(int x) {
        os.insert({x,size++});
    }
 
    void erase(int x) {
        os.erase(os.lower_bound({x,0}));
    }
    int order_of_key(int x) {
        return os.order_of_key({x,0});
    }
 
    int find_by_order(int k) {
        return (*os.find_by_order(k)).first;
    }
 
};
 
 
 
const ll MOD = 1e9+7;
const int N = 200001;
 
 
template <class T> 
struct seg_tree {
    vector<T> tree;
    int arr_size;
 
    seg_tree(int size, T def) {
        int new_size = size;
        while( __builtin_popcount(new_size) != 1) {
            new_size++;
        }
        tree.resize(2*new_size);
        arr_size = new_size;
 
        for(int i = new_size;i < 2*new_size;i++) tree[i] = def;
 
        for(int i = new_size - 1;i >= 1;i--) {
            tree[i] = tree[2*i] + tree[2*i + 1];
        }
    }
 
    seg_tree() {
 
    }
 
    seg_tree(vector<T> arr) {
        int size = arr.size();
        int new_size = size;
        while( __builtin_popcount(new_size) != 1) {
            new_size++;
        }
        tree.resize(2*new_size);
        arr_size = new_size;
        for(int i = 0;i < size;i++) {
            tree[i+new_size] = arr[i];
        }
        for(int i = new_size - 1;i >= 1;i--) {
            tree[i] = tree[2*i] + tree[2*i + 1];
        }
    }
 
 
    seg_tree(T arr[], int size) {
        int new_size = size;
        while( __builtin_popcount(new_size) != 1) {
            new_size++;
        }
        tree.resize(2*new_size);
        arr_size = new_size;
        for(int i = 0;i < size;i++) {
            tree[i+new_size] = arr[i];
        }
        for(int i = new_size - 1;i >= 1;i--) {
            tree[i] = tree[2*i] + tree[2*i + 1];
        }
    }
    private:
    void update_helper(int node) {
        if(node == 0) return;
        tree[node] = tree[2*node] + tree[2*node + 1];
        update_helper(node/2);
    }
 
    public:
    void update(int index, T value) {
        tree[index + arr_size] = value;
        update_helper((index + arr_size)/2);
    }
 
    T query(int q_left, int q_right, int node = 1, int node_left = 0, int node_right = -1) {
        if(node_right == -1) {
            node_right = arr_size - 1;
        }
 
        if(q_left <= node_left && q_right >= node_right) {
            return tree[node]; 
        }
        if(q_right < node_left || q_left > node_right) {
            return (T)0;
        } 
        int mid = (node_left + node_right) / 2;
        return query(q_left, q_right, 2*node, node_left, mid)
        + query(q_left, q_right, 2*node + 1, mid + 1, node_right);
    }
 
    T get(int i) {
        return tree[arr_size + i];
    }
}; 

string f(int n, string a, string b) {
    vector<vector<array<int, 3>>> dp(n, vector<array<int,3>> (n));
    if(a[0] == b[0])dp[0][0] = {1,-1,-1};
    else dp[0][0] = {0, -1, -2};

    for(int i = 0;i < n;i++) {
        for(int j = 0;j < n;j++) {
            if(i && j && a[i] == b[j]) {
                dp[i][j] = {dp[i - 1][j - 1][0] + 1, i - 1, j - 1};
                continue;
            }
            if(i - 1 >= 0)dp[i][j] = {dp[i - 1][j][0], i - 1, j};
            if(j - 1 >= 0 && dp[i][j - 1] >= dp[i][j]) dp[i][j] = {dp[i][j - 1][0], i, j - 1};
        }
    }
    int i = n - 1, j = n - 1;
    string ans = "";
    while(i >= 0 && j >= 0) {
        if(dp[i][j][1] == i - 1 && dp[i][j][2] == j - 1) ans.push_back(a[i]);
        int ii = i;
        i = dp[i][j][1], j = dp[ii][j][2];
    }
    reverse(all(ans));
    return ans;
}

void solve() {
    int n; cin >> n;
    string a,b; cin >> a >> b;
    int size = 12;
    string ans = "";
    for(int i = 0;i < n;i+=size) {
        ans += f(size, a.substr(i, size), b.substr(i, size));
    }
    cout << ans.substr(0, n/2);
}

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

    solve();
    return 0;
    

    int t;cin >> t;
    for(int i = 1;i <= t;i++) {
        solve();
    }
    return 0;
}