#ifndef LAYOUT_INC_CPP

#define LAYOUT_INC_CPP

#include <cassert></cassert>

#include <cstdio></cstdio>

#include <vector></vector>

#include <algorithm></algorithm>

struct Layout {

  typedef std::vector<layout> List;</layout>

  int sx, sy, sz;

  int x0, x1;

  int y0, y1;

  int z0, z1;

  inline Layout(): sx(), sy(), sz(), x0(), x1(), y0(), y1(), z0(), z1() { }

  explicit inline Layout(int sx, int sy = 1, int sz = 1):

    sx(sx), sy(sy), sz(sz), x0(), x1(sx), y0(), y1(sy), z0(), z1(sz) { }

  inline Layout& expandX  (int e0, int e1) { return sx += e0+e1, x0 += e0, x1 += e0, *this; }

  inline Layout& expandY  (int e0, int e1) { return sy += e0+e1, y0 += e0, y1 += e0, *this; }

  inline Layout& expandZ  (int e0, int e1) { return sz += e0+e1, z0 += e0, z1 += e0, *this; }

  inline Layout& expandXY (int e0, int e1) { return expandX (e0, e1).expandY(e0, e1); }

  inline Layout& expandXYZ(int e0, int e1) { return expandXY(e0, e1).expandZ(e0, e1); }

  inline Layout& expandX  (int e)          { return expandX  (e, e); }

  inline Layout& expandY  (int e)          { return expandY  (e, e); }

  inline Layout& expandZ  (int e)          { return expandX  (e, e); }

  inline Layout& expandXY (int e)          { return expandXY (e, e); }

  inline Layout& expandXYZ(int e)          { return expandXYZ(e, e); }

  inline Layout& padX  (int p0, int p1) { return x0 += p0, x1 -= p0, *this; }

  inline Layout& padY  (int p0, int p1) { return y0 += p0, y1 -= p0, *this; }

  inline Layout& padZ  (int p0, int p1) { return z0 += p0, z1 -= p0, *this; }

  inline Layout& padXY (int p0, int p1) { return padX (p0, p1).padY(p0, p1); }

  inline Layout& padXYZ(int p0, int p1) { return padXY(p0, p1).padZ(p0, p1); }

  inline Layout& padX  (int p)          { return padX  (p, p); }

  inline Layout& padY  (int p)          { return padY  (p, p); }

  inline Layout& padZ  (int p)          { return padX  (p, p); }

  inline Layout& padXY (int p)          { return padXY (p, p); }

  inline Layout& padXYZ(int p)          { return padXYZ(p, p); }

  inline bool hasPadX() const { return x0 > 0 || x1 < sx; }

  inline bool hasPadY() const { return y0 > 0 || y1 < sy; }

  inline bool hasPadZ() const { return z0 > 0 || z1 < sz; }

  inline bool hasPad()  const { return hasPadX() || hasPadY() || hasPadZ(); }

  inline int getW() const { return x1 - x0; }

  inline int getH() const { return y1 - y0; }

  inline int getD() const { return z1 - z0; }

  inline int getCount() const { return sx*sy*sz; }

  inline int getActiveCount() const { return getW()*getH()*getD(); }

  inline operator bool() const {

    return x0 >= 0 && x0 < x1 && x1 <= sx

        && y0 >= 0 && y0 < y1 && y1 <= sy

        && z0 >= 0 && z0 < z1 && z1 <= sz;

  }

  inline bool isSameSizeWith(const Layout &b) const

    { return sx == b.sx && sy == b.sy && sz == b.sz; }

  inline bool isSameActiveSizeWith(const Layout &b) const

    { return getW() == b.getW() && getH() == b.getH() && getD() == b.getD(); }

  inline bool isSubLayoutOf(const Layout &b) const

    { return isSameSizeWith(b) && b.x0 <= x0 && x0 < x1 && x1 <= b.x1; }

  inline bool isParentLayoutOf(const Layout &b) const

    { return b.isSubLayoutOf(*this); }

  void splitX(List &list, int count) const {

    if (count <= 0) return list.clear();

    list.resize(count);

    int v = x0, s = x1 - v;

    for(int i = 0; i < count; ++i) {

      Layout &l = list[i] = *this;

      l.x0 = v;

      l.x1 = (v += s/count + (i < s%count));

    }

  }

  void splitY(List &list, int count) const {

    if (count <= 0) return list.clear();

    list.resize(count);

    int v = y0, s = y1 - v;

    for(int i = 0; i < count; ++i) {

      Layout &l = list[i] = *this;

      l.y0 = v;

      l.y1 = (v += s/count + (i < s%count));

    }

  }

  void splitZ(List &list, int count) const {

    if (count <= 0) return list.clear();

    list.resize(count);

    int v = z0, s = z1 - v;

    for(int i = 0; i < count; ++i) {

      Layout &l = list[i] = *this;

      l.z0 = v;

      l.z1 = (v += s/count + (i < s%count));

    }

  }

  void split(List &list, int count) const {

    int h = getH(), w = getW(), d = getD();

    if (h >= w && h >= d) splitY(list, count); else

              if (w >= d) splitX(list, count); else

                          splitZ(list, count);

  }

  void print(const char *prefix = nullptr) const {

    if (prefix && *prefix) printf("%s: ", prefix);

    printf("x: %d (%d-%d), y: %d (%d-%d), z: %d (%d-%d)\n", sx, x0, x1, sy, y0, y1, sz, z0, z1);

  }

  void printYXZ(const char *prefix = nullptr) const {

    if (prefix && *prefix) printf("%s: ", prefix);

    printf("y: %d (%d-%d), x: %d (%d-%d), z: %d (%d-%d)\n", sy, y0, y1, sx, x0, x1, sz, z0, z1);

  }

};

#endif