We have a grid with (2^N - 1) rows and (2^M-1) columns. You are asked to write 0 or 1 in each of these squares. Let a_{i,j} be the number written in the square at the i-th row from the top and the j-th column from the left.

For a quadruple of integers (i_1, i_2, j_1, j_2) such that 1\leq i_1 \leq i_2\leq 2^N-1, 1\leq j_1 \leq j_2\leq 2^M-1, let S(i_1, i_2, j_1, j_2) = \displaystyle \sum_{r=i_1}^{i_2}\sum_{c=j_1}^{j_2}a_{r,c}. Then, let the oddness of the grid be the number of quadruples (i_1, i_2, j_1, j_2) such that S(i_1, i_2, j_1, j_2) is odd.

Find a way to fill in the grid that maximizes its oddness.

Constraints

* N and M are integers between 1 and 10 (inclusive).

Input

Input is given from Standard Input in the following format:


N M


Output

Print numbers to write in the grid so that its oddness is maximized, in the following format:


a_{1,1}a_{1,2}\cdots a_{1,2^M-1}
a_{2,1}a_{2,2}\cdots a_{2,2^M-1}
\vdots
a_{2^N-1,1}a_{2^N-1,2}\cdots a_{2^N-1,2^M-1}


If there are multiple solutions, you can print any of them.

Example

Input

1 2


Output

111
//#pragma comment(linker, "/stack:200000000")
//#pragma GCC optimize("Ofast")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
//#pragma GCC optimize("unroll-loops")
  
#include <iostream>
#include <stdlib.h>
#include <cmath>
#include <algorithm>
#include <vector>
#include <queue>
#include <deque>
#include <set>
#include <map>
#include <unordered_map>
#include <unordered_set>
#include <random>
#include <assert.h>
#include <memory.h>
#include <time.h>
#include <bitset>
  
#define uint unsigned int
#define ll long long
#define ull unsigned long long
#define ld long double
#define rep(i, l, r) for (int i = (l); i < (r); i++)
#define repb(i, r, l) for (int i = (r); i > (l); i--)
#define sz(a) (int)a.size()
#define fi first
#define se second
#define mp(a, b) make_pair(a, b)
#define rank qwertyuio
#define next dfghjk
#define plus fsghsf
#define minus ytryr
  
using namespace std;
  
inline bool setmin(int &x, int y) { return (y < x) ? x = y, 1 : 0; }
inline bool setmax(int &x, int y) { return (y > x) ? x = y, 1 : 0; }
inline bool setmin(ll &x, ll y) { return (y < x) ? x = y, 1 : 0; }
inline bool setmax(ll &x, ll y) { return (y > x) ? x = y, 1 : 0; }
  
const int N = 200000 + 239;
const int inf = (int)1e9 + 1;
const ll big = (ll)1e18 + 1;
const int P = 239;
const int P1 = 31;
const int P2 = 57;
const int MOD = (int)1e9 + 7;
const int MOD1 = (int)1e9 + 9;
const int MOD2 = 998244353;
const ld eps = 1e-12;
const double pi = atan2(0, -1);
const int ABC = 26;

vector<vector<int> > a[11];

int main()
{
    //freopen("a.in", "r", stdin);
    //freopen("a.out", "w", stdout);
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.precision(20);
    //ll TL = 10.95 * CLOCKS_PER_SEC;
    //clock_t time = clock();
    a[1] = {{1}};
    rep(b, 2, 11) {
        vector<vector<int> > tmp;
        rep(i, 0, sz(a[b - 1])) {
            tmp.push_back({});
            for (int j : a[b - 1][i]) {
                tmp.back().push_back(j);
                tmp.back().push_back(j);
            }
            tmp.back().push_back(0);
        }
        vector<int> ttt;
        rep(i, 0, (1 << b) - 1) {
            ttt.push_back(1 - i % 2);
        }

        for (auto it : tmp) {
            a[b].push_back(it);
        }
        a[b].push_back(ttt);
        for (auto it : tmp) {
            a[b].push_back(it);
        }
    }

    /*int x;
    cin >> x;
    for (auto it : a[x]) {
        for (int i : it) {
            cout << i << " ";
        }
        cout << endl;
    }*/

    int n, m;
    cin >> n >> m;
    bool sw = false;
    if (n > m) {
        swap(n, m);
        sw = true;
    }

    rep(i, 0, sz(a[m])) {
        int cur = 0;
        repb(j, sz(a[m][i]) - 1, 0) {
            a[m][i][j] ^= a[m][i][j - 1];
        }
    }

    int ans[(1 << n) - 1][(1 << m) - 1];
    rep(i, 0, (1 << n) - 1) {
        rep(j, 0, (1 << m) - 1) {
            ans[i][j] = a[m][i][j];
        }
    }

    if (!sw) {
        rep(i, 0, (1 << n) - 1) {
            rep(j, 0, (1 << m) - 1) {
                cout << ans[i][j] << "";
            }
            cout << "\n";
        }
    } else {
        rep(i, 0, (1 << m) - 1) {
            rep(j, 0, (1 << n) - 1) {
                cout << ans[j][i] << "";
            }
            cout << "\n";
        }
    }
    return 0;
}