#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_N = 1000;
const int MAX_VAL = 0xFFFF;

void write_case(const vector<int> &v, string type, int digits = -1)
{
  ofstream out(filename(type));
  out << v.size() << endl;
  for (auto x : v) {
    if (digits < 0) {
      out << hex << uppercase << x << endl;
    } else {
      out << hex << uppercase << setw(digits) << setfill('0') << x << endl;
    }
  }
}

void write_case(const vector<string> &v, string type)
{
  ofstream out(filename(type));
  out << v.size() << endl;
  for (auto x : v) {
    out << x << endl;
  }
}

const int generic_size[] = { 1, 12, 57, 234, 1000 };

int random_any(int digit)
{
  int lo = (digit == 1) ? 0 : (1 << (4*(digit-1)));
  int hi = (1 << (4*digit)) - 1;
  return random_int(lo, hi);
}

int random_no_ambiguous(int digit)
{
  const string dig = "12345679ACEF";
  
  string s(digit, ' ');
  for (int i = 0; i < digit; i++) {
    s[i] = dig[random_int(0, 11)];
  }

  return stoi(s, nullptr, 16);
}

int random_only_ambiguous(int digit)
{
  const string dig = "08BD";
  string s(digit, ' ');
  for (int i = 0; i < digit; i++) {
    int lo = (i == 0 && digit > 1) ? 1 : 0;
    s[i] = dig[random_int(lo, 3)];
  }

  return stoi(s, nullptr, 16);
}

void only_ambiguous()
{
  for (int i = 0; i < 5; i++) {
    int N = generic_size[i];
    vector<int> v(N);
    for (auto &x : v) {
      x = random_only_ambiguous(random_int(1,4));
    }
    write_case(v, "only_ambiguous");
  }
}

void no_ambiguous()
{
  for (int i = 0; i < 5; i++) {
    int N = generic_size[i];
    vector<int> v(N);
    for (auto &x : v) {
      x = random_no_ambiguous(random_int(1,4));
    }
    write_case(v, "no_ambiguous");
  }
}

void justD()
{
  const int val[] = { 0xD, 0xDD, 0xDDD, 0xDDDD };
  
  vector<int> v(MAX_N);
  for (auto &x : v) {
    x = val[random_int(0, 3)];
  }
  write_case(v, "justD");
}

void just0()
{
  vector<int> v(MAX_N, 0);
  write_case(v, "just0");
}

void justFFFF()
{
  vector<int> v(MAX_N, 0xFFFF);
  write_case(v, "justFFFF");
}

void smallest()
{
  vector<int> v;
  v.push_back(0);
  write_case(v, "smallest");

  for (int i = 0; i < 10; i++) {
    v[0] = random_int(0, MAX_VAL);
    write_case(v, "smallest");
  }
}

void biggest()
{
  vector<int> v(MAX_N);
  for (auto &x : v) {
    x = random_int(0, MAX_VAL);
  }
  write_case(v, "biggest");
}

void leadingD()
{
  vector<int> v(MAX_N);
  for (auto &x : v) {
    x = random_int(0, (1 << 12)-1) + 0xD000;
  }
  write_case(v, "leadingD");
}

void leading0()
{
  for (int i = 0; i < 3; i++) {
    vector<int> v(MAX_N);
    for (auto &x : v) {
      x = random_int(0, (1 << 12)-1);
    }
    write_case(v, "leading0", 4);
  }
}

void different0()
{
  vector<string> v(MAX_N);
  for (auto &x : v) {
    int len = random_int(1, 4);
    x = string(len, '0');
  }
  write_case(v, "different0");
}

void random_case()
{
  for (int i = 0; i < 30; i++) {
    int N = random_int(1, MAX_N);
    vector<int> v(N);
    for (auto &x : v) {
      x = random_int(0, MAX_VAL);
    }
    write_case(v, "random");
  }
}

int main()
{
  only_ambiguous();
  no_ambiguous();
  justD();
  just0();
  justFFFF();
  leadingD();
  smallest();
  biggest();
  random_case();
  leading0();
  different0();
  
  return 0;
}