{
  "schemaVersion": 1,
  "productId": "atlas",
  "languageVersion": "6.0",
  "revision": "359626f52d56468f9b1bbf729532645368aaecd2",
  "files": [
    {
      "path": "core/topaz/linebreak/금칙분류.tpz",
      "language": "topaz",
      "bytes": 10362,
      "sha256": "f29d7737904fb852573226ef158ab8ab4e7d2b638cc4d924f709a117a63e33ad",
      "content": "// 아틀라스 금칙분류. 어디서 줄을 끊어도 되는지 가리는 분류기다(break-opportunity classifier, kinsoku).\n// 통합 줄바꿈기 `줄바꿈.tpz`의 1단계(어디서 줄을 끊을 수 있는지)를 따로 떼어 적었다.\n// 순수하고 결정론적이다. 클러스터들(한 줄당 하나)을 받아 줄바꿈 기회 \"<단위끝> <분할종류>\"를 낸다.\n// 분할종류 토큰(latin_space, korean_cluster 등)은 seam I/O 계약이라 ASCII로 유지한다.\n//\n// 입출력. 표준입력으로 클러스터(한 줄당 하나)를 받아 줄바꿈 기회 \"<단위끝> <분할종류>\"를 한 줄에 하나씩 낸다.\n\nimport std.io\n\nfunction 첫코드포인트(텍스트: string) -> int { 텍스트.codePointAt(0) ?? -1 }\nfunction 단일스칼라(텍스트: string) -> bool { 텍스트.scalars().length == 1 }\n\n// ── 글자류 판정 (char-class predicates over a single code point) ──\nfunction 한글분할문자인가(코드: int) -> bool {\n  (코드 >= 4352 && 코드 <= 4607)        // U+1100..U+11FF  한글 자모\n  || (코드 >= 12592 && 코드 <= 12687)   // U+3130..U+318F  한글 호환 자모\n  || (코드 >= 44032 && 코드 <= 55215)   // U+AC00..U+D7AF  한글 음절\n  || (코드 >= 13312 && 코드 <= 19903)   // U+3400..U+4DBF  CJK 확장 A\n  || (코드 >= 19968 && 코드 <= 40959)   // U+4E00..U+9FFF  CJK 통합\n  || (코드 >= 63744 && 코드 <= 64255)   // U+F900..U+FAFF  CJK 호환\n  || 코드 == 65292 || 코드 == 12289 || 코드 == 12290 || 코드 == 65307 || 코드 == 65306  // ， 、 。 ； ：\n}\nfunction 줄머리금지인가(코드: int) -> bool {\n  코드 == 41 || 코드 == 93 || 코드 == 125          // ) ] }\n  || 코드 == 12301 || 코드 == 12303 || 코드 == 12299 || 코드 == 12297  // 」 』 》 〉\n  || 코드 == 44 || 코드 == 46 || 코드 == 59 || 코드 == 58 || 코드 == 33 || 코드 == 63  // , . ; : ! ?\n  || 코드 == 12289 || 코드 == 12290            // 、 。\n  || 코드 == 8217 || 코드 == 8230 || 코드 == 65289 || 코드 == 12305 || 코드 == 65341 || 코드 == 65373 || 코드 == 65292 || 코드 == 65294 || 코드 == 65307 || 코드 == 65306 || 코드 == 65281 || 코드 == 65311 || 코드 == 187 || 코드 == 8250\n}\nfunction 줄끝금지인가(코드: int) -> bool {\n  코드 == 40 || 코드 == 91 || 코드 == 123          // ( [ {\n  || 코드 == 12300 || 코드 == 12302 || 코드 == 12298 || 코드 == 12296  // 「 『 《 〈\n  || 코드 == 65288 || 코드 == 12304 || 코드 == 65339 || 코드 == 65371 || 코드 == 171 || 코드 == 8249\n}\n\n// ── 클러스터 스칼라 전체/일부 판정 (빈 문자열 -> all=true, any=false) ──\nfunction 모두한글분할(텍스트: string) -> bool {\n  텍스트.scalars().reduce(true, (참: bool, 스칼라: string) => 참 && 한글분할문자인가(첫코드포인트(스칼라)))\n}\nfunction 모두줄머리금지(텍스트: string) -> bool {\n  텍스트.scalars().reduce(true, (참: bool, 스칼라: string) => 참 && 줄머리금지인가(첫코드포인트(스칼라)))\n}\nfunction 일부줄머리금지(텍스트: string) -> bool {\n  텍스트.scalars().reduce(false, (발견: bool, 스칼라: string) => 발견 || 줄머리금지인가(첫코드포인트(스칼라)))\n}\nfunction 일부줄끝금지(텍스트: string) -> bool {\n  텍스트.scalars().reduce(false, (발견: bool, 스칼라: string) => 발견 || 줄끝금지인가(첫코드포인트(스칼라)))\n}\n\n// ── 단어 전체 판정 (single-scalar equality) ──\nfunction 분할가능라틴공백인가(텍스트: string) -> bool { 단일스칼라(텍스트) && 첫코드포인트(텍스트) == 32 }\nfunction 라틴공백인가(텍스트: string) -> bool { 단일스칼라(텍스트) && (첫코드포인트(텍스트) == 32 || 첫코드포인트(텍스트) == 160 || 첫코드포인트(텍스트) == 8239) }\nfunction 비분할공백인가(텍스트: string) -> bool { 단일스칼라(텍스트) && (첫코드포인트(텍스트) == 160 || 첫코드포인트(텍스트) == 8239) }\nfunction 라틴붙임표인가(텍스트: string) -> bool {\n  단일스칼라(텍스트) && (첫코드포인트(텍스트) == 45 || 첫코드포인트(텍스트) == 8208 || 첫코드포인트(텍스트) == 8209 || 첫코드포인트(텍스트) == 8211)\n}\nfunction 쉼표마침표콜론인가(텍스트: string) -> bool { 단일스칼라(텍스트) && (첫코드포인트(텍스트) == 44 || 첫코드포인트(텍스트) == 46 || 첫코드포인트(텍스트) == 58) }\nfunction 아스키숫자인가(텍스트: string) -> bool { 텍스트.byteLength() == 1 && 첫코드포인트(텍스트) >= 48 && 첫코드포인트(텍스트) <= 57 }\n\n// ── 이웃 클러스터 가드 ──\nfunction 다음은라틴공백아님(다음: Option<string>) -> bool {\n  match (다음) {\n    case Some(텍스트) => !라틴공백인가(텍스트)\n    case None() => true\n  }\n}\nfunction 다음은줄머리금지없음(다음: Option<string>) -> bool {\n  match (다음) {\n    case Some(텍스트) => !일부줄머리금지(텍스트)\n    case None() => true\n  }\n}\nfunction 다음은라틴공백(다음: Option<string>) -> bool {\n  match (다음) {\n    case Some(텍스트) => 라틴공백인가(텍스트)\n    case None() => false\n  }\n}\nfunction 다음은일부줄머리금지(다음: Option<string>) -> bool {\n  match (다음) {\n    case Some(텍스트) => 일부줄머리금지(텍스트)\n    case None() => false\n  }\n}\nfunction 옵션아스키숫자인가(옵션: Option<string>) -> bool {\n  match (옵션) {\n    case Some(텍스트) => 아스키숫자인가(텍스트)\n    case None() => false\n  }\n}\n\nfunction 숫자구분자인가(현재: string, 이전: Option<string>, 다음: Option<string>) -> bool {\n  쉼표마침표콜론인가(현재) && 옵션아스키숫자인가(이전) && 옵션아스키숫자인가(다음)\n}\nfunction 닫음부호허용인가(현재: string, 이전: Option<string>, 다음: Option<string>) -> bool {\n  모두줄머리금지(현재) && 다음은라틴공백아님(다음) && 다음은줄머리금지없음(다음) && !숫자구분자인가(현재, 이전, 다음)\n}\nfunction 한글분할허용인가(현재: string, 다음: Option<string>) -> bool {\n  모두한글분할(현재) && 다음은라틴공백아님(다음) && 다음은줄머리금지없음(다음) && !일부줄끝금지(현재)\n}\n\n// 모든 후보에 적용하는 원문 문맥 금칙. 공백 뒤의 부호도 앞 낱말에 붙인다.\nfunction 공백코드인가(코드: int) -> bool {\n  (코드 >= 9 && 코드 <= 13) || 코드 == 32 || 코드 == 133 || 코드 == 160 || 코드 == 5760\n  || (코드 >= 8192 && 코드 <= 8202) || 코드 == 8232 || 코드 == 8233 || 코드 == 8239 || 코드 == 8287 || 코드 == 12288\n}\nfunction 여는직선따옴표인가(글자들: Array<string>, 위치: int) -> bool {\n  let 코드 = 첫코드포인트(글자들[위치])\n  if (코드 != 34 && 코드 != 39) { return false }\n  if (위치 == 0) { return true }\n  let 앞 = 첫코드포인트(글자들[위치 - 1])\n  공백코드인가(앞) || 줄끝금지인가(앞)\n}\nfunction 라틴낱말코드인가(코드: int) -> bool {\n  (코드 >= 65 && 코드 <= 90) || (코드 >= 97 && 코드 <= 122)\n  || (코드 >= 192 && 코드 <= 591) || (코드 >= 7680 && 코드 <= 7935)\n}\nfunction 문맥경계허용인가(글자들: Array<string>, 경계: int) -> bool {\n  let mut 왼쪽 = 경계 - 1\n  while (왼쪽 >= 0) {\n    if (!공백코드인가(첫코드포인트(글자들[왼쪽]))) { break }\n    왼쪽 -= 1\n  }\n  if (왼쪽 > 0 && 왼쪽 + 1 < 글자들.length) {\n    let 코드 = 첫코드포인트(글자들[왼쪽])\n    if ((코드 == 8217 || 코드 == 39) && 라틴낱말코드인가(첫코드포인트(글자들[왼쪽 - 1])) && 라틴낱말코드인가(첫코드포인트(글자들[왼쪽 + 1]))) { return false }\n  }\n  if (왼쪽 >= 0) {\n    if (줄끝금지인가(첫코드포인트(글자들[왼쪽])) || 여는직선따옴표인가(글자들, 왼쪽)) { return false }\n  }\n  let mut 오른쪽 = 경계\n  while (오른쪽 < 글자들.length) {\n    if (!공백코드인가(첫코드포인트(글자들[오른쪽]))) { break }\n    오른쪽 += 1\n  }\n  if (오른쪽 < 글자들.length) {\n    let 코드 = 첫코드포인트(글자들[오른쪽])\n    if (줄머리금지인가(코드)) { return false }\n    if ((코드 == 34 || 코드 == 39) && !여는직선따옴표인가(글자들, 오른쪽)) { return false }\n    if (코드 == 8212) {\n      if (오른쪽 > 0 && 줄머리금지인가(첫코드포인트(글자들[오른쪽 - 1]))) { return false }\n      if (오른쪽 + 1 < 글자들.length && 줄머리금지인가(첫코드포인트(글자들[오른쪽 + 1]))) { return false }\n    }\n  }\n  true\n}\n\nfunction 분류(클러스터들: Array<string>) -> string {\n  let 개수 = 클러스터들.length\n  let mut 전체텍스트 = \"\"\n  for 단위 in (클러스터들) { 전체텍스트 = 전체텍스트 + 단위 }\n  let 글자들 = 전체텍스트.scalars()\n  let mut 글자끝 = 0\n  let mut 출력 = \"\"\n  for i in (0..<개수) {\n    let 단위 = 클러스터들[i]\n    let 단위끝 = i + 1\n    글자끝 += 단위.scalars().length\n    let 이전: Option<string> = 클러스터들.get(i - 1)\n    let 다음 = 클러스터들.get(단위끝)\n    let 결과: { 종류: string, 내보냄: bool } = match (true) {\n      case _ if (단위끝 == 개수) => { 종류: \"forced_end\", 내보냄: true }\n      case _ if (!문맥경계허용인가(글자들, 글자끝)) => { 종류: \"\", 내보냄: false }\n      case _ if (분할가능라틴공백인가(단위)) => { 종류: \"latin_space\", 내보냄: true }\n      case _ if (라틴붙임표인가(단위)) => { 종류: \"latin_hyphen\", 내보냄: true }\n      case _ if (닫음부호허용인가(단위, 이전, 다음)) => { 종류: \"closing_punctuation\", 내보냄: true }\n      case _ if (한글분할허용인가(단위, 다음)) => { 종류: \"korean_cluster\", 내보냄: true }\n      case _ if (다음은라틴공백(다음) || 비분할공백인가(단위) || 다음은일부줄머리금지(다음)) => { 종류: \"\", 내보냄: false }\n      case _ => { 종류: \"hard_fallback\", 내보냄: true }\n    }\n    if (결과.내보냄) {\n      let 종류 = 결과.종류\n      출력 = if (출력 == \"\") { \"{단위끝} {종류}\" } else { \"{출력}\\n{단위끝} {종류}\" }\n    }\n  }\n  출력\n}\n\nio.writeLine(분류(io.readStdin().split(\"\\n\")))\n",
      "sourceSha256": "f29d7737904fb852573226ef158ab8ab4e7d2b638cc4d924f709a117a63e33ad"
    },
    {
      "path": "core/topaz/linebreak/나쁨도.tpz",
      "language": "topaz",
      "bytes": 2569,
      "sha256": "521e25290a0eb8e51dfc573f461b81d24856991438ce8ae9dbdcd58b30f1939d",
      "content": "// 아틀라스 나쁨도. 한 줄의 나쁨도를 고정소수로 매기는 명세다(fixed-point line badness).\n// 통합 줄바꿈기 `줄바꿈.tpz`의 2단계(한 줄이 목표너비에 견줘 얼마나 헐겁거나 빡빡한지를 점수로\n// 매기는 일)를 따로 떼어 적었다.\n// 입출력. 표준입력으로 \"<너비>|<목표너비>|<글자수>|<공백수>|<분할종류>|<마지막인가(0/1)>\" 꼴의 줄을 받아 줄마다 나쁨도(B 단위)를 낸다.\n\nimport std.io\n\nlet R = 100000000   // 1e8 비율 스케일 (ratio scale)\nlet B = 1000000     // 1e6 나쁨도 스케일 (badness scale)\n\nfunction 반올림나눗셈(분자: int, 분모: int) -> int {   // round-half-up, 음이 아닌 값만\n  let 몫 = 분자 / 분모\n  let 나머지 = 분자 % 분모\n  if (나머지 >= (분모 + 1) / 2) { 몫 + 1 } else { 몫 }\n}\nfunction 절댓값(값: int) -> int { if (값 < 0) { -값 } else { 값 } }\n\nfunction 나쁨도(너비: int, 목표너비: int, 글자수: int, 공백수: int, 분할종류: string, 마지막인가: bool) -> int {\n  let 여유 = 목표너비 - 너비\n  let 절대여유 = 절댓값(여유)\n  let 원시R = if (절대여유 >= 4 * 목표너비) { 4 * R } else { 절대여유 * R / 목표너비 }\n  let 조정상한센티 = if (여유 >= 0) { 100 + 공백수 * 45 } else { 100 + 공백수 * 25 }\n  let 비례R = 반올림나눗셈(원시R * 100, 조정상한센티)\n  let 제곱 = 비례R * 비례R\n  let 몫 = 반올림나눗셈(제곱, R)\n  let mut 기본B = 반올림나눗셈(몫 * (1000 * B), R)\n  if (마지막인가) {\n    기본B = 반올림나눗셈(기본B * 2, 5)\n    if (너비 * 100 < 목표너비 * 52 && 글자수 > 0) { 기본B += 500 * B }\n  }\n  if (여유 < 0) {\n    기본B += 20000 * B + 반올림나눗셈(20000 * B * 비례R, R)\n  }\n  if (분할종류 == \"latin_hyphen\") { 기본B += 65 * B }\n  if (분할종류 == \"hard_fallback\") { 기본B += 50000 * B }\n  if (글자수 <= 2) { 기본B += 275 * B }\n  기본B += 10 * B\n  기본B\n}\n\nfunction 처리(입력: string) -> string {\n  let mut 출력 = \"\"\n  for 줄 in (입력.split(\"\\n\")) {\n    let 칸 = 줄.split(\"|\")\n    let 너비 = 칸[0].toInt() ?? 0\n    let 목표 = 칸[1].toInt() ?? 0\n    let 글자수 = 칸[2].toInt() ?? 0\n    let 공백수 = 칸[3].toInt() ?? 0\n    let 분할종류 = 칸[4]\n    let 마지막인가 = 칸[5] == \"1\"\n    let 값 = 나쁨도(너비, 목표, 글자수, 공백수, 분할종류, 마지막인가)\n    출력 = if (출력 == \"\") { \"{값}\" } else { \"{출력}\\n{값}\" }\n  }\n  출력\n}\n\nio.writeLine(처리(io.readStdin()))\n",
      "sourceSha256": "521e25290a0eb8e51dfc573f461b81d24856991438ce8ae9dbdcd58b30f1939d"
    },
    {
      "path": "core/topaz/linebreak/정렬벌점.tpz",
      "language": "topaz",
      "bytes": 6797,
      "sha256": "a211ad69447d4f8bd408902175f58da4a0ec4ebd35cf5627be11e7ce108ea16a",
      "content": "// 아틀라스 정렬벌점. 양끝맞춤의 무리함을 고정소수로 매기는 벌점 명세다(Latin + CJK justification penalty).\n// 통합 줄바꿈기 `줄바꿈.tpz`의 3단계(한 줄을 양끝맞춤할 때 글자사이·낱말사이를 얼마나 벌려야 하는지,\n// 그 무리함에 벌점을 매기는 일)를 따로 떼어 적었다.\n// 입출력. 표준입력 헤더 \"<목표너비> <최소간격> <비율M> <최대조정량> <최대간격> <최대간격비율R> <모드> <마지막인가>\"\n//      이어서 \"<진행>\\t<텍스트>\" 줄들을 받아 단일 정렬 벌점(B 단위)을 낸다.\n\nimport std.io\n\nlet B = 1000000\nlet R = 100000000\nlet CAP = 25000\nfunction 반올림나눗셈(분자: int, 분모: int) -> int {\n  let 몫 = 분자 / 분모\n  let 나머지 = 분자 % 분모\n  if (나머지 >= (분모 + 1) / 2) { 몫 + 1 } else { 몫 }\n}\nfunction 첫코드포인트(텍스트: string) -> int { 텍스트.codePointAt(0) ?? -1 }\nfunction 단일스칼라(텍스트: string) -> bool { 텍스트.scalars().length == 1 }\nfunction 낱말공백인가(텍스트: string) -> bool { 단일스칼라(텍스트) && (첫코드포인트(텍스트) == 32 || 첫코드포인트(텍스트) == 160) }\nfunction U0020인가(텍스트: string) -> bool { 단일스칼라(텍스트) && 첫코드포인트(텍스트) == 32 }\nfunction CJK정렬문자인가(코드: int) -> bool {\n  (코드 >= 4352 && 코드 <= 4607) || (코드 >= 12592 && 코드 <= 12687) || (코드 >= 13312 && 코드 <= 19903)\n  || (코드 >= 19968 && 코드 <= 40959) || (코드 >= 44032 && 코드 <= 55203) || (코드 >= 63744 && 코드 <= 64255)\n}\nfunction 정렬부호코드인가(코드: int) -> bool {\n  코드 == 46 || 코드 == 44 || 코드 == 59 || 코드 == 58 || 코드 == 33 || 코드 == 63 || 코드 == 34 || 코드 == 39\n  || 코드 == 40 || 코드 == 41 || 코드 == 91 || 코드 == 93 || 코드 == 123 || 코드 == 125\n  || 코드 == 12290 || 코드 == 12289 || 코드 == 65292 || 코드 == 65294\n  || 코드 == 12300 || 코드 == 12301 || 코드 == 12302 || 코드 == 12303 || 코드 == 12298 || 코드 == 12299 || 코드 == 12296 || 코드 == 12297\n}\nfunction 단일CJK인가(텍스트: string) -> bool { 단일스칼라(텍스트) && CJK정렬문자인가(첫코드포인트(텍스트)) }\nfunction 정렬부호단위인가(텍스트: string) -> bool {\n  텍스트.scalars().reduce(false, (발견: bool, 스칼라: string) => 발견 || 정렬부호코드인가(첫코드포인트(스칼라)))\n}\nfunction CJK간격후보인가(왼쪽: string, 오른쪽: string) -> bool { 단일CJK인가(왼쪽) && 단일CJK인가(오른쪽) && !정렬부호단위인가(왼쪽) && !정렬부호단위인가(오른쪽) }\nfunction 한글공백간격후보인가(왼쪽: string, 공백: string, 오른쪽: string) -> bool {\n  단일CJK인가(왼쪽) && 낱말공백인가(공백) && 단일CJK인가(오른쪽) && !정렬부호단위인가(왼쪽) && !정렬부호단위인가(오른쪽)\n}\nfunction CJK간격수(텍스트들: Array<string>, 시작: int, 끝: int) -> int {\n  let mut 간격 = 0\n  for i in (시작..<끝) {\n    if (i + 1 < 끝 && CJK간격후보인가(텍스트들[i], 텍스트들[i + 1])) { 간격 += 1 }\n  }\n  for i in (시작..<끝) {\n    if (i + 2 < 끝 && 한글공백간격후보인가(텍스트들[i], 텍스트들[i + 1], 텍스트들[i + 2])) {\n      if (!CJK간격후보인가(텍스트들[i], 텍스트들[i + 1])) { 간격 += 1 }\n      if (!CJK간격후보인가(텍스트들[i + 1], 텍스트들[i + 2])) { 간격 += 1 }\n    }\n  }\n  간격\n}\n\nfunction 정렬벌점(진행: Array<int>, 텍스트들: Array<string>, 목표너비: int, 최소간격: int, 비율M: int,\n                  최대조정량: int, 최대간격: int, 최대간격비율R: int, 모드: int, 마지막인가: bool) -> int {\n  if (마지막인가) { return 0 }\n  let 개수 = 텍스트들.length\n  let mut 유효 = 개수\n  while (유효 > 0 && 낱말공백인가(텍스트들[유효 - 1])) { 유효 -= 1 }\n  if (유효 == 0) { return CAP * B }\n  if (목표너비 <= 0) { return CAP * B }\n  let 원래너비 = (0..<유효).reduce(0, (합: int, i: int) => 합 + 진행[i])\n  if (원래너비 * 1000 < 목표너비 * 비율M) { return CAP * B }\n  let 조정량 = 목표너비 - 원래너비\n  if (조정량 <= 1) { return 0 }\n  if (조정량 > 최대조정량) { return CAP * B + 반올림나눗셈((조정량 - 최대조정량) * B, 1000) }\n  if (모드 == 0) {\n    let 간격 = (0..<유효).filter((i: int) => U0020인가(텍스트들[i])).length\n    if (간격 < 최소간격 || 간격 == 0) { return CAP * B }\n    let 초과 = 조정량 - 간격 * 최대간격\n    if (초과 > 간격) { return CAP * B + 반올림나눗셈(초과 * B, 간격) }\n  } else {\n    let 간격 = CJK간격수(텍스트들, 0, 유효)\n    if (간격 < 최소간격 || 간격 == 0) { return CAP * B }\n    // 대표 CJK 진행은 단일 CJK 단위의 합과 개수로 구한다. 개수가 0이거나 진행이 1 이하면 None으로 보아 CAP를 준다.\n    let 대표인덱스 = (0..<유효).filter((i: int) => 단일CJK인가(텍스트들[i]))\n    let 대표합 = 대표인덱스.reduce(0, (합: int, i: int) => 합 + 진행[i])\n    let 대표수 = 대표인덱스.length\n    let 불량 = 대표인덱스.reduce(false, (발견: bool, i: int) => 발견 || 진행[i] <= 1)\n    if (불량 || 대표수 == 0) { return CAP * B }\n    let 초과 = 조정량 - 간격 * 최대간격\n    let 비율R = 반올림나눗셈(조정량 * 대표수 * R, 간격 * 대표합)\n    let 비율초과 = 비율R - 최대간격비율R\n    if (초과 > 간격 || 비율초과 > 100000) {\n      let 초과항 = if (초과 > 0) { 반올림나눗셈(초과 * B, 간격) } else { 0 }\n      let 비율항 = if (비율초과 > 0) { 비율초과 * 100 } else { 0 }\n      return CAP * B + 초과항 + 비율항\n    }\n  }\n  0\n}\n\nfunction 처리(입력: string) -> string {\n  let 줄들 = 입력.split(\"\\n\")\n  let 헤더 = 줄들[0].split(\" \")\n  let 목표너비 = 헤더[0].toInt() ?? 0\n  let 최소간격 = 헤더[1].toInt() ?? 0\n  let 비율M = 헤더[2].toInt() ?? 0\n  let 최대조정량 = 헤더[3].toInt() ?? 0\n  let 최대간격 = 헤더[4].toInt() ?? 0\n  let 최대간격비율R = 헤더[5].toInt() ?? 0\n  let 모드 = 헤더[6].toInt() ?? 0\n  let 마지막인가 = (헤더[7].toInt() ?? 0) != 0\n  let mut 진행: Array<int> = []\n  let mut 텍스트들: Array<string> = []\n  for li in (1..<줄들.length) {\n    let 부분들 = 줄들[li].split(\"\\t\")\n    진행.push(부분들[0].toInt() ?? 0)\n    텍스트들.push(if (부분들.length >= 2) { 부분들[1] } else { \"\" })\n  }\n  \"{정렬벌점(진행, 텍스트들, 목표너비, 최소간격, 비율M, 최대조정량, 최대간격, 최대간격비율R, 모드, 마지막인가)}\"\n}\n\nio.writeLine(처리(io.readStdin()))\n",
      "sourceSha256": "a211ad69447d4f8bd408902175f58da4a0ec4ebd35cf5627be11e7ce108ea16a"
    },
    {
      "path": "core/topaz/linebreak/줄바꿈.tpz",
      "language": "topaz",
      "bytes": 29482,
      "sha256": "23792cc631f76cffacc00cad8b312aeac7278a2e96b48c9da264f88a5b246bb3",
      "content": "// 아틀라스 줄바꿈. 한국어 식별자로 쓴 토파즈 줄바꿈기다(the published Korean line-breaker).\n//\n// 이 모듈은 아틀라스 본문 조판의 줄바꿈 알고리즘 전체를 토파즈로 구현한 실행 가능한 명세이다.\n// 네 단계로 이뤄진다.\n//   1) 금칙분류는 어디서 줄을 끊을 수 있는지 가린다(break-opportunity classifier, kinsoku).\n//   2) 나쁨도는 한 줄이 얼마나 헐겁거나 빡빡한지 매긴다(fixed-point badness).\n//   3) 정렬벌점은 양끝맞춤이 얼마나 무리인지 매긴다(justification penalty, Latin + CJK).\n//   4) 최적분할은 전체 비용이 최소인 분할을 고른다(optimal-fit integer DP).\n// 모든 연산은 정수 밀리포인트(mpt)와 정수 B 단위로 한다. 부동소수는 쓰지 않는다.\n//\n// 입력/출력 프로토콜 (스텝퍼, io.readStdin() → 처리 → io.writeLine())\n//   입력 0행 헤더 \"<목표너비mpt> <첫줄목표너비mpt> <드롭캡줄수> <드롭캡인셋mpt> <정렬모드>\n//                  <최소간격> <비율M> <최대조정량mpt> <최대간격mpt> <최대간격비율R>\"\n//       정렬모드  -1=없음, 0=라틴낱말간격, 1=CJK글자사이\n//       드롭캡줄수 0과 드롭캡인셋 0이면 드롭캡 OFF (단일 버킷)\n//   입력 1행~  \"<진행mpt>\\t<클러스터텍스트>\"  (셰이프된 클러스터 하나당 한 행, 순서대로)\n//   출력 각 줄  \"<시작클러스터> <끝클러스터배타> <줄나쁨도B>\"\n//   출력 마지막 \"TOTAL <총비용B>\"\n//   오류 센티넬 \"OUT_OF_BOUNDS\" 또는 \"NO_PLAN\"\n\nimport std.io\n\nlet R = 100000000   // 1e8 비율 스케일 (ratio scale)\nlet B = 1000000     // 1e6 나쁨도/벌점 스케일 (badness/penalty scale)\nlet CAP = 25000     // 정렬 벌점 상한 (justification penalty cap)\n\n// ── 공용 정수 보조 (shared integer helpers) ──\nfunction 반올림나눗셈(분자: int, 분모: int) -> int {   // round-half-up, 음이 아닌 값만\n  let 몫 = 분자 / 분모\n  let 나머지 = 분자 % 분모\n  if (나머지 >= (분모 + 1) / 2) { 몫 + 1 } else { 몫 }\n}\nfunction 절댓값(값: int) -> int { if (값 < 0) { -값 } else { 값 } }\nfunction 첫코드포인트(텍스트: string) -> int { 텍스트.codePointAt(0) ?? -1 }\nfunction 단일스칼라(텍스트: string) -> bool { 텍스트.scalars().length == 1 }\n\n// ── 금칙분류 · 글자류 판정 (char-class predicates over a single code point) ──\nfunction 한글분할문자인가(코드: int) -> bool {\n  (코드 >= 4352 && 코드 <= 4607)        // U+1100..U+11FF  한글 자모\n  || (코드 >= 12592 && 코드 <= 12687)   // U+3130..U+318F  한글 호환 자모\n  || (코드 >= 44032 && 코드 <= 55215)   // U+AC00..U+D7AF  한글 음절\n  || (코드 >= 13312 && 코드 <= 19903)   // U+3400..U+4DBF  CJK 확장 A\n  || (코드 >= 19968 && 코드 <= 40959)   // U+4E00..U+9FFF  CJK 통합\n  || (코드 >= 63744 && 코드 <= 64255)   // U+F900..U+FAFF  CJK 호환\n  || 코드 == 65292 || 코드 == 12289 || 코드 == 12290 || 코드 == 65307 || 코드 == 65306  // ， 、 。 ； ：\n}\nfunction 줄머리금지인가(코드: int) -> bool {\n  코드 == 41 || 코드 == 93 || 코드 == 125          // ) ] }\n  || 코드 == 12301 || 코드 == 12303 || 코드 == 12299 || 코드 == 12297  // 」 』 》 〉\n  || 코드 == 44 || 코드 == 46 || 코드 == 59 || 코드 == 58 || 코드 == 33 || 코드 == 63  // , . ; : ! ?\n  || 코드 == 12289 || 코드 == 12290            // 、 。\n  || 코드 == 8221                              // ”\n  || 코드 == 8217 || 코드 == 8230 || 코드 == 65289 || 코드 == 12305 || 코드 == 65341 || 코드 == 65373 || 코드 == 65292 || 코드 == 65294 || 코드 == 65307 || 코드 == 65306 || 코드 == 65281 || 코드 == 65311 || 코드 == 187 || 코드 == 8250\n}\nfunction 줄끝금지인가(코드: int) -> bool {\n  코드 == 40 || 코드 == 91 || 코드 == 123          // ( [ {\n  || 코드 == 12300 || 코드 == 12302 || 코드 == 12298 || 코드 == 12296  // 「 『 《 〈\n  || 코드 == 8220 || 코드 == 8216               // “ ‘\n  || 코드 == 65288 || 코드 == 12304 || 코드 == 65339 || 코드 == 65371 || 코드 == 171 || 코드 == 8249\n}\n\n// ── 클러스터 스칼라 전체/일부 판정 (all/any over a cluster's scalars; 빈 문자열 -> all=true, any=false) ──\nfunction 모두한글분할(텍스트: string) -> bool {\n  텍스트.scalars().reduce(true, (참: bool, 스칼라: string) => 참 && 한글분할문자인가(첫코드포인트(스칼라)))\n}\nfunction 모두줄머리금지(텍스트: string) -> bool {\n  텍스트.scalars().reduce(true, (참: bool, 스칼라: string) => 참 && 줄머리금지인가(첫코드포인트(스칼라)))\n}\nfunction 일부줄머리금지(텍스트: string) -> bool {\n  텍스트.scalars().reduce(false, (발견: bool, 스칼라: string) => 발견 || 줄머리금지인가(첫코드포인트(스칼라)))\n}\nfunction 일부줄끝금지(텍스트: string) -> bool {\n  텍스트.scalars().reduce(false, (발견: bool, 스칼라: string) => 발견 || 줄끝금지인가(첫코드포인트(스칼라)))\n}\n\n// ── 단어 전체 판정 (whole-string predicates; single-scalar equality) ──\nfunction 분할가능라틴공백인가(텍스트: string) -> bool { 단일스칼라(텍스트) && 첫코드포인트(텍스트) == 32 }\nfunction 라틴공백인가(텍스트: string) -> bool { 단일스칼라(텍스트) && (첫코드포인트(텍스트) == 32 || 첫코드포인트(텍스트) == 160 || 첫코드포인트(텍스트) == 8239) }\nfunction 비분할공백인가(텍스트: string) -> bool { 단일스칼라(텍스트) && (첫코드포인트(텍스트) == 160 || 첫코드포인트(텍스트) == 8239) }\nfunction 라틴붙임표인가(텍스트: string) -> bool {\n  단일스칼라(텍스트) && (첫코드포인트(텍스트) == 45 || 첫코드포인트(텍스트) == 8208 || 첫코드포인트(텍스트) == 8209 || 첫코드포인트(텍스트) == 8211)\n}\nfunction 쉼표마침표콜론인가(텍스트: string) -> bool { 단일스칼라(텍스트) && (첫코드포인트(텍스트) == 44 || 첫코드포인트(텍스트) == 46 || 첫코드포인트(텍스트) == 58) }\nfunction 아스키숫자인가(텍스트: string) -> bool { 텍스트.byteLength() == 1 && 첫코드포인트(텍스트) >= 48 && 첫코드포인트(텍스트) <= 57 }\n\n// ── 이웃 클러스터 가드 (Option<string> neighbor guards) ──\nfunction 다음은라틴공백아님(다음: Option<string>) -> bool {\n  match (다음) {\n    case Some(텍스트) => !라틴공백인가(텍스트)\n    case None() => true\n  }\n}\nfunction 다음은줄머리금지없음(다음: Option<string>) -> bool {\n  match (다음) {\n    case Some(텍스트) => !일부줄머리금지(텍스트)\n    case None() => true\n  }\n}\nfunction 다음은라틴공백(다음: Option<string>) -> bool {\n  match (다음) {\n    case Some(텍스트) => 라틴공백인가(텍스트)\n    case None() => false\n  }\n}\nfunction 다음은일부줄머리금지(다음: Option<string>) -> bool {\n  match (다음) {\n    case Some(텍스트) => 일부줄머리금지(텍스트)\n    case None() => false\n  }\n}\nfunction 옵션아스키숫자인가(옵션: Option<string>) -> bool {\n  match (옵션) {\n    case Some(텍스트) => 아스키숫자인가(텍스트)\n    case None() => false\n  }\n}\n\nfunction 숫자구분자인가(현재: string, 이전: Option<string>, 다음: Option<string>) -> bool {\n  쉼표마침표콜론인가(현재) && 옵션아스키숫자인가(이전) && 옵션아스키숫자인가(다음)\n}\nfunction 닫음부호허용인가(현재: string, 이전: Option<string>, 다음: Option<string>) -> bool {\n  모두줄머리금지(현재) && 다음은라틴공백아님(다음) && 다음은줄머리금지없음(다음) && !숫자구분자인가(현재, 이전, 다음)\n}\nfunction 한글분할허용인가(현재: string, 다음: Option<string>) -> bool {\n  모두한글분할(현재) && 다음은라틴공백아님(다음) && 다음은줄머리금지없음(다음) && !일부줄끝금지(현재)\n}\n\n// ── 분할점생성 · 단위 끝과 분할종류 (break opportunities, 인덱스 0에 센티넬) ──\n// 분할종류 토큰은 ASCII 유지(입출력 토큰).\n// 모든 후보에 적용하는 원문 문맥 금칙. 공백 뒤의 부호도 앞 낱말에 붙인다.\nfunction 공백코드인가(코드: int) -> bool {\n  (코드 >= 9 && 코드 <= 13) || 코드 == 32 || 코드 == 133 || 코드 == 160 || 코드 == 5760\n  || (코드 >= 8192 && 코드 <= 8202) || 코드 == 8232 || 코드 == 8233 || 코드 == 8239 || 코드 == 8287 || 코드 == 12288\n}\nfunction 여는직선따옴표인가(글자들: Array<string>, 위치: int) -> bool {\n  let 코드 = 첫코드포인트(글자들[위치])\n  if (코드 != 34 && 코드 != 39) { return false }\n  if (위치 == 0) { return true }\n  let 앞 = 첫코드포인트(글자들[위치 - 1])\n  공백코드인가(앞) || 줄끝금지인가(앞)\n}\nfunction 라틴낱말코드인가(코드: int) -> bool {\n  (코드 >= 65 && 코드 <= 90) || (코드 >= 97 && 코드 <= 122)\n  || (코드 >= 192 && 코드 <= 591) || (코드 >= 7680 && 코드 <= 7935)\n}\nfunction 문맥경계허용인가(글자들: Array<string>, 경계: int) -> bool {\n  let mut 왼쪽 = 경계 - 1\n  while (왼쪽 >= 0) {\n    if (!공백코드인가(첫코드포인트(글자들[왼쪽]))) { break }\n    왼쪽 -= 1\n  }\n  if (왼쪽 > 0 && 왼쪽 + 1 < 글자들.length) {\n    let 코드 = 첫코드포인트(글자들[왼쪽])\n    if ((코드 == 8217 || 코드 == 39) && 라틴낱말코드인가(첫코드포인트(글자들[왼쪽 - 1])) && 라틴낱말코드인가(첫코드포인트(글자들[왼쪽 + 1]))) { return false }\n  }\n  if (왼쪽 >= 0) {\n    if (줄끝금지인가(첫코드포인트(글자들[왼쪽])) || 여는직선따옴표인가(글자들, 왼쪽)) { return false }\n  }\n  let mut 오른쪽 = 경계\n  while (오른쪽 < 글자들.length) {\n    if (!공백코드인가(첫코드포인트(글자들[오른쪽]))) { break }\n    오른쪽 += 1\n  }\n  if (오른쪽 < 글자들.length) {\n    let 코드 = 첫코드포인트(글자들[오른쪽])\n    if (줄머리금지인가(코드)) { return false }\n    if ((코드 == 34 || 코드 == 39) && !여는직선따옴표인가(글자들, 오른쪽)) { return false }\n    if (코드 == 8212) {\n      if (오른쪽 > 0 && 줄머리금지인가(첫코드포인트(글자들[오른쪽 - 1]))) { return false }\n      if (오른쪽 + 1 < 글자들.length && 줄머리금지인가(첫코드포인트(글자들[오른쪽 + 1]))) { return false }\n    }\n  }\n  true\n}\n\nfunction 분할점생성(클러스터들: Array<string>) -> { 단위들: Array<int>, 종류들: Array<string> } {\n  let 개수 = 클러스터들.length\n  let mut 전체텍스트 = \"\"\n  for 단위 in (클러스터들) { 전체텍스트 = 전체텍스트 + 단위 }\n  let 글자들 = 전체텍스트.scalars()\n  let mut 글자끝 = 0\n  let mut 단위들 = [0]\n  let mut 종류들 = [\"forced_end\"]\n  for i in (0..<개수) {\n    let 단위 = 클러스터들[i]\n    let 단위끝 = i + 1\n    글자끝 += 단위.scalars().length\n    let 이전: Option<string> = 클러스터들.get(i - 1)\n    let 다음 = 클러스터들.get(단위끝)\n    let 결과: { 종류: string, 내보냄: bool } = match (true) {\n      case _ if (단위끝 == 개수) => { 종류: \"forced_end\", 내보냄: true }\n      case _ if (!문맥경계허용인가(글자들, 글자끝)) => { 종류: \"\", 내보냄: false }\n      case _ if (분할가능라틴공백인가(단위)) => { 종류: \"latin_space\", 내보냄: true }\n      case _ if (라틴붙임표인가(단위)) => { 종류: \"latin_hyphen\", 내보냄: true }\n      case _ if (닫음부호허용인가(단위, 이전, 다음)) => { 종류: \"closing_punctuation\", 내보냄: true }\n      case _ if (한글분할허용인가(단위, 다음)) => { 종류: \"korean_cluster\", 내보냄: true }\n      case _ if (다음은라틴공백(다음) || 비분할공백인가(단위) || 일부줄끝금지(단위) || 다음은일부줄머리금지(다음)) => { 종류: \"\", 내보냄: false }\n      case _ => { 종류: \"hard_fallback\", 내보냄: true }\n    }\n    if (결과.내보냄) {\n      단위들.push(단위끝)\n      종류들.push(결과.종류)\n    }\n  }\n  { 단위들: 단위들, 종류들: 종류들 }\n}\n\n// ── 나쁨도 · 고정소수 줄 나쁨도 (fixed-point line badness, justification=None 경로) ──\nfunction 나쁨도(너비: int, 목표너비: int, 글자수: int, 공백수: int, 분할종류: string, 마지막인가: bool) -> int {\n  let 여유 = 목표너비 - 너비\n  let 절대여유 = 절댓값(여유)\n  let 원시R = if (절대여유 >= 4 * 목표너비) { 4 * R } else { 절대여유 * R / 목표너비 }\n  let 조정상한센티 = if (여유 >= 0) { 100 + 공백수 * 45 } else { 100 + 공백수 * 25 }\n  let 비례R = 반올림나눗셈(원시R * 100, 조정상한센티)\n  let 제곱 = 비례R * 비례R\n  let 몫 = 반올림나눗셈(제곱, R)\n  let mut 기본B = 반올림나눗셈(몫 * (1000 * B), R)\n  if (마지막인가) {\n    기본B = 반올림나눗셈(기본B * 2, 5)\n    if (너비 * 100 < 목표너비 * 52 && 글자수 > 0) { 기본B += 500 * B }\n  }\n  if (여유 < 0) { 기본B += 20000 * B + 반올림나눗셈(20000 * B * 비례R, R) }\n  if (분할종류 == \"latin_hyphen\") { 기본B += 65 * B }\n  if (분할종류 == \"hard_fallback\") { 기본B += 50000 * B }\n  if (글자수 <= 2) { 기본B += 275 * B }\n  기본B += 10 * B\n  기본B\n}\n\n// ── 정렬벌점 · CJK 글자사이 정렬 보조 (CJK justification helpers) ──\nfunction 낱말공백인가(텍스트: string) -> bool { 단일스칼라(텍스트) && (첫코드포인트(텍스트) == 32 || 첫코드포인트(텍스트) == 160) }\nfunction U0020인가(텍스트: string) -> bool { 단일스칼라(텍스트) && 첫코드포인트(텍스트) == 32 }\nfunction CJK정렬문자인가(코드: int) -> bool {\n  (코드 >= 4352 && 코드 <= 4607) || (코드 >= 12592 && 코드 <= 12687) || (코드 >= 13312 && 코드 <= 19903)\n  || (코드 >= 19968 && 코드 <= 40959) || (코드 >= 44032 && 코드 <= 55203) || (코드 >= 63744 && 코드 <= 64255)\n}\nfunction 정렬부호코드인가(코드: int) -> bool {\n  코드 == 46 || 코드 == 44 || 코드 == 59 || 코드 == 58 || 코드 == 33 || 코드 == 63 || 코드 == 34 || 코드 == 39\n  || 코드 == 40 || 코드 == 41 || 코드 == 91 || 코드 == 93 || 코드 == 123 || 코드 == 125\n  || 코드 == 12290 || 코드 == 12289 || 코드 == 65292 || 코드 == 65294\n  || 코드 == 12300 || 코드 == 12301 || 코드 == 12302 || 코드 == 12303 || 코드 == 12298 || 코드 == 12299 || 코드 == 12296 || 코드 == 12297\n}\nfunction 단일CJK인가(텍스트: string) -> bool { 단일스칼라(텍스트) && CJK정렬문자인가(첫코드포인트(텍스트)) }\nfunction 정렬부호단위인가(텍스트: string) -> bool {\n  텍스트.scalars().reduce(false, (발견: bool, 스칼라: string) => 발견 || 정렬부호코드인가(첫코드포인트(스칼라)))\n}\nfunction CJK간격후보인가(왼쪽: string, 오른쪽: string) -> bool { 단일CJK인가(왼쪽) && 단일CJK인가(오른쪽) && !정렬부호단위인가(왼쪽) && !정렬부호단위인가(오른쪽) }\nfunction 한글공백간격후보인가(왼쪽: string, 공백: string, 오른쪽: string) -> bool {\n  단일CJK인가(왼쪽) && 낱말공백인가(공백) && 단일CJK인가(오른쪽) && !정렬부호단위인가(왼쪽) && !정렬부호단위인가(오른쪽)\n}\nfunction CJK간격수(텍스트들: Array<string>, 시작: int, 끝: int) -> int {\n  let mut 간격 = 0\n  for i in (시작..<끝) {\n    if (i + 1 < 끝 && CJK간격후보인가(텍스트들[i], 텍스트들[i + 1])) { 간격 += 1 }\n  }\n  for i in (시작..<끝) {\n    if (i + 2 < 끝 && 한글공백간격후보인가(텍스트들[i], 텍스트들[i + 1], 텍스트들[i + 2])) {\n      if (!CJK간격후보인가(텍스트들[i], 텍스트들[i + 1])) { 간격 += 1 }\n      if (!CJK간격후보인가(텍스트들[i + 1], 텍스트들[i + 2])) { 간격 += 1 }\n    }\n  }\n  간격\n}\n\n// ── 정렬벌점 · 라틴 낱말간격과 CJK 글자사이 통합 (full justification penalty, Latin + CJK) ──\nfunction 정렬벌점(진행: Array<int>, 텍스트들: Array<string>, 목표너비: int, 최소간격: int, 비율M: int,\n                  최대조정량: int, 최대간격: int, 최대간격비율R: int, 모드: int, 마지막인가: bool, 최종비율M: int) -> int {\n  if (마지막인가) { return 0 }\n  let 개수 = 텍스트들.length\n  let mut 유효 = 개수\n  while (유효 > 0 && 낱말공백인가(텍스트들[유효 - 1])) { 유효 -= 1 }\n  if (유효 == 0) { return CAP * B }\n  if (목표너비 <= 0) { return CAP * B }\n  let 원래너비 = (0..<유효).reduce(0, (합: int, i: int) => 합 + 진행[i])\n  if (최종비율M > 0) {\n    let 간격 = (0..<유효).filter((i: int) => U0020인가(텍스트들[i])).length\n    if (간격 > 0 || 모드 == 0) {\n      let 간격조정량 = 간격 * 최대간격\n      let 가능너비 = 원래너비 + (if (최대조정량 < 간격조정량) { 최대조정량 } else { 간격조정량 })\n      let 하한 = 반올림나눗셈(목표너비 * 최종비율M, 1000)\n      if (가능너비 >= 하한) { return 0 }\n      return CAP * B + 반올림나눗셈((하한 - 가능너비) * B, 목표너비) * 1000000\n    }\n  }\n  if (원래너비 * 1000 < 목표너비 * 비율M) { return CAP * B + 반올림나눗셈((목표너비 - 원래너비) * B, 목표너비) * (if (모드 == 0) { 1000000 } else { 100000 }) }\n  let 조정량 = 목표너비 - 원래너비\n  if (조정량 <= 1) { return 0 }\n  if (조정량 > 최대조정량) { return CAP * B + 반올림나눗셈((조정량 - 최대조정량) * B, 1000) }\n  if (모드 == 0) {\n    let 간격 = (0..<유효).filter((i: int) => U0020인가(텍스트들[i])).length\n    if (간격 < 최소간격 || 간격 == 0) { return CAP * B }\n    let 초과 = 조정량 - 간격 * 최대간격\n    if (초과 > 간격) { return CAP * B + 반올림나눗셈(초과 * B, 간격) }\n  } else {\n    let 낱말간격 = (0..<유효).filter((i: int) => U0020인가(텍스트들[i])).length\n    if (낱말간격 > 0) {\n      let 초과 = 조정량 - 낱말간격 * 최대간격\n      if (초과 > 낱말간격) { return CAP * B + 반올림나눗셈(초과 * B, 낱말간격) }\n      return 0\n    }\n    let 간격 = CJK간격수(텍스트들, 0, 유효)\n    if (간격 < 최소간격 || 간격 == 0) { return CAP * B }\n    // 대표 CJK 진행은 단일 CJK 단위의 합과 개수로 구한다. 개수가 0이거나 진행이 1 이하면 None으로 보아 CAP를 준다.\n    let 대표인덱스 = (0..<유효).filter((i: int) => 단일CJK인가(텍스트들[i]))\n    let 대표합 = 대표인덱스.reduce(0, (합: int, i: int) => 합 + 진행[i])\n    let 대표수 = 대표인덱스.length\n    let 불량 = 대표인덱스.reduce(false, (발견: bool, i: int) => 발견 || 진행[i] <= 1)\n    if (불량 || 대표수 == 0) { return CAP * B }\n    let 초과 = 조정량 - 간격 * 최대간격\n    let 비율R = 반올림나눗셈(조정량 * 대표수 * R, 간격 * 대표합)\n    let 비율초과 = 비율R - 최대간격비율R\n    if (초과 > 간격 || 비율초과 > 100000) {\n      let 초과항 = if (초과 > 0) { 반올림나눗셈(초과 * B, 간격) } else { 0 }\n      let 비율항 = if (비율초과 > 0) { 비율초과 * 100 } else { 0 }\n      return CAP * B + 초과항 + 비율항\n    }\n  }\n  0\n}\n\n// ── 한 줄 정렬벌점 · 후보 줄 [start, endExcl)의 정렬 벌점을 슬라이스로 계산 ──\n// 정렬모드가 0보다 작으면(없음) 0이다. 마지막 줄이어도 0이다(정렬벌점 자체가 마지막 줄에 0).\nfunction 줄정렬벌점(진행: Array<int>, 클러스터들: Array<string>, 시작: int, 끝: int, 목표너비: int,\n                    정렬모드: int, 최소간격: int, 비율M: int, 최대조정량: int, 최대간격: int,\n                    최대간격비율R: int, 마지막인가: bool, 최종비율M: int) -> int {\n  if (정렬모드 < 0) { return 0 }\n  if (마지막인가) { return 0 }\n  let 줄진행 = (시작..<끝).map((u: int) => 진행[u])\n  let 줄텍스트 = (시작..<끝).map((u: int) => 클러스터들[u])\n  정렬벌점(줄진행, 줄텍스트, 목표너비, 최소간격, 비율M, 최대조정량, 최대간격, 최대간격비율R, 정렬모드, false, 최종비율M)\n}\n\n// ── 줄 목표너비 · 드롭캡 줄수 안에서는 인셋만큼 줄어든 목표를 쓴다 (drop-cap line bucket inset) ──\n//   기준 = if (시작 == 0) { 첫줄목표너비 } else { 목표너비 }   (첫줄목표는 본문의 첫 단위에서 시작하는 줄에만)\n//   기준 - 드롭캡인셋 (인셋은 버킷 < 드롭캡줄수일 때만)\n// 즉 첫줄목표 선택은 단위 시작(시작==0)으로, 인셋은 줄버킷(버킷)으로 키잉한다. 드롭캡 OFF(드롭캡줄수 0)면\n// 인셋은 0이므로 기준 너비를 쓴다.\nfunction 줄목표너비(버킷: int, 시작: int, 목표너비: int, 첫줄목표너비: int, 드롭캡줄수: int, 드롭캡인셋: int) -> int {\n  let 기준 = if (시작 == 0) { 첫줄목표너비 } else { 목표너비 }\n  if (버킷 < 드롭캡줄수) { 기준 - 드롭캡인셋 } else { 기준 }\n}\n\n// ── 처리(스텝퍼 진입점) · 헤더와 단위를 파싱하고 최적분할 DP를 돌린 뒤 분할 계획을 직렬화한다 ──\nfunction 처리(입력: string) -> string {\n  let 줄들 = 입력.split(\"\\n\")\n  let 헤더 = 줄들[0].split(\" \")\n  let 목표너비 = 헤더[0].toInt() ?? 0\n  let 첫줄목표너비_원 = 헤더[1].toInt() ?? 0\n  let 드롭캡줄수 = 헤더[2].toInt() ?? 0\n  let 드롭캡인셋 = 헤더[3].toInt() ?? 0\n  let 정렬모드 = 헤더[4].toInt() ?? -1\n  let 최소간격 = 헤더[5].toInt() ?? 1\n  let 비율M = 헤더[6].toInt() ?? 0\n  let 최대조정량 = 헤더[7].toInt() ?? 0\n  let 최대간격 = 헤더[8].toInt() ?? 0\n  let 최대간격비율R = 헤더[9].toInt() ?? 0\n  let 최종비율M = if (헤더.length > 10) { 헤더[10].toInt() ?? 0 } else { 0 }\n  // 시드 캡(seam caps). 목표너비는 [1, 23e9] 범위여야 한다. 벗어나면 OUT_OF_BOUNDS.\n  if (목표너비 <= 0 || 목표너비 > 23000000000) { return \"OUT_OF_BOUNDS\" }\n  let 첫줄목표너비 = if (첫줄목표너비_원 <= 0) { 목표너비 } else { 첫줄목표너비_원 }\n\n  let mut 클러스터들: Array<string> = []\n  let mut 진행: Array<int> = []\n  for li in (1..<줄들.length) {\n    let 부분들 = 줄들[li].split(\"\\t\")\n    진행.push(부분들[0].toInt() ?? 0)\n    클러스터들.push(if (부분들.length >= 2) { 부분들[1] } else { \"\" })\n  }\n  let 개수 = 클러스터들.length\n\n  // 접두합(prefix sums). 너비와 글자수.\n  let mut 너비접두 = [0]\n  let mut 글자접두 = [0]\n  for i in (0..<개수) {\n    너비접두.push(너비접두[i] + 진행[i])\n    글자접두.push(글자접두[i] + 클러스터들[i].scalars().length)\n  }\n\n  let 분할점 = 분할점생성(클러스터들)\n  let 분할점단위 = 분할점.단위들\n  let 분할점종류 = 분할점.종류들\n  let 분할점수 = 분할점단위.length\n\n  // ── 최적분할 2-D DP · (분할점, 버킷) 상태 ──\n  // 드롭캡이 켜지면 한 줄의 인셋(따라서 목표너비, 따라서 비용)이 지금까지 방출한 줄 수(=버킷)에 따라 달라진다.\n  // 그래서 같은 분할점에 줄 수가 다른 두 경로가 도달하면 둘은 서로 교환할 수 없다. 버킷을 DP의 두 번째 차원으로 둔다.\n  //   버킷 = min(지금까지 방출한 줄 수, K),  K = min(드롭캡줄수, 3).  버킷수 = K + 1.\n  //   드롭캡 OFF면 버킷수 = 1.\n  //   다음버킷 = min(이전버킷 + 1, 마지막버킷) (마지막 버킷에서 포화).\n  // 2-D 상태는 평탄화(flatten)한다.  상태인덱스(ei, b) = ei * 버킷수 + b.  병렬 1-D 배열은 ei 오름차순으로,\n  // 같은 ei 안에서는 버킷 오름차순으로 push된다.  각 상태는 (있음, 비용, 이전ei, 이전버킷, 줄비용)을 담는다.\n  let 버킷수 = if (드롭캡줄수 <= 0 || 드롭캡인셋 <= 0) {\n    1\n  } else {\n    (if (드롭캡줄수 < 3) { 드롭캡줄수 } else { 3 }) + 1\n  }\n  let 마지막버킷 = 버킷수 - 1\n\n  // 상태[0][b]는 버킷 0만 존재하고(비용 0) 나머지 버킷은 부재다.\n  let mut 상태들: Array<{ 있음: bool, 비용: int, 이전ei: int, 이전버킷: int, 줄나쁨: int }> = []\n  for b0 in (0..<버킷수) {\n    상태들.push({ 있음: b0 == 0, 비용: 0, 이전ei: 0, 이전버킷: 0, 줄나쁨: 0 })\n  }\n\n  for ei in (1..<분할점수) {\n    let 끝단위 = 분할점단위[ei]\n    let 끝종류 = 분할점종류[ei]\n    // 전임자 창(predecessor window). 한 줄에 분할점이 80개를 넘게 들어갈 일은 없으므로 80개 이전의 분할점은\n    // 후보에서 제외한다(O(n^2) 폭주 방지).\n    let mut 이전시작 = if (ei > 80) { ei - 80 } else { 0 }\n    let 넓은목표 = if (목표너비 > 첫줄목표너비) { 목표너비 } else { 첫줄목표너비 }\n    while (이전시작 > 0 && 너비접두[끝단위] - 너비접두[분할점단위[이전시작 - 1]] <= 넓은목표 + 1) { 이전시작 -= 1 }\n    let 마지막인가 = 끝단위 == 개수\n    // 이 분할점에 도달하는 최적 상태를 다음버킷별로 모은다(최선[다음버킷]).\n    let mut 최선들: Array<{ 있음: bool, 비용: int, 이전ei: int, 이전버킷: int, 줄나쁨: int }> = []\n    for nb in (0..<버킷수) {\n      최선들.push({ 있음: false, 비용: 0, 이전ei: 0, 이전버킷: 0, 줄나쁨: 0 })\n    }\n\n    for pi in (이전시작..<ei) {\n      let 시작 = 분할점단위[pi]\n      if (시작 < 끝단위) {\n        let 너비 = 너비접두[끝단위] - 너비접두[시작]\n        let mut 유효끝 = 끝단위\n        while (유효끝 > 시작 && 낱말공백인가(클러스터들[유효끝 - 1])) { 유효끝 -= 1 }\n        let 먹너비 = 너비접두[유효끝] - 너비접두[시작]\n        for 이전버킷 in (0..<버킷수) {\n          let 이전상태 = 상태들[pi * 버킷수 + 이전버킷]\n          if (이전상태.있음) {\n            // 새 줄은 인셋 목적상 이전버킷 번째 줄이다(버킷이 곧 인셋의 유효 줄 인덱스).  첫줄목표는 단위 시작(시작==0)으로 키잉한다.\n            let 이줄목표 = 줄목표너비(이전버킷, 시작, 목표너비, 첫줄목표너비, 드롭캡줄수, 드롭캡인셋)\n            if (!(먹너비 > 이줄목표 + 1 && 끝단위 > 시작 + 1)) {\n              let 공백수 = (시작..<끝단위).filter((i: int) => 분할가능라틴공백인가(클러스터들[i])).length\n              let 줄나쁨 = 나쁨도(너비, 이줄목표, 글자접두[끝단위] - 글자접두[시작], 공백수, 끝종류, 마지막인가)\n              let 정렬 = 줄정렬벌점(진행, 클러스터들, 시작, 끝단위, 이줄목표, 정렬모드, 최소간격, 비율M,\n                                    최대조정량, 최대간격, 최대간격비율R, 마지막인가, 최종비율M)\n              let 줄비용 = 줄나쁨 + 정렬\n              let 후보비용 = 이전상태.비용 + 줄비용\n              let 다음버킷 = if (이전버킷 + 1 < 마지막버킷) { 이전버킷 + 1 } else { 마지막버킷 }\n              // strict `<` keep-first. pi·버킷을 오름차순으로 도므로, 정확히 같은 i64 비용일 때는 첫(가장 낮은) 전임자가 이긴다.\n              let 최선 = 최선들[다음버킷]\n              if (!최선.있음 || 후보비용 < 최선.비용) {\n                최선들[다음버킷] = { 있음: true, 비용: 후보비용, 이전ei: pi, 이전버킷: 이전버킷, 줄나쁨: 줄비용 }\n              }\n            }\n          }\n        }\n      }\n    }\n\n    for wb in (0..<버킷수) {\n      상태들.push(최선들[wb])\n    }\n  }\n\n  let 마지막 = 분할점수 - 1\n  // 종단 최소. 버킷을 가로질러 i64 strict `<` keep-first로 고르되, 가장 낮은 버킷이 먼저다.  OFF면 버킷 0만 존재한다.\n  let mut 종단버킷 = -1\n  for tb in (0..<버킷수) {\n    let 종단상태 = 상태들[마지막 * 버킷수 + tb]\n    if (종단상태.있음) {\n      if (종단버킷 < 0 || 종단상태.비용 < 상태들[마지막 * 버킷수 + 종단버킷].비용) {\n        종단버킷 = tb\n      }\n    }\n  }\n  if (종단버킷 < 0) { return \"NO_PLAN\" }\n\n  // 역추적(reversed 수집). (분할점, 버킷) 셀을 이전버킷을 따라 거꾸로 걸으며 줄들을 모은다.\n  let mut 역줄들: Array<{ 시작: int, 끝: int, 줄나쁨: int }> = []\n  let mut wi = 마지막\n  let mut wbucket = 종단버킷\n  while (wi > 0) {\n    let 셀 = wi * 버킷수 + wbucket\n    let 상태 = 상태들[셀]\n    역줄들.push({ 시작: 분할점단위[상태.이전ei], 끝: 분할점단위[wi], 줄나쁨: 상태.줄나쁨 })\n    let 다음wi = 상태.이전ei\n    wbucket = 상태.이전버킷\n    wi = 다음wi\n  }\n  let mut 출력 = \"\"\n  let mut 총비용 = 0\n  let mut k = 역줄들.length - 1\n  while (k >= 0) {\n    let 줄 = 역줄들[k]\n    let 시작 = 줄.시작\n    let 끝 = 줄.끝\n    let 줄나쁨 = 줄.줄나쁨\n    출력 = if (출력 == \"\") { \"{시작} {끝} {줄나쁨}\" } else { \"{출력}\\n{시작} {끝} {줄나쁨}\" }\n    총비용 += 줄나쁨\n    k -= 1\n  }\n  \"{출력}\\nTOTAL {총비용}\"\n}\n\nio.writeLine(처리(io.readStdin()))\n",
      "sourceSha256": "23792cc631f76cffacc00cad8b312aeac7278a2e96b48c9da264f88a5b246bb3"
    },
    {
      "path": "core/topaz/linebreak/최적분할.tpz",
      "language": "topaz",
      "bytes": 14382,
      "sha256": "dd4f0cc59bc877e36d93ef173cb2d9ea27a8420edbb75a3a8c6315c9648553dd",
      "content": "// 아틀라스 최적분할. 전체 비용이 가장 낮은 줄 분할을 고르는 고정소수 정수 DP 명세다(optimal-fit integer DP).\n// 통합 줄바꿈기 `줄바꿈.tpz`의 4단계(정수 동적계획법)를 따로\n// 떼어 적었다.\n// 범위는 드롭캡 OFF(단일 버킷), 첫줄=목표, 정렬=없음이다. 1·2·4단계(금칙분류·나쁨도·정수 DP)를 한 파일에 인라인한다.\n// 드롭캡·첫줄목표·정렬을 더한 2차원 (분할점, 버킷) 전체 DP는 통합본 `줄바꿈.tpz`에 있다.\n// 입출력. 표준입력으로 \"<목표너비mpt>\\n<진행mpt>\\t<텍스트>\\n...\"를 받아 \"<시작> <끝배타> <줄나쁨도B>\\n...TOTAL <B>\"를 낸다.\n\nimport std.io\n\nlet R = 100000000\nlet B = 1000000\n\n// ── 금칙분류 ──\nfunction 첫코드포인트(텍스트: string) -> int { 텍스트.codePointAt(0) ?? -1 }\nfunction 단일스칼라(텍스트: string) -> bool { 텍스트.scalars().length == 1 }\nfunction 한글분할문자인가(코드: int) -> bool {\n  (코드 >= 4352 && 코드 <= 4607) || (코드 >= 12592 && 코드 <= 12687) || (코드 >= 44032 && 코드 <= 55215)\n  || (코드 >= 13312 && 코드 <= 19903) || (코드 >= 19968 && 코드 <= 40959) || (코드 >= 63744 && 코드 <= 64255)\n  || 코드 == 65292 || 코드 == 12289 || 코드 == 12290 || 코드 == 65307 || 코드 == 65306\n}\nfunction 줄머리금지인가(코드: int) -> bool {\n  코드 == 41 || 코드 == 93 || 코드 == 125 || 코드 == 12301 || 코드 == 12303 || 코드 == 12299 || 코드 == 12297\n  || 코드 == 44 || 코드 == 46 || 코드 == 59 || 코드 == 58 || 코드 == 33 || 코드 == 63 || 코드 == 12289 || 코드 == 12290\n  || 코드 == 8217 || 코드 == 8230 || 코드 == 65289 || 코드 == 12305 || 코드 == 65341 || 코드 == 65373 || 코드 == 65292 || 코드 == 65294 || 코드 == 65307 || 코드 == 65306 || 코드 == 65281 || 코드 == 65311 || 코드 == 187 || 코드 == 8250\n}\nfunction 줄끝금지인가(코드: int) -> bool {\n  코드 == 40 || 코드 == 91 || 코드 == 123 || 코드 == 12300 || 코드 == 12302 || 코드 == 12298 || 코드 == 12296\n  || 코드 == 65288 || 코드 == 12304 || 코드 == 65339 || 코드 == 65371 || 코드 == 171 || 코드 == 8249\n}\nfunction 모두한글분할(텍스트: string) -> bool {\n  텍스트.scalars().reduce(true, (참: bool, 스칼라: string) => 참 && 한글분할문자인가(첫코드포인트(스칼라)))\n}\nfunction 모두줄머리금지(텍스트: string) -> bool {\n  텍스트.scalars().reduce(true, (참: bool, 스칼라: string) => 참 && 줄머리금지인가(첫코드포인트(스칼라)))\n}\nfunction 일부줄머리금지(텍스트: string) -> bool {\n  텍스트.scalars().reduce(false, (발견: bool, 스칼라: string) => 발견 || 줄머리금지인가(첫코드포인트(스칼라)))\n}\nfunction 일부줄끝금지(텍스트: string) -> bool {\n  텍스트.scalars().reduce(false, (발견: bool, 스칼라: string) => 발견 || 줄끝금지인가(첫코드포인트(스칼라)))\n}\nfunction 분할가능라틴공백인가(텍스트: string) -> bool { 단일스칼라(텍스트) && 첫코드포인트(텍스트) == 32 }\nfunction 라틴공백인가(텍스트: string) -> bool { 단일스칼라(텍스트) && (첫코드포인트(텍스트) == 32 || 첫코드포인트(텍스트) == 160) }\nfunction 비분할공백인가(텍스트: string) -> bool { 단일스칼라(텍스트) && (첫코드포인트(텍스트) == 160 || 첫코드포인트(텍스트) == 8239) }\nfunction 라틴붙임표인가(텍스트: string) -> bool {\n  단일스칼라(텍스트) && (첫코드포인트(텍스트) == 45 || 첫코드포인트(텍스트) == 8208 || 첫코드포인트(텍스트) == 8209 || 첫코드포인트(텍스트) == 8211)\n}\nfunction 쉼표마침표콜론인가(텍스트: string) -> bool { 단일스칼라(텍스트) && (첫코드포인트(텍스트) == 44 || 첫코드포인트(텍스트) == 46 || 첫코드포인트(텍스트) == 58) }\nfunction 아스키숫자인가(텍스트: string) -> bool { 텍스트.byteLength() == 1 && 첫코드포인트(텍스트) >= 48 && 첫코드포인트(텍스트) <= 57 }\nfunction 다음은라틴공백아님(다음: Option<string>) -> bool {\n  match (다음) {\n    case Some(텍스트) => !라틴공백인가(텍스트)\n    case None() => true\n  }\n}\nfunction 다음은줄머리금지없음(다음: Option<string>) -> bool {\n  match (다음) {\n    case Some(텍스트) => !일부줄머리금지(텍스트)\n    case None() => true\n  }\n}\nfunction 다음은라틴공백(다음: Option<string>) -> bool {\n  match (다음) {\n    case Some(텍스트) => 라틴공백인가(텍스트)\n    case None() => false\n  }\n}\nfunction 다음은일부줄머리금지(다음: Option<string>) -> bool {\n  match (다음) {\n    case Some(텍스트) => 일부줄머리금지(텍스트)\n    case None() => false\n  }\n}\nfunction 옵션아스키숫자인가(옵션: Option<string>) -> bool {\n  match (옵션) {\n    case Some(텍스트) => 아스키숫자인가(텍스트)\n    case None() => false\n  }\n}\nfunction 숫자구분자인가(현재: string, 이전: Option<string>, 다음: Option<string>) -> bool {\n  쉼표마침표콜론인가(현재) && 옵션아스키숫자인가(이전) && 옵션아스키숫자인가(다음)\n}\nfunction 닫음부호허용인가(현재: string, 이전: Option<string>, 다음: Option<string>) -> bool {\n  모두줄머리금지(현재) && 다음은라틴공백아님(다음) && 다음은줄머리금지없음(다음) && !숫자구분자인가(현재, 이전, 다음)\n}\nfunction 한글분할허용인가(현재: string, 다음: Option<string>) -> bool {\n  모두한글분할(현재) && 다음은라틴공백아님(다음) && 다음은줄머리금지없음(다음) && !일부줄끝금지(현재)\n}\n\n// ── 나쁨도 (정렬=없음 경로) ──\nfunction 반올림나눗셈(분자: int, 분모: int) -> int {\n  let 몫 = 분자 / 분모\n  let 나머지 = 분자 % 분모\n  if (나머지 >= (분모 + 1) / 2) { 몫 + 1 } else { 몫 }\n}\nfunction 절댓값(값: int) -> int { if (값 < 0) { -값 } else { 값 } }\nfunction 나쁨도(너비: int, 목표너비: int, 글자수: int, 공백수: int, 분할종류: string, 마지막인가: bool) -> int {\n  let 여유 = 목표너비 - 너비\n  let 절대여유 = 절댓값(여유)\n  let 원시R = if (절대여유 >= 4 * 목표너비) { 4 * R } else { 절대여유 * R / 목표너비 }\n  let 조정상한센티 = if (여유 >= 0) { 100 + 공백수 * 45 } else { 100 + 공백수 * 25 }\n  let 비례R = 반올림나눗셈(원시R * 100, 조정상한센티)\n  let 제곱 = 비례R * 비례R\n  let 몫 = 반올림나눗셈(제곱, R)\n  let mut 기본B = 반올림나눗셈(몫 * (1000 * B), R)\n  if (마지막인가) {\n    기본B = 반올림나눗셈(기본B * 2, 5)\n    if (너비 * 100 < 목표너비 * 52 && 글자수 > 0) { 기본B += 500 * B }\n  }\n  if (여유 < 0) { 기본B += 20000 * B + 반올림나눗셈(20000 * B * 비례R, R) }\n  if (분할종류 == \"latin_hyphen\") { 기본B += 65 * B }\n  if (분할종류 == \"hard_fallback\") { 기본B += 50000 * B }\n  if (글자수 <= 2) { 기본B += 275 * B }\n  기본B += 10 * B\n  기본B\n}\n\n// ── 분할점(단위 + 종류), 인덱스 0에 센티넬 ──\n// 모든 후보에 적용하는 원문 문맥 금칙. 공백 뒤의 부호도 앞 낱말에 붙인다.\nfunction 공백코드인가(코드: int) -> bool {\n  (코드 >= 9 && 코드 <= 13) || 코드 == 32 || 코드 == 133 || 코드 == 160 || 코드 == 5760\n  || (코드 >= 8192 && 코드 <= 8202) || 코드 == 8232 || 코드 == 8233 || 코드 == 8239 || 코드 == 8287 || 코드 == 12288\n}\nfunction 여는직선따옴표인가(글자들: Array<string>, 위치: int) -> bool {\n  let 코드 = 첫코드포인트(글자들[위치])\n  if (코드 != 34 && 코드 != 39) { return false }\n  if (위치 == 0) { return true }\n  let 앞 = 첫코드포인트(글자들[위치 - 1])\n  공백코드인가(앞) || 줄끝금지인가(앞)\n}\nfunction 라틴낱말코드인가(코드: int) -> bool {\n  (코드 >= 65 && 코드 <= 90) || (코드 >= 97 && 코드 <= 122)\n  || (코드 >= 192 && 코드 <= 591) || (코드 >= 7680 && 코드 <= 7935)\n}\nfunction 문맥경계허용인가(글자들: Array<string>, 경계: int) -> bool {\n  let mut 왼쪽 = 경계 - 1\n  while (왼쪽 >= 0) {\n    if (!공백코드인가(첫코드포인트(글자들[왼쪽]))) { break }\n    왼쪽 -= 1\n  }\n  if (왼쪽 > 0 && 왼쪽 + 1 < 글자들.length) {\n    let 코드 = 첫코드포인트(글자들[왼쪽])\n    if ((코드 == 8217 || 코드 == 39) && 라틴낱말코드인가(첫코드포인트(글자들[왼쪽 - 1])) && 라틴낱말코드인가(첫코드포인트(글자들[왼쪽 + 1]))) { return false }\n  }\n  if (왼쪽 >= 0) {\n    if (줄끝금지인가(첫코드포인트(글자들[왼쪽])) || 여는직선따옴표인가(글자들, 왼쪽)) { return false }\n  }\n  let mut 오른쪽 = 경계\n  while (오른쪽 < 글자들.length) {\n    if (!공백코드인가(첫코드포인트(글자들[오른쪽]))) { break }\n    오른쪽 += 1\n  }\n  if (오른쪽 < 글자들.length) {\n    let 코드 = 첫코드포인트(글자들[오른쪽])\n    if (줄머리금지인가(코드)) { return false }\n    if ((코드 == 34 || 코드 == 39) && !여는직선따옴표인가(글자들, 오른쪽)) { return false }\n    if (코드 == 8212) {\n      if (오른쪽 > 0 && 줄머리금지인가(첫코드포인트(글자들[오른쪽 - 1]))) { return false }\n      if (오른쪽 + 1 < 글자들.length && 줄머리금지인가(첫코드포인트(글자들[오른쪽 + 1]))) { return false }\n    }\n  }\n  true\n}\n\nfunction 분할점생성(클러스터들: Array<string>) -> { 단위들: Array<int>, 종류들: Array<string> } {\n  let 개수 = 클러스터들.length\n  let mut 전체텍스트 = \"\"\n  for 단위 in (클러스터들) { 전체텍스트 = 전체텍스트 + 단위 }\n  let 글자들 = 전체텍스트.scalars()\n  let mut 글자끝 = 0\n  let mut 단위들 = [0]\n  let mut 종류들 = [\"forced_end\"]\n  for i in (0..<개수) {\n    let 단위 = 클러스터들[i]\n    let 단위끝 = i + 1\n    글자끝 += 단위.scalars().length\n    let 이전: Option<string> = 클러스터들.get(i - 1)\n    let 다음 = 클러스터들.get(단위끝)\n    let 결과: { 종류: string, 내보냄: bool } = match (true) {\n      case _ if (단위끝 == 개수) => { 종류: \"forced_end\", 내보냄: true }\n      case _ if (!문맥경계허용인가(글자들, 글자끝)) => { 종류: \"\", 내보냄: false }\n      case _ if (분할가능라틴공백인가(단위)) => { 종류: \"latin_space\", 내보냄: true }\n      case _ if (라틴붙임표인가(단위)) => { 종류: \"latin_hyphen\", 내보냄: true }\n      case _ if (닫음부호허용인가(단위, 이전, 다음)) => { 종류: \"closing_punctuation\", 내보냄: true }\n      case _ if (한글분할허용인가(단위, 다음)) => { 종류: \"korean_cluster\", 내보냄: true }\n      case _ if (다음은라틴공백(다음) || 비분할공백인가(단위) || 다음은일부줄머리금지(다음)) => { 종류: \"\", 내보냄: false }\n      case _ => { 종류: \"hard_fallback\", 내보냄: true }\n    }\n    if (결과.내보냄) {\n      단위들.push(단위끝)\n      종류들.push(결과.종류)\n    }\n  }\n  { 단위들: 단위들, 종류들: 종류들 }\n}\n\nfunction 처리(입력: string) -> string {\n  let 줄들 = 입력.split(\"\\n\")\n  let 목표 = 줄들[0].toInt() ?? 0\n  if (목표 <= 0 || 목표 > 23000000000) { return \"OUT_OF_BOUNDS\" }\n  let mut 클러스터들: Array<string> = []\n  let mut 진행: Array<int> = []\n  for li in (1..<줄들.length) {\n    let 부분들 = 줄들[li].split(\"\\t\")\n    진행.push(부분들[0].toInt() ?? 0)\n    클러스터들.push(if (부분들.length >= 2) { 부분들[1] } else { \"\" })\n  }\n  let 개수 = 클러스터들.length\n  // 접두합\n  let mut 너비접두 = [0]\n  let mut 글자접두 = [0]\n  for i in (0..<개수) {\n    너비접두.push(너비접두[i] + 진행[i])\n    글자접두.push(글자접두[i] + 클러스터들[i].scalars().length)\n  }\n  let 분할점 = 분할점생성(클러스터들)\n  let 분할점단위 = 분할점.단위들\n  let 분할점종류 = 분할점.종류들\n  let 분할점수 = 분할점단위.length\n  // DP 상태(병렬 배열, endIndex 순으로 push)\n  let mut 상태들: Array<{ 있음: bool, 비용: int, 이전: int, 줄나쁨: int }> = [\n    { 있음: true, 비용: 0, 이전: 0, 줄나쁨: 0 }\n  ]\n  for ei in (1..<분할점수) {\n    let 끝단위 = 분할점단위[ei]\n    let 끝종류 = 분할점종류[ei]\n    let 이전시작 = if (ei > 80) { ei - 80 } else { 0 }\n    let 마지막인가 = 끝단위 == 개수\n    let mut 최선 = { 있음: false, 비용: 0, 이전: 0, 줄나쁨: 0 }\n    for pi in (이전시작..<ei) {\n      if (상태들[pi].있음) {\n        let 시작 = 분할점단위[pi]\n        if (시작 < 끝단위) {\n          let 너비 = 너비접두[끝단위] - 너비접두[시작]\n          if (!(너비 > 목표 + 1 && 끝단위 > 시작 + 1)) {\n            let 공백수 = (시작..<끝단위).filter((i: int) => 분할가능라틴공백인가(클러스터들[i])).length\n            let 줄비용 = 나쁨도(너비, 목표, 글자접두[끝단위] - 글자접두[시작], 공백수, 끝종류, 마지막인가)\n            let 후보비용 = 상태들[pi].비용 + 줄비용\n            if (!최선.있음 || 후보비용 < 최선.비용) {\n              최선 = { 있음: true, 비용: 후보비용, 이전: pi, 줄나쁨: 줄비용 }\n            }\n          }\n        }\n      }\n    }\n    상태들.push(최선)\n  }\n  let 마지막 = 분할점수 - 1\n  if (!상태들[마지막].있음) { return \"NO_PLAN\" }\n  // 역추적(reversed 수집)\n  let mut 역줄들: Array<{ 시작: int, 끝: int, 줄나쁨: int }> = []\n  let mut wi = 마지막\n  while (wi > 0) {\n    let 상태 = 상태들[wi]\n    역줄들.push({ 시작: 분할점단위[상태.이전], 끝: 분할점단위[wi], 줄나쁨: 상태.줄나쁨 })\n    wi = 상태.이전\n  }\n  let mut 출력 = \"\"\n  let mut 총비용 = 0\n  let mut k = 역줄들.length - 1\n  while (k >= 0) {\n    let 줄 = 역줄들[k]\n    let 시작 = 줄.시작\n    let 끝 = 줄.끝\n    let 줄나쁨 = 줄.줄나쁨\n    출력 = if (출력 == \"\") { \"{시작} {끝} {줄나쁨}\" } else { \"{출력}\\n{시작} {끝} {줄나쁨}\" }\n    총비용 += 줄나쁨\n    k -= 1\n  }\n  \"{출력}\\nTOTAL {총비용}\"\n}\n\nio.writeLine(처리(io.readStdin()))\n",
      "sourceSha256": "dd4f0cc59bc877e36d93ef173cb2d9ea27a8420edbb75a3a8c6315c9648553dd"
    }
  ],
  "bundleSha256": "3cd27ed5d431ab1e686d70ec99191650911d4bcfc40190c2bec46d440d1894b4",
  "publication": {
    "notices": "SOURCE-NOTICES.txt",
    "statusEn": "Topaz 6.0 source.",
    "statusKo": "토파즈 6.0 소스다.",
    "editing": "Reviewed comments may be edited for publication. sourceSha256 identifies the upstream file. sha256 identifies the published file. Executable code is unchanged."
  }
}
