#pragma region Macros

#pragma GCC target("avx,avx2,fma")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
// #pragma GCC target("avx,avx2,fma,sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,tune=native")

// #include <bits/extc++.h>
#include <bits/stdc++.h>
using namespace std;
// using namespace __gnu_pbds;
// using namespace __gnu_cxx;
// #include <atcoder/fenwicktree>
// #include <atcoder/segtree>
// #include <atcoder/maxflow>
// #include <atcoder/all>
// using namespace atcoder;

// #include <boost/multiprecision/cpp_int.hpp>
// namespace mp = boost::multiprecision;
// using Bint = mp::cpp_int;

#define TO_STRING(var) # var
#define pb emplace_back
// #define int ll
#define endl '\n'

using ll = long long;
using ld = long double;
const ld PI = acos(-1);
const ld EPS = 1e-10;
const ll INFL = 1LL << 61;
const int MOD = 998244353;
// const int MOD = 1000000007;

__attribute__((constructor))
void constructor() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
}

#pragma endregion

signed main() {
    int H, W;
    cin >> H >> W;
    vector<vector<char>> S(H, vector<char>(W));
    for (int i = 0; i < H; i++) {
        for (int j = 0; j < W; j++) {
            cin >> S[i][j];
        }
    }

    vector<char> ans(H + W - 1, 123);
    vector<vector<vector<bool>>> flag(H, vector<vector<bool>>(W, vector<bool>(2)));

    ans[0] = S[0][0];

    queue<vector<int>> qu;
    vector<int> A(3);
    qu.push(A);

    while (!qu.empty()) {
        auto V = qu.front();
        qu.pop();
        int i = V[0];
        int j = V[1];
        int k = V[2];

        if (i && k == 0 && S[i - 1][j] != ans[i + j - 1]) continue;
        if (j && k == 1 && S[i][j - 1] != ans[i + j - 1]) continue;

        char c = 'z';
        if (S[i][j] < ans[i + j]) {
            ans[i + j] = S[i][j];
            if (i + 1 < H && !flag[i + 1][j][0]) {
                flag[i + 1][j][0] = true;
                qu.emplace(vector<int>{i + 1, j, 0});
                c = S[i + 1][j];
            }
            if (j + 1 < W && !flag[i][j + 1][1]) {
                flag[i][j + 1][1] = true;
                qu.emplace(vector<int>{i, j + 1, 1});
                c = S[i][j + 1];
            }
        }
        if (S[i][j] == ans[i + j]) {
            if (i + 1 < H && !flag[i + 1][j][0] && S[i + 1][j] <= c) {
                flag[i + 1][j][0] = true;
                qu.emplace(vector<int>{i + 1, j, 0});
                c = min(c, S[i + 1][j]);
            }
            if (j + 1 < W && !flag[i][j + 1][1] && S[i][j + 1] <= c) {
                flag[i][j + 1][1] = true;
                qu.emplace(vector<int>{i, j + 1, 1});
                c = min(c, S[i][j + 1]);
            }
        }
    }
    for (auto &x : ans) {
        cout << x;
    }
    cout << endl;
}