#include <bits/stdc++.h>

using namespace std;

default_random_engine generator;
uniform_int_distribution<int> distribution(0,INT_MAX);

int random_int(int lo, int hi)
{
  int t = distribution(generator) % (hi - lo + 1) + lo;
  return t;
}

string filename(const string &type)
{
  static int serial = 1;
  ostringstream oss;
  oss << setw(3) << setfill('0') << serial << "-" << type << ".in";
  serial++;
  return oss.str();
}

const int MAX_W = 500;
const int MAX_KC = 200;

void write_case(int W, int K, int C, const string &type)
{
  ofstream out(filename(type));
  out << W << ' ' << K << ' ' << C << endl;
}

const int generic_size[] = { 12, 57, 123, 157 };

void one_genie()
{
  // some yes cases when no extra genie is needed
  for (int i = 0; i < 4; i++) {
    write_case(generic_size[i], generic_size[i], random_int(1, MAX_KC),
	       "one_genie");
  }

  // some no cases when first genie already grants too many
  for (int i = 0; i < 4; i++) {
    write_case(generic_size[i], random_int(generic_size[i]+1, MAX_KC),
	       random_int(1, MAX_KC), "one_genie");
  }

  // some no cases when C is so large that it is effectively one genie
  for (int i = 0; i < 4; i++) {
    int K = random_int(2, generic_size[i]-1);
    write_case(generic_size[i], K, K-1, "one_genie");
    write_case(generic_size[i], K, random_int(K, MAX_KC), "one_genie");
  }
}

void boundary_input()
{
  // biggest and smallest values
  write_case(1, 1, 1, "boundary_input");
  write_case(1, 1, MAX_KC, "boundary_input");
  write_case(1, MAX_KC, 1, "boundary_input");
  write_case(1, MAX_KC, MAX_KC, "boundary_input");
  write_case(MAX_W, 1, 1, "boundary_input");
  write_case(MAX_W, 1, MAX_KC, "boundary_input");
  write_case(MAX_W, MAX_KC, 1, "boundary_input");
  write_case(MAX_W, MAX_KC, MAX_KC, "boundary_input");  
}

void boundary_case()
{
  for (int i = 0; i < 5; i++) {
    int K = random_int(3, 25);
    int C = random_int(1, K-2);

    int total = 0;
    int KK = K;
    while (KK > 1) {
      if (KK - C > 1) {
	total += KK-1;
      } else {
	total += KK;
      }
      KK -= C;
    }

    // number of wishes is not enough
    write_case(total+1, K, C, "boundary_yn");

    // just enough
    write_case(total, K, C, "boundary_yn");

    // more than enough (answer may be yes or no depending on C)
    if (total > 0)
      write_case(total-1, K, C, "boundary_yn");
  }
}

void random_case()
{
  for (int i = 0; i < 30; i++) {
    int K = random_int(1, MAX_W);
    int W = random_int(1, MAX_KC);
    int C = random_int(1, MAX_KC);
    write_case(K, W, C, "random");
  }
}

void slow()
{
  // large W, reasonable size of K but small C
  for (int i = 0; i < 10; i++) {
    int W = random_int(MAX_KC, MAX_W);
    int K = random_int(MAX_KC/2, MAX_KC);
    int C = random_int(1, 5);

    write_case(W-1, K, C, "slow_yn");
  }
}

int main()
{
  one_genie();
  boundary_input();
  boundary_case();
  slow();
  random_case();
  
  return 0;
}