{
  "schemaVersion": 1,
  "productId": "image",
  "languageVersion": "topaz-5.21",
  "revision": "45bbebca37e0b251b198fab9a90db3b782b6e530",
  "files": [
    {
      "path": "topaz/src/core.tpz",
      "language": "topaz",
      "bytes": 3448,
      "sha256": "ada687d8748740d5fc215bfc49212ac733eb232cec661b1996ebd9f1a61d2bc9",
      "content": "// Public CodeImage ABI facade.\n// Each export forwards to the module that implements it.\n\nimport std.bytes { Bytes }\nimport ecc\nimport hash\nimport image_carrier\nimport projection\nimport structure\n\nexport function 해시이백오십육(입력: Bytes) -> Result<Bytes, string> {\n  hash.해시이백오십육(입력)\n}\n\nexport function 구조인코드(입력: string) -> Result<Bytes, string> {\n  structure.구조인코드(입력)\n}\n\nexport function 구조디코드(와이어: Bytes, 식별자표: Array<bool>) -> Result<string, string> {\n  structure.구조디코드(와이어, 식별자표)\n}\n\nexport function 리드솔로몬보호(논리: Bytes) -> Result<Bytes, string> {\n  ecc.리드솔로몬보호(논리)\n}\n\nexport function 리드솔로몬해제(보호: Bytes, 논리길이: int) -> Result<Bytes, string> {\n  ecc.리드솔로몬해제(보호, 논리길이)\n}\n\nexport function 이미지계획하기(요청글: string, 논리: Bytes) -> Result<string, string> {\n  image_carrier.이미지계획하기(요청글, 논리)\n}\n\nexport function 이미지쪽렌더준비됨(요청글: string, 논리: Bytes, 계획글: string, 쪽번호: int) -> Result<Bytes, string> {\n  image_carrier.이미지쪽렌더준비됨(요청글, 논리, 계획글, 쪽번호)\n}\n\nexport function 이미지쪽렌더(요청글: string, 논리: Bytes, 쪽번호: int) -> Result<Bytes, string> {\n  image_carrier.이미지쪽렌더(요청글, 논리, 쪽번호)\n}\n\nexport function 이미지세트렌더(요청글: string, 논리: Bytes) -> Result<Array<Bytes>, string> {\n  image_carrier.이미지세트렌더(요청글, 논리)\n}\n\nexport function 이미지세트계획렌더(요청글: string, 논리: Bytes) -> Result<Array<Bytes>, string> {\n  image_carrier.이미지세트계획렌더(요청글, 논리)\n}\n\nexport function 투영구조인쇄검사(언어번호: int, 구조글: string) -> Result<bool, string> {\n  projection.투영구조인쇄검사(언어번호, 구조글)\n}\n\nexport function 투영원본인쇄(언어번호: int, 구조글: string, 키바이트: Bytes, 키있음: bool) -> Result<string, string> {\n  projection.투영원본인쇄(언어번호, 구조글, 키바이트, 키있음)\n}\n\nexport function 투영노드인쇄진단(언어번호: int, 구조글: string, 순번: int) -> Result<string, string> {\n  projection.투영노드인쇄진단(언어번호, 구조글, 순번)\n}\n\nexport function 투영원본바이트인쇄(언어번호: int, 구조글: string, 키바이트: Bytes, 키있음: bool) -> Result<Bytes, string> {\n  projection.투영원본바이트인쇄(언어번호, 구조글, 키바이트, 키있음)\n}\n\nexport function 투영원본조각바이트인쇄(\n  언어번호: int,\n  구조글: string,\n  키바이트: Bytes,\n  키있음: bool\n) -> Result<Array<Bytes>, string> {\n  projection.투영원본조각바이트인쇄(언어번호, 구조글, 키바이트, 키있음)\n}\n\nexport function 투영노드깊이바이트인쇄(언어번호: int, 구조글: string, 키바이트: Bytes, 키있음: bool, 순번: int, 깊이: int) -> Result<Bytes, string> {\n  projection.투영노드깊이바이트인쇄(언어번호, 구조글, 키바이트, 키있음, 순번, 깊이)\n}\n\nexport function 투영노드묶음인쇄(\n  언어번호: int,\n  구조글: string,\n  키바이트: Bytes,\n  키있음: bool,\n  묶음글: string\n) -> Result<string, string> {\n  projection.투영노드묶음인쇄(언어번호, 구조글, 키바이트, 키있음, 묶음글)\n}\n",
      "sourceSha256": "ada687d8748740d5fc215bfc49212ac733eb232cec661b1996ebd9f1a61d2bc9"
    },
    {
      "path": "topaz/src/detached_key.tpz",
      "language": "topaz",
      "bytes": 5026,
      "sha256": "bdbc6e241395652000ee171926d4e17a0380f59398f6ff789e320e4269342b86",
      "content": "// Detached text key decoding and validation.\n\nimport std.bytes { Bytes }\nimport std.json\nimport hash { 해시배열 }\nimport print { 제이슨문자필드, 제이슨정수필드 }\nimport structure { 구조입력 }\nimport types { 댓글고정, 분리본문키결과 }\nimport util { 바이트로, 바이트배열로, 배열같음, 부분배열 }\nimport wire { 삼십이읽기 }\n\nexport function 분리본문키읽기(언어번호: int, 구조: 구조입력, 키바이트: Bytes) -> Result<분리본문키결과, string> {\n  let 전체 = 바이트배열로(키바이트)\n  if 전체.length < 48 || 전체.length > 2097152 { return Err(\"분리 본문 키 길이가 허용 범위 밖입니다\") }\n  if 해시배열(전체).length != 32 { return Err(\"분리 본문 키 해시를 만들지 못했습니다\") }\n  let 실제키해시 = (바이트로(해시배열(전체))?).toHex()\n  if 실제키해시 != 구조.분리본문키해시 { return Err(\"분리 본문 키 해시가 구조와 다릅니다\") }\n  let 본문끝 = 전체.length - 32\n  let 본문 = 부분배열(전체, 0, 본문끝)\n  if !배열같음(부분배열(전체, 본문끝, 전체.length), 해시배열(본문)) { return Err(\"분리 본문 키 검사합이 맞지 않습니다\") }\n  if 본문[0] != 67 || 본문[1] != 73 || 본문[2] != 70 || 본문[3] != 75 { return Err(\"분리 본문 키 마법값이 틀립니다\") }\n  if 본문[4] != 1 || 본문[5] != 0 || 본문[6] != 0 || 본문[7] != 0 { return Err(\"분리 본문 키 버전이 틀립니다\") }\n  if 삼십이읽기(본문, 8) != 전체.length || 삼십이읽기(본문, 12) != 본문.length - 16 { return Err(\"분리 본문 키 길이 머리가 틀립니다\") }\n  let 키글 = (바이트로(부분배열(본문, 16, 본문.length))?).decodeUtf8()?\n  let 키 = match json.parse(키글) {\n    case Ok(값) => 값\n    case Err(잘못) => return Err(\"분리 본문 키 JSON이 틀립니다: {잘못.message}\")\n  }\n  let 판 = 제이슨문자필드(키, \"schemaVersion\")?\n  let 둘째판 = 판 == \"codeimage.js-total-detached-text-key.v2\"\n  if !둘째판 && 판 != \"codeimage.js-total-detached-text-key.v1\" { return Err(\"분리 본문 키 스키마가 틀립니다\") }\n  let 프로필 = 제이슨문자필드(키, \"renderProfileId\")?\n  let 프로필맞음 = if 언어번호 == 1 {\n    if 둘째판 {\n      프로필 == \"sha256:1fa3f5b3b0d3422e39b0eb8807b6ee44da1b0545da5f8dd1560bd0e69dfc92cc\"\n    } else {\n      프로필 == \"sha256:ccb2118f24d950388cf113c255563d7045d2f874009671e34fe93896a5f0c1c0\" ||\n        프로필 == \"sha256:f4750eeae24b4d3b6ae5bdeb857f53890cb198d61753768d87b30de9032d8e97\" ||\n        프로필 == \"sha256:1fa3f5b3b0d3422e39b0eb8807b6ee44da1b0545da5f8dd1560bd0e69dfc92cc\"\n    }\n  } else {\n    프로필 == \"sha256:c5c215334bfc8d8803d771e997b05e6093179cfaa4ebc82de5f06e8d2f3de2a6\"\n  }\n  if !프로필맞음 { return Err(\"분리 본문 키 프로필이 언어와 다릅니다\") }\n  let 구조해시 = 제이슨문자필드(키, \"structureDigest\")?\n  if 구조해시.scalars().length != 71 { return Err(\"분리 본문 키 구조 해시 길이가 틀립니다\") }\n  let 값제이슨 = match 키.get(\"values\").flatMap((값) => 값.asArray()) {\n    case Some(값들) => 값들\n    case None => return Err(\"분리 본문 키 값들이 배열이 아닙니다\")\n  }\n  if 값제이슨.length != 구조.분리본문값수 { return Err(\"분리 본문 키 값 수가 구조와 다릅니다\") }\n  let mut 값들: Array<string> = []\n  let mut 고정들: Array<댓글고정> = []\n  let mut 값색인 = 0\n  while 값색인 < 값제이슨.length {\n    let 항목 = 값제이슨[값색인]\n    match 항목.asString() {\n      case Some(글) => 값들.push(글)\n      case None => {\n        if !둘째판 { return Err(\"첫째 판 분리 본문 키에 객체 값이 있습니다\") }\n        let 값 = 제이슨문자필드(항목, \"value\")?\n        let 고정 = match 항목.get(\"anchor\") {\n          case Some(찾음) => 찾음\n          case None => return Err(\"둘째 판 댓글 값에 고정점이 없습니다\")\n        }\n        let 붙임노드순번 = 제이슨정수필드(고정, \"nodeOrdinal\")?\n        let 놓임 = 제이슨문자필드(고정, \"placement\")?\n        let 앞줄수 = 제이슨정수필드(고정, \"lineBreaksBefore\")?\n        let 뒤줄수 = 제이슨정수필드(고정, \"lineBreaksAfter\")?\n        if 놓임 != \"leading\" && 놓임 != \"trailing\" && 놓임 != \"inner\" { return Err(\"댓글 고정점 놓임이 틀립니다\") }\n        if 붙임노드순번 < 0 || 붙임노드순번 >= 구조.노드들.length || 앞줄수 < 0 || 뒤줄수 < 0 {\n          return Err(\"댓글 고정점 범위가 틀립니다\")\n        }\n        값들.push(값)\n        고정들.push(댓글고정 {\n          값색인: 값색인, 붙임노드순번: 붙임노드순번, 놓임: 놓임,\n          앞줄수: 앞줄수, 뒤줄수: 뒤줄수\n        })\n      }\n    }\n    값색인 = 값색인 + 1\n  }\n  Ok(분리본문키결과 { 값들: 값들, 댓글고정들: 고정들, 둘째판: 둘째판 })\n}\n",
      "sourceSha256": "bdbc6e241395652000ee171926d4e17a0380f59398f6ff789e320e4269342b86"
    },
    {
      "path": "topaz/src/ecc.tpz",
      "language": "topaz",
      "bytes": 5857,
      "sha256": "91d727614bbb2a61c2bd15b6296b274e4ad9cf267ae88250f5aaf985e91fadcf",
      "content": "// Reed-Solomon protection and verification.\n\nimport std.bytes { Bytes }\nimport util { 바이트로, 바이트배열로, 바이트추가, 배열같음, 부분배열, 비트배타합 }\nimport wire { 갈루아표 }\n\n// 체에서 곱셈은 로그의 덧셈이다. 0은 로그가 없으므로 먼저 걸러낸다.\nexport function 갈루아곱(왼쪽: int, 오른쪽: int, 표: 갈루아표) -> int {\n  if 왼쪽 == 0 || 오른쪽 == 0 { return 0 }\n  표.지수[표.로그[왼쪽] + 표.로그[오른쪽]]\n}\n\nexport function 다항식곱(왼쪽: Array<int>, 오른쪽: Array<int>, 표: 갈루아표) -> Array<int> {\n  let mut 결과: Array<int> = []\n  let mut 색인 = 0\n  while 색인 < 왼쪽.length + 오른쪽.length - 1 { 결과.push(0); 색인 = 색인 + 1 }\n  let mut 왼색인 = 0\n  while 왼색인 < 왼쪽.length {\n    let mut 오른색인 = 0\n    while 오른색인 < 오른쪽.length {\n      let 결과색인 = 왼색인 + 오른색인\n      결과[결과색인] = 비트배타합(결과[결과색인], 갈루아곱(왼쪽[왼색인], 오른쪽[오른색인], 표), 8)\n      오른색인 = 오른색인 + 1\n    }\n    왼색인 = 왼색인 + 1\n  }\n  결과\n}\n\nlet 체다항식 = 285\nlet 부호바이트수 = 255\nlet 자료바이트수 = 223\nlet 패리티바이트수 = 32\n\n// 갈루아 체 GF(256)의 곱셈표. 상수를 외워 적지 않고 원시원소 2를\n// 거듭제곱하며 지수표를 기른다. 값이 넘칠 때마다 체다항식으로 줄이면\n// 255걸음 만에 0을 제외한 모든 원소를 한 번씩 지난다. 지수표를 두 배\n// 길이로 이어 두면 로그 두 개의 합이 255를 넘어도 나머지 연산 없이\n// 바로 읽을 수 있다.\nfunction 갈루아표만들기() -> 갈루아표 {\n  let mut 지수: Array<int> = []\n  let mut 로그: Array<int> = []\n  let mut 색인 = 0\n  while 색인 < 512 { 지수.push(0); 색인 = 색인 + 1 }\n  색인 = 0\n  while 색인 < 256 { 로그.push(0); 색인 = 색인 + 1 }\n  let mut 값 = 1\n  색인 = 0\n  while 색인 < 255 {\n    지수[색인] = 값\n    로그[값] = 색인\n    값 = 값 * 2\n    if 값 >= 256 { 값 = 비트배타합(값, 체다항식, 9) }\n    색인 = 색인 + 1\n  }\n  while 색인 < 512 { 지수[색인] = 지수[색인 - 255]; 색인 = 색인 + 1 }\n  갈루아표 { 지수: 지수, 로그: 로그 }\n}\n\n// 생성다항식은 일차식 (x - α^i)를 근 α^0부터 α^31까지 차례로 곱해\n// 자라난다. 서른두 개의 근이 서른두 바이트의 패리티를 만든다.\nfunction 생성다항식(표: 갈루아표) -> Array<int> {\n  let mut 생성 = [1]\n  let mut 근 = 0\n  while 근 < 패리티바이트수 { 생성 = 다항식곱(생성, [1, 표.지수[근]], 표); 근 = 근 + 1 }\n  생성\n}\n\n// 패리티는 다항식 나눗셈의 나머지다. 자료를 255칸 작업대의 앞 223칸에\n// 펼치고 위치마다 생성다항식 배수를 빼 나가면 앞쪽은 전부 지워지고\n// 마지막 서른두 칸에 나머지만 남는다.\nfunction 패리티(자료: Array<int>, 표: 갈루아표, 생성: Array<int>) -> Result<Array<int>, string> {\n  if 자료.length != 자료바이트수 { return Err(\"리드 솔로몬 자료 조각은 223바이트여야 합니다\") }\n  let mut 작업: Array<int> = []\n  let mut 색인 = 0\n  while 색인 < 부호바이트수 { 작업.push(if 색인 < 자료바이트수 { 자료[색인] } else { 0 }); 색인 = 색인 + 1 }\n  let mut 위치 = 0\n  while 위치 < 자료바이트수 {\n    let 계수 = 작업[위치]\n    if 계수 != 0 {\n      색인 = 0\n      while 색인 < 생성.length {\n        작업[위치 + 색인] = 비트배타합(작업[위치 + 색인], 갈루아곱(생성[색인], 계수, 표), 8)\n        색인 = 색인 + 1\n      }\n    }\n    위치 = 위치 + 1\n  }\n  Ok(부분배열(작업, 자료바이트수, 부호바이트수))\n}\n\n// 보호 방향은 승인된 기성 부호기가 맡는다. 해제 방향은 아래에서 같은\n// 수학을 열린 토파즈로 다시 유도해 검증하므로 읽는 사람이 두 방향의\n// 일치를 직접 확인할 수 있다.\nexport function 리드솔로몬보호(논리: Bytes) -> Result<Bytes, string> {\n  if 논리.length() == 0 { return Err(\"논리 와이어는 비어 있을 수 없습니다\") }\n  let 조각수 = (논리.length() + 자료바이트수 - 1) / 자료바이트수\n  if 조각수 > 65535 { return Err(\"리드 솔로몬 조각 수가 너무 많습니다\") }\n  논리.reedSolomon255223Protect()\n}\n\nexport function 리드솔로몬해제(보호: Bytes, 논리길이: int) -> Result<Bytes, string> {\n  let 입력 = 바이트배열로(보호)\n  if 입력.length == 0 || 입력.length % 부호바이트수 != 0 { return Err(\"보호 와이어가 조각 경계에 맞지 않습니다\") }\n  let 조각수 = 입력.length / 부호바이트수\n  let 최대길이 = 조각수 * 자료바이트수\n  if 논리길이 <= 0 || 논리길이 > 최대길이 || 논리길이 <= 최대길이 - 자료바이트수 { return Err(\"논리 길이가 정규 범위가 아닙니다\") }\n  let 표 = 갈루아표만들기()\n  let 생성 = 생성다항식(표)\n  let mut 자료전체: Array<int> = []\n  let mut 조각 = 0\n  while 조각 < 조각수 {\n    let 시작 = 조각 * 부호바이트수\n    let 자료 = 부분배열(입력, 시작, 시작 + 자료바이트수)\n    let 실제 = 부분배열(입력, 시작 + 자료바이트수, 시작 + 부호바이트수)\n    if !배열같음(패리티(자료, 표, 생성)?, 실제) { return Err(\"리드 솔로몬 패리티가 맞지 않습니다\") }\n    자료전체 = 바이트추가(자료전체, 자료)\n    조각 = 조각 + 1\n  }\n  let mut 색인 = 논리길이\n  while 색인 < 자료전체.length {\n    if 자료전체[색인] != 0 { return Err(\"리드 솔로몬 채움 바이트가 영이 아닙니다\") }\n    색인 = 색인 + 1\n  }\n  바이트로(부분배열(자료전체, 0, 논리길이))\n}\n",
      "sourceSha256": "91d727614bbb2a61c2bd15b6296b274e4ad9cf267ae88250f5aaf985e91fadcf"
    },
    {
      "path": "topaz/src/hash.tpz",
      "language": "topaz",
      "bytes": 520,
      "sha256": "a6710058b0e41def439f9e56d212372df08ddbbe56fcebb8e0f4c41a723e45aa",
      "content": "// SHA-256 byte-array hashing.\n\nimport std.bytes { Bytes }\nimport util { 바이트로, 바이트배열로 }\n\nexport function 해시배열(원본: Array<int>) -> Array<int> {\n  let mut 입력 = ByteBuffer.allocate(원본.length)\n  let mut 색인 = 0\n  while 색인 < 원본.length { 입력.set(색인, 원본[색인]); 색인 = 색인 + 1 }\n  입력.toBytes().sha256().toArray()\n}\n\nexport function 해시이백오십육(입력: Bytes) -> Result<Bytes, string> {\n  바이트로(해시배열(바이트배열로(입력)))\n}\n",
      "sourceSha256": "a6710058b0e41def439f9e56d212372df08ddbbe56fcebb8e0f4c41a723e45aa"
    },
    {
      "path": "topaz/src/image_carrier.tpz",
      "language": "topaz",
      "bytes": 16482,
      "sha256": "d8770e1c3af0ac90de1b4b01b6554bd07b26b1e0442822d9bb4bd8a3a9ad7959",
      "content": "// Image request validation, page planning, and the page rendering entry points.\n\nimport std.bytes { Bytes }\nimport std.json\nimport ecc { 리드솔로몬보호 }\nimport hash { 해시이백오십육 }\nimport image_raster { 그림준비하기, 정규피엔지, 조상또는자신 }\nimport plan {\n  배열에있음,\n  범위코드,\n  보호길이,\n  이미지계획,\n  이미지배치,\n  이미지배치계산,\n  이미지쪽계획,\n  이미지프로필해시맞음,\n  쪽투영문자열,\n  파일프로그램코드,\n  픽셀글꼴,\n}\nimport printers { 인쇄구조검사, 준비된구조 }\nimport structure { 구조노드, 구조언어번호, 구조입력, 이미지요청, 이미지요청읽기 }\nimport util { 작은값, 큰값 }\n\n// 이미지 운반체. 큰 래스터는 바이트 배열로 펼치지 않고 좌표 함수로\n// 계산하여 불변 바이트 경계를 지킨다.\n\nexport record 준비된이미지요청 {\n  요청: 이미지요청,\n  구조: 준비된구조,\n  논리: Bytes\n}\n\nexport record 준비된이미지계획 {\n  요청: 준비된이미지요청,\n  계획: 이미지계획\n}\n\nexport record 이미지계획출력 {\n  쪽수: int,\n  세트해시: string,\n  높이들: Array<int>,\n  노드시작들: Array<int>,\n  노드수들: Array<int>,\n  논리길이들: Array<int>,\n  보호길이들: Array<int>,\n  패리티길이들: Array<int>\n}\n\nfunction 요청검사(요청: 이미지요청) -> Result<준비된구조, string> {\n  if 요청.언어번호 != 1 && 요청.언어번호 != 2 && 요청.언어번호 != 3 &&\n    요청.언어번호 != 4 && 요청.언어번호 != 5 &&\n    요청.언어번호 != 6 && 요청.언어번호 != 7 &&\n    요청.언어번호 != 8 && 요청.언어번호 != 9 &&\n    요청.언어번호 != 10 && 요청.언어번호 != 11 &&\n    요청.언어번호 != 12 && 요청.언어번호 != 13 &&\n    요청.언어번호 != 14 && 요청.언어번호 != 15 &&\n    요청.언어번호 != 16 && 요청.언어번호 != 17 &&\n    요청.언어번호 != 18 && 요청.언어번호 != 19 &&\n    요청.언어번호 != 21 && 요청.언어번호 != 20 &&\n    요청.언어번호 != 22 && 요청.언어번호 != 23 &&\n    요청.언어번호 != 24 && 요청.언어번호 != 25 &&\n    요청.언어번호 != 26 && 요청.언어번호 != 27 &&\n    요청.언어번호 != 28 && 요청.언어번호 != 29 &&\n    요청.언어번호 != 30 {\n    return Err(\"지원하지 않는 언어입니다\")\n  }\n  if 구조언어번호(요청.구조) != 요청.언어번호 { return Err(\"구조 뿌리의 언어가 이미지 요청과 다릅니다\") }\n  인쇄구조검사(요청.언어번호, 요청.구조)?\n  if 요청.팔레트번호 != 요청.언어번호 || !이미지프로필해시맞음(요청.언어번호, 요청.프로필해시) {\n    return Err(\"언어 팔레트 프로필이 맞지 않습니다\")\n  }\n  if 요청.프로필해시.scalars().length != 64 || 요청.구조해시.scalars().length != 64 || 요청.키해시.scalars().length != 64 {\n    return Err(\"이미지 해시 길이가 틀립니다\")\n  }\n  if 요청.구조.분리본문키해시 != 요청.키해시 { return Err(\"구조와 키 해시가 다릅니다\") }\n  if 요청.구조.노드들.length == 0 { return Err(\"이미지는 파일 뿌리 노드가 필요합니다\") }\n  if 요청.크롬번호 < 0 || 요청.크롬번호 > 1 { return Err(\"크롬 번호가 틀립니다\") }\n  if 요청.크롬번호 == 0 && (요청.제목 != \"\" || 요청.원본줄수 != 0) { return Err(\"민무늬 크롬에 책 메타데이터가 있습니다\") }\n  let 제목바이트 = 요청.제목.encodeUtf8()\n  if 제목바이트.length() > 24 { return Err(\"책 제목이 24바이트를 넘습니다\") }\n  for 글자 in 요청.제목.scalars() {\n    if 픽셀글꼴(글자) == \"\" { return Err(\"책 제목에 없는 픽셀 글자가 있습니다\") }\n  }\n  Ok(준비된구조 { 언어번호: 요청.언어번호, 구조: 요청.구조 })\n}\n\nfunction 이미지요청준비(요청글: string, 논리: Bytes) -> Result<준비된이미지요청, string> {\n  let 요청 = 이미지요청읽기(요청글)?\n  let 준비된구조값 = 요청검사(요청)?\n  if 논리.length() <= 0 { return Err(\"구조 논리 와이어가 비었습니다\") }\n  Ok(준비된이미지요청 {\n    요청: 요청,\n    구조: 준비된구조값,\n    논리: 논리\n  })\n}\n\nfunction 선호행경계(요청: 이미지요청) -> Array<int> {\n  let 노드들 = 요청.구조.노드들\n  let mut 경계들: Array<int> = []\n  let mut 순번 = 0\n  while 순번 < 노드들.length {\n    let 노드 = 노드들[순번]\n    if 범위코드(요청.언어번호, 노드.코드워드) && !파일프로그램코드(요청.언어번호, 노드.코드워드) {\n      let mut 끝 = 순번\n      let mut 살피기 = 순번 + 1\n      while 살피기 < 노드들.length && 조상또는자신(노드들, 살피기, 순번) { 끝 = 살피기; 살피기 = 살피기 + 1 }\n      if (끝 + 1) % 12 == 0 { 경계들.push((끝 + 1) / 12) }\n    }\n    순번 = 순번 + 1\n  }\n  경계들\n}\n\nfunction 이미지세트해시계산(요청: 이미지요청, 논리: Bytes, 쪽들: Array<이미지쪽계획>) -> Result<string, string> {\n  let 크롬글 = if 요청.크롬번호 == 1 { \"book\" } else { \"plain\" }\n  let 논리해시바이트 = 해시이백오십육(논리)?\n  let 논리해시 = 논리해시바이트.toHex()\n  let 투영 = \"\\{\" + json.stringify(\"chromePreset\")? + \":\" + json.stringify(크롬글)? +\n    \",\" + json.stringify(\"detachedTextKeySha256\")? + \":\" + json.stringify(\"sha256:\" + 요청.키해시)? +\n    \",\" + json.stringify(\"domain\")? + \":\" + json.stringify(\"codeimage.js-total-format.v2.pageset\")? +\n    \",\" + json.stringify(\"pages\")? + \":\" + 쪽투영문자열(쪽들)? +\n    \",\" + json.stringify(\"sourceLineCount\")? + \":\" + \"{요청.원본줄수}\" +\n    \",\" + json.stringify(\"structureDigest\")? + \":\" + json.stringify(\"sha256:\" + 요청.구조해시)? +\n    \",\" + json.stringify(\"structureLogicalSha256\")? + \":\" + json.stringify(\"sha256:\" + 논리해시)? +\n    \",\" + json.stringify(\"title\")? + \":\" + json.stringify(요청.제목)? + \"\\}\"\n  let 세트해시바이트 = 해시이백오십육(투영.encodeUtf8())?\n  Ok(세트해시바이트.toHex())\n}\n\nfunction 이미지계획준비(준비된요청: 준비된이미지요청) -> Result<준비된이미지계획, string> {\n  let 요청 = 준비된요청.요청\n  let 논리 = 준비된요청.논리\n  let 전체행수 = (요청.구조.노드들.length + 11) / 12\n  let 선호 = 선호행경계(요청)\n  let 꼬리 = if 요청.크롬번호 == 1 { 64 } else { 24 }\n  let mut 쪽수 = 1\n  while 쪽수 <= 32 {\n    let mut 논리시작들: Array<int> = []\n    let mut 논리끝들: Array<int> = []\n    let mut 보호길이들: Array<int> = []\n    let mut 용량들: Array<int> = []\n    let mut 유효 = true\n    let mut 쪽번호 = 0\n    while 쪽번호 < 쪽수 {\n      let 시작 = (논리.length() * 쪽번호) / 쪽수\n      let 끝 = (논리.length() * (쪽번호 + 1)) / 쪽수\n      if 끝 <= 시작 { 유효 = false }\n      let 길이 = 보호길이(끝 - 시작)\n      let 띠행수 = 큰값(1, (길이 + 161) / 162)\n      let 용량 = (2800 - (89 + 꼬리) - 띠행수 * 2) / 36\n      if 용량 < 1 { 유효 = false }\n      논리시작들.push(시작); 논리끝들.push(끝); 보호길이들.push(길이); 용량들.push(용량)\n      쪽번호 = 쪽번호 + 1\n    }\n    let mut 용량합 = 0\n    for 용량 in 용량들 { 용량합 = 용량합 + 용량 }\n    if 유효 && 용량합 >= 전체행수 {\n      let mut 행경계 = [0]\n      let mut 행시작 = 0\n      쪽번호 = 0\n      while 쪽번호 < 쪽수 - 1 {\n        let mut 남은용량 = 0\n        let mut 다음 = 쪽번호 + 1\n        while 다음 < 쪽수 { 남은용량 = 남은용량 + 용량들[다음]; 다음 = 다음 + 1 }\n        let 최소끝 = 큰값(행시작 + 1, 전체행수 - 남은용량)\n        let 최대끝 = 작은값(행시작 + 용량들[쪽번호], 전체행수 - (쪽수 - 쪽번호 - 1))\n        if 최소끝 > 최대끝 { 유효 = false }\n        let mut 행끝 = 최대끝\n        let mut 후보 = 최대끝\n        while 후보 >= 최소끝 {\n          if 배열에있음(선호, 후보) { 행끝 = 후보; 후보 = 최소끝 - 1 }\n          else { 후보 = 후보 - 1 }\n        }\n        행경계.push(행끝)\n        행시작 = 행끝\n        쪽번호 = 쪽번호 + 1\n      }\n      if 유효 {\n        행경계.push(전체행수)\n        let mut 쪽들: Array<이미지쪽계획> = []\n        쪽번호 = 0\n        while 쪽번호 < 쪽수 {\n          let 노드시작 = 행경계[쪽번호] * 12\n          let 노드끝 = 작은값(요청.구조.노드들.length, 행경계[쪽번호 + 1] * 12)\n          let 배치 = 이미지배치계산(노드끝 - 노드시작, 보호길이들[쪽번호], 요청.크롬번호)?\n          쪽들.push(이미지쪽계획 {\n            쪽번호: 쪽번호, 노드시작: 노드시작, 노드끝: 노드끝,\n            논리시작: 논리시작들[쪽번호], 논리끝: 논리끝들[쪽번호],\n            보호길이: 보호길이들[쪽번호], 패리티길이: (보호길이들[쪽번호] / 255) * 32,\n            배치: 배치\n          })\n          쪽번호 = 쪽번호 + 1\n        }\n        let 세트해시 = 이미지세트해시계산(요청, 논리, 쪽들)?\n        return Ok(준비된이미지계획 {\n          요청: 준비된요청,\n          계획: 이미지계획 { 쪽들: 쪽들, 세트해시: 세트해시 }\n        })\n      }\n    }\n    쪽수 = 쪽수 + 1\n  }\n  Err(\"이미지 세트가 32쪽 한계를 넘습니다\")\n}\n\nexport function 이미지계획하기(요청글: string, 논리: Bytes) -> Result<string, string> {\n  let 준비된요청 = 이미지요청준비(요청글, 논리)?\n  let 준비된계획 = 이미지계획준비(준비된요청)?\n  let 계획 = 준비된계획.계획\n  let mut 높이들: Array<int> = []\n  let mut 노드시작들: Array<int> = []\n  let mut 노드수들: Array<int> = []\n  let mut 논리길이들: Array<int> = []\n  let mut 보호길이들: Array<int> = []\n  let mut 패리티길이들: Array<int> = []\n  for 쪽 in 계획.쪽들 {\n    높이들.push(쪽.배치.높이); 노드시작들.push(쪽.노드시작); 노드수들.push(쪽.노드끝 - 쪽.노드시작)\n    논리길이들.push(쪽.논리끝 - 쪽.논리시작); 보호길이들.push(쪽.보호길이); 패리티길이들.push(쪽.패리티길이)\n  }\n  json.stringify(이미지계획출력 {\n    쪽수: 계획.쪽들.length, 세트해시: 계획.세트해시, 높이들: 높이들,\n    노드시작들: 노드시작들, 노드수들: 노드수들, 논리길이들: 논리길이들,\n    보호길이들: 보호길이들, 패리티길이들: 패리티길이들\n  })\n}\n\nfunction 이미지계획복원(\n  준비된요청: 준비된이미지요청,\n  출력: 이미지계획출력\n) -> Result<준비된이미지계획, string> {\n  let 요청 = 준비된요청.요청\n  let 논리 = 준비된요청.논리\n  let 쪽수 = 출력.쪽수\n  if 쪽수 <= 0 || 쪽수 > 32 { return Err(\"준비된 이미지 계획의 쪽 수가 범위를 벗어났습니다\") }\n  if 출력.높이들.length != 쪽수 || 출력.노드시작들.length != 쪽수 ||\n    출력.노드수들.length != 쪽수 || 출력.논리길이들.length != 쪽수 ||\n    출력.보호길이들.length != 쪽수 || 출력.패리티길이들.length != 쪽수 {\n    return Err(\"준비된 이미지 계획의 배열 길이가 다릅니다\")\n  }\n  let mut 쪽들: Array<이미지쪽계획> = []\n  let mut 다음노드 = 0\n  let mut 다음논리 = 0\n  let mut 쪽번호 = 0\n  while 쪽번호 < 쪽수 {\n    let 노드시작 = 출력.노드시작들[쪽번호]\n    let 노드수 = 출력.노드수들[쪽번호]\n    let 논리길이 = 출력.논리길이들[쪽번호]\n    let 보호 = 출력.보호길이들[쪽번호]\n    let 패리티 = 출력.패리티길이들[쪽번호]\n    if 노드시작 != 다음노드 || 노드수 <= 0 || 노드시작 + 노드수 > 요청.구조.노드들.length {\n      return Err(\"준비된 이미지 계획의 노드 범위가 올바르지 않습니다\")\n    }\n    if 쪽번호 < 쪽수 - 1 && 노드수 % 12 != 0 {\n      return Err(\"준비된 이미지 계획의 노드 행 경계가 올바르지 않습니다\")\n    }\n    if 논리길이 <= 0 || 다음논리 + 논리길이 > 논리.length() {\n      return Err(\"준비된 이미지 계획의 논리 범위가 올바르지 않습니다\")\n    }\n    let 예상논리시작 = (논리.length() * 쪽번호) / 쪽수\n    let 예상논리끝 = (논리.length() * (쪽번호 + 1)) / 쪽수\n    if 다음논리 != 예상논리시작 || 다음논리 + 논리길이 != 예상논리끝 {\n      return Err(\"준비된 이미지 계획의 논리 분할이 올바르지 않습니다\")\n    }\n    if 보호 != 보호길이(논리길이) || 패리티 != (보호 / 255) * 32 {\n      return Err(\"준비된 이미지 계획의 보호 길이가 올바르지 않습니다\")\n    }\n    let 배치 = 이미지배치계산(노드수, 보호, 요청.크롬번호)?\n    if 배치.높이 != 출력.높이들[쪽번호] {\n      return Err(\"준비된 이미지 계획의 높이가 올바르지 않습니다\")\n    }\n    쪽들.push(이미지쪽계획 {\n      쪽번호: 쪽번호, 노드시작: 노드시작, 노드끝: 노드시작 + 노드수,\n      논리시작: 다음논리, 논리끝: 다음논리 + 논리길이,\n      보호길이: 보호, 패리티길이: 패리티, 배치: 배치\n    })\n    다음노드 = 다음노드 + 노드수\n    다음논리 = 다음논리 + 논리길이\n    쪽번호 = 쪽번호 + 1\n  }\n  if 다음노드 != 요청.구조.노드들.length || 다음논리 != 논리.length() {\n    return Err(\"준비된 이미지 계획이 전체 입력을 덮지 않습니다\")\n  }\n  let 세트해시 = 이미지세트해시계산(요청, 논리, 쪽들)?\n  if 세트해시 != 출력.세트해시 {\n    return Err(\"준비된 이미지 계획의 세트 해시가 다릅니다\")\n  }\n  Ok(준비된이미지계획 {\n    요청: 준비된요청,\n    계획: 이미지계획 { 쪽들: 쪽들, 세트해시: 세트해시 }\n  })\n}\n\nfunction 이미지쪽렌더계획됨(준비된계획: 준비된이미지계획, 쪽번호: int) -> Result<Bytes, string> {\n  let 요청 = 준비된계획.요청.요청\n  let 논리 = 준비된계획.요청.논리\n  let 계획 = 준비된계획.계획\n  if 쪽번호 < 0 || 쪽번호 >= 계획.쪽들.length { return Err(\"쪽 번호가 범위를 벗어났습니다\") }\n  let 쪽 = 계획.쪽들[쪽번호]\n  let 논리조각 = 논리.slice(쪽.논리시작, 쪽.논리끝)\n  let 보호 = 리드솔로몬보호(논리조각)?\n  정규피엔지(그림준비하기(요청, 계획, 쪽, 보호)?)\n}\n\nexport function 이미지쪽렌더준비됨(요청글: string, 논리: Bytes, 계획글: string, 쪽번호: int) -> Result<Bytes, string> {\n  let 준비된요청 = 이미지요청준비(요청글, 논리)?\n  let 출력 = json.parseAs<이미지계획출력>(계획글)?\n  let 준비된계획 = 이미지계획복원(준비된요청, 출력)?\n  이미지쪽렌더계획됨(준비된계획, 쪽번호)\n}\n\nexport function 이미지쪽렌더(요청글: string, 논리: Bytes, 쪽번호: int) -> Result<Bytes, string> {\n  let 준비된요청 = 이미지요청준비(요청글, 논리)?\n  let 준비된계획 = 이미지계획준비(준비된요청)?\n  이미지쪽렌더계획됨(준비된계획, 쪽번호)\n}\n\nfunction 이미지세트렌더계획됨(준비된계획: 준비된이미지계획) -> Result<Array<Bytes>, string> {\n  let mut 쪽들: Array<Bytes> = []\n  let mut 쪽번호 = 0\n  while 쪽번호 < 준비된계획.계획.쪽들.length {\n    쪽들.push(이미지쪽렌더계획됨(준비된계획, 쪽번호)?)\n    쪽번호 = 쪽번호 + 1\n  }\n  Ok(쪽들)\n}\n\nexport function 이미지세트렌더(요청글: string, 논리: Bytes) -> Result<Array<Bytes>, string> {\n  let 준비된요청 = 이미지요청준비(요청글, 논리)?\n  let 준비된계획 = 이미지계획준비(준비된요청)?\n  이미지세트렌더계획됨(준비된계획)\n}\n\nexport function 이미지세트계획렌더(요청글: string, 논리: Bytes) -> Result<Array<Bytes>, string> {\n  let 준비된요청 = 이미지요청준비(요청글, 논리)?\n  let 준비된계획 = 이미지계획준비(준비된요청)?\n  let mut 출력: Array<Bytes> = [Bytes.fromHex(준비된계획.계획.세트해시)?]\n  let 쪽들 = 이미지세트렌더계획됨(준비된계획)?\n  for 쪽 in 쪽들 { 출력.push(쪽) }\n  Ok(출력)\n}\n",
      "sourceSha256": "d8770e1c3af0ac90de1b4b01b6554bd07b26b1e0442822d9bb4bd8a3a9ad7959"
    },
    {
      "path": "topaz/src/image_raster.tpz",
      "language": "topaz",
      "bytes": 24321,
      "sha256": "8ec630bcdac3dffd9d5b8eec79bd5b902670e45a4663280eff2626813c674e0e",
      "content": "// Page headers, raster pixels computed as functions of their coordinates, and\n// canonical PNG output.\n\nimport std.bytes { Bytes }\nimport hash { 해시이백오십육 }\nimport plan {\n  띠팔레트,\n  범위씻김팔레트,\n  범위코드,\n  이미지계획,\n  이미지배치,\n  이미지쪽계획,\n  이미지팔레트,\n  이역할팔레트,\n  파일프로그램코드,\n  팔그물팔레트,\n  픽셀글꼴,\n  형식팔레트,\n}\nimport render { 글자그림, 사각안, 이미지머리, 이역할변형, 청크만들기 }\nimport structure { 구조노드, 구조입력, 이미지요청 }\nimport util { 거듭제곱이, 십육진숫자, 작은값, 큰값 }\n\nexport record 그림준비 {\n  요청: 이미지요청,\n  머리: 이미지머리,\n  머리바이트: ByteBuffer,\n  보호바이트: ByteBuffer,\n  노드시작: int,\n  노드끝: int,\n  수직씻김: Array<int>,\n  수평씻김: Array<int>,\n  이역할: Array<int>,\n  팔그물: Array<int>\n}\nexport record 주사그림 { 준비: 그림준비, 바이트들: ByteBuffer }\n\nexport function 조상또는자신(노드들: Array<구조노드>, 순번: int, 조상: int) -> bool {\n  let mut 현재 = 순번\n  while 현재 >= 0 {\n    if 현재 == 조상 { return true }\n    현재 = 노드들[현재].부모순번\n  }\n  false\n}\n\nfunction 범위깊이(노드들: Array<구조노드>, 언어번호: int, 순번: int) -> int {\n  let mut 깊이 = 0\n  let mut 현재 = 순번\n  while 현재 >= 0 {\n    let 노드 = 노드들[현재]\n    if 범위코드(언어번호, 노드.코드워드) && !파일프로그램코드(언어번호, 노드.코드워드) { 깊이 = 깊이 + 1 }\n    현재 = 노드.부모순번\n  }\n  깊이\n}\n\nfunction 머리만들기(요청: 이미지요청, 계획: 이미지계획, 쪽: 이미지쪽계획) -> Result<ByteBuffer, string> {\n  let mut 본문 = ByteBuffer.allocate(192)\n  본문.set(0, 67); 본문.set(1, 73); 본문.set(2, 70); 본문.set(3, 54)\n  본문.set(4, 2); 본문.set(5, 1); 본문.set(6, 요청.언어번호); 본문.set(7, 요청.팔레트번호)\n  본문.set(8, 8); 본문.set(9, 3); 본문.set(10, 2); 본문.set(11, 0)\n  본문.set(12, 1304 / 256); 본문.set(13, 1304 % 256)\n  본문.set(14, 쪽.배치.높이 / 256); 본문.set(15, 쪽.배치.높이 % 256)\n  본문.set(16, 0); 본문.set(17, 71)\n  본문.set(18, 쪽.배치.판행수 / 256); 본문.set(19, 쪽.배치.판행수 % 256)\n  본문.set(20, 12); 본문.set(21, 30); 본문.set(22, 6); 본문.set(23, 2)\n  본문.set(24, 쪽.배치.띠위 / 256); 본문.set(25, 쪽.배치.띠위 % 256)\n  본문.set(26, 쪽.배치.띠행수 / 256); 본문.set(27, 쪽.배치.띠행수 % 256)\n  let 수치들 = [쪽.노드끝 - 쪽.노드시작, 쪽.보호길이, 쪽.논리끝 - 쪽.논리시작, 쪽.패리티길이]\n  let mut 색인 = 0\n  while 색인 < 4 {\n    let 값 = 수치들[색인]\n    let 위치 = 28 + 색인 * 4\n    본문.set(위치, (값 / 16777216) % 256); 본문.set(위치 + 1, (값 / 65536) % 256)\n    본문.set(위치 + 2, (값 / 256) % 256); 본문.set(위치 + 3, 값 % 256)\n    색인 = 색인 + 1\n  }\n  let 프로필 = ByteBuffer.fromBytes(Bytes.fromHex(요청.프로필해시)?)\n  let 키 = ByteBuffer.fromBytes(Bytes.fromHex(요청.키해시)?)\n  let 구조 = ByteBuffer.fromBytes(Bytes.fromHex(요청.구조해시)?)\n  let 세트 = ByteBuffer.fromBytes(Bytes.fromHex(계획.세트해시)?)\n  본문.copy(프로필, 0, 44, 32); 본문.copy(키, 0, 76, 32); 본문.copy(구조, 0, 108, 16); 본문.copy(세트, 0, 128, 32)\n  본문.set(124, 쪽.쪽번호); 본문.set(125, 계획.쪽들.length - 1); 본문.set(126, 요청.크롬번호)\n  let 제목바이트 = ByteBuffer.fromBytes(요청.제목.encodeUtf8())\n  본문.set(127, 제목바이트.length())\n  본문.copy(제목바이트, 0, 160, 제목바이트.length())\n  let 원본줄수 = 요청.원본줄수\n  본문.set(184, (원본줄수 / 16777216) % 256); 본문.set(185, (원본줄수 / 65536) % 256)\n  본문.set(186, (원본줄수 / 256) % 256); 본문.set(187, 원본줄수 % 256)\n  let 노드시작 = 쪽.노드시작\n  본문.set(188, (노드시작 / 16777216) % 256); 본문.set(189, (노드시작 / 65536) % 256)\n  본문.set(190, (노드시작 / 256) % 256); 본문.set(191, 노드시작 % 256)\n  let 검사합 = ByteBuffer.fromBytes(해시이백오십육(본문.toBytes())?)\n  let mut 전체 = ByteBuffer.allocate(224)\n  전체.copy(본문, 0, 0, 192); 전체.copy(검사합, 0, 192, 32)\n  Ok(전체)\n}\n\nfunction 머리레코드(요청: 이미지요청, 계획: 이미지계획, 쪽: 이미지쪽계획) -> 이미지머리 {\n  이미지머리 {\n    버전: 2, 언어번호: 요청.언어번호, 팔레트번호: 요청.팔레트번호,\n    너비: 1304, 높이: 쪽.배치.높이, 판행수: 쪽.배치.판행수,\n    띠위: 쪽.배치.띠위, 띠행수: 쪽.배치.띠행수,\n    노드수: 쪽.노드끝 - 쪽.노드시작, 보호길이: 쪽.보호길이,\n    논리길이: 쪽.논리끝 - 쪽.논리시작, 패리티길이: 쪽.패리티길이,\n    프로필해시: 요청.프로필해시, 키해시: 요청.키해시,\n    구조해시앞: 요청.구조해시.scalars().slice(0, 32).join(\"\"),\n    쪽번호: 쪽.쪽번호, 쪽수: 계획.쪽들.length, 노드시작: 쪽.노드시작,\n    크롬번호: 요청.크롬번호, 제목: 요청.제목, 원본줄수: 요청.원본줄수,\n    세트해시: 계획.세트해시\n  }\n}\n\nexport function 그림준비하기(요청: 이미지요청, 계획: 이미지계획, 쪽: 이미지쪽계획, 보호: Bytes) -> Result<그림준비, string> {\n  let 머리바이트 = 머리만들기(요청, 계획, 쪽)?\n  let 보호바이트 = ByteBuffer.fromBytes(보호)\n  if 보호바이트.length() != 쪽.보호길이 { return Err(\"보호 조각 길이가 계획과 다릅니다\") }\n  let 노드수 = 쪽.노드끝 - 쪽.노드시작\n  let mut 수직씻김: Array<int> = []\n  let mut 수평씻김: Array<int> = []\n  let mut 이역할: Array<int> = []\n  let mut 팔그물: Array<int> = []\n  let mut 색인 = 0\n  while 색인 < 노드수 { 수직씻김.push(0); 수평씻김.push(0); 이역할.push(-1); 팔그물.push(-1); 색인 = 색인 + 1 }\n  let 노드들 = 요청.구조.노드들\n  let mut 범위순번 = 0\n  while 범위순번 < 노드들.length {\n    let 범위 = 노드들[범위순번]\n    if 범위코드(요청.언어번호, 범위.코드워드) && !파일프로그램코드(요청.언어번호, 범위.코드워드) {\n      let mut 끝 = 범위순번\n      let mut 살피기 = 범위순번 + 1\n      while 살피기 < 노드들.length && 조상또는자신(노드들, 살피기, 범위순번) { 끝 = 살피기; 살피기 = 살피기 + 1 }\n      let 깊이 = 범위깊이(노드들, 요청.언어번호, 범위순번)\n      let 보이는시작 = 큰값(범위순번, 쪽.노드시작)\n      let 보이는끝 = 작은값(끝, 쪽.노드끝 - 1)\n      let mut 순번 = 보이는시작\n      while 순번 < 보이는끝 {\n        let 지역 = 순번 - 쪽.노드시작\n        if 지역 % 12 != 11 && 수직씻김[지역] < 깊이 { 수직씻김[지역] = 깊이 }\n        순번 = 순번 + 1\n      }\n      순번 = 보이는시작\n      while 순번 + 12 <= 보이는끝 {\n        let 지역 = 순번 - 쪽.노드시작\n        if 수평씻김[지역] < 깊이 { 수평씻김[지역] = 깊이 }\n        순번 = 순번 + 1\n      }\n    }\n    범위순번 = 범위순번 + 1\n  }\n  색인 = 0\n  while 색인 < 노드수 {\n    let 노드 = 노드들[쪽.노드시작 + 색인]\n    if 노드.부모순번 >= 0 { 이역할[색인] = 이역할변형(노드.자식필드) }\n    if 노드.식별자있음 && 노드.식별자류번호 < 9 { 팔그물[색인] = 노드.식별자류번호 }\n    색인 = 색인 + 1\n  }\n  Ok(그림준비 {\n    요청: 요청, 머리: 머리레코드(요청, 계획, 쪽), 머리바이트: 머리바이트,\n    보호바이트: 보호바이트, 노드시작: 쪽.노드시작, 노드끝: 쪽.노드끝,\n    수직씻김: 수직씻김, 수평씻김: 수평씻김, 이역할: 이역할, 팔그물: 팔그물\n  })\n}\n\nfunction 크롬색(준비: 그림준비, 가로: int, 세로: int, 바탕: int) -> int {\n  if 준비.머리.크롬번호 != 1 { return 바탕 }\n  let mut 색 = 바탕\n  let 잉크 = 2959909\n  let 줄색 = 5458753\n  let 제목글자수 = 준비.머리.제목.scalars().length\n  if 제목글자수 > 0 && 글자그림(준비.머리.제목, (1304 - 제목글자수 * 12) / 2, 2, 3, 가로, 세로) { 색 = 잉크 }\n  if 사각안(가로, 세로, 56, 19, 1192, 1) || 사각안(가로, 세로, 56, 21, 1192, 1) { 색 = 줄색 }\n  let 기림글 = \"LINES {준비.머리.원본줄수} / NODES {준비.요청.구조.노드들.length}\"\n  if 글자그림(기림글, (1304 - 기림글.scalars().length * 8) / 2, 42, 2, 가로, 세로) { 색 = 잉크 }\n  if 사각안(가로, 세로, 56, 58, 1192, 1) || 사각안(가로, 세로, 56, 60, 1192, 1) { 색 = 줄색 }\n  let 꼬리위 = 준비.머리.높이 - 64\n  if 사각안(가로, 세로, 56, 꼬리위 + 11, 1192, 1) || 사각안(가로, 세로, 56, 꼬리위 + 13, 1192, 1) { 색 = 줄색 }\n  let 쪽글 = \"{준비.머리.쪽번호 + 1} / {준비.머리.쪽수}\"\n  if 글자그림(쪽글, (1304 - 쪽글.scalars().length * 12) / 2, 준비.머리.높이 - 35, 3, 가로, 세로) { 색 = 잉크 }\n  let 등왼쪽 = if 준비.머리.쪽번호 % 2 == 0 { 0 } else { 1300 }\n  if 사각안(가로, 세로, 등왼쪽, 64, 4, 준비.머리.높이 - 64) { 색 = 7365459 }\n  for 장식가로 in [18, 1277] {\n    if 사각안(가로, 세로, 장식가로, 7, 9, 1) || 사각안(가로, 세로, 장식가로, 7, 1, 6) ||\n      사각안(가로, 세로, 장식가로, 65, 9, 1) || 사각안(가로, 세로, 장식가로, 65, 1, 6) ||\n      사각안(가로, 세로, 장식가로, 준비.머리.높이 - 18, 9, 1) ||\n      사각안(가로, 세로, 장식가로, 준비.머리.높이 - 23, 1, 6) { 색 = 8417112 }\n  }\n  let 인장왼쪽 = 1247\n  let 인장위 = 준비.머리.높이 - 49\n  if 사각안(가로, 세로, 인장왼쪽, 인장위, 36, 1) || 사각안(가로, 세로, 인장왼쪽, 인장위 + 35, 36, 1) ||\n    사각안(가로, 세로, 인장왼쪽, 인장위, 1, 36) || 사각안(가로, 세로, 인장왼쪽 + 35, 인장위, 1, 36) { 색 = 12466730 }\n  let 상대가로 = 가로 - (인장왼쪽 + 5)\n  let 상대세로 = 세로 - (인장위 + 5)\n  if 상대가로 >= 0 && 상대세로 >= 0 && 상대가로 < 26 && 상대세로 < 26 && 상대가로 % 7 < 5 && 상대세로 % 7 < 5 {\n    let 비트 = (상대세로 / 7) * 4 + (상대가로 / 7)\n    if 비트 < 16 {\n      let 해시글자 = 준비.머리.세트해시.scalars()\n      let 바이트 = 십육진숫자(해시글자[(비트 / 8) * 2]) * 16 + 십육진숫자(해시글자[(비트 / 8) * 2 + 1])\n      if (바이트 / 거듭제곱이(7 - (비트 % 8))) % 2 == 1 { 색 = 12466730 }\n    }\n  }\n  색\n}\n\nfunction 그림색(준비: 그림준비, 가로: int, 세로: int) -> int {\n  let mut 색 = 15262682\n  let 형식색 = 형식팔레트()\n  if 가로 >= 78 && 세로 >= 24 {\n    let 칸가로 = (가로 - 78) / 2\n    let 칸세로 = (세로 - 24) / 2\n    if (가로 - 78) % 2 < 2 && (세로 - 24) % 2 < 2 && 칸가로 < 320 {\n      let 바이트색인 = 칸세로 * 80 + 칸가로 / 4\n      if 바이트색인 < 준비.머리바이트.length() {\n        let 부분 = 칸가로 % 4\n        let 숫자 = (준비.머리바이트.get(바이트색인) / 거듭제곱이((3 - 부분) * 2)) % 4\n        색 = 형식색[숫자]\n      }\n    }\n  }\n  let 코드색 = 이미지팔레트(준비.머리.언어번호)\n  let mut 색인 = 0\n  while 색인 < 코드색.length {\n    if 사각안(가로, 세로, 804 + 색인 * 16, 24, 12, 12) { 색 = 코드색[색인] }\n    색인 = 색인 + 1\n  }\n  let 표들 = [이역할팔레트(), 팔그물팔레트(), 범위씻김팔레트()]\n  let 왼쪽들 = [804, 884, 964]\n  let mut 표번호 = 0\n  while 표번호 < 3 {\n    색인 = 0\n    while 색인 < 표들[표번호].length {\n      if 사각안(가로, 세로, 왼쪽들[표번호] + 색인 * 8, 42, 6, 6) { 색 = 표들[표번호][색인] }\n      색인 = 색인 + 1\n    }\n    표번호 = 표번호 + 1\n  }\n  let 노드수 = 준비.노드끝 - 준비.노드시작\n  let 판상대세로 = 세로 - 71\n  if 판상대세로 >= 0 {\n    let 행 = 판상대세로 / 36\n    let 행안 = 판상대세로 % 36\n    if 행안 < 30 {\n      let 수직상대 = 가로 - 109\n      if 수직상대 >= 0 && 수직상대 % 108 < 6 {\n        let 열 = 수직상대 / 108\n        let 지역 = 행 * 12 + 열\n        if 열 < 12 && 지역 < 노드수 && 준비.수직씻김[지역] > 0 {\n          색 = 범위씻김팔레트()[작은값(준비.수직씻김[지역], 3) - 1]\n        }\n      }\n    } else {\n      let 열상대 = 가로 - 7\n      if 열상대 >= 0 {\n        let 열 = 열상대 / 108\n        let 열안 = 열상대 % 108\n        let 지역 = 행 * 12 + 열\n        if 열 < 12 && 열안 < 102 && 지역 < 노드수 && 준비.수평씻김[지역] > 0 {\n          색 = 범위씻김팔레트()[작은값(준비.수평씻김[지역], 3) - 1]\n        }\n      }\n    }\n  }\n  let 첫열가로 = 가로 - 55\n  let 첫열세로 = 세로 - 65\n  if 첫열가로 >= 0 && 첫열가로 < 6 && 첫열세로 >= 0 && 첫열세로 % 36 < 6 {\n    let 지역 = (첫열세로 / 36) * 12\n    if 지역 < 노드수 && 준비.이역할[지역] >= 0 { 색 = 이역할팔레트()[준비.이역할[지역]] }\n  }\n  let 역할가로 = 가로 - 1\n  let 역할세로 = 세로 - 83\n  if 역할가로 >= 0 && 역할세로 >= 0 && 역할가로 % 108 < 6 && 역할세로 % 36 < 6 {\n    let 열 = 역할가로 / 108\n    let 행 = 역할세로 / 36\n    let 지역 = 행 * 12 + 열\n    if 열 >= 1 && 열 < 12 && 지역 < 노드수 && 준비.이역할[지역] >= 0 { 색 = 이역할팔레트()[준비.이역할[지역]] }\n  }\n  let 그물가로 = 가로 - 109\n  let 그물세로 = 세로 - 71\n  if 그물가로 >= 0 && 그물세로 >= 0 && 그물가로 % 108 < 6 && 그물세로 % 36 < 6 {\n    let 열 = 그물가로 / 108\n    let 행 = 그물세로 / 36\n    let 지역 = 행 * 12 + 열\n    if 열 < 12 && 지역 < 노드수 && 준비.팔그물[지역] >= 0 { 색 = 팔그물팔레트()[준비.팔그물[지역]] }\n  }\n  if 판상대세로 >= 0 && 판상대세로 % 36 < 30 {\n    let 열상대 = 가로 - 7\n    if 열상대 >= 0 {\n      let 열 = 열상대 / 108\n      let 열안 = 열상대 % 108\n      let 지역 = (판상대세로 / 36) * 12 + 열\n      if 열 < 12 && 지역 < 노드수 {\n        let 코드칸 = if 열안 < 30 { 0 } else if 열안 >= 36 && 열안 < 66 { 1 } else if 열안 >= 72 && 열안 < 102 { 2 } else { -1 }\n        if 코드칸 >= 0 {\n          let 코드 = 준비.요청.구조.노드들[준비.노드시작 + 지역].코드워드\n          let 숫자 = if 코드칸 == 0 { 코드 / 64 } else if 코드칸 == 1 { (코드 / 8) % 8 } else { 코드 % 8 }\n          색 = 코드색[숫자]\n        }\n      }\n    }\n  }\n  if 가로 >= 4 && 세로 >= 준비.머리.띠위 {\n    let 칸가로 = (가로 - 4) / 2\n    let 칸세로 = (세로 - 준비.머리.띠위) / 2\n    if 칸가로 < 648 {\n      let 바이트색인 = 칸세로 * 162 + 칸가로 / 4\n      if 바이트색인 < 준비.보호바이트.length() {\n        let 부분 = 칸가로 % 4\n        let 숫자 = (준비.보호바이트.get(바이트색인) / 거듭제곱이((3 - 부분) * 2)) % 4\n        색 = 띠팔레트()[숫자]\n      }\n    }\n  }\n  크롬색(준비, 가로, 세로, 색)\n}\n\nfunction 사각채우기(그림: 주사그림, 왼쪽: int, 위: int, 너비: int, 높이: int, 색: int) -> bool {\n  let mut 바이트들 = 그림.바이트들\n  let 빨강 = (색 / 65536) % 256\n  let 초록 = (색 / 256) % 256\n  let 파랑 = 색 % 256\n  let mut 세로 = 위\n  while 세로 < 위 + 높이 {\n    let mut 위치 = 세로 * 3913 + 1 + 왼쪽 * 3\n    let 끝 = 위치 + 너비 * 3\n    while 위치 < 끝 {\n      바이트들.set(위치, 빨강); 바이트들.set(위치 + 1, 초록); 바이트들.set(위치 + 2, 파랑)\n      위치 = 위치 + 3\n    }\n    세로 = 세로 + 1\n  }\n  true\n}\n\nfunction 바이트그리기(그림: 주사그림, 바이트들: ByteBuffer, 왼쪽: int, 위: int, 행바이트: int, 칸크기: int, 팔레트: Array<int>) -> bool {\n  let mut 색인 = 0\n  while 색인 < 바이트들.length() {\n    let 행 = 색인 / 행바이트\n    let 바이트열 = 색인 % 행바이트\n    let 값 = 바이트들.get(색인)\n    let mut 부분 = 0\n    while 부분 < 4 {\n      let 숫자 = (값 / 거듭제곱이((3 - 부분) * 2)) % 4\n      사각채우기(그림, 왼쪽 + (바이트열 * 4 + 부분) * 칸크기, 위 + 행 * 칸크기, 칸크기, 칸크기, 팔레트[숫자])\n      부분 = 부분 + 1\n    }\n    색인 = 색인 + 1\n  }\n  true\n}\n\nfunction 글자그리기(그림: 주사그림, 글: string, 왼쪽: int, 위: int, 배율: int, 색: int) -> bool {\n  let 글자들 = 글.scalars()\n  let mut 글자색인 = 0\n  while 글자색인 < 글자들.length {\n    let 모양 = 픽셀글꼴(글자들[글자색인]).scalars()\n    let mut 행 = 0\n    while 행 < 5 {\n      let mut 열 = 0\n      while 열 < 3 {\n        if 모양[행 * 3 + 열] == \"1\" {\n          사각채우기(그림, 왼쪽 + 글자색인 * 4 * 배율 + 열 * 배율, 위 + 행 * 배율, 배율, 배율, 색)\n        }\n        열 = 열 + 1\n      }\n      행 = 행 + 1\n    }\n    글자색인 = 글자색인 + 1\n  }\n  true\n}\n\nfunction 책크롬그리기(그림: 주사그림) -> bool {\n  let 머리 = 그림.준비.머리\n  let 잉크 = 2959909\n  let 줄색 = 5458753\n  let 제목길이 = 머리.제목.scalars().length\n  if 제목길이 > 0 { 글자그리기(그림, 머리.제목, (1304 - 제목길이 * 12) / 2, 2, 3, 잉크) }\n  사각채우기(그림, 56, 19, 1192, 1, 줄색); 사각채우기(그림, 56, 21, 1192, 1, 줄색)\n  let 기림글 = \"LINES {머리.원본줄수} / NODES {그림.준비.요청.구조.노드들.length}\"\n  글자그리기(그림, 기림글, (1304 - 기림글.scalars().length * 8) / 2, 42, 2, 잉크)\n  사각채우기(그림, 56, 58, 1192, 1, 줄색); 사각채우기(그림, 56, 60, 1192, 1, 줄색)\n  let 꼬리위 = 머리.높이 - 64\n  사각채우기(그림, 56, 꼬리위 + 11, 1192, 1, 줄색); 사각채우기(그림, 56, 꼬리위 + 13, 1192, 1, 줄색)\n  let 쪽글 = \"{머리.쪽번호 + 1} / {머리.쪽수}\"\n  글자그리기(그림, 쪽글, (1304 - 쪽글.scalars().length * 12) / 2, 머리.높이 - 35, 3, 잉크)\n  let 등왼쪽 = if 머리.쪽번호 % 2 == 0 { 0 } else { 1300 }\n  사각채우기(그림, 등왼쪽, 64, 4, 머리.높이 - 64, 7365459)\n  for 장식가로 in [18, 1277] {\n    사각채우기(그림, 장식가로, 7, 9, 1, 8417112); 사각채우기(그림, 장식가로, 7, 1, 6, 8417112)\n    사각채우기(그림, 장식가로, 65, 9, 1, 8417112); 사각채우기(그림, 장식가로, 65, 1, 6, 8417112)\n    사각채우기(그림, 장식가로, 머리.높이 - 18, 9, 1, 8417112)\n    사각채우기(그림, 장식가로, 머리.높이 - 23, 1, 6, 8417112)\n  }\n  let 인장왼쪽 = 1247\n  let 인장위 = 머리.높이 - 49\n  let 인장색 = 12466730\n  사각채우기(그림, 인장왼쪽, 인장위, 36, 1, 인장색); 사각채우기(그림, 인장왼쪽, 인장위 + 35, 36, 1, 인장색)\n  사각채우기(그림, 인장왼쪽, 인장위, 1, 36, 인장색); 사각채우기(그림, 인장왼쪽 + 35, 인장위, 1, 36, 인장색)\n  let 해시글자 = 머리.세트해시.scalars()\n  let mut 비트 = 0\n  while 비트 < 16 {\n    let 바이트 = 십육진숫자(해시글자[(비트 / 8) * 2]) * 16 + 십육진숫자(해시글자[(비트 / 8) * 2 + 1])\n    if (바이트 / 거듭제곱이(7 - (비트 % 8))) % 2 == 1 {\n      사각채우기(그림, 인장왼쪽 + 5 + (비트 % 4) * 7, 인장위 + 5 + (비트 / 4) * 7, 5, 5, 인장색)\n    }\n    비트 = 비트 + 1\n  }\n  true\n}\n\nfunction 주사그림만들기(준비: 그림준비) -> 주사그림 {\n  let mut 바이트들 = ByteBuffer.allocate(3913 * 준비.머리.높이)\n  let mut 가로 = 0\n  while 가로 < 1304 {\n    let 위치 = 1 + 가로 * 3\n    바이트들.set(위치, 232); 바이트들.set(위치 + 1, 227); 바이트들.set(위치 + 2, 218)\n    가로 = 가로 + 1\n  }\n  let mut 세로 = 1\n  while 세로 < 준비.머리.높이 { 바이트들.copy(바이트들, 0, 세로 * 3913, 3913); 세로 = 세로 + 1 }\n  let 그림 = 주사그림 { 준비: 준비, 바이트들: 바이트들 }\n  바이트그리기(그림, 준비.머리바이트, 78, 24, 80, 2, 형식팔레트())\n  let 코드색 = 이미지팔레트(준비.머리.언어번호)\n  let mut 색인 = 0\n  while 색인 < 코드색.length { 사각채우기(그림, 804 + 색인 * 16, 24, 12, 12, 코드색[색인]); 색인 = 색인 + 1 }\n  let 표들 = [이역할팔레트(), 팔그물팔레트(), 범위씻김팔레트()]\n  let 왼쪽들 = [804, 884, 964]\n  let mut 표번호 = 0\n  while 표번호 < 3 {\n    색인 = 0\n    while 색인 < 표들[표번호].length {\n      사각채우기(그림, 왼쪽들[표번호] + 색인 * 8, 42, 6, 6, 표들[표번호][색인])\n      색인 = 색인 + 1\n    }\n    표번호 = 표번호 + 1\n  }\n  let 노드수 = 준비.노드끝 - 준비.노드시작\n  색인 = 0\n  while 색인 < 노드수 {\n    let 행 = 색인 / 12\n    let 열 = 색인 % 12\n    let 왼쪽 = 7 + 열 * 108\n    let 위 = 71 + 행 * 36\n    if 준비.수직씻김[색인] > 0 {\n      사각채우기(그림, 왼쪽 + 102, 위, 6, 30, 범위씻김팔레트()[작은값(준비.수직씻김[색인], 3) - 1])\n    }\n    if 준비.수평씻김[색인] > 0 {\n      사각채우기(그림, 왼쪽, 위 + 30, 102, 6, 범위씻김팔레트()[작은값(준비.수평씻김[색인], 3) - 1])\n    }\n    if 준비.이역할[색인] >= 0 {\n      let 역할왼쪽 = if 열 == 0 { 왼쪽 + 48 } else { 왼쪽 - 6 }\n      let 역할위 = if 열 == 0 { 위 - 6 } else { 위 + 12 }\n      사각채우기(그림, 역할왼쪽, 역할위, 6, 6, 이역할팔레트()[준비.이역할[색인]])\n    }\n    if 준비.팔그물[색인] >= 0 {\n      사각채우기(그림, 왼쪽 + 102, 위, 6, 6, 팔그물팔레트()[준비.팔그물[색인]])\n    }\n    let 코드 = 준비.요청.구조.노드들[준비.노드시작 + 색인].코드워드\n    let 숫자들 = [코드 / 64, (코드 / 8) % 8, 코드 % 8]\n    let 칸왼쪽들 = [0, 36, 72]\n    let mut 칸 = 0\n    while 칸 < 3 {\n      사각채우기(그림, 왼쪽 + 칸왼쪽들[칸], 위, 30, 30, 코드색[숫자들[칸]])\n      칸 = 칸 + 1\n    }\n    색인 = 색인 + 1\n  }\n  바이트그리기(그림, 준비.보호바이트, 4, 준비.머리.띠위, 162, 2, 띠팔레트())\n  if 준비.머리.크롬번호 == 1 { 책크롬그리기(그림) }\n  그림\n}\n\nfunction 고정디플레이트(그림: 주사그림) -> Result<Bytes, string> {\n  그림.바이트들.toBytes().deflateFixedCompress()\n}\n\nexport function 정규피엔지(준비: 그림준비) -> Result<Bytes, string> {\n  let 그림 = 주사그림만들기(준비)\n  let 압축 = ByteBuffer.fromBytes(그림.바이트들.toBytes().zlibFixedCompress()?)\n  let mut 헤더 = ByteBuffer.allocate(13)\n  헤더.set(0, 1304 / 16777216); 헤더.set(1, (1304 / 65536) % 256)\n  헤더.set(2, (1304 / 256) % 256); 헤더.set(3, 1304 % 256)\n  let 높이 = 준비.머리.높이\n  헤더.set(4, (높이 / 16777216) % 256); 헤더.set(5, (높이 / 65536) % 256)\n  헤더.set(6, (높이 / 256) % 256); 헤더.set(7, 높이 % 256)\n  헤더.set(8, 8); 헤더.set(9, 2); 헤더.set(10, 0); 헤더.set(11, 0); 헤더.set(12, 0)\n  let 아이헤더 = ByteBuffer.fromBytes(청크만들기(\"IHDR\".encodeUtf8(), 헤더.toBytes()))\n  let 아이데이터 = ByteBuffer.fromBytes(청크만들기(\"IDAT\".encodeUtf8(), 압축.toBytes()))\n  let 아이끝 = ByteBuffer.fromBytes(청크만들기(\"IEND\".encodeUtf8(), Bytes.fromHex(\"\")?))\n  let 서명 = ByteBuffer.fromBytes(Bytes.fromHex(\"89504e470d0a1a0a\")?)\n  let mut 결과 = ByteBuffer.allocate(서명.length() + 아이헤더.length() + 아이데이터.length() + 아이끝.length())\n  let mut 위치 = 0\n  결과.copy(서명, 0, 위치, 서명.length()); 위치 = 위치 + 서명.length()\n  결과.copy(아이헤더, 0, 위치, 아이헤더.length()); 위치 = 위치 + 아이헤더.length()\n  결과.copy(아이데이터, 0, 위치, 아이데이터.length()); 위치 = 위치 + 아이데이터.length()\n  결과.copy(아이끝, 0, 위치, 아이끝.length())\n  Ok(결과.toBytes())\n}\n",
      "sourceSha256": "8ec630bcdac3dffd9d5b8eec79bd5b902670e45a4663280eff2626813c674e0e"
    },
    {
      "path": "topaz/src/names.tpz",
      "language": "topaz",
      "bytes": 9566,
      "sha256": "bee378aa020d6c33c47cbe2ee59ebf8d6e7fc64679cc386149ea5280a562ae53",
      "content": "// Anonymous identifier names: reserved-name dispatch, short-name generation, and\n// validation of the allocation plans an image carries.\n\nimport std.json\nimport names.c { 씨예약이름 }\nimport names.coffeescript { 커피스크립트예약이름 }\nimport names.cpp { 씨플러스플러스예약이름 }\nimport names.csharp { 씨샵예약이름 }\nimport names.elisp { 이맥스리습예약이름 }\nimport names.elixir { 엘릭서예약이름 }\nimport names.elm { 엘름예약이름 }\nimport names.haskell { 하스켈예약이름 }\nimport names.java { 자바예약이름 }\nimport names.julia { 줄리아예약이름 }\nimport names.lua { 루아예약이름 }\nimport names.objc { 오브젝티브씨예약이름 }\nimport names.ocaml { 오캐멀예약이름 }\nimport names.r { 알예약이름 }\nimport names.rescript { 리스크립트예약이름 }\nimport names.ruby { 루비예약이름 }\nimport names.rust { 러스트예약이름 }\nimport names.solidity { 솔리디티예약이름 }\nimport names.zig { 지그예약이름 }\nimport printer_state { 준비된인쇄상태 }\nimport structure { 구조노드, 구조입력, 스칼라문자, 스칼라있음, 스칼라정수 }\nimport util { 문자열배열에있음 }\nimport wire { 널문자있음 }\n\nexport function 익명이름예약(언어번호: int, 이름: string) -> bool {\n  if 언어번호 == 5 { return 러스트예약이름(이름) }\n  if 언어번호 == 6 { return 자바예약이름(이름) }\n  if 언어번호 == 7 { return 씨예약이름(이름) }\n  if 언어번호 == 8 { return 씨플러스플러스예약이름(이름) }\n  if 언어번호 == 9 { return 씨샵예약이름(이름) }\n  if 언어번호 == 10 { return 루비예약이름(이름) }\n  if 언어번호 == 16 { return 엘릭서예약이름(이름) }\n  if 언어번호 == 17 { return 하스켈예약이름(이름) }\n  if 언어번호 == 18 { return 루아예약이름(이름) }\n  if 언어번호 == 19 { return 알예약이름(이름) }\n  if 언어번호 == 20 { return 줄리아예약이름(이름) }\n  if 언어번호 == 21 { return 오캐멀예약이름(이름) }\n  if 언어번호 == 22 { return 엘름예약이름(이름) }\n  if 언어번호 == 23 { return 리스크립트예약이름(이름) }\n  if 언어번호 == 24 { return 커피스크립트예약이름(이름) }\n  if 언어번호 == 25 { return 오브젝티브씨예약이름(이름) }\n  if 언어번호 == 26 { return 이맥스리습예약이름(이름) }\n  if 언어번호 == 27 { return 솔리디티예약이름(이름) }\n  if 언어번호 == 28 { return 지그예약이름(이름) }\n  false\n}\n\nfunction 러스트정수거듭제곱(밑: int, 지수: int) -> int {\n  let mut 결과 = 1\n  let mut 횟수 = 0\n  while 횟수 < 지수 {\n    결과 = 결과 * 밑\n    횟수 = 횟수 + 1\n  }\n  결과\n}\n\nexport function 러스트짧은이름(\n  언어번호: int,\n  최대폭: int,\n  보존이름들: Array<string>\n) -> string {\n  let 첫글자들 = (if 언어번호 == 27 {\n    \"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$\"\n  } else if 언어번호 == 28 {\n    \"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_\"\n  } else if 언어번호 == 25 {\n    \"abcdefghijklmnopqrstuvwxyz_\"\n  } else { \"abcdefghijklmnopqrstuvwxyz\" }).scalars()\n  let 뒷글자들 = (if 언어번호 == 27 {\n    \"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$0123456789\"\n  } else if 언어번호 == 28 {\n    \"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_0123456789\"\n  } else if 언어번호 == 26 {\n    \"abcdefghijklmnopqrstuvwxyz0123456789-\"\n  } else if 언어번호 == 25 {\n    \"abcdefghijklmnopqrstuvwxyz_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789\"\n  } else if 언어번호 == 23 {\n    \"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_\"\n  } else { \"abcdefghijklmnopqrstuvwxyz0123456789_\" }).scalars()\n  let mut 폭 = 1\n  while 폭 <= 최대폭 {\n    let 뒷용량 = 러스트정수거듭제곱(뒷글자들.length, 폭 - 1)\n    let 용량 = 첫글자들.length * 뒷용량\n    let mut 번호 = 0\n    while 번호 < 용량 {\n      let mut 나머지 = 번호\n      let 첫색인 = 나머지 / 뒷용량\n      나머지 = 나머지 % 뒷용량\n      let mut 후보 = 첫글자들[첫색인]\n      let mut 자리 = 폭 - 2\n      while 자리 >= 0 {\n        let 자리값 = 러스트정수거듭제곱(뒷글자들.length, 자리)\n        후보 = 후보 + 뒷글자들[나머지 / 자리값]\n        나머지 = 나머지 % 자리값\n        자리 = 자리 - 1\n      }\n      if !익명이름예약(언어번호, 후보) && !문자열배열에있음(보존이름들, 후보) {\n        return 후보\n      }\n      번호 = 번호 + 1\n    }\n    폭 = 폭 + 1\n  }\n  \"\"\n}\n\nexport record 익명식별자할당 {\n  anonymousName: string,\n  identifierClassId: int,\n  maximumScalarWidth: int\n}\n\nexport record 익명식별자할당계획 {\n  allocations: Array<익명식별자할당>,\n  languageId: string,\n  overflowClassIds: Array<int>,\n  reservedNames: Array<string>,\n  schemaVersion: string\n}\n\nfunction 익명할당계획언어(언어번호: int) -> string {\n  if 언어번호 == 11 { return \"php\" }\n  if 언어번호 == 14 { return \"scala\" }\n  if 언어번호 == 15 { return \"dart\" }\n  if 언어번호 == 17 { return \"haskell\" }\n  if 언어번호 == 18 { return \"lua\" }\n  if 언어번호 == 19 { return \"r\" }\n  if 언어번호 == 20 { return \"julia\" }\n  if 언어번호 == 22 { return \"elm\" }\n  if 언어번호 == 23 { return \"rescript\" }\n  if 언어번호 == 26 { return \"elisp\" }\n  if 언어번호 == 27 { return \"solidity\" }\n  if 언어번호 == 28 { return \"zig\" }\n  \"\"\n}\n\n// 이 언어들의 익명 이름은 이제 생산자가 한 번 결정해 이미지에 싣는다.\n// 인쇄기는 예약 집합이나 넘침을 다시 계산하지 않고 정규 계획을 검증한 뒤\n// 그대로 소비한다. 넘친 류가 분리 식별자로 남아 있으면 인쇄하지 않고 닫힌다.\nexport function 익명할당계획이름들(준비: 준비된인쇄상태) -> Result<Array<string>, string> {\n  let 언어 = 익명할당계획언어(준비.언어번호)\n  if 언어 == \"\" { return Ok(준비.익명이름들) }\n  let 인코드 = 스칼라문자(준비.구조.노드들[0], \"anonymousIdentifierAllocationPlanV1\")\n  if 인코드 == \"\" { return Err(\"익명 식별자 할당 계획이 없습니다\") }\n  let 계획 = json.parseAs<익명식별자할당계획>(인코드)?\n  if json.stringify(계획)? != 인코드 {\n    return Err(\"익명 식별자 할당 계획 JSON이 정규형이 아닙니다\")\n  }\n  if 계획.schemaVersion != \"codeimage.anonymous-identifier-allocation-plan.v1\" ||\n    계획.languageId != 언어 {\n    return Err(\"익명 식별자 할당 계획의 정체성이 틀립니다\")\n  }\n  let mut 이전예약 = \"\"\n  let mut 첫예약 = true\n  for 예약 in 계획.reservedNames {\n    if 예약 == \"\" || 널문자있음(예약) || (!첫예약 && 이전예약 >= 예약) {\n      return Err(\"익명 식별자 할당 계획의 예약 이름이 정규형이 아닙니다\")\n    }\n    이전예약 = 예약\n    첫예약 = false\n  }\n  let 류수 = 준비.익명이름들.length\n  let mut 계획이름들: Array<string> = []\n  let mut 최대폭들: Array<int> = []\n  let mut 덮임들: Array<bool> = []\n  let mut 사용이름들: Array<string> = []\n  let mut 류 = 0\n  while 류 < 류수 {\n    계획이름들.push(준비.익명이름들[류])\n    최대폭들.push(9007199254740991)\n    덮임들.push(false)\n    류 = 류 + 1\n  }\n  for 노드 in 준비.구조.노드들 {\n    if 노드.식별자있음 && 노드.식별자류번호 >= 0 && 노드.식별자류번호 < 류수 &&\n      스칼라정수(노드, \"startRow\") == 스칼라정수(노드, \"endRow\") {\n      let 폭 = if 스칼라있음(노드, \"identifierScalarColumnSpan\") {\n        스칼라정수(노드, \"identifierScalarColumnSpan\")\n      } else {\n        스칼라정수(노드, \"endColumn\") - 스칼라정수(노드, \"startColumn\")\n      }\n      if 폭 < 최대폭들[노드.식별자류번호] {\n        최대폭들[노드.식별자류번호] = 폭\n      }\n    }\n  }\n  let mut 이전류 = -1\n  for 할당 in 계획.allocations {\n    let 할당류 = 할당.identifierClassId\n    if 할당류 < 0 || 할당류 >= 류수 || 할당류 <= 이전류 || 덮임들[할당류] ||\n      할당.maximumScalarWidth != 최대폭들[할당류] ||\n      할당.anonymousName == \"\" || 널문자있음(할당.anonymousName) ||\n      할당.anonymousName.scalars().length > 할당.maximumScalarWidth ||\n      문자열배열에있음(계획.reservedNames, 할당.anonymousName) ||\n      문자열배열에있음(사용이름들, 할당.anonymousName) {\n      return Err(\"익명 식별자 할당 계획의 할당이 불가능합니다\")\n    }\n    계획이름들[할당류] = 할당.anonymousName\n    덮임들[할당류] = true\n    사용이름들.push(할당.anonymousName)\n    이전류 = 할당류\n  }\n  이전류 = -1\n  for 넘침류 in 계획.overflowClassIds {\n    if 넘침류 < 0 || 넘침류 >= 류수 || 넘침류 <= 이전류 || 덮임들[넘침류] {\n      return Err(\"익명 식별자 할당 계획의 넘침 집합이 정규형이 아닙니다\")\n    }\n    // 이 계획의 류는 분리 식별자 발생에서 유도된다. 따라서 넘친 류가\n    // 여기에 남았다는 것은 인쇄기가 넓은 별칭을 내지 말고 거부할 경우다.\n    return Err(\"넘친 익명 식별자 류는 인쇄할 수 없습니다\")\n  }\n  류 = 0\n  while 류 < 류수 {\n    if !덮임들[류] { return Err(\"익명 식별자 할당 계획이 류를 덮지 않습니다\") }\n    류 = 류 + 1\n  }\n  Ok(계획이름들)\n}\n",
      "sourceSha256": "bee378aa020d6c33c47cbe2ee59ebf8d6e7fc64679cc386149ea5280a562ae53"
    },
    {
      "path": "topaz/src/names/ascii.tpz",
      "language": "topaz",
      "bytes": 1037,
      "sha256": "fb20725ddcab09469e15dff739403738e66da273c8bf88c8e7c6d0e0582df8cb",
      "content": "// ASCII identifier scanning shared by the anonymous name rules.\n\nimport print { 글자합치기 }\nimport util { 문자열배열에있음 }\n\nexport function 아스키식별자시작(글자: string) -> bool {\n  문자열배열에있음(\n    \"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_\".scalars(),\n    글자\n  )\n}\n\nexport function 아스키식별자계속(글자: string) -> bool {\n  아스키식별자시작(글자) ||\n    문자열배열에있음(\"0123456789\".scalars(), 글자)\n}\n\nexport function 아스키이름들(글: string) -> Array<string> {\n  let 글자들 = 글.scalars()\n  let mut 이름들: Array<string> = []\n  let mut 색인 = 0\n  while 색인 < 글자들.length {\n    if !아스키식별자시작(글자들[색인]) {\n      색인 = 색인 + 1\n      continue\n    }\n    let 시작 = 색인\n    색인 = 색인 + 1\n    while 색인 < 글자들.length && 아스키식별자계속(글자들[색인]) {\n      색인 = 색인 + 1\n    }\n    이름들.push(글자합치기(글자들, 시작, 색인))\n  }\n  이름들\n}\n",
      "sourceSha256": "fb20725ddcab09469e15dff739403738e66da273c8bf88c8e7c6d0e0582df8cb"
    },
    {
      "path": "topaz/src/names/c.tpz",
      "language": "topaz",
      "bytes": 2584,
      "sha256": "850eecff1e728fd054ede1fa800e203061b72817c8658147bc940b58523cb81a",
      "content": "// C reserved words and preprocessor-resident names that anonymous names avoid.\n\nimport names.ascii { 아스키식별자계속, 아스키식별자시작 }\nimport print { 글자합치기 }\nimport util { 문자열배열에있음 }\n\nexport function 씨예약이름(이름: string) -> bool {\n  문자열배열에있음([\n    \"_Alignas\", \"_Alignof\", \"_Atomic\", \"_Bool\", \"_Complex\", \"_Generic\",\n    \"_Imaginary\", \"_Noreturn\", \"_Static_assert\", \"_Thread_local\", \"alignas\",\n    \"alignof\", \"auto\", \"bool\", \"break\", \"case\", \"char\", \"const\",\n    \"constexpr\", \"continue\", \"default\", \"do\", \"double\", \"else\", \"enum\",\n    \"extern\", \"false\", \"float\", \"for\", \"goto\", \"if\", \"inline\", \"int\",\n    \"long\", \"nullptr\", \"register\", \"restrict\", \"return\", \"short\", \"signed\",\n    \"sizeof\", \"static\", \"static_assert\", \"struct\", \"switch\", \"thread_local\",\n    \"true\", \"typedef\", \"typeof\", \"typeof_unqual\", \"union\", \"unsigned\", \"void\",\n    \"volatile\", \"while\"\n  ], 이름)\n}\n\nexport function 씨전처리예약이름들(글: string) -> Array<string> {\n  let 글자들 = 글.scalars()\n  let mut 이름들: Array<string> = []\n  let mut 색인 = 0\n  while 색인 < 글자들.length {\n    if 글자들[색인] == \"/\" && 색인 + 1 < 글자들.length &&\n      글자들[색인 + 1] == \"/\" {\n      색인 = 색인 + 2\n      while 색인 < 글자들.length && 글자들[색인] != \"\\n\" &&\n        글자들[색인] != \"\\r\" {\n        색인 = 색인 + 1\n      }\n      continue\n    }\n    if 글자들[색인] == \"/\" && 색인 + 1 < 글자들.length &&\n      글자들[색인 + 1] == \"*\" {\n      색인 = 색인 + 2\n      while 색인 + 1 < 글자들.length &&\n        !(글자들[색인] == \"*\" && 글자들[색인 + 1] == \"/\") {\n        색인 = 색인 + 1\n      }\n      if 색인 + 1 < 글자들.length { 색인 = 색인 + 2 }\n      continue\n    }\n    if 글자들[색인] == \"\\\"\" || 글자들[색인] == \"'\" {\n      let 닫개 = 글자들[색인]\n      색인 = 색인 + 1\n      while 색인 < 글자들.length {\n        if 글자들[색인] == \"\\\\\" {\n          색인 = 색인 + 2\n          continue\n        }\n        if 글자들[색인] == 닫개 {\n          색인 = 색인 + 1\n          break\n        }\n        색인 = 색인 + 1\n      }\n      continue\n    }\n    if 아스키식별자시작(글자들[색인]) {\n      let 시작 = 색인\n      색인 = 색인 + 1\n      while 색인 < 글자들.length && 아스키식별자계속(글자들[색인]) {\n        색인 = 색인 + 1\n      }\n      이름들.push(글자합치기(글자들, 시작, 색인))\n      continue\n    }\n    색인 = 색인 + 1\n  }\n  이름들\n}\n",
      "sourceSha256": "850eecff1e728fd054ede1fa800e203061b72817c8658147bc940b58523cb81a"
    },
    {
      "path": "topaz/src/names/coffeescript.tpz",
      "language": "topaz",
      "bytes": 2126,
      "sha256": "9bc3d2f7bce4d6a13e144ce21868a9ec4d0db045c8aa83c0b2ebd546895964ee",
      "content": "// CoffeeScript reserved words and interpolation names that anonymous names avoid.\n\nimport names.ascii { 아스키식별자계속, 아스키식별자시작 }\nimport print { 글자합치기 }\nimport util { 문자열배열에있음 }\n\nexport function 커피스크립트예약이름(이름: string) -> bool {\n  문자열배열에있음([\n    \"and\", \"arguments\", \"await\", \"break\", \"by\", \"catch\", \"class\",\n    \"continue\", \"debugger\", \"delete\", \"do\", \"else\", \"eval\", \"extends\",\n    \"false\", \"finally\", \"for\", \"from\", \"function\", \"if\", \"in\",\n    \"instanceof\", \"is\", \"isnt\", \"loop\", \"new\", \"no\", \"not\", \"null\",\n    \"of\", \"off\", \"on\", \"or\", \"own\", \"return\", \"super\", \"switch\",\n    \"then\", \"this\", \"throw\", \"true\", \"try\", \"typeof\", \"undefined\",\n    \"unless\", \"until\", \"when\", \"while\", \"yes\", \"yield\"\n  ], 이름)\n}\n\n// CoffeeScript 보간 본문은 실행 코드다. 바깥 리터럴의 #{...} 구간만\n// 읽어 그 안의 ASCII 식별자를 예약한다. 중첩 보간은 중괄호 깊이로\n// 함께 들어오며, 이 보수적 집합은 살아 있는 이름을 별칭이 가리는\n// 방향만 막는다.\nexport function 커피스크립트보간이름들(글: string) -> Array<string> {\n  let 글자들 = 글.scalars()\n  let mut 이름들: Array<string> = []\n  let mut 깊이 = 0\n  let mut 색인 = 0\n  while 색인 < 글자들.length {\n    if 색인 + 1 < 글자들.length && 글자들[색인] == \"#\" &&\n      글자들[색인 + 1] == \"\\{\" {\n      깊이 = 깊이 + 1\n      색인 = 색인 + 2\n      continue\n    }\n    if 깊이 > 0 && 글자들[색인] == \"\\{\" {\n      깊이 = 깊이 + 1\n      색인 = 색인 + 1\n      continue\n    }\n    if 깊이 > 0 && 글자들[색인] == \"\\}\" {\n      깊이 = 깊이 - 1\n      색인 = 색인 + 1\n      continue\n    }\n    if 깊이 > 0 && 아스키식별자시작(글자들[색인]) {\n      let 시작 = 색인\n      색인 = 색인 + 1\n      while 색인 < 글자들.length && 아스키식별자계속(글자들[색인]) {\n        색인 = 색인 + 1\n      }\n      이름들.push(글자합치기(글자들, 시작, 색인))\n      continue\n    }\n    색인 = 색인 + 1\n  }\n  이름들\n}\n",
      "sourceSha256": "9bc3d2f7bce4d6a13e144ce21868a9ec4d0db045c8aa83c0b2ebd546895964ee"
    },
    {
      "path": "topaz/src/names/cpp.tpz",
      "language": "topaz",
      "bytes": 1298,
      "sha256": "34d67de55d2f4f642fedd5e549ef28f35ff32a8f6e2e0d99318b969f13028975",
      "content": "// C++ reserved words that anonymous names avoid.\n\nimport util { 문자열배열에있음 }\n\nexport function 씨플러스플러스예약이름(이름: string) -> bool {\n  문자열배열에있음([\n    \"alignas\", \"alignof\", \"and\", \"and_eq\", \"asm\", \"atomic_cancel\",\n    \"atomic_commit\", \"atomic_noexcept\", \"auto\", \"bitand\", \"bitor\", \"bool\",\n    \"break\", \"case\", \"catch\", \"char\", \"char8_t\", \"char16_t\", \"char32_t\",\n    \"class\", \"compl\", \"concept\", \"const\", \"consteval\", \"constexpr\",\n    \"constinit\", \"const_cast\", \"continue\", \"co_await\", \"co_return\", \"co_yield\",\n    \"decltype\", \"default\", \"delete\", \"do\", \"double\", \"dynamic_cast\", \"else\",\n    \"enum\", \"explicit\", \"export\", \"extern\", \"false\", \"float\", \"for\", \"friend\",\n    \"goto\", \"if\", \"inline\", \"int\", \"long\", \"mutable\", \"namespace\", \"new\",\n    \"noexcept\", \"not\", \"not_eq\", \"nullptr\", \"operator\", \"or\", \"or_eq\",\n    \"private\", \"protected\", \"public\", \"reflexpr\", \"register\", \"reinterpret_cast\",\n    \"requires\", \"return\", \"short\", \"signed\", \"sizeof\", \"static\", \"static_assert\",\n    \"static_cast\", \"struct\", \"switch\", \"synchronized\", \"template\", \"this\",\n    \"thread_local\", \"throw\", \"true\", \"try\", \"typedef\", \"typeid\", \"typename\",\n    \"union\", \"unsigned\", \"using\", \"virtual\", \"void\", \"volatile\", \"wchar_t\",\n    \"while\", \"xor\", \"xor_eq\"\n  ], 이름)\n}\n",
      "sourceSha256": "34d67de55d2f4f642fedd5e549ef28f35ff32a8f6e2e0d99318b969f13028975"
    },
    {
      "path": "topaz/src/names/csharp.tpz",
      "language": "topaz",
      "bytes": 1342,
      "sha256": "312a5a496d44de9418e5b86a405e41264ddcad4c1ba0f8cd492dd3ee7aeb6fd6",
      "content": "// C# reserved words that anonymous names avoid.\n\nimport util { 문자열배열에있음 }\n\nexport function 씨샵예약이름(이름: string) -> bool {\n  문자열배열에있음([\n    \"abstract\", \"and\", \"as\", \"ascending\", \"async\", \"await\", \"base\", \"bool\",\n    \"break\", \"by\", \"byte\", \"case\", \"catch\", \"char\", \"checked\", \"class\",\n    \"const\", \"continue\", \"decimal\", \"default\", \"delegate\", \"descending\", \"do\",\n    \"double\", \"dynamic\", \"else\", \"enum\", \"equals\", \"event\", \"explicit\",\n    \"extern\", \"false\", \"file\", \"finally\", \"fixed\", \"float\", \"for\", \"foreach\",\n    \"from\", \"get\", \"global\", \"goto\", \"group\", \"if\", \"implicit\", \"in\", \"init\",\n    \"int\", \"interface\", \"internal\", \"into\", \"is\", \"join\", \"let\", \"lock\",\n    \"long\", \"managed\", \"nameof\", \"new\", \"nint\", \"not\", \"notnull\", \"nuint\",\n    \"null\", \"object\", \"on\", \"operator\", \"or\", \"orderby\", \"out\", \"override\",\n    \"params\", \"partial\", \"private\", \"protected\", \"public\", \"readonly\", \"record\",\n    \"ref\", \"remove\", \"required\", \"return\", \"sbyte\", \"scoped\", \"sealed\",\n    \"select\", \"set\", \"short\", \"sizeof\", \"stackalloc\", \"static\", \"string\",\n    \"struct\", \"switch\", \"this\", \"throw\", \"true\", \"try\", \"typeof\", \"uint\",\n    \"ulong\", \"unchecked\", \"unmanaged\", \"unsafe\", \"ushort\", \"using\", \"value\",\n    \"var\", \"virtual\", \"void\", \"volatile\", \"when\", \"where\", \"while\", \"with\",\n    \"yield\"\n  ], 이름)\n}\n",
      "sourceSha256": "312a5a496d44de9418e5b86a405e41264ddcad4c1ba0f8cd492dd3ee7aeb6fd6"
    },
    {
      "path": "topaz/src/names/elisp.tpz",
      "language": "topaz",
      "bytes": 977,
      "sha256": "24a2cf45b8ba84f41412a398bb25ddd869dcdeadb363c6fcc8c809f755110ac8",
      "content": "// Emacs Lisp reserved symbols and interned symbol spellings for anonymous names.\n\nimport util { 문자열배열에있음 }\n\nexport function 이맥스리습예약이름(이름: string) -> bool {\n  문자열배열에있음([\n    \"nil\", \"t\", \"&allow-other-keys\", \"&aux\", \"&body\", \"&environment\",\n    \"&key\", \"&optional\", \"&rest\", \"&whole\", \"and\", \"catch\", \"cond\",\n    \"condition-case\", \"defconst\", \"defcustom\", \"defmacro\", \"defun\",\n    \"defvar\", \"function\", \"if\", \"interactive\", \"lambda\", \"let\", \"let*\",\n    \"or\", \"progn\", \"prog1\", \"prog2\", \"quote\", \"setq\", \"setq-default\",\n    \"unwind-protect\", \"while\"\n  ], 이름)\n}\n\nexport function 이맥스리습인턴이름(글: string) -> string {\n  let 글자들 = 글.scalars()\n  let mut 이름 = \"\"\n  let mut 색인 = 0\n  while 색인 < 글자들.length {\n    if 글자들[색인] == \"\\\\\" && 색인 + 1 < 글자들.length {\n      색인 = 색인 + 1\n    }\n    이름 = 이름 + 글자들[색인]\n    색인 = 색인 + 1\n  }\n  이름\n}\n",
      "sourceSha256": "24a2cf45b8ba84f41412a398bb25ddd869dcdeadb363c6fcc8c809f755110ac8"
    },
    {
      "path": "topaz/src/names/elixir.tpz",
      "language": "topaz",
      "bytes": 630,
      "sha256": "9bd5dde91d63d0a61e80dc75de749541c67b1b14a86f2b0ffcaf75120c95cf71",
      "content": "// Elixir reserved words that anonymous names avoid.\n\nimport util { 문자열배열에있음 }\n\nexport function 엘릭서예약이름(이름: string) -> bool {\n  문자열배열에있음([\n    \"after\", \"and\", \"catch\", \"cond\", \"def\", \"defdelegate\", \"defexception\",\n    \"defguard\", \"defguardp\", \"defimpl\", \"defmacro\", \"defmacrop\", \"defmodule\",\n    \"defoverridable\", \"defp\", \"defprotocol\", \"defstruct\", \"do\", \"else\", \"end\",\n    \"false\", \"fn\", \"for\", \"if\", \"in\", \"nil\", \"not\", \"or\", \"quote\", \"raise\",\n    \"receive\", \"rescue\", \"super\", \"throw\", \"true\", \"try\", \"unless\", \"unquote\",\n    \"unquote_splicing\", \"when\", \"with\"\n  ], 이름)\n}\n",
      "sourceSha256": "9bd5dde91d63d0a61e80dc75de749541c67b1b14a86f2b0ffcaf75120c95cf71"
    },
    {
      "path": "topaz/src/names/elm.tpz",
      "language": "topaz",
      "bytes": 359,
      "sha256": "4858bfbe3536628443870aabb3045db26cdc7c0b1b5582259b1b060157f3217c",
      "content": "// Elm reserved words that anonymous names avoid.\n\nimport util { 문자열배열에있음 }\n\nexport function 엘름예약이름(이름: string) -> bool {\n  문자열배열에있음([\n    \"alias\", \"as\", \"case\", \"else\", \"exposing\", \"if\", \"import\", \"in\",\n    \"infix\", \"infixl\", \"infixr\", \"let\", \"module\", \"of\", \"port\", \"then\",\n    \"type\", \"where\"\n  ], 이름)\n}\n",
      "sourceSha256": "4858bfbe3536628443870aabb3045db26cdc7c0b1b5582259b1b060157f3217c"
    },
    {
      "path": "topaz/src/names/haskell.tpz",
      "language": "topaz",
      "bytes": 595,
      "sha256": "c32daab3ac36bca4c05b6d6a05d2c221d069c67543c2a3c0f782589ad9b31cf1",
      "content": "// Haskell reserved words that anonymous names avoid.\n\nimport util { 문자열배열에있음 }\n\nexport function 하스켈예약이름(이름: string) -> bool {\n  문자열배열에있음([\n    \"anyclass\", \"as\", \"by\", \"case\", \"class\", \"data\", \"default\", \"deriving\",\n    \"do\", \"else\", \"family\", \"foreign\", \"forall\", \"group\", \"hiding\", \"if\",\n    \"import\", \"in\", \"infix\", \"infixl\", \"infixr\", \"instance\", \"interruptible\",\n    \"let\", \"mdo\", \"module\", \"newtype\", \"of\", \"pattern\", \"qualified\", \"role\",\n    \"safe\", \"static\", \"stock\", \"then\", \"type\", \"unsafe\", \"using\", \"via\",\n    \"where\"\n  ], 이름)\n}\n",
      "sourceSha256": "c32daab3ac36bca4c05b6d6a05d2c221d069c67543c2a3c0f782589ad9b31cf1"
    },
    {
      "path": "topaz/src/names/java.tpz",
      "language": "topaz",
      "bytes": 1984,
      "sha256": "95adc31b8e2310a5d473eab478b15dc2cd6ef908184a99f29004216babf31a93",
      "content": "// Java reserved words and identifier-ignorable code points for anonymous names.\n\nimport util { 문자열배열에있음 }\n\nexport function 자바예약이름(이름: string) -> bool {\n  문자열배열에있음([\n    \"abstract\", \"assert\", \"boolean\", \"break\", \"byte\", \"case\", \"catch\",\n    \"char\", \"class\", \"const\", \"continue\", \"default\", \"do\", \"double\",\n    \"else\", \"enum\", \"exports\", \"extends\", \"false\", \"final\", \"finally\",\n    \"float\", \"for\", \"goto\", \"if\", \"implements\", \"import\", \"instanceof\",\n    \"int\", \"interface\", \"long\", \"module\", \"native\", \"new\", \"non-sealed\",\n    \"null\", \"open\", \"opens\", \"package\", \"permits\", \"private\", \"protected\",\n    \"provides\", \"public\", \"record\", \"requires\", \"return\", \"sealed\", \"short\",\n    \"static\", \"strictfp\", \"super\", \"switch\", \"synchronized\", \"this\", \"throw\",\n    \"throws\", \"to\", \"transient\", \"true\", \"try\", \"uses\", \"var\", \"void\",\n    \"volatile\", \"when\", \"while\", \"with\", \"yield\", \"_\"\n  ], 이름)\n}\n\nfunction 자바식별자무시코드(코드: int) -> bool {\n  (코드 >= 0 && 코드 <= 8) || (코드 >= 14 && 코드 <= 27) ||\n    (코드 >= 127 && 코드 <= 159) || 코드 == 173 ||\n    (코드 >= 1536 && 코드 <= 1541) || 코드 == 1564 || 코드 == 1757 ||\n    코드 == 1807 || 코드 == 2274 || 코드 == 6158 ||\n    (코드 >= 8203 && 코드 <= 8207) || (코드 >= 8234 && 코드 <= 8238) ||\n    (코드 >= 8288 && 코드 <= 8292) || (코드 >= 8294 && 코드 <= 8303) ||\n    코드 == 65279 || (코드 >= 65529 && 코드 <= 65531) ||\n    코드 == 69821 || 코드 == 69837 ||\n    (코드 >= 78896 && 코드 <= 78904) ||\n    (코드 >= 113824 && 코드 <= 113827) ||\n    (코드 >= 119155 && 코드 <= 119162) || 코드 == 917505 ||\n    (코드 >= 917536 && 코드 <= 917631)\n}\n\nexport function 자바정규식별자(이름: string) -> string {\n  let mut 결과 = \"\"\n  for 글자 in 이름.scalars() {\n    let 코드 = 글자.codePointAt(0) ?? 0\n    if !자바식별자무시코드(코드) { 결과 = 결과 + 글자 }\n  }\n  결과\n}\n",
      "sourceSha256": "95adc31b8e2310a5d473eab478b15dc2cd6ef908184a99f29004216babf31a93"
    },
    {
      "path": "topaz/src/names/julia.tpz",
      "language": "topaz",
      "bytes": 563,
      "sha256": "0f16abb84ff9f1de93b1711e486378f6bef878ae26b27f033bd83a13a5b1c721",
      "content": "// Julia reserved words that anonymous names avoid.\n\nimport util { 문자열배열에있음 }\n\nexport function 줄리아예약이름(이름: string) -> bool {\n  문자열배열에있음([\n    \"abstract\", \"baremodule\", \"begin\", \"break\", \"catch\", \"const\",\n    \"continue\", \"do\", \"else\", \"elseif\", \"end\", \"export\", \"false\",\n    \"finally\", \"for\", \"function\", \"global\", \"if\", \"import\", \"let\",\n    \"local\", \"macro\", \"module\", \"mutable\", \"outer\", \"primitive\",\n    \"public\", \"quote\", \"return\", \"struct\", \"true\", \"try\", \"type\",\n    \"using\", \"where\", \"while\"\n  ], 이름)\n}\n",
      "sourceSha256": "0f16abb84ff9f1de93b1711e486378f6bef878ae26b27f033bd83a13a5b1c721"
    },
    {
      "path": "topaz/src/names/kotlin.tpz",
      "language": "topaz",
      "bytes": 374,
      "sha256": "f6f45078f6a07b8d19d5764c8999170d69c88fbbcd865fca86077c4bbc34dd50",
      "content": "// Kotlin backquoted identifier spellings for anonymous names.\n\nimport print { 글자합치기 }\n\nexport function 코틀린정규식별자(이름: string) -> string {\n  let 글자들 = 이름.scalars()\n  if 글자들.length >= 2 && 글자들[0] == \"`\" && 글자들[글자들.length - 1] == \"`\" {\n    글자합치기(글자들, 1, 글자들.length - 1)\n  } else { 이름 }\n}\n",
      "sourceSha256": "f6f45078f6a07b8d19d5764c8999170d69c88fbbcd865fca86077c4bbc34dd50"
    },
    {
      "path": "topaz/src/names/lua.tpz",
      "language": "topaz",
      "bytes": 387,
      "sha256": "9e4bb9bf9c22234abe55620dd4f8f45672d0e52a0363249507c7717de4ffd896",
      "content": "// Lua reserved words that anonymous names avoid.\n\nimport util { 문자열배열에있음 }\n\nexport function 루아예약이름(이름: string) -> bool {\n  문자열배열에있음([\n    \"and\", \"break\", \"do\", \"else\", \"elseif\", \"end\", \"false\", \"for\",\n    \"function\", \"goto\", \"if\", \"in\", \"local\", \"nil\", \"not\", \"or\",\n    \"repeat\", \"return\", \"then\", \"true\", \"until\", \"while\"\n  ], 이름)\n}\n",
      "sourceSha256": "9e4bb9bf9c22234abe55620dd4f8f45672d0e52a0363249507c7717de4ffd896"
    },
    {
      "path": "topaz/src/names/objc.tpz",
      "language": "topaz",
      "bytes": 4658,
      "sha256": "338815016bbd8ff5312bda9f2789a7d3663ae8446419d7297c30824b29a59817",
      "content": "// Objective-C reserved words, identifier spellings, and preprocessor-resident\n// names for anonymous names.\n\nimport objc_xid { 오브젝티브씨식별자계속, 오브젝티브씨식별자시작 }\nimport print { 글자합치기 }\nimport util { 문자열배열에있음 }\n\nexport function 오브젝티브씨예약이름(이름: string) -> bool {\n  문자열배열에있음([\n    \"_Bool\", \"_Complex\", \"_Imaginary\", \"asm\", \"auto\", \"bool\", \"break\",\n    \"bycopy\", \"byref\", \"case\", \"char\", \"Class\", \"const\", \"continue\",\n    \"default\", \"do\", \"double\", \"else\", \"enum\", \"extern\", \"false\", \"float\",\n    \"for\", \"goto\", \"id\", \"if\", \"IMP\", \"in\", \"inout\", \"instancetype\", \"int\",\n    \"long\", \"nil\", \"NO\", \"NULL\", \"oneway\", \"out\", \"Protocol\", \"register\",\n    \"restrict\", \"return\", \"SEL\", \"self\", \"short\", \"signed\", \"sizeof\", \"static\",\n    \"struct\", \"super\", \"switch\", \"typedef\", \"typeof\", \"union\", \"unsigned\",\n    \"void\", \"volatile\", \"while\", \"YES\"\n  ], 이름)\n}\n\n// C 전처리 원문은 이미지에 남으므로 그 안의 식별자는 익명 별칭이\n// 덮어쓸 수 없다. 댓글과 문자열/문자 리터럴은 이름 공간이 아니어서\n// 건너뛰고, 별칭과 충돌할 수 있는 ASCII 식별자만 독립적으로 읽는다.\nfunction 오브젝티브씨이어진본문(글: string) -> string {\n  let 글자들 = 글.scalars()\n  let mut 결과 = \"\"\n  let mut 색인 = 0\n  while 색인 < 글자들.length {\n    if 글자들[색인] == \"\\\\\" {\n      let mut 끝 = 색인 + 1\n      while 끝 < 글자들.length && (글자들[끝] == \" \" || 글자들[끝] == \"\\t\" ||\n        글자들[끝].codePointAt(0) == Some(11) || 글자들[끝].codePointAt(0) == Some(12)) {\n        끝 = 끝 + 1\n      }\n      if 끝 < 글자들.length && (글자들[끝] == \"\\r\" || 글자들[끝] == \"\\n\") {\n        let 줄끝 = 글자들[끝]\n        끝 = 끝 + 1\n        if 끝 < 글자들.length && ((줄끝 == \"\\r\" && 글자들[끝] == \"\\n\") ||\n          (줄끝 == \"\\n\" && 글자들[끝] == \"\\r\")) { 끝 = 끝 + 1 }\n        색인 = 끝\n        continue\n      }\n    }\n    결과 = 결과 + 글자들[색인]\n    색인 = 색인 + 1\n  }\n  결과\n}\n\n// Returns the complete UCN width, or zero when this is not a UCN spelling.\nfunction 오브젝티브씨보편문자폭(글자들: Array<string>, 색인: int) -> int {\n  if 색인 + 1 >= 글자들.length || 글자들[색인] != \"\\\\\" { return 0 }\n  let 폭 = if 글자들[색인 + 1] == \"u\" { 6 }\n    else if 글자들[색인 + 1] == \"U\" { 10 } else { 0 }\n  if 폭 == 0 || 색인 + 폭 > 글자들.length { return 0 }\n  let mut 자리 = 색인 + 2\n  while 자리 < 색인 + 폭 {\n    if 오브젝티브씨십육진값(글자들[자리]) < 0 { return 0 }\n    자리 = 자리 + 1\n  }\n  폭\n}\n\nfunction 오브젝티브씨십육진값(글자: string) -> int {\n  let 값 = 글자.codePointAt(0) ?? 0\n  if 값 >= 48 && 값 <= 57 { 값 - 48 }\n  else if 값 >= 65 && 값 <= 70 { 값 - 55 }\n  else if 값 >= 97 && 값 <= 102 { 값 - 87 }\n  else { -1 }\n}\n\nexport function 오브젝티브씨정규식별자(글: string) -> string {\n  let 글자들 = 오브젝티브씨이어진본문(글).scalars()\n  let mut 결과 = \"\"\n  let mut 색인 = 0\n  while 색인 < 글자들.length {\n    let 폭 = 오브젝티브씨보편문자폭(글자들, 색인)\n    if 폭 > 0 {\n      let mut 값 = 0\n      let mut 자리 = 색인 + 2\n      while 자리 < 색인 + 폭 {\n        값 = 값 * 16 + 오브젝티브씨십육진값(글자들[자리])\n        자리 = 자리 + 1\n      }\n      결과 = 결과 + (값.toCodePoint() ?? 글자합치기(글자들, 색인, 색인 + 폭))\n      색인 = 색인 + 폭\n    } else {\n      결과 = 결과 + 글자들[색인]\n      색인 = 색인 + 1\n    }\n  }\n  결과\n}\n\nexport function 오브젝티브씨전처리이름들(글: string) -> Array<string> {\n  let 글자들 = 오브젝티브씨이어진본문(글).scalars()\n  let mut 이름들: Array<string> = []\n  let mut 색인 = 0\n  while 색인 < 글자들.length {\n    let 폭 = 오브젝티브씨보편문자폭(글자들, 색인)\n    if 폭 == 0 && !오브젝티브씨식별자시작(글자들[색인].codePointAt(0) ?? 0) {\n      색인 = 색인 + 1\n      continue\n    }\n    let 시작 = 색인\n    색인 = 색인 + (if 폭 > 0 { 폭 } else { 1 })\n    while 색인 < 글자들.length {\n      let 다음폭 = 오브젝티브씨보편문자폭(글자들, 색인)\n      if 다음폭 == 0 && !오브젝티브씨식별자계속(글자들[색인].codePointAt(0) ?? 0) { break }\n      색인 = 색인 + (if 다음폭 > 0 { 다음폭 } else { 1 })\n    }\n    이름들.push(오브젝티브씨정규식별자(글자합치기(글자들, 시작, 색인)))\n  }\n  이름들\n}\n",
      "sourceSha256": "338815016bbd8ff5312bda9f2789a7d3663ae8446419d7297c30824b29a59817"
    },
    {
      "path": "topaz/src/names/ocaml.tpz",
      "language": "topaz",
      "bytes": 716,
      "sha256": "a743fc30f3d515389943edae9be33fd5618a2195cbb09d02f1c105f4fd980b56",
      "content": "// OCaml reserved words that anonymous names avoid.\n\nimport util { 문자열배열에있음 }\n\nexport function 오캐멀예약이름(이름: string) -> bool {\n  문자열배열에있음([\n    \"and\", \"as\", \"assert\", \"asr\", \"begin\", \"class\", \"constraint\",\n    \"do\", \"done\", \"downto\", \"else\", \"end\", \"exception\", \"external\",\n    \"false\", \"for\", \"fun\", \"function\", \"functor\", \"if\", \"in\",\n    \"include\", \"inherit\", \"initializer\", \"land\", \"lazy\", \"let\",\n    \"lor\", \"lsl\", \"lsr\", \"lxor\", \"match\", \"method\", \"mod\",\n    \"module\", \"mutable\", \"new\", \"nonrec\", \"object\", \"of\", \"open\",\n    \"or\", \"private\", \"rec\", \"sig\", \"struct\", \"then\", \"to\", \"true\",\n    \"try\", \"type\", \"val\", \"virtual\", \"when\", \"while\", \"with\"\n  ], 이름)\n}\n",
      "sourceSha256": "a743fc30f3d515389943edae9be33fd5618a2195cbb09d02f1c105f4fd980b56"
    },
    {
      "path": "topaz/src/names/python.tpz",
      "language": "topaz",
      "bytes": 3395,
      "sha256": "7265a9692dc7bacf89350bea0456eb592c2e03e9b3cad40e8257b5a8e38f3986",
      "content": "// Python name-suggestion distance: a candidate anonymous name is skipped when\n// Python would offer it as a suggestion for a name the program can see.\n\nimport std.bytes { Bytes }\nimport util { 작은값 }\n\nfunction 파이썬제안대치비용(왼쪽: int, 오른쪽: int) -> int {\n  if 왼쪽 % 32 != 오른쪽 % 32 { return 2 }\n  if 왼쪽 == 오른쪽 { return 0 }\n  let 접은왼쪽 = if 왼쪽 >= 65 && 왼쪽 <= 90 { 왼쪽 + 32 } else { 왼쪽 }\n  let 접은오른쪽 = if 오른쪽 >= 65 && 오른쪽 <= 90 { 오른쪽 + 32 } else { 오른쪽 }\n  if 접은왼쪽 == 접은오른쪽 { 1 } else { 2 }\n}\n\nfunction 파이썬제안편집비용(왼쪽값: Bytes, 오른쪽값: Bytes, 최대비용: int) -> int {\n  let mut 왼쪽시작 = 0\n  let mut 오른쪽시작 = 0\n  let mut 왼쪽끝 = 왼쪽값.length()\n  let mut 오른쪽끝 = 오른쪽값.length()\n  while 왼쪽시작 < 왼쪽끝 && 오른쪽시작 < 오른쪽끝 &&\n    왼쪽값.get(왼쪽시작) == 오른쪽값.get(오른쪽시작) {\n    왼쪽시작 = 왼쪽시작 + 1\n    오른쪽시작 = 오른쪽시작 + 1\n  }\n  while 왼쪽시작 < 왼쪽끝 && 오른쪽시작 < 오른쪽끝 &&\n    왼쪽값.get(왼쪽끝 - 1) == 오른쪽값.get(오른쪽끝 - 1) {\n    왼쪽끝 = 왼쪽끝 - 1\n    오른쪽끝 = 오른쪽끝 - 1\n  }\n\n  let mut 왼쪽 = 왼쪽값.slice(왼쪽시작, 왼쪽끝)\n  let mut 오른쪽 = 오른쪽값.slice(오른쪽시작, 오른쪽끝)\n  if 왼쪽.length() == 0 || 오른쪽.length() == 0 {\n    return (왼쪽.length() + 오른쪽.length()) * 2\n  }\n  if 왼쪽.length() > 40 || 오른쪽.length() > 40 { return 최대비용 + 1 }\n  if 오른쪽.length() < 왼쪽.length() {\n    let 바꿈 = 왼쪽\n    왼쪽 = 오른쪽\n    오른쪽 = 바꿈\n  }\n  if (오른쪽.length() - 왼쪽.length()) * 2 > 최대비용 { return 최대비용 + 1 }\n\n  let mut 행: Array<int> = []\n  let mut 왼쪽색인 = 0\n  while 왼쪽색인 < 왼쪽.length() {\n    행.push((왼쪽색인 + 1) * 2)\n    왼쪽색인 = 왼쪽색인 + 1\n  }\n  let mut 결과 = 0\n  let mut 오른쪽색인 = 0\n  while 오른쪽색인 < 오른쪽.length() {\n    let 코드 = 오른쪽.get(오른쪽색인) ?? 0\n    결과 = 오른쪽색인 * 2\n    let mut 거리 = 결과\n    let mut 최소 = 2147483647\n    왼쪽색인 = 0\n    while 왼쪽색인 < 왼쪽.length() {\n      let 대치 = 거리 + 파이썬제안대치비용(코드, 왼쪽.get(왼쪽색인) ?? 0)\n      거리 = 행[왼쪽색인]\n      let 넣기빼기 = 작은값(결과, 거리) + 2\n      결과 = 작은값(넣기빼기, 대치)\n      행[왼쪽색인] = 결과\n      최소 = 작은값(최소, 결과)\n      왼쪽색인 = 왼쪽색인 + 1\n    }\n    if 최소 > 최대비용 { return 최대비용 + 1 }\n    오른쪽색인 = 오른쪽색인 + 1\n  }\n  결과\n}\n\nfunction 파이썬이름제안가능(틀린이름: string, 후보이름: string) -> bool {\n  if 틀린이름 == 후보이름 { return false }\n  let 틀림 = 틀린이름.encodeUtf8()\n  let 후보 = 후보이름.encodeUtf8()\n  let 최대거리 = (틀림.length() + 후보.length() + 3) * 2 / 6\n  파이썬제안편집비용(틀림, 후보, 최대거리) <= 최대거리\n}\n\nexport function 파이썬후보가제안만듦(후보: string, 보이는이름들: Array<string>) -> bool {\n  for 보이는이름 in 보이는이름들 {\n    if 파이썬이름제안가능(보이는이름, 후보) { return true }\n  }\n  false\n}\n",
      "sourceSha256": "7265a9692dc7bacf89350bea0456eb592c2e03e9b3cad40e8257b5a8e38f3986"
    },
    {
      "path": "topaz/src/names/r.tpz",
      "language": "topaz",
      "bytes": 383,
      "sha256": "05fd8b98a86e774881bf22a7502ffc068782a220523c471514999fad2fbae9f1",
      "content": "// R reserved words that anonymous names avoid.\n\nimport util { 문자열배열에있음 }\n\nexport function 알예약이름(이름: string) -> bool {\n  문자열배열에있음([\n    \"break\", \"else\", \"FALSE\", \"for\", \"function\", \"if\", \"Inf\", \"in\",\n    \"NA\", \"NA_character_\", \"NA_complex_\", \"NA_integer_\", \"NA_real_\",\n    \"NaN\", \"next\", \"NULL\", \"repeat\", \"TRUE\", \"while\"\n  ], 이름)\n}\n",
      "sourceSha256": "05fd8b98a86e774881bf22a7502ffc068782a220523c471514999fad2fbae9f1"
    },
    {
      "path": "topaz/src/names/rescript.tpz",
      "language": "topaz",
      "bytes": 497,
      "sha256": "05793e4c5df65db9c20834aca7bc59967fd4acffbcbd118d97841556bf894c8f",
      "content": "// ReScript reserved words that anonymous names avoid.\n\nimport util { 문자열배열에있음 }\n\nexport function 리스크립트예약이름(이름: string) -> bool {\n  문자열배열에있음([\n    \"and\", \"as\", \"assert\", \"async\", \"await\", \"catch\", \"constraint\",\n    \"else\", \"exception\", \"external\", \"false\", \"for\", \"if\", \"in\",\n    \"include\", \"lazy\", \"let\", \"module\", \"mutable\", \"open\", \"private\",\n    \"rec\", \"switch\", \"true\", \"try\", \"type\", \"unpack\", \"when\", \"while\",\n    \"with\"\n  ], 이름)\n}\n",
      "sourceSha256": "05793e4c5df65db9c20834aca7bc59967fd4acffbcbd118d97841556bf894c8f"
    },
    {
      "path": "topaz/src/names/ruby.tpz",
      "language": "topaz",
      "bytes": 1799,
      "sha256": "72908a0bc6f016e4621d498140e54355b236b00f179fdf42a536881ffd963dd8",
      "content": "// Ruby reserved words and regular-expression capture names that anonymous names avoid.\n\nimport names.ascii { 아스키식별자계속, 아스키식별자시작 }\nimport print { 글자합치기 }\nimport util { 문자열배열에있음 }\n\nexport function 루비예약이름(이름: string) -> bool {\n  문자열배열에있음([\n    \"BEGIN\", \"END\", \"__ENCODING__\", \"__FILE__\", \"__LINE__\", \"alias\", \"and\",\n    \"begin\", \"break\", \"case\", \"class\", \"def\", \"defined?\", \"do\", \"else\",\n    \"elsif\", \"end\", \"ensure\", \"false\", \"for\", \"if\", \"in\", \"module\", \"next\",\n    \"nil\", \"not\", \"or\", \"redo\", \"rescue\", \"retry\", \"return\", \"self\", \"super\",\n    \"then\", \"true\", \"undef\", \"unless\", \"until\", \"when\", \"while\", \"yield\"\n  ], 이름)\n}\n\nexport function 루비정규식캡처이름들(글: string) -> Array<string> {\n  let 글자들 = 글.scalars()\n  let mut 이름들: Array<string> = []\n  let mut 색인 = 0\n  while 색인 + 3 < 글자들.length {\n    if 글자들[색인] != \"(\" || 글자들[색인 + 1] != \"?\" ||\n      (글자들[색인 + 2] != \"<\" && 글자들[색인 + 2] != \"'\") {\n      색인 = 색인 + 1\n      continue\n    }\n    let 닫개 = if 글자들[색인 + 2] == \"<\" { \">\" } else { \"'\" }\n    let 시작 = 색인 + 3\n    let mut 끝 = 시작\n    while 끝 < 글자들.length && 글자들[끝] != 닫개 { 끝 = 끝 + 1 }\n    if 끝 < 글자들.length && 끝 > 시작 && 아스키식별자시작(글자들[시작]) {\n      let mut 올바름 = true\n      let mut 자리 = 시작 + 1\n      while 자리 < 끝 {\n        if !아스키식별자계속(글자들[자리]) { 올바름 = false }\n        자리 = 자리 + 1\n      }\n      if 올바름 { 이름들.push(글자합치기(글자들, 시작, 끝)) }\n    }\n    색인 = if 끝 < 글자들.length { 끝 + 1 } else { 글자들.length }\n  }\n  이름들\n}\n",
      "sourceSha256": "72908a0bc6f016e4621d498140e54355b236b00f179fdf42a536881ffd963dd8"
    },
    {
      "path": "topaz/src/names/rust.tpz",
      "language": "topaz",
      "bytes": 935,
      "sha256": "992136b9168765235f0bd3a870710bdbf4f988f460b976a3cd48861c8d608d05",
      "content": "// Rust reserved words and raw identifier spellings for anonymous names.\n\nimport print { 글자합치기 }\nimport util { 문자열배열에있음 }\n\nexport function 러스트예약이름(이름: string) -> bool {\n  문자열배열에있음([\n    \"Self\", \"abstract\", \"as\", \"async\", \"await\", \"become\", \"box\", \"break\",\n    \"const\", \"continue\", \"crate\", \"do\", \"dyn\", \"else\", \"enum\", \"extern\",\n    \"false\", \"final\", \"fn\", \"for\", \"gen\", \"if\", \"impl\", \"in\", \"let\", \"loop\",\n    \"macro\", \"match\", \"mod\", \"move\", \"mut\", \"override\", \"priv\", \"pub\", \"ref\",\n    \"return\", \"self\", \"static\", \"struct\", \"super\", \"trait\", \"true\", \"try\", \"type\",\n    \"typeof\", \"union\", \"unsafe\", \"unsized\", \"use\", \"virtual\", \"where\", \"while\", \"yield\"\n  ], 이름)\n}\n\nexport function 러스트정규식별자(이름: string) -> string {\n  if !이름.startsWith(\"r#\") { return 이름 }\n  let 글자들 = 이름.scalars()\n  글자합치기(글자들, 2, 글자들.length)\n}\n",
      "sourceSha256": "992136b9168765235f0bd3a870710bdbf4f988f460b976a3cd48861c8d608d05"
    },
    {
      "path": "topaz/src/names/scala.tpz",
      "language": "topaz",
      "bytes": 1625,
      "sha256": "273c17bc5bf4cb9458e5d80357721038aa1a58b955d91fed93a0d1a9f284715d",
      "content": "// Scala backquoted identifier spellings for anonymous names.\n\nimport print { 글자합치기 }\nimport structure { 구조노드, 구조입력, 스칼라정수 }\n\nexport function 스칼라정규식별자(이름: string) -> string {\n  let 글자들 = 이름.scalars()\n  if 글자들.length >= 2 && 글자들[0] == \"`\" && 글자들[글자들.length - 1] == \"`\" {\n    글자합치기(글자들, 1, 글자들.length - 1)\n  } else { 이름 }\n}\n\nexport function 스칼라감싼식별자인가(구조: 구조입력, 순번: int) -> bool {\n  if 순번 < 0 || 순번 >= 구조.노드들.length { return false }\n  let 노드 = 구조.노드들[순번]\n  if 노드.코드워드 != 416 || 스칼라정수(노드, \"childCount\") != 1 ||\n    순번 + 1 >= 구조.노드들.length {\n    return false\n  }\n  let 자식 = 구조.노드들[순번 + 1]\n  자식.부모순번 == 순번 && 스칼라정수(자식, \"childCount\") == 0 &&\n    자식.시작 == 노드.시작 && 자식.끝 == 노드.끝 &&\n    스칼라정수(자식, \"startRow\") == 스칼라정수(노드, \"startRow\") &&\n    스칼라정수(자식, \"startColumn\") == 스칼라정수(노드, \"startColumn\") &&\n    스칼라정수(자식, \"endRow\") == 스칼라정수(노드, \"endRow\") &&\n    스칼라정수(자식, \"endColumn\") == 스칼라정수(노드, \"endColumn\")\n}\n\nexport function 스칼라감싼식별자자식인가(구조: 구조입력, 순번: int) -> bool {\n  if 순번 <= 0 || 순번 >= 구조.노드들.length { return false }\n  let 부모순번 = 구조.노드들[순번].부모순번\n  부모순번 + 1 == 순번 && 스칼라감싼식별자인가(구조, 부모순번)\n}\n",
      "sourceSha256": "273c17bc5bf4cb9458e5d80357721038aa1a58b955d91fed93a0d1a9f284715d"
    },
    {
      "path": "topaz/src/names/solidity.tpz",
      "language": "topaz",
      "bytes": 1170,
      "sha256": "4f9ddb046e4d35a549765026d356d32603327b3e65911d893f47299c2170639c",
      "content": "// Solidity reserved words that anonymous names avoid.\n\nimport util { 문자열배열에있음 }\n\nexport function 솔리디티예약이름(이름: string) -> bool {\n  문자열배열에있음([\n    \"abstract\", \"after\", \"alias\", \"anonymous\", \"apply\", \"as\", \"assembly\",\n    \"bool\", \"break\", \"byte\", \"calldata\", \"case\", \"catch\", \"constant\",\n    \"constructor\", \"continue\", \"contract\", \"days\", \"default\", \"delete\",\n    \"do\", \"else\", \"emit\", \"enum\", \"ether\", \"event\", \"external\",\n    \"false\", \"fallback\", \"final\", \"for\", \"function\",\n    \"gwei\", \"hours\", \"if\", \"immutable\", \"implements\", \"import\", \"in\",\n    \"indexed\", \"inline\", \"interface\", \"internal\", \"is\", \"let\", \"library\",\n    \"mapping\", \"match\", \"memory\", \"minutes\", \"modifier\", \"mutable\", \"new\",\n    \"null\", \"of\", \"override\", \"partial\", \"payable\", \"pragma\", \"private\",\n    \"promise\", \"public\", \"pure\", \"receive\", \"reference\", \"relocatable\",\n    \"return\", \"returns\", \"sealed\", \"seconds\", \"sizeof\", \"static\",\n    \"storage\", \"string\", \"struct\", \"supports\", \"switch\", \"this\",\n    \"throw\", \"true\", \"try\", \"type\", \"typedef\", \"typeof\", \"unchecked\",\n    \"using\", \"var\", \"view\", \"virtual\", \"weeks\", \"wei\", \"while\"\n  ], 이름)\n}\n",
      "sourceSha256": "4f9ddb046e4d35a549765026d356d32603327b3e65911d893f47299c2170639c"
    },
    {
      "path": "topaz/src/names/zig.tpz",
      "language": "topaz",
      "bytes": 1122,
      "sha256": "db78617375747e84c14a0c83f85a7893325a1b1670575d0d56065bc95b761cae",
      "content": "// Zig reserved words that anonymous names avoid.\n\nimport util { 문자열배열에있음 }\n\nexport function 지그예약이름(이름: string) -> bool {\n  문자열배열에있음([\n    \"addrspace\", \"align\", \"allowzero\", \"and\", \"anyframe\", \"anytype\",\n    \"asm\", \"async\", \"await\", \"break\", \"callconv\", \"catch\", \"comptime\",\n    \"const\", \"continue\", \"defer\", \"else\", \"enum\", \"errdefer\", \"error\",\n    \"export\", \"extern\", \"false\", \"fn\", \"for\", \"if\", \"inline\", \"linksection\",\n    \"noalias\", \"noinline\", \"nosuspend\", \"null\", \"opaque\", \"or\", \"orelse\",\n    \"packed\", \"pub\", \"resume\", \"return\", \"struct\", \"suspend\", \"switch\",\n    \"test\", \"threadlocal\", \"true\", \"try\", \"undefined\", \"union\", \"unreachable\",\n    \"usingnamespace\", \"var\", \"volatile\", \"while\", \"bool\", \"isize\", \"usize\",\n    \"noreturn\", \"type\", \"anyerror\", \"void\", \"anyopaque\", \"comptime_int\",\n    \"comptime_float\", \"f16\", \"f32\", \"f64\", \"f80\", \"f128\", \"c_longdouble\",\n    \"i8\", \"i16\", \"i32\", \"i64\", \"i128\", \"u8\", \"u16\", \"u32\", \"u64\",\n    \"u128\", \"c_char\", \"c_short\", \"c_ushort\", \"c_int\", \"c_uint\", \"c_long\",\n    \"c_ulong\", \"c_longlong\", \"c_ulonglong\", \"_\"\n  ], 이름)\n}\n",
      "sourceSha256": "db78617375747e84c14a0c83f85a7893325a1b1670575d0d56065bc95b761cae"
    },
    {
      "path": "topaz/src/nodes.tpz",
      "language": "topaz",
      "bytes": 3914,
      "sha256": "6b4ae0ffd29827d90cb3316d48d2a08661f312a7b4773e602b938fbb24fffdfc",
      "content": "// Language node-table dispatch.\n\nimport nodes.c { 씨노드종류표 }\nimport nodes.cpp { 씨플러스플러스노드종류표 }\nimport nodes.csharp { 씨샵노드종류표 }\nimport nodes.coffeescript { 커피스크립트노드종류표 }\nimport nodes.dart { 다트노드종류표 }\nimport nodes.elixir { 엘릭서노드종류표 }\nimport nodes.elisp { 이맥스리습노드종류표 }\nimport nodes.elm { 엘름노드종류표 }\nimport nodes.go { 고노드종류표 }\nimport nodes.haskell { 하스켈노드종류표 }\nimport nodes.java { 자바노드종류표 }\nimport nodes.javascript { 자바스크립트노드종류표 }\nimport nodes.julia { 줄리아노드종류표 }\nimport nodes.kotlin { 코틀린노드종류표 }\nimport nodes.lispex { 리스펙스노드종류표 }\nimport nodes.topaz_language { 토파즈언어노드종류표 }\nimport nodes.lua { 루아노드종류표 }\nimport nodes.objc { 오브젝티브씨노드종류표 }\nimport nodes.ocaml { 오캐멀노드종류표 }\nimport nodes.php { 피에이치피노드종류표 }\nimport nodes.python { 파이썬노드종류표 }\nimport nodes.r { 알노드종류표 }\nimport nodes.rescript { 리스크립트노드종류표 }\nimport nodes.ruby { 루비노드종류표 }\nimport nodes.rust { 러스트노드종류표 }\nimport nodes.scala { 스칼라노드종류표 }\nimport nodes.solidity { 솔리디티노드종류표 }\nimport nodes.swift { 스위프트노드종류표 }\nimport nodes.typescript { 타입스크립트노드종류표 }\nimport nodes.zig { 지그노드종류표 }\n\n// BEGIN GENERATED TOPAZ PRINTER CODEWORD TABLE\n// 백 단위는 인쇄 계열이다: 원시 1, 모음 2, 계산 3, 단순문 4, 제어문 5, 클래스 6, 형식 7.\n// 각 표의 코드포인트는 U+E000 + 내부 종류이며 U+E000은 미매핑 표지다.\nexport function 노드종류(언어번호: int, 코드: int) -> int {\n  if 코드 < 0 || 코드 > 510 { return 0 }\n  let 표 = if 언어번호 == 1 { 자바스크립트노드종류표() }\n    else if 언어번호 == 2 { 타입스크립트노드종류표() }\n    else if 언어번호 == 3 { 파이썬노드종류표() }\n    else if 언어번호 == 4 { 고노드종류표() }\n    else if 언어번호 == 5 { 러스트노드종류표() }\n    else if 언어번호 == 6 { 자바노드종류표() }\n    else if 언어번호 == 7 { 씨노드종류표() }\n    else if 언어번호 == 8 { 씨플러스플러스노드종류표() }\n    else if 언어번호 == 9 { 씨샵노드종류표() }\n    else if 언어번호 == 10 { 루비노드종류표() }\n    else if 언어번호 == 11 { 피에이치피노드종류표() }\n    else if 언어번호 == 12 { 스위프트노드종류표() }\n    else if 언어번호 == 13 { 코틀린노드종류표() }\n    else if 언어번호 == 14 { 스칼라노드종류표() }\n    else if 언어번호 == 15 { 다트노드종류표() }\n    else if 언어번호 == 16 { 엘릭서노드종류표() }\n    else if 언어번호 == 17 { 하스켈노드종류표() }\n    else if 언어번호 == 18 { 루아노드종류표() }\n    else if 언어번호 == 19 { 알노드종류표() }\n    else if 언어번호 == 21 { 오캐멀노드종류표() }\n    else if 언어번호 == 20 { 줄리아노드종류표() }\n    else if 언어번호 == 22 { 엘름노드종류표() }\n    else if 언어번호 == 23 { 리스크립트노드종류표() }\n    else if 언어번호 == 24 { 커피스크립트노드종류표() }\n    else if 언어번호 == 25 { 오브젝티브씨노드종류표() }\n    else if 언어번호 == 26 { 이맥스리습노드종류표() }\n    else if 언어번호 == 27 { 솔리디티노드종류표() }\n    else if 언어번호 == 28 { 지그노드종류표() }\n    else if 언어번호 == 29 { 리스펙스노드종류표() }\n    else if 언어번호 == 30 { 토파즈언어노드종류표() }\n    else { return 0 }\n  (표.codePointAt(코드) ?? 57344) - 57344\n}\n// END GENERATED TOPAZ PRINTER CODEWORD TABLE\n",
      "sourceSha256": "6b4ae0ffd29827d90cb3316d48d2a08661f312a7b4773e602b938fbb24fffdfc"
    },
    {
      "path": "topaz/src/nodes/c.tpz",
      "language": "topaz",
      "bytes": 1616,
      "sha256": "9d25101d2b80f8791eea401e5d94819f568c4940742cd51774ef43890f73efd7",
      "content": "// c node codeword table.\n\nexport function 씨노드종류표() -> string {\n  \"\"\n}\n",
      "sourceSha256": "9d25101d2b80f8791eea401e5d94819f568c4940742cd51774ef43890f73efd7"
    },
    {
      "path": "topaz/src/nodes/coffeescript.tpz",
      "language": "topaz",
      "bytes": 1642,
      "sha256": "ece316c3795c6d616e54c6119536e303d6fd7ea949f349b287f7a3535858421c",
      "content": "// coffeescript node codeword table.\n\nexport function 커피스크립트노드종류표() -> string {\n  \"\"\n}\n",
      "sourceSha256": "ece316c3795c6d616e54c6119536e303d6fd7ea949f349b287f7a3535858421c"
    },
    {
      "path": "topaz/src/nodes/cpp.tpz",
      "language": "topaz",
      "bytes": 1636,
      "sha256": "edb1274b1fe1ac09bfee5ff16a625f6c333f7de503f9fcb411bf0d4a972d892a",
      "content": "// cpp node codeword table.\n\nexport function 씨플러스플러스노드종류표() -> string {\n  \"\"\n}\n",
      "sourceSha256": "edb1274b1fe1ac09bfee5ff16a625f6c333f7de503f9fcb411bf0d4a972d892a"
    },
    {
      "path": "topaz/src/nodes/csharp.tpz",
      "language": "topaz",
      "bytes": 1624,
      "sha256": "a86e777c3dfa39ca7fd48cd1d76810cfcd10e76cded94a3568aabb50f55ec52c",
      "content": "// csharp node codeword table.\n\nexport function 씨샵노드종류표() -> string {\n  \"\"\n}\n",
      "sourceSha256": "a86e777c3dfa39ca7fd48cd1d76810cfcd10e76cded94a3568aabb50f55ec52c"
    },
    {
      "path": "topaz/src/nodes/dart.tpz",
      "language": "topaz",
      "bytes": 1622,
      "sha256": "3e7e134e94f1eff86013b73d7c9d08afaa11d8c09615596b9244d45a4e0587a9",
      "content": "// dart node codeword table.\n\nexport function 다트노드종류표() -> string {\n  \"\"\n}\n",
      "sourceSha256": "3e7e134e94f1eff86013b73d7c9d08afaa11d8c09615596b9244d45a4e0587a9"
    },
    {
      "path": "topaz/src/nodes/elisp.tpz",
      "language": "topaz",
      "bytes": 1632,
      "sha256": "a02140e16ee16f5d8ac1bb469382168b9ecf8d70c2846ba02ea2c6af8845b9dc",
      "content": "// elisp node codeword table.\n\nexport function 이맥스리습노드종류표() -> string {\n  \"\"\n}\n",
      "sourceSha256": "a02140e16ee16f5d8ac1bb469382168b9ecf8d70c2846ba02ea2c6af8845b9dc"
    },
    {
      "path": "topaz/src/nodes/elixir.tpz",
      "language": "topaz",
      "bytes": 1627,
      "sha256": "0705574c393510abe96e8f8480961706e6cdee9acc3b4da1516291fe3138cf60",
      "content": "// elixir node codeword table.\n\nexport function 엘릭서노드종류표() -> string {\n  \"\"\n}\n",
      "sourceSha256": "0705574c393510abe96e8f8480961706e6cdee9acc3b4da1516291fe3138cf60"
    },
    {
      "path": "topaz/src/nodes/elm.tpz",
      "language": "topaz",
      "bytes": 1621,
      "sha256": "3ab4cfc77f373a979cf2e871146f7e61e79d16fa562491518b8bf8ffede17b48",
      "content": "// elm node codeword table.\n\nexport function 엘름노드종류표() -> string {\n  \"\"\n}\n",
      "sourceSha256": "3ab4cfc77f373a979cf2e871146f7e61e79d16fa562491518b8bf8ffede17b48"
    },
    {
      "path": "topaz/src/nodes/go.tpz",
      "language": "topaz",
      "bytes": 1617,
      "sha256": "23c87de9d6a2c0202cad7eb6d85d5512f4eaf1e5fe2a1cf24bcf59ef17e1ac9a",
      "content": "// go node codeword table.\n\nexport function 고노드종류표() -> string {\n  \"\"\n}\n",
      "sourceSha256": "23c87de9d6a2c0202cad7eb6d85d5512f4eaf1e5fe2a1cf24bcf59ef17e1ac9a"
    },
    {
      "path": "topaz/src/nodes/haskell.tpz",
      "language": "topaz",
      "bytes": 1628,
      "sha256": "6d28e23dc63ee974b64106af1c7e2f814313c54ffd87550a5b2a515a1abebf67",
      "content": "// haskell node codeword table.\n\nexport function 하스켈노드종류표() -> string {\n  \"\"\n}\n",
      "sourceSha256": "6d28e23dc63ee974b64106af1c7e2f814313c54ffd87550a5b2a515a1abebf67"
    },
    {
      "path": "topaz/src/nodes/java.tpz",
      "language": "topaz",
      "bytes": 1622,
      "sha256": "fb3065d8647831fe73b8e15717721244e7bbaa4b4ad3164f806deaeaa0b66a0f",
      "content": "// java node codeword table.\n\nexport function 자바노드종류표() -> string {\n  \"\"\n}\n",
      "sourceSha256": "fb3065d8647831fe73b8e15717721244e7bbaa4b4ad3164f806deaeaa0b66a0f"
    },
    {
      "path": "topaz/src/nodes/javascript.tpz",
      "language": "topaz",
      "bytes": 1640,
      "sha256": "ac44f7ccd609206cf0875247f8203825a7415938769e85edf135e03b6cdac411",
      "content": "// javascript node codeword table.\n\nexport function 자바스크립트노드종류표() -> string {\n  \"\"\n}\n",
      "sourceSha256": "ac44f7ccd609206cf0875247f8203825a7415938769e85edf135e03b6cdac411"
    },
    {
      "path": "topaz/src/nodes/julia.tpz",
      "language": "topaz",
      "bytes": 1626,
      "sha256": "7f23a4e4a4c03272794ca1a0af25ca83af890b9a172679b72484a9be62a9ccaa",
      "content": "// julia node codeword table.\n\nexport function 줄리아노드종류표() -> string {\n  \"\"\n}\n",
      "sourceSha256": "7f23a4e4a4c03272794ca1a0af25ca83af890b9a172679b72484a9be62a9ccaa"
    },
    {
      "path": "topaz/src/nodes/kotlin.tpz",
      "language": "topaz",
      "bytes": 1627,
      "sha256": "c92db4a7a6146ebbafcd0f519e981dc236fc2848fd9ee0e70df1e8743b89b0b2",
      "content": "// kotlin node codeword table.\n\nexport function 코틀린노드종류표() -> string {\n  \"\"\n}\n",
      "sourceSha256": "c92db4a7a6146ebbafcd0f519e981dc236fc2848fd9ee0e70df1e8743b89b0b2"
    },
    {
      "path": "topaz/src/nodes/lispex.tpz",
      "language": "topaz",
      "bytes": 1630,
      "sha256": "3ab72578f6954d06f3e0a7b88799ce6bd8188e37333ba9eccc9f43204fe9a542",
      "content": "// lispex node codeword table.\n\nexport function 리스펙스노드종류표() -> string {\n  \"\"\n}\n",
      "sourceSha256": "3ab72578f6954d06f3e0a7b88799ce6bd8188e37333ba9eccc9f43204fe9a542"
    },
    {
      "path": "topaz/src/nodes/lua.tpz",
      "language": "topaz",
      "bytes": 1621,
      "sha256": "c125b9f32a6f70bd359e8c636406122dda71808fbac63c69862b014bf999e5d6",
      "content": "// lua node codeword table.\n\nexport function 루아노드종류표() -> string {\n  \"\"\n}\n",
      "sourceSha256": "c125b9f32a6f70bd359e8c636406122dda71808fbac63c69862b014bf999e5d6"
    },
    {
      "path": "topaz/src/nodes/objc.tpz",
      "language": "topaz",
      "bytes": 1634,
      "sha256": "f8b5264007b4e3cce785b7f67213b9564db09733201d27dc5e48f97bbc97650a",
      "content": "// objc node codeword table.\n\nexport function 오브젝티브씨노드종류표() -> string {\n  \"\"\n}\n",
      "sourceSha256": "f8b5264007b4e3cce785b7f67213b9564db09733201d27dc5e48f97bbc97650a"
    },
    {
      "path": "topaz/src/nodes/ocaml.tpz",
      "language": "topaz",
      "bytes": 1626,
      "sha256": "d454670dbab3b7c73e58b764951d913d3dce46d625c55f82d28a5fb75072cc02",
      "content": "// ocaml node codeword table.\n\nexport function 오캐멀노드종류표() -> string {\n  \"\"\n}\n",
      "sourceSha256": "d454670dbab3b7c73e58b764951d913d3dce46d625c55f82d28a5fb75072cc02"
    },
    {
      "path": "topaz/src/nodes/php.tpz",
      "language": "topaz",
      "bytes": 1630,
      "sha256": "df076bb49f399f47ce45a4c63b22b94fc2f4ed1f90571993398d54823e2a06ce",
      "content": "// php node codeword table.\n\nexport function 피에이치피노드종류표() -> string {\n  \"\"\n}\n",
      "sourceSha256": "df076bb49f399f47ce45a4c63b22b94fc2f4ed1f90571993398d54823e2a06ce"
    },
    {
      "path": "topaz/src/nodes/python.tpz",
      "language": "topaz",
      "bytes": 1627,
      "sha256": "7a49616b2ac2d6559ebf80432cd540d52498d221c05ff9c02c879cc2be3b29c4",
      "content": "// python node codeword table.\n\nexport function 파이썬노드종류표() -> string {\n  \"\"\n}\n",
      "sourceSha256": "7a49616b2ac2d6559ebf80432cd540d52498d221c05ff9c02c879cc2be3b29c4"
    },
    {
      "path": "topaz/src/nodes/r.tpz",
      "language": "topaz",
      "bytes": 1616,
      "sha256": "d23985a5ce381b21e8e8e144429a4f18f10c12d15e0a3695e29b1131d242c719",
      "content": "// r node codeword table.\n\nexport function 알노드종류표() -> string {\n  \"\"\n}\n",
      "sourceSha256": "d23985a5ce381b21e8e8e144429a4f18f10c12d15e0a3695e29b1131d242c719"
    },
    {
      "path": "topaz/src/nodes/rescript.tpz",
      "language": "topaz",
      "bytes": 1635,
      "sha256": "1786e671ed5ce533fa0438c05d22e98c4c5c7a0981d5935d1b360c7266b32dd1",
      "content": "// rescript node codeword table.\n\nexport function 리스크립트노드종류표() -> string {\n  \"\"\n}\n",
      "sourceSha256": "1786e671ed5ce533fa0438c05d22e98c4c5c7a0981d5935d1b360c7266b32dd1"
    },
    {
      "path": "topaz/src/nodes/ruby.tpz",
      "language": "topaz",
      "bytes": 1622,
      "sha256": "b17881d10f9e14c91d8edd48254c4a992a86e3fa3320bfc1d83f802a26e25bfc",
      "content": "// ruby node codeword table.\n\nexport function 루비노드종류표() -> string {\n  \"\"\n}\n",
      "sourceSha256": "b17881d10f9e14c91d8edd48254c4a992a86e3fa3320bfc1d83f802a26e25bfc"
    },
    {
      "path": "topaz/src/nodes/rust.tpz",
      "language": "topaz",
      "bytes": 1625,
      "sha256": "02cc22d925b1682928257eef9742c97d1444fb45c50662e0f5345cf9a4d4614f",
      "content": "// rust node codeword table.\n\nexport function 러스트노드종류표() -> string {\n  \"\"\n}\n",
      "sourceSha256": "02cc22d925b1682928257eef9742c97d1444fb45c50662e0f5345cf9a4d4614f"
    },
    {
      "path": "topaz/src/nodes/scala.tpz",
      "language": "topaz",
      "bytes": 1626,
      "sha256": "01aeedc19937b7ad65438289862f494bbcd0ce5e22f54db4870d2d7b0d7364e2",
      "content": "// scala node codeword table.\n\nexport function 스칼라노드종류표() -> string {\n  \"\"\n}\n",
      "sourceSha256": "01aeedc19937b7ad65438289862f494bbcd0ce5e22f54db4870d2d7b0d7364e2"
    },
    {
      "path": "topaz/src/nodes/solidity.tpz",
      "language": "topaz",
      "bytes": 1632,
      "sha256": "398e2f41cc53d5d1415a52c6923825546504793f4946dd675f444ea598c410ec",
      "content": "// solidity node codeword table.\n\nexport function 솔리디티노드종류표() -> string {\n  \"\"\n}\n",
      "sourceSha256": "398e2f41cc53d5d1415a52c6923825546504793f4946dd675f444ea598c410ec"
    },
    {
      "path": "topaz/src/nodes/swift.tpz",
      "language": "topaz",
      "bytes": 1629,
      "sha256": "30b5ba6145f43a49574ef81ad47e1dfeabb70b734e14a4dea73653593841bad2",
      "content": "// swift node codeword table.\n\nexport function 스위프트노드종류표() -> string {\n  \"\"\n}\n",
      "sourceSha256": "30b5ba6145f43a49574ef81ad47e1dfeabb70b734e14a4dea73653593841bad2"
    },
    {
      "path": "topaz/src/nodes/topaz_language.tpz",
      "language": "topaz",
      "bytes": 1632,
      "sha256": "a2a3ea1cc4c8c3021832668c20b87ea60d2bffc68e9853115abd1f1cf50e815c",
      "content": "// topaz node codeword table.\n\nexport function 토파즈언어노드종류표() -> string {\n  \"\"\n}\n",
      "sourceSha256": "a2a3ea1cc4c8c3021832668c20b87ea60d2bffc68e9853115abd1f1cf50e815c"
    },
    {
      "path": "topaz/src/nodes/typescript.tpz",
      "language": "topaz",
      "bytes": 1640,
      "sha256": "97370ff1cfb92014ef85d217f4eb9a631c71b84f2ab26a57e44ce86ec6f46622",
      "content": "// typescript node codeword table.\n\nexport function 타입스크립트노드종류표() -> string {\n  \"\"\n}\n",
      "sourceSha256": "97370ff1cfb92014ef85d217f4eb9a631c71b84f2ab26a57e44ce86ec6f46622"
    },
    {
      "path": "topaz/src/nodes/zig.tpz",
      "language": "topaz",
      "bytes": 1621,
      "sha256": "4bc735eca361d36d34a9dffd2c84dd8e68cf693c6c6e4a9aa5d865d879dc6fd8",
      "content": "// zig node codeword table.\n\nexport function 지그노드종류표() -> string {\n  \"\"\n}\n",
      "sourceSha256": "4bc735eca361d36d34a9dffd2c84dd8e68cf693c6c6e4a9aa5d865d879dc6fd8"
    },
    {
      "path": "topaz/src/objc_xid.tpz",
      "language": "topaz",
      "bytes": 21749,
      "sha256": "331a35aed599bd09def73ebe767ae0523caa96a0c45ed5c4b709cebc61049906",
      "content": "// Generated by topaz/objc-xid-generator.mjs; the kernel's Unicode identifier domains.\n\nexport function 오브젝티브씨식별자시작(code: int) -> bool {\n  let ranges: Array<int> = [\n    65, 90, 95, 95, 97, 122, 170, 170, 181, 181, 186, 186, 192, 214, 216, 246,\n    248, 705, 710, 721, 736, 740, 748, 748, 750, 750, 880, 884, 886, 887, 891, 893,\n    895, 895, 902, 902, 904, 906, 908, 908, 910, 929, 931, 1013, 1015, 1153, 1162, 1327,\n    1329, 1366, 1369, 1369, 1376, 1416, 1488, 1514, 1519, 1522, 1568, 1610, 1646, 1647, 1649, 1747,\n    1749, 1749, 1765, 1766, 1774, 1775, 1786, 1788, 1791, 1791, 1808, 1808, 1810, 1839, 1869, 1957,\n    1969, 1969, 1994, 2026, 2036, 2037, 2042, 2042, 2048, 2069, 2074, 2074, 2084, 2084, 2088, 2088,\n    2112, 2136, 2144, 2154, 2160, 2183, 2185, 2191, 2208, 2249, 2308, 2361, 2365, 2365, 2384, 2384,\n    2392, 2401, 2417, 2432, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489,\n    2493, 2493, 2510, 2510, 2524, 2525, 2527, 2529, 2544, 2545, 2556, 2556, 2565, 2570, 2575, 2576,\n    2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2649, 2652, 2654, 2654, 2674, 2676,\n    2693, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2749, 2749, 2768, 2768,\n    2784, 2785, 2809, 2809, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2869, 2873,\n    2877, 2877, 2908, 2909, 2911, 2913, 2929, 2929, 2947, 2947, 2949, 2954, 2958, 2960, 2962, 2965,\n    2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 3001, 3024, 3024, 3077, 3084,\n    3086, 3088, 3090, 3112, 3114, 3129, 3133, 3133, 3160, 3162, 3164, 3165, 3168, 3169, 3200, 3200,\n    3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3261, 3261, 3292, 3294, 3296, 3297,\n    3313, 3314, 3332, 3340, 3342, 3344, 3346, 3386, 3389, 3389, 3406, 3406, 3412, 3414, 3423, 3425,\n    3450, 3455, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3585, 3632, 3634, 3634,\n    3648, 3654, 3713, 3714, 3716, 3716, 3718, 3722, 3724, 3747, 3749, 3749, 3751, 3760, 3762, 3762,\n    3773, 3773, 3776, 3780, 3782, 3782, 3804, 3807, 3840, 3840, 3904, 3911, 3913, 3948, 3976, 3980,\n    4096, 4138, 4159, 4159, 4176, 4181, 4186, 4189, 4193, 4193, 4197, 4198, 4206, 4208, 4213, 4225,\n    4238, 4238, 4256, 4293, 4295, 4295, 4301, 4301, 4304, 4346, 4348, 4680, 4682, 4685, 4688, 4694,\n    4696, 4696, 4698, 4701, 4704, 4744, 4746, 4749, 4752, 4784, 4786, 4789, 4792, 4798, 4800, 4800,\n    4802, 4805, 4808, 4822, 4824, 4880, 4882, 4885, 4888, 4954, 4992, 5007, 5024, 5109, 5112, 5117,\n    5121, 5740, 5743, 5759, 5761, 5786, 5792, 5866, 5870, 5880, 5888, 5905, 5919, 5937, 5952, 5969,\n    5984, 5996, 5998, 6000, 6016, 6067, 6103, 6103, 6108, 6108, 6176, 6264, 6272, 6312, 6314, 6314,\n    6320, 6389, 6400, 6430, 6480, 6509, 6512, 6516, 6528, 6571, 6576, 6601, 6656, 6678, 6688, 6740,\n    6823, 6823, 6917, 6963, 6981, 6988, 7043, 7072, 7086, 7087, 7098, 7141, 7168, 7203, 7245, 7247,\n    7258, 7293, 7296, 7306, 7312, 7354, 7357, 7359, 7401, 7404, 7406, 7411, 7413, 7414, 7418, 7418,\n    7424, 7615, 7680, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027,\n    8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147,\n    8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8305, 8305, 8319, 8319, 8336, 8348, 8450, 8450,\n    8455, 8455, 8458, 8467, 8469, 8469, 8472, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8505,\n    8508, 8511, 8517, 8521, 8526, 8526, 8544, 8584, 11264, 11492, 11499, 11502, 11506, 11507, 11520, 11557,\n    11559, 11559, 11565, 11565, 11568, 11623, 11631, 11631, 11648, 11670, 11680, 11686, 11688, 11694, 11696, 11702,\n    11704, 11710, 11712, 11718, 11720, 11726, 11728, 11734, 11736, 11742, 12293, 12295, 12321, 12329, 12337, 12341,\n    12344, 12348, 12353, 12438, 12445, 12447, 12449, 12538, 12540, 12543, 12549, 12591, 12593, 12686, 12704, 12735,\n    12784, 12799, 13312, 19903, 19968, 42124, 42192, 42237, 42240, 42508, 42512, 42527, 42538, 42539, 42560, 42606,\n    42623, 42653, 42656, 42735, 42775, 42783, 42786, 42888, 42891, 42972, 42993, 43009, 43011, 43013, 43015, 43018,\n    43020, 43042, 43072, 43123, 43138, 43187, 43250, 43255, 43259, 43259, 43261, 43262, 43274, 43301, 43312, 43334,\n    43360, 43388, 43396, 43442, 43471, 43471, 43488, 43492, 43494, 43503, 43514, 43518, 43520, 43560, 43584, 43586,\n    43588, 43595, 43616, 43638, 43642, 43642, 43646, 43695, 43697, 43697, 43701, 43702, 43705, 43709, 43712, 43712,\n    43714, 43714, 43739, 43741, 43744, 43754, 43762, 43764, 43777, 43782, 43785, 43790, 43793, 43798, 43808, 43814,\n    43816, 43822, 43824, 43866, 43868, 43881, 43888, 44002, 44032, 55203, 55216, 55238, 55243, 55291, 63744, 64109,\n    64112, 64217, 64256, 64262, 64275, 64279, 64285, 64285, 64287, 64296, 64298, 64310, 64312, 64316, 64318, 64318,\n    64320, 64321, 64323, 64324, 64326, 64433, 64467, 64605, 64612, 64829, 64848, 64911, 64914, 64967, 65008, 65017,\n    65137, 65137, 65139, 65139, 65143, 65143, 65145, 65145, 65147, 65147, 65149, 65149, 65151, 65276, 65313, 65338,\n    65345, 65370, 65382, 65437, 65440, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500, 65536, 65547,\n    65549, 65574, 65576, 65594, 65596, 65597, 65599, 65613, 65616, 65629, 65664, 65786, 65856, 65908, 66176, 66204,\n    66208, 66256, 66304, 66335, 66349, 66378, 66384, 66421, 66432, 66461, 66464, 66499, 66504, 66511, 66513, 66517,\n    66560, 66717, 66736, 66771, 66776, 66811, 66816, 66855, 66864, 66915, 66928, 66938, 66940, 66954, 66956, 66962,\n    66964, 66965, 66967, 66977, 66979, 66993, 66995, 67001, 67003, 67004, 67008, 67059, 67072, 67382, 67392, 67413,\n    67424, 67431, 67456, 67461, 67463, 67504, 67506, 67514, 67584, 67589, 67592, 67592, 67594, 67637, 67639, 67640,\n    67644, 67644, 67647, 67669, 67680, 67702, 67712, 67742, 67808, 67826, 67828, 67829, 67840, 67861, 67872, 67897,\n    67904, 67929, 67968, 68023, 68030, 68031, 68096, 68096, 68112, 68115, 68117, 68119, 68121, 68149, 68192, 68220,\n    68224, 68252, 68288, 68295, 68297, 68324, 68352, 68405, 68416, 68437, 68448, 68466, 68480, 68497, 68608, 68680,\n    68736, 68786, 68800, 68850, 68864, 68899, 68938, 68965, 68975, 68997, 69248, 69289, 69296, 69297, 69314, 69319,\n    69376, 69404, 69415, 69415, 69424, 69445, 69488, 69505, 69552, 69572, 69600, 69622, 69635, 69687, 69745, 69746,\n    69749, 69749, 69763, 69807, 69840, 69864, 69891, 69926, 69956, 69956, 69959, 69959, 69968, 70002, 70006, 70006,\n    70019, 70066, 70081, 70084, 70106, 70106, 70108, 70108, 70144, 70161, 70163, 70187, 70207, 70208, 70272, 70278,\n    70280, 70280, 70282, 70285, 70287, 70301, 70303, 70312, 70320, 70366, 70405, 70412, 70415, 70416, 70419, 70440,\n    70442, 70448, 70450, 70451, 70453, 70457, 70461, 70461, 70480, 70480, 70493, 70497, 70528, 70537, 70539, 70539,\n    70542, 70542, 70544, 70581, 70583, 70583, 70609, 70609, 70611, 70611, 70656, 70708, 70727, 70730, 70751, 70753,\n    70784, 70831, 70852, 70853, 70855, 70855, 71040, 71086, 71128, 71131, 71168, 71215, 71236, 71236, 71296, 71338,\n    71352, 71352, 71424, 71450, 71488, 71494, 71680, 71723, 71840, 71903, 71935, 71942, 71945, 71945, 71948, 71955,\n    71957, 71958, 71960, 71983, 71999, 71999, 72001, 72001, 72096, 72103, 72106, 72144, 72161, 72161, 72163, 72163,\n    72192, 72192, 72203, 72242, 72250, 72250, 72272, 72272, 72284, 72329, 72349, 72349, 72368, 72440, 72640, 72672,\n    72704, 72712, 72714, 72750, 72768, 72768, 72818, 72847, 72960, 72966, 72968, 72969, 72971, 73008, 73030, 73030,\n    73056, 73061, 73063, 73064, 73066, 73097, 73112, 73112, 73136, 73179, 73440, 73458, 73474, 73474, 73476, 73488,\n    73490, 73523, 73648, 73648, 73728, 74649, 74752, 74862, 74880, 75075, 77712, 77808, 77824, 78895, 78913, 78918,\n    78944, 82938, 82944, 83526, 90368, 90397, 92160, 92728, 92736, 92766, 92784, 92862, 92880, 92909, 92928, 92975,\n    92992, 92995, 93027, 93047, 93053, 93071, 93504, 93548, 93760, 93823, 93856, 93880, 93883, 93907, 93952, 94026,\n    94032, 94032, 94099, 94111, 94176, 94177, 94179, 94179, 94194, 94198, 94208, 101589, 101631, 101662, 101760, 101874,\n    110576, 110579, 110581, 110587, 110589, 110590, 110592, 110882, 110898, 110898, 110928, 110930, 110933, 110933, 110948, 110951,\n    110960, 111355, 113664, 113770, 113776, 113788, 113792, 113800, 113808, 113817, 119808, 119892, 119894, 119964, 119966, 119967,\n    119970, 119970, 119973, 119974, 119977, 119980, 119982, 119993, 119995, 119995, 119997, 120003, 120005, 120069, 120071, 120074,\n    120077, 120084, 120086, 120092, 120094, 120121, 120123, 120126, 120128, 120132, 120134, 120134, 120138, 120144, 120146, 120485,\n    120488, 120512, 120514, 120538, 120540, 120570, 120572, 120596, 120598, 120628, 120630, 120654, 120656, 120686, 120688, 120712,\n    120714, 120744, 120746, 120770, 120772, 120779, 122624, 122654, 122661, 122666, 122928, 122989, 123136, 123180, 123191, 123197,\n    123214, 123214, 123536, 123565, 123584, 123627, 124112, 124139, 124368, 124397, 124400, 124400, 124608, 124638, 124640, 124642,\n    124644, 124645, 124647, 124653, 124656, 124660, 124670, 124671, 124896, 124902, 124904, 124907, 124909, 124910, 124912, 124926,\n    124928, 125124, 125184, 125251, 125259, 125259, 126464, 126467, 126469, 126495, 126497, 126498, 126500, 126500, 126503, 126503,\n    126505, 126514, 126516, 126519, 126521, 126521, 126523, 126523, 126530, 126530, 126535, 126535, 126537, 126537, 126539, 126539,\n    126541, 126543, 126545, 126546, 126548, 126548, 126551, 126551, 126553, 126553, 126555, 126555, 126557, 126557, 126559, 126559,\n    126561, 126562, 126564, 126564, 126567, 126570, 126572, 126578, 126580, 126583, 126585, 126588, 126590, 126590, 126592, 126601,\n    126603, 126619, 126625, 126627, 126629, 126633, 126635, 126651, 131072, 173791, 173824, 178205, 178208, 183981, 183984, 191456,\n    191472, 192093, 194560, 195101, 196608, 201546, 201552, 210041,\n  ]\n  let mut low = 0\n  let mut high = ranges.length / 2\n  while low < high {\n    let middle = (low + high) / 2\n    if code < ranges[middle * 2] { high = middle }\n    else if code > ranges[middle * 2 + 1] { low = middle + 1 }\n    else { return true }\n  }\n  false\n}\n\nexport function 오브젝티브씨식별자계속(code: int) -> bool {\n  let ranges: Array<int> = [\n    48, 57, 65, 90, 95, 95, 97, 122, 170, 170, 181, 181, 183, 183, 186, 186,\n    192, 214, 216, 246, 248, 705, 710, 721, 736, 740, 748, 748, 750, 750, 768, 884,\n    886, 887, 891, 893, 895, 895, 902, 906, 908, 908, 910, 929, 931, 1013, 1015, 1153,\n    1155, 1159, 1162, 1327, 1329, 1366, 1369, 1369, 1376, 1416, 1425, 1469, 1471, 1471, 1473, 1474,\n    1476, 1477, 1479, 1479, 1488, 1514, 1519, 1522, 1552, 1562, 1568, 1641, 1646, 1747, 1749, 1756,\n    1759, 1768, 1770, 1788, 1791, 1791, 1808, 1866, 1869, 1969, 1984, 2037, 2042, 2042, 2045, 2045,\n    2048, 2093, 2112, 2139, 2144, 2154, 2160, 2183, 2185, 2191, 2199, 2273, 2275, 2403, 2406, 2415,\n    2417, 2435, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2492, 2500,\n    2503, 2504, 2507, 2510, 2519, 2519, 2524, 2525, 2527, 2531, 2534, 2545, 2556, 2556, 2558, 2558,\n    2561, 2563, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617,\n    2620, 2620, 2622, 2626, 2631, 2632, 2635, 2637, 2641, 2641, 2649, 2652, 2654, 2654, 2662, 2677,\n    2689, 2691, 2693, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2748, 2757,\n    2759, 2761, 2763, 2765, 2768, 2768, 2784, 2787, 2790, 2799, 2809, 2815, 2817, 2819, 2821, 2828,\n    2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2869, 2873, 2876, 2884, 2887, 2888, 2891, 2893,\n    2901, 2903, 2908, 2909, 2911, 2915, 2918, 2927, 2929, 2929, 2946, 2947, 2949, 2954, 2958, 2960,\n    2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 3001, 3006, 3010,\n    3014, 3016, 3018, 3021, 3024, 3024, 3031, 3031, 3046, 3055, 3072, 3084, 3086, 3088, 3090, 3112,\n    3114, 3129, 3132, 3140, 3142, 3144, 3146, 3149, 3157, 3158, 3160, 3162, 3164, 3165, 3168, 3171,\n    3174, 3183, 3200, 3203, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3260, 3268,\n    3270, 3272, 3274, 3277, 3285, 3286, 3292, 3294, 3296, 3299, 3302, 3311, 3313, 3315, 3328, 3340,\n    3342, 3344, 3346, 3396, 3398, 3400, 3402, 3406, 3412, 3415, 3423, 3427, 3430, 3439, 3450, 3455,\n    3457, 3459, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3530, 3530, 3535, 3540,\n    3542, 3542, 3544, 3551, 3558, 3567, 3570, 3571, 3585, 3642, 3648, 3662, 3664, 3673, 3713, 3714,\n    3716, 3716, 3718, 3722, 3724, 3747, 3749, 3749, 3751, 3773, 3776, 3780, 3782, 3782, 3784, 3790,\n    3792, 3801, 3804, 3807, 3840, 3840, 3864, 3865, 3872, 3881, 3893, 3893, 3895, 3895, 3897, 3897,\n    3902, 3911, 3913, 3948, 3953, 3972, 3974, 3991, 3993, 4028, 4038, 4038, 4096, 4169, 4176, 4253,\n    4256, 4293, 4295, 4295, 4301, 4301, 4304, 4346, 4348, 4680, 4682, 4685, 4688, 4694, 4696, 4696,\n    4698, 4701, 4704, 4744, 4746, 4749, 4752, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805,\n    4808, 4822, 4824, 4880, 4882, 4885, 4888, 4954, 4957, 4959, 4969, 4977, 4992, 5007, 5024, 5109,\n    5112, 5117, 5121, 5740, 5743, 5759, 5761, 5786, 5792, 5866, 5870, 5880, 5888, 5909, 5919, 5940,\n    5952, 5971, 5984, 5996, 5998, 6000, 6002, 6003, 6016, 6099, 6103, 6103, 6108, 6109, 6112, 6121,\n    6155, 6157, 6159, 6169, 6176, 6264, 6272, 6314, 6320, 6389, 6400, 6430, 6432, 6443, 6448, 6459,\n    6470, 6509, 6512, 6516, 6528, 6571, 6576, 6601, 6608, 6618, 6656, 6683, 6688, 6750, 6752, 6780,\n    6783, 6793, 6800, 6809, 6823, 6823, 6832, 6845, 6847, 6877, 6880, 6891, 6912, 6988, 6992, 7001,\n    7019, 7027, 7040, 7155, 7168, 7223, 7232, 7241, 7245, 7293, 7296, 7306, 7312, 7354, 7357, 7359,\n    7376, 7378, 7380, 7418, 7424, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025,\n    8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140,\n    8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8204, 8205, 8255, 8256, 8276, 8276,\n    8305, 8305, 8319, 8319, 8336, 8348, 8400, 8412, 8417, 8417, 8421, 8432, 8450, 8450, 8455, 8455,\n    8458, 8467, 8469, 8469, 8472, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8505, 8508, 8511,\n    8517, 8521, 8526, 8526, 8544, 8584, 11264, 11492, 11499, 11507, 11520, 11557, 11559, 11559, 11565, 11565,\n    11568, 11623, 11631, 11631, 11647, 11670, 11680, 11686, 11688, 11694, 11696, 11702, 11704, 11710, 11712, 11718,\n    11720, 11726, 11728, 11734, 11736, 11742, 11744, 11775, 12293, 12295, 12321, 12335, 12337, 12341, 12344, 12348,\n    12353, 12438, 12441, 12442, 12445, 12447, 12449, 12543, 12549, 12591, 12593, 12686, 12704, 12735, 12784, 12799,\n    13312, 19903, 19968, 42124, 42192, 42237, 42240, 42508, 42512, 42539, 42560, 42607, 42612, 42621, 42623, 42737,\n    42775, 42783, 42786, 42888, 42891, 42972, 42993, 43047, 43052, 43052, 43072, 43123, 43136, 43205, 43216, 43225,\n    43232, 43255, 43259, 43259, 43261, 43309, 43312, 43347, 43360, 43388, 43392, 43456, 43471, 43481, 43488, 43518,\n    43520, 43574, 43584, 43597, 43600, 43609, 43616, 43638, 43642, 43714, 43739, 43741, 43744, 43759, 43762, 43766,\n    43777, 43782, 43785, 43790, 43793, 43798, 43808, 43814, 43816, 43822, 43824, 43866, 43868, 43881, 43888, 44010,\n    44012, 44013, 44016, 44025, 44032, 55203, 55216, 55238, 55243, 55291, 63744, 64109, 64112, 64217, 64256, 64262,\n    64275, 64279, 64285, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433,\n    64467, 64605, 64612, 64829, 64848, 64911, 64914, 64967, 65008, 65017, 65024, 65039, 65056, 65071, 65075, 65076,\n    65101, 65103, 65137, 65137, 65139, 65139, 65143, 65143, 65145, 65145, 65147, 65147, 65149, 65149, 65151, 65276,\n    65296, 65305, 65313, 65338, 65343, 65343, 65345, 65370, 65381, 65470, 65474, 65479, 65482, 65487, 65490, 65495,\n    65498, 65500, 65536, 65547, 65549, 65574, 65576, 65594, 65596, 65597, 65599, 65613, 65616, 65629, 65664, 65786,\n    65856, 65908, 66045, 66045, 66176, 66204, 66208, 66256, 66272, 66272, 66304, 66335, 66349, 66378, 66384, 66426,\n    66432, 66461, 66464, 66499, 66504, 66511, 66513, 66517, 66560, 66717, 66720, 66729, 66736, 66771, 66776, 66811,\n    66816, 66855, 66864, 66915, 66928, 66938, 66940, 66954, 66956, 66962, 66964, 66965, 66967, 66977, 66979, 66993,\n    66995, 67001, 67003, 67004, 67008, 67059, 67072, 67382, 67392, 67413, 67424, 67431, 67456, 67461, 67463, 67504,\n    67506, 67514, 67584, 67589, 67592, 67592, 67594, 67637, 67639, 67640, 67644, 67644, 67647, 67669, 67680, 67702,\n    67712, 67742, 67808, 67826, 67828, 67829, 67840, 67861, 67872, 67897, 67904, 67929, 67968, 68023, 68030, 68031,\n    68096, 68099, 68101, 68102, 68108, 68115, 68117, 68119, 68121, 68149, 68152, 68154, 68159, 68159, 68192, 68220,\n    68224, 68252, 68288, 68295, 68297, 68326, 68352, 68405, 68416, 68437, 68448, 68466, 68480, 68497, 68608, 68680,\n    68736, 68786, 68800, 68850, 68864, 68903, 68912, 68921, 68928, 68965, 68969, 68973, 68975, 68997, 69248, 69289,\n    69291, 69292, 69296, 69297, 69314, 69319, 69370, 69404, 69415, 69415, 69424, 69456, 69488, 69509, 69552, 69572,\n    69600, 69622, 69632, 69702, 69734, 69749, 69759, 69818, 69826, 69826, 69840, 69864, 69872, 69881, 69888, 69940,\n    69942, 69951, 69956, 69959, 69968, 70003, 70006, 70006, 70016, 70084, 70089, 70092, 70094, 70106, 70108, 70108,\n    70144, 70161, 70163, 70199, 70206, 70209, 70272, 70278, 70280, 70280, 70282, 70285, 70287, 70301, 70303, 70312,\n    70320, 70378, 70384, 70393, 70400, 70403, 70405, 70412, 70415, 70416, 70419, 70440, 70442, 70448, 70450, 70451,\n    70453, 70457, 70459, 70468, 70471, 70472, 70475, 70477, 70480, 70480, 70487, 70487, 70493, 70499, 70502, 70508,\n    70512, 70516, 70528, 70537, 70539, 70539, 70542, 70542, 70544, 70581, 70583, 70592, 70594, 70594, 70597, 70597,\n    70599, 70602, 70604, 70611, 70625, 70626, 70656, 70730, 70736, 70745, 70750, 70753, 70784, 70853, 70855, 70855,\n    70864, 70873, 71040, 71093, 71096, 71104, 71128, 71133, 71168, 71232, 71236, 71236, 71248, 71257, 71296, 71352,\n    71360, 71369, 71376, 71395, 71424, 71450, 71453, 71467, 71472, 71481, 71488, 71494, 71680, 71738, 71840, 71913,\n    71935, 71942, 71945, 71945, 71948, 71955, 71957, 71958, 71960, 71989, 71991, 71992, 71995, 72003, 72016, 72025,\n    72096, 72103, 72106, 72151, 72154, 72161, 72163, 72164, 72192, 72254, 72263, 72263, 72272, 72345, 72349, 72349,\n    72368, 72440, 72544, 72551, 72640, 72672, 72688, 72697, 72704, 72712, 72714, 72758, 72760, 72768, 72784, 72793,\n    72818, 72847, 72850, 72871, 72873, 72886, 72960, 72966, 72968, 72969, 72971, 73014, 73018, 73018, 73020, 73021,\n    73023, 73031, 73040, 73049, 73056, 73061, 73063, 73064, 73066, 73102, 73104, 73105, 73107, 73112, 73120, 73129,\n    73136, 73179, 73184, 73193, 73440, 73462, 73472, 73488, 73490, 73530, 73534, 73538, 73552, 73562, 73648, 73648,\n    73728, 74649, 74752, 74862, 74880, 75075, 77712, 77808, 77824, 78895, 78912, 78933, 78944, 82938, 82944, 83526,\n    90368, 90425, 92160, 92728, 92736, 92766, 92768, 92777, 92784, 92862, 92864, 92873, 92880, 92909, 92912, 92916,\n    92928, 92982, 92992, 92995, 93008, 93017, 93027, 93047, 93053, 93071, 93504, 93548, 93552, 93561, 93760, 93823,\n    93856, 93880, 93883, 93907, 93952, 94026, 94031, 94087, 94095, 94111, 94176, 94177, 94179, 94180, 94192, 94198,\n    94208, 101589, 101631, 101662, 101760, 101874, 110576, 110579, 110581, 110587, 110589, 110590, 110592, 110882, 110898, 110898,\n    110928, 110930, 110933, 110933, 110948, 110951, 110960, 111355, 113664, 113770, 113776, 113788, 113792, 113800, 113808, 113817,\n    113821, 113822, 118000, 118009, 118528, 118573, 118576, 118598, 119141, 119145, 119149, 119154, 119163, 119170, 119173, 119179,\n    119210, 119213, 119362, 119364, 119808, 119892, 119894, 119964, 119966, 119967, 119970, 119970, 119973, 119974, 119977, 119980,\n    119982, 119993, 119995, 119995, 119997, 120003, 120005, 120069, 120071, 120074, 120077, 120084, 120086, 120092, 120094, 120121,\n    120123, 120126, 120128, 120132, 120134, 120134, 120138, 120144, 120146, 120485, 120488, 120512, 120514, 120538, 120540, 120570,\n    120572, 120596, 120598, 120628, 120630, 120654, 120656, 120686, 120688, 120712, 120714, 120744, 120746, 120770, 120772, 120779,\n    120782, 120831, 121344, 121398, 121403, 121452, 121461, 121461, 121476, 121476, 121499, 121503, 121505, 121519, 122624, 122654,\n    122661, 122666, 122880, 122886, 122888, 122904, 122907, 122913, 122915, 122916, 122918, 122922, 122928, 122989, 123023, 123023,\n    123136, 123180, 123184, 123197, 123200, 123209, 123214, 123214, 123536, 123566, 123584, 123641, 124112, 124153, 124368, 124410,\n    124608, 124638, 124640, 124661, 124670, 124671, 124896, 124902, 124904, 124907, 124909, 124910, 124912, 124926, 124928, 125124,\n    125136, 125142, 125184, 125259, 125264, 125273, 126464, 126467, 126469, 126495, 126497, 126498, 126500, 126500, 126503, 126503,\n    126505, 126514, 126516, 126519, 126521, 126521, 126523, 126523, 126530, 126530, 126535, 126535, 126537, 126537, 126539, 126539,\n    126541, 126543, 126545, 126546, 126548, 126548, 126551, 126551, 126553, 126553, 126555, 126555, 126557, 126557, 126559, 126559,\n    126561, 126562, 126564, 126564, 126567, 126570, 126572, 126578, 126580, 126583, 126585, 126588, 126590, 126590, 126592, 126601,\n    126603, 126619, 126625, 126627, 126629, 126633, 126635, 126651, 130032, 130041, 131072, 173791, 173824, 178205, 178208, 183981,\n    183984, 191456, 191472, 192093, 194560, 195101, 196608, 201546, 201552, 210041, 917760, 917999,\n  ]\n  let mut low = 0\n  let mut high = ranges.length / 2\n  while low < high {\n    let middle = (low + high) / 2\n    if code < ranges[middle * 2] { high = middle }\n    else if code > ranges[middle * 2 + 1] { low = middle + 1 }\n    else { return true }\n  }\n  false\n}\n",
      "sourceSha256": "331a35aed599bd09def73ebe767ae0523caa96a0c45ed5c4b709cebc61049906"
    },
    {
      "path": "topaz/src/plan.tpz",
      "language": "topaz",
      "bytes": 28057,
      "sha256": "522f90714963c59fafc32fe81046b3afb3ce4d68aa576c4651611cf0fad82639",
      "content": "// Page layout records and arithmetic, palettes, render profile hashes, and the\n// pixel font the image modules draw with.\n\nimport std.bytes { Bytes }\nimport std.json\nimport util { 작은값, 큰값 }\n\nexport record 이미지배치 {\n  너비: int,\n  높이: int,\n  판행수: int,\n  판높이: int,\n  띠위: int,\n  띠행수: int,\n  꼬리높이: int\n}\n\nexport record 이미지쪽계획 {\n  쪽번호: int,\n  노드시작: int,\n  노드끝: int,\n  논리시작: int,\n  논리끝: int,\n  보호길이: int,\n  패리티길이: int,\n  배치: 이미지배치\n}\n\nexport record 이미지계획 {\n  쪽들: Array<이미지쪽계획>,\n  세트해시: string\n}\n\nfunction 큰바이트로(입력: Array<int>) -> Result<Bytes, string> {\n  let 숫자들 = [\"0\", \"1\", \"2\", \"3\", \"4\", \"5\", \"6\", \"7\", \"8\", \"9\", \"a\", \"b\", \"c\", \"d\", \"e\", \"f\"]\n  let mut 결과 = Bytes.fromHex(\"\")?\n  let mut 시작 = 0\n  while 시작 < 입력.length {\n    let 끝 = 작은값(시작 + 4096, 입력.length)\n    let mut 글 = \"\"\n    let mut 색인 = 시작\n    while 색인 < 끝 {\n      let 값 = 입력[색인]\n      if 값 < 0 || 값 > 255 { return Err(\"바이트 범위를 벗어났습니다\") }\n      글 = 글 + 숫자들[값 / 16] + 숫자들[값 % 16]\n      색인 = 색인 + 1\n    }\n    결과 = 결과.concat(Bytes.fromHex(글)?)\n    시작 = 끝\n  }\n  Ok(결과)\n}\n\nfunction 십육쓰기(출력: Array<int>, 값: int) -> Array<int> {\n  let mut 결과 = 출력\n  결과.push((값 / 256) % 256)\n  결과.push(값 % 256)\n  결과\n}\n\nfunction 십육읽기(입력: Array<int>, 위치: int) -> int { 입력[위치] * 256 + 입력[위치 + 1] }\n\nfunction 작은십육쓰기(출력: Array<int>, 값: int) -> Array<int> {\n  let mut 결과 = 출력\n  결과.push(값 % 256)\n  결과.push((값 / 256) % 256)\n  결과\n}\n\nfunction 작은삼십이쓰기(출력: Array<int>, 값: int) -> Array<int> {\n  let mut 결과 = 출력\n  결과.push(값 % 256)\n  결과.push((값 / 256) % 256)\n  결과.push((값 / 65536) % 256)\n  결과.push((값 / 16777216) % 256)\n  결과\n}\n\nexport function 이미지팔레트(언어번호: int) -> Array<int> {\n  if 언어번호 == 1 {\n    return [16170304, 15790315, 7324761, 3715756, 11888088, 6782698, 1581104, 15093571]\n  }\n  if 언어번호 == 2 {\n    return [1581104, 6782698, 11888088, 3715756, 16170304, 15790315, 15093571, 7324761]\n  }\n  if 언어번호 == 4 {\n    return [1388868, 44504, 16119280, 16764216, 5488253, 15558746, 9925846, 7375511]\n  }\n  if 언어번호 == 5 {\n    return [13852726, 15657436, 4680860, 14790209, 1974826, 6661724, 10250416, 12730695]\n  }\n  if 언어번호 == 6 {\n    return [2303786, 5472929, 16316658, 15359060, 16036864, 7384391, 9922485, 7964046]\n  }\n  if 언어번호 == 7 {\n    return [1254195, 3762865, 15658728, 16098851, 6076508, 14043722, 9725885, 6979469]\n  }\n  if 언어번호 == 8 {\n    return [1254195, 3762865, 15658728, 16098851, 6076508, 14043722, 9725885, 6979469]\n  }\n  if 언어번호 == 9 {\n    return [1840679, 6824314, 16052984, 4160191, 15445556, 6073197, 13390435, 8287371]\n  }\n  if 언어번호 == 10 {\n    return [1254195, 3762865, 15658728, 16098851, 6076508, 14043722, 9725885, 6979469]\n  }\n  if 언어번호 == 11 {\n    return [1254195, 3762865, 15658728, 16098851, 6076508, 14043722, 9725885, 6979469]\n  }\n  if 언어번호 == 12 {\n    return [1254195, 3762865, 15658728, 16098851, 6076508, 14043722, 9725885, 6979469]\n  }\n  if 언어번호 == 13 {\n    return [1579040, 8344319, 16053241, 16220518, 4364769, 6732650, 15489918, 7896206]\n  }\n  if 언어번호 == 14 {\n    return [1579040, 14430272, 16053241, 16220518, 4364769, 6732650, 15489918, 7896206]\n  }\n  if 언어번호 == 15 {\n    return [858922, 46296, 95682, 15923194, 4576767, 4635008, 16034608, 7898258]\n  }\n  if 언어번호 == 16 {\n    return [1254195, 3762865, 15658728, 16098851, 6076508, 14043722, 9725885, 6979469]\n  }\n  if 언어번호 == 17 {\n    return [1254195, 3762865, 15658728, 16098851, 6076508, 14043722, 9725885, 6979469]\n  }\n  if 언어번호 == 18 {\n    return [1254195, 3762865, 15658728, 16098851, 6076508, 14043722, 9725885, 6979469]\n  }\n  if 언어번호 == 19 {\n    return [1254195, 3762865, 15658728, 16098851, 6076508, 14043722, 9725885, 6979469]\n  }\n  if 언어번호 == 21 {\n    return [1254195, 3762865, 15658728, 16098851, 6076508, 14043722, 9725885, 6979469]\n  }\n  if 언어번호 == 20 {\n    return [2039856, 9787570, 4219864, 3708966, 13319219, 15921911, 16170569, 5987695]\n  }\n  if 언어번호 == 22 {\n    return [1254195, 3762865, 15658728, 16098851, 6076508, 14043722, 9725885, 6979469]\n  }\n  if 언어번호 == 23 {\n    return [1254195, 3762865, 15658728, 16098851, 6076508, 14043722, 9725885, 6979469]\n  }\n  if 언어번호 == 24 {\n    return [1254195, 4224448, 15658728, 16098851, 6076508, 14043722, 9725885, 6979469]\n  }\n  if 언어번호 == 25 {\n    return [1254195, 31487, 15658728, 16098851, 6076508, 14043722, 9725885, 6979469]\n  }\n  if 언어번호 == 26 {\n    return [1254195, 8280002, 15658728, 16098851, 6076508, 14043722, 9725885, 6979469]\n  }\n  if 언어번호 == 27 {\n    return [1254195, 3552822, 15658728, 16098851, 6076508, 14043722, 9725885, 6979469]\n  }\n  if 언어번호 == 28 {\n    return [1254195, 16229405, 15658728, 16098851, 6076508, 14043722, 9725885, 6979469]\n  }\n  if 언어번호 == 29 {\n    return [1910324, 14437953, 16039490, 6863992, 3650220, 5276100, 7694533, 15526108]\n  }\n  if 언어번호 == 30 {\n    return [1712688, 13781309, 15708480, 6074737, 3450029, 4420542, 8281274, 15657176]\n  }\n  [3715756, 15790315, 6782698, 16170304, 1581104, 7324761, 11888088, 15093571]\n}\n\nexport function 형식팔레트() -> Array<int> { [2105376, 6710886, 11184810, 15790320] }\nexport function 띠팔레트() -> Array<int> { [2306107, 6255723, 11636610, 14607308] }\n\nexport function 이역할팔레트() -> Array<int> {\n  [0, 2763306, 4473924, 6052956, 7697781, 9539985, 11645361, 14013909, 16777215]\n}\n\nexport function 팔그물팔레트() -> Array<int> {\n  [15093571, 16170304, 7324761, 3715756, 5080774, 6782698, 11888088, 14245773, 9203014]\n}\n\nexport function 범위씻김팔레트() -> Array<int> { [14342095, 13488071, 12568512] }\n\nexport function 프로필해시(언어번호: int) -> string {\n  if 언어번호 == 1 { return \"1fa3f5b3b0d3422e39b0eb8807b6ee44da1b0545da5f8dd1560bd0e69dfc92cc\" }\n  if 언어번호 == 2 { return \"c5c215334bfc8d8803d771e997b05e6093179cfaa4ebc82de5f06e8d2f3de2a6\" }\n  if 언어번호 == 3 { return \"70df4222bcdd747d8d72e39333273174a3d9d6b4b402e54776000dd2e80bd85a\" }\n  if 언어번호 == 4 { return \"5f9de14502494593c178310efe921bc1863e52e606b49dc8f73ffba78eebc7df\" }\n  if 언어번호 == 5 { return \"83f96dda7e896274168b40288b730fbe3fab1ec79adfc5bd04ee4f350fb24de9\" }\n  if 언어번호 == 6 { return \"f3cab03da81a066a6f9a626f764730b7e578976a70b3db66999266f7cb3e6472\" }\n  if 언어번호 == 7 { return \"c2f63075652bc9bfba7e2a8597e06c76a99e087baa2c9e755d9cb9fdf923668b\" }\n  if 언어번호 == 8 { return \"284d950655b6be34129cb88357b1d10dc07e7b928684fa05c1f2230130fd478f\" }\n  if 언어번호 == 10 { return \"736b26bd60139cf3bba2b44702b86fe4c67c0fd10410f73adfbdf9027eb42784\" }\n  if 언어번호 == 11 { return \"d0427ff7f04d50b6ffd9e7582d16bdec2cd36e4e90feb9721b961992f66f0418\" }\n  if 언어번호 == 12 { return \"5325b5751c17bd1fc9bdc9bb838c437b89acd5ffbd120d233c657a5e2eb239a8\" }\n  if 언어번호 == 13 { return \"1d8b58fcce9849d9a5cdcde082a5bd0957c03f9e32d098299d3ab4ae0e1352fe\" }\n  if 언어번호 == 14 { return \"2493b61ddd30e1fe638cabfea5ad9aa129326c7ecae209b97e007a1052e921a2\" }\n  if 언어번호 == 15 { return \"ee39d7021081a8eb765fcf04f8f01910a1f41b58e51f4f04f8c8253c3f5cb6c8\" }\n  if 언어번호 == 16 { return \"26e8cc038ac235f7f21e54786c0986343008bfbdaf9b1f3c00ee5cc6879756d3\" }\n  if 언어번호 == 17 { return \"bd8ccddcb1e65e3706031bd6f8fc98ca3be8c1141a69be671de4c08000ba5949\" }\n  if 언어번호 == 18 { return \"0a75ea3fb381c217d95bd147272864dec1024878912d5f03bfd78bd6573f6618\" }\n  if 언어번호 == 19 { return \"58b0dc5f2a17b45972c92efe3988f495cb01265437e30f60a0f070f6e3f7526a\" }\n  if 언어번호 == 21 { return \"6d1e9b453a4472672dbb9c9ed9e1aca347fbe8ecdb3c099dfab079708dd91701\" }\n  if 언어번호 == 20 { return \"6c57d09598b0fd51922e39408fe1dbb559ae6b3f682e9ad2d153f70495cda276\" }\n  if 언어번호 == 22 { return \"c053682a4b8ba9993ab5ad08ec1fcb050f602608993b1301944bb0ec8c636d02\" }\n  if 언어번호 == 23 { return \"bc843caf58ef8228fe6e8bad3bea7be1dc02f0227020f39e7a528ff2b04602bd\" }\n  if 언어번호 == 24 { return \"640c89f30f547cf3ba1089ed373880780f3d0cac9efe9fb434711f8b46be7370\" }\n  if 언어번호 == 25 { return \"cd0148389b740b6c1d14121d3a1b2f2300c258e104a0d9c6ab0794beb0b85d39\" }\n  if 언어번호 == 26 { return \"35484caafa313594b3c05996e2955c1abbffaf365be10ce04045f384cb1ac83f\" }\n  if 언어번호 == 27 { return \"f6e4049cb0f313607167be8ccb18d929240dc62bd2cf5b53139584ede8451021\" }\n  if 언어번호 == 28 { return \"30a15ace395aaa68d6d0fc8537e5a742acb120e05b34e53c2d8ebf49415814ac\" }\n  if 언어번호 == 29 { return \"c5ea789d8298997b93578278b859ae859a745d2fe21eb5a7bd271fd5783d2824\" }\n  if 언어번호 == 30 { return \"ed0c51aea4f0f649eda47668c03e242e07f85ec8c2e920f3025d63a29870fdea\" }\n  \"ad04188529524dd09c81cf65d40a673d26de49369581e31787544b374ff209d8\"\n}\n\nexport function 이미지프로필해시맞음(언어번호: int, 해시: string) -> bool {\n  if 언어번호 == 1 {\n    return 해시 == 프로필해시(언어번호) ||\n      해시 == \"229be6c2ed935738c75c7458baa19c4cce0a7d1df8abdbb32cf82582175f11b2\"\n  }\n  if 언어번호 == 2 {\n    return 해시 == 프로필해시(언어번호) ||\n      해시 == \"3bbe416c28fbebf8d0845e5df32d055bab21be2e89d27fad1b87db207bc4bff7\"\n  }\n  if 언어번호 == 3 {\n    return 해시 == 프로필해시(언어번호) ||\n      해시 == \"0612e39566dbed4cfd14b833bf34e42c67ffebdff7c9950079cea4f2414b8121\"\n  }\n  if 언어번호 == 4 {\n    return 해시 == 프로필해시(언어번호) ||\n      해시 == \"2b5e642f239298736443a031e577654b6ea169067cd7ac9acb76e154bc714513\"\n  }\n  if 언어번호 == 5 {\n    return 해시 == 프로필해시(언어번호) ||\n      해시 == \"bfeb028a351670e31f1a5b3ee08362d9b48dd2a380fd811645d248e0e32792e9\"\n  }\n  if 언어번호 == 6 {\n    return 해시 == 프로필해시(언어번호) ||\n      해시 == \"691f972f1910f41ebad040a7df7e476caa7dc7804d0e3aeddb741b87bde81a7a\"\n  }\n  if 언어번호 == 7 {\n    return 해시 == 프로필해시(언어번호) ||\n      해시 == \"2c2a94174438fa58b4cd9d8410b9e920744fb7eb89683adee686ebe881113a70\"\n  }\n  if 언어번호 == 8 {\n    return 해시 == 프로필해시(언어번호) ||\n      해시 == \"f1c4d0173fa29dba8ed9de1be9078b1026c818e632b914e16416c4a7834fcf84\"\n  }\n  if 언어번호 == 9 {\n    return 해시 == 프로필해시(언어번호) ||\n      해시 == \"fc2d4f6d835c0eaab781d13047812e998f3416ad9b94b1470b78111b3a68e4e7\"\n  }\n  if 언어번호 == 10 {\n    return 해시 == 프로필해시(언어번호) ||\n      해시 == \"14b680b294d36fca30ba6c9d2a466c45afbc62de9fbc572fdad68b05bf95c502\"\n  }\n  if 언어번호 == 11 {\n    return 해시 == 프로필해시(언어번호) ||\n      해시 == \"04e2d104948d2f2b19c30e957c1da39d64562353aeb32f77761004ac6a0aa505\"\n  }\n  if 언어번호 == 12 {\n    return 해시 == 프로필해시(언어번호) ||\n      해시 == \"26d5681f3e6b8f438721b9981ae12c1d5a27b971f826025e165fb5d00d1c1a30\"\n  }\n  if 언어번호 == 13 {\n    return 해시 == 프로필해시(언어번호) ||\n      해시 == \"e17c4ceee236086fdccf627eab4580b51b2f2eae1d88cb199ce5724036cc5b3c\"\n  }\n  if 언어번호 == 14 {\n    return 해시 == 프로필해시(언어번호) ||\n      해시 == \"5e466bca2f7eacc14d72d9d9d43181ddca4077105604bf4ff3856420279a2a70\"\n  }\n  if 언어번호 == 15 {\n    return 해시 == 프로필해시(언어번호) ||\n      해시 == \"ade0d3b29a6937bf9417202e7ef3bbf34d0ed993df5b852d9890ccee6c9294be\"\n  }\n  if 언어번호 == 16 {\n    return 해시 == 프로필해시(언어번호) ||\n      해시 == \"c0c24fe0387c00db24380c9390bdb042df30ba683a82b57d3552f0b4b987b42a\"\n  }\n  if 언어번호 == 17 {\n    return 해시 == 프로필해시(언어번호) ||\n      해시 == \"c68be5eeef2ad90c3dffac79635a710b12976281c868c7647577b158681f6a17\"\n  }\n  if 언어번호 == 18 {\n    return 해시 == 프로필해시(언어번호) ||\n      해시 == \"82ef222bdafce8a2b75b341148ea5c47c59a96460f6b50bfdf50a5cc82a10e37\"\n  }\n  if 언어번호 == 19 {\n    return 해시 == 프로필해시(언어번호) ||\n      해시 == \"a48dfc56c48f7b348cb35d2b99600e45e8079049ae4a614c644c7ccb1643294e\"\n  }\n  if 언어번호 == 21 {\n    return 해시 == 프로필해시(언어번호) ||\n      해시 == \"11cbaea1865e3ee10616a823e5ade7a1f7bbce51b079aaab5de06a65cc013907\"\n  }\n  if 언어번호 == 20 {\n    return 해시 == 프로필해시(언어번호) ||\n      해시 == \"0cd672b3d723396b73ad715748829e3c1c0ccee03748cd1436a1caff46e7271d\"\n  }\n  if 언어번호 == 22 {\n    return 해시 == 프로필해시(언어번호) ||\n      해시 == \"5765d97a1cfa05f82dc0ba98758f9832c6838d98d47372516bf0f660947f08a3\"\n  }\n  if 언어번호 == 23 {\n    return 해시 == 프로필해시(언어번호) ||\n      해시 == \"8000923ad434d7623a8abe74802cc73bde081ab931de14ffd162da85618dafa2\"\n  }\n  if 언어번호 == 24 {\n    return 해시 == 프로필해시(언어번호) ||\n      해시 == \"786c7f51e3a9343d09e66e4a8d5b8698b4478eb69d94637009af2bb57f4ec6d3\"\n  }\n  if 언어번호 == 25 {\n    return 해시 == 프로필해시(언어번호) ||\n      해시 == \"d9238804d40604de7e8a859e5fe7820698b71644efb1f3cca6a653d4344aa9af\"\n  }\n  if 언어번호 == 26 {\n    return 해시 == 프로필해시(언어번호) ||\n      해시 == \"709ce0c4ebd1aa41a3baeb8aecfa8c2bd0fd938860be0a061c095d4c9e40b6d3\"\n  }\n  if 언어번호 == 27 {\n    return 해시 == 프로필해시(언어번호) ||\n      해시 == \"e9ef6119924ebcd7e943010feda0b1cb83f4c19168763a6c76c343291c8a6cd3\"\n  }\n  if 언어번호 == 28 {\n    return 해시 == 프로필해시(언어번호) ||\n      해시 == \"4cd5cc449f6b8770983d936ff0329ae886b59be6c1fac94dfb5acebb26eeffa8\"\n  }\n  if 언어번호 == 29 {\n    return 해시 == 프로필해시(언어번호) ||\n      해시 == \"a16808e3e3104e88d968e1a3109e9d3b6880eac67375a140bc4adc14917b44f5\"\n  }\n  if 언어번호 == 30 {\n    return 해시 == 프로필해시(언어번호) ||\n      해시 == \"504196b395c1fd82a46efbd937b33ab9ddac7d86aaff12eb201eff92429ae1ca\"\n  }\n  false\n}\n\nexport record 글꼴자모 {\n  글자: string,\n  줄들: Array<string>\n}\n\n// 책 제목을 찍는 3x5 픽셀 글꼴. 각 자모의 다섯 줄을 그대로 눕혀 두었으니\n// 소스에서 글자 모양이 보인다. 표가 곧 그림이다.\nlet 픽셀자모들 = [\n  글꼴자모 { 글자: \" \", 줄들: [\"000\",\n                              \"000\",\n                              \"000\",\n                              \"000\",\n                              \"000\"] },\n  글꼴자모 { 글자: \"A\", 줄들: [\"010\",\n                              \"101\",\n                              \"111\",\n                              \"101\",\n                              \"101\"] },\n  글꼴자모 { 글자: \"B\", 줄들: [\"110\",\n                              \"101\",\n                              \"110\",\n                              \"101\",\n                              \"110\"] },\n  글꼴자모 { 글자: \"C\", 줄들: [\"011\",\n                              \"100\",\n                              \"100\",\n                              \"100\",\n                              \"011\"] },\n  글꼴자모 { 글자: \"D\", 줄들: [\"110\",\n                              \"101\",\n                              \"101\",\n                              \"101\",\n                              \"110\"] },\n  글꼴자모 { 글자: \"E\", 줄들: [\"111\",\n                              \"100\",\n                              \"110\",\n                              \"100\",\n                              \"111\"] },\n  글꼴자모 { 글자: \"F\", 줄들: [\"111\",\n                              \"100\",\n                              \"110\",\n                              \"100\",\n                              \"100\"] },\n  글꼴자모 { 글자: \"G\", 줄들: [\"011\",\n                              \"100\",\n                              \"101\",\n                              \"101\",\n                              \"011\"] },\n  글꼴자모 { 글자: \"H\", 줄들: [\"101\",\n                              \"101\",\n                              \"111\",\n                              \"101\",\n                              \"101\"] },\n  글꼴자모 { 글자: \"I\", 줄들: [\"111\",\n                              \"010\",\n                              \"010\",\n                              \"010\",\n                              \"111\"] },\n  글꼴자모 { 글자: \"J\", 줄들: [\"001\",\n                              \"001\",\n                              \"001\",\n                              \"101\",\n                              \"010\"] },\n  글꼴자모 { 글자: \"K\", 줄들: [\"101\",\n                              \"101\",\n                              \"110\",\n                              \"101\",\n                              \"101\"] },\n  글꼴자모 { 글자: \"L\", 줄들: [\"100\",\n                              \"100\",\n                              \"100\",\n                              \"100\",\n                              \"111\"] },\n  글꼴자모 { 글자: \"M\", 줄들: [\"101\",\n                              \"111\",\n                              \"111\",\n                              \"101\",\n                              \"101\"] },\n  글꼴자모 { 글자: \"N\", 줄들: [\"101\",\n                              \"111\",\n                              \"111\",\n                              \"111\",\n                              \"101\"] },\n  글꼴자모 { 글자: \"O\", 줄들: [\"010\",\n                              \"101\",\n                              \"101\",\n                              \"101\",\n                              \"010\"] },\n  글꼴자모 { 글자: \"P\", 줄들: [\"110\",\n                              \"101\",\n                              \"110\",\n                              \"100\",\n                              \"100\"] },\n  글꼴자모 { 글자: \"Q\", 줄들: [\"010\",\n                              \"101\",\n                              \"101\",\n                              \"111\",\n                              \"011\"] },\n  글꼴자모 { 글자: \"R\", 줄들: [\"110\",\n                              \"101\",\n                              \"110\",\n                              \"101\",\n                              \"101\"] },\n  글꼴자모 { 글자: \"S\", 줄들: [\"011\",\n                              \"100\",\n                              \"010\",\n                              \"001\",\n                              \"110\"] },\n  글꼴자모 { 글자: \"T\", 줄들: [\"111\",\n                              \"010\",\n                              \"010\",\n                              \"010\",\n                              \"010\"] },\n  글꼴자모 { 글자: \"U\", 줄들: [\"101\",\n                              \"101\",\n                              \"101\",\n                              \"101\",\n                              \"111\"] },\n  글꼴자모 { 글자: \"V\", 줄들: [\"101\",\n                              \"101\",\n                              \"101\",\n                              \"101\",\n                              \"010\"] },\n  글꼴자모 { 글자: \"W\", 줄들: [\"101\",\n                              \"101\",\n                              \"111\",\n                              \"111\",\n                              \"101\"] },\n  글꼴자모 { 글자: \"X\", 줄들: [\"101\",\n                              \"101\",\n                              \"010\",\n                              \"101\",\n                              \"101\"] },\n  글꼴자모 { 글자: \"Y\", 줄들: [\"101\",\n                              \"101\",\n                              \"010\",\n                              \"010\",\n                              \"010\"] },\n  글꼴자모 { 글자: \"Z\", 줄들: [\"111\",\n                              \"001\",\n                              \"010\",\n                              \"100\",\n                              \"111\"] },\n  글꼴자모 { 글자: \"0\", 줄들: [\"111\",\n                              \"101\",\n                              \"101\",\n                              \"101\",\n                              \"111\"] },\n  글꼴자모 { 글자: \"1\", 줄들: [\"010\",\n                              \"110\",\n                              \"010\",\n                              \"010\",\n                              \"111\"] },\n  글꼴자모 { 글자: \"2\", 줄들: [\"110\",\n                              \"001\",\n                              \"111\",\n                              \"100\",\n                              \"111\"] },\n  글꼴자모 { 글자: \"3\", 줄들: [\"110\",\n                              \"001\",\n                              \"110\",\n                              \"001\",\n                              \"110\"] },\n  글꼴자모 { 글자: \"4\", 줄들: [\"101\",\n                              \"101\",\n                              \"111\",\n                              \"001\",\n                              \"001\"] },\n  글꼴자모 { 글자: \"5\", 줄들: [\"111\",\n                              \"100\",\n                              \"110\",\n                              \"001\",\n                              \"110\"] },\n  글꼴자모 { 글자: \"6\", 줄들: [\"011\",\n                              \"100\",\n                              \"110\",\n                              \"101\",\n                              \"010\"] },\n  글꼴자모 { 글자: \"7\", 줄들: [\"111\",\n                              \"001\",\n                              \"010\",\n                              \"010\",\n                              \"010\"] },\n  글꼴자모 { 글자: \"8\", 줄들: [\"010\",\n                              \"101\",\n                              \"010\",\n                              \"101\",\n                              \"010\"] },\n  글꼴자모 { 글자: \"9\", 줄들: [\"010\",\n                              \"101\",\n                              \"011\",\n                              \"001\",\n                              \"110\"] },\n  글꼴자모 { 글자: \".\", 줄들: [\"000\",\n                              \"000\",\n                              \"000\",\n                              \"000\",\n                              \"010\"] },\n  글꼴자모 { 글자: \",\", 줄들: [\"000\",\n                              \"000\",\n                              \"000\",\n                              \"010\",\n                              \"100\"] },\n  글꼴자모 { 글자: \":\", 줄들: [\"000\",\n                              \"010\",\n                              \"000\",\n                              \"010\",\n                              \"000\"] },\n  글꼴자모 { 글자: \";\", 줄들: [\"000\",\n                              \"010\",\n                              \"000\",\n                              \"010\",\n                              \"100\"] },\n  글꼴자모 { 글자: \"!\", 줄들: [\"010\",\n                              \"010\",\n                              \"010\",\n                              \"000\",\n                              \"010\"] },\n  글꼴자모 { 글자: \"?\", 줄들: [\"110\",\n                              \"001\",\n                              \"010\",\n                              \"000\",\n                              \"010\"] },\n  글꼴자모 { 글자: \"/\", 줄들: [\"001\",\n                              \"001\",\n                              \"010\",\n                              \"100\",\n                              \"100\"] },\n  글꼴자모 { 글자: \"+\", 줄들: [\"000\",\n                              \"010\",\n                              \"111\",\n                              \"010\",\n                              \"000\"] },\n  글꼴자모 { 글자: \"-\", 줄들: [\"000\",\n                              \"000\",\n                              \"111\",\n                              \"000\",\n                              \"000\"] },\n  글꼴자모 { 글자: \"_\", 줄들: [\"000\",\n                              \"000\",\n                              \"000\",\n                              \"000\",\n                              \"111\"] },\n  글꼴자모 { 글자: \"=\", 줄들: [\"000\",\n                              \"111\",\n                              \"000\",\n                              \"111\",\n                              \"000\"] },\n  글꼴자모 { 글자: \"(\", 줄들: [\"001\",\n                              \"010\",\n                              \"010\",\n                              \"010\",\n                              \"001\"] },\n  글꼴자모 { 글자: \")\", 줄들: [\"100\",\n                              \"010\",\n                              \"010\",\n                              \"010\",\n                              \"100\"] },\n  글꼴자모 { 글자: \"#\", 줄들: [\"101\",\n                              \"111\",\n                              \"101\",\n                              \"111\",\n                              \"101\"] },\n  글꼴자모 { 글자: \"&\", 줄들: [\"010\",\n                              \"101\",\n                              \"010\",\n                              \"101\",\n                              \"011\"] },\n]\n\nexport function 픽셀글꼴(글자: string) -> string {\n  for 자모 in 픽셀자모들 {\n    if 자모.글자 == 글자 {\n      let mut 비트들 = \"\"\n      for 줄 in 자모.줄들 { 비트들 = 비트들 + 줄 }\n      return 비트들\n    }\n  }\n  \"\"\n}\n\nexport function 보호길이(논리길이: int) -> int { ((논리길이 + 222) / 223) * 255 }\n\nexport function 이미지배치계산(노드수: int, 보호바이트수: int, 크롬번호: int) -> Result<이미지배치, string> {\n  if 노드수 <= 0 { return Err(\"쪽에는 노드가 하나 이상 있어야 합니다\") }\n  let 판행수 = (노드수 + 11) / 12\n  let 판높이 = 판행수 * 36 - 6\n  let 띠위 = 71 + 판높이 + 24\n  let 띠행수 = 큰값(1, (보호바이트수 + 161) / 162)\n  let 꼬리높이 = if 크롬번호 == 1 { 64 } else { 24 }\n  let 높이 = 띠위 + 띠행수 * 2 + 꼬리높이\n  if 높이 > 2800 || 높이 > 65535 || 띠행수 > 65535 { return Err(\"쪽이 2800픽셀 예산을 넘습니다\") }\n  Ok(이미지배치 { 너비: 1304, 높이: 높이, 판행수: 판행수, 판높이: 판높이, 띠위: 띠위, 띠행수: 띠행수, 꼬리높이: 꼬리높이 })\n}\n\nexport function 배열에있음(값들: Array<int>, 찾기: int) -> bool {\n  for 값 in 값들 { if 값 == 찾기 { return true } }\n  false\n}\n\nexport function 범위코드(언어번호: int, 코드: int) -> bool {\n  if 언어번호 == 1 { return 배열에있음([141, 419, 307, 188], 코드) && 코드 != 239 && 코드 != 419 }\n  if 언어번호 == 2 { return 배열에있음([398, 128, 281, 65, 232, 75, 359, 413], 코드) && 코드 != 209 && 코드 != 128 }\n  if 언어번호 == 24 { return 코드 == 201 }\n  if 언어번호 == 26 { return 코드 == 37 }\n  if 언어번호 == 29 { return 코드 == 53 }\n  if 언어번호 == 30 { return 코드 == 101 || 코드 == 350 }\n  false\n}\n\nexport function 파일프로그램코드(언어번호: int, 코드: int) -> bool {\n  if 언어번호 == 1 { return 코드 == 239 || 코드 == 419 }\n  if 언어번호 == 2 { return 코드 == 209 || 코드 == 128 }\n  if 언어번호 == 3 { return 코드 == 243 }\n  if 언어번호 == 4 { return 코드 == 47 }\n  if 언어번호 == 5 { return 코드 == 297 }\n  if 언어번호 == 6 { return 코드 == 357 }\n  if 언어번호 == 7 { return 코드 == 289 }\n  if 언어번호 == 8 { return 코드 == 232 }\n  if 언어번호 == 9 { return 코드 == 229 }\n  if 언어번호 == 10 { return 코드 == 184 }\n  if 언어번호 == 11 { return 코드 == 168 }\n  if 언어번호 == 24 { return 코드 == 200 }\n  if 언어번호 == 25 { return 코드 == 220 }\n  코드 == 36\n}\n\nexport function 쪽투영문자열(쪽들: Array<이미지쪽계획>) -> Result<string, string> {\n  let mut 글 = \"[\"\n  let mut 색인 = 0\n  while 색인 < 쪽들.length {\n    if 색인 > 0 { 글 = 글 + \",\" }\n    let 쪽 = 쪽들[색인]\n    글 = 글 + \"\\{\" + json.stringify(\"logicalEnd\")? + \":\" + \"{쪽.논리끝}\" + \",\" + json.stringify(\"logicalStart\")? + \":\" + \"{쪽.논리시작}\" +\n      \",\" + json.stringify(\"nodeEnd\")? + \":\" + \"{쪽.노드끝}\" + \",\" + json.stringify(\"nodeStart\")? + \":\" + \"{쪽.노드시작}\" +\n      \",\" + json.stringify(\"pageIndex\")? + \":\" + \"{쪽.쪽번호}\" + \"\\}\"\n    색인 = 색인 + 1\n  }\n  Ok(글 + \"]\")\n}\n",
      "sourceSha256": "522f90714963c59fafc32fe81046b3afb3ce4d68aa576c4651611cf0fad82639"
    },
    {
      "path": "topaz/src/print.tpz",
      "language": "topaz",
      "bytes": 15239,
      "sha256": "b4df54de87bc5576ab422573e52911fa65f4a996a8aac989993f4b5ed3b30fc6",
      "content": "// Printer piece ropes, text and JSON field helpers, and the one source cursor\n// every printer advances.\n\nimport std.json\nimport schema { 들여쓰기 }\nimport types { 인쇄조각범위, 인쇄조각판 }\n\nexport function 인쇄조각판만들기() -> 인쇄조각판 {\n  인쇄조각판 {\n    종류들: [0], 글들: [\"\"], 왼들: [-1], 오른들: [-1],\n    시작들: [0], 끝들: [0], 횟수들: [0], 길이들: [0],\n    행수들: [0], 첫글들: [\"\"], 끝글들: [\"\"]\n  }\n}\n\nfunction 글행사건수(글자들: Array<string>) -> int {\n  let mut 행수 = 0\n  let mut 색인 = 0\n  while 색인 < 글자들.length {\n    let 글자 = 글자들[색인]\n    if 글자 == \"\\r\" && 색인 + 1 < 글자들.length && 글자들[색인 + 1] == \"\\n\" {\n      행수 = 행수 + 1\n      색인 = 색인 + 2\n      continue\n    }\n    if 글자 == \"\\n\" || 글자 == \"\\r\" || 글자 == \" \" || 글자 == \" \" {\n      행수 = 행수 + 1\n    }\n    색인 = 색인 + 1\n  }\n  행수\n}\n\nexport function 인쇄글조각(판: 인쇄조각판, 글: string) -> int {\n  let 글자들 = 글.scalars()\n  if 글자들.length == 0 { return 0 }\n  let 번호 = 판.종류들.length\n  let mut 종류들 = 판.종류들; let mut 글들 = 판.글들\n  let mut 왼들 = 판.왼들; let mut 오른들 = 판.오른들\n  let mut 시작들 = 판.시작들; let mut 끝들 = 판.끝들\n  let mut 횟수들 = 판.횟수들; let mut 길이들 = 판.길이들\n  let mut 행수들 = 판.행수들\n  let mut 첫글들 = 판.첫글들; let mut 끝글들 = 판.끝글들\n  종류들.push(1); 글들.push(글); 왼들.push(-1); 오른들.push(-1)\n  시작들.push(0); 끝들.push(글자들.length); 횟수들.push(1)\n  길이들.push(글자들.length); 행수들.push(글행사건수(글자들)); 첫글들.push(글자들[0])\n  끝글들.push(글자들[글자들.length - 1])\n  번호\n}\n\nexport function 인쇄조각이음(판: 인쇄조각판, 왼: int, 오른: int) -> int {\n  if 왼 == 0 { return 오른 }\n  if 오른 == 0 { return 왼 }\n  let 번호 = 판.종류들.length\n  let mut 종류들 = 판.종류들; let mut 글들 = 판.글들\n  let mut 왼들 = 판.왼들; let mut 오른들 = 판.오른들\n  let mut 시작들 = 판.시작들; let mut 끝들 = 판.끝들\n  let mut 횟수들 = 판.횟수들; let mut 길이들 = 판.길이들\n  let mut 행수들 = 판.행수들\n  let mut 첫글들 = 판.첫글들; let mut 끝글들 = 판.끝글들\n  종류들.push(2); 글들.push(\"\"); 왼들.push(왼); 오른들.push(오른)\n  시작들.push(0); 끝들.push(0); 횟수들.push(1)\n  길이들.push(길이들[왼] + 길이들[오른])\n  행수들.push(\n    행수들[왼] + 행수들[오른] -\n      (if 끝글들[왼] == \"\\r\" && 첫글들[오른] == \"\\n\" { 1 } else { 0 })\n  )\n  첫글들.push(첫글들[왼]); 끝글들.push(끝글들[오른])\n  번호\n}\n\nfunction 인쇄조각반복(판: 인쇄조각판, 글: string, 횟수: int) -> Result<int, string> {\n  let 글자들 = 글.scalars()\n  if 횟수 <= 0 || 글자들.length == 0 { return Ok(0) }\n  if 횟수 == 1 { return Ok(인쇄글조각(판, 글)) }\n  if 글자들.length > 2147483647 / 횟수 { return Err(\"인쇄 조각 반복 길이가 너무 큽니다\") }\n  let 번호 = 판.종류들.length\n  let mut 종류들 = 판.종류들; let mut 글들 = 판.글들\n  let mut 왼들 = 판.왼들; let mut 오른들 = 판.오른들\n  let mut 시작들 = 판.시작들; let mut 끝들 = 판.끝들\n  let mut 횟수들 = 판.횟수들; let mut 길이들 = 판.길이들\n  let mut 행수들 = 판.행수들\n  let mut 첫글들 = 판.첫글들; let mut 끝글들 = 판.끝글들\n  종류들.push(4); 글들.push(글); 왼들.push(-1); 오른들.push(-1)\n  시작들.push(0); 끝들.push(글자들.length); 횟수들.push(횟수)\n  길이들.push(글자들.length * 횟수)\n  행수들.push(\n    글행사건수(글자들) * 횟수 -\n      (if 글자들[글자들.length - 1] == \"\\r\" && 글자들[0] == \"\\n\" { 횟수 - 1 } else { 0 })\n  )\n  첫글들.push(글자들[0])\n  끝글들.push(글자들[글자들.length - 1])\n  Ok(번호)\n}\n\nfunction 인쇄조각글자들(판: 인쇄조각판, 뿌리: int) -> Result<Array<string>, string> {\n  if 뿌리 < 0 || 뿌리 >= 판.종류들.length { return Err(\"인쇄 조각 번호가 범위를 벗어났습니다\") }\n  let mut 결과: Array<string> = []\n  let mut 일들: Array<인쇄조각범위> = [\n    인쇄조각범위 { 조각: 뿌리, 시작: 0, 끝: 판.길이들[뿌리] }\n  ]\n  let mut 꼭대기 = 1\n  let mut 단계수 = 0\n  let 최대단계수 = 판.종류들.length * 4 + 판.길이들[뿌리] + 16\n  while 꼭대기 > 0 {\n    단계수 = 단계수 + 1\n    if 단계수 > 최대단계수 { return Err(\"인쇄 조각 순회 단계 한도를 넘었습니다\") }\n    꼭대기 = 꼭대기 - 1\n    let 일 = 일들[꼭대기]\n    if 일.시작 < 0 || 일.끝 < 일.시작 || 일.끝 > 판.길이들[일.조각] {\n      return Err(\"인쇄 조각 범위가 틀립니다\")\n    }\n    if 일.시작 < 일.끝 {\n      let 종류 = 판.종류들[일.조각]\n      if 종류 == 1 {\n        let 글자들 = 판.글들[일.조각].scalars()\n        let mut 색인 = 일.시작\n        while 색인 < 일.끝 { 결과.push(글자들[색인]); 색인 = 색인 + 1 }\n      } else if 종류 == 2 {\n        let 왼 = 판.왼들[일.조각]\n        let 오른 = 판.오른들[일.조각]\n        let 왼길이 = 판.길이들[왼]\n        let 오른시작 = if 일.시작 > 왼길이 { 일.시작 - 왼길이 } else { 0 }\n        let 오른끝 = if 일.끝 > 왼길이 { 일.끝 - 왼길이 } else { 0 }\n        if 오른시작 < 오른끝 {\n          let 오른일 = 인쇄조각범위 { 조각: 오른, 시작: 오른시작, 끝: 오른끝 }\n          if 꼭대기 < 일들.length { 일들[꼭대기] = 오른일 } else { 일들.push(오른일) }\n          꼭대기 = 꼭대기 + 1\n        }\n        let 왼시작 = if 일.시작 < 왼길이 { 일.시작 } else { 왼길이 }\n        let 왼끝 = if 일.끝 < 왼길이 { 일.끝 } else { 왼길이 }\n        if 왼시작 < 왼끝 {\n          let 왼일 = 인쇄조각범위 { 조각: 왼, 시작: 왼시작, 끝: 왼끝 }\n          if 꼭대기 < 일들.length { 일들[꼭대기] = 왼일 } else { 일들.push(왼일) }\n          꼭대기 = 꼭대기 + 1\n        }\n      } else if 종류 == 3 {\n        let 원본 = 판.왼들[일.조각]\n        let 원본일 = 인쇄조각범위 {\n          조각: 원본,\n          시작: 판.시작들[일.조각] + 일.시작,\n          끝: 판.시작들[일.조각] + 일.끝\n        }\n        if 꼭대기 < 일들.length { 일들[꼭대기] = 원본일 } else { 일들.push(원본일) }\n        꼭대기 = 꼭대기 + 1\n      } else if 종류 == 4 {\n        let 글자들 = 판.글들[일.조각].scalars()\n        let mut 색인 = 일.시작\n        while 색인 < 일.끝 {\n          결과.push(글자들[색인 % 글자들.length])\n          색인 = 색인 + 1\n        }\n      } else if 종류 != 0 {\n        return Err(\"인쇄 조각 종류가 틀립니다\")\n      }\n    }\n  }\n  Ok(결과)\n}\n\nexport function 인쇄조각자름(판: 인쇄조각판, 원본: int, 시작: int, 끝: int) -> Result<int, string> {\n  if 원본 < 0 || 원본 >= 판.종류들.length { return Err(\"인쇄 조각 번호가 범위를 벗어났습니다\") }\n  if 시작 < 0 || 끝 < 시작 || 끝 > 판.길이들[원본] { return Err(\"인쇄 조각 자름 범위가 틀립니다\") }\n  if 시작 == 끝 { return Ok(0) }\n  if 시작 == 0 && 끝 == 판.길이들[원본] { return Ok(원본) }\n  let 번호 = 판.종류들.length\n  let mut 종류들 = 판.종류들; let mut 글들 = 판.글들\n  let mut 왼들 = 판.왼들; let mut 오른들 = 판.오른들\n  let mut 시작들 = 판.시작들; let mut 끝들 = 판.끝들\n  let mut 횟수들 = 판.횟수들; let mut 길이들 = 판.길이들\n  let mut 행수들 = 판.행수들\n  let mut 첫글들 = 판.첫글들; let mut 끝글들 = 판.끝글들\n  종류들.push(3); 글들.push(\"\"); 왼들.push(원본); 오른들.push(-1)\n  시작들.push(시작); 끝들.push(끝); 횟수들.push(1); 길이들.push(끝 - 시작)\n  첫글들.push(\"\"); 끝글들.push(\"\")\n  let 글자들 = 인쇄조각글자들(판, 번호)?\n  행수들.push(글행사건수(글자들))\n  첫글들[번호] = 글자들[0]; 끝글들[번호] = 글자들[글자들.length - 1]\n  Ok(번호)\n}\n\nexport function 인쇄조각평평하게(판: 인쇄조각판, 조각: int) -> Result<string, string> {\n  if 조각 == 0 { return Ok(\"\") }\n  if 조각 > 0 && 조각 < 판.종류들.length && 판.종류들[조각] == 1 {\n    return Ok(판.글들[조각])\n  }\n  let 글자들 = 인쇄조각글자들(판, 조각)?\n  Ok(글자합치기(글자들, 0, 글자들.length))\n}\n\nexport function 인쇄조각행수(판: 인쇄조각판, 조각: int) -> int {\n  판.행수들[조각]\n}\n\nexport function 인쇄조각같음(판: 인쇄조각판, 왼: int, 오른: int) -> Result<bool, string> {\n  if 판.길이들[왼] != 판.길이들[오른] { return Ok(false) }\n  let 왼글자들 = 인쇄조각글자들(판, 왼)?\n  let 오른글자들 = 인쇄조각글자들(판, 오른)?\n  let mut 색인 = 0\n  while 색인 < 왼글자들.length {\n    if 왼글자들[색인] != 오른글자들[색인] { return Ok(false) }\n    색인 = 색인 + 1\n  }\n  Ok(true)\n}\n\nexport function 인쇄조각접두(판: 인쇄조각판, 조각: int, 접두: string) -> Result<bool, string> {\n  let 접두조각 = 인쇄글조각(판, 접두)\n  if 판.길이들[접두조각] > 판.길이들[조각] { return Ok(false) }\n  let 앞 = 인쇄조각자름(판, 조각, 0, 판.길이들[접두조각])?\n  인쇄조각같음(판, 앞, 접두조각)\n}\n\nexport function 인쇄조각접미(판: 인쇄조각판, 조각: int, 접미: string) -> Result<bool, string> {\n  let 접미조각 = 인쇄글조각(판, 접미)\n  if 판.길이들[접미조각] > 판.길이들[조각] { return Ok(false) }\n  let 뒤 = 인쇄조각자름(판, 조각, 판.길이들[조각] - 판.길이들[접미조각], 판.길이들[조각])?\n  인쇄조각같음(판, 뒤, 접미조각)\n}\n\nexport function 글자합치기(글자들: Array<string>, 시작: int, 끝: int) -> string {\n  글자들.slice(시작, 끝).join(\"\")\n}\n\nexport function 글평평하게(글: string) -> string {\n  let 글자들 = 글.scalars()\n  글자합치기(글자들, 0, 글자들.length)\n}\n\nexport function 제이슨문자필드(뿌리: JSONValue, 이름: string) -> Result<string, string> {\n  match 뿌리.get(이름).flatMap((값) => 값.asString()) {\n    case Some(글) => Ok(글)\n    case None => Err(\"분리 본문 키의 {이름} 필드가 문자열이 아닙니다\")\n  }\n}\n\nexport function 제이슨정수필드(뿌리: JSONValue, 이름: string) -> Result<int, string> {\n  match 뿌리.get(이름).flatMap((값) => 값.asInt()) {\n    case Some(수) => Ok(수)\n    case None => Err(\"분리 본문 키의 {이름} 필드가 정수가 아닙니다\")\n  }\n}\n\n// 언어마다 분리 댓글로 다루는 코드워드다. 러스트는 여기에 없다. 러스트의\n// 주석은 원본 인쇄 경로가 잎 토큰으로 직접 나르기 때문이다.\nexport function 댓글코드(언어번호: int, 코드워드: int) -> bool {\n  if 언어번호 == 1 { return 코드워드 == 7 || 코드워드 == 205 }\n  if 언어번호 == 2 { return 코드워드 == 349 || 코드워드 == 392 }\n  if 언어번호 == 3 { return 코드워드 == 289 }\n  if 언어번호 == 4 { return 코드워드 == 43 }\n  if 언어번호 == 5 { return false }\n  if 언어번호 == 6 { return false }\n  if 언어번호 == 7 { return false }\n  if 언어번호 == 8 { return false }\n  if 언어번호 == 9 { return false }\n  false\n}\n\nexport function 줄과들여쓰기(줄수: int, 깊이: int) -> string {\n  let mut 글 = \"\"; let mut 남음 = 줄수\n  while 남음 > 0 { 글 = 글 + \"\\n\" + 들여쓰기(깊이); 남음 = 남음 - 1 }\n  글\n}\n\n// 인쇄는 재귀 대신 명시적 호출 더미로 돈다. 깊이는 힙에 쌓이고\n// 네이티브 스택은 한 층에 머무니 깊은 나무도 두렵지 않다.\nexport record 인쇄호출 {\n  모드: int,\n  순번: int,\n  깊이: int\n}\n\n// 파이썬과 고와 러스트와 자바는 잎 토큰의 행과 칸 간격에서 원형을 복원한다.\n// 들여쓰기가 문법인 언어에서는 배치가 곧 구조다.\n// 세 언어의 원본 인쇄가 같은 손질을 쓴다. 줄 끝의 공백을 걷어내고\n// 줄바꿈 여부를 살피는 일에는 언어의 사투리가 없다.\nexport function 끝공백제거(글: string) -> string {\n  let 글자들 = 글.scalars()\n  let mut 끝 = 글자들.length\n  while 끝 > 0 {\n    let 글자 = 글자들[끝 - 1]\n    if 글자 != \" \" && 글자 != \"\\t\" && 글자 != \"\\n\" && 글자 != \"\\r\" { break }\n    끝 = 끝 - 1\n  }\n  글자합치기(글자들, 0, 끝)\n}\n\nexport function 줄끝인가(글: string) -> bool {\n  let 글자들 = 글.scalars()\n  if 글자들.length == 0 { return false }\n  let 끝 = 글자들[글자들.length - 1]\n  끝 == \"\\n\" || 끝 == \"\\r\"\n}\n\nexport function 고여는구분자(글: string) -> bool {\n  if 글 == \"\\{\" { return true }\n  if 글 == \"(\" { return true }\n  글 == \"[\"\n}\n\nexport function 고닫는구분자(글: string) -> bool {\n  if 글 == \"\\}\" { return true }\n  if 글 == \")\" { return true }\n  글 == \"]\"\n}\n\n// There is exactly ONE guest cursor. Which scalars end a row and how\n// wide a scalar is are parameters supplied by the caller from the language's\n// declared carried geometry (printer_cursor.tpz `언어행종결자` / `언어열규칙`), never\n// properties of whichever helper a printer happened to forward to. Forwarding\n// aliases are what let the Elm, PHP and Solidity printers measure their output\n// with a terminator their kernel counterparts do not use, so there are none.\n//   복귀행종결: false = a row ends on a line feed alone and a lone carriage\n//               return is a column; true = a lone carriage return also ends a\n//               row and CRLF ends exactly one.\n//   열규칙:     0 = one column per scalar; 1 = UTF-8 bytes per scalar;\n//               2 = a carriage return takes no column at all.\nexport function 위치전진(\n  복귀행종결: bool,\n  열규칙: int,\n  행: int,\n  열: int,\n  본문: string\n) -> Array<int> {\n  let mut 현재행 = 행\n  let mut 현재열 = 열\n  let mut 이전복귀 = false\n  let 글자들 = 본문.scalars()\n  let mut 색인 = 0\n  while 색인 < 글자들.length {\n    let 글자 = 글자들[색인]\n    if 글자 == \"\\r\" && 복귀행종결 {\n      현재행 = 현재행 + 1\n      현재열 = 0\n      이전복귀 = true\n    } else if 글자 == \"\\n\" {\n      if !이전복귀 { 현재행 = 현재행 + 1 }\n      현재열 = 0\n      이전복귀 = false\n    } else if 글자 == \"\\r\" && 열규칙 == 2 {\n      이전복귀 = false\n    } else {\n      현재열 = 현재열 +\n        (if 열규칙 == 1 { 글자.encodeUtf8().length() } else { 1 })\n      이전복귀 = false\n    }\n    색인 = 색인 + 1\n  }\n  [현재행, 현재열]\n}\n\nexport function 끝가로공백제거(글: string) -> string {\n  let 글자들 = 글.scalars()\n  let mut 끝 = 글자들.length\n  while 끝 > 0 {\n    let 글자 = 글자들[끝 - 1]\n    if 글자 != \" \" && 글자 != \"\\t\" { break }\n    끝 = 끝 - 1\n  }\n  글자합치기(글자들, 0, 끝)\n}\n",
      "sourceSha256": "b4df54de87bc5576ab422573e52911fa65f4a996a8aac989993f4b5ed3b30fc6"
    },
    {
      "path": "topaz/src/printer_common.tpz",
      "language": "topaz",
      "bytes": 1298,
      "sha256": "b0e419666b7604027fe55327b5842b9e59c36d721bc7a055492f4bf7d3b10f8d",
      "content": "// Leading-layout and source-order checks shared by several language printers.\n\nimport structure { 구조노드, 구조스칼라, 구조입력, 노드스칼라 }\n\nexport function 선행가로배치인가(노드: 구조노드, 수직탭허용: bool, 줄바꿈허용: bool) -> bool {\n  let 값 = 노드스칼라(노드, \"leadingHorizontalLayout\")\n  if 값.필드 == \"\" || 값.태그 != 5 { return false }\n  let 수직탭 = (11).toCodePoint() ?? \"\"\n  let 폼피드 = (12).toCodePoint() ?? \"\"\n  let 복귀 = (13).toCodePoint() ?? \"\"\n  let 글자들 = 값.문자열값.scalars()\n  if 글자들.length == 0 { return false }\n  for 글자 in 글자들 {\n    if 글자 != \" \" && 글자 != \"\\t\" && 글자 != 폼피드 &&\n      (!수직탭허용 || 글자 != 수직탭) &&\n      (!줄바꿈허용 || (글자 != \"\\n\" && 글자 != 복귀)) { return false }\n  }\n  true\n}\n\nexport function 오브젝티브씨잎앞섬(구조: 구조입력, 왼쪽: int, 오른쪽: int) -> bool {\n  let 왼쪽노드 = 구조.노드들[왼쪽]\n  let 오른쪽노드 = 구조.노드들[오른쪽]\n  if 왼쪽노드.시작 != 오른쪽노드.시작 {\n    return 왼쪽노드.시작 < 오른쪽노드.시작\n  }\n  if 왼쪽노드.끝 != 오른쪽노드.끝 {\n    return 왼쪽노드.끝 < 오른쪽노드.끝\n  }\n  왼쪽 < 오른쪽\n}\n",
      "sourceSha256": "b0e419666b7604027fe55327b5842b9e59c36d721bc7a055492f4bf7d3b10f8d"
    },
    {
      "path": "topaz/src/printer_cursor.tpz",
      "language": "topaz",
      "bytes": 3917,
      "sha256": "7aaf7d9dbd2746770a097c20e7dcd6930c7e9764423babed22cb2dd80651d11a",
      "content": "// Row terminators, column rules, and the source cursor every language printer\n// measures its own output with.\n\nimport print { 위치전진 }\nimport structure { 구조노드, 스칼라문자, 스칼라있음, 스칼라정수 }\n\n// The row terminator and the column width are declared properties of a\n// LANGUAGE's carried geometry - the row oracle its kernel projection printer\n// splits its own emitted text on - and never properties of whichever cursor a\n// guest printer forwards to. These two declarations plus the one dispatcher\n// below are the whole guest-side model: every guest printer calls\n// `본문위치전진` with its own language number, so it cannot measure its output\n// with a terminator its kernel counterpart does not use.\n// topaz/courts/printer-identity.test.mjs derives each shipped language's rule\n// from packages/kernel/src/<lang>-projection-to-source.ts and asserts these\n// declarations against it, so a drift is a red court rather than a silent byte\n// divergence.\n//\n// A lone carriage return ends a row for exactly the languages whose kernel\n// printer splits its emitted text on the carriage-return-or-line-feed row\n// pattern: java 6, c 7, cpp 8,\n// dart 15, haskell 17, r 19, rescript 23, objc 25, elisp 26, zig 28. Every\n// other shipped language's kernel printer splits on the line feed alone, which\n// makes a lone carriage return inside a token a scalar column.\nfunction 언어행종결자(언어번호: int) -> bool {\n  언어번호 == 6 || 언어번호 == 7 || 언어번호 == 8 || 언어번호 == 15 ||\n    언어번호 == 17 || 언어번호 == 19 || 언어번호 == 23 || 언어번호 == 25 ||\n    언어번호 == 26 || 언어번호 == 28\n}\n\n// 0 = one column per scalar. Swift 12 measures columns in UTF-8 bytes and\n// CoffeeScript 24 gives a carriage return no column at all; both match their\n// own kernel printers' column oracles.\nfunction 언어열규칙(언어번호: int) -> int {\n  if 언어번호 == 12 { return 1 }\n  if 언어번호 == 24 { return 2 }\n  0\n}\n\nexport function 본문위치전진(언어번호: int, 행: int, 열: int, 글: string) -> Array<int> {\n  위치전진(언어행종결자(언어번호), 언어열규칙(언어번호), 행, 열, 글)\n}\n\n// C 7 is the one shipped language whose kernel row oracle is conditional on a\n// carried scalar: c-projection-to-source.ts splits on the line feed alone\n// when the image carries `loneCrLayout` and on the carriage-return-or-line-\n// feed row pattern otherwise. The\n// condition is part of the language's declaration, not a printer-local\n// override of the cursor.\nfunction 씨행종결자(단독복귀배치: bool) -> bool {\n  언어행종결자(7) && !단독복귀배치\n}\n\nexport function 씨본문위치전진(\n  단독복귀배치: bool,\n  행: int,\n  열: int,\n  글: string\n) -> Array<int> {\n  위치전진(씨행종결자(단독복귀배치), 언어열규칙(7), 행, 열, 글)\n}\n\nexport function 토파즈언어유티에프십육폭(글: string) -> int {\n  let mut 폭 = 0\n  for 글자 in 글.scalars() {\n    let 코드 = 글자.codePointAt(0) ?? 0\n    폭 = 폭 + (if 코드 > 65535 { 2 } else { 1 })\n  }\n  폭\n}\n\nexport function 러스트문자열반복(글: string, 횟수: int) -> string {\n  let mut 결과 = \"\"\n  let mut 번호 = 0\n  while 번호 < 횟수 {\n    결과 = 결과 + 글\n    번호 = 번호 + 1\n  }\n  결과\n}\n\nexport function 러스트열폭(\n  노드: 구조노드,\n  접두: string,\n  종류: string,\n  대체: int\n) -> int {\n  let 필드 = 접두 + 종류 + \"ColumnSpan\"\n  if 스칼라있음(노드, 필드) { 스칼라정수(노드, 필드) } else { 대체 }\n}\n\nexport function 러스트행들여쓰기(노드: 구조노드, 열: int) -> string {\n  if 스칼라있음(노드, \"rowIndentText\") {\n    let 들여쓰기 = 스칼라문자(노드, \"rowIndentText\")\n    if 들여쓰기.scalars().length == 열 { return 들여쓰기 }\n  }\n  러스트문자열반복(\" \", 열)\n}\n",
      "sourceSha256": "7aaf7d9dbd2746770a097c20e7dcd6930c7e9764423babed22cb2dd80651d11a"
    },
    {
      "path": "topaz/src/printer_setup.tpz",
      "language": "topaz",
      "bytes": 20247,
      "sha256": "e407a09e779f0e44da0e26c2feadb145fd77b29b712d5cc4c234174fc26aaf25",
      "content": "// Printer state construction: child links, comment tables, and anonymous\n// identifier names.\n\nimport names { 러스트짧은이름, 익명이름예약 }\nimport names.ascii { 아스키이름들 }\nimport names.c { 씨전처리예약이름들 }\nimport names.coffeescript { 커피스크립트보간이름들 }\nimport names.elisp { 이맥스리습인턴이름 }\nimport names.java { 자바정규식별자 }\nimport names.kotlin { 코틀린정규식별자 }\nimport names.objc { 오브젝티브씨전처리이름들, 오브젝티브씨정규식별자 }\nimport names.python { 파이썬후보가제안만듦 }\nimport names.ruby { 루비정규식캡처이름들 }\nimport names.rust { 러스트정규식별자 }\nimport names.scala { 스칼라감싼식별자인가, 스칼라정규식별자 }\nimport nodes { 노드종류 }\nimport print { 댓글코드, 인쇄조각판만들기 }\nimport printer_state { 고정식별자이름, 준비된인쇄상태 }\nimport structure { 구조노드, 구조입력, 스칼라문자, 스칼라있음, 스칼라정수 }\nimport types { 댓글고정 }\nimport util { 문자열배열에있음 }\n\nfunction 구조조상코드있음(구조: 구조입력, 순번: int, 코드워드: int) -> bool {\n  let mut 부모 = 구조.노드들[순번].부모순번\n  while 부모 >= 0 {\n    if 구조.노드들[부모].코드워드 == 코드워드 { return true }\n    부모 = 구조.노드들[부모].부모순번\n  }\n  false\n}\n\nfunction 구조자식필드있음(\n  구조: 구조입력,\n  부모순번: int,\n  필드: string\n) -> bool {\n  for 노드 in 구조.노드들 {\n    if 노드.부모순번 == 부모순번 && 노드.자식필드있음 &&\n      노드.자식필드 == 필드 {\n      return true\n    }\n  }\n  false\n}\n\nexport function 인쇄상태만들기(\n  언어번호: int,\n  구조: 구조입력,\n  값들: Array<string>,\n  댓글고정들: Array<댓글고정>,\n  소비추적: bool,\n  오프셋배치: bool\n) -> 준비된인쇄상태 {\n  let mut 첫자식들: Array<int> = []\n  let mut 다음형제들: Array<int> = []\n  let mut 마지막자식들: Array<int> = []\n  let mut 본문색인들: Array<int> = []\n  let mut 소비자식들: Array<bool> = []\n  let mut 인머리들: Array<bool> = []\n  let mut 기계저장세대들: Array<int> = []\n  let mut 기계저장깊이들: Array<int> = []\n  let mut 기계저장상태들: Array<int> = []\n  let mut 기계저장조각들: Array<int> = []\n  let mut 기계저장오류들: Array<string> = []\n  let mut 보존이름들: Array<string> = []\n  let mut 파이썬보이는이름들: Array<string> = []\n  let mut 댓글시작들: Array<int> = []\n  let mut 댓글끝들: Array<int> = []\n  let mut 댓글행들: Array<int> = []\n  let mut 댓글바이트누적들: Array<int> = [0]\n  let mut 줄댓글수누적들: Array<int> = [0]\n  let mut 영상댓글누적추가행들: Array<int> = []\n  let mut 식별자류수 = 0\n  let mut 순번 = 0\n  while 순번 < 구조.노드들.length {\n    첫자식들.push(-1); 다음형제들.push(-1); 마지막자식들.push(-1); 본문색인들.push(-1)\n    인머리들.push(false)\n    영상댓글누적추가행들.push(0)\n    if 소비추적 { 소비자식들.push(false) }\n    let mut 모드 = 0\n    while 모드 < 3 {\n      기계저장세대들.push(0); 기계저장깊이들.push(0)\n      기계저장상태들.push(0); 기계저장조각들.push(0); 기계저장오류들.push(\"\")\n      모드 = 모드 + 1\n    }\n    순번 = 순번 + 1\n  }\n  let mut 값색인 = 0\n  순번 = 0\n  while 순번 < 구조.노드들.length {\n    let 노드 = 구조.노드들[순번]\n    if 노드.부모순번 >= 0 {\n      let 부모 = 노드.부모순번\n      if 첫자식들[부모] < 0 { 첫자식들[부모] = 순번 }\n      else { 다음형제들[마지막자식들[부모]] = 순번 }\n      마지막자식들[부모] = 순번\n    }\n    if 노드.식별자있음 || 댓글코드(언어번호, 노드.코드워드) { 본문색인들[순번] = 값색인; 값색인 = 값색인 + 1 }\n    if 노드.식별자있음 && 식별자류수 <= 노드.식별자류번호 {\n      식별자류수 = 노드.식별자류번호 + 1\n    }\n    let 종류 = 노드종류(언어번호, 노드.코드워드)\n    if 종류 == 119 || 종류 == 120 {\n      댓글시작들.push(노드.시작)\n      댓글끝들.push(노드.끝)\n      댓글행들.push(if 종류 == 120 { 스칼라정수(노드, \"startRow\") } else { -1 })\n      댓글바이트누적들.push(\n        댓글바이트누적들[댓글바이트누적들.length - 1] + 노드.끝 - 노드.시작\n      )\n      줄댓글수누적들.push(\n        줄댓글수누적들[줄댓글수누적들.length - 1] + (if 종류 == 120 { 1 } else { 0 })\n      )\n    }\n      if !노드.식별자있음 && (종류 == 106 || 종류 == 714 ||\n        (언어번호 == 12 && 노드.코드워드 == 419) ||\n        (언어번호 == 13 && 노드.코드워드 == 393 && 스칼라정수(노드, \"childCount\") == 0) ||\n        (언어번호 == 14 && 노드.코드워드 == 416 &&\n          (스칼라정수(노드, \"childCount\") == 0 || 스칼라감싼식별자인가(구조, 순번))) ||\n        (언어번호 == 15 && 노드.코드워드 == 90 && 스칼라정수(노드, \"childCount\") == 0) ||\n        (언어번호 == 16 && 노드.코드워드 == 418 && 스칼라정수(노드, \"childCount\") == 0) ||\n        (언어번호 == 17 && 노드.코드워드 == 139 && 스칼라정수(노드, \"childCount\") == 0) ||\n        (언어번호 == 18 && 노드.코드워드 == 340 && 스칼라정수(노드, \"childCount\") == 0) ||\n        (언어번호 == 19 && 노드.코드워드 == 190 && 스칼라정수(노드, \"childCount\") == 0) ||\n        (언어번호 == 20 && 노드.코드워드 == 214 && 스칼라정수(노드, \"childCount\") == 0) ||\n        (언어번호 == 21 && (노드.코드워드 == 109 || 노드.코드워드 == 269) && 스칼라정수(노드, \"childCount\") == 0) ||\n        (언어번호 == 22 && 노드.코드워드 == 419 && 스칼라정수(노드, \"childCount\") == 0) ||\n        (언어번호 == 23 && 노드.코드워드 == 8 && 스칼라정수(노드, \"childCount\") == 0) ||\n        (언어번호 == 24 && 노드.코드워드 == 204 && 스칼라정수(노드, \"childCount\") == 0) ||\n        (언어번호 == 25 && 노드.코드워드 == 221 && 스칼라정수(노드, \"childCount\") == 0) ||\n        (언어번호 == 26 && 노드.코드워드 == 474 && 스칼라정수(노드, \"childCount\") == 0) ||\n        (언어번호 == 27 && 노드.코드워드 == 218 && 스칼라정수(노드, \"childCount\") == 0) ||\n        (언어번호 == 28 && 노드.코드워드 == 238 && 스칼라정수(노드, \"childCount\") == 0) ||\n      (언어번호 == 9 && 노드.코드워드 == 203) ||\n      (언어번호 == 4 && (노드.코드워드 == 150 || 노드.코드워드 == 208 ||\n        노드.코드워드 == 371 || 노드.코드워드 == 430 || 노드.코드워드 == 439))) {\n      let 원문이름 = 스칼라문자(노드, if 언어번호 == 3 || 언어번호 == 4 ||\n        언어번호 == 5 || 언어번호 == 6 || 언어번호 == 7 ||\n          언어번호 == 8 || 언어번호 == 9 || 언어번호 == 10 || 언어번호 == 11 || 언어번호 == 12 || 언어번호 == 13 || 언어번호 == 14 || 언어번호 == 15 || 언어번호 == 16 || 언어번호 == 17 || 언어번호 == 18 || 언어번호 == 19 || 언어번호 == 20 || 언어번호 == 21 || 언어번호 == 22 || 언어번호 == 23 || 언어번호 == 24 || 언어번호 == 25 || 언어번호 == 26 || 언어번호 == 27 || 언어번호 == 28 { \"text\" } else { \"name\" })\n      let 이름 = if 언어번호 == 3 && 종류 == 106 {\n        스칼라문자(노드, \"pythonNfkcText\")\n      } else { 원문이름 }\n      if 이름 != \"\" {\n        let 보존이름 = if 언어번호 == 5 { 러스트정규식별자(이름) }\n          else if 언어번호 == 6 { 자바정규식별자(이름) }\n          else if 언어번호 == 13 { 코틀린정규식별자(이름) }\n          else if 언어번호 == 14 { 스칼라정규식별자(이름) }\n          else if 언어번호 == 25 { 오브젝티브씨정규식별자(이름) }\n          else { 이름 }\n        if !문자열배열에있음(보존이름들, 보존이름) { 보존이름들.push(보존이름) }\n        if 언어번호 == 3 && !문자열배열에있음(파이썬보이는이름들, 이름) {\n          파이썬보이는이름들.push(이름)\n        }\n      }\n    }\n    if 언어번호 == 25 && 노드.코드워드 == 229 && 스칼라있음(노드, \"text\") {\n      for 이름 in 오브젝티브씨전처리이름들(스칼라문자(노드, \"text\")) {\n        if !문자열배열에있음(보존이름들, 이름) { 보존이름들.push(이름) }\n      }\n    }\n    if 언어번호 == 7 && 스칼라있음(노드, \"preprocessorText\") {\n      for 이름 in 씨전처리예약이름들(스칼라문자(노드, \"preprocessorText\")) {\n        if !문자열배열에있음(보존이름들, 이름) { 보존이름들.push(이름) }\n      }\n    }\n    if 언어번호 == 10 {\n      if 스칼라정수(노드, \"childCount\") == 0 &&\n        (노드.코드워드 == 119 || 구조조상코드있음(구조, 순번, 119)) {\n        for 이름 in 루비정규식캡처이름들(스칼라문자(노드, \"text\")) {\n          if !문자열배열에있음(보존이름들, 이름) { 보존이름들.push(이름) }\n        }\n      }\n      if 노드.코드워드 == 241 && 스칼라있음(노드, \"text\") &&\n        노드.부모순번 >= 0 {\n        let 부모 = 구조.노드들[노드.부모순번]\n        if 부모.코드워드 == 44 ||\n          (부모.코드워드 == 178 &&\n            !구조자식필드있음(구조, 노드.부모순번, \"value\")) {\n          let 이름 = 스칼라문자(노드, \"text\")\n          if !문자열배열에있음(보존이름들, 이름) { 보존이름들.push(이름) }\n        }\n      }\n    }\n    if 언어번호 == 24 && 스칼라있음(노드, \"text\") {\n      let mut 이름들: Array<string> = []\n      if 노드.코드워드 == 209 {\n        이름들 = 아스키이름들(스칼라문자(노드, \"text\"))\n      } else if 노드.코드워드 == 207 || 노드.코드워드 == 208 {\n        이름들 = 커피스크립트보간이름들(스칼라문자(노드, \"text\"))\n      }\n      for 이름 in 이름들 {\n        if !문자열배열에있음(보존이름들, 이름) { 보존이름들.push(이름) }\n      }\n    }\n    if 언어번호 == 26 && 노드.코드워드 == 474 && 스칼라있음(노드, \"text\") {\n      let 이름 = 이맥스리습인턴이름(스칼라문자(노드, \"text\"))\n      if !문자열배열에있음(보존이름들, 이름) { 보존이름들.push(이름) }\n    }\n    순번 = 순번 + 1\n  }\n  let mut 고정류들: Array<bool> = []\n  let mut 류 = 0\n  while 류 < 식별자류수 { 고정류들.push(false); 류 = 류 + 1 }\n  let mut 러스트최대폭들: Array<int> = []\n  류 = 0\n  while 류 < 식별자류수 { 러스트최대폭들.push(2147483647); 류 = 류 + 1 }\n  순번 = 0\n  while 순번 < 구조.노드들.length {\n    let 노드 = 구조.노드들[순번]\n    if 노드.식별자있음 && 고정식별자이름(언어번호, 구조, 순번) != \"\" {\n      고정류들[노드.식별자류번호] = true\n    }\n      if (언어번호 == 5 || 언어번호 == 6 || 언어번호 == 7 || 언어번호 == 8 || 언어번호 == 9 || 언어번호 == 10 || 언어번호 == 11 || 언어번호 == 12 || 언어번호 == 13 || 언어번호 == 14 || 언어번호 == 15 || 언어번호 == 16 || 언어번호 == 17 || 언어번호 == 18 || 언어번호 == 19 || 언어번호 == 20 || 언어번호 == 21 || 언어번호 == 22 || 언어번호 == 23 || 언어번호 == 24 || 언어번호 == 25 || 언어번호 == 26 || 언어번호 == 27 || 언어번호 == 28) && 노드.식별자있음 &&\n      스칼라정수(노드, \"startRow\") == 스칼라정수(노드, \"endRow\") {\n      let 폭 = if 스칼라있음(노드, \"identifierScalarColumnSpan\") {\n        스칼라정수(노드, \"identifierScalarColumnSpan\")\n      } else {\n        스칼라정수(노드, \"endColumn\") - 스칼라정수(노드, \"startColumn\")\n      }\n      if 폭 < 러스트최대폭들[노드.식별자류번호] {\n        러스트최대폭들[노드.식별자류번호] = 폭\n      }\n    }\n    순번 = 순번 + 1\n  }\n  let mut 익명이름들: Array<string> = []\n  let mut 다음이름번호 = 1\n  류 = 0\n  while 류 < 식별자류수 {\n    if 고정류들[류] { 익명이름들.push(\"\") }\n    else {\n      let mut 후보 = \"v\" + \"{다음이름번호}\"\n      while 문자열배열에있음(보존이름들, 후보) ||\n        (언어번호 == 3 && 파이썬후보가제안만듦(후보, 파이썬보이는이름들)) ||\n          ((언어번호 == 5 || 언어번호 == 6 || 언어번호 == 7 || 언어번호 == 8 || 언어번호 == 9 || 언어번호 == 10 || 언어번호 == 11 || 언어번호 == 12 || 언어번호 == 13 || 언어번호 == 14 || 언어번호 == 15 || 언어번호 == 16 || 언어번호 == 17 || 언어번호 == 18 || 언어번호 == 19 || 언어번호 == 20 || 언어번호 == 21 || 언어번호 == 22 || 언어번호 == 23 || 언어번호 == 24 || 언어번호 == 25 || 언어번호 == 26 || 언어번호 == 27 || 언어번호 == 28) && 익명이름예약(언어번호, 후보)) {\n        다음이름번호 = 다음이름번호 + 1\n        후보 = \"v\" + \"{다음이름번호}\"\n      }\n        if (언어번호 == 5 || 언어번호 == 6 || 언어번호 == 7 || 언어번호 == 8 || 언어번호 == 9 || 언어번호 == 10 || 언어번호 == 11 || 언어번호 == 12 || 언어번호 == 13 || 언어번호 == 14 || 언어번호 == 15 || 언어번호 == 16 || 언어번호 == 17 || 언어번호 == 18 || 언어번호 == 19 || 언어번호 == 20 || 언어번호 == 21 || 언어번호 == 22 || 언어번호 == 23 || 언어번호 == 24 || 언어번호 == 25 || 언어번호 == 26 || 언어번호 == 27 || 언어번호 == 28) &&\n        후보.scalars().length > 러스트최대폭들[류] {\n        let 짧은이름 = 러스트짧은이름(\n          언어번호, 러스트최대폭들[류], 보존이름들\n        )\n        if 짧은이름 != \"\" { 후보 = 짧은이름 }\n      }\n      익명이름들.push(후보)\n      보존이름들.push(후보)\n      다음이름번호 = 다음이름번호 + 1\n    }\n    류 = 류 + 1\n  }\n  if 언어번호 == 2 {\n    let mut 부모순번 = 0\n    while 부모순번 < 구조.노드들.length {\n      let 부모 = 구조.노드들[부모순번]\n      let 부모종류 = 노드종류(언어번호, 부모.코드워드)\n      let 목록필드 = if 부모종류 == 511 { \"consequent\" }\n        else if 부모종류 == 102 || 부모종류 == 410 || 부모종류 == 603 ||\n          부모종류 == 609 || 부모종류 == 731 { \"body\" }\n        else { \"\" }\n      if 목록필드 != \"\" {\n        let mut 기준행 = 스칼라정수(부모, \"startRow\")\n        let mut 이전순번 = -1\n        let mut 누적추가행 = 0\n        let mut 자식 = 첫자식들[부모순번]\n        while 자식 >= 0 {\n          let 현재 = 구조.노드들[자식]\n          if 이전순번 < 0 &&\n            (현재.자식필드 == \"directives\" || 현재.자식필드 == \"interpreter\") {\n            기준행 = 스칼라정수(현재, \"endRow\")\n          }\n          if 현재.자식필드 == 목록필드 {\n            let 원본간격 = 스칼라정수(현재, \"startRow\") -\n              (if 이전순번 < 0 { 기준행 }\n                else { 스칼라정수(구조.노드들[이전순번], \"endRow\") })\n            let 보이는간격값 = 원본간격 - 누적추가행\n            let 보이는간격 = if 보이는간격값 < 0 { 0 } else { 보이는간격값 }\n            let 계획행 = 스칼라정수(현재, \"emission.imageOnlyLeadingLineCommentRows\")\n            let 출력간격 = if 보이는간격 > 계획행 { 보이는간격 } else { 계획행 }\n            누적추가행 = 누적추가행 + 출력간격 - 원본간격\n            영상댓글누적추가행들[자식] = 누적추가행\n            이전순번 = 자식\n          }\n          자식 = 다음형제들[자식]\n        }\n      }\n      부모순번 = 부모순번 + 1\n    }\n  }\n  준비된인쇄상태 {\n    언어번호: 언어번호, 오프셋배치: 오프셋배치, 구조: 구조, 본문값들: 값들,\n    첫자식들: 첫자식들, 다음형제들: 다음형제들, 본문색인들: 본문색인들,\n    익명이름들: 익명이름들,\n    댓글고정들: 댓글고정들,\n    댓글시작들: 댓글시작들,\n    댓글끝들: 댓글끝들,\n    댓글행들: 댓글행들,\n    댓글바이트누적들: 댓글바이트누적들,\n    줄댓글수누적들: 줄댓글수누적들,\n    영상댓글누적추가행들: 영상댓글누적추가행들,\n    소비자식들: 소비자식들,\n    인머리들: 인머리들,\n    조각판: 인쇄조각판만들기(),\n    기계활성들: [false], 기계세대들: [0],\n    기계필요모드들: [0], 기계필요순번들: [0], 기계필요깊이들: [0],\n    기계저장세대들: 기계저장세대들, 기계저장깊이들: 기계저장깊이들,\n    기계저장상태들: 기계저장상태들, 기계저장조각들: 기계저장조각들,\n    기계저장오류들: 기계저장오류들\n  }\n}\n\nexport function 인쇄상태조각판새로(준비: 준비된인쇄상태) -> 준비된인쇄상태 {\n  준비된인쇄상태 {\n    언어번호: 준비.언어번호,\n    오프셋배치: 준비.오프셋배치,\n    구조: 준비.구조,\n    본문값들: 준비.본문값들,\n    첫자식들: 준비.첫자식들,\n    다음형제들: 준비.다음형제들,\n    본문색인들: 준비.본문색인들,\n    익명이름들: 준비.익명이름들,\n    댓글고정들: 준비.댓글고정들,\n    댓글시작들: 준비.댓글시작들,\n    댓글끝들: 준비.댓글끝들,\n    댓글행들: 준비.댓글행들,\n    댓글바이트누적들: 준비.댓글바이트누적들,\n    줄댓글수누적들: 준비.줄댓글수누적들,\n    영상댓글누적추가행들: 준비.영상댓글누적추가행들,\n    소비자식들: 준비.소비자식들,\n    인머리들: 준비.인머리들,\n    조각판: 인쇄조각판만들기(),\n    기계활성들: 준비.기계활성들,\n    기계세대들: 준비.기계세대들,\n    기계필요모드들: 준비.기계필요모드들,\n    기계필요순번들: 준비.기계필요순번들,\n    기계필요깊이들: 준비.기계필요깊이들,\n    기계저장세대들: 준비.기계저장세대들,\n    기계저장깊이들: 준비.기계저장깊이들,\n    기계저장상태들: 준비.기계저장상태들,\n    기계저장조각들: 준비.기계저장조각들,\n    기계저장오류들: 준비.기계저장오류들\n  }\n}\n\nexport function 인쇄상태익명이름들바꾸기(\n  준비: 준비된인쇄상태,\n  익명이름들: Array<string>\n) -> 준비된인쇄상태 {\n  준비된인쇄상태 {\n    언어번호: 준비.언어번호,\n    오프셋배치: 준비.오프셋배치,\n    구조: 준비.구조,\n    본문값들: 준비.본문값들,\n    첫자식들: 준비.첫자식들,\n    다음형제들: 준비.다음형제들,\n    본문색인들: 준비.본문색인들,\n    익명이름들: 익명이름들,\n    댓글고정들: 준비.댓글고정들,\n    댓글시작들: 준비.댓글시작들,\n    댓글끝들: 준비.댓글끝들,\n    댓글행들: 준비.댓글행들,\n    댓글바이트누적들: 준비.댓글바이트누적들,\n    줄댓글수누적들: 준비.줄댓글수누적들,\n    영상댓글누적추가행들: 준비.영상댓글누적추가행들,\n    소비자식들: 준비.소비자식들,\n    인머리들: 준비.인머리들,\n    조각판: 준비.조각판,\n    기계활성들: 준비.기계활성들,\n    기계세대들: 준비.기계세대들,\n    기계필요모드들: 준비.기계필요모드들,\n    기계필요순번들: 준비.기계필요순번들,\n    기계필요깊이들: 준비.기계필요깊이들,\n    기계저장세대들: 준비.기계저장세대들,\n    기계저장깊이들: 준비.기계저장깊이들,\n    기계저장상태들: 준비.기계저장상태들,\n    기계저장조각들: 준비.기계저장조각들,\n    기계저장오류들: 준비.기계저장오류들\n  }\n}\n",
      "sourceSha256": "e407a09e779f0e44da0e26c2feadb145fd77b29b712d5cc4c234174fc26aaf25"
    },
    {
      "path": "topaz/src/printer_state.tpz",
      "language": "topaz",
      "bytes": 4950,
      "sha256": "fd817bcc947433504f3fd8f1aa864ad13f8290ed80c4d2e937f08542cc12bb79",
      "content": "// Printer state record and the child, comment, and identifier lookups printers share.\n\nimport nodes { 노드종류 }\nimport print { 댓글코드, 인쇄글조각, 인쇄조각이음 }\nimport structure { 구조노드, 구조입력, 스칼라문자 }\nimport types { 댓글고정, 인쇄조각판 }\n\nexport record 준비된인쇄상태 {\n  언어번호: int,\n  오프셋배치: bool,\n  구조: 구조입력,\n  본문값들: Array<string>,\n  첫자식들: Array<int>,\n  다음형제들: Array<int>,\n  본문색인들: Array<int>,\n  익명이름들: Array<string>,\n  댓글고정들: Array<댓글고정>,\n  댓글시작들: Array<int>,\n  댓글끝들: Array<int>,\n  댓글행들: Array<int>,\n  댓글바이트누적들: Array<int>,\n  줄댓글수누적들: Array<int>,\n  영상댓글누적추가행들: Array<int>,\n  소비자식들: Array<bool>,\n  인머리들: Array<bool>,\n  조각판: 인쇄조각판,\n  기계활성들: Array<bool>,\n  기계세대들: Array<int>,\n  기계필요모드들: Array<int>,\n  기계필요순번들: Array<int>,\n  기계필요깊이들: Array<int>,\n  기계저장세대들: Array<int>,\n  기계저장깊이들: Array<int>,\n  기계저장상태들: Array<int>,\n  기계저장조각들: Array<int>,\n  기계저장오류들: Array<string>\n}\n\nexport function 인쇄글조각결과(준비: 준비된인쇄상태, 글: string) -> Result<int, string> {\n  Ok(인쇄글조각(준비.조각판, 글))\n}\n\nexport function 인쇄조각결과합치기(\n  준비: 준비된인쇄상태,\n  조각들: Array<Result<int, string>>\n) -> Result<int, string> {\n  let mut 합 = 0\n  for 조각 in 조각들 {\n    match 조각 {\n      case Ok(값) => { 합 = 인쇄조각이음(준비.조각판, 합, 값) }\n      case Err(오류) => return Err(오류)\n    }\n  }\n  Ok(합)\n}\n\nexport function 고정식별자이름(\n  언어번호: int,\n  구조: 구조입력,\n  순번: int\n) -> string {\n  let 노드 = 구조.노드들[순번]\n  if 노드.부모순번 < 0 { return \"\" }\n  let 부모 = 구조.노드들[노드.부모순번]\n  let 부모종류 = 노드종류(언어번호, 부모.코드워드)\n  if 부모종류 == 604 && 노드.자식필드 == \"key\" &&\n    스칼라문자(부모, \"kind\") == \"constructor\" { return \"constructor\" }\n  \"\"\n}\n\nexport function 자식순번들(준비: 준비된인쇄상태, 부모: int, 필드: string) -> Array<int> {\n  let mut 결과: Array<int> = []\n  let mut 순번 = 준비.첫자식들[부모]\n  while 순번 >= 0 {\n    let 노드 = 준비.구조.노드들[순번]\n    if 노드.자식필드 == 필드 {\n      결과.push(순번)\n      if 준비.소비자식들.length > 0 {\n        let mut 소비자식들 = 준비.소비자식들\n        소비자식들[순번] = true\n      }\n    }\n    순번 = 준비.다음형제들[순번]\n  }\n  결과\n}\n\nexport function 자식순번(준비: 준비된인쇄상태, 부모: int, 필드: string) -> int {\n  let mut 순번 = 준비.첫자식들[부모]\n  while 순번 >= 0 {\n    if 준비.구조.노드들[순번].자식필드 == 필드 {\n      if 준비.소비자식들.length > 0 {\n        let mut 소비자식들 = 준비.소비자식들\n        소비자식들[순번] = true\n      }\n      return 순번\n    }\n    순번 = 준비.다음형제들[순번]\n  }\n  -1\n}\n\nexport function 댓글노드(준비: 준비된인쇄상태, 노드: 구조노드) -> bool {\n  댓글코드(준비.언어번호, 노드.코드워드)\n}\n\nexport function 본문값색인(준비: 준비된인쇄상태, 순번: int) -> int {\n  준비.본문색인들[순번]\n}\n\nexport function 식별자이름(준비: 준비된인쇄상태, 순번: int) -> Result<string, string> {\n  let 노드 = 준비.구조.노드들[순번]\n  if !노드.식별자있음 {\n    return Ok(스칼라문자(노드, if 준비.언어번호 == 3 || 준비.언어번호 == 4 ||\n      준비.언어번호 == 5 || 준비.언어번호 == 6 ||\n      준비.언어번호 == 7 || 준비.언어번호 == 8 ||\n      준비.언어번호 == 9 || 준비.언어번호 == 10 || 준비.언어번호 == 11 || 준비.언어번호 == 12 || 준비.언어번호 == 13 || 준비.언어번호 == 14 || 준비.언어번호 == 15 || 준비.언어번호 == 16 || 준비.언어번호 == 17 || 준비.언어번호 == 18 || 준비.언어번호 == 19 || 준비.언어번호 == 20 || 준비.언어번호 == 21 || 준비.언어번호 == 22 || 준비.언어번호 == 23 || 준비.언어번호 == 24 || 준비.언어번호 == 25 || 준비.언어번호 == 26 || 준비.언어번호 == 27 || 준비.언어번호 == 28 { \"text\" } else { \"name\" }))\n  }\n  if 준비.본문값들.length > 0 { return Ok(준비.본문값들[본문값색인(준비, 순번)]) }\n  let 고정이름 = 고정식별자이름(준비.언어번호, 준비.구조, 순번)\n  if 고정이름 != \"\" { return Ok(고정이름) }\n  Ok(준비.익명이름들[노드.식별자류번호])\n}\n\nexport function 댓글고정있음(준비: 준비된인쇄상태) -> bool {\n  준비.댓글고정들.length > 0\n}\n",
      "sourceSha256": "fd817bcc947433504f3fd8f1aa864ad13f8290ed80c4d2e937f08542cc12bb79"
    },
    {
      "path": "topaz/src/printer_text.tpz",
      "language": "topaz",
      "bytes": 2225,
      "sha256": "6e9fc56e390abf398ce6590b954cbf28f4589be882ed35336144d9a386d94e62",
      "content": "// Linear source text accumulation used by the language printers.\n\nimport print { 글자합치기 }\n\nexport record 선형원본누적 {\n  조각들: Array<string>,\n  스칼라길이들: Array<int>,\n  끝글들: Array<string>\n}\n\nexport function 선형원본만들기() -> 선형원본누적 {\n  선형원본누적 { 조각들: [], 스칼라길이들: [0], 끝글들: [\"\"] }\n}\n\nexport function 선형원본추가(원본: 선형원본누적, 글: string) {\n  let 글자들 = 글.scalars()\n  if 글자들.length == 0 { return }\n  let mut 조각들 = 원본.조각들\n  let mut 스칼라길이들 = 원본.스칼라길이들\n  let mut 끝글들 = 원본.끝글들\n  조각들.push(글)\n  스칼라길이들[0] = 스칼라길이들[0] + 글자들.length\n  끝글들[0] = 글자들[글자들.length - 1]\n}\n\nexport function 선형원본끝공백제거(원본: 선형원본누적) {\n  let mut 조각들 = 원본.조각들\n  let mut 스칼라길이들 = 원본.스칼라길이들\n  let mut 끝글들 = 원본.끝글들\n  let mut 조각번호 = 조각들.length - 1\n  let mut 지운길이 = 0\n  let mut 남음 = false\n  while 조각번호 >= 0 {\n    let 글자들 = 조각들[조각번호].scalars()\n    let mut 끝 = 글자들.length\n    while 끝 > 0 {\n      let 글자 = 글자들[끝 - 1]\n      if 글자 != \" \" && 글자 != \"\\t\" && 글자 != \"\\n\" && 글자 != \"\\r\" { break }\n      끝 = 끝 - 1\n    }\n    지운길이 = 지운길이 + 글자들.length - 끝\n    if 끝 == 글자들.length {\n      끝글들[0] = 글자들[끝 - 1]\n      남음 = true\n      break\n    }\n    조각들[조각번호] = if 끝 == 0 { \"\" } else {\n      글자합치기(글자들, 0, 끝)\n    }\n    if 끝 > 0 {\n      끝글들[0] = 글자들[끝 - 1]\n      남음 = true\n      break\n    }\n    조각번호 = 조각번호 - 1\n  }\n  스칼라길이들[0] = 스칼라길이들[0] - 지운길이\n  if !남음 { 끝글들[0] = \"\" }\n}\n\nexport function 선형원본길이(원본: 선형원본누적) -> int { 원본.스칼라길이들[0] }\n\nexport function 선형원본줄끝인가(원본: 선형원본누적) -> bool { 원본.끝글들[0] == \"\\n\" }\n\nexport function 선형원본평평하게(원본: 선형원본누적) -> string { 원본.조각들.join(\"\") }\n",
      "sourceSha256": "6e9fc56e390abf398ce6590b954cbf28f4589be882ed35336144d9a386d94e62"
    },
    {
      "path": "topaz/src/printers.tpz",
      "language": "topaz",
      "bytes": 10832,
      "sha256": "5ad7fbe3157c739e825a057b7b822a0d9fb7ee30d1eb3dc08e5d8ef8139f062a",
      "content": "// Printer structure validation: the per-language dispatch and the JavaScript and\n// TypeScript structure checks every printed image must pass.\n\nimport nodes { 노드종류 }\nimport print { 댓글코드 }\nimport printer_setup { 인쇄상태만들기, 인쇄상태조각판새로 }\nimport printer_state { 자식순번, 자식순번들, 준비된인쇄상태 }\nimport printers.c { 씨인쇄구조검사 }\nimport printers.coffeescript { 커피스크립트인쇄구조검사 }\nimport printers.cpp { 씨플러스플러스인쇄구조검사 }\nimport printers.csharp { 씨샵인쇄구조검사 }\nimport printers.dart { 다트인쇄구조검사 }\nimport printers.elisp { 이맥스리습인쇄구조검사 }\nimport printers.elixir { 엘릭서인쇄구조검사 }\nimport printers.elm { 엘름인쇄구조검사 }\nimport printers.go { 고인쇄구조검사 }\nimport printers.haskell { 하스켈인쇄구조검사 }\nimport printers.java { 자바인쇄구조검사 }\nimport printers.javascript { 순번인쇄조각 }\nimport printers.javascript.check { 노드자식스키마검사, 철자위치검사, 타입스크립트영상댓글행계획검사 }\nimport printers.julia { 줄리아인쇄구조검사 }\nimport printers.kotlin { 코틀린인쇄구조검사 }\nimport printers.lispex { 리스펙스인쇄구조검사 }\nimport printers.lua { 루아인쇄구조검사 }\nimport printers.objc { 오브젝티브씨인쇄구조검사 }\nimport printers.ocaml { 오캐멀인쇄구조검사 }\nimport printers.php { 피에이치피인쇄구조검사 }\nimport printers.python { 파이썬인쇄구조검사 }\nimport printers.r { 알인쇄구조검사 }\nimport printers.rescript { 리스크립트인쇄구조검사 }\nimport printers.ruby { 루비인쇄구조검사 }\nimport printers.rust { 러스트인쇄구조검사 }\nimport printers.scala { 스칼라인쇄구조검사 }\nimport printers.solidity { 솔리디티인쇄구조검사 }\nimport printers.swift { 스위프트인쇄구조검사 }\nimport printers.topaz_language { 토파즈언어인쇄구조검사 }\nimport printers.zig { 지그인쇄구조검사 }\nimport structure { 구조노드, 구조언어번호, 구조입력, 구조입력검사 }\n\nexport record 준비된구조 {\n  언어번호: int,\n  구조: 구조입력\n}\n\nexport function 인쇄구조검사(언어번호: int, 구조: 구조입력) -> Result<bool, string> {\n  if 언어번호 == 3 { return 파이썬인쇄구조검사(구조) }\n  if 언어번호 == 4 { return 고인쇄구조검사(구조) }\n  if 언어번호 == 5 { return 러스트인쇄구조검사(구조) }\n  if 언어번호 == 6 { return 자바인쇄구조검사(구조) }\n  if 언어번호 == 7 { return 씨인쇄구조검사(구조) }\n  if 언어번호 == 8 { return 씨플러스플러스인쇄구조검사(구조) }\n  if 언어번호 == 9 { return 씨샵인쇄구조검사(구조) }\n  if 언어번호 == 10 { return 루비인쇄구조검사(구조) }\n  if 언어번호 == 11 { return 피에이치피인쇄구조검사(구조) }\n  if 언어번호 == 12 { return 스위프트인쇄구조검사(구조) }\n  if 언어번호 == 13 { return 코틀린인쇄구조검사(구조) }\n  if 언어번호 == 14 { return 스칼라인쇄구조검사(구조) }\n  if 언어번호 == 15 { return 다트인쇄구조검사(구조) }\n  if 언어번호 == 16 { return 엘릭서인쇄구조검사(구조) }\n  if 언어번호 == 17 { return 하스켈인쇄구조검사(구조) }\n  if 언어번호 == 18 { return 루아인쇄구조검사(구조) }\n  if 언어번호 == 19 { return 알인쇄구조검사(구조) }\n  if 언어번호 == 21 { return 오캐멀인쇄구조검사(구조) }\n  if 언어번호 == 20 { return 줄리아인쇄구조검사(구조) }\n  if 언어번호 == 22 { return 엘름인쇄구조검사(구조) }\n  if 언어번호 == 23 { return 리스크립트인쇄구조검사(구조) }\n  if 언어번호 == 24 { return 커피스크립트인쇄구조검사(구조) }\n  if 언어번호 == 25 { return 오브젝티브씨인쇄구조검사(구조) }\n  if 언어번호 == 26 { return 이맥스리습인쇄구조검사(구조) }\n  if 언어번호 == 27 { return 솔리디티인쇄구조검사(구조) }\n  if 언어번호 == 28 { return 지그인쇄구조검사(구조) }\n  if 언어번호 == 29 { return 리스펙스인쇄구조검사(구조) }\n  if 언어번호 == 30 { return 토파즈언어인쇄구조검사(구조) }\n  if 언어번호 != 1 && 언어번호 != 2 { return Err(\"인쇄 구조 언어 번호가 틀립니다\") }\n  구조입력검사(언어번호, 구조)?\n  if 구조.노드들.length < 2 { return Err(\"인쇄 구조에 파일과 프로그램 노드가 필요합니다\") }\n  if 노드종류(언어번호, 구조.노드들[0].코드워드) != 101 ||\n    구조.노드들[0].부모순번 != -1 || 구조.노드들[0].자식필드있음 ||\n    구조.노드들[0].자식필드 != \"\" || 구조.노드들[0].자식색인 != -1 {\n    return Err(\"인쇄 구조 뿌리가 파일 노드가 아닙니다\")\n  }\n  if 노드종류(언어번호, 구조.노드들[1].코드워드) != 102 ||\n    구조.노드들[1].부모순번 != 0 || !구조.노드들[1].자식필드있음 ||\n    구조.노드들[1].자식필드 != \"program\" || 구조.노드들[1].자식색인 != -1 {\n    return Err(\"인쇄 구조의 프로그램 자식이 정규형이 아닙니다\")\n  }\n  let mut 순번 = 0\n  let mut 다음식별자류번호 = 0\n  let mut 분리본문발생수 = 0\n  while 순번 < 구조.노드들.length {\n    let 노드 = 구조.노드들[순번]\n    let 종류 = 노드종류(언어번호, 노드.코드워드)\n    if 종류 == 0 {\n      return Err(\"투영 인쇄기가 지원하지 않는 노드입니다: 순번 {순번}, 코드 {노드.코드워드}\")\n    }\n    if 순번 > 0 {\n      if 노드.부모순번 < 0 || 노드.부모순번 >= 순번 ||\n        !노드.자식필드있음 || 노드.자식필드 == \"\" {\n        return Err(\"인쇄 구조의 부모 또는 자식 필드가 정규형이 아닙니다: 순번 {순번}\")\n      }\n      let 부모종류 = 노드종류(언어번호, 구조.노드들[노드.부모순번].코드워드)\n      let 상속표현식자리 =\n        (부모종류 == 721 && 노드.자식필드 == \"extends\") ||\n        ((부모종류 == 601 || 부모종류 == 602) && 노드.자식필드 == \"implements\")\n      let 상속표현식감싸개 = 언어번호 == 2 && 노드.코드워드 == 460\n      if 상속표현식감싸개 != 상속표현식자리 {\n        return Err(\"형식 상속 표현식 감싸개가 정규 위치 또는 종류가 아닙니다: 순번 {순번}\")\n      }\n    }\n    if 노드.식별자있음 {\n      if 노드.식별자류번호 < 0 || 노드.식별자류번호 > 다음식별자류번호 {\n        return Err(\"식별자 알파류가 첫 사용 정규형이 아닙니다: 순번 {순번}\")\n      }\n      if 노드.식별자류번호 == 다음식별자류번호 {\n        다음식별자류번호 = 다음식별자류번호 + 1\n      }\n      분리본문발생수 = 분리본문발생수 + 1\n    } else if 노드.식별자류번호 != 0 {\n      return Err(\"식별자가 없는 노드의 알파류 번호가 0이 아닙니다: 순번 {순번}\")\n    }\n    if 댓글코드(언어번호, 노드.코드워드) {\n      분리본문발생수 = 분리본문발생수 + 1\n    }\n    순번 = 순번 + 1\n  }\n  if 구조.분리본문값수 < 0 || 구조.분리본문값수 != 분리본문발생수 {\n    return Err(\"분리 본문 값 수가 식별자와 댓글 발생 수에 맞지 않습니다\")\n  }\n  let 준비 = 인쇄상태만들기(언어번호, 구조, [], [], true, false)\n  순번 = 0\n  while 순번 < 구조.노드들.length {\n    let 노드 = 구조.노드들[순번]\n    let 종류 = 노드종류(언어번호, 노드.코드워드)\n    노드자식스키마검사(준비, 순번)?\n    철자위치검사(준비, 순번)?\n    if 언어번호 == 2 && 노드.코드워드 == 460 {\n      let 표현식순번 = 자식순번(준비, 순번, \"expression\")\n      let 표현식종류 = 노드종류(언어번호, 구조.노드들[표현식순번].코드워드)\n      if 표현식종류 != 106 && 표현식종류 != 711 {\n        return Err(\"형식 상속 표현식의 대상 종류가 틀립니다\")\n      }\n      let 형식인자순번 = 자식순번(준비, 순번, \"typeParameters\")\n      if 형식인자순번 >= 0 &&\n        노드종류(언어번호, 구조.노드들[형식인자순번].코드워드) != 713 {\n        return Err(\"형식 상속 표현식의 형식 인자 종류가 틀립니다\")\n      }\n    }\n    if 댓글코드(언어번호, 노드.코드워드) {\n      if 노드.부모순번 != 0 || 노드.자식필드 != \"comments\" {\n        return Err(\"댓글 노드가 파일 comments 목록 밖에 있습니다\")\n      }\n    } else if 노드.부모순번 == 0 && 노드.자식필드 == \"comments\" {\n      return Err(\"파일 comments 목록에 댓글이 아닌 노드가 있습니다\")\n    }\n    if 종류 == 306 {\n      let 왼 = 자식순번(준비, 순번, \"left\")\n      if 자식순번들(준비, 순번, \"decorators\").length > 0 && 왼 >= 0 &&\n        자식순번들(준비, 왼, \"decorators\").length > 0 {\n        return Err(\"기본값 매개변수의 장식자가 두 위치에 함께 있습니다\")\n      }\n    }\n    순번 = 순번 + 1\n  }\n  if 언어번호 == 2 { 타입스크립트영상댓글행계획검사(구조)? }\n  let 댓글들 = 자식순번들(준비, 0, \"comments\")\n  for 댓글순번 in 댓글들 {\n    if !댓글코드(언어번호, 구조.노드들[댓글순번].코드워드) {\n      return Err(\"파일 comments 목록에 댓글이 아닌 노드가 있습니다\")\n    }\n  }\n  let 프로그램순번 = 자식순번(준비, 0, \"program\")\n  let 지시들 = 자식순번들(준비, 프로그램순번, \"directives\")\n  let 본문들 = 자식순번들(준비, 프로그램순번, \"body\")\n  let mut 검사준비 = 준비\n  for 지시 in 지시들 {\n    순번인쇄조각(검사준비, 지시, 0)?\n    검사준비 = 인쇄상태조각판새로(검사준비)\n  }\n  for 문장 in 본문들 {\n    순번인쇄조각(검사준비, 문장, 0)?\n    검사준비 = 인쇄상태조각판새로(검사준비)\n  }\n  순번 = 2\n  while 순번 < 구조.노드들.length {\n    let 노드 = 구조.노드들[순번]\n    if !준비.소비자식들[순번] {\n      return Err(\"인쇄기가 소비하지 않는 자식입니다: 순번 {순번}, 필드 {노드.자식필드}\")\n    }\n    순번 = 순번 + 1\n  }\n  Ok(true)\n}\n\nexport function 인쇄구조준비(\n  언어번호: int,\n  구조: 구조입력,\n  언어결합검사: bool\n) -> Result<준비된구조, string> {\n  if 언어결합검사 && 구조언어번호(구조) != 언어번호 {\n    return Err(\"구조 뿌리의 언어가 인쇄 언어와 다릅니다\")\n  }\n  인쇄구조검사(언어번호, 구조)?\n  Ok(준비된구조 { 언어번호: 언어번호, 구조: 구조 })\n}\n",
      "sourceSha256": "5ad7fbe3157c739e825a057b7b822a0d9fb7ee30d1eb3dc08e5d8ef8139f062a"
    },
    {
      "path": "topaz/src/printers/c.tpz",
      "language": "topaz",
      "bytes": 15664,
      "sha256": "189cf16259196270ca8554ca1785fae8c62133a66752a1982287a667b5375b0b",
      "content": "// C structure validation and canonical source printing.\n\nimport nodes { 노드종류 }\nimport printer_cursor { 러스트열폭, 러스트행들여쓰기, 씨본문위치전진 }\nimport printer_setup { 인쇄상태만들기 }\nimport printer_state { 식별자이름 }\nimport printer_text { 선형원본끝공백제거, 선형원본만들기, 선형원본추가, 선형원본평평하게 }\nimport schema { 씨댓글코드 }\nimport structure { 구조노드, 구조스칼라, 구조입력, 구조입력검사, 노드스칼라, 스칼라논리, 스칼라문자, 스칼라있음 }\n\nfunction 씨정수스칼라검사(노드: 구조노드, 필드: string) -> Result<int, string> {\n  let 값 = 노드스칼라(노드, 필드)\n  if 값.필드 == \"\" || 값.태그 != 3 || 값.정수값 < 0 {\n    return Err(\"C 구조 정수 스칼라가 정규형이 아닙니다: {필드}\")\n  }\n  Ok(값.정수값)\n}\n\nfunction 씨전처리원문있음(노드: 구조노드) -> bool {\n  스칼라있음(노드, \"preprocessorText\")\n}\n\nfunction 씨전처리원자(노드: 구조노드) -> bool {\n  씨전처리원문있음(노드) && 스칼라논리(노드, \"preprocessorAtomic\")\n}\n\nexport function 씨인쇄구조검사(구조: 구조입력) -> Result<bool, string> {\n  구조입력검사(7, 구조)?\n  if 구조.노드들.length == 0 {\n    return Err(\"C 인쇄 구조에 번역 단위 노드가 필요합니다\")\n  }\n  if 구조.노드들[0].코드워드 != 289 ||\n    구조.노드들[0].부모순번 != -1 || 구조.노드들[0].자식필드있음 ||\n    구조.노드들[0].자식필드 != \"\" || 구조.노드들[0].자식색인 != -1 {\n    return Err(\"C 인쇄 구조 뿌리가 번역 단위 노드가 아닙니다\")\n  }\n  let mut 자식수들: Array<int> = []\n  let mut 순번 = 0\n  while 순번 < 구조.노드들.length { 자식수들.push(0); 순번 = 순번 + 1 }\n  let mut 다음식별자류번호 = 0\n  let mut 분리본문발생수 = 0\n  let mut 이전시작 = 0\n  순번 = 0\n  while 순번 < 구조.노드들.length {\n    let 노드 = 구조.노드들[순번]\n    let 종류 = 노드종류(7, 노드.코드워드)\n    if 종류 == 0 {\n      return Err(\"C 투영 인쇄기가 지원하지 않는 노드입니다: 순번 {순번}, 코드 {노드.코드워드}\")\n    }\n    if 순번 > 0 {\n      if 노드.부모순번 < 0 || 노드.부모순번 >= 순번 ||\n        !노드.자식필드있음 || 노드.자식필드 == \"\" || 노드.자식색인 < 0 {\n        return Err(\"C 인쇄 구조의 부모 또는 자식 위치가 정규형이 아닙니다: 순번 {순번}\")\n      }\n      if 노드.시작 < 이전시작 {\n        return Err(\"C 인쇄 구조의 원본 순서가 정규형이 아닙니다: 순번 {순번}\")\n      }\n      자식수들[노드.부모순번] = 자식수들[노드.부모순번] + 1\n    }\n    이전시작 = 노드.시작\n    if 노드.시작 < 0 || 노드.끝 < 노드.시작 {\n      return Err(\"C 인쇄 구조의 원본 범위가 틀립니다: 순번 {순번}\")\n    }\n    let 자식수 = 씨정수스칼라검사(노드, \"childCount\")?\n    let 시작행 = 씨정수스칼라검사(노드, \"startRow\")?\n    let 시작열 = 씨정수스칼라검사(노드, \"startColumn\")?\n    let 끝행 = 씨정수스칼라검사(노드, \"endRow\")?\n    let 끝열 = 씨정수스칼라검사(노드, \"endColumn\")?\n    if 끝행 < 시작행 || (끝행 == 시작행 && 끝열 < 시작열) {\n      return Err(\"C 인쇄 구조의 원본 좌표가 틀립니다: 순번 {순번}\")\n    }\n    if !스칼라있음(노드, \"named\") || !스칼라있음(노드, \"extra\") {\n      return Err(\"C 인쇄 구조의 노드 표지 스칼라가 없습니다: 순번 {순번}\")\n    }\n    let 전처리원문 = 씨전처리원문있음(노드)\n    if 전처리원문 {\n      if 노드스칼라(노드, \"preprocessorText\").태그 != 5 ||\n        !스칼라있음(노드, \"preprocessorAtomic\") ||\n        (노드스칼라(노드, \"preprocessorAtomic\").태그 != 1 &&\n          노드스칼라(노드, \"preprocessorAtomic\").태그 != 2) {\n        return Err(\"C 전처리 원문 스칼라가 정규형이 아닙니다: 순번 {순번}\")\n      }\n      if 씨전처리원자(노드) {\n        if 스칼라있음(노드, \"preprocessorHeaderEndRow\") ||\n          스칼라있음(노드, \"preprocessorHeaderEndColumn\") {\n          return Err(\"C 원자 전처리 원문에 머리 범위가 있습니다: 순번 {순번}\")\n        }\n      } else {\n        let 머리끝행 = 씨정수스칼라검사(노드, \"preprocessorHeaderEndRow\")?\n        let 머리끝열 = 씨정수스칼라검사(노드, \"preprocessorHeaderEndColumn\")?\n        if 머리끝행 < 시작행 || (머리끝행 == 시작행 && 머리끝열 < 시작열) ||\n          머리끝행 > 끝행 || (머리끝행 == 끝행 && 머리끝열 > 끝열) {\n          return Err(\"C 전처리 머리 범위가 원본 범위를 벗어납니다: 순번 {순번}\")\n        }\n      }\n    } else if 스칼라있음(노드, \"preprocessorAtomic\") {\n      return Err(\"C 전처리 원자 표지에 원문이 없습니다: 순번 {순번}\")\n    }\n    if 종류 == 106 {\n      if 노드.식별자있음 {\n        if 스칼라있음(노드, \"text\") {\n          return Err(\"C 식별자 이름이 이미지와 분리 본문에 함께 있습니다\")\n        }\n        if 노드.식별자류번호 < 0 || 노드.식별자류번호 > 다음식별자류번호 {\n          return Err(\"C 식별자 알파류가 첫 사용 정규형이 아닙니다: 순번 {순번}\")\n        }\n        if 노드.식별자류번호 == 다음식별자류번호 {\n          다음식별자류번호 = 다음식별자류번호 + 1\n        }\n        분리본문발생수 = 분리본문발생수 + 1\n      } else {\n        if 노드.식별자류번호 != 0 || !스칼라있음(노드, \"text\") ||\n          노드스칼라(노드, \"text\").태그 != 5 {\n          return Err(\"C 이미지 식별자 이름이 정규형이 아닙니다: 순번 {순번}\")\n        }\n      }\n    } else {\n      if 노드.식별자있음 || 노드.식별자류번호 != 0 {\n        return Err(\"C 식별자가 아닌 노드에 알파류가 있습니다: 순번 {순번}\")\n      }\n      if 씨댓글코드(노드.코드워드) {\n        if 스칼라있음(노드, \"text\") {\n          return Err(\"C 댓글 원문은 분리 본문에만 있어야 합니다: 순번 {순번}\")\n        }\n        분리본문발생수 = 분리본문발생수 + 1\n      } else if !전처리원문 && 자식수 == 0 {\n        if !스칼라있음(노드, \"text\") || 노드스칼라(노드, \"text\").태그 != 5 {\n          return Err(\"C 인쇄 토큰의 원문이 없습니다: 순번 {순번}\")\n        }\n      }\n    }\n    순번 = 순번 + 1\n  }\n  순번 = 0\n  while 순번 < 구조.노드들.length {\n    if 씨정수스칼라검사(구조.노드들[순번], \"childCount\")? != 자식수들[순번] {\n      return Err(\"C 노드 자식 수가 구조와 다릅니다: 순번 {순번}\")\n    }\n    순번 = 순번 + 1\n  }\n  if 구조.분리본문값수 < 0 || 구조.분리본문값수 != 분리본문발생수 {\n    return Err(\"C 분리 본문 값 수가 식별자와 댓글 발생 수에 맞지 않습니다\")\n  }\n  Ok(true)\n}\n\nfunction 씨전처리원자조상(구조: 구조입력, 순번: int) -> bool {\n  let mut 부모순번 = 구조.노드들[순번].부모순번\n  while 부모순번 >= 0 {\n    if 씨전처리원자(구조.노드들[부모순번]) { return true }\n    부모순번 = 구조.노드들[부모순번].부모순번\n  }\n  false\n}\n\nfunction 씨전처리머리조상(구조: 구조입력, 순번: int) -> Result<bool, string> {\n  let 시작행 = 씨정수스칼라검사(구조.노드들[순번], \"startRow\")?\n  let 시작열 = 씨정수스칼라검사(구조.노드들[순번], \"startColumn\")?\n  let mut 부모순번 = 구조.노드들[순번].부모순번\n  while 부모순번 >= 0 {\n    let 부모 = 구조.노드들[부모순번]\n    if 씨전처리원문있음(부모) && !씨전처리원자(부모) {\n      let 머리끝행 = 씨정수스칼라검사(부모, \"preprocessorHeaderEndRow\")?\n      let 머리끝열 = 씨정수스칼라검사(부모, \"preprocessorHeaderEndColumn\")?\n      if 시작행 < 머리끝행 || (시작행 == 머리끝행 && 시작열 < 머리끝열) {\n        return Ok(true)\n      }\n    }\n    부모순번 = 부모.부모순번\n  }\n  Ok(false)\n}\n\nfunction 씨원자본문코드(코드워드: int) -> bool {\n  코드워드 == 50 || 코드워드 == 298\n}\n\nfunction 씨원자본문조상(구조: 구조입력, 순번: int) -> bool {\n  let mut 부모순번 = 구조.노드들[순번].부모순번\n  while 부모순번 >= 0 {\n    if 씨원자본문코드(구조.노드들[부모순번].코드워드) { return true }\n    부모순번 = 구조.노드들[부모순번].부모순번\n  }\n  false\n}\n\nexport function 씨원본인쇄(구조: 구조입력) -> Result<string, string> {\n  씨인쇄구조검사(구조)?\n  let 준비 = 인쇄상태만들기(7, 구조, [], [], false, false)\n  let 단독복귀배치 = 스칼라논리(구조.노드들[0], \"loneCrLayout\")\n  let 끝줄이음 = if 스칼라있음(구조.노드들[0], \"eofLineSplice\") {\n    스칼라문자(구조.노드들[0], \"eofLineSplice\")\n  } else { \"\" }\n  if 끝줄이음 != \"\" && 끝줄이음 != \"\\\\\\n\" && 끝줄이음 != \"\\\\\\r\" &&\n    끝줄이음 != \"\\\\\\r\\n\" && 끝줄이음 != \"??/\\n\" &&\n    끝줄이음 != \"??/\\r\" && 끝줄이음 != \"??/\\r\\n\" {\n    return Err(\"C 투영의 파일 끝 줄 이음이 잘못되었습니다\")\n  }\n  let mut 토큰순번들: Array<int> = []\n  let mut 순번 = 0\n  while 순번 < 구조.노드들.length {\n    let 노드 = 구조.노드들[순번]\n    let 자식수 = 씨정수스칼라검사(노드, \"childCount\")?\n    if !씨전처리원자조상(구조, 순번) &&\n      !씨전처리머리조상(구조, 순번)? &&\n      !씨원자본문조상(구조, 순번) &&\n      (씨전처리원문있음(노드) || 씨원자본문코드(노드.코드워드) || 자식수 == 0) {\n      토큰순번들.push(순번)\n    }\n    순번 = 순번 + 1\n  }\n  let 원본 = 선형원본만들기()\n  let mut 출력행 = 0\n  let mut 출력열 = 0\n  let mut 이전끝행 = 0\n  let mut 이전끝열 = 0\n  let mut 이전끝스칼라열 = 0\n  let mut 이전있음 = false\n  let mut 토큰색인 = 0\n  while 토큰색인 < 토큰순번들.length {\n    순번 = 토큰순번들[토큰색인]\n    let 노드 = 구조.노드들[순번]\n    let 시작행 = 씨정수스칼라검사(노드, \"startRow\")?\n    let 시작열 = 씨정수스칼라검사(노드, \"startColumn\")?\n    let 끝행 = if 스칼라있음(노드, \"preprocessorHeaderEndRow\") {\n      씨정수스칼라검사(노드, \"preprocessorHeaderEndRow\")?\n    } else { 씨정수스칼라검사(노드, \"endRow\")? }\n    let 끝열 = if 스칼라있음(노드, \"preprocessorHeaderEndColumn\") {\n      씨정수스칼라검사(노드, \"preprocessorHeaderEndColumn\")?\n    } else { 씨정수스칼라검사(노드, \"endColumn\")? }\n    let 대체폭 = if 시작행 == 끝행 { 끝열 - 시작열 } else { 끝열 }\n    let 분리식별자 = 노드종류(7, 노드.코드워드) == 106 && 노드.식별자있음\n    let 생략댓글 = 씨댓글코드(노드.코드워드) && !스칼라있음(노드, \"text\")\n    let 행들여쓰기 = 러스트행들여쓰기(노드, 시작열)\n    let 토큰 = if 생략댓글 { \"\" } else if 씨전처리원문있음(노드) {\n      스칼라문자(노드, \"preprocessorText\")\n    } else if 노드종류(7, 노드.코드워드) == 106 {\n      식별자이름(준비, 순번)?\n    } else { 스칼라문자(노드, \"text\") }\n    let 원본스칼라폭 = if 분리식별자 {\n      러스트열폭(노드, \"identifier\", \"Scalar\", 대체폭)\n    } else if 생략댓글 {\n      러스트열폭(노드, \"comment\", \"Scalar\", 대체폭)\n    } else {\n      씨본문위치전진(단독복귀배치, 0, 0, 토큰)[1]\n    }\n    let 원본시작스칼라열 = if 이전있음 && 시작행 == 이전끝행 {\n      이전끝스칼라열 + 시작열 - 이전끝열\n    } else { 시작열 }\n    let 원본끝스칼라열 = if 끝행 == 시작행 {\n      원본시작스칼라열 + 원본스칼라폭\n    } else { 원본스칼라폭 }\n    let 구분필요 = 이전있음 && 시작행 == 이전끝행 && 시작열 > 이전끝열\n    if 생략댓글 {\n      let 다음시작행 = if 토큰색인 + 1 < 토큰순번들.length {\n        씨정수스칼라검사(\n          구조.노드들[토큰순번들[토큰색인 + 1]], \"startRow\"\n        )?\n      } else { -1 }\n      let 끝행에다음토큰없음 = 다음시작행 < 0 || 다음시작행 > 끝행\n      if 끝행에다음토큰없음 {\n        while 출력행 < 끝행 {\n          선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n        }\n      } else {\n        if 출력행 < 시작행 {\n          while 출력행 < 시작행 {\n            선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n          }\n          선형원본추가(원본, 행들여쓰기)\n          출력열 = 행들여쓰기.scalars().length\n          while 출력열 < 원본시작스칼라열 {\n            선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n          }\n        } else if 출력행 == 시작행 && 단독복귀배치 {\n          if 구분필요 { 선형원본추가(원본, \" \"); 출력열 = 출력열 + 1 }\n        } else if 출력행 == 시작행 && 출력열 < 원본시작스칼라열 {\n          while 출력열 < 원본시작스칼라열 {\n            선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n          }\n        } else if 출력행 == 시작행 && 구분필요 {\n          선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n        }\n        if 출력행 < 끝행 {\n          while 출력행 < 끝행 {\n            선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n          }\n          while 출력열 < 원본끝스칼라열 {\n            선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n          }\n        } else if 출력행 == 끝행 && 출력열 < 원본끝스칼라열 {\n          while 출력열 < 원본끝스칼라열 {\n            선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n          }\n        }\n      }\n    } else {\n      if 출력행 < 시작행 {\n        while 출력행 < 시작행 {\n          선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n        }\n        선형원본추가(원본, 행들여쓰기)\n        출력열 = 행들여쓰기.scalars().length\n        while 출력열 < 원본시작스칼라열 {\n          선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n        }\n      } else if 출력행 == 시작행 && 단독복귀배치 {\n        if 구분필요 { 선형원본추가(원본, \" \"); 출력열 = 출력열 + 1 }\n      } else if 출력행 == 시작행 && 출력열 < 원본시작스칼라열 {\n        while 출력열 < 원본시작스칼라열 {\n          선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n        }\n      } else if 출력행 == 시작행 && 구분필요 {\n        선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n      }\n      선형원본추가(원본, 토큰)\n      let 출력위치 = 씨본문위치전진(단독복귀배치, 출력행, 출력열, 토큰)\n      출력행 = 출력위치[0]\n      출력열 = 출력위치[1]\n    }\n    이전끝행 = 끝행\n    이전끝열 = 끝열\n    이전끝스칼라열 = 원본끝스칼라열\n    이전있음 = true\n    토큰색인 = 토큰색인 + 1\n  }\n  선형원본끝공백제거(원본)\n  선형원본추가(원본, \"\\n\")\n  if 끝줄이음 != \"\" { 선형원본추가(원본, 끝줄이음) }\n  Ok(선형원본평평하게(원본))\n}\n",
      "sourceSha256": "189cf16259196270ca8554ca1785fae8c62133a66752a1982287a667b5375b0b"
    },
    {
      "path": "topaz/src/printers/coffeescript.tpz",
      "language": "topaz",
      "bytes": 15041,
      "sha256": "cf429b2d0f29cfbd7eeaf3da979eaeb74683f558a85bdb0ac42257a438f9c860",
      "content": "// CoffeeScript structure validation and canonical source printing.\n\nimport nodes { 노드종류 }\nimport printer_cursor { 러스트열폭, 본문위치전진 }\nimport printer_setup { 인쇄상태만들기 }\nimport printer_state { 식별자이름 }\nimport printer_text { 선형원본만들기, 선형원본추가, 선형원본평평하게 }\nimport structure { 구조노드, 구조스칼라, 구조입력, 구조입력검사, 노드스칼라, 스칼라논리, 스칼라문자, 스칼라있음 }\n\nfunction 커피스크립트정수스칼라검사(노드: 구조노드, 필드: string) -> Result<int, string> {\n  let 값 = 노드스칼라(노드, 필드)\n  if 값.필드 == \"\" || 값.태그 != 3 || 값.정수값 < 0 {\n    return Err(\"CoffeeScript 구조 정수 스칼라가 정규형이 아닙니다: {필드}\")\n  }\n  Ok(값.정수값)\n}\n\nfunction 커피스크립트댓글자리표시(노드: 구조노드) -> Result<string, string> {\n  let 종류 = 스칼라문자(노드, \"commentKind\")\n  let 행폭 = 커피스크립트정수스칼라검사(노드, \"endRow\")? -\n    커피스크립트정수스칼라검사(노드, \"startRow\")?\n  let mut 본문 = \"\"\n  if 스칼라있음(노드, \"commentPlaceholderBody\") {\n    if 노드스칼라(노드, \"commentPlaceholderBody\").태그 != 5 {\n      return Err(\"CoffeeScript 댓글 자리표시 본문이 문자열이 아닙니다\")\n    }\n    본문 = 스칼라문자(노드, \"commentPlaceholderBody\")\n  } else if 종류 == \"line\" { 본문 = \"_\" } else if 행폭 == 0 { 본문 = \" \" } else {\n    let mut 행 = 1\n    while 행 < 행폭 { 본문 = 본문 + \"\\n.\"; 행 = 행 + 1 }\n    본문 = 본문 + \"\\n\"\n  }\n  let mut 줄수 = 0\n  for 글자 in 본문.scalars() {\n    let 코드 = 글자.codePointAt(0) ?? 0\n    let 종결자 = 코드 == 10 || 코드 == 8232 || 코드 == 8233\n    if 글자 != \" \" && 글자 != \".\" && 글자 != \"_\" && !종결자 {\n      return Err(\"CoffeeScript 댓글 자리표시 본문에 비기하 문자가 있습니다\")\n    }\n    if 종류 == \"line\" && 종결자 {\n      return Err(\"CoffeeScript 줄 댓글 자리표시가 여러 행에 걸칩니다\")\n    }\n    if 코드 == 10 { 줄수 = 줄수 + 1 }\n  }\n  if 종류 == \"line\" { return Ok(\"#\" + 본문) }\n  if 종류 != \"here\" || 본문 == \"\" || 줄수 != 행폭 {\n    return Err(\"CoffeeScript 여러줄 댓글 자리표시의 행 폭이 틀립니다\")\n  }\n  Ok(\"###\" + 본문 + \"###\")\n}\n\nexport function 커피스크립트인쇄구조검사(구조: 구조입력) -> Result<bool, string> {\n  구조입력검사(24, 구조)?\n  if 구조.노드들.length == 0 {\n    return Err(\"CoffeeScript 인쇄 구조에 program 노드가 필요합니다\")\n  }\n  if 구조.노드들[0].코드워드 != 200 ||\n    구조.노드들[0].부모순번 != -1 || 구조.노드들[0].자식필드있음 ||\n    구조.노드들[0].자식필드 != \"\" || 구조.노드들[0].자식색인 != -1 {\n    return Err(\"CoffeeScript 인쇄 구조 뿌리가 program 노드가 아닙니다\")\n  }\n  let mut 자식수들: Array<int> = []\n  let mut 순번 = 0\n  while 순번 < 구조.노드들.length { 자식수들.push(0); 순번 = 순번 + 1 }\n  let mut 분리본문발생수 = 0\n  let mut 다음식별자류번호 = 0\n  순번 = 0\n  while 순번 < 구조.노드들.length {\n    let 노드 = 구조.노드들[순번]\n    if 노드종류(24, 노드.코드워드) == 0 {\n      return Err(\"CoffeeScript 투영 인쇄기가 지원하지 않는 노드입니다: 순번 {순번}, 코드 {노드.코드워드}\")\n    }\n    if 순번 > 0 {\n      if 노드.부모순번 < 0 || 노드.부모순번 >= 순번 ||\n        !노드.자식필드있음 || 노드.자식필드 != \"children\" || 노드.자식색인 < 0 {\n        return Err(\"CoffeeScript 인쇄 구조의 부모 또는 자식 위치가 정규형이 아닙니다: 순번 {순번}\")\n      }\n      자식수들[노드.부모순번] = 자식수들[노드.부모순번] + 1\n    }\n    if 노드.시작 < 0 || 노드.끝 < 노드.시작 {\n      return Err(\"CoffeeScript 인쇄 구조의 원본 범위가 틀립니다: 순번 {순번}\")\n    }\n    let 자식수 = 커피스크립트정수스칼라검사(노드, \"childCount\")?\n    let 시작행 = 커피스크립트정수스칼라검사(노드, \"startRow\")?\n    let 시작열 = 커피스크립트정수스칼라검사(노드, \"startColumn\")?\n    let 끝행 = 커피스크립트정수스칼라검사(노드, \"endRow\")?\n    let 끝열 = 커피스크립트정수스칼라검사(노드, \"endColumn\")?\n    if 끝행 < 시작행 || (끝행 == 시작행 && 끝열 < 시작열) {\n      return Err(\"CoffeeScript 인쇄 구조의 원본 좌표가 틀립니다: 순번 {순번}\")\n    }\n    if !스칼라있음(노드, \"named\") || !스칼라있음(노드, \"extra\") {\n      return Err(\"CoffeeScript 인쇄 구조의 노드 표지 스칼라가 없습니다: 순번 {순번}\")\n    }\n    if 스칼라있음(노드, \"commentPlaceholderBody\") && (노드.코드워드 != 203 || 자식수 != 0) {\n      return Err(\"CoffeeScript 댓글 자리표시 본문은 댓글 잎에만 있어야 합니다: 순번 {순번}\")\n    }\n    if 노드.코드워드 == 204 && 자식수 == 0 {\n      if 노드.식별자있음 {\n        if 스칼라있음(노드, \"text\") {\n          return Err(\"CoffeeScript 식별자 이름이 이미지와 분리 본문에 함께 있습니다\")\n        }\n        if 노드.식별자류번호 < 0 || 노드.식별자류번호 > 다음식별자류번호 {\n          return Err(\"CoffeeScript 식별자 알파류가 첫 사용 정규형이 아닙니다: 순번 {순번}\")\n        }\n        if 노드.식별자류번호 == 다음식별자류번호 {\n          다음식별자류번호 = 다음식별자류번호 + 1\n        }\n        분리본문발생수 = 분리본문발생수 + 1\n      } else if 노드.식별자류번호 != 0 || !스칼라있음(노드, \"text\") ||\n        노드스칼라(노드, \"text\").태그 != 5 {\n        return Err(\"CoffeeScript 이미지 식별자 이름이 정규형이 아닙니다: 순번 {순번}\")\n      }\n    } else {\n      if 노드.식별자있음 || 노드.식별자류번호 != 0 {\n        return Err(\"CoffeeScript 식별자가 아닌 노드에 알파류가 있습니다: 순번 {순번}\")\n      }\n      if 노드.코드워드 == 203 {\n        if 자식수 != 0 || 스칼라있음(노드, \"text\") {\n          return Err(\"CoffeeScript 댓글 원문은 분리 본문에만 있어야 합니다: 순번 {순번}\")\n        }\n        if !스칼라있음(노드, \"commentKind\") ||\n          노드스칼라(노드, \"commentKind\").태그 != 5 {\n          return Err(\"CoffeeScript 댓글 종류가 정규형이 아닙니다: 순번 {순번}\")\n        }\n        let 댓글종류 = 스칼라문자(노드, \"commentKind\")\n        if 댓글종류 != \"line\" && 댓글종류 != \"here\" {\n          return Err(\"CoffeeScript 댓글 종류가 잘못되었습니다: 순번 {순번}\")\n        }\n        if 댓글종류 == \"line\" && 시작행 != 끝행 {\n          return Err(\"CoffeeScript 줄 댓글이 여러 행에 걸칩니다: 순번 {순번}\")\n        }\n        커피스크립트댓글자리표시(노드)?\n        if 스칼라있음(노드, \"commentTerminator\") {\n          if 노드스칼라(노드, \"commentTerminator\").태그 != 5 {\n            return Err(\"CoffeeScript 댓글 종결자가 문자열이 아닙니다: 순번 {순번}\")\n          }\n          let 종결글자들 = 스칼라문자(노드, \"commentTerminator\").scalars()\n          if 종결글자들.length != 1 {\n            return Err(\"CoffeeScript 댓글 종결자가 정규형이 아닙니다: 순번 {순번}\")\n          }\n          let 종결코드 = 종결글자들[0].codePointAt(0) ?? 0\n          if 종결코드 != 8232 && 종결코드 != 8233 {\n            return Err(\"CoffeeScript 댓글 종결자가 잘못되었습니다: 순번 {순번}\")\n          }\n        }\n        분리본문발생수 = 분리본문발생수 + 1\n      } else if 자식수 == 0 {\n        if !스칼라있음(노드, \"text\") || 노드스칼라(노드, \"text\").태그 != 5 {\n          return Err(\"CoffeeScript 인쇄 토큰의 원문이 없습니다: 순번 {순번}\")\n        }\n      } else if 스칼라있음(노드, \"text\") {\n        return Err(\"CoffeeScript 가지 노드에 토큰 원문이 있습니다: 순번 {순번}\")\n      }\n    }\n    순번 = 순번 + 1\n  }\n  순번 = 0\n  while 순번 < 구조.노드들.length {\n    if 커피스크립트정수스칼라검사(구조.노드들[순번], \"childCount\")? != 자식수들[순번] {\n      return Err(\"CoffeeScript 노드 자식 수가 구조와 다릅니다: 순번 {순번}\")\n    }\n    순번 = 순번 + 1\n  }\n  if 구조.분리본문값수 < 0 || 구조.분리본문값수 != 분리본문발생수 {\n    return Err(\"CoffeeScript 분리 본문 값 수가 식별자와 댓글 발생 수에 맞지 않습니다\")\n  }\n  Ok(true)\n}\n\nfunction 커피스크립트잎앞섬(구조: 구조입력, 왼쪽: int, 오른쪽: int) -> bool {\n  let 왼쪽노드 = 구조.노드들[왼쪽]\n  let 오른쪽노드 = 구조.노드들[오른쪽]\n  if 왼쪽노드.시작 != 오른쪽노드.시작 {\n    return 왼쪽노드.시작 < 오른쪽노드.시작\n  }\n  if 왼쪽노드.끝 != 오른쪽노드.끝 {\n    return 왼쪽노드.끝 < 오른쪽노드.끝\n  }\n  왼쪽 < 오른쪽\n}\n\nfunction 커피스크립트잎순번들(구조: 구조입력) -> Result<Array<int>, string> {\n  let mut 잎들: Array<int> = []\n  let mut 순번 = 0\n  while 순번 < 구조.노드들.length {\n    if 커피스크립트정수스칼라검사(구조.노드들[순번], \"childCount\")? == 0 {\n      잎들.push(순번)\n    }\n    순번 = 순번 + 1\n  }\n  let mut 색인 = 1\n  while 색인 < 잎들.length {\n    let 값 = 잎들[색인]\n    let mut 자리 = 색인\n    while 자리 > 0 && 커피스크립트잎앞섬(구조, 값, 잎들[자리 - 1]) {\n      잎들[자리] = 잎들[자리 - 1]\n      자리 = 자리 - 1\n    }\n    잎들[자리] = 값\n    색인 = 색인 + 1\n  }\n  Ok(잎들)\n}\n\nexport function 커피스크립트원본인쇄(구조: 구조입력) -> Result<string, string> {\n  커피스크립트인쇄구조검사(구조)?\n  let 준비 = 인쇄상태만들기(24, 구조, [], [], false, false)\n  let 잎들 = 커피스크립트잎순번들(구조)?\n  let 원본 = 선형원본만들기()\n  let mut 출력행 = 0\n  let mut 출력열 = 0\n  let mut 이전끝행 = 0\n  let mut 이전끝열 = 0\n  let mut 이전끝스칼라열 = 0\n  let mut 이전있음 = false\n  let mut 토큰색인 = 0\n  while 토큰색인 < 잎들.length {\n    let 순번 = 잎들[토큰색인]\n    let 노드 = 구조.노드들[순번]\n    let 시작행 = 커피스크립트정수스칼라검사(노드, \"startRow\")?\n    let 시작열 = 커피스크립트정수스칼라검사(노드, \"startColumn\")?\n    let 끝행 = 커피스크립트정수스칼라검사(노드, \"endRow\")?\n    let 끝열 = 커피스크립트정수스칼라검사(노드, \"endColumn\")?\n    let 선두들여쓰기있음 = 스칼라있음(노드, \"leadingIndentation\")\n    let 선두들여쓰기 = if 선두들여쓰기있음 {\n      스칼라문자(노드, \"leadingIndentation\")\n    } else { \"\" }\n    let 대체폭 = if 시작행 == 끝행 { 끝열 - 시작열 } else { 끝열 }\n    let 식별자노드 = 노드.코드워드 == 204\n    let 분리식별자 = 식별자노드 && 노드.식별자있음\n    let 생략댓글 = 노드.코드워드 == 203 && !스칼라있음(노드, \"text\")\n    let 토큰 = if 생략댓글 { \"\" } else if 식별자노드 {\n      식별자이름(준비, 순번)?\n    } else { 스칼라문자(노드, \"text\") }\n    let 원본스칼라폭 = if 분리식별자 {\n      러스트열폭(노드, \"identifier\", \"Scalar\", 대체폭)\n    } else if 생략댓글 {\n      러스트열폭(노드, \"comment\", \"Scalar\", 대체폭)\n    } else {\n      본문위치전진(24, 0, 0, 토큰)[1]\n    }\n    let 같은원본행 = 이전있음 && 시작행 == 이전끝행\n    let 원본간격 = if 같은원본행 { 시작열 - 이전끝열 } else { 0 }\n    let 원본시작스칼라열 = if 같은원본행 {\n      if 원본간격 == 0 { 출력열 } else { 이전끝스칼라열 + 원본간격 }\n    } else { 시작열 }\n    let 원본끝스칼라열 = if 끝행 == 시작행 {\n      원본시작스칼라열 + 원본스칼라폭\n    } else { 원본스칼라폭 }\n    let 구분필요 = 이전있음 && 시작행 == 이전끝행 && 시작열 > 이전끝열\n    if 출력행 < 시작행 {\n      while 출력행 < 시작행 {\n        선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n      }\n      if 선두들여쓰기있음 {\n        let 들여쓰기폭 = 본문위치전진(24, 0, 0, 선두들여쓰기)[1]\n        if 들여쓰기폭 > 원본시작스칼라열 {\n          return Err(\"CoffeeScript projection indentation exceeds its carried column\")\n        }\n        선형원본추가(원본, 선두들여쓰기)\n        출력열 = 출력열 + 들여쓰기폭\n      }\n      while 출력열 < 원본시작스칼라열 {\n        선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n      }\n    } else if 출력행 == 시작행 && 출력열 < 원본시작스칼라열 {\n      while 출력열 < 원본시작스칼라열 {\n        선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n      }\n    } else if 출력행 == 시작행 && 구분필요 {\n      선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n    }\n    if 생략댓글 {\n      let 자리표시 = 커피스크립트댓글자리표시(노드)?\n      선형원본추가(원본, 자리표시)\n      let 자리위치 = 본문위치전진(24, 출력행, 출력열, 자리표시)\n      출력행 = 자리위치[0]\n      출력열 = 자리위치[1]\n    } else {\n      if 스칼라논리(노드, \"opensOmittedCommentContinuationGroup\") {\n        선형원본추가(원본, \"(\")\n        출력열 = 출력열 + 1\n      }\n      선형원본추가(원본, 토큰)\n      let 출력위치 = 본문위치전진(24, 출력행, 출력열, 토큰)\n      출력행 = 출력위치[0]\n      출력열 = 출력위치[1]\n      if 스칼라논리(노드, \"closesOmittedCommentContinuationGroup\") {\n        선형원본추가(원본, \")\")\n        출력열 = 출력열 + 1\n      }\n    }\n    let 댓글종결자있음 = 스칼라있음(노드, \"commentTerminator\")\n    let 댓글종결자 = if 댓글종결자있음 {\n      스칼라문자(노드, \"commentTerminator\")\n    } else { \"\" }\n    if 댓글종결자있음 {\n      선형원본추가(원본, 댓글종결자)\n      let 종결위치 = 본문위치전진(24, 출력행, 출력열, 댓글종결자)\n      출력행 = 종결위치[0]\n      출력열 = 종결위치[1]\n    }\n    이전끝행 = 끝행\n    이전끝열 = 끝열\n    이전끝스칼라열 = if 생략댓글 {\n      let 종결자폭 = if 댓글종결자있음 {\n        본문위치전진(24, 0, 0, 댓글종결자)[1]\n      } else { 0 }\n      출력열 - 종결자폭\n    } else { 원본끝스칼라열 }\n    이전있음 = true\n    토큰색인 = 토큰색인 + 1\n  }\n  선형원본추가(원본, \"\\n\")\n  Ok(선형원본평평하게(원본))\n}\n",
      "sourceSha256": "cf429b2d0f29cfbd7eeaf3da979eaeb74683f558a85bdb0ac42257a438f9c860"
    },
    {
      "path": "topaz/src/printers/cpp.tpz",
      "language": "topaz",
      "bytes": 16757,
      "sha256": "ba1745ce3f5a404ce7d176727b591722f51645fd4fb712b1dd3ee21560f049ed",
      "content": "// C++ structure validation and canonical source printing.\n\nimport nodes { 노드종류 }\nimport printer_cursor { 러스트열폭, 러스트행들여쓰기, 본문위치전진 }\nimport printer_setup { 인쇄상태만들기 }\nimport printer_state { 식별자이름 }\nimport printer_text { 선형원본끝공백제거, 선형원본만들기, 선형원본추가, 선형원본평평하게 }\nimport schema { 씨플러스플러스댓글코드 }\nimport structure { 구조노드, 구조스칼라, 구조입력, 구조입력검사, 노드스칼라, 스칼라논리, 스칼라문자, 스칼라있음 }\n\nfunction 씨플러스플러스정수스칼라검사(노드: 구조노드, 필드: string) -> Result<int, string> {\n  let 값 = 노드스칼라(노드, 필드)\n  if 값.필드 == \"\" || 값.태그 != 3 || 값.정수값 < 0 {\n    return Err(\"C++ 구조 정수 스칼라가 정규형이 아닙니다: {필드}\")\n  }\n  Ok(값.정수값)\n}\n\nfunction 씨플러스플러스전처리원문있음(노드: 구조노드) -> bool {\n  스칼라있음(노드, \"preprocessorText\")\n}\n\nfunction 씨플러스플러스전처리원자(노드: 구조노드) -> bool {\n  씨플러스플러스전처리원문있음(노드) && 스칼라논리(노드, \"preprocessorAtomic\")\n}\n\nexport function 씨플러스플러스인쇄구조검사(구조: 구조입력) -> Result<bool, string> {\n  구조입력검사(8, 구조)?\n  if 구조.노드들.length == 0 {\n    return Err(\"C++ 인쇄 구조에 번역 단위 노드가 필요합니다\")\n  }\n  if 구조.노드들[0].코드워드 != 232 ||\n    구조.노드들[0].부모순번 != -1 || 구조.노드들[0].자식필드있음 ||\n    구조.노드들[0].자식필드 != \"\" || 구조.노드들[0].자식색인 != -1 {\n    return Err(\"C++ 인쇄 구조 뿌리가 번역 단위 노드가 아닙니다\")\n  }\n  let mut 자식수들: Array<int> = []\n  let mut 순번 = 0\n  while 순번 < 구조.노드들.length { 자식수들.push(0); 순번 = 순번 + 1 }\n  let mut 다음식별자류번호 = 0\n  let mut 분리본문발생수 = 0\n  let mut 이전시작 = 0\n  순번 = 0\n  while 순번 < 구조.노드들.length {\n    let 노드 = 구조.노드들[순번]\n    let 종류 = 노드종류(8, 노드.코드워드)\n    if 종류 == 0 {\n      return Err(\"C++ 투영 인쇄기가 지원하지 않는 노드입니다: 순번 {순번}, 코드 {노드.코드워드}\")\n    }\n    if 순번 > 0 {\n      if 노드.부모순번 < 0 || 노드.부모순번 >= 순번 ||\n        !노드.자식필드있음 || 노드.자식필드 == \"\" || 노드.자식색인 < 0 {\n        return Err(\"C++ 인쇄 구조의 부모 또는 자식 위치가 정규형이 아닙니다: 순번 {순번}\")\n      }\n      if 노드.시작 < 이전시작 {\n        return Err(\"C++ 인쇄 구조의 원본 순서가 정규형이 아닙니다: 순번 {순번}\")\n      }\n      자식수들[노드.부모순번] = 자식수들[노드.부모순번] + 1\n    }\n    이전시작 = 노드.시작\n    if 노드.시작 < 0 || 노드.끝 < 노드.시작 {\n      return Err(\"C++ 인쇄 구조의 원본 범위가 틀립니다: 순번 {순번}\")\n    }\n    let 자식수 = 씨플러스플러스정수스칼라검사(노드, \"childCount\")?\n    let 시작행 = 씨플러스플러스정수스칼라검사(노드, \"startRow\")?\n    let 시작열 = 씨플러스플러스정수스칼라검사(노드, \"startColumn\")?\n    let 끝행 = 씨플러스플러스정수스칼라검사(노드, \"endRow\")?\n    let 끝열 = 씨플러스플러스정수스칼라검사(노드, \"endColumn\")?\n    if 끝행 < 시작행 || (끝행 == 시작행 && 끝열 < 시작열) {\n      return Err(\"C++ 인쇄 구조의 원본 좌표가 틀립니다: 순번 {순번}\")\n    }\n    if !스칼라있음(노드, \"named\") || !스칼라있음(노드, \"extra\") {\n      return Err(\"C++ 인쇄 구조의 노드 표지 스칼라가 없습니다: 순번 {순번}\")\n    }\n    let 전처리원문 = 씨플러스플러스전처리원문있음(노드)\n    if 전처리원문 {\n      if 노드스칼라(노드, \"preprocessorText\").태그 != 5 ||\n        !스칼라있음(노드, \"preprocessorAtomic\") ||\n        (노드스칼라(노드, \"preprocessorAtomic\").태그 != 1 &&\n          노드스칼라(노드, \"preprocessorAtomic\").태그 != 2) {\n        return Err(\"C++ 전처리 원문 스칼라가 정규형이 아닙니다: 순번 {순번}\")\n      }\n      if 씨플러스플러스전처리원자(노드) {\n        if 스칼라있음(노드, \"preprocessorHeaderEndRow\") ||\n          스칼라있음(노드, \"preprocessorHeaderEndColumn\") {\n          return Err(\"C++ 원자 전처리 원문에 머리 범위가 있습니다: 순번 {순번}\")\n        }\n      } else {\n        let 머리끝행 = 씨플러스플러스정수스칼라검사(노드, \"preprocessorHeaderEndRow\")?\n        let 머리끝열 = 씨플러스플러스정수스칼라검사(노드, \"preprocessorHeaderEndColumn\")?\n        if 머리끝행 < 시작행 || (머리끝행 == 시작행 && 머리끝열 < 시작열) ||\n          머리끝행 > 끝행 || (머리끝행 == 끝행 && 머리끝열 > 끝열) {\n          return Err(\"C++ 전처리 머리 범위가 원본 범위를 벗어납니다: 순번 {순번}\")\n        }\n      }\n    } else if 스칼라있음(노드, \"preprocessorAtomic\") {\n      return Err(\"C++ 전처리 원자 표지에 원문이 없습니다: 순번 {순번}\")\n    }\n    if 종류 == 106 {\n      if 노드.식별자있음 {\n        if 스칼라있음(노드, \"text\") {\n          return Err(\"C++ 식별자 이름이 이미지와 분리 본문에 함께 있습니다\")\n        }\n        if 노드.식별자류번호 < 0 || 노드.식별자류번호 > 다음식별자류번호 {\n          return Err(\"C++ 식별자 알파류가 첫 사용 정규형이 아닙니다: 순번 {순번}\")\n        }\n        if 노드.식별자류번호 == 다음식별자류번호 {\n          다음식별자류번호 = 다음식별자류번호 + 1\n        }\n        분리본문발생수 = 분리본문발생수 + 1\n      } else {\n        if 노드.식별자류번호 != 0 || !스칼라있음(노드, \"text\") ||\n          노드스칼라(노드, \"text\").태그 != 5 {\n          return Err(\"C++ 이미지 식별자 이름이 정규형이 아닙니다: 순번 {순번}\")\n        }\n      }\n    } else {\n      if 노드.식별자있음 || 노드.식별자류번호 != 0 {\n        return Err(\"C++ 식별자가 아닌 노드에 알파류가 있습니다: 순번 {순번}\")\n      }\n      if 씨플러스플러스댓글코드(노드.코드워드) {\n        if 스칼라있음(노드, \"text\") {\n          return Err(\"C++ 댓글 원문은 분리 본문에만 있어야 합니다: 순번 {순번}\")\n        }\n        분리본문발생수 = 분리본문발생수 + 1\n      } else if !전처리원문 && 자식수 == 0 {\n        if !스칼라있음(노드, \"text\") || 노드스칼라(노드, \"text\").태그 != 5 {\n          return Err(\"C++ 인쇄 토큰의 원문이 없습니다: 순번 {순번}\")\n        }\n      }\n    }\n    순번 = 순번 + 1\n  }\n  순번 = 0\n  while 순번 < 구조.노드들.length {\n    if 씨플러스플러스정수스칼라검사(구조.노드들[순번], \"childCount\")? != 자식수들[순번] {\n      return Err(\"C++ 노드 자식 수가 구조와 다릅니다: 순번 {순번}\")\n    }\n    순번 = 순번 + 1\n  }\n  if 구조.분리본문값수 < 0 || 구조.분리본문값수 != 분리본문발생수 {\n    return Err(\"C++ 분리 본문 값 수가 식별자와 댓글 발생 수에 맞지 않습니다\")\n  }\n  Ok(true)\n}\n\nfunction 씨플러스플러스전처리원자조상(구조: 구조입력, 순번: int) -> bool {\n  let mut 부모순번 = 구조.노드들[순번].부모순번\n  while 부모순번 >= 0 {\n    if 씨플러스플러스전처리원자(구조.노드들[부모순번]) { return true }\n    부모순번 = 구조.노드들[부모순번].부모순번\n  }\n  false\n}\n\nfunction 씨플러스플러스전처리머리조상(구조: 구조입력, 순번: int) -> Result<bool, string> {\n  let 시작행 = 씨플러스플러스정수스칼라검사(구조.노드들[순번], \"startRow\")?\n  let 시작열 = 씨플러스플러스정수스칼라검사(구조.노드들[순번], \"startColumn\")?\n  let mut 부모순번 = 구조.노드들[순번].부모순번\n  while 부모순번 >= 0 {\n    let 부모 = 구조.노드들[부모순번]\n    if 씨플러스플러스전처리원문있음(부모) && !씨플러스플러스전처리원자(부모) {\n      let 머리끝행 = 씨플러스플러스정수스칼라검사(부모, \"preprocessorHeaderEndRow\")?\n      let 머리끝열 = 씨플러스플러스정수스칼라검사(부모, \"preprocessorHeaderEndColumn\")?\n      if 시작행 < 머리끝행 || (시작행 == 머리끝행 && 시작열 < 머리끝열) {\n        return Ok(true)\n      }\n    }\n    부모순번 = 부모.부모순번\n  }\n  Ok(false)\n}\n\nfunction 씨플러스플러스원자본문코드(코드워드: int) -> bool {\n  코드워드 == 334 || 코드워드 == 188 || 코드워드 == 361\n}\n\nfunction 씨플러스플러스원자본문조상(구조: 구조입력, 순번: int) -> bool {\n  let mut 부모순번 = 구조.노드들[순번].부모순번\n  while 부모순번 >= 0 {\n    if 씨플러스플러스원자본문코드(구조.노드들[부모순번].코드워드) { return true }\n    부모순번 = 구조.노드들[부모순번].부모순번\n  }\n  false\n}\n\nexport function 씨플러스플러스원본인쇄(구조: 구조입력) -> Result<string, string> {\n  씨플러스플러스인쇄구조검사(구조)?\n  let 준비 = 인쇄상태만들기(8, 구조, [], [], false, false)\n  let 단독복귀배치 = 스칼라논리(구조.노드들[0], \"loneCrLayout\")\n  let mut 토큰순번들: Array<int> = []\n  let mut 순번 = 0\n  while 순번 < 구조.노드들.length {\n    let 노드 = 구조.노드들[순번]\n    let 자식수 = 씨플러스플러스정수스칼라검사(노드, \"childCount\")?\n    if !씨플러스플러스전처리원자조상(구조, 순번) &&\n      !씨플러스플러스전처리머리조상(구조, 순번)? &&\n      !씨플러스플러스원자본문조상(구조, 순번) &&\n      (씨플러스플러스전처리원문있음(노드) || 씨플러스플러스원자본문코드(노드.코드워드) || 자식수 == 0) {\n      토큰순번들.push(순번)\n    }\n    순번 = 순번 + 1\n  }\n  let 원본 = 선형원본만들기()\n  let mut 출력행 = 0\n  let mut 출력열 = 0\n  let mut 이전끝행 = 0\n  let mut 이전끝열 = 0\n  let mut 이전끝스칼라열 = 0\n  let mut 이전있음 = false\n  let mut 토큰색인 = 0\n  while 토큰색인 < 토큰순번들.length {\n    순번 = 토큰순번들[토큰색인]\n    let 노드 = 구조.노드들[순번]\n    let 시작행 = 씨플러스플러스정수스칼라검사(노드, \"startRow\")?\n    let 시작열 = 씨플러스플러스정수스칼라검사(노드, \"startColumn\")?\n    let 끝행 = if 스칼라있음(노드, \"preprocessorHeaderEndRow\") {\n      씨플러스플러스정수스칼라검사(노드, \"preprocessorHeaderEndRow\")?\n    } else { 씨플러스플러스정수스칼라검사(노드, \"endRow\")? }\n    let 끝열 = if 스칼라있음(노드, \"preprocessorHeaderEndColumn\") {\n      씨플러스플러스정수스칼라검사(노드, \"preprocessorHeaderEndColumn\")?\n    } else { 씨플러스플러스정수스칼라검사(노드, \"endColumn\")? }\n    let 대체폭 = if 시작행 == 끝행 { 끝열 - 시작열 } else { 끝열 }\n    let 분리식별자 = 노드종류(8, 노드.코드워드) == 106 && 노드.식별자있음\n    let 분리댓글 = 씨플러스플러스댓글코드(노드.코드워드) && !스칼라있음(노드, \"text\")\n    let 의미낙하댓글 = 분리댓글 && 스칼라논리(노드, \"semanticFallthroughComment\")\n    let 생략댓글 = 분리댓글 && !의미낙하댓글\n    let 토큰 = if 의미낙하댓글 { \"[[fallthrough]];\" } else if 생략댓글 { \"\" } else if 씨플러스플러스전처리원문있음(노드) {\n      스칼라문자(노드, \"preprocessorText\")\n    } else if 노드종류(8, 노드.코드워드) == 106 {\n      식별자이름(준비, 순번)?\n    } else { 스칼라문자(노드, \"text\") }\n    let 원본스칼라폭 = if 분리식별자 {\n      러스트열폭(노드, \"identifier\", \"Scalar\", 대체폭)\n    } else if 분리댓글 {\n      러스트열폭(노드, \"comment\", \"Scalar\", 대체폭)\n    } else {\n      본문위치전진(8, 0, 0, 토큰)[1]\n    }\n    let 원본시작스칼라열 = if 이전있음 && 시작행 == 이전끝행 {\n      이전끝스칼라열 + 시작열 - 이전끝열\n    } else { 시작열 }\n    let 원본끝스칼라열 = if 끝행 == 시작행 {\n      원본시작스칼라열 + 원본스칼라폭\n    } else { 원본스칼라폭 }\n    let 행들여쓰기 = 러스트행들여쓰기(노드, 원본시작스칼라열)\n    let 구분필요 = 이전있음 && 시작행 == 이전끝행 && 시작열 > 이전끝열\n    if 생략댓글 {\n      let 다음시작행 = if 토큰색인 + 1 < 토큰순번들.length {\n        씨플러스플러스정수스칼라검사(\n          구조.노드들[토큰순번들[토큰색인 + 1]], \"startRow\"\n        )?\n      } else { -1 }\n      let 온줄차지 = (!이전있음 || 시작행 > 이전끝행) &&\n        (다음시작행 < 0 || 다음시작행 > 끝행)\n      let 줄끝댓글 = 이전있음 && 시작행 == 이전끝행 &&\n        (다음시작행 < 0 || 다음시작행 > 끝행)\n      if 온줄차지 {\n        while 출력행 < 시작행 {\n          선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n        }\n        while 출력행 < 끝행 {\n          선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n        }\n      } else if 줄끝댓글 {\n        이전끝행 = 끝행\n        이전끝열 = 끝열\n        이전끝스칼라열 = 원본끝스칼라열\n        이전있음 = true\n        토큰색인 = 토큰색인 + 1\n        continue\n      } else {\n        if 출력행 < 시작행 {\n          while 출력행 < 시작행 {\n            선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n          }\n          선형원본추가(원본, 행들여쓰기)\n          출력열 = 행들여쓰기.scalars().length\n          while 출력열 < 원본시작스칼라열 {\n            선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n          }\n        } else if 출력행 == 시작행 && 단독복귀배치 {\n          if 구분필요 { 선형원본추가(원본, \" \"); 출력열 = 출력열 + 1 }\n        } else if 출력행 == 시작행 && 출력열 < 원본시작스칼라열 {\n          while 출력열 < 원본시작스칼라열 {\n            선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n          }\n        } else if 출력행 == 시작행 && 구분필요 {\n          선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n        }\n        if 출력행 < 끝행 {\n          while 출력행 < 끝행 {\n            선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n          }\n          while 출력열 < 원본끝스칼라열 {\n            선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n          }\n        } else if 출력행 == 끝행 && 출력열 < 원본끝스칼라열 {\n          while 출력열 < 원본끝스칼라열 {\n            선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n          }\n        }\n      }\n    } else {\n      if 출력행 < 시작행 {\n        while 출력행 < 시작행 {\n          선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n        }\n        선형원본추가(원본, 행들여쓰기)\n        출력열 = 행들여쓰기.scalars().length\n        while 출력열 < 원본시작스칼라열 {\n          선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n        }\n      } else if 출력행 == 시작행 && 단독복귀배치 {\n        if 구분필요 { 선형원본추가(원본, \" \"); 출력열 = 출력열 + 1 }\n      } else if 출력행 == 시작행 && 출력열 < 원본시작스칼라열 {\n        while 출력열 < 원본시작스칼라열 {\n          선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n        }\n      } else if 출력행 == 시작행 && 구분필요 {\n        선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n      }\n      선형원본추가(원본, 토큰)\n      let 출력위치 = 본문위치전진(8, 출력행, 출력열, 토큰)\n      출력행 = 출력위치[0]\n      출력열 = 출력위치[1]\n    }\n    이전끝행 = 끝행\n    이전끝열 = 끝열\n    이전끝스칼라열 = 원본끝스칼라열\n    이전있음 = true\n    토큰색인 = 토큰색인 + 1\n  }\n  선형원본끝공백제거(원본)\n  선형원본추가(원본, \"\\n\")\n  Ok(선형원본평평하게(원본))\n}\n",
      "sourceSha256": "ba1745ce3f5a404ce7d176727b591722f51645fd4fb712b1dd3ee21560f049ed"
    },
    {
      "path": "topaz/src/printers/csharp.tpz",
      "language": "topaz",
      "bytes": 12034,
      "sha256": "9c9e9cdb3839b90267a595caf221bbcba83ecbc9c609151b481fde8e63b82874",
      "content": "// C# structure validation and canonical source printing.\n\nimport nodes { 노드종류 }\nimport printer_cursor { 러스트열폭, 본문위치전진 }\nimport printer_setup { 인쇄상태만들기 }\nimport printer_state { 식별자이름 }\nimport printer_text { 선형원본끝공백제거, 선형원본만들기, 선형원본추가, 선형원본평평하게 }\nimport schema { 씨샵댓글코드, 씨샵원자본문코드 }\nimport structure { 구조노드, 구조스칼라, 구조입력, 구조입력검사, 노드스칼라, 스칼라문자, 스칼라있음 }\n\nfunction 씨샵정수스칼라검사(노드: 구조노드, 필드: string) -> Result<int, string> {\n  let 값 = 노드스칼라(노드, 필드)\n  if 값.필드 == \"\" || 값.태그 != 3 || 값.정수값 < 0 {\n    return Err(\"C# 구조 정수 스칼라가 정규형이 아닙니다: {필드}\")\n  }\n  Ok(값.정수값)\n}\n\nexport function 씨샵인쇄구조검사(구조: 구조입력) -> Result<bool, string> {\n  구조입력검사(9, 구조)?\n  if 구조.노드들.length == 0 {\n    return Err(\"C# 인쇄 구조에 컴파일 단위 노드가 필요합니다\")\n  }\n  if 구조.노드들[0].코드워드 != 229 ||\n    구조.노드들[0].부모순번 != -1 || 구조.노드들[0].자식필드있음 ||\n    구조.노드들[0].자식필드 != \"\" || 구조.노드들[0].자식색인 != -1 {\n    return Err(\"C# 인쇄 구조 뿌리가 컴파일 단위 노드가 아닙니다\")\n  }\n  let mut 자식수들: Array<int> = []\n  let mut 순번 = 0\n  while 순번 < 구조.노드들.length { 자식수들.push(0); 순번 = 순번 + 1 }\n  let mut 다음식별자류번호 = 0\n  let mut 분리본문발생수 = 0\n  let mut 이전시작 = 0\n  순번 = 0\n  while 순번 < 구조.노드들.length {\n    let 노드 = 구조.노드들[순번]\n    let 종류 = 노드종류(9, 노드.코드워드)\n    if 종류 == 0 {\n      return Err(\"C# 투영 인쇄기가 지원하지 않는 노드입니다: 순번 {순번}, 코드 {노드.코드워드}\")\n    }\n    if 순번 > 0 {\n      if 노드.부모순번 < 0 || 노드.부모순번 >= 순번 ||\n        !노드.자식필드있음 || 노드.자식필드 == \"\" || 노드.자식색인 < 0 {\n        return Err(\"C# 인쇄 구조의 부모 또는 자식 위치가 정규형이 아닙니다: 순번 {순번}\")\n      }\n      if 노드.시작 < 이전시작 {\n        return Err(\"C# 인쇄 구조의 원본 순서가 정규형이 아닙니다: 순번 {순번}\")\n      }\n      자식수들[노드.부모순번] = 자식수들[노드.부모순번] + 1\n    }\n    이전시작 = 노드.시작\n    if 노드.시작 < 0 || 노드.끝 < 노드.시작 {\n      return Err(\"C# 인쇄 구조의 원본 범위가 틀립니다: 순번 {순번}\")\n    }\n    let 자식수 = 씨샵정수스칼라검사(노드, \"childCount\")?\n    let 시작행 = 씨샵정수스칼라검사(노드, \"startRow\")?\n    let 시작열 = 씨샵정수스칼라검사(노드, \"startColumn\")?\n    let 끝행 = 씨샵정수스칼라검사(노드, \"endRow\")?\n    let 끝열 = 씨샵정수스칼라검사(노드, \"endColumn\")?\n    if 끝행 < 시작행 || (끝행 == 시작행 && 끝열 < 시작열) {\n      return Err(\"C# 인쇄 구조의 원본 좌표가 틀립니다: 순번 {순번}\")\n    }\n    if !스칼라있음(노드, \"named\") || !스칼라있음(노드, \"extra\") {\n      return Err(\"C# 인쇄 구조의 노드 표지 스칼라가 없습니다: 순번 {순번}\")\n    }\n    let 식별자종류 = 종류 == 106 || 노드.코드워드 == 203\n    if 식별자종류 {\n      if 노드.식별자있음 {\n        if 스칼라있음(노드, \"text\") {\n          return Err(\"C# 식별자 이름이 이미지와 분리 본문에 함께 있습니다\")\n        }\n        if 노드.식별자류번호 < 0 || 노드.식별자류번호 > 다음식별자류번호 {\n          return Err(\"C# 식별자 알파류가 첫 사용 정규형이 아닙니다: 순번 {순번}\")\n        }\n        if 노드.식별자류번호 == 다음식별자류번호 {\n          다음식별자류번호 = 다음식별자류번호 + 1\n        }\n        분리본문발생수 = 분리본문발생수 + 1\n      } else {\n        if 노드.식별자류번호 != 0 || !스칼라있음(노드, \"text\") ||\n          노드스칼라(노드, \"text\").태그 != 5 {\n          return Err(\"C# 이미지 식별자 이름이 정규형이 아닙니다: 순번 {순번}\")\n        }\n      }\n    } else {\n      if 노드.식별자있음 || 노드.식별자류번호 != 0 {\n        return Err(\"C# 식별자가 아닌 노드에 알파류가 있습니다: 순번 {순번}\")\n      }\n      if 씨샵댓글코드(노드.코드워드) {\n        if 스칼라있음(노드, \"text\") {\n          return Err(\"C# 댓글 원문은 분리 본문에만 있어야 합니다: 순번 {순번}\")\n        }\n        분리본문발생수 = 분리본문발생수 + 1\n      } else if 씨샵원자본문코드(노드.코드워드) || 자식수 == 0 {\n        if !스칼라있음(노드, \"text\") || 노드스칼라(노드, \"text\").태그 != 5 {\n          return Err(\"C# 인쇄 토큰의 원문이 없습니다: 순번 {순번}\")\n        }\n      }\n    }\n    순번 = 순번 + 1\n  }\n  순번 = 0\n  while 순번 < 구조.노드들.length {\n    if 씨샵정수스칼라검사(구조.노드들[순번], \"childCount\")? != 자식수들[순번] {\n      return Err(\"C# 노드 자식 수가 구조와 다릅니다: 순번 {순번}\")\n    }\n    순번 = 순번 + 1\n  }\n  if 구조.분리본문값수 < 0 || 구조.분리본문값수 != 분리본문발생수 {\n    return Err(\"C# 분리 본문 값 수가 식별자와 댓글 발생 수에 맞지 않습니다\")\n  }\n  Ok(true)\n}\n\nfunction 씨샵원자본문조상(구조: 구조입력, 순번: int) -> bool {\n  let mut 부모순번 = 구조.노드들[순번].부모순번\n  while 부모순번 >= 0 {\n    if 씨샵원자본문코드(구조.노드들[부모순번].코드워드) { return true }\n    부모순번 = 구조.노드들[부모순번].부모순번\n  }\n  false\n}\n\nexport function 씨샵원본인쇄(구조: 구조입력) -> Result<string, string> {\n  씨샵인쇄구조검사(구조)?\n  let 준비 = 인쇄상태만들기(9, 구조, [], [], false, false)\n  let mut 토큰순번들: Array<int> = []\n  let mut 순번 = 0\n  while 순번 < 구조.노드들.length {\n    let 노드 = 구조.노드들[순번]\n    let 자식수 = 씨샵정수스칼라검사(노드, \"childCount\")?\n    if !씨샵원자본문조상(구조, 순번) &&\n      (씨샵원자본문코드(노드.코드워드) || 자식수 == 0) {\n      토큰순번들.push(순번)\n    }\n    순번 = 순번 + 1\n  }\n  let 원본 = 선형원본만들기()\n  let mut 출력행 = 0\n  let mut 출력열 = 0\n  let mut 이전끝행 = 0\n  let mut 이전끝열 = 0\n  let mut 이전끝스칼라열 = 0\n  let mut 이전있음 = false\n  let mut 토큰색인 = 0\n  while 토큰색인 < 토큰순번들.length {\n    순번 = 토큰순번들[토큰색인]\n    let 노드 = 구조.노드들[순번]\n    let 시작행 = 씨샵정수스칼라검사(노드, \"startRow\")?\n    let 시작열 = 씨샵정수스칼라검사(노드, \"startColumn\")?\n    let 끝행 = 씨샵정수스칼라검사(노드, \"endRow\")?\n    let 끝열 = 씨샵정수스칼라검사(노드, \"endColumn\")?\n    let 대체폭 = if 시작행 == 끝행 { 끝열 - 시작열 } else { 끝열 }\n    let 식별자노드 = 노드종류(9, 노드.코드워드) == 106 || 노드.코드워드 == 203\n    let 분리식별자 = 식별자노드 && 노드.식별자있음\n    let 생략댓글 = 씨샵댓글코드(노드.코드워드) && !스칼라있음(노드, \"text\")\n    let 토큰 = if 생략댓글 { \"\" } else if 식별자노드 {\n      식별자이름(준비, 순번)?\n    } else { 스칼라문자(노드, \"text\") }\n    let 원본스칼라폭 = if 분리식별자 {\n      러스트열폭(노드, \"identifier\", \"Scalar\", 대체폭)\n    } else if 생략댓글 {\n      러스트열폭(노드, \"comment\", \"Scalar\", 대체폭)\n    } else {\n      본문위치전진(9, 0, 0, 토큰)[1]\n    }\n    let 원본시작스칼라열 = if 이전있음 && 시작행 == 이전끝행 {\n      이전끝스칼라열 + 시작열 - 이전끝열\n    } else { 시작열 }\n    let 원본끝스칼라열 = if 끝행 == 시작행 {\n      원본시작스칼라열 + 원본스칼라폭\n    } else { 원본스칼라폭 }\n    let 구분필요 = 이전있음 && 시작행 == 이전끝행 && 시작열 > 이전끝열\n    if 생략댓글 {\n      let 다음시작행 = if 토큰색인 + 1 < 토큰순번들.length {\n        씨샵정수스칼라검사(\n          구조.노드들[토큰순번들[토큰색인 + 1]], \"startRow\"\n        )?\n      } else { -1 }\n      let 온줄차지 = (!이전있음 || 시작행 > 이전끝행) &&\n        (다음시작행 < 0 || 다음시작행 > 끝행)\n      let 줄끝댓글 = 이전있음 && 시작행 == 이전끝행 &&\n        (다음시작행 < 0 || 다음시작행 > 끝행)\n      if 온줄차지 {\n        while 출력행 < 시작행 {\n          선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n        }\n        while 출력행 < 끝행 {\n          선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n        }\n      } else if 줄끝댓글 {\n        이전끝행 = 끝행\n        이전끝열 = 끝열\n        이전끝스칼라열 = 원본끝스칼라열\n        이전있음 = true\n        토큰색인 = 토큰색인 + 1\n        continue\n      } else if 끝행 > 시작행 {\n        while 출력행 < 끝행 {\n          선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n        }\n        while 출력열 < 원본끝스칼라열 {\n          선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n        }\n      } else {\n        if 출력행 < 시작행 {\n          while 출력행 < 시작행 {\n            선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n          }\n          while 출력열 < 원본시작스칼라열 {\n            선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n          }\n        } else if 출력행 == 시작행 && 출력열 < 원본시작스칼라열 {\n          while 출력열 < 원본시작스칼라열 {\n            선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n          }\n        } else if 출력행 == 시작행 && 구분필요 {\n          선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n        }\n        if 출력행 < 끝행 {\n          while 출력행 < 끝행 {\n            선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n          }\n          while 출력열 < 원본끝스칼라열 {\n            선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n          }\n        } else if 출력행 == 끝행 && 출력열 < 원본끝스칼라열 {\n          while 출력열 < 원본끝스칼라열 {\n            선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n          }\n        }\n      }\n    } else {\n      if 출력행 < 시작행 {\n        while 출력행 < 시작행 {\n          선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n        }\n        while 출력열 < 원본시작스칼라열 {\n          선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n        }\n      } else if 출력행 == 시작행 && 출력열 < 원본시작스칼라열 {\n        while 출력열 < 원본시작스칼라열 {\n          선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n        }\n      } else if 출력행 == 시작행 && 구분필요 {\n        선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n      }\n      선형원본추가(원본, 토큰)\n      let 출력위치 = 본문위치전진(9, 출력행, 출력열, 토큰)\n      출력행 = 출력위치[0]\n      출력열 = 출력위치[1]\n    }\n    이전끝행 = 끝행\n    이전끝열 = 끝열\n    이전끝스칼라열 = 원본끝스칼라열\n    이전있음 = true\n    토큰색인 = 토큰색인 + 1\n  }\n  선형원본끝공백제거(원본)\n  선형원본추가(원본, \"\\n\")\n  Ok(선형원본평평하게(원본))\n}\n",
      "sourceSha256": "9c9e9cdb3839b90267a595caf221bbcba83ecbc9c609151b481fde8e63b82874"
    },
    {
      "path": "topaz/src/printers/dart.tpz",
      "language": "topaz",
      "bytes": 12770,
      "sha256": "ffa84256ce18d073b8c4082dfabc856de98c74488a5c03ae525ae66fd46800c0",
      "content": "// Dart structure validation and canonical source printing.\n\nimport names { 익명할당계획이름들 }\nimport nodes { 노드종류 }\nimport printer_cursor { 러스트열폭, 본문위치전진 }\nimport printer_setup { 인쇄상태만들기, 인쇄상태익명이름들바꾸기 }\nimport printer_state { 식별자이름 }\nimport printer_text { 선형원본끝공백제거, 선형원본만들기, 선형원본추가, 선형원본평평하게 }\nimport schema { 다트댓글코드, 다트원자본문코드 }\nimport structure { 구조노드, 구조스칼라, 구조입력, 구조입력검사, 노드스칼라, 스칼라문자, 스칼라있음 }\n\nfunction 다트정수스칼라검사(노드: 구조노드, 필드: string) -> Result<int, string> {\n  let 값 = 노드스칼라(노드, 필드)\n  if 값.필드 == \"\" || 값.태그 != 3 || 값.정수값 < 0 {\n    return Err(\"Dart 구조 정수 스칼라가 정규형이 아닙니다: {필드}\")\n  }\n  Ok(값.정수값)\n}\n\nexport function 다트인쇄구조검사(구조: 구조입력) -> Result<bool, string> {\n  구조입력검사(15, 구조)?\n  if 구조.노드들.length == 0 {\n    return Err(\"Dart 인쇄 구조에 프로그램 노드가 필요합니다\")\n  }\n  if 구조.노드들[0].코드워드 != 211 ||\n    구조.노드들[0].부모순번 != -1 || 구조.노드들[0].자식필드있음 ||\n    구조.노드들[0].자식필드 != \"\" || 구조.노드들[0].자식색인 != -1 {\n    return Err(\"Dart 인쇄 구조 뿌리가 프로그램 노드가 아닙니다\")\n  }\n  let mut 자식수들: Array<int> = []\n  let mut 순번 = 0\n  while 순번 < 구조.노드들.length { 자식수들.push(0); 순번 = 순번 + 1 }\n  let mut 분리본문발생수 = 0\n  let mut 다음식별자류번호 = 0\n  순번 = 0\n  while 순번 < 구조.노드들.length {\n    let 노드 = 구조.노드들[순번]\n    if 노드종류(15, 노드.코드워드) == 0 {\n      return Err(\"Dart 투영 인쇄기가 지원하지 않는 노드입니다: 순번 {순번}, 코드 {노드.코드워드}\")\n    }\n    if 순번 > 0 {\n      if 노드.부모순번 < 0 || 노드.부모순번 >= 순번 ||\n        !노드.자식필드있음 || 노드.자식필드 == \"\" || 노드.자식색인 < 0 {\n        return Err(\"Dart 인쇄 구조의 부모 또는 자식 위치가 정규형이 아닙니다: 순번 {순번}\")\n      }\n      자식수들[노드.부모순번] = 자식수들[노드.부모순번] + 1\n    }\n    if 노드.시작 < 0 || 노드.끝 < 노드.시작 {\n      return Err(\"Dart 인쇄 구조의 원본 범위가 틀립니다: 순번 {순번}\")\n    }\n    let 자식수 = 다트정수스칼라검사(노드, \"childCount\")?\n    let 시작행 = 다트정수스칼라검사(노드, \"startRow\")?\n    let 시작열 = 다트정수스칼라검사(노드, \"startColumn\")?\n    let 끝행 = 다트정수스칼라검사(노드, \"endRow\")?\n    let 끝열 = 다트정수스칼라검사(노드, \"endColumn\")?\n    if 끝행 < 시작행 || (끝행 == 시작행 && 끝열 < 시작열) {\n      return Err(\"Dart 인쇄 구조의 원본 좌표가 틀립니다: 순번 {순번}\")\n    }\n    if !스칼라있음(노드, \"named\") || !스칼라있음(노드, \"extra\") {\n      return Err(\"Dart 인쇄 구조의 노드 표지 스칼라가 없습니다: 순번 {순번}\")\n    }\n    if 스칼라있음(노드, \"sourceBom\") {\n      return Err(\"Dart 구조에 허용되지 않는 원본 BOM 표지가 있습니다: 순번 {순번}\")\n    }\n    if 노드.코드워드 == 90 && 자식수 == 0 {\n      if 노드.식별자있음 {\n        if 스칼라있음(노드, \"text\") {\n          return Err(\"Dart 식별자 이름이 이미지와 분리 본문에 함께 있습니다\")\n        }\n        if 노드.식별자류번호 < 0 || 노드.식별자류번호 > 다음식별자류번호 {\n          return Err(\"Dart 식별자 알파류가 첫 사용 정규형이 아닙니다: 순번 {순번}\")\n        }\n        if 노드.식별자류번호 == 다음식별자류번호 {\n          다음식별자류번호 = 다음식별자류번호 + 1\n        }\n        분리본문발생수 = 분리본문발생수 + 1\n      } else if 노드.식별자류번호 != 0 || !스칼라있음(노드, \"text\") ||\n        노드스칼라(노드, \"text\").태그 != 5 {\n        return Err(\"Dart 이미지 식별자 이름이 정규형이 아닙니다: 순번 {순번}\")\n      }\n    } else {\n      if 노드.식별자있음 || 노드.식별자류번호 != 0 {\n        return Err(\"Dart 식별자가 아닌 노드에 알파류가 있습니다: 순번 {순번}\")\n      }\n      if 다트댓글코드(노드.코드워드) {\n        if 스칼라있음(노드, \"text\") {\n          return Err(\"Dart 댓글 원문은 분리 본문에만 있어야 합니다: 순번 {순번}\")\n        }\n        분리본문발생수 = 분리본문발생수 + 1\n      } else if 자식수 == 0 || 다트원자본문코드(노드.코드워드) {\n        if !스칼라있음(노드, \"text\") || 노드스칼라(노드, \"text\").태그 != 5 {\n          return Err(\"Dart 인쇄 토큰의 원문이 없습니다: 순번 {순번}\")\n        }\n      } else if 스칼라있음(노드, \"text\") {\n        return Err(\"Dart 가지 노드에 토큰 원문이 있습니다: 순번 {순번}\")\n      }\n    }\n    순번 = 순번 + 1\n  }\n  순번 = 0\n  while 순번 < 구조.노드들.length {\n    if 다트정수스칼라검사(구조.노드들[순번], \"childCount\")? != 자식수들[순번] {\n      return Err(\"Dart 노드 자식 수가 구조와 다릅니다: 순번 {순번}\")\n    }\n    순번 = 순번 + 1\n  }\n  if 구조.분리본문값수 < 0 || 구조.분리본문값수 != 분리본문발생수 {\n    return Err(\"Dart 분리 본문 값 수가 식별자와 댓글 발생 수에 맞지 않습니다\")\n  }\n  Ok(true)\n}\n\nfunction 다트잎앞섬(구조: 구조입력, 왼쪽: int, 오른쪽: int) -> bool {\n  let 왼쪽노드 = 구조.노드들[왼쪽]\n  let 오른쪽노드 = 구조.노드들[오른쪽]\n  if 왼쪽노드.시작 != 오른쪽노드.시작 {\n    return 왼쪽노드.시작 < 오른쪽노드.시작\n  }\n  if 왼쪽노드.끝 != 오른쪽노드.끝 {\n    return 왼쪽노드.끝 < 오른쪽노드.끝\n  }\n  왼쪽 < 오른쪽\n}\n\nfunction 다트잎순번들(구조: 구조입력) -> Result<Array<int>, string> {\n  let mut 잎들: Array<int> = []\n  let mut 순번 = 0\n  while 순번 < 구조.노드들.length {\n    let 노드 = 구조.노드들[순번]\n    let mut 부모순번 = 노드.부모순번\n    let mut 원자본문조상있음 = false\n    while 부모순번 >= 0 {\n      if 다트원자본문코드(구조.노드들[부모순번].코드워드) {\n        원자본문조상있음 = true\n        부모순번 = -1\n      } else {\n        부모순번 = 구조.노드들[부모순번].부모순번\n      }\n    }\n    if !원자본문조상있음 &&\n      (다트원자본문코드(노드.코드워드) ||\n        다트정수스칼라검사(노드, \"childCount\")? == 0) {\n      잎들.push(순번)\n    }\n    순번 = 순번 + 1\n  }\n  let mut 색인 = 1\n  while 색인 < 잎들.length {\n    let 값 = 잎들[색인]\n    let mut 자리 = 색인\n    while 자리 > 0 && 다트잎앞섬(구조, 값, 잎들[자리 - 1]) {\n      잎들[자리] = 잎들[자리 - 1]\n      자리 = 자리 - 1\n    }\n    잎들[자리] = 값\n    색인 = 색인 + 1\n  }\n  Ok(잎들)\n}\n\nexport function 다트원본인쇄(구조: 구조입력) -> Result<string, string> {\n  다트인쇄구조검사(구조)?\n  let 기본준비 = 인쇄상태만들기(15, 구조, [], [], false, false)\n  let 준비 = 인쇄상태익명이름들바꾸기(기본준비, 익명할당계획이름들(기본준비)?)\n  let 잎들 = 다트잎순번들(구조)?\n  let 원본 = 선형원본만들기()\n  let mut 출력행 = 0\n  let mut 출력열 = 0\n  let mut 이전끝행 = 0\n  let mut 이전끝열 = 0\n  let mut 이전끝스칼라열 = 0\n  let mut 이전있음 = false\n  let mut 토큰색인 = 0\n  while 토큰색인 < 잎들.length {\n    let 순번 = 잎들[토큰색인]\n    let 노드 = 구조.노드들[순번]\n    let 시작행 = 다트정수스칼라검사(노드, \"startRow\")?\n    let 시작열 = 다트정수스칼라검사(노드, \"startColumn\")?\n    let 끝행 = 다트정수스칼라검사(노드, \"endRow\")?\n    let 끝열 = 다트정수스칼라검사(노드, \"endColumn\")?\n    let 대체폭 = if 시작행 == 끝행 { 끝열 - 시작열 } else { 끝열 }\n    let 식별자노드 = 노드.코드워드 == 90 && 다트정수스칼라검사(노드, \"childCount\")? == 0\n    let 분리식별자 = 식별자노드 && 노드.식별자있음\n    let 생략댓글 = 다트댓글코드(노드.코드워드) && !스칼라있음(노드, \"text\")\n    let 토큰 = if 생략댓글 { \"\" } else if 식별자노드 {\n      식별자이름(준비, 순번)?\n    } else { 스칼라문자(노드, \"text\") }\n    let 원본스칼라폭 = if 분리식별자 {\n      러스트열폭(노드, \"identifier\", \"Scalar\", 대체폭)\n    } else if 생략댓글 {\n      러스트열폭(노드, \"comment\", \"Scalar\", 대체폭)\n    } else {\n      본문위치전진(15, 0, 0, 토큰)[1]\n    }\n    let 원본시작스칼라열 = if 이전있음 && 시작행 == 이전끝행 {\n      이전끝스칼라열 + 시작열 - 이전끝열\n    } else { 시작열 }\n    let 원본끝스칼라열 = if 끝행 == 시작행 {\n      원본시작스칼라열 + 원본스칼라폭\n    } else { 원본스칼라폭 }\n    let 구분필요 = 이전있음 && 시작행 == 이전끝행 && 시작열 > 이전끝열\n    if 생략댓글 {\n      let 다음시작행 = if 토큰색인 + 1 < 잎들.length {\n        다트정수스칼라검사(구조.노드들[잎들[토큰색인 + 1]], \"startRow\")?\n      } else { -1 }\n      let 온줄차지 = (!이전있음 || 시작행 > 이전끝행) &&\n        (다음시작행 < 0 || 다음시작행 > 끝행)\n      let 줄끝댓글 = 이전있음 && 시작행 == 이전끝행 &&\n        (다음시작행 < 0 || 다음시작행 > 끝행)\n      if 온줄차지 {\n        while 출력행 < 시작행 {\n          선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n        }\n        while 출력행 < 끝행 {\n          선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n        }\n      } else if 줄끝댓글 {\n        이전끝행 = 끝행\n        이전끝열 = 끝열\n        이전끝스칼라열 = 원본끝스칼라열\n        이전있음 = true\n        토큰색인 = 토큰색인 + 1\n        continue\n      } else {\n        if 출력행 < 시작행 {\n          while 출력행 < 시작행 {\n            선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n          }\n          while 출력열 < 원본시작스칼라열 {\n            선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n          }\n        } else if 출력행 == 시작행 && 출력열 < 원본시작스칼라열 {\n          while 출력열 < 원본시작스칼라열 {\n            선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n          }\n        } else if 출력행 == 시작행 && 구분필요 {\n          선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n        }\n        if 출력행 < 끝행 {\n          while 출력행 < 끝행 {\n            선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n          }\n          while 출력열 < 원본끝스칼라열 {\n            선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n          }\n        } else if 출력행 == 끝행 && 출력열 < 원본끝스칼라열 {\n          while 출력열 < 원본끝스칼라열 {\n            선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n          }\n        }\n      }\n    } else {\n      if 출력행 < 시작행 {\n        while 출력행 < 시작행 {\n          선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n        }\n        while 출력열 < 원본시작스칼라열 {\n          선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n        }\n      } else if 출력행 == 시작행 && 출력열 < 원본시작스칼라열 {\n        while 출력열 < 원본시작스칼라열 {\n          선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n        }\n      } else if 출력행 == 시작행 && 구분필요 {\n        선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n      }\n      선형원본추가(원본, 토큰)\n      let 출력위치 = 본문위치전진(15, 출력행, 출력열, 토큰)\n      출력행 = 출력위치[0]\n      출력열 = 출력위치[1]\n    }\n    이전끝행 = 끝행\n    이전끝열 = 끝열\n    이전끝스칼라열 = 원본끝스칼라열\n    이전있음 = true\n    토큰색인 = 토큰색인 + 1\n  }\n  선형원본끝공백제거(원본)\n  선형원본추가(원본, \"\\n\")\n  Ok(선형원본평평하게(원본))\n}\n",
      "sourceSha256": "ffa84256ce18d073b8c4082dfabc856de98c74488a5c03ae525ae66fd46800c0"
    },
    {
      "path": "topaz/src/printers/elisp.tpz",
      "language": "topaz",
      "bytes": 13390,
      "sha256": "089c91f364942497c5ddcd49930db8e2511b129f1154cee75f375f722e2df4aa",
      "content": "// Emacs Lisp structure validation and canonical source printing.\n\nimport names { 익명할당계획이름들 }\nimport nodes { 노드종류 }\nimport printer_common { 오브젝티브씨잎앞섬 }\nimport printer_cursor { 러스트열폭, 본문위치전진 }\nimport printer_setup { 인쇄상태만들기, 인쇄상태익명이름들바꾸기 }\nimport printer_state { 식별자이름 }\nimport printer_text { 선형원본끝공백제거, 선형원본만들기, 선형원본추가, 선형원본평평하게 }\nimport structure { 구조노드, 구조스칼라, 구조입력, 구조입력검사, 노드스칼라, 스칼라문자, 스칼라있음 }\n\nfunction 이맥스리습정수스칼라검사(노드: 구조노드, 필드: string) -> Result<int, string> {\n  let 값 = 노드스칼라(노드, 필드)\n  if 값.필드 == \"\" || 값.태그 != 3 || 값.정수값 < 0 {\n    return Err(\"Elisp 구조 정수 스칼라가 정규형이 아닙니다: {필드}\")\n  }\n  Ok(값.정수값)\n}\n\nfunction 이맥스리습가지코드(코드워드: int) -> bool {\n  코드워드 == 37 || 코드워드 == 110 || 코드워드 == 183 || 코드워드 == 256\n}\n\nexport function 이맥스리습인쇄구조검사(구조: 구조입력) -> Result<bool, string> {\n  구조입력검사(26, 구조)?\n  if 구조.노드들.length == 0 {\n    return Err(\"Elisp 인쇄 구조에 source_file 노드가 필요합니다\")\n  }\n  if 구조.노드들[0].코드워드 != 37 ||\n    구조.노드들[0].부모순번 != -1 || 구조.노드들[0].자식필드있음 ||\n    구조.노드들[0].자식필드 != \"\" || 구조.노드들[0].자식색인 != -1 {\n    return Err(\"Elisp 인쇄 구조 뿌리가 source_file 노드가 아닙니다\")\n  }\n  let mut 자식수들: Array<int> = []\n  let mut 순번 = 0\n  while 순번 < 구조.노드들.length { 자식수들.push(0); 순번 = 순번 + 1 }\n  let mut 분리본문발생수 = 0\n  let mut 다음식별자류번호 = 0\n  순번 = 0\n  while 순번 < 구조.노드들.length {\n    let 노드 = 구조.노드들[순번]\n    if 노드종류(26, 노드.코드워드) == 0 {\n      return Err(\"Elisp 투영 인쇄기가 지원하지 않는 노드입니다: 순번 {순번}, 코드 {노드.코드워드}\")\n    }\n    if 순번 > 0 {\n      if 노드.부모순번 < 0 || 노드.부모순번 >= 순번 ||\n        !노드.자식필드있음 || 노드.자식색인 < 0 {\n        return Err(\"Elisp 인쇄 구조의 부모 또는 자식 위치가 정규형이 아닙니다: 순번 {순번}\")\n      }\n      let 부모 = 구조.노드들[노드.부모순번]\n      let 부모자식수 = 이맥스리습정수스칼라검사(부모, \"childCount\")?\n      if 노드.자식색인 >= 부모자식수 {\n        return Err(\"Elisp 자식 색인이 부모의 자식 수를 벗어납니다: 순번 {순번}\")\n      }\n      let 자식필드맞음 =\n        (부모.코드워드 == 37 && 노드.자식필드 == \"forms\") ||\n        ((부모.코드워드 == 110 || 부모.코드워드 == 183) && 노드.자식필드 == \"elements\") ||\n        (부모.코드워드 == 256 && 노드.자식색인 == 0 && 노드.자식필드 == \"operator\") ||\n        (부모.코드워드 == 256 && 노드.자식색인 > 0 && 노드.자식필드 == \"argument\")\n      if !자식필드맞음 {\n        return Err(\"Elisp 자식 필드가 부모 노드 종류와 다릅니다: 순번 {순번}\")\n      }\n      자식수들[노드.부모순번] = 자식수들[노드.부모순번] + 1\n    }\n    if 노드.시작 < 0 || 노드.끝 < 노드.시작 {\n      return Err(\"Elisp 인쇄 구조의 원본 범위가 틀립니다: 순번 {순번}\")\n    }\n    let 자식수 = 이맥스리습정수스칼라검사(노드, \"childCount\")?\n    let 시작행 = 이맥스리습정수스칼라검사(노드, \"startRow\")?\n    let 시작열 = 이맥스리습정수스칼라검사(노드, \"startColumn\")?\n    let 끝행 = 이맥스리습정수스칼라검사(노드, \"endRow\")?\n    let 끝열 = 이맥스리습정수스칼라검사(노드, \"endColumn\")?\n    if 끝행 < 시작행 || (끝행 == 시작행 && 끝열 < 시작열) {\n      return Err(\"Elisp 인쇄 구조의 원본 좌표가 틀립니다: 순번 {순번}\")\n    }\n    if 노드.코드워드 == 474 {\n      if 자식수 != 0 { return Err(\"Elisp symbol 노드에 자식이 있습니다: 순번 {순번}\") }\n      if 노드.식별자있음 {\n        if 스칼라있음(노드, \"text\") {\n          return Err(\"Elisp symbol 이름이 이미지와 분리 본문에 함께 있습니다\")\n        }\n        if 노드.식별자류번호 < 0 || 노드.식별자류번호 > 다음식별자류번호 {\n          return Err(\"Elisp symbol 알파류가 첫 사용 정규형이 아닙니다: 순번 {순번}\")\n        }\n        if 노드.식별자류번호 == 다음식별자류번호 {\n          다음식별자류번호 = 다음식별자류번호 + 1\n        }\n        분리본문발생수 = 분리본문발생수 + 1\n      } else if 노드.식별자류번호 != 0 || !스칼라있음(노드, \"text\") ||\n        노드스칼라(노드, \"text\").태그 != 5 {\n        return Err(\"Elisp 이미지 symbol 이름이 정규형이 아닙니다: 순번 {순번}\")\n      }\n    } else {\n      if 노드.식별자있음 || 노드.식별자류번호 != 0 {\n        return Err(\"Elisp symbol이 아닌 노드에 알파류가 있습니다: 순번 {순번}\")\n      }\n      if 노드.코드워드 == 400 {\n        if 자식수 != 0 || 스칼라있음(노드, \"text\") {\n          return Err(\"Elisp 댓글 원문은 분리 본문에만 있어야 합니다: 순번 {순번}\")\n        }\n        분리본문발생수 = 분리본문발생수 + 1\n      } else if 이맥스리습가지코드(노드.코드워드) {\n        if 스칼라있음(노드, \"text\") {\n          return Err(\"Elisp 가지 노드에 토큰 원문이 있습니다: 순번 {순번}\")\n        }\n        if 노드.코드워드 == 37 && 순번 != 0 {\n          return Err(\"Elisp source_file 노드는 뿌리에만 있어야 합니다\")\n        }\n        if 노드.코드워드 == 256 && 자식수 < 2 {\n          return Err(\"Elisp prefix_expression 자식 수가 2보다 작습니다: 순번 {순번}\")\n        }\n        if ((노드.코드워드 == 110 || 노드.코드워드 == 183) && 자식수 < 2) {\n          return Err(\"Elisp collection 노드에 구분자 자식이 없습니다: 순번 {순번}\")\n        }\n      } else if 자식수 != 0 || !스칼라있음(노드, \"text\") ||\n        노드스칼라(노드, \"text\").태그 != 5 {\n        return Err(\"Elisp 인쇄 토큰의 원문이 없습니다: 순번 {순번}\")\n      }\n    }\n    순번 = 순번 + 1\n  }\n  순번 = 0\n  while 순번 < 구조.노드들.length {\n    if 이맥스리습정수스칼라검사(구조.노드들[순번], \"childCount\")? != 자식수들[순번] {\n      return Err(\"Elisp 노드 자식 수가 구조와 다릅니다: 순번 {순번}\")\n    }\n    순번 = 순번 + 1\n  }\n  if 구조.분리본문값수 < 0 || 구조.분리본문값수 != 분리본문발생수 {\n    return Err(\"Elisp 분리 본문 값 수가 symbol과 댓글 발생 수에 맞지 않습니다\")\n  }\n  Ok(true)\n}\n\nfunction 이맥스리습잎순번들(구조: 구조입력) -> Result<Array<int>, string> {\n  let mut 잎들: Array<int> = []\n  let mut 순번 = 0\n  while 순번 < 구조.노드들.length {\n    if 이맥스리습정수스칼라검사(구조.노드들[순번], \"childCount\")? == 0 {\n      잎들.push(순번)\n    }\n    순번 = 순번 + 1\n  }\n  let mut 색인 = 1\n  while 색인 < 잎들.length {\n    let 값 = 잎들[색인]\n    let mut 자리 = 색인\n    while 자리 > 0 && 오브젝티브씨잎앞섬(구조, 값, 잎들[자리 - 1]) {\n      잎들[자리] = 잎들[자리 - 1]\n      자리 = 자리 - 1\n    }\n    잎들[자리] = 값\n    색인 = 색인 + 1\n  }\n  Ok(잎들)\n}\n\nexport function 이맥스리습원본인쇄(구조: 구조입력) -> Result<string, string> {\n  이맥스리습인쇄구조검사(구조)?\n  let 기본준비 = 인쇄상태만들기(26, 구조, [], [], false, false)\n  let 준비 = 인쇄상태익명이름들바꾸기(기본준비, 익명할당계획이름들(기본준비)?)\n  let 잎들 = 이맥스리습잎순번들(구조)?\n  let 원본 = 선형원본만들기()\n  let mut 출력행 = 0\n  let mut 출력열 = 0\n  let mut 이전끝행 = 0\n  let mut 이전끝열 = 0\n  let mut 이전끝스칼라열 = 0\n  let mut 이전있음 = false\n  let mut 토큰색인 = 0\n  while 토큰색인 < 잎들.length {\n    let 순번 = 잎들[토큰색인]\n    let 노드 = 구조.노드들[순번]\n    let 시작행 = 이맥스리습정수스칼라검사(노드, \"startRow\")?\n    let 시작열 = 이맥스리습정수스칼라검사(노드, \"startColumn\")?\n    let 끝행 = 이맥스리습정수스칼라검사(노드, \"endRow\")?\n    let 끝열 = 이맥스리습정수스칼라검사(노드, \"endColumn\")?\n    let 대체폭 = if 시작행 == 끝행 { 끝열 - 시작열 } else { 끝열 }\n    let 식별자노드 = 노드.코드워드 == 474\n    let 분리식별자 = 식별자노드 && 노드.식별자있음\n    let 생략댓글 = 노드.코드워드 == 400 && !스칼라있음(노드, \"text\")\n    let 토큰 = if 생략댓글 { \"\" } else if 식별자노드 {\n      식별자이름(준비, 순번)?\n    } else { 스칼라문자(노드, \"text\") }\n    let 원본스칼라폭 = if 분리식별자 {\n      러스트열폭(노드, \"identifier\", \"Scalar\", 대체폭)\n    } else if 생략댓글 {\n      러스트열폭(노드, \"comment\", \"Scalar\", 대체폭)\n    } else {\n      본문위치전진(26, 0, 0, 토큰)[1]\n    }\n    let 같은원본행 = 이전있음 && 시작행 == 이전끝행\n    let 원본간격 = if 같은원본행 { 시작열 - 이전끝열 } else { 0 }\n    let 원본시작스칼라열 = if 같은원본행 {\n      if 원본간격 == 0 { 출력열 } else { 이전끝스칼라열 + 원본간격 }\n    } else { 시작열 }\n    let 원본끝스칼라열 = if 끝행 == 시작행 {\n      원본시작스칼라열 + 원본스칼라폭\n    } else { 원본스칼라폭 }\n    let 구분필요 = 이전있음 && 시작행 == 이전끝행 && 시작열 > 이전끝열\n    if 생략댓글 {\n      let 다음시작행 = if 토큰색인 + 1 < 잎들.length {\n        이맥스리습정수스칼라검사(구조.노드들[잎들[토큰색인 + 1]], \"startRow\")?\n      } else { -1 }\n      let 온줄차지 = (!이전있음 || 시작행 > 이전끝행) &&\n        (다음시작행 < 0 || 다음시작행 > 끝행)\n      let 줄끝댓글 = 이전있음 && 시작행 == 이전끝행 &&\n        (다음시작행 < 0 || 다음시작행 > 끝행)\n      if 온줄차지 {\n        while 출력행 < 시작행 {\n          선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n        }\n        while 출력행 < 끝행 {\n          선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n        }\n      } else if 줄끝댓글 {\n        이전끝행 = 끝행\n        이전끝열 = 끝열\n        이전끝스칼라열 = 원본끝스칼라열\n        이전있음 = true\n        토큰색인 = 토큰색인 + 1\n        continue\n      } else {\n        if 출력행 < 시작행 {\n          while 출력행 < 시작행 {\n            선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n          }\n          while 출력열 < 원본시작스칼라열 {\n            선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n          }\n        } else if 출력행 == 시작행 && 출력열 < 원본시작스칼라열 {\n          while 출력열 < 원본시작스칼라열 {\n            선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n          }\n        } else if 출력행 == 시작행 && 구분필요 {\n          선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n        }\n        if 출력행 < 끝행 {\n          while 출력행 < 끝행 {\n            선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n          }\n          while 출력열 < 원본끝스칼라열 {\n            선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n          }\n        } else if 출력행 == 끝행 && 출력열 < 원본끝스칼라열 {\n          while 출력열 < 원본끝스칼라열 {\n            선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n          }\n        }\n      }\n    } else {\n      if 출력행 < 시작행 {\n        while 출력행 < 시작행 {\n          선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n        }\n        while 출력열 < 원본시작스칼라열 {\n          선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n        }\n      } else if 출력행 == 시작행 && 출력열 < 원본시작스칼라열 {\n        while 출력열 < 원본시작스칼라열 {\n          선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n        }\n      } else if 출력행 == 시작행 && 구분필요 {\n        선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n      }\n      선형원본추가(원본, 토큰)\n      let 출력위치 = 본문위치전진(26, 출력행, 출력열, 토큰)\n      출력행 = 출력위치[0]\n      출력열 = 출력위치[1]\n    }\n    이전끝행 = 끝행\n    이전끝열 = 끝열\n    이전끝스칼라열 = 원본끝스칼라열\n    이전있음 = true\n    토큰색인 = 토큰색인 + 1\n  }\n  선형원본끝공백제거(원본)\n  선형원본추가(원본, \"\\n\")\n  Ok(선형원본평평하게(원본))\n}\n",
      "sourceSha256": "089c91f364942497c5ddcd49930db8e2511b129f1154cee75f375f722e2df4aa"
    },
    {
      "path": "topaz/src/printers/elixir.tpz",
      "language": "topaz",
      "bytes": 12937,
      "sha256": "0779b97898cbad6509facf2422aeaa09f1b95c6dab6e04bffca9aa098c9d9ca1",
      "content": "// Elixir structure validation and canonical source printing.\n\nimport nodes { 노드종류 }\nimport print { 글자합치기 }\nimport printer_cursor { 러스트열폭, 본문위치전진 }\nimport printer_setup { 인쇄상태만들기 }\nimport printer_state { 식별자이름 }\nimport printer_text { 선형원본길이, 선형원본만들기, 선형원본추가, 선형원본평평하게 }\nimport schema { 엘릭서댓글코드, 엘릭서원자본문코드 }\nimport structure { 구조노드, 구조스칼라, 구조입력, 구조입력검사, 노드스칼라, 스칼라문자, 스칼라있음 }\n\nfunction 엘릭서정수스칼라검사(노드: 구조노드, 필드: string) -> Result<int, string> {\n  let 값 = 노드스칼라(노드, 필드)\n  if 값.필드 == \"\" || 값.태그 != 3 || 값.정수값 < 0 {\n    return Err(\"Elixir 구조 정수 스칼라가 정규형이 아닙니다: {필드}\")\n  }\n  Ok(값.정수값)\n}\n\nexport function 엘릭서인쇄구조검사(구조: 구조입력) -> Result<bool, string> {\n  구조입력검사(16, 구조)?\n  if 구조.노드들.length == 0 {\n    return Err(\"Elixir 인쇄 구조에 원본 노드가 필요합니다\")\n  }\n  if 구조.노드들[0].코드워드 != 23 ||\n    구조.노드들[0].부모순번 != -1 || 구조.노드들[0].자식필드있음 ||\n    구조.노드들[0].자식필드 != \"\" || 구조.노드들[0].자식색인 != -1 {\n    return Err(\"Elixir 인쇄 구조 뿌리가 원본 노드가 아닙니다\")\n  }\n  let mut 자식수들: Array<int> = []\n  let mut 순번 = 0\n  while 순번 < 구조.노드들.length { 자식수들.push(0); 순번 = 순번 + 1 }\n  let mut 분리본문발생수 = 0\n  let mut 다음식별자류번호 = 0\n  순번 = 0\n  while 순번 < 구조.노드들.length {\n    let 노드 = 구조.노드들[순번]\n    if 노드종류(16, 노드.코드워드) == 0 {\n      return Err(\"Elixir 투영 인쇄기가 지원하지 않는 노드입니다: 순번 {순번}, 코드 {노드.코드워드}\")\n    }\n    if 순번 > 0 {\n      if 노드.부모순번 < 0 || 노드.부모순번 >= 순번 ||\n        !노드.자식필드있음 || 노드.자식필드 == \"\" || 노드.자식색인 < 0 {\n        return Err(\"Elixir 인쇄 구조의 부모 또는 자식 위치가 정규형이 아닙니다: 순번 {순번}\")\n      }\n      자식수들[노드.부모순번] = 자식수들[노드.부모순번] + 1\n    }\n    if 노드.시작 < 0 || 노드.끝 < 노드.시작 {\n      return Err(\"Elixir 인쇄 구조의 원본 범위가 틀립니다: 순번 {순번}\")\n    }\n    let 자식수 = 엘릭서정수스칼라검사(노드, \"childCount\")?\n    let 시작행 = 엘릭서정수스칼라검사(노드, \"startRow\")?\n    let 시작열 = 엘릭서정수스칼라검사(노드, \"startColumn\")?\n    let 끝행 = 엘릭서정수스칼라검사(노드, \"endRow\")?\n    let 끝열 = 엘릭서정수스칼라검사(노드, \"endColumn\")?\n    if 끝행 < 시작행 || (끝행 == 시작행 && 끝열 < 시작열) {\n      return Err(\"Elixir 인쇄 구조의 원본 좌표가 틀립니다: 순번 {순번}\")\n    }\n    if !스칼라있음(노드, \"named\") || !스칼라있음(노드, \"extra\") {\n      return Err(\"Elixir 인쇄 구조의 노드 표지 스칼라가 없습니다: 순번 {순번}\")\n    }\n    if 스칼라있음(노드, \"sourceBom\") {\n      return Err(\"Elixir 구조에 허용되지 않는 원본 BOM 표지가 있습니다: 순번 {순번}\")\n    }\n    if 노드.코드워드 == 418 && 자식수 == 0 {\n      if 노드.식별자있음 {\n        if 스칼라있음(노드, \"text\") {\n          return Err(\"Elixir 식별자 이름이 이미지와 분리 본문에 함께 있습니다\")\n        }\n        if 노드.식별자류번호 < 0 || 노드.식별자류번호 > 다음식별자류번호 {\n          return Err(\"Elixir 식별자 알파류가 첫 사용 정규형이 아닙니다: 순번 {순번}\")\n        }\n        if 노드.식별자류번호 == 다음식별자류번호 {\n          다음식별자류번호 = 다음식별자류번호 + 1\n        }\n        분리본문발생수 = 분리본문발생수 + 1\n      } else if 노드.식별자류번호 != 0 || !스칼라있음(노드, \"text\") ||\n        노드스칼라(노드, \"text\").태그 != 5 {\n        return Err(\"Elixir 이미지 식별자 이름이 정규형이 아닙니다: 순번 {순번}\")\n      }\n    } else {\n      if 노드.식별자있음 || 노드.식별자류번호 != 0 {\n        return Err(\"Elixir 식별자가 아닌 노드에 알파류가 있습니다: 순번 {순번}\")\n      }\n      if 엘릭서댓글코드(노드.코드워드) {\n        if 스칼라있음(노드, \"text\") {\n          return Err(\"Elixir 댓글 원문은 분리 본문에만 있어야 합니다: 순번 {순번}\")\n        }\n        분리본문발생수 = 분리본문발생수 + 1\n      } else if 자식수 == 0 {\n        if !스칼라있음(노드, \"text\") || 노드스칼라(노드, \"text\").태그 != 5 {\n          return Err(\"Elixir 인쇄 토큰의 원문이 없습니다: 순번 {순번}\")\n        }\n      } else if 스칼라있음(노드, \"text\") {\n        return Err(\"Elixir 가지 노드에 토큰 원문이 있습니다: 순번 {순번}\")\n      }\n    }\n    순번 = 순번 + 1\n  }\n  순번 = 0\n  while 순번 < 구조.노드들.length {\n    if 엘릭서정수스칼라검사(구조.노드들[순번], \"childCount\")? != 자식수들[순번] {\n      return Err(\"Elixir 노드 자식 수가 구조와 다릅니다: 순번 {순번}\")\n    }\n    순번 = 순번 + 1\n  }\n  if 구조.분리본문값수 < 0 || 구조.분리본문값수 != 분리본문발생수 {\n    return Err(\"Elixir 분리 본문 값 수가 식별자와 댓글 발생 수에 맞지 않습니다\")\n  }\n  Ok(true)\n}\n\nfunction 엘릭서잎앞섬(구조: 구조입력, 왼쪽: int, 오른쪽: int) -> bool {\n  let 왼쪽노드 = 구조.노드들[왼쪽]\n  let 오른쪽노드 = 구조.노드들[오른쪽]\n  if 왼쪽노드.시작 != 오른쪽노드.시작 {\n    return 왼쪽노드.시작 < 오른쪽노드.시작\n  }\n  if 왼쪽노드.끝 != 오른쪽노드.끝 {\n    return 왼쪽노드.끝 < 오른쪽노드.끝\n  }\n  왼쪽 < 오른쪽\n}\n\nfunction 엘릭서잎순번들(구조: 구조입력) -> Result<Array<int>, string> {\n  let mut 잎들: Array<int> = []\n  let mut 순번 = 0\n  while 순번 < 구조.노드들.length {\n    let 노드 = 구조.노드들[순번]\n    let mut 부모순번 = 노드.부모순번\n    let mut 원자본문조상있음 = false\n    while 부모순번 >= 0 {\n      if 엘릭서원자본문코드(구조.노드들[부모순번].코드워드) {\n        원자본문조상있음 = true\n        부모순번 = -1\n      } else {\n        부모순번 = 구조.노드들[부모순번].부모순번\n      }\n    }\n    if !원자본문조상있음 &&\n      (엘릭서원자본문코드(노드.코드워드) ||\n        엘릭서정수스칼라검사(노드, \"childCount\")? == 0) {\n      잎들.push(순번)\n    }\n    순번 = 순번 + 1\n  }\n  let mut 색인 = 1\n  while 색인 < 잎들.length {\n    let 값 = 잎들[색인]\n    let mut 자리 = 색인\n    while 자리 > 0 && 엘릭서잎앞섬(구조, 값, 잎들[자리 - 1]) {\n      잎들[자리] = 잎들[자리 - 1]\n      자리 = 자리 - 1\n    }\n    잎들[자리] = 값\n    색인 = 색인 + 1\n  }\n  Ok(잎들)\n}\n\nexport function 엘릭서원본인쇄(구조: 구조입력) -> Result<string, string> {\n  엘릭서인쇄구조검사(구조)?\n  let 준비 = 인쇄상태만들기(16, 구조, [], [], false, false)\n  let 잎들 = 엘릭서잎순번들(구조)?\n  let 원본 = 선형원본만들기()\n  let mut 출력행 = 0\n  let mut 출력열 = 0\n  let mut 이전끝행 = 0\n  let mut 이전끝열 = 0\n  let mut 이전끝스칼라열 = 0\n  let mut 이전있음 = false\n  let mut 마지막토큰스칼라길이 = 0\n  let mut 토큰색인 = 0\n  while 토큰색인 < 잎들.length {\n    let 순번 = 잎들[토큰색인]\n    let 노드 = 구조.노드들[순번]\n    let 시작행 = 엘릭서정수스칼라검사(노드, \"startRow\")?\n    let 시작열 = 엘릭서정수스칼라검사(노드, \"startColumn\")?\n    let 끝행 = 엘릭서정수스칼라검사(노드, \"endRow\")?\n    let 끝열 = 엘릭서정수스칼라검사(노드, \"endColumn\")?\n    let 대체폭 = if 시작행 == 끝행 { 끝열 - 시작열 } else { 끝열 }\n    let 식별자노드 = 노드.코드워드 == 418 && 엘릭서정수스칼라검사(노드, \"childCount\")? == 0\n    let 분리식별자 = 식별자노드 && 노드.식별자있음\n    let 생략댓글 = 엘릭서댓글코드(노드.코드워드) && !스칼라있음(노드, \"text\")\n    let 토큰 = if 생략댓글 { \"\" } else if 식별자노드 {\n      식별자이름(준비, 순번)?\n    } else { 스칼라문자(노드, \"text\") }\n    let 원본스칼라폭 = if 분리식별자 {\n      러스트열폭(노드, \"identifier\", \"Scalar\", 대체폭)\n    } else if 생략댓글 {\n      러스트열폭(노드, \"comment\", \"Scalar\", 대체폭)\n    } else {\n      본문위치전진(16, 0, 0, 토큰)[1]\n    }\n    let 같은원본행 = 이전있음 && 시작행 == 이전끝행\n    let 원본간격 = if 같은원본행 { 시작열 - 이전끝열 } else { 0 }\n    let 원본시작스칼라열 = if 같은원본행 {\n      if 원본간격 == 0 { 출력열 } else { 이전끝스칼라열 + 원본간격 }\n    } else { 시작열 }\n    let 원본끝스칼라열 = if 끝행 == 시작행 {\n      원본시작스칼라열 + 원본스칼라폭\n    } else { 원본스칼라폭 }\n    let 구분필요 = 이전있음 && 시작행 == 이전끝행 && 시작열 > 이전끝열\n    if 생략댓글 {\n      let 다음시작행 = if 토큰색인 + 1 < 잎들.length {\n        엘릭서정수스칼라검사(구조.노드들[잎들[토큰색인 + 1]], \"startRow\")?\n      } else { -1 }\n      let 온줄차지 = (!이전있음 || 시작행 > 이전끝행) &&\n        (다음시작행 < 0 || 다음시작행 > 끝행)\n      let 줄끝댓글 = 이전있음 && 시작행 == 이전끝행 &&\n        (다음시작행 < 0 || 다음시작행 > 끝행)\n      if 온줄차지 {\n        while 출력행 < 시작행 {\n          선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n        }\n        while 출력행 < 끝행 {\n          선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n        }\n      } else if 줄끝댓글 {\n        이전끝행 = 끝행\n        이전끝열 = 끝열\n        이전끝스칼라열 = 원본끝스칼라열\n        이전있음 = true\n        토큰색인 = 토큰색인 + 1\n        continue\n      } else {\n        if 출력행 < 시작행 {\n          while 출력행 < 시작행 {\n            선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n          }\n          while 출력열 < 원본시작스칼라열 {\n            선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n          }\n        } else if 출력행 == 시작행 && 출력열 < 원본시작스칼라열 {\n          while 출력열 < 원본시작스칼라열 {\n            선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n          }\n        } else if 출력행 == 시작행 && 구분필요 {\n          선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n        }\n        if 출력행 < 끝행 {\n          while 출력행 < 끝행 {\n            선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n          }\n          while 출력열 < 원본끝스칼라열 {\n            선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n          }\n        } else if 출력행 == 끝행 && 출력열 < 원본끝스칼라열 {\n          while 출력열 < 원본끝스칼라열 {\n            선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n          }\n        }\n      }\n    } else {\n      if 출력행 < 시작행 {\n        while 출력행 < 시작행 {\n          선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n        }\n        while 출력열 < 원본시작스칼라열 {\n          선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n        }\n      } else if 출력행 == 시작행 && 출력열 < 원본시작스칼라열 {\n        while 출력열 < 원본시작스칼라열 {\n          선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n        }\n      } else if 출력행 == 시작행 && 구분필요 {\n        선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n      }\n      선형원본추가(원본, 토큰)\n      let 출력위치 = 본문위치전진(16, 출력행, 출력열, 토큰)\n      출력행 = 출력위치[0]\n      출력열 = 출력위치[1]\n      if 토큰 != \"\" { 마지막토큰스칼라길이 = 선형원본길이(원본) }\n    }\n    이전끝행 = 끝행\n    이전끝열 = 끝열\n    이전끝스칼라열 = 원본끝스칼라열\n    이전있음 = true\n    토큰색인 = 토큰색인 + 1\n  }\n  Ok(글자합치기(선형원본평평하게(원본).scalars(), 0, 마지막토큰스칼라길이) + \"\\n\")\n}\n",
      "sourceSha256": "0779b97898cbad6509facf2422aeaa09f1b95c6dab6e04bffca9aa098c9d9ca1"
    },
    {
      "path": "topaz/src/printers/elm.tpz",
      "language": "topaz",
      "bytes": 13396,
      "sha256": "c9e322bd3965fccfa6ab952b140293c309171972f51eb9349612bf40d53bf80d",
      "content": "// Elm structure validation and canonical source printing.\n\nimport names { 익명할당계획이름들 }\nimport nodes { 노드종류 }\nimport printer_cursor { 러스트열폭, 본문위치전진 }\nimport printer_setup { 인쇄상태만들기, 인쇄상태익명이름들바꾸기 }\nimport printer_state { 식별자이름 }\nimport printer_text { 선형원본끝공백제거, 선형원본만들기, 선형원본추가, 선형원본평평하게 }\nimport schema { 엘름댓글코드, 엘름원자본문코드 }\nimport structure { 구조노드, 구조스칼라, 구조입력, 구조입력검사, 노드스칼라, 스칼라문자, 스칼라있음 }\n\nfunction 엘름정수스칼라검사(노드: 구조노드, 필드: string) -> Result<int, string> {\n  let 값 = 노드스칼라(노드, 필드)\n  if 값.필드 == \"\" || 값.태그 != 3 || 값.정수값 < 0 {\n    return Err(\"Elm 구조 정수 스칼라가 정규형이 아닙니다: {필드}\")\n  }\n  Ok(값.정수값)\n}\n\nexport function 엘름인쇄구조검사(구조: 구조입력) -> Result<bool, string> {\n  구조입력검사(22, 구조)?\n  if 구조.노드들.length == 0 {\n    return Err(\"Elm 인쇄 구조에 file 노드가 필요합니다\")\n  }\n  if 구조.노드들[0].코드워드 != 449 ||\n    구조.노드들[0].부모순번 != -1 || 구조.노드들[0].자식필드있음 ||\n    구조.노드들[0].자식필드 != \"\" || 구조.노드들[0].자식색인 != -1 {\n    return Err(\"Elm 인쇄 구조 뿌리가 file 노드가 아닙니다\")\n  }\n  let mut 자식수들: Array<int> = []\n  let mut 순번 = 0\n  while 순번 < 구조.노드들.length { 자식수들.push(0); 순번 = 순번 + 1 }\n  let mut 분리본문발생수 = 0\n  let mut 다음식별자류번호 = 0\n  순번 = 0\n  while 순번 < 구조.노드들.length {\n    let 노드 = 구조.노드들[순번]\n    if 노드종류(22, 노드.코드워드) == 0 {\n      return Err(\"Elm 투영 인쇄기가 지원하지 않는 노드입니다: 순번 {순번}, 코드 {노드.코드워드}\")\n    }\n    if 순번 > 0 {\n      if 노드.부모순번 < 0 || 노드.부모순번 >= 순번 ||\n        !노드.자식필드있음 || 노드.자식필드 == \"\" || 노드.자식색인 < 0 {\n        return Err(\"Elm 인쇄 구조의 부모 또는 자식 위치가 정규형이 아닙니다: 순번 {순번}\")\n      }\n      자식수들[노드.부모순번] = 자식수들[노드.부모순번] + 1\n    }\n    if 노드.시작 < 0 || 노드.끝 < 노드.시작 {\n      return Err(\"Elm 인쇄 구조의 원본 범위가 틀립니다: 순번 {순번}\")\n    }\n    let 자식수 = 엘름정수스칼라검사(노드, \"childCount\")?\n    let 시작행 = 엘름정수스칼라검사(노드, \"startRow\")?\n    let 시작열 = 엘름정수스칼라검사(노드, \"startColumn\")?\n    let 끝행 = 엘름정수스칼라검사(노드, \"endRow\")?\n    let 끝열 = 엘름정수스칼라검사(노드, \"endColumn\")?\n    if 끝행 < 시작행 || (끝행 == 시작행 && 끝열 < 시작열) {\n      return Err(\"Elm 인쇄 구조의 원본 좌표가 틀립니다: 순번 {순번}\")\n    }\n    if !스칼라있음(노드, \"named\") || !스칼라있음(노드, \"extra\") {\n      return Err(\"Elm 인쇄 구조의 노드 표지 스칼라가 없습니다: 순번 {순번}\")\n    }\n    if 스칼라있음(노드, \"sourceBom\") {\n      return Err(\"Elm 구조에 허용되지 않는 원본 BOM 표지가 있습니다: 순번 {순번}\")\n    }\n    if 노드.코드워드 == 419 && 자식수 == 0 {\n      if 노드.식별자있음 {\n        if 스칼라있음(노드, \"text\") {\n          return Err(\"Elm 식별자 이름이 이미지와 분리 본문에 함께 있습니다\")\n        }\n        if 노드.식별자류번호 < 0 || 노드.식별자류번호 > 다음식별자류번호 {\n          return Err(\"Elm 식별자 알파류가 첫 사용 정규형이 아닙니다: 순번 {순번}\")\n        }\n        if 노드.식별자류번호 == 다음식별자류번호 {\n          다음식별자류번호 = 다음식별자류번호 + 1\n        }\n        분리본문발생수 = 분리본문발생수 + 1\n      } else if 노드.식별자류번호 != 0 || !스칼라있음(노드, \"text\") ||\n        노드스칼라(노드, \"text\").태그 != 5 {\n        return Err(\"Elm 이미지 식별자 이름이 정규형이 아닙니다: 순번 {순번}\")\n      }\n    } else {\n      if 노드.식별자있음 || 노드.식별자류번호 != 0 {\n        return Err(\"Elm 식별자가 아닌 노드에 알파류가 있습니다: 순번 {순번}\")\n      }\n      if 엘름댓글코드(노드.코드워드) {\n        if 자식수 != 0 || 스칼라있음(노드, \"text\") {\n          return Err(\"Elm 댓글 원문은 분리 본문에만 있어야 합니다: 순번 {순번}\")\n        }\n        분리본문발생수 = 분리본문발생수 + 1\n      } else if 엘름원자본문코드(노드.코드워드) || 자식수 == 0 {\n        if !스칼라있음(노드, \"text\") || 노드스칼라(노드, \"text\").태그 != 5 {\n          return Err(\"Elm 인쇄 토큰의 원문이 없습니다: 순번 {순번}\")\n        }\n      } else if 스칼라있음(노드, \"text\") {\n        return Err(\"Elm 가지 노드에 토큰 원문이 있습니다: 순번 {순번}\")\n      }\n    }\n    순번 = 순번 + 1\n  }\n  순번 = 0\n  while 순번 < 구조.노드들.length {\n    if 엘름정수스칼라검사(구조.노드들[순번], \"childCount\")? != 자식수들[순번] {\n      return Err(\"Elm 노드 자식 수가 구조와 다릅니다: 순번 {순번}\")\n    }\n    순번 = 순번 + 1\n  }\n  if 구조.분리본문값수 < 0 || 구조.분리본문값수 != 분리본문발생수 {\n    return Err(\"Elm 분리 본문 값 수가 식별자와 댓글 발생 수에 맞지 않습니다\")\n  }\n  Ok(true)\n}\n\nfunction 엘름잎앞섬(구조: 구조입력, 왼쪽: int, 오른쪽: int) -> bool {\n  let 왼쪽노드 = 구조.노드들[왼쪽]\n  let 오른쪽노드 = 구조.노드들[오른쪽]\n  if 왼쪽노드.시작 != 오른쪽노드.시작 {\n    return 왼쪽노드.시작 < 오른쪽노드.시작\n  }\n  if 왼쪽노드.끝 != 오른쪽노드.끝 {\n    return 왼쪽노드.끝 < 오른쪽노드.끝\n  }\n  왼쪽 < 오른쪽\n}\n\nfunction 엘름잎순번들(구조: 구조입력) -> Result<Array<int>, string> {\n  let mut 잎들: Array<int> = []\n  let mut 순번 = 0\n  while 순번 < 구조.노드들.length {\n    let 노드 = 구조.노드들[순번]\n    let mut 부모순번 = 노드.부모순번\n    let mut 원자본문조상있음 = false\n    while 부모순번 >= 0 {\n      if 엘름원자본문코드(구조.노드들[부모순번].코드워드) {\n        원자본문조상있음 = true\n        부모순번 = -1\n      } else {\n        부모순번 = 구조.노드들[부모순번].부모순번\n      }\n    }\n    if !원자본문조상있음 &&\n      (엘름원자본문코드(노드.코드워드) ||\n        엘름정수스칼라검사(노드, \"childCount\")? == 0) {\n      잎들.push(순번)\n    }\n    순번 = 순번 + 1\n  }\n  let mut 색인 = 1\n  while 색인 < 잎들.length {\n    let 값 = 잎들[색인]\n    let mut 자리 = 색인\n    while 자리 > 0 && 엘름잎앞섬(구조, 값, 잎들[자리 - 1]) {\n      잎들[자리] = 잎들[자리 - 1]\n      자리 = 자리 - 1\n    }\n    잎들[자리] = 값\n    색인 = 색인 + 1\n  }\n  Ok(잎들)\n}\n\nexport function 엘름원본인쇄(구조: 구조입력) -> Result<string, string> {\n  엘름인쇄구조검사(구조)?\n  let 기본준비 = 인쇄상태만들기(22, 구조, [], [], false, false)\n  let 준비 = 인쇄상태익명이름들바꾸기(기본준비, 익명할당계획이름들(기본준비)?)\n  let 잎들 = 엘름잎순번들(구조)?\n  let mut 다음보이는행들: Array<int> = []\n  let mut 채움 = 0\n  while 채움 < 잎들.length { 다음보이는행들.push(-1); 채움 = 채움 + 1 }\n  let mut 다음보이는행 = -1\n  let mut 역색인 = 잎들.length\n  while 역색인 > 0 {\n    역색인 = 역색인 - 1\n    다음보이는행들[역색인] = 다음보이는행\n    let 역노드 = 구조.노드들[잎들[역색인]]\n    let 역생략댓글 = 엘름댓글코드(역노드.코드워드) && !스칼라있음(역노드, \"text\")\n    if !역생략댓글 { 다음보이는행 = 엘름정수스칼라검사(역노드, \"startRow\")? }\n  }\n  let 원본 = 선형원본만들기()\n  let mut 출력행 = 0\n  let mut 출력열 = 0\n  let mut 이전끝행 = 0\n  let mut 이전끝열 = 0\n  let mut 이전끝스칼라열 = 0\n  let mut 이전있음 = false\n  let mut 토큰색인 = 0\n  while 토큰색인 < 잎들.length {\n    let 순번 = 잎들[토큰색인]\n    let 노드 = 구조.노드들[순번]\n    let 시작행 = 엘름정수스칼라검사(노드, \"startRow\")?\n    let 시작열 = 엘름정수스칼라검사(노드, \"startColumn\")?\n    let 끝행 = 엘름정수스칼라검사(노드, \"endRow\")?\n    let 끝열 = 엘름정수스칼라검사(노드, \"endColumn\")?\n    let 대체폭 = if 시작행 == 끝행 { 끝열 - 시작열 } else { 끝열 }\n    let 식별자노드 = 노드.코드워드 == 419 &&\n      엘름정수스칼라검사(노드, \"childCount\")? == 0\n    let 분리식별자 = 식별자노드 && 노드.식별자있음\n    let 생략댓글 = 엘름댓글코드(노드.코드워드) && !스칼라있음(노드, \"text\")\n    let 토큰 = if 생략댓글 { \"\" } else if 식별자노드 {\n      식별자이름(준비, 순번)?\n    } else { 스칼라문자(노드, \"text\") }\n    let 원본스칼라폭 = if 분리식별자 {\n      러스트열폭(노드, \"identifier\", \"Scalar\", 대체폭)\n    } else if 생략댓글 {\n      러스트열폭(노드, \"comment\", \"Scalar\", 대체폭)\n    } else {\n      본문위치전진(22, 0, 0, 토큰)[1]\n    }\n    let 같은원본행 = 이전있음 && 시작행 == 이전끝행\n    let 원본간격 = if 같은원본행 { 시작열 - 이전끝열 } else { 0 }\n    let 원본시작스칼라열 = if 같은원본행 {\n      if 원본간격 == 0 { 출력열 } else { 이전끝스칼라열 + 원본간격 }\n    } else { 시작열 }\n    let 원본끝스칼라열 = if 끝행 == 시작행 {\n      원본시작스칼라열 + 원본스칼라폭\n    } else { 원본스칼라폭 }\n    let 구분필요 = 이전있음 && 시작행 == 이전끝행 && 시작열 > 이전끝열\n    if 생략댓글 {\n      let 다음시작행 = 다음보이는행들[토큰색인]\n      let 온줄차지 = (!이전있음 || 시작행 > 이전끝행) &&\n        (다음시작행 < 0 || 다음시작행 > 끝행)\n      let 줄끝댓글 = 이전있음 && 시작행 == 이전끝행 &&\n        (다음시작행 < 0 || 다음시작행 > 끝행)\n      if 온줄차지 {\n        while 출력행 < 시작행 {\n          선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n        }\n        while 출력행 < 끝행 {\n          선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n        }\n      } else if 줄끝댓글 {\n        이전끝행 = 끝행\n        이전끝열 = 끝열\n        이전끝스칼라열 = 원본끝스칼라열\n        이전있음 = true\n        토큰색인 = 토큰색인 + 1\n        continue\n      } else if 끝행 > 시작행 {\n        while 출력행 < 끝행 {\n          선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n        }\n        while 출력열 < 원본끝스칼라열 {\n          선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n        }\n      } else {\n        if 출력행 < 시작행 {\n          while 출력행 < 시작행 {\n            선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n          }\n          while 출력열 < 원본시작스칼라열 {\n            선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n          }\n        } else if 출력행 == 시작행 && 출력열 < 원본시작스칼라열 {\n          while 출력열 < 원본시작스칼라열 {\n            선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n          }\n        } else if 출력행 == 시작행 && 구분필요 {\n          선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n        }\n        if 출력행 == 끝행 && 출력열 < 원본끝스칼라열 {\n          while 출력열 < 원본끝스칼라열 {\n            선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n          }\n        }\n      }\n    } else {\n      if 출력행 < 시작행 {\n        while 출력행 < 시작행 {\n          선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n        }\n        while 출력열 < 원본시작스칼라열 {\n          선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n        }\n      } else if 출력행 == 시작행 && 출력열 < 원본시작스칼라열 {\n        while 출력열 < 원본시작스칼라열 {\n          선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n        }\n      } else if 출력행 == 시작행 && 구분필요 {\n        선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n      }\n      선형원본추가(원본, 토큰)\n      let 출력위치 = 본문위치전진(22, 출력행, 출력열, 토큰)\n      출력행 = 출력위치[0]\n      출력열 = 출력위치[1]\n    }\n    이전끝행 = 끝행\n    이전끝열 = 끝열\n    이전끝스칼라열 = 원본끝스칼라열\n    이전있음 = true\n    토큰색인 = 토큰색인 + 1\n  }\n  선형원본끝공백제거(원본)\n  선형원본추가(원본, \"\\n\")\n  Ok(선형원본평평하게(원본))\n}\n",
      "sourceSha256": "c9e322bd3965fccfa6ab952b140293c309171972f51eb9349612bf40d53bf80d"
    },
    {
      "path": "topaz/src/printers/go.tpz",
      "language": "topaz",
      "bytes": 7729,
      "sha256": "d9dcf77beced486b27804ea83af9553b6d173c410b3c22800817d065c35a3137",
      "content": "// Go structure validation and canonical source printing.\n\nimport nodes { 노드종류 }\nimport print { 고닫는구분자, 고여는구분자 }\nimport printer_setup { 인쇄상태만들기 }\nimport printer_state { 식별자이름 }\nimport printer_text { 선형원본끝공백제거, 선형원본만들기, 선형원본추가, 선형원본평평하게 }\nimport structure { 구조노드, 구조스칼라, 구조입력, 구조입력검사, 노드스칼라, 스칼라문자, 스칼라있음 }\nimport util { 큰값 }\n\nfunction 고정수스칼라검사(노드: 구조노드, 필드: string) -> Result<int, string> {\n  let 값 = 노드스칼라(노드, 필드)\n  if 값.필드 == \"\" || 값.태그 != 3 || 값.정수값 < 0 {\n    return Err(\"고 구조 정수 스칼라가 정규형이 아닙니다: {필드}\")\n  }\n  Ok(값.정수값)\n}\n\nexport function 고인쇄구조검사(구조: 구조입력) -> Result<bool, string> {\n  구조입력검사(4, 구조)?\n  if 구조.노드들.length == 0 { return Err(\"고 인쇄 구조에 원본 파일 노드가 필요합니다\") }\n  if 구조.노드들[0].코드워드 != 47 ||\n    구조.노드들[0].부모순번 != -1 || 구조.노드들[0].자식필드있음 ||\n    구조.노드들[0].자식필드 != \"\" || 구조.노드들[0].자식색인 != -1 {\n    return Err(\"고 인쇄 구조 뿌리가 원본 파일 노드가 아닙니다\")\n  }\n  let mut 자식수들: Array<int> = []\n  let mut 순번 = 0\n  while 순번 < 구조.노드들.length { 자식수들.push(0); 순번 = 순번 + 1 }\n  let mut 다음식별자류번호 = 0\n  let mut 분리본문발생수 = 0\n  순번 = 0\n  while 순번 < 구조.노드들.length {\n    let 노드 = 구조.노드들[순번]\n    let 종류 = 노드종류(4, 노드.코드워드)\n    if 종류 == 0 {\n      return Err(\"고 투영 인쇄기가 지원하지 않는 노드입니다: 순번 {순번}, 코드 {노드.코드워드}\")\n    }\n    if 순번 > 0 {\n      if 노드.부모순번 < 0 || 노드.부모순번 >= 순번 ||\n        !노드.자식필드있음 || 노드.자식필드 == \"\" || 노드.자식색인 < 0 {\n        return Err(\"고 인쇄 구조의 부모 또는 자식 위치가 정규형이 아닙니다: 순번 {순번}\")\n      }\n      자식수들[노드.부모순번] = 자식수들[노드.부모순번] + 1\n    }\n    if 노드.시작 < 0 || 노드.끝 < 노드.시작 {\n      return Err(\"고 인쇄 구조의 원본 범위가 틀립니다: 순번 {순번}\")\n    }\n    let 자식수 = 고정수스칼라검사(노드, \"childCount\")?\n    let 시작행 = 고정수스칼라검사(노드, \"startRow\")?\n    let 시작열 = 고정수스칼라검사(노드, \"startColumn\")?\n    let 끝행 = 고정수스칼라검사(노드, \"endRow\")?\n    let 끝열 = 고정수스칼라검사(노드, \"endColumn\")?\n    if 끝행 < 시작행 || (끝행 == 시작행 && 끝열 < 시작열) {\n      return Err(\"고 인쇄 구조의 원본 좌표가 틀립니다: 순번 {순번}\")\n    }\n    if !스칼라있음(노드, \"named\") || !스칼라있음(노드, \"extra\") {\n      return Err(\"고 인쇄 구조의 노드 표지 스칼라가 없습니다: 순번 {순번}\")\n    }\n    if 종류 == 106 || 노드.코드워드 == 70 || 노드.코드워드 == 161 ||\n      노드.코드워드 == 363 || 노드.코드워드 == 403 {\n      if 노드.식별자있음 {\n        if 스칼라있음(노드, \"text\") {\n          return Err(\"고 식별자 이름이 이미지와 분리 본문에 함께 있습니다\")\n        }\n        if 노드.식별자류번호 < 0 || 노드.식별자류번호 > 다음식별자류번호 {\n          return Err(\"고 식별자 알파류가 첫 사용 정규형이 아닙니다: 순번 {순번}\")\n        }\n        if 노드.식별자류번호 == 다음식별자류번호 {\n          다음식별자류번호 = 다음식별자류번호 + 1\n        }\n        분리본문발생수 = 분리본문발생수 + 1\n      } else {\n        if 노드.식별자류번호 != 0 || !스칼라있음(노드, \"text\") ||\n          노드스칼라(노드, \"text\").태그 != 5 {\n          return Err(\"고 이미지 식별자 이름이 정규형이 아닙니다: 순번 {순번}\")\n        }\n      }\n    } else {\n      if 노드.식별자있음 || 노드.식별자류번호 != 0 {\n        return Err(\"고 식별자가 아닌 노드에 알파류가 있습니다: 순번 {순번}\")\n      }\n      if 노드.코드워드 == 43 {\n        if 스칼라있음(노드, \"text\") || 자식수 != 0 {\n          return Err(\"고 댓글 노드가 정규형이 아닙니다: 순번 {순번}\")\n        }\n        분리본문발생수 = 분리본문발생수 + 1\n      } else if 자식수 == 0 &&\n        (!스칼라있음(노드, \"text\") || 노드스칼라(노드, \"text\").태그 != 5) {\n        return Err(\"고 잎 노드의 원문이 없습니다: 순번 {순번}\")\n      }\n    }\n    순번 = 순번 + 1\n  }\n  순번 = 0\n  while 순번 < 구조.노드들.length {\n    if 고정수스칼라검사(구조.노드들[순번], \"childCount\")? != 자식수들[순번] {\n      return Err(\"고 노드 자식 수가 구조와 다릅니다: 순번 {순번}\")\n    }\n    순번 = 순번 + 1\n  }\n  if 구조.분리본문값수 < 0 || 구조.분리본문값수 != 분리본문발생수 {\n    return Err(\"고 분리 본문 값 수가 식별자와 댓글 발생 수에 맞지 않습니다\")\n  }\n  Ok(true)\n}\n\nexport function 고원본인쇄(구조: 구조입력) -> Result<string, string> {\n  고인쇄구조검사(구조)?\n  let 준비 = 인쇄상태만들기(4, 구조, [], [], false, false)\n  let 원본 = 선형원본만들기()\n  let mut 이전끝 = 0\n  let mut 이전끝행 = 0\n  let mut 이전있음 = false\n  let mut 줄머리 = true\n  let mut 구분자깊이 = 0\n  let mut 순번 = 0\n  while 순번 < 구조.노드들.length {\n    let 노드 = 구조.노드들[순번]\n    if 고정수스칼라검사(노드, \"childCount\")? == 0 && 노드.코드워드 != 43 {\n      let 토큰 = if 노드종류(4, 노드.코드워드) == 106 ||\n        노드.코드워드 == 70 || 노드.코드워드 == 161 ||\n        노드.코드워드 == 363 || 노드.코드워드 == 403 {\n        식별자이름(준비, 순번)?\n      } else { 스칼라문자(노드, \"text\") }\n      let 시작행 = 고정수스칼라검사(노드, \"startRow\")?\n      let 끝행 = 고정수스칼라검사(노드, \"endRow\")?\n      if !이전있음 && 시작행 > 0 {\n        let mut 줄수 = 0\n        while 줄수 < 시작행 {\n          선형원본추가(원본, \"\\n\")\n          줄수 = 줄수 + 1\n        }\n        줄머리 = true\n      } else if 이전있음 && 시작행 > 이전끝행 {\n        let mut 줄수 = 0\n        while 줄수 < 시작행 - 이전끝행 {\n          선형원본추가(원본, \"\\n\")\n          줄수 = 줄수 + 1\n        }\n        줄머리 = true\n      }\n      if 줄머리 {\n        let 들여쓰기수 = if 고닫는구분자(토큰) {\n          큰값(0, 구분자깊이 - 1)\n        } else { 구분자깊이 }\n        let mut 들여쓰기번호 = 0\n        while 들여쓰기번호 < 들여쓰기수 {\n          선형원본추가(원본, \"\\t\")\n          들여쓰기번호 = 들여쓰기번호 + 1\n        }\n      } else if 이전있음 && 시작행 == 이전끝행 && 노드.시작 > 이전끝 {\n        선형원본추가(원본, \" \")\n      }\n      선형원본추가(원본, 토큰)\n      if 고여는구분자(토큰) { 구분자깊이 = 구분자깊이 + 1 }\n      if 고닫는구분자(토큰) { 구분자깊이 = 큰값(0, 구분자깊이 - 1) }\n      줄머리 = false\n      이전끝 = 노드.끝\n      이전끝행 = 끝행\n      이전있음 = true\n    }\n    순번 = 순번 + 1\n  }\n  선형원본끝공백제거(원본)\n  선형원본추가(원본, \"\\n\")\n  Ok(선형원본평평하게(원본))\n}\n",
      "sourceSha256": "d9dcf77beced486b27804ea83af9553b6d173c410b3c22800817d065c35a3137"
    },
    {
      "path": "topaz/src/printers/haskell.tpz",
      "language": "topaz",
      "bytes": 13810,
      "sha256": "45808474330f58b55043423720d72cb47cff1f2357b30f2e7d050802f2a6dde5",
      "content": "// Haskell structure validation and canonical source printing.\n\nimport names { 익명할당계획이름들 }\nimport nodes { 노드종류 }\nimport printer_cursor { 러스트열폭, 러스트행들여쓰기, 본문위치전진 }\nimport printer_setup { 인쇄상태만들기, 인쇄상태익명이름들바꾸기 }\nimport printer_state { 식별자이름 }\nimport printer_text { 선형원본끝공백제거, 선형원본만들기, 선형원본추가, 선형원본평평하게 }\nimport schema { 하스켈댓글코드, 하스켈원자본문코드 }\nimport structure { 구조노드, 구조스칼라, 구조입력, 구조입력검사, 노드스칼라, 스칼라문자, 스칼라있음 }\n\nfunction 하스켈정수스칼라검사(노드: 구조노드, 필드: string) -> Result<int, string> {\n  let 값 = 노드스칼라(노드, 필드)\n  if 값.필드 == \"\" || 값.태그 != 3 || 값.정수값 < 0 {\n    return Err(\"Haskell 구조 정수 스칼라가 정규형이 아닙니다: {필드}\")\n  }\n  Ok(값.정수값)\n}\n\nexport function 하스켈인쇄구조검사(구조: 구조입력) -> Result<bool, string> {\n  구조입력검사(17, 구조)?\n  if 구조.노드들.length == 0 {\n    return Err(\"Haskell 인쇄 구조에 haskell 노드가 필요합니다\")\n  }\n  if 구조.노드들[0].코드워드 != 447 ||\n    구조.노드들[0].부모순번 != -1 || 구조.노드들[0].자식필드있음 ||\n    구조.노드들[0].자식필드 != \"\" || 구조.노드들[0].자식색인 != -1 {\n    return Err(\"Haskell 인쇄 구조 뿌리가 haskell 노드가 아닙니다\")\n  }\n  let mut 자식수들: Array<int> = []\n  let mut 순번 = 0\n  while 순번 < 구조.노드들.length { 자식수들.push(0); 순번 = 순번 + 1 }\n  let mut 분리본문발생수 = 0\n  let mut 다음식별자류번호 = 0\n  순번 = 0\n  while 순번 < 구조.노드들.length {\n    let 노드 = 구조.노드들[순번]\n    if 노드종류(17, 노드.코드워드) == 0 {\n      return Err(\"Haskell 투영 인쇄기가 지원하지 않는 노드입니다: 순번 {순번}, 코드 {노드.코드워드}\")\n    }\n    if 순번 > 0 {\n      if 노드.부모순번 < 0 || 노드.부모순번 >= 순번 ||\n        !노드.자식필드있음 || 노드.자식필드 == \"\" || 노드.자식색인 < 0 {\n        return Err(\"Haskell 인쇄 구조의 부모 또는 자식 위치가 정규형이 아닙니다: 순번 {순번}\")\n      }\n      자식수들[노드.부모순번] = 자식수들[노드.부모순번] + 1\n    }\n    if 노드.시작 < 0 || 노드.끝 < 노드.시작 {\n      return Err(\"Haskell 인쇄 구조의 원본 범위가 틀립니다: 순번 {순번}\")\n    }\n    let 자식수 = 하스켈정수스칼라검사(노드, \"childCount\")?\n    let 시작행 = 하스켈정수스칼라검사(노드, \"startRow\")?\n    let 시작열 = 하스켈정수스칼라검사(노드, \"startColumn\")?\n    let 끝행 = 하스켈정수스칼라검사(노드, \"endRow\")?\n    let 끝열 = 하스켈정수스칼라검사(노드, \"endColumn\")?\n    if 끝행 < 시작행 || (끝행 == 시작행 && 끝열 < 시작열) {\n      return Err(\"Haskell 인쇄 구조의 원본 좌표가 틀립니다: 순번 {순번}\")\n    }\n    if !스칼라있음(노드, \"named\") || !스칼라있음(노드, \"extra\") {\n      return Err(\"Haskell 인쇄 구조의 노드 표지 스칼라가 없습니다: 순번 {순번}\")\n    }\n    if 스칼라있음(노드, \"sourceBom\") {\n      return Err(\"Haskell 구조에 허용되지 않는 원본 BOM 표지가 있습니다: 순번 {순번}\")\n    }\n    if 노드.코드워드 == 139 && 자식수 == 0 {\n      if 노드.식별자있음 {\n        if 스칼라있음(노드, \"text\") {\n          return Err(\"Haskell 식별자 이름이 이미지와 분리 본문에 함께 있습니다\")\n        }\n        if 노드.식별자류번호 < 0 || 노드.식별자류번호 > 다음식별자류번호 {\n          return Err(\"Haskell 식별자 알파류가 첫 사용 정규형이 아닙니다: 순번 {순번}\")\n        }\n        if 노드.식별자류번호 == 다음식별자류번호 {\n          다음식별자류번호 = 다음식별자류번호 + 1\n        }\n        분리본문발생수 = 분리본문발생수 + 1\n      } else if 노드.식별자류번호 != 0 || !스칼라있음(노드, \"text\") ||\n        노드스칼라(노드, \"text\").태그 != 5 {\n        return Err(\"Haskell 이미지 식별자 이름이 정규형이 아닙니다: 순번 {순번}\")\n      }\n    } else {\n      if 노드.식별자있음 || 노드.식별자류번호 != 0 {\n        return Err(\"Haskell 식별자가 아닌 노드에 알파류가 있습니다: 순번 {순번}\")\n      }\n      if 하스켈댓글코드(노드.코드워드) {\n        if 자식수 != 0 || 스칼라있음(노드, \"text\") {\n          return Err(\"Haskell 댓글 원문은 분리 본문에만 있어야 합니다: 순번 {순번}\")\n        }\n        분리본문발생수 = 분리본문발생수 + 1\n      } else if 자식수 == 0 {\n        if !스칼라있음(노드, \"text\") || 노드스칼라(노드, \"text\").태그 != 5 {\n          return Err(\"Haskell 인쇄 토큰의 원문이 없습니다: 순번 {순번}\")\n        }\n      } else if 스칼라있음(노드, \"text\") {\n        return Err(\"Haskell 가지 노드에 토큰 원문이 있습니다: 순번 {순번}\")\n      }\n    }\n    순번 = 순번 + 1\n  }\n  순번 = 0\n  while 순번 < 구조.노드들.length {\n    if 하스켈정수스칼라검사(구조.노드들[순번], \"childCount\")? != 자식수들[순번] {\n      return Err(\"Haskell 노드 자식 수가 구조와 다릅니다: 순번 {순번}\")\n    }\n    순번 = 순번 + 1\n  }\n  if 구조.분리본문값수 < 0 || 구조.분리본문값수 != 분리본문발생수 {\n    return Err(\"Haskell 분리 본문 값 수가 식별자와 댓글 발생 수에 맞지 않습니다\")\n  }\n  Ok(true)\n}\n\nfunction 하스켈잎앞섬(구조: 구조입력, 왼쪽: int, 오른쪽: int) -> bool {\n  let 왼쪽노드 = 구조.노드들[왼쪽]\n  let 오른쪽노드 = 구조.노드들[오른쪽]\n  if 왼쪽노드.시작 != 오른쪽노드.시작 {\n    return 왼쪽노드.시작 < 오른쪽노드.시작\n  }\n  if 왼쪽노드.끝 != 오른쪽노드.끝 {\n    return 왼쪽노드.끝 < 오른쪽노드.끝\n  }\n  왼쪽 < 오른쪽\n}\n\nfunction 하스켈잎순번들(구조: 구조입력) -> Result<Array<int>, string> {\n  let mut 잎들: Array<int> = []\n  let mut 순번 = 0\n  while 순번 < 구조.노드들.length {\n    let 노드 = 구조.노드들[순번]\n    let mut 부모순번 = 노드.부모순번\n    let mut 원자본문조상있음 = false\n    while 부모순번 >= 0 {\n      if 하스켈원자본문코드(구조.노드들[부모순번].코드워드) {\n        원자본문조상있음 = true\n        부모순번 = -1\n      } else {\n        부모순번 = 구조.노드들[부모순번].부모순번\n      }\n    }\n    if !원자본문조상있음 &&\n      (하스켈원자본문코드(노드.코드워드) ||\n        하스켈정수스칼라검사(노드, \"childCount\")? == 0) {\n      잎들.push(순번)\n    }\n    순번 = 순번 + 1\n  }\n  let mut 색인 = 1\n  while 색인 < 잎들.length {\n    let 값 = 잎들[색인]\n    let mut 자리 = 색인\n    while 자리 > 0 && 하스켈잎앞섬(구조, 값, 잎들[자리 - 1]) {\n      잎들[자리] = 잎들[자리 - 1]\n      자리 = 자리 - 1\n    }\n    잎들[자리] = 값\n    색인 = 색인 + 1\n  }\n  Ok(잎들)\n}\n\nexport function 하스켈원본인쇄(구조: 구조입력) -> Result<string, string> {\n  하스켈인쇄구조검사(구조)?\n  let 기본준비 = 인쇄상태만들기(17, 구조, [], [], false, false)\n  let 준비 = 인쇄상태익명이름들바꾸기(기본준비, 익명할당계획이름들(기본준비)?)\n  let 잎들 = 하스켈잎순번들(구조)?\n  let mut 다음보이는행들: Array<int> = []\n  for 순번 in 잎들 { 다음보이는행들.push(-1) }\n  let mut 다음보이는행 = -1\n  let mut 역색인 = 잎들.length - 1\n  while 역색인 >= 0 {\n    다음보이는행들[역색인] = 다음보이는행\n    let 역노드 = 구조.노드들[잎들[역색인]]\n    if !하스켈댓글코드(역노드.코드워드) || 스칼라있음(역노드, \"text\") {\n      다음보이는행 = 하스켈정수스칼라검사(역노드, \"startRow\")?\n    }\n    역색인 = 역색인 - 1\n  }\n  let 원본 = 선형원본만들기()\n  let mut 출력행 = 0\n  let mut 출력열 = 0\n  let mut 이전끝행 = 0\n  let mut 이전끝열 = 0\n  let mut 이전끝스칼라열 = 0\n  let mut 이전있음 = false\n  let mut 좁은접미사열빚 = false\n  let mut 토큰색인 = 0\n  while 토큰색인 < 잎들.length {\n    let 순번 = 잎들[토큰색인]\n    let 노드 = 구조.노드들[순번]\n    let 시작행 = 하스켈정수스칼라검사(노드, \"startRow\")?\n    let 시작열 = 하스켈정수스칼라검사(노드, \"startColumn\")?\n    let 끝행 = 하스켈정수스칼라검사(노드, \"endRow\")?\n    let 끝열 = 하스켈정수스칼라검사(노드, \"endColumn\")?\n    let 대체폭 = if 시작행 == 끝행 { 끝열 - 시작열 } else { 끝열 }\n    let 식별자노드 = 노드.코드워드 == 139 && 하스켈정수스칼라검사(노드, \"childCount\")? == 0\n    let 분리식별자 = 식별자노드 && 노드.식별자있음\n    let 생략댓글 = 하스켈댓글코드(노드.코드워드) && !스칼라있음(노드, \"text\")\n    let 토큰 = if 생략댓글 { \"\" } else if 식별자노드 {\n      식별자이름(준비, 순번)?\n    } else { 스칼라문자(노드, \"text\") }\n    let 원본스칼라폭 = if 분리식별자 {\n      러스트열폭(노드, \"identifier\", \"Scalar\", 대체폭)\n    } else if 생략댓글 {\n      러스트열폭(노드, \"comment\", \"Display\", 대체폭)\n    } else {\n      본문위치전진(17, 0, 0, 토큰)[1]\n    }\n    let 같은원본행 = 이전있음 && 시작행 == 이전끝행\n    let 원본간격 = if 같은원본행 { 시작열 - 이전끝열 } else { 0 }\n    let 부모코드워드 = if 노드.부모순번 >= 0 {\n      구조.노드들[노드.부모순번].코드워드\n    } else { -1 }\n    let 좁은접미사 = (노드.코드워드 == 43 && 부모코드워드 == 410) ||\n      (노드.코드워드 == 390 && 부모코드워드 == 345)\n    if !같은원본행 || 원본간격 != 0 { 좁은접미사열빚 = false }\n    if 좁은접미사 { 좁은접미사열빚 = true }\n    let 원본시작스칼라열 = if 같은원본행 {\n      이전끝스칼라열 + 원본간격\n    } else { 시작열 }\n    let 출력시작스칼라열 = if 좁은접미사열빚 { 출력열 } else { 원본시작스칼라열 }\n    let 원본끝스칼라열 = if 끝행 == 시작행 {\n      원본시작스칼라열 + 원본스칼라폭\n    } else { 원본스칼라폭 }\n    let 구분필요 = 이전있음 && 시작행 == 이전끝행 && 시작열 > 이전끝열\n    if 생략댓글 {\n      let 다음시작행 = 다음보이는행들[토큰색인]\n      let 뒤토큰열지킴 = 다음시작행 >= 0 && 다음시작행 == 끝행\n      if !뒤토큰열지킴 {\n        while 출력행 < 시작행 {\n          선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n        }\n        while 출력행 < 끝행 {\n          선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n        }\n        이전끝행 = 끝행\n        이전끝열 = 끝열\n        이전끝스칼라열 = 원본끝스칼라열\n        이전있음 = true\n        토큰색인 = 토큰색인 + 1\n        continue\n      }\n      if 끝행 > 시작행 {\n        if 출력행 < 시작행 {\n          while 출력행 < 시작행 {\n            선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n          }\n        }\n        while 출력행 < 끝행 {\n          선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n        }\n        while 출력열 < 원본끝스칼라열 {\n          선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n        }\n      } else {\n        if 출력행 < 시작행 {\n          while 출력행 < 시작행 {\n            선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n          }\n          let 행들여쓰기 = 러스트행들여쓰기(노드, 출력시작스칼라열)\n          선형원본추가(원본, 행들여쓰기)\n          출력열 = 행들여쓰기.scalars().length\n        }\n        while 출력행 == 시작행 && 출력열 < 원본끝스칼라열 {\n          선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n        }\n      }\n    } else {\n      if 출력행 < 시작행 {\n        while 출력행 < 시작행 {\n          선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n        }\n        let 행들여쓰기 = 러스트행들여쓰기(노드, 출력시작스칼라열)\n        선형원본추가(원본, 행들여쓰기)\n        출력열 = 행들여쓰기.scalars().length\n        while 출력열 < 출력시작스칼라열 {\n          선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n        }\n      } else if 출력행 == 시작행 && 출력열 < 출력시작스칼라열 {\n        while 출력열 < 출력시작스칼라열 {\n          선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n        }\n      } else if 출력행 == 시작행 && 구분필요 {\n        선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n      }\n      선형원본추가(원본, 토큰)\n      let 출력위치 = 본문위치전진(17, 출력행, 출력열, 토큰)\n      출력행 = 출력위치[0]\n      출력열 = 출력위치[1]\n    }\n    이전끝행 = 끝행\n    이전끝열 = 끝열\n    이전끝스칼라열 = 원본끝스칼라열\n    이전있음 = true\n    토큰색인 = 토큰색인 + 1\n  }\n  선형원본끝공백제거(원본)\n  선형원본추가(원본, \"\\n\")\n  Ok(선형원본평평하게(원본))\n}\n",
      "sourceSha256": "45808474330f58b55043423720d72cb47cff1f2357b30f2e7d050802f2a6dde5"
    },
    {
      "path": "topaz/src/printers/java.tpz",
      "language": "topaz",
      "bytes": 11520,
      "sha256": "799584480c91ed3d47847b305cf5c276022192204f22a6ff5ab7a4bcf42929d1",
      "content": "// Java structure validation and canonical source printing.\n\nimport nodes { 노드종류 }\nimport print { 글자합치기 }\nimport printer_cursor { 러스트열폭, 본문위치전진 }\nimport printer_setup { 인쇄상태만들기 }\nimport printer_state { 식별자이름 }\nimport printer_text { 선형원본길이, 선형원본만들기, 선형원본추가, 선형원본평평하게 }\nimport schema { 자바댓글코드, 자바원자본문코드 }\nimport structure { 구조노드, 구조스칼라, 구조입력, 구조입력검사, 노드스칼라, 스칼라문자, 스칼라있음 }\n\nfunction 자바정수스칼라검사(노드: 구조노드, 필드: string) -> Result<int, string> {\n  let 값 = 노드스칼라(노드, 필드)\n  if 값.필드 == \"\" || 값.태그 != 3 || 값.정수값 < 0 {\n    return Err(\"자바 구조 정수 스칼라가 정규형이 아닙니다: {필드}\")\n  }\n  Ok(값.정수값)\n}\n\nexport function 자바인쇄구조검사(구조: 구조입력) -> Result<bool, string> {\n  구조입력검사(6, 구조)?\n  if 구조.노드들.length == 0 {\n    return Err(\"자바 인쇄 구조에 프로그램 노드가 필요합니다\")\n  }\n  if 구조.노드들[0].코드워드 != 357 ||\n    구조.노드들[0].부모순번 != -1 || 구조.노드들[0].자식필드있음 ||\n    구조.노드들[0].자식필드 != \"\" || 구조.노드들[0].자식색인 != -1 {\n    return Err(\"자바 인쇄 구조 뿌리가 프로그램 노드가 아닙니다\")\n  }\n  let mut 자식수들: Array<int> = []\n  let mut 순번 = 0\n  while 순번 < 구조.노드들.length { 자식수들.push(0); 순번 = 순번 + 1 }\n  let mut 다음식별자류번호 = 0\n  let mut 분리본문발생수 = 0\n  순번 = 0\n  while 순번 < 구조.노드들.length {\n    let 노드 = 구조.노드들[순번]\n    let 종류 = 노드종류(6, 노드.코드워드)\n    if 종류 == 0 {\n      return Err(\"자바 투영 인쇄기가 지원하지 않는 노드입니다: 순번 {순번}, 코드 {노드.코드워드}\")\n    }\n    if 순번 > 0 {\n      if 노드.부모순번 < 0 || 노드.부모순번 >= 순번 ||\n        !노드.자식필드있음 || 노드.자식필드 == \"\" || 노드.자식색인 < 0 {\n        return Err(\"자바 인쇄 구조의 부모 또는 자식 위치가 정규형이 아닙니다: 순번 {순번}\")\n      }\n      자식수들[노드.부모순번] = 자식수들[노드.부모순번] + 1\n    }\n    if 노드.시작 < 0 || 노드.끝 < 노드.시작 {\n      return Err(\"자바 인쇄 구조의 원본 범위가 틀립니다: 순번 {순번}\")\n    }\n    let 자식수 = 자바정수스칼라검사(노드, \"childCount\")?\n    let 시작행 = 자바정수스칼라검사(노드, \"startRow\")?\n    let 시작열 = 자바정수스칼라검사(노드, \"startColumn\")?\n    let 끝행 = 자바정수스칼라검사(노드, \"endRow\")?\n    let 끝열 = 자바정수스칼라검사(노드, \"endColumn\")?\n    if 끝행 < 시작행 || (끝행 == 시작행 && 끝열 < 시작열) {\n      return Err(\"자바 인쇄 구조의 원본 좌표가 틀립니다: 순번 {순번}\")\n    }\n    if !스칼라있음(노드, \"named\") || !스칼라있음(노드, \"extra\") {\n      return Err(\"자바 인쇄 구조의 노드 표지 스칼라가 없습니다: 순번 {순번}\")\n    }\n    if 종류 == 106 {\n      if 노드.식별자있음 {\n        if 스칼라있음(노드, \"text\") {\n          return Err(\"자바 식별자 이름이 이미지와 분리 본문에 함께 있습니다\")\n        }\n        if 노드.식별자류번호 < 0 || 노드.식별자류번호 > 다음식별자류번호 {\n          return Err(\"자바 식별자 알파류가 첫 사용 정규형이 아닙니다: 순번 {순번}\")\n        }\n        if 노드.식별자류번호 == 다음식별자류번호 {\n          다음식별자류번호 = 다음식별자류번호 + 1\n        }\n        분리본문발생수 = 분리본문발생수 + 1\n      } else {\n        if 노드.식별자류번호 != 0 || !스칼라있음(노드, \"text\") ||\n          노드스칼라(노드, \"text\").태그 != 5 {\n          return Err(\"자바 이미지 식별자 이름이 정규형이 아닙니다: 순번 {순번}\")\n        }\n      }\n    } else {\n      if 노드.식별자있음 || 노드.식별자류번호 != 0 {\n        return Err(\"자바 식별자가 아닌 노드에 알파류가 있습니다: 순번 {순번}\")\n      }\n      if 자바댓글코드(노드.코드워드) {\n        if 스칼라있음(노드, \"text\") {\n          if 노드스칼라(노드, \"text\").태그 != 5 {\n            return Err(\"자바 댓글 원문이 정규형이 아닙니다: 순번 {순번}\")\n          }\n        } else {\n          분리본문발생수 = 분리본문발생수 + 1\n        }\n      } else if 자바원자본문코드(노드.코드워드) || 자식수 == 0 {\n        if !스칼라있음(노드, \"text\") || 노드스칼라(노드, \"text\").태그 != 5 {\n          return Err(\"자바 인쇄 토큰의 원문이 없습니다: 순번 {순번}\")\n        }\n      }\n    }\n    순번 = 순번 + 1\n  }\n  순번 = 0\n  while 순번 < 구조.노드들.length {\n    if 자바정수스칼라검사(구조.노드들[순번], \"childCount\")? != 자식수들[순번] {\n      return Err(\"자바 노드 자식 수가 구조와 다릅니다: 순번 {순번}\")\n    }\n    순번 = 순번 + 1\n  }\n  if 구조.분리본문값수 < 0 || 구조.분리본문값수 != 분리본문발생수 {\n    return Err(\"자바 분리 본문 값 수가 식별자와 댓글 발생 수에 맞지 않습니다\")\n  }\n  Ok(true)\n}\n\nfunction 자바원자본문조상(구조: 구조입력, 순번: int) -> bool {\n  let mut 부모순번 = 구조.노드들[순번].부모순번\n  while 부모순번 >= 0 {\n    if 자바원자본문코드(구조.노드들[부모순번].코드워드) { return true }\n    부모순번 = 구조.노드들[부모순번].부모순번\n  }\n  false\n}\n\nexport function 자바원본인쇄(구조: 구조입력) -> Result<string, string> {\n  자바인쇄구조검사(구조)?\n  let 준비 = 인쇄상태만들기(6, 구조, [], [], false, false)\n  let mut 토큰순번들: Array<int> = []\n  let mut 순번 = 0\n  while 순번 < 구조.노드들.length {\n    let 노드 = 구조.노드들[순번]\n    let 자식수 = 자바정수스칼라검사(노드, \"childCount\")?\n    if !자바원자본문조상(구조, 순번) &&\n      (자바원자본문코드(노드.코드워드) || 자식수 == 0) {\n      토큰순번들.push(순번)\n    }\n    순번 = 순번 + 1\n  }\n  let 원본 = 선형원본만들기()\n  let mut 출력행 = 0\n  let mut 출력열 = 0\n  let mut 이전끝행 = 0\n  let mut 이전끝열 = 0\n  let mut 이전끝스칼라열 = 0\n  let mut 이전있음 = false\n  let mut 마지막토큰스칼라길이 = 0\n  let mut 토큰색인 = 0\n  while 토큰색인 < 토큰순번들.length {\n    순번 = 토큰순번들[토큰색인]\n    let 노드 = 구조.노드들[순번]\n    let 시작행 = 자바정수스칼라검사(노드, \"startRow\")?\n    let 시작열 = 자바정수스칼라검사(노드, \"startColumn\")?\n    let 끝행 = 자바정수스칼라검사(노드, \"endRow\")?\n    let 끝열 = 자바정수스칼라검사(노드, \"endColumn\")?\n    let 대체폭 = if 시작행 == 끝행 { 끝열 - 시작열 } else { 끝열 }\n    let 분리식별자 = 노드종류(6, 노드.코드워드) == 106 && 노드.식별자있음\n    let 생략댓글 = 자바댓글코드(노드.코드워드) && !스칼라있음(노드, \"text\")\n    let 토큰 = if 생략댓글 { \"\" } else if 노드종류(6, 노드.코드워드) == 106 {\n      식별자이름(준비, 순번)?\n    } else { 스칼라문자(노드, \"text\") }\n    let 원본스칼라폭 = if 분리식별자 {\n      러스트열폭(노드, \"identifier\", \"Scalar\", 대체폭)\n    } else if 생략댓글 {\n      러스트열폭(노드, \"comment\", \"Scalar\", 대체폭)\n    } else {\n      본문위치전진(6, 0, 0, 토큰)[1]\n    }\n    let 원본시작스칼라열 = if 이전있음 && 시작행 == 이전끝행 {\n      이전끝스칼라열 + 시작열 - 이전끝열\n    } else { 시작열 }\n    let 원본끝스칼라열 = if 끝행 == 시작행 {\n      원본시작스칼라열 + 원본스칼라폭\n    } else { 원본스칼라폭 }\n    let 구분필요 = 이전있음 && 시작행 == 이전끝행 && 시작열 > 이전끝열\n    if 생략댓글 {\n      let 다음시작행 = if 토큰색인 + 1 < 토큰순번들.length {\n        자바정수스칼라검사(\n          구조.노드들[토큰순번들[토큰색인 + 1]], \"startRow\"\n        )?\n      } else { -1 }\n      if 다음시작행 != 끝행 {\n        while 출력행 < 시작행 {\n          선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n        }\n        while 출력행 < 끝행 {\n          선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n        }\n      } else if 끝행 > 시작행 {\n        while 출력행 < 끝행 {\n          선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n        }\n        while 출력열 < 원본끝스칼라열 {\n          선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n        }\n      } else {\n        if 출력행 < 시작행 {\n          while 출력행 < 시작행 {\n            선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n          }\n          while 출력열 < 원본시작스칼라열 {\n            선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n          }\n        } else if 출력행 == 시작행 && 출력열 < 원본시작스칼라열 {\n          while 출력열 < 원본시작스칼라열 {\n            선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n          }\n        } else if 출력행 == 시작행 && 구분필요 {\n          선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n        }\n        if 출력행 < 끝행 {\n          while 출력행 < 끝행 {\n            선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n          }\n          while 출력열 < 원본끝스칼라열 {\n            선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n          }\n        } else if 출력행 == 끝행 && 출력열 < 원본끝스칼라열 {\n          while 출력열 < 원본끝스칼라열 {\n            선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n          }\n        }\n      }\n    } else {\n      if 출력행 < 시작행 {\n        while 출력행 < 시작행 {\n          선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n        }\n        while 출력열 < 원본시작스칼라열 {\n          선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n        }\n      } else if 출력행 == 시작행 && 출력열 < 원본시작스칼라열 {\n        while 출력열 < 원본시작스칼라열 {\n          선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n        }\n      } else if 출력행 == 시작행 && 구분필요 {\n        선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n      }\n      선형원본추가(원본, 토큰)\n      let 출력위치 = 본문위치전진(6, 출력행, 출력열, 토큰)\n      출력행 = 출력위치[0]\n      출력열 = 출력위치[1]\n      if 토큰 != \"\" { 마지막토큰스칼라길이 = 선형원본길이(원본) }\n    }\n    이전끝행 = 끝행\n    이전끝열 = 끝열\n    이전끝스칼라열 = 원본끝스칼라열\n    이전있음 = true\n    토큰색인 = 토큰색인 + 1\n  }\n  Ok(글자합치기(선형원본평평하게(원본).scalars(), 0, 마지막토큰스칼라길이) + \"\\n\")\n}\n",
      "sourceSha256": "799584480c91ed3d47847b305cf5c276022192204f22a6ff5ab7a4bcf42929d1"
    },
    {
      "path": "topaz/src/printers/javascript.tpz",
      "language": "topaz",
      "bytes": 118825,
      "sha256": "887fab33ce619d402403f3eb50e666a165a5a42e1ddec997428415f18eef2907",
      "content": "// JavaScript and TypeScript printing machine: the node printers and the iterative\n// driver that computes each child piece they request.\n\nimport nodes { 노드종류 }\nimport print { 글자합치기, 인쇄글조각, 인쇄조각같음, 인쇄조각이음, 인쇄조각자름, 인쇄조각접미, 인쇄호출 }\nimport printer_state { 댓글고정있음, 식별자이름, 인쇄글조각결과, 인쇄조각결과합치기, 자식순번, 자식순번들, 준비된인쇄상태 }\nimport printers.javascript.comments { 댓글붙이기조각 }\nimport printers.javascript.layout {\n  가장자리접두,\n  노드들여쓰기,\n  리터럴닫기접두,\n  리터럴사이접두,\n  리터럴열,\n  리터럴첫줄수,\n  매개기준끝행,\n  매개뒤형식접두,\n  명세닫기공백,\n  모듈출처접두,\n  문장부족행,\n  문장접두,\n  블록닫기접두,\n  유효시작행,\n  절접두,\n  조각끝행,\n  줄접두,\n  직접앞끝행,\n  함수몸접두,\n  호출대상끝행,\n  화살표괄호생략인가,\n  화살표머리첫잎이매개인가,\n}\nimport printers.javascript.literals { 철자문자열리터럴 }\nimport printers.javascript.precedence { 우선순위, 인괄호필요, 인머리끄기, 인머리내림, 인머리켜기 }\nimport printers.javascript.store { 인쇄글결과조각, 인쇄기계저장쓰기, 인쇄기계저장조각읽기 }\nimport schema { 들여쓰기 }\nimport structure { 구조노드, 구조스칼라, 구조입력, 노드스칼라, 스칼라논리, 스칼라문자, 스칼라있음, 스칼라정수 }\nimport types { 인쇄조각판 }\n\nfunction 들사이조각인쇄(준비: 준비된인쇄상태, 순번들: Array<int>, 깊이: int, 사이: string) -> Result<int, string> {\n  let mut 합 = 0; let mut 색인 = 0\n  while 색인 < 순번들.length {\n    if 색인 > 0 { 합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, 사이)) }\n    합 = 인쇄조각이음(준비.조각판, 합, 순번인쇄조각(준비, 순번들[색인], 깊이)?)\n    색인 = 색인 + 1\n  }\n  Ok(합)\n}\n\n// A named import/export clause prints `{`, its specifier list, then `}` as a\n// plain token, so the brace stays on the last specifier's row; the space before\n// it is suppressed exactly when the last specifier carries the clause's\n// trailing comma, because the reference printer drops the queued space that\n// follows a structural trailing comma. The list's own rows and columns come\n// from the one edge primitive, like every other edge.\nfunction 명세들조각인쇄(\n  준비: 준비된인쇄상태,\n  순번들: Array<int>,\n  깊이: int\n) -> Result<int, string> {\n  let mut 합 = 0\n  let mut 색인 = 0\n  while 색인 < 순번들.length {\n    if 색인 > 0 {\n      합 = 인쇄조각이음(\n        준비.조각판,\n        합,\n        인쇄글조각(준비.조각판, \",\" + 가장자리접두(준비, 순번들[색인], \" \"))\n      )\n    }\n    합 = 인쇄조각이음(준비.조각판, 합, 순번인쇄조각(준비, 순번들[색인], 깊이)?)\n    색인 = 색인 + 1\n  }\n  Ok(합)\n}\n\nfunction 형식목록조각인쇄(\n  준비: 준비된인쇄상태,\n  부모순번: int,\n  순번들: Array<int>,\n  깊이: int\n) -> Result<int, string> {\n  if !준비.오프셋배치 || 순번들.length == 0 {\n    return 들사이조각인쇄(준비, 순번들, 깊이, \", \")\n  }\n  let 부모 = 준비.구조.노드들[부모순번]\n  let mut 합 = 0\n  let mut 색인 = 0\n  while 색인 < 순번들.length {\n    let 현재 = 준비.구조.노드들[순번들[색인]]\n    if 색인 == 0 {\n      let 줄수 = 스칼라정수(현재, \"startRow\") - 스칼라정수(부모, \"startRow\")\n      if 줄수 > 0 {\n        합 = 인쇄조각이음(\n          준비.조각판, 합,\n          인쇄글조각(준비.조각판, 줄접두(줄수, 노드들여쓰기(준비, 순번들[색인])))\n        )\n      }\n    } else {\n      let 이전 = 준비.구조.노드들[순번들[색인 - 1]]\n      let 줄수 = 스칼라정수(현재, \"startRow\") - 스칼라정수(이전, \"endRow\")\n      let 사이 = if 줄수 > 0 {\n        \",\" + 줄접두(줄수, 노드들여쓰기(준비, 순번들[색인]))\n      } else { \", \" }\n      합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, 사이))\n    }\n    합 = 인쇄조각이음(\n      준비.조각판, 합, 순번인쇄조각(준비, 순번들[색인], 깊이)?\n    )\n    색인 = 색인 + 1\n  }\n  Ok(합)\n}\n\nfunction 매개들조각인쇄(\n  준비: 준비된인쇄상태,\n  부모순번: int,\n  순번들: Array<int>,\n  깊이: int\n) -> Result<int, string> {\n  if !준비.오프셋배치 || 순번들.length == 0 {\n    return 들사이조각인쇄(준비, 순번들, 깊이, \", \")\n  }\n  let 들여쓰기값 = 노드들여쓰기(준비, 부모순번)\n  let 기준끝행 = 매개기준끝행(준비, 부모순번)\n  let mut 합 = 0\n  let mut 색인 = 0\n  while 색인 < 순번들.length {\n    let 현재 = 준비.구조.노드들[순번들[색인]]\n    if 색인 == 0 {\n      let 줄수 = 스칼라정수(현재, \"startRow\") - 기준끝행\n      if 줄수 > 0 {\n        합 = 인쇄조각이음(\n          준비.조각판,\n          합,\n          인쇄글조각(준비.조각판, 줄접두(줄수, 들여쓰기값))\n        )\n      }\n    } else {\n      let 이전 = 준비.구조.노드들[순번들[색인 - 1]]\n      let 줄수 = 스칼라정수(현재, \"startRow\") - 스칼라정수(이전, \"endRow\")\n      let 사이 = if 줄수 > 0 { \",\" + 줄접두(줄수, 들여쓰기값) } else { \", \" }\n      합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, 사이))\n    }\n    합 = 인쇄조각이음(\n      준비.조각판,\n      합,\n      순번인쇄조각(준비, 순번들[색인], 깊이)?\n    )\n    색인 = 색인 + 1\n  }\n  Ok(합)\n}\n\nfunction 순번인쇄조각계산(준비: 준비된인쇄상태, 순번: int, 깊이: int) -> Result<int, string> {\n  let mut 장식들 = 자식순번들(준비, 순번, \"decorators\")\n  let 종류 = 노드종류(준비.언어번호, 준비.구조.노드들[순번].코드워드)\n  let mut 장식소유자 = 순번\n  if 장식들.length == 0 && 종류 == 306 {\n    let 왼 = 자식순번(준비, 순번, \"left\")\n    if 왼 >= 0 {\n      장식들 = 자식순번들(준비, 왼, \"decorators\")\n      장식소유자 = 왼\n    }\n  }\n  let mut 합 = 0\n  let mut 장식색인 = 0\n  while 장식색인 < 장식들.length {\n    let 장식 = 장식들[장식색인]\n    match 순번인쇄조각(준비, 장식, 깊이) {\n      case Ok(조각) => {\n        합 = 인쇄조각이음(준비.조각판, 합, 조각)\n        let mut 다음행 = 스칼라정수(준비.구조.노드들[순번], \"startRow\")\n        if 장식색인 + 1 < 장식들.length {\n          다음행 = 스칼라정수(준비.구조.노드들[장식들[장식색인 + 1]], \"startRow\")\n        } else if 종류 != 601 && 종류 != 602 {\n          let mut 다음시작 = 준비.구조.노드들[장식소유자].끝 + 1\n          for 후보 in 준비.구조.노드들 {\n            if 후보.부모순번 == 장식소유자 && 후보.자식필드 != \"decorators\" &&\n              후보.시작 < 다음시작 {\n              다음시작 = 후보.시작\n              다음행 = 스칼라정수(후보, \"startRow\")\n            }\n          }\n        }\n        let 줄수 = 다음행 -\n          스칼라정수(준비.구조.노드들[장식], \"endRow\")\n        합 = 인쇄조각이음(\n          준비.조각판,\n          합,\n          인쇄글조각(\n            준비.조각판,\n            if 준비.오프셋배치 && 줄수 > 0 {\n              줄접두(줄수, 노드들여쓰기(준비, 순번))\n            } else if 준비.오프셋배치 { \" \" }\n            else { \"\\n\" + 들여쓰기(깊이) }\n          )\n        )\n      }\n      case Err(오류) => return Err(오류)\n    }\n    장식색인 = 장식색인 + 1\n  }\n  let mut 몸 = if 댓글고정있음(준비) { 댓글노드인쇄조각(준비, 순번, 깊이)? }\n  else { 노드인쇄조각(준비, 순번, 깊이)? }\n  let 노드 = 준비.구조.노드들[순번]\n  let 부모종류 = if 노드.부모순번 < 0 { 0 }\n    else { 노드종류(준비.언어번호, 준비.구조.노드들[노드.부모순번].코드워드) }\n  let 부모연산 = if 노드.부모순번 < 0 { \"\" }\n    else { 스칼라문자(준비.구조.노드들[노드.부모순번], \"operator\") }\n  // The v4 spelling scalar is the exact number of explicit parenthesis groups\n  // on every expression kind. Apply all of them here; precedence printing\n  // below suppresses its synthetic group when an explicit group already does\n  // that job, so nested binary groups are neither dropped nor duplicated.\n  let 괄호수 = 스칼라정수(노드, \"spelling.parentheses\")\n  if 괄호수 > 0 {\n    let mut 열기 = \"\"\n    let mut 닫기 = \"\"\n    let mut 괄호 = 0\n    while 괄호 < 괄호수 {\n      열기 = 열기 + \"(\"\n      닫기 = 닫기 + \")\"\n      괄호 = 괄호 + 1\n    }\n    let 앞끝행 = if 노드.부모순번 < 0 { 스칼라정수(노드, \"startRow\") }\n      else { 직접앞끝행(준비, 노드.부모순번, 순번) }\n    let 안쪽줄수 = 스칼라정수(노드, \"startRow\") - 앞끝행\n    몸 = 인쇄조각결과합치기(준비, [\n      인쇄글조각결과(준비, 열기 + if 준비.오프셋배치 && 안쪽줄수 > 0 {\n        줄접두(안쪽줄수, 노드들여쓰기(준비, 순번))\n      } else { \"\" }),\n      Ok(몸), 인쇄글조각결과(준비, 닫기)\n    ])?\n  }\n  if 스칼라논리(준비.구조.노드들[순번], \"spelling.trailingComma\") {\n    몸 = 인쇄조각결과합치기(준비, [Ok(몸), 인쇄글조각결과(준비, \",\")])?\n  }\n  Ok(인쇄조각이음(준비.조각판, 합, 몸))\n}\n\nfunction 자식조각인쇄(준비: 준비된인쇄상태, 부모: int, 필드: string, 깊이: int) -> Result<int, string> {\n  let 순번 = 자식순번(준비, 부모, 필드)\n  if 순번 < 0 { Ok(0) }\n  else { 순번인쇄조각(준비, 순번, 깊이) }\n}\n\n// The same single child, printed through the one edge primitive: the caller\n// gives the spelling this edge takes when parent and child share a row, and the\n// primitive decides whether that spelling or the carried row break is what the\n// edge prints.\nfunction 자식조각인쇄접두(\n  준비: 준비된인쇄상태,\n  부모: int,\n  필드: string,\n  깊이: int,\n  같은행: string\n) -> Result<int, string> {\n  let 순번 = 자식순번(준비, 부모, 필드)\n  if 순번 < 0 { return Ok(0) }\n  인쇄조각결과합치기(준비, [\n    인쇄글조각결과(준비, 가장자리접두(준비, 순번, 같은행)),\n    순번인쇄조각(준비, 순번, 깊이)\n  ])\n}\n\nfunction 문장목록조각인쇄(준비: 준비된인쇄상태, 순번들: Array<int>, 깊이: int) -> Result<int, string> {\n  let mut 합 = 0; let mut 색인 = 0\n  let mut 이전부족행 = 0\n  while 색인 < 순번들.length {\n    if 준비.오프셋배치 {\n      합 = 인쇄조각이음(\n        준비.조각판, 합,\n        인쇄글조각(준비.조각판, 문장접두(준비, 순번들, 색인, 이전부족행))\n      )\n    } else {\n      if 색인 > 0 { 합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, \"\\n\")) }\n      합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, 들여쓰기(깊이)))\n    }\n    let 문장조각 = 순번인쇄조각(준비, 순번들[색인], 깊이)?\n    합 = 인쇄조각이음(준비.조각판, 합, 문장조각)\n    이전부족행 = if 준비.오프셋배치 {\n      문장부족행(준비, 순번들[색인], 문장조각)\n    } else { 0 }\n    색인 = 색인 + 1\n  }\n  Ok(합)\n}\n\nfunction 문장블록조각인쇄(준비: 준비된인쇄상태, 순번: int, 깊이: int, 머리: string) -> Result<int, string> {\n  let 지시들 = 자식순번들(준비, 순번, \"directives\")\n  let 본문들 = 자식순번들(준비, 순번, \"body\")\n  if 지시들.length == 0 && 본문들.length == 0 {\n    if 준비.오프셋배치 {\n      let 노드 = 준비.구조.노드들[순번]\n      let 줄수 = 스칼라정수(노드, \"endRow\") - 스칼라정수(노드, \"startRow\")\n      if 줄수 > 0 {\n        let 닫기공백 = 노드들여쓰기(준비, 순번)\n        return 인쇄글조각결과(준비, 머리 + \"\\{\" + 줄접두(줄수, 닫기공백) + \"\\}\")\n      }\n    }\n    return 인쇄글조각결과(준비, 머리 + \"\\{\\}\")\n  }\n  if 준비.오프셋배치 {\n    let mut 내용들: Array<int> = []\n    for 지시 in 지시들 { 내용들.push(지시) }\n    for 본문 in 본문들 { 내용들.push(본문) }\n    let 내용조각 = 문장목록조각인쇄(준비, 내용들, 깊이 + 1)?\n    let 마지막부족행 = if 내용들.length == 0 { 0 } else {\n      문장부족행(\n        준비,\n        내용들[내용들.length - 1],\n        순번인쇄조각(준비, 내용들[내용들.length - 1], 깊이 + 1)?\n      )\n    }\n    return 인쇄조각결과합치기(준비, [\n      인쇄글조각결과(준비, 머리 + \"\\{\"),\n      Ok(내용조각),\n      인쇄글조각결과(준비, 블록닫기접두(준비, 순번, 내용들, 마지막부족행) + \"\\}\")\n    ])\n  }\n  인쇄조각결과합치기(준비, [\n    인쇄글조각결과(준비, 머리 + \"\\{\\n\"),\n    문장목록조각인쇄(준비, 지시들, 깊이 + 1),\n    인쇄글조각결과(준비, if 지시들.length > 0 && 본문들.length > 0 { \"\\n\\n\" } else { \"\" }),\n    문장목록조각인쇄(준비, 본문들, 깊이 + 1),\n    인쇄글조각결과(준비, \"\\n\" + 들여쓰기(깊이) + \"\\}\")\n  ])\n}\n\nfunction 하위식조각인쇄(준비: 준비된인쇄상태, 순번: int, 깊이: int, 최소: int) -> Result<int, string> {\n  let 명시괄호 = 스칼라정수(준비.구조.노드들[순번], \"spelling.parentheses\") > 0\n  let 정밀괄호 = !명시괄호 && 우선순위(준비, 순번) < 최소\n  if 정밀괄호 { 인머리끄기(준비, 순번) }\n  let 인괄호 = !명시괄호 && !정밀괄호 && 인괄호필요(준비, 순번)\n  let 식 = 순번인쇄조각(준비, 순번, 깊이)?\n  if 정밀괄호 || 인괄호 {\n    return 인쇄조각결과합치기(준비, [\n      인쇄글조각결과(준비, \"(\"), Ok(식), 인쇄글조각결과(준비, \")\")\n    ])\n  }\n  Ok(식)\n}\n\nfunction 하위식들조각인쇄(\n  준비: 준비된인쇄상태,\n  순번들: Array<int>,\n  깊이: int,\n  최소: int\n) -> Result<int, string> {\n  let mut 합 = 0\n  let mut 색인 = 0\n  while 색인 < 순번들.length {\n    if 색인 > 0 {\n      합 = 인쇄조각이음(\n        준비.조각판,\n        합,\n        인쇄글조각(준비.조각판, \",\" + 가장자리접두(준비, 순번들[색인], \" \"))\n      )\n    }\n    합 = 인쇄조각이음(\n      준비.조각판,\n      합,\n      하위식조각인쇄(준비, 순번들[색인], 깊이, 최소)?\n    )\n    색인 = 색인 + 1\n  }\n  Ok(합)\n}\n\nfunction 호출인수들조각인쇄(\n  준비: 준비된인쇄상태,\n  부모순번: int,\n  순번들: Array<int>,\n  깊이: int,\n  최소: int\n) -> Result<int, string> {\n  if !준비.오프셋배치 {\n    return 하위식들조각인쇄(준비, 순번들, 깊이, 최소)\n  }\n  let 부모 = 준비.구조.노드들[부모순번]\n  let 대상순번 = 자식순번(준비, 부모순번, \"callee\")\n  let 대상끝행 = 호출대상끝행(준비, 부모순번)\n  let mut 대상끝열 = if 대상순번 < 0 { 스칼라정수(부모, \"startColumn\") }\n    else { 스칼라정수(준비.구조.노드들[대상순번], \"endColumn\") }\n  let 형식인수 = if 자식순번(준비, 부모순번, \"typeArguments\") >= 0 {\n    자식순번(준비, 부모순번, \"typeArguments\")\n  } else { 자식순번(준비, 부모순번, \"typeParameters\") }\n  if 형식인수 >= 0 {\n    대상끝열 = 스칼라정수(준비.구조.노드들[형식인수], \"endColumn\")\n  }\n  // The reference printer catches the closing parenthesis up to the call's\n  // carried END row whether or not the list has any arguments.\n  if 순번들.length == 0 {\n    let 빈닫기줄수 = 스칼라정수(부모, \"endRow\") - 대상끝행\n    if 빈닫기줄수 > 0 {\n      return Ok(인쇄글조각(\n        준비.조각판,\n        줄접두(빈닫기줄수, 노드들여쓰기(준비, 부모순번))\n      ))\n    }\n    return Ok(0)\n  }\n  let 인수들여쓰기 = 노드들여쓰기(준비, 순번들[0])\n  let 첫구분자너비 = if 노드종류(준비.언어번호, 부모.코드워드) == 211 &&\n    스칼라논리(부모, \"optional\") { 3 } else { 1 }\n  let mut 합 = 0\n  let mut 색인 = 0\n  while 색인 < 순번들.length {\n    let 현재 = 준비.구조.노드들[순번들[색인]]\n    if 색인 == 0 {\n      // An argument the image carries parentheses for takes its row break\n      // inside them, so this edge stays on the callee's row.\n      let 첫줄수 = if 스칼라정수(현재, \"spelling.parentheses\") > 0 { 0 }\n        else { 유효시작행(준비, 순번들[색인]) - 대상끝행 }\n      if 첫줄수 > 0 {\n        합 = 인쇄조각이음(\n          준비.조각판,\n          합,\n          인쇄글조각(준비.조각판, 줄접두(첫줄수, 인수들여쓰기))\n        )\n      } else {\n        // A first argument whose parameter list prints without parentheses is\n        // reached by the reference printer's bare-arrow branch, which catches\n        // the row up before the delimiter gap can be applied, so the carried\n        // gap is not part of that edge.\n        let mut 공백수 = if 화살표괄호생략인가(준비, 순번들[색인]) { 0 }\n          else {\n            스칼라정수(현재, \"startColumn\") - 대상끝열 -\n              첫구분자너비 - 스칼라정수(현재, \"spelling.parentheses\")\n          }\n        let mut 공백 = \"\"\n        while 공백수 > 0 { 공백 = 공백 + \" \"; 공백수 = 공백수 - 1 }\n        if 공백 != \"\" {\n          합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, 공백))\n        }\n      }\n    } else {\n      let 이전 = 준비.구조.노드들[순번들[색인 - 1]]\n      let 줄수 = 유효시작행(준비, 순번들[색인]) - 스칼라정수(이전, \"endRow\")\n      let 사이 = if 줄수 > 0 { \",\" + 줄접두(줄수, 인수들여쓰기) } else { \", \" }\n      합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, 사이))\n    }\n    합 = 인쇄조각이음(\n      준비.조각판,\n      합,\n      하위식조각인쇄(준비, 순번들[색인], 깊이, 최소)?\n    )\n    색인 = 색인 + 1\n  }\n  let 닫기줄수 = 스칼라정수(부모, \"endRow\") - 조각끝행(준비, 대상끝행, 합)\n  if 닫기줄수 > 0 {\n    합 = 인쇄조각이음(\n      준비.조각판,\n      합,\n      인쇄글조각(준비.조각판, 줄접두(닫기줄수, 노드들여쓰기(준비, 부모순번)))\n    )\n  }\n  Ok(합)\n}\n\nfunction 연쇄대상조각인쇄(준비: 준비된인쇄상태, 순번: int, 깊이: int, 연속: bool) -> Result<int, string> {\n  let 종류 = 노드종류(준비.언어번호, 준비.구조.노드들[순번].코드워드)\n  if !연속 && (종류 == 211 || 종류 == 209) &&\n    스칼라정수(준비.구조.노드들[순번], \"spelling.parentheses\") == 0 {\n    인머리끄기(준비, 순번)\n    return 인쇄조각결과합치기(준비, [\n      인쇄글조각결과(준비, \"(\"),\n      순번인쇄조각(준비, 순번, 깊이),\n      인쇄글조각결과(준비, \")\")\n    ])\n  }\n  하위식조각인쇄(준비, 순번, 깊이, 17)\n}\n\nfunction 함수머리조각인쇄(준비: 준비된인쇄상태, 순번: int, 깊이: int, 이름있음: bool) -> Result<int, string> {\n  let 노드 = 준비.구조.노드들[순번]\n  let mut 머리 = (if 스칼라논리(노드, \"async\") { \"async \" } else { \"\" }) + \"function\"\n  if 스칼라논리(노드, \"generator\") { 머리 = 머리 + \"*\" }\n  if !이름있음 { 머리 = 머리 + \" \" }\n  let mut 합 = 인쇄글조각(준비.조각판, 머리)\n  if 이름있음 {\n    합 = 인쇄조각이음(\n      준비.조각판, 합, 자식조각인쇄접두(준비, 순번, \"id\", 깊이, \" \")?\n    )\n  }\n  let 형식매개 = 자식조각인쇄접두(준비, 순번, \"typeParameters\", 깊이, \"\")?\n  if 준비.조각판.길이들[형식매개] > 0 {\n    합 = 인쇄조각이음(준비.조각판, 합, 형식매개)\n  }\n  let 매개들 = 자식순번들(준비, 순번, \"params\")\n  합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, \"(\"))\n  합 = 인쇄조각이음(\n    준비.조각판,\n    합,\n    매개들조각인쇄(준비, 순번, 매개들, 깊이)?\n  )\n  합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, \")\"))\n  let 반환 = 자식조각인쇄(준비, 순번, \"returnType\", 깊이)?\n  if 준비.조각판.길이들[반환] > 0 {\n    합 = 인쇄조각결과합치기(준비, [\n      Ok(합), 인쇄글조각결과(준비, 매개뒤형식접두(준비, 순번, 매개들)), Ok(반환)\n    ])?\n  }\n  Ok(합)\n}\n\nfunction 메서드조각인쇄(준비: 준비된인쇄상태, 순번: int, 깊이: int) -> Result<int, string> {\n  let 노드 = 준비.구조.노드들[순번]\n  let 종류 = 노드종류(준비.언어번호, 노드.코드워드)\n  let mut 머리 = \"\"\n  if 스칼라논리(노드, \"declare\") { 머리 = 머리 + \"declare \" }\n  let 접근 = 스칼라문자(노드, \"accessibility\")\n  if 접근 != \"\" { 머리 = 머리 + 접근 + \" \" }\n  if 스칼라논리(노드, \"abstract\") { 머리 = 머리 + \"abstract \" }\n  if 스칼라논리(노드, \"static\") { 머리 = 머리 + \"static \" }\n  if 스칼라논리(노드, \"override\") { 머리 = 머리 + \"override \" }\n  if 스칼라논리(노드, \"async\") { 머리 = 머리 + \"async \" }\n  let 꼴 = 스칼라문자(노드, \"kind\")\n  if 꼴 == \"get\" || 꼴 == \"set\" { 머리 = 머리 + 꼴 + \" \" }\n  if 스칼라논리(노드, \"generator\") { 머리 = 머리 + \"*\" }\n  // The reference printer carries the method's key row across the WHOLE head:\n  // a `get` whose name the source puts on the following row is emitted on the\n  // name's row, not on its own. A decorated member's rows are placed by the\n  // decorator separator, which has already put the printer on the key's row, so\n  // the separator owns the edge there and a second carry would double it.\n  let 계산 = 스칼라논리(노드, \"computed\")\n  let 키순번 = 자식순번(준비, 순번, \"key\")\n  let 머리앞 = if 자식순번들(준비, 순번, \"decorators\").length > 0 { \"\" }\n    else { 가장자리접두(준비, 키순번, \"\") }\n  let mut 합 = 인쇄글조각(준비.조각판, 머리앞 + 머리)\n  let 키 = if 계산 && 키순번 >= 0 {\n    하위식조각인쇄(준비, 키순번, 깊이, 2)?\n  } else { 자식조각인쇄(준비, 순번, \"key\", 깊이)? }\n  if 계산 {\n    합 = 인쇄조각결과합치기(준비, [\n      Ok(합), 인쇄글조각결과(준비, \"[\"), Ok(키), 인쇄글조각결과(준비, \"]\")\n    ])?\n  } else {\n    합 = 인쇄조각이음(준비.조각판, 합, 키)\n  }\n  if 스칼라논리(노드, \"optional\") {\n    합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, \"?\"))\n  }\n  let 형식매개 = 자식조각인쇄접두(준비, 순번, \"typeParameters\", 깊이, \"\")?\n  if 준비.조각판.길이들[형식매개] > 0 {\n    합 = 인쇄조각이음(준비.조각판, 합, 형식매개)\n  }\n  let 매개들 = 자식순번들(준비, 순번, \"params\")\n  합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, \"(\"))\n  합 = 인쇄조각이음(\n    준비.조각판,\n    합,\n    매개들조각인쇄(준비, 순번, 매개들, 깊이)?\n  )\n  합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, \")\"))\n  let 반환 = 자식조각인쇄(준비, 순번, \"returnType\", 깊이)?\n  if 준비.조각판.길이들[반환] > 0 {\n    합 = 인쇄조각결과합치기(준비, [\n      Ok(합), 인쇄글조각결과(준비, 매개뒤형식접두(준비, 순번, 매개들)), Ok(반환)\n    ])?\n  }\n  let 몸 = 자식조각인쇄(준비, 순번, \"body\", 깊이)?\n  if 준비.조각판.길이들[몸] > 0 {\n    let 몸순번 = 자식순번(준비, 순번, \"body\")\n    합 = 인쇄조각결과합치기(준비, [\n      Ok(합), 인쇄글조각결과(준비, 함수몸접두(준비, 순번, 몸순번)), Ok(몸)\n    ])?\n  } else if 종류 == 604 || 종류 == 605 || 종류 == 606 {\n    합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, \";\"))\n  }\n  Ok(합)\n}\n\nfunction 중괄호목록조각인쇄(준비: 준비된인쇄상태, 순번들: Array<int>, 깊이: int, 세미콜론: bool) -> Result<int, string> {\n  if 순번들.length == 0 { return 인쇄글조각결과(준비, \"\\{\\}\") }\n  if 준비.오프셋배치 && 세미콜론 {\n    let 부모순번 = 준비.구조.노드들[순번들[0]].부모순번\n    let 부모 = 준비.구조.노드들[부모순번]\n    let mut 이전행 = 스칼라정수(부모, \"startRow\")\n    let mut 합 = 인쇄글조각(준비.조각판, \"\\{\")\n    for 멤버 in 순번들 {\n      let 멤버노드 = 준비.구조.노드들[멤버]\n      let 줄수 = 스칼라정수(멤버노드, \"startRow\") - 이전행\n      if 줄수 > 0 {\n        합 = 인쇄조각이음(\n          준비.조각판,\n          합,\n          인쇄글조각(준비.조각판, 줄접두(줄수, 노드들여쓰기(준비, 멤버)))\n        )\n      }\n      합 = 인쇄조각이음(준비.조각판, 합, 순번인쇄조각(준비, 멤버, 깊이 + 1)?)\n      let 구분자 = if 스칼라논리(준비.구조.노드들[멤버], \"spelling.typeMemberComma\") { \",\" } else { \";\" }\n      합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, 구분자))\n      이전행 = 스칼라정수(멤버노드, \"endRow\")\n    }\n    let 닫기줄수 = 스칼라정수(부모, \"endRow\") - 이전행\n    let 닫기접두 = if 닫기줄수 > 0 {\n      줄접두(닫기줄수, 노드들여쓰기(준비, 부모순번))\n    } else { \"\" }\n    return 인쇄조각결과합치기(준비, [\n      Ok(합), 인쇄글조각결과(준비, 닫기접두 + \"\\}\")\n    ])\n  }\n  if 준비.오프셋배치 && !세미콜론 {\n    let 부모순번 = 준비.구조.노드들[순번들[0]].부모순번\n    let 첫줄수 = 리터럴첫줄수(준비, 부모순번, 순번들[0])\n    let mut 몸 = 인쇄글조각(\n      준비.조각판,\n      if 첫줄수 > 0 { 줄접두(첫줄수, 리터럴열(준비, 순번들[0])) } else { \" \" }\n    )\n    let mut 색인 = 0\n    while 색인 < 순번들.length {\n      if 색인 > 0 {\n        let 접두 = 리터럴사이접두(준비, 순번들[색인 - 1], 순번들[색인])\n        몸 = 인쇄조각이음(준비.조각판, 몸, 인쇄글조각(준비.조각판, \",\" + 접두))\n      }\n      몸 = 인쇄조각이음(준비.조각판, 몸, 순번인쇄조각(준비, 순번들[색인], 깊이 + 1)?)\n      색인 = 색인 + 1\n    }\n    let 닫기접두 = 리터럴닫기접두(준비, 부모순번, 몸)?\n    let 닫기 = if 닫기접두 != \"\" { 닫기접두 + \"\\}\" } else { \" \\}\" }\n    return 인쇄조각결과합치기(준비, [\n      인쇄글조각결과(준비, \"\\{\"), Ok(몸), 인쇄글조각결과(준비, 닫기)\n    ])\n  }\n  let mut 합 = 인쇄글조각(준비.조각판, \"\\{\\n\"); let mut 색인 = 0\n  while 색인 < 순번들.length {\n    합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, 들여쓰기(깊이 + 1)))\n    합 = 인쇄조각이음(준비.조각판, 합, 순번인쇄조각(준비, 순번들[색인], 깊이 + 1)?)\n    if 세미콜론 {\n      let 구분자 = if 스칼라논리(\n        준비.구조.노드들[순번들[색인]],\n        \"spelling.typeMemberComma\"\n      ) { \",\" } else { \";\" }\n      합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, 구분자))\n    } else if 색인 + 1 < 순번들.length {\n      합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, \",\"))\n    }\n    합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, \"\\n\"))\n    색인 = 색인 + 1\n  }\n  합 = 인쇄조각이음(\n    준비.조각판,\n    합,\n    인쇄글조각(준비.조각판, 들여쓰기(깊이) + \"\\}\")\n  )\n  Ok(합)\n}\n\nfunction 원시노드조각인쇄(준비: 준비된인쇄상태, 순번: int, 깊이: int) -> Result<int, string> {\n  if 순번 < 0 || 순번 >= 준비.구조.노드들.length { return Err(\"인쇄 노드 순번이 범위를 벗어났습니다\") }\n  let 노드 = 준비.구조.노드들[순번]\n  let 종류 = 노드종류(준비.언어번호, 노드.코드워드)\n  if 종류 == 0 { return Err(\"인쇄기에 없는 노드 코드입니다: {노드.코드워드}\") }\n\n  if 종류 == 101 { return 자식조각인쇄(준비, 순번, \"program\", 깊이) }\n  if 종류 == 102 {\n    let 지시들 = 자식순번들(준비, 순번, \"directives\")\n    let 본문들 = 자식순번들(준비, 순번, \"body\")\n    if 준비.오프셋배치 {\n      return 인쇄조각결과합치기(준비, [\n        문장목록조각인쇄(준비, 지시들, 0),\n        문장목록조각인쇄(준비, 본문들, 0)\n      ])\n    }\n    return 인쇄조각결과합치기(준비, [\n      문장목록조각인쇄(준비, 지시들, 0),\n      인쇄글조각결과(준비, if 지시들.length > 0 && 본문들.length > 0 { \"\\n\\n\" } else { \"\" }),\n      문장목록조각인쇄(준비, 본문들, 0)\n    ])\n  }\n  if 종류 == 103 {\n    return 인쇄조각결과합치기(준비, [\n      자식조각인쇄(준비, 순번, \"value\", 깊이),\n      인쇄글조각결과(준비, \";\")\n    ])\n  }\n  if 종류 == 104 {\n    if 스칼라있음(노드, \"spelling.singleQuote\") ||\n      스칼라있음(노드, \"spelling.escapeBody\") {\n      return 인쇄글결과조각(준비, 철자문자열리터럴(노드))\n    }\n    let 값 = 스칼라문자(노드, \"value\")\n    let mut 역빗금수 = 0; let mut 큰따옴표 = false; let mut 작은따옴표 = false\n    for 글자 in 값.scalars() {\n      if 글자 == \"\\\\\" { 역빗금수 = 역빗금수 + 1 }\n      else {\n        if 역빗금수 % 2 == 0 {\n          if 글자 == \"\\\"\" { 큰따옴표 = true }\n          if 글자 == \"'\" { 작은따옴표 = true }\n        }\n        역빗금수 = 0\n      }\n    }\n    if !큰따옴표 { return 인쇄글조각결과(준비, \"\\\"\" + 값 + \"\\\"\") }\n    if !작은따옴표 { return 인쇄글조각결과(준비, \"'\" + 값 + \"'\") }\n    return Err(\"지시문 리터럴에 탈출하지 않은 두 따옴표가 함께 있습니다\")\n  }\n  if 종류 == 105 {\n    let 식순번 = 자식순번(준비, 순번, \"expression\")\n    let mut 밑순번 = 식순번\n    if 밑순번 >= 0 &&\n      노드종류(준비.언어번호, 준비.구조.노드들[밑순번].코드워드) == 210 {\n      밑순번 = 자식순번(준비, 밑순번, \"callee\")\n    }\n    while 밑순번 >= 0 &&\n      노드종류(준비.언어번호, 준비.구조.노드들[밑순번].코드워드) == 208 &&\n      !스칼라논리(준비.구조.노드들[밑순번], \"computed\") {\n      밑순번 = 자식순번(준비, 밑순번, \"object\")\n    }\n    // An explicit expression wrapper already supplies the grouping required\n    // by decorator syntax. Babel does not add another synthetic pair around\n    // it, so preserve that same canonical boundary here.\n    let 그대로 = 스칼라정수(준비.구조.노드들[식순번], \"spelling.parentheses\") > 0 ||\n      (밑순번 >= 0 &&\n        노드종류(준비.언어번호, 준비.구조.노드들[밑순번].코드워드) == 106)\n    return 인쇄조각결과합치기(준비, [\n      인쇄글조각결과(준비, if 그대로 { \"@\" } else { \"@(\" }),\n      순번인쇄조각(준비, 식순번, 깊이),\n      인쇄글조각결과(준비, if 그대로 { \"\" } else { \")\" })\n    ])\n  }\n  if 종류 == 106 {\n    let mut 합 = 인쇄글조각(준비.조각판, 식별자이름(준비, 순번)?)\n    if 스칼라논리(노드, \"optional\") {\n      합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, \"?\"))\n    }\n    if 노드.부모순번 >= 0 && 노드.자식필드 == \"id\" {\n      let 부모 = 준비.구조.노드들[노드.부모순번]\n      if 노드종류(준비.언어번호, 부모.코드워드) == 408 &&\n        스칼라논리(부모, \"definite\") {\n        합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, \"!\"))\n      }\n    }\n    let 형식 = 자식조각인쇄접두(준비, 순번, \"typeAnnotation\", 깊이, \"\")?\n    return Ok(인쇄조각이음(준비.조각판, 합, 형식))\n  }\n  if 종류 == 107 {\n    return 인쇄조각결과합치기(준비, [\n      인쇄글조각결과(준비, \"#\"),\n      자식조각인쇄(준비, 순번, \"id\", 깊이)\n    ])\n  }\n  if 종류 == 108 { return 인쇄글결과조각(준비, 철자문자열리터럴(노드)) }\n  if 종류 == 109 { return 인쇄글조각결과(준비, 스칼라문자(노드, \"value\") + \"n\") }\n  if 종류 == 110 {\n    if 스칼라있음(노드, \"spelling.numericLexeme\") {\n      return 인쇄글조각결과(준비, 스칼라문자(노드, \"spelling.numericLexeme\"))\n    }\n    let 값 = 노드스칼라(노드, \"value\")\n    if 값.태그 == 5 {\n      let 원본 = 값.문자열값\n      if 원본 == \"number:-0\" { return 인쇄글조각결과(준비, \"0\") }\n      if 원본 == \"number:NaN\" { return 인쇄글조각결과(준비, \"0 / 0\") }\n      if 원본 == \"number:Infinity\" { return 인쇄글조각결과(준비, \"1e999\") }\n      if 원본 == \"number:-Infinity\" { return 인쇄글조각결과(준비, \"-1e999\") }\n    return 인쇄글조각결과(준비, 글자합치기(원본.scalars(), 7, 원본.scalars().length))\n    }\n    let 숫자 = 스칼라정수(노드, \"value\")\n    return 인쇄글조각결과(준비, \"{숫자}\")\n  }\n  if 종류 == 111 { return 인쇄글조각결과(준비, if 스칼라논리(노드, \"value\") { \"true\" } else { \"false\" }) }\n  if 종류 == 112 { return 인쇄글조각결과(준비, \"null\") }\n  if 종류 == 113 { return 인쇄글조각결과(준비, \"this\") }\n  if 종류 == 114 { return 인쇄글조각결과(준비, \"super\") }\n  if 종류 == 115 {\n    return 인쇄글조각결과(\n      준비,\n      \"/\" + 스칼라문자(노드, \"pattern\") + \"/\" + 스칼라문자(노드, \"flags\")\n    )\n  }\n  if 종류 == 116 { return 인쇄글조각결과(준비, 스칼라문자(노드, \"value.raw\")) }\n  if 종류 == 117 {\n    let 준문자들 = 자식순번들(준비, 순번, \"quasis\")\n    let 식들 = 자식순번들(준비, 순번, \"expressions\")\n    let mut 합 = 인쇄글조각(준비.조각판, \"`\"); let mut 색인 = 0\n    while 색인 < 준문자들.length {\n      let 준문자인쇄 = if 댓글고정있음(준비) { 댓글노드인쇄조각(준비, 준문자들[색인], 깊이) }\n        else { 노드인쇄조각(준비, 준문자들[색인], 깊이) }\n      합 = 인쇄조각이음(준비.조각판, 합, 준문자인쇄?)\n      if 색인 < 식들.length {\n        let 준문자 = 준비.구조.노드들[준문자들[색인]]\n        let 식노드 = 준비.구조.노드들[식들[색인]]\n        let 식줄수 = 스칼라정수(식노드, \"startRow\") - 스칼라정수(준문자, \"endRow\")\n        let 인괄호 = 인괄호필요(준비, 식들[색인])\n        let 식인쇄 = if 댓글고정있음(준비) { 댓글노드인쇄조각(준비, 식들[색인], 깊이) }\n          else { 노드인쇄조각(준비, 식들[색인], 깊이) }\n        합 = 인쇄조각이음(\n          준비.조각판, 합,\n          인쇄글조각(\n            준비.조각판,\n            (if 인괄호 { \"$\\{(\" } else { \"$\\{\" }) +\n              (if 준비.오프셋배치 && 식줄수 > 0 { 줄접두(식줄수, 0) } else { \"\" })\n          )\n        )\n        합 = 인쇄조각이음(준비.조각판, 합, 식인쇄?)\n        합 = 인쇄조각이음(\n          준비.조각판, 합,\n          인쇄글조각(준비.조각판, if 인괄호 { \")\\}\" } else { \"\\}\" })\n        )\n      }\n      색인 = 색인 + 1\n    }\n    return Ok(인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, \"`\")))\n  }\n  if 종류 == 118 {\n    let 이름있음 = 자식순번(준비, 순번, \"id\") >= 0\n    let 몸순번 = 자식순번(준비, 순번, \"body\")\n    return 인쇄조각결과합치기(준비, [\n      함수머리조각인쇄(준비, 순번, 깊이, 이름있음),\n      인쇄글조각결과(준비, 함수몸접두(준비, 순번, 몸순번)),\n      자식조각인쇄(준비, 순번, \"body\", 깊이)\n    ])\n  }\n  Err(\"원시 노드 인쇄 규칙을 찾지 못했습니다: {종류}\")\n}\n\nfunction 모음노드조각인쇄(준비: 준비된인쇄상태, 순번: int, 깊이: int) -> Result<int, string> {\n  let 노드 = 준비.구조.노드들[순번]\n  let 종류 = 노드종류(준비.언어번호, 노드.코드워드)\n  if 종류 == 201 || 종류 == 202 {\n    let 무늬 = 종류 == 202\n    if !스칼라있음(노드, \"child.elements.length\") { return Err(\"배열 요소 길이가 없습니다\") }\n    let 길이 = 스칼라정수(노드, \"child.elements.length\")\n    if 길이 < 0 { return Err(\"배열 요소 길이가 음수입니다\") }\n    let mut 요소들: Array<int> = []\n    let mut 색인 = 0\n    while 색인 < 길이 { 요소들.push(-1); 색인 = 색인 + 1 }\n    for 자식 in 자식순번들(준비, 순번, \"elements\") {\n      let 요소 = 준비.구조.노드들[자식]\n      if 요소.자식색인 < 0 || 요소.자식색인 >= 길이 || 요소들[요소.자식색인] >= 0 {\n        return Err(\"배열 요소 색인이 정규형이 아닙니다\")\n      }\n      요소들[요소.자식색인] = 자식\n    }\n    if 준비.오프셋배치 {\n      let mut 첫요소 = -1\n      let mut 마지막요소 = -1\n      for 요소순번 in 요소들 {\n        if 요소순번 >= 0 {\n          if 첫요소 < 0 { 첫요소 = 요소순번 }\n          마지막요소 = 요소순번\n        }\n      }\n      let mut 몸 = 0\n      let mut 이전요소 = -1\n      색인 = 0\n      while 색인 < 요소들.length {\n        if 색인 > 0 { 몸 = 인쇄조각이음(준비.조각판, 몸, 인쇄글조각(준비.조각판, \",\")) }\n        if 요소들[색인] >= 0 {\n          let 접두 = if 이전요소 < 0 {\n            let 첫줄수 = 리터럴첫줄수(준비, 순번, 요소들[색인])\n            if 첫줄수 > 0 { 줄접두(첫줄수, 리터럴열(준비, 요소들[색인])) }\n            else if 색인 > 0 { \" \" } else { \"\" }\n          } else {\n            리터럴사이접두(준비, 이전요소, 요소들[색인])\n          }\n          몸 = 인쇄조각이음(준비.조각판, 몸, 인쇄글조각(준비.조각판, 접두))\n          let 요소깊이 = if 노드종류(\n            준비.언어번호,\n            준비.구조.노드들[요소들[색인]].코드워드\n          ) == 201 { 깊이 + 1 } else { 깊이 }\n          let 요소결과 = if 무늬 { 순번인쇄조각(준비, 요소들[색인], 깊이) }\n            else { 하위식조각인쇄(준비, 요소들[색인], 요소깊이, 2) }\n          match 요소결과 {\n            case Ok(값) => { 몸 = 인쇄조각이음(준비.조각판, 몸, 값) }\n            case Err(오류) => return Err(오류)\n          }\n          이전요소 = 요소들[색인]\n        }\n        색인 = 색인 + 1\n      }\n      if 요소들.length > 0 && 요소들[요소들.length - 1] < 0 {\n        몸 = 인쇄조각이음(준비.조각판, 몸, 인쇄글조각(준비.조각판, \",\"))\n      }\n      let mut 합 = 인쇄조각이음(준비.조각판, 인쇄글조각(준비.조각판, \"[\"), 몸)\n      if 마지막요소 >= 0 {\n        let 닫기접두 = 리터럴닫기접두(준비, 순번, 몸)?\n        if 닫기접두 != \"\" {\n          합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, 닫기접두))\n        }\n      }\n      합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, \"]\"))\n      if 무늬 { 합 = 인쇄조각이음(준비.조각판, 합, 자식조각인쇄접두(준비, 순번, \"typeAnnotation\", 깊이, \"\")?) }\n      return Ok(합)\n    }\n    let mut 합 = 인쇄글조각(준비.조각판, \"[\")\n    색인 = 0\n    while 색인 < 요소들.length {\n      if 색인 > 0 { 합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, \",\")) }\n      if 요소들[색인] >= 0 {\n        if 색인 > 0 { 합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, \" \")) }\n        let 요소결과 = if 무늬 { 순번인쇄조각(준비, 요소들[색인], 깊이) }\n          else { 하위식조각인쇄(준비, 요소들[색인], 깊이, 2) }\n        match 요소결과 {\n          case Ok(값) => { 합 = 인쇄조각이음(준비.조각판, 합, 값) }\n          case Err(오류) => return Err(오류)\n        }\n      }\n      색인 = 색인 + 1\n    }\n    if 요소들.length > 0 && 요소들[요소들.length - 1] < 0 {\n      합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, \",\"))\n    }\n    합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, \"]\"))\n    if 무늬 {\n      match 자식조각인쇄접두(준비, 순번, \"typeAnnotation\", 깊이, \"\") {\n        case Ok(형식) => { 합 = 인쇄조각이음(준비.조각판, 합, 형식) }\n        case Err(오류) => return Err(오류)\n      }\n    }\n    return Ok(합)\n  }\n  if 종류 == 203 { return 중괄호목록조각인쇄(준비, 자식순번들(준비, 순번, \"properties\"), 깊이, false) }\n  if 종류 == 204 { return 중괄호목록조각인쇄(준비, 자식순번들(준비, 순번, \"properties\"), 깊이, false) }\n  if 종류 == 205 {\n    let 키순번 = 자식순번(준비, 순번, \"key\")\n    let 값순번 = 자식순번(준비, 순번, \"value\")\n    let 계산 = 스칼라논리(노드, \"computed\")\n    let 키 = match if 계산 && 키순번 >= 0 { 하위식조각인쇄(준비, 키순번, 깊이, 2) }\n      else if 댓글고정있음(준비) { 댓글노드인쇄조각(준비, 키순번, 깊이) }\n      else { 노드인쇄조각(준비, 키순번, 깊이) } {\n      case Ok(조각) => 조각\n      case Err(오류) => return Err(오류)\n    }\n    let 값 = match 하위식조각인쇄(준비, 값순번, 깊이, 2) {\n      case Ok(조각) => 조각\n      case Err(오류) => return Err(오류)\n    }\n    if 스칼라논리(노드, \"shorthand\") {\n      if 인쇄조각같음(준비.조각판, 키, 값)? { return Ok(키) }\n      if 노드종류(준비.언어번호, 준비.구조.노드들[값순번].코드워드) == 306 {\n        let 왼순번 = 자식순번(준비, 값순번, \"left\")\n        if 왼순번 >= 0 &&\n          노드종류(준비.언어번호, 준비.구조.노드들[왼순번].코드워드) == 106 &&\n          인쇄조각같음(\n            준비.조각판,\n            키,\n            인쇄글조각(준비.조각판, 식별자이름(준비, 왼순번)?)\n          )? { return Ok(값) }\n      }\n    }\n    let 키글 = if 계산 {\n      인쇄조각결과합치기(준비, [\n        인쇄글조각결과(준비, \"[\" + 가장자리접두(준비, 키순번, \"\")),\n        Ok(키), 인쇄글조각결과(준비, \"]\")\n      ])?\n    } else { 키 }\n    return 인쇄조각결과합치기(준비, [\n      Ok(키글), 인쇄글조각결과(준비, \":\" + 가장자리접두(준비, 값순번, \" \")), Ok(값)\n    ])\n  }\n  if 종류 == 206 {\n    let 인수순번 = 자식순번(준비, 순번, \"argument\")\n    return 인쇄조각결과합치기(준비, [\n      인쇄글조각결과(준비, \"...\" + 가장자리접두(준비, 인수순번, \"\")),\n      하위식조각인쇄(준비, 인수순번, 깊이, 2)\n    ])\n  }\n  if 종류 == 207 {\n    return 인쇄조각결과합치기(준비, [\n      인쇄글조각결과(준비, \"...\"),\n      자식조각인쇄(준비, 순번, \"argument\", 깊이),\n      자식조각인쇄접두(준비, 순번, \"typeAnnotation\", 깊이, \"\")\n    ])\n  }\n  if 종류 == 208 || 종류 == 209 {\n    let 선택 = 종류 == 209\n    let 대상순번 = 자식순번(준비, 순번, \"object\")\n    let 속성순번 = 자식순번(준비, 순번, \"property\")\n    let 대상종류 = if 대상순번 < 0 { 0 }\n      else { 노드종류(준비.언어번호, 준비.구조.노드들[대상순번].코드워드) }\n    let 대상 = match 연쇄대상조각인쇄(준비, 대상순번, 깊이, 선택) {\n      case Ok(조각) => if 대상종류 == 727 &&\n        스칼라정수(준비.구조.노드들[대상순번], \"spelling.parentheses\") == 0 {\n        인쇄조각결과합치기(준비, [\n          인쇄글조각결과(준비, \"(\"), Ok(조각), 인쇄글조각결과(준비, \")\")\n        ])?\n      } else { 조각 }\n      case Err(오류) => return Err(오류)\n    }\n    if 스칼라논리(노드, \"computed\") {\n      let 접근접두 = if 대상순번 >= 0 && 속성순번 >= 0 {\n        가장자리접두(준비, 속성순번, \"\")\n      } else { \"\" }\n      return 인쇄조각결과합치기(준비, [\n        Ok(대상),\n        인쇄글조각결과(준비, (if 선택 && 스칼라논리(노드, \"optional\") { \"?.\" } else { \"\" }) + \"[\"),\n        인쇄글조각결과(준비, 접근접두),\n        자식조각인쇄(준비, 순번, \"property\", 깊이),\n        인쇄글조각결과(준비, \"]\")\n      ])\n    }\n    let mut 정수대상 = false\n    if !선택 && 대상순번 >= 0 && 대상종류 == 110 {\n      let 숫자값 = 노드스칼라(준비.구조.노드들[대상순번], \"value\")\n      정수대상 = 숫자값.태그 == 3\n      if 숫자값.태그 == 5 {\n        let 글자들 = 숫자값.문자열값.scalars()\n        let mut 색인 = 7\n        정수대상 = 색인 < 글자들.length\n        while 정수대상 && 색인 < 글자들.length {\n          let 글자 = 글자들[색인]\n          정수대상 = 글자 >= \"0\" && 글자 <= \"9\"\n          색인 = 색인 + 1\n        }\n      }\n      if 스칼라정수(준비.구조.노드들[대상순번], \"spelling.parentheses\") > 0 { 정수대상 = false }\n    }\n    let 접근글 = if 선택 && 스칼라논리(노드, \"optional\") { \"?.\" } else if 정수대상 { \" .\" } else { \".\" }\n    let 접근접두 = if 대상순번 >= 0 && 속성순번 >= 0 {\n      가장자리접두(준비, 속성순번, \"\")\n    } else { \"\" }\n    return 인쇄조각결과합치기(준비, [\n      Ok(대상),\n      인쇄글조각결과(준비, 접근글 + 접근접두),\n      자식조각인쇄(준비, 순번, \"property\", 깊이)\n    ])\n  }\n  if 종류 == 210 || 종류 == 211 {\n    let 선택 = 종류 == 211\n    let 선택부름 = if 선택 && 스칼라논리(노드, \"optional\") { \"?.\" } else { \"\" }\n    let 형식인수 = match 자식조각인쇄접두(준비, 순번, \"typeParameters\", 깊이, \"\") {\n      case Ok(조각) => if 준비.조각판.길이들[조각] == 0 {\n        자식조각인쇄접두(준비, 순번, \"typeArguments\", 깊이, \"\")\n      } else { Ok(조각) }\n      case Err(오류) => Err(오류)\n    }\n    return 인쇄조각결과합치기(준비, [\n      연쇄대상조각인쇄(준비, 자식순번(준비, 순번, \"callee\"), 깊이, 선택),\n      인쇄글조각결과(준비, 선택부름),\n      형식인수,\n      인쇄글조각결과(준비, \"(\"),\n      호출인수들조각인쇄(준비, 순번, 자식순번들(준비, 순번, \"arguments\"), 깊이, 2),\n      인쇄글조각결과(준비, \")\")\n    ])\n  }\n  if 종류 == 212 {\n    let 형식인수 = match 자식조각인쇄접두(준비, 순번, \"typeParameters\", 깊이, \"\") {\n      case Ok(조각) => if 준비.조각판.길이들[조각] == 0 {\n        자식조각인쇄접두(준비, 순번, \"typeArguments\", 깊이, \"\")\n      } else { Ok(조각) }\n      case Err(오류) => Err(오류)\n    }\n    let 대상순번 = 자식순번(준비, 순번, \"callee\")\n    let 대상종류 = if 대상순번 < 0 { 0 }\n      else { 노드종류(준비.언어번호, 준비.구조.노드들[대상순번].코드워드) }\n    let mut 대상 = 연쇄대상조각인쇄(준비, 대상순번, 깊이, false)?\n    if 대상종류 == 210 &&\n      스칼라정수(준비.구조.노드들[대상순번], \"spelling.parentheses\") == 0 {\n      대상 = 인쇄조각결과합치기(준비, [\n        인쇄글조각결과(준비, \"(\"), Ok(대상), 인쇄글조각결과(준비, \")\")\n      ])?\n    }\n    return 인쇄조각결과합치기(준비, [\n      인쇄글조각결과(준비, \"new\" + 가장자리접두(준비, 대상순번, \" \")),\n      Ok(대상),\n      형식인수,\n      인쇄글조각결과(준비, \"(\"),\n      호출인수들조각인쇄(준비, 순번, 자식순번들(준비, 순번, \"arguments\"), 깊이, 2),\n      인쇄글조각결과(준비, \")\")\n    ])\n  }\n  if 종류 == 213 {\n    let 형식인수 = match 자식조각인쇄접두(준비, 순번, \"typeParameters\", 깊이, \"\") {\n      case Ok(조각) => if 준비.조각판.길이들[조각] == 0 {\n        자식조각인쇄접두(준비, 순번, \"typeArguments\", 깊이, \"\")\n      } else { Ok(조각) }\n      case Err(오류) => Err(오류)\n    }\n    let 준본순번 = 자식순번(준비, 순번, \"quasi\")\n    return 인쇄조각결과합치기(준비, [\n      연쇄대상조각인쇄(준비, 자식순번(준비, 순번, \"tag\"), 깊이, false),\n      형식인수,\n      인쇄글조각결과(준비, 가장자리접두(준비, 준본순번, \"\")),\n      자식조각인쇄(준비, 순번, \"quasi\", 깊이)\n    ])\n  }\n  Err(\"모음 노드 인쇄 규칙을 찾지 못했습니다: {종류}\")\n}\n\nfunction 계산노드조각인쇄(준비: 준비된인쇄상태, 순번: int, 깊이: int) -> Result<int, string> {\n  let 노드 = 준비.구조.노드들[순번]\n  let 종류 = 노드종류(준비.언어번호, 노드.코드워드)\n  if 종류 == 301 {\n    let 연산 = 스칼라문자(노드, \"operator\")\n    let 인수순번 = 자식순번(준비, 순번, \"argument\")\n    let mut 안연산 = \"\"\n    if 인수순번 >= 0 {\n      let 인수노드 = 준비.구조.노드들[인수순번]\n      let 인수종류 = 노드종류(준비.언어번호, 인수노드.코드워드)\n      if 인수종류 == 301 {\n        안연산 = 스칼라문자(인수노드, \"operator\")\n      }\n      else if 인수종류 == 311 && 스칼라논리(인수노드, \"prefix\") {\n        let 갱신 = 스칼라문자(인수노드, \"operator\")\n        if 갱신 == \"++\" { 안연산 = \"+\" }\n        else if 갱신 == \"--\" { 안연산 = \"-\" }\n      }\n    }\n    let 사이 = if 연산 == \"typeof\" || 연산 == \"void\" || 연산 == \"delete\" ||\n      ((연산 == \"+\" || 연산 == \"-\") && 안연산 == 연산) { \" \" } else { \"\" }\n    return 인쇄조각결과합치기(준비, [\n      인쇄글조각결과(준비, 연산 + 가장자리접두(준비, 인수순번, 사이)),\n      하위식조각인쇄(준비, 인수순번, 깊이, 15)\n    ])\n  }\n  if 종류 == 302 {\n    let 인수순번 = 자식순번(준비, 순번, \"argument\")\n    return 인쇄조각결과합치기(준비, [\n      인쇄글조각결과(준비, \"await\" + 가장자리접두(준비, 인수순번, \" \")),\n      하위식조각인쇄(준비, 인수순번, 깊이, 15)\n    ])\n  }\n  if 종류 == 309 {\n    let 인수 = 자식순번(준비, 순번, \"argument\")\n    if 인수 < 0 { return 인쇄글조각결과(준비, \"yield\") }\n    return 인쇄조각결과합치기(준비, [\n      인쇄글조각결과(준비, if 스칼라논리(노드, \"delegate\") { \"yield* \" } else { \"yield \" }),\n      하위식조각인쇄(준비, 인수, 깊이, 2)\n    ])\n  }\n  if 종류 == 311 {\n    let 연산 = 스칼라문자(노드, \"operator\")\n    let 인수순번 = 자식순번(준비, 순번, \"argument\")\n    let 인수 = 하위식조각인쇄(준비, 인수순번, 깊이, 16)\n    if 스칼라논리(노드, \"prefix\") {\n      return 인쇄조각결과합치기(준비, [\n        인쇄글조각결과(준비, 연산 + 가장자리접두(준비, 인수순번, \"\")), 인수\n      ])\n    }\n    let 뒤접두 = if 준비.오프셋배치 && 인수순번 >= 0 {\n      let 줄수 = 스칼라정수(노드, \"endRow\") -\n        스칼라정수(준비.구조.노드들[인수순번], \"endRow\")\n      if 줄수 > 0 { 줄접두(줄수, 노드들여쓰기(준비, 순번)) } else { \"\" }\n    } else { \"\" }\n    return 인쇄조각결과합치기(준비, [인수, 인쇄글조각결과(준비, 뒤접두 + 연산)])\n  }\n  if 종류 == 310 {\n    return 하위식들조각인쇄(준비, 자식순번들(준비, 순번, \"expressions\"), 깊이, 2)\n  }\n  if 종류 == 303 || 종류 == 304 {\n    let 우선 = 우선순위(준비, 순번)\n    let 연산 = 스칼라문자(노드, \"operator\")\n    let 왼순번 = 자식순번(준비, 순번, \"left\")\n    let 오른순번 = 자식순번(준비, 순번, \"right\")\n    let 왼최소 = if 연산 == \"**\" { 16 } else { 우선 }\n    let 오른노드 = 준비.구조.노드들[오른순번]\n    let 오른최소 = if 연산 == \"**\" { 우선 }\n      else if 종류 == 304 &&\n        노드종류(준비.언어번호, 오른노드.코드워드) == 304 &&\n        스칼라문자(오른노드, \"operator\") == 연산 { 우선 }\n      else { 우선 + 1 }\n    // `??`와 `||`/`&&`가 섞이면 아래에서 괄호를 씌우므로\n    // 그 피연산자 안에서는 [+In]이 되살아난다.\n    if 종류 == 304 {\n      let 왼먼저 = 준비.구조.노드들[왼순번]\n      if 노드종류(준비.언어번호, 왼먼저.코드워드) == 304 &&\n        (연산 == \"??\") != (스칼라문자(왼먼저, \"operator\") == \"??\") &&\n        스칼라정수(왼먼저, \"spelling.parentheses\") == 0 {\n        인머리끄기(준비, 왼순번)\n      }\n      if 노드종류(준비.언어번호, 오른노드.코드워드) == 304 &&\n        (연산 == \"??\") != (스칼라문자(오른노드, \"operator\") == \"??\") &&\n        스칼라정수(오른노드, \"spelling.parentheses\") == 0 {\n        인머리끄기(준비, 오른순번)\n      }\n    }\n    let mut 왼 = match 하위식조각인쇄(준비, 왼순번, 깊이, 왼최소) {\n      case Ok(조각) => 조각\n      case Err(오류) => return Err(오류)\n    }\n    let mut 오른 = match 하위식조각인쇄(준비, 오른순번, 깊이, 오른최소) {\n      case Ok(조각) => 조각\n      case Err(오류) => return Err(오류)\n    }\n    if 종류 == 304 {\n      let 왼노드 = 준비.구조.노드들[왼순번]\n      if 노드종류(준비.언어번호, 왼노드.코드워드) == 304 &&\n        (연산 == \"??\") != (스칼라문자(왼노드, \"operator\") == \"??\") &&\n        스칼라정수(왼노드, \"spelling.parentheses\") == 0 {\n        match 순번인쇄조각(준비, 왼순번, 깊이) {\n          case Ok(조각) => {\n            왼 = 인쇄조각결과합치기(준비, [\n              인쇄글조각결과(준비, \"(\"), Ok(조각), 인쇄글조각결과(준비, \")\")\n            ])?\n          }\n          case Err(오류) => return Err(오류)\n        }\n      }\n      if 노드종류(준비.언어번호, 오른노드.코드워드) == 304 &&\n        (연산 == \"??\") != (스칼라문자(오른노드, \"operator\") == \"??\") &&\n        스칼라정수(오른노드, \"spelling.parentheses\") == 0 {\n        match 순번인쇄조각(준비, 오른순번, 깊이) {\n          case Ok(조각) => {\n            오른 = 인쇄조각결과합치기(준비, [\n              인쇄글조각결과(준비, \"(\"), Ok(조각), 인쇄글조각결과(준비, \")\")\n            ])?\n          }\n          case Err(오류) => return Err(오류)\n        }\n      }\n    }\n    let 연산접두 = \" \" + 연산 + 가장자리접두(준비, 오른순번, \" \")\n    return 인쇄조각결과합치기(준비, [\n      Ok(왼), 인쇄글조각결과(준비, 연산접두), Ok(오른)\n    ])\n  }\n  if 종류 == 305 {\n    let 왼순번 = 자식순번(준비, 순번, \"left\")\n    let 오른순번 = 자식순번(준비, 순번, \"right\")\n    return 인쇄조각결과합치기(준비, [\n      하위식조각인쇄(준비, 왼순번, 깊이, 3),\n      인쇄글조각결과(\n        준비,\n        \" \" + 스칼라문자(노드, \"operator\") + 가장자리접두(준비, 오른순번, \" \")\n      ),\n      하위식조각인쇄(준비, 오른순번, 깊이, 2)\n    ])\n  }\n  if 종류 == 306 {\n    let 왼순번 = 자식순번(준비, 순번, \"left\")\n    let 오른순번 = 자식순번(준비, 순번, \"right\")\n    return 인쇄조각결과합치기(준비, [\n      if 댓글고정있음(준비) { 댓글노드인쇄조각(준비, 왼순번, 깊이) }\n      else { 노드인쇄조각(준비, 왼순번, 깊이) },\n      인쇄글조각결과(준비, \" =\" + 가장자리접두(준비, 오른순번, \" \")),\n      하위식조각인쇄(준비, 오른순번, 깊이, 2)\n    ])\n  }\n  if 종류 == 307 {\n    let 시험순번 = 자식순번(준비, 순번, \"test\")\n    let 참순번 = 자식순번(준비, 순번, \"consequent\")\n    let 거짓순번 = 자식순번(준비, 순번, \"alternate\")\n    return 인쇄조각결과합치기(준비, [\n      하위식조각인쇄(준비, 시험순번, 깊이, 4),\n      인쇄글조각결과(준비, \" ?\" + 가장자리접두(준비, 참순번, \" \")),\n      하위식조각인쇄(준비, 참순번, 깊이, 2),\n      인쇄글조각결과(준비, \" :\" + 가장자리접두(준비, 거짓순번, \" \")),\n      하위식조각인쇄(준비, 거짓순번, 깊이, 2)\n    ])\n  }\n  if 종류 == 308 {\n    let 매개들 = 자식순번들(준비, 순번, \"params\")\n    let 형식매개 = 자식조각인쇄접두(준비, 순번, \"typeParameters\", 깊이, \"\")?\n    let mut 매개글 = 매개들조각인쇄(준비, 순번, 매개들, 깊이)?\n    let mut 괄호없음 = 준비.조각판.길이들[형식매개] == 0 && 매개들.length == 1 &&\n      노드종류(준비.언어번호, 준비.구조.노드들[매개들[0]].코드워드) == 106\n    if 괄호없음 && 준비.언어번호 == 2 {\n      let 매개 = 준비.구조.노드들[매개들[0]]\n      괄호없음 = !스칼라논리(매개, \"optional\") &&\n        자식순번들(준비, 매개들[0], \"decorators\").length == 0 &&\n        자식순번(준비, 매개들[0], \"typeAnnotation\") < 0\n    }\n    // The head's parentheses are not decided by a list of modifiers to\n    // exclude, they are decided by what the head EMITS before the parameter.\n    // The reference printer arms a no-line-terminator state with the only\n    // keyword an arrow head can carry, and then wraps any node printed in that\n    // state whose carried row is below the current row in a parenthesis\n    // indented one level (@babel/generator printer.js:409-412 and :441-447).\n    // So a head that emits nothing before its parameter prints bare, and a\n    // head that emits a keyword first keeps the parentheses exactly when the\n    // parameter's carried row is below the head's. Adding a further modifier\n    // to the head changes what it emits, and this expression reads that,\n    // rather than naming the modifier.\n    let 매개첫행 = if 매개들.length == 1 {\n      스칼라정수(준비.구조.노드들[매개들[0]], \"startRow\")\n    } else { 0 }\n    let 머리앞줄수 = if 괄호없음 && 매개들.length == 1 && 준비.오프셋배치 &&\n      스칼라논리(노드, \"async\") {\n      매개첫행 - 스칼라정수(노드, \"startRow\")\n    } else { 0 }\n    if 머리앞줄수 > 0 {\n      매개글 = 인쇄조각결과합치기(준비, [\n        인쇄글조각결과(\n          준비,\n          \"(\" + 줄접두(머리앞줄수, 노드들여쓰기(준비, 순번) + 2)\n        ),\n        순번인쇄조각(준비, 매개들[0], 깊이),\n        인쇄글조각결과(준비, \")\")\n      ])?\n    }\n    if !괄호없음 {\n      매개글 = 인쇄조각결과합치기(준비, [\n        인쇄글조각결과(준비, \"(\"), Ok(매개글), 인쇄글조각결과(준비, \")\")\n      ])?\n    }\n    let 반환 = 자식조각인쇄(준비, 순번, \"returnType\", 깊이)?\n    let 몸순번 = 자식순번(준비, 순번, \"body\")\n    let 몸종류 = 노드종류(준비.언어번호, 준비.구조.노드들[몸순번].코드워드)\n    let 몸 = if 몸종류 == 203 &&\n      스칼라정수(준비.구조.노드들[몸순번], \"spelling.parentheses\") == 0 {\n      인쇄조각결과합치기(준비, [\n        인쇄글조각결과(준비, \"(\"),\n        순번인쇄조각(준비, 몸순번, 깊이),\n        인쇄글조각결과(준비, \")\")\n      ])?\n    } else if 몸종류 == 203 { 순번인쇄조각(준비, 몸순번, 깊이)?\n    } else if 몸종류 == 410 { 순번인쇄조각(준비, 몸순번, 깊이)? }\n    else { 하위식조각인쇄(준비, 몸순번, 깊이, 2)? }\n    let 몸줄수 = 스칼라정수(준비.구조.노드들[몸순번], \"startRow\") -\n      직접앞끝행(준비, 순번, 몸순번)\n    // The reference printer resumes a carried row break at its own indentation\n    // level, which is the same level the block emitters use, so the arrow body\n    // is not a special case with a hard zero.\n    let 몸접두 = if 준비.오프셋배치 &&\n      스칼라정수(준비.구조.노드들[몸순번], \"spelling.parentheses\") == 0 &&\n      몸줄수 > 0 {\n      \" =>\" + 줄접두(몸줄수, 노드들여쓰기(준비, 몸순번))\n    } else { \" => \" }\n    return 인쇄조각결과합치기(준비, [\n      인쇄글조각결과(준비, if 스칼라논리(노드, \"async\") { \"async \" } else { \"\" }),\n      Ok(형식매개), Ok(매개글),\n      인쇄글조각결과(\n        준비,\n        if 준비.조각판.길이들[반환] > 0 { 매개뒤형식접두(준비, 순번, 매개들) } else { \"\" }\n      ),\n      Ok(반환), 인쇄글조각결과(준비, 몸접두), Ok(몸)\n    ])\n  }\n  Err(\"계산 노드 인쇄 규칙을 찾지 못했습니다: {종류}\")\n}\n\n// 지시 서두는 오로지 문자열 낱말로만 이루어진 식 문장이 잇달아 놓인\n// 첫 구간이다. 괄호를 두른 `('use strict');`은 낱말이 아니라 식이므로\n// 지시가 아니다. 명시 괄호는 `spelling.parentheses`로 되살리고, 그\n// 표지가 없는 문자열 식 문장이 서두 자리에 오면 안전 괄호를 씌운다.\n// 그러지 않으면 재해석이 지시로 읽어 감싸는 스크립트나 함수 본문을\n// 조용히 엄격 모드로 바꾼다.\nfunction 문자열식문장인가(준비: 준비된인쇄상태, 순번: int) -> bool {\n  if 노드종류(준비.언어번호, 준비.구조.노드들[순번].코드워드) != 401 { return false }\n  let mut 자식 = 준비.첫자식들[순번]\n  while 자식 >= 0 {\n    let 자식노드 = 준비.구조.노드들[자식]\n    if 자식노드.자식필드 == \"expression\" {\n      return 노드종류(준비.언어번호, 자식노드.코드워드) == 108 &&\n        스칼라정수(자식노드, \"spelling.parentheses\") == 0\n    }\n    자식 = 준비.다음형제들[자식]\n  }\n  false\n}\n\nfunction 지시서두자리인가(준비: 준비된인쇄상태, 순번: int) -> bool {\n  let 노드 = 준비.구조.노드들[순번]\n  if 노드.부모순번 < 0 || 노드.자식필드 != \"body\" { return false }\n  let 부모종류 = 노드종류(준비.언어번호, 준비.구조.노드들[노드.부모순번].코드워드)\n  if 부모종류 != 102 && 부모종류 != 410 { return false }\n  let mut 자식 = 준비.첫자식들[노드.부모순번]\n  while 자식 >= 0 && 자식 != 순번 {\n    if 준비.구조.노드들[자식].자식필드 == \"body\" &&\n      !문자열식문장인가(준비, 자식) { return false }\n    자식 = 준비.다음형제들[자식]\n  }\n  true\n}\n\nfunction 간단문장조각인쇄(준비: 준비된인쇄상태, 순번: int, 깊이: int) -> Result<int, string> {\n  let 노드 = 준비.구조.노드들[순번]\n  let 종류 = 노드종류(준비.언어번호, 노드.코드워드)\n  if 종류 == 401 {\n    let 식순번 = 자식순번(준비, 순번, \"expression\")\n    if 식순번 >= 0 &&\n      노드종류(준비.언어번호, 준비.구조.노드들[식순번].코드워드) == 108 &&\n      스칼라정수(준비.구조.노드들[식순번], \"spelling.parentheses\") == 0 &&\n      지시서두자리인가(준비, 순번) {\n      return 인쇄조각결과합치기(준비, [\n        인쇄글조각결과(준비, \"(\"),\n        순번인쇄조각(준비, 식순번, 깊이),\n        인쇄글조각결과(준비, \");\")\n      ])\n    }\n    let mut 머리순번 = 식순번\n    let mut 모호한머리 = false\n    while 머리순번 >= 0 && !모호한머리 {\n      let 머리종류 = 노드종류(준비.언어번호, 준비.구조.노드들[머리순번].코드워드)\n      if 머리종류 == 203 || 머리종류 == 204 || 머리종류 == 118 || 머리종류 == 602 {\n        모호한머리 = true\n      }\n      else if 머리종류 == 310 { 머리순번 = 자식순번(준비, 머리순번, \"expressions\") }\n      else if 머리종류 == 305 {\n        let 왼순번 = 자식순번(준비, 머리순번, \"left\")\n        if 왼순번 >= 0 &&\n          노드종류(준비.언어번호, 준비.구조.노드들[왼순번].코드워드) == 204 {\n          모호한머리 = true\n        } else {\n          머리순번 = 왼순번\n        }\n      }\n      else {\n        let 필드 = if 머리종류 == 208 || 머리종류 == 209 { \"object\" }\n          else if 머리종류 == 210 || 머리종류 == 211 { \"callee\" }\n          else if 머리종류 == 213 { \"tag\" }\n          else if 머리종류 == 303 || 머리종류 == 304 { \"left\" }\n          else if 머리종류 == 307 { \"test\" }\n          else if 머리종류 >= 724 && 머리종류 <= 727 { \"expression\" }\n          else { \"\" }\n        머리순번 = if 필드 == \"\" { -1 } else { 자식순번(준비, 머리순번, 필드) }\n      }\n    }\n    let 식 = 순번인쇄조각(준비, 식순번, 깊이)?\n    if !모호한머리 ||\n      스칼라정수(준비.구조.노드들[식순번], \"spelling.parentheses\") > 0 ||\n      스칼라정수(준비.구조.노드들[머리순번], \"spelling.parentheses\") > 0 {\n      return 인쇄조각결과합치기(준비, [Ok(식), 인쇄글조각결과(준비, \";\")])\n    }\n    let 머리 = 순번인쇄조각(준비, 머리순번, 깊이)?\n    if 준비.조각판.길이들[머리] > 준비.조각판.길이들[식] {\n      return Err(\"모호한 식 문장의 머리가 전체 식보다 깁니다\")\n    }\n    let 식머리 = 인쇄조각자름(준비.조각판, 식, 0, 준비.조각판.길이들[머리])?\n    if !인쇄조각같음(준비.조각판, 머리, 식머리)? {\n      return Err(\"모호한 식 문장의 머리가 전체 식의 접두사가 아닙니다\")\n    }\n    let 나머지 = 인쇄조각자름(\n      준비.조각판, 식, 준비.조각판.길이들[머리], 준비.조각판.길이들[식]\n    )?\n    return 인쇄조각결과합치기(준비, [\n      인쇄글조각결과(준비, \"(\"), Ok(머리), 인쇄글조각결과(준비, \")\"),\n      Ok(나머지), 인쇄글조각결과(준비, \";\")\n    ])\n  }\n  if 종류 == 402 {\n    let 값 = 자식조각인쇄(준비, 순번, \"argument\", 깊이)?\n    if 준비.조각판.길이들[값] == 0 { return 인쇄글조각결과(준비, \"return;\") }\n    return 인쇄조각결과합치기(준비, [\n      인쇄글조각결과(준비, \"return \"), Ok(값), 인쇄글조각결과(준비, \";\")\n    ])\n  }\n  if 종류 == 403 {\n    return 인쇄조각결과합치기(준비, [\n      인쇄글조각결과(준비, \"throw \"),\n      자식조각인쇄(준비, 순번, \"argument\", 깊이),\n      인쇄글조각결과(준비, \";\")\n    ])\n  }\n  if 종류 == 404 || 종류 == 405 {\n    let 말 = if 종류 == 404 { \"break\" } else { \"continue\" }\n    let 이름 = 자식조각인쇄(준비, 순번, \"label\", 깊이)?\n    return 인쇄조각결과합치기(준비, [\n      인쇄글조각결과(준비, 말),\n      인쇄글조각결과(준비, if 준비.조각판.길이들[이름] == 0 { \"\" } else { \" \" }),\n      Ok(이름), 인쇄글조각결과(준비, \";\")\n    ])\n  }\n  if 종류 == 406 { return 인쇄글조각결과(준비, \";\") }\n  if 종류 == 407 {\n    return 인쇄조각결과합치기(준비, [\n      자식조각인쇄(준비, 순번, \"label\", 깊이),\n      인쇄글조각결과(\n        준비,\n        \":\" + 가장자리접두(준비, 자식순번(준비, 순번, \"body\"), \" \")\n      ),\n      자식조각인쇄(준비, 순번, \"body\", 깊이)\n    ])\n  }\n  if 종류 == 408 {\n    let 식별자순번 = 자식순번(준비, 순번, \"id\")\n    let 글 = 자식조각인쇄(준비, 순번, \"id\", 깊이)?\n    let 초기 = 자식순번(준비, 순번, \"init\")\n    let 값 = if 초기 < 0 { 0 } else { 하위식조각인쇄(준비, 초기, 깊이, 2)? }\n    if 값 == 0 { return Ok(글) }\n    let 초기접두 = if 준비.오프셋배치 && 식별자순번 >= 0 &&\n      스칼라정수(준비.구조.노드들[초기], \"spelling.parentheses\") == 0 {\n      let 초기시작행 = if 화살표머리첫잎이매개인가(준비, 초기) {\n        let 매개들 = 자식순번들(준비, 초기, \"params\")\n        스칼라정수(준비.구조.노드들[매개들[0]], \"startRow\")\n      } else { 스칼라정수(준비.구조.노드들[초기], \"startRow\") }\n      let 줄수 = 초기시작행 -\n        스칼라정수(준비.구조.노드들[식별자순번], \"endRow\")\n      // The arrow head emits this row itself only when it keeps a\n      // parenthesis for the carried row - the async bare head - so the\n      // declarator still owns the edge for every other bare head.\n      if 줄수 > 0 && 화살표머리첫잎이매개인가(준비, 초기) &&\n        스칼라논리(준비.구조.노드들[초기], \"async\") { \"\" }\n      else if 줄수 > 0 { 줄접두(줄수, 노드들여쓰기(준비, 초기)) }\n      else { \" \" }\n    } else { \" \" }\n    return 인쇄조각결과합치기(준비, [\n      Ok(글), 인쇄글조각결과(준비, \" =\" + 초기접두), Ok(값)\n    ])\n  }\n  if 종류 == 409 {\n    let 선언들 = 자식순번들(준비, 순번, \"declarations\")\n    let mut 초기있음 = false\n    for 선언순번 in 선언들 {\n      if 자식순번(준비, 선언순번, \"init\") >= 0 { 초기있음 = true }\n    }\n    let 부모종류 = if 노드.부모순번 < 0 { 0 }\n      else { 노드종류(준비.언어번호, 준비.구조.노드들[노드.부모순번].코드워드) }\n    let 여러줄 = 선언들.length > 1 && !준비.오프셋배치 &&\n      초기있음 && (부모종류 < 505 || 부모종류 > 507)\n    let mut 선언 = 0\n    let mut 선언색인 = 0\n    while 선언색인 < 선언들.length {\n      if 선언색인 > 0 {\n        let 이전 = 준비.구조.노드들[선언들[선언색인 - 1]]\n        let 현재 = 준비.구조.노드들[선언들[선언색인]]\n        let 줄수 = 스칼라정수(현재, \"startRow\") - 스칼라정수(이전, \"endRow\")\n        let 사이 = if 준비.오프셋배치 && 줄수 > 0 {\n          \",\" + 줄접두(\n            줄수,\n            스칼라정수(현재, \"startColumn\")\n          )\n        } else if 여러줄 {\n          \",\" + 줄접두(1, (깊이 + 1) * 2)\n        } else { \", \" }\n        선언 = 인쇄조각이음(준비.조각판, 선언, 인쇄글조각(준비.조각판, 사이))\n      }\n      선언 = 인쇄조각이음(\n        준비.조각판, 선언, 순번인쇄조각(준비, 선언들[선언색인], 깊이)?\n      )\n      선언색인 = 선언색인 + 1\n    }\n    return 인쇄조각결과합치기(준비, [\n      인쇄글조각결과(\n        준비,\n        (if 스칼라논리(노드, \"declare\") { \"declare \" } else { \"\" }) +\n          스칼라문자(노드, \"kind\") +\n          (if 선언들.length == 0 { \" \" }\n            else { 가장자리접두(준비, 선언들[0], \" \") })\n      ),\n      Ok(선언), 인쇄글조각결과(준비, \";\")\n    ])\n  }\n  if 종류 == 410 { return 문장블록조각인쇄(준비, 순번, 깊이, \"\") }\n  if 종류 == 411 {\n    let 몸순번 = 자식순번(준비, 순번, \"body\")\n    return 인쇄조각결과합치기(준비, [\n      함수머리조각인쇄(준비, 순번, 깊이, true),\n      인쇄글조각결과(준비, 함수몸접두(준비, 순번, 몸순번)),\n      자식조각인쇄(준비, 순번, \"body\", 깊이)\n    ])\n  }\n  Err(\"간단 문장 인쇄 규칙을 찾지 못했습니다: {종류}\")\n}\n\nfunction 제어문장조각인쇄(준비: 준비된인쇄상태, 순번: int, 깊이: int) -> Result<int, string> {\n  let 노드 = 준비.구조.노드들[순번]\n  let 종류 = 노드종류(준비.언어번호, 노드.코드워드)\n  if 종류 == 501 {\n    let 조건순번 = 자식순번(준비, 순번, \"test\")\n    let 조건 = 자식조각인쇄(준비, 순번, \"test\", 깊이)?\n    let 결과순번 = 자식순번(준비, 순번, \"consequent\")\n    let 결과인쇄 = if 댓글고정있음(준비) {\n      댓글노드인쇄조각(준비, 결과순번, 깊이)\n    } else { 노드인쇄조각(준비, 결과순번, 깊이) }\n    let 결과 = 결과인쇄?\n    let 결과접두 = 절접두(\n      준비, 순번,\n      if 조건순번 < 0 { -1 } else { 준비.구조.노드들[조건순번].끝 },\n      결과순번, 1, 1, \" \"\n    )\n    let mut 합 = 인쇄조각결과합치기(준비, [\n      인쇄글조각결과(준비, \"if (\" + 가장자리접두(준비, 조건순번, \"\")), Ok(조건),\n      인쇄글조각결과(준비, \")\" + 결과접두), Ok(결과)\n    ])?\n    let 아니면순번 = 자식순번(준비, 순번, \"alternate\")\n    if 아니면순번 >= 0 {\n      let 아니면인쇄 = if 댓글고정있음(준비) {\n        댓글노드인쇄조각(준비, 아니면순번, 깊이)\n      } else { 노드인쇄조각(준비, 아니면순번, 깊이) }\n      let 아니면 = 아니면인쇄?\n      let 아니면접두 = 절접두(\n        준비, 순번,\n        if 결과순번 < 0 { -1 } else { 준비.구조.노드들[결과순번].끝 },\n        아니면순번, 4, 2, \" \"\n      )\n      합 = 인쇄조각결과합치기(준비, [\n        Ok(합),\n        인쇄글조각결과(\n          준비,\n          (if 인쇄조각접미(준비.조각판, 결과, \"\\}\")? { \" else\" } else { \"else\" }) +\n            아니면접두\n        ),\n        Ok(아니면)\n      ])?\n    }\n    return Ok(합)\n  }\n  if 종류 == 502 || 종류 == 504 {\n    let 몸 = 자식조각인쇄(준비, 순번, \"body\", 깊이)?\n    let 필드 = if 종류 == 502 { \"test\" } else { \"object\" }\n    let 말 = if 종류 == 502 { \"while\" } else { \"with\" }\n    let 세미 = 인쇄글조각(준비.조각판, \";\")\n    return 인쇄조각결과합치기(준비, [\n      인쇄글조각결과(\n        준비,\n        말 + \" (\" + 가장자리접두(준비, 자식순번(준비, 순번, 필드), \"\")\n      ),\n      자식조각인쇄(준비, 순번, 필드, 깊이),\n      인쇄글조각결과(\n        준비,\n        \")\" + 가장자리접두(\n          준비,\n          자식순번(준비, 순번, \"body\"),\n          if 인쇄조각같음(준비.조각판, 몸, 세미)? { \"\" } else { \" \" }\n        )\n      ),\n      Ok(몸)\n    ])\n  }\n  if 종류 == 503 {\n    let 몸순번 = 자식순번(준비, 순번, \"body\")\n    let 시험순번 = 자식순번(준비, 순번, \"test\")\n    let 몸접두 = 절접두(준비, 순번, 노드.시작 + 2, 몸순번, 0, 1, \" \")\n    // 바벨은 `while (`를 찍은 뒤에 시험 노드를 찍으면서 행을 따라잡으므로\n    // 끊김 자리는 여는 괄호 다음이고, 한 행 표기에는 빈칸이 없다.\n    let 시험접두 = 절접두(\n      준비, 순번,\n      if 몸순번 < 0 { -1 } else { 준비.구조.노드들[몸순번].끝 },\n      시험순번, 7, 1, \"\"\n    )\n    return 인쇄조각결과합치기(준비, [\n      인쇄글조각결과(준비, \"do\" + 몸접두),\n      자식조각인쇄(준비, 순번, \"body\", 깊이),\n      인쇄글조각결과(준비, \" while (\" + 시험접두),\n      자식조각인쇄(준비, 순번, \"test\", 깊이),\n      인쇄글조각결과(준비, \");\")\n    ])\n  }\n  if 종류 >= 505 && 종류 <= 507 {\n    let 몸 = 자식조각인쇄(준비, 순번, \"body\", 깊이)?\n    let 세미 = 인쇄글조각(준비.조각판, \";\")\n    let 몸사이 = if 인쇄조각같음(준비.조각판, 몸, 세미)? { \"\" } else { \" \" }\n    if 종류 == 505 {\n      인머리켜기(준비, 자식순번(준비, 순번, \"init\"))\n      let 초기순번 = 자식순번(준비, 순번, \"init\")\n      let 시험순번 = 자식순번(준비, 순번, \"test\")\n      let 갱신순번 = 자식순번(준비, 순번, \"update\")\n      let 몸순번 = 자식순번(준비, 순번, \"body\")\n      let mut 초기 = 자식조각인쇄(준비, 순번, \"init\", 깊이)?\n      if 인쇄조각접미(준비.조각판, 초기, \";\")? {\n        초기 = 인쇄조각자름(준비.조각판, 초기, 0, 준비.조각판.길이들[초기] - 1)?\n      }\n      let 시험 = 자식조각인쇄(준비, 순번, \"test\", 깊이)?\n      let 갱신 = 자식조각인쇄(준비, 순번, \"update\", 깊이)?\n      let 머리공백 = 노드들여쓰기(준비, 순번)\n      let 초기접두 = if 준비.오프셋배치 && 초기순번 >= 0 {\n        let 줄수 = 스칼라정수(준비.구조.노드들[초기순번], \"startRow\") -\n          스칼라정수(노드, \"startRow\")\n        if 줄수 > 0 { 줄접두(줄수, 머리공백) } else { \"\" }\n      } else { \"\" }\n      let 시험접두 = if 준비.오프셋배치 && 시험순번 >= 0 {\n        let 이전행 = if 초기순번 >= 0 {\n          스칼라정수(준비.구조.노드들[초기순번], \"endRow\")\n        } else { 스칼라정수(노드, \"startRow\") }\n        let 줄수 = 스칼라정수(준비.구조.노드들[시험순번], \"startRow\") - 이전행\n        if 줄수 > 0 { 줄접두(줄수, 머리공백) } else { \" \" }\n      } else if 준비.조각판.길이들[시험] == 0 { \"\" } else { \" \" }\n      let 갱신접두 = if 준비.오프셋배치 && 갱신순번 >= 0 {\n        let 이전행 = if 시험순번 >= 0 {\n          스칼라정수(준비.구조.노드들[시험순번], \"endRow\")\n        } else if 초기순번 >= 0 {\n          스칼라정수(준비.구조.노드들[초기순번], \"endRow\")\n        } else { 스칼라정수(노드, \"startRow\") }\n        let 줄수 = 스칼라정수(준비.구조.노드들[갱신순번], \"startRow\") - 이전행\n        if 줄수 > 0 { 줄접두(줄수, 머리공백) } else { \" \" }\n      } else if 준비.조각판.길이들[갱신] == 0 { \"\" } else { \" \" }\n      let 마지막행 = if 갱신순번 >= 0 {\n        스칼라정수(준비.구조.노드들[갱신순번], \"endRow\")\n      } else if 시험순번 >= 0 {\n        스칼라정수(준비.구조.노드들[시험순번], \"endRow\")\n      } else if 초기순번 >= 0 {\n        스칼라정수(준비.구조.노드들[초기순번], \"endRow\")\n      } else { 스칼라정수(노드, \"startRow\") }\n      let 몸접두 = if 준비.오프셋배치 && 몸순번 >= 0 {\n        let 줄수 = 스칼라정수(준비.구조.노드들[몸순번], \"startRow\") - 마지막행\n        if 줄수 > 0 { 줄접두(줄수, 머리공백) } else { 몸사이 }\n      } else { 몸사이 }\n      return 인쇄조각결과합치기(준비, [\n        인쇄글조각결과(준비, \"for (\" + 초기접두), Ok(초기),\n        인쇄글조각결과(준비, \";\" + 시험접두),\n        Ok(시험),\n        인쇄글조각결과(준비, \";\" + 갱신접두),\n        Ok(갱신), 인쇄글조각결과(준비, \")\" + 몸접두), Ok(몸)\n      ])\n    }\n    if 종류 == 506 { 인머리켜기(준비, 자식순번(준비, 순번, \"left\")) }\n    let mut 왼 = 자식조각인쇄(준비, 순번, \"left\", 깊이)?\n    if 인쇄조각접미(준비.조각판, 왼, \";\")? {\n      왼 = 인쇄조각자름(준비.조각판, 왼, 0, 준비.조각판.길이들[왼] - 1)?\n    }\n    let 잇기 = (if 종류 == 506 { \" in\" } else { \" of\" }) +\n      가장자리접두(준비, 자식순번(준비, 순번, \"right\"), \" \")\n    return 인쇄조각결과합치기(준비, [\n      인쇄글조각결과(\n        준비,\n        \"for \" +\n          (if 종류 == 507 && 스칼라논리(노드, \"await\") { \"await \" } else { \"\" }) +\n          \"(\" + 가장자리접두(준비, 자식순번(준비, 순번, \"left\"), \"\")\n      ),\n      Ok(왼), 인쇄글조각결과(준비, 잇기),\n      자식조각인쇄(준비, 순번, \"right\", 깊이),\n      인쇄글조각결과(\n        준비,\n        \")\" + 가장자리접두(준비, 자식순번(준비, 순번, \"body\"), 몸사이)\n      ),\n      Ok(몸)\n    ])\n  }\n  if 종류 == 508 {\n    let 블록순번 = 자식순번(준비, 순번, \"block\")\n    let 잡기순번 = 자식순번(준비, 순번, \"handler\")\n    let 마침순번 = 자식순번(준비, 순번, \"finalizer\")\n    let 블록 = 자식조각인쇄(준비, 순번, \"block\", 깊이)?\n    let 잡기 = 자식조각인쇄(준비, 순번, \"handler\", 깊이)?\n    let 마침 = 자식조각인쇄(준비, 순번, \"finalizer\", 깊이)?\n    let 블록끝 = if 블록순번 < 0 { -1 } else { 준비.구조.노드들[블록순번].끝 }\n    let 마침이전끝 = if 잡기순번 >= 0 { 준비.구조.노드들[잡기순번].끝 } else { 블록끝 }\n    return 인쇄조각결과합치기(준비, [\n      인쇄글조각결과(\n        준비,\n        \"try\" + 절접두(준비, 순번, 노드.시작 + 3, 블록순번, 0, 1, \" \")\n      ), Ok(블록),\n      인쇄글조각결과(\n        준비,\n        if 준비.조각판.길이들[잡기] == 0 { \"\" }\n        else { 절접두(준비, 순번, 블록끝, 잡기순번, 0, 1, \" \") }\n      ),\n      Ok(잡기),\n      인쇄글조각결과(\n        준비,\n        if 준비.조각판.길이들[마침] == 0 { \"\" }\n        else { \" finally\" + 절접두(준비, 순번, 마침이전끝, 마침순번, 7, 2, \" \") }\n      ),\n      Ok(마침)\n    ])\n  }\n  if 종류 == 509 {\n    let 매개 = 자식조각인쇄(준비, 순번, \"param\", 깊이)?\n    return 인쇄조각결과합치기(준비, [\n      인쇄글조각결과(\n        준비,\n        if 준비.조각판.길이들[매개] == 0 { \"catch \" }\n        else {\n          \"catch (\" + 가장자리접두(준비, 자식순번(준비, 순번, \"param\"), \"\")\n        }\n      ),\n      Ok(매개),\n      인쇄글조각결과(\n        준비,\n        (if 준비.조각판.길이들[매개] == 0 { \"\" } else { \")\" }) +\n          가장자리접두(\n            준비,\n            자식순번(준비, 순번, \"body\"),\n            if 준비.조각판.길이들[매개] == 0 { \"\" } else { \" \" }\n          )\n      ),\n      자식조각인쇄(준비, 순번, \"body\", 깊이)\n    ])\n  }\n  if 종류 == 510 {\n    let 경우들 = 자식순번들(준비, 순번, \"cases\")\n    let 판별순번 = 자식순번(준비, 순번, \"discriminant\")\n    let mut 이전행 = if 판별순번 < 0 {\n      스칼라정수(노드, \"startRow\")\n    } else { 스칼라정수(준비.구조.노드들[판별순번], \"endRow\") }\n    let mut 합 = 인쇄조각결과합치기(준비, [\n      인쇄글조각결과(준비, \"switch (\" + 가장자리접두(준비, 판별순번, \"\")),\n      자식조각인쇄(준비, 순번, \"discriminant\", 깊이),\n      인쇄글조각결과(준비, \") \\{\")\n    ])?\n    if 경우들.length == 0 {\n      return 인쇄조각결과합치기(준비, [Ok(합), 인쇄글조각결과(준비, \"\\}\")])\n    }\n    for 경우 in 경우들 {\n      let 경우인쇄 = if 댓글고정있음(준비) {\n        댓글노드인쇄조각(준비, 경우, 깊이 + 1)\n      } else { 노드인쇄조각(준비, 경우, 깊이 + 1) }\n      합 = 인쇄조각결과합치기(준비, [\n        Ok(합),\n        인쇄글조각결과(\n          준비,\n          if 준비.오프셋배치 {\n            let 경우노드 = 준비.구조.노드들[경우]\n            let 줄수 = 스칼라정수(경우노드, \"startRow\") - 이전행\n            if 줄수 > 0 {\n              줄접두(줄수, 노드들여쓰기(준비, 경우))\n            } else { \"\" }\n          }\n          else { \"\\n\" + 들여쓰기(깊이 + 1) }\n        ),\n        경우인쇄\n      ])?\n      이전행 = 스칼라정수(준비.구조.노드들[경우], \"endRow\")\n    }\n    let 닫기접두 = if 준비.오프셋배치 {\n      let 줄수 = 스칼라정수(노드, \"endRow\") - 이전행\n      if 줄수 > 0 {\n        줄접두(줄수, 노드들여쓰기(준비, 순번))\n      } else { \"\" }\n    } else { \"\\n\" + 들여쓰기(깊이) }\n    return 인쇄조각결과합치기(준비, [\n      Ok(합),\n      인쇄글조각결과(준비, 닫기접두 + \"\\}\")\n    ])\n  }\n  if 종류 == 511 {\n    let 시험 = 자식조각인쇄(준비, 순번, \"test\", 깊이)?\n    let 머리 = if 준비.조각판.길이들[시험] == 0 {\n      인쇄글조각(준비.조각판, \"default:\")\n    } else {\n      인쇄조각결과합치기(준비, [\n        인쇄글조각결과(\n          준비,\n          \"case\" + 가장자리접두(준비, 자식순번(준비, 순번, \"test\"), \" \")\n        ),\n        Ok(시험), 인쇄글조각결과(준비, \":\")\n      ])?\n    }\n    let 결과들 = 자식순번들(준비, 순번, \"consequent\")\n    if 결과들.length == 0 { return Ok(머리) }\n    if 준비.오프셋배치 {\n      return 인쇄조각결과합치기(준비, [\n        Ok(머리), 문장목록조각인쇄(준비, 결과들, 깊이 + 1)\n      ])\n    }\n    return 인쇄조각결과합치기(준비, [\n      Ok(머리), 인쇄글조각결과(준비, \"\\n\"),\n      문장목록조각인쇄(준비, 결과들, 깊이 + 1)\n    ])\n  }\n  Err(\"제어 문장 인쇄 규칙을 찾지 못했습니다: {종류}\")\n}\n\nfunction 클래스문장조각인쇄(준비: 준비된인쇄상태, 순번: int, 깊이: int) -> Result<int, string> {\n  let 노드 = 준비.구조.노드들[순번]\n  let 종류 = 노드종류(준비.언어번호, 노드.코드워드)\n  if 종류 == 601 || 종류 == 602 {\n    let mut 머리 = \"\"\n    if 스칼라논리(노드, \"declare\") { 머리 = 머리 + \"declare \" }\n    if 스칼라논리(노드, \"abstract\") { 머리 = 머리 + \"abstract \" }\n    let mut 합 = 인쇄글조각(준비.조각판, 머리 + \"class\")\n    let 이름순번 = 자식순번(준비, 순번, \"id\")\n    let 이름 = 자식조각인쇄(준비, 순번, \"id\", 깊이)?\n    if 준비.조각판.길이들[이름] > 0 {\n      let 이름접두 = 가장자리접두(준비, 이름순번, \" \")\n      합 = 인쇄조각결과합치기(준비, [\n        Ok(합), 인쇄글조각결과(준비, 이름접두), Ok(이름)\n      ])?\n    }\n    합 = 인쇄조각이음(\n      준비.조각판, 합, 자식조각인쇄접두(준비, 순번, \"typeParameters\", 깊이, \"\")?\n    )\n    let 상위순번 = 자식순번(준비, 순번, \"superClass\")\n    if 상위순번 >= 0 {\n      합 = 인쇄조각결과합치기(준비, [\n        Ok(합),\n        인쇄글조각결과(준비, \" extends\" + 가장자리접두(준비, 상위순번, \" \")),\n        하위식조각인쇄(준비, 상위순번, 깊이, 17),\n        자식조각인쇄접두(준비, 순번, \"superTypeParameters\", 깊이, \"\")\n      ])?\n    }\n    let 구현들 = 자식순번들(준비, 순번, \"implements\")\n    if 구현들.length > 0 {\n      합 = 인쇄조각결과합치기(준비, [\n        Ok(합),\n        인쇄글조각결과(준비, \" implements\" + 가장자리접두(준비, 구현들[0], \" \")),\n        들사이조각인쇄(준비, 구현들, 깊이, \", \")\n      ])?\n    }\n    return 인쇄조각결과합치기(준비, [\n      Ok(합), 자식조각인쇄접두(준비, 순번, \"body\", 깊이, \" \")\n    ])\n  }\n  if 종류 == 603 { return 문장블록조각인쇄(준비, 순번, 깊이, \"\") }\n  if 종류 == 609 { return 문장블록조각인쇄(준비, 순번, 깊이, \"static \") }\n  if 종류 == 604 || 종류 == 605 || 종류 == 606 {\n    return 메서드조각인쇄(준비, 순번, 깊이)\n  }\n  if 종류 == 607 || 종류 == 608 || 종류 == 610 {\n    let mut 머리 = \"\"\n    if 스칼라논리(노드, \"declare\") { 머리 = 머리 + \"declare \" }\n    let 접근 = 스칼라문자(노드, \"accessibility\")\n    if 접근 != \"\" { 머리 = 머리 + 접근 + \" \" }\n    if 스칼라논리(노드, \"abstract\") { 머리 = 머리 + \"abstract \" }\n    if 스칼라논리(노드, \"static\") { 머리 = 머리 + \"static \" }\n    if 스칼라논리(노드, \"override\") { 머리 = 머리 + \"override \" }\n    if 스칼라논리(노드, \"readonly\") { 머리 = 머리 + \"readonly \" }\n    if 종류 == 610 { 머리 = 머리 + \"accessor \" }\n    let mut 합 = 인쇄글조각(준비.조각판, 머리)\n    let 계산 = 스칼라논리(노드, \"computed\")\n    let 키순번 = 자식순번(준비, 순번, \"key\")\n    let 키결과 = if 계산 && 키순번 >= 0 {\n      하위식조각인쇄(준비, 키순번, 깊이, 2)\n    } else { 자식조각인쇄(준비, 순번, \"key\", 깊이) }\n    let 키 = 키결과?\n    if 계산 {\n      합 = 인쇄조각결과합치기(준비, [\n        Ok(합), 인쇄글조각결과(준비, \"[\"), Ok(키), 인쇄글조각결과(준비, \"]\")\n      ])?\n    } else { 합 = 인쇄조각이음(준비.조각판, 합, 키) }\n    if 스칼라논리(노드, \"optional\") {\n      합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, \"?\"))\n    }\n    if 스칼라논리(노드, \"definite\") {\n      합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, \"!\"))\n    }\n    합 = 인쇄조각이음(\n      준비.조각판, 합, 자식조각인쇄접두(준비, 순번, \"typeAnnotation\", 깊이, \"\")?\n    )\n    let 값순번 = 자식순번(준비, 순번, \"value\")\n    if 값순번 >= 0 {\n      합 = 인쇄조각결과합치기(준비, [\n        Ok(합), 인쇄글조각결과(준비, \" =\" + 가장자리접두(준비, 값순번, \" \")),\n        하위식조각인쇄(준비, 값순번, 깊이, 2)\n      ])?\n    }\n    return 인쇄조각결과합치기(준비, [Ok(합), 인쇄글조각결과(준비, \";\")])\n  }\n  Err(\"클래스 문장 인쇄 규칙을 찾지 못했습니다: {종류}\")\n}\n\nfunction 형식노드조각인쇄(준비: 준비된인쇄상태, 순번: int, 깊이: int) -> Result<int, string> {\n  let 노드 = 준비.구조.노드들[순번]\n  let 종류 = 노드종류(준비.언어번호, 노드.코드워드)\n  if 종류 == 701 {\n    return 인쇄조각결과합치기(준비, [\n      인쇄글조각결과(\n        준비,\n        \":\" + 가장자리접두(준비, 자식순번(준비, 순번, \"typeAnnotation\"), \" \")\n      ),\n      자식조각인쇄(준비, 순번, \"typeAnnotation\", 깊이)\n    ])\n  }\n  if 종류 == 702 { return 인쇄글조각결과(준비, \"any\") }\n  if 종류 == 703 { return 인쇄글조각결과(준비, \"string\") }\n  if 종류 == 704 { return 인쇄글조각결과(준비, \"number\") }\n  if 종류 == 705 { return 인쇄글조각결과(준비, \"unknown\") }\n  if 종류 == 706 { return 인쇄글조각결과(준비, \"void\") }\n  if 종류 == 707 { return 인쇄글조각결과(준비, \"object\") }\n  if 종류 == 708 { return 인쇄글조각결과(준비, \"this\") }\n  if 종류 == 709 { return 자식조각인쇄(준비, 순번, \"literal\", 깊이) }\n  if 종류 == 710 {\n    return 인쇄조각결과합치기(준비, [\n      자식조각인쇄(준비, 순번, \"typeName\", 깊이),\n      자식조각인쇄접두(준비, 순번, \"typeParameters\", 깊이, \"\")\n    ])\n  }\n  if 종류 == 711 {\n    return 인쇄조각결과합치기(준비, [\n      자식조각인쇄(준비, 순번, \"left\", 깊이),\n      인쇄글조각결과(준비, \".\"),\n      자식조각인쇄(준비, 순번, \"right\", 깊이)\n    ])\n  }\n  if 종류 == 712 || 종류 == 713 {\n    return 인쇄조각결과합치기(준비, [\n      인쇄글조각결과(준비, \"<\"),\n      형식목록조각인쇄(준비, 순번, 자식순번들(준비, 순번, \"params\"), 깊이),\n      인쇄글조각결과(준비, \">\")\n    ])\n  }\n  if 종류 == 714 {\n    let mut 합 = 인쇄글조각(\n      준비.조각판,\n      (if 스칼라논리(노드, \"const\") { \"const \" } else { \"\" }) +\n        (if 스칼라논리(노드, \"in\") { \"in \" } else { \"\" }) +\n        (if 스칼라논리(노드, \"out\") { \"out \" } else { \"\" }) +\n        (if 노드.식별자있음 {\n          식별자이름(준비, 순번)?\n        } else { 스칼라문자(노드, \"name\") })\n    )\n    let 제한 = 자식조각인쇄접두(준비, 순번, \"constraint\", 깊이, \" \")?\n    if 준비.조각판.길이들[제한] > 0 {\n      합 = 인쇄조각결과합치기(준비, [\n        Ok(합), 인쇄글조각결과(준비, \" extends\"), Ok(제한)\n      ])?\n    }\n    let 기본 = 자식조각인쇄접두(준비, 순번, \"default\", 깊이, \" \")?\n    if 준비.조각판.길이들[기본] > 0 {\n      합 = 인쇄조각결과합치기(준비, [\n        Ok(합), 인쇄글조각결과(준비, \" =\"), Ok(기본)\n      ])?\n    }\n    return Ok(합)\n  }\n  if 종류 == 715 {\n    let 형식들 = 자식순번들(준비, 순번, \"types\")\n    let mut 합 = 0\n    let mut 색인 = 0\n    while 색인 < 형식들.length {\n      if 색인 > 0 {\n        let 이전 = 준비.구조.노드들[형식들[색인 - 1]]\n        let 현재 = 준비.구조.노드들[형식들[색인]]\n        let 줄수 = 스칼라정수(현재, \"startRow\") - 스칼라정수(이전, \"endRow\")\n        let 사이 = if 준비.오프셋배치 && 줄수 > 0 {\n          \" |\" + 줄접두(줄수, 깊이 * 2)\n        } else { \" | \" }\n        합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, 사이))\n      }\n      합 = 인쇄조각이음(\n        준비.조각판,\n        합,\n        순번인쇄조각(준비, 형식들[색인], 깊이)?\n      )\n      색인 = 색인 + 1\n    }\n    return Ok(합)\n  }\n  if 종류 == 716 {\n    let 요소순번 = 자식순번(준비, 순번, \"elementType\")\n    let 요소종류 = 노드종류(준비.언어번호, 준비.구조.노드들[요소순번].코드워드)\n    let mut 요소 = 자식조각인쇄(준비, 순번, \"elementType\", 깊이)?\n    if 요소종류 == 715 || 요소종류 == 719 {\n      요소 = 인쇄조각결과합치기(준비, [\n        인쇄글조각결과(준비, \"(\"), Ok(요소), 인쇄글조각결과(준비, \")\")\n      ])?\n    }\n    return 인쇄조각결과합치기(준비, [Ok(요소), 인쇄글조각결과(준비, \"[]\")])\n  }\n  if 종류 == 717 {\n    return 중괄호목록조각인쇄(준비, 자식순번들(준비, 순번, \"members\"), 깊이, true)\n  }\n  if 종류 == 739 {\n    return 인쇄조각결과합치기(준비, [\n      인쇄글조각결과(준비, \"(\"),\n      자식조각인쇄접두(준비, 순번, \"typeAnnotation\", 깊이, \"\"),\n      인쇄글조각결과(준비, \")\")\n    ])\n  }\n  if 종류 == 740 {\n    let 연산 = 스칼라문자(노드, \"operator\")\n    if 연산 != \"keyof\" && 연산 != \"unique\" && 연산 != \"readonly\" {\n      return Err(\"형식 단항 연산자가 틀립니다\")\n    }\n    return 인쇄조각결과합치기(준비, [\n      인쇄글조각결과(\n        준비,\n        연산 + 가장자리접두(준비, 자식순번(준비, 순번, \"typeAnnotation\"), \" \")\n      ),\n      자식조각인쇄(준비, 순번, \"typeAnnotation\", 깊이)\n    ])\n  }\n  if 종류 == 742 { return 인쇄글조각결과(준비, \"symbol\") }\n  if 종류 == 743 {\n    let 대상순번 = 자식순번(준비, 순번, \"objectType\")\n    let 대상종류 = 노드종류(준비.언어번호, 준비.구조.노드들[대상순번].코드워드)\n    let mut 대상 = 자식조각인쇄(준비, 순번, \"objectType\", 깊이)?\n    if 대상종류 == 715 || 대상종류 == 719 {\n      대상 = 인쇄조각결과합치기(준비, [\n        인쇄글조각결과(준비, \"(\"), Ok(대상), 인쇄글조각결과(준비, \")\")\n      ])?\n    }\n    return 인쇄조각결과합치기(준비, [\n      Ok(대상), 인쇄글조각결과(준비, \"[\"),\n      자식조각인쇄(준비, 순번, \"indexType\", 깊이),\n      인쇄글조각결과(준비, \"]\")\n    ])\n  }\n  if 종류 == 744 {\n    return 인쇄조각결과합치기(준비, [\n      자식조각인쇄접두(준비, 순번, \"typeParameters\", 깊이, \"\"),\n      인쇄글조각결과(준비, \"(\"),\n      들사이조각인쇄(준비, 자식순번들(준비, 순번, \"parameters\"), 깊이, \", \"),\n      인쇄글조각결과(준비, \")\"),\n      자식조각인쇄접두(준비, 순번, \"typeAnnotation\", 깊이, \"\")\n    ])\n  }\n  if 종류 == 745 { return 인쇄글조각결과(준비, \"boolean\") }\n  if 종류 == 718 {\n    let 계산 = 스칼라논리(노드, \"computed\")\n    let 키순번 = 자식순번(준비, 순번, \"key\")\n    let 키 = if 계산 && 키순번 >= 0 {\n      하위식조각인쇄(준비, 키순번, 깊이, 2)?\n    } else { 자식조각인쇄(준비, 순번, \"key\", 깊이)? }\n    let mut 합 = 인쇄글조각(\n      준비.조각판,\n      if 스칼라논리(노드, \"readonly\") { \"readonly \" } else { \"\" }\n    )\n    if 계산 {\n      합 = 인쇄조각결과합치기(준비, [\n        Ok(합), 인쇄글조각결과(준비, \"[\"), Ok(키), 인쇄글조각결과(준비, \"]\")\n      ])?\n    } else {\n      합 = 인쇄조각이음(준비.조각판, 합, 키)\n    }\n    if 스칼라논리(노드, \"optional\") {\n      합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, \"?\"))\n    }\n    return 인쇄조각결과합치기(준비, [\n      Ok(합), 자식조각인쇄접두(준비, 순번, \"typeAnnotation\", 깊이, \"\")\n    ])\n  }\n  if 종류 == 741 {\n    let 꼴 = 스칼라문자(노드, \"kind\")\n    if 꼴 != \"method\" && 꼴 != \"get\" && 꼴 != \"set\" {\n      return Err(\"형식 메서드 서명의 종류가 틀립니다\")\n    }\n    let 계산 = 스칼라논리(노드, \"computed\")\n    let 키순번 = 자식순번(준비, 순번, \"key\")\n    let 키 = if 계산 && 키순번 >= 0 {\n      하위식조각인쇄(준비, 키순번, 깊이, 2)?\n    } else { 자식조각인쇄(준비, 순번, \"key\", 깊이)? }\n    let mut 합 = 인쇄글조각(\n      준비.조각판,\n      if 꼴 == \"get\" || 꼴 == \"set\" { 꼴 + \" \" } else { \"\" }\n    )\n    if 계산 {\n      합 = 인쇄조각결과합치기(준비, [\n        Ok(합), 인쇄글조각결과(준비, \"[\"), Ok(키), 인쇄글조각결과(준비, \"]\")\n      ])?\n    } else {\n      합 = 인쇄조각이음(준비.조각판, 합, 키)\n    }\n    if 스칼라논리(노드, \"optional\") {\n      합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, \"?\"))\n    }\n    합 = 인쇄조각이음(\n      준비.조각판,\n      합,\n      자식조각인쇄접두(준비, 순번, \"typeParameters\", 깊이, \"\")?\n    )\n    합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, \"(\"))\n    합 = 인쇄조각이음(\n      준비.조각판,\n      합,\n      들사이조각인쇄(준비, 자식순번들(준비, 순번, \"parameters\"), 깊이, \", \")?\n    )\n    합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, \")\"))\n    return 인쇄조각결과합치기(준비, [\n      Ok(합), 자식조각인쇄접두(준비, 순번, \"typeAnnotation\", 깊이, \"\")\n    ])\n  }\n  if 종류 == 719 {\n    let 형식매개 = 자식조각인쇄접두(준비, 순번, \"typeParameters\", 깊이, \"\")?\n    let 매개들 = 들사이조각인쇄(\n      준비,\n      자식순번들(준비, 순번, \"parameters\"),\n      깊이,\n      \", \"\n    )?\n    let mut 반환 = 자식조각인쇄(준비, 순번, \"typeAnnotation\", 깊이)?\n    let 반환길이 = 준비.조각판.길이들[반환]\n    if 반환길이 >= 2 {\n      반환 = 인쇄조각자름(준비.조각판, 반환, 2, 반환길이)?\n    }\n    return 인쇄조각결과합치기(준비, [\n      Ok(형식매개), 인쇄글조각결과(준비, \"(\"), Ok(매개들),\n      인쇄글조각결과(준비, \") => \"), Ok(반환)\n    ])\n  }\n  if 종류 == 720 {\n    return 중괄호목록조각인쇄(준비, 자식순번들(준비, 순번, \"body\"), 깊이, true)\n  }\n  if 종류 == 721 {\n    let 상속들 = 자식순번들(준비, 순번, \"extends\")\n    let mut 합 = 인쇄조각결과합치기(준비, [\n      인쇄글조각결과(\n        준비,\n        (if 스칼라논리(노드, \"declare\") { \"declare \" } else { \"\" }) + \"interface \"\n      ),\n      자식조각인쇄(준비, 순번, \"id\", 깊이),\n      자식조각인쇄접두(준비, 순번, \"typeParameters\", 깊이, \"\")\n    ])?\n    if 상속들.length > 0 {\n      합 = 인쇄조각결과합치기(준비, [\n        Ok(합),\n        인쇄글조각결과(준비, \" extends\" + 가장자리접두(준비, 상속들[0], \" \")),\n        들사이조각인쇄(준비, 상속들, 깊이, \", \")\n      ])?\n    }\n    return 인쇄조각결과합치기(준비, [\n      Ok(합), 자식조각인쇄접두(준비, 순번, \"body\", 깊이, \" \")\n    ])\n  }\n  if 종류 == 722 {\n    let 형식순번 = 자식순번(준비, 순번, \"typeAnnotation\")\n    let 매개순번 = 자식순번(준비, 순번, \"typeParameters\")\n    let 이전순번 = if 매개순번 >= 0 { 매개순번 }\n      else { 자식순번(준비, 순번, \"id\") }\n    let 형식접두 = if 준비.오프셋배치 && 형식순번 >= 0 && 이전순번 >= 0 {\n      let 줄수 = 스칼라정수(준비.구조.노드들[형식순번], \"startRow\") -\n        스칼라정수(준비.구조.노드들[이전순번], \"endRow\")\n      if 줄수 > 0 { 줄접두(줄수, 노드들여쓰기(준비, 형식순번)) } else { \" \" }\n    } else { \" \" }\n    return 인쇄조각결과합치기(준비, [\n      인쇄글조각결과(\n        준비,\n        (if 스칼라논리(노드, \"declare\") { \"declare \" } else { \"\" }) + \"type \"\n      ),\n      자식조각인쇄(준비, 순번, \"id\", 깊이),\n      자식조각인쇄접두(준비, 순번, \"typeParameters\", 깊이, \"\"),\n      인쇄글조각결과(준비, \" =\" + 형식접두),\n      자식조각인쇄(준비, 순번, \"typeAnnotation\", 깊이),\n      인쇄글조각결과(준비, \";\")\n    ])\n  }\n  if 종류 == 723 {\n    let 식순번 = 자식순번(준비, 순번, \"expression\")\n    let 식종류 = if 식순번 < 0 { 0 } else { 노드종류(준비.언어번호, 준비.구조.노드들[식순번].코드워드) }\n    let 식 = 하위식조각인쇄(준비, 식순번, 깊이, 10)?\n    let 단언괄호 = (식종류 == 724 || 식종류 == 725) &&\n      스칼라정수(준비.구조.노드들[식순번], \"spelling.parentheses\") == 0\n    return 인쇄조각결과합치기(준비, [\n      인쇄글조각결과(준비, \"<\"),\n      자식조각인쇄접두(준비, 순번, \"typeAnnotation\", 깊이, \"\"),\n      인쇄글조각결과(준비, \"> \"),\n      인쇄글조각결과(준비, if 단언괄호 { \"(\" } else { \"\" }),\n      Ok(식),\n      인쇄글조각결과(준비, if 단언괄호 { \")\" } else { \"\" })\n    ])\n  }\n  if 종류 == 724 || 종류 == 725 {\n    let 형식순번 = 자식순번(준비, 순번, \"typeAnnotation\")\n    return 인쇄조각결과합치기(준비, [\n      하위식조각인쇄(준비, 자식순번(준비, 순번, \"expression\"), 깊이, 10),\n      인쇄글조각결과(\n        준비,\n        (if 종류 == 724 { \" as\" } else { \" satisfies\" }) +\n          가장자리접두(준비, 형식순번, \" \")\n      ),\n      자식조각인쇄(준비, 순번, \"typeAnnotation\", 깊이)\n    ])\n  }\n  if 종류 == 726 {\n    let 식순번 = 자식순번(준비, 순번, \"expression\")\n    let 식종류 = if 식순번 < 0 { 0 }\n      else { 노드종류(준비.언어번호, 준비.구조.노드들[식순번].코드워드) }\n    return 인쇄조각결과합치기(준비, [\n      하위식조각인쇄(준비, 식순번, 깊이, if 식종류 == 727 { 18 } else { 16 }),\n      인쇄글조각결과(준비, \"!\")\n    ])\n  }\n  if 종류 == 727 {\n    return 인쇄조각결과합치기(준비, [\n      연쇄대상조각인쇄(준비, 자식순번(준비, 순번, \"expression\"), 깊이, false),\n      자식조각인쇄접두(준비, 순번, \"typeParameters\", 깊이, \"\")\n    ])\n  }\n  if 종류 == 728 {\n    return 인쇄조각결과합치기(준비, [\n      인쇄글조각결과(준비, \"typeof \"),\n      자식조각인쇄(준비, 순번, \"exprName\", 깊이),\n      자식조각인쇄접두(준비, 순번, \"typeParameters\", 깊이, \"\")\n    ])\n  }\n  if 종류 == 729 {\n    let mut 머리 = \"\"\n    let 접근 = 스칼라문자(노드, \"accessibility\")\n    if 접근 != \"\" { 머리 = 머리 + 접근 + \" \" }\n    if 스칼라논리(노드, \"override\") { 머리 = 머리 + \"override \" }\n    if 스칼라논리(노드, \"readonly\") { 머리 = 머리 + \"readonly \" }\n    return 인쇄조각결과합치기(준비, [\n      인쇄글조각결과(준비, 머리),\n      자식조각인쇄(준비, 순번, \"parameter\", 깊이)\n    ])\n  }\n  if 종류 == 730 {\n    return 인쇄조각결과합치기(준비, [\n      인쇄글조각결과(\n        준비,\n        if 스칼라논리(노드, \"declare\") { \"declare \" } else { \"\" }\n      ),\n      함수머리조각인쇄(준비, 순번, 깊이, 자식순번(준비, 순번, \"id\") >= 0),\n      인쇄글조각결과(준비, \";\")\n    ])\n  }\n  if 종류 == 731 { return 문장블록조각인쇄(준비, 순번, 깊이, \"\") }\n  if 종류 == 732 {\n    let mut 합 = 인쇄글조각(\n      준비.조각판,\n      if 스칼라논리(노드, \"declare\") { \"declare \" } else { \"\" }\n    )\n    if 스칼라논리(노드, \"global\") {\n      return 인쇄조각결과합치기(준비, [\n        Ok(합), 자식조각인쇄(준비, 순번, \"id\", 깊이),\n        자식조각인쇄접두(준비, 순번, \"body\", 깊이, \" \")\n      ])\n    }\n    let 꼴 = 스칼라문자(노드, \"kind\")\n    합 = 인쇄조각이음(\n      준비.조각판,\n      합,\n      인쇄글조각(준비.조각판, if 꼴 == \"module\" { \"module \" } else { \"namespace \" })\n    )\n    let mut 모듈순번 = 순번\n    let mut 끝 = false\n    while !끝 {\n      합 = 인쇄조각이음(\n        준비.조각판,\n        합,\n        자식조각인쇄(준비, 모듈순번, \"id\", 깊이)?\n      )\n      let 몸순번 = 자식순번(준비, 모듈순번, \"body\")\n      if 몸순번 < 0 {\n        합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, \";\"))\n        끝 = true\n      } else if 노드종류(준비.언어번호, 준비.구조.노드들[몸순번].코드워드) == 732 {\n        합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, \".\"))\n        모듈순번 = 몸순번\n      } else {\n        합 = 인쇄조각결과합치기(준비, [\n          Ok(합), 인쇄글조각결과(준비, 가장자리접두(준비, 몸순번, \" \")),\n          순번인쇄조각(준비, 몸순번, 깊이)\n        ])?\n        끝 = true\n      }\n    }\n    return Ok(합)\n  }\n  if 종류 == 733 {\n    let 이름 = 자식조각인쇄(준비, 순번, \"id\", 깊이)?\n    let 값 = 자식조각인쇄(준비, 순번, \"initializer\", 깊이)?\n    if 준비.조각판.길이들[값] == 0 { return Ok(이름) }\n    return 인쇄조각결과합치기(준비, [\n      Ok(이름),\n      인쇄글조각결과(\n        준비,\n        \" =\" + 가장자리접두(준비, 자식순번(준비, 순번, \"initializer\"), \" \")\n      ),\n      Ok(값)\n    ])\n  }\n  if 종류 == 734 {\n    let 멤버들 = 자식순번들(준비, 순번, \"members\")\n    let mut 합 = 인쇄조각결과합치기(준비, [\n      인쇄글조각결과(\n        준비,\n        (if 스칼라논리(노드, \"declare\") { \"declare \" } else { \"\" }) +\n          (if 스칼라논리(노드, \"const\") { \"const \" } else { \"\" }) +\n          \"enum\"\n      ),\n      자식조각인쇄접두(준비, 순번, \"id\", 깊이, \" \"),\n      인쇄글조각결과(준비, \" \\{\")\n    ])?\n    if 멤버들.length == 0 {\n      return 인쇄조각결과합치기(준비, [Ok(합), 인쇄글조각결과(준비, \"\\}\")])\n    }\n    if 준비.오프셋배치 {\n      let 이름순번 = 자식순번(준비, 순번, \"id\")\n      let mut 이전행 = if 이름순번 < 0 { 스칼라정수(노드, \"startRow\") }\n        else { 스칼라정수(준비.구조.노드들[이름순번], \"endRow\") }\n      let mut 색인 = 0\n      for 멤버 in 멤버들 {\n        let 멤버노드 = 준비.구조.노드들[멤버]\n        let 줄수 = 스칼라정수(멤버노드, \"startRow\") - 이전행\n        let 접두 = if 줄수 > 0 { 줄접두(줄수, 노드들여쓰기(준비, 멤버)) }\n          else if 색인 > 0 { \" \" } else { \"\" }\n        합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, 접두))\n        합 = 인쇄조각이음(준비.조각판, 합, 순번인쇄조각(준비, 멤버, 깊이 + 1)?)\n        if !스칼라논리(준비.구조.노드들[멤버], \"spelling.omitTrailingComma\") {\n          합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, \",\"))\n        }\n        이전행 = 스칼라정수(멤버노드, \"endRow\")\n        색인 = 색인 + 1\n      }\n      let 닫기줄수 = 스칼라정수(노드, \"endRow\") - 이전행\n      let 닫기접두 = if 닫기줄수 > 0 {\n        줄접두(닫기줄수, 노드들여쓰기(준비, 순번))\n      } else { \"\" }\n      return 인쇄조각결과합치기(준비, [\n        Ok(합), 인쇄글조각결과(준비, 닫기접두 + \"\\}\")\n      ])\n    }\n    합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, \"\\n\"))\n    for 멤버 in 멤버들 {\n      let 멤버인쇄 = if 댓글고정있음(준비) {\n        댓글노드인쇄조각(준비, 멤버, 깊이 + 1)\n      } else { 노드인쇄조각(준비, 멤버, 깊이 + 1) }\n      합 = 인쇄조각결과합치기(준비, [\n        Ok(합), 인쇄글조각결과(준비, 들여쓰기(깊이 + 1)),\n        멤버인쇄,\n        인쇄글조각결과(\n          준비,\n          if 스칼라논리(준비.구조.노드들[멤버], \"spelling.omitTrailingComma\") {\n            \"\\n\"\n          } else { \",\\n\" }\n        )\n      ])?\n    }\n    return 인쇄조각결과합치기(준비, [\n      Ok(합), 인쇄글조각결과(준비, 들여쓰기(깊이) + \"\\}\")\n    ])\n  }\n  if 종류 == 735 {\n    let 가져옴 = 자식조각인쇄(준비, 순번, \"imported\", 깊이)?\n    let 지역 = 자식조각인쇄(준비, 순번, \"local\", 깊이)?\n    let 앞 = 인쇄글조각(\n      준비.조각판,\n      if 스칼라문자(노드, \"importKind\") == \"type\" {\n        \"type\" + 가장자리접두(준비, 자식순번(준비, 순번, \"imported\"), \" \")\n      } else { 가장자리접두(준비, 자식순번(준비, 순번, \"imported\"), \"\") }\n    )\n    if 인쇄조각같음(준비.조각판, 가져옴, 지역)? {\n      return 인쇄조각결과합치기(준비, [Ok(앞), Ok(가져옴)])\n    }\n    return 인쇄조각결과합치기(준비, [\n      Ok(앞), Ok(가져옴), 인쇄글조각결과(준비,\n        \" as\" + 가장자리접두(준비, 자식순번(준비, 순번, \"local\"), \" \")),\n      Ok(지역)\n    ])\n  }\n  if 종류 == 736 {\n    let 명세들 = 자식순번들(준비, 순번, \"specifiers\")\n    let 출처 = 자식조각인쇄(준비, 순번, \"source\", 깊이)?\n    let 출처접두 = 모듈출처접두(준비, 순번)\n    let 빈이름절있음 = 스칼라있음(노드, \"emptyNamedImportClause\")\n    if 빈이름절있음 && !스칼라논리(노드, \"emptyNamedImportClause\") {\n      return Err(\"빈 이름 가져오기 절 표지가 참이 아닙니다\")\n    }\n    if 빈이름절있음 && 명세들.length != 0 {\n      return Err(\"명세가 있는 가져오기에 빈 이름 절 표지가 있습니다\")\n    }\n    if 명세들.length == 0 {\n      let 가져오기종류 = 스칼라문자(노드, \"importKind\")\n      if (가져오기종류 == \"type\" || 가져오기종류 == \"typeof\") && !빈이름절있음 {\n        return Err(\"빈 형식 가져오기에 이름 절 표지가 없습니다\")\n      }\n      if 빈이름절있음 {\n        return 인쇄조각결과합치기(준비, [\n          인쇄글조각결과(\n            준비,\n            if 가져오기종류 == \"type\" || 가져오기종류 == \"typeof\" {\n              \"import {가져오기종류} \\{\\}\" + 출처접두\n            } else {\n              \"import \\{\\}\" + 출처접두\n            }\n          ),\n          Ok(출처),\n          인쇄글조각결과(준비, \";\")\n        ])\n      }\n      return 인쇄조각결과합치기(준비, [\n        인쇄글조각결과(준비, \"import \"), Ok(출처), 인쇄글조각결과(준비, \";\")\n      ])\n    }\n    return 인쇄조각결과합치기(준비, [\n      인쇄글조각결과(\n        준비,\n        (if 스칼라문자(노드, \"importKind\") == \"type\" { \"import type \\{\" }\n          else { \"import \\{\" }) + 가장자리접두(준비, 명세들[0], \" \")\n      ),\n      명세들조각인쇄(준비, 명세들, 깊이),\n      인쇄글조각결과(준비, 명세닫기공백(준비, 명세들) + \"\\}\" + 출처접두),\n      Ok(출처),\n      인쇄글조각결과(준비, \";\")\n    ])\n  }\n  if 종류 == 737 {\n    let 지역 = 자식조각인쇄(준비, 순번, \"local\", 깊이)?\n    let 내보냄 = 자식조각인쇄(준비, 순번, \"exported\", 깊이)?\n    let 앞 = 인쇄글조각(\n      준비.조각판,\n      if 스칼라문자(노드, \"exportKind\") == \"type\" { \"type \" } else { \"\" }\n    )\n    if 인쇄조각같음(준비.조각판, 지역, 내보냄)? {\n      return 인쇄조각결과합치기(준비, [Ok(앞), Ok(지역)])\n    }\n    return 인쇄조각결과합치기(준비, [\n      Ok(앞), Ok(지역), 인쇄글조각결과(준비, \" as \"), Ok(내보냄)\n    ])\n  }\n  if 종류 == 738 {\n    let 선언 = 자식조각인쇄(준비, 순번, \"declaration\", 깊이)?\n    if 준비.조각판.길이들[선언] > 0 {\n      return 인쇄조각결과합치기(준비, [\n        인쇄글조각결과(\n          준비,\n          \"export\" +\n            가장자리접두(준비, 자식순번(준비, 순번, \"declaration\"), \" \")\n        ),\n        Ok(선언)\n      ])\n    }\n    let 앞 = 인쇄글조각(\n      준비.조각판,\n      if 스칼라문자(노드, \"exportKind\") == \"type\" { \"export type \" } else { \"export \" }\n    )\n    let 명세들 = 자식순번들(준비, 순번, \"specifiers\")\n    let 명세 = 명세들조각인쇄(준비, 명세들, 깊이)?\n    let 묶음 = if 준비.조각판.길이들[명세] == 0 {\n      인쇄글조각(준비.조각판, \"\\{\\}\")\n    } else {\n      인쇄조각결과합치기(준비, [\n        인쇄글조각결과(준비, \"\\{\" + 가장자리접두(준비, 명세들[0], \" \")),\n        Ok(명세),\n        인쇄글조각결과(준비, 명세닫기공백(준비, 명세들) + \"\\}\")\n      ])?\n    }\n    let 출처 = 자식조각인쇄(준비, 순번, \"source\", 깊이)?\n    if 준비.조각판.길이들[출처] == 0 {\n      return 인쇄조각결과합치기(준비, [\n        Ok(앞), Ok(묶음), 인쇄글조각결과(준비, \";\")\n      ])\n    }\n    return 인쇄조각결과합치기(준비, [\n      Ok(앞), Ok(묶음), 인쇄글조각결과(준비, 모듈출처접두(준비, 순번)),\n      Ok(출처), 인쇄글조각결과(준비, \";\")\n    ])\n  }\n  Err(\"형식 노드 인쇄 규칙을 찾지 못했습니다: {종류}\")\n}\n\nfunction 댓글노드조각계산(준비: 준비된인쇄상태, 순번: int, 깊이: int) -> Result<int, string> {\n  댓글붙이기조각(준비, 순번, 깊이, 노드인쇄조각(준비, 순번, 깊이)?)\n}\n\nfunction 인쇄기계계산(준비: 준비된인쇄상태, 호출: 인쇄호출) -> Result<int, string> {\n  if 호출.모드 == 1 { return 순번인쇄조각계산(준비, 호출.순번, 호출.깊이) }\n  if 호출.모드 == 2 {\n    if 호출.순번 < 0 || 호출.순번 >= 준비.구조.노드들.length {\n      return Err(\"인쇄 노드 순번이 범위를 벗어났습니다\")\n    }\n    인머리내림(준비, 호출.순번)\n    let 종류 = 노드종류(준비.언어번호, 준비.구조.노드들[호출.순번].코드워드)\n    if 종류 / 100 == 1 { return 원시노드조각인쇄(준비, 호출.순번, 호출.깊이) }\n    if 종류 / 100 == 2 { return 모음노드조각인쇄(준비, 호출.순번, 호출.깊이) }\n    if 종류 / 100 == 3 { return 계산노드조각인쇄(준비, 호출.순번, 호출.깊이) }\n    if 종류 / 100 == 4 { return 간단문장조각인쇄(준비, 호출.순번, 호출.깊이) }\n    if 종류 / 100 == 5 { return 제어문장조각인쇄(준비, 호출.순번, 호출.깊이) }\n    if 종류 / 100 == 6 { return 클래스문장조각인쇄(준비, 호출.순번, 호출.깊이) }\n    if 종류 / 100 == 7 { return 형식노드조각인쇄(준비, 호출.순번, 호출.깊이) }\n    return 원시노드조각인쇄(준비, 호출.순번, 호출.깊이)\n  }\n  if 호출.모드 == 3 { return 댓글노드조각계산(준비, 호출.순번, 호출.깊이) }\n  Err(\"인쇄 기계 호출 모드가 틀립니다\")\n}\n\nfunction 인쇄기계실행(\n  준비: 준비된인쇄상태,\n  모드: int,\n  순번: int,\n  깊이: int\n) -> Result<int, string> {\n  if 순번 < 0 || 순번 >= 준비.구조.노드들.length {\n    return Err(\"인쇄 노드 순번이 범위를 벗어났습니다\")\n  }\n  let mut 활성들 = 준비.기계활성들\n  let mut 세대들 = 준비.기계세대들\n  활성들[0] = true\n  세대들[0] = 세대들[0] + 1\n  let 뿌리 = 인쇄호출 { 모드: 모드, 순번: 순번, 깊이: 깊이 }\n  let mut 호출들: Array<인쇄호출> = [뿌리]\n  let mut 꼭대기 = 1\n  let mut 단계수 = 0\n  let 최대단계수 = 준비.구조.노드들.length * 64 + 1024\n  let 최대꼭대기 = 준비.구조.노드들.length * 4 + 16\n  let mut 기계오류 = \"\"\n  while 꼭대기 > 0 && 기계오류 == \"\" {\n    단계수 = 단계수 + 1\n    if 단계수 > 최대단계수 {\n      기계오류 = \"인쇄 기계 단계 한도를 넘었습니다\"\n    } else {\n      let 호출 = 호출들[꼭대기 - 1]\n      let mut 필요모드들 = 준비.기계필요모드들\n      필요모드들[0] = 0\n      let 결과 = 인쇄기계계산(준비, 호출)\n      if 준비.기계필요모드들[0] != 0 {\n        let 필요 = 인쇄호출 {\n          모드: 준비.기계필요모드들[0],\n          순번: 준비.기계필요순번들[0],\n          깊이: 준비.기계필요깊이들[0]\n        }\n        if 꼭대기 >= 최대꼭대기 {\n          기계오류 = \"인쇄 기계 계속 저장 한도를 넘었습니다\"\n        } else {\n          if 꼭대기 < 호출들.length { 호출들[꼭대기] = 필요 }\n          else { 호출들.push(필요) }\n          꼭대기 = 꼭대기 + 1\n        }\n      } else {\n        인쇄기계저장쓰기(준비, 호출, 결과)\n        꼭대기 = 꼭대기 - 1\n      }\n    }\n  }\n  활성들[0] = false\n  if 기계오류 != \"\" { return Err(기계오류) }\n  인쇄기계저장조각읽기(준비, 모드, 순번, 깊이)\n}\n\nexport function 순번인쇄조각(준비: 준비된인쇄상태, 순번: int, 깊이: int) -> Result<int, string> {\n  if 준비.기계활성들[0] { 인쇄기계저장조각읽기(준비, 1, 순번, 깊이) }\n  else { 인쇄기계실행(준비, 1, 순번, 깊이) }\n}\n\nexport function 노드인쇄조각(준비: 준비된인쇄상태, 순번: int, 깊이: int) -> Result<int, string> {\n  if 준비.기계활성들[0] { 인쇄기계저장조각읽기(준비, 2, 순번, 깊이) }\n  else { 인쇄기계실행(준비, 2, 순번, 깊이) }\n}\n\nexport function 댓글노드인쇄조각(준비: 준비된인쇄상태, 순번: int, 깊이: int) -> Result<int, string> {\n  if 준비.기계활성들[0] { 인쇄기계저장조각읽기(준비, 3, 순번, 깊이) }\n  else { 인쇄기계실행(준비, 3, 순번, 깊이) }\n}\n",
      "sourceSha256": "887fab33ce619d402403f3eb50e666a165a5a42e1ddec997428415f18eef2907"
    },
    {
      "path": "topaz/src/printers/javascript/check.tpz",
      "language": "topaz",
      "bytes": 15409,
      "sha256": "b273f9fd9761f686e76bb82f2904beabdf861968ad0565a4903af24dd8e1327c",
      "content": "// JavaScript and TypeScript structure checks against the generated printer rules.\n\nimport nodes { 노드종류 }\nimport printer_state { 준비된인쇄상태 }\nimport printers.javascript.rules { 스칼라뜻검사, 인쇄노드규칙, 인쇄노드규칙읽기, 자식메타필드허용, 자식필드모드 }\nimport structure { 구조노드, 구조스칼라, 구조입력, 노드스칼라, 스칼라논리, 스칼라문자, 스칼라있음, 스칼라정수 }\nimport util { 문자열배열에있음 }\n\nfunction 철자스칼라뜻검사(\n  종류: int,\n  언어번호: int,\n  스칼라: 구조스칼라\n) -> Result<bool, string> {\n  if 언어번호 != 1 && 언어번호 != 2 {\n    return Err(\"자바스크립트가 아닌 구조에 철자 스칼라가 있습니다\")\n  }\n  let 필드 = 스칼라.필드\n  if 필드 == \"spelling.singleQuote\" {\n    if (종류 != 104 && 종류 != 108) || 스칼라.태그 != 2 {\n      return Err(\"작은따옴표 철자 표지가 문자열 리터럴의 참 값이 아닙니다\")\n    }\n    return Ok(true)\n  }\n  if 필드 == \"spelling.escapeBody\" {\n    if (종류 != 104 && 종류 != 108) || 스칼라.태그 != 5 || 스칼라.문자열값 == \"\" {\n      return Err(\"탈출 철자 본문이 문자열 리터럴의 문자열 값이 아닙니다\")\n    }\n    let mut 특수철자있음 = false\n    for 글자 in 스칼라.문자열값.scalars() {\n      let 코드 = 글자.codePointAt(0) ?? 0\n      if 글자 == \"\\\\\" || 코드 < 32 || 코드 > 126 { 특수철자있음 = true }\n    }\n    if !특수철자있음 { return Err(\"탈출 철자 본문에 비정규 철자가 없습니다\") }\n    return Ok(true)\n  }\n  if 필드 == \"spelling.numericLexeme\" {\n    if 종류 != 110 || 스칼라.태그 != 5 || 스칼라.문자열값 == \"\" {\n      return Err(\"숫자 철자 값이 숫자 리터럴의 문자열 값이 아닙니다\")\n    }\n    return Ok(true)\n  }\n  if 필드 == \"spelling.parentheses\" {\n    if 스칼라.태그 != 3 || 스칼라.정수값 < 1 || 스칼라.정수값 > 262144 {\n      return Err(\"덧괄호 수가 정규 범위의 양의 정수가 아닙니다\")\n    }\n    return Ok(true)\n  }\n  if 문자열배열에있음([\n    \"spelling.trailingComma\",\n    \"spelling.omitTrailingComma\",\n    \"spelling.typeMemberComma\"\n  ], 필드) {\n    if 스칼라.태그 != 2 { return Err(\"구분자 철자 표지가 참 값이 아닙니다\") }\n    return Ok(true)\n  }\n  Err(\"지원하지 않는 철자 스칼라 필드입니다: {필드}\")\n}\n\nfunction 방출행사건서명(글: string) -> string {\n  let 글자들 = 글.scalars()\n  let mut 사건들: Array<string> = []\n  let mut 색인 = 0\n  while 색인 < 글자들.length {\n    if 글자들[색인] == \"\\r\" {\n      if 색인 + 1 < 글자들.length && 글자들[색인 + 1] == \"\\n\" {\n        사건들.push(\"crlf\")\n        색인 = 색인 + 2\n      } else {\n        사건들.push(\"cr\")\n        색인 = 색인 + 1\n      }\n    } else if 글자들[색인] == \"\\n\" {\n      사건들.push(\"lf\")\n      색인 = 색인 + 1\n    } else {\n      let 코드 = 글자들[색인].codePointAt(0) ?? 0\n      if 코드 == 8232 { 사건들.push(\"ls\") }\n      else if 코드 == 8233 { 사건들.push(\"ps\") }\n      색인 = 색인 + 1\n    }\n  }\n  사건들.join(\",\")\n}\n\nfunction 방출행사건뜻검사(종류: int, 스칼라: 구조스칼라, 노드: 구조노드) -> Result<bool, string> {\n  if 스칼라.태그 != 5 || 스칼라.문자열값 == \"\" {\n    return Err(\"방출 행 사건이 비어 있거나 문자열이 아닙니다\")\n  }\n  let 원시 = if 종류 == 116 { 스칼라문자(노드, \"value.raw\") }\n    else if 종류 == 104 || 종류 == 108 { 스칼라문자(노드, \"spelling.escapeBody\") }\n    else { \"\" }\n  if 원시 == \"\" || 방출행사건서명(원시) != 스칼라.문자열값 {\n    return Err(\"방출 행 사건이 소유 원시 토큰과 다릅니다\")\n  }\n  Ok(true)\n}\n\nexport function 철자위치검사(준비: 준비된인쇄상태, 순번: int) -> Result<bool, string> {\n  let 노드 = 준비.구조.노드들[순번]\n  let 꼬리 = 스칼라논리(노드, \"spelling.trailingComma\")\n  let 꼬리생략 = 스칼라논리(노드, \"spelling.omitTrailingComma\")\n  let 형식쉼표 = 스칼라논리(노드, \"spelling.typeMemberComma\")\n  let 구분자수 = (if 꼬리 { 1 } else { 0 }) +\n    (if 꼬리생략 { 1 } else { 0 }) + (if 형식쉼표 { 1 } else { 0 })\n  if 구분자수 > 1 { return Err(\"한 노드에 서로 다른 구분자 철자 표지가 함께 있습니다\") }\n  if 구분자수 == 0 { return Ok(true) }\n  if 노드.부모순번 < 0 || !노드.자식필드있음 {\n    return Err(\"구분자 철자 표지에 부모 역할이 없습니다\")\n  }\n  let 부모종류 = 노드종류(\n    준비.언어번호,\n    준비.구조.노드들[노드.부모순번].코드워드\n  )\n  if 형식쉼표 {\n    if !((부모종류 == 717 && 노드.자식필드 == \"members\") ||\n      (부모종류 == 720 && 노드.자식필드 == \"body\")) {\n      return Err(\"형식 멤버 쉼표가 형식 멤버 자리에 있지 않습니다\")\n    }\n    return Ok(true)\n  }\n  if 노드.자식색인 < 0 { return Err(\"꼬리 쉼표 표지가 목록 자식에 있지 않습니다\") }\n  let mut 다음 = 준비.다음형제들[순번]\n  while 다음 >= 0 {\n    if 준비.구조.노드들[다음].자식필드 == 노드.자식필드 {\n      return Err(\"꼬리 쉼표 표지가 마지막 목록 자식에 있지 않습니다\")\n    }\n    다음 = 준비.다음형제들[다음]\n  }\n  if 꼬리생략 {\n    if 부모종류 != 734 || 노드.자식필드 != \"members\" {\n      return Err(\"열거형 꼬리 쉼표 생략 표지가 열거형 멤버에 있지 않습니다\")\n    }\n    return Ok(true)\n  }\n  if !문자열배열에있음([\n    \"elements\", \"properties\", \"arguments\", \"params\", \"specifiers\", \"elementTypes\"\n  ], 노드.자식필드) {\n    return Err(\"꼬리 쉼표 표지가 허용된 문법 목록에 있지 않습니다\")\n  }\n  Ok(true)\n}\n\nfunction 자식무리검사(\n  준비: 준비된인쇄상태,\n  부모순번: int,\n  종류: int,\n  필드: string,\n  모드: int\n) -> Result<bool, string> {\n  let 부모 = 준비.구조.노드들[부모순번]\n  let 길이스칼라 = 노드스칼라(부모, \"child.{필드}.length\")\n  let 있음스칼라 = 노드스칼라(부모, \"child.{필드}.present\")\n  let 길이있음 = 길이스칼라.필드 != \"\"\n  let 있음있음 = 있음스칼라.필드 != \"\"\n  if 길이있음 && 있음있음 { return Err(\"자식 필드 길이와 있음 표지가 함께 있습니다: {필드}\") }\n  if 길이있음 && (길이스칼라.태그 != 3 || 길이스칼라.정수값 > 262144) {\n    return Err(\"자식 필드 길이가 정규 범위의 음이 아닌 정수가 아닙니다: {필드}\")\n  }\n  if 있음있음 && 있음스칼라.태그 != 1 {\n    return Err(\"없는 자식 필드의 있음 표지가 false가 아닙니다: {필드}\")\n  }\n  let mut 수 = 0\n  let mut 이전색인 = -1\n  let mut 순번 = 준비.첫자식들[부모순번]\n  while 순번 >= 0 {\n    let 자식 = 준비.구조.노드들[순번]\n    if 자식.자식필드 == 필드 {\n      if 모드 <= 2 {\n        if 자식.자식색인 != -1 { return Err(\"단일 자식에 목록 색인이 있습니다: {필드}\") }\n      } else {\n        if 자식.자식색인 < 0 { return Err(\"목록 자식에 목록 색인이 없습니다: {필드}\") }\n        let 희소 = (종류 == 201 || 종류 == 202) && 필드 == \"elements\"\n        if 희소 {\n          if 자식.자식색인 <= 이전색인 {\n            return Err(\"희소 배열 자식 색인이 오름차순이 아닙니다: {필드}\")\n          }\n        } else if 자식.자식색인 != 수 {\n          return Err(\"목록 자식 색인이 조밀한 순번과 다릅니다: {필드}\")\n        }\n        이전색인 = 자식.자식색인\n      }\n      수 = 수 + 1\n    }\n    순번 = 준비.다음형제들[순번]\n  }\n  if 모드 == 1 {\n    if 수 != 1 || 길이있음 || 있음있음 { return Err(\"필수 단일 자식이 정규형이 아닙니다: {필드}\") }\n  } else if 모드 == 2 {\n    if 수 > 1 || 길이있음 || (수 == 0 && !있음있음) || (수 == 1 && 있음있음) {\n      return Err(\"선택 단일 자식이 정규형이 아닙니다: {필드}\")\n    }\n  } else {\n    if 모드 == 3 && (!길이있음 || 있음있음) {\n      return Err(\"필수 목록 자식의 길이 표지가 정규형이 아닙니다: {필드}\")\n    }\n    if 모드 == 4 && ((!길이있음 && !있음있음) || (길이있음 && 있음있음)) {\n      return Err(\"선택 목록 자식의 메타 표지가 정규형이 아닙니다: {필드}\")\n    }\n    if 있음있음 && 수 != 0 { return Err(\"없다고 표시한 목록에 자식이 있습니다: {필드}\") }\n    if 길이있음 {\n      let 길이 = 길이스칼라.정수값\n      let 희소 = (종류 == 201 || 종류 == 202) && 필드 == \"elements\"\n      if (!희소 && 수 != 길이) || (희소 && 이전색인 >= 길이) {\n        return Err(\"목록 자식 수 또는 색인이 선언 길이와 다릅니다: {필드}\")\n      }\n    }\n  }\n  Ok(true)\n}\n\nexport function 노드자식스키마검사(준비: 준비된인쇄상태, 부모순번: int) -> Result<bool, string> {\n  let 부모 = 준비.구조.노드들[부모순번]\n  let 종류 = 노드종류(준비.언어번호, 부모.코드워드)\n  let 규칙 = 인쇄노드규칙읽기(준비.언어번호, 종류)\n  for 스칼라 in 부모.스칼라들 {\n    if 스칼라.필드.startsWith(\"child.\") {\n      if !자식메타필드허용(\n        규칙.선택단일,\n        규칙.필수목록,\n        규칙.선택목록,\n        스칼라.필드\n      ) {\n        return Err(\"노드 종류에 허용되지 않은 자식 메타 필드입니다: {스칼라.필드}\")\n      }\n    } else if 스칼라.필드.startsWith(\"spelling.\") {\n      철자스칼라뜻검사(종류, 준비.언어번호, 스칼라)?\n    } else if 스칼라.필드 == \"emission.rawRowEvents\" &&\n      (준비.언어번호 == 1 || 준비.언어번호 == 2) {\n      방출행사건뜻검사(종류, 스칼라, 부모)?\n    } else if 스칼라.필드 == \"emission.imageOnlyLeadingLineCommentRows\" {\n      if 준비.언어번호 != 2 || 스칼라.태그 != 3 ||\n        스칼라.정수값 < 1 || 스칼라.정수값 > 262144 {\n        return Err(\"영상 전용 줄댓글 행수가 정규 양의 정수가 아닙니다\")\n      }\n      if 부모.부모순번 < 0 || !부모.자식필드있음 {\n        return Err(\"영상 전용 줄댓글 행수에 문장 목록 자리가 없습니다\")\n      }\n      let 목록종류 = 노드종류(\n        준비.언어번호,\n        준비.구조.노드들[부모.부모순번].코드워드\n      )\n      if !((부모.자식필드 == \"body\" &&\n          (목록종류 == 102 || 목록종류 == 410 || 목록종류 == 603 ||\n            목록종류 == 609 || 목록종류 == 731)) ||\n        (부모.자식필드 == \"consequent\" && 목록종류 == 511)) {\n        return Err(\"영상 전용 줄댓글 행수가 문장 목록 밖에 있습니다\")\n      }\n    } else if (준비.언어번호 == 1 || 준비.언어번호 == 2) &&\n      문자열배열에있음([\"startRow\", \"startColumn\", \"endRow\", \"endColumn\"], 스칼라.필드) {\n      if 스칼라.태그 != 3 || 스칼라.정수값 < 0 {\n        return Err(\"JS/TS 행 기하 스칼라가 음이 아닌 정수가 아닙니다: {스칼라.필드}\")\n      }\n    } else {\n      if !문자열배열에있음(규칙.허용스칼라, 스칼라.필드) {\n        return Err(\"노드 종류에 허용되지 않은 구조 스칼라 필드입니다: {스칼라.필드}\")\n      }\n      스칼라뜻검사(종류, 준비.언어번호, 스칼라)?\n    }\n  }\n  for 필드 in 규칙.필수스칼라 {\n    if !스칼라있음(부모, 필드) {\n      return Err(\"노드 종류의 필수 구조 스칼라가 없습니다: {필드}\")\n    }\n  }\n  if 종류 == 106 || 종류 == 714 {\n    if 부모.식별자있음 {\n      if 스칼라있음(부모, \"name\") {\n        return Err(\"식별자 이름이 이미지와 분리 본문에 함께 있습니다\")\n      }\n    } else if !스칼라있음(부모, \"name\") {\n      return Err(\"이미지에 남은 식별자 이름 스칼라가 없습니다\")\n    }\n  } else if 부모.식별자있음 {\n    return Err(\"식별자가 아닌 노드에 식별자 분리 본문이 있습니다\")\n  }\n  let mut 자식순번값 = 준비.첫자식들[부모순번]\n  while 자식순번값 >= 0 {\n    let 자식 = 준비.구조.노드들[자식순번값]\n    let 모드 = 자식필드모드(\n      규칙.필수단일,\n      규칙.선택단일,\n      규칙.필수목록,\n      규칙.선택목록,\n      자식.자식필드\n    )\n    if 모드 == 0 {\n      return Err(\"노드 종류에 허용되지 않은 자식 필드입니다: {자식.자식필드}\")\n    }\n    자식순번값 = 준비.다음형제들[자식순번값]\n  }\n  for 필드 in 규칙.필수단일 { 자식무리검사(준비, 부모순번, 종류, 필드, 1)? }\n  for 필드 in 규칙.선택단일 { 자식무리검사(준비, 부모순번, 종류, 필드, 2)? }\n  for 필드 in 규칙.필수목록 { 자식무리검사(준비, 부모순번, 종류, 필드, 3)? }\n  for 필드 in 규칙.선택목록 { 자식무리검사(준비, 부모순번, 종류, 필드, 4)? }\n  Ok(true)\n}\n\nexport function 타입스크립트영상댓글행계획검사(구조: 구조입력) -> Result<bool, string> {\n  let mut 문장들: Array<int> = []\n  let mut 댓글들: Array<int> = []\n  let mut 기대행들: Array<int> = []\n  let mut 순번 = 0\n  let mut 이전문장시작 = -1\n  let mut 이전댓글끝 = -1\n  while 순번 < 구조.노드들.length {\n    기대행들.push(0)\n    let 노드 = 구조.노드들[순번]\n    if 노드.부모순번 >= 0 && 노드.자식필드있음 {\n      let 부모종류 = 노드종류(2, 구조.노드들[노드.부모순번].코드워드)\n      let 문장자리 =\n        (노드.자식필드 == \"body\" &&\n          (부모종류 == 102 || 부모종류 == 410 || 부모종류 == 603 ||\n            부모종류 == 609 || 부모종류 == 731)) ||\n        (노드.자식필드 == \"consequent\" && 부모종류 == 511)\n      if 문장자리 {\n        if 노드.시작 < 이전문장시작 {\n          return Err(\"영상 전용 줄댓글 문장들이 원본 차례가 아닙니다\")\n        }\n        문장들.push(순번)\n        이전문장시작 = 노드.시작\n      }\n    }\n    if 노드종류(2, 노드.코드워드) == 120 {\n      if 노드.끝 < 이전댓글끝 {\n        return Err(\"영상 전용 줄댓글들이 원본 차례가 아닙니다\")\n      }\n      댓글들.push(순번)\n      이전댓글끝 = 노드.끝\n    }\n    순번 = 순번 + 1\n  }\n  let mut 문장색인 = 0\n  for 댓글순번 in 댓글들 {\n    let 댓글 = 구조.노드들[댓글순번]\n    while 문장색인 < 문장들.length &&\n      구조.노드들[문장들[문장색인]].시작 < 댓글.끝 {\n      문장색인 = 문장색인 + 1\n    }\n    if 문장색인 < 문장들.length {\n      let 문장순번 = 문장들[문장색인]\n      기대행들[문장순번] = 기대행들[문장순번] + 1\n    }\n  }\n  순번 = 0\n  while 순번 < 구조.노드들.length {\n    let 노드 = 구조.노드들[순번]\n    let 실제 = 스칼라정수(노드, \"emission.imageOnlyLeadingLineCommentRows\")\n    if 실제 != 기대행들[순번] {\n      return Err(\"영상 전용 줄댓글 행수가 원본 기하와 다릅니다: 순번 {순번}\")\n    }\n    순번 = 순번 + 1\n  }\n  Ok(true)\n}\n",
      "sourceSha256": "b273f9fd9761f686e76bb82f2904beabdf861968ad0565a4903af24dd8e1327c"
    },
    {
      "path": "topaz/src/printers/javascript/comments.tpz",
      "language": "topaz",
      "bytes": 9292,
      "sha256": "b959fda6e353ff1fe8339f42c70874dac5d3bba7a61ae01cef0685da4b1a2c4d",
      "content": "// Comment positions, line-comment prefixes, and comment attachment for the\n// JavaScript and TypeScript printer.\n\nimport nodes { 노드종류 }\nimport print { 글평평하게, 인쇄조각이음, 인쇄조각자름, 인쇄조각접두, 줄과들여쓰기 }\nimport printer_state { 댓글노드, 본문값색인, 인쇄글조각결과, 인쇄조각결과합치기, 준비된인쇄상태 }\nimport structure { 구조노드, 구조입력, 스칼라논리 }\nimport types { 댓글고정, 인쇄조각판 }\n\nfunction 댓글시작색인(준비: 준비된인쇄상태, 시작: int) -> int {\n  let mut 낮음 = 0\n  let mut 높음 = 준비.댓글시작들.length\n  while 낮음 < 높음 {\n    let 가운데 = 낮음 + (높음 - 낮음) / 2\n    if 준비.댓글시작들[가운데] < 시작 { 낮음 = 가운데 + 1 }\n    else { 높음 = 가운데 }\n  }\n  낮음\n}\n\nfunction 댓글끝색인(준비: 준비된인쇄상태, 끝: int) -> int {\n  let mut 낮음 = 0\n  let mut 높음 = 준비.댓글끝들.length\n  while 낮음 < 높음 {\n    let 가운데 = 낮음 + (높음 - 낮음) / 2\n    if 준비.댓글끝들[가운데] <= 끝 { 낮음 = 가운데 + 1 }\n    else { 높음 = 가운데 }\n  }\n  낮음\n}\n\nfunction 댓글바이트사이(준비: 준비된인쇄상태, 시작: int, 끝: int) -> int {\n  if 준비.댓글시작들.length == 0 { return 0 }\n  let 첫 = 댓글시작색인(준비, 시작)\n  let 뒤 = 댓글끝색인(준비, 끝)\n  if 뒤 <= 첫 { 0 }\n  else { 준비.댓글바이트누적들[뒤] - 준비.댓글바이트누적들[첫] }\n}\n\nexport function 댓글수사이(준비: 준비된인쇄상태, 시작: int, 끝: int) -> int {\n  if 준비.댓글시작들.length == 0 { return 0 }\n  let 첫 = 댓글시작색인(준비, 시작)\n  let 뒤 = 댓글끝색인(준비, 끝)\n  if 뒤 <= 첫 { 0 } else { 뒤 - 첫 }\n}\n\nexport function 줄댓글수사이(준비: 준비된인쇄상태, 시작: int, 끝: int) -> int {\n  if 준비.댓글시작들.length == 0 { return 0 }\n  let 첫 = 댓글시작색인(준비, 시작)\n  let 뒤 = 댓글끝색인(준비, 끝)\n  if 뒤 <= 첫 { 0 }\n  else { 준비.줄댓글수누적들[뒤] - 준비.줄댓글수누적들[첫] }\n}\n\nexport function 줄댓글접두(줄수: int, 공백수: int, 댓글수: int) -> string {\n  if 줄수 <= 0 { return \"\" }\n  let mut 결과 = \"\"\n  let mut 빈줄 = 줄수 - 댓글수\n  if 빈줄 < 0 { 빈줄 = 0 }\n  while 빈줄 > 0 { 결과 = 결과 + \"\\n\"; 빈줄 = 빈줄 - 1 }\n  let mut 남은댓글 = if 댓글수 > 줄수 { 줄수 } else { 댓글수 }\n  while 남은댓글 > 0 {\n    let mut 댓글공백 = 공백수\n    while 댓글공백 > 0 { 결과 = 결과 + \" \"; 댓글공백 = 댓글공백 - 1 }\n    결과 = 결과 + \"//\\n\"\n    남은댓글 = 남은댓글 - 1\n  }\n  let mut 공백 = 공백수\n  while 공백 > 0 { 결과 = 결과 + \" \"; 공백 = 공백 - 1 }\n  결과\n}\n\nexport function 행끝줄댓글접두(\n  줄수: int,\n  공백수: int,\n  행끝댓글수: int,\n  나머지댓글수: int\n) -> string {\n  let mut 결과 = \"\"\n  let mut 댓글색인 = 0\n  while 댓글색인 < 행끝댓글수 {\n    if 댓글색인 == 0 { 결과 = 결과 + \" \" }\n    else {\n      let mut 공백 = 공백수\n      while 공백 > 0 { 결과 = 결과 + \" \"; 공백 = 공백 - 1 }\n    }\n    결과 = 결과 + \"//\\n\"\n    댓글색인 = 댓글색인 + 1\n  }\n  let 나머지줄수 = if 줄수 > 행끝댓글수 { 줄수 - 행끝댓글수 } else { 0 }\n  결과 + 줄댓글접두(나머지줄수, 공백수, 나머지댓글수)\n}\n\nexport function 행끝줄댓글있음(준비: 준비된인쇄상태, 시작: int, 끝: int, 행: int) -> bool {\n  let mut 색인 = 댓글시작색인(준비, 시작)\n  let 뒤 = 댓글끝색인(준비, 끝)\n  while 색인 < 뒤 {\n    if 준비.댓글행들[색인] == 행 { return true }\n    색인 = 색인 + 1\n  }\n  false\n}\n\nfunction 오프셋간격(준비: 준비된인쇄상태, 시작: int, 끝: int) -> int {\n  let 간격 = if 준비.댓글시작들.length == 0 { 끝 - 시작 }\n    else { 끝 - 시작 - 댓글바이트사이(준비, 시작, 끝) }\n  if 간격 < 0 { 0 } else { 간격 }\n}\n\nfunction 댓글값글(준비: 준비된인쇄상태, 값색인: int) -> string {\n  let mut 순번 = 0\n  while 순번 < 준비.구조.노드들.length {\n    if 본문값색인(준비, 순번) == 값색인 && 댓글노드(준비, 준비.구조.노드들[순번]) {\n      let 값 = 준비.본문값들[값색인]\n      if 노드종류(준비.언어번호, 준비.구조.노드들[순번].코드워드) == 119 {\n        return \"/*\" + 값 + \"*/\"\n      }\n      return \"//\" + 값\n    }\n    순번 = 순번 + 1\n  }\n  \"\"\n}\n\nfunction 댓글고정값인가(준비: 준비된인쇄상태, 값색인: int) -> bool {\n  for 고정 in 준비.댓글고정들 { if 고정.값색인 == 값색인 { return true } }\n  false\n}\n\nexport function 댓글붙이기조각(준비: 준비된인쇄상태, 순번: int, 깊이: int, 몸: int) -> Result<int, string> {\n  if 준비.댓글고정들.length == 0 { return Ok(몸) }\n  let mut 앞 = 0\n  let mut 속 = 0\n  let mut 뒤 = 0\n  for 고정 in 준비.댓글고정들 {\n    if 고정.붙임노드순번 == 순번 {\n      let 댓글 = 댓글값글(준비, 고정.값색인)\n      if 고정.놓임 == \"leading\" {\n        let 줄수 = if 댓글.startsWith(\"//\") && 고정.뒤줄수 == 0 { 1 } else { 고정.뒤줄수 }\n        앞 = 인쇄조각결과합치기(준비, [\n          Ok(앞), 인쇄글조각결과(준비, 댓글),\n          인쇄글조각결과(준비, 줄과들여쓰기(줄수, 깊이))\n        ])?\n      } else if 고정.놓임 == \"trailing\" {\n        if 고정.앞줄수 == 0 {\n          뒤 = 인쇄조각결과합치기(준비, [\n            Ok(뒤), 인쇄글조각결과(준비, \" \"), 인쇄글조각결과(준비, 댓글)\n          ])?\n        } else {\n          뒤 = 인쇄조각결과합치기(준비, [\n            Ok(뒤), 인쇄글조각결과(준비, 줄과들여쓰기(고정.앞줄수, 깊이)),\n            인쇄글조각결과(준비, 댓글)\n          ])?\n        }\n      } else {\n        let 뒤줄수 = if 댓글.startsWith(\"//\") && 고정.뒤줄수 == 0 { 1 } else { 고정.뒤줄수 }\n        속 = 인쇄조각결과합치기(준비, [\n          Ok(속), 인쇄글조각결과(준비, 줄과들여쓰기(고정.앞줄수, 깊이 + 1)),\n          인쇄글조각결과(준비, 댓글),\n          인쇄글조각결과(준비, 줄과들여쓰기(뒤줄수, 깊이 + 1))\n        ])?\n      }\n    }\n  }\n  let mut 가운데 = 몸\n  if 준비.조각판.길이들[속] > 0 {\n    let 몸길이 = 준비.조각판.길이들[몸]\n    let 여는몸 = 몸길이 >= 2 && (\n      인쇄조각접두(준비.조각판, 몸, \"\\{\")? ||\n      인쇄조각접두(준비.조각판, 몸, \"(\")? ||\n      인쇄조각접두(준비.조각판, 몸, \"[\")?\n    )\n    if 여는몸 {\n      가운데 = 인쇄조각결과합치기(준비, [\n        인쇄조각자름(준비.조각판, 몸, 0, 1),\n        Ok(속),\n        인쇄조각자름(준비.조각판, 몸, 1, 몸길이)\n      ])?\n    } else {\n      가운데 = 인쇄조각이음(준비.조각판, 속, 몸)\n    }\n  }\n  인쇄조각결과합치기(준비, [Ok(앞), Ok(가운데), Ok(뒤)])\n}\n\nexport function 댓글머리(준비: 준비된인쇄상태) -> string {\n  if 준비.본문값들.length == 0 { return \"\" }\n  let mut 글 = \"\"; let mut 순번 = 0\n  while 순번 < 준비.구조.노드들.length {\n    let 노드 = 준비.구조.노드들[순번]\n    if 댓글노드(준비, 노드) && !댓글고정값인가(준비, 본문값색인(준비, 순번)) {\n      if 글 != \"\" { 글 = 글 + \"\\n\" }\n      let 값 = 준비.본문값들[본문값색인(준비, 순번)]\n      if 노드종류(준비.언어번호, 노드.코드워드) == 119 { 글 = 글 + \"/*\" + 값 + \"*/\" }\n      else { 글 = 글 + \"//\" + 값 }\n      글 = 글평평하게(글)\n    }\n    순번 = 순번 + 1\n  }\n  글\n}\n\nexport function 합성내보내기머리(준비: 준비된인쇄상태) -> string {\n  if 준비.본문값들.length > 0 { return \"\" }\n  let mut 횟수들: Array<int> = []\n  let mut 내보내기뿐들: Array<bool> = []\n  let mut 순번 = 0\n  while 순번 < 준비.구조.노드들.length {\n    횟수들.push(0); 내보내기뿐들.push(false); 순번 = 순번 + 1\n  }\n  순번 = 0\n  while 순번 < 준비.구조.노드들.length {\n    let 노드 = 준비.구조.노드들[순번]\n    if 노드.식별자있음 {\n      let 류 = 노드.식별자류번호\n      횟수들[류] = 횟수들[류] + 1\n      if 노드.부모순번 >= 0 {\n        let 부모 = 준비.구조.노드들[노드.부모순번]\n        if 노드종류(준비.언어번호, 부모.코드워드) == 737 && 노드.자식필드 == \"local\" && 부모.부모순번 >= 0 {\n          let 선언 = 준비.구조.노드들[부모.부모순번]\n          if 노드종류(준비.언어번호, 선언.코드워드) == 738 &&\n            !스칼라논리(선언, \"child.source.present\") { 내보내기뿐들[류] = true }\n        }\n      }\n    }\n    순번 = 순번 + 1\n  }\n  let mut 글 = \"\"; let mut 류 = 0\n  while 류 < 횟수들.length {\n    if 내보내기뿐들[류] && 횟수들[류] == 1 {\n      if 글 != \"\" { 글 = 글 + \"\\n\" }\n      글 = 글 + \"const \" + 준비.익명이름들[류] + \" = undefined;\"\n      글 = 글평평하게(글)\n    }\n    류 = 류 + 1\n  }\n  글\n}\n",
      "sourceSha256": "b959fda6e353ff1fe8339f42c70874dac5d3bba7a61ae01cef0685da4b1a2c4d"
    },
    {
      "path": "topaz/src/printers/javascript/layout.tpz",
      "language": "topaz",
      "bytes": 30347,
      "sha256": "7da2f11dc011bd51e88faacb149d2b0bbeb34210f18db4cb645ac00990f1ada2",
      "content": "// Row, column, and indentation decisions of the JavaScript and TypeScript printer,\n// taken from the geometry the image carries.\n\nimport nodes { 노드종류 }\nimport print { 인쇄조각평평하게, 인쇄조각행수 }\nimport printer_cursor { 토파즈언어유티에프십육폭 }\nimport printer_state { 자식순번, 자식순번들, 준비된인쇄상태 }\nimport printers.javascript.comments { 댓글수사이, 줄댓글수사이, 줄댓글접두, 행끝줄댓글있음, 행끝줄댓글접두 }\nimport structure { 구조노드, 구조입력, 스칼라논리, 스칼라정수 }\nimport types { 인쇄조각판 }\n\nexport function 명세닫기공백(준비: 준비된인쇄상태, 순번들: Array<int>) -> string {\n  if !준비.오프셋배치 || 순번들.length == 0 { return \" \" }\n  let 마지막 = 준비.구조.노드들[순번들[순번들.length - 1]]\n  if 스칼라논리(마지막, \"spelling.trailingComma\") { \"\" } else { \" \" }\n}\n\nexport function 모듈출처접두(준비: 준비된인쇄상태, 부모순번: int) -> string {\n  let 출처순번 = 자식순번(준비, 부모순번, \"source\")\n  if 출처순번 < 0 { return \" from \" }\n  \" from\" + 가장자리접두(준비, 출처순번, \" \")\n}\n\n// The row the printer is on when a child begins: the end row of the last\n// direct child that ends before the child starts, and the parent's own start\n// row when there is none. This is the predecessor the kernel oracle derives in\n// `delimiterRelativeGaps`, and the sibling chain visits exactly the parent's\n// own children in the same order the projection records them.\nexport function 직접앞끝행(준비: 준비된인쇄상태, 부모순번: int, 순번: int) -> int {\n  let 부모 = 준비.구조.노드들[부모순번]\n  let 현재 = 준비.구조.노드들[순번]\n  let mut 끝행 = 스칼라정수(부모, \"startRow\")\n  let mut 끝 = 부모.시작\n  let mut 후보순번 = 준비.첫자식들[부모순번]\n  while 후보순번 >= 0 {\n    let 후보 = 준비.구조.노드들[후보순번]\n    if 후보.끝 <= 현재.시작 && 후보.끝 > 끝 {\n      끝 = 후보.끝\n      끝행 = 스칼라정수(후보, \"endRow\")\n    }\n    후보순번 = 준비.다음형제들[후보순번]\n  }\n  끝행\n}\n\n// The row the printer is on when a parameter list begins: after the name and\n// the type parameters the head already emitted, not at the head's own start.\nexport function 매개기준끝행(준비: 준비된인쇄상태, 부모순번: int) -> int {\n  let 부모 = 준비.구조.노드들[부모순번]\n  let mut 끝행 = 스칼라정수(부모, \"startRow\")\n  let 이름순번 = 자식순번(준비, 부모순번, \"id\")\n  if 이름순번 >= 0 {\n    끝행 = 스칼라정수(준비.구조.노드들[이름순번], \"endRow\")\n  }\n  let 키순번 = 자식순번(준비, 부모순번, \"key\")\n  if 키순번 >= 0 {\n    끝행 = 스칼라정수(준비.구조.노드들[키순번], \"endRow\")\n  }\n  // A head that prints its parameter list WITHOUT parentheses emits nothing\n  // before the parameter, so the parameter is already where the arrow's own\n  // edge put the printer and this list must not carry the row a second time.\n  let 괄호생략매개들 = 자식순번들(준비, 부모순번, \"params\")\n  if 화살표괄호생략인가(준비, 부모순번) && 괄호생략매개들.length == 1 {\n    끝행 = 스칼라정수(준비.구조.노드들[괄호생략매개들[0]], \"startRow\")\n  }\n  let 형식매개 = 자식순번(준비, 부모순번, \"typeParameters\")\n  if 형식매개 >= 0 {\n    let 형식들 = 자식순번들(준비, 형식매개, \"params\")\n    끝행 = if 형식들.length == 0 {\n      스칼라정수(준비.구조.노드들[형식매개], \"endRow\")\n    } else {\n      스칼라정수(준비.구조.노드들[형식들[형식들.length - 1]], \"endRow\")\n    }\n  }\n  끝행\n}\n\nfunction 매개목록다중행(준비: 준비된인쇄상태, 부모순번: int, 순번들: Array<int>) -> bool {\n  if 순번들.length == 0 { return false }\n  let 첫 = 준비.구조.노드들[순번들[0]]\n  if 스칼라정수(첫, \"startRow\") > 매개기준끝행(준비, 부모순번) { return true }\n  let mut 색인 = 1\n  while 색인 < 순번들.length {\n    let 이전 = 준비.구조.노드들[순번들[색인 - 1]]\n    let 현재 = 준비.구조.노드들[순번들[색인]]\n    if 스칼라정수(현재, \"startRow\") > 스칼라정수(이전, \"endRow\") { return true }\n    색인 = 색인 + 1\n  }\n  false\n}\n\nexport function 매개뒤형식접두(준비: 준비된인쇄상태, 부모순번: int, 순번들: Array<int>) -> string {\n  if !준비.오프셋배치 { return \"\" }\n  let 반환순번 = 자식순번(준비, 부모순번, \"returnType\")\n  if 반환순번 < 0 { return \"\" }\n  let 기준행 = if 순번들.length > 0 {\n    스칼라정수(준비.구조.노드들[순번들[순번들.length - 1]], \"endRow\")\n  } else { 매개기준끝행(준비, 부모순번) }\n  let 줄수 = 스칼라정수(준비.구조.노드들[반환순번], \"startRow\") - 기준행\n  if 줄수 > 0 { 줄접두(줄수, 노드들여쓰기(준비, 반환순번)) } else { \"\" }\n}\n\nexport function 줄접두(줄수: int, 공백수: int) -> string {\n  if 줄수 <= 0 { return \"\" }\n  let mut 글 = \"\"\n  let mut 남은줄 = 줄수\n  while 남은줄 > 0 { 글 = 글 + \"\\n\"; 남은줄 = 남은줄 - 1 }\n  let mut 남은공백 = 공백수\n  while 남은공백 > 0 { 글 = 글 + \" \"; 남은공백 = 남은공백 - 1 }\n  글\n}\n\n// The reference printer is @babel/generator run with `retainLines`\n// (packages/kernel/src/print-projection-to-source.ts). A node whose carried row\n// is below the current row is reached by `Printer.catchUp`, which emits bare\n// line feeds; the column that follows is added lazily by `Printer._maybeIndent`\n// and is exactly `Printer._indent`. That counter is moved only by\n// `Printer.indent` / `Printer.dedent`, so the column after a carried row break\n// is the sum of the indent decisions taken on the path from the program root\n// down to the node - never the carried startColumn, and never a depth estimate.\n//\n// Which edges take a decision is DERIVED from the generator's own call sites\n// into `spec/g6-f/babel-generator-indent-inventory.v1.json` by\n// `scripts/generate-babel-indent-inventory.mjs`, and\n// `topaz/courts/printer-identity.test.mjs` asserts this table against that\n// inventory, so a decision this table does not carry - or one the generator\n// stops taking - is a red court rather than a silent byte divergence.\n//\n// A decision belongs to a PARENT KIND and a CHILD FIELD together, never to a\n// parent kind alone: `SwitchCase` indents its `consequent` and prints its\n// `test` at the enclosing level, and reading the field is what keeps a `case`\n// head out of the case body's column.\n//\n// BEGIN BABEL INDENT INVENTORY TABLE\nfunction 가장자리들여쓰기(준비: 준비된인쇄상태, 자식순번: int) -> int {\n  if 자식순번 < 0 { return 0 }\n  let 자식 = 준비.구조.노드들[자식순번]\n  let 부모순번 = 자식.부모순번\n  if 부모순번 < 0 { return 0 }\n  let 부모종류 = 노드종류(준비.언어번호, 준비.구조.노드들[부모순번].코드워드)\n  let 필드 = 자식.자식필드\n  // mode `always`\n  if (부모종류 == 410 && (필드 == \"body\" || 필드 == \"directives\")) ||\n    (부모종류 == 603 && 필드 == \"body\") ||\n    (부모종류 == 609 && 필드 == \"body\") ||\n    (부모종류 == 720 && 필드 == \"body\") ||\n    (부모종류 == 731 && 필드 == \"body\") ||\n    (부모종류 == 717 && 필드 == \"members\") ||\n    (부모종류 == 734 && 필드 == \"members\") ||\n    (부모종류 == 510 && 필드 == \"cases\") ||\n    (부모종류 == 511 && 필드 == \"consequent\") ||\n    ((부모종류 == 203 || 부모종류 == 204) && 필드 == \"properties\") {\n    return 2\n  }\n  // mode `conditional:node.declarations.length > 1`\n  if 부모종류 == 409 && 필드 == \"declarations\" {\n    if 자식순번들(준비, 부모순번, \"declarations\").length > 1 { return 2 }\n    return 0\n  }\n  // mode `row-dependent`. Every generator that prints a `decorators` list\n  // prints it through `printJoin` with no indent argument, on every kind that\n  // can hold one, so the field alone decides it.\n  if 필드 == \"decorators\" ||\n    ((부모종류 == 210 || 부모종류 == 211 || 부모종류 == 212) &&\n      필드 == \"arguments\") ||\n    (부모종류 == 310 && 필드 == \"expressions\") ||\n    ((부모종류 == 736 || 부모종류 == 738) &&\n      (필드 == \"specifiers\" || 필드 == \"attributes\" || 필드 == \"assertions\")) ||\n    ((부모종류 == 601 || 부모종류 == 602) && 필드 == \"implements\") ||\n    (부모종류 == 721 && 필드 == \"extends\") ||\n    ((부모종류 == 712 || 부모종류 == 713) && 필드 == \"params\") ||\n    (부모종류 == 715 && 필드 == \"types\") {\n    return 목록행의존들여쓰기(준비, 부모순번, 필드)\n  }\n  0\n}\n// END BABEL INDENT INVENTORY TABLE\n\n// `printJoin`'s own run-time rule under `retainLines`: a list whose `indent`\n// argument is absent indents exactly when its first element carries a row\n// other than the row the printer is on when the list begins. An element the\n// image carries explicit parentheses for is rebuilt as a\n// `ParenthesizedExpression`, which carries no position at all, and a list whose\n// first element has no position never indents.\nfunction 목록행의존들여쓰기(\n  준비: 준비된인쇄상태,\n  부모순번: int,\n  필드: string\n) -> int {\n  let 요소들 = 자식순번들(준비, 부모순번, 필드)\n  if 요소들.length == 0 { return 0 }\n  let 첫순번 = 요소들[0]\n  let 첫 = 준비.구조.노드들[첫순번]\n  if 스칼라정수(첫, \"spelling.parentheses\") > 0 { return 0 }\n  let 부모종류 = 노드종류(준비.언어번호, 준비.구조.노드들[부모순번].코드워드)\n  let 앞행 = if (부모종류 == 210 || 부모종류 == 211 || 부모종류 == 212) &&\n    필드 == \"arguments\" {\n    호출대상끝행(준비, 부모순번)\n  } else { 직접앞끝행(준비, 부모순번, 첫순번) }\n  // `printJoin` reads the element's OWN carried position for this decision,\n  // not the row its head first emits on, so a bare arrow whose parameter sits\n  // a row below still leaves the list unindented.\n  if 스칼라정수(첫, \"startRow\") != 앞행 { return 2 }\n  0\n}\n\n// `Printer._indent` while the node's own tokens are printed.\nexport function 노드들여쓰기(준비: 준비된인쇄상태, 순번: int) -> int {\n  if 순번 < 0 { return 0 }\n  let mut 합 = 0\n  let mut 현재 = 순번\n  while 현재 >= 0 {\n    합 = 합 + 가장자리들여쓰기(준비, 현재)\n    현재 = 준비.구조.노드들[현재].부모순번\n  }\n  합\n}\n\n// The ONE geometry-carrying edge primitive. Its domain is every\n// parent-child edge the guest printer emits, not a list of node kinds that\n// somebody remembered: the row it carries is the difference between the child's\n// carried startRow and the row the printer is on when the child begins, which\n// the carried geometry names as `직접앞끝행`, and the column it carries is\n// `노드들여쓰기`. Wherever a guest edge used to print a constant separator it\n// now prints that constant through this primitive, so the constant survives\n// only as the SAME-ROW spelling of one edge and never as its geometry.\n//\n// A child the image carries explicit parentheses for takes its row break INSIDE\n// those parentheses: the reference printer emits `(` and only then catches the\n// row up, because the parenthesis it rebuilds carries no position of its own.\n// `순번인쇄조각계산` owns that break, so this primitive leaves such an edge on\n// one row and the constant separator stands.\n// The row on which a node BEGINS PRINTING is the row of the first leaf it\n// emits, which is its own carried startRow for every node whose head emits a\n// token - and its parameter's row for a bare arrow head, which emits nothing\n// before the parameter.\nexport function 유효시작행(준비: 준비된인쇄상태, 순번: int) -> int {\n  if 화살표머리첫잎이매개인가(준비, 순번) {\n    let 매개들 = 자식순번들(준비, 순번, \"params\")\n    if 매개들.length == 1 {\n      return 스칼라정수(준비.구조.노드들[매개들[0]], \"startRow\")\n    }\n  }\n  스칼라정수(준비.구조.노드들[순번], \"startRow\")\n}\n\nfunction 가장자리행수(준비: 준비된인쇄상태, 자식순번: int) -> int {\n  if !준비.오프셋배치 || 자식순번 < 0 { return 0 }\n  let 자식 = 준비.구조.노드들[자식순번]\n  if 자식.부모순번 < 0 { return 0 }\n  if 스칼라정수(자식, \"spelling.parentheses\") > 0 { return 0 }\n  let 줄수 = 유효시작행(준비, 자식순번) -\n    직접앞끝행(준비, 자식.부모순번, 자식순번)\n  if 줄수 < 0 { 0 } else { 줄수 }\n}\n\nexport function 가장자리접두(\n  준비: 준비된인쇄상태,\n  자식순번: int,\n  같은행: string\n) -> string {\n  let 줄수 = 가장자리행수(준비, 자식순번)\n  if 줄수 > 0 { 줄접두(줄수, 노드들여쓰기(준비, 자식순번)) } else { 같은행 }\n}\n\n// The row the printer is on after emitting a piece. The piece counts its own\n// row events, so this is the printer's real position rather than the position\n// the image carries for a node the printer may have emitted differently, which\n// is the position `catchUp` compares against.\nexport function 조각끝행(준비: 준비된인쇄상태, 시작행: int, 조각: int) -> int {\n  시작행 + 인쇄조각행수(준비.조각판, 조각)\n}\n\n// The column the printer is on after emitting a piece that contains at least\n// one row event, measured the way the reference printer's buffer measures it:\n// UTF-16 code units since the last row event. Walking the rope from the right\n// stops at the first piece that carries a row event, so only the final row is\n// ever flattened.\nfunction 조각끝열(준비: 준비된인쇄상태, 조각: int) -> Result<int, string> {\n  let mut 열 = 0\n  let mut 쌓임: Array<int> = []\n  let mut 꼭대기 = 0\n  let mut 현재 = 조각\n  let mut 걸음 = 0\n  let 최대걸음 = 준비.조각판.종류들.length * 2 + 32\n  while 걸음 <= 최대걸음 {\n    걸음 = 걸음 + 1\n    if 현재 > 0 && 준비.조각판.종류들[현재] == 2 {\n      let 왼 = 준비.조각판.왼들[현재]\n      if 꼭대기 < 쌓임.length { 쌓임[꼭대기] = 왼 } else { 쌓임.push(왼) }\n      꼭대기 = 꼭대기 + 1\n      현재 = 준비.조각판.오른들[현재]\n      continue\n    }\n    if 현재 > 0 {\n      let 글 = 인쇄조각평평하게(준비.조각판, 현재)?\n      let 글자들 = 글.scalars()\n      let mut 색인 = 글자들.length\n      let mut 꼬리 = 0\n      let mut 행끝 = false\n      while 색인 > 0 && !행끝 {\n        let 글자 = 글자들[색인 - 1]\n        if 글자 == \"\\n\" || 글자 == \"\\r\" || 글자 == \" \" || 글자 == \" \" {\n          행끝 = true\n        } else {\n          꼬리 = 꼬리 + 토파즈언어유티에프십육폭(글자)\n          색인 = 색인 - 1\n        }\n      }\n      열 = 열 + 꼬리\n      if 행끝 { return Ok(열) }\n    }\n    if 꼭대기 == 0 { return Ok(열) }\n    꼭대기 = 꼭대기 - 1\n    현재 = 쌓임[꼭대기]\n  }\n  Ok(열)\n}\n\nfunction 무해리터럴식문장인가(준비: 준비된인쇄상태, 순번: int) -> bool {\n  if 순번 < 0 ||\n    노드종류(준비.언어번호, 준비.구조.노드들[순번].코드워드) != 401 {\n    return false\n  }\n  let 식순번 = 자식순번(준비, 순번, \"expression\")\n  if 식순번 < 0 { return false }\n  let 종류 = 노드종류(준비.언어번호, 준비.구조.노드들[식순번].코드워드)\n  종류 == 108 || 종류 == 109 || 종류 == 110 || 종류 == 111 || 종류 == 112\n}\n\nexport function 문장접두(\n  준비: 준비된인쇄상태,\n  순번들: Array<int>,\n  색인: int,\n  추가행: int\n) -> string {\n  let 현재 = 준비.구조.노드들[순번들[색인]]\n  let 부모순번 = 현재.부모순번\n  let 부모 = 준비.구조.노드들[부모순번]\n  let 부모종류 = 노드종류(준비.언어번호, 부모.코드워드)\n  let 들여쓰기 = 노드들여쓰기(준비, 순번들[색인])\n  let mut 시작행 = 스칼라정수(부모, \"startRow\")\n  let mut 시작 = 부모.시작\n  if 색인 > 0 {\n    let 이전 = 준비.구조.노드들[순번들[색인 - 1]]\n    시작 = 이전.끝\n    시작행 = 스칼라정수(이전, \"endRow\")\n  }\n  else {\n    // The first statement of a list begins on the row the printer is on, which\n    // is the end row of the last direct child the parent emitted before it -\n    // a directive, an interpreter line, or a `case` head - and the parent's own\n    // start row when there is none. Naming the fields that can precede it is\n    // what put a `case` body one row below its own head, so the walk asks the\n    // projection instead. A detached comment is not emitted here; its rows are\n    // carried by the comment machinery below.\n    let mut 후보순번 = 준비.첫자식들[부모순번]\n    while 후보순번 >= 0 {\n      let 후보 = 준비.구조.노드들[후보순번]\n      let 후보종류 = 노드종류(준비.언어번호, 후보.코드워드)\n      if 후보종류 != 119 && 후보종류 != 120 &&\n        후보.끝 <= 현재.시작 && 후보.끝 > 시작 {\n        시작 = 후보.끝\n        시작행 = 스칼라정수(후보, \"endRow\")\n      }\n      후보순번 = 준비.다음형제들[후보순번]\n    }\n  }\n  let mut 줄수 = 스칼라정수(현재, \"startRow\") - 시작행 + 추가행\n  if 색인 > 0 && 준비.언어번호 == 2 {\n    줄수 = 줄수 - 준비.영상댓글누적추가행들[순번들[색인 - 1]]\n  }\n  if 부모종류 == 102 && 색인 > 0 && 색인 + 1 == 순번들.length && 줄수 == 0 &&\n    무해리터럴식문장인가(준비, 순번들[색인 - 1]) &&\n    무해리터럴식문장인가(준비, 순번들[색인]) { 줄수 = 1 }\n  if 줄수 < 0 { 줄수 = 0 }\n  let 출력들여쓰기 = 들여쓰기\n  if 준비.언어번호 == 2 {\n    let 계획댓글수 = 스칼라정수(현재, \"emission.imageOnlyLeadingLineCommentRows\")\n    let 실제댓글수 = 줄댓글수사이(준비, 시작, 현재.시작)\n    let 댓글수 = if 실제댓글수 > 계획댓글수 { 실제댓글수 } else { 계획댓글수 }\n    let 출력줄수 = if 줄수 > 계획댓글수 { 줄수 } else { 계획댓글수 }\n    if 색인 > 0 && 계획댓글수 > 0 && 준비.본문값들.length == 0 {\n      let 이전 = 준비.구조.노드들[순번들[색인 - 1]]\n      let 이전안댓글수 = 줄댓글수사이(준비, 이전.시작, 이전.끝)\n      let 행끝댓글수 = if 이전안댓글수 < 계획댓글수 {\n        이전안댓글수\n      } else { 계획댓글수 }\n      if 행끝댓글수 > 0 {\n        return 행끝줄댓글접두(\n          출력줄수,\n          출력들여쓰기,\n          행끝댓글수,\n          댓글수 - 행끝댓글수\n        )\n      }\n    }\n    let 접두 = 줄댓글접두(출력줄수, 출력들여쓰기, 댓글수)\n    if 색인 > 0 && 접두.startsWith(\"//\") &&\n      (계획댓글수 > 0 || 행끝줄댓글있음(준비, 시작, 현재.시작, 시작행)) {\n      return \" \" + 접두\n    }\n    return 접두\n  }\n  줄접두(줄수, 출력들여쓰기)\n}\n\nexport function 문장부족행(준비: 준비된인쇄상태, 순번: int, 조각: int) -> int {\n  let 노드 = 준비.구조.노드들[순번]\n  let 기대행 = 스칼라정수(노드, \"endRow\") - 스칼라정수(노드, \"startRow\")\n  let 실제행 = 인쇄조각행수(준비.조각판, 조각)\n  if 기대행 > 실제행 { 기대행 - 실제행 } else { 0 }\n}\n\nfunction 문장목록다중행(준비: 준비된인쇄상태, 순번들: Array<int>) -> bool {\n  if 순번들.length == 0 { return false }\n  let 첫 = 준비.구조.노드들[순번들[0]]\n  let 부모순번 = 첫.부모순번\n  let 부모 = 준비.구조.노드들[부모순번]\n  let 부모종류 = 노드종류(준비.언어번호, 부모.코드워드)\n  if 부모종류 == 511 { return false }\n  let mut 시작행 = 스칼라정수(부모, \"startRow\")\n  let mut 시작 = 부모.시작\n  for 후보 in 준비.구조.노드들 {\n    if 후보.부모순번 == 부모순번 &&\n      (후보.자식필드 == \"directives\" || 후보.자식필드 == \"interpreter\") &&\n      후보.끝 <= 첫.시작 && 후보.끝 > 시작 {\n      시작 = 후보.끝\n      시작행 = 스칼라정수(후보, \"endRow\")\n    }\n  }\n  let 첫줄수 = 스칼라정수(첫, \"startRow\") - 시작행\n  if 첫줄수 > 0 { return true }\n  let mut 색인 = 1\n  while 색인 < 순번들.length {\n    let 이전 = 준비.구조.노드들[순번들[색인 - 1]]\n    let 현재 = 준비.구조.노드들[순번들[색인]]\n    let 줄수 = 스칼라정수(현재, \"startRow\") - 스칼라정수(이전, \"endRow\")\n    if 줄수 > 0 { return true }\n    색인 = 색인 + 1\n  }\n  false\n}\n\n// Whether the arrow's parameter list prints WITHOUT parentheses. This answers\n// one question only, and it is the same question the kind 308 emitter answers\n// when it builds `괄호없음`.\nexport function 화살표괄호생략인가(준비: 준비된인쇄상태, 화살표순번: int) -> bool {\n  if 화살표순번 < 0 { return false }\n  let 화살표 = 준비.구조.노드들[화살표순번]\n  if 노드종류(준비.언어번호, 화살표.코드워드) != 308 ||\n    자식순번(준비, 화살표순번, \"typeParameters\") >= 0 ||\n    자식순번(준비, 화살표순번, \"returnType\") >= 0 ||\n    자식순번(준비, 화살표순번, \"predicate\") >= 0 {\n    return false\n  }\n  let 매개들 = 자식순번들(준비, 화살표순번, \"params\")\n  if 매개들.length != 1 { return false }\n  let 매개 = 준비.구조.노드들[매개들[0]]\n  노드종류(준비.언어번호, 매개.코드워드) == 106 &&\n    !스칼라논리(매개, \"optional\") &&\n    자식순번들(준비, 매개들[0], \"decorators\").length == 0 &&\n    자식순번(준비, 매개들[0], \"typeAnnotation\") < 0\n}\n\n// Whether the FIRST LEAF the arrow head emits is the parameter itself,\n// which is the only case in which the parameter's carried row is the arrow's\n// carried row. This is not a list of modifiers to exclude: it quantifies over\n// the head's own emit sequence in the kind 308 emitter, which is exactly\n//   [ \"async \" when the async scalar is set ]\n//   [ the typeParameters child, when present ]\n//   [ \"(\" when the parameter list keeps its parentheses ]\n//   [ the first parameter ]\n// so the head begins at the parameter precisely when the first three are all\n// empty. Any modifier added to that head - a further keyword, another type\n// position, a decorator list - lands in the sequence above and is answered\n// here without touching this predicate, because the question asked is \"does\n// anything print before the parameter\", never \"is it one of these\".\nexport function 화살표머리첫잎이매개인가(준비: 준비된인쇄상태, 화살표순번: int) -> bool {\n  if !화살표괄호생략인가(준비, 화살표순번) { return false }\n  let 화살표 = 준비.구조.노드들[화살표순번]\n  !스칼라논리(화살표, \"async\") &&\n    자식순번(준비, 화살표순번, \"typeParameters\") < 0 &&\n    자식순번들(준비, 화살표순번, \"params\").length == 1\n}\n\nexport function 블록닫기접두(\n  준비: 준비된인쇄상태,\n  순번: int,\n  내용들: Array<int>,\n  추가행: int\n) -> string {\n  if !문장목록다중행(준비, 내용들) && 추가행 <= 0 { return \"\" }\n  let 블록 = 준비.구조.노드들[순번]\n  if 블록.자식필드 == \"body\" &&\n    화살표괄호생략인가(준비, 블록.부모순번) { return \"\" }\n  let 닫기들여쓰기 = 노드들여쓰기(준비, 순번)\n  let 부모 = 준비.구조.노드들[순번]\n  let 마지막 = 준비.구조.노드들[내용들[내용들.length - 1]]\n  let mut 줄수 = 스칼라정수(부모, \"endRow\") - 스칼라정수(마지막, \"endRow\") + 추가행\n  if 줄수 < 0 { 줄수 = 0 }\n  줄접두(줄수, 닫기들여쓰기)\n}\n\n// 겹문의 절은 자식이 하나뿐인 필드라서 어떤 목록 묶음도 덮지 않았고, 원본이\n// 절 사이에 쓴 행을 여태 되살리지 못했다. Error.prototype.stack이 물리 행을\n// 드러내므로 삼켜진 절 행 하나가 그 뒤 모든 행을 다시 번호 매긴다.\n// 끊긴 구분자는 줄바꿈 하나에 다음 행 들여쓰기를 더해 쓰고, 끊기지 않은\n// 구분자는 빈칸 하나를 쓴다. 같은 바이트를 여러 (끊김수, 행수) 짝이 쓸 수\n// 있으니 간격과 맞는 가장 적은 행수를 답으로 삼는다. 행을 만들어 내는 쪽이\n// 해로운 방향이기 때문이다. 끊김과 빈칸이 같은 바이트를 쓰는 자리에서는\n// 한 행 표기를 그대로 두는데, 이는 문장 목록 모형이 이미 적어 둔 충돌이다.\nfunction 절행수(\n  준비: 준비된인쇄상태,\n  부모순번: int,\n  이전끝: int,\n  절순번: int,\n  고정바이트: int,\n  구분자수: int\n) -> int {\n  if 절순번 < 0 { return 0 }\n  let 절 = 준비.구조.노드들[절순번]\n  if 이전끝 < 0 || 이전끝 > 절.시작 { return 0 }\n  // 절 사이 댓글은 제 행을 따로 실어 나르고 그 행은 댓글 생략 경로가 이미\n  // 갖고 있다. 두 번 세지 않도록 절을 건드리지 않는다.\n  if 댓글수사이(준비, 이전끝, 절.시작) > 0 { return 0 }\n  let 부모 = 준비.구조.노드들[부모순번]\n  let mut 이전행 = 스칼라정수(부모, \"startRow\")\n  for 후보 in 준비.구조.노드들 {\n    if 후보.끝 == 이전끝 { 이전행 = 스칼라정수(후보, \"endRow\") }\n  }\n  let 행수 = 스칼라정수(절, \"startRow\") - 이전행\n  if 행수 < 0 { 0 } else { 행수 }\n}\n\nexport function 절접두(\n  준비: 준비된인쇄상태,\n  부모순번: int,\n  이전끝: int,\n  절순번: int,\n  고정바이트: int,\n  구분자수: int,\n  한행: string\n) -> string {\n  if !준비.오프셋배치 { return 한행 }\n  let 행수 = 절행수(준비, 부모순번, 이전끝, 절순번, 고정바이트, 구분자수)\n  if 행수 <= 0 { return 한행 }\n  줄접두(행수, 노드들여쓰기(준비, 절순번))\n}\n\n// A literal list element carries its own start column, and the kernel asks the\n// reference printer for that column at line start only. The pad is skipped when\n// the carried column is zero, and the printer's own lazy indentation then\n// applies, so the element's column is the carried column when it is non-zero\n// and @babel/generator's indent level when it is zero.\nexport function 리터럴열(준비: 준비된인쇄상태, 순번: int) -> int {\n  let 열 = 스칼라정수(준비.구조.노드들[순번], \"startColumn\")\n  if 열 > 0 { 열 } else { 노드들여쓰기(준비, 순번) }\n}\n\nexport function 리터럴첫줄수(준비: 준비된인쇄상태, 부모순번: int, 첫순번: int) -> int {\n  let 줄수 = 스칼라정수(준비.구조.노드들[첫순번], \"startRow\") -\n    스칼라정수(준비.구조.노드들[부모순번], \"startRow\")\n  if 줄수 < 0 { 0 } else { 줄수 }\n}\n\nexport function 리터럴사이접두(\n  준비: 준비된인쇄상태,\n  이전순번: int,\n  현재순번: int\n) -> string {\n  let 이전 = 준비.구조.노드들[이전순번]\n  let 현재 = 준비.구조.노드들[현재순번]\n  let 줄수 = 스칼라정수(현재, \"startRow\") - 스칼라정수(이전, \"endRow\")\n  if 줄수 > 0 { 줄접두(줄수, 리터럴열(준비, 현재순번)) } else { \" \" }\n}\n\n// The reference printer catches a literal's closing delimiter up to the node's\n// carried END row and then pads to its carried close column, and it compares\n// both against the printer's REAL position rather than against the position the\n// image carries for the last element - `sourceWithOffset(\"end\", loc, -1)` in\n// @babel/generator and the close-delimiter branch of `tokenChar` in the\n// kernel's structural printer. The emitted body counts its own rows and its own\n// trailing column, so the guest reads the same two facts.\nexport function 리터럴닫기접두(\n  준비: 준비된인쇄상태,\n  부모순번: int,\n  몸조각: int\n) -> Result<string, string> {\n  let 부모 = 준비.구조.노드들[부모순번]\n  let 줄수 = 스칼라정수(부모, \"endRow\") -\n    조각끝행(준비, 스칼라정수(부모, \"startRow\"), 몸조각)\n  let 닫기열 = 스칼라정수(부모, \"endColumn\") - 1\n  if 줄수 > 0 {\n    let 들여쓰기값 = if 닫기열 > 0 { 닫기열 } else { 노드들여쓰기(준비, 부모순번) }\n    return Ok(줄접두(줄수, 들여쓰기값))\n  }\n  if 줄수 < 0 || 닫기열 <= 0 { return Ok(\"\") }\n  if 인쇄조각행수(준비.조각판, 몸조각) == 0 { return Ok(\"\") }\n  let 현재열 = 조각끝열(준비, 몸조각)?\n  if 현재열 >= 닫기열 { return Ok(\"\") }\n  let mut 공백 = \"\"\n  let mut 남음 = 닫기열 - 현재열\n  while 남음 > 0 { 공백 = 공백 + \" \"; 남음 = 남음 - 1 }\n  Ok(공백)\n}\n\n// The row the printer is on when a call's argument list begins. The reference\n// printer emits the closing `>` of a type-argument list without catching a row\n// up, so the row is the last type argument's end row rather than the list\n// node's; the list's indent decision and its emission read this one function so\n// they cannot disagree about which row the list begins on.\nexport function 호출대상끝행(준비: 준비된인쇄상태, 부모순번: int) -> int {\n  let 부모 = 준비.구조.노드들[부모순번]\n  let 대상순번 = 자식순번(준비, 부모순번, \"callee\")\n  let mut 끝행 = if 대상순번 < 0 { 스칼라정수(부모, \"startRow\") }\n    else { 스칼라정수(준비.구조.노드들[대상순번], \"endRow\") }\n  let 형식인수 = if 자식순번(준비, 부모순번, \"typeArguments\") >= 0 {\n    자식순번(준비, 부모순번, \"typeArguments\")\n  } else { 자식순번(준비, 부모순번, \"typeParameters\") }\n  if 형식인수 >= 0 {\n    let 형식들 = 자식순번들(준비, 형식인수, \"params\")\n    끝행 = if 형식들.length == 0 {\n      스칼라정수(준비.구조.노드들[형식인수], \"endRow\")\n    } else {\n      스칼라정수(준비.구조.노드들[형식들[형식들.length - 1]], \"endRow\")\n    }\n  }\n  끝행\n}\n\nexport function 함수몸접두(준비: 준비된인쇄상태, 부모순번: int, 몸순번: int) -> string {\n  if 몸순번 < 0 { return \" \" }\n  가장자리접두(준비, 몸순번, \" \")\n}\n",
      "sourceSha256": "7da2f11dc011bd51e88faacb149d2b0bbeb34210f18db4cb645ac00990f1ada2"
    },
    {
      "path": "topaz/src/printers/javascript/literals.tpz",
      "language": "topaz",
      "bytes": 2408,
      "sha256": "586802890c95a860b0b0bbd55df8a087a0104dccc801f752d70f4d82595e9ad8",
      "content": "// String literal spellings for the JavaScript and TypeScript printer.\n\nimport structure { 구조노드, 구조스칼라, 노드스칼라, 스칼라논리, 스칼라문자, 스칼라있음 }\nimport wire { 대문자십육진네자리, 대문자십육진두자리, 안전문자열코드단위키, 코드단위키읽기 }\n\nfunction 원본문자열리터럴(스칼라: 구조스칼라) -> Result<string, string> {\n  let 키 = if 스칼라.태그 == 5 { 안전문자열코드단위키(스칼라.문자열값) }\n    else if 스칼라.태그 == 6 { 스칼라.문자열값 }\n    else { return Err(\"문자열 리터럴 스칼라 태그가 틀립니다\") }\n  let 단위들 = 코드단위키읽기(키, true)?\n  let mut 조각들: Array<string> = [\"\\\"\"]\n  let mut 색인 = 0\n  while 색인 < 단위들.length {\n    let 단위 = 단위들[색인]\n    if 단위 == 34 { 조각들.push(\"\\\\\\\"\") }\n    else if 단위 == 92 { 조각들.push(\"\\\\\\\\\") }\n    else if 단위 == 8 { 조각들.push(\"\\\\b\") }\n    else if 단위 == 9 { 조각들.push(\"\\\\t\") }\n    else if 단위 == 10 { 조각들.push(\"\\\\n\") }\n    else if 단위 == 12 { 조각들.push(\"\\\\f\") }\n    else if 단위 == 13 { 조각들.push(\"\\\\r\") }\n    else if 단위 == 0 {\n      let 다음숫자 = 색인 + 1 < 단위들.length && 단위들[색인 + 1] >= 48 && 단위들[색인 + 1] <= 57\n      조각들.push(if 다음숫자 { \"\\\\x00\" } else { \"\\\\0\" })\n    } else if 단위 >= 32 && 단위 <= 126 {\n      match 단위.toCodePoint() {\n        case Some(문자) => { 조각들.push(문자) }\n        case None => return Err(\"ASCII 코드 단위가 유니코드 스칼라가 아닙니다\")\n      }\n    } else if 단위 <= 255 {\n      조각들.push(\"\\\\x\")\n      조각들.push(대문자십육진두자리(단위))\n    } else {\n      조각들.push(\"\\\\u\")\n      조각들.push(대문자십육진네자리(단위))\n    }\n    색인 = 색인 + 1\n  }\n  조각들.push(\"\\\"\")\n  Ok(조각들.join(\"\"))\n}\n\nexport function 철자문자열리터럴(노드: 구조노드) -> Result<string, string> {\n  let 따옴표 = if 스칼라논리(노드, \"spelling.singleQuote\") { \"'\" } else { \"\\\"\" }\n  if 스칼라있음(노드, \"spelling.escapeBody\") {\n    return Ok(따옴표 + 스칼라문자(노드, \"spelling.escapeBody\") + 따옴표)\n  }\n  if 따옴표 == \"'\" { return Ok(\"'\" + 스칼라문자(노드, \"value\") + \"'\") }\n  원본문자열리터럴(노드스칼라(노드, \"value\"))\n}\n",
      "sourceSha256": "586802890c95a860b0b0bbd55df8a087a0104dccc801f752d70f4d82595e9ad8"
    },
    {
      "path": "topaz/src/printers/javascript/precedence.tpz",
      "language": "topaz",
      "bytes": 5325,
      "sha256": "64868ef4ab1e468ee3373d0b7f84b841b93bac3ac7b3a6431778d924ed908d72",
      "content": "// Operator precedence and the `in` operator context of the JavaScript and\n// TypeScript printer.\n\nimport nodes { 노드종류 }\nimport printer_state { 자식순번들, 준비된인쇄상태 }\nimport structure { 구조노드, 구조입력, 스칼라문자 }\n\nexport function 우선순위(준비: 준비된인쇄상태, 순번: int) -> int {\n  if 순번 < 0 { return 99 }\n  let 노드 = 준비.구조.노드들[순번]\n  let 종류 = 노드종류(준비.언어번호, 노드.코드워드)\n  if 종류 == 310 { return 1 }\n  if 종류 == 308 || 종류 == 305 || 종류 == 306 || 종류 == 309 { return 2 }\n  if 종류 == 307 { return 3 }\n  if 종류 == 304 {\n    let 연산 = 스칼라문자(노드, \"operator\")\n    if 연산 == \"&&\" { return 5 }; return 4\n  }\n  if 종류 == 303 {\n    let 연산 = 스칼라문자(노드, \"operator\")\n    if 연산 == \"|\" { return 6 }; if 연산 == \"^\" { return 7 }; if 연산 == \"&\" { return 8 }\n    if 연산 == \"==\" || 연산 == \"!=\" || 연산 == \"===\" || 연산 == \"!==\" { return 9 }\n    if 연산 == \"<\" || 연산 == \">\" || 연산 == \"<=\" || 연산 == \">=\" || 연산 == \"in\" || 연산 == \"instanceof\" { return 10 }\n    if 연산 == \"<<\" || 연산 == \">>\" || 연산 == \">>>\" { return 11 }\n    if 연산 == \"+\" || 연산 == \"-\" { return 12 }\n    if 연산 == \"*\" || 연산 == \"/\" || 연산 == \"%\" { return 13 }\n    return 14\n  }\n  if 종류 == 724 || 종류 == 725 { return 10 }\n  if 종류 == 301 || 종류 == 302 || 종류 == 723 { return 15 }\n  if 종류 == 311 { return 16 }\n  if 종류 == 210 || 종류 == 212 || 종류 == 208 || 종류 == 211 || 종류 == 209 ||\n    종류 == 213 || 종류 == 727 || 종류 == 726 { return 17 }\n  18\n}\n\n// 자바스크립트 문법의 [~In] 매개변수.\n// `for` 머리의 초기식과 `for ... in`의 왼쪽에서는\n// `RelationalExpression in ShiftExpression` 생성이 없다.\n// 그러니 그 자리의 `in`은 괄호가 문법상 필수다.\n// 제약은 머리의 모든 하위식으로 물려받고,\n// 대괄호나 중괄호나 소괄호가 [+In]을 되살리는 자리에서 끊긴다.\nfunction 인이항인가(준비: 준비된인쇄상태, 순번: int) -> bool {\n  if 순번 < 0 { return false }\n  let 노드 = 준비.구조.노드들[순번]\n  노드종류(준비.언어번호, 노드.코드워드) == 303 && 스칼라문자(노드, \"operator\") == \"in\"\n}\n\nfunction 인머리인가(준비: 준비된인쇄상태, 순번: int) -> bool {\n  순번 >= 0 && 순번 < 준비.인머리들.length && 준비.인머리들[순번]\n}\n\nexport function 인머리켜기(준비: 준비된인쇄상태, 순번: int) {\n  if 순번 >= 0 && 순번 < 준비.인머리들.length {\n    let mut 인머리들 = 준비.인머리들\n    인머리들[순번] = true\n  }\n}\n\nexport function 인머리끄기(준비: 준비된인쇄상태, 순번: int) {\n  if 순번 >= 0 && 순번 < 준비.인머리들.length {\n    let mut 인머리들 = 준비.인머리들\n    인머리들[순번] = false\n  }\n}\n\nexport function 인괄호필요(준비: 준비된인쇄상태, 순번: int) -> bool {\n  인머리인가(준비, 순번) && 인이항인가(준비, 순번)\n}\n\nfunction 인머리자식들켜기(준비: 준비된인쇄상태, 순번: int, 필드: string) {\n  for 자식 in 자식순번들(준비, 순번, 필드) { 인머리켜기(준비, 자식) }\n}\n\n// 괄호가 붙는 노드는 그 안에서 [+In]이 되살아나므로 물려주지 않는다.\n// 괄호 판정은 인쇄 전에 우선순위만으로 정해지니 여기서 미리 끈다.\nexport function 인머리내림(준비: 준비된인쇄상태, 순번: int) {\n  if !인머리인가(준비, 순번) { return }\n  if 인이항인가(준비, 순번) {\n    인머리자식들켜기(준비, 순번, \"left\")\n    인머리자식들켜기(준비, 순번, \"right\")\n    return\n  }\n  let 종류 = 노드종류(준비.언어번호, 준비.구조.노드들[순번].코드워드)\n  if 종류 == 409 { 인머리자식들켜기(준비, 순번, \"declarations\"); return }\n  if 종류 == 408 { 인머리자식들켜기(준비, 순번, \"init\"); return }\n  if 종류 == 303 || 종류 == 304 || 종류 == 305 {\n    인머리자식들켜기(준비, 순번, \"left\")\n    인머리자식들켜기(준비, 순번, \"right\")\n    return\n  }\n  if 종류 == 306 { 인머리자식들켜기(준비, 순번, \"right\"); return }\n  if 종류 == 307 {\n    인머리자식들켜기(준비, 순번, \"test\")\n    인머리자식들켜기(준비, 순번, \"consequent\")\n    인머리자식들켜기(준비, 순번, \"alternate\")\n    return\n  }\n  if 종류 == 310 || 종류 == 117 {\n    인머리자식들켜기(준비, 순번, \"expressions\")\n    return\n  }\n  if 종류 == 301 || 종류 == 302 || 종류 == 309 || 종류 == 311 || 종류 == 206 {\n    인머리자식들켜기(준비, 순번, \"argument\")\n    return\n  }\n  if 종류 == 208 || 종류 == 209 { 인머리자식들켜기(준비, 순번, \"object\"); return }\n  if 종류 == 210 || 종류 == 211 || 종류 == 212 {\n    인머리자식들켜기(준비, 순번, \"callee\")\n    return\n  }\n  if 종류 == 213 {\n    인머리자식들켜기(준비, 순번, \"tag\")\n    인머리자식들켜기(준비, 순번, \"quasi\")\n    return\n  }\n  if 종류 == 308 { 인머리자식들켜기(준비, 순번, \"body\"); return }\n  if 종류 == 601 || 종류 == 602 { 인머리자식들켜기(준비, 순번, \"superClass\") }\n}\n",
      "sourceSha256": "64868ef4ab1e468ee3373d0b7f84b841b93bac3ac7b3a6431778d924ed908d72"
    },
    {
      "path": "topaz/src/printers/javascript/rules.tpz",
      "language": "topaz",
      "bytes": 18831,
      "sha256": "d11322666f672b664b3260e73a052a1ccf9eb577e39ee0d065cc8b3ebc9a20b8",
      "content": "// Generated by topaz/printer-schema-generator.mjs from topaz/printer-schema.json;\n// the JavaScript and TypeScript printer rules.\n\nimport structure { 구조스칼라 }\nimport util { 문자열배열에있음 }\n\n// BEGIN GENERATED TOPAZ PRINTER RULES\nexport record 인쇄노드규칙 {\n  필수단일: Array<string>,\n  선택단일: Array<string>,\n  필수목록: Array<string>,\n  선택목록: Array<string>,\n  허용스칼라: Array<string>,\n  필수스칼라: Array<string>\n}\n\nfunction 인쇄노드규칙만들기(\n  필수단일: Array<string>,\n  선택단일: Array<string>,\n  필수목록: Array<string>,\n  선택목록: Array<string>,\n  허용스칼라: Array<string>,\n  필수스칼라: Array<string>\n) -> 인쇄노드규칙 {\n  인쇄노드규칙 {\n    필수단일: 필수단일,\n    선택단일: 선택단일,\n    필수목록: 필수목록,\n    선택목록: 선택목록,\n    허용스칼라: 허용스칼라,\n    필수스칼라: 필수스칼라\n  }\n}\n\nfunction 빈인쇄노드규칙() -> 인쇄노드규칙 {\n  인쇄노드규칙만들기([], [], [], [], [], [])\n}\n\nexport function 인쇄노드규칙읽기(언어번호: int, 종류: int) -> 인쇄노드규칙 {\n  if 종류 == 606 {\n    return if 언어번호 == 1 { 인쇄노드규칙만들기([\"key\",\"body\"], [\"typeParameters\",\"returnType\"], [\"params\"], [\"decorators\"], [\"async\",\"computed\",\"generator\",\"id\",\"kind\",\"method\"], [\"kind\"]) }\n      else { 인쇄노드규칙만들기([\"key\"], [\"typeParameters\",\"returnType\"], [\"params\"], [\"decorators\"], [\"abstract\",\"access\",\"accessibility\",\"async\",\"computed\",\"generator\",\"id\",\"kind\",\"optional\",\"override\",\"static\"], [\"kind\"]) }\n  }\n  match 종류 {\n    case 101 => 인쇄노드규칙만들기([\"program\"], [], [], [\"comments\"], [], [])\n    case 102 => 인쇄노드규칙만들기([], [\"interpreter\"], [\"directives\",\"body\"], [], [\"sourceType\"], [\"sourceType\"])\n    case 103 => 인쇄노드규칙만들기([\"value\"], [], [], [], [], [])\n    case 104 => 인쇄노드규칙만들기([], [], [], [], [\"value\"], [\"value\"])\n    case 105 => 인쇄노드규칙만들기([\"expression\"], [], [], [], [], [])\n    case 106 => 인쇄노드규칙만들기([], [\"typeAnnotation\"], [], [\"decorators\"], [\"name\",\"optional\"], [])\n    case 107 => 인쇄노드규칙만들기([\"id\"], [], [], [], [], [])\n    case 108 => 인쇄노드규칙만들기([], [], [], [], [\"value\"], [\"value\"])\n    case 109 => 인쇄노드규칙만들기([], [], [], [], [\"value\"], [\"value\"])\n    case 110 => 인쇄노드규칙만들기([], [], [], [], [\"value\"], [\"value\"])\n    case 111 => 인쇄노드규칙만들기([], [], [], [], [\"value\"], [\"value\"])\n    case 115 => 인쇄노드규칙만들기([], [], [], [], [\"flags\",\"pattern\"], [\"flags\",\"pattern\"])\n    case 116 => 인쇄노드규칙만들기([], [], [], [], [\"tail\",\"value.raw\",\"value.cooked\"], [\"tail\",\"value.cooked\",\"value.raw\"])\n    case 117 => 인쇄노드규칙만들기([], [], [\"quasis\",\"expressions\"], [], [], [])\n    case 118 => 인쇄노드규칙만들기([\"body\"], [\"id\",\"typeParameters\",\"predicate\",\"returnType\"], [\"params\"], [], [\"async\",\"generator\"], [])\n    case 201 => 인쇄노드규칙만들기([], [], [\"elements\"], [], [], [])\n    case 202 => 인쇄노드규칙만들기([], [\"typeAnnotation\"], [\"elements\"], [], [\"decorators\",\"optional\"], [])\n    case 203 => 인쇄노드규칙만들기([], [], [\"properties\"], [], [], [])\n    case 204 => 인쇄노드규칙만들기([], [\"typeAnnotation\"], [\"properties\"], [\"decorators\"], [\"optional\"], [])\n    case 205 => 인쇄노드규칙만들기([\"key\",\"value\"], [], [], [\"decorators\"], [\"computed\",\"method\",\"shorthand\"], [])\n    case 206 => 인쇄노드규칙만들기([\"argument\"], [], [], [], [], [])\n    case 207 => 인쇄노드규칙만들기([\"argument\"], [\"typeAnnotation\"], [], [], [\"decorators\",\"optional\"], [])\n    case 208 => 인쇄노드규칙만들기([\"object\",\"property\"], [], [], [], [\"computed\",\"optional\"], [])\n    case 209 => 인쇄노드규칙만들기([\"object\",\"property\"], [], [], [], [\"computed\",\"optional\"], [])\n    case 210 => 인쇄노드규칙만들기([\"callee\"], [\"typeParameters\",\"typeArguments\"], [\"arguments\"], [], [\"optional\"], [])\n    case 211 => 인쇄노드규칙만들기([\"callee\"], [\"typeParameters\",\"typeArguments\"], [\"arguments\"], [], [\"optional\"], [])\n    case 212 => 인쇄노드규칙만들기([\"callee\"], [\"typeParameters\",\"typeArguments\"], [\"arguments\"], [], [\"optional\"], [])\n    case 213 => 인쇄노드규칙만들기([\"tag\",\"quasi\"], [\"typeParameters\"], [], [], [], [])\n    case 301 => 인쇄노드규칙만들기([\"argument\"], [], [], [], [\"operator\",\"prefix\"], [\"operator\"])\n    case 302 => 인쇄노드규칙만들기([\"argument\"], [], [], [], [], [])\n    case 303 => 인쇄노드규칙만들기([\"left\",\"right\"], [], [], [], [\"operator\"], [\"operator\"])\n    case 304 => 인쇄노드규칙만들기([\"left\",\"right\"], [], [], [], [\"operator\"], [\"operator\"])\n    case 305 => 인쇄노드규칙만들기([\"left\",\"right\"], [], [], [], [\"operator\"], [\"operator\"])\n    case 306 => 인쇄노드규칙만들기([\"left\",\"right\"], [], [], [\"decorators\"], [\"optional\",\"typeAnnotation\"], [])\n    case 307 => 인쇄노드규칙만들기([\"test\",\"consequent\",\"alternate\"], [], [], [], [], [])\n    case 308 => 인쇄노드규칙만들기([\"body\"], [\"typeParameters\",\"predicate\",\"returnType\"], [\"params\"], [], [\"async\",\"expression\",\"generator\",\"id\"], [])\n    case 309 => 인쇄노드규칙만들기([], [\"argument\"], [], [], [\"delegate\"], [])\n    case 310 => 인쇄노드규칙만들기([], [], [\"expressions\"], [], [], [])\n    case 311 => 인쇄노드규칙만들기([\"argument\"], [], [], [], [\"operator\",\"prefix\"], [\"operator\"])\n    case 401 => 인쇄노드규칙만들기([\"expression\"], [], [], [], [], [])\n    case 402 => 인쇄노드규칙만들기([], [\"argument\"], [], [], [], [])\n    case 403 => 인쇄노드규칙만들기([\"argument\"], [], [], [], [], [])\n    case 404 => 인쇄노드규칙만들기([], [\"label\"], [], [], [], [])\n    case 405 => 인쇄노드규칙만들기([], [\"label\"], [], [], [], [])\n    case 407 => 인쇄노드규칙만들기([\"label\",\"body\"], [], [], [], [], [])\n    case 408 => 인쇄노드규칙만들기([\"id\"], [\"init\"], [], [], [\"definite\"], [])\n    case 409 => 인쇄노드규칙만들기([], [], [\"declarations\"], [], [\"declare\",\"kind\"], [\"kind\"])\n    case 410 => 인쇄노드규칙만들기([], [], [\"directives\",\"body\"], [], [], [])\n    case 411 => 인쇄노드규칙만들기([\"body\"], [\"id\",\"typeParameters\",\"predicate\",\"returnType\"], [\"params\"], [], [\"async\",\"declare\",\"generator\"], [])\n    case 501 => 인쇄노드규칙만들기([\"test\",\"consequent\"], [\"alternate\"], [], [], [], [])\n    case 502 => 인쇄노드규칙만들기([\"test\",\"body\"], [], [], [], [], [])\n    case 503 => 인쇄노드규칙만들기([\"body\",\"test\"], [], [], [], [], [])\n    case 504 => 인쇄노드규칙만들기([\"object\",\"body\"], [], [], [], [], [])\n    case 505 => 인쇄노드규칙만들기([\"body\"], [\"init\",\"test\",\"update\"], [], [], [], [])\n    case 506 => 인쇄노드규칙만들기([\"left\",\"right\",\"body\"], [], [], [], [], [])\n    case 507 => 인쇄노드규칙만들기([\"left\",\"right\",\"body\"], [], [], [], [\"await\"], [])\n    case 508 => 인쇄노드규칙만들기([\"block\"], [\"handler\",\"finalizer\"], [], [], [], [])\n    case 509 => 인쇄노드규칙만들기([\"body\"], [\"param\"], [], [], [], [])\n    case 510 => 인쇄노드규칙만들기([\"discriminant\"], [], [\"cases\"], [], [], [])\n    case 511 => 인쇄노드규칙만들기([], [\"test\"], [\"consequent\"], [], [], [])\n    case 601 => 인쇄노드규칙만들기([\"body\"], [\"id\",\"typeParameters\",\"superClass\",\"superTypeParameters\",\"mixins\"], [], [\"decorators\",\"implements\"], [\"abstract\",\"declare\"], [])\n    case 602 => 인쇄노드규칙만들기([\"body\"], [\"id\",\"typeParameters\",\"superClass\",\"superTypeParameters\",\"mixins\"], [], [\"decorators\",\"implements\"], [], [])\n    case 603 => 인쇄노드규칙만들기([], [], [\"body\"], [], [], [])\n    case 604 => 인쇄노드규칙만들기([\"key\",\"body\"], [\"typeParameters\",\"returnType\"], [\"params\"], [\"decorators\"], [\"abstract\",\"access\",\"accessibility\",\"async\",\"computed\",\"generator\",\"id\",\"kind\",\"optional\",\"override\",\"static\"], [\"kind\"])\n    case 605 => 인쇄노드규칙만들기([\"key\",\"body\"], [\"typeParameters\",\"returnType\"], [\"params\"], [\"decorators\"], [\"abstract\",\"access\",\"accessibility\",\"async\",\"computed\",\"generator\",\"id\",\"kind\",\"optional\",\"override\",\"static\"], [\"kind\"])\n    case 607 => 인쇄노드규칙만들기([\"key\"], [\"variance\",\"typeAnnotation\",\"value\"], [], [\"decorators\"], [\"abstract\",\"accessibility\",\"computed\",\"declare\",\"definite\",\"optional\",\"override\",\"readonly\",\"static\"], [])\n    case 608 => 인쇄노드규칙만들기([\"key\"], [\"variance\",\"typeAnnotation\",\"value\"], [], [\"decorators\"], [\"definite\",\"optional\",\"readonly\",\"static\"], [])\n    case 609 => 인쇄노드규칙만들기([], [], [\"body\"], [], [], [])\n    case 610 => 인쇄노드규칙만들기([\"key\"], [\"typeAnnotation\",\"value\"], [], [\"decorators\"], [\"abstract\",\"accessibility\",\"computed\",\"declare\",\"definite\",\"optional\",\"override\",\"readonly\",\"static\"], [])\n    case 701 => 인쇄노드규칙만들기([\"typeAnnotation\"], [], [], [], [], [])\n    case 709 => 인쇄노드규칙만들기([\"literal\"], [], [], [], [], [])\n    case 710 => 인쇄노드규칙만들기([\"typeName\"], [\"typeParameters\"], [], [], [], [])\n    case 711 => 인쇄노드규칙만들기([\"left\",\"right\"], [], [], [], [], [])\n    case 712 => 인쇄노드규칙만들기([], [], [\"params\"], [], [], [])\n    case 713 => 인쇄노드규칙만들기([], [], [\"params\"], [], [], [])\n    case 714 => 인쇄노드규칙만들기([], [\"constraint\",\"default\"], [], [], [\"const\",\"in\",\"name\",\"out\"], [])\n    case 715 => 인쇄노드규칙만들기([], [], [\"types\"], [], [], [])\n    case 716 => 인쇄노드규칙만들기([\"elementType\"], [], [], [], [], [])\n    case 717 => 인쇄노드규칙만들기([], [], [\"members\"], [], [], [])\n    case 718 => 인쇄노드규칙만들기([\"key\"], [\"typeAnnotation\"], [], [], [\"computed\",\"kind\",\"optional\",\"readonly\"], [])\n    case 719 => 인쇄노드규칙만들기([], [\"typeParameters\",\"typeAnnotation\"], [\"parameters\"], [], [], [])\n    case 720 => 인쇄노드규칙만들기([], [], [\"body\"], [], [], [])\n    case 721 => 인쇄노드규칙만들기([\"id\",\"body\"], [\"typeParameters\"], [], [\"extends\"], [\"declare\"], [])\n    case 722 => 인쇄노드규칙만들기([\"id\",\"typeAnnotation\"], [\"typeParameters\"], [], [], [\"declare\"], [])\n    case 723 => 인쇄노드규칙만들기([\"typeAnnotation\",\"expression\"], [], [], [], [], [])\n    case 724 => 인쇄노드규칙만들기([\"expression\",\"typeAnnotation\"], [], [], [], [], [])\n    case 725 => 인쇄노드규칙만들기([\"expression\",\"typeAnnotation\"], [], [], [], [], [])\n    case 726 => 인쇄노드규칙만들기([\"expression\"], [], [], [], [], [])\n    case 727 => 인쇄노드규칙만들기([\"expression\"], [\"typeParameters\"], [], [], [], [])\n    case 728 => 인쇄노드규칙만들기([\"exprName\"], [\"typeParameters\"], [], [], [], [])\n    case 729 => 인쇄노드규칙만들기([\"parameter\"], [], [], [\"decorators\"], [\"accessibility\",\"override\",\"readonly\"], [])\n    case 730 => 인쇄노드규칙만들기([], [\"id\",\"typeParameters\",\"returnType\"], [\"params\"], [], [\"async\",\"declare\",\"generator\"], [])\n    case 731 => 인쇄노드규칙만들기([], [], [\"body\"], [], [], [])\n    case 732 => 인쇄노드규칙만들기([\"id\"], [\"body\"], [], [], [\"declare\",\"global\",\"kind\"], [])\n    case 733 => 인쇄노드규칙만들기([\"id\"], [\"initializer\"], [], [], [], [])\n    case 734 => 인쇄노드규칙만들기([\"id\"], [], [\"members\"], [], [\"body\",\"const\",\"declare\",\"initializer\"], [])\n    case 735 => 인쇄노드규칙만들기([\"imported\",\"local\"], [], [], [], [\"importKind\"], [])\n    case 736 => 인쇄노드규칙만들기([\"source\"], [], [\"specifiers\"], [\"attributes\",\"assertions\"], [\"emptyNamedImportClause\",\"importKind\",\"module\",\"phase\"], [])\n    case 737 => 인쇄노드규칙만들기([\"local\",\"exported\"], [], [], [], [\"exportKind\"], [])\n    case 738 => 인쇄노드규칙만들기([], [\"declaration\",\"source\"], [\"specifiers\"], [\"attributes\",\"assertions\"], [\"exportKind\"], [])\n    case 739 => 인쇄노드규칙만들기([\"typeAnnotation\"], [], [], [], [], [])\n    case 740 => 인쇄노드규칙만들기([\"typeAnnotation\"], [], [], [], [\"operator\"], [\"operator\"])\n    case 741 => 인쇄노드규칙만들기([\"key\"], [\"typeParameters\",\"typeAnnotation\"], [\"parameters\"], [], [\"computed\",\"kind\",\"optional\"], [\"kind\"])\n    case 743 => 인쇄노드규칙만들기([\"objectType\",\"indexType\"], [], [], [], [], [])\n    case 744 => 인쇄노드규칙만들기([\"typeAnnotation\"], [\"typeParameters\"], [\"parameters\"], [], [], [])\n    case _ => 빈인쇄노드규칙()\n  }\n}\n\nexport function 자식필드모드(\n  필수단일: Array<string>,\n  선택단일: Array<string>,\n  필수목록: Array<string>,\n  선택목록: Array<string>,\n  필드: string\n) -> int {\n  if 문자열배열에있음(필수단일, 필드) { return 1 }\n  if 문자열배열에있음(선택단일, 필드) { return 2 }\n  if 문자열배열에있음(필수목록, 필드) { return 3 }\n  if 문자열배열에있음(선택목록, 필드) { return 4 }\n  0\n}\n\nexport function 자식메타필드허용(\n  선택단일: Array<string>,\n  필수목록: Array<string>,\n  선택목록: Array<string>,\n  메타필드: string\n) -> bool {\n  for 필드 in 선택단일 {\n    if 메타필드 == \"child.{필드}.present\" { return true }\n  }\n  for 필드 in 필수목록 {\n    if 메타필드 == \"child.{필드}.length\" { return true }\n  }\n  for 필드 in 선택목록 {\n    if 메타필드 == \"child.{필드}.length\" || 메타필드 == \"child.{필드}.present\" {\n      return true\n    }\n  }\n  false\n}\n\nexport function 스칼라뜻검사(종류: int, 언어번호: int, 스칼라: 구조스칼라) -> Result<bool, string> {\n  let 필드 = 스칼라.필드\n  let 태그 = 스칼라.태그\n  let 값 = 스칼라.문자열값\n  if 종류 == 108 && 필드 == \"value\" {\n    if 태그 == 5 || 태그 == 6 { return Ok(true) }\n    return Err(\"문자열 리터럴 값의 스칼라 종류가 틀립니다\")\n  }\n  if (종류 == 104 || 종류 == 109) && 필드 == \"value\" {\n    if 태그 == 5 { return Ok(true) }\n    return Err(\"문자 리터럴 값의 스칼라 종류가 틀립니다\")\n  }\n  if 종류 == 110 && 필드 == \"value\" {\n    if 태그 == 3 || 태그 == 4 || (태그 == 5 && 값.startsWith(\"number:\")) { return Ok(true) }\n    return Err(\"숫자 리터럴 값의 스칼라 종류가 틀립니다\")\n  }\n  if 종류 == 111 && 필드 == \"value\" {\n    if 태그 == 1 || 태그 == 2 { return Ok(true) }\n    return Err(\"논리 리터럴 값의 스칼라 종류가 틀립니다\")\n  }\n  if 종류 == 116 {\n    if 필드 == \"tail\" && (태그 == 1 || 태그 == 2) { return Ok(true) }\n    if 필드 == \"value.raw\" && 태그 == 5 { return Ok(true) }\n    if 필드 == \"value.cooked\" && (태그 == 0 || 태그 == 5 || 태그 == 6) { return Ok(true) }\n    return Err(\"템플릿 원소 스칼라의 종류가 틀립니다\")\n  }\n  if 필드 == \"operator\" {\n    if 태그 != 5 { return Err(\"연산자 스칼라가 문자열이 아닙니다\") }\n    let 허용들: Array<string> = if 종류 == 301 {\n      [\"void\",\"delete\",\"!\",\"+\",\"-\",\"~\",\"typeof\"]\n    } else if 종류 == 303 {\n      [\"+\",\"-\",\"/\",\"%\",\"*\",\"**\",\"&\",\"|\",\">>\",\">>>\",\"<<\",\"^\",\"==\",\"===\",\"!=\",\"!==\",\"in\",\"instanceof\",\">\",\"<\",\">=\",\"<=\"]\n    } else if 종류 == 304 {\n      [\"||\",\"&&\",\"??\"]\n    } else if 종류 == 305 {\n      [\"=\",\"+=\",\"-=\",\"/=\",\"%=\",\"*=\",\"**=\",\"&=\",\"|=\",\">>=\",\">>>=\",\"<<=\",\"^=\",\"||=\",\"&&=\",\"??=\"]\n    } else if 종류 == 311 {\n      [\"++\",\"--\"]\n    } else if 종류 == 740 {\n      [\"keyof\",\"unique\",\"readonly\"]\n    } else { [] }\n    if 문자열배열에있음(허용들, 값) { return Ok(true) }\n    return Err(\"노드 종류에 허용되지 않은 연산자입니다: {값}\")\n  }\n  if 필드 == \"kind\" {\n    if 태그 == 0 && 종류 == 718 { return Ok(true) }\n    if 태그 != 5 { return Err(\"종류 스칼라가 문자열이 아닙니다\") }\n    let 허용들: Array<string> = if 종류 == 409 {\n      [\"var\",\"let\",\"const\",\"using\",\"await using\"]\n    } else if 종류 == 604 {\n      [\"get\",\"set\",\"method\",\"constructor\"]\n    } else if 종류 == 605 {\n      [\"get\",\"set\",\"method\",\"constructor\"]\n    } else if 종류 == 606 {\n      if 언어번호 == 1 { [\"method\",\"get\",\"set\"] }\n      else { [\"get\",\"set\",\"method\",\"constructor\"] }\n    } else if 종류 == 732 {\n      [\"global\",\"module\",\"namespace\"]\n    } else if 종류 == 741 {\n      [\"method\",\"get\",\"set\"]\n    } else { [] }\n    if 문자열배열에있음(허용들, 값) { return Ok(true) }\n    return Err(\"노드 종류에 허용되지 않은 종류 값입니다: {값}\")\n  }\n  if 필드 == \"sourceType\" {\n    if 태그 == 5 && 문자열배열에있음([\"script\",\"module\"], 값) { return Ok(true) }\n    return Err(\"프로그램 sourceType이 틀립니다\")\n  }\n  if 문자열배열에있음([\"access\",\"accessibility\"], 필드) {\n    if 태그 == 0 ||\n      (태그 == 5 && 문자열배열에있음([\"public\",\"private\",\"protected\"], 값)) {\n      return Ok(true)\n    }\n    return Err(\"접근성 스칼라가 틀립니다\")\n  }\n  if 필드 == \"importKind\" {\n    if 태그 == 0 ||\n      (태그 == 5 && 문자열배열에있음([\"type\",\"typeof\",\"value\"], 값)) {\n      return Ok(true)\n    }\n    return Err(\"가져오기 종류 스칼라가 틀립니다\")\n  }\n  if 필드 == \"exportKind\" {\n    if 태그 == 0 || (태그 == 5 && 문자열배열에있음([\"type\",\"value\"], 값)) {\n      return Ok(true)\n    }\n    return Err(\"내보내기 종류 스칼라가 틀립니다\")\n  }\n  if 필드 == \"phase\" {\n    if 태그 == 0 || (태그 == 5 && 문자열배열에있음([\"source\",\"defer\"], 값)) {\n      return Ok(true)\n    }\n    return Err(\"가져오기 phase 스칼라가 틀립니다\")\n  }\n  if 문자열배열에있음([\"name\",\"pattern\",\"flags\",\"leadingHorizontalLayout\",\"trailingFileLayout\"], 필드) {\n    if 태그 == 5 { return Ok(true) }\n    return Err(\"문자열 스칼라의 종류가 틀립니다: {필드}\")\n  }\n  if 문자열배열에있음([\"optional\",\"async\",\"generator\",\"computed\",\"method\",\"shorthand\",\"prefix\",\"delegate\",\"expression\",\"definite\",\"declare\",\"await\",\"abstract\",\"override\",\"static\",\"readonly\",\"const\",\"in\",\"out\",\"global\",\"module\",\"emptyNamedImportClause\"], 필드) {\n    if 태그 >= 0 && 태그 <= 2 { return Ok(true) }\n    return Err(\"논리 스칼라의 종류가 틀립니다: {필드}\")\n  }\n  if 문자열배열에있음([\"body\",\"initializer\",\"typeAnnotation\",\"decorators\",\"id\"], 필드) {\n    if 태그 == 0 { return Ok(true) }\n    return Err(\"빈 노드 자리 스칼라가 null이 아닙니다: {필드}\")\n  }\n  Err(\"허용 스칼라의 값 종류 규칙이 없습니다: {필드}\")\n}\n// END GENERATED TOPAZ PRINTER RULES\n",
      "sourceSha256": "d11322666f672b664b3260e73a052a1ccf9eb577e39ee0d065cc8b3ebc9a20b8"
    },
    {
      "path": "topaz/src/printers/javascript/store.tpz",
      "language": "topaz",
      "bytes": 2652,
      "sha256": "7f067ca66f0019fa6df150ea999a30d9b182c8dc48f1720eba0ec72a7b0320ca",
      "content": "// Stored pieces and pending requests of the iterative JavaScript and TypeScript\n// printing machine.\n\nimport print { 인쇄글조각, 인쇄호출 }\nimport printer_state { 준비된인쇄상태 }\nimport structure { 구조입력 }\n\nfunction 인쇄저장칸(준비: 준비된인쇄상태, 모드: int, 순번: int) -> int {\n  (모드 - 1) * 준비.구조.노드들.length + 순번\n}\n\nfunction 인쇄기계필요설정(준비: 준비된인쇄상태, 모드: int, 순번: int, 깊이: int) {\n  if 준비.기계필요모드들[0] != 0 { return }\n  let mut 모드들 = 준비.기계필요모드들\n  let mut 순번들 = 준비.기계필요순번들\n  let mut 깊이들 = 준비.기계필요깊이들\n  모드들[0] = 모드; 순번들[0] = 순번; 깊이들[0] = 깊이\n}\n\nexport function 인쇄기계저장조각읽기(\n  준비: 준비된인쇄상태,\n  모드: int,\n  순번: int,\n  깊이: int\n) -> Result<int, string> {\n  if 순번 < 0 || 순번 >= 준비.구조.노드들.length {\n    return Err(\"인쇄 노드 순번이 범위를 벗어났습니다\")\n  }\n  let 칸 = 인쇄저장칸(준비, 모드, 순번)\n  let 세대 = 준비.기계세대들[0]\n  if 준비.기계저장세대들[칸] == 세대 {\n    if 준비.기계저장깊이들[칸] != 깊이 {\n      return Err(\"인쇄 기계가 한 노드를 서로 다른 깊이로 요청했습니다\")\n    }\n    if 준비.기계저장상태들[칸] == 1 { return Ok(준비.기계저장조각들[칸]) }\n    return Err(준비.기계저장오류들[칸])\n  }\n  인쇄기계필요설정(준비, 모드, 순번, 깊이)\n  Err(\"인쇄 기계가 하위 호출을 기다립니다\")\n}\n\nexport function 인쇄기계저장쓰기(\n  준비: 준비된인쇄상태,\n  호출: 인쇄호출,\n  결과: Result<int, string>\n) {\n  let 칸 = 인쇄저장칸(준비, 호출.모드, 호출.순번)\n  let mut 세대들 = 준비.기계저장세대들\n  let mut 깊이들 = 준비.기계저장깊이들\n  let mut 상태들 = 준비.기계저장상태들\n  let mut 조각들 = 준비.기계저장조각들\n  let mut 오류들 = 준비.기계저장오류들\n  세대들[칸] = 준비.기계세대들[0]\n  깊이들[칸] = 호출.깊이\n  match 결과 {\n    case Ok(조각) => {\n      상태들[칸] = 1\n      조각들[칸] = 조각\n      오류들[칸] = \"\"\n    }\n    case Err(오류) => {\n      상태들[칸] = 2\n      조각들[칸] = 0\n      오류들[칸] = 오류\n    }\n  }\n}\n\nexport function 인쇄글결과조각(준비: 준비된인쇄상태, 결과: Result<string, string>) -> Result<int, string> {\n  match 결과 {\n    case Ok(글) => Ok(인쇄글조각(준비.조각판, 글))\n    case Err(오류) => Err(오류)\n  }\n}\n",
      "sourceSha256": "7f067ca66f0019fa6df150ea999a30d9b182c8dc48f1720eba0ec72a7b0320ca"
    },
    {
      "path": "topaz/src/printers/julia.tpz",
      "language": "topaz",
      "bytes": 11602,
      "sha256": "1f57a911e5484bb454524205aa407323bdefb8394fe2cd620051c4eea5dd98bc",
      "content": "// Julia structure validation and canonical source printing.\n\nimport names { 익명할당계획이름들 }\nimport nodes { 노드종류 }\nimport printer_cursor { 러스트열폭, 본문위치전진 }\nimport printer_setup { 인쇄상태만들기, 인쇄상태익명이름들바꾸기 }\nimport printer_state { 식별자이름 }\nimport printer_text { 선형원본길이, 선형원본만들기, 선형원본추가, 선형원본평평하게 }\nimport schema { 줄리아댓글코드, 줄리아원자본문코드 }\nimport structure { 구조노드, 구조스칼라, 구조입력, 구조입력검사, 노드스칼라, 스칼라논리, 스칼라문자, 스칼라있음 }\n\nfunction 줄리아정수스칼라검사(노드: 구조노드, 필드: string) -> Result<int, string> {\n  let 값 = 노드스칼라(노드, 필드)\n  if 값.필드 == \"\" || 값.태그 != 3 || 값.정수값 < 0 {\n    return Err(\"Julia 구조 정수 스칼라가 정규형이 아닙니다: {필드}\")\n  }\n  Ok(값.정수값)\n}\n\nexport function 줄리아인쇄구조검사(구조: 구조입력) -> Result<bool, string> {\n  구조입력검사(20, 구조)?\n  if 구조.노드들.length == 0 {\n    return Err(\"Julia 인쇄 구조에 source_file 노드가 필요합니다\")\n  }\n  if 구조.노드들[0].코드워드 != 383 ||\n    구조.노드들[0].부모순번 != -1 || 구조.노드들[0].자식필드있음 ||\n    구조.노드들[0].자식필드 != \"\" || 구조.노드들[0].자식색인 != -1 {\n    return Err(\"Julia 인쇄 구조 뿌리가 source_file 노드가 아닙니다\")\n  }\n  let mut 자식수들: Array<int> = []\n  let mut 순번 = 0\n  while 순번 < 구조.노드들.length { 자식수들.push(0); 순번 = 순번 + 1 }\n  let mut 분리본문발생수 = 0\n  let mut 다음식별자류번호 = 0\n  순번 = 0\n  while 순번 < 구조.노드들.length {\n    let 노드 = 구조.노드들[순번]\n    if 노드종류(20, 노드.코드워드) == 0 {\n      return Err(\"Julia 투영 인쇄기가 지원하지 않는 노드입니다: 순번 {순번}, 코드 {노드.코드워드}\")\n    }\n    if 순번 > 0 {\n      if 노드.부모순번 < 0 || 노드.부모순번 >= 순번 ||\n        !노드.자식필드있음 || 노드.자식필드 == \"\" || 노드.자식색인 < 0 {\n        return Err(\"Julia 인쇄 구조의 부모 또는 자식 위치가 정규형이 아닙니다: 순번 {순번}\")\n      }\n      자식수들[노드.부모순번] = 자식수들[노드.부모순번] + 1\n    }\n    if 노드.시작 < 0 || 노드.끝 < 노드.시작 {\n      return Err(\"Julia 인쇄 구조의 원본 범위가 틀립니다: 순번 {순번}\")\n    }\n    let 자식수 = 줄리아정수스칼라검사(노드, \"childCount\")?\n    let 시작행 = 줄리아정수스칼라검사(노드, \"startRow\")?\n    let 시작열 = 줄리아정수스칼라검사(노드, \"startColumn\")?\n    let 끝행 = 줄리아정수스칼라검사(노드, \"endRow\")?\n    let 끝열 = 줄리아정수스칼라검사(노드, \"endColumn\")?\n    if 끝행 < 시작행 || (끝행 == 시작행 && 끝열 < 시작열) {\n      return Err(\"Julia 인쇄 구조의 원본 좌표가 틀립니다: 순번 {순번}\")\n    }\n    if !스칼라있음(노드, \"named\") || !스칼라있음(노드, \"extra\") {\n      return Err(\"Julia 인쇄 구조의 노드 표지 스칼라가 없습니다: 순번 {순번}\")\n    }\n    if 스칼라있음(노드, \"sourceBom\") {\n      return Err(\"Julia 구조에 허용되지 않는 원본 BOM 표지가 있습니다: 순번 {순번}\")\n    }\n    if 노드.코드워드 == 214 && 자식수 == 0 {\n      if 노드.식별자있음 {\n        if 스칼라있음(노드, \"text\") {\n          return Err(\"Julia 식별자 이름이 이미지와 분리 본문에 함께 있습니다\")\n        }\n        if 노드.식별자류번호 < 0 || 노드.식별자류번호 > 다음식별자류번호 {\n          return Err(\"Julia 식별자 알파류가 첫 사용 정규형이 아닙니다: 순번 {순번}\")\n        }\n        if 노드.식별자류번호 == 다음식별자류번호 {\n          다음식별자류번호 = 다음식별자류번호 + 1\n        }\n        분리본문발생수 = 분리본문발생수 + 1\n      } else if 노드.식별자류번호 != 0 || !스칼라있음(노드, \"text\") ||\n        노드스칼라(노드, \"text\").태그 != 5 {\n        return Err(\"Julia 이미지 식별자 이름이 정규형이 아닙니다: 순번 {순번}\")\n      }\n    } else {\n      if 노드.식별자있음 || 노드.식별자류번호 != 0 {\n        return Err(\"Julia 식별자가 아닌 노드에 알파류가 있습니다: 순번 {순번}\")\n      }\n      if 줄리아댓글코드(노드.코드워드) {\n        if 자식수 != 0 || 스칼라있음(노드, \"text\") {\n          return Err(\"Julia 댓글 원문은 분리 본문에만 있어야 합니다: 순번 {순번}\")\n        }\n        분리본문발생수 = 분리본문발생수 + 1\n      } else if 줄리아원자본문코드(노드.코드워드) || 자식수 == 0 {\n        if !스칼라있음(노드, \"text\") || 노드스칼라(노드, \"text\").태그 != 5 {\n          return Err(\"Julia 인쇄 토큰의 원문이 없습니다: 순번 {순번}\")\n        }\n      } else if 스칼라있음(노드, \"text\") {\n        return Err(\"Julia 가지 노드에 토큰 원문이 있습니다: 순번 {순번}\")\n      }\n    }\n    순번 = 순번 + 1\n  }\n  순번 = 0\n  while 순번 < 구조.노드들.length {\n    if 줄리아정수스칼라검사(구조.노드들[순번], \"childCount\")? != 자식수들[순번] {\n      return Err(\"Julia 노드 자식 수가 구조와 다릅니다: 순번 {순번}\")\n    }\n    순번 = 순번 + 1\n  }\n  if 구조.분리본문값수 < 0 || 구조.분리본문값수 != 분리본문발생수 {\n    return Err(\"Julia 분리 본문 값 수가 식별자와 댓글 발생 수에 맞지 않습니다\")\n  }\n  Ok(true)\n}\n\nfunction 줄리아잎앞섬(구조: 구조입력, 왼쪽: int, 오른쪽: int) -> bool {\n  let 왼쪽노드 = 구조.노드들[왼쪽]\n  let 오른쪽노드 = 구조.노드들[오른쪽]\n  if 왼쪽노드.시작 != 오른쪽노드.시작 {\n    return 왼쪽노드.시작 < 오른쪽노드.시작\n  }\n  if 왼쪽노드.끝 != 오른쪽노드.끝 {\n    return 왼쪽노드.끝 < 오른쪽노드.끝\n  }\n  왼쪽 < 오른쪽\n}\n\nfunction 줄리아잎순번들(구조: 구조입력) -> Result<Array<int>, string> {\n  let mut 잎들: Array<int> = []\n  let mut 순번 = 0\n  while 순번 < 구조.노드들.length {\n    let 노드 = 구조.노드들[순번]\n    let mut 부모순번 = 노드.부모순번\n    let mut 원자본문조상있음 = false\n    while 부모순번 >= 0 {\n      if 줄리아원자본문코드(구조.노드들[부모순번].코드워드) {\n        원자본문조상있음 = true\n        부모순번 = -1\n      } else {\n        부모순번 = 구조.노드들[부모순번].부모순번\n      }\n    }\n    if !원자본문조상있음 &&\n      (줄리아원자본문코드(노드.코드워드) ||\n        줄리아정수스칼라검사(노드, \"childCount\")? == 0) {\n      잎들.push(순번)\n    }\n    순번 = 순번 + 1\n  }\n  let mut 색인 = 1\n  while 색인 < 잎들.length {\n    let 값 = 잎들[색인]\n    let mut 자리 = 색인\n    while 자리 > 0 && 줄리아잎앞섬(구조, 값, 잎들[자리 - 1]) {\n      잎들[자리] = 잎들[자리 - 1]\n      자리 = 자리 - 1\n    }\n    잎들[자리] = 값\n    색인 = 색인 + 1\n  }\n  Ok(잎들)\n}\n\nexport function 줄리아원본인쇄(구조: 구조입력) -> Result<string, string> {\n  줄리아인쇄구조검사(구조)?\n  let 기본준비 = 인쇄상태만들기(20, 구조, [], [], false, false)\n  let 준비 = 인쇄상태익명이름들바꾸기(기본준비, 익명할당계획이름들(기본준비)?)\n  let 잎들 = 줄리아잎순번들(구조)?\n  let 원본 = 선형원본만들기()\n  let mut 출력행 = 0\n  let mut 출력열 = 0\n  let mut 이전끝행 = 0\n  let mut 이전끝열 = 0\n  let mut 이전끝스칼라열 = 0\n  let mut 이전있음 = false\n  let mut 뒤간격접기 = false\n  let mut 뒤간격구분 = false\n  let mut 이전생략댓글 = false\n  let mut 토큰색인 = 0\n  while 토큰색인 < 잎들.length {\n    let 순번 = 잎들[토큰색인]\n    let 노드 = 구조.노드들[순번]\n    let 시작행 = 줄리아정수스칼라검사(노드, \"startRow\")?\n    let 시작열 = 줄리아정수스칼라검사(노드, \"startColumn\")?\n    let 끝행 = 줄리아정수스칼라검사(노드, \"endRow\")?\n    let 끝열 = 줄리아정수스칼라검사(노드, \"endColumn\")?\n    let 대체폭 = if 시작행 == 끝행 { 끝열 - 시작열 } else { 끝열 }\n    let 식별자노드 = 노드.코드워드 == 214 &&\n      줄리아정수스칼라검사(노드, \"childCount\")? == 0\n    let 분리식별자 = 식별자노드 && 노드.식별자있음\n    let 생략댓글 = 줄리아댓글코드(노드.코드워드) && !스칼라있음(노드, \"text\")\n    let 토큰 = if 생략댓글 { \"\" } else if 식별자노드 {\n      식별자이름(준비, 순번)?\n    } else { 스칼라문자(노드, \"text\") }\n    let 원본스칼라폭 = if 분리식별자 {\n      러스트열폭(노드, \"identifier\", \"Scalar\", 대체폭)\n    } else if 생략댓글 {\n      러스트열폭(노드, \"comment\", \"Scalar\", 대체폭)\n    } else {\n      본문위치전진(20, 0, 0, 토큰)[1]\n    }\n    let 같은원본행 = 이전있음 && 시작행 == 이전끝행\n    let 원본간격 = if 같은원본행 { 시작열 - 이전끝열 } else { 0 }\n    let 원본간격접기 = 뒤간격접기 && 같은원본행\n    let 생략뒤구분 = 뒤간격구분 && 같은원본행\n    let 원본시작스칼라열 = if 같은원본행 {\n      if 원본간격접기 || (원본간격 == 0 && !이전생략댓글) { 출력열 }\n      else { 이전끝스칼라열 + 원본간격 }\n    } else { 시작열 }\n    let 원본끝스칼라열 = if 끝행 == 시작행 {\n      원본시작스칼라열 + 원본스칼라폭\n    } else { 원본스칼라폭 }\n    let 구분필요 = (이전있음 && 시작행 == 이전끝행 && 시작열 > 이전끝열 &&\n      !원본간격접기) || 생략뒤구분\n    뒤간격접기 = false\n    뒤간격구분 = false\n    if 생략댓글 {\n      뒤간격접기 = 스칼라논리(노드, \"commentOmissionCollapsesFollowingGap\")\n      뒤간격구분 = 스칼라논리(노드, \"commentOmissionRequiresFollowingSeparator\")\n    } else {\n      if 출력행 < 시작행 {\n        while 출력행 < 시작행 {\n          선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n        }\n        while 출력열 < 원본시작스칼라열 {\n          선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n        }\n      } else if 출력행 == 시작행 && 출력열 < 원본시작스칼라열 {\n        while 출력열 < 원본시작스칼라열 {\n          선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n        }\n      } else if 출력행 == 시작행 && 구분필요 {\n        선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n      }\n      선형원본추가(원본, 토큰)\n      let 출력위치 = 본문위치전진(20, 출력행, 출력열, 토큰)\n      출력행 = 출력위치[0]\n      출력열 = 출력위치[1]\n      뒤간격구분 = 스칼라논리(노드, \"ternaryColonRequiresFollowingSeparator\")\n    }\n    이전끝행 = 끝행\n    이전끝열 = 끝열\n    이전끝스칼라열 = 원본끝스칼라열\n    이전있음 = true\n    이전생략댓글 = 생략댓글\n    토큰색인 = 토큰색인 + 1\n  }\n  if 선형원본길이(원본) == 0 || 출력열 != 0 { 선형원본추가(원본, \"\\n\") }\n  Ok(선형원본평평하게(원본))\n}\n",
      "sourceSha256": "1f57a911e5484bb454524205aa407323bdefb8394fe2cd620051c4eea5dd98bc"
    },
    {
      "path": "topaz/src/printers/kotlin.tpz",
      "language": "topaz",
      "bytes": 16107,
      "sha256": "cd14cdf68a6a9794eb5c4dab2d41df66709e61fa6fe60ddb02a082ed142b94e5",
      "content": "// Kotlin structure validation and canonical source printing.\n\nimport nodes { 노드종류 }\nimport printer_cursor { 러스트열폭, 본문위치전진 }\nimport printer_setup { 인쇄상태만들기 }\nimport printer_state { 식별자이름 }\nimport printer_text { 선형원본끝공백제거, 선형원본만들기, 선형원본추가, 선형원본평평하게 }\nimport schema { 코틀린댓글코드, 코틀린원자본문코드 }\nimport structure { 구조노드, 구조스칼라, 구조입력, 구조입력검사, 노드스칼라, 스칼라문자, 스칼라있음 }\n\nfunction 코틀린정수스칼라검사(노드: 구조노드, 필드: string) -> Result<int, string> {\n  let 값 = 노드스칼라(노드, 필드)\n  if 값.필드 == \"\" || 값.태그 != 3 || 값.정수값 < 0 {\n    return Err(\"Kotlin 구조 정수 스칼라가 정규형이 아닙니다: {필드}\")\n  }\n  Ok(값.정수값)\n}\n\nexport function 코틀린인쇄구조검사(구조: 구조입력) -> Result<bool, string> {\n  구조입력검사(13, 구조)?\n  if 구조.노드들.length == 0 {\n    return Err(\"Kotlin 인쇄 구조에 원본 파일 노드가 필요합니다\")\n  }\n  if 구조.노드들[0].코드워드 != 13 ||\n    구조.노드들[0].부모순번 != -1 || 구조.노드들[0].자식필드있음 ||\n    구조.노드들[0].자식필드 != \"\" || 구조.노드들[0].자식색인 != -1 {\n    return Err(\"Kotlin 인쇄 구조 뿌리가 원본 파일 노드가 아닙니다\")\n  }\n  let mut 자식수들: Array<int> = []\n  let mut 순번 = 0\n  while 순번 < 구조.노드들.length { 자식수들.push(0); 순번 = 순번 + 1 }\n  let mut 분리본문발생수 = 0\n  let mut 다음식별자류번호 = 0\n  순번 = 0\n  while 순번 < 구조.노드들.length {\n    let 노드 = 구조.노드들[순번]\n    if 노드종류(13, 노드.코드워드) == 0 {\n      return Err(\"Kotlin 투영 인쇄기가 지원하지 않는 노드입니다: 순번 {순번}, 코드 {노드.코드워드}\")\n    }\n    if 순번 > 0 {\n      if 노드.부모순번 < 0 || 노드.부모순번 >= 순번 ||\n        !노드.자식필드있음 || 노드.자식필드 == \"\" || 노드.자식색인 < 0 {\n        return Err(\"Kotlin 인쇄 구조의 부모 또는 자식 위치가 정규형이 아닙니다: 순번 {순번}\")\n      }\n      자식수들[노드.부모순번] = 자식수들[노드.부모순번] + 1\n    }\n    if 노드.시작 < 0 || 노드.끝 < 노드.시작 {\n      return Err(\"Kotlin 인쇄 구조의 원본 범위가 틀립니다: 순번 {순번}\")\n    }\n    let 자식수 = 코틀린정수스칼라검사(노드, \"childCount\")?\n    let 시작행 = 코틀린정수스칼라검사(노드, \"startRow\")?\n    let 시작열 = 코틀린정수스칼라검사(노드, \"startColumn\")?\n    let 끝행 = 코틀린정수스칼라검사(노드, \"endRow\")?\n    let 끝열 = 코틀린정수스칼라검사(노드, \"endColumn\")?\n    if 끝행 < 시작행 || (끝행 == 시작행 && 끝열 < 시작열) {\n      return Err(\"Kotlin 인쇄 구조의 원본 좌표가 틀립니다: 순번 {순번}\")\n    }\n    if !스칼라있음(노드, \"named\") || !스칼라있음(노드, \"extra\") {\n      return Err(\"Kotlin 인쇄 구조의 노드 표지 스칼라가 없습니다: 순번 {순번}\")\n    }\n    if 스칼라있음(노드, \"sourceBom\") {\n      return Err(\"Kotlin 구조에 허용되지 않는 원본 BOM 표지가 있습니다: 순번 {순번}\")\n    }\n    if 노드.코드워드 == 393 && 자식수 == 0 {\n      if 노드.식별자있음 {\n        if 스칼라있음(노드, \"text\") {\n          return Err(\"Kotlin 식별자 이름이 이미지와 분리 본문에 함께 있습니다\")\n        }\n        if 노드.식별자류번호 < 0 || 노드.식별자류번호 > 다음식별자류번호 {\n          return Err(\"Kotlin 식별자 알파류가 첫 사용 정규형이 아닙니다: 순번 {순번}\")\n        }\n        if 노드.식별자류번호 == 다음식별자류번호 {\n          다음식별자류번호 = 다음식별자류번호 + 1\n        }\n        분리본문발생수 = 분리본문발생수 + 1\n      } else if 노드.식별자류번호 != 0 || !스칼라있음(노드, \"text\") ||\n        노드스칼라(노드, \"text\").태그 != 5 {\n        return Err(\"Kotlin 이미지 식별자 이름이 정규형이 아닙니다: 순번 {순번}\")\n      }\n    } else {\n      if 노드.식별자있음 || 노드.식별자류번호 != 0 {\n        return Err(\"Kotlin 식별자가 아닌 노드에 알파류가 있습니다: 순번 {순번}\")\n      }\n      if 코틀린댓글코드(노드.코드워드) {\n        if 자식수 != 0 || 스칼라있음(노드, \"text\") {\n          return Err(\"Kotlin 댓글 원문은 분리 본문에만 있어야 합니다: 순번 {순번}\")\n        }\n        분리본문발생수 = 분리본문발생수 + 1\n      } else if 자식수 == 0 || 코틀린원자본문코드(노드.코드워드) {\n        if !스칼라있음(노드, \"text\") || 노드스칼라(노드, \"text\").태그 != 5 {\n          return Err(\"Kotlin 인쇄 토큰의 원문이 없습니다: 순번 {순번}\")\n        }\n      } else if 스칼라있음(노드, \"text\") {\n        return Err(\"Kotlin 가지 노드에 토큰 원문이 있습니다: 순번 {순번}\")\n      }\n    }\n    순번 = 순번 + 1\n  }\n  순번 = 0\n  while 순번 < 구조.노드들.length {\n    if 코틀린정수스칼라검사(구조.노드들[순번], \"childCount\")? != 자식수들[순번] {\n      return Err(\"Kotlin 노드 자식 수가 구조와 다릅니다: 순번 {순번}\")\n    }\n    순번 = 순번 + 1\n  }\n  if 구조.분리본문값수 < 0 || 구조.분리본문값수 != 분리본문발생수 {\n    return Err(\"Kotlin 분리 본문 값 수가 식별자와 댓글 발생 수에 맞지 않습니다\")\n  }\n  Ok(true)\n}\n\nexport record 코틀린인쇄토큰 {\n  순번: int,\n  간격색인: int\n}\n\nfunction 코틀린토큰정수(구조: 구조입력, 토큰: 코틀린인쇄토큰, 접미: string) -> Result<int, string> {\n  let 노드 = 구조.노드들[토큰.순번]\n  if 토큰.간격색인 < 0 {\n    let 필드 = if 접미 == \"StartRow\" { \"startRow\" }\n      else if 접미 == \"StartColumn\" { \"startColumn\" }\n      else if 접미 == \"EndRow\" { \"endRow\" }\n      else if 접미 == \"EndColumn\" { \"endColumn\" }\n      else { 접미 }\n    return 코틀린정수스칼라검사(노드, 필드)\n  }\n  코틀린정수스칼라검사(노드, \"sourceGap{토큰.간격색인}{접미}\")\n}\n\nfunction 코틀린잎앞섬(구조: 구조입력, 왼쪽: 코틀린인쇄토큰, 오른쪽: 코틀린인쇄토큰) -> Result<bool, string> {\n  let 왼쪽시작 = if 왼쪽.간격색인 < 0 { 구조.노드들[왼쪽.순번].시작 }\n    else { 코틀린토큰정수(구조, 왼쪽, \"Start\")? }\n  let 오른쪽시작 = if 오른쪽.간격색인 < 0 { 구조.노드들[오른쪽.순번].시작 }\n    else { 코틀린토큰정수(구조, 오른쪽, \"Start\")? }\n  if 왼쪽시작 != 오른쪽시작 {\n    return Ok(왼쪽시작 < 오른쪽시작)\n  }\n  let 왼쪽끝 = if 왼쪽.간격색인 < 0 { 구조.노드들[왼쪽.순번].끝 }\n    else { 코틀린토큰정수(구조, 왼쪽, \"End\")? }\n  let 오른쪽끝 = if 오른쪽.간격색인 < 0 { 구조.노드들[오른쪽.순번].끝 }\n    else { 코틀린토큰정수(구조, 오른쪽, \"End\")? }\n  if 왼쪽끝 != 오른쪽끝 {\n    return Ok(왼쪽끝 < 오른쪽끝)\n  }\n  if 왼쪽.순번 != 오른쪽.순번 { Ok(왼쪽.순번 < 오른쪽.순번) }\n  else { Ok(왼쪽.간격색인 < 오른쪽.간격색인) }\n}\n\nfunction 코틀린잎순번들(구조: 구조입력) -> Result<Array<코틀린인쇄토큰>, string> {\n  let mut 잎들: Array<코틀린인쇄토큰> = []\n  let mut 순번 = 0\n  while 순번 < 구조.노드들.length {\n    let 노드 = 구조.노드들[순번]\n    let mut 부모순번 = 노드.부모순번\n    let mut 원자본문조상있음 = false\n    while 부모순번 >= 0 {\n      if 코틀린원자본문코드(구조.노드들[부모순번].코드워드) {\n        원자본문조상있음 = true\n        부모순번 = -1\n      } else {\n        부모순번 = 구조.노드들[부모순번].부모순번\n      }\n    }\n    if !원자본문조상있음 &&\n      (코틀린원자본문코드(노드.코드워드) ||\n        코틀린정수스칼라검사(노드, \"childCount\")? == 0) {\n      잎들.push(코틀린인쇄토큰 { 순번: 순번, 간격색인: -1 })\n    }\n    if 스칼라있음(노드, \"sourceGapCount\") {\n      let 간격수 = 코틀린정수스칼라검사(노드, \"sourceGapCount\")?\n      let mut 간격색인 = 0\n      while 간격색인 < 간격수 {\n        let 시작 = 코틀린정수스칼라검사(노드, \"sourceGap{간격색인}Start\")?\n        let 끝 = 코틀린정수스칼라검사(노드, \"sourceGap{간격색인}End\")?\n        let 글 = 스칼라문자(노드, \"sourceGap{간격색인}Text\")\n        if 시작 < 노드.시작 || 끝 <= 시작 || 끝 > 노드.끝 || 글 == \"\" {\n          return Err(\"Kotlin 투영의 원문 간격이 잘못되었습니다\")\n        }\n        잎들.push(코틀린인쇄토큰 { 순번: 순번, 간격색인: 간격색인 })\n        if 잎들.length > 구조.노드들.length * 2 {\n          return Err(\"Kotlin 투영에 원문 간격이 너무 많습니다\")\n        }\n        간격색인 = 간격색인 + 1\n      }\n    }\n    순번 = 순번 + 1\n  }\n  let mut 색인 = 1\n  while 색인 < 잎들.length {\n    let 값 = 잎들[색인]\n    let mut 자리 = 색인\n    while 자리 > 0 && 코틀린잎앞섬(구조, 값, 잎들[자리 - 1])? {\n      잎들[자리] = 잎들[자리 - 1]\n      자리 = 자리 - 1\n    }\n    잎들[자리] = 값\n    색인 = 색인 + 1\n  }\n  Ok(잎들)\n}\n\nexport function 코틀린원본인쇄(구조: 구조입력) -> Result<string, string> {\n  코틀린인쇄구조검사(구조)?\n  let 준비 = 인쇄상태만들기(13, 구조, [], [], false, false)\n  let 잎들 = 코틀린잎순번들(구조)?\n  let 원본 = 선형원본만들기()\n  let mut 출력행 = 0\n  let mut 출력열 = 0\n  let mut 이전끝행 = 0\n  let mut 이전끝열 = 0\n  let mut 이전끝스칼라열 = 0\n  let mut 이전있음 = false\n  let mut 접힌댓글행수 = 0\n  let mut 접힌댓글뒤구분 = false\n  let mut 토큰색인 = 0\n  while 토큰색인 < 잎들.length {\n    let 인쇄토큰 = 잎들[토큰색인]\n    let 순번 = 인쇄토큰.순번\n    let 노드 = 구조.노드들[순번]\n    let 시작행 = 코틀린토큰정수(구조, 인쇄토큰, \"StartRow\")?\n    let 시작열 = 코틀린토큰정수(구조, 인쇄토큰, \"StartColumn\")?\n    let 끝행 = 코틀린토큰정수(구조, 인쇄토큰, \"EndRow\")?\n    let 끝열 = 코틀린토큰정수(구조, 인쇄토큰, \"EndColumn\")?\n    let 보이는시작행 = 시작행 - 접힌댓글행수\n    let 보이는끝행 = 끝행 - 접힌댓글행수\n    if 보이는시작행 < 0 || 보이는끝행 < 보이는시작행 {\n      return Err(\"Kotlin 투영의 보이는 행 배치가 잘못되었습니다\")\n    }\n    let 대체폭 = if 시작행 == 끝행 { 끝열 - 시작열 } else { 끝열 }\n    let 원문간격 = 인쇄토큰.간격색인 >= 0\n    let 식별자노드 = !원문간격 && 노드.코드워드 == 393 && 코틀린정수스칼라검사(노드, \"childCount\")? == 0\n    let 분리식별자 = 식별자노드 && 노드.식별자있음\n    let 생략댓글 = !원문간격 && 코틀린댓글코드(노드.코드워드) && !스칼라있음(노드, \"text\")\n    let 토큰 = if 생략댓글 { \"\" } else if 식별자노드 {\n      식별자이름(준비, 순번)?\n    } else if 원문간격 {\n      스칼라문자(노드, \"sourceGap{인쇄토큰.간격색인}Text\")\n    } else { 스칼라문자(노드, \"text\") }\n    let 원본스칼라폭 = if 분리식별자 {\n      러스트열폭(노드, \"identifier\", \"Scalar\", 대체폭)\n    } else if 생략댓글 {\n      러스트열폭(노드, \"comment\", \"Scalar\", 대체폭)\n    } else {\n      본문위치전진(13, 0, 0, 토큰)[1]\n    }\n    let 원본시작스칼라열 = if 이전있음 && 시작행 == 이전끝행 {\n      이전끝스칼라열 + 시작열 - 이전끝열\n    } else { 시작열 }\n    let 원본끝스칼라열 = if 끝행 == 시작행 {\n      원본시작스칼라열 + 원본스칼라폭\n    } else { 원본스칼라폭 }\n    let 구분필요 = 이전있음 && 시작행 == 이전끝행 && 시작열 > 이전끝열\n    if 생략댓글 {\n      let 다음시작행 = if 토큰색인 + 1 < 잎들.length {\n        코틀린토큰정수(구조, 잎들[토큰색인 + 1], \"StartRow\")?\n      } else { -1 }\n      let 식안접힘 = 이전있음 && 시작행 == 이전끝행 && 끝행 > 시작행 &&\n        다음시작행 == 끝행\n      if 식안접힘 {\n        접힌댓글행수 = 접힌댓글행수 + 끝행 - 시작행\n        접힌댓글뒤구분 = true\n        토큰색인 = 토큰색인 + 1\n        continue\n      }\n      let 온줄차지 = (!이전있음 || 시작행 > 이전끝행) &&\n        (다음시작행 < 0 || 다음시작행 > 끝행)\n      let 줄끝댓글 = 이전있음 && 시작행 == 이전끝행 &&\n        (다음시작행 < 0 || 다음시작행 > 끝행)\n      if 온줄차지 {\n        while 출력행 < 보이는시작행 {\n          선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n        }\n        while 출력행 < 보이는끝행 {\n          선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n        }\n      } else if 줄끝댓글 {\n        이전끝행 = 끝행\n        이전끝열 = 끝열\n        이전끝스칼라열 = 원본끝스칼라열\n        이전있음 = true\n        토큰색인 = 토큰색인 + 1\n        continue\n      } else {\n        if 출력행 < 보이는시작행 {\n          while 출력행 < 보이는시작행 {\n            선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n          }\n          while 출력열 < 원본시작스칼라열 {\n            선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n          }\n        } else if 출력행 == 보이는시작행 && 출력열 < 원본시작스칼라열 {\n          while 출력열 < 원본시작스칼라열 {\n            선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n          }\n        } else if 출력행 == 보이는시작행 && 구분필요 {\n          선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n        }\n        if 출력행 < 보이는끝행 {\n          while 출력행 < 보이는끝행 {\n            선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n          }\n          while 출력열 < 원본끝스칼라열 {\n            선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n          }\n        } else if 출력행 == 보이는끝행 && 출력열 < 원본끝스칼라열 {\n          while 출력열 < 원본끝스칼라열 {\n            선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n          }\n        }\n      }\n    } else {\n      if 출력행 < 보이는시작행 {\n        while 출력행 < 보이는시작행 {\n          선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n        }\n        while 출력열 < 원본시작스칼라열 {\n          선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n        }\n      } else if 출력행 == 보이는시작행 && 출력열 < 원본시작스칼라열 {\n        while 출력열 < 원본시작스칼라열 {\n          선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n        }\n      } else if 출력행 == 보이는시작행 && (구분필요 || 접힌댓글뒤구분) {\n        선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n      }\n      선형원본추가(원본, 토큰)\n      접힌댓글뒤구분 = false\n      let 출력위치 = 본문위치전진(13, 출력행, 출력열, 토큰)\n      출력행 = 출력위치[0]\n      출력열 = 출력위치[1]\n    }\n    이전끝행 = 끝행\n    이전끝열 = 끝열\n    이전끝스칼라열 = 원본끝스칼라열\n    이전있음 = true\n    토큰색인 = 토큰색인 + 1\n  }\n  선형원본끝공백제거(원본)\n  선형원본추가(원본, \"\\n\")\n  Ok(선형원본평평하게(원본))\n}\n",
      "sourceSha256": "cd14cdf68a6a9794eb5c4dab2d41df66709e61fa6fe60ddb02a082ed142b94e5"
    },
    {
      "path": "topaz/src/printers/lispex.tpz",
      "language": "topaz",
      "bytes": 16805,
      "sha256": "4406e422199f69b873c7ee80bdb65121ccfc0fd2f2656964f3abb210c32f32ea",
      "content": "// Lispex structure validation and canonical source printing.\n\nimport nodes { 노드종류 }\nimport printer_common { 오브젝티브씨잎앞섬 }\nimport printer_cursor { 러스트열폭, 본문위치전진 }\nimport printer_text { 선형원본만들기, 선형원본추가, 선형원본평평하게 }\nimport structure { 구조노드, 구조스칼라, 구조입력, 구조입력검사, 노드스칼라, 스칼라문자, 스칼라있음 }\n\nfunction 리스펙스정수스칼라검사(노드: 구조노드, 필드: string) -> Result<int, string> {\n  let 값 = 노드스칼라(노드, 필드)\n  if 값.필드 == \"\" || 값.태그 != 3 || 값.정수값 < 0 {\n    return Err(\"Lispex 구조 정수 스칼라가 정규형이 아닙니다: {필드}\")\n  }\n  Ok(값.정수값)\n}\n\nfunction 리스펙스가지코드(코드워드: int) -> bool {\n  코드워드 == 53 || 코드워드 == 132 || 코드워드 == 211 ||\n    코드워드 == 290 || 코드워드 == 369 || 코드워드 == 448\n}\n\nfunction 리스펙스접두코드(코드워드: int) -> bool {\n  코드워드 == 410 || 코드워드 == 489 || 코드워드 == 56 || 코드워드 == 135\n}\n\nexport function 리스펙스인쇄구조검사(구조: 구조입력) -> Result<bool, string> {\n  구조입력검사(29, 구조)?\n  if 구조.노드들.length == 0 {\n    return Err(\"Lispex 인쇄 구조에 source_file 노드가 필요합니다\")\n  }\n  if 구조.노드들[0].코드워드 != 53 ||\n    구조.노드들[0].부모순번 != -1 || 구조.노드들[0].자식필드있음 ||\n    구조.노드들[0].자식필드 != \"\" || 구조.노드들[0].자식색인 != -1 ||\n    구조.노드들[0].시작 != 0 {\n    return Err(\"Lispex 인쇄 구조 뿌리가 source_file 노드가 아닙니다\")\n  }\n  let mut 자식수들: Array<int> = []\n  let mut 비댓글수들: Array<int> = []\n  let mut 첫비댓글코드들: Array<int> = []\n  let mut 마지막비댓글코드들: Array<int> = []\n  let mut 점수들: Array<int> = []\n  let mut 점전자료수들: Array<int> = []\n  let mut 점후자료수들: Array<int> = []\n  let mut 순번 = 0\n  while 순번 < 구조.노드들.length {\n    자식수들.push(0)\n    비댓글수들.push(0)\n    첫비댓글코드들.push(-1)\n    마지막비댓글코드들.push(-1)\n    점수들.push(0)\n    점전자료수들.push(0)\n    점후자료수들.push(0)\n    순번 = 순번 + 1\n  }\n  let mut 분리본문발생수 = 0\n  순번 = 0\n  while 순번 < 구조.노드들.length {\n    let 노드 = 구조.노드들[순번]\n    if 노드종류(29, 노드.코드워드) == 0 {\n      return Err(\"Lispex 투영 인쇄기가 지원하지 않는 노드입니다: 순번 {순번}, 코드 {노드.코드워드}\")\n    }\n    if 순번 > 0 {\n      if 노드.부모순번 < 0 || 노드.부모순번 >= 순번 ||\n        !노드.자식필드있음 || 노드.자식필드 == \"\" || 노드.자식색인 < 0 {\n        return Err(\"Lispex 인쇄 구조의 부모 또는 자식 위치가 정규형이 아닙니다: 순번 {순번}\")\n      }\n      let 부모 = 구조.노드들[노드.부모순번]\n      if !리스펙스가지코드(부모.코드워드) {\n        return Err(\"Lispex 잎 노드가 자식을 가집니다: 순번 {순번}\")\n      }\n      let 부모자식수 = 리스펙스정수스칼라검사(부모, \"childCount\")?\n      if 노드.자식색인 != 자식수들[노드.부모순번] || 노드.자식색인 >= 부모자식수 {\n        return Err(\"Lispex 자식 색인이 정규 순서나 부모 자식 수와 다릅니다: 순번 {순번}\")\n      }\n      let 자식필드맞음 =\n        (부모.코드워드 == 53 && 노드.자식필드 == \"forms\") ||\n        (부모.코드워드 == 448 && 노드.자식색인 == 0 && 노드.자식필드 == \"operator\") ||\n        (부모.코드워드 == 448 && 노드.코드워드 == 334 && 노드.자식색인 > 0 && 노드.자식필드 == \"atmosphere\") ||\n        (부모.코드워드 == 448 && 노드.코드워드 != 334 && 노드.자식색인 > 0 && 노드.자식필드 == \"argument\") ||\n        ((부모.코드워드 == 132 || 부모.코드워드 == 211 ||\n          부모.코드워드 == 290 || 부모.코드워드 == 369) && 노드.자식필드 == \"elements\")\n      if !자식필드맞음 {\n        return Err(\"Lispex 자식 필드가 부모 노드 종류와 다릅니다: 순번 {순번}\")\n      }\n      if 노드.시작 < 부모.시작 || 노드.끝 > 부모.끝 {\n        return Err(\"Lispex 자식 원본 범위가 부모를 벗어납니다: 순번 {순번}\")\n      }\n      if 부모.코드워드 == 132 || 부모.코드워드 == 211 {\n        if 노드.자식색인 == 0 && 노드.코드워드 != 15 {\n          return Err(\"Lispex 목록의 여는 괄호가 없습니다: 순번 {순번}\")\n        }\n        if 노드.자식색인 == 부모자식수 - 1 && 노드.코드워드 != 94 {\n          return Err(\"Lispex 목록의 닫는 괄호가 없습니다: 순번 {순번}\")\n        }\n      }\n      if 부모.코드워드 == 290 {\n        if 노드.자식색인 == 0 && 노드.코드워드 != 173 {\n          return Err(\"Lispex 벡터의 여는 토큰이 없습니다: 순번 {순번}\")\n        }\n        if 노드.자식색인 == 부모자식수 - 1 && 노드.코드워드 != 94 {\n          return Err(\"Lispex 벡터의 닫는 괄호가 없습니다: 순번 {순번}\")\n        }\n      }\n      if 부모.코드워드 == 369 {\n        if 노드.자식색인 == 0 && 노드.코드워드 != 252 {\n          return Err(\"Lispex 바이트벡터의 여는 토큰이 없습니다: 순번 {순번}\")\n        }\n        if 노드.자식색인 == 부모자식수 - 1 && 노드.코드워드 != 94 {\n          return Err(\"Lispex 바이트벡터의 닫는 괄호가 없습니다: 순번 {순번}\")\n        }\n        if 노드.자식색인 > 0 && 노드.자식색인 < 부모자식수 - 1 &&\n          노드.코드워드 != 176 && 노드.코드워드 != 334 {\n          return Err(\"Lispex 바이트벡터에 바이트가 아닌 원소가 있습니다: 순번 {순번}\")\n        }\n      }\n      자식수들[노드.부모순번] = 자식수들[노드.부모순번] + 1\n      if 노드.코드워드 != 334 {\n        if 첫비댓글코드들[노드.부모순번] < 0 {\n          첫비댓글코드들[노드.부모순번] = 노드.코드워드\n        }\n        마지막비댓글코드들[노드.부모순번] = 노드.코드워드\n        비댓글수들[노드.부모순번] = 비댓글수들[노드.부모순번] + 1\n        if 노드.코드워드 == 331 {\n          점수들[노드.부모순번] = 점수들[노드.부모순번] + 1\n        } else if 노드.코드워드 != 15 && 노드.코드워드 != 94 &&\n          노드.코드워드 != 173 && 노드.코드워드 != 252 {\n          if 점수들[노드.부모순번] == 0 {\n            점전자료수들[노드.부모순번] = 점전자료수들[노드.부모순번] + 1\n          } else {\n            점후자료수들[노드.부모순번] = 점후자료수들[노드.부모순번] + 1\n          }\n        }\n      }\n    }\n    if 노드.시작 < 0 || 노드.끝 < 노드.시작 {\n      return Err(\"Lispex 인쇄 구조의 원본 범위가 틀립니다: 순번 {순번}\")\n    }\n    let 자식수 = 리스펙스정수스칼라검사(노드, \"childCount\")?\n    let 시작행 = 리스펙스정수스칼라검사(노드, \"startRow\")?\n    let 시작열 = 리스펙스정수스칼라검사(노드, \"startColumn\")?\n    let 끝행 = 리스펙스정수스칼라검사(노드, \"endRow\")?\n    let 끝열 = 리스펙스정수스칼라검사(노드, \"endColumn\")?\n    if 끝행 < 시작행 || (끝행 == 시작행 && 끝열 < 시작열) {\n      return Err(\"Lispex 인쇄 구조의 원본 좌표가 틀립니다: 순번 {순번}\")\n    }\n    if 노드.식별자있음 || 노드.식별자류번호 != 0 {\n      return Err(\"Lispex 이름은 모두 이미지에 있어야 합니다: 순번 {순번}\")\n    }\n    if 노드.코드워드 == 334 {\n      if 자식수 != 0 || 스칼라있음(노드, \"text\") {\n        return Err(\"Lispex 댓글 원문은 분리 본문에만 있어야 합니다: 순번 {순번}\")\n      }\n      분리본문발생수 = 분리본문발생수 + 1\n    } else if 노드.코드워드 == 255 &&\n      (!스칼라있음(노드, \"text\") || 노드스칼라(노드, \"text\").태그 != 5 ||\n        스칼라문자(노드, \"text\").scalars().length == 0) {\n      return Err(\"Lispex 이미지 symbol 이름이 정규형이 아닙니다: 순번 {순번}\")\n    } else if 리스펙스가지코드(노드.코드워드) {\n      if 스칼라있음(노드, \"text\") {\n        return Err(\"Lispex 가지 노드에 토큰 원문이 있습니다: 순번 {순번}\")\n      }\n      if 노드.코드워드 == 53 && 순번 != 0 {\n        return Err(\"Lispex source_file 노드는 뿌리에만 있어야 합니다\")\n      }\n    } else if 자식수 != 0 || !스칼라있음(노드, \"text\") ||\n      노드스칼라(노드, \"text\").태그 != 5 {\n      return Err(\"Lispex 인쇄 토큰의 원문이 없습니다: 순번 {순번}\")\n    }\n    순번 = 순번 + 1\n  }\n  순번 = 0\n  while 순번 < 구조.노드들.length {\n    let 노드 = 구조.노드들[순번]\n    if 리스펙스정수스칼라검사(노드, \"childCount\")? != 자식수들[순번] {\n      return Err(\"Lispex 노드 자식 수가 구조와 다릅니다: 순번 {순번}\")\n    }\n    if 노드.코드워드 == 448 &&\n      (비댓글수들[순번] != 2 || !리스펙스접두코드(첫비댓글코드들[순번])) {\n      return Err(\"Lispex 접두 표현식 모양이 정규형이 아닙니다: 순번 {순번}\")\n    }\n    if 노드.코드워드 == 132 &&\n      (첫비댓글코드들[순번] != 15 || 마지막비댓글코드들[순번] != 94 || 점수들[순번] != 0) {\n      return Err(\"Lispex 목록 모양이 정규형이 아닙니다: 순번 {순번}\")\n    }\n    if 노드.코드워드 == 211 &&\n      (첫비댓글코드들[순번] != 15 || 마지막비댓글코드들[순번] != 94 ||\n        점수들[순번] != 1 || 점전자료수들[순번] < 1 || 점후자료수들[순번] != 1) {\n      return Err(\"Lispex 점 목록 모양이 정규형이 아닙니다: 순번 {순번}\")\n    }\n    if 노드.코드워드 == 290 &&\n      (첫비댓글코드들[순번] != 173 || 마지막비댓글코드들[순번] != 94 || 점수들[순번] != 0) {\n      return Err(\"Lispex 벡터 모양이 정규형이 아닙니다: 순번 {순번}\")\n    }\n    if 노드.코드워드 == 369 &&\n      (첫비댓글코드들[순번] != 252 || 마지막비댓글코드들[순번] != 94 || 점수들[순번] != 0) {\n      return Err(\"Lispex 바이트벡터 모양이 정규형이 아닙니다: 순번 {순번}\")\n    }\n    순번 = 순번 + 1\n  }\n  if 구조.분리본문값수 < 0 || 구조.분리본문값수 != 분리본문발생수 {\n    return Err(\"Lispex 분리 본문 값 수가 댓글 발생 수와 맞지 않습니다\")\n  }\n  Ok(true)\n}\n\nfunction 리스펙스잎순번들(구조: 구조입력) -> Result<Array<int>, string> {\n  let mut 잎들: Array<int> = []\n  let mut 순번 = 1\n  while 순번 < 구조.노드들.length {\n    if 리스펙스정수스칼라검사(구조.노드들[순번], \"childCount\")? == 0 {\n      잎들.push(순번)\n    }\n    순번 = 순번 + 1\n  }\n  let mut 색인 = 1\n  while 색인 < 잎들.length {\n    let 값 = 잎들[색인]\n    let mut 자리 = 색인\n    while 자리 > 0 && 오브젝티브씨잎앞섬(구조, 값, 잎들[자리 - 1]) {\n      잎들[자리] = 잎들[자리 - 1]\n      자리 = 자리 - 1\n    }\n    잎들[자리] = 값\n    색인 = 색인 + 1\n  }\n  Ok(잎들)\n}\n\nexport function 리스펙스원본인쇄(구조: 구조입력) -> Result<string, string> {\n  리스펙스인쇄구조검사(구조)?\n  let 잎들 = 리스펙스잎순번들(구조)?\n  // `원본`은 실제 토큰 글자로만 자라므로 언제나 마지막으로 찍은 토큰에서\n  // 끝난다. 배치 공백은 커서만 움직이고 토큰을 찍는 자리에서 실체가 되니,\n  // 뒤에 토큰이 없는 채움 공백은 출력에 닿지 않는다. 줄 끝 채움은 다음 토큰의\n  // 열을 붙잡기 위해 있고 그 줄에 다음 토큰이 없으면 붙잡을 열이 없다.\n  // 커널 인쇄기와 같은 규칙이며, 끝을 잘라내지 않는 쪽이 규범이다. 잘라내기는\n  // 토큰 내용인 스칼라를 지울 수 있기 때문이다.\n  let 원본 = 선형원본만들기()\n  let mut 확정행 = 0\n  let mut 확정열 = 0\n  let mut 출력행 = 0\n  let mut 출력열 = 0\n  let mut 이전끝행 = 0\n  let mut 이전끝열 = 0\n  let mut 이전끝스칼라열 = 0\n  let mut 이전있음 = false\n  let mut 토큰색인 = 0\n  while 토큰색인 < 잎들.length {\n    let 순번 = 잎들[토큰색인]\n    let 노드 = 구조.노드들[순번]\n    let 시작행 = 리스펙스정수스칼라검사(노드, \"startRow\")?\n    let 시작열 = 리스펙스정수스칼라검사(노드, \"startColumn\")?\n    let 끝행 = 리스펙스정수스칼라검사(노드, \"endRow\")?\n    let 끝열 = 리스펙스정수스칼라검사(노드, \"endColumn\")?\n    let 대체폭 = if 시작행 == 끝행 { 끝열 - 시작열 } else { 끝열 }\n    let 생략댓글 = 노드.코드워드 == 334 && !스칼라있음(노드, \"text\")\n    let 토큰 = if 생략댓글 { \"\" } else { 스칼라문자(노드, \"text\") }\n    let 원본스칼라폭 = if 생략댓글 {\n      러스트열폭(노드, \"comment\", \"Scalar\", 대체폭)\n    } else {\n      본문위치전진(29, 0, 0, 토큰)[1]\n    }\n    let 같은원본행 = 이전있음 && 시작행 == 이전끝행\n    let 원본간격 = if 같은원본행 { 시작열 - 이전끝열 } else { 0 }\n    let 원본시작스칼라열 = if 같은원본행 {\n      if 원본간격 == 0 { 출력열 } else { 이전끝스칼라열 + 원본간격 }\n    } else { 시작열 }\n    let 원본끝스칼라열 = if 끝행 == 시작행 {\n      원본시작스칼라열 + 원본스칼라폭\n    } else { 원본스칼라폭 }\n    let 구분필요 = 이전있음 && 시작행 == 이전끝행 && 시작열 > 이전끝열\n    if 생략댓글 {\n      let 다음시작행 = if 토큰색인 + 1 < 잎들.length {\n        리스펙스정수스칼라검사(구조.노드들[잎들[토큰색인 + 1]], \"startRow\")?\n      } else { -1 }\n      let 온줄차지 = (!이전있음 || 시작행 > 이전끝행) &&\n        (다음시작행 < 0 || 다음시작행 > 끝행)\n      let 줄끝댓글 = 이전있음 && 시작행 == 이전끝행 &&\n        (다음시작행 < 0 || 다음시작행 > 끝행)\n      if 온줄차지 {\n        if 출력행 < 시작행 { 출력행 = 시작행; 출력열 = 0 }\n        if 출력행 < 끝행 { 출력행 = 끝행; 출력열 = 0 }\n      } else if 줄끝댓글 {\n        이전끝행 = 끝행\n        이전끝열 = 끝열\n        이전끝스칼라열 = 원본끝스칼라열\n        이전있음 = true\n        토큰색인 = 토큰색인 + 1\n        continue\n      } else {\n        if 출력행 < 시작행 {\n          출력행 = 시작행\n          출력열 = 원본시작스칼라열\n        } else if 출력행 == 시작행 && 출력열 < 원본시작스칼라열 {\n          출력열 = 원본시작스칼라열\n        } else if 출력행 == 시작행 && 구분필요 {\n          출력열 = 출력열 + 1\n        }\n        if 출력행 < 끝행 {\n          출력행 = 끝행\n          출력열 = 원본끝스칼라열\n        } else if 출력행 == 끝행 && 출력열 < 원본끝스칼라열 {\n          출력열 = 원본끝스칼라열\n        }\n      }\n    } else {\n      if 출력행 < 시작행 {\n        출력행 = 시작행\n        출력열 = 원본시작스칼라열\n      } else if 출력행 == 시작행 && 출력열 < 원본시작스칼라열 {\n        출력열 = 원본시작스칼라열\n      } else if 출력행 == 시작행 && 구분필요 {\n        출력열 = 출력열 + 1\n      }\n      if 출력행 > 확정행 {\n        let mut 남은줄 = 출력행 - 확정행\n        while 남은줄 > 0 { 선형원본추가(원본, \"\\n\"); 남은줄 = 남은줄 - 1 }\n        let mut 첫칸 = 출력열\n        while 첫칸 > 0 { 선형원본추가(원본, \" \"); 첫칸 = 첫칸 - 1 }\n      } else {\n        if 출력열 < 확정열 { return Err(\"리스펙스 인쇄 배치 커서가 뒤로 갔습니다\") }\n        let mut 남은칸 = 출력열 - 확정열\n        while 남은칸 > 0 { 선형원본추가(원본, \" \"); 남은칸 = 남은칸 - 1 }\n      }\n      선형원본추가(원본, 토큰)\n      let 출력위치 = 본문위치전진(29, 출력행, 출력열, 토큰)\n      출력행 = 출력위치[0]\n      출력열 = 출력위치[1]\n      확정행 = 출력행\n      확정열 = 출력열\n    }\n    이전끝행 = 끝행\n    이전끝열 = 끝열\n    이전끝스칼라열 = 원본끝스칼라열\n    이전있음 = true\n    토큰색인 = 토큰색인 + 1\n  }\n  선형원본추가(원본, \"\\n\")\n  Ok(선형원본평평하게(원본))\n}\n",
      "sourceSha256": "4406e422199f69b873c7ee80bdb65121ccfc0fd2f2656964f3abb210c32f32ea"
    },
    {
      "path": "topaz/src/printers/lua.tpz",
      "language": "topaz",
      "bytes": 14616,
      "sha256": "3475c17995750c87701e88f8ce17ab6fd718a0797cdc0279598b92ae6f6c61cb",
      "content": "// Lua structure validation and canonical source printing.\n\nimport names { 익명할당계획이름들 }\nimport nodes { 노드종류 }\nimport printer_cursor { 러스트열폭, 본문위치전진 }\nimport printer_setup { 인쇄상태만들기, 인쇄상태익명이름들바꾸기 }\nimport printer_state { 식별자이름 }\nimport printer_text { 선형원본끝공백제거, 선형원본만들기, 선형원본추가, 선형원본평평하게 }\nimport schema { 루아댓글코드, 루아원자본문코드 }\nimport structure { 구조노드, 구조스칼라, 구조입력, 구조입력검사, 노드스칼라, 스칼라문자, 스칼라있음 }\n\nfunction 루아정수스칼라검사(노드: 구조노드, 필드: string) -> Result<int, string> {\n  let 값 = 노드스칼라(노드, 필드)\n  if 값.필드 == \"\" || 값.태그 != 3 || 값.정수값 < 0 {\n    return Err(\"Lua 구조 정수 스칼라가 정규형이 아닙니다: {필드}\")\n  }\n  Ok(값.정수값)\n}\n\n// Lua 5.4.6 loader: byte-zero BOM, then SPACEBIT (SP or TAB..CR).\nfunction 루아원본시작배치인가(글: string) -> bool {\n  let 글자들 = 글.scalars()\n  let mut 색인 = 0\n  while 색인 < 글자들.length {\n    let 코드 = 글자들[색인].codePointAt(0) ?? 0\n    if !(색인 == 0 && 코드 == 65279) && 코드 != 32 && !(코드 >= 9 && 코드 <= 13) {\n      return false\n    }\n    색인 = 색인 + 1\n  }\n  true\n}\n\nexport function 루아인쇄구조검사(구조: 구조입력) -> Result<bool, string> {\n  구조입력검사(18, 구조)?\n  if 구조.노드들.length == 0 {\n    return Err(\"Lua 인쇄 구조에 chunk 노드가 필요합니다\")\n  }\n  if 구조.노드들[0].코드워드 != 102 ||\n    구조.노드들[0].부모순번 != -1 || 구조.노드들[0].자식필드있음 ||\n    구조.노드들[0].자식필드 != \"\" || 구조.노드들[0].자식색인 != -1 {\n    return Err(\"Lua 인쇄 구조 뿌리가 chunk 노드가 아닙니다\")\n  }\n  let mut 자식수들: Array<int> = []\n  let mut 순번 = 0\n  while 순번 < 구조.노드들.length { 자식수들.push(0); 순번 = 순번 + 1 }\n  let mut 분리본문발생수 = 0\n  let mut 다음식별자류번호 = 0\n  순번 = 0\n  while 순번 < 구조.노드들.length {\n    let 노드 = 구조.노드들[순번]\n    if 노드종류(18, 노드.코드워드) == 0 {\n      return Err(\"Lua 투영 인쇄기가 지원하지 않는 노드입니다: 순번 {순번}, 코드 {노드.코드워드}\")\n    }\n    if 순번 > 0 {\n      if 노드.부모순번 < 0 || 노드.부모순번 >= 순번 ||\n        !노드.자식필드있음 || 노드.자식필드 == \"\" || 노드.자식색인 < 0 {\n        return Err(\"Lua 인쇄 구조의 부모 또는 자식 위치가 정규형이 아닙니다: 순번 {순번}\")\n      }\n      자식수들[노드.부모순번] = 자식수들[노드.부모순번] + 1\n    }\n    if 노드.시작 < 0 || 노드.끝 < 노드.시작 {\n      return Err(\"Lua 인쇄 구조의 원본 범위가 틀립니다: 순번 {순번}\")\n    }\n    let 자식수 = 루아정수스칼라검사(노드, \"childCount\")?\n    let 시작행 = 루아정수스칼라검사(노드, \"startRow\")?\n    let 시작열 = 루아정수스칼라검사(노드, \"startColumn\")?\n    let 끝행 = 루아정수스칼라검사(노드, \"endRow\")?\n    let 끝열 = 루아정수스칼라검사(노드, \"endColumn\")?\n    if 끝행 < 시작행 || (끝행 == 시작행 && 끝열 < 시작열) {\n      return Err(\"Lua 인쇄 구조의 원본 좌표가 틀립니다: 순번 {순번}\")\n    }\n    if !스칼라있음(노드, \"named\") || !스칼라있음(노드, \"extra\") {\n      return Err(\"Lua 인쇄 구조의 노드 표지 스칼라가 없습니다: 순번 {순번}\")\n    }\n    if 스칼라있음(노드, \"sourceBom\") {\n      return Err(\"Lua 구조에 허용되지 않는 원본 BOM 표지가 있습니다: 순번 {순번}\")\n    }\n    if 스칼라있음(노드, \"sourceStartLayout\") {\n      if 순번 != 0 || 노드스칼라(노드, \"sourceStartLayout\").태그 != 5 ||\n        !루아원본시작배치인가(스칼라문자(노드, \"sourceStartLayout\")) {\n        return Err(\"Lua 원본 시작 배치가 정규형이 아닙니다: 순번 {순번}\")\n      }\n    }\n    if 노드.코드워드 == 340 && 자식수 == 0 {\n      if 노드.식별자있음 {\n        if 스칼라있음(노드, \"text\") {\n          return Err(\"Lua 식별자 이름이 이미지와 분리 본문에 함께 있습니다\")\n        }\n        if 노드.식별자류번호 < 0 || 노드.식별자류번호 > 다음식별자류번호 {\n          return Err(\"Lua 식별자 알파류가 첫 사용 정규형이 아닙니다: 순번 {순번}\")\n        }\n        if 노드.식별자류번호 == 다음식별자류번호 {\n          다음식별자류번호 = 다음식별자류번호 + 1\n        }\n        분리본문발생수 = 분리본문발생수 + 1\n      } else if 노드.식별자류번호 != 0 || !스칼라있음(노드, \"text\") ||\n        노드스칼라(노드, \"text\").태그 != 5 {\n        return Err(\"Lua 이미지 식별자 이름이 정규형이 아닙니다: 순번 {순번}\")\n      }\n    } else {\n      if 노드.식별자있음 || 노드.식별자류번호 != 0 {\n        return Err(\"Lua 식별자가 아닌 노드에 알파류가 있습니다: 순번 {순번}\")\n      }\n      if 루아댓글코드(노드.코드워드) {\n        if 자식수 != 0 || 스칼라있음(노드, \"text\") {\n          return Err(\"Lua 댓글 원문은 분리 본문에만 있어야 합니다: 순번 {순번}\")\n        }\n        분리본문발생수 = 분리본문발생수 + 1\n      } else if 자식수 == 0 {\n        if !스칼라있음(노드, \"text\") || 노드스칼라(노드, \"text\").태그 != 5 {\n          return Err(\"Lua 인쇄 토큰의 원문이 없습니다: 순번 {순번}\")\n        }\n      } else if 스칼라있음(노드, \"text\") {\n        return Err(\"Lua 가지 노드에 토큰 원문이 있습니다: 순번 {순번}\")\n      }\n    }\n    순번 = 순번 + 1\n  }\n  순번 = 0\n  while 순번 < 구조.노드들.length {\n    if 루아정수스칼라검사(구조.노드들[순번], \"childCount\")? != 자식수들[순번] {\n      return Err(\"Lua 노드 자식 수가 구조와 다릅니다: 순번 {순번}\")\n    }\n    순번 = 순번 + 1\n  }\n  if 구조.분리본문값수 < 0 || 구조.분리본문값수 != 분리본문발생수 {\n    return Err(\"Lua 분리 본문 값 수가 식별자와 댓글 발생 수에 맞지 않습니다\")\n  }\n  Ok(true)\n}\n\nfunction 루아잎앞섬(구조: 구조입력, 왼쪽: int, 오른쪽: int) -> bool {\n  let 왼쪽노드 = 구조.노드들[왼쪽]\n  let 오른쪽노드 = 구조.노드들[오른쪽]\n  if 왼쪽노드.시작 != 오른쪽노드.시작 {\n    return 왼쪽노드.시작 < 오른쪽노드.시작\n  }\n  if 왼쪽노드.끝 != 오른쪽노드.끝 {\n    return 왼쪽노드.끝 < 오른쪽노드.끝\n  }\n  왼쪽 < 오른쪽\n}\n\nfunction 루아잎순번들(구조: 구조입력) -> Result<Array<int>, string> {\n  let mut 잎들: Array<int> = []\n  let mut 순번 = 0\n  while 순번 < 구조.노드들.length {\n    let 노드 = 구조.노드들[순번]\n    let mut 부모순번 = 노드.부모순번\n    let mut 원자본문조상있음 = false\n    while 부모순번 >= 0 {\n      if 루아원자본문코드(구조.노드들[부모순번].코드워드) {\n        원자본문조상있음 = true\n        부모순번 = -1\n      } else {\n        부모순번 = 구조.노드들[부모순번].부모순번\n      }\n    }\n    if !원자본문조상있음 &&\n      (루아원자본문코드(노드.코드워드) ||\n        루아정수스칼라검사(노드, \"childCount\")? == 0) {\n      잎들.push(순번)\n    }\n    순번 = 순번 + 1\n  }\n  let mut 색인 = 1\n  while 색인 < 잎들.length {\n    let 값 = 잎들[색인]\n    let mut 자리 = 색인\n    while 자리 > 0 && 루아잎앞섬(구조, 값, 잎들[자리 - 1]) {\n      잎들[자리] = 잎들[자리 - 1]\n      자리 = 자리 - 1\n    }\n    잎들[자리] = 값\n    색인 = 색인 + 1\n  }\n  Ok(잎들)\n}\n\nexport function 루아원본인쇄(구조: 구조입력) -> Result<string, string> {\n  루아인쇄구조검사(구조)?\n  let 기본준비 = 인쇄상태만들기(18, 구조, [], [], false, false)\n  let 준비 = 인쇄상태익명이름들바꾸기(기본준비, 익명할당계획이름들(기본준비)?)\n  let 잎들 = 루아잎순번들(구조)?\n  let mut 다음보이는행들: Array<int> = []\n  let mut 채움 = 0\n  while 채움 < 잎들.length { 다음보이는행들.push(-1); 채움 = 채움 + 1 }\n  let mut 다음보이는행 = -1\n  let mut 역색인 = 잎들.length - 1\n  while 역색인 >= 0 {\n    다음보이는행들[역색인] = 다음보이는행\n    let 역노드 = 구조.노드들[잎들[역색인]]\n    let 역생략댓글 = 루아댓글코드(역노드.코드워드) && !스칼라있음(역노드, \"text\")\n    if !역생략댓글 { 다음보이는행 = 루아정수스칼라검사(역노드, \"startRow\")? }\n    역색인 = 역색인 - 1\n  }\n  let 원본 = 선형원본만들기()\n  let 시작배치 = 스칼라문자(구조.노드들[0], \"sourceStartLayout\")\n  let 시작글자들 = 시작배치.scalars()\n  let 머리표지 = if 시작배치.startsWith(\"﻿\") { \"﻿\" } else { \"\" }\n  let 머리폭 = if 머리표지 == \"\" { 0 } else { 1 }\n  let 시작본문 = 시작글자들.slice(머리폭, 시작글자들.length).join(\"\")\n  선형원본추가(원본, 시작본문)\n  let 시작위치 = 본문위치전진(18, 0, 머리폭, 시작본문)\n  let mut 출력행 = 시작위치[0]\n  let mut 출력열 = 시작위치[1]\n  let mut 이전끝행 = 0\n  let mut 이전끝열 = 0\n  let mut 이전끝스칼라열 = 0\n  let mut 이전있음 = false\n  let mut 토큰색인 = 0\n  while 토큰색인 < 잎들.length {\n    let 순번 = 잎들[토큰색인]\n    let 노드 = 구조.노드들[순번]\n    let 시작행 = 루아정수스칼라검사(노드, \"startRow\")?\n    let 시작열 = 루아정수스칼라검사(노드, \"startColumn\")?\n    let 끝행 = 루아정수스칼라검사(노드, \"endRow\")?\n    let 끝열 = 루아정수스칼라검사(노드, \"endColumn\")?\n    let 대체폭 = if 시작행 == 끝행 { 끝열 - 시작열 } else { 끝열 }\n    let 식별자노드 = 노드.코드워드 == 340 && 루아정수스칼라검사(노드, \"childCount\")? == 0\n    let 분리식별자 = 식별자노드 && 노드.식별자있음\n    let 생략댓글 = 루아댓글코드(노드.코드워드) && !스칼라있음(노드, \"text\")\n    let 토큰 = if 생략댓글 { \"\" } else if 식별자노드 {\n      식별자이름(준비, 순번)?\n    } else { 스칼라문자(노드, \"text\") }\n    let 원본스칼라폭 = if 분리식별자 {\n      러스트열폭(노드, \"identifier\", \"Scalar\", 대체폭)\n    } else if 생략댓글 {\n      러스트열폭(노드, \"comment\", \"Scalar\", 대체폭)\n    } else {\n      본문위치전진(18, 0, 0, 토큰)[1]\n    }\n    let 같은원본행 = 이전있음 && 시작행 == 이전끝행\n    let 원본간격 = if 같은원본행 { 시작열 - 이전끝열 } else { 0 }\n    let 원본시작스칼라열 = if 같은원본행 {\n      if 원본간격 == 0 { 출력열 } else { 이전끝스칼라열 + 원본간격 }\n    } else { 시작열 }\n    let 원본끝스칼라열 = if 끝행 == 시작행 {\n      원본시작스칼라열 + 원본스칼라폭\n    } else { 원본스칼라폭 }\n    let 구분필요 = 이전있음 && 시작행 == 이전끝행 && 시작열 > 이전끝열\n    if 생략댓글 {\n      let 다음시작행 = 다음보이는행들[토큰색인]\n      let 온줄차지 = (!이전있음 || 시작행 > 이전끝행) &&\n        (다음시작행 < 0 || 다음시작행 > 끝행)\n      let 줄끝댓글 = 이전있음 && 시작행 == 이전끝행 &&\n        (다음시작행 < 0 || 다음시작행 > 끝행)\n      if 온줄차지 {\n        while 출력행 < 시작행 {\n          선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n        }\n        while 출력행 < 끝행 {\n          선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n        }\n      } else if 줄끝댓글 {\n        이전끝행 = 끝행\n        이전끝열 = 끝열\n        이전끝스칼라열 = 원본끝스칼라열\n        이전있음 = true\n        토큰색인 = 토큰색인 + 1\n        continue\n      } else if 출력행 < 끝행 {\n        while 출력행 < 끝행 {\n          선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n        }\n        while 출력열 < 원본끝스칼라열 {\n          선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n        }\n      } else {\n        if 출력행 < 시작행 {\n          while 출력행 < 시작행 {\n            선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n          }\n          while 출력열 < 원본시작스칼라열 {\n            선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n          }\n        } else if 출력행 == 시작행 && 출력열 < 원본시작스칼라열 {\n          while 출력열 < 원본시작스칼라열 {\n            선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n          }\n        } else if 출력행 == 시작행 && 구분필요 {\n          선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n        }\n        if 출력행 == 끝행 && 출력열 < 원본끝스칼라열 {\n          while 출력열 < 원본끝스칼라열 {\n            선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n          }\n        }\n      }\n    } else {\n      if 출력행 < 시작행 {\n        while 출력행 < 시작행 {\n          선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n        }\n        while 출력열 < 원본시작스칼라열 {\n          선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n        }\n      } else if 출력행 == 시작행 && 출력열 < 원본시작스칼라열 {\n        while 출력열 < 원본시작스칼라열 {\n          선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n        }\n      } else if 출력행 == 시작행 && 구분필요 {\n        선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n      }\n      선형원본추가(원본, 토큰)\n      let 출력위치 = 본문위치전진(18, 출력행, 출력열, 토큰)\n      출력행 = 출력위치[0]\n      출력열 = 출력위치[1]\n    }\n    이전끝행 = 끝행\n    이전끝열 = 끝열\n    이전끝스칼라열 = 원본끝스칼라열\n    이전있음 = true\n    토큰색인 = 토큰색인 + 1\n  }\n  선형원본끝공백제거(원본)\n  선형원본추가(원본, \"\\n\")\n  Ok(머리표지 + 선형원본평평하게(원본))\n}\n",
      "sourceSha256": "3475c17995750c87701e88f8ce17ab6fd718a0797cdc0279598b92ae6f6c61cb"
    },
    {
      "path": "topaz/src/printers/objc.tpz",
      "language": "topaz",
      "bytes": 14631,
      "sha256": "bc01bb6af48fb1f52a99c6508e921f12ed0ffd9c8f8de3ac8858fe28e684cbc6",
      "content": "// Objective-C structure validation and canonical source printing.\n\nimport nodes { 노드종류 }\nimport printer_common { 오브젝티브씨잎앞섬 }\nimport printer_cursor { 러스트열폭, 본문위치전진 }\nimport printer_setup { 인쇄상태만들기 }\nimport printer_state { 식별자이름 }\nimport printer_text { 선형원본끝공백제거, 선형원본만들기, 선형원본추가, 선형원본평평하게 }\nimport structure { 구조노드, 구조스칼라, 구조입력, 구조입력검사, 노드스칼라, 스칼라문자, 스칼라있음, 스칼라정수 }\n\nfunction 오브젝티브씨정수스칼라검사(노드: 구조노드, 필드: string) -> Result<int, string> {\n  let 값 = 노드스칼라(노드, 필드)\n  if 값.필드 == \"\" || 값.태그 != 3 || 값.정수값 < 0 {\n    return Err(\"Objective-C 구조 정수 스칼라가 정규형이 아닙니다: {필드}\")\n  }\n  Ok(값.정수값)\n}\n\nfunction 오브젝티브씨댓글코드(코드워드: int) -> bool {\n  코드워드 == 227 || 코드워드 == 228\n}\n\nexport function 오브젝티브씨인쇄구조검사(구조: 구조입력) -> Result<bool, string> {\n  구조입력검사(25, 구조)?\n  if 구조.노드들.length == 0 {\n    return Err(\"Objective-C 인쇄 구조에 source_file 노드가 필요합니다\")\n  }\n  if 구조.노드들[0].코드워드 != 220 ||\n    구조.노드들[0].부모순번 != -1 || 구조.노드들[0].자식필드있음 ||\n    구조.노드들[0].자식필드 != \"\" || 구조.노드들[0].자식색인 != -1 {\n    return Err(\"Objective-C 인쇄 구조 뿌리가 source_file 노드가 아닙니다\")\n  }\n  let mut 자식수들: Array<int> = []\n  let mut 순번 = 0\n  while 순번 < 구조.노드들.length { 자식수들.push(0); 순번 = 순번 + 1 }\n  let mut 분리본문발생수 = 0\n  let mut 다음식별자류번호 = 0\n  순번 = 0\n  while 순번 < 구조.노드들.length {\n    let 노드 = 구조.노드들[순번]\n    if 노드종류(25, 노드.코드워드) == 0 {\n      return Err(\"Objective-C 투영 인쇄기가 지원하지 않는 노드입니다: 순번 {순번}, 코드 {노드.코드워드}\")\n    }\n    if 순번 > 0 {\n      if 노드.부모순번 != 0 || !노드.자식필드있음 ||\n        노드.자식필드 != \"tokens\" || 노드.자식색인 < 0 {\n        return Err(\"Objective-C 인쇄 구조의 부모 또는 자식 위치가 정규형이 아닙니다: 순번 {순번}\")\n      }\n      자식수들[노드.부모순번] = 자식수들[노드.부모순번] + 1\n    }\n    if 노드.시작 < 0 || 노드.끝 < 노드.시작 {\n      return Err(\"Objective-C 인쇄 구조의 원본 범위가 틀립니다: 순번 {순번}\")\n    }\n    let 자식수 = 오브젝티브씨정수스칼라검사(노드, \"childCount\")?\n    let 시작행 = 오브젝티브씨정수스칼라검사(노드, \"startRow\")?\n    let 시작열 = 오브젝티브씨정수스칼라검사(노드, \"startColumn\")?\n    let 끝행 = 오브젝티브씨정수스칼라검사(노드, \"endRow\")?\n    let 끝열 = 오브젝티브씨정수스칼라검사(노드, \"endColumn\")?\n    if 끝행 < 시작행 || (끝행 == 시작행 && 끝열 < 시작열) {\n      return Err(\"Objective-C 인쇄 구조의 원본 좌표가 틀립니다: 순번 {순번}\")\n    }\n    if 스칼라있음(노드, \"projectionStartRow\") || 스칼라있음(노드, \"projectionStartColumn\") ||\n      스칼라있음(노드, \"projectionEndRow\") || 스칼라있음(노드, \"projectionEndColumn\") ||\n      스칼라있음(노드, \"projectionScalarColumnSpan\") {\n      if 순번 == 0 || 자식수 != 0 {\n        return Err(\"Objective-C 투영 좌표는 토큰 잎에만 있어야 합니다: 순번 {순번}\")\n      }\n      let 투영시작행 = 오브젝티브씨정수스칼라검사(노드, \"projectionStartRow\")?\n      let 투영시작열 = 오브젝티브씨정수스칼라검사(노드, \"projectionStartColumn\")?\n      let 투영끝행 = 오브젝티브씨정수스칼라검사(노드, \"projectionEndRow\")?\n      let 투영끝열 = 오브젝티브씨정수스칼라검사(노드, \"projectionEndColumn\")?\n      let 투영폭 = 오브젝티브씨정수스칼라검사(노드, \"projectionScalarColumnSpan\")?\n      let 기대폭 = if 투영시작행 == 투영끝행 { 투영끝열 - 투영시작열 } else { 투영끝열 }\n      if 투영끝행 < 투영시작행 || (투영끝행 == 투영시작행 && 투영끝열 < 투영시작열) || 투영폭 != 기대폭 {\n        return Err(\"Objective-C 인쇄 구조의 투영 좌표가 틀립니다: 순번 {순번}\")\n      }\n    }\n    if !스칼라있음(노드, \"named\") || !스칼라있음(노드, \"extra\") {\n      return Err(\"Objective-C 인쇄 구조의 노드 표지 스칼라가 없습니다: 순번 {순번}\")\n    }\n    if 노드.코드워드 == 221 {\n      if 자식수 != 0 { return Err(\"Objective-C 식별자에 자식이 있습니다: 순번 {순번}\") }\n      if 노드.식별자있음 {\n        if 스칼라있음(노드, \"text\") {\n          return Err(\"Objective-C 식별자 이름이 이미지와 분리 본문에 함께 있습니다\")\n        }\n        if 노드.식별자류번호 < 0 || 노드.식별자류번호 > 다음식별자류번호 {\n          return Err(\"Objective-C 식별자 알파류가 첫 사용 정규형이 아닙니다: 순번 {순번}\")\n        }\n        if 노드.식별자류번호 == 다음식별자류번호 {\n          다음식별자류번호 = 다음식별자류번호 + 1\n        }\n        분리본문발생수 = 분리본문발생수 + 1\n      } else if 노드.식별자류번호 != 0 || !스칼라있음(노드, \"text\") ||\n        노드스칼라(노드, \"text\").태그 != 5 {\n        return Err(\"Objective-C 이미지 식별자 이름이 정규형이 아닙니다: 순번 {순번}\")\n      }\n    } else {\n      if 노드.식별자있음 || 노드.식별자류번호 != 0 {\n        return Err(\"Objective-C 식별자가 아닌 노드에 알파류가 있습니다: 순번 {순번}\")\n      }\n      if 오브젝티브씨댓글코드(노드.코드워드) {\n        if 자식수 != 0 || 스칼라있음(노드, \"text\") {\n          return Err(\"Objective-C 댓글 원문은 분리 본문에만 있어야 합니다: 순번 {순번}\")\n        }\n        분리본문발생수 = 분리본문발생수 + 1\n      } else if 순번 == 0 {\n        if 자식수 == 0 || 스칼라있음(노드, \"text\") {\n          return Err(\"Objective-C source_file 구조가 정규형이 아닙니다\")\n        }\n      } else if 자식수 != 0 || !스칼라있음(노드, \"text\") ||\n        노드스칼라(노드, \"text\").태그 != 5 {\n        return Err(\"Objective-C 인쇄 토큰의 원문이 없습니다: 순번 {순번}\")\n      }\n    }\n    순번 = 순번 + 1\n  }\n  순번 = 0\n  while 순번 < 구조.노드들.length {\n    if 오브젝티브씨정수스칼라검사(구조.노드들[순번], \"childCount\")? != 자식수들[순번] {\n      return Err(\"Objective-C 노드 자식 수가 구조와 다릅니다: 순번 {순번}\")\n    }\n    순번 = 순번 + 1\n  }\n  if 구조.분리본문값수 < 0 || 구조.분리본문값수 != 분리본문발생수 {\n    return Err(\"Objective-C 분리 본문 값 수가 식별자와 댓글 발생 수에 맞지 않습니다\")\n  }\n  Ok(true)\n}\n\nfunction 오브젝티브씨잎순번들(구조: 구조입력) -> Result<Array<int>, string> {\n  let mut 잎들: Array<int> = []\n  let mut 순번 = 0\n  while 순번 < 구조.노드들.length {\n    if 구조.노드들[순번].부모순번 >= 0 &&\n      오브젝티브씨정수스칼라검사(구조.노드들[순번], \"childCount\")? == 0 {\n      잎들.push(순번)\n    }\n    순번 = 순번 + 1\n  }\n  let mut 색인 = 1\n  while 색인 < 잎들.length {\n    let 값 = 잎들[색인]\n    let mut 자리 = 색인\n    while 자리 > 0 && 오브젝티브씨잎앞섬(구조, 값, 잎들[자리 - 1]) {\n      잎들[자리] = 잎들[자리 - 1]\n      자리 = 자리 - 1\n    }\n    잎들[자리] = 값\n    색인 = 색인 + 1\n  }\n  Ok(잎들)\n}\n\nexport function 오브젝티브씨원본인쇄(구조: 구조입력) -> Result<string, string> {\n  오브젝티브씨인쇄구조검사(구조)?\n  let 준비 = 인쇄상태만들기(25, 구조, [], [], false, false)\n  let 잎들 = 오브젝티브씨잎순번들(구조)?\n  let 원본 = 선형원본만들기()\n  let mut 출력행 = 0\n  let mut 출력열 = 0\n  let mut 이전끝행 = 0\n  let mut 이전끝열 = 0\n  let mut 이전끝스칼라열 = 0\n  let mut 이전있음 = false\n  let mut 토큰색인 = 0\n  while 토큰색인 < 잎들.length {\n    let 순번 = 잎들[토큰색인]\n    let 노드 = 구조.노드들[순번]\n    let 투영좌표 = 스칼라있음(노드, \"projectionStartRow\") &&\n      스칼라있음(노드, \"projectionStartColumn\") && 스칼라있음(노드, \"projectionEndRow\") &&\n      스칼라있음(노드, \"projectionEndColumn\")\n    let 시작행 = 오브젝티브씨정수스칼라검사(노드, if 투영좌표 { \"projectionStartRow\" } else { \"startRow\" })?\n    let 시작열 = 오브젝티브씨정수스칼라검사(노드, if 투영좌표 { \"projectionStartColumn\" } else { \"startColumn\" })?\n    let 끝행 = 오브젝티브씨정수스칼라검사(노드, if 투영좌표 { \"projectionEndRow\" } else { \"endRow\" })?\n    let 끝열 = 오브젝티브씨정수스칼라검사(노드, if 투영좌표 { \"projectionEndColumn\" } else { \"endColumn\" })?\n    let 물리시작행 = 스칼라정수(노드, \"startRow\")\n    let 물리끝행 = 스칼라정수(노드, \"endRow\")\n    let 대체폭 = if 물리시작행 == 물리끝행 {\n      스칼라정수(노드, \"endColumn\") - 스칼라정수(노드, \"startColumn\")\n    } else { 스칼라정수(노드, \"endColumn\") }\n    let 식별자노드 = 노드.코드워드 == 221\n    let 분리식별자 = 식별자노드 && 노드.식별자있음\n    let 생략댓글 = 오브젝티브씨댓글코드(노드.코드워드) && !스칼라있음(노드, \"text\")\n    let 토큰 = if 생략댓글 { \"\" } else if 식별자노드 {\n      식별자이름(준비, 순번)?\n    } else { 스칼라문자(노드, \"text\") }\n    let 원본스칼라폭 = if 투영좌표 && 스칼라있음(노드, \"projectionScalarColumnSpan\") {\n      오브젝티브씨정수스칼라검사(노드, \"projectionScalarColumnSpan\")?\n    } else if 분리식별자 {\n      러스트열폭(노드, \"identifier\", \"Scalar\", 대체폭)\n    } else if 생략댓글 {\n      러스트열폭(노드, \"comment\", \"Scalar\", 대체폭)\n    } else {\n      본문위치전진(25, 0, 0, 토큰)[1]\n    }\n    let 같은원본행 = 이전있음 && 시작행 == 이전끝행\n    let 원본간격 = if 같은원본행 { 시작열 - 이전끝열 } else { 0 }\n    let 원본시작스칼라열 = if 같은원본행 {\n      if 원본간격 == 0 { 출력열 } else { 이전끝스칼라열 + 원본간격 }\n    } else { 시작열 }\n    let 원본끝스칼라열 = if 끝행 == 시작행 {\n      원본시작스칼라열 + 원본스칼라폭\n    } else { 원본스칼라폭 }\n    let 구분필요 = 이전있음 && 시작행 == 이전끝행 && 시작열 > 이전끝열\n    if 생략댓글 {\n      let 다음시작행 = if 토큰색인 + 1 < 잎들.length {\n        오브젝티브씨정수스칼라검사(구조.노드들[잎들[토큰색인 + 1]], \"startRow\")?\n      } else { -1 }\n      let 온줄차지 = (!이전있음 || 시작행 > 이전끝행) &&\n        (다음시작행 < 0 || 다음시작행 > 끝행)\n      let 줄끝댓글 = 이전있음 && 시작행 == 이전끝행 &&\n        (다음시작행 < 0 || 다음시작행 > 끝행)\n      if 온줄차지 {\n        while 출력행 < 시작행 {\n          선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n        }\n        while 출력행 < 끝행 {\n          선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n        }\n      } else if 줄끝댓글 {\n        이전끝행 = 끝행\n        이전끝열 = 끝열\n        이전끝스칼라열 = 원본끝스칼라열\n        이전있음 = true\n        토큰색인 = 토큰색인 + 1\n        continue\n      } else if 끝행 > 시작행 {\n        while 출력행 < 끝행 {\n          선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n        }\n        while 출력열 < 원본끝스칼라열 {\n          선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n        }\n      } else {\n        if 출력행 < 시작행 {\n          while 출력행 < 시작행 {\n            선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n          }\n          while 출력열 < 원본시작스칼라열 {\n            선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n          }\n        } else if 출력행 == 시작행 && 출력열 < 원본시작스칼라열 {\n          while 출력열 < 원본시작스칼라열 {\n            선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n          }\n        } else if 출력행 == 시작행 && 구분필요 {\n          선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n        }\n        if 출력행 < 끝행 {\n          while 출력행 < 끝행 {\n            선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n          }\n          while 출력열 < 원본끝스칼라열 {\n            선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n          }\n        } else if 출력행 == 끝행 && 출력열 < 원본끝스칼라열 {\n          while 출력열 < 원본끝스칼라열 {\n            선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n          }\n        }\n      }\n    } else {\n      if 출력행 < 시작행 {\n        while 출력행 < 시작행 {\n          선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n        }\n        while 출력열 < 원본시작스칼라열 {\n          선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n        }\n      } else if 출력행 == 시작행 && 출력열 < 원본시작스칼라열 {\n        while 출력열 < 원본시작스칼라열 {\n          선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n        }\n      } else if 출력행 == 시작행 && 구분필요 {\n        선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n      }\n      선형원본추가(원본, 토큰)\n      let 출력위치 = 본문위치전진(25, 출력행, 출력열, 토큰)\n      출력행 = 출력위치[0]\n      출력열 = 출력위치[1]\n    }\n    이전끝행 = 끝행\n    이전끝열 = 끝열\n    이전끝스칼라열 = 원본끝스칼라열\n    이전있음 = true\n    토큰색인 = 토큰색인 + 1\n  }\n  선형원본끝공백제거(원본)\n  선형원본추가(원본, \"\\n\")\n  Ok(선형원본평평하게(원본))\n}\n",
      "sourceSha256": "bc01bb6af48fb1f52a99c6508e921f12ed0ffd9c8f8de3ac8858fe28e684cbc6"
    },
    {
      "path": "topaz/src/printers/ocaml.tpz",
      "language": "topaz",
      "bytes": 11069,
      "sha256": "5c00b0e1e85bd45d6b3a3cedbb2b359c2659bbb42b5d25d03287fbe0076f7035",
      "content": "// OCaml structure validation and canonical source printing.\n\nimport nodes { 노드종류 }\nimport printer_cursor { 러스트열폭, 본문위치전진 }\nimport printer_setup { 인쇄상태만들기 }\nimport printer_state { 식별자이름 }\nimport printer_text { 선형원본끝공백제거, 선형원본만들기, 선형원본추가, 선형원본평평하게 }\nimport schema { 오캐멀댓글코드, 오캐멀원자본문코드 }\nimport structure { 구조노드, 구조스칼라, 구조입력, 구조입력검사, 노드스칼라, 스칼라문자, 스칼라있음 }\n\nfunction 오캐멀정수스칼라검사(노드: 구조노드, 필드: string) -> Result<int, string> {\n  let 값 = 노드스칼라(노드, 필드)\n  if 값.필드 == \"\" || 값.태그 != 3 || 값.정수값 < 0 {\n    return Err(\"OCaml 구조 정수 스칼라가 정규형이 아닙니다: {필드}\")\n  }\n  Ok(값.정수값)\n}\n\nexport function 오캐멀인쇄구조검사(구조: 구조입력) -> Result<bool, string> {\n  구조입력검사(21, 구조)?\n  if 구조.노드들.length == 0 {\n    return Err(\"OCaml 인쇄 구조에 compilation_unit 노드가 필요합니다\")\n  }\n  if 구조.노드들[0].코드워드 != 24 ||\n    구조.노드들[0].부모순번 != -1 || 구조.노드들[0].자식필드있음 ||\n    구조.노드들[0].자식필드 != \"\" || 구조.노드들[0].자식색인 != -1 {\n    return Err(\"OCaml 인쇄 구조 뿌리가 compilation_unit 노드가 아닙니다\")\n  }\n  let mut 자식수들: Array<int> = []\n  let mut 순번 = 0\n  while 순번 < 구조.노드들.length { 자식수들.push(0); 순번 = 순번 + 1 }\n  let mut 분리본문발생수 = 0\n  let mut 다음식별자류번호 = 0\n  순번 = 0\n  while 순번 < 구조.노드들.length {\n    let 노드 = 구조.노드들[순번]\n    if 노드종류(21, 노드.코드워드) == 0 {\n      return Err(\"OCaml 투영 인쇄기가 지원하지 않는 노드입니다: 순번 {순번}, 코드 {노드.코드워드}\")\n    }\n    if 순번 > 0 {\n      if 노드.부모순번 < 0 || 노드.부모순번 >= 순번 ||\n        !노드.자식필드있음 || 노드.자식필드 == \"\" || 노드.자식색인 < 0 {\n        return Err(\"OCaml 인쇄 구조의 부모 또는 자식 위치가 정규형이 아닙니다: 순번 {순번}\")\n      }\n      자식수들[노드.부모순번] = 자식수들[노드.부모순번] + 1\n    }\n    if 노드.시작 < 0 || 노드.끝 < 노드.시작 {\n      return Err(\"OCaml 인쇄 구조의 원본 범위가 틀립니다: 순번 {순번}\")\n    }\n    let 자식수 = 오캐멀정수스칼라검사(노드, \"childCount\")?\n    let 시작행 = 오캐멀정수스칼라검사(노드, \"startRow\")?\n    let 시작열 = 오캐멀정수스칼라검사(노드, \"startColumn\")?\n    let 끝행 = 오캐멀정수스칼라검사(노드, \"endRow\")?\n    let 끝열 = 오캐멀정수스칼라검사(노드, \"endColumn\")?\n    if 끝행 < 시작행 || (끝행 == 시작행 && 끝열 < 시작열) {\n      return Err(\"OCaml 인쇄 구조의 원본 좌표가 틀립니다: 순번 {순번}\")\n    }\n    if !스칼라있음(노드, \"named\") || !스칼라있음(노드, \"extra\") {\n      return Err(\"OCaml 인쇄 구조의 노드 표지 스칼라가 없습니다: 순번 {순번}\")\n    }\n    if 스칼라있음(노드, \"sourceBom\") {\n      return Err(\"OCaml 구조에 허용되지 않는 원본 BOM 표지가 있습니다: 순번 {순번}\")\n    }\n    if (노드.코드워드 == 109 || 노드.코드워드 == 269) && 자식수 == 0 {\n      if 노드.식별자있음 {\n        if 스칼라있음(노드, \"text\") {\n          return Err(\"OCaml 식별자 이름이 이미지와 분리 본문에 함께 있습니다\")\n        }\n        if 노드.식별자류번호 < 0 || 노드.식별자류번호 > 다음식별자류번호 {\n          return Err(\"OCaml 식별자 알파류가 첫 사용 정규형이 아닙니다: 순번 {순번}\")\n        }\n        if 노드.식별자류번호 == 다음식별자류번호 {\n          다음식별자류번호 = 다음식별자류번호 + 1\n        }\n        분리본문발생수 = 분리본문발생수 + 1\n      } else if 노드.식별자류번호 != 0 || !스칼라있음(노드, \"text\") ||\n        노드스칼라(노드, \"text\").태그 != 5 {\n        return Err(\"OCaml 이미지 식별자 이름이 정규형이 아닙니다: 순번 {순번}\")\n      }\n    } else {\n      if 노드.식별자있음 || 노드.식별자류번호 != 0 {\n        return Err(\"OCaml 식별자가 아닌 노드에 알파류가 있습니다: 순번 {순번}\")\n      }\n      if 오캐멀댓글코드(노드.코드워드) {\n        if 자식수 != 0 || 스칼라있음(노드, \"text\") {\n          return Err(\"OCaml 댓글 원문은 분리 본문에만 있어야 합니다: 순번 {순번}\")\n        }\n        분리본문발생수 = 분리본문발생수 + 1\n      } else if 오캐멀원자본문코드(노드.코드워드) || 자식수 == 0 {\n        if !스칼라있음(노드, \"text\") || 노드스칼라(노드, \"text\").태그 != 5 {\n          return Err(\"OCaml 인쇄 토큰의 원문이 없습니다: 순번 {순번}\")\n        }\n      } else if 스칼라있음(노드, \"text\") {\n        return Err(\"OCaml 가지 노드에 토큰 원문이 있습니다: 순번 {순번}\")\n      }\n    }\n    순번 = 순번 + 1\n  }\n  순번 = 0\n  while 순번 < 구조.노드들.length {\n    if 오캐멀정수스칼라검사(구조.노드들[순번], \"childCount\")? != 자식수들[순번] {\n      return Err(\"OCaml 노드 자식 수가 구조와 다릅니다: 순번 {순번}\")\n    }\n    순번 = 순번 + 1\n  }\n  if 구조.분리본문값수 < 0 || 구조.분리본문값수 != 분리본문발생수 {\n    return Err(\"OCaml 분리 본문 값 수가 식별자와 댓글 발생 수에 맞지 않습니다\")\n  }\n  Ok(true)\n}\n\nfunction 오캐멀잎앞섬(구조: 구조입력, 왼쪽: int, 오른쪽: int) -> bool {\n  let 왼쪽노드 = 구조.노드들[왼쪽]\n  let 오른쪽노드 = 구조.노드들[오른쪽]\n  if 왼쪽노드.시작 != 오른쪽노드.시작 {\n    return 왼쪽노드.시작 < 오른쪽노드.시작\n  }\n  if 왼쪽노드.끝 != 오른쪽노드.끝 {\n    return 왼쪽노드.끝 < 오른쪽노드.끝\n  }\n  왼쪽 < 오른쪽\n}\n\nfunction 오캐멀잎순번들(구조: 구조입력) -> Result<Array<int>, string> {\n  let mut 잎들: Array<int> = []\n  let mut 순번 = 0\n  while 순번 < 구조.노드들.length {\n    let 노드 = 구조.노드들[순번]\n    let mut 부모순번 = 노드.부모순번\n    let mut 원자본문조상있음 = false\n    while 부모순번 >= 0 {\n      if 오캐멀원자본문코드(구조.노드들[부모순번].코드워드) {\n        원자본문조상있음 = true\n        부모순번 = -1\n      } else {\n        부모순번 = 구조.노드들[부모순번].부모순번\n      }\n    }\n    if !원자본문조상있음 &&\n      (오캐멀원자본문코드(노드.코드워드) ||\n        오캐멀정수스칼라검사(노드, \"childCount\")? == 0) {\n      잎들.push(순번)\n    }\n    순번 = 순번 + 1\n  }\n  let mut 색인 = 1\n  while 색인 < 잎들.length {\n    let 값 = 잎들[색인]\n    let mut 자리 = 색인\n    while 자리 > 0 && 오캐멀잎앞섬(구조, 값, 잎들[자리 - 1]) {\n      잎들[자리] = 잎들[자리 - 1]\n      자리 = 자리 - 1\n    }\n    잎들[자리] = 값\n    색인 = 색인 + 1\n  }\n  Ok(잎들)\n}\n\n// OCaml의 생산자와 기준 인쇄기는 LF 하나만 물리 행 사건으로 삼는다.\n// 문자열 안의 bare CR은 그 토큰의 열을 전진시킬 뿐 다음 토큰의 행을 바꾸지 않는다.\n\nexport function 오캐멀원본인쇄(구조: 구조입력) -> Result<string, string> {\n  오캐멀인쇄구조검사(구조)?\n  let 준비 = 인쇄상태만들기(21, 구조, [], [], false, false)\n  let 잎들 = 오캐멀잎순번들(구조)?\n  let 원본 = 선형원본만들기()\n  let mut 출력행 = 0\n  let mut 출력열 = 0\n  let mut 이전끝행 = 0\n  let mut 이전끝열 = 0\n  let mut 이전끝스칼라열 = 0\n  let mut 이전있음 = false\n  let mut 토큰색인 = 0\n  while 토큰색인 < 잎들.length {\n    let 순번 = 잎들[토큰색인]\n    let 노드 = 구조.노드들[순번]\n    let 시작행 = 오캐멀정수스칼라검사(노드, \"startRow\")?\n    let 시작열 = 오캐멀정수스칼라검사(노드, \"startColumn\")?\n    let 끝행 = 오캐멀정수스칼라검사(노드, \"endRow\")?\n    let 끝열 = 오캐멀정수스칼라검사(노드, \"endColumn\")?\n    let 대체폭 = if 시작행 == 끝행 { 끝열 - 시작열 } else { 끝열 }\n    let 식별자노드 = (노드.코드워드 == 109 || 노드.코드워드 == 269) &&\n      오캐멀정수스칼라검사(노드, \"childCount\")? == 0\n    let 분리식별자 = 식별자노드 && 노드.식별자있음\n    let 생략댓글 = 오캐멀댓글코드(노드.코드워드) && !스칼라있음(노드, \"text\")\n    let 토큰 = if 생략댓글 { \"\" } else if 식별자노드 {\n      식별자이름(준비, 순번)?\n    } else { 스칼라문자(노드, \"text\") }\n    let 원본스칼라폭 = if 분리식별자 {\n      러스트열폭(노드, \"identifier\", \"Scalar\", 대체폭)\n    } else if 생략댓글 {\n      러스트열폭(노드, \"comment\", \"Display\", 대체폭)\n    } else {\n      본문위치전진(21, 0, 0, 토큰)[1]\n    }\n    let 같은원본행 = 이전있음 && 시작행 == 이전끝행\n    let 원본간격 = if 같은원본행 { 시작열 - 이전끝열 } else { 0 }\n    let 원본시작스칼라열 = if 같은원본행 {\n      이전끝스칼라열 + 원본간격\n    } else { 시작열 }\n    let 원본끝스칼라열 = if 끝행 == 시작행 {\n      원본시작스칼라열 + 원본스칼라폭\n    } else { 원본스칼라폭 }\n    let 구분필요 = 이전있음 && 시작행 == 이전끝행 && 시작열 > 이전끝열\n    // 생략 댓글은 출력 사각형을 소유하지 않는다. 그 끝 기하는 다음\n    // 보이는 토큰의 정상 전진에서 한 번만 소비된다.\n    if !생략댓글 {\n      if 출력행 < 시작행 {\n        while 출력행 < 시작행 {\n          선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n        }\n        while 출력열 < 원본시작스칼라열 {\n          선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n        }\n      } else if 출력행 == 시작행 && 출력열 < 원본시작스칼라열 {\n        while 출력열 < 원본시작스칼라열 {\n          선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n        }\n      } else if 출력행 == 시작행 && 구분필요 {\n        선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n      }\n      선형원본추가(원본, 토큰)\n      let 출력위치 = 본문위치전진(21, 출력행, 출력열, 토큰)\n      출력행 = 출력위치[0]\n      출력열 = 출력위치[1]\n    }\n    이전끝행 = 끝행\n    이전끝열 = 끝열\n    이전끝스칼라열 = 원본끝스칼라열\n    이전있음 = true\n    토큰색인 = 토큰색인 + 1\n  }\n  선형원본끝공백제거(원본)\n  선형원본추가(원본, \"\\n\")\n  Ok(선형원본평평하게(원본))\n}\n",
      "sourceSha256": "5c00b0e1e85bd45d6b3a3cedbb2b359c2659bbb42b5d25d03287fbe0076f7035"
    },
    {
      "path": "topaz/src/printers/php.tpz",
      "language": "topaz",
      "bytes": 14442,
      "sha256": "61004967b5d6fad8a16fc5931a73a04d2875548ebf0c158db45012f8c67edba2",
      "content": "// PHP structure validation and canonical source printing.\n\nimport names { 익명할당계획이름들 }\nimport nodes { 노드종류 }\nimport printer_cursor { 러스트열폭, 본문위치전진 }\nimport printer_setup { 인쇄상태만들기, 인쇄상태익명이름들바꾸기 }\nimport printer_state { 식별자이름 }\nimport printer_text { 선형원본끝공백제거, 선형원본만들기, 선형원본추가, 선형원본평평하게 }\nimport schema { 피에이치피댓글코드 }\nimport structure { 구조노드, 구조스칼라, 구조입력, 구조입력검사, 노드스칼라, 스칼라논리, 스칼라문자, 스칼라있음 }\n\nfunction 피에이치피정수스칼라검사(노드: 구조노드, 필드: string) -> Result<int, string> {\n  let 값 = 노드스칼라(노드, 필드)\n  if 값.필드 == \"\" || 값.태그 != 3 || 값.정수값 < 0 {\n    return Err(\"PHP 구조 정수 스칼라가 정규형이 아닙니다: {필드}\")\n  }\n  Ok(값.정수값)\n}\n\nexport function 피에이치피인쇄구조검사(구조: 구조입력) -> Result<bool, string> {\n  구조입력검사(11, 구조)?\n  if 구조.노드들.length == 0 {\n    return Err(\"PHP 인쇄 구조에 프로그램 노드가 필요합니다\")\n  }\n  if 구조.노드들[0].코드워드 != 168 ||\n    구조.노드들[0].부모순번 != -1 || 구조.노드들[0].자식필드있음 ||\n    구조.노드들[0].자식필드 != \"\" || 구조.노드들[0].자식색인 != -1 {\n    return Err(\"PHP 인쇄 구조 뿌리가 프로그램 노드가 아닙니다\")\n  }\n  let mut 자식수들: Array<int> = []\n  let mut 순번 = 0\n  while 순번 < 구조.노드들.length { 자식수들.push(0); 순번 = 순번 + 1 }\n  let mut 분리본문발생수 = 0\n  let mut 다음식별자류번호 = 0\n  순번 = 0\n  while 순번 < 구조.노드들.length {\n    let 노드 = 구조.노드들[순번]\n    let 종류 = 노드종류(11, 노드.코드워드)\n    if 종류 == 0 {\n      return Err(\"PHP 투영 인쇄기가 지원하지 않는 노드입니다: 순번 {순번}, 코드 {노드.코드워드}\")\n    }\n    if 순번 > 0 {\n      if 노드.부모순번 < 0 || 노드.부모순번 >= 순번 ||\n        !노드.자식필드있음 || 노드.자식필드 == \"\" || 노드.자식색인 < 0 {\n        return Err(\"PHP 인쇄 구조의 부모 또는 자식 위치가 정규형이 아닙니다: 순번 {순번}\")\n      }\n      자식수들[노드.부모순번] = 자식수들[노드.부모순번] + 1\n    }\n    if 노드.시작 < 0 || 노드.끝 < 노드.시작 {\n      return Err(\"PHP 인쇄 구조의 원본 범위가 틀립니다: 순번 {순번}\")\n    }\n    let 자식수 = 피에이치피정수스칼라검사(노드, \"childCount\")?\n    let 시작행 = 피에이치피정수스칼라검사(노드, \"startRow\")?\n    let 시작열 = 피에이치피정수스칼라검사(노드, \"startColumn\")?\n    let 끝행 = 피에이치피정수스칼라검사(노드, \"endRow\")?\n    let 끝열 = 피에이치피정수스칼라검사(노드, \"endColumn\")?\n    if 끝행 < 시작행 || (끝행 == 시작행 && 끝열 < 시작열) {\n      return Err(\"PHP 인쇄 구조의 원본 좌표가 틀립니다: 순번 {순번}\")\n    }\n    if !스칼라있음(노드, \"named\") || !스칼라있음(노드, \"extra\") {\n      return Err(\"PHP 인쇄 구조의 노드 표지 스칼라가 없습니다: 순번 {순번}\")\n    }\n    if 순번 == 0 {\n      if 스칼라있음(노드, \"sourceBom\") && !스칼라논리(노드, \"sourceBom\") {\n        return Err(\"PHP 원본 BOM 표지가 정규형이 아닙니다\")\n      }\n    } else if 스칼라있음(노드, \"sourceBom\") {\n      return Err(\"PHP 원본 BOM 표지가 뿌리 밖에 있습니다: 순번 {순번}\")\n    }\n    if 스칼라있음(노드, \"closeTagEchoedTail\") {\n      if 순번 != 0 || 노드스칼라(노드, \"closeTagEchoedTail\").태그 != 5 {\n        return Err(\"PHP 닫는 태그 출력 꼬리가 정규형이 아닙니다\")\n      }\n      for 글자 in 스칼라문자(노드, \"closeTagEchoedTail\").scalars() {\n        if 글자 != \" \" && 글자 != \"\\t\" && 글자 != \"\\n\" && 글자 != \"\\r\" {\n          return Err(\"PHP 닫는 태그 출력 꼬리에 비배치 문자가 있습니다\")\n        }\n      }\n    }\n    if 스칼라있음(노드, \"heredocEndIndentTabs\") &&\n      (노드.코드워드 != 222 || !스칼라논리(노드, \"heredocEndIndentTabs\")) {\n      return Err(\"PHP heredoc 탭 들여쓰기 표지가 정규형이 아닙니다: 순번 {순번}\")\n    }\n    if 종류 == 106 {\n      if 노드.식별자있음 {\n        if 스칼라있음(노드, \"text\") {\n          return Err(\"PHP 식별자 이름이 이미지와 분리 본문에 함께 있습니다\")\n        }\n        if 노드.식별자류번호 < 0 || 노드.식별자류번호 > 다음식별자류번호 {\n          return Err(\"PHP 식별자 알파류가 첫 사용 정규형이 아닙니다: 순번 {순번}\")\n        }\n        if 노드.식별자류번호 == 다음식별자류번호 {\n          다음식별자류번호 = 다음식별자류번호 + 1\n        }\n        분리본문발생수 = 분리본문발생수 + 1\n      } else if 노드.식별자류번호 != 0 || !스칼라있음(노드, \"text\") ||\n        노드스칼라(노드, \"text\").태그 != 5 {\n        return Err(\"PHP 이미지 식별자 이름이 정규형이 아닙니다: 순번 {순번}\")\n      }\n    } else {\n      if 노드.식별자있음 || 노드.식별자류번호 != 0 {\n        return Err(\"PHP 식별자가 아닌 노드에 알파류가 있습니다: 순번 {순번}\")\n      }\n      if 피에이치피댓글코드(노드.코드워드) {\n        if 스칼라있음(노드, \"text\") {\n          return Err(\"PHP 댓글 원문은 분리 본문에만 있어야 합니다: 순번 {순번}\")\n        }\n        분리본문발생수 = 분리본문발생수 + 1\n      } else if 자식수 == 0 {\n        if !스칼라있음(노드, \"text\") || 노드스칼라(노드, \"text\").태그 != 5 {\n          return Err(\"PHP 인쇄 토큰의 원문이 없습니다: 순번 {순번}\")\n        }\n      } else if 스칼라있음(노드, \"text\") {\n        return Err(\"PHP 가지 노드에 토큰 원문이 있습니다: 순번 {순번}\")\n      }\n    }\n    순번 = 순번 + 1\n  }\n  순번 = 0\n  while 순번 < 구조.노드들.length {\n    if 피에이치피정수스칼라검사(구조.노드들[순번], \"childCount\")? != 자식수들[순번] {\n      return Err(\"PHP 노드 자식 수가 구조와 다릅니다: 순번 {순번}\")\n    }\n    순번 = 순번 + 1\n  }\n  if 구조.분리본문값수 < 0 || 구조.분리본문값수 != 분리본문발생수 {\n    return Err(\"PHP 분리 본문 값 수가 식별자와 댓글 발생 수에 맞지 않습니다\")\n  }\n  if 스칼라문자(구조.노드들[0], \"closeTagEchoedTail\") != \"\" {\n    let 잎들 = 피에이치피잎순번들(구조)?\n    if 잎들.length == 0 || 구조.노드들[잎들[잎들.length - 1]].코드워드 != 216 {\n      return Err(\"PHP 닫는 태그 없이 출력 꼬리가 있습니다\")\n    }\n  }\n  Ok(true)\n}\n\nfunction 피에이치피잎앞섬(구조: 구조입력, 왼쪽: int, 오른쪽: int) -> bool {\n  let 왼쪽노드 = 구조.노드들[왼쪽]\n  let 오른쪽노드 = 구조.노드들[오른쪽]\n  if 왼쪽노드.시작 != 오른쪽노드.시작 {\n    return 왼쪽노드.시작 < 오른쪽노드.시작\n  }\n  if 왼쪽노드.끝 != 오른쪽노드.끝 {\n    return 왼쪽노드.끝 < 오른쪽노드.끝\n  }\n  왼쪽 < 오른쪽\n}\n\nfunction 피에이치피잎순번들(구조: 구조입력) -> Result<Array<int>, string> {\n  let mut 잎들: Array<int> = []\n  let mut 순번 = 0\n  while 순번 < 구조.노드들.length {\n    if 피에이치피정수스칼라검사(구조.노드들[순번], \"childCount\")? == 0 {\n      잎들.push(순번)\n    }\n    순번 = 순번 + 1\n  }\n  let mut 색인 = 1\n  while 색인 < 잎들.length {\n    let 값 = 잎들[색인]\n    let mut 자리 = 색인\n    while 자리 > 0 && 피에이치피잎앞섬(구조, 값, 잎들[자리 - 1]) {\n      잎들[자리] = 잎들[자리 - 1]\n      자리 = 자리 - 1\n    }\n    잎들[자리] = 값\n    색인 = 색인 + 1\n  }\n  Ok(잎들)\n}\n\nexport function 피에이치피원본인쇄(구조: 구조입력) -> Result<string, string> {\n  피에이치피인쇄구조검사(구조)?\n  let 기본준비 = 인쇄상태만들기(11, 구조, [], [], false, false)\n  let 준비 = 인쇄상태익명이름들바꾸기(기본준비, 익명할당계획이름들(기본준비)?)\n  let 잎들 = 피에이치피잎순번들(구조)?\n  let 출력꼬리 = 스칼라문자(구조.노드들[0], \"closeTagEchoedTail\")\n  let 원본머리표지있음 = 스칼라논리(구조.노드들[0], \"sourceBom\")\n  let 원본 = 선형원본만들기()\n  if 원본머리표지있음 { 선형원본추가(원본, (65279).toCodePoint() ?? \"\") }\n  let mut 출력행 = 0\n  let mut 출력열 = if 원본머리표지있음 { 1 } else { 0 }\n  let mut 이전끝행 = 0\n  let mut 이전끝열 = 0\n  let mut 이전끝스칼라열 = 0\n  let mut 이전있음 = false\n  let mut 토큰색인 = 0\n  while 토큰색인 < 잎들.length {\n    let 순번 = 잎들[토큰색인]\n    let 노드 = 구조.노드들[순번]\n    let 시작행 = 피에이치피정수스칼라검사(노드, \"startRow\")?\n    let 시작열 = 피에이치피정수스칼라검사(노드, \"startColumn\")?\n    let 끝행 = 피에이치피정수스칼라검사(노드, \"endRow\")?\n    let 끝열 = 피에이치피정수스칼라검사(노드, \"endColumn\")?\n    let 대체폭 = if 시작행 == 끝행 { 끝열 - 시작열 } else { 끝열 }\n    let 식별자노드 = 노드종류(11, 노드.코드워드) == 106\n    let 분리식별자 = 식별자노드 && 노드.식별자있음\n    let 생략댓글 = 피에이치피댓글코드(노드.코드워드) && !스칼라있음(노드, \"text\")\n    let 토큰 = if 생략댓글 { \"\" } else if 식별자노드 {\n      식별자이름(준비, 순번)?\n    } else { 스칼라문자(노드, \"text\") }\n    let 원본스칼라폭 = if 분리식별자 {\n      러스트열폭(노드, \"identifier\", \"Scalar\", 대체폭)\n    } else if 생략댓글 {\n      러스트열폭(노드, \"comment\", \"Scalar\", 대체폭)\n    } else {\n      본문위치전진(11, 0, 0, 토큰)[1]\n    }\n    let 원본시작스칼라열 = if 이전있음 && 시작행 == 이전끝행 {\n      이전끝스칼라열 + 시작열 - 이전끝열\n    } else { 시작열 }\n    let 원본끝스칼라열 = if 끝행 == 시작행 {\n      원본시작스칼라열 + 원본스칼라폭\n    } else { 원본스칼라폭 }\n    let 구분필요 = 이전있음 && 시작행 == 이전끝행 && 시작열 > 이전끝열\n    if 생략댓글 {\n      let 다음시작행 = if 토큰색인 + 1 < 잎들.length {\n        피에이치피정수스칼라검사(구조.노드들[잎들[토큰색인 + 1]], \"startRow\")?\n      } else { -1 }\n      let 온줄차지 = (!이전있음 || 시작행 > 이전끝행) &&\n        (다음시작행 < 0 || 다음시작행 > 끝행)\n      let 줄끝댓글 = 이전있음 && 시작행 == 이전끝행 &&\n        (다음시작행 < 0 || 다음시작행 > 끝행)\n      if 온줄차지 {\n        while 출력행 < 시작행 {\n          선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n        }\n        while 출력행 < 끝행 {\n          선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n        }\n      } else if 줄끝댓글 {\n        이전끝행 = 끝행\n        이전끝열 = 끝열\n        이전끝스칼라열 = 원본끝스칼라열\n        이전있음 = true\n        토큰색인 = 토큰색인 + 1\n        continue\n      } else if 끝행 > 시작행 {\n        while 출력행 < 끝행 {\n          선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n        }\n        while 출력열 < 원본끝스칼라열 {\n          선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n        }\n      } else {\n        if 출력행 < 시작행 {\n          while 출력행 < 시작행 {\n            선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n          }\n          while 출력열 < 원본시작스칼라열 {\n            선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n          }\n        } else if 출력행 == 시작행 && 출력열 < 원본시작스칼라열 {\n          while 출력열 < 원본시작스칼라열 {\n            선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n          }\n        } else if 출력행 == 시작행 && 구분필요 {\n          선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n        }\n        if 출력행 < 끝행 {\n          while 출력행 < 끝행 {\n            선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n          }\n          while 출력열 < 원본끝스칼라열 {\n            선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n          }\n        } else if 출력행 == 끝행 && 출력열 < 원본끝스칼라열 {\n          while 출력열 < 원본끝스칼라열 {\n            선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n          }\n        }\n      }\n    } else {\n      let 탭들여쓰기 = 노드.코드워드 == 222 &&\n        스칼라논리(노드, \"heredocEndIndentTabs\")\n      if 출력행 < 시작행 {\n        while 출력행 < 시작행 {\n          선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n        }\n        while 출력열 < 원본시작스칼라열 {\n          if 탭들여쓰기 { 선형원본추가(원본, \"\\t\") } else { 선형원본추가(원본, \" \") }\n          출력열 = 출력열 + 1\n        }\n      } else if 출력행 == 시작행 && 출력열 < 원본시작스칼라열 {\n        while 출력열 < 원본시작스칼라열 {\n          선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n        }\n      } else if 출력행 == 시작행 && 구분필요 {\n        선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n      }\n      선형원본추가(원본, 토큰)\n      let 출력위치 = 본문위치전진(11, 출력행, 출력열, 토큰)\n      출력행 = 출력위치[0]\n      출력열 = 출력위치[1]\n    }\n    이전끝행 = 끝행\n    이전끝열 = 끝열\n    이전끝스칼라열 = 원본끝스칼라열\n    이전있음 = true\n    토큰색인 = 토큰색인 + 1\n  }\n  선형원본끝공백제거(원본)\n  선형원본추가(원본, \"\\n\")\n  선형원본추가(원본, 출력꼬리)\n  Ok(선형원본평평하게(원본))\n}\n",
      "sourceSha256": "61004967b5d6fad8a16fc5931a73a04d2875548ebf0c158db45012f8c67edba2"
    },
    {
      "path": "topaz/src/printers/python.tpz",
      "language": "topaz",
      "bytes": 14765,
      "sha256": "bca5a2dabb92a94cdaa392150877a25f397f1d3b53d572753c3ca236a7528232",
      "content": "// Python structure validation and canonical source printing.\n\nimport nodes { 노드종류 }\nimport print { 줄끝인가 }\nimport printer_common { 선행가로배치인가 }\nimport printer_setup { 인쇄상태만들기 }\nimport printer_state { 식별자이름 }\nimport printer_text { 선형원본끝공백제거, 선형원본만들기, 선형원본추가, 선형원본평평하게 }\nimport structure { 구조노드, 구조스칼라, 구조입력, 구조입력검사, 노드스칼라, 스칼라문자, 스칼라있음 }\n\nfunction 파이썬정수스칼라검사(노드: 구조노드, 필드: string) -> Result<int, string> {\n  let 값 = 노드스칼라(노드, 필드)\n  if 값.필드 == \"\" || 값.태그 != 3 || 값.정수값 < 0 {\n    return Err(\"파이썬 구조 정수 스칼라가 정규형이 아닙니다: {필드}\")\n  }\n  Ok(값.정수값)\n}\n\nfunction 파이썬가로배치인가(노드: 구조노드) -> bool {\n  선행가로배치인가(노드, false, false)\n}\n\nfunction 파이썬원자본문노드(노드: 구조노드) -> bool {\n  (노드.코드워드 == 254 || 노드.코드워드 == 462) &&\n    스칼라있음(노드, \"text\")\n}\n\nexport function 파이썬인쇄구조검사(구조: 구조입력) -> Result<bool, string> {\n  구조입력검사(3, 구조)?\n  if 구조.노드들.length == 0 { return Err(\"파이썬 인쇄 구조에 모듈 노드가 필요합니다\") }\n  if 구조.노드들[0].코드워드 != 243 ||\n    구조.노드들[0].부모순번 != -1 || 구조.노드들[0].자식필드있음 ||\n    구조.노드들[0].자식필드 != \"\" || 구조.노드들[0].자식색인 != -1 {\n    return Err(\"파이썬 인쇄 구조 뿌리가 모듈 노드가 아닙니다\")\n  }\n  let mut 자식수들: Array<int> = []\n  let mut 순번 = 0\n  while 순번 < 구조.노드들.length { 자식수들.push(0); 순번 = 순번 + 1 }\n  let mut 다음식별자류번호 = 0\n  let mut 분리본문발생수 = 0\n  순번 = 0\n  while 순번 < 구조.노드들.length {\n    let 노드 = 구조.노드들[순번]\n    let 종류 = 노드종류(3, 노드.코드워드)\n    if 종류 == 0 {\n      return Err(\"파이썬 투영 인쇄기가 지원하지 않는 노드입니다: 순번 {순번}, 코드 {노드.코드워드}\")\n    }\n    if 순번 > 0 {\n      if 노드.부모순번 < 0 || 노드.부모순번 >= 순번 ||\n        !노드.자식필드있음 || 노드.자식필드 == \"\" || 노드.자식색인 < 0 {\n        return Err(\"파이썬 인쇄 구조의 부모 또는 자식 위치가 정규형이 아닙니다: 순번 {순번}\")\n      }\n      자식수들[노드.부모순번] = 자식수들[노드.부모순번] + 1\n    }\n    if 노드.시작 < 0 || 노드.끝 < 노드.시작 {\n      return Err(\"파이썬 인쇄 구조의 원본 범위가 틀립니다: 순번 {순번}\")\n    }\n    let 자식수 = 파이썬정수스칼라검사(노드, \"childCount\")?\n    let 시작행 = 파이썬정수스칼라검사(노드, \"startRow\")?\n    let 시작열 = 파이썬정수스칼라검사(노드, \"startColumn\")?\n    let 끝행 = 파이썬정수스칼라검사(노드, \"endRow\")?\n    let 끝열 = 파이썬정수스칼라검사(노드, \"endColumn\")?\n    if 끝행 < 시작행 || (끝행 == 시작행 && 끝열 < 시작열) {\n      return Err(\"파이썬 인쇄 구조의 원본 좌표가 틀립니다: 순번 {순번}\")\n    }\n    if 스칼라있음(노드, \"leadingLineContinuations\") &&\n      파이썬정수스칼라검사(노드, \"leadingLineContinuations\")? <= 0 {\n      return Err(\"파이썬 선행 줄 이음 수가 양수가 아닙니다: 순번 {순번}\")\n    }\n    if 스칼라있음(노드, \"leadingHorizontalLayout\") {\n      if !파이썬가로배치인가(노드) {\n        return Err(\"파이썬 선행 가로 배치가 정규형이 아닙니다: 순번 {순번}\")\n      }\n      if 스칼라있음(노드, \"leadingStringLayout\") {\n        return Err(\"파이썬 토큰에 문자열 배치와 가로 배치가 함께 있습니다: 순번 {순번}\")\n      }\n    }\n    if !스칼라있음(노드, \"named\") || !스칼라있음(노드, \"extra\") {\n      return Err(\"파이썬 인쇄 구조의 노드 표지 스칼라가 없습니다: 순번 {순번}\")\n    }\n    if 종류 == 106 {\n      if 노드.식별자있음 {\n        if 스칼라있음(노드, \"text\") {\n          return Err(\"파이썬 식별자 이름이 이미지와 분리 본문에 함께 있습니다\")\n        }\n        if 스칼라있음(노드, \"pythonNfkcText\") {\n          return Err(\"파이썬 분리 식별자에 정규화 이름이 있습니다: 순번 {순번}\")\n        }\n        if 노드.식별자류번호 < 0 || 노드.식별자류번호 > 다음식별자류번호 {\n          return Err(\"파이썬 식별자 알파류가 첫 사용 정규형이 아닙니다: 순번 {순번}\")\n        }\n        if 노드.식별자류번호 == 다음식별자류번호 {\n          다음식별자류번호 = 다음식별자류번호 + 1\n        }\n        분리본문발생수 = 분리본문발생수 + 1\n      } else {\n        if 노드.식별자류번호 != 0 || !스칼라있음(노드, \"text\") ||\n          노드스칼라(노드, \"text\").태그 != 5 {\n          return Err(\"파이썬 이미지 식별자 이름이 정규형이 아닙니다: 순번 {순번}\")\n        }\n        if 스칼라있음(노드, \"pythonNfkcText\") &&\n          (노드스칼라(노드, \"pythonNfkcText\").태그 != 5 ||\n            노드스칼라(노드, \"pythonNfkcText\").문자열값 == \"\") {\n          return Err(\"파이썬 이미지 식별자의 정규화 이름이 틀립니다: 순번 {순번}\")\n        }\n      }\n    } else {\n      if 스칼라있음(노드, \"pythonNfkcText\") {\n        return Err(\"파이썬 식별자가 아닌 노드에 정규화 이름이 있습니다: 순번 {순번}\")\n      }\n      if 노드.식별자있음 || 노드.식별자류번호 != 0 {\n        return Err(\"파이썬 식별자가 아닌 노드에 알파류가 있습니다: 순번 {순번}\")\n      }\n      if 노드.코드워드 == 289 {\n        if 스칼라있음(노드, \"text\") || 자식수 != 0 {\n          return Err(\"파이썬 댓글 노드가 정규형이 아닙니다: 순번 {순번}\")\n        }\n        분리본문발생수 = 분리본문발생수 + 1\n      } else if 파이썬원자본문노드(노드) {\n        if 노드스칼라(노드, \"text\").태그 != 5 {\n          return Err(\"파이썬 원자 본문이 정규형이 아닙니다: 순번 {순번}\")\n        }\n      } else if 자식수 == 0 &&\n        (!스칼라있음(노드, \"text\") || 노드스칼라(노드, \"text\").태그 != 5) {\n        return Err(\"파이썬 잎 노드의 원문이 없습니다: 순번 {순번}\")\n      }\n    }\n    순번 = 순번 + 1\n  }\n  순번 = 0\n  while 순번 < 구조.노드들.length {\n    if 파이썬정수스칼라검사(구조.노드들[순번], \"childCount\")? != 자식수들[순번] {\n      return Err(\"파이썬 노드 자식 수가 구조와 다릅니다: 순번 {순번}\")\n    }\n    순번 = 순번 + 1\n  }\n  if 구조.분리본문값수 < 0 || 구조.분리본문값수 != 분리본문발생수 {\n    return Err(\"파이썬 분리 본문 값 수가 식별자와 댓글 발생 수에 맞지 않습니다\")\n  }\n  Ok(true)\n}\n\nexport function 파이썬인쇄정규화이름검사(구조: 구조입력) -> Result<bool, string> {\n  let mut 순번 = 0\n  while 순번 < 구조.노드들.length {\n    let 노드 = 구조.노드들[순번]\n    if 노드종류(3, 노드.코드워드) == 106 && !노드.식별자있음 &&\n      !스칼라있음(노드, \"pythonNfkcText\") {\n      return Err(\"파이썬 인쇄 식별자의 정규화 이름이 없습니다: 순번 {순번}\")\n    }\n    순번 = 순번 + 1\n  }\n  Ok(true)\n}\n\nfunction 파이썬들여쓰기(구조: 구조입력, 순번: int) -> string {\n  let mut 깊이 = 0\n  let mut 부모순번 = 구조.노드들[순번].부모순번\n  while 부모순번 >= 0 {\n    if 구조.노드들[부모순번].코드워드 == 101 { 깊이 = 깊이 + 1 }\n    부모순번 = 구조.노드들[부모순번].부모순번\n  }\n  let mut 글 = \"\"\n  let mut 색인 = 0\n  while 색인 < 깊이 { 글 = 글 + \"    \"; 색인 = 색인 + 1 }\n  글\n}\n\nfunction 파이썬원자본문조상(구조: 구조입력, 순번: int) -> bool {\n  let mut 부모순번 = 구조.노드들[순번].부모순번\n  while 부모순번 >= 0 {\n    if 파이썬원자본문노드(구조.노드들[부모순번]) { return true }\n    부모순번 = 구조.노드들[부모순번].부모순번\n  }\n  false\n}\n\nfunction 파이썬문자열조상순번(구조: 구조입력, 순번: int) -> int {\n  let mut 부모순번 = 구조.노드들[순번].부모순번\n  while 부모순번 >= 0 {\n    if 구조.노드들[부모순번].코드워드 == 363 { return 부모순번 }\n    부모순번 = 구조.노드들[부모순번].부모순번\n  }\n  -1\n}\n\nfunction 파이썬지정조상인가(구조: 구조입력, 순번: int, 조상순번: int) -> bool {\n  let mut 부모순번 = 구조.노드들[순번].부모순번\n  while 부모순번 >= 0 {\n    if 부모순번 == 조상순번 { return true }\n    부모순번 = 구조.노드들[부모순번].부모순번\n  }\n  false\n}\n\nexport function 파이썬원본인쇄(구조: 구조입력) -> Result<string, string> {\n  파이썬인쇄구조검사(구조)?\n  파이썬인쇄정규화이름검사(구조)?\n  let 준비 = 인쇄상태만들기(3, 구조, [], [], false, false)\n  let 원본 = 선형원본만들기()\n  let mut 이전끝 = 0\n  let mut 이전끝행 = 0\n  let mut 이전있음 = false\n  let mut 줄머리 = true\n  let mut 줄머리문자열순번 = -1\n  let mut 순번 = 0\n  while 순번 < 구조.노드들.length {\n    let 노드 = 구조.노드들[순번]\n    if !파이썬원자본문조상(구조, 순번) &&\n      (파이썬원자본문노드(노드) ||\n        파이썬정수스칼라검사(노드, \"childCount\")? == 0) &&\n      노드.코드워드 != 289 {\n      if 노드.코드워드 == 218 && 스칼라있음(노드, \"lineContinuationOwnerOrdinal\") {\n        let 소유자순번 = 파이썬정수스칼라검사(노드, \"lineContinuationOwnerOrdinal\")?\n        if 소유자순번 <= 순번 || 소유자순번 >= 구조.노드들.length {\n          return Err(\"파이썬 줄 이음에 뒤따르는 소유자가 없습니다\")\n        }\n        if 구조.노드들[소유자순번].코드워드 == 289 {\n          순번 = 순번 + 1\n          continue\n        }\n      }\n      let 토큰 = if 노드종류(3, 노드.코드워드) == 106 {\n        식별자이름(준비, 순번)?\n      } else { 스칼라문자(노드, \"text\") }\n      let 시작행 = 파이썬정수스칼라검사(노드, \"startRow\")?\n      let 끝행 = 파이썬정수스칼라검사(노드, \"endRow\")?\n      let 줄이음수 = if 스칼라있음(노드, \"leadingLineContinuations\") {\n        파이썬정수스칼라검사(노드, \"leadingLineContinuations\")?\n      } else { 0 }\n      let 문자열배치있음 = 스칼라있음(노드, \"leadingStringLayout\")\n      let 문자열배치 = if 문자열배치있음 {\n        스칼라문자(노드, \"leadingStringLayout\")\n      } else { \"\" }\n      let 가로배치있음 = 스칼라있음(노드, \"leadingHorizontalLayout\")\n      let 가로배치 = if 가로배치있음 {\n        스칼라문자(노드, \"leadingHorizontalLayout\")\n      } else { \"\" }\n      if 문자열배치있음 {\n        if 문자열배치 == \"\" {\n          return Err(\"파이썬 문자열 배치는 비어 있을 수 없습니다\")\n        }\n        let 문자열순번 = 파이썬문자열조상순번(구조, 순번)\n        if !이전있음 || 문자열순번 < 0 {\n          return Err(\"파이썬 문자열 배치 앞에 같은 문자열 토큰이 없습니다\")\n        }\n        선형원본추가(원본, 문자열배치)\n        줄머리 = 줄끝인가(문자열배치)\n        줄머리문자열순번 = if 줄머리 { 문자열순번 } else { -1 }\n      } else {\n        if 줄이음수 > 0 {\n          if !이전있음 || 줄머리 {\n            return Err(\"파이썬 줄 이음 앞에 인쇄 토큰이 없습니다\")\n          }\n          선형원본끝공백제거(원본)\n          선형원본추가(원본, \" \\\\\\n\")\n          let mut 줄이음번호 = 1\n          while 줄이음번호 < 줄이음수 {\n            선형원본추가(원본, \"\\\\\\n\")\n            줄이음번호 = 줄이음번호 + 1\n          }\n          줄머리 = true\n          줄머리문자열순번 = -1\n        }\n        if !이전있음 && 시작행 > 0 {\n          let mut 빈줄수 = 0\n          while 빈줄수 < 시작행 {\n            선형원본추가(원본, \"\\n\")\n            빈줄수 = 빈줄수 + 1\n          }\n          줄머리 = true\n          줄머리문자열순번 = -1\n        } else if 이전있음 && 시작행 > 이전끝행 + 줄이음수 {\n          // 토큰을 찍고 나면 커서는 그 토큰의 끝행에 있고 바로 위에서 찍은 줄\n          // 이음이 각각 한 행씩 더 먹었으므로, 남은 간격은\n          // 시작행 - 이전끝행 - 줄이음수 줄이다. 줄 이음은 두 가지 모습으로\n          // 오는데 이 분기 하나가 둘 다 감당한다. 트리시터가 line_continuation\n          // 잎을 낼 때는 그 본문에 줄바꿈이 이미 들어 있어 끝공백제거가 그것을\n          // 지웠고, 노드 없이 이미지가 개수만 실어 나를 때는 행 넘김 자체가\n          // 막혀 있었다. 어느 쪽이든 줄 이음 뒤의 빈 줄이 물리 행 하나를\n          // 잃었고, 파이썬은 co_firstlineno와 f_lineno와 tb_lineno로 물리\n          // 행을 드러낸다.\n          let mut 빈줄수 = 0\n          while 빈줄수 < 시작행 - 이전끝행 - 줄이음수 {\n            선형원본추가(원본, \"\\n\")\n            빈줄수 = 빈줄수 + 1\n          }\n          줄머리 = true\n          줄머리문자열순번 = -1\n        }\n        if 이전있음 && 시작행 == 이전끝행 && !줄머리 && 노드.시작 > 이전끝 {\n          선형원본추가(원본, if 가로배치있음 { 가로배치 } else { \" \" })\n        }\n      }\n      if 줄머리 {\n        if 줄머리문자열순번 < 0 ||\n          !파이썬지정조상인가(구조, 순번, 줄머리문자열순번) {\n          선형원본추가(원본, if 가로배치있음 { 가로배치 } else {\n            파이썬들여쓰기(구조, 순번)\n          })\n        }\n      }\n      선형원본추가(원본, 토큰)\n      줄머리 = 줄끝인가(토큰)\n      줄머리문자열순번 = if 줄머리 {\n        파이썬문자열조상순번(구조, 순번)\n      } else { -1 }\n      이전끝 = 노드.끝\n      이전끝행 = 끝행\n      이전있음 = true\n    }\n    순번 = 순번 + 1\n  }\n  선형원본끝공백제거(원본)\n  선형원본추가(원본, \"\\n\")\n  Ok(선형원본평평하게(원본))\n}\n",
      "sourceSha256": "bca5a2dabb92a94cdaa392150877a25f397f1d3b53d572753c3ca236a7528232"
    },
    {
      "path": "topaz/src/printers/r.tpz",
      "language": "topaz",
      "bytes": 15351,
      "sha256": "33a8d59a867cc189934fce9e4e258574b0778ccad23484365cc074eefe1f1825",
      "content": "// R structure validation and canonical source printing.\n\nimport names { 익명할당계획이름들 }\nimport nodes { 노드종류 }\nimport printer_cursor { 러스트열폭, 본문위치전진 }\nimport printer_setup { 인쇄상태만들기, 인쇄상태익명이름들바꾸기 }\nimport printer_state { 식별자이름 }\nimport printer_text { 선형원본끝공백제거, 선형원본만들기, 선형원본추가, 선형원본평평하게 }\nimport schema { 알댓글코드, 알원자본문코드 }\nimport structure { 구조노드, 구조스칼라, 구조입력, 구조입력검사, 노드스칼라, 스칼라문자, 스칼라있음 }\n\nfunction 알정수스칼라검사(노드: 구조노드, 필드: string) -> Result<int, string> {\n  let 값 = 노드스칼라(노드, 필드)\n  if 값.필드 == \"\" || 값.태그 != 3 || 값.정수값 < 0 {\n    return Err(\"R 구조 정수 스칼라가 정규형이 아닙니다: {필드}\")\n  }\n  Ok(값.정수값)\n}\n\nexport function 알인쇄구조검사(구조: 구조입력) -> Result<bool, string> {\n  구조입력검사(19, 구조)?\n  if 구조.노드들.length == 0 {\n    return Err(\"R 인쇄 구조에 program 노드가 필요합니다\")\n  }\n  if 구조.노드들[0].코드워드 != 375 ||\n    구조.노드들[0].부모순번 != -1 || 구조.노드들[0].자식필드있음 ||\n    구조.노드들[0].자식필드 != \"\" || 구조.노드들[0].자식색인 != -1 {\n    return Err(\"R 인쇄 구조 뿌리가 program 노드가 아닙니다\")\n  }\n  let mut 자식수들: Array<int> = []\n  let mut 순번 = 0\n  while 순번 < 구조.노드들.length { 자식수들.push(0); 순번 = 순번 + 1 }\n  let mut 분리본문발생수 = 0\n  let mut 다음식별자류번호 = 0\n  순번 = 0\n  while 순번 < 구조.노드들.length {\n    let 노드 = 구조.노드들[순번]\n    if 노드종류(19, 노드.코드워드) == 0 {\n      return Err(\"R 투영 인쇄기가 지원하지 않는 노드입니다: 순번 {순번}, 코드 {노드.코드워드}\")\n    }\n    if 순번 > 0 {\n      if 노드.부모순번 < 0 || 노드.부모순번 >= 순번 ||\n        !노드.자식필드있음 || 노드.자식필드 == \"\" || 노드.자식색인 < 0 {\n        return Err(\"R 인쇄 구조의 부모 또는 자식 위치가 정규형이 아닙니다: 순번 {순번}\")\n      }\n      자식수들[노드.부모순번] = 자식수들[노드.부모순번] + 1\n    }\n    if 노드.시작 < 0 || 노드.끝 < 노드.시작 {\n      return Err(\"R 인쇄 구조의 원본 범위가 틀립니다: 순번 {순번}\")\n    }\n    let 자식수 = 알정수스칼라검사(노드, \"childCount\")?\n    let 시작행 = 알정수스칼라검사(노드, \"startRow\")?\n    let 시작열 = 알정수스칼라검사(노드, \"startColumn\")?\n    let 끝행 = 알정수스칼라검사(노드, \"endRow\")?\n    let 끝열 = 알정수스칼라검사(노드, \"endColumn\")?\n    if 끝행 < 시작행 || (끝행 == 시작행 && 끝열 < 시작열) {\n      return Err(\"R 인쇄 구조의 원본 좌표가 틀립니다: 순번 {순번}\")\n    }\n    if !스칼라있음(노드, \"named\") || !스칼라있음(노드, \"extra\") {\n      return Err(\"R 인쇄 구조의 노드 표지 스칼라가 없습니다: 순번 {순번}\")\n    }\n    if 스칼라있음(노드, \"sourceBom\") {\n      return Err(\"R 구조에 허용되지 않는 원본 BOM 표지가 있습니다: 순번 {순번}\")\n    }\n    if 노드.코드워드 == 190 && 자식수 == 0 {\n      if 노드.식별자있음 {\n        if 스칼라있음(노드, \"text\") {\n          return Err(\"R 식별자 이름이 이미지와 분리 본문에 함께 있습니다\")\n        }\n        if 노드.식별자류번호 < 0 || 노드.식별자류번호 > 다음식별자류번호 {\n          return Err(\"R 식별자 알파류가 첫 사용 정규형이 아닙니다: 순번 {순번}\")\n        }\n        if 노드.식별자류번호 == 다음식별자류번호 {\n          다음식별자류번호 = 다음식별자류번호 + 1\n        }\n        분리본문발생수 = 분리본문발생수 + 1\n      } else if 노드.식별자류번호 != 0 || !스칼라있음(노드, \"text\") ||\n        노드스칼라(노드, \"text\").태그 != 5 {\n        return Err(\"R 이미지 식별자 이름이 정규형이 아닙니다: 순번 {순번}\")\n      }\n    } else {\n      if 노드.식별자있음 || 노드.식별자류번호 != 0 {\n        return Err(\"R 식별자가 아닌 노드에 알파류가 있습니다: 순번 {순번}\")\n      }\n      if 알댓글코드(노드.코드워드) {\n        if 자식수 != 0 || 스칼라있음(노드, \"text\") {\n          return Err(\"R 댓글 원문은 분리 본문에만 있어야 합니다: 순번 {순번}\")\n        }\n        분리본문발생수 = 분리본문발생수 + 1\n      } else if 알원자본문코드(노드.코드워드) || 자식수 == 0 {\n        if !스칼라있음(노드, \"text\") || 노드스칼라(노드, \"text\").태그 != 5 {\n          return Err(\"R 인쇄 토큰의 원문이 없습니다: 순번 {순번}\")\n        }\n      } else if 스칼라있음(노드, \"text\") {\n        return Err(\"R 가지 노드에 토큰 원문이 있습니다: 순번 {순번}\")\n      }\n    }\n    순번 = 순번 + 1\n  }\n  순번 = 0\n  while 순번 < 구조.노드들.length {\n    if 알정수스칼라검사(구조.노드들[순번], \"childCount\")? != 자식수들[순번] {\n      return Err(\"R 노드 자식 수가 구조와 다릅니다: 순번 {순번}\")\n    }\n    순번 = 순번 + 1\n  }\n  if 구조.분리본문값수 < 0 || 구조.분리본문값수 != 분리본문발생수 {\n    return Err(\"R 분리 본문 값 수가 식별자와 댓글 발생 수에 맞지 않습니다\")\n  }\n  Ok(true)\n}\n\nfunction 알잎앞섬(구조: 구조입력, 왼쪽: int, 오른쪽: int) -> bool {\n  let 왼쪽노드 = 구조.노드들[왼쪽]\n  let 오른쪽노드 = 구조.노드들[오른쪽]\n  if 왼쪽노드.시작 != 오른쪽노드.시작 {\n    return 왼쪽노드.시작 < 오른쪽노드.시작\n  }\n  if 왼쪽노드.끝 != 오른쪽노드.끝 {\n    return 왼쪽노드.끝 < 오른쪽노드.끝\n  }\n  왼쪽 < 오른쪽\n}\n\nfunction 알잎순번들(구조: 구조입력) -> Result<Array<int>, string> {\n  let mut 잎들: Array<int> = []\n  let mut 순번 = 0\n  while 순번 < 구조.노드들.length {\n    let 노드 = 구조.노드들[순번]\n    let mut 부모순번 = 노드.부모순번\n    let mut 원자본문조상있음 = false\n    while 부모순번 >= 0 {\n      if 알원자본문코드(구조.노드들[부모순번].코드워드) {\n        원자본문조상있음 = true\n        부모순번 = -1\n      } else {\n        부모순번 = 구조.노드들[부모순번].부모순번\n      }\n    }\n    if !원자본문조상있음 &&\n      (알원자본문코드(노드.코드워드) ||\n        알정수스칼라검사(노드, \"childCount\")? == 0) {\n      잎들.push(순번)\n    }\n    순번 = 순번 + 1\n  }\n  let mut 색인 = 1\n  while 색인 < 잎들.length {\n    let 값 = 잎들[색인]\n    let mut 자리 = 색인\n    while 자리 > 0 && 알잎앞섬(구조, 값, 잎들[자리 - 1]) {\n      잎들[자리] = 잎들[자리 - 1]\n      자리 = 자리 - 1\n    }\n    잎들[자리] = 값\n    색인 = 색인 + 1\n  }\n  Ok(잎들)\n}\n\nexport function 알원본인쇄(구조: 구조입력) -> Result<string, string> {\n  알인쇄구조검사(구조)?\n  let 기본준비 = 인쇄상태만들기(19, 구조, [], [], false, false)\n  let 준비 = 인쇄상태익명이름들바꾸기(기본준비, 익명할당계획이름들(기본준비)?)\n  let 잎들 = 알잎순번들(구조)?\n  let 원본 = 선형원본만들기()\n  let mut 출력행 = 0\n  let mut 출력열 = 0\n  let mut 이전끝행 = 0\n  let mut 이전끝열 = 0\n  let mut 이전끝스칼라열 = 0\n  let mut 이전있음 = false\n  let mut 토큰색인 = 0\n  while 토큰색인 < 잎들.length {\n    let 순번 = 잎들[토큰색인]\n    let 노드 = 구조.노드들[순번]\n    let 시작행 = 알정수스칼라검사(노드, \"startRow\")?\n    let 시작열 = 알정수스칼라검사(노드, \"startColumn\")?\n    let 끝행 = 알정수스칼라검사(노드, \"endRow\")?\n    let 끝열 = 알정수스칼라검사(노드, \"endColumn\")?\n    let 대체폭 = if 시작행 == 끝행 { 끝열 - 시작열 } else { 끝열 }\n    let 식별자노드 = 노드.코드워드 == 190 && 알정수스칼라검사(노드, \"childCount\")? == 0\n    let 분리식별자 = 식별자노드 && 노드.식별자있음\n    let 생략댓글 = 알댓글코드(노드.코드워드) && !스칼라있음(노드, \"text\")\n    let 토큰 = if 생략댓글 { \"\" } else if 식별자노드 {\n      식별자이름(준비, 순번)?\n    } else { 스칼라문자(노드, \"text\") }\n    let 원본스칼라폭 = if 분리식별자 {\n      러스트열폭(노드, \"identifier\", \"Scalar\", 대체폭)\n    } else if 생략댓글 {\n      러스트열폭(노드, \"comment\", \"Scalar\", 대체폭)\n    } else {\n      본문위치전진(19, 0, 0, 토큰)[1]\n    }\n    let 같은원본행 = 이전있음 && 시작행 == 이전끝행\n    let 원본간격 = if 같은원본행 { 시작열 - 이전끝열 } else { 0 }\n    let 원본시작스칼라열 = if 같은원본행 {\n      if 원본간격 == 0 { 출력열 } else { 이전끝스칼라열 + 원본간격 }\n    } else { 시작열 }\n    let 원본끝스칼라열 = if 끝행 == 시작행 {\n      원본시작스칼라열 + 원본스칼라폭\n    } else { 원본스칼라폭 }\n    let 구분필요 = 이전있음 && 시작행 == 이전끝행 && 시작열 > 이전끝열\n    let 앞세미콜론수 = if 스칼라있음(노드, \"leadingSemicolonCount\") {\n      알정수스칼라검사(노드, \"leadingSemicolonCount\")?\n    } else { 0 }\n    let 뒤세미콜론수 = if 스칼라있음(노드, \"trailingSemicolonCount\") {\n      알정수스칼라검사(노드, \"trailingSemicolonCount\")?\n    } else { 0 }\n    if 앞세미콜론수 > 0 {\n      if 스칼라있음(노드, \"leadingSemicolonStartRow\") &&\n        스칼라있음(노드, \"leadingSemicolonStartColumn\") {\n        let 세미콜론행 = 알정수스칼라검사(노드, \"leadingSemicolonStartRow\")?\n        let 세미콜론열 = 알정수스칼라검사(노드, \"leadingSemicolonStartColumn\")?\n        if 출력행 < 세미콜론행 {\n          while 출력행 < 세미콜론행 {\n            선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n          }\n          while 출력열 < 세미콜론열 {\n            선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n          }\n        } else if 출력행 == 세미콜론행 && 출력열 < 세미콜론열 {\n          while 출력열 < 세미콜론열 {\n            선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n          }\n        }\n      }\n      let mut 세미콜론 = 0\n      while 세미콜론 < 앞세미콜론수 {\n        선형원본추가(원본, \";\"); 출력열 = 출력열 + 1; 세미콜론 = 세미콜론 + 1\n      }\n    }\n    if 생략댓글 {\n      let 다음시작행 = if 토큰색인 + 1 < 잎들.length {\n        알정수스칼라검사(구조.노드들[잎들[토큰색인 + 1]], \"startRow\")?\n      } else { -1 }\n      let 온줄차지 = 뒤세미콜론수 == 0 && (!이전있음 || 시작행 > 이전끝행) &&\n        (다음시작행 < 0 || 다음시작행 > 끝행)\n      let 줄끝댓글 = 뒤세미콜론수 == 0 && 이전있음 && 시작행 == 이전끝행 &&\n        (다음시작행 < 0 || 다음시작행 > 끝행)\n      if 온줄차지 {\n        while 출력행 < 시작행 {\n          선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n        }\n        while 출력행 < 끝행 {\n          선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n        }\n      } else if 줄끝댓글 {\n        이전끝행 = 끝행\n        이전끝열 = 끝열\n        이전끝스칼라열 = 원본끝스칼라열\n        이전있음 = true\n        토큰색인 = 토큰색인 + 1\n        continue\n      } else {\n        if 출력행 < 시작행 {\n          while 출력행 < 시작행 {\n            선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n          }\n          while 출력열 < 원본시작스칼라열 {\n            선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n          }\n        } else if 출력행 == 시작행 && 출력열 < 원본시작스칼라열 {\n          while 출력열 < 원본시작스칼라열 {\n            선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n          }\n        } else if 출력행 == 시작행 && 구분필요 {\n          선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n        }\n        if 출력행 < 끝행 {\n          while 출력행 < 끝행 {\n            선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n          }\n          while 출력열 < 원본끝스칼라열 {\n            선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n          }\n        } else if 출력행 == 끝행 && 출력열 < 원본끝스칼라열 {\n          while 출력열 < 원본끝스칼라열 {\n            선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n          }\n        }\n      }\n    } else {\n      if 출력행 < 시작행 {\n        while 출력행 < 시작행 {\n          선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n        }\n        while 출력열 < 원본시작스칼라열 {\n          선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n        }\n      } else if 출력행 == 시작행 && 출력열 < 원본시작스칼라열 {\n        while 출력열 < 원본시작스칼라열 {\n          선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n        }\n      } else if 출력행 == 시작행 && 구분필요 {\n        선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n      }\n      선형원본추가(원본, 토큰)\n      let 출력위치 = 본문위치전진(19, 출력행, 출력열, 토큰)\n      출력행 = 출력위치[0]\n      출력열 = 출력위치[1]\n    }\n    if 뒤세미콜론수 > 0 {\n      if 스칼라있음(노드, \"trailingSemicolonStartRow\") &&\n        스칼라있음(노드, \"trailingSemicolonStartColumn\") {\n        let 세미콜론행 = 알정수스칼라검사(노드, \"trailingSemicolonStartRow\")?\n        let 세미콜론열 = 알정수스칼라검사(노드, \"trailingSemicolonStartColumn\")?\n        if 출력행 < 세미콜론행 {\n          while 출력행 < 세미콜론행 {\n            선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n          }\n          while 출력열 < 세미콜론열 {\n            선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n          }\n        } else if 출력행 == 세미콜론행 && 출력열 < 세미콜론열 {\n          while 출력열 < 세미콜론열 {\n            선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n          }\n        }\n      }\n      let mut 세미콜론 = 0\n      while 세미콜론 < 뒤세미콜론수 {\n        선형원본추가(원본, \";\"); 출력열 = 출력열 + 1; 세미콜론 = 세미콜론 + 1\n      }\n    }\n    이전끝행 = 끝행\n    이전끝열 = 끝열\n    이전끝스칼라열 = 원본끝스칼라열\n    이전있음 = true\n    토큰색인 = 토큰색인 + 1\n  }\n  선형원본끝공백제거(원본)\n  선형원본추가(원본, \"\\n\")\n  Ok(선형원본평평하게(원본))\n}\n",
      "sourceSha256": "33a8d59a867cc189934fce9e4e258574b0778ccad23484365cc074eefe1f1825"
    },
    {
      "path": "topaz/src/printers/rescript.tpz",
      "language": "topaz",
      "bytes": 10221,
      "sha256": "4d8769b40080a2015614da5f7d8a0032b1a00af971e09e5fed82b63cf7639cb6",
      "content": "// ReScript structure validation and canonical source printing.\n\nimport names { 익명할당계획이름들 }\nimport nodes { 노드종류 }\nimport printer_cursor { 러스트열폭, 본문위치전진 }\nimport printer_setup { 인쇄상태만들기, 인쇄상태익명이름들바꾸기 }\nimport printer_state { 식별자이름 }\nimport printer_text { 선형원본끝공백제거, 선형원본만들기, 선형원본추가, 선형원본평평하게 }\nimport structure { 구조노드, 구조스칼라, 구조입력, 구조입력검사, 노드스칼라, 스칼라문자, 스칼라있음 }\n\nfunction 리스크립트정수스칼라검사(노드: 구조노드, 필드: string) -> Result<int, string> {\n  let 값 = 노드스칼라(노드, 필드)\n  if 값.필드 == \"\" || 값.태그 != 3 || 값.정수값 < 0 {\n    return Err(\"ReScript 구조 정수 스칼라가 정규형이 아닙니다: {필드}\")\n  }\n  Ok(값.정수값)\n}\n\nexport function 리스크립트인쇄구조검사(구조: 구조입력) -> Result<bool, string> {\n  구조입력검사(23, 구조)?\n  if 구조.노드들.length == 0 {\n    return Err(\"ReScript 인쇄 구조에 source_file 노드가 필요합니다\")\n  }\n  if 구조.노드들[0].코드워드 != 0 ||\n    구조.노드들[0].부모순번 != -1 || 구조.노드들[0].자식필드있음 ||\n    구조.노드들[0].자식필드 != \"\" || 구조.노드들[0].자식색인 != -1 {\n    return Err(\"ReScript 인쇄 구조 뿌리가 source_file 노드가 아닙니다\")\n  }\n  let mut 자식수들: Array<int> = []\n  let mut 순번 = 0\n  while 순번 < 구조.노드들.length { 자식수들.push(0); 순번 = 순번 + 1 }\n  let mut 분리본문발생수 = 0\n  let mut 다음식별자류번호 = 0\n  순번 = 0\n  while 순번 < 구조.노드들.length {\n    let 노드 = 구조.노드들[순번]\n    if 노드종류(23, 노드.코드워드) == 0 {\n      return Err(\"ReScript 투영 인쇄기가 지원하지 않는 노드입니다: 순번 {순번}, 코드 {노드.코드워드}\")\n    }\n    if 순번 > 0 {\n      if 노드.부모순번 < 0 || 노드.부모순번 >= 순번 ||\n        !노드.자식필드있음 || 노드.자식필드 != \"children\" || 노드.자식색인 < 0 {\n        return Err(\"ReScript 인쇄 구조의 부모 또는 자식 위치가 정규형이 아닙니다: 순번 {순번}\")\n      }\n      자식수들[노드.부모순번] = 자식수들[노드.부모순번] + 1\n    }\n    if 노드.시작 < 0 || 노드.끝 < 노드.시작 {\n      return Err(\"ReScript 인쇄 구조의 원본 범위가 틀립니다: 순번 {순번}\")\n    }\n    let 자식수 = 리스크립트정수스칼라검사(노드, \"childCount\")?\n    let 시작행 = 리스크립트정수스칼라검사(노드, \"startRow\")?\n    let 시작열 = 리스크립트정수스칼라검사(노드, \"startColumn\")?\n    let 끝행 = 리스크립트정수스칼라검사(노드, \"endRow\")?\n    let 끝열 = 리스크립트정수스칼라검사(노드, \"endColumn\")?\n    if 끝행 < 시작행 || (끝행 == 시작행 && 끝열 < 시작열) {\n      return Err(\"ReScript 인쇄 구조의 원본 좌표가 틀립니다: 순번 {순번}\")\n    }\n    if !스칼라있음(노드, \"named\") || !스칼라있음(노드, \"extra\") {\n      return Err(\"ReScript 인쇄 구조의 노드 표지 스칼라가 없습니다: 순번 {순번}\")\n    }\n    if 노드.코드워드 == 8 && 자식수 == 0 {\n      if 노드.식별자있음 {\n        if 스칼라있음(노드, \"text\") {\n          return Err(\"ReScript 식별자 이름이 이미지와 분리 본문에 함께 있습니다\")\n        }\n        if 노드.식별자류번호 < 0 || 노드.식별자류번호 > 다음식별자류번호 {\n          return Err(\"ReScript 식별자 알파류가 첫 사용 정규형이 아닙니다: 순번 {순번}\")\n        }\n        if 노드.식별자류번호 == 다음식별자류번호 {\n          다음식별자류번호 = 다음식별자류번호 + 1\n        }\n        분리본문발생수 = 분리본문발생수 + 1\n      } else if 노드.식별자류번호 != 0 || !스칼라있음(노드, \"text\") ||\n        노드스칼라(노드, \"text\").태그 != 5 {\n        return Err(\"ReScript 이미지 식별자 이름이 정규형이 아닙니다: 순번 {순번}\")\n      }\n    } else {\n      if 노드.식별자있음 || 노드.식별자류번호 != 0 {\n        return Err(\"ReScript 식별자가 아닌 노드에 알파류가 있습니다: 순번 {순번}\")\n      }\n      if 노드.코드워드 == 6 {\n        if 자식수 != 0 || 스칼라있음(노드, \"text\") {\n          return Err(\"ReScript 댓글 원문은 분리 본문에만 있어야 합니다: 순번 {순번}\")\n        }\n        분리본문발생수 = 분리본문발생수 + 1\n      } else if 자식수 == 0 {\n        if 순번 != 0 && (!스칼라있음(노드, \"text\") || 노드스칼라(노드, \"text\").태그 != 5) {\n          return Err(\"ReScript 인쇄 토큰의 원문이 없습니다: 순번 {순번}\")\n        }\n      } else if 스칼라있음(노드, \"text\") {\n        return Err(\"ReScript 가지 노드에 토큰 원문이 있습니다: 순번 {순번}\")\n      }\n    }\n    순번 = 순번 + 1\n  }\n  순번 = 0\n  while 순번 < 구조.노드들.length {\n    if 리스크립트정수스칼라검사(구조.노드들[순번], \"childCount\")? != 자식수들[순번] {\n      return Err(\"ReScript 노드 자식 수가 구조와 다릅니다: 순번 {순번}\")\n    }\n    순번 = 순번 + 1\n  }\n  if 구조.분리본문값수 < 0 || 구조.분리본문값수 != 분리본문발생수 {\n    return Err(\"ReScript 분리 본문 값 수가 식별자와 댓글 발생 수에 맞지 않습니다\")\n  }\n  Ok(true)\n}\n\nfunction 리스크립트잎앞섬(구조: 구조입력, 왼쪽: int, 오른쪽: int) -> bool {\n  let 왼쪽노드 = 구조.노드들[왼쪽]\n  let 오른쪽노드 = 구조.노드들[오른쪽]\n  if 왼쪽노드.시작 != 오른쪽노드.시작 {\n    return 왼쪽노드.시작 < 오른쪽노드.시작\n  }\n  if 왼쪽노드.끝 != 오른쪽노드.끝 {\n    return 왼쪽노드.끝 < 오른쪽노드.끝\n  }\n  왼쪽 < 오른쪽\n}\n\nfunction 리스크립트잎순번들(구조: 구조입력) -> Result<Array<int>, string> {\n  let mut 잎들: Array<int> = []\n  // source_file is the unit and never a printable token, including when an\n  // empty or whitespace-only unit makes it the only childless node.\n  let mut 순번 = 1\n  while 순번 < 구조.노드들.length {\n    if 리스크립트정수스칼라검사(구조.노드들[순번], \"childCount\")? == 0 {\n      잎들.push(순번)\n    }\n    순번 = 순번 + 1\n  }\n  let mut 색인 = 1\n  while 색인 < 잎들.length {\n    let 값 = 잎들[색인]\n    let mut 자리 = 색인\n    while 자리 > 0 && 리스크립트잎앞섬(구조, 값, 잎들[자리 - 1]) {\n      잎들[자리] = 잎들[자리 - 1]\n      자리 = 자리 - 1\n    }\n    잎들[자리] = 값\n    색인 = 색인 + 1\n  }\n  Ok(잎들)\n}\n\nexport function 리스크립트원본인쇄(구조: 구조입력) -> Result<string, string> {\n  리스크립트인쇄구조검사(구조)?\n  let 기본준비 = 인쇄상태만들기(23, 구조, [], [], false, false)\n  let 준비 = 인쇄상태익명이름들바꾸기(기본준비, 익명할당계획이름들(기본준비)?)\n  let 잎들 = 리스크립트잎순번들(구조)?\n  let 원본 = 선형원본만들기()\n  let mut 출력행 = 0\n  let mut 출력열 = 0\n  let mut 이전끝행 = 0\n  let mut 이전끝열 = 0\n  let mut 이전끝스칼라열 = 0\n  let mut 이전있음 = false\n  let mut 토큰색인 = 0\n  while 토큰색인 < 잎들.length {\n    let 순번 = 잎들[토큰색인]\n    let 노드 = 구조.노드들[순번]\n    let 시작행 = 리스크립트정수스칼라검사(노드, \"startRow\")?\n    let 시작열 = 리스크립트정수스칼라검사(노드, \"startColumn\")?\n    let 끝행 = 리스크립트정수스칼라검사(노드, \"endRow\")?\n    let 끝열 = 리스크립트정수스칼라검사(노드, \"endColumn\")?\n    let 대체폭 = if 시작행 == 끝행 { 끝열 - 시작열 } else { 끝열 }\n    let 식별자노드 = 노드.코드워드 == 8\n    let 분리식별자 = 식별자노드 && 노드.식별자있음\n    let 생략댓글 = 노드.코드워드 == 6 && !스칼라있음(노드, \"text\")\n    if 생략댓글 {\n      토큰색인 = 토큰색인 + 1\n      continue\n    }\n    let 토큰 = if 식별자노드 {\n      식별자이름(준비, 순번)?\n    } else { 스칼라문자(노드, \"text\") }\n    let 원본스칼라폭 = if 분리식별자 {\n      러스트열폭(노드, \"identifier\", \"Scalar\", 대체폭)\n    } else {\n      본문위치전진(23, 0, 0, 토큰)[1]\n    }\n    let 같은원본행 = 이전있음 && 시작행 == 이전끝행\n    let 원본간격 = if 같은원본행 { 시작열 - 이전끝열 } else { 0 }\n    let 원본시작스칼라열 = if 같은원본행 {\n      if 원본간격 == 0 { 출력열 } else { 이전끝스칼라열 + 원본간격 }\n    } else { 시작열 }\n    let 원본끝스칼라열 = if 끝행 == 시작행 {\n      원본시작스칼라열 + 원본스칼라폭\n    } else { 원본스칼라폭 }\n    let 구분필요 = 이전있음 && 시작행 == 이전끝행 && 시작열 > 이전끝열\n    if 출력행 < 시작행 {\n      while 출력행 < 시작행 {\n        선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n      }\n      while 출력열 < 원본시작스칼라열 {\n        선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n      }\n    } else if 출력행 == 시작행 && 출력열 < 원본시작스칼라열 {\n      while 출력열 < 원본시작스칼라열 {\n        선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n      }\n    } else if 출력행 == 시작행 && 구분필요 {\n      선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n    }\n    선형원본추가(원본, 토큰)\n    let 출력위치 = 본문위치전진(23, 출력행, 출력열, 토큰)\n    출력행 = 출력위치[0]\n    출력열 = 출력위치[1]\n    이전끝행 = 끝행\n    이전끝열 = 끝열\n    이전끝스칼라열 = 원본끝스칼라열\n    이전있음 = true\n    토큰색인 = 토큰색인 + 1\n  }\n  선형원본끝공백제거(원본)\n  선형원본추가(원본, \"\\n\")\n  Ok(선형원본평평하게(원본))\n}\n",
      "sourceSha256": "4d8769b40080a2015614da5f7d8a0032b1a00af971e09e5fed82b63cf7639cb6"
    },
    {
      "path": "topaz/src/printers/ruby.tpz",
      "language": "topaz",
      "bytes": 11843,
      "sha256": "45c9c7dad643fa2157b0d980531024b5cceacb738a7d95f0ba37504cc541f9e0",
      "content": "// Ruby structure validation and canonical source printing.\n\nimport nodes { 노드종류 }\nimport printer_cursor { 러스트열폭, 본문위치전진 }\nimport printer_setup { 인쇄상태만들기 }\nimport printer_state { 식별자이름 }\nimport printer_text { 선형원본끝공백제거, 선형원본만들기, 선형원본추가, 선형원본평평하게 }\nimport schema { 루비댓글코드 }\nimport structure { 구조노드, 구조스칼라, 구조입력, 구조입력검사, 노드스칼라, 스칼라문자, 스칼라있음 }\n\nfunction 루비정수스칼라검사(노드: 구조노드, 필드: string) -> Result<int, string> {\n  let 값 = 노드스칼라(노드, 필드)\n  if 값.필드 == \"\" || 값.태그 != 3 || 값.정수값 < 0 {\n    return Err(\"루비 구조 정수 스칼라가 정규형이 아닙니다: {필드}\")\n  }\n  Ok(값.정수값)\n}\n\nexport function 루비인쇄구조검사(구조: 구조입력) -> Result<bool, string> {\n  구조입력검사(10, 구조)?\n  if 구조.노드들.length == 0 {\n    return Err(\"루비 인쇄 구조에 프로그램 노드가 필요합니다\")\n  }\n  if 구조.노드들[0].코드워드 != 184 ||\n    구조.노드들[0].부모순번 != -1 || 구조.노드들[0].자식필드있음 ||\n    구조.노드들[0].자식필드 != \"\" || 구조.노드들[0].자식색인 != -1 {\n    return Err(\"루비 인쇄 구조 뿌리가 프로그램 노드가 아닙니다\")\n  }\n  let mut 자식수들: Array<int> = []\n  let mut 순번 = 0\n  while 순번 < 구조.노드들.length { 자식수들.push(0); 순번 = 순번 + 1 }\n  let mut 분리본문발생수 = 0\n  let mut 다음식별자류번호 = 0\n  순번 = 0\n  while 순번 < 구조.노드들.length {\n    let 노드 = 구조.노드들[순번]\n    let 종류 = 노드종류(10, 노드.코드워드)\n    if 종류 == 0 {\n      return Err(\"루비 투영 인쇄기가 지원하지 않는 노드입니다: 순번 {순번}, 코드 {노드.코드워드}\")\n    }\n    if 순번 > 0 {\n      if 노드.부모순번 < 0 || 노드.부모순번 >= 순번 ||\n        !노드.자식필드있음 || 노드.자식필드 == \"\" || 노드.자식색인 < 0 {\n        return Err(\"루비 인쇄 구조의 부모 또는 자식 위치가 정규형이 아닙니다: 순번 {순번}\")\n      }\n      자식수들[노드.부모순번] = 자식수들[노드.부모순번] + 1\n    }\n    if 노드.시작 < 0 || 노드.끝 < 노드.시작 {\n      return Err(\"루비 인쇄 구조의 원본 범위가 틀립니다: 순번 {순번}\")\n    }\n    let 자식수 = 루비정수스칼라검사(노드, \"childCount\")?\n    let 시작행 = 루비정수스칼라검사(노드, \"startRow\")?\n    let 시작열 = 루비정수스칼라검사(노드, \"startColumn\")?\n    let 끝행 = 루비정수스칼라검사(노드, \"endRow\")?\n    let 끝열 = 루비정수스칼라검사(노드, \"endColumn\")?\n    if 끝행 < 시작행 || (끝행 == 시작행 && 끝열 < 시작열) {\n      return Err(\"루비 인쇄 구조의 원본 좌표가 틀립니다: 순번 {순번}\")\n    }\n    if !스칼라있음(노드, \"named\") || !스칼라있음(노드, \"extra\") {\n      return Err(\"루비 인쇄 구조의 노드 표지 스칼라가 없습니다: 순번 {순번}\")\n    }\n    if 종류 == 106 {\n      if 노드.식별자있음 {\n        if 스칼라있음(노드, \"text\") {\n          return Err(\"루비 식별자 이름이 이미지와 분리 본문에 함께 있습니다\")\n        }\n        if 노드.식별자류번호 < 0 || 노드.식별자류번호 > 다음식별자류번호 {\n          return Err(\"루비 식별자 알파류가 첫 사용 정규형이 아닙니다: 순번 {순번}\")\n        }\n        if 노드.식별자류번호 == 다음식별자류번호 {\n          다음식별자류번호 = 다음식별자류번호 + 1\n        }\n        분리본문발생수 = 분리본문발생수 + 1\n      } else if 노드.식별자류번호 != 0 || !스칼라있음(노드, \"text\") ||\n        노드스칼라(노드, \"text\").태그 != 5 {\n        return Err(\"루비 이미지 식별자 이름이 정규형이 아닙니다: 순번 {순번}\")\n      }\n    } else {\n      if 노드.식별자있음 || 노드.식별자류번호 != 0 {\n        return Err(\"루비 식별자가 아닌 노드에 알파류가 있습니다: 순번 {순번}\")\n      }\n      if 루비댓글코드(노드.코드워드) {\n        if 스칼라있음(노드, \"text\") {\n          return Err(\"루비 댓글 원문은 분리 본문에만 있어야 합니다: 순번 {순번}\")\n        }\n        분리본문발생수 = 분리본문발생수 + 1\n      } else if 자식수 == 0 {\n        if !스칼라있음(노드, \"text\") || 노드스칼라(노드, \"text\").태그 != 5 {\n          return Err(\"루비 인쇄 토큰의 원문이 없습니다: 순번 {순번}\")\n        }\n      } else if 스칼라있음(노드, \"text\") {\n        return Err(\"루비 가지 노드에 토큰 원문이 있습니다: 순번 {순번}\")\n      }\n    }\n    순번 = 순번 + 1\n  }\n  순번 = 0\n  while 순번 < 구조.노드들.length {\n    if 루비정수스칼라검사(구조.노드들[순번], \"childCount\")? != 자식수들[순번] {\n      return Err(\"루비 노드 자식 수가 구조와 다릅니다: 순번 {순번}\")\n    }\n    순번 = 순번 + 1\n  }\n  if 구조.분리본문값수 < 0 || 구조.분리본문값수 != 분리본문발생수 {\n    return Err(\"루비 분리 본문 값 수가 식별자와 댓글 발생 수에 맞지 않습니다\")\n  }\n  Ok(true)\n}\n\nfunction 루비잎앞섬(구조: 구조입력, 왼쪽: int, 오른쪽: int) -> bool {\n  let 왼쪽노드 = 구조.노드들[왼쪽]\n  let 오른쪽노드 = 구조.노드들[오른쪽]\n  if 왼쪽노드.시작 != 오른쪽노드.시작 {\n    return 왼쪽노드.시작 < 오른쪽노드.시작\n  }\n  if 왼쪽노드.끝 != 오른쪽노드.끝 {\n    return 왼쪽노드.끝 < 오른쪽노드.끝\n  }\n  왼쪽 < 오른쪽\n}\n\nfunction 루비잎순번들(구조: 구조입력) -> Result<Array<int>, string> {\n  let mut 잎들: Array<int> = []\n  let mut 순번 = 0\n  while 순번 < 구조.노드들.length {\n    if 루비정수스칼라검사(구조.노드들[순번], \"childCount\")? == 0 {\n      잎들.push(순번)\n    }\n    순번 = 순번 + 1\n  }\n  let mut 색인 = 1\n  while 색인 < 잎들.length {\n    let 값 = 잎들[색인]\n    let mut 자리 = 색인\n    while 자리 > 0 && 루비잎앞섬(구조, 값, 잎들[자리 - 1]) {\n      잎들[자리] = 잎들[자리 - 1]\n      자리 = 자리 - 1\n    }\n    잎들[자리] = 값\n    색인 = 색인 + 1\n  }\n  Ok(잎들)\n}\n\nexport function 루비원본인쇄(구조: 구조입력) -> Result<string, string> {\n  루비인쇄구조검사(구조)?\n  let 준비 = 인쇄상태만들기(10, 구조, [], [], false, false)\n  let 잎들 = 루비잎순번들(구조)?\n  let 원본 = 선형원본만들기()\n  let mut 출력행 = 0\n  let mut 출력열 = 0\n  let mut 이전끝행 = 0\n  let mut 이전끝열 = 0\n  let mut 이전끝스칼라열 = 0\n  let mut 이전있음 = false\n  let mut 토큰색인 = 0\n  while 토큰색인 < 잎들.length {\n    let 순번 = 잎들[토큰색인]\n    let 노드 = 구조.노드들[순번]\n    let 시작행 = 루비정수스칼라검사(노드, \"startRow\")?\n    let 시작열 = 루비정수스칼라검사(노드, \"startColumn\")?\n    let 끝행 = 루비정수스칼라검사(노드, \"endRow\")?\n    let 끝열 = 루비정수스칼라검사(노드, \"endColumn\")?\n    let 대체폭 = if 시작행 == 끝행 { 끝열 - 시작열 } else { 끝열 }\n    let 식별자노드 = 노드종류(10, 노드.코드워드) == 106\n    let 분리식별자 = 식별자노드 && 노드.식별자있음\n    let 생략댓글 = 루비댓글코드(노드.코드워드) && !스칼라있음(노드, \"text\")\n    let 토큰 = if 생략댓글 { \"\" } else if 식별자노드 {\n      식별자이름(준비, 순번)?\n    } else { 스칼라문자(노드, \"text\") }\n    let 원본스칼라폭 = if 분리식별자 {\n      러스트열폭(노드, \"identifier\", \"Scalar\", 대체폭)\n    } else if 생략댓글 {\n      러스트열폭(노드, \"comment\", \"Scalar\", 대체폭)\n    } else {\n      본문위치전진(10, 0, 0, 토큰)[1]\n    }\n    let 원본시작스칼라열 = if 이전있음 && 시작행 == 이전끝행 {\n      이전끝스칼라열 + 시작열 - 이전끝열\n    } else { 시작열 }\n    let 원본끝스칼라열 = if 끝행 == 시작행 {\n      원본시작스칼라열 + 원본스칼라폭\n    } else { 원본스칼라폭 }\n    let 구분필요 = 이전있음 && 시작행 == 이전끝행 && 시작열 > 이전끝열\n    if 생략댓글 {\n      let 다음시작행 = if 토큰색인 + 1 < 잎들.length {\n        루비정수스칼라검사(구조.노드들[잎들[토큰색인 + 1]], \"startRow\")?\n      } else { -1 }\n      let 온줄차지 = (!이전있음 || 시작행 > 이전끝행) &&\n        (다음시작행 < 0 || 다음시작행 > 끝행)\n      let 줄끝댓글 = 이전있음 && 시작행 == 이전끝행 &&\n        (다음시작행 < 0 || 다음시작행 > 끝행)\n      if 온줄차지 {\n        while 출력행 < 시작행 {\n          선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n        }\n        while 출력행 < 끝행 {\n          선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n        }\n      } else if 줄끝댓글 {\n        이전끝행 = 끝행\n        이전끝열 = 끝열\n        이전끝스칼라열 = 원본끝스칼라열\n        이전있음 = true\n        토큰색인 = 토큰색인 + 1\n        continue\n      } else {\n        if 출력행 < 시작행 {\n          while 출력행 < 시작행 {\n            선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n          }\n          while 출력열 < 원본시작스칼라열 {\n            선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n          }\n        } else if 출력행 == 시작행 && 출력열 < 원본시작스칼라열 {\n          while 출력열 < 원본시작스칼라열 {\n            선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n          }\n        } else if 출력행 == 시작행 && 구분필요 {\n          선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n        }\n        if 출력행 < 끝행 {\n          while 출력행 < 끝행 {\n            선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n          }\n          while 출력열 < 원본끝스칼라열 {\n            선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n          }\n        } else if 출력행 == 끝행 && 출력열 < 원본끝스칼라열 {\n          while 출력열 < 원본끝스칼라열 {\n            선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n          }\n        }\n      }\n    } else {\n      if 출력행 < 시작행 {\n        while 출력행 < 시작행 {\n          선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n        }\n        while 출력열 < 원본시작스칼라열 {\n          선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n        }\n      } else if 출력행 == 시작행 && 출력열 < 원본시작스칼라열 {\n        while 출력열 < 원본시작스칼라열 {\n          선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n        }\n      } else if 출력행 == 시작행 && 구분필요 {\n        선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n      }\n      선형원본추가(원본, 토큰)\n      let 출력위치 = 본문위치전진(10, 출력행, 출력열, 토큰)\n      출력행 = 출력위치[0]\n      출력열 = 출력위치[1]\n    }\n    이전끝행 = 끝행\n    이전끝열 = 끝열\n    이전끝스칼라열 = 원본끝스칼라열\n    이전있음 = true\n    토큰색인 = 토큰색인 + 1\n  }\n  선형원본끝공백제거(원본)\n  선형원본추가(원본, \"\\n\")\n  Ok(선형원본평평하게(원본))\n}\n",
      "sourceSha256": "45c9c7dad643fa2157b0d980531024b5cceacb738a7d95f0ba37504cc541f9e0"
    },
    {
      "path": "topaz/src/printers/rust.tpz",
      "language": "topaz",
      "bytes": 16997,
      "sha256": "e906cc4717e5b155eaca6fce141861de5562faa266e135fae7bce73766f5bedc",
      "content": "// Rust structure validation and canonical source printing.\n\nimport nodes { 노드종류 }\nimport printer_cursor { 러스트문자열반복, 러스트열폭, 러스트행들여쓰기, 본문위치전진 }\nimport printer_setup { 인쇄상태만들기 }\nimport printer_state { 식별자이름 }\nimport printer_text { 선형원본끝공백제거, 선형원본만들기, 선형원본추가, 선형원본평평하게 }\nimport schema { 러스트댓글코드, 러스트원자본문코드 }\nimport structure { 구조노드, 구조스칼라, 구조입력, 구조입력검사, 노드스칼라, 스칼라문자, 스칼라있음 }\nimport util { 작은값, 큰값 }\n\nfunction 러스트정수스칼라검사(노드: 구조노드, 필드: string) -> Result<int, string> {\n  let 값 = 노드스칼라(노드, 필드)\n  if 값.필드 == \"\" || 값.태그 != 3 || 값.정수값 < 0 {\n    return Err(\"러스트 구조 정수 스칼라가 정규형이 아닙니다: {필드}\")\n  }\n  Ok(값.정수값)\n}\n\nexport function 러스트인쇄구조검사(구조: 구조입력) -> Result<bool, string> {\n  구조입력검사(5, 구조)?\n  if 구조.노드들.length == 0 {\n    return Err(\"러스트 인쇄 구조에 원본 파일 노드가 필요합니다\")\n  }\n  if 구조.노드들[0].코드워드 != 297 ||\n    구조.노드들[0].부모순번 != -1 || 구조.노드들[0].자식필드있음 ||\n    구조.노드들[0].자식필드 != \"\" || 구조.노드들[0].자식색인 != -1 {\n    return Err(\"러스트 인쇄 구조 뿌리가 원본 파일 노드가 아닙니다\")\n  }\n  let mut 자식수들: Array<int> = []\n  let mut 순번 = 0\n  while 순번 < 구조.노드들.length { 자식수들.push(0); 순번 = 순번 + 1 }\n  let mut 다음식별자류번호 = 0\n  let mut 분리본문발생수 = 0\n  순번 = 0\n  while 순번 < 구조.노드들.length {\n    let 노드 = 구조.노드들[순번]\n    let 종류 = 노드종류(5, 노드.코드워드)\n    if 종류 == 0 {\n      return Err(\"러스트 투영 인쇄기가 지원하지 않는 노드입니다: 순번 {순번}, 코드 {노드.코드워드}\")\n    }\n    if 순번 > 0 {\n      if 노드.부모순번 < 0 || 노드.부모순번 >= 순번 ||\n        !노드.자식필드있음 || 노드.자식필드 == \"\" || 노드.자식색인 < 0 {\n        return Err(\"러스트 인쇄 구조의 부모 또는 자식 위치가 정규형이 아닙니다: 순번 {순번}\")\n      }\n      자식수들[노드.부모순번] = 자식수들[노드.부모순번] + 1\n    }\n    if 노드.시작 < 0 || 노드.끝 < 노드.시작 {\n      return Err(\"러스트 인쇄 구조의 원본 범위가 틀립니다: 순번 {순번}\")\n    }\n    let 자식수 = 러스트정수스칼라검사(노드, \"childCount\")?\n    let 시작행 = 러스트정수스칼라검사(노드, \"startRow\")?\n    let 시작열 = 러스트정수스칼라검사(노드, \"startColumn\")?\n    let 끝행 = 러스트정수스칼라검사(노드, \"endRow\")?\n    let 끝열 = 러스트정수스칼라검사(노드, \"endColumn\")?\n    if 끝행 < 시작행 || (끝행 == 시작행 && 끝열 < 시작열) {\n      return Err(\"러스트 인쇄 구조의 원본 좌표가 틀립니다: 순번 {순번}\")\n    }\n    if !스칼라있음(노드, \"named\") || !스칼라있음(노드, \"extra\") {\n      return Err(\"러스트 인쇄 구조의 노드 표지 스칼라가 없습니다: 순번 {순번}\")\n    }\n    if 종류 == 106 {\n      if 노드.식별자있음 {\n        if 스칼라있음(노드, \"text\") {\n          return Err(\"러스트 식별자 이름이 이미지와 분리 본문에 함께 있습니다\")\n        }\n        if 노드.식별자류번호 < 0 || 노드.식별자류번호 > 다음식별자류번호 {\n          return Err(\"러스트 식별자 알파류가 첫 사용 정규형이 아닙니다: 순번 {순번}\")\n        }\n        if 노드.식별자류번호 == 다음식별자류번호 {\n          다음식별자류번호 = 다음식별자류번호 + 1\n        }\n        분리본문발생수 = 분리본문발생수 + 1\n      } else {\n        if 노드.식별자류번호 != 0 || !스칼라있음(노드, \"text\") ||\n          노드스칼라(노드, \"text\").태그 != 5 {\n          return Err(\"러스트 이미지 식별자 이름이 정규형이 아닙니다: 순번 {순번}\")\n        }\n      }\n    } else {\n      if 노드.식별자있음 || 노드.식별자류번호 != 0 {\n        return Err(\"러스트 식별자가 아닌 노드에 알파류가 있습니다: 순번 {순번}\")\n      }\n      if 러스트댓글코드(노드.코드워드) {\n        if 스칼라있음(노드, \"text\") {\n          if 노드스칼라(노드, \"text\").태그 != 5 {\n            return Err(\"러스트 문서 댓글 원문이 정규형이 아닙니다: 순번 {순번}\")\n          }\n        } else {\n          분리본문발생수 = 분리본문발생수 + 1\n        }\n      } else if 러스트원자본문코드(노드.코드워드) || 자식수 == 0 {\n        if !스칼라있음(노드, \"text\") || 노드스칼라(노드, \"text\").태그 != 5 {\n          return Err(\"러스트 인쇄 토큰의 원문이 없습니다: 순번 {순번}\")\n        }\n      } else if 노드.코드워드 == 367 && 스칼라있음(노드, \"text\") &&\n        노드스칼라(노드, \"text\").태그 != 5 {\n        return Err(\"러스트 줄임 필드 이름이 정규형이 아닙니다: 순번 {순번}\")\n      }\n    }\n    순번 = 순번 + 1\n  }\n  순번 = 0\n  while 순번 < 구조.노드들.length {\n    if 러스트정수스칼라검사(구조.노드들[순번], \"childCount\")? != 자식수들[순번] {\n      return Err(\"러스트 노드 자식 수가 구조와 다릅니다: 순번 {순번}\")\n    }\n    순번 = 순번 + 1\n  }\n  if 구조.분리본문값수 < 0 || 구조.분리본문값수 != 분리본문발생수 {\n    return Err(\"러스트 분리 본문 값 수가 식별자와 댓글 발생 수에 맞지 않습니다\")\n  }\n  Ok(true)\n}\n\nfunction 러스트원자본문조상(구조: 구조입력, 순번: int) -> bool {\n  let mut 부모순번 = 구조.노드들[순번].부모순번\n  while 부모순번 >= 0 {\n    if 러스트원자본문코드(구조.노드들[부모순번].코드워드) { return true }\n    부모순번 = 구조.노드들[부모순번].부모순번\n  }\n  false\n}\n\nfunction 러스트생략댓글자리표시(\n  행폭: int,\n  스칼라폭: int,\n  유티에프십육폭: int,\n  표시폭: int\n) -> Result<string, string> {\n  let 아스트랄수 = 유티에프십육폭 - 스칼라폭\n  let 고정스칼라수 = if 행폭 == 0 { 4 } else { 2 }\n  let 가변스칼라수 = 스칼라폭 - 고정스칼라수 - 아스트랄수\n  let 표시조정 = 표시폭 - 스칼라폭\n  if 아스트랄수 < 0 || 가변스칼라수 < 0 {\n    return Err(\"러스트 생략 댓글 열 기하를 재현할 수 없습니다\")\n  }\n\n  let 최소아스트랄조정 = 큰값(\n    -아스트랄수, 표시조정 - 3 * 가변스칼라수\n  )\n  let 최대아스트랄조정 = 작은값(\n    아스트랄수, 표시조정 + 가변스칼라수\n  )\n  let mut 아스트랄조정 = 큰값(\n    최소아스트랄조정, 작은값(0, 최대아스트랄조정)\n  )\n  let mut 비엠피조정 = 표시조정 - 아스트랄조정\n  if 비엠피조정 == 3 * 가변스칼라수 - 1 {\n    if 아스트랄조정 < 최대아스트랄조정 {\n      아스트랄조정 = 아스트랄조정 + 1\n    } else if 아스트랄조정 > 최소아스트랄조정 {\n      아스트랄조정 = 아스트랄조정 - 1\n    }\n    비엠피조정 = 표시조정 - 아스트랄조정\n  }\n  if 최소아스트랄조정 > 최대아스트랄조정 ||\n    비엠피조정 < -가변스칼라수 || 비엠피조정 > 3 * 가변스칼라수 ||\n    비엠피조정 == 3 * 가변스칼라수 - 1 {\n    return Err(\"러스트 생략 댓글 열 기하를 재현할 수 없습니다\")\n  }\n\n  let 폭없는아스트랄수 = 큰값(0, -아스트랄조정)\n  let 넓은아스트랄수 = 큰값(0, 아스트랄조정)\n  let 보통아스트랄수 = 아스트랄수 - 폭없는아스트랄수 - 넓은아스트랄수\n  let mut 탭수 = 0\n  let mut 넓은비엠피수 = 0\n  let mut 폭없는비엠피수 = 0\n  if 비엠피조정 < 0 {\n    폭없는비엠피수 = -비엠피조정\n  } else if 비엠피조정 <= 가변스칼라수 {\n    넓은비엠피수 = 비엠피조정\n  } else {\n    탭수 = 비엠피조정 / 3\n    넓은비엠피수 = 비엠피조정 - 3 * 탭수\n  }\n  let 보통비엠피수 = 가변스칼라수 - 탭수 - 넓은비엠피수 - 폭없는비엠피수\n  if 보통아스트랄수 < 0 || 보통비엠피수 < 0 {\n    return Err(\"러스트 생략 댓글 열 기하를 재현할 수 없습니다\")\n  }\n  let 꼬리 = 러스트문자열반복(\"x\", 보통비엠피수) +\n    러스트문자열반복((127462).toCodePoint() ?? \"\", 보통아스트랄수) +\n    러스트문자열반복((917760).toCodePoint() ?? \"\", 폭없는아스트랄수) +\n    러스트문자열반복(\"😀\", 넓은아스트랄수) +\n    러스트문자열반복(\"\\t\", 탭수) +\n    러스트문자열반복(\"一\", 넓은비엠피수) +\n    러스트문자열반복(\"́\", 폭없는비엠피수) + \"*/\"\n  if 행폭 == 0 {\n    Ok(\"/*\" + 꼬리)\n  } else {\n    Ok(\"/*\" + 러스트문자열반복(\"\\n\", 행폭) + 꼬리)\n  }\n}\n\nexport function 러스트원본인쇄(구조: 구조입력) -> Result<string, string> {\n  러스트인쇄구조검사(구조)?\n  let 준비 = 인쇄상태만들기(5, 구조, [], [], false, false)\n  let mut 토큰순번들: Array<int> = []\n  let mut 순번 = 0\n  while 순번 < 구조.노드들.length {\n    let 노드 = 구조.노드들[순번]\n    let 자식수 = 러스트정수스칼라검사(노드, \"childCount\")?\n    if !러스트원자본문조상(구조, 순번) &&\n      (러스트원자본문코드(노드.코드워드) || 자식수 == 0) {\n      토큰순번들.push(순번)\n    }\n    순번 = 순번 + 1\n  }\n  let 원본 = 선형원본만들기()\n  let mut 출력행 = 0\n  let mut 출력열 = 0\n  let mut 이전끝행 = 0\n  let mut 이전끝열 = 0\n  let mut 이전끝스칼라열 = 0\n  let mut 이전있음 = false\n  let mut 토큰색인 = 0\n  while 토큰색인 < 토큰순번들.length {\n    순번 = 토큰순번들[토큰색인]\n    let 노드 = 구조.노드들[순번]\n    let 시작행 = 러스트정수스칼라검사(노드, \"startRow\")?\n    let 시작열 = 러스트정수스칼라검사(노드, \"startColumn\")?\n    let 끝행 = 러스트정수스칼라검사(노드, \"endRow\")?\n    let 끝열 = 러스트정수스칼라검사(노드, \"endColumn\")?\n    let 대체폭 = if 시작행 == 끝행 { 끝열 - 시작열 } else { 끝열 }\n    let 분리식별자 = 노드종류(5, 노드.코드워드) == 106 && 노드.식별자있음\n    let 생략댓글 = 러스트댓글코드(노드.코드워드) && !스칼라있음(노드, \"text\")\n    let 토큰 = if 생략댓글 { \"\" } else if 노드종류(5, 노드.코드워드) == 106 {\n      let 이름 = 식별자이름(준비, 순번)?\n      if 노드.식별자있음 && 노드.부모순번 >= 0 {\n        let 부모 = 구조.노드들[노드.부모순번]\n        if 부모.코드워드 == 367 && 스칼라있음(부모, \"text\") {\n          스칼라문자(부모, \"text\") + \": \" + 이름\n        } else { 이름 }\n      } else { 이름 }\n    } else { 스칼라문자(노드, \"text\") }\n    let 원본스칼라폭 = if 분리식별자 {\n      러스트열폭(노드, \"identifier\", \"Scalar\", 대체폭)\n    } else if 생략댓글 {\n      러스트열폭(노드, \"comment\", \"Scalar\", 대체폭)\n    } else {\n      본문위치전진(5, 0, 0, 토큰)[1]\n    }\n    let 원본시작스칼라열 = if 이전있음 && 시작행 == 이전끝행 {\n      이전끝스칼라열 + 시작열 - 이전끝열\n    } else { 시작열 }\n    let 원본끝스칼라열 = if 끝행 == 시작행 {\n      원본시작스칼라열 + 원본스칼라폭\n    } else { 원본스칼라폭 }\n    let 구분필요 = 이전있음 && 시작행 == 이전끝행 && 시작열 > 이전끝열\n    if 러스트댓글코드(노드.코드워드) && !스칼라있음(노드, \"text\") {\n      let 다음시작행 = if 토큰색인 + 1 < 토큰순번들.length {\n        러스트정수스칼라검사(\n          구조.노드들[토큰순번들[토큰색인 + 1]],\n          \"startRow\"\n        )?\n      } else { -1 }\n      let 온줄차지 = (!이전있음 || 시작행 > 이전끝행) &&\n        (다음시작행 < 0 || 다음시작행 > 끝행)\n      let 줄끝댓글 = 이전있음 && 시작행 == 이전끝행 &&\n        (다음시작행 < 0 || 다음시작행 > 끝행)\n      let 댓글스칼라폭 = 러스트열폭(노드, \"comment\", \"Scalar\", 대체폭)\n      let 댓글유티에프십육폭 = 러스트열폭(\n        노드, \"comment\", \"Utf16\", 댓글스칼라폭\n      )\n      let 댓글표시폭 = 러스트열폭(노드, \"comment\", \"Display\", 댓글스칼라폭)\n      let 자리표시필요 = 노드.코드워드 == 406 &&\n        (댓글유티에프십육폭 != 댓글스칼라폭 || 댓글표시폭 != 댓글스칼라폭) &&\n        다음시작행 == 끝행\n      if 온줄차지 {\n        while 출력행 < 시작행 {\n          선형원본추가(원본, \"\\n\")\n          출력행 = 출력행 + 1\n          출력열 = 0\n        }\n        while 출력행 < 끝행 {\n          선형원본추가(원본, \"\\n\")\n          출력행 = 출력행 + 1\n          출력열 = 0\n        }\n      } else if 줄끝댓글 {\n        이전끝행 = 끝행\n        이전끝열 = 끝열\n        이전끝스칼라열 = 원본끝스칼라열\n        이전있음 = true\n        토큰색인 = 토큰색인 + 1\n        continue\n      } else if 끝행 > 시작행 && !자리표시필요 {\n        while 출력행 < 끝행 {\n          선형원본추가(원본, \"\\n\")\n          출력행 = 출력행 + 1\n          출력열 = 0\n        }\n        let mut 공백수 = 0\n        while 공백수 < 댓글스칼라폭 {\n          선형원본추가(원본, \" \")\n          출력열 = 출력열 + 1\n          공백수 = 공백수 + 1\n        }\n      } else {\n        if 출력행 < 시작행 {\n          while 출력행 < 시작행 {\n            선형원본추가(원본, \"\\n\")\n            출력행 = 출력행 + 1\n            출력열 = 0\n          }\n          선형원본추가(원본, 러스트행들여쓰기(노드, 원본시작스칼라열))\n          출력열 = 원본시작스칼라열\n        } else if 출력행 == 시작행 && 출력열 < 원본시작스칼라열 {\n          while 출력열 < 원본시작스칼라열 {\n            선형원본추가(원본, \" \")\n            출력열 = 출력열 + 1\n          }\n        } else if 출력행 == 시작행 && 구분필요 {\n          선형원본추가(원본, \" \")\n          출력열 = 출력열 + 1\n        }\n        if 자리표시필요 {\n          let 자리표시 = 러스트생략댓글자리표시(\n            끝행 - 시작행, 댓글스칼라폭, 댓글유티에프십육폭, 댓글표시폭\n          )?\n          선형원본추가(원본, 자리표시)\n          let 출력위치 = 본문위치전진(5, 출력행, 출력열, 자리표시)\n          출력행 = 출력위치[0]\n          출력열 = 출력위치[1]\n        } else if 출력행 < 끝행 {\n          while 출력행 < 끝행 {\n            선형원본추가(원본, \"\\n\")\n            출력행 = 출력행 + 1\n            출력열 = 0\n          }\n          let mut 공백수 = 0\n          while 공백수 < 댓글스칼라폭 {\n            선형원본추가(원본, \" \")\n            출력열 = 출력열 + 1\n            공백수 = 공백수 + 1\n          }\n        } else if 출력행 == 끝행 && 출력열 < 원본끝스칼라열 {\n          let mut 공백수 = 0\n          while 공백수 < 댓글스칼라폭 {\n            선형원본추가(원본, \" \")\n            출력열 = 출력열 + 1\n            공백수 = 공백수 + 1\n          }\n        }\n      }\n    } else {\n      if 출력행 < 시작행 {\n        while 출력행 < 시작행 {\n          선형원본추가(원본, \"\\n\")\n          출력행 = 출력행 + 1\n          출력열 = 0\n        }\n        선형원본추가(원본, 러스트행들여쓰기(노드, 원본시작스칼라열))\n        출력열 = 원본시작스칼라열\n      } else if 출력행 == 시작행 && 출력열 < 원본시작스칼라열 {\n        while 출력열 < 원본시작스칼라열 {\n          선형원본추가(원본, \" \")\n          출력열 = 출력열 + 1\n        }\n      } else if 출력행 == 시작행 && 구분필요 {\n        선형원본추가(원본, \" \")\n        출력열 = 출력열 + 1\n      }\n      선형원본추가(원본, 토큰)\n      let 출력위치 = 본문위치전진(5, 출력행, 출력열, 토큰)\n      출력행 = 출력위치[0]\n      출력열 = 출력위치[1]\n    }\n    이전끝행 = 끝행\n    이전끝열 = 끝열\n    이전끝스칼라열 = 원본끝스칼라열\n    이전있음 = true\n    토큰색인 = 토큰색인 + 1\n  }\n  선형원본끝공백제거(원본)\n  선형원본추가(원본, \"\\n\")\n  Ok(선형원본평평하게(원본))\n}\n",
      "sourceSha256": "e906cc4717e5b155eaca6fce141861de5562faa266e135fae7bce73766f5bedc"
    },
    {
      "path": "topaz/src/printers/scala.tpz",
      "language": "topaz",
      "bytes": 16526,
      "sha256": "d5eb5bd96230634f8215ff653045cf895a0d6740b120f783d3e20f80c7441073",
      "content": "// Scala structure validation and canonical source printing.\n\nimport names { 익명할당계획이름들 }\nimport names.scala { 스칼라감싼식별자인가, 스칼라감싼식별자자식인가 }\nimport nodes { 노드종류 }\nimport printer_common { 선행가로배치인가 }\nimport printer_cursor { 러스트열폭, 러스트행들여쓰기, 본문위치전진 }\nimport printer_setup { 인쇄상태만들기, 인쇄상태익명이름들바꾸기 }\nimport printer_state { 식별자이름 }\nimport printer_text { 선형원본만들기, 선형원본줄끝인가, 선형원본추가, 선형원본평평하게 }\nimport schema { 스칼라댓글코드, 스칼라원자본문코드 }\nimport structure { 구조노드, 구조스칼라, 구조입력, 구조입력검사, 노드스칼라, 스칼라문자, 스칼라있음 }\n\nfunction 스칼라정수스칼라검사(노드: 구조노드, 필드: string) -> Result<int, string> {\n  let 값 = 노드스칼라(노드, 필드)\n  if 값.필드 == \"\" || 값.태그 != 3 || 값.정수값 < 0 {\n    return Err(\"Scala 구조 정수 스칼라가 정규형이 아닙니다: {필드}\")\n  }\n  Ok(값.정수값)\n}\n\nexport function 스칼라인쇄구조검사(구조: 구조입력) -> Result<bool, string> {\n  구조입력검사(14, 구조)?\n  if 구조.노드들.length == 0 {\n    return Err(\"Scala 인쇄 구조에 컴파일 단위 노드가 필요합니다\")\n  }\n  if 구조.노드들[0].코드워드 != 157 ||\n    구조.노드들[0].부모순번 != -1 || 구조.노드들[0].자식필드있음 ||\n    구조.노드들[0].자식필드 != \"\" || 구조.노드들[0].자식색인 != -1 {\n    return Err(\"Scala 인쇄 구조 뿌리가 컴파일 단위 노드가 아닙니다\")\n  }\n  let mut 자식수들: Array<int> = []\n  let mut 순번 = 0\n  while 순번 < 구조.노드들.length { 자식수들.push(0); 순번 = 순번 + 1 }\n  let mut 분리본문발생수 = 0\n  let mut 다음식별자류번호 = 0\n  순번 = 0\n  while 순번 < 구조.노드들.length {\n    let 노드 = 구조.노드들[순번]\n    if 노드종류(14, 노드.코드워드) == 0 {\n      return Err(\"Scala 투영 인쇄기가 지원하지 않는 노드입니다: 순번 {순번}, 코드 {노드.코드워드}\")\n    }\n    if 순번 > 0 {\n      if 노드.부모순번 < 0 || 노드.부모순번 >= 순번 ||\n        !노드.자식필드있음 || 노드.자식필드 == \"\" || 노드.자식색인 < 0 {\n        return Err(\"Scala 인쇄 구조의 부모 또는 자식 위치가 정규형이 아닙니다: 순번 {순번}\")\n      }\n      자식수들[노드.부모순번] = 자식수들[노드.부모순번] + 1\n    }\n    if 노드.시작 < 0 || 노드.끝 < 노드.시작 {\n      return Err(\"Scala 인쇄 구조의 원본 범위가 틀립니다: 순번 {순번}\")\n    }\n    let 자식수 = 스칼라정수스칼라검사(노드, \"childCount\")?\n    let 시작행 = 스칼라정수스칼라검사(노드, \"startRow\")?\n    let 시작열 = 스칼라정수스칼라검사(노드, \"startColumn\")?\n    let 끝행 = 스칼라정수스칼라검사(노드, \"endRow\")?\n    let 끝열 = 스칼라정수스칼라검사(노드, \"endColumn\")?\n    if 끝행 < 시작행 || (끝행 == 시작행 && 끝열 < 시작열) {\n      return Err(\"Scala 인쇄 구조의 원본 좌표가 틀립니다: 순번 {순번}\")\n    }\n    if !스칼라있음(노드, \"named\") || !스칼라있음(노드, \"extra\") {\n      return Err(\"Scala 인쇄 구조의 노드 표지 스칼라가 없습니다: 순번 {순번}\")\n    }\n    if 스칼라있음(노드, \"sourceBom\") {\n      return Err(\"Scala 구조에 허용되지 않는 원본 BOM 표지가 있습니다: 순번 {순번}\")\n    }\n    if 스칼라있음(노드, \"leadingHorizontalLayout\") &&\n      (!선행가로배치인가(노드, false, true) ||\n        !(자식수 == 0 || 스칼라원자본문코드(노드.코드워드) ||\n          스칼라감싼식별자인가(구조, 순번))) {\n      return Err(\"Scala 선행 가로 배치가 정규형이 아닙니다: 순번 {순번}\")\n    }\n    if 노드.코드워드 == 416 && (자식수 == 0 || 스칼라감싼식별자인가(구조, 순번)) {\n      if 노드.식별자있음 {\n        if 스칼라있음(노드, \"text\") {\n          return Err(\"Scala 식별자 이름이 이미지와 분리 본문에 함께 있습니다\")\n        }\n        if 노드.식별자류번호 < 0 || 노드.식별자류번호 > 다음식별자류번호 {\n          return Err(\"Scala 식별자 알파류가 첫 사용 정규형이 아닙니다: 순번 {순번}\")\n        }\n        if 노드.식별자류번호 == 다음식별자류번호 {\n          다음식별자류번호 = 다음식별자류번호 + 1\n        }\n        분리본문발생수 = 분리본문발생수 + 1\n      } else if 노드.식별자류번호 != 0 || !스칼라있음(노드, \"text\") ||\n        노드스칼라(노드, \"text\").태그 != 5 {\n        return Err(\"Scala 이미지 식별자 이름이 정규형이 아닙니다: 순번 {순번}\")\n      }\n    } else {\n      if 노드.식별자있음 || 노드.식별자류번호 != 0 {\n        return Err(\"Scala 식별자가 아닌 노드에 알파류가 있습니다: 순번 {순번}\")\n      }\n      if 스칼라댓글코드(노드.코드워드) {\n        if 스칼라있음(노드, \"text\") {\n          return Err(\"Scala 댓글 원문은 분리 본문에만 있어야 합니다: 순번 {순번}\")\n        }\n        분리본문발생수 = 분리본문발생수 + 1\n      } else if 스칼라감싼식별자자식인가(구조, 순번) {\n        if 스칼라있음(노드, \"text\") {\n          return Err(\"Scala 감싼 식별자 자식에 중복 토큰 원문이 있습니다: 순번 {순번}\")\n        }\n      } else if 자식수 == 0 || 스칼라원자본문코드(노드.코드워드) {\n        if !스칼라있음(노드, \"text\") || 노드스칼라(노드, \"text\").태그 != 5 {\n          return Err(\"Scala 인쇄 토큰의 원문이 없습니다: 순번 {순번}\")\n        }\n      } else if 스칼라있음(노드, \"text\") {\n        return Err(\"Scala 가지 노드에 토큰 원문이 있습니다: 순번 {순번}\")\n      }\n    }\n    순번 = 순번 + 1\n  }\n  순번 = 0\n  while 순번 < 구조.노드들.length {\n    if 스칼라정수스칼라검사(구조.노드들[순번], \"childCount\")? != 자식수들[순번] {\n      return Err(\"Scala 노드 자식 수가 구조와 다릅니다: 순번 {순번}\")\n    }\n    순번 = 순번 + 1\n  }\n  if 구조.분리본문값수 < 0 || 구조.분리본문값수 != 분리본문발생수 {\n    return Err(\"Scala 분리 본문 값 수가 식별자와 댓글 발생 수에 맞지 않습니다\")\n  }\n  Ok(true)\n}\n\nfunction 스칼라잎앞섬(구조: 구조입력, 왼쪽: int, 오른쪽: int) -> bool {\n  let 왼쪽노드 = 구조.노드들[왼쪽]\n  let 오른쪽노드 = 구조.노드들[오른쪽]\n  if 왼쪽노드.시작 != 오른쪽노드.시작 {\n    return 왼쪽노드.시작 < 오른쪽노드.시작\n  }\n  if 왼쪽노드.끝 != 오른쪽노드.끝 {\n    return 왼쪽노드.끝 < 오른쪽노드.끝\n  }\n  왼쪽 < 오른쪽\n}\n\nfunction 스칼라잎순번들(구조: 구조입력) -> Result<Array<int>, string> {\n  let mut 잎들: Array<int> = []\n  let mut 순번 = 0\n  while 순번 < 구조.노드들.length {\n    let 노드 = 구조.노드들[순번]\n    let mut 부모순번 = 노드.부모순번\n    let mut 원자본문조상있음 = false\n    while 부모순번 >= 0 {\n      if 스칼라원자본문코드(구조.노드들[부모순번].코드워드) ||\n        스칼라감싼식별자인가(구조, 부모순번) {\n        원자본문조상있음 = true\n        부모순번 = -1\n      } else {\n        부모순번 = 구조.노드들[부모순번].부모순번\n      }\n    }\n    if !원자본문조상있음 &&\n      (스칼라원자본문코드(노드.코드워드) || 스칼라감싼식별자인가(구조, 순번) ||\n        스칼라정수스칼라검사(노드, \"childCount\")? == 0) {\n      잎들.push(순번)\n    }\n    순번 = 순번 + 1\n  }\n  let mut 색인 = 1\n  while 색인 < 잎들.length {\n    let 값 = 잎들[색인]\n    let mut 자리 = 색인\n    while 자리 > 0 && 스칼라잎앞섬(구조, 값, 잎들[자리 - 1]) {\n      잎들[자리] = 잎들[자리 - 1]\n      자리 = 자리 - 1\n    }\n    잎들[자리] = 값\n    색인 = 색인 + 1\n  }\n  Ok(잎들)\n}\n\nexport function 스칼라원본인쇄(구조: 구조입력) -> Result<string, string> {\n  스칼라인쇄구조검사(구조)?\n  let 기본준비 = 인쇄상태만들기(14, 구조, [], [], false, false)\n  let 준비 = 인쇄상태익명이름들바꾸기(기본준비, 익명할당계획이름들(기본준비)?)\n  let 잎들 = 스칼라잎순번들(구조)?\n  let mut 다음보이는행들: Array<int> = []\n  let mut 채움 = 0\n  while 채움 < 잎들.length { 다음보이는행들.push(-1); 채움 = 채움 + 1 }\n  let mut 다음보이는행 = -1\n  let mut 역색인 = 잎들.length\n  while 역색인 > 0 {\n    역색인 = 역색인 - 1\n    다음보이는행들[역색인] = 다음보이는행\n    let 역노드 = 구조.노드들[잎들[역색인]]\n    let 역생략댓글 = 스칼라댓글코드(역노드.코드워드) && !스칼라있음(역노드, \"text\")\n    if !역생략댓글 {\n      다음보이는행 = 스칼라정수스칼라검사(역노드, \"startRow\")?\n    }\n  }\n  // Every source row an omitted comment occupies. A carried run is in-line\n  // whitespace whose role the Scala scanner reads off the whole row it stands\n  // in, so it is emitted only into a row this mode prints unchanged. Keyed\n  // decode prints every comment and therefore every run; image-only decode\n  // prints no comment, and on a row it has emptied the same scalar is read as\n  // that row's first or last content instead of as a gap between two tokens.\n  let mut 최대행 = 0\n  let mut 행훑기 = 0\n  while 행훑기 < 잎들.length {\n    let 행노드 = 구조.노드들[잎들[행훑기]]\n    let 행끝 = 스칼라정수스칼라검사(행노드, \"endRow\")?\n    if 행끝 > 최대행 { 최대행 = 행끝 }\n    행훑기 = 행훑기 + 1\n  }\n  let mut 생략댓글행들: Array<bool> = []\n  let mut 행채움 = 0\n  while 행채움 <= 최대행 { 생략댓글행들.push(false); 행채움 = 행채움 + 1 }\n  let mut 댓글훑기 = 0\n  while 댓글훑기 < 잎들.length {\n    let 댓글노드 = 구조.노드들[잎들[댓글훑기]]\n    if 스칼라댓글코드(댓글노드.코드워드) && !스칼라있음(댓글노드, \"text\") {\n      let 댓글시작행 = 스칼라정수스칼라검사(댓글노드, \"startRow\")?\n      let 댓글끝행 = 스칼라정수스칼라검사(댓글노드, \"endRow\")?\n      let mut 댓글행 = 댓글시작행\n      while 댓글행 <= 댓글끝행 {\n        if 댓글행 >= 0 && 댓글행 < 생략댓글행들.length {\n          생략댓글행들[댓글행] = true\n        }\n        댓글행 = 댓글행 + 1\n      }\n    }\n    댓글훑기 = 댓글훑기 + 1\n  }\n  let 원본 = 선형원본만들기()\n  let mut 출력행 = 0\n  let mut 출력열 = 0\n  let mut 이전끝행 = 0\n  let mut 이전끝열 = 0\n  let mut 이전끝스칼라열 = 0\n  let mut 이전있음 = false\n  let mut 생략행조정 = 0\n  let mut 생략행조정끝행 = -1\n  let mut 토큰색인 = 0\n  while 토큰색인 < 잎들.length {\n    let 순번 = 잎들[토큰색인]\n    let 노드 = 구조.노드들[순번]\n    let 시작행 = 스칼라정수스칼라검사(노드, \"startRow\")?\n    let 시작열 = 스칼라정수스칼라검사(노드, \"startColumn\")?\n    let 끝행 = 스칼라정수스칼라검사(노드, \"endRow\")?\n    let 끝열 = 스칼라정수스칼라검사(노드, \"endColumn\")?\n    let 대체폭 = if 시작행 == 끝행 { 끝열 - 시작열 } else { 끝열 }\n    let 식별자노드 = 노드.코드워드 == 416 &&\n      (스칼라정수스칼라검사(노드, \"childCount\")? == 0 || 스칼라감싼식별자인가(구조, 순번))\n    let 분리식별자 = 식별자노드 && 노드.식별자있음\n    let 생략댓글 = 스칼라댓글코드(노드.코드워드) && !스칼라있음(노드, \"text\")\n    let 토큰 = if 생략댓글 { \"\" } else if 식별자노드 {\n      식별자이름(준비, 순번)?\n    } else { 스칼라문자(노드, \"text\") }\n    let 원본스칼라폭 = if 분리식별자 {\n      러스트열폭(노드, \"identifier\", \"Scalar\", 대체폭)\n    } else if 생략댓글 {\n      러스트열폭(노드, \"comment\", \"Scalar\", 대체폭)\n    } else {\n      본문위치전진(14, 0, 0, 토큰)[1]\n    }\n    let 원본시작스칼라열 = if 이전있음 && 시작행 == 이전끝행 {\n      이전끝스칼라열 + 시작열 - 이전끝열\n    } else { 시작열 }\n    let 원본끝스칼라열 = if 끝행 == 시작행 {\n      원본시작스칼라열 + 원본스칼라폭\n    } else { 원본스칼라폭 }\n    let 구분필요 = 이전있음 && 시작행 == 이전끝행 && 시작열 > 이전끝열\n    let 배치행비었음 = 시작행 < 0 || 시작행 >= 생략댓글행들.length ||\n      !생략댓글행들[시작행]\n    let 가로배치있음 = 스칼라있음(노드, \"leadingHorizontalLayout\") && 배치행비었음\n    if 가로배치있음 {\n      let 조정 = if 시작행 > 생략행조정끝행 { 0 } else { 생략행조정 }\n      let 실린시작행 = 시작행 - 조정\n      if 실린시작행 < 0 { return Err(\"Scala 투영의 보이는 행 배치가 잘못되었습니다\") }\n      let 가로배치 = 스칼라문자(노드, \"leadingHorizontalLayout\")\n      let 가로크기 = 본문위치전진(14, 0, 0, 가로배치)\n      let 실은행수 = 가로크기[0]\n      let 꼬리폭 = 가로크기[1]\n      if 실은행수 == 0 {\n        let 실기전열 = if 원본시작스칼라열 > 꼬리폭 { 원본시작스칼라열 - 꼬리폭 } else { 0 }\n        while 출력행 < 실린시작행 {\n          선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n        }\n        while 출력열 < 실기전열 {\n          선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n        }\n      } else {\n        while 출력행 + 실은행수 < 실린시작행 {\n          선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n        }\n      }\n      선형원본추가(원본, 가로배치)\n      let 가로위치 = 본문위치전진(14, 출력행, 출력열, 가로배치)\n      출력행 = 가로위치[0]\n      출력열 = 가로위치[1]\n      if 출력행 != 실린시작행 {\n        return Err(\"Scala 실린 가로 배치가 기록된 행과 어긋납니다: 순번 {순번}\")\n      }\n    }\n    if 생략댓글 {\n      let 다음행 = 다음보이는행들[토큰색인]\n      if 다음행 == 끝행 && 이전있음 && 시작행 == 이전끝행 && 끝행 > 시작행 {\n        let 바라는행 = 출력행 + 1\n        생략행조정 = 다음행 - 바라는행\n        생략행조정끝행 = 끝행\n      }\n      토큰색인 = 토큰색인 + 1\n      continue\n    } else {\n      if 시작행 > 생략행조정끝행 {\n        생략행조정 = 0\n        생략행조정끝행 = -1\n      }\n      let 출력시작행 = 시작행 - 생략행조정\n      if 출력시작행 < 0 { return Err(\"Scala 투영의 보이는 행 배치가 잘못되었습니다\") }\n      let 행들여쓰기 = 러스트행들여쓰기(노드, 원본시작스칼라열)\n      if 출력행 < 출력시작행 {\n        while 출력행 < 출력시작행 {\n          선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n        }\n        선형원본추가(원본, 행들여쓰기)\n        출력열 = 행들여쓰기.scalars().length\n        while 출력열 < 원본시작스칼라열 {\n          선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n        }\n      } else if 출력행 == 출력시작행 && 출력열 < 원본시작스칼라열 {\n        while 출력열 < 원본시작스칼라열 {\n          선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n        }\n      } else if 출력행 == 출력시작행 && 구분필요 && !가로배치있음 {\n        선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n      }\n      선형원본추가(원본, 토큰)\n      let 출력위치 = 본문위치전진(14, 출력행, 출력열, 토큰)\n      출력행 = 출력위치[0]\n      출력열 = 출력위치[1]\n    }\n    이전끝행 = 끝행\n    이전끝열 = 끝열\n    이전끝스칼라열 = 원본끝스칼라열\n    이전있음 = true\n    토큰색인 = 토큰색인 + 1\n  }\n  if !선형원본줄끝인가(원본) { 선형원본추가(원본, \"\\n\") }\n  Ok(선형원본평평하게(원본))\n}\n",
      "sourceSha256": "d5eb5bd96230634f8215ff653045cf895a0d6740b120f783d3e20f80c7441073"
    },
    {
      "path": "topaz/src/printers/solidity.tpz",
      "language": "topaz",
      "bytes": 12442,
      "sha256": "d6e3b73230a5230d716d8f7c5162040a58aa48f31846b884f21c28cc4b39684c",
      "content": "// Solidity structure validation and canonical source printing.\n\nimport names { 익명할당계획이름들 }\nimport nodes { 노드종류 }\nimport printer_common { 오브젝티브씨잎앞섬 }\nimport printer_cursor { 러스트열폭, 본문위치전진 }\nimport printer_setup { 인쇄상태만들기, 인쇄상태익명이름들바꾸기 }\nimport printer_state { 식별자이름 }\nimport printer_text { 선형원본끝공백제거, 선형원본만들기, 선형원본추가, 선형원본평평하게 }\nimport structure { 구조노드, 구조스칼라, 구조입력, 구조입력검사, 노드스칼라, 스칼라문자, 스칼라있음 }\n\nfunction 솔리디티정수스칼라검사(노드: 구조노드, 필드: string) -> Result<int, string> {\n  let 값 = 노드스칼라(노드, 필드)\n  if 값.필드 == \"\" || 값.태그 != 3 || 값.정수값 < 0 {\n    return Err(\"Solidity 구조 정수 스칼라가 정규형이 아닙니다: {필드}\")\n  }\n  Ok(값.정수값)\n}\n\nfunction 솔리디티댓글코드(코드워드: int) -> bool {\n  코드워드 == 221 || 코드워드 == 222\n}\n\nexport function 솔리디티인쇄구조검사(구조: 구조입력) -> Result<bool, string> {\n  구조입력검사(27, 구조)?\n  if 구조.노드들.length == 0 {\n    return Err(\"Solidity 인쇄 구조에 source_unit 노드가 필요합니다\")\n  }\n  if 구조.노드들[0].코드워드 != 216 ||\n    구조.노드들[0].부모순번 != -1 || 구조.노드들[0].자식필드있음 ||\n    구조.노드들[0].자식필드 != \"\" || 구조.노드들[0].자식색인 != -1 {\n    return Err(\"Solidity 인쇄 구조 뿌리가 source_unit 노드가 아닙니다\")\n  }\n  let mut 자식수들: Array<int> = []\n  let mut 순번 = 0\n  while 순번 < 구조.노드들.length { 자식수들.push(0); 순번 = 순번 + 1 }\n  let mut 분리본문발생수 = 0\n  let mut 다음식별자류번호 = 0\n  순번 = 0\n  while 순번 < 구조.노드들.length {\n    let 노드 = 구조.노드들[순번]\n    if 노드종류(27, 노드.코드워드) == 0 {\n      return Err(\"Solidity 투영 인쇄기가 지원하지 않는 노드입니다: 순번 {순번}, 코드 {노드.코드워드}\")\n    }\n    if 순번 > 0 {\n      if 노드.부모순번 != 0 || !노드.자식필드있음 ||\n        노드.자식필드 != \"tokens\" || 노드.자식색인 < 0 {\n        return Err(\"Solidity 인쇄 구조의 부모 또는 자식 위치가 정규형이 아닙니다: 순번 {순번}\")\n      }\n      자식수들[노드.부모순번] = 자식수들[노드.부모순번] + 1\n    }\n    if 노드.시작 < 0 || 노드.끝 < 노드.시작 {\n      return Err(\"Solidity 인쇄 구조의 원본 범위가 틀립니다: 순번 {순번}\")\n    }\n    let 자식수 = 솔리디티정수스칼라검사(노드, \"childCount\")?\n    let 시작행 = 솔리디티정수스칼라검사(노드, \"startRow\")?\n    let 시작열 = 솔리디티정수스칼라검사(노드, \"startColumn\")?\n    let 끝행 = 솔리디티정수스칼라검사(노드, \"endRow\")?\n    let 끝열 = 솔리디티정수스칼라검사(노드, \"endColumn\")?\n    if 끝행 < 시작행 || (끝행 == 시작행 && 끝열 < 시작열) {\n      return Err(\"Solidity 인쇄 구조의 원본 좌표가 틀립니다: 순번 {순번}\")\n    }\n    if !스칼라있음(노드, \"named\") || !스칼라있음(노드, \"extra\") {\n      return Err(\"Solidity 인쇄 구조의 노드 표지 스칼라가 없습니다: 순번 {순번}\")\n    }\n    if 노드.코드워드 == 218 {\n      if 자식수 != 0 { return Err(\"Solidity 식별자에 자식이 있습니다: 순번 {순번}\") }\n      if 노드.식별자있음 {\n        if 스칼라있음(노드, \"text\") {\n          return Err(\"Solidity 식별자 이름이 이미지와 분리 본문에 함께 있습니다\")\n        }\n        if 노드.식별자류번호 < 0 || 노드.식별자류번호 > 다음식별자류번호 {\n          return Err(\"Solidity 식별자 알파류가 첫 사용 정규형이 아닙니다: 순번 {순번}\")\n        }\n        if 노드.식별자류번호 == 다음식별자류번호 {\n          다음식별자류번호 = 다음식별자류번호 + 1\n        }\n        분리본문발생수 = 분리본문발생수 + 1\n      } else if 노드.식별자류번호 != 0 || !스칼라있음(노드, \"text\") ||\n        노드스칼라(노드, \"text\").태그 != 5 {\n        return Err(\"Solidity 이미지 식별자 이름이 정규형이 아닙니다: 순번 {순번}\")\n      }\n    } else {\n      if 노드.식별자있음 || 노드.식별자류번호 != 0 {\n        return Err(\"Solidity 식별자가 아닌 노드에 알파류가 있습니다: 순번 {순번}\")\n      }\n      if 솔리디티댓글코드(노드.코드워드) {\n        if 자식수 != 0 || 스칼라있음(노드, \"text\") {\n          return Err(\"Solidity 댓글 원문은 분리 본문에만 있어야 합니다: 순번 {순번}\")\n        }\n        분리본문발생수 = 분리본문발생수 + 1\n      } else if 순번 == 0 {\n        if 스칼라있음(노드, \"text\") {\n          return Err(\"Solidity source_unit 구조가 정규형이 아닙니다\")\n        }\n      } else if 자식수 != 0 || !스칼라있음(노드, \"text\") ||\n        노드스칼라(노드, \"text\").태그 != 5 {\n        return Err(\"Solidity 인쇄 토큰의 원문이 없습니다: 순번 {순번}\")\n      }\n    }\n    순번 = 순번 + 1\n  }\n  순번 = 0\n  while 순번 < 구조.노드들.length {\n    if 솔리디티정수스칼라검사(구조.노드들[순번], \"childCount\")? != 자식수들[순번] {\n      return Err(\"Solidity 노드 자식 수가 구조와 다릅니다: 순번 {순번}\")\n    }\n    순번 = 순번 + 1\n  }\n  if 구조.분리본문값수 < 0 || 구조.분리본문값수 != 분리본문발생수 {\n    return Err(\"Solidity 분리 본문 값 수가 식별자와 댓글 발생 수에 맞지 않습니다\")\n  }\n  Ok(true)\n}\n\nfunction 솔리디티잎순번들(구조: 구조입력) -> Result<Array<int>, string> {\n  let mut 잎들: Array<int> = []\n  let mut 순번 = 1\n  while 순번 < 구조.노드들.length {\n    if 솔리디티정수스칼라검사(구조.노드들[순번], \"childCount\")? == 0 {\n      잎들.push(순번)\n    }\n    순번 = 순번 + 1\n  }\n  let mut 색인 = 1\n  while 색인 < 잎들.length {\n    let 값 = 잎들[색인]\n    let mut 자리 = 색인\n    while 자리 > 0 && 오브젝티브씨잎앞섬(구조, 값, 잎들[자리 - 1]) {\n      잎들[자리] = 잎들[자리 - 1]\n      자리 = 자리 - 1\n    }\n    잎들[자리] = 값\n    색인 = 색인 + 1\n  }\n  Ok(잎들)\n}\n\nexport function 솔리디티원본인쇄(구조: 구조입력) -> Result<string, string> {\n  솔리디티인쇄구조검사(구조)?\n  let 기본준비 = 인쇄상태만들기(27, 구조, [], [], false, false)\n  let 준비 = 인쇄상태익명이름들바꾸기(기본준비, 익명할당계획이름들(기본준비)?)\n  let 잎들 = 솔리디티잎순번들(구조)?\n  let 원본 = 선형원본만들기()\n  let mut 출력행 = 0\n  let mut 출력열 = 0\n  let mut 이전끝행 = 0\n  let mut 이전끝열 = 0\n  let mut 이전끝스칼라열 = 0\n  let mut 이전있음 = false\n  let mut 토큰색인 = 0\n  while 토큰색인 < 잎들.length {\n    let 순번 = 잎들[토큰색인]\n    let 노드 = 구조.노드들[순번]\n    let 시작행 = 솔리디티정수스칼라검사(노드, \"startRow\")?\n    let 시작열 = 솔리디티정수스칼라검사(노드, \"startColumn\")?\n    let 끝행 = 솔리디티정수스칼라검사(노드, \"endRow\")?\n    let 끝열 = 솔리디티정수스칼라검사(노드, \"endColumn\")?\n    let 대체폭 = if 시작행 == 끝행 { 끝열 - 시작열 } else { 끝열 }\n    let 식별자노드 = 노드.코드워드 == 218\n    let 분리식별자 = 식별자노드 && 노드.식별자있음\n    let 생략댓글 = 솔리디티댓글코드(노드.코드워드) && !스칼라있음(노드, \"text\")\n    let 토큰 = if 생략댓글 { \"\" } else if 식별자노드 {\n      식별자이름(준비, 순번)?\n    } else { 스칼라문자(노드, \"text\") }\n    let 원본스칼라폭 = if 분리식별자 {\n      러스트열폭(노드, \"identifier\", \"Scalar\", 대체폭)\n    } else if 생략댓글 {\n      러스트열폭(노드, \"comment\", \"Scalar\", 대체폭)\n    } else {\n      본문위치전진(27, 0, 0, 토큰)[1]\n    }\n    let 같은원본행 = 이전있음 && 시작행 == 이전끝행\n    let 원본간격 = if 같은원본행 { 시작열 - 이전끝열 } else { 0 }\n    let 원본시작스칼라열 = if 같은원본행 {\n      if 원본간격 == 0 { 출력열 } else { 이전끝스칼라열 + 원본간격 }\n    } else { 시작열 }\n    let 원본끝스칼라열 = if 끝행 == 시작행 {\n      원본시작스칼라열 + 원본스칼라폭\n    } else { 원본스칼라폭 }\n    let 구분필요 = 이전있음 && 시작행 == 이전끝행 && 시작열 > 이전끝열\n    if 생략댓글 {\n      let 다음시작행 = if 토큰색인 + 1 < 잎들.length {\n        솔리디티정수스칼라검사(구조.노드들[잎들[토큰색인 + 1]], \"startRow\")?\n      } else { -1 }\n      let 온줄차지 = (!이전있음 || 시작행 > 이전끝행) &&\n        (다음시작행 < 0 || 다음시작행 > 끝행)\n      let 줄끝댓글 = 이전있음 && 시작행 == 이전끝행 &&\n        (다음시작행 < 0 || 다음시작행 > 끝행)\n      if 온줄차지 {\n        while 출력행 < 시작행 {\n          선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n        }\n        while 출력행 < 끝행 {\n          선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n        }\n      } else if 줄끝댓글 {\n        이전끝행 = 끝행\n        이전끝열 = 끝열\n        이전끝스칼라열 = 원본끝스칼라열\n        이전있음 = true\n        토큰색인 = 토큰색인 + 1\n        continue\n      } else if 끝행 > 시작행 {\n        while 출력행 < 끝행 {\n          선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n        }\n        while 출력열 < 원본끝스칼라열 {\n          선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n        }\n      } else {\n        if 출력행 < 시작행 {\n          while 출력행 < 시작행 {\n            선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n          }\n          while 출력열 < 원본시작스칼라열 {\n            선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n          }\n        } else if 출력행 == 시작행 && 출력열 < 원본시작스칼라열 {\n          while 출력열 < 원본시작스칼라열 {\n            선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n          }\n        } else if 출력행 == 시작행 && 구분필요 {\n          선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n        }\n        if 출력행 < 끝행 {\n          while 출력행 < 끝행 {\n            선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n          }\n          while 출력열 < 원본끝스칼라열 {\n            선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n          }\n        } else if 출력행 == 끝행 && 출력열 < 원본끝스칼라열 {\n          while 출력열 < 원본끝스칼라열 {\n            선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n          }\n        }\n      }\n    } else {\n      if 출력행 < 시작행 {\n        while 출력행 < 시작행 {\n          선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n        }\n        while 출력열 < 원본시작스칼라열 {\n          선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n        }\n      } else if 출력행 == 시작행 && 출력열 < 원본시작스칼라열 {\n        while 출력열 < 원본시작스칼라열 {\n          선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n        }\n      } else if 출력행 == 시작행 && 구분필요 {\n        선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n      }\n      선형원본추가(원본, 토큰)\n      let 출력위치 = 본문위치전진(27, 출력행, 출력열, 토큰)\n      출력행 = 출력위치[0]\n      출력열 = 출력위치[1]\n    }\n    이전끝행 = 끝행\n    이전끝열 = 끝열\n    이전끝스칼라열 = 원본끝스칼라열\n    이전있음 = true\n    토큰색인 = 토큰색인 + 1\n  }\n  선형원본끝공백제거(원본)\n  선형원본추가(원본, \"\\n\")\n  Ok(선형원본평평하게(원본))\n}\n",
      "sourceSha256": "d6e3b73230a5230d716d8f7c5162040a58aa48f31846b884f21c28cc4b39684c"
    },
    {
      "path": "topaz/src/printers/swift.tpz",
      "language": "topaz",
      "bytes": 13556,
      "sha256": "4bfe5ab6918c7062fe3d9adc374adad90e45ef86f977f2ee262a002dc4a9bd70",
      "content": "// Swift structure validation and canonical source printing.\n\nimport nodes { 노드종류 }\nimport printer_common { 선행가로배치인가 }\nimport printer_cursor { 러스트열폭, 본문위치전진 }\nimport printer_setup { 인쇄상태만들기 }\nimport printer_state { 식별자이름 }\nimport printer_text { 선형원본만들기, 선형원본줄끝인가, 선형원본추가, 선형원본평평하게 }\nimport schema { 스위프트댓글코드 }\nimport structure { 구조노드, 구조스칼라, 구조입력, 구조입력검사, 노드스칼라, 스칼라문자, 스칼라있음 }\n\nfunction 스위프트정수스칼라검사(노드: 구조노드, 필드: string) -> Result<int, string> {\n  let 값 = 노드스칼라(노드, 필드)\n  if 값.필드 == \"\" || 값.태그 != 3 || 값.정수값 < 0 {\n    return Err(\"Swift 구조 정수 스칼라가 정규형이 아닙니다: {필드}\")\n  }\n  Ok(값.정수값)\n}\n\nexport function 스위프트인쇄구조검사(구조: 구조입력) -> Result<bool, string> {\n  구조입력검사(12, 구조)?\n  if 구조.노드들.length == 0 {\n    return Err(\"Swift 인쇄 구조에 원본 파일 노드가 필요합니다\")\n  }\n  if 구조.노드들[0].코드워드 != 36 ||\n    구조.노드들[0].부모순번 != -1 || 구조.노드들[0].자식필드있음 ||\n    구조.노드들[0].자식필드 != \"\" || 구조.노드들[0].자식색인 != -1 {\n    return Err(\"Swift 인쇄 구조 뿌리가 원본 파일 노드가 아닙니다\")\n  }\n  let mut 자식수들: Array<int> = []\n  let mut 순번 = 0\n  while 순번 < 구조.노드들.length { 자식수들.push(0); 순번 = 순번 + 1 }\n  let mut 분리본문발생수 = 0\n  let mut 다음식별자류번호 = 0\n  순번 = 0\n  while 순번 < 구조.노드들.length {\n    let 노드 = 구조.노드들[순번]\n    let 종류 = 노드종류(12, 노드.코드워드)\n    if 종류 == 0 {\n      return Err(\"Swift 투영 인쇄기가 지원하지 않는 노드입니다: 순번 {순번}, 코드 {노드.코드워드}\")\n    }\n    if 순번 > 0 {\n      if 노드.부모순번 < 0 || 노드.부모순번 >= 순번 ||\n        !노드.자식필드있음 || 노드.자식필드 == \"\" || 노드.자식색인 < 0 {\n        return Err(\"Swift 인쇄 구조의 부모 또는 자식 위치가 정규형이 아닙니다: 순번 {순번}\")\n      }\n      자식수들[노드.부모순번] = 자식수들[노드.부모순번] + 1\n    }\n    if 노드.시작 < 0 || 노드.끝 < 노드.시작 {\n      return Err(\"Swift 인쇄 구조의 원본 범위가 틀립니다: 순번 {순번}\")\n    }\n    let 자식수 = 스위프트정수스칼라검사(노드, \"childCount\")?\n    let 시작행 = 스위프트정수스칼라검사(노드, \"startRow\")?\n    let 시작열 = 스위프트정수스칼라검사(노드, \"startColumn\")?\n    let 끝행 = 스위프트정수스칼라검사(노드, \"endRow\")?\n    let 끝열 = 스위프트정수스칼라검사(노드, \"endColumn\")?\n    if 끝행 < 시작행 || (끝행 == 시작행 && 끝열 < 시작열) {\n      return Err(\"Swift 인쇄 구조의 원본 좌표가 틀립니다: 순번 {순번}\")\n    }\n    if !스칼라있음(노드, \"named\") || !스칼라있음(노드, \"extra\") {\n      return Err(\"Swift 인쇄 구조의 노드 표지 스칼라가 없습니다: 순번 {순번}\")\n    }\n    if 스칼라있음(노드, \"sourceBom\") {\n      return Err(\"Swift 구조에 허용되지 않는 원본 BOM 표지가 있습니다: 순번 {순번}\")\n    }\n    if 스칼라있음(노드, \"leadingHorizontalLayout\") &&\n      (!선행가로배치인가(노드, true, true) || 자식수 != 0) {\n      return Err(\"Swift 선행 가로 배치가 정규형이 아닙니다: 순번 {순번}\")\n    }\n    if 노드.코드워드 == 419 {\n      if 노드.식별자있음 {\n        if 스칼라있음(노드, \"text\") {\n          return Err(\"Swift 식별자 이름이 이미지와 분리 본문에 함께 있습니다\")\n        }\n        if 노드.식별자류번호 < 0 || 노드.식별자류번호 > 다음식별자류번호 {\n          return Err(\"Swift 식별자 알파류가 첫 사용 정규형이 아닙니다: 순번 {순번}\")\n        }\n        if 노드.식별자류번호 == 다음식별자류번호 {\n          다음식별자류번호 = 다음식별자류번호 + 1\n        }\n        분리본문발생수 = 분리본문발생수 + 1\n      } else if 노드.식별자류번호 != 0 || !스칼라있음(노드, \"text\") ||\n        노드스칼라(노드, \"text\").태그 != 5 {\n        return Err(\"Swift 이미지 식별자 이름이 정규형이 아닙니다: 순번 {순번}\")\n      }\n    } else {\n      if 노드.식별자있음 || 노드.식별자류번호 != 0 {\n        return Err(\"Swift 식별자가 아닌 노드에 알파류가 있습니다: 순번 {순번}\")\n      }\n      if 스위프트댓글코드(노드.코드워드) {\n        if 스칼라있음(노드, \"text\") {\n          return Err(\"Swift 댓글 원문은 분리 본문에만 있어야 합니다: 순번 {순번}\")\n        }\n        분리본문발생수 = 분리본문발생수 + 1\n      } else if 자식수 == 0 {\n        if !스칼라있음(노드, \"text\") || 노드스칼라(노드, \"text\").태그 != 5 {\n          return Err(\"Swift 인쇄 토큰의 원문이 없습니다: 순번 {순번}\")\n        }\n      } else if 스칼라있음(노드, \"text\") {\n        return Err(\"Swift 가지 노드에 토큰 원문이 있습니다: 순번 {순번}\")\n      }\n    }\n    순번 = 순번 + 1\n  }\n  순번 = 0\n  while 순번 < 구조.노드들.length {\n    if 스위프트정수스칼라검사(구조.노드들[순번], \"childCount\")? != 자식수들[순번] {\n      return Err(\"Swift 노드 자식 수가 구조와 다릅니다: 순번 {순번}\")\n    }\n    순번 = 순번 + 1\n  }\n  if 구조.분리본문값수 < 0 || 구조.분리본문값수 != 분리본문발생수 {\n      return Err(\"Swift 분리 본문 값 수가 식별자와 댓글 발생 수에 맞지 않습니다\")\n  }\n  Ok(true)\n}\n\nfunction 스위프트잎앞섬(구조: 구조입력, 왼쪽: int, 오른쪽: int) -> bool {\n  let 왼쪽노드 = 구조.노드들[왼쪽]\n  let 오른쪽노드 = 구조.노드들[오른쪽]\n  if 왼쪽노드.시작 != 오른쪽노드.시작 {\n    return 왼쪽노드.시작 < 오른쪽노드.시작\n  }\n  if 왼쪽노드.끝 != 오른쪽노드.끝 {\n    return 왼쪽노드.끝 < 오른쪽노드.끝\n  }\n  왼쪽 < 오른쪽\n}\n\nfunction 스위프트잎순번들(구조: 구조입력) -> Result<Array<int>, string> {\n  let mut 잎들: Array<int> = []\n  let mut 순번 = 0\n  while 순번 < 구조.노드들.length {\n    if 스위프트정수스칼라검사(구조.노드들[순번], \"childCount\")? == 0 {\n      잎들.push(순번)\n    }\n    순번 = 순번 + 1\n  }\n  let mut 색인 = 1\n  while 색인 < 잎들.length {\n    let 값 = 잎들[색인]\n    let mut 자리 = 색인\n    while 자리 > 0 && 스위프트잎앞섬(구조, 값, 잎들[자리 - 1]) {\n      잎들[자리] = 잎들[자리 - 1]\n      자리 = 자리 - 1\n    }\n    잎들[자리] = 값\n    색인 = 색인 + 1\n  }\n  Ok(잎들)\n}\n\n// Swift의 #column은 행 안의 UTF-8 바이트 위치를 보고한다. 생산자의 행\n// 기하는 LF에서만 전진하므로 bare CR은 바이트 열만 늘리고 행은 바꾸지 않는다.\n\nexport function 스위프트원본인쇄(구조: 구조입력) -> Result<string, string> {\n  스위프트인쇄구조검사(구조)?\n  let 준비 = 인쇄상태만들기(12, 구조, [], [], false, false)\n  let 잎들 = 스위프트잎순번들(구조)?\n  let 원본 = 선형원본만들기()\n  let mut 출력행 = 0\n  let mut 출력열 = 0\n  let mut 이전끝행 = 0\n  let mut 이전끝열 = 0\n  let mut 이전끝표시열 = 0\n  let mut 이전있음 = false\n  let mut 토큰색인 = 0\n  while 토큰색인 < 잎들.length {\n    let 순번 = 잎들[토큰색인]\n    let 노드 = 구조.노드들[순번]\n    let 시작행 = 스위프트정수스칼라검사(노드, \"startRow\")?\n    let 시작열 = 스위프트정수스칼라검사(노드, \"startColumn\")?\n    let 끝행 = 스위프트정수스칼라검사(노드, \"endRow\")?\n    let 끝열 = 스위프트정수스칼라검사(노드, \"endColumn\")?\n    let 대체폭 = if 시작행 == 끝행 { 끝열 - 시작열 } else { 끝열 }\n    let 식별자노드 = 노드.코드워드 == 419\n    let 분리식별자 = 식별자노드 && 노드.식별자있음\n    let 생략댓글 = 스위프트댓글코드(노드.코드워드) && !스칼라있음(노드, \"text\")\n    let 토큰 = if 생략댓글 { \"\" } else if 식별자노드 {\n      식별자이름(준비, 순번)?\n    } else { 스칼라문자(노드, \"text\") }\n    let 원본표시폭 = if 분리식별자 {\n      러스트열폭(노드, \"identifier\", \"Display\", 대체폭)\n    } else if 생략댓글 {\n      러스트열폭(노드, \"comment\", \"Display\", 대체폭)\n    } else {\n      본문위치전진(12, 0, 0, 토큰)[1]\n    }\n    let 원본시작표시열 = if 이전있음 && 시작행 == 이전끝행 {\n      이전끝표시열 + 시작열 - 이전끝열\n    } else { 시작열 }\n    let 원본끝표시열 = if 끝행 == 시작행 {\n      원본시작표시열 + 원본표시폭\n    } else { 원본표시폭 }\n    let 구분필요 = 이전있음 && 시작행 == 이전끝행 && 시작열 > 이전끝열\n    let 가로배치있음 = 스칼라있음(노드, \"leadingHorizontalLayout\")\n    if 가로배치있음 {\n      let 가로배치 = 스칼라문자(노드, \"leadingHorizontalLayout\")\n      let 가로크기 = 본문위치전진(12, 0, 0, 가로배치)\n      let 실은행수 = 가로크기[0]\n      let 꼬리폭 = 가로크기[1]\n      if 실은행수 == 0 {\n        let 실기전열 = if 원본시작표시열 > 꼬리폭 { 원본시작표시열 - 꼬리폭 } else { 0 }\n        while 출력행 < 시작행 {\n          선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n        }\n        while 출력열 < 실기전열 {\n          선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n        }\n      } else {\n        while 출력행 + 실은행수 < 시작행 {\n          선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n        }\n      }\n      선형원본추가(원본, 가로배치)\n      let 가로위치 = 본문위치전진(12, 출력행, 출력열, 가로배치)\n      출력행 = 가로위치[0]\n      출력열 = 가로위치[1]\n      if 출력행 != 시작행 {\n        return Err(\"Swift 실린 가로 배치가 기록된 행과 어긋납니다: 순번 {순번}\")\n      }\n    }\n    if 생략댓글 {\n      let 다음시작행 = if 토큰색인 + 1 < 잎들.length {\n        스위프트정수스칼라검사(구조.노드들[잎들[토큰색인 + 1]], \"startRow\")?\n      } else { -1 }\n      let 뒤열유지 = 다음시작행 >= 0 && 다음시작행 == 끝행\n      if !뒤열유지 {\n        while 출력행 < 시작행 {\n          선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n        }\n        while 출력행 < 끝행 {\n          선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n        }\n      } else if 끝행 > 시작행 {\n        while 출력행 < 시작행 {\n          선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n        }\n        while 출력행 < 끝행 {\n          선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n        }\n        while 출력열 < 원본끝표시열 {\n          선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n        }\n      } else {\n        if 출력행 < 시작행 {\n          while 출력행 < 시작행 {\n            선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n          }\n          while 출력열 < 원본시작표시열 {\n            선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n          }\n        } else if 출력행 == 시작행 && 출력열 < 원본시작표시열 {\n          while 출력열 < 원본시작표시열 {\n            선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n          }\n        } else if 출력행 == 시작행 && 구분필요 && !가로배치있음 {\n          선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n        }\n        while 출력열 < 원본끝표시열 {\n          선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n        }\n      }\n    } else {\n      if 출력행 < 시작행 {\n        while 출력행 < 시작행 {\n          선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n        }\n        while 출력열 < 원본시작표시열 {\n          선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n        }\n      } else if 출력행 == 시작행 && 출력열 < 원본시작표시열 {\n        while 출력열 < 원본시작표시열 {\n          선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n        }\n      } else if 출력행 == 시작행 && 구분필요 && !가로배치있음 {\n        선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n      }\n      선형원본추가(원본, 토큰)\n      let 출력위치 = 본문위치전진(12, 출력행, 출력열, 토큰)\n      출력행 = 출력위치[0]\n      출력열 = 출력위치[1]\n    }\n    이전끝행 = 끝행\n    이전끝열 = 끝열\n    이전끝표시열 = 원본끝표시열\n    이전있음 = true\n    토큰색인 = 토큰색인 + 1\n  }\n  선형원본추가(원본, 스칼라문자(구조.노드들[0], \"trailingFileLayout\"))\n  if !선형원본줄끝인가(원본) { 선형원본추가(원본, \"\\n\") }\n  Ok(선형원본평평하게(원본))\n}\n",
      "sourceSha256": "4bfe5ab6918c7062fe3d9adc374adad90e45ef86f977f2ee262a002dc4a9bd70"
    },
    {
      "path": "topaz/src/printers/topaz_language.tpz",
      "language": "topaz",
      "bytes": 10145,
      "sha256": "2e8ab381a9a36b3ad77d4ddbe15a1d1a5463ba8c88835ca405059f6e265c1bb3",
      "content": "// Topaz structure validation and canonical source printing.\n\nimport std.bytes { Bytes }\nimport nodes { 노드종류 }\nimport printer_cursor { 본문위치전진, 토파즈언어유티에프십육폭 }\nimport printer_text { 선형원본만들기, 선형원본줄끝인가, 선형원본추가, 선형원본평평하게 }\nimport structure { 구조노드, 구조스칼라, 구조입력, 구조입력검사, 노드스칼라, 스칼라문자, 스칼라있음 }\n\nfunction 토파즈언어정수스칼라검사(노드: 구조노드, 필드: string) -> Result<int, string> {\n  let 값 = 노드스칼라(노드, 필드)\n  if 값.필드 == \"\" || 값.태그 != 3 || 값.정수값 < 0 {\n    return Err(\"Topaz language structure integer scalar is invalid: {필드}\")\n  }\n  Ok(값.정수값)\n}\n\nfunction 토파즈언어가지코드(코드워드: int) -> bool {\n  코드워드 == 101 || 코드워드 == 184 || 코드워드 == 267 ||\n    코드워드 == 350 || 코드워드 == 433 || 코드워드 == 4\n}\n\nfunction 토파즈언어댓글코드(코드워드: int) -> bool {\n  코드워드 == 253 || 코드워드 == 336\n}\n\nexport function 토파즈언어인쇄구조검사(구조: 구조입력) -> Result<bool, string> {\n  구조입력검사(30, 구조)?\n  if 구조.노드들.length == 0 {\n    return Err(\"Topaz language projection requires a source_file root\")\n  }\n  let 뿌리 = 구조.노드들[0]\n  if 뿌리.코드워드 != 101 || 뿌리.부모순번 != -1 ||\n    뿌리.자식필드있음 || 뿌리.자식필드 != \"\" ||\n    뿌리.자식색인 != -1 || 뿌리.시작 != 0 {\n    return Err(\"Topaz language projection root is invalid\")\n  }\n\n  let mut 자식수들: Array<int> = []\n  let mut 첫자식들: Array<int> = []\n  let mut 마지막자식들: Array<int> = []\n  let mut 순번 = 0\n  while 순번 < 구조.노드들.length {\n    자식수들.push(0)\n    첫자식들.push(-1)\n    마지막자식들.push(-1)\n    순번 = 순번 + 1\n  }\n\n  let mut 분리댓글수 = 0\n  let mut 바이트커서 = 0\n  let mut 유티에프십육커서 = 0\n  순번 = 0\n  while 순번 < 구조.노드들.length {\n    let 노드 = 구조.노드들[순번]\n    if 노드종류(30, 노드.코드워드) == 0 {\n      return Err(\"Topaz language projection contains an unknown node code at {순번}\")\n    }\n    if 노드.시작 < 0 || 노드.끝 < 노드.시작 {\n      return Err(\"Topaz language node byte geometry is invalid at {순번}\")\n    }\n    let 자식수 = 토파즈언어정수스칼라검사(노드, \"childCount\")?\n    let 시작행 = 토파즈언어정수스칼라검사(노드, \"startRow\")?\n    let 시작열 = 토파즈언어정수스칼라검사(노드, \"startColumn\")?\n    let 끝행 = 토파즈언어정수스칼라검사(노드, \"endRow\")?\n    let 끝열 = 토파즈언어정수스칼라검사(노드, \"endColumn\")?\n    let 시작유티에프십육 = 토파즈언어정수스칼라검사(노드, \"startUtf16\")?\n    let 끝유티에프십육 = 토파즈언어정수스칼라검사(노드, \"endUtf16\")?\n    if 끝행 < 시작행 || (끝행 == 시작행 && 끝열 < 시작열) ||\n      끝유티에프십육 < 시작유티에프십육 {\n      return Err(\"Topaz language node source geometry is reversed at {순번}\")\n    }\n\n    if 순번 > 0 {\n      if 노드.부모순번 < 0 || 노드.부모순번 >= 순번 ||\n        !노드.자식필드있음 || 노드.자식필드 != \"children\" ||\n        노드.자식색인 < 0 {\n        return Err(\"Topaz language node parent relation is invalid at {순번}\")\n      }\n      let 부모 = 구조.노드들[노드.부모순번]\n      if !토파즈언어가지코드(부모.코드워드) {\n        return Err(\"Topaz language leaf has a child at {순번}\")\n      }\n      let 부모자식수 = 토파즈언어정수스칼라검사(부모, \"childCount\")?\n      if 노드.자식색인 != 자식수들[노드.부모순번] ||\n        노드.자식색인 >= 부모자식수 {\n        return Err(\"Topaz language child index is not canonical at {순번}\")\n      }\n      if 노드.시작 < 부모.시작 || 노드.끝 > 부모.끝 {\n        return Err(\"Topaz language child escapes its parent range at {순번}\")\n      }\n      if 첫자식들[노드.부모순번] < 0 { 첫자식들[노드.부모순번] = 순번 }\n      마지막자식들[노드.부모순번] = 순번\n      자식수들[노드.부모순번] = 자식수들[노드.부모순번] + 1\n    }\n\n    if 노드.식별자있음 || 노드.식별자류번호 != 0 {\n      return Err(\"Topaz language identifiers must remain image-resident at {순번}\")\n    }\n    if 토파즈언어댓글코드(노드.코드워드) {\n      if 자식수 != 0 || 스칼라있음(노드, \"text\") ||\n        !스칼라있음(노드, \"commentReplacement\") ||\n        노드스칼라(노드, \"commentReplacement\").태그 != 5 {\n        return Err(\"Topaz language comment shape is invalid at {순번}\")\n      }\n      let 대체 = 스칼라문자(노드, \"commentReplacement\")\n      if 대체 != (if 노드.코드워드 == 336 { \" \" } else { \"\" }) ||\n        토파즈언어정수스칼라검사(노드, \"commentUtf8Bytes\")? != 노드.끝 - 노드.시작 {\n        return Err(\"Topaz language comment replacement is invalid at {순번}\")\n      }\n      분리댓글수 = 분리댓글수 + 1\n    } else if 토파즈언어가지코드(노드.코드워드) {\n      if 스칼라있음(노드, \"text\") ||\n        (노드.코드워드 != 101 && 자식수 == 0) {\n        return Err(\"Topaz language compound node shape is invalid at {순번}\")\n      }\n      if 노드.코드워드 == 101 && 순번 != 0 {\n        return Err(\"Topaz language source_file appears below the root\")\n      }\n    } else {\n      if 자식수 != 0 || !스칼라있음(노드, \"text\") ||\n        노드스칼라(노드, \"text\").태그 != 5 {\n        return Err(\"Topaz language leaf token text is invalid at {순번}\")\n      }\n      let 글 = 스칼라문자(노드, \"text\")\n      if 글.encodeUtf8().length() != 노드.끝 - 노드.시작 ||\n        토파즈언어유티에프십육폭(글) != 끝유티에프십육 - 시작유티에프십육 {\n        return Err(\"Topaz language leaf token geometry is invalid at {순번}\")\n      }\n      let 다음위치 = 본문위치전진(30, 시작행, 시작열, 글)\n      if 다음위치[0] != 끝행 || 다음위치[1] != 끝열 {\n        return Err(\"Topaz language leaf coordinates are invalid at {순번}\")\n      }\n    }\n\n    if 자식수 == 0 {\n      if 노드.시작 != 바이트커서 || 시작유티에프십육 != 유티에프십육커서 {\n        return Err(\"Topaz language leaf stream has a source gap or overlap at {순번}\")\n      }\n      바이트커서 = 노드.끝\n      유티에프십육커서 = 끝유티에프십육\n    }\n    순번 = 순번 + 1\n  }\n\n  순번 = 0\n  while 순번 < 구조.노드들.length {\n    let 노드 = 구조.노드들[순번]\n    let 자식수 = 토파즈언어정수스칼라검사(노드, \"childCount\")?\n    if 자식수 != 자식수들[순번] {\n      return Err(\"Topaz language child count differs from its tree at {순번}\")\n    }\n    if 자식수 > 0 {\n      let 첫 = 구조.노드들[첫자식들[순번]]\n      let 마지막 = 구조.노드들[마지막자식들[순번]]\n      if 노드.시작 != 첫.시작 || 노드.끝 != 마지막.끝 ||\n        토파즈언어정수스칼라검사(노드, \"startUtf16\")? !=\n          토파즈언어정수스칼라검사(첫, \"startUtf16\")? ||\n        토파즈언어정수스칼라검사(노드, \"endUtf16\")? !=\n          토파즈언어정수스칼라검사(마지막, \"endUtf16\")? {\n        return Err(\"Topaz language compound range is not child-bound at {순번}\")\n      }\n      if 노드.코드워드 == 184 &&\n        (첫.코드워드 != 45 || 스칼라문자(첫, \"text\") != \"(\" ||\n          마지막.코드워드 != 45 || 스칼라문자(마지막, \"text\") != \")\") {\n        return Err(\"Topaz language parenthesized delimiters are invalid at {순번}\")\n      }\n      if 노드.코드워드 == 267 &&\n        (첫.코드워드 != 45 || 스칼라문자(첫, \"text\") != \"[\" ||\n          마지막.코드워드 != 45 || 스칼라문자(마지막, \"text\") != \"]\") {\n        return Err(\"Topaz language bracket delimiters are invalid at {순번}\")\n      }\n      if 노드.코드워드 == 350 &&\n        (첫.코드워드 != 45 || 스칼라문자(첫, \"text\") != \"\\{\" ||\n          마지막.코드워드 != 45 || 스칼라문자(마지막, \"text\") != \"\\}\") {\n        return Err(\"Topaz language brace delimiters are invalid at {순번}\")\n      }\n      if 노드.코드워드 == 433 &&\n        ((첫.코드워드 != 59 && 첫.코드워드 != 142) || 마지막.코드워드 != 308) {\n        return Err(\"Topaz language string delimiters are invalid at {순번}\")\n      }\n      if 노드.코드워드 == 4 &&\n        (첫.코드워드 != 391 || 스칼라문자(첫, \"text\") != \"\\{\" ||\n          마지막.코드워드 != 474 || 스칼라문자(마지막, \"text\") != \"\\}\") {\n        return Err(\"Topaz language interpolation delimiters are invalid at {순번}\")\n      }\n    }\n    순번 = 순번 + 1\n  }\n\n  if 구조.분리본문값수 != 분리댓글수 {\n    return Err(\"Topaz language detached value count differs from comment occurrences\")\n  }\n  if 바이트커서 != 뿌리.끝 || 유티에프십육커서 !=\n    토파즈언어정수스칼라검사(뿌리, \"endUtf16\")? {\n    return Err(\"Topaz language leaf stream does not cover the source\")\n  }\n  Ok(true)\n}\n\nexport function 토파즈언어원본인쇄(구조: 구조입력) -> Result<string, string> {\n  토파즈언어인쇄구조검사(구조)?\n  let 원본 = 선형원본만들기()\n  let mut 순번 = 0\n  while 순번 < 구조.노드들.length {\n    let 노드 = 구조.노드들[순번]\n    if 토파즈언어정수스칼라검사(노드, \"childCount\")? == 0 {\n      if 토파즈언어댓글코드(노드.코드워드) {\n        선형원본추가(원본, 스칼라문자(노드, \"commentReplacement\"))\n      } else {\n        선형원본추가(원본, 스칼라문자(노드, \"text\"))\n      }\n    }\n    순번 = 순번 + 1\n  }\n  if !선형원본줄끝인가(원본) { 선형원본추가(원본, \"\\n\") }\n  Ok(선형원본평평하게(원본))\n}\n",
      "sourceSha256": "2e8ab381a9a36b3ad77d4ddbe15a1d1a5463ba8c88835ca405059f6e265c1bb3"
    },
    {
      "path": "topaz/src/printers/zig.tpz",
      "language": "topaz",
      "bytes": 12694,
      "sha256": "f06418f5dcb8333325086848c3af9fe243befebf0b19b92114b701c0d98e4e7a",
      "content": "// Zig structure validation and canonical source printing.\n\nimport names { 익명할당계획이름들 }\nimport nodes { 노드종류 }\nimport printer_common { 오브젝티브씨잎앞섬 }\nimport printer_cursor { 러스트열폭, 본문위치전진 }\nimport printer_setup { 인쇄상태만들기, 인쇄상태익명이름들바꾸기 }\nimport printer_state { 식별자이름 }\nimport printer_text { 선형원본끝공백제거, 선형원본만들기, 선형원본추가, 선형원본평평하게 }\nimport structure { 구조노드, 구조스칼라, 구조입력, 구조입력검사, 노드스칼라, 스칼라문자, 스칼라있음 }\n\nfunction 지그정수스칼라검사(노드: 구조노드, 필드: string) -> Result<int, string> {\n  let 값 = 노드스칼라(노드, 필드)\n  if 값.필드 == \"\" || 값.태그 != 3 || 값.정수값 < 0 {\n    return Err(\"Zig 구조 정수 스칼라가 정규형이 아닙니다: {필드}\")\n  }\n  Ok(값.정수값)\n}\n\nfunction 지그가지코드(코드워드: int) -> bool {\n  코드워드 >= 233 && 코드워드 <= 236\n}\n\nexport function 지그인쇄구조검사(구조: 구조입력) -> Result<bool, string> {\n  구조입력검사(28, 구조)?\n  if 구조.노드들.length == 0 {\n    return Err(\"Zig 인쇄 구조에 source_file 노드가 필요합니다\")\n  }\n  if 구조.노드들[0].코드워드 != 233 ||\n    구조.노드들[0].부모순번 != -1 || 구조.노드들[0].자식필드있음 ||\n    구조.노드들[0].자식필드 != \"\" || 구조.노드들[0].자식색인 != -1 {\n    return Err(\"Zig 인쇄 구조 뿌리가 source_file 노드가 아닙니다\")\n  }\n  let mut 자식수들: Array<int> = []\n  let mut 순번 = 0\n  while 순번 < 구조.노드들.length { 자식수들.push(0); 순번 = 순번 + 1 }\n  let mut 분리본문발생수 = 0\n  let mut 다음식별자류번호 = 0\n  순번 = 0\n  while 순번 < 구조.노드들.length {\n    let 노드 = 구조.노드들[순번]\n    if 노드종류(28, 노드.코드워드) == 0 {\n      return Err(\"Zig 투영 인쇄기가 지원하지 않는 노드입니다: 순번 {순번}, 코드 {노드.코드워드}\")\n    }\n    if 순번 > 0 {\n      if 노드.부모순번 < 0 || 노드.부모순번 >= 순번 ||\n        !노드.자식필드있음 || 노드.자식필드 != \"children\" || 노드.자식색인 < 0 {\n        return Err(\"Zig 인쇄 구조의 부모 또는 자식 위치가 정규형이 아닙니다: 순번 {순번}\")\n      }\n      let 부모 = 구조.노드들[노드.부모순번]\n      if !지그가지코드(부모.코드워드) {\n        return Err(\"Zig 잎 노드가 자식을 가집니다: 순번 {순번}\")\n      }\n      let 부모자식수 = 지그정수스칼라검사(부모, \"childCount\")?\n      if 노드.자식색인 >= 부모자식수 {\n        return Err(\"Zig 자식 색인이 부모의 자식 수를 벗어납니다: 순번 {순번}\")\n      }\n      자식수들[노드.부모순번] = 자식수들[노드.부모순번] + 1\n    }\n    if 노드.시작 < 0 || 노드.끝 < 노드.시작 {\n      return Err(\"Zig 인쇄 구조의 원본 범위가 틀립니다: 순번 {순번}\")\n    }\n    let 자식수 = 지그정수스칼라검사(노드, \"childCount\")?\n    let 시작행 = 지그정수스칼라검사(노드, \"startRow\")?\n    let 시작열 = 지그정수스칼라검사(노드, \"startColumn\")?\n    let 끝행 = 지그정수스칼라검사(노드, \"endRow\")?\n    let 끝열 = 지그정수스칼라검사(노드, \"endColumn\")?\n    if 끝행 < 시작행 || (끝행 == 시작행 && 끝열 < 시작열) {\n      return Err(\"Zig 인쇄 구조의 원본 좌표가 틀립니다: 순번 {순번}\")\n    }\n    if !스칼라있음(노드, \"named\") || !스칼라있음(노드, \"extra\") {\n      return Err(\"Zig 인쇄 구조의 노드 표지 스칼라가 없습니다: 순번 {순번}\")\n    }\n    if 노드.코드워드 == 238 {\n      if 자식수 != 0 { return Err(\"Zig 식별자에 자식이 있습니다: 순번 {순번}\") }\n      if 노드.식별자있음 {\n        if 스칼라있음(노드, \"text\") {\n          return Err(\"Zig 식별자 이름이 이미지와 분리 본문에 함께 있습니다\")\n        }\n        if 노드.식별자류번호 < 0 || 노드.식별자류번호 > 다음식별자류번호 {\n          return Err(\"Zig 식별자 알파류가 첫 사용 정규형이 아닙니다: 순번 {순번}\")\n        }\n        if 노드.식별자류번호 == 다음식별자류번호 {\n          다음식별자류번호 = 다음식별자류번호 + 1\n        }\n        분리본문발생수 = 분리본문발생수 + 1\n      } else if 노드.식별자류번호 != 0 || !스칼라있음(노드, \"text\") ||\n        노드스칼라(노드, \"text\").태그 != 5 {\n        return Err(\"Zig 이미지 식별자 이름이 정규형이 아닙니다: 순번 {순번}\")\n      }\n    } else {\n      if 노드.식별자있음 || 노드.식별자류번호 != 0 {\n        return Err(\"Zig 식별자가 아닌 노드에 알파류가 있습니다: 순번 {순번}\")\n      }\n      if 노드.코드워드 == 245 {\n        if 자식수 != 0 || 스칼라있음(노드, \"text\") {\n          return Err(\"Zig 댓글 원문은 분리 본문에만 있어야 합니다: 순번 {순번}\")\n        }\n        분리본문발생수 = 분리본문발생수 + 1\n      } else if 지그가지코드(노드.코드워드) {\n        if 스칼라있음(노드, \"text\") {\n          return Err(\"Zig 가지 노드에 토큰 원문이 있습니다: 순번 {순번}\")\n        }\n        if 노드.코드워드 == 233 && 순번 != 0 {\n          return Err(\"Zig source_file 노드는 뿌리에만 있어야 합니다\")\n        }\n        if 노드.코드워드 != 233 && 자식수 < 2 {\n          return Err(\"Zig 구분자 그룹에 여는 토큰과 닫는 토큰이 없습니다: 순번 {순번}\")\n        }\n      } else if 자식수 != 0 || !스칼라있음(노드, \"text\") ||\n        노드스칼라(노드, \"text\").태그 != 5 {\n        return Err(\"Zig 인쇄 토큰의 원문이 없습니다: 순번 {순번}\")\n      }\n    }\n    순번 = 순번 + 1\n  }\n  순번 = 0\n  while 순번 < 구조.노드들.length {\n    if 지그정수스칼라검사(구조.노드들[순번], \"childCount\")? != 자식수들[순번] {\n      return Err(\"Zig 노드 자식 수가 구조와 다릅니다: 순번 {순번}\")\n    }\n    순번 = 순번 + 1\n  }\n  if 구조.분리본문값수 < 0 || 구조.분리본문값수 != 분리본문발생수 {\n    return Err(\"Zig 분리 본문 값 수가 식별자와 댓글 발생 수에 맞지 않습니다\")\n  }\n  Ok(true)\n}\n\nfunction 지그잎순번들(구조: 구조입력) -> Result<Array<int>, string> {\n  let mut 잎들: Array<int> = []\n  let mut 순번 = 1\n  while 순번 < 구조.노드들.length {\n    if 지그정수스칼라검사(구조.노드들[순번], \"childCount\")? == 0 {\n      잎들.push(순번)\n    }\n    순번 = 순번 + 1\n  }\n  let mut 색인 = 1\n  while 색인 < 잎들.length {\n    let 값 = 잎들[색인]\n    let mut 자리 = 색인\n    while 자리 > 0 && 오브젝티브씨잎앞섬(구조, 값, 잎들[자리 - 1]) {\n      잎들[자리] = 잎들[자리 - 1]\n      자리 = 자리 - 1\n    }\n    잎들[자리] = 값\n    색인 = 색인 + 1\n  }\n  Ok(잎들)\n}\n\nexport function 지그원본인쇄(구조: 구조입력) -> Result<string, string> {\n  지그인쇄구조검사(구조)?\n  let 기본준비 = 인쇄상태만들기(28, 구조, [], [], false, false)\n  let 준비 = 인쇄상태익명이름들바꾸기(기본준비, 익명할당계획이름들(기본준비)?)\n  let 잎들 = 지그잎순번들(구조)?\n  let 원본 = 선형원본만들기()\n  let mut 출력행 = 0\n  let mut 출력열 = 0\n  let mut 이전끝행 = 0\n  let mut 이전끝열 = 0\n  let mut 이전끝스칼라열 = 0\n  let mut 이전있음 = false\n  let mut 토큰색인 = 0\n  while 토큰색인 < 잎들.length {\n    let 순번 = 잎들[토큰색인]\n    let 노드 = 구조.노드들[순번]\n    let 시작행 = 지그정수스칼라검사(노드, \"startRow\")?\n    let 시작열 = 지그정수스칼라검사(노드, \"startColumn\")?\n    let 끝행 = 지그정수스칼라검사(노드, \"endRow\")?\n    let 끝열 = 지그정수스칼라검사(노드, \"endColumn\")?\n    let 대체폭 = if 시작행 == 끝행 { 끝열 - 시작열 } else { 끝열 }\n    let 식별자노드 = 노드.코드워드 == 238\n    let 분리식별자 = 식별자노드 && 노드.식별자있음\n    let 생략댓글 = 노드.코드워드 == 245 && !스칼라있음(노드, \"text\")\n    let 토큰 = if 생략댓글 { \"\" } else if 식별자노드 {\n      식별자이름(준비, 순번)?\n    } else { 스칼라문자(노드, \"text\") }\n    let 원본스칼라폭 = if 분리식별자 {\n      러스트열폭(노드, \"identifier\", \"Scalar\", 대체폭)\n    } else if 생략댓글 {\n      러스트열폭(노드, \"comment\", \"Scalar\", 대체폭)\n    } else {\n      본문위치전진(28, 0, 0, 토큰)[1]\n    }\n    let 같은원본행 = 이전있음 && 시작행 == 이전끝행\n    let 원본간격 = if 같은원본행 { 시작열 - 이전끝열 } else { 0 }\n    let 원본시작스칼라열 = if 같은원본행 {\n      이전끝스칼라열 + 원본간격\n    } else { 시작열 }\n    let 원본끝스칼라열 = if 끝행 == 시작행 {\n      원본시작스칼라열 + 원본스칼라폭\n    } else { 원본스칼라폭 }\n    let 구분필요 = 이전있음 && 시작행 == 이전끝행 && 시작열 > 이전끝열\n    if 생략댓글 {\n      let 다음시작행 = if 토큰색인 + 1 < 잎들.length {\n        지그정수스칼라검사(구조.노드들[잎들[토큰색인 + 1]], \"startRow\")?\n      } else { -1 }\n      let 온줄차지 = (!이전있음 || 시작행 > 이전끝행) &&\n        (다음시작행 < 0 || 다음시작행 > 끝행)\n      let 줄끝댓글 = 이전있음 && 시작행 == 이전끝행 &&\n        (다음시작행 < 0 || 다음시작행 > 끝행)\n      if 온줄차지 {\n        while 출력행 < 시작행 {\n          선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n        }\n        while 출력행 < 끝행 {\n          선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n        }\n      } else if 줄끝댓글 {\n        이전끝행 = 끝행\n        이전끝열 = 끝열\n        이전끝스칼라열 = 원본끝스칼라열\n        이전있음 = true\n        토큰색인 = 토큰색인 + 1\n        continue\n      } else {\n        if 출력행 < 시작행 {\n          while 출력행 < 시작행 {\n            선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n          }\n          while 출력열 < 원본시작스칼라열 {\n            선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n          }\n        } else if 출력행 == 시작행 && 출력열 < 원본시작스칼라열 {\n          while 출력열 < 원본시작스칼라열 {\n            선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n          }\n        } else if 출력행 == 시작행 && 구분필요 {\n          선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n        }\n        if 출력행 < 끝행 {\n          while 출력행 < 끝행 {\n            선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n          }\n          while 출력열 < 원본끝스칼라열 {\n            선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n          }\n        } else if 출력행 == 끝행 && 출력열 < 원본끝스칼라열 {\n          while 출력열 < 원본끝스칼라열 {\n            선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n          }\n        }\n      }\n    } else {\n      if 출력행 < 시작행 {\n        while 출력행 < 시작행 {\n          선형원본추가(원본, \"\\n\"); 출력행 = 출력행 + 1; 출력열 = 0\n        }\n        while 출력열 < 원본시작스칼라열 {\n          선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n        }\n      } else if 출력행 == 시작행 && 출력열 < 원본시작스칼라열 {\n        while 출력열 < 원본시작스칼라열 {\n          선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n        }\n      } else if 출력행 == 시작행 && 구분필요 {\n        선형원본추가(원본, \" \"); 출력열 = 출력열 + 1\n      }\n      선형원본추가(원본, 토큰)\n      let 출력위치 = 본문위치전진(28, 출력행, 출력열, 토큰)\n      출력행 = 출력위치[0]\n      출력열 = 출력위치[1]\n    }\n    이전끝행 = 끝행\n    이전끝열 = 끝열\n    이전끝스칼라열 = 원본끝스칼라열\n    이전있음 = true\n    토큰색인 = 토큰색인 + 1\n  }\n  선형원본끝공백제거(원본)\n  선형원본추가(원본, \"\\n\")\n  Ok(선형원본평평하게(원본))\n}\n",
      "sourceSha256": "f06418f5dcb8333325086848c3af9fe243befebf0b19b92114b701c0d98e4e7a"
    },
    {
      "path": "topaz/src/projection.tpz",
      "language": "topaz",
      "bytes": 37789,
      "sha256": "7a07e3e9f657336375ff3645ab037034eda8a1acfc75b4a8f43bbed2553837a8",
      "content": "// Source projection entry points: per-language source printing, byte and chunk\n// transport, node diagnostics, and batch node printing.\n\nimport std.bytes { Bytes }\nimport std.json\nimport detached_key { 분리본문키읽기 }\nimport nodes { 노드종류 }\nimport print { 글자합치기, 인쇄조각평평하게 }\nimport printer_setup { 인쇄상태만들기, 인쇄상태조각판새로 }\nimport printer_state { 댓글고정있음, 자식순번, 자식순번들, 준비된인쇄상태 }\nimport printers { 인쇄구조준비, 준비된구조 }\nimport printers.c { 씨원본인쇄 }\nimport printers.coffeescript { 커피스크립트원본인쇄 }\nimport printers.cpp { 씨플러스플러스원본인쇄 }\nimport printers.csharp { 씨샵원본인쇄 }\nimport printers.dart { 다트원본인쇄 }\nimport printers.elisp { 이맥스리습원본인쇄 }\nimport printers.elixir { 엘릭서원본인쇄 }\nimport printers.elm { 엘름원본인쇄 }\nimport printers.go { 고원본인쇄 }\nimport printers.haskell { 하스켈원본인쇄 }\nimport printers.java { 자바원본인쇄 }\nimport printers.javascript { 노드인쇄조각, 댓글노드인쇄조각, 순번인쇄조각 }\nimport printers.javascript.comments { 댓글머리, 합성내보내기머리 }\nimport printers.javascript.layout { 문장부족행, 문장접두 }\nimport printers.julia { 줄리아원본인쇄 }\nimport printers.kotlin { 코틀린원본인쇄 }\nimport printers.lispex { 리스펙스원본인쇄 }\nimport printers.lua { 루아원본인쇄 }\nimport printers.objc { 오브젝티브씨원본인쇄 }\nimport printers.ocaml { 오캐멀원본인쇄 }\nimport printers.php { 피에이치피원본인쇄 }\nimport printers.python { 파이썬원본인쇄, 파이썬인쇄정규화이름검사 }\nimport printers.r { 알원본인쇄 }\nimport printers.rescript { 리스크립트원본인쇄 }\nimport printers.ruby { 루비원본인쇄 }\nimport printers.rust { 러스트원본인쇄 }\nimport printers.scala { 스칼라원본인쇄 }\nimport printers.solidity { 솔리디티원본인쇄 }\nimport printers.swift { 스위프트원본인쇄 }\nimport printers.topaz_language { 토파즈언어원본인쇄 }\nimport printers.zig { 지그원본인쇄 }\nimport structure { 구조노드, 구조입력, 구조입력읽기 }\nimport types { 분리본문키결과 }\n\nfunction 인쇄상태준비(\n  언어번호: int,\n  구조: 구조입력,\n  키바이트: Bytes,\n  키있음: bool\n) -> Result<준비된인쇄상태, string> {\n  let 준비된구조값 = 인쇄구조준비(언어번호, 구조, true)?\n  let 검사된구조 = 준비된구조값.구조\n  let mut 키결과 = 분리본문키결과 { 값들: [], 댓글고정들: [], 둘째판: false }\n  if 키있음 { 키결과 = 분리본문키읽기(언어번호, 검사된구조, 키바이트)? }\n  Ok(인쇄상태만들기(\n    준비된구조값.언어번호,\n    검사된구조,\n    키결과.값들,\n    키결과.댓글고정들,\n    false,\n    !키있음 && (언어번호 == 1 || 언어번호 == 2)\n  ))\n}\n\nexport function 투영구조인쇄검사(언어번호: int, 구조글: string) -> Result<bool, string> {\n  let 구조 = 구조입력읽기(구조글)?\n  인쇄구조준비(언어번호, 구조, false)?\n  if 언어번호 == 3 { 파이썬인쇄정규화이름검사(구조)? }\n  Ok(true)\n}\n\nexport function 투영원본인쇄(언어번호: int, 구조글: string, 키바이트: Bytes, 키있음: bool) -> Result<string, string> {\n  if 언어번호 == 3 {\n    if 키있음 { return Err(\"파이썬 정규 인쇄는 이미지 전용 구조만 받습니다\") }\n    let 파이썬구조 = 구조입력읽기(구조글)?\n    인쇄구조준비(언어번호, 파이썬구조, true)?\n    return 파이썬원본인쇄(파이썬구조)\n  }\n  if 언어번호 == 4 {\n    if 키있음 { return Err(\"고 정규 인쇄는 이미지 전용 구조만 받습니다\") }\n    let 고구조 = 구조입력읽기(구조글)?\n    인쇄구조준비(언어번호, 고구조, true)?\n    return 고원본인쇄(고구조)\n  }\n  if 언어번호 == 5 {\n    if 키있음 { return Err(\"러스트 정규 인쇄는 이미지 전용 구조만 받습니다\") }\n    let 러스트구조 = 구조입력읽기(구조글)?\n    인쇄구조준비(언어번호, 러스트구조, true)?\n    return 러스트원본인쇄(러스트구조)\n  }\n  if 언어번호 == 6 {\n    if 키있음 { return Err(\"자바 정규 인쇄는 이미지 전용 구조만 받습니다\") }\n    let 자바구조 = 구조입력읽기(구조글)?\n    인쇄구조준비(언어번호, 자바구조, true)?\n    return 자바원본인쇄(자바구조)\n  }\n  if 언어번호 == 7 {\n    if 키있음 { return Err(\"C 정규 인쇄는 이미지 전용 구조만 받습니다\") }\n    let 씨구조 = 구조입력읽기(구조글)?\n    인쇄구조준비(언어번호, 씨구조, true)?\n    return 씨원본인쇄(씨구조)\n  }\n  if 언어번호 == 8 {\n    if 키있음 { return Err(\"C++ 정규 인쇄는 이미지 전용 구조만 받습니다\") }\n    let 씨플러스플러스구조 = 구조입력읽기(구조글)?\n    인쇄구조준비(언어번호, 씨플러스플러스구조, true)?\n    return 씨플러스플러스원본인쇄(씨플러스플러스구조)\n  }\n  if 언어번호 == 9 {\n    if 키있음 { return Err(\"C# 정규 인쇄는 이미지 전용 구조만 받습니다\") }\n    let 씨샵구조 = 구조입력읽기(구조글)?\n    인쇄구조준비(언어번호, 씨샵구조, true)?\n    return 씨샵원본인쇄(씨샵구조)\n  }\n  if 언어번호 == 10 {\n    if 키있음 { return Err(\"루비 정규 인쇄는 이미지 전용 구조만 받습니다\") }\n    let 루비구조 = 구조입력읽기(구조글)?\n    인쇄구조준비(언어번호, 루비구조, true)?\n    return 루비원본인쇄(루비구조)\n  }\n  if 언어번호 == 11 {\n    if 키있음 { return Err(\"PHP 정규 인쇄는 이미지 전용 구조만 받습니다\") }\n    let 피에이치피구조 = 구조입력읽기(구조글)?\n    인쇄구조준비(언어번호, 피에이치피구조, true)?\n    return 피에이치피원본인쇄(피에이치피구조)\n  }\n  if 언어번호 == 12 {\n    if 키있음 { return Err(\"Swift 정규 인쇄는 이미지 전용 구조만 받습니다\") }\n    let 스위프트구조 = 구조입력읽기(구조글)?\n    인쇄구조준비(언어번호, 스위프트구조, true)?\n    return 스위프트원본인쇄(스위프트구조)\n  }\n  if 언어번호 == 13 {\n    if 키있음 { return Err(\"Kotlin 정규 인쇄는 이미지 전용 구조만 받습니다\") }\n    let 코틀린구조 = 구조입력읽기(구조글)?\n    인쇄구조준비(언어번호, 코틀린구조, true)?\n    return 코틀린원본인쇄(코틀린구조)\n  }\n  if 언어번호 == 14 {\n    if 키있음 { return Err(\"Scala 정규 인쇄는 이미지 전용 구조만 받습니다\") }\n    let 스칼라구조 = 구조입력읽기(구조글)?\n    인쇄구조준비(언어번호, 스칼라구조, true)?\n    return 스칼라원본인쇄(스칼라구조)\n  }\n  if 언어번호 == 15 {\n    if 키있음 { return Err(\"Dart 정규 인쇄는 이미지 전용 구조만 받습니다\") }\n    let 다트구조 = 구조입력읽기(구조글)?\n    인쇄구조준비(언어번호, 다트구조, true)?\n    return 다트원본인쇄(다트구조)\n  }\n  if 언어번호 == 16 {\n    if 키있음 { return Err(\"Elixir 정규 인쇄는 이미지 전용 구조만 받습니다\") }\n    let 엘릭서구조 = 구조입력읽기(구조글)?\n    인쇄구조준비(언어번호, 엘릭서구조, true)?\n    return 엘릭서원본인쇄(엘릭서구조)\n  }\n  if 언어번호 == 17 {\n    if 키있음 { return Err(\"Haskell 정규 인쇄는 이미지 전용 구조만 받습니다\") }\n    let 하스켈구조 = 구조입력읽기(구조글)?\n    인쇄구조준비(언어번호, 하스켈구조, true)?\n    return 하스켈원본인쇄(하스켈구조)\n  }\n  if 언어번호 == 18 {\n    if 키있음 { return Err(\"Lua 정규 인쇄는 이미지 전용 구조만 받습니다\") }\n    let 루아구조 = 구조입력읽기(구조글)?\n    인쇄구조준비(언어번호, 루아구조, true)?\n    return 루아원본인쇄(루아구조)\n  }\n  if 언어번호 == 19 {\n    if 키있음 { return Err(\"R 정규 인쇄는 이미지 전용 구조만 받습니다\") }\n    let 알구조 = 구조입력읽기(구조글)?\n    인쇄구조준비(언어번호, 알구조, true)?\n    return 알원본인쇄(알구조)\n  }\n  if 언어번호 == 21 {\n    if 키있음 { return Err(\"OCaml 정규 인쇄는 이미지 전용 구조만 받습니다\") }\n    let 오캐멀구조 = 구조입력읽기(구조글)?\n    인쇄구조준비(언어번호, 오캐멀구조, true)?\n    return 오캐멀원본인쇄(오캐멀구조)\n  }\n  if 언어번호 == 20 {\n    if 키있음 { return Err(\"Julia 정규 인쇄는 이미지 전용 구조만 받습니다\") }\n    let 줄리아구조 = 구조입력읽기(구조글)?\n    인쇄구조준비(언어번호, 줄리아구조, true)?\n    return 줄리아원본인쇄(줄리아구조)\n  }\n  if 언어번호 == 22 {\n    if 키있음 { return Err(\"Elm 정규 인쇄는 이미지 전용 구조만 받습니다\") }\n    let 엘름구조 = 구조입력읽기(구조글)?\n    인쇄구조준비(언어번호, 엘름구조, true)?\n    return 엘름원본인쇄(엘름구조)\n  }\n  if 언어번호 == 23 {\n    if 키있음 { return Err(\"ReScript 정규 인쇄는 이미지 전용 구조만 받습니다\") }\n    let 리스크립트구조 = 구조입력읽기(구조글)?\n    인쇄구조준비(언어번호, 리스크립트구조, true)?\n    return 리스크립트원본인쇄(리스크립트구조)\n  }\n  if 언어번호 == 24 {\n    if 키있음 { return Err(\"CoffeeScript 정규 인쇄는 이미지 전용 구조만 받습니다\") }\n    let 커피스크립트구조 = 구조입력읽기(구조글)?\n    인쇄구조준비(언어번호, 커피스크립트구조, true)?\n    return 커피스크립트원본인쇄(커피스크립트구조)\n  }\n  if 언어번호 == 25 {\n    if 키있음 { return Err(\"Objective-C 정규 인쇄는 이미지 전용 구조만 받습니다\") }\n    let 오브젝티브씨구조 = 구조입력읽기(구조글)?\n    인쇄구조준비(언어번호, 오브젝티브씨구조, true)?\n    return 오브젝티브씨원본인쇄(오브젝티브씨구조)\n  }\n  if 언어번호 == 26 {\n    if 키있음 { return Err(\"Elisp 정규 인쇄는 이미지 전용 구조만 받습니다\") }\n    let 이맥스리습구조 = 구조입력읽기(구조글)?\n    인쇄구조준비(언어번호, 이맥스리습구조, true)?\n    return 이맥스리습원본인쇄(이맥스리습구조)\n  }\n  if 언어번호 == 27 {\n    if 키있음 { return Err(\"Solidity 정규 인쇄는 이미지 전용 구조만 받습니다\") }\n    let 솔리디티구조 = 구조입력읽기(구조글)?\n    인쇄구조준비(언어번호, 솔리디티구조, true)?\n    return 솔리디티원본인쇄(솔리디티구조)\n  }\n  if 언어번호 == 28 {\n    if 키있음 { return Err(\"Zig 정규 인쇄는 이미지 전용 구조만 받습니다\") }\n    let 지그구조 = 구조입력읽기(구조글)?\n    인쇄구조준비(언어번호, 지그구조, true)?\n    return 지그원본인쇄(지그구조)\n  }\n  if 언어번호 == 29 {\n    if 키있음 { return Err(\"Lispex 정규 인쇄는 이미지 전용 구조만 받습니다\") }\n    let 리스펙스구조 = 구조입력읽기(구조글)?\n    인쇄구조준비(언어번호, 리스펙스구조, true)?\n    return 리스펙스원본인쇄(리스펙스구조)\n  }\n  if 언어번호 == 30 {\n    if 키있음 { return Err(\"Topaz language canonical printing accepts image-only structure\") }\n    let 토파즈언어구조 = 구조입력읽기(구조글)?\n    인쇄구조준비(언어번호, 토파즈언어구조, true)?\n    return 토파즈언어원본인쇄(토파즈언어구조)\n  }\n  if 언어번호 != 1 && 언어번호 != 2 { return Err(\"인쇄 언어 번호가 틀립니다\") }\n  let 구조 = 구조입력읽기(구조글)?\n  if 구조.노드들.length == 0 { return Err(\"인쇄할 노드가 없습니다\") }\n  let 준비 = 인쇄상태준비(언어번호, 구조, 키바이트, 키있음)?\n  let 뿌리종류 = 노드종류(언어번호, 준비.구조.노드들[0].코드워드)\n  if 뿌리종류 != 101 { return Err(\"투영 뿌리가 파일 노드가 아닙니다\") }\n  let 본문조각 = if 댓글고정있음(준비) {\n    댓글노드인쇄조각(준비, 1, 0)\n  } else { 노드인쇄조각(준비, 1, 0) }\n  let 본문 = 인쇄조각평평하게(준비.조각판, 본문조각?)?\n  let 댓글원본 = 댓글머리(준비)\n  let 댓글글자들 = 댓글원본.scalars()\n  let 댓글 = 글자합치기(댓글글자들, 0, 댓글글자들.length)\n  Ok((if 댓글 == \"\" { \"\" } else { 댓글 + \"\\n\" }) + 본문 + \"\\n\")\n}\n\nexport function 투영노드인쇄진단(언어번호: int, 구조글: string, 순번: int) -> Result<string, string> {\n  let 구조 = 구조입력읽기(구조글)?\n  let 준비된구조값 = 인쇄구조준비(언어번호, 구조, true)?\n  let 준비 = 인쇄상태만들기(\n    준비된구조값.언어번호,\n    준비된구조값.구조,\n    [],\n    [],\n    false,\n    false\n  )\n  let 조각 = if 댓글고정있음(준비) {\n    댓글노드인쇄조각(준비, 순번, 0)\n  } else { 노드인쇄조각(준비, 순번, 0) }\n  인쇄조각평평하게(준비.조각판, 조각?)\n}\n\nexport function 투영원본바이트인쇄(언어번호: int, 구조글: string, 키바이트: Bytes, 키있음: bool) -> Result<Bytes, string> {\n  if 언어번호 == 3 {\n    if 키있음 { return Err(\"파이썬 정규 인쇄는 이미지 전용 구조만 받습니다\") }\n    let 파이썬구조 = 구조입력읽기(구조글)?\n    인쇄구조준비(언어번호, 파이썬구조, true)?\n    return Ok((파이썬원본인쇄(파이썬구조)?).encodeUtf8())\n  }\n  if 언어번호 == 4 {\n    if 키있음 { return Err(\"고 정규 인쇄는 이미지 전용 구조만 받습니다\") }\n    let 고구조 = 구조입력읽기(구조글)?\n    인쇄구조준비(언어번호, 고구조, true)?\n    return Ok((고원본인쇄(고구조)?).encodeUtf8())\n  }\n  if 언어번호 == 5 {\n    if 키있음 { return Err(\"러스트 정규 인쇄는 이미지 전용 구조만 받습니다\") }\n    let 러스트구조 = 구조입력읽기(구조글)?\n    인쇄구조준비(언어번호, 러스트구조, true)?\n    return Ok((러스트원본인쇄(러스트구조)?).encodeUtf8())\n  }\n  if 언어번호 == 6 {\n    if 키있음 { return Err(\"자바 정규 인쇄는 이미지 전용 구조만 받습니다\") }\n    let 자바구조 = 구조입력읽기(구조글)?\n    인쇄구조준비(언어번호, 자바구조, true)?\n    return Ok((자바원본인쇄(자바구조)?).encodeUtf8())\n  }\n  if 언어번호 == 7 {\n    if 키있음 { return Err(\"C 정규 인쇄는 이미지 전용 구조만 받습니다\") }\n    let 씨구조 = 구조입력읽기(구조글)?\n    인쇄구조준비(언어번호, 씨구조, true)?\n    return Ok((씨원본인쇄(씨구조)?).encodeUtf8())\n  }\n  if 언어번호 == 8 {\n    if 키있음 { return Err(\"C++ 정규 인쇄는 이미지 전용 구조만 받습니다\") }\n    let 씨플러스플러스구조 = 구조입력읽기(구조글)?\n    인쇄구조준비(언어번호, 씨플러스플러스구조, true)?\n    return Ok((씨플러스플러스원본인쇄(씨플러스플러스구조)?).encodeUtf8())\n  }\n  if 언어번호 == 9 {\n    if 키있음 { return Err(\"C# 정규 인쇄는 이미지 전용 구조만 받습니다\") }\n    let 씨샵구조 = 구조입력읽기(구조글)?\n    인쇄구조준비(언어번호, 씨샵구조, true)?\n    return Ok((씨샵원본인쇄(씨샵구조)?).encodeUtf8())\n  }\n  if 언어번호 == 10 {\n    if 키있음 { return Err(\"루비 정규 인쇄는 이미지 전용 구조만 받습니다\") }\n    let 루비구조 = 구조입력읽기(구조글)?\n    인쇄구조준비(언어번호, 루비구조, true)?\n    return Ok((루비원본인쇄(루비구조)?).encodeUtf8())\n  }\n  if 언어번호 == 11 {\n    if 키있음 { return Err(\"PHP 정규 인쇄는 이미지 전용 구조만 받습니다\") }\n    let 피에이치피구조 = 구조입력읽기(구조글)?\n    인쇄구조준비(언어번호, 피에이치피구조, true)?\n    return Ok((피에이치피원본인쇄(피에이치피구조)?).encodeUtf8())\n  }\n  if 언어번호 == 12 {\n    if 키있음 { return Err(\"Swift 정규 인쇄는 이미지 전용 구조만 받습니다\") }\n    let 스위프트구조 = 구조입력읽기(구조글)?\n    인쇄구조준비(언어번호, 스위프트구조, true)?\n    return Ok((스위프트원본인쇄(스위프트구조)?).encodeUtf8())\n  }\n  if 언어번호 == 13 {\n    if 키있음 { return Err(\"Kotlin 정규 인쇄는 이미지 전용 구조만 받습니다\") }\n    let 코틀린구조 = 구조입력읽기(구조글)?\n    인쇄구조준비(언어번호, 코틀린구조, true)?\n    return Ok((코틀린원본인쇄(코틀린구조)?).encodeUtf8())\n  }\n  if 언어번호 == 14 {\n    if 키있음 { return Err(\"Scala 정규 인쇄는 이미지 전용 구조만 받습니다\") }\n    let 스칼라구조 = 구조입력읽기(구조글)?\n    인쇄구조준비(언어번호, 스칼라구조, true)?\n    return Ok((스칼라원본인쇄(스칼라구조)?).encodeUtf8())\n  }\n  if 언어번호 == 15 {\n    if 키있음 { return Err(\"Dart 정규 인쇄는 이미지 전용 구조만 받습니다\") }\n    let 다트구조 = 구조입력읽기(구조글)?\n    인쇄구조준비(언어번호, 다트구조, true)?\n    return Ok((다트원본인쇄(다트구조)?).encodeUtf8())\n  }\n  if 언어번호 == 16 {\n    if 키있음 { return Err(\"Elixir 정규 인쇄는 이미지 전용 구조만 받습니다\") }\n    let 엘릭서구조 = 구조입력읽기(구조글)?\n    인쇄구조준비(언어번호, 엘릭서구조, true)?\n    return Ok((엘릭서원본인쇄(엘릭서구조)?).encodeUtf8())\n  }\n  if 언어번호 == 17 {\n    if 키있음 { return Err(\"Haskell 정규 인쇄는 이미지 전용 구조만 받습니다\") }\n    let 하스켈구조 = 구조입력읽기(구조글)?\n    인쇄구조준비(언어번호, 하스켈구조, true)?\n    return Ok((하스켈원본인쇄(하스켈구조)?).encodeUtf8())\n  }\n  if 언어번호 == 18 {\n    if 키있음 { return Err(\"Lua 정규 인쇄는 이미지 전용 구조만 받습니다\") }\n    let 루아구조 = 구조입력읽기(구조글)?\n    인쇄구조준비(언어번호, 루아구조, true)?\n    return Ok((루아원본인쇄(루아구조)?).encodeUtf8())\n  }\n  if 언어번호 == 19 {\n    if 키있음 { return Err(\"R 정규 인쇄는 이미지 전용 구조만 받습니다\") }\n    let 알구조 = 구조입력읽기(구조글)?\n    인쇄구조준비(언어번호, 알구조, true)?\n    return Ok((알원본인쇄(알구조)?).encodeUtf8())\n  }\n  if 언어번호 == 21 {\n    if 키있음 { return Err(\"OCaml 정규 인쇄는 이미지 전용 구조만 받습니다\") }\n    let 오캐멀구조 = 구조입력읽기(구조글)?\n    인쇄구조준비(언어번호, 오캐멀구조, true)?\n    return Ok((오캐멀원본인쇄(오캐멀구조)?).encodeUtf8())\n  }\n  if 언어번호 == 20 {\n    if 키있음 { return Err(\"Julia 정규 인쇄는 이미지 전용 구조만 받습니다\") }\n    let 줄리아구조 = 구조입력읽기(구조글)?\n    인쇄구조준비(언어번호, 줄리아구조, true)?\n    return Ok((줄리아원본인쇄(줄리아구조)?).encodeUtf8())\n  }\n  if 언어번호 == 22 {\n    if 키있음 { return Err(\"Elm 정규 인쇄는 이미지 전용 구조만 받습니다\") }\n    let 엘름구조 = 구조입력읽기(구조글)?\n    인쇄구조준비(언어번호, 엘름구조, true)?\n    return Ok((엘름원본인쇄(엘름구조)?).encodeUtf8())\n  }\n  if 언어번호 == 23 {\n    if 키있음 { return Err(\"ReScript 정규 인쇄는 이미지 전용 구조만 받습니다\") }\n    let 리스크립트구조 = 구조입력읽기(구조글)?\n    인쇄구조준비(언어번호, 리스크립트구조, true)?\n    return Ok((리스크립트원본인쇄(리스크립트구조)?).encodeUtf8())\n  }\n  if 언어번호 == 24 {\n    if 키있음 { return Err(\"CoffeeScript 정규 인쇄는 이미지 전용 구조만 받습니다\") }\n    let 커피스크립트구조 = 구조입력읽기(구조글)?\n    인쇄구조준비(언어번호, 커피스크립트구조, true)?\n    return Ok((커피스크립트원본인쇄(커피스크립트구조)?).encodeUtf8())\n  }\n  if 언어번호 == 25 {\n    if 키있음 { return Err(\"Objective-C 정규 인쇄는 이미지 전용 구조만 받습니다\") }\n    let 오브젝티브씨구조 = 구조입력읽기(구조글)?\n    인쇄구조준비(언어번호, 오브젝티브씨구조, true)?\n    return Ok((오브젝티브씨원본인쇄(오브젝티브씨구조)?).encodeUtf8())\n  }\n  if 언어번호 == 26 {\n    if 키있음 { return Err(\"Elisp 정규 인쇄는 이미지 전용 구조만 받습니다\") }\n    let 이맥스리습구조 = 구조입력읽기(구조글)?\n    인쇄구조준비(언어번호, 이맥스리습구조, true)?\n    return Ok((이맥스리습원본인쇄(이맥스리습구조)?).encodeUtf8())\n  }\n  if 언어번호 == 27 {\n    if 키있음 { return Err(\"Solidity 정규 인쇄는 이미지 전용 구조만 받습니다\") }\n    let 솔리디티구조 = 구조입력읽기(구조글)?\n    인쇄구조준비(언어번호, 솔리디티구조, true)?\n    return Ok((솔리디티원본인쇄(솔리디티구조)?).encodeUtf8())\n  }\n  if 언어번호 == 28 {\n    if 키있음 { return Err(\"Zig 정규 인쇄는 이미지 전용 구조만 받습니다\") }\n    let 지그구조 = 구조입력읽기(구조글)?\n    인쇄구조준비(언어번호, 지그구조, true)?\n    return Ok((지그원본인쇄(지그구조)?).encodeUtf8())\n  }\n  if 언어번호 == 29 {\n    if 키있음 { return Err(\"Lispex 정규 인쇄는 이미지 전용 구조만 받습니다\") }\n    let 리스펙스구조 = 구조입력읽기(구조글)?\n    인쇄구조준비(언어번호, 리스펙스구조, true)?\n    return Ok((리스펙스원본인쇄(리스펙스구조)?).encodeUtf8())\n  }\n  if 언어번호 == 30 {\n    if 키있음 { return Err(\"Topaz language canonical printing accepts image-only structure\") }\n    let 토파즈언어구조 = 구조입력읽기(구조글)?\n    인쇄구조준비(언어번호, 토파즈언어구조, true)?\n    return Ok((토파즈언어원본인쇄(토파즈언어구조)?).encodeUtf8())\n  }\n  if 언어번호 != 1 && 언어번호 != 2 { return Err(\"인쇄 언어 번호가 틀립니다\") }\n  let 구조 = 구조입력읽기(구조글)?\n  if 구조.노드들.length == 0 { return Err(\"인쇄할 노드가 없습니다\") }\n  let 준비 = 인쇄상태준비(언어번호, 구조, 키바이트, 키있음)?\n  let 뿌리종류 = 노드종류(언어번호, 준비.구조.노드들[0].코드워드)\n  if 뿌리종류 != 101 { return Err(\"투영 뿌리가 파일 노드가 아닙니다\") }\n  let 본문조각 = if 댓글고정있음(준비) {\n    댓글노드인쇄조각(준비, 1, 0)\n  } else { 노드인쇄조각(준비, 1, 0) }\n  let 본문 = ByteBuffer.fromBytes((\n    인쇄조각평평하게(준비.조각판, 본문조각?)?\n  ).encodeUtf8())\n  let 댓글 = ByteBuffer.fromBytes(댓글머리(준비).encodeUtf8())\n  let 합성머리 = ByteBuffer.fromBytes(합성내보내기머리(준비).encodeUtf8())\n  let 댓글사이 = if 댓글.length() == 0 { 0 } else { 1 }\n  let 합성머리사이 = if 합성머리.length() == 0 { 0 } else { 1 }\n  let mut 결과 = ByteBuffer.allocate(댓글.length() + 댓글사이 + 합성머리.length() + 합성머리사이 + 본문.length() + 1)\n  let mut 위치 = 0\n  if 댓글.length() > 0 {\n    결과.copy(댓글, 0, 위치, 댓글.length()); 위치 = 위치 + 댓글.length()\n    결과.set(위치, 10); 위치 = 위치 + 1\n  }\n  if 합성머리.length() > 0 {\n    결과.copy(합성머리, 0, 위치, 합성머리.length()); 위치 = 위치 + 합성머리.length()\n    결과.set(위치, 10); 위치 = 위치 + 1\n  }\n  결과.copy(본문, 0, 위치, 본문.length()); 위치 = 위치 + 본문.length()\n  결과.set(위치, 10)\n  Ok(결과.toBytes())\n}\n\nexport function 투영원본조각바이트인쇄(\n  언어번호: int,\n  구조글: string,\n  키바이트: Bytes,\n  키있음: bool\n) -> Result<Array<Bytes>, string> {\n  if 언어번호 == 3 {\n    if 키있음 { return Err(\"파이썬 정규 인쇄는 이미지 전용 구조만 받습니다\") }\n    let 파이썬구조 = 구조입력읽기(구조글)?\n    인쇄구조준비(언어번호, 파이썬구조, true)?\n    return Ok([(파이썬원본인쇄(파이썬구조)?).encodeUtf8()])\n  }\n  if 언어번호 == 4 {\n    if 키있음 { return Err(\"고 정규 인쇄는 이미지 전용 구조만 받습니다\") }\n    let 고구조 = 구조입력읽기(구조글)?\n    인쇄구조준비(언어번호, 고구조, true)?\n    return Ok([(고원본인쇄(고구조)?).encodeUtf8()])\n  }\n  if 언어번호 == 5 {\n    if 키있음 { return Err(\"러스트 정규 인쇄는 이미지 전용 구조만 받습니다\") }\n    let 러스트구조 = 구조입력읽기(구조글)?\n    인쇄구조준비(언어번호, 러스트구조, true)?\n    return Ok([(러스트원본인쇄(러스트구조)?).encodeUtf8()])\n  }\n  if 언어번호 == 6 {\n    if 키있음 { return Err(\"자바 정규 인쇄는 이미지 전용 구조만 받습니다\") }\n    let 자바구조 = 구조입력읽기(구조글)?\n    인쇄구조준비(언어번호, 자바구조, true)?\n    return Ok([(자바원본인쇄(자바구조)?).encodeUtf8()])\n  }\n  if 언어번호 == 7 {\n    if 키있음 { return Err(\"C 정규 인쇄는 이미지 전용 구조만 받습니다\") }\n    let 씨구조 = 구조입력읽기(구조글)?\n    인쇄구조준비(언어번호, 씨구조, true)?\n    return Ok([(씨원본인쇄(씨구조)?).encodeUtf8()])\n  }\n  if 언어번호 == 8 {\n    if 키있음 { return Err(\"C++ 정규 인쇄는 이미지 전용 구조만 받습니다\") }\n    let 씨플러스플러스구조 = 구조입력읽기(구조글)?\n    인쇄구조준비(언어번호, 씨플러스플러스구조, true)?\n    return Ok([(씨플러스플러스원본인쇄(씨플러스플러스구조)?).encodeUtf8()])\n  }\n  if 언어번호 == 9 {\n    if 키있음 { return Err(\"C# 정규 인쇄는 이미지 전용 구조만 받습니다\") }\n    let 씨샵구조 = 구조입력읽기(구조글)?\n    인쇄구조준비(언어번호, 씨샵구조, true)?\n    return Ok([(씨샵원본인쇄(씨샵구조)?).encodeUtf8()])\n  }\n  if 언어번호 == 10 {\n    if 키있음 { return Err(\"루비 정규 인쇄는 이미지 전용 구조만 받습니다\") }\n    let 루비구조 = 구조입력읽기(구조글)?\n    인쇄구조준비(언어번호, 루비구조, true)?\n    return Ok([(루비원본인쇄(루비구조)?).encodeUtf8()])\n  }\n  if 언어번호 == 11 {\n    if 키있음 { return Err(\"PHP 정규 인쇄는 이미지 전용 구조만 받습니다\") }\n    let 피에이치피구조 = 구조입력읽기(구조글)?\n    인쇄구조준비(언어번호, 피에이치피구조, true)?\n    return Ok([(피에이치피원본인쇄(피에이치피구조)?).encodeUtf8()])\n  }\n  if 언어번호 == 12 {\n    if 키있음 { return Err(\"Swift 정규 인쇄는 이미지 전용 구조만 받습니다\") }\n    let 스위프트구조 = 구조입력읽기(구조글)?\n    인쇄구조준비(언어번호, 스위프트구조, true)?\n    return Ok([(스위프트원본인쇄(스위프트구조)?).encodeUtf8()])\n  }\n  if 언어번호 == 13 {\n    if 키있음 { return Err(\"Kotlin 정규 인쇄는 이미지 전용 구조만 받습니다\") }\n    let 코틀린구조 = 구조입력읽기(구조글)?\n    인쇄구조준비(언어번호, 코틀린구조, true)?\n    return Ok([(코틀린원본인쇄(코틀린구조)?).encodeUtf8()])\n  }\n  if 언어번호 == 14 {\n    if 키있음 { return Err(\"Scala 정규 인쇄는 이미지 전용 구조만 받습니다\") }\n    let 스칼라구조 = 구조입력읽기(구조글)?\n    인쇄구조준비(언어번호, 스칼라구조, true)?\n    return Ok([(스칼라원본인쇄(스칼라구조)?).encodeUtf8()])\n  }\n  if 언어번호 == 15 {\n    if 키있음 { return Err(\"Dart 정규 인쇄는 이미지 전용 구조만 받습니다\") }\n    let 다트구조 = 구조입력읽기(구조글)?\n    인쇄구조준비(언어번호, 다트구조, true)?\n    return Ok([(다트원본인쇄(다트구조)?).encodeUtf8()])\n  }\n  if 언어번호 == 16 {\n    if 키있음 { return Err(\"Elixir 정규 인쇄는 이미지 전용 구조만 받습니다\") }\n    let 엘릭서구조 = 구조입력읽기(구조글)?\n    인쇄구조준비(언어번호, 엘릭서구조, true)?\n    return Ok([(엘릭서원본인쇄(엘릭서구조)?).encodeUtf8()])\n  }\n  if 언어번호 == 17 {\n    if 키있음 { return Err(\"Haskell 정규 인쇄는 이미지 전용 구조만 받습니다\") }\n    let 하스켈구조 = 구조입력읽기(구조글)?\n    인쇄구조준비(언어번호, 하스켈구조, true)?\n    return Ok([(하스켈원본인쇄(하스켈구조)?).encodeUtf8()])\n  }\n  if 언어번호 == 18 {\n    if 키있음 { return Err(\"Lua 정규 인쇄는 이미지 전용 구조만 받습니다\") }\n    let 루아구조 = 구조입력읽기(구조글)?\n    인쇄구조준비(언어번호, 루아구조, true)?\n    return Ok([(루아원본인쇄(루아구조)?).encodeUtf8()])\n  }\n  if 언어번호 == 19 {\n    if 키있음 { return Err(\"R 정규 인쇄는 이미지 전용 구조만 받습니다\") }\n    let 알구조 = 구조입력읽기(구조글)?\n    인쇄구조준비(언어번호, 알구조, true)?\n    return Ok([(알원본인쇄(알구조)?).encodeUtf8()])\n  }\n  if 언어번호 == 21 {\n    if 키있음 { return Err(\"OCaml 정규 인쇄는 이미지 전용 구조만 받습니다\") }\n    let 오캐멀구조 = 구조입력읽기(구조글)?\n    인쇄구조준비(언어번호, 오캐멀구조, true)?\n    return Ok([(오캐멀원본인쇄(오캐멀구조)?).encodeUtf8()])\n  }\n  if 언어번호 == 20 {\n    if 키있음 { return Err(\"Julia 정규 인쇄는 이미지 전용 구조만 받습니다\") }\n    let 줄리아구조 = 구조입력읽기(구조글)?\n    인쇄구조준비(언어번호, 줄리아구조, true)?\n    return Ok([(줄리아원본인쇄(줄리아구조)?).encodeUtf8()])\n  }\n  if 언어번호 == 22 {\n    if 키있음 { return Err(\"Elm 정규 인쇄는 이미지 전용 구조만 받습니다\") }\n    let 엘름구조 = 구조입력읽기(구조글)?\n    인쇄구조준비(언어번호, 엘름구조, true)?\n    return Ok([(엘름원본인쇄(엘름구조)?).encodeUtf8()])\n  }\n  if 언어번호 == 23 {\n    if 키있음 { return Err(\"ReScript 정규 인쇄는 이미지 전용 구조만 받습니다\") }\n    let 리스크립트구조 = 구조입력읽기(구조글)?\n    인쇄구조준비(언어번호, 리스크립트구조, true)?\n    return Ok([(리스크립트원본인쇄(리스크립트구조)?).encodeUtf8()])\n  }\n  if 언어번호 == 24 {\n    if 키있음 { return Err(\"CoffeeScript 정규 인쇄는 이미지 전용 구조만 받습니다\") }\n    let 커피스크립트구조 = 구조입력읽기(구조글)?\n    인쇄구조준비(언어번호, 커피스크립트구조, true)?\n    return Ok([(커피스크립트원본인쇄(커피스크립트구조)?).encodeUtf8()])\n  }\n  if 언어번호 == 25 {\n    if 키있음 { return Err(\"Objective-C 정규 인쇄는 이미지 전용 구조만 받습니다\") }\n    let 오브젝티브씨구조 = 구조입력읽기(구조글)?\n    인쇄구조준비(언어번호, 오브젝티브씨구조, true)?\n    return Ok([(오브젝티브씨원본인쇄(오브젝티브씨구조)?).encodeUtf8()])\n  }\n  if 언어번호 == 26 {\n    if 키있음 { return Err(\"Elisp 정규 인쇄는 이미지 전용 구조만 받습니다\") }\n    let 이맥스리습구조 = 구조입력읽기(구조글)?\n    인쇄구조준비(언어번호, 이맥스리습구조, true)?\n    return Ok([(이맥스리습원본인쇄(이맥스리습구조)?).encodeUtf8()])\n  }\n  if 언어번호 == 27 {\n    if 키있음 { return Err(\"Solidity 정규 인쇄는 이미지 전용 구조만 받습니다\") }\n    let 솔리디티구조 = 구조입력읽기(구조글)?\n    인쇄구조준비(언어번호, 솔리디티구조, true)?\n    return Ok([(솔리디티원본인쇄(솔리디티구조)?).encodeUtf8()])\n  }\n  if 언어번호 == 28 {\n    if 키있음 { return Err(\"Zig 정규 인쇄는 이미지 전용 구조만 받습니다\") }\n    let 지그구조 = 구조입력읽기(구조글)?\n    인쇄구조준비(언어번호, 지그구조, true)?\n    return Ok([(지그원본인쇄(지그구조)?).encodeUtf8()])\n  }\n  if 언어번호 == 29 {\n    if 키있음 { return Err(\"Lispex 정규 인쇄는 이미지 전용 구조만 받습니다\") }\n    let 리스펙스구조 = 구조입력읽기(구조글)?\n    인쇄구조준비(언어번호, 리스펙스구조, true)?\n    return Ok([(리스펙스원본인쇄(리스펙스구조)?).encodeUtf8()])\n  }\n  if 언어번호 == 30 {\n    if 키있음 { return Err(\"Topaz language canonical printing accepts image-only structure\") }\n    let 토파즈언어구조 = 구조입력읽기(구조글)?\n    인쇄구조준비(언어번호, 토파즈언어구조, true)?\n    return Ok([(토파즈언어원본인쇄(토파즈언어구조)?).encodeUtf8()])\n  }\n  if 언어번호 != 1 && 언어번호 != 2 { return Err(\"인쇄 언어 번호가 틀립니다\") }\n  let 구조 = 구조입력읽기(구조글)?\n  if 구조.노드들.length == 0 { return Err(\"인쇄할 노드가 없습니다\") }\n  let mut 준비 = 인쇄상태준비(언어번호, 구조, 키바이트, 키있음)?\n  let 뿌리종류 = 노드종류(언어번호, 준비.구조.노드들[0].코드워드)\n  if 뿌리종류 != 101 { return Err(\"투영 뿌리가 파일 노드가 아닙니다\") }\n  let mut 결과: Array<Bytes> = []\n  let 댓글 = 댓글머리(준비)\n  if 댓글 != \"\" { 결과.push((댓글 + \"\\n\").encodeUtf8()) }\n  let 합성머리 = 합성내보내기머리(준비)\n  if 합성머리 != \"\" { 결과.push((합성머리 + \"\\n\").encodeUtf8()) }\n  let 프로그램순번 = 자식순번(준비, 0, \"program\")\n  if 준비.오프셋배치 {\n    let 지시들 = 자식순번들(준비, 프로그램순번, \"directives\")\n    let 본문들 = 자식순번들(준비, 프로그램순번, \"body\")\n    let mut 색인 = 0\n    let mut 이전부족행 = 0\n    while 색인 < 지시들.length {\n      let 접두 = 문장접두(준비, 지시들, 색인, 이전부족행)\n      let 조각 = 순번인쇄조각(준비, 지시들[색인], 0)?\n      let 글 = 인쇄조각평평하게(준비.조각판, 조각)?\n      이전부족행 = 문장부족행(준비, 지시들[색인], 조각)\n      let 꼬리 = if 색인 + 1 == 지시들.length && 본문들.length == 0 { \"\\n\" } else { \"\" }\n      결과.push((접두 + 글 + 꼬리).encodeUtf8())\n      준비 = 인쇄상태조각판새로(준비)\n      색인 = 색인 + 1\n    }\n    색인 = 0\n    while 색인 < 본문들.length {\n      let 접두 = 문장접두(준비, 본문들, 색인, 이전부족행)\n      let 조각 = 순번인쇄조각(준비, 본문들[색인], 0)?\n      let 글 = 인쇄조각평평하게(준비.조각판, 조각)?\n      이전부족행 = 문장부족행(준비, 본문들[색인], 조각)\n      let 꼬리 = if 색인 + 1 == 본문들.length { \"\\n\" } else { \"\" }\n      결과.push((접두 + 글 + 꼬리).encodeUtf8())\n      준비 = 인쇄상태조각판새로(준비)\n      색인 = 색인 + 1\n    }\n    if 지시들.length == 0 && 본문들.length == 0 {\n      결과.push(\"\\n\".encodeUtf8())\n    }\n    return Ok(결과)\n  }\n  let 지시들 = 자식순번들(준비, 프로그램순번, \"directives\")\n  let 본문들 = 자식순번들(준비, 프로그램순번, \"body\")\n  let mut 색인 = 0\n  while 색인 < 지시들.length {\n    let 조각 = 순번인쇄조각(준비, 지시들[색인], 0)?\n    let 글 = 인쇄조각평평하게(준비.조각판, 조각)?\n    let 꼬리 = if 색인 + 1 < 지시들.length { \"\\n\" }\n      else if 본문들.length > 0 { \"\\n\\n\" }\n      else { \"\\n\" }\n    결과.push((글 + 꼬리).encodeUtf8())\n    준비 = 인쇄상태조각판새로(준비)\n    색인 = 색인 + 1\n  }\n  색인 = 0\n  while 색인 < 본문들.length {\n    let 조각 = 순번인쇄조각(준비, 본문들[색인], 0)?\n    let 글 = 인쇄조각평평하게(준비.조각판, 조각)?\n    결과.push((글 + \"\\n\").encodeUtf8())\n    준비 = 인쇄상태조각판새로(준비)\n    색인 = 색인 + 1\n  }\n  if 지시들.length == 0 && 본문들.length == 0 {\n    결과.push(\"\\n\".encodeUtf8())\n  }\n  Ok(결과)\n}\n\nexport function 투영노드깊이바이트인쇄(언어번호: int, 구조글: string, 키바이트: Bytes, 키있음: bool, 순번: int, 깊이: int) -> Result<Bytes, string> {\n  let 구조 = 구조입력읽기(구조글)?\n  let 준비 = 인쇄상태준비(언어번호, 구조, 키바이트, 키있음)?\n  match 인쇄조각평평하게(준비.조각판, 순번인쇄조각(준비, 순번, 깊이)?) {\n    case Ok(글) => Ok(글.encodeUtf8())\n    case Err(오류) => Err(오류)\n  }\n}\n\nexport record 노드묶음요청 {\n  순번: int,\n  깊이: int\n}\n\nexport function 투영노드묶음인쇄(\n  언어번호: int,\n  구조글: string,\n  키바이트: Bytes,\n  키있음: bool,\n  묶음글: string\n) -> Result<string, string> {\n  let 구조 = 구조입력읽기(구조글)?\n  let 준비 = 인쇄상태준비(언어번호, 구조, 키바이트, 키있음)?\n  let 요청들 = json.parseAs<Array<노드묶음요청>>(묶음글)?\n  let mut 결과들: Array<string> = []\n  for 요청 in 요청들 {\n    결과들.push(인쇄조각평평하게(\n      준비.조각판,\n      순번인쇄조각(준비, 요청.순번, 요청.깊이)?\n    )?)\n  }\n  json.stringify(결과들)\n}\n",
      "sourceSha256": "7a07e3e9f657336375ff3645ab037034eda8a1acfc75b4a8f43bbed2553837a8"
    },
    {
      "path": "topaz/src/render.tpz",
      "language": "topaz",
      "bytes": 11737,
      "sha256": "f3baf43a32892a1049163fa204b689cca1d1c1134b2fe35630c3c1205dd62a48",
      "content": "// Raster primitives under image_raster.tpz: the page header record, glyph and box\n// tests, fixed-Huffman deflate, and PNG chunks.\n\nimport std.bytes { Bytes }\nimport plan { 보호길이, 프로필해시, 픽셀글꼴 }\nimport util { 거듭제곱이, 문자열배열에있음, 작은값, 큰값 }\n\nexport record 이미지머리 {\n  버전: int,\n  언어번호: int,\n  팔레트번호: int,\n  너비: int,\n  높이: int,\n  판행수: int,\n  띠위: int,\n  띠행수: int,\n  노드수: int,\n  보호길이: int,\n  논리길이: int,\n  패리티길이: int,\n  프로필해시: string,\n  키해시: string,\n  구조해시앞: string,\n  쪽번호: int,\n  쪽수: int,\n  노드시작: int,\n  크롬번호: int,\n  제목: string,\n  원본줄수: int,\n  세트해시: string\n}\n\nexport record 비트기록 { 출력: ByteBuffer, 출력길이: int, 값: int, 수: int }\nexport record 일치 { 길이: int, 거리: int }\nexport record 비트읽기 { 값: int, 다음: int }\nexport record 부풀림 { 잡은바이트: Array<int>, 출력길이: int }\nexport record 원시쪽 { 머리: 이미지머리, 머리바이트: Array<int>, 띠바이트: Array<int> }\n\nexport function 이역할변형(필드: string) -> int {\n  if 문자열배열에있음([\"exported\", \"exprName\", \"id\", \"imported\", \"key\", \"label\", \"local\", \"meta\", \"name\", \"namespace\"], 필드) { return 0 }\n  if 문자열배열에있음([\"param\", \"parameter\", \"parameterName\", \"parameters\", \"params\", \"rest\"], 필드) { return 1 }\n  if 문자열배열에있음([\"argument\", \"arguments\", \"callee\", \"object\", \"property\", \"qualification\", \"qualifier\", \"quasi\", \"quasis\", \"tag\"], 필드) { return 2 }\n  if 문자열배열에있음([\"alternate\", \"cases\", \"consequent\", \"default\", \"discriminant\", \"finalizer\", \"handler\", \"test\"], 필드) { return 3 }\n  if 문자열배열에있음([\"block\", \"body\", \"children\", \"closingElement\", \"closingFragment\", \"openingElement\", \"openingFragment\", \"program\"], 필드) { return 4 }\n  if 문자열배열에있음([\"expression\", \"expressions\", \"init\", \"initializer\", \"left\", \"literal\", \"right\", \"source\", \"update\", \"value\"], 필드) { return 5 }\n  if 문자열배열에있음([\"assertions\", \"attributes\", \"declaration\", \"declarations\", \"decorators\", \"directives\", \"elements\", \"members\", \"options\", \"properties\", \"specifiers\"], 필드) { return 6 }\n  if 문자열배열에있음([\"bound\", \"callProperties\", \"checkType\", \"constraint\", \"elementType\", \"elementTypes\", \"extends\", \"extendsType\", \"falseType\", \"implements\", \"impltype\", \"indexers\", \"indexType\", \"internalSlots\", \"mixins\", \"moduleReference\", \"nameType\", \"objectType\", \"predicate\", \"returnType\", \"superClass\", \"supertype\", \"superTypeParameters\", \"this\", \"trueType\", \"typeAnnotation\", \"typeArguments\", \"typeName\", \"typeParameter\", \"typeParameters\", \"types\", \"variance\"], 필드) { return 7 }\n  8\n}\n\nexport function 사각안(가로: int, 세로: int, 왼쪽: int, 위: int, 너비: int, 높이: int) -> bool {\n  가로 >= 왼쪽 && 가로 < 왼쪽 + 너비 && 세로 >= 위 && 세로 < 위 + 높이\n}\n\nexport function 글자그림(글: string, 왼쪽: int, 위: int, 배율: int, 가로: int, 세로: int) -> bool {\n  if 세로 < 위 || 세로 >= 위 + 5 * 배율 || 가로 < 왼쪽 { return false }\n  let 글자들 = 글.scalars()\n  let 상대가로 = 가로 - 왼쪽\n  let 글자폭 = 4 * 배율\n  let 글자색인 = 상대가로 / 글자폭\n  if 글자색인 >= 글자들.length { return false }\n  let 글자안가로 = 상대가로 % 글자폭\n  if 글자안가로 >= 3 * 배율 { return false }\n  let 열 = 글자안가로 / 배율\n  let 행 = (세로 - 위) / 배율\n  픽셀글꼴(글자들[글자색인]).scalars()[행 * 3 + 열] == \"1\"\n}\n\nfunction 비트뒤집기(값: int, 수: int) -> int {\n  let mut 원본 = 값\n  let mut 결과 = 0\n  let mut 색인 = 0\n  while 색인 < 수 { 결과 = 결과 * 2 + 원본 % 2; 원본 = 원본 / 2; 색인 = 색인 + 1 }\n  결과\n}\n\nfunction 고정기호비트(기호: int) -> int {\n  if 기호 <= 143 { return 비트뒤집기(48 + 기호, 8) }\n  if 기호 <= 255 { return 비트뒤집기(400 + 기호 - 144, 9) }\n  if 기호 <= 279 { return 비트뒤집기(기호 - 256, 7) }\n  비트뒤집기(192 + 기호 - 280, 8)\n}\n\nfunction 고정기호길이(기호: int) -> int {\n  if 기호 <= 143 { return 8 }\n  if 기호 <= 255 { return 9 }\n  if 기호 <= 279 { return 7 }\n  8\n}\n\nfunction 비트쓰기(기록: 비트기록, 값: int, 수: int) -> 비트기록 {\n  let mut 출력 = 기록.출력\n  let mut 출력길이 = 기록.출력길이\n  let mut 대기값 = 기록.값 + 값 * 거듭제곱이(기록.수)\n  let mut 대기수 = 기록.수 + 수\n  while 대기수 >= 8 {\n    출력.set(출력길이, 대기값 % 256); 출력길이 = 출력길이 + 1\n    대기값 = 대기값 / 256; 대기수 = 대기수 - 8\n  }\n  비트기록 { 출력: 출력, 출력길이: 출력길이, 값: 대기값, 수: 대기수 }\n}\n\nfunction 고정기호쓰기(기록: 비트기록, 기호: int) -> 비트기록 {\n  비트쓰기(기록, 고정기호비트(기호), 고정기호길이(기호))\n}\n\nfunction 길이밑들() -> Array<int> { [3,4,5,6,7,8,9,10,11,13,15,17,19,23,27,31,35,43,51,59,67,83,99,115,131,163,195,227,258] }\nfunction 길이더비트들() -> Array<int> { [0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0] }\nfunction 거리밑들() -> Array<int> { [1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193,257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577] }\nfunction 거리더비트들() -> Array<int> { [0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13] }\n\nfunction 밑색인(밑들: Array<int>, 값: int) -> int {\n  let mut 색인 = 밑들.length - 1\n  while 색인 >= 0 { if 값 >= 밑들[색인] { return 색인 }; 색인 = 색인 - 1 }\n  -1\n}\n\nfunction 일치비트수(길이: int, 거리: int) -> int {\n  let 길이색인 = 밑색인(길이밑들(), 길이)\n  let 거리색인 = 밑색인(거리밑들(), 거리)\n  고정기호길이(257 + 길이색인) + 길이더비트들()[길이색인] + 5 + 거리더비트들()[거리색인]\n}\n\nfunction 글자비트수(입력: ByteBuffer, 위치: int, 길이: int) -> int {\n  let mut 비트 = 0\n  let mut 색인 = 위치\n  while 색인 < 위치 + 길이 { 비트 = 비트 + if 입력.get(색인) <= 143 { 8 } else { 9 }; 색인 = 색인 + 1 }\n  비트\n}\n\nfunction 위치넣기(입력: ByteBuffer, 위치: int, 전체길이: int, 해시머리: ByteBuffer, 이전위치: ByteBuffer, 자리위치: ByteBuffer) -> bool {\n  if 위치 + 3 > 전체길이 { return false }\n  let 값 = 입력.get(위치) * 65536 + 입력.get(위치 + 1) * 256 + 입력.get(위치 + 2)\n  let 해시 = ((값 * 506832829) % 4294967296) / 65536\n  let 자리 = 위치 % 32768\n  let 해시자리 = 해시 * 4\n  let 이전 = 해시머리.get(해시자리) * 16777216 + 해시머리.get(해시자리 + 1) * 65536 +\n    해시머리.get(해시자리 + 2) * 256 + 해시머리.get(해시자리 + 3)\n  let 자리바이트 = 자리 * 4\n  let mut 이전출력 = 이전위치\n  이전출력.set(자리바이트, (이전 / 16777216) % 256); 이전출력.set(자리바이트 + 1, (이전 / 65536) % 256)\n  이전출력.set(자리바이트 + 2, (이전 / 256) % 256); 이전출력.set(자리바이트 + 3, 이전 % 256)\n  let 저장 = 위치 + 1\n  let mut 자리출력 = 자리위치\n  자리출력.set(자리바이트, (저장 / 16777216) % 256); 자리출력.set(자리바이트 + 1, (저장 / 65536) % 256)\n  자리출력.set(자리바이트 + 2, (저장 / 256) % 256); 자리출력.set(자리바이트 + 3, 저장 % 256)\n  let mut 머리출력 = 해시머리\n  머리출력.set(해시자리, (저장 / 16777216) % 256); 머리출력.set(해시자리 + 1, (저장 / 65536) % 256)\n  머리출력.set(해시자리 + 2, (저장 / 256) % 256); 머리출력.set(해시자리 + 3, 저장 % 256)\n  true\n}\n\nfunction 일치찾기(입력: ByteBuffer, 위치: int, 전체길이: int, 해시머리: ByteBuffer, 이전위치: ByteBuffer, 자리위치: ByteBuffer) -> 일치 {\n  if 위치 + 3 > 전체길이 { return 일치 { 길이: 0, 거리: 0 } }\n  let 값 = 입력.get(위치) * 65536 + 입력.get(위치 + 1) * 256 + 입력.get(위치 + 2)\n  let 해시 = ((값 * 506832829) % 4294967296) / 65536\n  let 최소위치 = 큰값(0, 위치 - 32768)\n  let 최대길이 = 작은값(258, 전체길이 - 위치)\n  let 해시자리 = 해시 * 4\n  let mut 후보 = 해시머리.get(해시자리) * 16777216 + 해시머리.get(해시자리 + 1) * 65536 +\n    해시머리.get(해시자리 + 2) * 256 + 해시머리.get(해시자리 + 3) - 1\n  let mut 찾은수 = 0\n  let mut 가장길이 = 0\n  let mut 가장거리 = 0\n  while 후보 >= 최소위치 && 후보 >= 0 && 찾은수 < 128 {\n    let 자리 = 후보 % 32768\n    let 자리바이트 = 자리 * 4\n    let 자리값 = 자리위치.get(자리바이트) * 16777216 + 자리위치.get(자리바이트 + 1) * 65536 +\n      자리위치.get(자리바이트 + 2) * 256 + 자리위치.get(자리바이트 + 3) - 1\n    if 자리값 != 후보 { 후보 = -1 }\n    else {\n      if 가장길이 == 0 || 가장길이 == 최대길이 || 입력.get(후보 + 가장길이) == 입력.get(위치 + 가장길이) {\n        let mut 길이 = 0\n        while 길이 < 최대길이 && 입력.get(후보 + 길이) == 입력.get(위치 + 길이) { 길이 = 길이 + 1 }\n        if 길이 > 가장길이 {\n          가장길이 = 길이; 가장거리 = 위치 - 후보\n          if 가장길이 == 최대길이 { 후보 = -1 }\n        }\n      }\n      if 후보 >= 0 {\n        후보 = 이전위치.get(자리바이트) * 16777216 + 이전위치.get(자리바이트 + 1) * 65536 +\n          이전위치.get(자리바이트 + 2) * 256 + 이전위치.get(자리바이트 + 3) - 1\n        찾은수 = 찾은수 + 1\n      }\n    }\n  }\n  if 가장길이 < 3 || 일치비트수(가장길이, 가장거리) >= 글자비트수(입력, 위치, 가장길이) { return 일치 { 길이: 0, 거리: 0 } }\n  일치 { 길이: 가장길이, 거리: 가장거리 }\n}\n\nfunction 고정일치쓰기(기록: 비트기록, 길이: int, 거리: int) -> 비트기록 {\n  let 길이밑 = 길이밑들(); let 길이더 = 길이더비트들()\n  let 거리밑 = 거리밑들(); let 거리더 = 거리더비트들()\n  let 길이색인 = 밑색인(길이밑, 길이)\n  let mut 결과 = 고정기호쓰기(기록, 257 + 길이색인)\n  if 길이더[길이색인] > 0 { 결과 = 비트쓰기(결과, 길이 - 길이밑[길이색인], 길이더[길이색인]) }\n  let 거리색인 = 밑색인(거리밑, 거리)\n  결과 = 비트쓰기(결과, 비트뒤집기(거리색인, 5), 5)\n  if 거리더[거리색인] > 0 { 결과 = 비트쓰기(결과, 거리 - 거리밑[거리색인], 거리더[거리색인]) }\n  결과\n}\n\nexport function 청크만들기(종류바이트: Bytes, 자료바이트: Bytes) -> Bytes {\n  let 종류 = ByteBuffer.fromBytes(종류바이트)\n  let 자료 = ByteBuffer.fromBytes(자료바이트)\n  let 자료길이 = 자료.length()\n  let mut 결과 = ByteBuffer.allocate(12 + 자료길이)\n  결과.set(0, (자료길이 / 16777216) % 256); 결과.set(1, (자료길이 / 65536) % 256)\n  결과.set(2, (자료길이 / 256) % 256); 결과.set(3, 자료길이 % 256)\n  결과.copy(종류, 0, 4, 종류.length()); 결과.copy(자료, 0, 8, 자료길이)\n  let mut 검사입력 = ByteBuffer.allocate(종류.length() + 자료길이)\n  검사입력.copy(종류, 0, 0, 종류.length()); 검사입력.copy(자료, 0, 종류.length(), 자료길이)\n  let 검사합 = 검사입력.toBytes().crc32()\n  let 위치 = 8 + 자료길이\n  결과.set(위치, (검사합 / 16777216) % 256); 결과.set(위치 + 1, (검사합 / 65536) % 256)\n  결과.set(위치 + 2, (검사합 / 256) % 256); 결과.set(위치 + 3, 검사합 % 256)\n  결과.toBytes()\n}\n",
      "sourceSha256": "f3baf43a32892a1049163fa204b689cca1d1c1134b2fe35630c3c1205dd62a48"
    },
    {
      "path": "topaz/src/schema.tpz",
      "language": "topaz",
      "bytes": 4061,
      "sha256": "c57e53e85cce51ae7e17d0a12f32afef7a3bb192e6f518f312d4be9080b30bc6",
      "content": "// Per-language comment and atomic-body codeword predicates, and indentation text.\n\nexport function 들여쓰기(깊이: int) -> string {\n  let mut 글 = \"\"; let mut 색인 = 0\n  while 색인 < 깊이 { 글 = 글 + \"  \"; 색인 = 색인 + 1 }\n  글\n}\n\nexport function 러스트댓글코드(코드워드: int) -> bool {\n  코드워드 == 70 || 코드워드 == 406\n}\n\nexport function 러스트원자본문코드(코드워드: int) -> bool {\n  러스트댓글코드(코드워드) || 코드워드 == 338 ||\n    코드워드 == 454 || 코드워드 == 479\n}\n\nexport function 자바댓글코드(코드워드: int) -> bool {\n  코드워드 == 201 || 코드워드 == 290\n}\n\nexport function 자바원자본문코드(코드워드: int) -> bool {\n  자바댓글코드(코드워드) || 코드워드 == 104 || 코드워드 == 278\n}\n\nexport function 씨댓글코드(코드워드: int) -> bool {\n  코드워드 == 99\n}\n\nexport function 씨플러스플러스댓글코드(코드워드: int) -> bool {\n  코드워드 == 3\n}\n\nexport function 씨샵댓글코드(코드워드: int) -> bool {\n  코드워드 == 100\n}\n\nexport function 씨샵원자본문코드(코드워드: int) -> bool {\n  씨샵댓글코드(코드워드) || 코드워드 == 65 || 코드워드 == 62 ||\n    코드워드 == 368 || 코드워드 == 192 || 코드워드 == 73\n}\n\nexport function 루비댓글코드(코드워드: int) -> bool {\n  코드워드 == 318\n}\n\nexport function 피에이치피댓글코드(코드워드: int) -> bool {\n  코드워드 == 239\n}\n\nexport function 스위프트댓글코드(코드워드: int) -> bool {\n  코드워드 == 488 || 코드워드 == 59\n}\n\nexport function 코틀린댓글코드(코드워드: int) -> bool {\n  코드워드 == 385 || 코드워드 == 340\n}\n\nexport function 코틀린원자본문코드(코드워드: int) -> bool {\n  코틀린댓글코드(코드워드) ||\n    코드워드 == 267 || 코드워드 == 177 || 코드워드 == 424\n}\n\nexport function 스칼라댓글코드(코드워드: int) -> bool {\n  코드워드 == 391 || 코드워드 == 365\n}\n\nexport function 스칼라원자본문코드(코드워드: int) -> bool {\n  스칼라댓글코드(코드워드) ||\n    코드워드 == 66 || 코드워드 == 72 || 코드워드 == 398\n}\n\nexport function 다트댓글코드(코드워드: int) -> bool {\n  코드워드 == 19 || 코드워드 == 195\n}\n\nexport function 다트원자본문코드(코드워드: int) -> bool {\n  다트댓글코드(코드워드) || 코드워드 == 355\n}\n\nexport function 엘릭서댓글코드(코드워드: int) -> bool {\n  코드워드 == 485\n}\n\nexport function 엘릭서원자본문코드(코드워드: int) -> bool {\n  엘릭서댓글코드(코드워드)\n}\n\nexport function 하스켈댓글코드(코드워드: int) -> bool {\n  코드워드 == 187 || 코드워드 == 225\n}\n\nexport function 하스켈원자본문코드(코드워드: int) -> bool {\n  하스켈댓글코드(코드워드)\n}\n\nexport function 루아댓글코드(코드워드: int) -> bool {\n  코드워드 == 261\n}\n\nexport function 루아원자본문코드(코드워드: int) -> bool {\n  루아댓글코드(코드워드)\n}\n\nexport function 알댓글코드(코드워드: int) -> bool {\n  코드워드 == 53\n}\n\nexport function 알원자본문코드(코드워드: int) -> bool {\n  코드워드 == 228 || 코드워드 == 307\n}\n\nexport function 오캐멀댓글코드(코드워드: int) -> bool {\n  코드워드 == 436\n}\n\nexport function 오캐멀원자본문코드(코드워드: int) -> bool {\n  코드워드 == 260 || 코드워드 == 396 || 코드워드 == 400\n}\n\nexport function 줄리아댓글코드(코드워드: int) -> bool {\n  코드워드 == 157 || 코드워드 == 182\n}\n\nexport function 줄리아원자본문코드(코드워드: int) -> bool {\n  코드워드 == 298 || 코드워드 == 348 || 코드워드 == 376 ||\n    코드워드 == 423 || 코드워드 == 462\n}\n\nexport function 엘름댓글코드(코드워드: int) -> bool {\n  코드워드 == 44 || 코드워드 == 56\n}\n\nexport function 엘름원자본문코드(코드워드: int) -> bool {\n  엘름댓글코드(코드워드)\n}\n",
      "sourceSha256": "c57e53e85cce51ae7e17d0a12f32afef7a3bb192e6f518f312d4be9080b30bc6"
    },
    {
      "path": "topaz/src/structure.tpz",
      "language": "topaz",
      "bytes": 24062,
      "sha256": "061425cc359393de90b973775c94d2a7fc2b25999b2614916a44cb26dd55474c",
      "content": "// Canonical structure records, their JSON readers and scalar accessors, and\n// structure validation with canonical wire encoding and decoding.\n\nimport std.bytes { Bytes }\nimport std.json\nimport hash { 해시배열 }\nimport nodes { 노드종류 }\nimport util { 바이트로, 바이트배열로, 바이트추가, 배열같음, 부분배열 }\nimport wire {\n  가변정수쓰기,\n  가변정수읽기,\n  널문자있음,\n  사전색인,\n  사전쓰기,\n  사전읽기,\n  사전해석,\n  삼십이쓰기,\n  삼십이읽기,\n  안전문자열코드단위키,\n  정렬고유,\n  정수읽기,\n  짝없는대리자있음,\n  코드단위문자열,\n  코드단위문자열만들기,\n  코드단위사전쓰기,\n  코드단위사전읽기,\n  코드단위사전해석,\n  코드단위키읽기,\n}\n\nexport record 구조스칼라 {\n  필드: string,\n  태그: int,\n  정수값: int,\n  문자열값: string\n}\n\nexport record 구조노드 {\n  코드워드: int,\n  부모순번: int,\n  자식필드있음: bool,\n  자식필드: string,\n  자식색인: int,\n  시작: int,\n  끝: int,\n  스칼라들: Array<구조스칼라>,\n  식별자있음: bool,\n  식별자류번호: int\n}\n\nexport record 구조입력 {\n  분리본문키해시: string,\n  분리본문값수: int,\n  노드들: Array<구조노드>\n}\n\nexport record 이미지요청 {\n  언어번호: int,\n  팔레트번호: int,\n  프로필해시: string,\n  구조해시: string,\n  키해시: string,\n  크롬번호: int,\n  제목: string,\n  원본줄수: int,\n  구조: 구조입력\n}\n\n// JSON readers. A record is read from JSON in the module that declares it, so\n// the image request, which embeds a structure, is declared here as well.\nexport function 구조입력읽기(글: string) -> Result<구조입력, string> {\n  json.parseAs<구조입력>(글)\n}\n\nexport function 이미지요청읽기(글: string) -> Result<이미지요청, string> {\n  json.parseAs<이미지요청>(글)\n}\n\nexport function 구조언어번호(구조: 구조입력) -> int {\n  if 구조.노드들.length == 0 { return 0 }\n  let 뿌리코드 = 구조.노드들[0].코드워드\n  if 노드종류(1, 뿌리코드) == 101 { return 1 }\n  if 노드종류(2, 뿌리코드) == 101 { return 2 }\n  if 노드종류(3, 뿌리코드) == 101 { return 3 }\n  if 노드종류(4, 뿌리코드) == 101 { return 4 }\n  if 노드종류(5, 뿌리코드) == 101 { return 5 }\n  if 노드종류(6, 뿌리코드) == 101 { return 6 }\n  if 노드종류(7, 뿌리코드) == 101 { return 7 }\n  if 노드종류(8, 뿌리코드) == 101 { return 8 }\n  if 노드종류(9, 뿌리코드) == 101 { return 9 }\n  if 노드종류(10, 뿌리코드) == 101 { return 10 }\n  if 노드종류(11, 뿌리코드) == 101 { return 11 }\n  if 노드종류(12, 뿌리코드) == 101 { return 12 }\n  if 노드종류(13, 뿌리코드) == 101 { return 13 }\n  if 노드종류(14, 뿌리코드) == 101 { return 14 }\n  if 노드종류(15, 뿌리코드) == 101 { return 15 }\n  if 노드종류(16, 뿌리코드) == 101 { return 16 }\n  if 노드종류(17, 뿌리코드) == 101 { return 17 }\n  if 노드종류(18, 뿌리코드) == 101 { return 18 }\n  if 노드종류(19, 뿌리코드) == 101 { return 19 }\n  if 노드종류(21, 뿌리코드) == 101 { return 21 }\n  if 노드종류(20, 뿌리코드) == 101 { return 20 }\n  if 노드종류(22, 뿌리코드) == 101 { return 22 }\n  if 노드종류(23, 뿌리코드) == 101 { return 23 }\n  if 노드종류(24, 뿌리코드) == 101 { return 24 }\n  if 노드종류(25, 뿌리코드) == 101 { return 25 }\n  if 노드종류(26, 뿌리코드) == 101 { return 26 }\n  if 노드종류(27, 뿌리코드) == 101 { return 27 }\n  if 노드종류(28, 뿌리코드) == 101 { return 28 }\n  if 노드종류(29, 뿌리코드) == 101 { return 29 }\n  if 노드종류(30, 뿌리코드) == 101 { return 30 }\n  0\n}\n\nfunction 코드단위태그허용(언어번호: int, 노드: 구조노드, 스칼라: 구조스칼라) -> bool {\n  if 언어번호 != 1 && 언어번호 != 2 { return false }\n  let 종류 = 노드종류(언어번호, 노드.코드워드)\n  (종류 == 108 && 스칼라.필드 == \"value\") ||\n    (종류 == 116 && 스칼라.필드 == \"value.cooked\")\n}\n\nfunction 구조스칼라검사(언어번호: int, 노드: 구조노드, 스칼라: 구조스칼라) -> Result<bool, string> {\n  if 스칼라.필드 == \"\" || 널문자있음(스칼라.필드) {\n    return Err(\"구조 스칼라 필드가 비었거나 영 문자를 포함합니다\")\n  }\n  if 스칼라.필드 == \"trailingFileLayout\" {\n    if 언어번호 != 12 || 노드.부모순번 != -1 || 노드.코드워드 != 36 ||\n      스칼라.태그 != 5 || 스칼라.문자열값 == \"\" || 스칼라.문자열값.scalars().length > 4194304 {\n      return Err(\"Swift 파일 끝 배치가 정규형이 아닙니다\")\n    }\n    for 글자 in 스칼라.문자열값.scalars() {\n      let 코드 = 글자.codePointAt(0) ?? 0\n      if 코드 != 32 && !(코드 >= 9 && 코드 <= 13) {\n        return Err(\"Swift 파일 끝 배치에 비배치 문자가 있습니다\")\n      }\n    }\n  }\n  if 스칼라.태그 >= 0 && 스칼라.태그 <= 2 {\n    if 스칼라.정수값 != 0 || 스칼라.문자열값 != \"\" {\n      return Err(\"논리 구조 스칼라의 빈 본문이 정규형이 아닙니다\")\n    }\n    return Ok(true)\n  }\n  if 스칼라.태그 == 3 {\n    if 스칼라.정수값 < 0 || 스칼라.정수값 > 9007199254740991 || 스칼라.문자열값 != \"\" {\n      return Err(\"양의 구조 스칼라가 안전 정수 정규형이 아닙니다\")\n    }\n    return Ok(true)\n  }\n  if 스칼라.태그 == 4 {\n    if 스칼라.정수값 < 1 || 스칼라.정수값 > 9007199254740991 || 스칼라.문자열값 != \"\" {\n      return Err(\"음의 구조 스칼라가 안전 정수 정규형이 아닙니다\")\n    }\n    return Ok(true)\n  }\n  if 스칼라.태그 == 5 {\n    if 스칼라.정수값 != 0 { return Err(\"문자열 구조 스칼라 정수 본문이 0이 아닙니다\") }\n    return Ok(true)\n  }\n  if 스칼라.태그 == 6 {\n    if 스칼라.정수값 != 0 { return Err(\"UTF-16 호스트 스칼라 정수 본문이 0이 아닙니다\") }\n    let 단위들 = 코드단위키읽기(스칼라.문자열값, false)?\n    if !짝없는대리자있음(단위들) {\n      return Err(\"UTF-16 호스트 스칼라에 짝없는 대리자가 없습니다\")\n    }\n    if !코드단위태그허용(언어번호, 노드, 스칼라) {\n      return Err(\"UTF-16 호스트 스칼라가 허용되지 않은 구조 위치에 있습니다\")\n    }\n    return Ok(true)\n  }\n  Err(\"지원하지 않는 구조 스칼라 태그입니다\")\n}\n\nexport function 구조입력검사(언어번호: int, 구조: 구조입력) -> Result<bool, string> {\n  for 노드 in 구조.노드들 {\n    let mut 첫필드 = true\n    let mut 이전필드 = \"\"\n    for 스칼라 in 노드.스칼라들 {\n      if !첫필드 && 이전필드 >= 스칼라.필드 { return Err(\"구조 스칼라 필드가 정규 순서가 아닙니다\") }\n      구조스칼라검사(언어번호, 노드, 스칼라)?\n      이전필드 = 스칼라.필드\n      첫필드 = false\n    }\n  }\n  Ok(true)\n}\n\nfunction 구조스칼라코드단위문자열(스칼라: 구조스칼라) -> Result<코드단위문자열, string> {\n  if 스칼라.태그 == 5 {\n    let 키 = 안전문자열코드단위키(스칼라.문자열값)\n    return Ok(코드단위문자열 { 키: 키, 안전값: 스칼라.문자열값, 안전: true })\n  }\n  if 스칼라.태그 == 6 { return 코드단위문자열만들기(스칼라.문자열값) }\n  Err(\"문자열이 아닌 구조 스칼라입니다\")\n}\n\nexport record 압축원본행 {\n  행: int,\n  시작: int\n}\n\nfunction 원본기하필드인가(필드: string) -> bool {\n  필드 == \"startRow\" || 필드 == \"startColumn\" ||\n    필드 == \"endRow\" || 필드 == \"endColumn\"\n}\n\nfunction 압축원본행들(구조: 구조입력) -> Result<Array<압축원본행>, string> {\n  let mut 행들: Array<압축원본행> = []\n  for 노드 in 구조.노드들 {\n    let mut 모서리 = 0\n    while 모서리 < 2 {\n      let 행필드 = if 모서리 == 0 { \"startRow\" } else { \"endRow\" }\n      let 열필드 = if 모서리 == 0 { \"startColumn\" } else { \"endColumn\" }\n      let 오프셋 = if 모서리 == 0 { 노드.시작 } else { 노드.끝 }\n      let 행스칼라 = 노드스칼라(노드, 행필드)\n      let 열스칼라 = 노드스칼라(노드, 열필드)\n      if 행스칼라.태그 != 3 || 열스칼라.태그 != 3 ||\n        행스칼라.정수값 < 0 || 열스칼라.정수값 < 0 || 열스칼라.정수값 > 오프셋 {\n        return Err(\"JS/TS 원본 행 기하가 틀립니다\")\n      }\n      let 행 = 행스칼라.정수값\n      let 행시작 = 오프셋 - 열스칼라.정수값\n      let mut 찾음 = false\n      for 기존 in 행들 {\n        if 기존.행 == 행 {\n          if 기존.시작 != 행시작 { return Err(\"한 원본 행의 시작 오프셋이 서로 다릅니다\") }\n          찾음 = true\n        }\n      }\n      if !찾음 { 행들.push(압축원본행 { 행: 행, 시작: 행시작 }) }\n      모서리 = 모서리 + 1\n    }\n  }\n  let mut 왼쪽 = 0\n  while 왼쪽 < 행들.length {\n    let mut 오른쪽 = 왼쪽 + 1\n    while 오른쪽 < 행들.length {\n      if 행들[오른쪽].행 < 행들[왼쪽].행 {\n        let 임시 = 행들[왼쪽]\n        행들[왼쪽] = 행들[오른쪽]\n        행들[오른쪽] = 임시\n      }\n      오른쪽 = 오른쪽 + 1\n    }\n    왼쪽 = 왼쪽 + 1\n  }\n  let mut 색인 = 1\n  while 색인 < 행들.length {\n    if 행들[색인].시작 <= 행들[색인 - 1].시작 {\n      return Err(\"원본 행 시작 오프셋이 엄격히 증가하지 않습니다\")\n    }\n    색인 = 색인 + 1\n  }\n  Ok(행들)\n}\n\nfunction 압축원본문자위치(\n  행들: Array<압축원본행>,\n  오프셋: int\n) -> Result<Array<int>, string> {\n  let mut 아래 = -1\n  let mut 위 = 행들.length\n  while 아래 + 1 < 위 {\n    let 가운데 = (아래 + 위) / 2\n    if 행들[가운데].시작 <= 오프셋 { 아래 = 가운데 } else { 위 = 가운데 }\n  }\n  if 아래 < 0 { return Err(\"노드 오프셋이 첫 원본 행보다 앞섭니다\") }\n  Ok([행들[아래].행, 오프셋 - 행들[아래].시작])\n}\n\nfunction 구조스칼라필드정렬(값들: Array<구조스칼라>) -> Array<구조스칼라> {\n  let mut 결과 = 값들\n  let mut 왼쪽 = 0\n  while 왼쪽 < 결과.length {\n    let mut 오른쪽 = 왼쪽 + 1\n    while 오른쪽 < 결과.length {\n      if 결과[오른쪽].필드 < 결과[왼쪽].필드 {\n        let 임시 = 결과[왼쪽]\n        결과[왼쪽] = 결과[오른쪽]\n        결과[오른쪽] = 임시\n      }\n      오른쪽 = 오른쪽 + 1\n    }\n    왼쪽 = 왼쪽 + 1\n  }\n  결과\n}\n\nfunction 구조인코드배열(구조: 구조입력) -> Result<Array<int>, string> {\n  let 언어번호 = 구조언어번호(구조)\n  let 압축기하 = 언어번호 == 1 || 언어번호 == 2\n  구조입력검사(언어번호, 구조)?\n  if 구조.분리본문키해시.scalars().length != 64 { return Err(\"분리 본문 키 해시 길이가 틀립니다\") }\n  let mut 자식모음: Array<string> = []\n  let mut 스칼라필드모음: Array<string> = []\n  let mut 스칼라문자키들: Array<string> = []\n  for 노드 in 구조.노드들 {\n    if 노드.자식필드있음 { 자식모음.push(노드.자식필드) }\n    for 스칼라 in 노드.스칼라들 {\n      if !압축기하 || !원본기하필드인가(스칼라.필드) {\n        스칼라필드모음.push(스칼라.필드)\n        if 스칼라.태그 == 5 || 스칼라.태그 == 6 {\n          let 코드단위문자열 = 구조스칼라코드단위문자열(스칼라)?\n          스칼라문자키들.push(코드단위문자열.키)\n        }\n      }\n    }\n  }\n  let mut 원본행들: Array<압축원본행> = []\n  if 압축기하 { 원본행들 = 압축원본행들(구조)? }\n  let 자식사전 = 정렬고유(자식모음)\n  let 스칼라필드사전 = 정렬고유(스칼라필드모음)\n  let 스칼라문자사전 = 정렬고유(스칼라문자키들)\n  let mut 내용 = 바이트배열로(Bytes.fromHex(구조.분리본문키해시)?)\n  내용 = 가변정수쓰기(내용, 구조.노드들.length)\n  내용 = 가변정수쓰기(내용, 구조.분리본문값수)\n  if 압축기하 {\n    내용 = 가변정수쓰기(내용, 원본행들.length)\n    let mut 이전행 = -1\n    let mut 이전시작 = 0\n    for 행 in 원본행들 {\n      내용 = 가변정수쓰기(내용, 행.행 - 이전행)\n      내용 = 가변정수쓰기(내용, 행.시작 - 이전시작)\n      이전행 = 행.행\n      이전시작 = 행.시작\n    }\n  }\n  내용 = 사전쓰기(내용, 자식사전)?\n  내용 = 사전쓰기(내용, 스칼라필드사전)?\n  내용 = 코드단위사전쓰기(내용, 스칼라문자사전)?\n  let mut 순번 = 0\n  let mut 스칼라문자순번 = 0\n  for 노드 in 구조.노드들 {\n    내용 = 가변정수쓰기(내용, 노드.코드워드)\n    내용 = 가변정수쓰기(내용, if 노드.부모순번 < 0 { 0 } else { 순번 - 노드.부모순번 })\n    내용 = 가변정수쓰기(내용, if 노드.자식필드있음 { 사전색인(자식사전, 노드.자식필드) + 1 } else { 0 })\n    내용 = 가변정수쓰기(내용, if 노드.자식색인 < 0 { 0 } else { 노드.자식색인 + 1 })\n    내용 = 가변정수쓰기(내용, 노드.시작)\n    내용 = 가변정수쓰기(내용, 노드.끝)\n    let mut 스칼라수 = 0\n    for 스칼라 in 노드.스칼라들 {\n      if !압축기하 || !원본기하필드인가(스칼라.필드) { 스칼라수 = 스칼라수 + 1 }\n    }\n    내용 = 가변정수쓰기(내용, 스칼라수)\n    for 스칼라 in 노드.스칼라들 {\n      if !압축기하 || !원본기하필드인가(스칼라.필드) {\n        내용 = 가변정수쓰기(내용, 사전색인(스칼라필드사전, 스칼라.필드))\n        내용.push(if 스칼라.태그 == 6 { 5 } else { 스칼라.태그 })\n        if 스칼라.태그 == 3 || 스칼라.태그 == 4 { 내용 = 가변정수쓰기(내용, 스칼라.정수값) }\n        else if 스칼라.태그 == 5 || 스칼라.태그 == 6 {\n          if 스칼라문자순번 >= 스칼라문자키들.length {\n            return Err(\"스칼라 문자열 키 캐시가 구조보다 짧습니다\")\n          }\n          내용 = 가변정수쓰기(\n            내용,\n            사전색인(스칼라문자사전, 스칼라문자키들[스칼라문자순번])\n          )\n          스칼라문자순번 = 스칼라문자순번 + 1\n        }\n      }\n    }\n    if 노드.식별자있음 { 내용 = 가변정수쓰기(내용, 노드.식별자류번호) }\n    순번 = 순번 + 1\n  }\n  if 스칼라문자순번 != 스칼라문자키들.length {\n    return Err(\"스칼라 문자열 키 캐시가 구조보다 깁니다\")\n  }\n  let 구조버전 = if 언어번호 == 1 || 언어번호 == 2 { 4 } else { 1 }\n  let mut 본문 = [67, 73, 70, 83, 구조버전, 1, 0, 0]\n  본문 = 삼십이쓰기(본문, 16 + 내용.length + 32)\n  본문 = 삼십이쓰기(본문, 내용.length)\n  본문 = 바이트추가(본문, 내용)\n  let 결과 = 바이트추가(본문, 해시배열(본문))\n  Ok(결과)\n}\n\nexport function 구조인코드(입력: string) -> Result<Bytes, string> {\n  let 구조 = json.parseAs<구조입력>(입력)?\n  바이트로(구조인코드배열(구조)?)\n}\n\nexport function 구조디코드(와이어: Bytes, 식별자표: Array<bool>) -> Result<string, string> {\n  let 전체 = 바이트배열로(와이어)\n  if 전체.length < 48 { return Err(\"구조 와이어가 잘렸습니다\") }\n  if 전체.length > 2097152 { return Err(\"구조 와이어가 허용량을 넘습니다\") }\n  let 본문 = 부분배열(전체, 0, 전체.length - 32)\n  let 실제해시 = 부분배열(전체, 전체.length - 32, 전체.length)\n  if !배열같음(실제해시, 해시배열(본문)) { return Err(\"구조 와이어 검사합이 맞지 않습니다\") }\n  if 본문[0] != 67 || 본문[1] != 73 || 본문[2] != 70 || 본문[3] != 83 { return Err(\"구조 와이어 마법값이 틀립니다\") }\n  if (본문[4] != 1 && 본문[4] != 4) || 본문[5] != 1 || 본문[6] != 0 || 본문[7] != 0 {\n    return Err(\"구조 와이어 버전이 틀립니다\")\n  }\n  let 와이어버전 = 본문[4]\n  if 삼십이읽기(본문, 8) != 전체.length || 삼십이읽기(본문, 12) != 본문.length - 16 { return Err(\"구조 와이어 길이가 틀립니다\") }\n  let mut 위치 = 16\n  let 해시끝 = 위치 + 32\n  let 분리본문키바이트 = 바이트로(부분배열(본문, 위치, 해시끝))?\n  let 분리본문키해시 = 분리본문키바이트.toHex()\n  위치 = 해시끝\n  let 노드수읽기 = 가변정수읽기(본문, 위치)?; 위치 = 노드수읽기.다음\n  let 본문수읽기 = 가변정수읽기(본문, 위치)?; 위치 = 본문수읽기.다음\n  if 식별자표.length != 노드수읽기.값 { return Err(\"식별자 표 길이가 노드 수와 다릅니다\") }\n  let mut 원본행들: Array<압축원본행> = []\n  if 와이어버전 == 4 {\n    let 행수읽기 = 가변정수읽기(본문, 위치)?; 위치 = 행수읽기.다음\n    if 행수읽기.값 == 0 || 행수읽기.값 > 노드수읽기.값 * 2 {\n      return Err(\"원본 행 수가 허용량을 넘습니다\")\n    }\n    let mut 이전행 = -1\n    let mut 이전시작 = 0\n    let mut 행색인 = 0\n    while 행색인 < 행수읽기.값 {\n      let 행차 = 가변정수읽기(본문, 위치)?; 위치 = 행차.다음\n      let 시작차 = 가변정수읽기(본문, 위치)?; 위치 = 시작차.다음\n      if 행차.값 == 0 || (행색인 > 0 && 시작차.값 == 0) {\n        return Err(\"원본 행들이 엄격히 증가하지 않습니다\")\n      }\n      let 행 = 이전행 + 행차.값\n      let 시작 = 이전시작 + 시작차.값\n      원본행들.push(압축원본행 { 행: 행, 시작: 시작 })\n      이전행 = 행\n      이전시작 = 시작\n      행색인 = 행색인 + 1\n    }\n  }\n  let 자식읽기 = 사전해석(본문, 위치)?; 위치 = 자식읽기.다음\n  let 필드읽기 = 사전해석(본문, 위치)?; 위치 = 필드읽기.다음\n  if 와이어버전 == 4 {\n    for 필드 in 필드읽기.값들 {\n      if 원본기하필드인가(필드) { return Err(\"원본 기하가 스칼라 사전에 중복되었습니다\") }\n    }\n  }\n  let 문자읽기 = 코드단위사전해석(본문, 위치)?; 위치 = 문자읽기.다음\n  let mut 노드들: Array<구조노드> = []\n  let mut 순번 = 0\n  while 순번 < 노드수읽기.값 {\n    let 코드 = 가변정수읽기(본문, 위치)?; 위치 = 코드.다음\n    let 부모차 = 가변정수읽기(본문, 위치)?; 위치 = 부모차.다음\n    let 자식필드코드 = 가변정수읽기(본문, 위치)?; 위치 = 자식필드코드.다음\n    let 자식색인코드 = 가변정수읽기(본문, 위치)?; 위치 = 자식색인코드.다음\n    let 시작읽기 = 가변정수읽기(본문, 위치)?; 위치 = 시작읽기.다음\n    let 끝읽기 = 가변정수읽기(본문, 위치)?; 위치 = 끝읽기.다음\n    let 스칼라수 = 가변정수읽기(본문, 위치)?; 위치 = 스칼라수.다음\n    if 자식필드코드.값 > 자식읽기.값들.length { return Err(\"자식 필드 사전 색인이 틀립니다\") }\n    let mut 스칼라들: Array<구조스칼라> = []\n    let mut 스칼라색인 = 0\n    let mut 이전필드 = -1\n    while 스칼라색인 < 스칼라수.값 {\n      let 필드색인 = 가변정수읽기(본문, 위치)?; 위치 = 필드색인.다음\n      if 필드색인.값 >= 필드읽기.값들.length || 필드색인.값 <= 이전필드 { return Err(\"스칼라 필드가 정규 순서가 아닙니다\") }\n      이전필드 = 필드색인.값\n      if 위치 >= 본문.length { return Err(\"스칼라 태그가 잘렸습니다\") }\n      let 태그 = 본문[위치]; 위치 = 위치 + 1\n      let mut 호스트태그 = 태그\n      let mut 정수값 = 0\n      let mut 문자열값 = \"\"\n      if 태그 == 3 || 태그 == 4 {\n        let 정수읽기값 = 가변정수읽기(본문, 위치)?; 위치 = 정수읽기값.다음\n        정수값 = 정수읽기값.값\n        if 태그 == 4 && 정수값 == 0 { return Err(\"음수 영은 허용되지 않습니다\") }\n      } else if 태그 == 5 {\n        let 문자열색인 = 가변정수읽기(본문, 위치)?; 위치 = 문자열색인.다음\n        if 문자열색인.값 >= 문자읽기.값들.length { return Err(\"스칼라 문자열 사전 색인이 틀립니다\") }\n        let 문자값 = 문자읽기.값들[문자열색인.값]\n        if 문자값.안전 { 문자열값 = 문자값.안전값 }\n        else { 호스트태그 = 6; 문자열값 = 문자값.키 }\n      } else if 태그 < 0 || 태그 > 2 { return Err(\"스칼라 태그가 틀립니다\") }\n      스칼라들.push(구조스칼라 {\n        필드: 필드읽기.값들[필드색인.값], 태그: 호스트태그,\n        정수값: 정수값, 문자열값: 문자열값\n      })\n      스칼라색인 = 스칼라색인 + 1\n    }\n    if 와이어버전 == 4 {\n      let 시작기하 = 압축원본문자위치(원본행들, 시작읽기.값)?\n      let 끝기하 = 압축원본문자위치(원본행들, 끝읽기.값)?\n      스칼라들.push(구조스칼라 { 필드: \"startRow\", 태그: 3, 정수값: 시작기하[0], 문자열값: \"\" })\n      스칼라들.push(구조스칼라 { 필드: \"startColumn\", 태그: 3, 정수값: 시작기하[1], 문자열값: \"\" })\n      스칼라들.push(구조스칼라 { 필드: \"endRow\", 태그: 3, 정수값: 끝기하[0], 문자열값: \"\" })\n      스칼라들.push(구조스칼라 { 필드: \"endColumn\", 태그: 3, 정수값: 끝기하[1], 문자열값: \"\" })\n      스칼라들 = 구조스칼라필드정렬(스칼라들)\n    }\n    let 식별자있음 = 식별자표[순번]\n    let mut 식별자류번호 = 0\n    if 식별자있음 {\n      let 식별자읽기 = 가변정수읽기(본문, 위치)?; 위치 = 식별자읽기.다음\n      식별자류번호 = 식별자읽기.값\n    }\n    노드들.push(구조노드 {\n      코드워드: 코드.값,\n      부모순번: if 순번 == 0 { -1 } else { 순번 - 부모차.값 },\n      자식필드있음: 자식필드코드.값 != 0,\n      자식필드: if 자식필드코드.값 == 0 { \"\" } else { 자식읽기.값들[자식필드코드.값 - 1] },\n      자식색인: if 자식색인코드.값 == 0 { -1 } else { 자식색인코드.값 - 1 },\n      시작: 시작읽기.값,\n      끝: 끝읽기.값,\n      스칼라들: 스칼라들,\n      식별자있음: 식별자있음,\n      식별자류번호: 식별자류번호\n    })\n    순번 = 순번 + 1\n  }\n  if 위치 != 본문.length { return Err(\"구조 와이어 뒤에 바이트가 남았습니다\") }\n  let 구조 = 구조입력 { 분리본문키해시: 분리본문키해시, 분리본문값수: 본문수읽기.값, 노드들: 노드들 }\n  let 언어번호 = 구조언어번호(구조)\n  let 예상버전 = if 언어번호 == 1 || 언어번호 == 2 { 4 } else { 1 }\n  if 와이어버전 != 예상버전 { return Err(\"구조 와이어 버전이 언어와 맞지 않습니다\") }\n  구조입력검사(언어번호, 구조)?\n  if !배열같음(구조인코드배열(구조)?, 전체) { return Err(\"구조 와이어가 정규 인코딩이 아닙니다\") }\n  json.stringify(구조)\n}\n\nexport function 노드스칼라(노드: 구조노드, 필드: string) -> 구조스칼라 {\n  for 스칼라 in 노드.스칼라들 { if 스칼라.필드 == 필드 { return 스칼라 } }\n  구조스칼라 { 필드: \"\", 태그: 0, 정수값: 0, 문자열값: \"\" }\n}\n\nexport function 스칼라있음(노드: 구조노드, 필드: string) -> bool { 노드스칼라(노드, 필드).필드 != \"\" }\nexport function 스칼라문자(노드: 구조노드, 필드: string) -> string { 노드스칼라(노드, 필드).문자열값 }\nexport function 스칼라논리(노드: 구조노드, 필드: string) -> bool { 노드스칼라(노드, 필드).태그 == 2 }\nexport function 스칼라정수(노드: 구조노드, 필드: string) -> int {\n  let 값 = 노드스칼라(노드, 필드)\n  if 값.태그 == 4 { -값.정수값 } else { 값.정수값 }\n}\n",
      "sourceSha256": "061425cc359393de90b973775c94d2a7fc2b25999b2614916a44cb26dd55474c"
    },
    {
      "path": "topaz/src/types.tpz",
      "language": "topaz",
      "bytes": 854,
      "sha256": "48bbf17416d0e00caef13fe7b5cdf9465cfde68b8bf92937283a84d99b2a0759",
      "content": "// Shared structure and printer record types.\n\n// 투영 원본 인쇄. 와이어 노드의 공개 구조와 선택적인 분리 본문 키만\n// 사용하여 정규 JavaScript/TypeScript 표기를 재현한다.\n\nexport record 댓글고정 {\n  값색인: int,\n  붙임노드순번: int,\n  놓임: string,\n  앞줄수: int,\n  뒤줄수: int\n}\n\nexport record 분리본문키결과 {\n  값들: Array<string>,\n  댓글고정들: Array<댓글고정>,\n  둘째판: bool\n}\n\nexport record 인쇄조각판 {\n  종류들: Array<int>,\n  글들: Array<string>,\n  왼들: Array<int>,\n  오른들: Array<int>,\n  시작들: Array<int>,\n  끝들: Array<int>,\n  횟수들: Array<int>,\n  길이들: Array<int>,\n  행수들: Array<int>,\n  첫글들: Array<string>,\n  끝글들: Array<string>\n}\n\nexport record 인쇄조각범위 {\n  조각: int,\n  시작: int,\n  끝: int\n}\n",
      "sourceSha256": "48bbf17416d0e00caef13fe7b5cdf9465cfde68b8bf92937283a84d99b2a0759"
    },
    {
      "path": "topaz/src/util.tpz",
      "language": "topaz",
      "bytes": 3076,
      "sha256": "21a28aac8b6c6e0276c5cd1da0d7e049d3d5a400d4e2be8bc2bed0e3cde0612d",
      "content": "// Shared byte, integer, and collection helpers.\n\nimport std.bytes { Bytes }\n\nexport function 거듭제곱이(지수: int) -> int {\n  let mut 값 = 1\n  let mut 색인 = 0\n  while 색인 < 지수 { 값 = 값 * 2; 색인 = 색인 + 1 }\n  값\n}\n\nexport function 십육진숫자(글자: string) -> int {\n  if 글자 == \"0\" { return 0 }\n  if 글자 == \"1\" { return 1 }\n  if 글자 == \"2\" { return 2 }\n  if 글자 == \"3\" { return 3 }\n  if 글자 == \"4\" { return 4 }\n  if 글자 == \"5\" { return 5 }\n  if 글자 == \"6\" { return 6 }\n  if 글자 == \"7\" { return 7 }\n  if 글자 == \"8\" { return 8 }\n  if 글자 == \"9\" { return 9 }\n  if 글자 == \"a\" { return 10 }\n  if 글자 == \"b\" { return 11 }\n  if 글자 == \"c\" { return 12 }\n  if 글자 == \"d\" { return 13 }\n  if 글자 == \"e\" { return 14 }\n  if 글자 == \"f\" { 15 } else { 0 }\n}\n\nexport function 바이트배열로(입력: Bytes) -> Array<int> {\n  let 글자들 = 입력.toHex().scalars()\n  let mut 결과: Array<int> = []\n  let mut 색인 = 0\n  while 색인 < 글자들.length {\n    결과.push(십육진숫자(글자들[색인]) * 16 + 십육진숫자(글자들[색인 + 1]))\n    색인 = 색인 + 2\n  }\n  결과\n}\n\nexport function 바이트로(입력: Array<int>) -> Result<Bytes, string> {\n  let 숫자들 = [\"0\", \"1\", \"2\", \"3\", \"4\", \"5\", \"6\", \"7\", \"8\", \"9\", \"a\", \"b\", \"c\", \"d\", \"e\", \"f\"]\n  let mut 조각들: Array<string> = []\n  for 값 in 입력 {\n    if 값 < 0 || 값 > 255 { return Err(\"바이트 범위를 벗어났습니다\") }\n    조각들.push(숫자들[값 / 16])\n    조각들.push(숫자들[값 % 16])\n  }\n  Bytes.fromHex(조각들.join(\"\"))\n}\n\nexport function 배열같음(왼쪽: Array<int>, 오른쪽: Array<int>) -> bool {\n  if 왼쪽.length != 오른쪽.length { return false }\n  let mut 색인 = 0\n  while 색인 < 왼쪽.length {\n    if 왼쪽[색인] != 오른쪽[색인] { return false }\n    색인 = 색인 + 1\n  }\n  true\n}\n\nexport function 부분배열(입력: Array<int>, 시작: int, 끝: int) -> Array<int> {\n  let mut 결과: Array<int> = []\n  let mut 색인 = 시작\n  while 색인 < 끝 { 결과.push(입력[색인]); 색인 = 색인 + 1 }\n  결과\n}\n\nexport function 바이트추가(대상: Array<int>, 원본: Array<int>) -> Array<int> {\n  let mut 결과 = 대상\n  for 값 in 원본 { 결과.push(값) }\n  결과\n}\n\nexport function 비트배타합(왼쪽: int, 오른쪽: int, 자리수: int) -> int {\n  let mut 왼 = 왼쪽\n  let mut 오 = 오른쪽\n  let mut 자리 = 1\n  let mut 결과 = 0\n  let mut 색인 = 0\n  while 색인 < 자리수 {\n    if (왼 % 2) != (오 % 2) { 결과 = 결과 + 자리 }\n    왼 = 왼 / 2\n    오 = 오 / 2\n    자리 = 자리 * 2\n    색인 = 색인 + 1\n  }\n  결과\n}\n\nexport function 작은값(왼쪽: int, 오른쪽: int) -> int { if 왼쪽 < 오른쪽 { 왼쪽 } else { 오른쪽 } }\nexport function 큰값(왼쪽: int, 오른쪽: int) -> int { if 왼쪽 > 오른쪽 { 왼쪽 } else { 오른쪽 } }\n\nexport function 문자열배열에있음(값들: Array<string>, 찾기: string) -> bool {\n  for 값 in 값들 { if 값 == 찾기 { return true } }\n  false\n}\n",
      "sourceSha256": "21a28aac8b6c6e0276c5cd1da0d7e049d3d5a400d4e2be8bc2bed0e3cde0612d"
    },
    {
      "path": "topaz/src/wire.tpz",
      "language": "topaz",
      "bytes": 15759,
      "sha256": "20257fdf2b6f5c41d4e2146a652c45af7177e1ab6c40c44d730b457db1e1bd32",
      "content": "// Wire primitives under structure.tpz: variable-length integers, string\n// dictionaries, UTF-16 code-unit strings, hex digits, and the Galois table record.\n\nimport std.bytes { Bytes }\nimport std.json\nimport util { 바이트로, 바이트배열로, 바이트추가, 부분배열 }\n\nexport record 정수읽기 { 값: int, 다음: int }\nexport record 문자열읽기 { 값: string, 다음: int }\nexport record 사전읽기 { 값들: Array<string>, 다음: int }\nexport record 코드단위문자열 {\n  키: string,\n  안전값: string,\n  안전: bool\n}\nexport record 코드단위문자열읽기 { 값: 코드단위문자열, 다음: int }\nexport record 코드단위사전읽기 { 값들: Array<코드단위문자열>, 다음: int }\nexport record 갈루아표 { 지수: Array<int>, 로그: Array<int> }\n\n// 구조 와이어의 낱말들. 십육진 표기와 가변 정수와 정렬 사전이\n// 위의 모든 계층이 함께 쓰는 어휘다.\nfunction 소문자십육진글자(값: int) -> string {\n  [\"0\", \"1\", \"2\", \"3\", \"4\", \"5\", \"6\", \"7\", \"8\", \"9\", \"a\", \"b\", \"c\", \"d\", \"e\", \"f\"][값]\n}\n\nfunction 대문자십육진글자(값: int) -> string {\n  [\"0\", \"1\", \"2\", \"3\", \"4\", \"5\", \"6\", \"7\", \"8\", \"9\", \"A\", \"B\", \"C\", \"D\", \"E\", \"F\"][값]\n}\n\nfunction 소문자십육진네자리(값: int) -> string {\n  소문자십육진글자((값 / 4096) % 16) + 소문자십육진글자((값 / 256) % 16) +\n    소문자십육진글자((값 / 16) % 16) + 소문자십육진글자(값 % 16)\n}\n\nexport function 대문자십육진네자리(값: int) -> string {\n  대문자십육진글자((값 / 4096) % 16) + 대문자십육진글자((값 / 256) % 16) +\n    대문자십육진글자((값 / 16) % 16) + 대문자십육진글자(값 % 16)\n}\n\nexport function 대문자십육진두자리(값: int) -> string {\n  대문자십육진글자((값 / 16) % 16) + 대문자십육진글자(값 % 16)\n}\n\nfunction 십육진글자인가(글자: string) -> bool {\n  (글자 >= \"0\" && 글자 <= \"9\") || (글자 >= \"a\" && 글자 <= \"f\") ||\n    (글자 >= \"A\" && 글자 <= \"F\")\n}\n\nfunction 소문자십육진글자인가(글자: string) -> bool {\n  (글자 >= \"0\" && 글자 <= \"9\") || (글자 >= \"a\" && 글자 <= \"f\")\n}\n\nfunction 제이슨십육진숫자(글자: string) -> int {\n  if 글자 >= \"0\" && 글자 <= \"9\" { return (글자.codePointAt(0) ?? 48) - 48 }\n  if 글자 >= \"a\" && 글자 <= \"f\" { return (글자.codePointAt(0) ?? 97) - 97 + 10 }\n  (글자.codePointAt(0) ?? 65) - 65 + 10\n}\n\nfunction 높은대리자인가(단위: int) -> bool { 단위 >= 55296 && 단위 <= 56319 }\nfunction 낮은대리자인가(단위: int) -> bool { 단위 >= 56320 && 단위 <= 57343 }\n\nexport function 널문자있음(값: string) -> bool {\n  for 글자 in 값.scalars() {\n    if (글자.codePointAt(0) ?? -1) == 0 { return true }\n  }\n  false\n}\n\nfunction 코드단위키만들기(단위들: Array<int>) -> string {\n  let mut 조각들: Array<string> = []\n  for 단위 in 단위들 { 조각들.push(소문자십육진네자리(단위)) }\n  조각들.join(\"\")\n}\n\nexport function 안전문자열코드단위키(값: string) -> string {\n  let mut 조각들: Array<string> = []\n  for 글자 in 값.scalars() {\n    let 코드 = 글자.codePointAt(0) ?? 0\n    if 코드 <= 65535 { 조각들.push(소문자십육진네자리(코드)) }\n    else {\n      let 나머지 = 코드 - 65536\n      조각들.push(소문자십육진네자리(55296 + 나머지 / 1024))\n      조각들.push(소문자십육진네자리(56320 + 나머지 % 1024))\n    }\n  }\n  조각들.join(\"\")\n}\n\nexport function 코드단위키읽기(키: string, 빈값허용: bool) -> Result<Array<int>, string> {\n  let 글자들 = 키.scalars()\n  if (!빈값허용 && 글자들.length == 0) || 글자들.length % 4 != 0 {\n    return Err(\"UTF-16 코드 단위 키 길이가 틀립니다\")\n  }\n  let mut 단위들: Array<int> = []\n  let mut 색인 = 0\n  while 색인 < 글자들.length {\n    let mut 자리 = 0\n    let mut 값 = 0\n    while 자리 < 4 {\n      let 글자 = 글자들[색인 + 자리]\n      if !소문자십육진글자인가(글자) { return Err(\"UTF-16 코드 단위 키가 소문자 십육진수가 아닙니다\") }\n      값 = 값 * 16 + 제이슨십육진숫자(글자)\n      자리 = 자리 + 1\n    }\n    단위들.push(값)\n    색인 = 색인 + 4\n  }\n  Ok(단위들)\n}\n\nexport function 짝없는대리자있음(단위들: Array<int>) -> bool {\n  let mut 색인 = 0\n  while 색인 < 단위들.length {\n    let 단위 = 단위들[색인]\n    if 높은대리자인가(단위) {\n      if 색인 + 1 < 단위들.length && 낮은대리자인가(단위들[색인 + 1]) { 색인 = 색인 + 2 }\n      else { return true }\n    } else if 낮은대리자인가(단위) { return true }\n    else { 색인 = 색인 + 1 }\n  }\n  false\n}\n\nfunction 안전코드단위값(단위들: Array<int>) -> Result<string, string> {\n  if 짝없는대리자있음(단위들) { return Err(\"짝없는 UTF-16 대리자는 Topaz 문자열이 될 수 없습니다\") }\n  let mut 조각들: Array<string> = []\n  let mut 색인 = 0\n  while 색인 < 단위들.length {\n    let 단위 = 단위들[색인]\n    let 코드 = if 높은대리자인가(단위) {\n      let 낮음 = 단위들[색인 + 1]\n      색인 = 색인 + 2\n      65536 + (단위 - 55296) * 1024 + (낮음 - 56320)\n    } else {\n      색인 = 색인 + 1\n      단위\n    }\n    match 코드.toCodePoint() {\n      case Some(글자) => { 조각들.push(글자) }\n      case None => return Err(\"UTF-16 코드 단위가 유니코드 스칼라가 아닙니다\")\n    }\n  }\n  Ok(조각들.join(\"\"))\n}\n\nfunction 와이어제이슨문자열(키: string) -> Result<string, string> {\n  let 단위들 = 코드단위키읽기(키, true)?\n  let mut 조각들: Array<string> = [\"\\\"\"]\n  let mut 색인 = 0\n  while 색인 < 단위들.length {\n    let 단위 = 단위들[색인]\n    if 단위 == 34 { 조각들.push(\"\\\\\\\"\") }\n    else if 단위 == 92 { 조각들.push(\"\\\\\\\\\") }\n    else if 단위 == 8 { 조각들.push(\"\\\\b\") }\n    else if 단위 == 12 { 조각들.push(\"\\\\f\") }\n    else if 단위 == 10 { 조각들.push(\"\\\\n\") }\n    else if 단위 == 13 { 조각들.push(\"\\\\r\") }\n    else if 단위 == 9 { 조각들.push(\"\\\\t\") }\n    else if 높은대리자인가(단위) && 색인 + 1 < 단위들.length && 낮은대리자인가(단위들[색인 + 1]) {\n      let 코드 = 65536 + (단위 - 55296) * 1024 + (단위들[색인 + 1] - 56320)\n      match 코드.toCodePoint() {\n        case Some(문자) => { 조각들.push(문자) }\n        case None => return Err(\"UTF-16 대리자 쌍이 유니코드 스칼라가 아닙니다\")\n      }\n      색인 = 색인 + 1\n    } else if 높은대리자인가(단위) || 낮은대리자인가(단위) || 단위 < 32 {\n      조각들.push(\"\\\\u\")\n      조각들.push(소문자십육진네자리(단위))\n    } else {\n      match 단위.toCodePoint() {\n        case Some(문자) => { 조각들.push(문자) }\n        case None => return Err(\"UTF-16 코드 단위가 유니코드 스칼라가 아닙니다\")\n      }\n    }\n    색인 = 색인 + 1\n  }\n  조각들.push(\"\\\"\")\n  Ok(조각들.join(\"\"))\n}\n\nexport function 코드단위문자열만들기(키: string) -> Result<코드단위문자열, string> {\n  let 단위들 = 코드단위키읽기(키, true)?\n  if 짝없는대리자있음(단위들) {\n    return Ok(코드단위문자열 { 키: 키, 안전값: \"\", 안전: false })\n  }\n  Ok(코드단위문자열 { 키: 키, 안전값: 안전코드단위값(단위들)?, 안전: true })\n}\n\nfunction 제이슨문자열코드단위로(직렬: string) -> Result<코드단위문자열, string> {\n  let 글자들 = 직렬.scalars()\n  if 글자들.length < 2 || 글자들[0] != \"\\\"\" || 글자들[글자들.length - 1] != \"\\\"\" {\n    return Err(\"스칼라 문자열 사전 값이 JSON 문자열이 아닙니다\")\n  }\n  let mut 단위들: Array<int> = []\n  let mut 색인 = 1\n  while 색인 < 글자들.length - 1 {\n    let 글자 = 글자들[색인]\n    if 글자 == \"\\\"\" { return Err(\"스칼라 문자열 사전에 닫는 따옴표 뒤 글자가 있습니다\") }\n    if 글자 == \"\\\\\" {\n      if 색인 + 1 >= 글자들.length - 1 { return Err(\"스칼라 문자열 사전의 탈출 문자가 잘렸습니다\") }\n      let 탈출 = 글자들[색인 + 1]\n      if 탈출 == \"u\" {\n        if 색인 + 5 >= 글자들.length - 1 { return Err(\"스칼라 문자열 사전의 유니코드 탈출이 잘렸습니다\") }\n        let mut 자리 = 0\n        let mut 단위 = 0\n        while 자리 < 4 {\n          let 숫자글자 = 글자들[색인 + 2 + 자리]\n          if !십육진글자인가(숫자글자) { return Err(\"스칼라 문자열 사전의 유니코드 탈출이 틀립니다\") }\n          단위 = 단위 * 16 + 제이슨십육진숫자(숫자글자)\n          자리 = 자리 + 1\n        }\n        단위들.push(단위)\n        색인 = 색인 + 6\n      } else {\n        if 탈출 == \"\\\"\" { 단위들.push(34) }\n        else if 탈출 == \"\\\\\" { 단위들.push(92) }\n        else if 탈출 == \"/\" { 단위들.push(47) }\n        else if 탈출 == \"b\" { 단위들.push(8) }\n        else if 탈출 == \"f\" { 단위들.push(12) }\n        else if 탈출 == \"n\" { 단위들.push(10) }\n        else if 탈출 == \"r\" { 단위들.push(13) }\n        else if 탈출 == \"t\" { 단위들.push(9) }\n        else { return Err(\"스칼라 문자열 사전의 탈출 문자가 틀립니다\") }\n        색인 = 색인 + 2\n      }\n    } else {\n      let 코드 = 글자.codePointAt(0) ?? -1\n      if 코드 < 32 { return Err(\"스칼라 문자열 사전에 탈출하지 않은 제어 문자가 있습니다\") }\n      if 코드 <= 65535 { 단위들.push(코드) }\n      else {\n        let 나머지 = 코드 - 65536\n        단위들.push(55296 + 나머지 / 1024)\n        단위들.push(56320 + 나머지 % 1024)\n      }\n      색인 = 색인 + 1\n    }\n  }\n  if 색인 != 글자들.length - 1 { return Err(\"스칼라 문자열 사전 값 길이가 틀립니다\") }\n  let 키 = 코드단위키만들기(단위들)\n  if 와이어제이슨문자열(키)? != 직렬 { return Err(\"스칼라 문자열 사전 값이 정규 JSON이 아닙니다\") }\n  if 짝없는대리자있음(단위들) {\n    Ok(코드단위문자열 { 키: 키, 안전값: \"\", 안전: false })\n  } else {\n    Ok(코드단위문자열 { 키: 키, 안전값: json.parseAs<string>(직렬)?, 안전: true })\n  }\n}\n\nexport function 사전색인(값들: Array<string>, 찾기: string) -> int {\n  let mut 색인 = 0\n  while 색인 < 값들.length {\n    if 값들[색인] == 찾기 { return 색인 }\n    색인 = 색인 + 1\n  }\n  -1\n}\n\nexport function 정렬고유(값들: Array<string>) -> Array<string> {\n  let 정렬 = 값들.sorted()\n  let mut 결과: Array<string> = []\n  for 값 in 정렬 {\n    if 결과.length == 0 || 결과[결과.length - 1] != 값 { 결과.push(값) }\n  }\n  결과\n}\n\nexport function 가변정수쓰기(출력: Array<int>, 원본: int) -> Array<int> {\n  let mut 결과 = 출력\n  let mut 남음 = 원본\n  while 남음 >= 128 {\n    결과.push((남음 % 128) + 128)\n    남음 = 남음 / 128\n  }\n  결과.push(남음)\n  결과\n}\n\nexport function 삼십이쓰기(출력: Array<int>, 값: int) -> Array<int> {\n  let mut 결과 = 출력\n  결과.push((값 / 16777216) % 256)\n  결과.push((값 / 65536) % 256)\n  결과.push((값 / 256) % 256)\n  결과.push(값 % 256)\n  결과\n}\n\nexport function 삼십이읽기(입력: Array<int>, 위치: int) -> int {\n  입력[위치] * 16777216 + 입력[위치 + 1] * 65536 + 입력[위치 + 2] * 256 + 입력[위치 + 3]\n}\n\nfunction 정규문자열쓰기(출력: Array<int>, 값: string) -> Result<Array<int>, string> {\n  let 직렬 = json.stringify(값)?\n  let 바이트들 = 바이트배열로(직렬.encodeUtf8())\n  let 길이쓴 = 가변정수쓰기(출력, 바이트들.length)\n  Ok(바이트추가(길이쓴, 바이트들))\n}\n\nfunction 코드단위문자열쓰기(출력: Array<int>, 키: string) -> Result<Array<int>, string> {\n  let 직렬 = 와이어제이슨문자열(키)?\n  let 바이트들 = 바이트배열로(직렬.encodeUtf8())\n  let 길이쓴 = 가변정수쓰기(출력, 바이트들.length)\n  Ok(바이트추가(길이쓴, 바이트들))\n}\n\nexport function 사전쓰기(출력: Array<int>, 값들: Array<string>) -> Result<Array<int>, string> {\n  let mut 결과 = 가변정수쓰기(출력, 값들.length)\n  for 값 in 값들 { 결과 = 정규문자열쓰기(결과, 값)? }\n  Ok(결과)\n}\n\nexport function 코드단위사전쓰기(출력: Array<int>, 키들: Array<string>) -> Result<Array<int>, string> {\n  let mut 결과 = 가변정수쓰기(출력, 키들.length)\n  for 키 in 키들 { 결과 = 코드단위문자열쓰기(결과, 키)? }\n  Ok(결과)\n}\n\nexport function 가변정수읽기(입력: Array<int>, 시작: int) -> Result<정수읽기, string> {\n  let mut 값 = 0\n  let mut 배수 = 1\n  let mut 위치 = 시작\n  let mut 색인 = 0\n  while 색인 < 8 {\n    if 위치 >= 입력.length { return Err(\"가변 정수가 잘렸습니다\") }\n    let 바이트 = 입력[위치]\n    위치 = 위치 + 1\n    let 숫자 = 바이트 % 128\n    if 숫자 > (9007199254740991 - 값) / 배수 { return Err(\"가변 정수가 안전 범위를 넘습니다\") }\n    값 = 값 + 숫자 * 배수\n    if 바이트 < 128 { return Ok(정수읽기 { 값: 값, 다음: 위치 }) }\n    배수 = 배수 * 128\n    색인 = 색인 + 1\n  }\n  Err(\"가변 정수가 너무 깁니다\")\n}\n\nfunction 정규문자열읽기(입력: Array<int>, 시작: int) -> Result<문자열읽기, string> {\n  let 길이읽기 = 가변정수읽기(입력, 시작)?\n  let 끝 = 길이읽기.다음 + 길이읽기.값\n  if 끝 > 입력.length { return Err(\"문자열이 잘렸습니다\") }\n  let 조각 = 바이트로(부분배열(입력, 길이읽기.다음, 끝))?\n  let 직렬 = 조각.decodeUtf8()?\n  let 값 = json.parseAs<string>(직렬)?\n  if json.stringify(값)? != 직렬 { return Err(\"문자열이 정규 JSON이 아닙니다\") }\n  Ok(문자열읽기 { 값: 값, 다음: 끝 })\n}\n\nfunction 코드단위문자열해석(입력: Array<int>, 시작: int) -> Result<코드단위문자열읽기, string> {\n  let 길이읽기 = 가변정수읽기(입력, 시작)?\n  let 끝 = 길이읽기.다음 + 길이읽기.값\n  if 끝 > 입력.length { return Err(\"스칼라 문자열이 잘렸습니다\") }\n  let 조각 = 바이트로(부분배열(입력, 길이읽기.다음, 끝))?\n  let 직렬 = 조각.decodeUtf8()?\n  Ok(코드단위문자열읽기 { 값: 제이슨문자열코드단위로(직렬)?, 다음: 끝 })\n}\n\nexport function 사전해석(입력: Array<int>, 시작: int) -> Result<사전읽기, string> {\n  let 수읽기 = 가변정수읽기(입력, 시작)?\n  let mut 위치 = 수읽기.다음\n  let mut 값들: Array<string> = []\n  let mut 색인 = 0\n  while 색인 < 수읽기.값 {\n    let 읽기 = 정규문자열읽기(입력, 위치)?\n    if 색인 > 0 && 값들[색인 - 1] >= 읽기.값 { return Err(\"사전이 엄격히 정렬되지 않았습니다\") }\n    값들.push(읽기.값)\n    위치 = 읽기.다음\n    색인 = 색인 + 1\n  }\n  Ok(사전읽기 { 값들: 값들, 다음: 위치 })\n}\n\nexport function 코드단위사전해석(입력: Array<int>, 시작: int) -> Result<코드단위사전읽기, string> {\n  let 수읽기 = 가변정수읽기(입력, 시작)?\n  let mut 위치 = 수읽기.다음\n  let mut 값들: Array<코드단위문자열> = []\n  let mut 색인 = 0\n  while 색인 < 수읽기.값 {\n    let 읽기 = 코드단위문자열해석(입력, 위치)?\n    if 색인 > 0 && 값들[색인 - 1].키 >= 읽기.값.키 {\n      return Err(\"스칼라 문자열 사전이 UTF-16 코드 단위 순서로 정렬되지 않았습니다\")\n    }\n    값들.push(읽기.값)\n    위치 = 읽기.다음\n    색인 = 색인 + 1\n  }\n  Ok(코드단위사전읽기 { 값들: 값들, 다음: 위치 })\n}\n",
      "sourceSha256": "20257fdf2b6f5c41d4e2146a652c45af7177e1ab6c40c44d730b457db1e1bd32"
    }
  ],
  "bundleSha256": "36bb4313d67adb655309e48aa99f3e38ead50032e7e5780800155bc8cda657c2",
  "publication": {
    "notices": "SOURCE-NOTICES.txt",
    "statusEn": "Product sources pinned to Topaz 5.21.0.",
    "statusKo": "토파즈 5.21.0에 맞춘 제품 소스다.",
    "editing": "Reviewed comments may be edited for publication. sourceSha256 identifies the upstream file. sha256 identifies the published file. Executable code is unchanged."
  }
}
