diff --git a/tennis.c b/tennis.c
new file mode 100644
index 0000000..dce7a93
--- /dev/null
+++ b/tennis.c
@@ -0,0 +1,328 @@
+// arbitrary terminology i made up on the spot:
+// "entry" = code as exposed to user, in ASCII.
+// "code" = code as indices into lut, used internally.
+
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+typedef uint32_t u32;
+typedef uint64_t u64;
+
+#define lament(...) fprintf(stderr, __VA_ARGS__)
+#define sizeofel(a) (sizeof(*(a)))
+#define LEN(a) (sizeof(a) / sizeofel(a))
+
+const char *lut[] = {
+    // characters within the same string are considered the same.
+    // that means the number of choices for a single character
+    // goes down from 36 to 28.
+    "N", "P", "Q", "R",
+    "T", "W", "X", "Y",
+    "17I", "2Z", "5S", "8B",
+    "0OD", "UV", "3", "4",
+    "6", "9", "A", "C",
+    "E", "F", "G", "H",
+    "J", "K", "L", "M",
+};
+
+enum {lutlen = LEN(lut)}; // should be 28.
+
+const u32 bases[] = {
+    64,
+    11,
+    21,
+    2,
+    21,
+    8,
+    6, // dummy value.
+};
+
+enum {
+    MT_CHOICE = -1,
+};
+
+typedef enum {
+    MT_YOSHI,
+    MT_PEACH,
+    MT_MARIO,
+    MT_BOWSER,
+    MT_BOO,
+    MT_DK,
+    MT_BABY_MARIO,
+    MT_TOAD,
+    MT_WALUIGI,
+    MT_WARIO,
+    MT_LUIGI,
+    MT_DAISY,
+    MT_BIRDO,
+    MT_SHYGUY,
+    MT_DK_JR,
+    MT_PARATROOPA,
+} character_t;
+
+typedef enum {
+    MT_SINGLES_GAME,
+    MT_SINGLES_TIME_3,
+    MT_SINGLES_TIME_5,
+    MT_SINGLES_BALL_1,
+    MT_SINGLES_BALL_3,
+    MT_SINGLES_POINT_3,
+    MT_SINGLES_POINT_5,
+    MT_DOUBLES_GAME_1,
+    MT_DOUBLES_TIME_3,
+    MT_DOUBLES_BALL_1,
+    MT_DOUBLES_POINT_3,
+} gamemode_t;
+
+typedef enum {
+    MT_HARD,
+    MT_CLAY,
+    MT_GRASS,
+    MT_COMPOSITION,
+    MT_OPEN,
+} court_t;
+
+typedef struct {
+    char code[9];
+    // data[0]: cup name
+    // data[1]: gamemode
+    // data[2]: player character (-1 for player's choice)
+    // data[3]: unknown (boolean)
+    // data[4]: opponent character (-1 for player's choice)
+    // data[5]: unknown
+    // data[6]: court (-1 for player's choice)
+    u32 data[7];
+} code_t;
+
+code_t translate(const char *entry) {
+    code_t code = {0};
+    for (int i = 0; i < 9; i++) {
+        char e = entry[i];
+        if (e == '\0') return code;
+        for (int j = 0; j < lutlen; j++) {
+            const char *c = lut[j];
+            while (*c != '\0') {
+                if (e == *c) {
+                    code.code[i] = j;
+                    goto nextchar;
+                }
+                c++;
+            }
+        }
+    nextchar:
+        ;
+    }
+    return code;
+}
+
+int check_ranges(const code_t *code) {
+    const u32 choice = (u32)MT_CHOICE;
+    const u32 *data = code->data;
+
+    return
+        (data[0] < bases[0]) && 
+        (data[1] < bases[1]) &&
+        (data[2] + 1 < bases[2] - 4) &&
+        (data[3] < bases[3]) &&
+        (data[4] + 1 < bases[4] - 4) &&
+        (data[5] < bases[5]) &&
+        (data[6] + 1 < bases[6]) &&
+        (data[2] == choice || data[2] != data[4]) &&
+        (data[1] < 7 || (data[2] != choice && data[4] != choice));
+}
+
+int decode_data(code_t *code) {
+    u32 part0 = 0, part1 = 0;
+    for (int i = 5; i >= 0; i--) part0 = part0 * lutlen + code->code[i];
+    for (int i = 8; i >= 6; i--) part1 = part1 * lutlen + code->code[i];
+    u32 checksum = (part0 + 0x2AE0) % (lutlen * lutlen * lutlen);
+
+#if !NDEBUG
+    lament("merged data: %08X\n", part0);
+    lament("expected checksum: %08X\n", part1);
+    lament("actual checksum: %08X\n", checksum);
+#endif
+
+    u32 leftover = part0 ^ 0x02AAAAAA;
+
+    code->data[0] = leftover % bases[0]; leftover /= bases[0];
+    code->data[1] = leftover % bases[1]; leftover /= bases[1];
+    code->data[2] = leftover % bases[2]; leftover /= bases[2];
+    code->data[3] = leftover % bases[3]; leftover /= bases[3];
+    code->data[4] = leftover % bases[4]; leftover /= bases[4];
+    code->data[5] = leftover % bases[5]; leftover /= bases[5];
+    code->data[6] = leftover;
+
+    code->data[2]--;
+    code->data[4]--;
+    code->data[6]--;
+
+#if !NDEBUG
+    lament("stored data:");
+    for (int i = 0; i < 7; i++) lament(" %i", code->data[i]);
+    lament("\n");
+#endif
+
+    if (checksum != part1) return 0;
+
+    if (!check_ranges(code)) return 0;
+
+    return 1;
+}
+
+int encode_data(code_t *code) {
+    if (!check_ranges(code)) return 0;
+
+    u32 combined = 0;
+    combined = code->data[6] + 1;
+    combined = combined * bases[5] + code->data[5];
+    combined = combined * bases[4] + code->data[4] + 1;
+    combined = combined * bases[3] + code->data[3];
+    combined = combined * bases[2] + code->data[2] + 1;
+    combined = combined * bases[1] + code->data[1];
+    combined = combined * bases[0] + code->data[0];
+    combined = combined ^ 0x02AAAAAA;
+
+    u32 checksum = (combined + 0x2AE0) % (lutlen * lutlen * lutlen);
+
+#if !NDEBUG
+    lament("merged data: %08X\n", combined);
+    lament("checksum: %08X\n", checksum);
+#endif
+
+    u32 part0 = combined, part1 = checksum;
+    for (int i = 0; i <= 5; i++) {
+        code->code[i] = part0 % lutlen; part0 /= lutlen;
+    }
+    for (int i = 6; i <= 8; i++) {
+        code->code[i] = part1 % lutlen; part1 /= lutlen;
+    }
+
+    return 1;
+}
+
+int validate_entry(const char *entry) {
+    code_t code = translate(entry);
+
+#if !NDEBUG
+    lament("character mapping:");
+    for (int i = 0; i < 9; i++) {
+        lament(" %c->%i,", entry[i], code.code[i]);
+    }
+    lament("\n");
+#endif
+
+    return decode_data(&code);
+}
+
+static void print_code(const code_t *code) {
+    for (int j = 0; j < 9; j++) {
+        int index = code->code[j];
+        printf("%c", lut[index][0]);
+    }
+    printf("\n");
+}
+
+static u64 prng_state = 1;
+static u32 prng() {
+    prng_state = 3935559000370003845 * prng_state + 1;
+    return prng_state ^ (prng_state >> 32);
+}
+
+int bruteforce(int count) {
+    /*  with a fixed seed, this is useful for testing.
+        the first 10 results should be:
+        8RPEHR8R4
+        MNXKWQMNE
+        CE922RCER
+        MQ1KMQMQG
+        2N9GGR2NR
+        25L53R250
+        15R09R159
+        9R9LMQ9RR
+        L312MQL3G
+        P93M6QP9N
+    */
+
+    int found = 0;
+    code_t code = {0};
+    while (found < count) {
+        for (int j = 0; j < 9; j++) {
+            code.code[j] = prng() % lutlen;
+        }
+        if (decode_data(&code)) {
+            found++;
+            print_code(&code);
+        }
+    }
+    return 1;
+}
+
+#ifndef TENNIS_NO_MAIN
+int main(int argc, char **argv) {
+    if (argc == 1) {
+        // self-test with codes known before this program was written.
+#define TEST(entry) if (!validate_entry(entry)) return -1
+        TEST("48HWOR482");
+        TEST("5G3LTQ5GN");
+        TEST("A3W5KQA3C");
+        TEST("ARM6JQARU");
+        TEST("E880MPE8K");
+        TEST("E8ULJRE8M");
+        TEST("EPJEGREP5");
+        TEST("GH4KNQGHP");
+        TEST("H6L3MPH60");
+        TEST("HH4KNQHHP");
+        TEST("J6M9PQJ6U");
+        TEST("JEP8YQJE4");
+        TEST("LA98JRLAR");
+        TEST("LQM1MPLQU");
+        TEST("LTHWYQLT2");
+        TEST("M1C2YQM1W");
+        TEST("MM55MQMMJ");
+        TEST("N24K8QN2P");
+        TEST("OF9XFQOFR");
+        TEST("P4K6GRP48");
+        TEST("TE6WARTEQ");
+        TEST("TQJEGRTQ5");
+        TEST("UOUFMPUOM");
+        TEST("V2UFMPUZM");
+        TEST("W2HEGRW22");
+        TEST("WQJEGRWQ5");
+        TEST("WRWQARWRC");
+        TEST("YQJEGRYQ5");
+#undef TEST
+        return 0;
+    }
+
+    code_t code = {0};
+    int code_i = 0;
+
+    int invalid_count = 0;
+    for (int i = 1; i < argc; i++) {
+        const char *arg = argv[i];
+        if (strlen(arg) == 9) {
+            //if (validate_entry(arg)) printf("%s\n", arg);
+            invalid_count += !validate_entry(arg);
+        } else if (!strcmp(arg, "bruteforce")) {
+            invalid_count += !bruteforce(10);
+        } else {
+            u32 datum = strtoul(arg, NULL, 0);
+            code.data[code_i] = datum;
+            code_i++;
+
+            if (code_i >= 7) {
+                code_i = 0;
+                if (encode_data(&code)) {
+                    print_code(&code);
+                } else {
+                    invalid_count++;
+                }
+            }
+        }
+    }
+    return invalid_count;
+}
+#endif