#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]; };

// The two special cases.
vector<pt> r5 = vector<pt>{pt{0,0,0}, pt{0,0,1}, pt{0,1,0}, pt{1,0,0}};
vector<pt> r23 = vector<pt>{
  // Trial and error find.
  pt{0,0,2}, pt{2,0,0}, pt{0,2,0},
  pt{1,0,2}, pt{2,1,2}, pt{2,0,1},
  pt{0,2,2}, pt{1,2,2}, pt{2,1,2}};

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;
          }
        }
      }
    }

    if (!found) {
      // This means we have found one of:
      // (a, b, c, v, r) = (1, 1, 1, 1, 5)
      // (a, b, c, v, r) = (2, 2, 2, 25, 23)
      if (r == 5) {
        pts = r5;
      } else { // r == 23
        pts = r23;
      }
    }
  }
  
  cout << pts.size() << '\n';
  for (pt vtx : pts)
    cout << vtx.v[0] << ' ' << vtx.v[1] << ' ' << vtx.v[2] << '\n';
}