diff --git a/README.md b/README.md
index fea25f6f..721bbbf3 100644
--- a/README.md
+++ b/README.md
@@ -1,5 +1,5 @@
 # nypc.github.io
 
-넥슨 청소년 프로그래밍 챌린지 (NYPC) 아카이브
+넥슨 영 프로그래머스 컵 (NYPC) 아카이브
 
 [작업 가이드](GUIDE.md)
diff --git a/public/favicon.ico b/public/favicon.ico
index 4ed1b724..2ea7896d 100644
Binary files a/public/favicon.ico and b/public/favicon.ico differ
diff --git a/src/components/Details.tsx b/src/components/Details.tsx
new file mode 100644
index 00000000..fbf978e8
--- /dev/null
+++ b/src/components/Details.tsx
@@ -0,0 +1,29 @@
+import styled from "@emotion/styled";
+import type { ReactNode } from "react";
+
+const DetailsContainer = styled.details`
+  margin: 16px 0;
+  padding: 8px 16px;
+  border: ${({ theme }) => theme.styles.border()};
+  border-radius: 8px;
+`;
+
+const Summary = styled.summary`
+  cursor: pointer;
+  font-weight: bold;
+`;
+
+export const Details = ({
+  summary = "자세히 보기",
+  children,
+}: {
+  summary?: string;
+  children?: ReactNode;
+}) => {
+  return (
+    <DetailsContainer>
+      <Summary>{summary}</Summary>
+      {children}
+    </DetailsContainer>
+  );
+};
diff --git a/src/components/PostLayout.tsx b/src/components/PostLayout.tsx
index ea348ce2..53d11e0b 100644
--- a/src/components/PostLayout.tsx
+++ b/src/components/PostLayout.tsx
@@ -65,7 +65,7 @@ export const PostLayout: React.FC<Props> = (props) => {
     ? `${meta.title}${
         meta.codebattle ? " — NYPC CODE BATTLE" : meta.year ? ` — NYPC ${meta.year}` : ""
       }`
-    : "NYPC — Nexon Youth Programming Challenge";
+    : "NYPC — NEXON Young Programmers Cup";
 
   return (
     <>
diff --git a/src/components/Simulators.tsx b/src/components/Simulators.tsx
index eb231227..123bdcb2 100644
--- a/src/components/Simulators.tsx
+++ b/src/components/Simulators.tsx
@@ -11,10 +11,11 @@ const SimulatorButtonsGrid = styled.div`
 interface Props {
   urlPrefix: string;
   count: number;
+  param?: string;
 }
 
 export const Simulators = (props: Props) => {
-  const { urlPrefix, count } = props;
+  const { urlPrefix, count, param = "subtask" } = props;
 
   return (
     <SimulatorButtonsGrid>
@@ -23,7 +24,7 @@ export const Simulators = (props: Props) => {
         .map((_, index) => (
           <Button
             as="a"
-            href={`${urlPrefix}?subtask=${index + 1}`}
+            href={`${urlPrefix}?${param}=${index + 1}`}
             target="_blank"
             rel="noreferrer"
             key={index.toString()}
diff --git a/src/components/components.tsx b/src/components/components.tsx
index b31735a4..c63804f3 100644
--- a/src/components/components.tsx
+++ b/src/components/components.tsx
@@ -12,6 +12,7 @@ import {
 import { IconCheck, IconTriangle, IconX } from "@tabler/icons-react";
 import { Blockquote } from "./Blockquote";
 import { Code } from "./Code";
+import { Details } from "./Details";
 import { Examples, IO, Input, Output } from "./Example";
 import { Figure } from "./Figure";
 import { LanguageDetails } from "./LanguageDetails";
@@ -71,6 +72,7 @@ export const mdxComponents: ReturnType<UseMdxComponents> = {
   IO,
   Input,
   Output,
+  Details,
   Figure,
   LanguageDetails,
   LanguageExample,
diff --git a/src/components/themes.tsx b/src/components/themes.tsx
index ff37ce53..096710ab 100644
--- a/src/components/themes.tsx
+++ b/src/components/themes.tsx
@@ -47,4 +47,8 @@ export const themes: Record<number, ThemeItem> = {
     color: "#FFFFFF",
     codebattle: true,
   },
+  2026: {
+    background: "#191716",
+    color: "#FFFFFF",
+  },
 };
diff --git a/src/routes/2026/index.tsx b/src/routes/2026/index.tsx
new file mode 100644
index 00000000..975263b6
--- /dev/null
+++ b/src/routes/2026/index.tsx
@@ -0,0 +1,43 @@
+import { Divider, Typo } from "@solved-ac/ui-react";
+import { createFileRoute } from "@tanstack/react-router";
+import { PostLayout, ProblemList } from "components";
+
+const year = 2026;
+
+export const problems = {
+  rookie: [
+    ["pre_1a", "대청소 (스텝 업)"],
+    ["pre_1b", "대청소 (챌린지)"],
+    ["pre_2a", "씨앗 운반 (스텝 업)"],
+    ["pre_2b", "씨앗 운반 (챌린지)"],
+  ],
+  master: [["pre_m", "NEXT NATION"]],
+} as const;
+
+const List = () => {
+  return (
+    <PostLayout
+      meta={{
+        title: `NYPC ${year}`,
+      }}
+      theme={{
+        background: "#191716",
+        color: "#FFFFFF",
+      }}
+    >
+      <Typo h2 no-margin>
+        루키 트랙 &mdash; 예선 라운드
+      </Typo>
+      <ProblemList year={year} problems={problems.rookie} />
+      <Divider />
+      <Typo h2 no-margin>
+        마스터 트랙 &mdash; 예선 라운드
+      </Typo>
+      <ProblemList year={year} problems={problems.master} />
+    </PostLayout>
+  );
+};
+
+export const Route = createFileRoute("/2026/")({
+  component: List,
+});
diff --git a/src/routes/2026/pre_1a.mdx b/src/routes/2026/pre_1a.mdx
new file mode 100644
index 00000000..b07fbff9
--- /dev/null
+++ b/src/routes/2026/pre_1a.mdx
@@ -0,0 +1,116 @@
+---
+title: 대청소 (스텝 업)
+year: 2026
+stage: 루키 트랙 예선 라운드
+---
+
+배찌는 봄을 맞아 대청소를 하려고 합니다.
+
+배찌의 집은 세로 $N$칸, 가로 $M$칸으로 이루어진 격자로 나타낼 수 있습니다. 각 칸은 빈 칸, 장애물, 블럭 중 하나입니다.
+배찌는 혼자서, 또는 친구 다오와 함께 물풍선으로 집에 있는 모든 블럭을 없애려고 합니다.
+
+처음에 배찌와 다오는 각자 서로 다른 빈칸 중 하나에 서 있습니다. 배찌와 다오는 **이동**과 **물폭탄 터트리기** 중 하나를 골라 행동하는 것을 반복합니다. 만약 배찌와 다오가 같이 청소를 하고 있다면, 배찌부터 시작해서 번갈아가면서 행동합니다.
+
+**이동**을 선택했다면, 배찌 또는 다오는 상하좌우 중 인접한 칸 하나를 골라 그 칸으로 움직일 수 있습니다.
+
+- 장애물 또는 블럭이 있는 칸으로 이동하거나 집 밖으로 이동하는 것은 불가능합니다.
+- 배찌 또는 다오가 서 있는 칸으로는 서로 이동할 수 있습니다.
+
+**물폭탄 터트리기**를 선택했다면, 즉시 4개의 물줄기가 상하좌우 각 방향으로 나아갑니다.
+
+- 물줄기가 블럭에 부딫힌다면 물줄기는 블럭과 같이 사라지고, 블럭은 빈 칸이 됩니다.
+- 물줄기는 최대 $K$칸 나아간 뒤 사라집니다. 즉, 물폭탄을 터트린 캐릭터와 파괴된 블럭의 거리는 $K$ 이하입니다.
+- 물줄기가 나아가는 도중 장애물이나 집 끝에 도달하면 물줄기는 멈춥니다.
+- 배찌와 다오의 물줄기의 세기 $K$는 다를 수 있습니다.
+
+배찌와 다오는 최소한의 움직임으로 모든 블럭을 터트리려고 합니다. 배찌와 다오의 청소를 도와줍시다!
+
+### 입력 형식
+
+첫째 줄에 정수 $N, M, C$가 공백으로 구분되어 주어집니다. $C = 1$이라면 배찌만, $C = 2$인 경우 배찌와 다오가 같이 움직입니다.
+
+둘째 줄에 $C = 1$이라면 $K_1$이, $C = 2$라면 $K_1, K_2$가 공백으로 구분되어 주어집니다. $K_1$은 배찌의 물줄기 세기, $K_2$는 다오의 물줄기 세기입니다.
+
+다음 $N$개의 줄에 걸쳐 집의 상태를 나타내는 길이 $M$의 문자열이 주어집니다. $i$번째 문자열의 $j$번째 문자는, 위에서 부터 $i$번째 행, 왼쪽에서부터 $j$번째 열에 해당하는 칸의 상태를 나타냅니다. 각 문자의 의미는 다음과 같습니다.
+
+- `.`: 빈 칸
+- `#`: 장애물
+- `@`: 블럭
+- `B`: 초기에 배찌가 있는 빈 칸
+- `D`: 초기에 다오가 있는 빈 칸
+
+단, 입력에 `B`는 정확히 한 개, `D`는 $C=2$인 경우에만 정확히 한 개 주어지며, 모든 블럭을 파괴할 수 있는 입력만 주어집니다.
+
+### 출력 형식
+
+배찌의 행동을 나타내는 `U`, `D`, `L`, `R`, `B`로 이루어진 길이 $1$ 이상 $100\,000$ 이하의 문자열을 출력합니다.
+
+각 문자의 의미는 다음과 같습니다.
+
+- `U`: 위로 이동
+- `D`: 아래로 이동
+- `L`: 왼쪽으로 이동
+- `R`: 오른쪽으로 이동
+- `B`: 물폭탄을 터트림
+
+$C = 1$인 경우 배찌의 행동을 차례대로, $C = 2$인 경우, 배찌와 다오의 행동을 번갈아가며 출력합니다.
+
+### 제한
+
+- $1 \le N \le 50$
+- $1 \le M \le 50$
+- $C$는 $1$ 또는 $2$
+- $1 \le K_1, K_2 \le 5$
+
+### 채점
+
+**스텝 업 문제는 전체 문제의 점수의 20% 비중을 차지합니다.**
+
+올바르지 않은 출력을 한 경우 오답이 되며 점수는 $0$점입니다. 올바르지 않은 출력의 예시는 다음과 같습니다.
+
+- 출력 형식을 맞추지 않은 경우
+- 장애물이나 블럭이 있는 칸으로 이동한 경우
+- 집 밖으로 이동한 경우
+
+**각 테스트케이스에 대한 비용 $\textrm{Cost}$는 다음과 같이 정해집니다.**
+
+- 모든 행동이 끝나고 파괴되지 않은 블럭의 수를 $X$, 출력한 문자열의 길이를 $T$라고 합시다.
+  - $X = 0$인 경우 $\textrm{Cost} = T$
+  - $X \ne 0$인 경우 $\textrm{Cost} = 100\,000 + X$
+- 비용이 낮을수록 더 좋은 결과입니다.
+
+각 테스트케이스당 실제 점수는 배점 $S$와 기준 점수 $\textrm{Cost}'$에 대해 $\left\lfloor S \times \min\left(\frac{\textrm{Cost}'}{\textrm{Cost}}, 1\right) \right\rfloor$로 정해집니다. 각 테스트케이스의 배점과 기준 점수는 다음과 같습니다:
+
+| 번호 | $N$  | $M$  | $C$ | $\textrm{Cost}'$ |    $S$     |
+| :--: | :--: | :--: | :-: | :--------------: | :--------: |
+|  01  | $3$  | $3$  | $1$ |       $1$        | $50\,000$  |
+|  02  | $1$  | $5$  | $1$ |       $4$        | $50\,000$  |
+|  03  | $5$  | $5$  | $2$ |       $3$        | $50\,000$  |
+|  04  | $5$  | $7$  | $1$ |       $9$        | $50\,000$  |
+|  05  | $6$  | $7$  | $1$ |       $18$       | $50\,000$  |
+|  06  | $4$  | $5$  | $1$ |       $12$       | $50\,000$  |
+|  07  | $13$ | $13$ | $1$ |       $37$       | $50\,000$  |
+|  08  | $20$ | $20$ | $2$ |      $129$       | $50\,000$  |
+|  09  | $20$ | $20$ | $2$ |      $151$       | $50\,000$  |
+|  10  | $16$ | $16$ | $1$ |      $127$       | $50\,000$  |
+|  11  | $17$ | $18$ | $2$ |       $80$       | $100\,000$ |
+|  12  | $13$ | $13$ | $2$ |       $37$       | $100\,000$ |
+|  13  | $15$ | $15$ | $2$ |       $35$       | $100\,000$ |
+|  14  | $20$ | $20$ | $2$ |      $238$       | $100\,000$ |
+|  15  | $20$ | $20$ | $2$ |       $72$       | $100\,000$ |
+
+스텝 업 문제에서의 최종 점수는 모든 테스트케이스의 점수의 합입니다.
+
+### 시뮬레이터
+
+문제 풀이를 돕기 위해, 시뮬레이터가 제공됩니다. [바로가기](https://d89uk4296q2gf.cloudfront.net/)
+
+우하단에서 미션을 선택하면 자동으로 시뮬레이터가 미션에 해당하는 입력을 보여줍니다.
+
+시뮬레이터에서 문제를 해결했다면, "출력" 탭에서 본인의 답안을 텍스트 형태로 확인할 수 있습니다.
+
+원한다면 출력된 본인의 답안을 그대로 제출할 수 있습니다. 문제를 푸는 데 시뮬레이터를 필수적으로 사용해야 하는 것은 아닙니다.
+
+아래 버튼을 누르면 각 번호에 해당하는 입력이 열립니다.
+
+<Simulators urlPrefix="https://d89uk4296q2gf.cloudfront.net/" param="input" count={15} />
diff --git a/src/routes/2026/pre_1b.mdx b/src/routes/2026/pre_1b.mdx
new file mode 100644
index 00000000..38d14812
--- /dev/null
+++ b/src/routes/2026/pre_1b.mdx
@@ -0,0 +1,182 @@
+---
+title: 대청소 (챌린지)
+year: 2026
+stage: 루키 트랙 예선 라운드
+---
+
+배찌는 봄을 맞아 대청소를 하려고 합니다.
+
+배찌의 집은 세로 $N$칸, 가로 $M$칸으로 이루어진 격자로 나타낼 수 있습니다. 각 칸은 빈 칸, 장애물, 블럭 중 하나입니다.
+배찌는 혼자서, 또는 친구 다오와 함께 물풍선으로 집에 있는 모든 블럭을 없애려고 합니다.
+
+처음에 배찌와 다오는 각자 서로 다른 빈칸 중 하나에 서 있습니다. 배찌와 다오는 **이동**과 **물폭탄 터트리기** 중 하나를 골라 행동하는 것을 반복합니다. 만약 배찌와 다오가 같이 청소를 하고 있다면, 배찌부터 시작해서 번갈아가면서 행동합니다.
+
+**이동**을 선택했다면, 배찌 또는 다오는 상하좌우 중 인접한 칸 하나를 골라 그 칸으로 움직일 수 있습니다.
+
+- 장애물 또는 블럭이 있는 칸으로 이동하거나 집 밖으로 이동하는 것은 불가능합니다.
+- 배찌 또는 다오가 서 있는 칸으로는 서로 이동할 수 있습니다.
+
+**물폭탄 터트리기**를 선택했다면, 즉시 4개의 물줄기가 상하좌우 각 방향으로 나아갑니다.
+
+- 물줄기가 블럭에 부딫힌다면 물줄기는 블럭과 같이 사라지고, 블럭은 빈 칸이 됩니다.
+- 물줄기는 최대 $K$칸 나아간 뒤 사라집니다. 즉, 물폭탄을 터트린 캐릭터와 파괴된 블럭의 거리는 $K$ 이하입니다.
+- 물줄기가 나아가는 도중 장애물이나 집 끝에 도달하면 물줄기는 멈춥니다.
+- 배찌와 다오의 물줄기의 세기 $K$는 다를 수 있습니다.
+
+배찌와 다오는 최소한의 움직임으로 모든 블럭을 터트리려고 합니다. 배찌와 다오의 청소를 도와줍시다!
+
+### 입력 형식
+
+첫째 줄에 정수 $N, M, C$가 공백으로 구분되어 주어집니다. $C = 1$이라면 배찌만, $C = 2$인 경우 배찌와 다오가 같이 움직입니다.
+
+둘째 줄에 $C = 1$이라면 $K_1$이, $C = 2$라면 $K_1, K_2$가 공백으로 구분되어 주어집니다. $K_1$은 배찌의 물줄기 세기, $K_2$는 다오의 물줄기 세기입니다.
+
+다음 $N$개의 줄에 걸쳐 집의 상태를 나타내는 길이 $M$의 문자열이 주어집니다. $i$번째 문자열의 $j$번째 문자는, 위에서 부터 $i$번째 행, 왼쪽에서부터 $j$번째 열에 해당하는 칸의 상태를 나타냅니다. 각 문자의 의미는 다음과 같습니다.
+
+- `.`: 빈 칸
+- `#`: 장애물
+- `@`: 블럭
+- `B`: 초기에 배찌가 있는 빈 칸
+- `D`: 초기에 다오가 있는 빈 칸
+
+단, 입력에 `B`는 정확히 한 개, `D`는 $C=2$인 경우에만 정확히 한 개 주어지며, 모든 블럭을 파괴할 수 있는 입력만 주어집니다.
+
+### 출력 형식
+
+배찌의 행동을 나타내는 `U`, `D`, `L`, `R`, `B`로 이루어진 길이 $1$ 이상 $100\,000$ 이하의 문자열을 출력합니다.
+
+각 문자의 의미는 다음과 같습니다.
+
+- `U`: 위로 이동
+- `D`: 아래로 이동
+- `L`: 왼쪽으로 이동
+- `R`: 오른쪽으로 이동
+- `B`: 물폭탄을 터트림
+
+$C = 1$인 경우 배찌의 행동을 차례대로, $C = 2$인 경우, 배찌와 다오의 행동을 번갈아가며 출력합니다.
+
+### 제한
+
+- $N = 50; M=50$
+- $C$는 $1$ 또는 $2$
+- $1 \le K_1, K_2 \le 5$
+
+### 예제 입출력
+
+- [예제 입력 다운로드](https://nypc-static.s3.ap-northeast-2.amazonaws.com/2026/cleaning-9c70899b/data/sample_input.txt)
+- [예제 출력 다운로드](https://nypc-static.s3.ap-northeast-2.amazonaws.com/2026/cleaning-9c70899b/data/sample_output.txt)
+
+### 채점
+
+**챌린지 문제는 전체 문제의 점수의 80% 비중을 차지합니다.**
+
+올바르지 않은 출력을 한 경우 오답이 되며 점수는 $0$점입니다. 올바르지 않은 출력의 예시는 다음과 같습니다.
+
+- 출력 형식을 맞추지 않은 경우
+- 장애물이나 블럭이 있는 칸으로 이동한 경우
+- 집 밖으로 이동한 경우
+
+**각 테스트케이스에 대한 비용 $\textrm{Cost}$는 다음과 같이 정해집니다.**
+
+- 모든 행동이 끝나고 파괴되지 않은 블럭의 수를 $X$, 출력한 문자열의 길이를 $T$라고 합시다.
+  - $X = 0$인 경우 $\textrm{Cost} = T$
+  - $X \ne 0$인 경우 $\textrm{Cost} = 100\,000 + X$
+- 비용이 낮을수록 더 좋은 결과입니다.
+
+이때의 각 테스트케이스의 점수는 다음과 같은 방법으로 정해집니다.
+
+- 전체 참가자의 수: $n_\textrm{tot}$
+- 자신보다 비용이 낮은 참가자의 수: $n_\textrm{lose}$
+- 자신과 비용이 같은 다른 참가자의 수: $n_\textrm{draw}$
+- $\textrm{Score} = \left\lfloor 10^6 \left(1 - 0.5\sqrt{\dfrac{n_\textrm{lose} + 0.5 n_\textrm{draw}}{n_\textrm{tot}}}\right) \right\rfloor$
+
+챌린지 문제의 최종 점수는 최종 평가에 사용된 각 테스트 케이스 점수의 평균이 됩니다. 비슷하게, 중간 평가의 점수는 중간 평가에 사용된 각 테스트 케이스 점수의 평균이 되며, 이 점수는 참고용으로 최종 점수에 반영되지 않습니다. 평가에는 예제 코드보다 낮은 비용을 받은 제출만 채점됩니다.
+
+문제의 점수는 각 테스트 케이스 별로 매겨지며, 최종 점수는 테스트 케이스별 점수의 평균으로 계산됩니다.
+
+### 데이터 제작 방법
+
+<Details>
+
+- $X$가 $a$ 이상 $b$ 이하에서 선택되었다는 것을 $X \sim \mathcal{U}\{a, b\}$ 으로 표현합니다.
+- 특정 범위에서 정수를 고를 때, 해당 범위에서 모든 수가 선택될 확률은 동일하며, 모든 시행은 독립입니다.
+
+데이터는 다음과 같은 방법으로 만들어집니다.
+
+- $C \sim \mathcal{U}\{1, 2\}$.
+- $K_1 \sim \mathcal{U}\{1, 5\}$.
+- $C = 2$인 경우 $K_2 \sim \mathcal{U}\{1, 5\}$.
+- 장애물의 총 개수를 $W$라 할 때, $W \sim \mathcal{U}\{250, 500\}$.
+- 블럭의 총 개수를 $B$라 할 때, $B \sim \mathcal{U}\{100, 1\,000\}$.
+- $W$번 동안 다음 시행을 반복합니다.
+  - 행, 열 번호 $r, c$에 대해 $r \sim \mathcal{U}\{1, 50\}, c \sim \mathcal{U}\{1, 50\}$
+  - 해당 위치에 장애물 설치를 시도합니다.
+    - 해당 위치에 이미 장애물이 있거나, 해당 위치에 장애물을 설치하는 것이 빈 칸 끼리 서로 연결되어있지 않은 경우, 설치는 실패합니다.
+  - 설치가 실패했다면, 시행 횟수를 차감하지 않고 $r, c$를 다시 고릅니다.
+- $B$번 동안 다음 시행을 반복합니다.
+  - 행, 열 번호 $r, c$에 대해 $r \sim \mathcal{U}\{1, 50\}, c \sim \mathcal{U}\{1, 50\}$
+  - 해당 위치에 블럭 설치를 시도합니다.
+    - 해당 위치에 이미 장애물 혹은 블럭이 있는 경우 설치는 실패합니다.
+  - 설치가 실패했다면, 시행 횟수를 차감하지 않고 $r, c$를 다시 고릅니다.
+- $C = 1$인 경우 배찌, $C = 2$인 경우 배찌와 다오에 대해 다음 시행을 합니다.
+  - 행, 열 번호 $r, c$에 대해 $r \sim \mathcal{U}\{1, 50\}, c \sim \mathcal{U}\{1, 50\}$
+  - 해당 위치에 캐릭터를 배치하는 것을 시도합니다.
+    - 해당 위치에 이미 장애물, 블럭, 혹은 캐릭터가 있는 경우 배치는 실패합니다.
+  - 배치가 실패했다면 $r, c$를 다시 고릅니다.
+
+#### 중간 평가 데이터 제작 방법
+
+각 중간 평가 별로 $18$개의 데이터가 사용됩니다. 각 데이터의 $C, W, B$를 선택하는 부분이 다음과 같이 대체됩니다.
+
+|  번호  | $C$ |         $W$ 범위          |           $B$ 범위           |
+| :----: | :-: | :-----------------------: | :--------------------------: |
+| **1**  | $1$ | $\mathcal{U}\{250, 333\}$ |  $\mathcal{U}\{100, 399\}$   |
+| **2**  | $1$ | $\mathcal{U}\{250, 333\}$ |  $\mathcal{U}\{400, 700\}$   |
+| **3**  | $1$ | $\mathcal{U}\{250, 333\}$ | $\mathcal{U}\{701, 1\,000\}$ |
+| **4**  | $1$ | $\mathcal{U}\{334, 416\}$ |  $\mathcal{U}\{100, 399\}$   |
+| **5**  | $1$ | $\mathcal{U}\{334, 416\}$ |  $\mathcal{U}\{400, 700\}$   |
+| **6**  | $1$ | $\mathcal{U}\{334, 416\}$ | $\mathcal{U}\{701, 1\,000\}$ |
+| **7**  | $1$ | $\mathcal{U}\{417, 500\}$ |  $\mathcal{U}\{100, 399\}$   |
+| **8**  | $1$ | $\mathcal{U}\{417, 500\}$ |  $\mathcal{U}\{400, 700\}$   |
+| **9**  | $1$ | $\mathcal{U}\{417, 500\}$ | $\mathcal{U}\{701, 1\,000\}$ |
+| **10** | $2$ | $\mathcal{U}\{250, 333\}$ |  $\mathcal{U}\{100, 399\}$   |
+| **11** | $2$ | $\mathcal{U}\{250, 333\}$ |  $\mathcal{U}\{400, 700\}$   |
+| **12** | $2$ | $\mathcal{U}\{250, 333\}$ | $\mathcal{U}\{701, 1\,000\}$ |
+| **13** | $2$ | $\mathcal{U}\{334, 416\}$ |  $\mathcal{U}\{100, 399\}$   |
+| **14** | $2$ | $\mathcal{U}\{334, 416\}$ |  $\mathcal{U}\{400, 700\}$   |
+| **15** | $2$ | $\mathcal{U}\{334, 416\}$ | $\mathcal{U}\{701, 1\,000\}$ |
+| **16** | $2$ | $\mathcal{U}\{417, 500\}$ |  $\mathcal{U}\{100, 399\}$   |
+| **17** | $2$ | $\mathcal{U}\{417, 500\}$ |  $\mathcal{U}\{400, 700\}$   |
+| **18** | $2$ | $\mathcal{U}\{417, 500\}$ | $\mathcal{U}\{701, 1\,000\}$ |
+
+</Details>
+
+### 시뮬레이터
+
+문제 풀이를 돕기 위해, 시뮬레이터가 제공됩니다. [바로가기](https://d89uk4296q2gf.cloudfront.net/)
+
+제출 내역에서 본인이 제출한 코드가 내놓은 답안이 실제로 어떻게 동작하는지 확인할 수 있습니다.
+
+### 예제 코드
+
+대회에서 지원하는 각 언어로 작성된 예제 코드를 아래에서 확인할 수 있습니다.
+
+- C: [sample-code.c](https://nypc-static.s3.ap-northeast-2.amazonaws.com/2026/cleaning-9c70899b/sample-code/sample-code.c)
+- C++: [sample-code.cpp](https://nypc-static.s3.ap-northeast-2.amazonaws.com/2026/cleaning-9c70899b/sample-code/sample-code.cpp)
+- Python: [sample-code.py](https://nypc-static.s3.ap-northeast-2.amazonaws.com/2026/cleaning-9c70899b/sample-code/sample-code.py)
+- Rust: [sample-code.rs](https://nypc-static.s3.ap-northeast-2.amazonaws.com/2026/cleaning-9c70899b/sample-code/sample-code.rs)
+- Java: [sample-code.java](https://nypc-static.s3.ap-northeast-2.amazonaws.com/2026/cleaning-9c70899b/sample-code/sample-code.java)
+- JavaScript: [sample-code.js](https://nypc-static.s3.ap-northeast-2.amazonaws.com/2026/cleaning-9c70899b/sample-code/sample-code.js)
+- TypeScript: [sample-code.ts](https://nypc-static.s3.ap-northeast-2.amazonaws.com/2026/cleaning-9c70899b/sample-code/sample-code.ts)
+- C#: [sample-code.cs](https://nypc-static.s3.ap-northeast-2.amazonaws.com/2026/cleaning-9c70899b/sample-code/sample-code.cs)
+- Kotlin: [sample-code.kt](https://nypc-static.s3.ap-northeast-2.amazonaws.com/2026/cleaning-9c70899b/sample-code/sample-code.kt)
+- Go: [sample-code.go](https://nypc-static.s3.ap-northeast-2.amazonaws.com/2026/cleaning-9c70899b/sample-code/sample-code.go)
+- Scala: [sample-code.scala](https://nypc-static.s3.ap-northeast-2.amazonaws.com/2026/cleaning-9c70899b/sample-code/sample-code.scala)
+- Lua: [sample-code.lua](https://nypc-static.s3.ap-northeast-2.amazonaws.com/2026/cleaning-9c70899b/sample-code/sample-code.lua)
+
+주어지는 예제 코드의 동작은 다음과 같습니다.
+
+1. 배찌와 다오가 위쪽을 보도록 합니다.
+2. 각 캐릭터의 앞이 막혀있지 않으면 앞으로 한 칸 이동합니다.
+3. 각 캐릭터의 앞이 막다른 길이라면 폭탄을 설치하고 시계방향으로 90도 회전합니다.
+4. 100번 행동할 때까지 위를 반복합니다.
diff --git a/src/routes/2026/pre_2a.mdx b/src/routes/2026/pre_2a.mdx
new file mode 100644
index 00000000..7d2c46a6
--- /dev/null
+++ b/src/routes/2026/pre_2a.mdx
@@ -0,0 +1,122 @@
+---
+title: 씨앗 운반 (스텝 업)
+year: 2026
+stage: 루키 트랙 예선 라운드
+---
+
+$(R+2)$ 행 $C$ 열 격자 모양의 들판이 있습니다. 가장 위쪽 행에는 씨앗이 떨어지는 꽃이, 가장 아래쪽 행에는 씨앗을 저장하는 굴이 한 칸에 하나씩 총 $C$개 있으며, 가운데 $R$개의 행은 모두 빈 칸입니다. 이 문제에서 당신의 임무는
+
+- 빈 칸으로 이루어진 행의 개수 $R$을 설정하고,
+- 빈 칸에 **다람쥐** 혹은 **햄스터**를 적절히 배치하고, 씨앗을 옮길 방법을 정하는 것
+
+입니다. 당신은 각 꽃에서 떨어지는 씨앗을 최대한 요구치에 가깝게 각 굴로 옮겨야 합니다.
+
+<center>
+  ![씨앗 운반 – 스텝업 1번
+  이미지](https://nypc-static.s3.ap-northeast-2.amazonaws.com/2026/dotory-21kancu9/img/a95d17e8-a1c0-4c9e-a13c-2da4e3f494ee.png)
+</center>
+
+---
+
+빈 칸을 기준으로 위에서 $r$번째 행, 왼쪽에서 $c$번째 열에 해당하는 칸을 $(r, c)$라고 합시다. 또한, 가장 위쪽 행의 꽃은 각각 $(0, 1), (0, 2), \cdots, (0, C)$, 가장 아래쪽 행의 굴은 각각 $(R+1, 1), (R+1, 2), \cdots, (R+1, C)$라고 합시다.
+
+- 꽃 $(0, i)$에서는 씨앗이 $A_i$개 열립니다.
+- 굴 $(R+1, i)$까지 씨앗을 $B_i$개 옮기려고 합니다.
+- 꽃에 열리는 씨앗의 총 개수와, 굴까지 옮겨야할 씨앗의 총 개수는 같습니다. 즉, $A_1 + A_2 + \cdots + A_C  = B_1 + B_2 + \cdots + B_C$입니다.
+- 가장 많은 씨앗이 열리는 꽃에서는 $M$개의 씨앗이 열립니다. 또한, 각 굴에서 요구하는 씨앗의 최대 개수는 $M$ 이하입니다. 즉, $\max(B_1, B_2, \cdots, B_C) \le \max(A_1, A_2, \cdots, A_C) = M$입니다.
+
+격자의 빈 칸에는 **다람쥐** 혹은 **햄스터**를 배치할 수 있습니다. 각 다람쥐 혹은 햄스터는 자신의 칸의 씨앗을 정해진 규칙에 따라 다른 칸으로 옮깁니다.
+
+- **다람쥐**: 상하좌우로 인접한 칸으로 씨앗을 보낼 수 있습니다. `↑, ↓, ←, →` 중 원하는 방향을 원하는 순서대로 고르면, 해당 칸으로 씨앗을 배분합니다.
+- **햄스터**: **같은 행이나 같은 열에 있는 인접하지 않은** 칸을 골라서 멀리 씨앗을 보낼 수 있습니다.
+
+---
+
+배치가 끝나면, $T$초에 걸쳐 씨앗 운반이 시작됩니다. 각 시각 $t = 1, 2, \cdots, T$초에는 다음 과정이 순서대로 발생합니다.
+
+1. **씨앗 수확**: 각 꽃 $(0, i)$는 $t = M-A_i+1, M-A_i+2, \cdots, M$인 동안 씨앗을 $1$개씩 $(1, i)$로 떨어뜨립니다.
+2. **씨앗 보내기**: 모든 다람쥐와 햄스터가 동시에 자신의 칸에 있는 씨앗을 다른 칸으로 보냅니다.
+   - **다람쥐**: 각 다람쥐는 **지난번에 마지막으로 씨앗을 보냈던 방향의 다음 순서**부터 시작하여, 고른 방향 순서대로 돌아가며 씨앗을 한 개씩 보냅니다. 같은 방향으로는 최대 한 개씩만 보냅니다.
+   - **햄스터**: 자신의 칸에 씨앗이 있다면 정해진 다른 칸으로 씨앗을 **$\textbf{1}$개** 보냅니다.
+   - 이 과정에서 칸에 있는 모든 씨앗을 다른 칸으로 보내지 못한 경우, 칸이 **과부하**됩니다.
+     - 빈 칸 혹은 굴에 남아있는 씨앗을 옮길 다람쥐 혹은 햄스터가 없는 경우도 마찬가지로 과부하됩니다.
+   - **예시**: 다람쥐에게 4개의 칸을 골라 `[↑, ↓, ←, →]` 순서로 보내도록 지정한 경우,
+     - **시각 $\textbf{T}$**: 칸에 씨앗이 **$\textbf{2}$개** 있다면, `↑`, `↓`로 씨앗을 한 개 보냅니다.
+     - **시각 $\textbf{T+1}$**: 칸에 씨앗이 **$\textbf{3}$개** 있다면, `↓` 다음 순서인 `←`부터 시작해서 `←`, `→`, `↑`으로 씨앗을 한 개 보냅니다.
+     - **시각 $\textbf{T+2}$**: 칸에 씨앗이 **$\textbf{6}$개** 있다면, `↑` 다음 순서인 `↓`부터 시작해서 `↓`, `←`, `→`, `↑`으로 씨앗을 한 개 보냅니다. 남은 씨앗 **$\textbf{2}$개**는 가지고 있습니다. 해당 칸은 **과부하**된 칸이 됩니다.
+3. **씨앗 받기**: 과부하된 칸이 바로 직전의 **씨앗 보내기** 단계에서 받은 모든 씨앗을 원래 칸으로 되돌려놓습니다.
+4. **씨앗 저장**: $(R + 1, i)$에 씨앗이 떨어져 있다면, 씨앗 $1$개가 굴 안으로 굴러떨어집니다. 이 씨앗은 더 이상 운반될 일이 없습니다.
+
+### 입력 형식
+
+첫 줄에 $C, T, M$이 공백으로 구분되어 주어집니다.
+
+다음 줄에 $A_1, A_2, \cdots, A_C$가 공백으로 구분되어 주어집니다.
+
+다음 줄에 $B_1, B_2, \cdots, B_C$가 공백으로 구분되어 주어집니다.
+
+### 출력 형식
+
+첫 줄에 사용하기로 결정한 격자판 행의 개수 $R$을 출력합니다. $R$은 $C$ 이상 $C+20$이하의 수여야 합니다.
+
+다음 줄부터 $R$개의 줄 각각에 $C$개의 문자열을 공백으로 구분하여 출력합니다. $r$번째 줄의 $c$번째 문자열은 $(r, c)$에 있는 다람쥐가 씨앗을 전달하는 방법을 의미합니다. 위쪽을 `U`, 아래쪽을 `D`, 오른쪽을 `R`, 왼쪽을 `L`이라는 문자로 표현합니다. 꽃으로는 씨앗을 보낼 수 없습니다.
+
+1. 다람쥐: 고른 방향을 순서대로 공백 없이 붙여서 표현합니다. 만약 고른 방향이 없다면 `X`로 표시합니다.
+   - `[위, 아래, 오른쪽]` 은 `UDR`로 표현합니다.
+2. 햄스터: 고른 격자칸까지의 거리와 방향을 차례대로 공백 없이 붙여서 표현합니다.
+   - $12$칸 아래의 격자칸으로 씨앗을 던지고 싶다면 `12D` 로 표현합니다.
+
+### 제한
+
+- $2 \le C \le 10$
+- $10 \le M < T \le 2\,000$
+- $0 \le A_i \le M$ $(1 \le i \le C)$
+- $0 \le B_i \le M$ $(1 \le i \le C)$
+- $A_1 + A_2 + \cdots + A_C = B_1 + B_2 + \cdots + B_C$
+- $\max(A_1, A_2, \cdots, A_C) = M$
+
+### 채점
+
+**스텝 업 문제는 전체 문제의 점수의 50% 비중을 차지합니다.**
+
+출력 형식이 틀렸거나, 존재하지 않는 칸에 씨앗을 던지려 하는 등 올바르지 않은 출력의 경우 $0$점입니다.
+
+$T$초가 끝난 시점에 $(R+1, i)$에 있는 굴에 있는 씨앗의 개수를 $B'_i$라고 할 때
+
+- 오차: 운반해야 하는 씨앗 개수와, 실제로 운반된 씨앗 개수의 차이 합 $E = \sum_{i=1}^C \lvert B'_i - B_i \rvert$
+- 손실: 굴로 운반되지 못한 씨앗의 개수 $L = \sum_{i=1}^C B_i - \sum_{i=1}^C B'_i$
+- 지연: $L > 0$이라면 $D = T$, 아닐 경우 마지막 씨앗이 굴로 들어간 시각을 $T_{\textrm{last}}$라고 할 때, $D = T_\textrm{last} - M$
+
+비용은 다음과 같은 방법으로 정해집니다.
+
+- $\textrm{Cost} = 2^{R-C}+\max(E, D) + T\times L$
+
+각 테스트케이스당 실제 점수는 기준 비용 $\textrm{Cost}'$, 최대 점수 $\textrm{Score}'$에 대해 $\displaystyle \left\lfloor \textrm{Score}' \times 0.9^{\max\left(0,\, \frac{\mathrm{Cost}}{\mathrm{Cost}'}-1\right)} \right\rfloor$로 정해집니다. 각 테스트케이스의 기준 비용과 최대 점수는 다음과 같습니다:
+
+| 번호 | 기준 비용 | <div style={{ minWidth: "160px" }}>최대 점수</div> |
+| :--: | :-------: | :------------------------------------------------: |
+|  01  |    $1$    |                     $50\,000$                      |
+|  02  |    $3$    |                     $50\,000$                      |
+|  03  |    $3$    |                     $50\,000$                      |
+|  04  |    $2$    |                     $50\,000$                      |
+|  05  |    $2$    |                     $50\,000$                      |
+|  06  |    $3$    |                     $100\,000$                     |
+|  07  |    $3$    |                     $50\,000$                      |
+|  08  |    $2$    |                     $50\,000$                      |
+|  09  |    $2$    |                     $50\,000$                      |
+|  10  |    $3$    |                     $100\,000$                     |
+|  11  |    $3$    |                     $50\,000$                      |
+|  12  |    $4$    |                     $100\,000$                     |
+|  13  |    $3$    |                     $50\,000$                      |
+|  14  |    $5$    |                     $100\,000$                     |
+|  15  |    $3$    |                     $100\,000$                     |
+
+스텝 업 문제에서의 최종 점수는 각 테스트케이스에서 받은 최고 점수의 합입니다.
+
+### 시뮬레이터
+
+문제 풀이에 도움이 되는 시각화 도구를 제공합니다. [바로가기](https://d3omc4vctoe1wi.cloudfront.net/)
+
+아래 버튼을 누르면 각 번호에 해당하는 입력이 열립니다.
+
+<Simulators urlPrefix="https://d3omc4vctoe1wi.cloudfront.net/" param="input" count={15} />
diff --git a/src/routes/2026/pre_2b.mdx b/src/routes/2026/pre_2b.mdx
new file mode 100644
index 00000000..959229ed
--- /dev/null
+++ b/src/routes/2026/pre_2b.mdx
@@ -0,0 +1,186 @@
+---
+title: 씨앗 운반 (챌린지)
+year: 2026
+stage: 루키 트랙 예선 라운드
+---
+
+$(R+2)$ 행 $C$ 열 격자 모양의 들판이 있습니다. 가장 위쪽 행에는 씨앗이 떨어지는 꽃이, 가장 아래쪽 행에는 씨앗을 저장하는 굴이 한 칸에 하나씩 총 $C$개 있으며, 가운데 $R$개의 행은 모두 빈 칸입니다. 이 문제에서 당신의 임무는
+
+- 빈 칸으로 이루어진 행의 개수 $R$을 설정하고,
+- 빈 칸에 **다람쥐** 혹은 **햄스터**를 적절히 배치하고, 씨앗을 옮길 방법을 정하는 것
+
+입니다. 당신은 각 꽃에서 떨어지는 씨앗을 최대한 요구치에 가깝게 각 굴로 옮겨야 합니다.
+
+<center>
+  ![씨앗 운반 – 스텝업 1번
+  이미지](https://nypc-static.s3.ap-northeast-2.amazonaws.com/2026/dotory-21kancu9/img/a95d17e8-a1c0-4c9e-a13c-2da4e3f494ee.png)
+</center>
+
+---
+
+빈 칸을 기준으로 위에서 $r$번째 행, 왼쪽에서 $c$번째 열에 해당하는 칸을 $(r, c)$라고 합시다. 또한, 가장 위쪽 행의 꽃은 각각 $(0, 1), (0, 2), \cdots, (0, C)$, 가장 아래쪽 행의 굴은 각각 $(R+1, 1), (R+1, 2), \cdots, (R+1, C)$라고 합시다.
+
+- 꽃 $(0, i)$에서는 씨앗이 $A_i$개 열립니다.
+- 굴 $(R+1, i)$까지 씨앗을 $B_i$개 옮기려고 합니다.
+- 꽃에 열리는 씨앗의 총 개수와, 굴까지 옮겨야할 씨앗의 총 개수는 같습니다. 즉, $A_1 + A_2 + \cdots + A_C  = B_1 + B_2 + \cdots + B_C$입니다.
+- 가장 많은 씨앗이 열리는 꽃에서는 $M$개의 씨앗이 열립니다. 또한, 각 굴에서 요구하는 씨앗의 최대 개수는 $M$ 이하입니다. 즉, $\max(B_1, B_2, \cdots, B_C) \le \max(A_1, A_2, \cdots, A_C) = M$입니다.
+
+격자의 빈 칸에는 **다람쥐** 혹은 **햄스터**를 배치할 수 있습니다. 각 다람쥐 혹은 햄스터는 자신의 칸의 씨앗을 정해진 규칙에 따라 다른 칸으로 옮깁니다.
+
+- **다람쥐**: 상하좌우로 인접한 칸으로 씨앗을 보낼 수 있습니다. `↑, ↓, ←, →` 중 원하는 방향을 원하는 순서대로 고르면, 해당 칸으로 씨앗을 배분합니다.
+- **햄스터**: **같은 행이나 같은 열에 있는 인접하지 않은** 칸을 골라서 멀리 씨앗을 보낼 수 있습니다.
+
+---
+
+배치가 끝나면, $T$초에 걸쳐 씨앗 운반이 시작됩니다. 각 시각 $t = 1, 2, \cdots, T$초에는 다음 과정이 순서대로 발생합니다.
+
+1. **씨앗 수확**: 각 꽃 $(0, i)$는 $t = M-A_i+1, M-A_i+2, \cdots, M$인 동안 씨앗을 $1$개씩 $(1, i)$로 떨어뜨립니다.
+2. **씨앗 보내기**: 모든 다람쥐와 햄스터가 동시에 자신의 칸에 있는 씨앗을 다른 칸으로 보냅니다.
+   - **다람쥐**: 각 다람쥐는 **지난번에 마지막으로 씨앗을 보냈던 방향의 다음 순서**부터 시작하여, 고른 방향 순서대로 돌아가며 씨앗을 한 개씩 보냅니다. 같은 방향으로는 최대 한 개씩만 보냅니다.
+   - **햄스터**: 자신의 칸에 씨앗이 있다면 정해진 다른 칸으로 씨앗을 **$\textbf{1}$개** 보냅니다.
+   - 이 과정에서 칸에 있는 모든 씨앗을 다른 칸으로 보내지 못한 경우, 칸이 **과부하**됩니다.
+     - 빈 칸 혹은 굴에 남아있는 씨앗을 옮길 다람쥐 혹은 햄스터가 없는 경우도 마찬가지로 과부하됩니다.
+   - **예시**: 다람쥐에게 4개의 칸을 골라 `[↑, ↓, ←, →]` 순서로 보내도록 지정한 경우,
+     - **시각 $\textbf{T}$**: 칸에 씨앗이 **$\textbf{2}$개** 있다면, `↑`, `↓`로 씨앗을 한 개 보냅니다.
+     - **시각 $\textbf{T+1}$**: 칸에 씨앗이 **$\textbf{3}$개** 있다면, `↓` 다음 순서인 `←`부터 시작해서 `←`, `→`, `↑`으로 씨앗을 한 개 보냅니다.
+     - **시각 $\textbf{T+2}$**: 칸에 씨앗이 **$\textbf{6}$개** 있다면, `↑` 다음 순서인 `↓`부터 시작해서 `↓`, `←`, `→`, `↑`으로 씨앗을 한 개 보냅니다. 남은 씨앗 **$\textbf{2}$개**는 가지고 있습니다. 해당 칸은 **과부하**된 칸이 됩니다.
+3. **씨앗 받기**: 과부하된 칸이 바로 직전의 **씨앗 보내기** 단계에서 받은 모든 씨앗을 원래 칸으로 되돌려놓습니다.
+4. **씨앗 저장**: $(R + 1, i)$에 씨앗이 떨어져 있다면, 씨앗 $1$개가 굴 안으로 굴러떨어집니다. 이 씨앗은 더 이상 운반될 일이 없습니다.
+
+### 입력 형식
+
+첫 줄에 $C, T, M$이 공백으로 구분되어 주어집니다.
+
+다음 줄에 $A_1, A_2, \cdots, A_C$가 공백으로 구분되어 주어집니다.
+
+다음 줄에 $B_1, B_2, \cdots, B_C$가 공백으로 구분되어 주어집니다.
+
+### 출력 형식
+
+첫 줄에 사용하기로 결정한 격자판 행의 개수 $R$을 출력합니다. $R$은 $C$ 이상 $C+20$이하의 수여야 합니다.
+
+다음 줄부터 $R$개의 줄 각각에 $C$개의 문자열을 공백으로 구분하여 출력합니다. $r$번째 줄의 $c$번째 문자열은 $(r, c)$에 있는 다람쥐가 씨앗을 전달하는 방법을 의미합니다. 위쪽을 `U`, 아래쪽을 `D`, 오른쪽을 `R`, 왼쪽을 `L`이라는 문자로 표현합니다. 꽃으로는 씨앗을 보낼 수 없습니다.
+
+1. 다람쥐: 고른 방향을 순서대로 공백 없이 붙여서 표현합니다. 만약 고른 방향이 없다면 `X`로 표시합니다.
+   - `[위, 아래, 오른쪽]` 은 `UDR`로 표현합니다.
+2. 햄스터: 고른 격자칸까지의 거리와 방향을 차례대로 공백 없이 붙여서 표현합니다.
+   - $12$칸 아래의 격자칸으로 씨앗을 던지고 싶다면 `12D` 로 표현합니다.
+
+### 제한
+
+- $5 \le C \le 10$
+- $T = 2\,000\,000$
+- $100\,000 \le M \le 1\,000\,000$
+- $0 \le A_i \le M$ $(1 \le i \le C)$
+- $0 \le B_i \le M$ $(1 \le i \le C)$
+- $A_1 + A_2 + \cdots + A_C = B_1 + B_2 + \cdots + B_C = 1\,000\,000$
+- $\max(A_1, A_2, \cdots, A_C) = M$
+
+### 채점
+
+**챌린지 문제는 전체 문제의 점수의 50% 비중을 차지합니다.**
+
+올바르지 않은 출력을 한 경우, 즉, 출력 형식을 맞추지 않았거나, 존재하지 않은 칸에 씨앗을 던지려 한 경우 $0$점입니다.
+
+아닌 경우, $T$초가 끝난 이후 $(R+1, i)$에 있는 씨앗 굴에 있는 씨앗의 개수를 $B'_i$라고 할 때
+
+- 오차: 운반해야 하는 씨앗 개수와, 실제로 운반된 씨앗 개수의 차이 합 $E = \sum_{i=1}^C \lvert B'_i - B_i \rvert$
+- 손실: 굴로 운반되지 못한 씨앗의 개수 $L = \sum_{i=1}^C B_i - \sum_{i=1}^C B'_i$
+- 지연: $L > 0$이라면 $D = T$, 아닐 경우 마지막 씨앗이 굴로 들어간 시간을 $T_{\textrm{last}}$라고 할 때, $D = T_\textrm{last} - M$
+
+이때 **비용**은 다음과 같은 방법으로 정해집니다.
+
+- $\textrm{Cost} = 2^{R-C}+\max(E, D) + T\times L$
+- 비용이 낮을수록 더 좋은 결과입니다.
+
+이때의 각 테스트케이스의 점수는 다음과 같은 방법으로 정해집니다.
+
+- 전체 참가자의 수: $n_\textrm{tot}$
+- 자신보다 비용이 낮은 참가자의 수: $n_\textrm{lose}$
+- 자신과 비용이 같은 다른 참가자의 수: $n_\textrm{draw}$
+- $\textrm{Score} = \left\lfloor 10^6 \left(1 - 0.5\sqrt{\dfrac{n_\textrm{lose} + 0.5 n_\textrm{draw}}{n_\textrm{tot}}}\right) \right\rfloor$
+
+챌린지 문제의 최종 점수는 최종 평가에 사용된 각 테스트 케이스 점수의 평균이 됩니다. 비슷하게, 중간 평가의 점수는 중간 평가에 사용된 각 테스트 케이스 점수의 평균이 되며, 이 점수는 참고용으로 최종 점수에 반영되지 않습니다. 평가에는 예제 코드보다 낮은 비용을 받은 제출만 채점됩니다.
+
+문제의 점수는 각 테스트 케이스 별로 매겨지며, 최종 점수는 테스트 케이스별 점수의 평균으로 계산됩니다.
+
+### 시뮬레이터
+
+문제 풀이에 도움이 되는 시각화 도구를 제공합니다. [바로가기](https://d3omc4vctoe1wi.cloudfront.net/)
+
+### 예제 코드
+
+대회에서 지원하는 각 언어로 작성된 예제 코드를 아래에서 확인할 수 있습니다.
+
+- C: [sample_code.c](https://nypc-static.s3.ap-northeast-2.amazonaws.com/2026/seed-21kancu9/sample_code.c)
+- C++: [sample_code.cpp](https://nypc-static.s3.ap-northeast-2.amazonaws.com/2026/seed-21kancu9/sample_code.cpp)
+- Python: [sample_code.py](https://nypc-static.s3.ap-northeast-2.amazonaws.com/2026/seed-21kancu9/sample_code.py)
+- Rust: [sample_code.rs](https://nypc-static.s3.ap-northeast-2.amazonaws.com/2026/seed-21kancu9/sample_code.rs)
+- Java: [sample_code.java](https://nypc-static.s3.ap-northeast-2.amazonaws.com/2026/seed-21kancu9/sample_code.java)
+- JavaScript: [sample_code.js](https://nypc-static.s3.ap-northeast-2.amazonaws.com/2026/seed-21kancu9/sample_code.js)
+- TypeScript: [sample_code.ts](https://nypc-static.s3.ap-northeast-2.amazonaws.com/2026/seed-21kancu9/sample_code.ts)
+- C#: [sample_code.cs](https://nypc-static.s3.ap-northeast-2.amazonaws.com/2026/seed-21kancu9/sample_code.cs)
+- Kotlin: [sample_code.kt](https://nypc-static.s3.ap-northeast-2.amazonaws.com/2026/seed-21kancu9/sample_code.kt)
+- Go: [sample_code.go](https://nypc-static.s3.ap-northeast-2.amazonaws.com/2026/seed-21kancu9/sample_code.go)
+- Scala: [sample_code.scala](https://nypc-static.s3.ap-northeast-2.amazonaws.com/2026/seed-21kancu9/sample_code.scala)
+- Lua: [sample_code.lua](https://nypc-static.s3.ap-northeast-2.amazonaws.com/2026/seed-21kancu9/sample_code.lua)
+
+### 데이터 제작 방법
+
+<Details>
+
+- $X$가 $a$ 이상 $b$ 이하에서 선택되었다는 것을 $X \sim \mathcal{U}\{a; b\}$ 으로 표현합니다.
+- 특정 범위에서 정수를 고를 때, 해당 범위에서 모든 수가 선택될 확률은 동일하며, 모든 시행은 독립입니다.
+
+데이터는 다음과 같은 방법으로 생성됩니다.
+
+- $T = 2\,000\,000$
+- $C\sim \mathcal{U}\{5; 10\}$
+- 다음과 같은 방법으로 수열 $N_1, N_2, \cdots, N_C$를 두 개 생성합니다.
+  - $i = 1, \cdots, C-1$에 대해 $X'_i \sim \mathcal{U}\{1; 1\,000\,000+C-1\}$.
+  - $X'_1, X'_2, \cdots, X'_{C-1}$에 중복된 원소가 있으면 수열을 다시 뽑습니다.
+  - $X'_1, X'_2, \cdots, X'_{C-1}$를 오름차순으로 정렬한 수열을 $X_1, X_2, \cdots, X_{C-1}$로 놓습니다.
+  - $X_0 = 0, X_C = 1\,000\,000 + C$라고 놓은 이후, $N_i = X_i - X_{i-1} - 1$로 놓습니다. $(1 \le i \le C)$
+- 생성한 두 수열 중 원소의 최댓값이 큰 쪽을 $A$, 작은 쪽을 $B$로 정합니다. 최댓값이 같은 경우 먼저 생성한 수열이 $A$입니다.
+
+#### 중간 평가 데이터 제작 방법
+
+각 중간 평가 별로 $30$개의 데이터가 사용됩니다.
+
+1. 각 데이터의 $C$를 선택하는 부분이 다음과 같이 대체됩니다.
+2. 데이터를 모두 생성한 이후 계산한 $M$의 값이 해당 범위 밖이라면 데이터 생성을 처음부터 다시 시작합니다.
+
+|  번호  |  $C$  |  $M$ 범위 ($MN \le M \le MX$)   |
+| :----: | :---: | :-----------------------------: |
+| **1**  | $ 5 $ |  $200\,000\le M \le  421\,816$  |
+| **2**  | $ 5 $ |  $421\,817\le M \le  479\,291$  |
+| **3**  | $ 5 $ |  $479\,292\le M \le  539\,215$  |
+| **4**  | $ 5 $ |  $539\,216\le M \le  618\,806$  |
+| **5**  | $ 5 $ | $618\,807\le M \le 1\,000\,000$ |
+| **6**  | $ 6 $ |  $166\,667\le M \le  376\,195$  |
+| **7**  | $ 6 $ |  $376\,196\le M \le  427\,656$  |
+| **8**  | $ 6 $ |  $427\,657\le M \le  481\,244$  |
+| **9**  | $ 6 $ |  $481\,245\le M \le  554\,261$  |
+| **10** | $ 6$  | $554\,262\le M \le 1\,000\,000$ |
+| **11** | $ 7$  |  $142\,858\le M \le  340\,734$  |
+| **12** | $ 7$  |  $340\,735\le M \le  387\,307$  |
+| **13** | $ 7$  |  $387\,308\le M \le  435\,920$  |
+| **14** | $ 7$  |  $435\,921\le M \le  502\,939$  |
+| **15** | $ 7$  | $502\,940\le M \le 1\,000\,000$ |
+| **16** | $ 8$  |  $125\,000\le M \le  312\,245$  |
+| **17** | $ 8$  |  $312\,246\le M \le  354\,780$  |
+| **18** | $ 8$  |  $354\,781\le M \le  399\,301$  |
+| **19** | $ 8 $ |  $399\,302\le M \le  461\,116$  |
+| **20** | $ 8 $ | $461\,117\le M \le 1\,000\,000$ |
+| **21** | $ 9 $ |  $111\,112\le M \le  288\,765$  |
+| **22** | $ 9 $ |  $288\,766\le M \le  327\,921$  |
+| **23** | $ 9 $ |  $327\,922\le M \le  368\,995$  |
+| **24** | $ 9 $ |  $368\,996\le M \le  426\,322$  |
+| **25** | $ 9 $ | $426\,323\le M \le 1\,000\,000$ |
+| **26** | $10 $ |  $100\,000\le M \le  269\,020$  |
+| **27** | $10 $ |  $269\,021\le M \le  305\,310$  |
+| **28** | $10 $ |  $305\,311\le M \le  343\,441$  |
+| **29** | $10 $ |  $343\,442\le M \le  396\,873$  |
+| **30** | $10 $ | $396\,874\le M \le 1\,000\,000$ |
+
+</Details>
diff --git a/src/routes/2026/pre_m.mdx b/src/routes/2026/pre_m.mdx
new file mode 100644
index 00000000..07eda278
--- /dev/null
+++ b/src/routes/2026/pre_m.mdx
@@ -0,0 +1,377 @@
+---
+title: NEXT NATION
+year: 2026
+stage: 마스터 트랙 예선 라운드
+---
+
+**NEXT NATION**은 건물을 건설하고 전사들을 훈련시켜 적의 본부를 파괴하는 2인 턴제 전략 게임입니다.
+
+<center>
+  <YouTube videoId="BnExruRtP1A" />
+</center>
+
+<br />
+<br />
+<br />
+
+## 게임 규칙
+
+### 1 | 개요
+
+게임은 **전장** 위에서 진행됩니다. 전장은 $0$번부터 $N-1$번까지 번호가 붙은 $N$개의 **구역**으로 나뉘어 있으며, 중심을 기준으로 점대칭을 이룹니다. 가장 왼쪽($0$번)과 오른쪽($N-1$번) 구역에는 각 플레이어의 **본부**가 있습니다. 본부가 없는 구역 중 $K$개는 **기지**를 건설 가능한 **거점**입니다.
+
+전장의 크기 $N$은 $51 \le N \le 109$, 거점의 수 $K$는 $\lceil 0.15N \rceil \le K \le \lfloor 0.2N \rfloor$입니다. $N$과 $K$는 반드시 홀수입니다.
+
+각 플레이어는 본부에 위치한 **전사** $3$명과 **금화** $500$개로 시작합니다. 본부는 초기에 레벨 $1$, 체력 $10$이며, 전사의 초기 체력은 $4$입니다. 본부가 파괴된 플레이어는 패배합니다.
+
+플레이어는 매일 다음 명령을 원하는 만큼 내릴 수 있습니다.
+
+- **건설**: 이미 있는 아군 건물(본부 및 기지)을 업그레이드하거나, 건물이 없는 거점 위에 새로운 기지를 건설할 수 있습니다.
+  - 건설 명령을 수행할 위치에는 아군 전사가 한 명 이상 있고, 적 전사가 없어야 합니다.
+- **이동**: 현재 이동 상태가 아닌 전사 하나에게 특정 구역으로 이동하라고 명령합니다.
+- **훈련**: 본부에서 전사를 $n$명 훈련합니다. $n$은 `본부의 훈련 가능 전사 수` 이하인 $0$ 이상의 정수여야 합니다.
+  - 훈련 명령은 하루에 한 번 초과로 할 수 없습니다.
+
+플레이어가 명령을 전달하고 나면, 하루가 시작됩니다. 하루는 **아침**, **낮**, **저녁**으로 나뉩니다.
+
+#### 아침
+
+**건설 단계** → **이동 단계** → **훈련 단계** 순서대로 진행됩니다.
+
+- **건설 단계**에서는, 금화를 지불하고 새로 기지를 건설하거나 기존에 지어진 건물을 업그레이드합니다.
+- **이동 단계**에서는, 오늘 이동 명령을 받았거나 이동 중이었던 전사들이 **이동 규칙**(섹션 3)에 따라 최대 한 칸 이동합니다.
+  - 이동 명령을 새로 받은 병사마다 금화 $10$개를 지불합니다. 단, 목적지가 아군 건물이라면 지불하지 않습니다.
+- **훈련 단계**에서는, 훈련시키기로 한 전사 수만큼 본부에서 전사를 훈련하고 한 명당 금화 $120$개를 지불합니다.
+  - 훈련된 전사의 체력은 본부의 레벨에 따릅니다.
+  - 전사는 훈련되면 고유한 번호를 받으며, 먼저 훈련된 전사가 더 작은 번호를 가집니다.
+
+#### 낮
+
+**전투 단계**가 진행됩니다.
+
+- **전투 단계**에서는, **전투 규칙**(섹션 3)에 따라 적 전사와 건물을 공격합니다.
+
+#### 저녁
+
+**노동 단계** → **보급 단계** 순서대로 진행됩니다.
+
+- **노동 단계**에서는 각 건물에서 $15 \times x$만큼 금화를 얻습니다. $x$는 `해당 구역의 아군 전사 수`와 `해당 건물의 노동 가능 전사 수` 중 작은 값입니다.
+- **보급 단계**에서는, 번호 오름차순으로 각 전사가 $2$만큼의 금화를 식비로 소모합니다. 만약 식비가 부족한 경우, 해당 전사는 체력을 1 잃습니다. 이때 전사의 체력이 $0$이 된 경우 전사는 퇴각하여 전장에서 벗어납니다.
+
+<br />
+
+---
+
+<br />
+
+### 2 | 건물
+
+건물은 수입을 책임지는 원천입니다.
+
+건물은 업그레이드 또는 수리 시 체력이 최대 체력까지 가득 찹니다.
+
+건물에는 포탑이 있어, 매일 전투 단계 시작 시에 공격력만큼 같은 구역에 공격을 수행합니다. 상세 설명은 전투 단계를 확인해 주세요.
+
+각 구역에 대해 건설 명령은 하루에 최대 한 번만 내릴 수 있습니다. 즉, 한 건물을 하루에 두 번 이상 업그레이드 하거나, 오늘 새로 지어진 건물을 오늘 업그레이드할 수 없습니다.
+
+#### 본부
+
+각 플레이어는 처음에 레벨 $1$인 본부를 가지고 시작합니다. 본부는 각 플레이어마다 하나씩만 가질 수 있습니다.
+
+|    레벨     | 업그레이드 비용 | 전사 최대 체력 | 본부 최대 체력 | 포탑 공격력 | 훈련 가능 전사 수 | 노동 가능 전사 수 |
+| :---------: | :-------------: | :------------: | :------------: | :---------: | :---------------: | :---------------: |
+|     $1$     |        -        |      $4$       |      $10$      |     $1$     |        $1$        |        $1$        |
+|     $2$     |  금화 $600$개   |      $5$       |      $15$      |     $2$     |        $1$        |        $2$        |
+|     $3$     | 금화 $1\,200$개 |      $6$       |      $20$      |     $2$     |        $2$        |        $3$        |
+|     $4$     | 금화 $2\,400$개 |      $7$       |      $25$      |     $3$     |        $2$        |        $4$        |
+|     $5$     | 금화 $3\,600$개 |      $8$       |      $30$      |     $3$     |        $3$        |        $5$        |
+| $5+$ (수리) | 금화 $1\,000$개 |       -        |       -        |      -      |         -         |         -         |
+
+<br />
+
+#### 기지
+
+각 플레이어는 원하는 만큼 기지를 지을 수 있습니다. 기지에서는 본부와 달리, 전사를 훈련시킬 수 없습니다.
+
+|    레벨     | 건설 또는 업그레이드 비용 | 최대 체력 | 포탑 공격력 | 노동 가능 전사 수 |
+| :---------: | :-----------------------: | :-------: | :---------: | :---------------: |
+|     $1$     |       금화 $300$개        |    $6$    |     $1$     |        $1$        |
+|     $2$     |       금화 $600$개        |   $12$    |     $1$     |        $2$        |
+|     $3$     |      금화 $1\,000$개      |   $18$    |     $2$     |        $3$        |
+| $3+$ (수리) |       금화 $500$개        |     -     |      -      |         -         |
+
+<br />
+
+---
+
+<br />
+
+### 3 | 이동과 전투
+
+#### 이동 규칙
+
+이동 명령을 수행 중인 각 전사는 현재 구역에 적 전사가 없다면, 현재 위치에서 목적지까지 인접한 두 구역 사이의 직선 거리 합이 가장 짧은 경로를 따라 한 구역 이동합니다. 엄밀하게는 다음과 같습니다.
+
+<Details>
+
+중심이 $(x_1, y_1)$와 $(x_2, y_2)$인 두 구역 간의 **직선 거리**를 $\left \lceil \sqrt{(x_1 - x_2) ^2 + (y_1 - y_2)^2 } \right \rceil$, 즉 두 구역의 중심 사이의 유클리드 거리의 올림이라 합시다. 이때 각 전사는 현재 위치에서 목적지까지 인접한 구역을 통해서만 이동하되, 경로 위에서 연속한 두 구역 사이의 **직선 거리** 합이 최소가 되는 경로를 찾아 해당 경로에서 현재 위치 바로 다음에 있는 구역으로 이동합니다. 그러한 경로가 여럿이라면, 구역 번호가 더 작은 구역으로 이동합니다.
+
+</Details>
+
+이동 명령을 한 번 내리면 해당 전사는 목적지에 도착할 때까지 다른 이동 명령을 받을 수 없습니다. 전사에게 내려진 이동 명령은 목적지에 도착하는 즉시 끝납니다.
+
+- 금화를 소모하는 이동 명령을 내린 후, 목적지에 기지가 건설되더라도 소모한 금화가 반환되지는 않습니다.
+- 금화를 소모하지 않는 이동 명령을 내린 후, 목적지의 건물이 파괴되더라도 이동이 중단되지는 않습니다.
+
+#### 전투 규칙
+
+1. 건물이 있는 구역에서, 해당 건물은 포탑 공격력 횟수만큼 공격을 수행합니다.
+2. 각 구역에서, 나와 상대 전사 수가 각각 $a$, $b$라 할 때, 상대는 $a$번, 나는 $b$번 공격당합니다. 체력이 $0$인 전사는 전투가 끝날 때까지 퇴각하지 않으므로, 포탑 공격으로 체력이 $0$이 된 전사도 $a$와 $b$에 포함됩니다.
+3. 전투가 종료되고, 체력 $0$인 전사들이 퇴각하여 전장에서 벗어납니다. 또한 체력 $0$인 건물이 파괴됩니다.
+
+매 공격은 다음 규칙을 따라 수행됩니다.
+
+- 그 구역에서 체력이 $0$이 아닌 상대편의 전사 중, 체력이 가장 작은 전사의 체력이 $1$ 감소합니다. 만약 그러한 전사가 여럿이라면, 번호가 가장 앞선 전사가 대상이 됩니다.
+- 만약 그 구역에 체력이 $0$이 아닌 상대편의 전사가 없고, 체력이 $0$이 아닌 상대편의 건물이 있다면 해당 건물의 체력이 $1$ 감소합니다.
+
+<br />
+
+---
+
+<br />
+
+### 4 | 게임 종료
+
+게임이 시작하고 $200$일 동안 어느 한 플레이어의 본부가 파괴되었다면 파괴되지 않은 플레이어의 승리입니다.
+
+두 본부가 동시에 파괴된 경우 혹은 게임이 시작하고 $200$일 동안 양쪽 본부가 파괴되지 않은 경우, 본부의 체력이 더 많은 쪽이 승리합니다.
+
+만약 본부의 체력도 같다면 무승부가 됩니다.
+
+<br />
+
+---
+
+<br />
+
+### 5 | 세부 규칙: 전장 생성 방식
+
+전장의 구조는 입력으로 주어지기 때문에, 생성 규칙을 알아야만 문제를 해결할 수 있는 것은 아닙니다.
+
+전장이 어떠한 방식으로 생성되는지 알고 싶으신 분은 아래를 읽을 것을 권장드립니다.
+
+<Details>
+
+### 전장
+
+전장은 무한한 크기의 유클리드 평면 위에 있습니다.
+
+- 전장에는 정확히 $N = 2N'+1$개의 다각형 모양 구역이 있습니다.
+- 각 구역은 다각형의 테두리를 제외한 내부에 있는 점인 **중심**을 하나씩 가집니다.
+- 두 구역이 인접하다는 것은, 두 구역이 적어도 하나의 변을 공유한다는 것입니다.
+- 가장 왼쪽($0$번 구역)과 오른쪽의 구역($N-1$번 구역)에는 각 플레이어의 **본부**가 세워져 있습니다.
+
+전장에는 특수한 구역인 거점이 있습니다.
+
+- $K = 2K'+1$개의 구역은 거점입니다. 거점에는 건물을 건설할 수 있습니다.
+
+전장은 매 게임마다 구조가 무작위로 생성됩니다. 구체적인 규칙은 아래에서 확인할 수 있습니다.
+
+#### 생성 과정
+
+아래 설명에서 $L = 10^4$, $D = 100$, $A = 24$입니다.
+매 시행은 독립이며, 특정한 범위에서 대상을 뽑을 때, 해당 범위 안에 있는 대상이 모두 같은 확률로 선택됩니다.
+
+(1) $N'$과 $K'$을 정합니다.
+
+- $N'$은 $25$ 이상 $54$ 이하의 정수 중에서 무작위로 정해집니다.
+- 이후에 $K'$은 $\left\lceil \frac{0.15(2N'+1)-1}{2} \right\rceil$ 이상 $\left\lfloor \frac{0.2(2N'+1)-1}{2} \right\rfloor$ 이하의 정수에서 무작위로 정해집니다.
+
+(2) 유클리드 좌표평면에서, 원점을 중심으로 삼고 반지름이 $L$인 원을 $S$라고 합시다.
+
+(3) 처음에 $P = \{(0, 0)\}$입니다. 다음을 $N'$회 반복합니다.
+
+- $S$의 경계 또는 내부에 있는 격자점을 하나 뽑아 $u=(x_u, y_u)$라 합니다.
+- 만약 어떤 점 $(x_v, y_v) = v \in P$가 존재해서 다음 중 하나를 만족한다면 $u$를 다시 뽑습니다. $\mathrm{dist}(u, v)$는 점 $u$와 $v$ 사이의 유클리드 거리입니다.
+  - $x_u = x_v$
+  - $\mathrm{dist}(u, v) < D$
+- $P$에 $u$와 $u$를 원점 $O$ 기준으로 점대칭한 점인 $u'$를 추가합니다.
+
+반복 후 $|P| = 2N' + 1$입니다. $x$좌표가 증가하는 순서대로 $0$번부터 $N-1$번까지 번호를 붙입니다.
+
+(4) 원점 $O$를 중심으로 하고 반지름이 $1.5L$인 원 $C$를 그린 후 $A$등분합니다. 구체적으로, $C$와 $x$축이 교차하는 두 점을 각각 $t_1$과 $t_2$라고 할 때, $t_1$과 $t_2$를 잇는 위쪽 호와 아랫쪽 호를 각각 $A/2$등분하는 점들을 찾습니다. 이 점들을 $Q$라고 합니다.
+
+(5) $P \cup Q$에 있는 점들을 기준으로 보로노이 다이어그램과 델루네 삼각분할을 계산합니다. $P$의 각 점과 듀얼 관계인 보로노이 다이어그램의 다각형들의 각 무게중심을 모아 $P'$이라고 하고, 각 점에 부여된 번호를 그대로 다시 붙입니다. 이후 $P' \cup Q$를 기준으로 보로노이 다이어그램과 델루네 삼각분할을 다시 계산합니다.
+
+(6) $t$번 점과 듀얼 관계가 있는 보로노이 다이어그램의 다각형이 $t$번 구역이 되고 $t$번 점은 $t$번 구역의 중심이 됩니다. 각 구역은 그 구역의 중심이 점 $u$라고 할 때 $u$와 델루네 삼각분할에서 이어져 있으면서 $v \in P$인 점 $v$가 중심인 구역과 이어져 있습니다. 쉽게 말해, 각 구역은 델루네 삼각분할로 이어진 구역 중 $Q$로부터 만들어지지 않은 구역들과 인접합니다.
+
+(7) 처음에 $R = \{N'\}$입니다. 다음을 $K'$회 반복합니다.
+
+- $t \in [0, N-1]$이고 $t \not \in R$인 무작위 $t$를 고릅니다.
+- 만약 하나 이상의 $r \in R$에 대해 $t$번 구역 또는 $N-1-t$번 구역이 $r$번 구역과 인접해 있다면, $t$를 다시 뽑습니다.
+- 만약 $t$번 구역과 $N-1-t$번 구역이 인접해 있다면, $t$를 다시 뽑습니다.
+- $R$에 $t$와 $N-1-t$를 추가합니다.
+
+반복 후 $|R| = 2K' + 1$입니다. 각 $r \in R$에 대해, $r$번 구역은 거점입니다.
+
+</Details>
+
+<br />
+
+---
+
+## 인터랙션
+
+참가자의 프로그램은 표준 입력(`stdin`)에서 입력을 받아 각 명령에 따라 동작해야 합니다.
+
+#### 준비
+
+```
+READY (LEFT | RIGHT)
+N K
+x_{0} ... x_{N-1}
+y_{0} ... y_{N-1}
+p_{0} ... p_{K-1}
+a_{0} b_{0,0} ... b_{0,a_{0}-1}
+...
+a_{N-1} b_{N-1,0} b_{N-1,1} ... b_{N-1,a_{N-1}-1}
+```
+
+플레이어의 진영과 맵에 대한 정보를 알려주는 명령입니다.
+
+- 첫 번째 줄에 어느 쪽 본부를 사용하는지가 주어집니다.
+- 두 번째 줄에 $N$과 $K$가 주어집니다.
+- $x_i$와 $y_i$는 각각 $i$번 구역 중심의 $x$좌표와 $y$좌표입니다.
+- $p_i$는 거점의 구역 번호입니다.
+- $i$번 구역은 $a_i$개의 구역과 인접해 있습니다. $i$번 구역과 인접한 구역의 목록은 $b_{i,j}$ ($0 \le j < a_i$)로 주어집니다.
+
+플레이어는 입력 준비 완료를 의미하는 `OK`를 $1\,000$ms 안에 출력해야 합니다. 그렇지 않은 경우 시간 초과(TLE)로 패배합니다.
+
+#### 명령 시작
+
+```
+START TURN T
+```
+
+매 턴의 시작마다, `START` 명령어가 주어집니다. $T$는 오늘이 몇 번째 날인지를 나타냅니다.
+
+#### 명령 제출
+
+```
+COMMAND
+...
+MOVE a d
+TRAIN n
+UPGRADE d
+...
+END
+```
+
+플레이어는 `COMMAND` 명령어로 명령 단계를 시작할 수 있습니다. 플레이어는 원하는 개수만큼의 명령어를 순서 상관 없이 제출할 수 있습니다. 그 후 `END` 명령어로 목록의 끝을 표시합니다.
+
+처음 주어지는 전사들의 번호는 왼쪽 플레이어의 경우 `A1`, `A2`, `A3`이고, 오른쪽 플레이어의 경우 `B1`, `B2`, `B3`입니다.
+
+- `MOVE`: 번호가 $a$인 전사를 $d$번 구역으로 이동시키는 이동 명령을 내립니다.
+- `TRAIN`: 본부에서 $n$명의 전사를 훈련합니다. 이 명령은 명령 단계에 반드시 $1$개 이하로 존재해야 합니다.
+- `UPGRADE`: $d$번 구역에 있는 아군 건물을 업그레이드하거나 수리합니다. $d$번 구역에 건물이 없다면, 대신 기지를 건설합니다.
+
+플레이어는 `START` 명령어를 받고 난 후부터 $100$ms 안에 목록을 제출해야 합니다(`END` 명령어를 출력해야 합니다). 만약 $100$ms를 초과하여 사용하였다면, 초과한 시간 $t$ms에 대해 $\displaystyle \left \lceil \frac{t}{100} \right \rceil$개의 초읽기를 소모합니다. 남은 초읽기가 없는 상태에서 시간을 초과했다면, 시간 초과(TLE)로 패배합니다. 각 플레이어는 처음에 $5$개씩의 초읽기를 가지고 시작합니다.
+
+유효하지 않은 명령을 제출했다면, 그 즉시 규칙 위반(WA)로 패배합니다. 동시에 유효하지 않은 명령을 제출했다면, 무승부가 됩니다.
+
+#### 결과 보기
+
+```
+TURN T
+TIME T_x R_x T_y R_y
+UPGRADE N
+t_1 d_1
+...
+TRAIN N
+a_1 ... a_N
+MOVE N
+a_1 d_1
+...
+DAMAGE N
+C_1 a_1 h_1
+...
+SIEGE N
+t_1 d_1 h_1
+...
+```
+
+두 플레이어가 모두 명령 제출을 정상적으로 마쳤다면, 결과가 반환됩니다. `TRAIN`, `UPGRADE`, `MOVE`, `DAMAGE`, `SIEGE` 섹션에서 $N = 0$인 경우, 해당 섹션에는 뒤따르는 줄이 주어지지 않습니다.
+
+- `TURN` $T$: 현재 $T$일차에 대한 정보가 표기됨을 알려줍니다.
+- `TIME` $T_x$ $R_x$ $T_y$ $R_y$:
+  - $T_x$와 $T_y$는 각각 이번 턴에 자신과 상대 플레이어가 시간을 얼마나 사용했는지를 나타냅니다(ms).
+  - $R_x$와 $R_y$는 자신과 상대 플레이어에게 몇 개의 초읽기가 남아있는지를 나타냅니다.
+- `UPGRADE` $N$:
+  - 이번 턴에 건설, 업그레이드 또는 수리된 건물의 수 $N$이 주어집니다.
+  - 이어 $N$개의 줄에 건물의 소속 $t_i$($t_i$는 `A`나 `B`), 해당 건물이 있는 구역 번호 $d_i$가 차례대로 주어집니다.
+- `TRAIN` $N$:
+  - 이번 턴에 훈련된 전사의 수 $N$이 주어집니다.
+  - 이어 다음 줄에 새롭게 훈련된 전사의 번호가 차례대로 주어집니다. 전사의 번호는 유일하게 부여되며, 각 플레이별로 1부터 차례대로 증가합니다.
+  - 전사의 번호는 항상 `A` 또는 `B`에 정수를 하나 이어 붙인 형태입니다(e.g. `A12`, `B7`). `A`로 시작하면 왼쪽 플레이어의 전사이고, `B`로 시작하면 오른쪽 플레이어의 전사입니다.
+- `MOVE` $N$:
+  - 이번 턴에 이동한 전사의 수 $N$이 주어집니다.
+  - 이어 $N$개의 줄에 이동한 전사의 번호 $a_i$와 이동한 구역 번호 $d_i$가 차례대로 주어집니다.
+- `DAMAGE` $N$:
+  - 이번 턴에 전사에 발생한 피해 정보의 개수 $N$이 주어집니다.
+  - 이어 $N$개의 줄에 피해 원인 $C_i$, 피해를 입은 전사의 번호 $a_i$, 입힌 피해량 $h_i$가 차례대로 주어집니다.
+  - $C_i$는 다음 중 하나입니다: `TURRET`(건물 포탑에 의한 피해), `COMBAT`(전사 간 전투에 의한 피해), `HUNGER`(보급 단계 식비 부족에 의한 피해).
+- `SIEGE` $N$:
+  - 이번 턴에 건물에 발생한 피해 정보의 개수 $N$이 주어집니다.
+  - 이어 $N$개의 줄에 건물의 소속 $t_i$($t_i$는 `A`나 `B`), 피해를 입은 건물이 있는 구역 번호 $d_i$와 입힌 공성 피해량 $h_i$가 차례대로 주어집니다.
+
+각 턴의 결과는 `END` 명령어로 마무리됩니다.
+
+### 게임 종료
+
+```
+FINISH
+```
+
+어떤 이유로든 게임이 종료되면, `FINISH` 명령어가 주어집니다. **이 명령을 받으면 게임 진행 상황에 관계 없이 프로그램은 즉시 정상적으로 종료되어야 합니다.** 다시 말해 턴이 종료되고 나서 결과 대신 `FINISH` 명령어가 주어진다면, 프로그램은 결과를 읽으려 시도하기 전에 즉시 종료해야 합니다.
+
+## 게임 시뮬레이터
+
+[시뮬레이터 바로가기](https://d3a0kd35ch7dmv.cloudfront.net/)
+
+위 시뮬레이터에 로그를 붙여 넣어 게임 플레이를 분석할 수 있습니다.
+
+## CLI 툴
+
+[CLI 툴 다운로드](https://nypc-static.s3.ap-northeast-2.amazonaws.com/2026/nextnation-61bnx71k/nation-providing.zip)
+
+위 CLI 툴을 활용하여 로컬에서 AI를 대결시켜볼 수 있습니다.
+
+## 예제 코드
+
+대회에서 지원하는 각 언어로 작성된 예제 코드를 아래에서 확인할 수 있습니다.
+
+- C: [sample-code.c](https://nypc-static.s3.ap-northeast-2.amazonaws.com/2026/nextnation-61bnx71k/sample-code/sample-code.c)
+- C++: [sample-code.cpp](https://nypc-static.s3.ap-northeast-2.amazonaws.com/2026/nextnation-61bnx71k/sample-code/sample-code.cpp)
+- Python: [sample-code.py](https://nypc-static.s3.ap-northeast-2.amazonaws.com/2026/nextnation-61bnx71k/sample-code/sample-code.py)
+- Rust: [sample-code.rs](https://nypc-static.s3.ap-northeast-2.amazonaws.com/2026/nextnation-61bnx71k/sample-code/sample-code.rs)
+- Java: [Main.java](https://nypc-static.s3.ap-northeast-2.amazonaws.com/2026/nextnation-61bnx71k/sample-code/Main.java)
+- JavaScript: [sample-code.js](https://nypc-static.s3.ap-northeast-2.amazonaws.com/2026/nextnation-61bnx71k/sample-code/sample-code.js)
+- TypeScript: [sample-code.ts](https://nypc-static.s3.ap-northeast-2.amazonaws.com/2026/nextnation-61bnx71k/sample-code/sample-code.ts)
+- C#: [sample-code.cs](https://nypc-static.s3.ap-northeast-2.amazonaws.com/2026/nextnation-61bnx71k/sample-code/sample-code.cs)
+- Kotlin: [sample-code.kt](https://nypc-static.s3.ap-northeast-2.amazonaws.com/2026/nextnation-61bnx71k/sample-code/sample-code.kt)
+- Go: [sample-code.go](https://nypc-static.s3.ap-northeast-2.amazonaws.com/2026/nextnation-61bnx71k/sample-code/sample-code.go)
+- Scala: [sample-code.scala](https://nypc-static.s3.ap-northeast-2.amazonaws.com/2026/nextnation-61bnx71k/sample-code/sample-code.scala)
+- Lua: [sample-code.lua](https://nypc-static.s3.ap-northeast-2.amazonaws.com/2026/nextnation-61bnx71k/sample-code/sample-code.lua)
+
+## 샘플 AI
+
+| 배틀 번호 | <div style={{ minWidth: "320px" }}>설명</div> |
+| :-------: | :-------------------------------------------: |
+|    $1$    |         아무 명령도 내리지 않습니다.          |
+|    $2$    |       샘플 코드와 동일한 동작을 합니다.       |
+|    $3$    |      기초적인 공격형 전략을 구사합니다.       |
+|    $4$    |      기초적인 성장형 전략을 구사합니다.       |
+|    $5$    |      초보적인 공격형 전략을 구사합니다.       |
+|    $6$    |      초보적인 성장형 전략을 구사합니다.       |
+|    $7$    |      적응적인 공격형 전략을 구사합니다.       |
+|    $8$    |       심화된 공격형 전략을 구사합니다.        |
diff --git a/src/routes/__root.tsx b/src/routes/__root.tsx
index f4cb2768..344b8b0a 100644
--- a/src/routes/__root.tsx
+++ b/src/routes/__root.tsx
@@ -39,7 +39,7 @@ export const Route = createRootRoute({
         content: "width=device-width, initial-scale=1",
       },
       {
-        title: "NYPC — Nexon Youth Programming Challenge",
+        title: "NYPC — NEXON Young Programmers Cup",
       },
     ],
     links: [
diff --git a/src/routes/en/2026/index.tsx b/src/routes/en/2026/index.tsx
new file mode 100644
index 00000000..8c23e034
--- /dev/null
+++ b/src/routes/en/2026/index.tsx
@@ -0,0 +1,33 @@
+import { Typo } from "@solved-ac/ui-react";
+import { createFileRoute } from "@tanstack/react-router";
+import { PostLayout, ProblemList } from "components";
+
+const year = 2026;
+
+export const problems = {
+  master: [["pre_m", "NEXT NATION"]],
+} as const;
+
+const List = () => {
+  return (
+    <PostLayout
+      en={true}
+      meta={{
+        title: `NYPC ${year}`,
+      }}
+      theme={{
+        background: "#191716",
+        color: "#FFFFFF",
+      }}
+    >
+      <Typo h2 no-margin>
+        Master Track &mdash; Qualification Round
+      </Typo>
+      <ProblemList en={true} year={year} problems={problems.master} />
+    </PostLayout>
+  );
+};
+
+export const Route = createFileRoute("/en/2026/")({
+  component: List,
+});
diff --git a/src/routes/en/2026/pre_m.mdx b/src/routes/en/2026/pre_m.mdx
new file mode 100644
index 00000000..1de331b8
--- /dev/null
+++ b/src/routes/en/2026/pre_m.mdx
@@ -0,0 +1,379 @@
+---
+title: NEXT NATION
+year: 2026
+stage: Master Track Qualification Round
+---
+
+**NEXT NATION** is a two-player turn-based strategy game where players build buildings, train warriors, and destroy the opponent's headquarter.
+
+<center>
+  <YouTube videoId="BnExruRtP1A" />
+</center>
+
+<br />
+<br />
+<br />
+
+## Rules
+
+### 1 | Introduction
+
+The game is played on the **battlefield**. The battlefield consists of $N$ areas indexed from $0$ through $N-1$, point-symmetric with respect to the origin. The leftmost area #$0$ and the rightmost area #$N-1$ each have a player's **headquarter**. Among areas without headquarter, $K$ areas are **stronghold**s, where **base**s can be built.
+
+$N$, the size of battlefield, satisfies $51 \le N \le 109$, and $K$, the number of strongholds, satisfies $\lceil 0.15N \rceil \le K \le \lfloor 0.2N \rfloor$. $N$ and $K$ are both odd numbers.
+
+Each player starts the game with $3$ **warriors** on their headquarter and $500$ gold. The headquarter is initially at level $1$, HP $10$, and the warriors are initially at HP $4$. If the headquarter is destroyed, the owner loses.
+
+Every day, a player can deliver the following commands as many times as they want:
+
+- **Upgrade**: A player can upgrade existing allied buildings (headquarter or base), or build a new base on a stronghold with no building.
+  - To deliver an Upgrade command, there should be one or more allied warriors and no enemy warriors at the target area.
+- **Move**: A player can command a warrior that is not currently in the moving state to move to a desired area.
+  - However, if there is an allied building on the desired area, no gold is consumed.
+- **Train**: By using $120 \times n$ gold, train $n$ warriors on the headquarter. $n$ is a non-negative integer less than or equal to `# of trainable warriors`.
+  - You cannot use Train command more than once on the same day.
+
+After delivering the commands, the day starts. The day consists of **The Morning**, **The Daytime**, and **The Evening**.
+
+#### The Morning
+
+The Morning consists of **Building Step** → **Moving Step** → **Training Step**, in order.
+
+- In the **Building Step**, new bases are raised and buildings already built are upgraded by spending gold.
+- In the **Moving Step**, the warriors that received Move commands on the same day or were already in moving state move up to one area according to the **Movement Rule** (Section 3).
+  - You spend $10$ golds for every warrior that recieved the move command on the current day. However you do not pay if the destination have allied building.
+- In the **Training Step**, train the commanded number of warriors and spend $120$ gold for each warrior.
+  - The HP of each warrior is determined by the level of the headquarter.
+  - The warriors are indexed uniquely, and warriors trained earlier have smaller indices.
+
+#### The Daytime
+
+**Battle Step** occurs.
+
+- In the **Battle Step**, warriors attack other warriors or buildings with respect to the **Battle Rule** (Section 3).
+
+#### The Evening
+
+The Evening consists of **Labor Step** → **Supply Step**, in order.
+
+- In the **Labor Step**, each building produces $15 \times x$ gold, where $x$ is the minimum value of `# of allied warriors in the area` and `# of labor slots`.
+- In the **Supply Step**, each warrior consumes $2$ gold in increasing order of number. If there is not enough gold when a warrior tries to consume gold, the warrior loses 1 HP. If the HP of the warrior becomes 0, the warrior retreats, leaving the battlefield.
+
+<br />
+
+---
+
+<br />
+
+### 2 | Building
+
+Buildings are the source of income.
+
+After raising, upgrading or repairing buildings, the HP becomes its maximum HP.
+
+At the start of each battle step, the turret in the building performs attacks in the same area as many times as its attack damage (AD). For further information, please refer to the Battle Step.
+
+For each area, an Upgrade command can be delivered at most once per day. A building cannot be upgraded twice on the same day, nor can a building be upgraded on the same day it is built.
+
+#### Headquarter (HQ)
+
+Each player starts with a headquarter of level $1$. Only one headquarter is allowed for each player.
+
+|     Level     | Upgrade cost  | Max HP of Warrior | Max HP of HQ | AD of turret | # of trainable warrior | # of labor slot |
+| :-----------: | :-----------: | :---------------: | :----------: | :----------: | :--------------------: | :-------------: |
+|      $1$      |       -       |        $4$        |     $10$     |     $1$      |          $1$           |       $1$       |
+|      $2$      |  $600$ gold   |        $5$        |     $15$     |     $2$      |          $1$           |       $2$       |
+|      $3$      | $1\,200$ gold |        $6$        |     $20$     |     $2$      |          $2$           |       $3$       |
+|      $4$      | $2\,400$ gold |        $7$        |     $25$     |     $3$      |          $2$           |       $4$       |
+|      $5$      | $3\,600$ gold |        $8$        |     $30$     |     $3$      |          $3$           |       $5$       |
+| $5+$ (Repair) | $1\,000$ gold |         -         |      -       |      -       |           -            |        -        |
+
+<br />
+
+#### Base
+
+Each player can build as many bases as they want. Unlike headquarter, warriors cannot be trained on base.
+
+|     Level     | Raise/Upgrade cost | Max HP | AD of turret | # of labor slot |
+| :-----------: | :----------------: | :----: | :----------: | :-------------: |
+|      $1$      |     $300$ gold     |  $6$   |     $1$      |       $1$       |
+|      $2$      |     $600$ gold     |  $12$  |     $1$      |       $2$       |
+|      $3$      |   $1\,000$ gold    |  $18$  |     $2$      |       $3$       |
+| $3+$ (Repair) |     $500$ gold     |   -    |      -       |        -        |
+
+<br />
+
+---
+
+<br />
+
+### 3 | Movement and Battle
+
+#### Movement Rule
+
+If there is no enemy warrior in the same area as a warrior that is performing a Move command, it moves by one area along a path whose sum of straight line distances between adjacent areas is minimum. Technical details are as follows:
+
+<Details summary="Details">
+
+Define **straight line distance** between $(x_1, y_1)$ and $(x_2, y_2)$ as $\left \lceil \sqrt{(x_1 - x_2) ^2 + (y_1 - y_2)^2 } \right \rceil$, i.e., the ceiling of Euclidean distance. Each warrior finds a path to its target by moving only through adjacent areas, minimizing the sum of straight line distances between consecutive areas on the path, and moves to the next area on that path. If multiple such paths exist, it moves to the area with the smaller index.
+
+</Details>
+
+After delivering a Move command to a warrior, it enters the moving state and cannot receive another Move command before it arrives at the target area. The moving state ends as soon as it arrives at the target area.
+
+- After delivering a Move command that costs gold, the gold is not refunded even if the building is built on the target area.
+- After delivering a Move command that does not cost gold, the movement is not aborted even if the building is destroyed on that area.
+
+#### Battle Rule
+
+1. In each area with a building, the building performs attacks as many times as its turret AD.
+2. In each area, say the numbers of my warriors and the opponent's warriors are $a$ and $b$; the opponent is attacked $a$ times and I am attacked $b$ times. Warriors with $0$ HP do not retreat until the battle finishes, so warriors whose HP became $0$ from turret attacks are still counted in $a$ and $b$.
+3. After the battle finishes, warriors with $0$ HP retreat and leave the battlefield. Buildings with $0$ HP are destroyed.
+
+The rule of each attack is as follows:
+
+- Among the opponent's warriors with positive HP, decrease the HP of the warrior with minimum HP by 1. If multiple such warriors exist, the warrior with the lowest number is targeted.
+- If there is no opponent's warrior with positive HP, and the opponent's building has positive HP, the HP of the opponent's building is decreased by 1.
+
+<br />
+
+---
+
+<br />
+
+### 4 | Game End
+
+During $200$ days from the game start, if the Headquarter is destroyed, then the player whose Headquarter is not destroyed wins.
+
+If two headquarters are destroyed on the same day, or both headquarters are not destroyed in $200$ days, then the side whose HQ has more HP wins.
+
+If the HP of two HQ are equal, then the game ends in a draw.
+
+<br />
+
+---
+
+<br />
+
+### 5 | Detailed Rules: Battlefield Generation Method
+
+Since the structure of the battlefield is given as input, you do not need to know the generation rules to solve the problem.
+
+If you would like to know how the battlefield is generated, the details are as follows:
+
+<Details summary="Details">
+
+### Battlefield
+
+The battlefield can be represented as an infinitely sized Euclidean plane.
+
+- The battlefield has exactly $N = 2N'+1$ polygonal areas.
+- Each area has a **center**, which is a point inside the polygon excluding the border.
+- Two areas are adjacent if they share at least one side.
+- Each player's **headquarter** is established in the leftmost area #$0$ and the rightmost area #$N-1$.
+
+The battlefield contains special areas called strongholds.
+
+- $K = 2K'+1$ areas are strongholds. Buildings can be constructed on strongholds.
+
+The battlefield structure is randomly generated for every game. Specific rules can be found below.
+
+#### Generation Process
+
+In the description below, $L = 10^4$, $D = 100$, and $A = 24$.
+
+Each trial is independent, and when selecting a target from a specific range, all targets within that range are selected with equal probability.
+
+(1) Determine $N'$ and $K'$.
+
+- $N'$ is randomly selected from integers between $25$ and $54$ inclusive.
+- Subsequently, $K'$ is randomly selected from integers between $\left\lceil \frac{0.15(2N'+1)-1}{2} \right\rceil$ and $\left\lfloor \frac{0.2(2N'+1)-1}{2} \right\rfloor$ inclusive.
+
+(2) In the Euclidean coordinate plane, let $S$ be a circle centered at the origin with radius $L$.
+
+(3) Initially, $P = \{(0, 0)\}$. Repeat the following $N'$ times.
+
+- Select a grid point on or inside the boundary of $S$ and set it as $u=(x_u, y_u)$.
+- If there exists a point $(x_v, y_v) = v \in P$ satisfying one of the following, select $u$ again. $\mathrm{dist}(u, v)$ is the Euclidean distance between point $u$ and $v$.
+  - $x_u = x_v$
+  - $\mathrm{dist}(u, v) < D$
+- Add $u$ and $u'$, which is the point reflection of $u$ across the origin $O$, to $P$.
+
+After the repetition, $|P| = 2N' + 1$. Number the points from $0$ to $N-1$ in increasing order of the $x$ coordinates.
+
+(4) Draw a circle $C$ centered at the origin $O$ with radius $1.5L$ and divide it into $A$ equal parts. Specifically, let $t_1$ and $t_2$ be the two points where $C$ intersects the $x$ axis. Find the points that divide the upper arc and the lower arc connecting $t_1$ and $t_2$ into $A/2$ equal parts, respectively. Let these points be $Q$.
+
+(5) Calculate the Voronoi diagram and the Delaunay triangulation based on the points in $P \cup Q$. Collect the centroids of the Voronoi diagram polygons that are dual to each point in $P$ and call this $P'$, and reassign the numbers given to each point. Then, calculate the Voronoi diagram and the Delaunay triangulation based on $P' \cup Q$.
+
+(6) The Voronoi diagram polygon that is dual to point $t$ becomes area #$t$, and point $t$ becomes the center of area #$t$. If the center of an area is point $u$, that area is adjacent to areas whose centers are points $v \in P$ connected to $u$ in the Delaunay triangulation. Simply put, each area is adjacent to the areas connected by the Delaunay triangulation that were not formed from $Q$.
+
+(7) Initially, $R = \{N'\}$. Repeat the following $K'$ times.
+
+- Choose a random $t$ such that $t \in [0, N-1]$ and $t \not \in R$.
+- If for one or more $r \in R$, area #$t$ or area #$N-1-t$ is adjacent to area #$r$, draw $t$ again.
+- If area #$t$ and area #$N-1-t$ are adjacent, draw $t$ again.
+- Add $t$ and $N-1-t$ to $R$.
+
+After the iteration, $|R| = 2K' + 1$. For each $r \in R$, area #$r$ is a stronghold.
+
+</Details>
+
+<br />
+
+---
+
+## Interaction
+
+Your program must read input from standard input (`stdin`) and follow the protocol of each command.
+
+#### Ready
+
+```
+READY (LEFT | RIGHT)
+N K
+x_{0} ... x_{N-1}
+y_{0} ... y_{N-1}
+p_{0} ... p_{K-1}
+a_{0} b_{0,0} ... b_{0,a_{0}-1}
+...
+a_{N-1} b_{N-1,0} b_{N-1,1} ... b_{N-1,a_{N-1}-1}
+```
+
+This command informs the player of the side and the map of the battlefield.
+
+- The first line indicates which side of Headquarter the player uses.
+- The second line contains $N$ and $K$.
+- $x_i$ and $y_i$ are the $x$ and $y$-coordinates of the center of area #$i$.
+- $p_i$s are the indices of the strongholds.
+- Area #$i$ is adjacent to $a_i$ areas. The indices of adjacent areas are given as $b_{i,j}$ ($0 \le j < a_i$).
+
+Player must output `OK` in $1\,000$ms to indicate the program is ready. Failing to do so results in Time Limit Exceeded(TLE) and forfeits the game.
+
+#### Command Start
+
+```
+START TURN T
+```
+
+At the start of each turn, the `START` command is given. $T$ denotes the day index.
+
+#### Deliver Command
+
+```
+COMMAND
+...
+MOVE a d
+TRAIN n
+UPGRADE d
+...
+END
+```
+
+Player can start the command phase with the `COMMAND` command. Player can submit any number of commands in any order. Then, mark the end of the list with the `END` command.
+
+The initial warriors are indexed `A1`, `A2`, and `A3` for the left player, and `B1`, `B2`, and `B3` for the right player.
+
+- `MOVE`: Deliver a Move command to move warrior #$a$ to area #$d$.
+- `TRAIN`: Train $n$ warriors at the headquarter. There must be at most $1$ such command in the command phase.
+- `UPGRADE`: Upgrade or repair the allied building in area #$d$. If there is no building in area #$d$, build a base instead.
+
+Player must submit the list within $100$ms after receiving the `START` command (that is, output the `END` command). If more than $100$ms is used, for the exceeded time $t$ms, $\displaystyle \left \lceil \frac{t}{100} \right \rceil$ countdown tokens are consumed. If time is exceeded with no remaining countdown tokens, the player loses by Time Limit Exceeded(TLE). Each player starts with $5$ countdown tokens.
+
+If an invalid command is submitted, the player immediately loses by Wrong Answer(WA). If invalid commands are submitted at the same time, the game becomes a draw.
+
+#### View Result
+
+```
+TURN T
+TIME T_x R_x T_y R_y
+UPGRADE N
+t_1 d_1
+...
+TRAIN N
+a_1 ... a_N
+MOVE N
+a_1 d_1
+...
+DAMAGE N
+C_1 a_1 h_1
+...
+SIEGE N
+t_1 d_1 h_1
+...
+```
+
+If both players finish submitting commands normally, the result is returned. If $N = 0$ in a `TRAIN`, `UPGRADE`, `MOVE`, `DAMAGE`, or `SIEGE` section, no following line is given for that section.
+
+- `TURN` $T$: Indicates that information for the current day $T$ is shown.
+- `TIME` $T_x$ $R_x$ $T_y$ $R_y$:
+  - $T_x$ and $T_y$ indicate how much time you and the opponent used this turn, respectively (ms).
+  - $R_x$ and $R_y$ indicate how many countdown tokens remain for you and the opponent, respectively.
+- `UPGRADE` $N$:
+  - $N$, the number of buildings built, upgraded, or repaired this turn, is given.
+  - The next $N$ lines give the $t_i$, `A` or `B`, the owner of the building and $d_i$, the index of area of the building in order.
+- `TRAIN` $N$:
+  - $N$, the number of warriors trained this turn, is given.
+  - The next line gives the indices of newly trained warriors in order. Warrior indices are assigned uniquely, increasing sequentially from 1 for each player.
+  - Warrior indices are always in the form of `A` or `B` followed by an integer (e.g. `A12`, `B7`). If it starts with `A`, it is a warrior of the left player; if it starts with `B`, it is a warrior of the right player.
+- `MOVE` $N$:
+  - $N$, the number of warriors moved this turn, is given.
+  - The next $N$ lines give the index $a_i$ of the moved warrior and the index $d_i$ of the area it moved to in order.
+- `DAMAGE` $N$:
+  - $N$, the number of damage records for warriors this turn, is given.
+  - The next $N$ lines give the damage cause $C_i$, the index $a_i$ of the damaged warrior, and the damage amount $h_i$ in order.
+  - $C_i$ is one of the following: `TURRET`(damage by building turret), `COMBAT`(damage by combat between warriors), `HUNGER`(damage by lack of food cost in Supply Step).
+- `SIEGE` $N$:
+  - $N$, the number of damage records for buildings this turn, is given.
+  - The next $N$ lines give the building owner $t_i$ ($t_i$ is `A` or `B`), area #$d_i$ of the damaged building, and the siege damage amount $h_i$ in order.
+
+The result of each turn ends with the `END` command.
+
+### Game End
+
+```
+FINISH
+```
+
+When the game ends for any reason, the `FINISH` command is given. **When this command is received, the program must immediately terminate gracefully regardless of the game state.** In other words, if the `FINISH` command is given instead of the result after a turn ends, the program must immediately terminate before trying to read the result.
+
+## Game Simulator
+
+[Go to Simulator](https://d3a0kd35ch7dmv.cloudfront.net/)
+
+You can paste logs into the simulator above to analyze game play.
+
+## CLI Tool
+
+[Download CLI Tool](https://nypc-static.s3.ap-northeast-2.amazonaws.com/2026/nextnation-61bnx71k/nation-providing.zip)
+
+You can use the CLI tool above to have AIs play against each other locally.
+
+## Sample Code
+
+Sample code written in each supported language is available below.
+
+- C: [sample-code.c](https://nypc-static.s3.ap-northeast-2.amazonaws.com/2026/nextnation-61bnx71k/sample-code/sample-code.c)
+- C++: [sample-code.cpp](https://nypc-static.s3.ap-northeast-2.amazonaws.com/2026/nextnation-61bnx71k/sample-code/sample-code.cpp)
+- Python: [sample-code.py](https://nypc-static.s3.ap-northeast-2.amazonaws.com/2026/nextnation-61bnx71k/sample-code/sample-code.py)
+- Rust: [sample-code.rs](https://nypc-static.s3.ap-northeast-2.amazonaws.com/2026/nextnation-61bnx71k/sample-code/sample-code.rs)
+- Java: [Main.java](https://nypc-static.s3.ap-northeast-2.amazonaws.com/2026/nextnation-61bnx71k/sample-code/Main.java)
+- JavaScript: [sample-code.js](https://nypc-static.s3.ap-northeast-2.amazonaws.com/2026/nextnation-61bnx71k/sample-code/sample-code.js)
+- TypeScript: [sample-code.ts](https://nypc-static.s3.ap-northeast-2.amazonaws.com/2026/nextnation-61bnx71k/sample-code/sample-code.ts)
+- C#: [sample-code.cs](https://nypc-static.s3.ap-northeast-2.amazonaws.com/2026/nextnation-61bnx71k/sample-code/sample-code.cs)
+- Kotlin: [sample-code.kt](https://nypc-static.s3.ap-northeast-2.amazonaws.com/2026/nextnation-61bnx71k/sample-code/sample-code.kt)
+- Go: [sample-code.go](https://nypc-static.s3.ap-northeast-2.amazonaws.com/2026/nextnation-61bnx71k/sample-code/sample-code.go)
+- Scala: [sample-code.scala](https://nypc-static.s3.ap-northeast-2.amazonaws.com/2026/nextnation-61bnx71k/sample-code/sample-code.scala)
+- Lua: [sample-code.lua](https://nypc-static.s3.ap-northeast-2.amazonaws.com/2026/nextnation-61bnx71k/sample-code/sample-code.lua)
+
+## Sample AI
+
+| Battle Number | <div style={{ minWidth: "320px" }}>Description</div> |
+| :-----------: | :--------------------------------------------------: |
+|      $1$      |             Does not issue any commands.             |
+|      $2$      |   Performs the same operations as the sample code.   |
+|      $3$      |         Employs a basic offensive strategy.          |
+|      $4$      |      Employs a basic growth-oriented strategy.       |
+|      $5$      |      Employs an elementary offensive strategy.       |
+|      $6$      |   Employs an elementary growth-oriented strategy.    |
+|      $7$      |       Employs an adaptive offensive strategy.        |
+|      $8$      |       Employs an advanced offensive strategy.        |
diff --git a/src/routes/en/index.tsx b/src/routes/en/index.tsx
index f7ab9f7d..cc742216 100644
--- a/src/routes/en/index.tsx
+++ b/src/routes/en/index.tsx
@@ -48,10 +48,33 @@ const Home = () => {
     >
       <YearContainer>
         {Object.entries(themes)
-          .filter(([year]) => year === "2025")
+          .filter(([year]) => ["2025", "2026"].includes(year))
           .sort((a, b) => b[0].localeCompare(a[0]))
           .map(([year, { background, color, codebattle }]) => (
             <Row key={year}>
+              {year === "2026" && (
+                <Year
+                  style={{
+                    color,
+                  }}
+                  as="a"
+                  clickable
+                  href={`/en/${year}`}
+                  backgroundColor={background}
+                >
+                  <Typo h2 no-margin>
+                    NYPC {year}
+                  </Typo>
+                  <Typo
+                    style={{
+                      color: readableColor(background),
+                      opacity: 0.8,
+                    }}
+                  >
+                    NEXON Young Programmers Cup
+                  </Typo>
+                </Year>
+              )}
               {codebattle && (
                 <Year
                   style={{
diff --git a/src/routes/index.tsx b/src/routes/index.tsx
index e62f7966..2ed95fc3 100644
--- a/src/routes/index.tsx
+++ b/src/routes/index.tsx
@@ -68,7 +68,9 @@ const Home = () => {
                     opacity: 0.8,
                   }}
                 >
-                  제 {+year - 2015}회 넥슨 청소년 프로그래밍 챌린지
+                  {+year >= 2026
+                    ? `${year} 넥슨 영 프로그래머스 컵`
+                    : `제 ${+year - 2015}회 넥슨 청소년 프로그래밍 챌린지`}
                 </Typo>
               </Year>
               {codebattle && (