diff --git a/src/lib/utils/contest.ts b/src/lib/utils/contest.ts
index 50f7867db..309299ae0 100644
--- a/src/lib/utils/contest.ts
+++ b/src/lib/utils/contest.ts
@@ -108,7 +108,7 @@ const AGC_LIKE: ContestPrefix = {
 } as const;
 const agcLikePrefixes = getContestPrefixes(AGC_LIKE);
 
-// HACK: As of early November 2024, only UTPC is included.
+// HACK: As of November 2024, UTPC, TTPC and TUPC are included.
 // More university contests may be added in the future.
 /**
  * Maps university contest ID prefixes to their display names.
@@ -190,7 +190,7 @@ export function getContestPrefixes(contestPrefixes: Record<string, string>) {
 }
 
 /**
- * Contest type priorities (0 = Highest, 19 = Lowest)
+ * Contest type priorities (0 = Highest, 20 = Lowest)
  *
  * Priority assignment rationale:
  * - Educational contests (0-10): ABS, ABC, APG4B, etc.
@@ -240,54 +240,122 @@ export function getContestPriority(contestId: string): number {
   }
 }
 
-export const getContestNameLabel = (contest_id: string) => {
-  if (contest_id === 'APG4b' || contest_id === 'APG4bPython') {
-    return contest_id;
+/**
+ * Regular expression to match contest codes.
+ *
+ * This regex matches strings that start with one of the following prefixes:
+ * - "abc"
+ * - "arc"
+ * - "agc"
+ *
+ * followed by exactly three digits. The matching is case-insensitive.
+ *
+ * Example matches:
+ * - "abc376"
+ * - "ARC128"
+ * - "agc045"
+ *
+ * Example non-matches:
+ * - "xyz123"
+ * - "abc12"
+ * - "abc1234"
+ */
+const regexForAxc = /^(abc|arc|agc)(\d{3})/i;
+
+/**
+ * Regular expression to match AtCoder University contest identifiers.
+ *
+ * The pattern matches strings that:
+ * - Start with either "ut", "tt", or "tu"
+ * - Followed by "pc"
+ * - End with exactly year (four digits)
+ *
+ * Example matches:
+ * - "utpc2014"
+ * - "ttpc2022"
+ * - "tupc2023"
+ */
+const regexForAtCoderUniversity = /^(ut|tt|tu)(pc)(\d{4})/i;
+
+export const getContestNameLabel = (contestId: string) => {
+  // AtCoder
+  if (regexForAxc.exec(contestId)) {
+    return contestId.replace(
+      regexForAxc,
+      (_, contestType, contestNumber) => `${contestType.toUpperCase()} ${contestNumber}`,
+    );
   }
 
-  if (contest_id === 'typical90') {
+  if (contestId === 'APG4b' || contestId === 'APG4bPython') {
+    return contestId;
+  }
+
+  if (contestId === 'typical90') {
     return '競プロ典型 90 問';
   }
 
-  if (contest_id === 'dp') {
+  if (contestId === 'dp') {
     return 'EDPC';
   }
 
-  if (contest_id === 'tdpc') {
+  if (contestId === 'tdpc') {
     return 'TDPC';
   }
 
-  if (contest_id === 'practice2') {
+  if (contestId === 'practice2') {
     return 'ACL Practice';
   }
 
-  if (contest_id === 'tessoku-book') {
+  if (contestId === 'tessoku-book') {
     return '競技プログラミングの鉄則';
   }
 
-  if (contest_id === 'math-and-algorithm') {
+  if (contestId === 'math-and-algorithm') {
     return 'アルゴリズムと数学';
   }
 
-  if (contest_id.startsWith('chokudai_S')) {
-    return contest_id.replace('chokudai_S', 'Chokudai SpeedRun ');
+  if (regexForAtCoderUniversity.exec(contestId)) {
+    return getAtCoderUniversityContestLabel(contestId);
   }
 
-  if (aojCoursePrefixes.has(contest_id)) {
+  if (contestId.startsWith('chokudai_S')) {
+    return contestId.replace('chokudai_S', 'Chokudai SpeedRun ');
+  }
+
+  // AIZU ONLINE JUDGE
+  if (aojCoursePrefixes.has(contestId)) {
     return 'AOJ Courses';
   }
 
-  if (contest_id.startsWith('PCK')) {
-    return getAojChallengeLabel(PCK_TRANSLATIONS, contest_id);
+  if (contestId.startsWith('PCK')) {
+    return getAojChallengeLabel(PCK_TRANSLATIONS, contestId);
   }
 
-  if (contest_id.startsWith('JAG')) {
-    return getAojChallengeLabel(JAG_TRANSLATIONS, contest_id);
+  if (contestId.startsWith('JAG')) {
+    return getAojChallengeLabel(JAG_TRANSLATIONS, contestId);
   }
 
-  return contest_id.toUpperCase();
+  return contestId.toUpperCase();
 };
 
+/**
+ * Generates a formatted contest label for AtCoder University contests.
+ *
+ * This function takes a contest ID string and replaces parts of it using a regular expression
+ * to generate a formatted label. The label is constructed by converting the contest type and
+ * common part to uppercase and appending the contest year.
+ *
+ * @param contestId - The ID of the contest to format (ex: utpc2023).
+ * @returns The formatted contest label (ex: UTPC 2023).
+ */
+export function getAtCoderUniversityContestLabel(contestId: string): string {
+  return contestId.replace(
+    regexForAtCoderUniversity,
+    (_, contestType, common, contestYear) =>
+      `${(contestType + common).toUpperCase()} ${contestYear}`,
+  );
+}
+
 /**
  * Maps PCK contest type abbreviations to their Japanese translations.
  *
@@ -300,8 +368,8 @@ export const getContestNameLabel = (contest_id: string) => {
  */
 const PCK_TRANSLATIONS = {
   PCK: 'パソコン甲子園',
-  Prelim: '予選',
-  Final: '本選',
+  Prelim: ' 予選 ',
+  Final: ' 本選 ',
 };
 
 /**
@@ -309,17 +377,15 @@ const PCK_TRANSLATIONS = {
  *
  * @example
  * {
- *   Prelim: '模擬国内予選',
- *   Regional: '模擬アジア地区予選'
+ *   Prelim: '模擬国内',
+ *   Regional: '模擬地区'
  * }
  */
 const JAG_TRANSLATIONS = {
-  Prelim: '模擬国内予選',
-  Regional: '模擬アジア地区予選',
+  Prelim: ' 模擬国内 ',
+  Regional: ' 模擬地区 ',
 };
 
-const aojBaseLabel = 'AOJ - ';
-
 function getAojChallengeLabel(
   translations: Readonly<ContestLabelTranslations>,
   contestId: string,
@@ -330,11 +396,19 @@ function getAojChallengeLabel(
     label = label.replace(abbrEnglish, japanese);
   });
 
-  return aojBaseLabel + label;
+  return '（' + label + '）';
 }
 
 export const addContestNameToTaskIndex = (contestId: string, taskTableIndex: string): string => {
   const contestName = getContestNameLabel(contestId);
 
+  if (isAojContest(contestId)) {
+    return `AOJ ${taskTableIndex}${contestName}`;
+  }
+
   return `${contestName} - ${taskTableIndex}`;
 };
+
+function isAojContest(contestId: string): boolean {
+  return contestId.startsWith('PCK') || contestId.startsWith('JAG');
+}
diff --git a/src/test/lib/utils/contest.test.ts b/src/test/lib/utils/contest.test.ts
index c3ca37ea1..530908967 100644
--- a/src/test/lib/utils/contest.test.ts
+++ b/src/test/lib/utils/contest.test.ts
@@ -350,30 +350,6 @@ describe('Contest', () => {
 
   describe('get contest name label', () => {
     describe('AtCoder', () => {
-      describe('when contest_id contains abc', () => {
-        TestCasesForContestNameLabel.abc.forEach(({ name, value }) => {
-          runTests(`${name}`, [value], ({ contestId, expected }: TestCaseForContestNameLabel) => {
-            expect(getContestNameLabel(contestId)).toEqual(expected);
-          });
-        });
-      });
-
-      describe('when contest_id starts with APG4b', () => {
-        TestCasesForContestNameLabel.apg4b.forEach(({ name, value }) => {
-          runTests(`${name}`, [value], ({ contestId, expected }: TestCaseForContestNameLabel) => {
-            expect(getContestNameLabel(contestId)).toEqual(expected);
-          });
-        });
-      });
-
-      describe('when contest_id is typical90', () => {
-        TestCasesForContestNameLabel.typical90.forEach(({ name, value }) => {
-          runTests(`${name}`, [value], ({ contestId, expected }: TestCaseForContestNameLabel) => {
-            expect(getContestNameLabel(contestId)).toEqual(expected);
-          });
-        });
-      });
-
       describe('when contest_id is dp (EDPC)', () => {
         TestCasesForContestNameLabel.edpc.forEach(({ name, value }) => {
           runTests(`${name}`, [value], ({ contestId, expected }: TestCaseForContestNameLabel) => {
@@ -422,46 +398,6 @@ describe('Contest', () => {
         });
       });
 
-      describe('when contest_id is tessoku-book', () => {
-        TestCasesForContestNameLabel.tessokuBook.forEach(({ name, value }) => {
-          runTests(`${name}`, [value], ({ contestId, expected }: TestCaseForContestNameLabel) => {
-            expect(getContestNameLabel(contestId)).toEqual(expected);
-          });
-        });
-      });
-
-      describe('when contest_id is math-and-algorithm', () => {
-        TestCasesForContestNameLabel.mathAndAlgorithm.forEach(({ name, value }) => {
-          runTests(`${name}`, [value], ({ contestId, expected }: TestCaseForContestNameLabel) => {
-            expect(getContestNameLabel(contestId)).toEqual(expected);
-          });
-        });
-      });
-
-      describe('when contest_id contains arc', () => {
-        TestCasesForContestNameLabel.arc.forEach(({ name, value }) => {
-          runTests(`${name}`, [value], ({ contestId, expected }: TestCaseForContestNameLabel) => {
-            expect(getContestNameLabel(contestId)).toEqual(expected);
-          });
-        });
-      });
-
-      describe('when contest_id contains agc', () => {
-        TestCasesForContestNameLabel.agc.forEach(({ name, value }) => {
-          runTests(`${name}`, [value], ({ contestId, expected }: TestCaseForContestNameLabel) => {
-            expect(getContestNameLabel(contestId)).toEqual(expected);
-          });
-        });
-      });
-
-      describe('when contest_id matches contests held by university students', () => {
-        TestCasesForContestNameLabel.universities.forEach(({ name, value }) => {
-          runTests(`${name}`, [value], ({ contestId, expected }: TestCaseForContestNameLabel) => {
-            expect(getContestNameLabel(contestId)).toEqual(expected);
-          });
-        });
-      });
-
       describe('when contest_id contains chokudai_S', () => {
         TestCasesForContestNameLabel.atCoderOthers.forEach(({ name, value }) => {
           runTests(`${name}`, [value], ({ contestId, expected }: TestCaseForContestNameLabel) => {
@@ -470,32 +406,6 @@ describe('Contest', () => {
         });
       });
     });
-
-    describe('AOJ', () => {
-      describe('when contest_id means AOJ courses', () => {
-        TestCasesForContestNameLabel.aojCourses.forEach(({ name, value }) => {
-          runTests(`${name}`, [value], ({ contestId, expected }: TestCaseForContestNameLabel) => {
-            expect(getContestNameLabel(contestId)).toEqual(expected);
-          });
-        });
-      });
-
-      describe('when contest_id means AOJ PCK (prelim and final)', () => {
-        TestCasesForContestNameLabel.aojPck.forEach(({ name, value }) => {
-          runTests(`${name}`, [value], ({ contestId, expected }: TestCaseForContestNameLabel) => {
-            expect(getContestNameLabel(contestId)).toEqual(expected);
-          });
-        });
-      });
-
-      describe('when contest_id means AOJ JAG (prelim and regional)', () => {
-        TestCasesForContestNameLabel.aojJag.forEach(({ name, value }) => {
-          runTests(`${name}`, [value], ({ contestId, expected }: TestCaseForContestNameLabel) => {
-            expect(getContestNameLabel(contestId)).toEqual(expected);
-          });
-        });
-      });
-    });
   });
 
   describe('add contest name to task index', () => {
diff --git a/src/test/lib/utils/test_cases/contest_name_and_task_index.ts b/src/test/lib/utils/test_cases/contest_name_and_task_index.ts
index 6b4b99350..267f3f7fd 100644
--- a/src/test/lib/utils/test_cases/contest_name_and_task_index.ts
+++ b/src/test/lib/utils/test_cases/contest_name_and_task_index.ts
@@ -1,4 +1,5 @@
 import { createTestCase, zip } from '../../common/test_helpers';
+import { getAtCoderUniversityContestLabel } from '$lib/utils/contest';
 
 export type TestCaseForContestNameAndTaskIndex = {
   contestId: string;
@@ -13,13 +14,13 @@ const generateAbcTestCases = (
   taskIndices: string[],
 ): { name: string; value: TestCaseForContestNameAndTaskIndex }[] => {
   return zip(contestIds, taskIndices).map(([contestId, taskIndex]) => {
-    const testCase = createTestCaseForContestNameAndTaskIndex(`ABC${contestId}, task ${taskIndex}`)(
-      {
-        contestId: `abc${contestId}`,
-        taskTableIndex: taskIndex,
-        expected: `ABC${contestId} - ${taskIndex}`,
-      },
-    );
+    const testCase = createTestCaseForContestNameAndTaskIndex(
+      `ABC ${contestId}, task ${taskIndex}`,
+    )({
+      contestId: `abc${contestId}`,
+      taskTableIndex: taskIndex,
+      expected: `ABC ${contestId} - ${taskIndex}`,
+    });
 
     return testCase;
   });
@@ -162,13 +163,13 @@ const generateArcTestCases = (
   taskIndices: string[],
 ): { name: string; value: TestCaseForContestNameAndTaskIndex }[] => {
   return zip(contestIds, taskIndices).map(([contestId, taskIndex]) => {
-    const testCase = createTestCaseForContestNameAndTaskIndex(`ARC${contestId}, task ${taskIndex}`)(
-      {
-        contestId: `arc${contestId}`,
-        taskTableIndex: taskIndex,
-        expected: `ARC${contestId} - ${taskIndex}`,
-      },
-    );
+    const testCase = createTestCaseForContestNameAndTaskIndex(
+      `ARC ${contestId}, task ${taskIndex}`,
+    )({
+      contestId: `arc${contestId}`,
+      taskTableIndex: taskIndex,
+      expected: `ARC ${contestId} - ${taskIndex}`,
+    });
 
     return testCase;
   });
@@ -184,13 +185,13 @@ const generateAgcTestCases = (
   taskIndices: string[],
 ): { name: string; value: TestCaseForContestNameAndTaskIndex }[] => {
   return zip(contestIds, taskIndices).map(([contestId, taskIndex]) => {
-    const testCase = createTestCaseForContestNameAndTaskIndex(`AGC${contestId}, task ${taskIndex}`)(
-      {
-        contestId: `agc${contestId}`,
-        taskTableIndex: taskIndex,
-        expected: `AGC${contestId} - ${taskIndex}`,
-      },
-    );
+    const testCase = createTestCaseForContestNameAndTaskIndex(
+      `AGC ${contestId}, task ${taskIndex}`,
+    )({
+      contestId: `agc${contestId}`,
+      taskTableIndex: taskIndex,
+      expected: `AGC ${contestId} - ${taskIndex}`,
+    });
 
     return testCase;
   });
@@ -220,6 +221,13 @@ interface UniversityContestsTestData {
   [key: string]: UniversityContestTestData;
 }
 
+// Note:
+// UTPC contests on AtCoder: 2011-2014 and 2020-2023 (not held during 2015-2019)
+// TTPC contests on AtCoder: 2015, 2019, 2022-
+// TUPC contests on AtCoder: 2022-
+//
+// See:
+// https://kenkoooo.com/atcoder/resources/contests.json
 type UtpcTaskPatterns = {
   '2011-2014': string[];
   '2020': string[];
@@ -300,11 +308,11 @@ const generateUniversityTestCases = (
 ): { name: string; value: TestCaseForContestNameAndTaskIndex }[] => {
   return zip(contestIds, taskIndices).map(([contestId, taskIndex]) => {
     const testCase = createTestCaseForContestNameAndTaskIndex(
-      `${contestId.toUpperCase()} ${taskIndex}`,
+      `${getAtCoderUniversityContestLabel(contestId)} ${taskIndex}`,
     )({
       contestId: `${contestId}`,
       taskTableIndex: taskIndex,
-      expected: `${contestId.toUpperCase()} - ${taskIndex}`,
+      expected: `${getAtCoderUniversityContestLabel(contestId)} - ${taskIndex}`,
     });
 
     return testCase;
@@ -382,37 +390,37 @@ export const aojCourses = Object.entries(AOJ_COURSES_TEST_DATA).flatMap(([contes
  * Format: {round}{year} - {problemId}
  */
 const AOJ_PCK_TEST_DATA = {
-  Prelim2023: {
-    contestId: 'Prelim2023',
-    tasks: ['4012', '4013', '4022'],
-  },
-  Prelim2022: {
-    contestId: 'Prelim2022',
-    tasks: ['0479', '0489'],
+  Prelim2004: {
+    contestId: 'Prelim2004',
+    tasks: ['0027', '0043'],
   },
   Prelim2005: {
     contestId: 'Prelim2005',
     tasks: ['0073', '0092'],
   },
-  Prelim2004: {
-    contestId: 'Prelim2004',
-    tasks: ['0027', '0043'],
+  Prelim2022: {
+    contestId: 'Prelim2022',
+    tasks: ['0479', '0489'],
   },
-  Final2023: {
-    contestId: 'Final2023',
-    tasks: ['4023', '4035'],
+  Prelim2023: {
+    contestId: 'Prelim2023',
+    tasks: ['4012', '4013', '4022'],
   },
-  Final2022: {
-    contestId: 'Final2022',
-    tasks: ['4000', '4011'],
+  Final2003: {
+    contestId: 'Final2003',
+    tasks: ['0000', '0098'],
   },
   Final2004: {
     contestId: 'Final2004',
     tasks: ['0044', '0097'],
   },
-  Final2003: {
-    contestId: 'Final2003',
-    tasks: ['0000', '0098'],
+  Final2022: {
+    contestId: 'Final2022',
+    tasks: ['4000', '4011'],
+  },
+  Final2023: {
+    contestId: 'Final2023',
+    tasks: ['4023', '4035'],
   },
 };
 
@@ -431,7 +439,7 @@ const generateAojPckTestCases = (
     )({
       contestId: `PCK${contestId}`,
       taskTableIndex: taskIndex,
-      expected: `AOJ - パソコン甲子園${contestId.replace('Prelim', '予選').replace('Final', '本選')} - ${taskIndex}`,
+      expected: `AOJ ${taskIndex}（パソコン甲子園${contestId.replace('Prelim', ' 予選 ').replace('Final', ' 本選 ')}）`,
     });
 
     return testCase;
@@ -533,7 +541,7 @@ const generateAojJagTestCases = (contestIds: JagContestIds, taskIndices: string[
     taskIndices,
     (contestId, taskIndex) => `AOJ, JAG${contestId} - ${taskIndex}`,
     (contestId, taskIndex) =>
-      `AOJ - JAG${contestId.replace('Prelim', '模擬国内予選').replace('Regional', '模擬アジア地区予選')} - ${taskIndex}`,
+      `AOJ ${taskIndex}（JAG${contestId.replace('Prelim', ' 模擬国内 ').replace('Regional', ' 模擬地区 ')}）`,
   );
 
 export const aojJag = Object.entries(AOJ_JAG_TEST_DATA).flatMap(([contestId, tasks]) =>
diff --git a/src/test/lib/utils/test_cases/contest_name_labels.ts b/src/test/lib/utils/test_cases/contest_name_labels.ts
index 07b8ce1ec..d5008dea9 100644
--- a/src/test/lib/utils/test_cases/contest_name_labels.ts
+++ b/src/test/lib/utils/test_cases/contest_name_labels.ts
@@ -7,49 +7,6 @@ export type TestCaseForContestNameLabel = {
 
 const createTestCaseForContestNameLabel = createTestCase<TestCaseForContestNameLabel>;
 
-const generateAbcTestCases = (
-  contestIds: string[],
-): { name: string; value: TestCaseForContestNameLabel }[] => {
-  return contestIds.map((contestId) => {
-    const testCase = createTestCaseForContestNameLabel(`ABC${contestId}`)({
-      contestId: `abc${contestId}`,
-      expected: `ABC${contestId}`,
-    });
-
-    return testCase;
-  });
-};
-
-export const abc = generateAbcTestCases([
-  '001',
-  '002',
-  '099',
-  '100',
-  '101',
-  '200',
-  '201',
-  '365',
-  '999',
-]);
-
-export const apg4b = [
-  createTestCaseForContestNameLabel('APG4b')({
-    contestId: 'APG4b',
-    expected: 'APG4b',
-  }),
-  createTestCaseForContestNameLabel('APG4b Python')({
-    contestId: 'APG4bPython',
-    expected: 'APG4bPython',
-  }),
-];
-
-export const typical90 = [
-  createTestCaseForContestNameLabel('Typical90')({
-    contestId: 'typical90',
-    expected: '競プロ典型 90 問',
-  }),
-];
-
 export const edpc = [
   createTestCaseForContestNameLabel('DP')({
     contestId: 'dp',
@@ -155,152 +112,6 @@ export const joi = [
   }),
 ];
 
-export const tessokuBook = [
-  createTestCaseForContestNameLabel('Tessoku Book')({
-    contestId: 'tessoku-book',
-    expected: '競技プログラミングの鉄則',
-  }),
-];
-
-export const mathAndAlgorithm = [
-  createTestCaseForContestNameLabel('Math and Algorithm')({
-    contestId: 'math-and-algorithm',
-    expected: 'アルゴリズムと数学',
-  }),
-];
-
-export const arc = [
-  createTestCaseForContestNameLabel('ARC001')({
-    contestId: 'arc001',
-    expected: 'ARC001',
-  }),
-  createTestCaseForContestNameLabel('ARC002')({
-    contestId: 'arc002',
-    expected: 'ARC002',
-  }),
-  createTestCaseForContestNameLabel('ARC057')({
-    contestId: 'arc057',
-    expected: 'ARC057',
-  }),
-  createTestCaseForContestNameLabel('ARC058')({
-    contestId: 'arc058',
-    expected: 'ARC058',
-  }),
-  createTestCaseForContestNameLabel('ARC099')({
-    contestId: 'arc099',
-    expected: 'ARC099',
-  }),
-  createTestCaseForContestNameLabel('ARC100')({
-    contestId: 'arc100',
-    expected: 'ARC100',
-  }),
-  createTestCaseForContestNameLabel('ARC101')({
-    contestId: 'arc101',
-    expected: 'ARC101',
-  }),
-  createTestCaseForContestNameLabel('ARC103')({
-    contestId: 'arc103',
-    expected: 'ARC103',
-  }),
-  createTestCaseForContestNameLabel('ARC104')({
-    contestId: 'arc104',
-    expected: 'ARC104',
-  }),
-  createTestCaseForContestNameLabel('ARC105')({
-    contestId: 'arc105',
-    expected: 'ARC105',
-  }),
-  createTestCaseForContestNameLabel('ARC182')({
-    contestId: 'arc182',
-    expected: 'ARC182',
-  }),
-  createTestCaseForContestNameLabel('ARC183')({
-    contestId: 'arc183',
-    expected: 'ARC183',
-  }),
-];
-
-export const agc = [
-  createTestCaseForContestNameLabel('AGC001')({
-    contestId: 'agc001',
-    expected: 'AGC001',
-  }),
-  createTestCaseForContestNameLabel('AGC002')({
-    contestId: 'agc002',
-    expected: 'AGC002',
-  }),
-  createTestCaseForContestNameLabel('AGC009')({
-    contestId: 'agc009',
-    expected: 'AGC009',
-  }),
-  createTestCaseForContestNameLabel('AGC010')({
-    contestId: 'agc010',
-    expected: 'AGC010',
-  }),
-  createTestCaseForContestNameLabel('AGC011')({
-    contestId: 'agc011',
-    expected: 'AGC011',
-  }),
-  createTestCaseForContestNameLabel('AGC066')({
-    contestId: 'agc066',
-    expected: 'AGC066',
-  }),
-  createTestCaseForContestNameLabel('AGC067')({
-    contestId: 'agc067',
-    expected: 'AGC067',
-  }),
-];
-
-const generateUtpcTestCases = (
-  years: number[],
-): { name: string; value: TestCaseForContestNameLabel }[] => {
-  return years.map((year) => {
-    const testCase = createTestCaseForContestNameLabel(`UTPC ${year}`)({
-      contestId: `utpc${year}`,
-      expected: `UTPC${year}`,
-    });
-
-    return testCase;
-  });
-};
-const generateTtpcTestCases = (
-  years: number[],
-): { name: string; value: TestCaseForContestNameLabel }[] => {
-  return years.map((year) => {
-    const testCase = createTestCaseForContestNameLabel(`TTPC ${year}`)({
-      contestId: `ttpc${year}`,
-      expected: `TTPC${year}`,
-    });
-
-    return testCase;
-  });
-};
-const generateTupcTestCases = (
-  years: number[],
-): { name: string; value: TestCaseForContestNameLabel }[] => {
-  return years.map((year) => {
-    const testCase = createTestCaseForContestNameLabel(`TUPC ${year}`)({
-      contestId: `tupc${year}`,
-      expected: `TUPC${year}`,
-    });
-
-    return testCase;
-  });
-};
-
-// Note:
-// UTPC contests on AtCoder: 2011-2014 and 2020-2023 (not held during 2015-2019)
-// TTPC contests on AtCoder: 2015, 2019, 2022-
-// TUPC contests on AtCoder: 2022-
-//
-// See:
-// https://kenkoooo.com/atcoder/resources/contests.json
-export const universities = [
-  ...generateUtpcTestCases([2011, 2012, 2013, 2014, 2020, 2021, 2022, 2023]),
-  ...generateTtpcTestCases([2015, 2019, 2022, 2023]),
-  ...generateTupcTestCases([2022, 2023]),
-];
-
 export const atCoderOthers = [
   createTestCaseForContestNameLabel('Chokudai SpeedRun 001')({
     contestId: 'chokudai_S001',
@@ -311,144 +122,3 @@ export const atCoderOthers = [
     expected: 'Chokudai SpeedRun 002',
   }),
 ];
-
-export const aojCourses = [
-  createTestCaseForContestNameLabel('AOJ Courses, ITP1')({
-    contestId: 'ITP1',
-    expected: 'AOJ Courses',
-  }),
-  createTestCaseForContestNameLabel('AOJ Courses, ALDS1')({
-    contestId: 'ALDS1',
-    expected: 'AOJ Courses',
-  }),
-  createTestCaseForContestNameLabel('AOJ Courses, ITP2')({
-    contestId: 'ITP2',
-    expected: 'AOJ Courses',
-  }),
-  createTestCaseForContestNameLabel('AOJ Courses, DPL')({
-    contestId: 'DPL',
-    expected: 'AOJ Courses',
-  }),
-];
-
-export const aojPck = [
-  createTestCaseForContestNameLabel('AOJ, PCK Prelim 2023')({
-    contestId: 'PCKPrelim2023',
-    expected: 'AOJ - パソコン甲子園予選2023',
-  }),
-  createTestCaseForContestNameLabel('AOJ, PCK Prelim 2022')({
-    contestId: 'PCKPrelim2022',
-    expected: 'AOJ - パソコン甲子園予選2022',
-  }),
-  createTestCaseForContestNameLabel('AOJ, PCK Prelim 2005')({
-    contestId: 'PCKPrelim2005',
-    expected: 'AOJ - パソコン甲子園予選2005',
-  }),
-  createTestCaseForContestNameLabel('AOJ, PCK Prelim 2004')({
-    contestId: 'PCKPrelim2004',
-    expected: 'AOJ - パソコン甲子園予選2004',
-  }),
-  createTestCaseForContestNameLabel('AOJ, PCK Final 2023')({
-    contestId: 'PCKFinal2023',
-    expected: 'AOJ - パソコン甲子園本選2023',
-  }),
-  createTestCaseForContestNameLabel('AOJ, PCK Final 2022')({
-    contestId: 'PCKFinal2022',
-    expected: 'AOJ - パソコン甲子園本選2022',
-  }),
-  createTestCaseForContestNameLabel('AOJ, PCK Final 2021')({
-    contestId: 'PCKFinal2021',
-    expected: 'AOJ - パソコン甲子園本選2021',
-  }),
-  createTestCaseForContestNameLabel('AOJ, PCK Final 2004')({
-    contestId: 'PCKFinal2004',
-    expected: 'AOJ - パソコン甲子園本選2004',
-  }),
-  createTestCaseForContestNameLabel('AOJ, PCK Final 2003')({
-    contestId: 'PCKFinal2003',
-    expected: 'AOJ - パソコン甲子園本選2003',
-  }),
-];
-
-export const aojJag = [
-  createTestCaseForContestNameLabel('AOJ, JAG Prelim 2005')({
-    contestId: 'JAGPrelim2005',
-    expected: 'AOJ - JAG模擬国内予選2005',
-  }),
-  createTestCaseForContestNameLabel('AOJ, JAG Prelim 2006')({
-    contestId: 'JAGPrelim2006',
-    expected: 'AOJ - JAG模擬国内予選2006',
-  }),
-  createTestCaseForContestNameLabel('AOJ, JAG Prelim 2009')({
-    contestId: 'JAGPrelim2009',
-    expected: 'AOJ - JAG模擬国内予選2009',
-  }),
-  createTestCaseForContestNameLabel('AOJ, JAG Prelim 2010')({
-    contestId: 'JAGPrelim2010',
-    expected: 'AOJ - JAG模擬国内予選2010',
-  }),
-  createTestCaseForContestNameLabel('AOJ, JAG Prelim 2011')({
-    contestId: 'JAGPrelim2011',
-    expected: 'AOJ - JAG模擬国内予選2011',
-  }),
-  createTestCaseForContestNameLabel('AOJ, JAG Prelim 2020')({
-    contestId: 'JAGPrelim2020',
-    expected: 'AOJ - JAG模擬国内予選2020',
-  }),
-  createTestCaseForContestNameLabel('AOJ, JAG Prelim 2021')({
-    contestId: 'JAGPrelim2021',
-    expected: 'AOJ - JAG模擬国内予選2021',
-  }),
-  createTestCaseForContestNameLabel('AOJ, JAG Prelim 2022')({
-    contestId: 'JAGPrelim2022',
-    expected: 'AOJ - JAG模擬国内予選2022',
-  }),
-  createTestCaseForContestNameLabel('AOJ, JAG Prelim 2023')({
-    contestId: 'JAGPrelim2023',
-    expected: 'AOJ - JAG模擬国内予選2023',
-  }),
-  createTestCaseForContestNameLabel('AOJ, JAG Prelim 2024')({
-    contestId: 'JAGPrelim2024',
-    expected: 'AOJ - JAG模擬国内予選2024',
-  }),
-  createTestCaseForContestNameLabel('AOJ, JAG Regional 2005')({
-    contestId: 'JAGRegional2005',
-    expected: 'AOJ - JAG模擬アジア地区予選2005',
-  }),
-  createTestCaseForContestNameLabel('AOJ, JAG Regional 2006')({
-    contestId: 'JAGRegional2006',
-    expected: 'AOJ - JAG模擬アジア地区予選2006',
-  }),
-  createTestCaseForContestNameLabel('AOJ, JAG Regional 2009')({
-    contestId: 'JAGRegional2009',
-    expected: 'AOJ - JAG模擬アジア地区予選2009',
-  }),
-  createTestCaseForContestNameLabel('AOJ, JAG Regional 2010')({
-    contestId: 'JAGRegional2010',
-    expected: 'AOJ - JAG模擬アジア地区予選2010',
-  }),
-  createTestCaseForContestNameLabel('AOJ, JAG Regional 2011')({
-    contestId: 'JAGRegional2011',
-    expected: 'AOJ - JAG模擬アジア地区予選2011',
-  }),
-  createTestCaseForContestNameLabel('AOJ, JAG Regional 2016')({
-    contestId: 'JAGRegional2016',
-    expected: 'AOJ - JAG模擬アジア地区予選2016',
-  }),
-  createTestCaseForContestNameLabel('AOJ, JAG Regional 2017')({
-    contestId: 'JAGRegional2017',
-    expected: 'AOJ - JAG模擬アジア地区予選2017',
-  }),
-  createTestCaseForContestNameLabel('AOJ, JAG Regional 2020')({
-    contestId: 'JAGRegional2020',
-    expected: 'AOJ - JAG模擬アジア地区予選2020',
-  }),
-  createTestCaseForContestNameLabel('AOJ, JAG Regional 2021')({
-    contestId: 'JAGRegional2021',
-    expected: 'AOJ - JAG模擬アジア地区予選2021',
-  }),
-  createTestCaseForContestNameLabel('AOJ, JAG Regional 2022')({
-    contestId: 'JAGRegional2022',
-    expected: 'AOJ - JAG模擬アジア地区予選2022',
-  }),
-];