#include <bits/stdc++.h>
using namespace std;
using ll = long long;

// This is an implementation of Paul's solution as described in the README.

struct pt { ll v[3]; };

// This just permutes the axes of the points in pts so they fit in the input rectangl-oid.
void fix_and_print(const vector<pt>& pts, ll in[3]) {
  ll p[3] = {0, 1, 2};
  do {
    bool ok = true;
    for (pt vtx : pts)
      ok = ok && vtx.v[p[0]] <= in[0] && vtx.v[p[1]] <= in[1] && vtx.v[p[2]] <= in[2];
    if (ok) break;
  } while (next_permutation(p, p+3));

  cout << pts.size() << '\n';
  for (pt vtx : pts)
    cout << vtx.v[p[0]] << ' ' << vtx.v[p[1]] << ' ' << vtx.v[p[2]] << '\n';
  exit(0);
}

void sort(ll &a, ll &b, ll &c) {
  if (a > b) swap(a, b);
  if (b > c) swap(b, c);
  if (a > b) swap(a, b);
}

void tetra_corner(vector<pt>& pts, ll cx, ll cy, ll cz, ll rx, ll ry, ll rz) {
  pts.push_back(pt{cx ? cx - rx : rx, cy, cz});
  pts.push_back(pt{cx, cy ? cy - ry : ry, cz});
  pts.push_back(pt{cx, cy, cz ? cz - rz : rz});
}

struct Option { ll prod, x, y, z; };
vector<Option> generate_options(ll a, ll b, ll c) {
  vector<Option> options;
  for (ll x = 0; x <= a; ++x)
    for (ll y = 0; y <= b; ++y)
      for (ll z = 0; z <= c; ++z)
        options.push_back(Option{x*y*z, x, y, z});
  return options;
}

int main() {
  ll a, b, c, v;
  cin >> a >> b >> c >> v;

  ll in[3] = {a, b, c};
  sort(a, b, c);

  while (6LL * a * b * (c - 1) >= v) {
    c -= 1;
    sort(a, b, c);
  }

  ll r = 6 * a * b * c - v;
  cerr << ' ' << a << ' ' << b << ' '<< c << ' ' << r << endl;
  // Goal: remove r/6 volume from the a x b x c cube.
  // By construction, r < 6 * a * b.

  vector<pt> pts;
  pts.push_back(pt{0, 0, 0});
  pts.push_back(pt{a, b, 0});
  pts.push_back(pt{a, 0, c});
  pts.push_back(pt{0, b, c});
  

  if (c >= 6) {
    // Given a \leq b \leq c, c \geq 6, we find
    // 0 \leq u < a, 0 \leq v < b, 0 \leq w < c,
    // such that r = u + a*v + a*b*w.
    // This is possible since r < 6 * a * b and c \geq 6.

    ll w = r / (a * b);
    ll v = (r % (a * b)) / a;
    ll u = r % a;

    // Three cut corners
    // Take u * 1 * 1 from corner (a, 0, 0)
    // Take a * v * 1 from corner (0, b, 0)
    // take a * b * w from corner (0, 0, c)
    tetra_corner(pts, a, 0, 0, u, 1, 1);
    tetra_corner(pts, 0, b, 0, a, v, 1);
    tetra_corner(pts, 0, 0, c, a, b, w);

    // One unused corner.
    pts.push_back(pt{a, b, c});
  } else {
    // Try manually finding the four corners, we have max(a, b, c) \leq 6 anyway.
    vector<Option> options = generate_options(a, b, c);
    bool found = false;
    for (Option _a00 : options) {
      if (found) break;
      for (Option _0b0 : options) {
        if (found) break;
        for (Option _00c : options) {
          if (found) break;
          for (Option _abc : options) {
            if (_a00.prod + _0b0.prod + _00c.prod + _abc.prod != r)
              continue;
            tetra_corner(pts, a, 0, 0, _a00.x, _a00.y, _a00.z);
            tetra_corner(pts, 0, b, 0, _0b0.x, _0b0.y, _0b0.z);
            tetra_corner(pts, 0, 0, c, _00c.x, _00c.y, _00c.z);
            tetra_corner(pts, a, b, c, _abc.x, _abc.y, _abc.z);
            found = true;
            break;
          }
        }
      }
    }
  }

  fix_and_print(pts, in);
}