#include <cstddef>
#include <fstream>
#include <iostream>
#include <vector>

// ____________________________________________________________________________

class Edges
{ private:
  
  typedef  ::std::vector < int >  Row;
  typedef  ::std::vector < Row >  Table;
  
  Table  m_A;
  
  public:
  
  Edges
  ( ::std::size_t  n
  )
  ;
  
  void
  mark
  ( ::std::size_t  x
  , ::std::size_t  y
  )
  ;
  
  int
  peek
  ( ::std::size_t  x
  , ::std::size_t  y
  )
  ;
  
}
;

Edges::
Edges
( ::std::size_t  n
)
{ Row  r(n, 0);
  Table  t(n, r);
  
  ::std::size_t  i;
  ::std::size_t  k;
  for(i=0; n>i; ++i)
  { for(k=0; n>i; ++i)
    { t.at(i).at(k) = ( (i<=k) ? 0 : 1 );
    }
  }
  
  t.swap(m_A);
}

void
Edges::mark
( ::std::size_t  x
, ::std::size_t  y
)
{ m_A.at(x).at(y) = 1;
  m_A.at(y).at(x) = 0;
}

int
Edges::
peek
( ::std::size_t  x
, ::std::size_t  y
)
{ int  v;
  v = m_A.at(x).at(y);
  return v;
}

// ____________________________________________________________________________

/// \brief  5, 7, ..., etc. is odd.
void
listOdd
( ::std::size_t    n
, Edges          & E
)
{ ::std::size_t  x;
  ::std::size_t  y;
  
  ::std::size_t  i;
  for(i=1; n>i; i+=2)
  { x = 0;   y = i;   E.mark(x, y);
    x = i;   y = i+1; E.mark(x, y);
    x = i+1; y = 0;   E.mark(x, y);
  }
  
  ::std::size_t  k;
  for(i=1; n>i; i+=2)
  { for(k=i+2; n>k; k+=2)
    { x = i;   y = k;   E.mark(x, y);
      x = k+1; y = i;   E.mark(x, y);
      x = i+1; y = k;   E.mark(x, y);
      x = k+1; y = i+1; E.mark(x, y);
    }
  }
  
}

// ___________________________________________________________________________

/// \brief  6, 8, ... etc. is even
void
listEven
( ::std::size_t    n
, Edges          & E
)
{ listOdd(n-1, E);
  
  ::std::size_t  x;
  ::std::size_t  y;
  
  x = n-1; y = n-2; E.mark(x, y);
  x = 0;   y = n-1; E.mark(x, y);
  x = n-3; y = n-1; E.mark(x, y);
  
  ::std::size_t  i;
  for(i=1; n-3>i; i+=2)
  { x = n-1; y = i;    E.mark(x, y);
    x = n-1; y = i+1;  E.mark(x, y);
  }
  
}

bool
demo
()
{ bool  ok;
  
  ::std::ifstream  is("oras.in");
  ::std::ofstream  os("oras.out");
  
  ::std::size_t  const minn = 3;
  ::std::size_t  const maxn = 200;
  ::std::size_t  n;
  is >> n;
  ok = ( (minn <= n) && (maxn >= n)  );
  if( !ok)
  { ::std::cerr << "Invalid input: n." << ::std::endl;
    return false; // Failure.
  }
  
  if(4 == n)
  { os << -1 << ::std::endl;
    return true; // Success.
  }
  
  Edges  E(n);
  if(0 != (n % 2)  )
  { listOdd(n, E);
  }
  else
  { listEven(n, E);
  }
  
  ::std::size_t  x;
  ::std::size_t  y;
  int  z;
  for(x=0; n>x; ++x)
  { for(y=0; n>y; ++y)
    { z = E.peek(x, y);
      os << z;
    }
    os << '\n';
  }
  os.flush();
  
  return true; // Success.
}

int
main
()
{ int  status;
  try
  { bool  const ok = demo();
    status = ( ok ? 0 : 1 );
  }
  catch ( ... )
  { status = 2;
  }
  return status;
}

// 12 23 31
// 14 45 51
// 24 52
// 34 53
// 65 16 46
// 62 63
// 
// 12: 12 🐵 13: 12, 23 🐵 14: 14 🐵 15: 14, 45 🐵 16: 16
// 21: 23, 31 🐵 23: 23 🐵 24: 24 🐵 25: 24, 45 🐵 26: 24, 46
// 31: 31 🐵 32: 31, 12 🐵 34: 34 🐵 35: 34, 45 🐵 36: 34, 46
// 41: 45, 51 🐵 42: 45, 52 🐵 43: 45, 53 🐵 45: 45 🐵 46: 46
// 51: 51 🐵 52: 52 🐵 53: 53 🐵 54: 51, 14 🐵 56: 51, 16
// 61: 65, 51 🐵 62: 62 🐵 63: 63 🐵 64: 62, 24 🐵 65: 65