#include <iostream>
#include <string>
#include <stdlib.h> 
#include <iomanip>

//********************************************************************
// DIAGONAL ENTITY
//
// Class Diagonal and his functions
//********************************************************************

// Diagonal type
enum DiagType {INCREASE, MAXIMUM, DECREASE};
// Diagonal direction
enum DiagDirect {BOTTOM_TOP, TOP_BOTTOM};

// Simple coordinates
struct Coordinates {
  int x;
  int y;
  Coordinates() : x(0), y(0){}
};

//--------------------------------------------------------------------
// Diagonal count in a 2d-array h * m size
//--------------------------------------------------------------------
inline int DiagonsCount( const int& h, const int& w ) {
  return h + w - 1;
}

//--------------------------------------------------------------------
// Diagonal max length in a 2d-array h * m size
//--------------------------------------------------------------------
inline int DiagonMaxLength( const int& h, const int& w ) {
  return h < w ? h : w;
}

//--------------------------------------------------------------------
// Count diagonal wih max lenght in a 2d-array h * m size
//--------------------------------------------------------------------
inline int DiagonsMaxLengthCount( const int& h, const int& w ) {
  return abs( h - w ) + 1;
}

//--------------------------------------------------------------------
// Diagonal #index type in a 2d-array h * m size
//--------------------------------------------------------------------
DiagType DiagonType( const int& h, const int& w, const int& index ) {
  int maxLength = DiagonMaxLength( h, w );
  if ( ( index + 1 ) < maxLength )
    return INCREASE;
  else if ( ( index + 1 ) <= maxLength + DiagonsMaxLengthCount( h, w ) - 1 )
    return MAXIMUM;
  else
    return DECREASE;
}

//--------------------------------------------------------------------
// Diagonal #index length in a 2d-array h * m size
//--------------------------------------------------------------------
int DiagonLength( const int& h, const int& w, const int& index ) {
  switch ( DiagonType( h, w, index ) ) {
    case INCREASE: return index + 1;
    case MAXIMUM: return DiagonMaxLength( h, w );
    case DECREASE: return DiagonsCount( h, w ) - index;
  }
}

//--------------------------------------------------------------------
// Diagonal #index top element coordinates in a 2d-array
//--------------------------------------------------------------------
void DiagonTop( const int& width, const int& index, Coordinates& coor ) {
  int correction = ( index + 1 ) - width;
  correction = correction > 0 ? correction : 0;
  if ( correction )
    coor.x = width - 1;
  else
    coor.x = index;
  coor.y = correction;
}

//--------------------------------------------------------------------
// Diagonal entity class
//--------------------------------------------------------------------
class Diagonal {
public:
  Diagonal(); // default constructor
  Diagonal( const Diagonal&, const int&, const int& ); // constructor
  int Index() const { return _index; } // index in a 2d-array
  int Length() const { return _length; } // count of elements
  int MaxElement() const { return _maxelement; } // max element value
  Coordinates Top() const { return _top; } // coordinates top element
  DiagDirect Direction() const { return _direction; } // up-down, down-up
  DiagType Type() const { return _type; } // increase, maximum length, decrease
private:
  Diagonal( const Diagonal& ){}; // hidden copy constructor
  int _index;
  int _length;
  int _maxelement;
  Coordinates _top;
  DiagDirect _direction;
  DiagType _type;
};

//--------------------------------------------------------------------
// Default constructor - creates first diagonal 2d-array
//--------------------------------------------------------------------
Diagonal::Diagonal() :
  _index(0),
  _length(1),
  _maxelement(1),
  _top(),
  _direction(TOP_BOTTOM),
  _type(INCREASE)
{}

//--------------------------------------------------------------------
// Constructor - creates NEXT diagonal using input diagonal data
//--------------------------------------------------------------------
Diagonal::Diagonal( const Diagonal& diagonal, const int& height, const int& width ) {
  _index = diagonal.Index() + 1;
  _type = DiagonType( height, width, Index() );
  _length = DiagonLength( height, width, Index() );
  _maxelement = diagonal.MaxElement() + Length();
  _direction = diagonal.Direction() == TOP_BOTTOM ? BOTTOM_TOP : TOP_BOTTOM;
  DiagonTop( width, Index(), _top );
}

//--------------------------------------------------------------------
// Indicates whether element belongs diagonal
//--------------------------------------------------------------------
bool DiagHasElement( const Diagonal& diagonal, const int& element ) {
  int minElement = diagonal.MaxElement() - diagonal.Length() + 1;
  return ( element >= minElement ) && ( element <= diagonal.MaxElement() );
}


//--------------------------------------------------------------------
// Returns element coordinates if it belongs diagonal, otherwise -1,-1
//--------------------------------------------------------------------
bool DiagElementCoor( const Diagonal& diagonal, const int& element, Coordinates& coor ) {
  if ( DiagHasElement( diagonal, element ) ) {
    int topElement = 0;
    if ( diagonal.Direction() == TOP_BOTTOM )
      topElement = diagonal.MaxElement() - diagonal.Length() + 1;
    else
      topElement = diagonal.MaxElement();
    int correction = abs( topElement - element );
    coor = diagonal.Top();

    coor.x -= correction;
    coor.y += correction;
  }
  else
    coor.x = coor.y = -1;
}


//********************************************************************
// ARRAY2D ENTITY
//
// Class Array2d, containes 2-dimentional array
//********************************************************************


//--------------------------------------------------------------------
// Array2d entity class
//--------------------------------------------------------------------
class Array2d {
public:
  Array2d( const int&, const int& ); // default constructor
  ~Array2d(); // destructor
  int Height() const { return _height; }
  int Width() const { return _width; }
  int Item( const int& x, const int& y ) const { return _array[x][y]; }
  void SetItem( const int& ); // set value to some item
  class exc_out_of_range{}; // out of range exception
private:
  Array2d( const Array2d& ){}; // hidden copy constructor
  Array2d operator= ( const Array2d& ) {}; // hidden assing operation
  int _height;
  int _width;
  int** _array;
  Diagonal* _diagonals;
};


//--------------------------------------------------------------------
// Default constructor - creates 2d-array, filled with 0, and diagonal array
// Bad example - might be raised bad_alloc exception
//--------------------------------------------------------------------
Array2d::Array2d( const int& a, const int& b ) : _height(a), _width(b) {
  _array = new int* [ Width() ];
  for ( int i = 0; i < Width(); ++i )
    _array[i] = new int[ Height() ];

  for ( int i = 0; i < Height(); ++i ) {
    for ( int j = 0; j < Width(); ++j ) {
      _array[j][i] = 0;
    }
  }

  int count = DiagonsCount( Height(), Width() );
  _diagonals = new Diagonal[ count ];
  _diagonals[0] = Diagonal();
  for ( int i = 1; i < count; ++i )
    _diagonals[i] = Diagonal( _diagonals[ i-1 ], Height(), Width() );  
}

//--------------------------------------------------------------------
// Destructor - destroys 2d-array and diagonal array
//--------------------------------------------------------------------
Array2d::~Array2d() {
  for ( int i = 0; i < Width(); ++i )
    delete[] _array[i];
  delete[] _array;
  delete[] _diagonals;
}

//--------------------------------------------------------------------
// Operator << - showes 2d-array with intendation
//--------------------------------------------------------------------
std::ostream& operator<< ( std::ostream& o, const Array2d& a ) {
  float d = a.Height()*a.Width();
  int intend = 0;
  while ( d > 1 ) {
    ++intend;
    d /= 10;
  }
  for ( int i = 0; i < a.Height(); ++i ) {
    for ( int j = 0; j < a.Width(); ++j )
      o << std::setw( intend ) << a.Item( j,i ) << ' ';
    o << std::endl;
  }
}

//--------------------------------------------------------------------
// Sets value element to some item in the 2d-array
//--------------------------------------------------------------------
void Array2d::SetItem( const int& element ) {
  if ( ( element <= 0 ) || ( element > Height() * Width() ) )
    throw exc_out_of_range();

  int count = DiagonsCount( Height(), Width() );
  int index;
  for ( index = 0; index < count; ++index ) {
    if ( DiagHasElement( _diagonals[ index ], element ) )
      break;
  }
  Coordinates c;
  DiagElementCoor( _diagonals[ index ], element, c );
  _array[c.x][c.y] = element;
}

//********************************************************************
// INPUT INTEGET FUNCTIONS
//
// Input integer from cin functions
//********************************************************************

class exc_bad_int{};

//--------------------------------------------------------------------
// Indicates whether string can be NONNEGATIVE integer
//--------------------------------------------------------------------
bool IsDigits( const std::string& str ) {
  std::string::const_iterator iter = str.begin();
  for ( iter; iter != str.end(); ++iter )
    if ( !( isdigit( *iter ) ) )
      return false;
  return true;
}

//--------------------------------------------------------------------
// Translates string to NONNEGATIVE integer. Exception exc_bad_int could be raised
//--------------------------------------------------------------------
int StringToInt( const std::string& str ) {
  if ( !( IsDigits( str ) ) )
    throw exc_bad_int();
  return atoi( str.c_str() );
}

//--------------------------------------------------------------------
// Returns NONNEGATIVE integer from cin
//--------------------------------------------------------------------
int IntegerIntput() {
  bool input = false;
  int i = 0;
  std::string str;
  while ( true ) {
    std::cin >> str;
    try {
      i = StringToInt( str );
      return i;
    }
    catch( exc_bad_int ) {
      std::cout << "Error: value is not positive integer." << std::endl;
    }
  }
}


//********************************************************************
// MAIN SECTION
//********************************************************************
int main( int argc, char **argv ) {
  std::cout << "Input array height:" << std::endl;
  int height = IntegerIntput();
  std::cout << "Input array width:" << std::endl;
  int width = IntegerIntput();

  Array2d a( height, width );

  int count = height * width;
  for ( int i = 1; i <= count; ++i )
    a.SetItem( i );
  std::cout << a;

  return 0;
}