diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 167c8ae3c38b..4381e0802612 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -84,6 +84,7 @@ jobs:
       matrix:
         language:
           - da
+          - ko
     env:
       MDBOOK_BOOK__LANGUAGE: ${{ matrix.language }}
       MDBOOK_PREPROCESSOR__GETTEXT__PO_FILE: po/${{ matrix.language }}.po
diff --git a/po/ko.po b/po/ko.po
new file mode 100644
index 000000000000..ecb963a6a429
--- /dev/null
+++ b/po/ko.po
@@ -0,0 +1,12440 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: Comprehensive Rust\n"
+"POT-Creation-Date: \n"
+"PO-Revision-Date: 2023-01-10 16:04+0100\n"
+"Last-Translator: keispace <keispace.kyj@google.com>\n"
+"Language-Team: \n"
+"Language: ko\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Plural-Forms: nplurals=1; plural=0;\n"
+
+#: src/SUMMARY.md:3
+msgid "Welcome to Comprehensive Rust 🦀"
+msgstr ""
+
+#: src/SUMMARY.md:4
+msgid "Using Cargo"
+msgstr "카고 사용하기"
+
+#: src/SUMMARY.md:5
+msgid "Rust Ecosystem"
+msgstr "러스트 생태계"
+
+#: src/SUMMARY.md:6
+msgid "Code Samples"
+msgstr "코드 샘플"
+
+#: src/SUMMARY.md:7
+msgid "Running Cargo Locally"
+msgstr "로컬 환경의 카고"
+
+#: src/SUMMARY.md:8
+msgid "Course Structure"
+msgstr "강의 구성"
+
+#: src/SUMMARY.md:11
+msgid "Day 1: Morning"
+msgstr "1일차 오전"
+
+#: src/SUMMARY.md:15 src/SUMMARY.md:71 src/SUMMARY.md:124 src/SUMMARY.md:174
+msgid "Welcome"
+msgstr "개요"
+
+#: src/SUMMARY.md:16
+msgid "What is Rust?"
+msgstr "러스트란?"
+
+#: src/SUMMARY.md:17
+msgid "Hello World!"
+msgstr ""
+
+#: src/SUMMARY.md:18
+msgid "Small Example"
+msgstr "작은 예제"
+
+#: src/SUMMARY.md:19
+msgid "Why Rust?"
+msgstr "러스트를 써야하는 이유"
+
+#: src/SUMMARY.md:20
+msgid "Compile Time Guarantees"
+msgstr "컴파일 보증"
+
+#: src/SUMMARY.md:21
+msgid "Runtime Guarantees"
+msgstr "런타임 보증"
+
+#: src/SUMMARY.md:22
+msgid "Modern Features"
+msgstr "현대적인 특징"
+
+#: src/SUMMARY.md:23
+msgid "Basic Syntax"
+msgstr "기본 문법"
+
+#: src/SUMMARY.md:24
+msgid "Scalar Types"
+msgstr "스칼라 타입"
+
+#: src/SUMMARY.md:25
+msgid "Compound Types"
+msgstr "복합 타입"
+
+#: src/SUMMARY.md:26
+msgid "References"
+msgstr "참조"
+
+#: src/SUMMARY.md:27
+msgid "Dangling References"
+msgstr "댕글링 참조"
+
+#: src/SUMMARY.md:28
+msgid "Slices"
+msgstr "슬라이스"
+
+#: src/SUMMARY.md:29
+msgid "String vs str"
+msgstr ""
+
+#: src/SUMMARY.md:30
+msgid "Functions"
+msgstr "함수"
+
+#: src/SUMMARY.md:31 src/SUMMARY.md:78
+msgid "Methods"
+msgstr "메서드"
+
+#: src/SUMMARY.md:32
+msgid "Overloading"
+msgstr "오버로딩"
+
+#: src/SUMMARY.md:33 src/SUMMARY.md:62 src/SUMMARY.md:86 src/SUMMARY.md:115
+#: src/SUMMARY.md:142 src/SUMMARY.md:166 src/SUMMARY.md:189 src/SUMMARY.md:216
+msgid "Exercises"
+msgstr "연습문제"
+
+#: src/SUMMARY.md:34
+msgid "Implicit Conversions"
+msgstr "명시적 형변환"
+
+#: src/SUMMARY.md:35
+msgid "Arrays and for Loops"
+msgstr "배열과 for 반복문"
+
+#: src/SUMMARY.md:37
+msgid "Day 1: Afternoon"
+msgstr "1일차 오후"
+
+#: src/SUMMARY.md:39
+msgid "Variables"
+msgstr "변수"
+
+#: src/SUMMARY.md:40
+msgid "Type Inference"
+msgstr "타입 추론"
+
+#: src/SUMMARY.md:41
+msgid "static & const"
+msgstr ""
+
+#: src/SUMMARY.md:42
+msgid "Scopes and Shadowing"
+msgstr "스코프(범위)와 쉐도잉"
+
+#: src/SUMMARY.md:43
+msgid "Memory Management"
+msgstr "메모리 관리"
+
+#: src/SUMMARY.md:44
+msgid "Stack vs Heap"
+msgstr ""
+
+#: src/SUMMARY.md:45
+msgid "Stack Memory"
+msgstr "스택 메모리"
+
+#: src/SUMMARY.md:46
+msgid "Manual Memory Management"
+msgstr "수동 메모리 관리"
+
+#: src/SUMMARY.md:47
+msgid "Scope-Based Memory Management"
+msgstr "범위기반 메모리 관리"
+
+#: src/SUMMARY.md:48
+msgid "Garbage Collection"
+msgstr "가비지 컬렉션"
+
+#: src/SUMMARY.md:49
+msgid "Rust Memory Management"
+msgstr "러스트의 메모리 관리"
+
+#: src/SUMMARY.md:50
+msgid "Comparison"
+msgstr "비교"
+
+#: src/SUMMARY.md:51
+msgid "Ownership"
+msgstr "소유권"
+
+#: src/SUMMARY.md:52
+msgid "Move Semantics"
+msgstr "의미 이동"
+
+#: src/SUMMARY.md:53
+msgid "Moved Strings in Rust"
+msgstr "러스트의 이동된 문자열"
+
+#: src/SUMMARY.md:54
+msgid "Double Frees in Modern C++"
+msgstr "모던C++에서 이중해제 문제"
+
+#: src/SUMMARY.md:55
+msgid "Moves in Function Calls"
+msgstr "함수호출에서 이동"
+
+#: src/SUMMARY.md:56
+msgid "Copying and Cloning"
+msgstr "복사와 복제"
+
+#: src/SUMMARY.md:57
+msgid "Borrowing"
+msgstr "빌림"
+
+#: src/SUMMARY.md:58
+msgid "Shared and Unique Borrows"
+msgstr "공유와 고유 빌림"
+
+#: src/SUMMARY.md:59
+msgid "Lifetimes"
+msgstr "수명"
+
+#: src/SUMMARY.md:60
+msgid "Lifetimes in Function Calls"
+msgstr "함수호출에서의 수명"
+
+#: src/SUMMARY.md:61
+msgid "Lifetimes in Data Structures"
+msgstr "자료 구조에서의 수명"
+
+#: src/SUMMARY.md:63
+msgid "Designing a Library"
+msgstr "도서관 설계"
+
+#: src/SUMMARY.md:64
+msgid "Iterators and Ownership"
+msgstr "반복자와 소유권"
+
+#: src/SUMMARY.md:67
+msgid "Day 2: Morning"
+msgstr "2일차 오전"
+
+#: src/SUMMARY.md:72
+msgid "Structs"
+msgstr "구조체"
+
+#: src/SUMMARY.md:73
+msgid "Tuple Structs"
+msgstr "튜플"
+
+#: src/SUMMARY.md:74
+msgid "Field Shorthand Syntax"
+msgstr "필드 할당 단축 문법"
+
+#: src/SUMMARY.md:75
+msgid "Enums"
+msgstr "열거형"
+
+#: src/SUMMARY.md:76
+msgid "Variant Payloads"
+msgstr ""
+
+#: src/SUMMARY.md:77
+msgid "Enum Sizes"
+msgstr "열거형 크기"
+
+#: src/SUMMARY.md:79
+msgid "Method Receiver"
+msgstr "메서드 인자"
+
+#: src/SUMMARY.md:80 src/SUMMARY.md:184
+msgid "Example"
+msgstr "예제"
+
+#: src/SUMMARY.md:81
+msgid "Pattern Matching"
+msgstr "패턴 매칭"
+
+#: src/SUMMARY.md:82
+msgid "Destructuring Enums"
+msgstr "열거형 분해"
+
+#: src/SUMMARY.md:83
+msgid "Destructuring Structs"
+msgstr "구조체 분해"
+
+#: src/SUMMARY.md:84
+msgid "Destructuring Arrays"
+msgstr "배열 분해"
+
+#: src/SUMMARY.md:85
+msgid "Match Guards"
+msgstr "매치 검사식"
+
+#: src/SUMMARY.md:87
+msgid "Health Statistics"
+msgstr "건강상태 통계"
+
+#: src/SUMMARY.md:88
+msgid "Points and Polygons"
+msgstr "점과 다각형"
+
+#: src/SUMMARY.md:90
+msgid "Day 2: Afternoon"
+msgstr "2일차 오후"
+
+#: src/SUMMARY.md:92
+msgid "Control Flow"
+msgstr "흐름 제어"
+
+#: src/SUMMARY.md:93
+msgid "Blocks"
+msgstr "블록"
+
+#: src/SUMMARY.md:94
+msgid "if expressions"
+msgstr "if 표현식"
+
+#: src/SUMMARY.md:95
+msgid "if let expressions"
+msgstr "if let 표현식"
+
+#: src/SUMMARY.md:96
+msgid "while expressions"
+msgstr "while 표현식"
+
+#: src/SUMMARY.md:97
+msgid "while let expressions"
+msgstr "while let 표현식"
+
+#: src/SUMMARY.md:98
+msgid "for expressions"
+msgstr "for 표현식"
+
+#: src/SUMMARY.md:99
+msgid "loop expressions"
+msgstr "loop 표현식"
+
+#: src/SUMMARY.md:100
+msgid "match expressions"
+msgstr "match 표현식"
+
+#: src/SUMMARY.md:101
+msgid "break & continue"
+msgstr ""
+
+#: src/SUMMARY.md:102
+msgid "Standard Library"
+msgstr "표준 라이브러리"
+
+#: src/SUMMARY.md:103
+msgid "String"
+msgstr ""
+
+#: src/SUMMARY.md:104
+msgid "Option and Result"
+msgstr ""
+
+#: src/SUMMARY.md:105
+msgid "Vec"
+msgstr ""
+
+#: src/SUMMARY.md:106
+msgid "HashMap"
+msgstr ""
+
+#: src/SUMMARY.md:107
+msgid "Box"
+msgstr ""
+
+#: src/SUMMARY.md:108
+msgid "Recursive Data Types"
+msgstr "재귀적 자료구조"
+
+#: src/SUMMARY.md:109
+msgid "Niche Optimization"
+msgstr ""
+
+#: src/SUMMARY.md:110
+msgid "Rc"
+msgstr ""
+
+#: src/SUMMARY.md:111
+msgid "Modules"
+msgstr "모듈"
+
+#: src/SUMMARY.md:112
+msgid "Visibility"
+msgstr "접근자"
+
+#: src/SUMMARY.md:113
+msgid "Paths"
+msgstr "경로"
+
+#: src/SUMMARY.md:114
+msgid "Filesystem Hierarchy"
+msgstr "파일시스템 계층"
+
+#: src/SUMMARY.md:116
+msgid "Luhn Algorithm"
+msgstr "룬 알고리즘"
+
+#: src/SUMMARY.md:117
+msgid "Strings and Iterators"
+msgstr "문자열과 반복자"
+
+#: src/SUMMARY.md:120
+msgid "Day 3: Morning"
+msgstr "3일차 오전"
+
+#: src/SUMMARY.md:125
+msgid "Traits"
+msgstr "트레이트"
+
+#: src/SUMMARY.md:126
+msgid "Deriving Traits"
+msgstr "트레이트 파생"
+
+#: src/SUMMARY.md:127
+msgid "Default Methods"
+msgstr "기본 메서드"
+
+#: src/SUMMARY.md:128
+msgid "Important Traits"
+msgstr "중요 트레이트"
+
+#: src/SUMMARY.md:129
+msgid "Iterator"
+msgstr "반복자"
+
+#: src/SUMMARY.md:130
+msgid "From and Into"
+msgstr ""
+
+#: src/SUMMARY.md:131
+msgid "Read and Write"
+msgstr ""
+
+#: src/SUMMARY.md:132
+msgid "Add, Mul, ..."
+msgstr ""
+
+#: src/SUMMARY.md:133
+msgid "Drop"
+msgstr ""
+
+#: src/SUMMARY.md:134
+msgid "Generics"
+msgstr "제너릭"
+
+#: src/SUMMARY.md:135
+msgid "Generic Data Types"
+msgstr "제너릭 데이터 타입"
+
+#: src/SUMMARY.md:136
+msgid "Generic Methods"
+msgstr "제너릭 메서드"
+
+#: src/SUMMARY.md:137
+msgid "Trait Bounds"
+msgstr "제너릭 타입 제한(트레이트 경계)"
+
+#: src/SUMMARY.md:138
+msgid "impl Trait"
+msgstr "트레이트"
+
+#: src/SUMMARY.md:139
+msgid "Closures"
+msgstr "클로저"
+
+#: src/SUMMARY.md:140
+msgid "Monomorphization"
+msgstr "단형화"
+
+#: src/SUMMARY.md:141
+msgid "Trait Objects"
+msgstr "트레이트 객체"
+
+#: src/SUMMARY.md:143
+msgid "A Simple GUI Library"
+msgstr "간단한 GUI 라이브러리"
+
+#: src/SUMMARY.md:145
+msgid "Day 3: Afternoon"
+msgstr "3일차 오후"
+
+#: src/SUMMARY.md:147
+msgid "Error Handling"
+msgstr "오류처리"
+
+#: src/SUMMARY.md:148
+msgid "Panics"
+msgstr "패닉"
+
+#: src/SUMMARY.md:149
+msgid "Catching Stack Unwinding"
+msgstr "스택 해제 추적"
+
+#: src/SUMMARY.md:150
+msgid "Structured Error Handling"
+msgstr "구조화된 오류처리"
+
+#: src/SUMMARY.md:151
+msgid "Propagating Errors with ?"
+msgstr "'?'를 이용한 오류 전파"
+
+#: src/SUMMARY.md:152
+msgid "Converting Error Types"
+msgstr "오류타입 변환"
+
+#: src/SUMMARY.md:153
+msgid "Deriving Error Enums"
+msgstr "파생 오류 열거형"
+
+#: src/SUMMARY.md:154
+msgid "Adding Context to Errors"
+msgstr "오류에 상황정보 추가"
+
+#: src/SUMMARY.md:155
+msgid "Testing"
+msgstr "테스트"
+
+#: src/SUMMARY.md:156
+msgid "Unit Tests"
+msgstr "단위 테스트"
+
+#: src/SUMMARY.md:157
+msgid "Test Modules"
+msgstr "테스트모듈"
+
+#: src/SUMMARY.md:158
+msgid "Documentation Tests"
+msgstr "문서 테스트"
+
+#: src/SUMMARY.md:159
+msgid "Integration Tests"
+msgstr "통합 테스트"
+
+#: src/SUMMARY.md:160
+msgid "Unsafe Rust"
+msgstr "안전하지 않은 러스트"
+
+#: src/SUMMARY.md:161
+msgid "Dereferencing Raw Pointers"
+msgstr "원시포인트 역참조"
+
+#: src/SUMMARY.md:162
+msgid "Mutable Static Variables"
+msgstr "정적 가변 변수"
+
+#: src/SUMMARY.md:163
+msgid "Calling Unsafe Functions"
+msgstr "안전하지 않은 함수 호출"
+
+#: src/SUMMARY.md:164
+msgid "Extern Functions"
+msgstr "외부(다른언어) 함수들"
+
+#: src/SUMMARY.md:165
+msgid "Unions"
+msgstr ""
+
+#: src/SUMMARY.md:167
+msgid "Safe FFI Wrapper"
+msgstr "FFI래퍼"
+
+#: src/SUMMARY.md:170
+msgid "Day 4: Morning"
+msgstr "4일차 오전"
+
+#: src/SUMMARY.md:175
+msgid "Concurrency"
+msgstr "동시성"
+
+#: src/SUMMARY.md:176
+msgid "Threads"
+msgstr "스레드"
+
+#: src/SUMMARY.md:177
+msgid "Scoped Threads"
+msgstr "범위 스레드(Scoped Threads)"
+
+#: src/SUMMARY.md:178
+msgid "Channels"
+msgstr "채널"
+
+#: src/SUMMARY.md:179
+msgid "Unbounded Channels"
+msgstr "무경계 채널"
+
+#: src/SUMMARY.md:180
+msgid "Bounded Channels"
+msgstr "경계 채널"
+
+#: src/SUMMARY.md:181
+msgid "Shared State"
+msgstr "상태 공유"
+
+#: src/SUMMARY.md:182
+msgid "Arc"
+msgstr ""
+
+#: src/SUMMARY.md:183
+msgid "Mutex"
+msgstr ""
+
+#: src/SUMMARY.md:185
+msgid "Send and Sync"
+msgstr ""
+
+#: src/SUMMARY.md:185
+msgid "Send"
+msgstr ""
+
+#: src/SUMMARY.md:185
+msgid "Sync"
+msgstr ""
+
+#: src/SUMMARY.md:188
+msgid "Examples"
+msgstr "예제"
+
+#: src/SUMMARY.md:190
+msgid "Dining Philosophers"
+msgstr "식사하는 철학자들"
+
+#: src/SUMMARY.md:191
+msgid "Multi-threaded Link Checker"
+msgstr "멀티스레드 링크 검사기"
+
+#: src/SUMMARY.md:193
+msgid "Day 4: Afternoon"
+msgstr "4일차 오후"
+
+#: src/SUMMARY.md:197
+msgid "Android"
+msgstr "안드로이드"
+
+#: src/SUMMARY.md:198
+msgid "Setup"
+msgstr "설치"
+
+#: src/SUMMARY.md:199
+msgid "Build Rules"
+msgstr "빌드 규칙"
+
+#: src/SUMMARY.md:200
+msgid "Binary"
+msgstr "바이너리"
+
+#: src/SUMMARY.md:201
+msgid "Library"
+msgstr "라이브러리"
+
+#: src/SUMMARY.md:202
+msgid "AIDL"
+msgstr ""
+
+#: src/SUMMARY.md:203
+msgid "Interface"
+msgstr "인터페이스"
+
+#: src/SUMMARY.md:204
+msgid "Implementation"
+msgstr "구현"
+
+#: src/SUMMARY.md:205
+msgid "Server"
+msgstr "서버"
+
+#: src/SUMMARY.md:206
+msgid "Deploy"
+msgstr "배포"
+
+#: src/SUMMARY.md:207
+msgid "Client"
+msgstr "클라이언트"
+
+#: src/SUMMARY.md:208
+msgid "Changing API"
+msgstr "API 수정"
+
+#: src/SUMMARY.md:209
+msgid "Logging"
+msgstr "로깅"
+
+#: src/SUMMARY.md:210
+msgid "Interoperability"
+msgstr "상호운용성"
+
+#: src/SUMMARY.md:211
+msgid "With C"
+msgstr ""
+
+#: src/SUMMARY.md:212
+msgid "Calling C with Bindgen"
+msgstr "Bindgen을 사용한 C호출"
+
+#: src/SUMMARY.md:213
+msgid "Calling Rust from C"
+msgstr "C에서 러스트 호출"
+
+#: src/SUMMARY.md:214
+msgid "With C++"
+msgstr ""
+
+#: src/SUMMARY.md:215
+msgid "With Java"
+msgstr ""
+
+#: src/SUMMARY.md:218
+msgid "Final Words"
+msgstr ""
+
+#: src/SUMMARY.md:220
+msgid "Thanks!"
+msgstr ""
+
+#: src/SUMMARY.md:221
+msgid "Other Resources"
+msgstr "다른 자료"
+
+#: src/SUMMARY.md:222
+msgid "Credits"
+msgstr ""
+
+#: src/SUMMARY.md:226
+msgid "Solutions"
+msgstr "해답"
+
+#: src/SUMMARY.md:231
+msgid "Day 1 Morning"
+msgstr "1일차 오전"
+
+#: src/SUMMARY.md:232
+msgid "Day 1 Afternoon"
+msgstr "1일차 오후"
+
+#: src/SUMMARY.md:233
+msgid "Day 2 Morning"
+msgstr "2일차 오전"
+
+#: src/SUMMARY.md:234
+msgid "Day 2 Afternoon"
+msgstr "2일차 오후"
+
+#: src/SUMMARY.md:235
+msgid "Day 3 Morning"
+msgstr "3일차 오전"
+
+#: src/SUMMARY.md:236
+msgid "Day 3 Afternoon"
+msgstr "3일차 오후"
+
+#: src/SUMMARY.md:237
+msgid "Day 4 Morning"
+msgstr "4일차 오전"
+
+#: src/welcome.md:1
+msgid "# Welcome to Comprehensive Rust 🦀"
+msgstr ""
+
+#: src/welcome.md:3
+msgid ""
+"This is a four day Rust course developed by the Android team. The course "
+"covers\n"
+"the full spectrum of Rust, from basic syntax to advanced topics like "
+"generics\n"
+"and error handling. It also includes Android-specific content on the last "
+"day."
+msgstr ""
+"이 4일간의 러스트 강의는 안드로이드 팀에 의해 개발되었습니다. \n"
+"기본 문법부터 제너릭, 에러 핸들링과 같은 고급주제까지 러스트의 모든 것을 포함"
+"합니다.\n"
+"마지막 날에는 안드로이드에 대한 것 까지 다룹니다."
+
+#: src/welcome.md:7
+msgid ""
+"The goal of the course is to teach you Rust. We assume you don't know "
+"anything\n"
+"about Rust and hope to:"
+msgstr ""
+"강의는 당신이 러스트에 대해서 아무것도 모른다고 가정하고 아래의 목표를가지고 "
+"있습니다."
+
+#: src/welcome.md:10
+msgid ""
+"* Give you a comprehensive understanding of the Rust syntax and language.\n"
+"* Enable you to modify existing programs and write new programs in Rust.\n"
+"* Show you common Rust idioms."
+msgstr ""
+"* 러스트 구문과 언어에 대한 포괄적인 이해를 제공합니다.\n"
+"* 기존 프로그램을 수정하고 러스트에서 새 프로그램을 작성할 수 있습니다.\n"
+"* 일반적인 러스트 관용구를 보여줍니다."
+
+#: src/welcome.md:14
+msgid "On Day 4, we will cover Android-specific things such as:"
+msgstr "4일차 강의에 우리는 아래와 같은 안드로이드 특유의 것들도 설명합니다."
+
+#: src/welcome.md:16
+msgid ""
+"* Building Android components in Rust.\n"
+"* AIDL servers and clients.\n"
+"* Interoperability with C, C++, and Java."
+msgstr ""
+"* 러스트에서 Android 구성 요소를 구축.\n"
+"* AIDL 서버 및 클라이언트.\n"
+"* C, C++ 및 Java와의 상호 운용성."
+
+#: src/welcome.md:20
+msgid ""
+"It is important to note that this course does not cover Android "
+"**application** \n"
+"development in Rust, and that the Android-specific parts are specifically "
+"about\n"
+"writing code for Android itself, the operating system. "
+msgstr ""
+"이 과정은 러스트로 안드로이드 **어플리케이션**을 개발하는 것은 다루는 것이 아"
+"니라,\n"
+"안드로이드 OS에서의 러스트 코드 작성을 다룹니다."
+
+#: src/welcome.md:24
+msgid "## Non-Goals"
+msgstr "## 제외사항"
+
+#: src/welcome.md:26
+msgid ""
+"Rust is a large language and we won't be able to cover all of it in a few "
+"days.\n"
+"Some non-goals of this course are:"
+msgstr ""
+"러스트는 몇일만에 모든 것을 다루기에는 너무 큰 언어입니다. 그래서 아래와 같은"
+"것을 목표로 하지 않습니다."
+
+#: src/welcome.md:29
+msgid ""
+"* Learn how to use async Rust --- we'll only mention async Rust when\n"
+"  covering traditional concurrency primitives. Please see [Asynchronous\n"
+"  Programming in Rust](https://rust-lang.github.io/async-book/) instead for\n"
+"  details on this topic.\n"
+"* Learn how to develop macros, please see [Chapter 19.5 in the Rust\n"
+"  Book](https://doc.rust-lang.org/book/ch19-06-macros.html) and [Rust by\n"
+"  Example](https://doc.rust-lang.org/rust-by-example/macros.html) instead."
+msgstr ""
+"* 비동기적 러스트 사용법 --- 간단하게 언급정도는 하겠지만 좀 더 자세한 내용"
+"은 [Asynchronous Programming in Rust](https://rust-lang.github.io/async-"
+"book/)를 참조해주세요.\n"
+"* 매크로를 개발하는 방법. [Chapter 19.5 in the Rust Book](https://doc.rust-"
+"lang.org/book/ch19-06-macros.html)와 [Rust by Example](https://doc.rust-lang."
+"org/rust-by-example/macros.html)를 참조하세요."
+
+#: src/welcome.md:37
+msgid "## Assumptions"
+msgstr "## 독자 수준에 대한 가정"
+
+#: src/welcome.md:39
+msgid ""
+"The course assumes that you already know how to program. Rust is a "
+"statically\n"
+"typed language and we will sometimes make comparisons with C and C++ to "
+"better\n"
+"explain or contrast the Rust approach."
+msgstr ""
+"본 강의는 독자가 프로그래밍 자체에 대해서는 알고 있다고 가정합니다.\n"
+"러스트는 정적타입 언어이며, 강좌에서는 C와 C++과 비교, 대조를 통해 러스트를 "
+"설명할 것입니다."
+
+#: src/welcome.md:43
+msgid ""
+"If you know how to program in a dynamically typed language such as Python "
+"or\n"
+"JavaScript, then you will be able to follow along just fine too."
+msgstr ""
+"만일 동적 타입 언어(Python이나 JavaScript 등)로 프로그래밍 하는 방법을 알고 "
+"있다면 잘 따라올 수 있을 것입니다. "
+
+#: src/welcome.md:46 src/cargo/rust-ecosystem.md:19
+#: src/cargo/code-samples.md:22 src/cargo/running-locally.md:68
+#: src/welcome-day-1.md:14 src/welcome-day-1/what-is-rust.md:19
+#: src/hello-world.md:20 src/hello-world/small-example.md:21 src/why-rust.md:9
+#: src/why-rust/compile-time.md:14 src/why-rust/runtime.md:8
+#: src/why-rust/modern.md:17 src/exercises/day-1/morning.md:9
+#: src/basic-syntax/variables.md:15 src/basic-syntax/type-inference.md:24
+#: src/basic-syntax/scopes-shadowing.md:23 src/ownership/copy-clone.md:33
+#: src/ownership/borrowing.md:25 src/ownership/shared-unique-borrows.md:23
+#: src/ownership/lifetimes-function-calls.md:27
+#: src/enums/variant-payloads.md:33 src/enums/sizes.md:31
+#: src/concurrency/threads.md:28
+msgid "<details>"
+msgstr ""
+
+#: src/welcome.md:48
+msgid ""
+"This is an example of a _speaker note_. We will use these to add additional\n"
+"information to the slides. This could be key points which the instructor "
+"should\n"
+"cover as well as answers to typical questions which come up in class."
+msgstr ""
+"이것은 _발표자 노트_의 예제입니다. 이 부분을 이용해서 추가 정보를 제공합니"
+"다. \n"
+"주로 강의실에서 제기되는 일반적인 질문에 대한 답변과 강사가 다루어야 할 키 포"
+"인트일 수 있습니다. "
+
+#: src/welcome.md:52 src/cargo/rust-ecosystem.md:67
+#: src/cargo/code-samples.md:35 src/cargo/running-locally.md:74
+#: src/welcome-day-1.md:29 src/welcome-day-1/what-is-rust.md:27
+#: src/hello-world.md:36 src/hello-world/small-example.md:44 src/why-rust.md:24
+#: src/why-rust/compile-time.md:33 src/why-rust/runtime.md:22
+#: src/why-rust/modern.md:51 src/exercises/day-1/morning.md:24
+#: src/basic-syntax/variables.md:20 src/basic-syntax/type-inference.md:44
+#: src/basic-syntax/scopes-shadowing.md:37 src/ownership/copy-clone.md:48
+#: src/ownership/borrowing.md:51 src/ownership/shared-unique-borrows.md:29
+#: src/ownership/lifetimes-function-calls.md:54
+#: src/enums/variant-payloads.md:39 src/enums/sizes.md:37
+#: src/concurrency/threads.md:45
+msgid "</details>"
+msgstr ""
+
+#: src/cargo.md:1
+msgid "# Using Cargo"
+msgstr "# 카고(Cargo) 사용하기"
+
+#: src/cargo.md:3
+msgid ""
+"When you start reading about Rust, you will soon meet [Cargo](https://doc."
+"rust-lang.org/cargo/), the standard tool\n"
+"used in the Rust ecosystem to build and run Rust applications. Here we want "
+"to\n"
+"give a brief overview of what Cargo is and how it fits into the wider "
+"ecosystem\n"
+"and how it fits into this training."
+msgstr ""
+"러스트를 시작하려고하면 당신은 곧 [Cargo](https://doc.rust-lang.org/cargo/)라"
+"는 러스트 생태계에서 사용하는 표준 빌드/실행 도구를 만날 것 입니다.  \n"
+"여기서는 카고가 무엇인지, 그리고 카고가 더 넓은 생태계에 어떻게 적합한지, 그"
+"리고 이 교육에 어떻게 적합한지에 대한 간략한 개요를 제공하고자 합니다."
+
+#: src/cargo.md:8
+msgid "## Installation"
+msgstr "## 설치하기"
+
+#: src/cargo.md:10
+msgid "### Rustup (Recommended)"
+msgstr "#### Rustup (추천)"
+
+#: src/cargo.md:12
+msgid ""
+"You can follow the instructions to install cargo and rust compiler, among "
+"other standard ecosystem tools with the [rustup][3] tool, which is "
+"maintained by the Rust Foundation."
+msgstr ""
+"러스트 재단에서 관리하고 있는 [rustup][3] 도구를 사용하여 카고 및 러스트 컴파"
+"일러 등 표준 생태계 도구를 설치 할 수 있습니다."
+
+#: src/cargo.md:14
+msgid ""
+"Along with cargo and rustc, Rustup will install itself as a command line "
+"utility that you can use to install/switch toolchains, setup cross "
+"compilation, etc."
+msgstr ""
+"rustup은 cargo, rustc와 함께 툴체인의 설치.전환, 교차 컴파일 설정등에  사용 "
+"되는 cli 유틸리티로 자체 설치됩니다. "
+
+#: src/cargo.md:16
+msgid "### Package Managers"
+msgstr "### 패키지 매니저"
+
+#: src/cargo.md:18
+msgid "#### Debian"
+msgstr "#### 데비안"
+
+#: src/cargo.md:20
+msgid "On Debian/Ubuntu, you can install Cargo and the Rust source with"
+msgstr "Debian이나 Ubuntu에서 cargo와 rust-src를 아래 커맨드로 설치합니다. "
+
+#: src/cargo.md:22
+msgid ""
+"```shell\n"
+"$ sudo apt install cargo rust-src\n"
+"```"
+msgstr ""
+
+#: src/cargo.md:26
+msgid ""
+"This will allow [rust-analyzer][1] to jump to the definitions. We suggest "
+"using\n"
+"[VS Code][2] to edit the code (but any LSP compatible editor works)."
+msgstr ""
+"[VS Code][2]에서 작업하는 걸 추천 드립니다. [rust-analyzer][1] 확장을 통해  "
+"정의 이동 등 개발에 도움 받을 수 있습니다.(또는 다른 IDE나 편집기를  사용해"
+"도 무방합니다.)"
+
+#: src/cargo.md:29
+msgid ""
+"Some folks also like to use the [Jetbrains][4] family of IDEs, which do "
+"their own analysis but have their own tradeoffs. If you prefer them, you can "
+"install the [Rust Plugin][5]. Please take note that as of January 2023 "
+"debugging only works on the CLion version of the Jetbrains IDEA suite."
+msgstr ""
+"일부는 자체 분석을 수행하지만 자체적인 장단점을 가진 [Jetbrains][4]  제품군"
+"을 사용하는걸 선호합니다. 이 경우, [러스트 플러그인][5]을 설치  할 수 있습니"
+"다. 다만 2023년 1월 기준, 디버깅은 Jetbrains IDEA suite의  CLion 버전에서만 "
+"작동한다는 점에 유의하시기 바랍니다."
+
+#: src/cargo.md:31
+msgid ""
+"[1]: https://rust-analyzer.github.io/\n"
+"[2]: https://code.visualstudio.com/\n"
+"[3]: https://rustup.rs/\n"
+"[4]: https://www.jetbrains.com/clion/\n"
+"[5]: https://www.jetbrains.com/rust/"
+msgstr ""
+
+#: src/cargo/rust-ecosystem.md:1
+msgid "# The Rust Ecosystem"
+msgstr "# 러스트 생태계"
+
+#: src/cargo/rust-ecosystem.md:3
+msgid ""
+"The Rust ecosystem consists of a number of tools, of which the main ones are:"
+msgstr ""
+"러스트의 생태계는 여러가지 도구들로 구성되어 있으며, 그 중 중요한 것들은 아래"
+"와 같습니다: "
+
+#: src/cargo/rust-ecosystem.md:5
+msgid ""
+"* `rustc`: the Rust compiler which turns `.rs` files into binaries and "
+"other\n"
+"  intermediate formats[^rustc]."
+msgstr ""
+"* `rustc`: `.rs`확장자 파일을 바이너리 혹은 다른 중간자 형식으로 변환해주는  "
+"Rust 컴파일러입니다."
+
+#: src/cargo/rust-ecosystem.md:8
+msgid ""
+"* `cargo`: the Rust dependency manager and build tool. Cargo knows how to\n"
+"  download dependencies hosted on <https://crates.io> and it will pass them "
+"to\n"
+"  `rustc` when building your project. Cargo also comes with a built-in test\n"
+"  runner which is used to execute unit tests[^cargo]."
+msgstr ""
+"* `cargo`: 러스트 종속성 관리자 및 빌드도구 입니다. <https://crates.io>에서 "
+"호스팅되는 여러 종속성을 다운로드하고 `rustc`가 당신의 프로젝트를 빌드할 때 "
+"이를 전달합니다. \n"
+"  또한 유닛 테스트를 실행하는 테스트 툴을 내장하고 있습니다."
+
+#: src/cargo/rust-ecosystem.md:13
+msgid ""
+"* `rustup`: the Rust toolchain installer and updater. This tool is used to\n"
+"  install and update `rustc` and `cargo` when new versions of Rust is "
+"released.\n"
+"  In addition, `rustup` can also download documentation for the standard\n"
+"  library. You can have multiple versions of Rust installed at once and "
+"`rustup`\n"
+"  will let you switch between them as needed."
+msgstr ""
+"* `rustup`: 러스트 툴체인 설치 프로그램 및 업데이트 프로그램. \n"
+"  이 도구는 새 버전의 러스트가 출시될 때 `rustc` 및 `cargo` 설치하고 업데이트"
+"하는 데 사용됩니다. \n"
+"  또한 `rustup`은 표준 라이브러리에 대한 문서를 다운로드할 수도 있습니다. \n"
+"  한 번에 여러 버전의 러스트를 설치할 수 있으며 `rustup`을 통해 필요에 따라 "
+"이들 버전을 전환할 수 있습니다"
+
+#: src/cargo/rust-ecosystem.md:21 src/hello-world.md:25
+#: src/hello-world/small-example.md:27 src/why-rust/runtime.md:10
+#: src/why-rust/modern.md:19 src/concurrency/threads.md:30
+msgid "Key points:"
+msgstr "키포인트:"
+
+#: src/cargo/rust-ecosystem.md:23
+msgid ""
+"* Rust has a rapid release schedule with a new release coming out\n"
+"  every six weeks. New releases maintain backwards compatibility with\n"
+"  old releases --- plus they enable new functionality."
+msgstr ""
+"* 러스트는 6주마다 새로운 릴리즈가 발표되며 이전 릴리즈와의 호환성을 유지하\n"
+"고 있습니다."
+
+#: src/cargo/rust-ecosystem.md:27
+msgid ""
+"* There are three release channels: \"stable\", \"beta\", and \"nightly\"."
+msgstr ""
+"* 릴리즈는 3가지 버전으로 제공됩니다: \"stable\", \"beta\" 그리고\n"
+"\"nightly\"."
+
+#: src/cargo/rust-ecosystem.md:29
+msgid ""
+"* New features are being tested on \"nightly\", \"beta\" is what becomes\n"
+"  \"stable\" every six weeks."
+msgstr ""
+"* 새로운 기능은 \"nightly\" -> \"beta\" -(6주 후)-> \"stable\" 로 변경됩니다."
+
+#: src/cargo/rust-ecosystem.md:32
+msgid ""
+"* Rust also has [editions]: the current edition is Rust 2021. Previous\n"
+"  editions were Rust 2015 and Rust 2018."
+msgstr ""
+"* 러스트는 [editions]으로 으로 진행됩니다: 현재는 Rust 2021 에디션입니다. "
+"그\n"
+"전에는 Rust 2015와 Rust 2018입니다."
+
+#: src/cargo/rust-ecosystem.md:35
+msgid ""
+"  * The editions are allowed to make backwards incompatible changes to\n"
+"    the language."
+msgstr "  * 에디션은 이전 에디션과 호환이 되지 않을 수 있습니다."
+
+#: src/cargo/rust-ecosystem.md:38
+msgid ""
+"  * To prevent breaking code, editions are opt-in: you select the\n"
+"    edition for your crate via the `Cargo.toml` file."
+msgstr ""
+"  * 프로그램 붕괴를 방지하기 위해 에디션은 옵션입니다: `Cargo.toml`에서 지정"
+"할 수 있습니다."
+
+#: src/cargo/rust-ecosystem.md:41
+msgid ""
+"  * To avoid splitting the ecosystem, Rust compilers can mix code\n"
+"    written for different editions."
+msgstr ""
+"  * 생태계가 분열되는 것을 막기 위해 러스트 컴파일러는 다른 에디션에서 작성"
+"된 코드의 혼합이 가능합니다."
+
+#: src/cargo/rust-ecosystem.md:44
+msgid ""
+"  * Mention that it is quite rare to ever use the compiler directly not "
+"through `cargo` (most users never do)."
+msgstr ""
+"  * `cargo`를 사용하지 않고 컴파일러를 직접 사용하는 경우는 거의 없음을  언급"
+"해 주시기 바랍니다."
+
+#: src/cargo/rust-ecosystem.md:46
+msgid ""
+"  * It might be worth alluding that Cargo itself is an extremely powerful "
+"and comprehensive tool.  It is capable of many advanced features including "
+"but not limited to: \n"
+"      * Project/package structure\n"
+"      * [workspaces]\n"
+"      * Dev Dependencies and Runtime Dependency management/caching\n"
+"      * [build scripting]\n"
+"      * [global installation]\n"
+"      * It is also extensible with sub command plugins as well (such as "
+"[cargo clippy]).\n"
+"  * Read more from the [official Cargo Book]"
+msgstr ""
+"  * cargo 자체가 매우 강력하고 포괄적인 도구임을 암시할 가치가 있습니다.\n"
+"  다음과 같은 다양한 고급 기능을 제공합니다.\n"
+"      * 프로젝트/패키지 구조화\n"
+"      * [workspaces]\n"
+"      * 개발/런타임 종속성 관리 및 캐싱\n"
+"      * [build scripting]\n"
+"      * [global installation]\n"
+"      * [cargo clippy]와 같은 하위 플러그인으로 확장 가능\n"
+"  * [official Cargo Book]에서 자세한 사항을 확인하시기 바랍니다."
+
+#: src/cargo/rust-ecosystem.md:55
+msgid "[editions]: https://doc.rust-lang.org/edition-guide/"
+msgstr ""
+
+#: src/cargo/rust-ecosystem.md:57
+msgid "[workspaces]: https://doc.rust-lang.org/cargo/reference/workspaces.html"
+msgstr ""
+
+#: src/cargo/rust-ecosystem.md:59
+msgid ""
+"[build scripting]: https://doc.rust-lang.org/cargo/reference/build-scripts."
+"html"
+msgstr ""
+
+#: src/cargo/rust-ecosystem.md:61
+msgid ""
+"[global installation]: https://doc.rust-lang.org/cargo/commands/cargo-"
+"install.html"
+msgstr ""
+
+#: src/cargo/rust-ecosystem.md:63
+msgid "[cargo clippy]: https://github.com/rust-lang/rust-clippy"
+msgstr ""
+
+#: src/cargo/rust-ecosystem.md:65
+msgid "[official Cargo Book]: https://doc.rust-lang.org/cargo/"
+msgstr ""
+
+#: src/cargo/code-samples.md:1
+msgid "# Code Samples in This Training"
+msgstr "# 강의에서의 코드 샘플"
+
+#: src/cargo/code-samples.md:3
+msgid ""
+"For this training, we will mostly explore the Rust language through "
+"examples\n"
+"which can be executed through your browser. This makes the setup much easier "
+"and\n"
+"ensures a consistent experience for everyone."
+msgstr ""
+"이 교육을 위해 우리는 당신의 브라우저에서 실행될 수 있는 예제를 제공할 것입니"
+"다. \n"
+"이렇게 하면 설치가 훨씬 쉬워지고 모든 사용자가 일관된 환경을 사용할 수 있게됩"
+"니다."
+
+#: src/cargo/code-samples.md:7
+msgid ""
+"Installing Cargo is still encouraged: it will make it easier for you to do "
+"the\n"
+"exercises. On the last day, we will do a larger exercise which shows you how "
+"to\n"
+"work with dependencies and for that you need Cargo."
+msgstr ""
+"카고(cargo)를 설치하는 것은 학습을 더 쉽게 만들어 줍니다. \n"
+"마지막 날 강의에서 카고를 필요로 하는 의존성을 가지고 작업하는 경험을 할 것입"
+"니다."
+
+#: src/cargo/code-samples.md:11
+msgid "The code blocks in this course are fully interactive:"
+msgstr "이 과정의 코드 블록들은 전부 대화형으로 구성되 있습니다. "
+
+#: src/cargo/code-samples.md:13
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    println!(\"Edit me!\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/cargo/code-samples.md:19
+msgid ""
+"You can use <kbd>Ctrl-Enter</kbd> to execute the code when focus is in the "
+"text\n"
+"box."
+msgstr ""
+"코드 블록에 포커스를 두고 <kbd>Ctrl-Enter</kbd>를 눌러 실행해 볼 수 있습니"
+"다. "
+
+#: src/cargo/code-samples.md:24
+msgid ""
+"Most code samples are editable like shown above. A few code samples\n"
+"are not editable for various reasons:"
+msgstr ""
+"강의에서 대부분의 코드 샘플은 위와 같이 수정할수 있지만 일부 코드는 다음과  "
+"같은 이유로 수정할 수 없습니다: "
+
+#: src/cargo/code-samples.md:27
+msgid ""
+"* The embedded playgrounds cannot execute unit tests. Copy-paste the\n"
+"  code and open it in the real Playground to demonstrate unit tests."
+msgstr ""
+"* 유닛 테스트는 내장 플레이그라운드에서 실행이 안됩니다. 외부 플레이그라운"
+"드 \n"
+"  사이트에 붙여넣어 테스트를 실행하시기 바랍니다."
+
+#: src/cargo/code-samples.md:30
+msgid ""
+"* The embedded playgrounds lose their state the moment you navigate\n"
+"  away from the page! This is the reason that the students should\n"
+"  solve the exercises using a local Rust installation or via the\n"
+"  Playground."
+msgstr ""
+"* 내장된 플레이그라운드에서는 페이지 이동시 작성된 모든 내용이 사라집니다.  "
+"따라서 로컬 환경이나 외부 플레이그라운드 사이트에서 연습문제를 해결하는 것이 "
+"좋습니다."
+
+#: src/cargo/running-locally.md:1
+msgid "# Running Code Locally with Cargo"
+msgstr "# 로컬 환경의 카고"
+
+#: src/cargo/running-locally.md:3
+msgid ""
+"If you want to experiment with the code on your own system, then you will "
+"need\n"
+"to first install Rust. Do this by following the [instructions in the Rust\n"
+"Book][1]. This should give you a working `rustc` and `cargo`. At the time "
+"of\n"
+"writing, the latest stable Rust release has these version numbers:"
+msgstr ""
+"만약 당신이 로컬 시스템에서 코드를 실행해보려면 먼저 러스트를 설치해야  합니"
+"다.  \n"
+"[Rust Book][1]의 지침에 따라 `rustc`와 `cargo`를 함께  설치 하시기 바랍니"
+"다.  \n"
+"  설치 후 아래 커맨드를 통해 각 생태계 툴의 버전을 확인 할 수 있습니다. "
+
+#: src/cargo/running-locally.md:8
+msgid ""
+"```shell\n"
+"% rustc --version\n"
+"rustc 1.61.0 (fe5b13d68 2022-05-18)\n"
+"% cargo --version\n"
+"cargo 1.61.0 (a028ae4 2022-04-29)\n"
+"```"
+msgstr ""
+
+#: src/cargo/running-locally.md:15
+msgid ""
+"With this is in place, then follow these steps to build a Rust binary from "
+"one\n"
+"of the examples in this training:"
+msgstr ""
+"정상적으로 설치가 되었으면 강의의 코드 블록중 하나를 아래 단계를 따라 로컬에"
+"서 실행할 수 있습니다."
+
+#: src/cargo/running-locally.md:18
+msgid ""
+"1. Click the \"Copy to clipboard\" button on the example you want to copy."
+msgstr "1. 예시 블록에 있는 \"Copy to clipboard\"버튼을 클릭해서 복사합니다."
+
+#: src/cargo/running-locally.md:20
+msgid ""
+"2. Use `cargo new exercise` to create a new `exercise/` directory for your "
+"code:"
+msgstr ""
+"2. 터미널에서 `cargo new exercise`를 입력해서 새로운 `exercise/` 폴더를 만듭"
+"니다."
+
+#: src/cargo/running-locally.md:22
+msgid ""
+"    ```shell\n"
+"    $ cargo new exercise\n"
+"         Created binary (application) `exercise` package\n"
+"    ```"
+msgstr ""
+
+#: src/cargo/running-locally.md:27
+msgid ""
+"3. Navigate into `exercise/` and use `cargo run` to build and run your "
+"binary:"
+msgstr ""
+"3. `exercise/` 폴더로 이동한 후, `cargo run` 커맨드로 코드를 실행합니다."
+
+#: src/cargo/running-locally.md:29
+msgid ""
+"    ```shell\n"
+"    $ cd exercise\n"
+"    $ cargo run\n"
+"       Compiling exercise v0.1.0 (/home/mgeisler/tmp/exercise)\n"
+"        Finished dev [unoptimized + debuginfo] target(s) in 0.75s\n"
+"         Running `target/debug/exercise`\n"
+"    Hello, world!\n"
+"    ```"
+msgstr ""
+
+#: src/cargo/running-locally.md:38
+msgid ""
+"4. Replace the boiler-plate code in `src/main.rs` with your own code. For\n"
+"   example, using the example on the previous page, make `src/main.rs` look "
+"like"
+msgstr ""
+"4. `src/main.rs`에 코드를 작성합니다. 예를 들어 이전 페이지의 소스를 아래와 "
+"같이 `src/main.rs`에 작성합니다."
+
+#: src/cargo/running-locally.md:41
+msgid ""
+"    ```rust\n"
+"    fn main() {\n"
+"        println!(\"Edit me!\");\n"
+"    }\n"
+"    ```"
+msgstr ""
+
+#: src/cargo/running-locally.md:47
+msgid "5. Use `cargo run` to build and run your updated binary:"
+msgstr "5. `cargo run`커맨드로 소스를 빌드하고 실행합니다."
+
+#: src/cargo/running-locally.md:49
+msgid ""
+"    ```shell\n"
+"    $ cargo run\n"
+"       Compiling exercise v0.1.0 (/home/mgeisler/tmp/exercise)\n"
+"        Finished dev [unoptimized + debuginfo] target(s) in 0.24s\n"
+"         Running `target/debug/exercise`\n"
+"    Edit me!\n"
+"    ```"
+msgstr ""
+
+#: src/cargo/running-locally.md:57
+msgid ""
+"6. Use `cargo check` to quickly check your project for errors, use `cargo "
+"build`\n"
+"   to compile it without running it. You will find the output in `target/"
+"debug/`\n"
+"   for a normal debug build. Use `cargo build --release` to produce an "
+"optimized\n"
+"   release build in `target/release/`."
+msgstr ""
+"6. `cargo check`커맨드는 빠르게 당신의 프로젝트에서 에러를 확인할 수  있습니"
+"다. \n"
+"    * `cargo build`는 실행없이 소스를 컴파일 합니다.  이 경우에 `target/"
+"debug/`폴더에서 output을 확인 할 수 있습니다. \n"
+"    * `cargo build --release`커맨드는 릴리즈 버전의 최적화된 output으로  컴파"
+"일하며 `target/release/`폴더에서 확인 할 수 있습니다."
+
+#: src/cargo/running-locally.md:62
+msgid ""
+"7. You can add dependencies for your project by editing `Cargo.toml`. When "
+"you\n"
+"   run `cargo` commands, it will automatically download and compile missing\n"
+"   dependencies for you."
+msgstr ""
+"7. `Cargo.toml`파일에는 당신의 프로젝트에 사용하는 의존성 패키지를 추가할 "
+"수  있습니다. \n"
+"    - `cargo`커맨드를 실행하면 자동으로 프로젝트의 의존성 패키지를 다운로"
+"드,  컴파일 해줍니다."
+
+#: src/cargo/running-locally.md:66
+msgid "[1]: https://doc.rust-lang.org/book/ch01-01-installation.html"
+msgstr ""
+
+#: src/cargo/running-locally.md:70
+msgid ""
+"Try to encourage the class participants to install Cargo and use a\n"
+"local editor. It will make their life easier since they will have a\n"
+"normal development environment."
+msgstr ""
+"강의 참여자들이 카고를 설치하고 로컬 편집기를 이용하는 것을 추천합니다.  \n"
+"이 편이 좀 더 정상적인 개발환경을 갖출 수 있습니다."
+
+#: src/structure.md:1
+msgid "# Course Structure"
+msgstr "# 강의 구성"
+
+#: src/structure.md:3
+msgid ""
+"The course is fast paced and we will cover a lot of ground over the next "
+"3--4\n"
+"days:"
+msgstr ""
+"강의는 빠른 속도로 진행되며 다음 3,4일동안 많은 범위의 부분을 다룹니다:"
+
+#: src/structure.md:6
+msgid ""
+"* Day 1: Basic Rust, ownership and the borrow checker.\n"
+"* Day 2: Compound data types,  pattern matching, the standard library.\n"
+"* Day 3: Traits and generics, error handling, testing, unsafe Rust.\n"
+"* Day 4: Concurrency in Rust and interoperability with other languages"
+msgstr ""
+"* 1일차: 러스트 기본, 소유권(ownership)과 빌림(borrow) 체크.\n"
+"* 2일차: 복합 데이터 유형, 패턴 매칭, 표준 라이브러리\n"
+"* 3일차: 트레잇(traits)과 제너릭(generics), 에러 핸들링(오류 처리), 테스트, "
+"안전하지 않은 러스트.\n"
+"* 4일차: 러스트의 동시성 및 다른 언어와의 상호 운용성"
+
+#: src/structure.md:11
+msgid ""
+"> **Exercise for Day 4:** Do you interface with some C/C++ code in your "
+"project\n"
+"> which we could attempt to move to Rust? The fewer dependencies the "
+"better.\n"
+"> Parsing code would be ideal."
+msgstr ""
+" **4일차의 연습:** 러스트 프로젝트에서 C/C++로 작성된 코드를 이전해서  연결하"
+"려고 한다면 종속성이 적을 수록 좋습니다.  코드를 구문분석하는 것이 이상적입니"
+"다."
+
+#: src/structure.md:15
+msgid "## Format"
+msgstr "## 강의 형식"
+
+#: src/structure.md:17
+msgid ""
+"The course is interactive and your questions will drive our exploration of "
+"Rust!"
+msgstr "강의는 대화식이며 당신의 질문이 러스트 탐험을 이끌 것입니다!"
+
+#: src/structure.md:19
+msgid ""
+"* Please ask questions when you get them, don't save them to the end.\n"
+"* Discussions are very much encouraged!\n"
+"* We will likely talk about things ahead of the slides.\n"
+"  * The slides are just a support and we are free to skip them as we like."
+msgstr ""
+"* 질문이 생기면 질문해주세요\n"
+"* 토론은 매우 권장됩니다!\n"
+"* 강의의 자료는 참고자료일 뿐으로 건너띌 수 있습니다."
+
+#: src/welcome-day-1.md:1
+msgid "# Welcome to Day 1"
+msgstr "# 개요"
+
+#: src/welcome-day-1.md:3
+msgid ""
+"This is the first day of Comprehensive Rust. We will cover a lot of ground\n"
+"today:"
+msgstr "강의의 첫 날입니다. 우리는 오늘 많은 부분을 다룰 것입니다."
+
+#: src/welcome-day-1.md:6
+msgid ""
+"* Basic Rust syntax: variables, scalar and compound types, enums, structs,\n"
+"  references, functions, and methods."
+msgstr ""
+"* 러스트 기본 문법: 변수, 스칼라 / 복합 타입, 열거형, 구조체, 참조형, 함수"
+"와  메서드."
+
+#: src/welcome-day-1.md:9
+msgid ""
+"* Memory management: stack vs heap, manual memory management, scope-based "
+"memory\n"
+"  management, and garbage collection."
+msgstr ""
+"* 메모리 관리: 스택과 힙, 수동 메모리 관리, 스코프(범위)기반 메모리 관리,  가"
+"비지 컬렉션(GC)"
+
+#: src/welcome-day-1.md:12
+msgid ""
+"* Ownership: move semantics, copying and cloning, borrowing, and lifetimes."
+msgstr "* 소유권: 의미 이동, 복사와 복제, 빌림, 수명."
+
+#: src/welcome-day-1.md:16
+msgid ""
+"The idea for the first day is to show _just enough_ of Rust to be able to "
+"speak\n"
+"about the famous borrow checker. The way Rust handles memory is a major "
+"feature\n"
+"and we should show students this right away."
+msgstr ""
+"첫 날 강의의 목표는 빌림 확인 등 강의에서 다룬 주제에 대해 이야기 할수 있을 "
+"정도로 익숙해지도록 하는 것입니다. \n"
+"러스트가 메모리를 다루는 방식은 주요한 특징이며 우리는 학생들에게 우선해서 보"
+"여주려고 합니다. "
+
+#: src/welcome-day-1.md:20
+msgid ""
+"If you're teaching this in a classroom, this is a good place to go over the\n"
+"schedule. We suggest splitting the day into two parts (following the slides):"
+msgstr ""
+"만약 당신이 교실환경에서 가르치고 있다면, 이 슬라이드는 일정을 검토하기에 \n"
+"적합한 곳입니다.우리는 하루의 강의를 슬라이드에 따라서 두 부분으로 나누는 것"
+"을 추천합니다."
+
+#: src/welcome-day-1.md:23
+msgid ""
+"* Morning: 9:00 to 12:00,\n"
+"* Afternoon: 13:00 to 16:00."
+msgstr ""
+"* 오전: 9:00 to 12:00,\n"
+"* 오후: 13:00 to 16:00."
+
+#: src/welcome-day-1.md:26
+msgid ""
+"You can of course adjust this as necessary. Please make sure to include "
+"breaks,\n"
+"we recommend a break every hour!"
+msgstr ""
+"물론 필요에 따라 조절할 수 있습니다. 강의 중간에 쉬는시간을 넣는걸 부탁드립니"
+"다. 매 시간 휴식을 갖는걸 추천드립니다."
+
+#: src/welcome-day-1/what-is-rust.md:1
+msgid "# What is Rust?"
+msgstr "# 러스트란?"
+
+#: src/welcome-day-1/what-is-rust.md:3
+msgid "Rust is a new programming language which had its 1.0 release in 2015:"
+msgstr "러스트는 2015년 1.0으로 릴리즈된 새로운 프로그램 언어입니다: "
+
+#: src/welcome-day-1/what-is-rust.md:5
+msgid ""
+"* Rust is a statically compiled language in a similar role as C++\n"
+"  * `rustc` uses LLVM as its backend.\n"
+"* Rust supports many [platforms and\n"
+"  architectures](https://doc.rust-lang.org/nightly/rustc/platform-support."
+"html):\n"
+"  * x86, ARM, WebAssembly, ...\n"
+"  * Linux, Mac, Windows, ...\n"
+"* Rust is used for a wide range of devices:\n"
+"  * firmware and boot loaders,\n"
+"  * smart displays,\n"
+"  * mobile phones,\n"
+"  * desktops,\n"
+"  * servers."
+msgstr ""
+"* 러스트는 C++과 비슷한 역할을 하는 정적 컴파일 언어입니다.\n"
+"  * 'rustc'는 LLVM을 백엔드로 사용합니다.\n"
+"* 러스트는 다양한 플랫폼과 아키텍쳐를 지원합니다.\n"
+"  * x86, ARM, WebAssembly, ...\n"
+"  * Linux, Mac, Windows, ...\n"
+"* 러스트는 넓은 범위의 장치에 적용될 수 있습니다. \n"
+"  * 펌웨어와 부트로더(임베디드)\n"
+"  * 스마트 디스플레이\n"
+"  * 스마트폰\n"
+"  * 데스크탑\n"
+"  * 서버"
+
+#: src/welcome-day-1/what-is-rust.md:21
+msgid "Rust fits in the same area as C++:"
+msgstr "러스트는 C++과 동일한 영역에서 사용됩니다."
+
+#: src/welcome-day-1/what-is-rust.md:23
+msgid ""
+"* High flexibility.\n"
+"* High level of control.\n"
+"* Can be scaled down to very constrained devices like mobile phones."
+msgstr ""
+"* 높은 유연성\n"
+"* 높은 레벨 수준의 제어\n"
+"* 휴대폰과 같은 매우 제한된 장치로 스케일 다운 가능."
+
+#: src/hello-world.md:1
+msgid "# Hello World!"
+msgstr ""
+
+#: src/hello-world.md:3
+msgid ""
+"Let us jump into the simplest possible Rust program, a classic Hello World\n"
+"program:"
+msgstr ""
+"가장 간단한 러스트 프로그램으로 고전적인 Hello World 출력 프로그램을 작성해 "
+"보겠습니다."
+
+#: src/hello-world.md:6
+msgid ""
+"```rust\n"
+"fn main() {\n"
+"    println!(\"Hello 🌍!\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/hello-world.md:12
+msgid "What you see:"
+msgstr "확인 할 수 있는 것들: "
+
+#: src/hello-world.md:14
+msgid ""
+"* Functions are introduced with `fn`.\n"
+"* Blocks are delimited by curly braces like in C and C++.\n"
+"* The `main` function is the entry point of the program.\n"
+"* Rust has hygienic macros, `println!` is an example of this.\n"
+"* Rust strings are UTF-8 encoded and can contain any Unicode character."
+msgstr ""
+"* 함수는 `fn`으로 선언됩니다.\n"
+"* C/C++과 마찬가지로 중괄호`{}`로 블록을 표시합니다. \n"
+"* `main` 함수는 프로그램 진입점입니다. \n"
+"* 러스트는 위생적인 매크로(hygienic macros)를 가지고 있습니다.   `println!`"
+"는 그 예시입니다. \n"
+"* 러스트의 문자열은 UTF-8로 인코딩되며 이모지와 같은 유니코드 문자를 포함할 "
+"수 있습니다."
+
+#: src/hello-world.md:22
+msgid ""
+"This slide tries to make the students comfortable with Rust code. They will "
+"see\n"
+"a ton of it over the next four days so we start small with something "
+"familiar."
+msgstr ""
+"이 슬라이드는 학생들이 러스트 코드에 익숙해지기 위해 작성되었습니다.앞으로 4"
+"일 동안 많은 코드를 접할 것이기 때문에 우선 친숙한 코드부터 시작합니다."
+
+#: src/hello-world.md:27
+msgid ""
+"* Rust is very much like other languages in the C/C++/Java tradition. It is\n"
+"  imperative (not functional) and it doesn't try to reinvent things unless\n"
+"  absolutely necessary."
+msgstr ""
+"* 러스트는 C/C++/Java와 같은 전통적인 다른 언어와 매우 유사합니다.  필수적이"
+"고 절대적으로 필요하지 않는 한 새로운 기능을 재창조하지 않았습니다."
+
+#: src/hello-world.md:31
+msgid "* Rust is modern with full support for things like Unicode."
+msgstr "* 러스트는 유니코드 지원과 같은 현대 언어의 특징을 전부 지원합니다."
+
+#: src/hello-world.md:33
+msgid ""
+"* Rust uses macros for situations where you want to have a variable number "
+"of\n"
+"  arguments (no function [overloading](basic-syntax/functions-interlude.md))."
+msgstr ""
+"* 러스트는 변수가 여러 종류로 요구되는 상황에서 함수 [오버로딩](basic-syntax/"
+"functions-interlude.md)기능 대신 매크로를 사용합니다.\n"
+"\n"
+"역주 \n"
+"* 매크로: 다른 코드를 작성하는 코드입니다(meta-programming).   런타임이 아닌 "
+"컴파일 전에 대치 작업이 이뤄지는데 C계열의 #define 문법을   생각하시면 됩니"
+"다.\n"
+"* 위생적인 매크로(hygienic macros, 위키)는 식별자가 겹치지 않음이 보장되는   "
+"매크로… 라는데 일단은 그렇구나하고 진행 "
+
+#: src/hello-world/small-example.md:1
+msgid "# Small Example"
+msgstr "# 작은 예제"
+
+#: src/hello-world/small-example.md:3
+msgid "Here is a small example program in Rust:"
+msgstr "러스트로 작성된 작은 예제입니다. "
+
+#: src/hello-world/small-example.md:5
+msgid ""
+"```rust,editable\n"
+"fn main() {              // Program entry point\n"
+"    let mut x: i32 = 6;  // Mutable variable binding\n"
+"    print!(\"{x}\");       // Macro for printing, like printf\n"
+"    while x != 1 {       // No parenthesis around expression\n"
+"        if x % 2 == 0 {  // Math like in other languages\n"
+"            x = x / 2;\n"
+"        } else {\n"
+"            x = 3 * x + 1;\n"
+"        }\n"
+"        print!(\" -> {x}\");\n"
+"    }\n"
+"    println!();\n"
+"}\n"
+"```"
+msgstr ""
+"```rust,editable\n"
+"fn main() {              // 프로그램 진입점입니다.\n"
+"    let mut x: i32 = 6;  // 가변 변수 할당(binding)입니다.\n"
+"    print!(\"{x}\");       // printf와 같은 출력을 위한 매크로 입니다.\n"
+"    while x != 1 {       // 표현식에 괄호는 없습니다.\n"
+"        if x % 2 == 0 {  // 다른 언어와 같은 수학연산식이 사용됩니다.\n"
+"            x = x / 2;\n"
+"        } else {\n"
+"            x = 3 * x + 1;\n"
+"        }\n"
+"        print!(\" -> {x}\");\n"
+"    }\n"
+"    println!();\n"
+"}\n"
+"```"
+
+#: src/hello-world/small-example.md:23
+msgid ""
+"The code implements the Collatz conjecture: it is believed that the loop "
+"will\n"
+"always end, but this is not yet proved. Edit the code and play with "
+"different\n"
+"inputs."
+msgstr ""
+"이 코드는 콜라츠 추측(Collatz conjecture)으로 구현됩니다:반복문이 언제나 종료"
+"될 것이라고 믿지만 증명된 것은 아닙니다. 코드를 수정하고 실행해 보시기 바랍니"
+"다."
+
+#: src/hello-world/small-example.md:29
+msgid ""
+"* Explain that all variables are statically typed. Try removing `i32` to "
+"trigger\n"
+"  type inference. Try with `i8` instead and trigger a runtime integer "
+"overflow."
+msgstr ""
+"* 모든 변수가 정적으로 입력됨을 설명합니다. i32를 삭제하여 유형 추론을 유발"
+"해 볼 수 있습니다. i32대신 i8로 변경하여 런타임 오버플로를 유발해 볼 수 있습"
+"니다."
+
+#: src/hello-world/small-example.md:32
+msgid "* Change `let mut x` to `let x`, discuss the compiler error."
+msgstr "* `let mut x`를 `let x`로 수정하여 컴파일 오류에 대해 토론합니다."
+
+#: src/hello-world/small-example.md:34
+msgid ""
+"* Show how `print!` gives a compilation error if the arguments don't match "
+"the\n"
+"  format string."
+msgstr ""
+"* 인수가 포맷 문자열과 일치하지 않는 경우 print!에서의 컴파일 오류가 발생함"
+"을  언급하는 것도 좋습니다."
+
+#: src/hello-world/small-example.md:37
+msgid ""
+"* Show how you need to use `{}` as a placeholder if you want to print an\n"
+"  expression which is more complex than just a single variable."
+msgstr ""
+"* 단일 변수보다 복잡한 식을 인쇄하려면 `{}`을(를) 자리 표시자로 사용하는   방"
+"법을 보여 줍니다."
+
+#: src/hello-world/small-example.md:40
+msgid ""
+"* Show the students the standard library, show them how to search for `std::"
+"fmt`\n"
+"  which has the rules of the formatting mini-language. It's important that "
+"the\n"
+"  students become familiar with searching in the standard library."
+msgstr ""
+"학생들에게 표준 라이브러리를 보여주고, 미니 언어 형식의 규칙이 있는  std::fmt"
+"를 검색하는 방법을 보여줍니다. 학생들이 표준 라이브러리에서 검색하는  것에 익"
+"숙해지는 것이 중요합니다."
+
+#: src/why-rust.md:1
+msgid "# Why Rust?"
+msgstr "# 러스트를 써야하는 이유"
+
+#: src/why-rust.md:3
+msgid "Some unique selling points of Rust:"
+msgstr "러스트만의 독특한 세일즈 포인트(장점):"
+
+#: src/why-rust.md:5
+msgid ""
+"* Compile time memory safety.\n"
+"* Lack of undefined runtime behavior.\n"
+"* Modern language features."
+msgstr ""
+"* 컴파일 시 메모리 안전\n"
+"* 정의되지 않은 런타임 동작이 없습니다.\n"
+"* 모던한 언어적 특징"
+
+#: src/why-rust.md:11
+msgid ""
+"Make sure to ask the class which languages they have experience with. "
+"Depending\n"
+"on the answer you can highlight different features of Rust:"
+msgstr ""
+"강의 참여자들에게 프로그래밍 언어 사용 경험을 물어보시기 바랍니다. 경험에 따"
+"라 러스트의 다양한 기능을 강조할 수 있습니다:"
+
+#: src/why-rust.md:14
+msgid ""
+"* Experience with C or C++: Rust eliminates a whole class of _runtime "
+"errors_\n"
+"  via the borrow checker. You get performance like in C and C++, but you "
+"don't\n"
+"  have the memory unsafety issues. In addition, you get a modern language "
+"with\n"
+"  constructs like pattern matching and built-in dependency management."
+msgstr ""
+"* C/C++ : 러스트는 '빌림'검사를 통해 전체 클래스의 런타임 에러를 제거합니다. "
+"C/C++ 처럼 성능은 확보되지만 메모리 안정성에 대한 문제가 없습니다. 또한, 패턴"
+"매칭이나 내장 종속성 관리 같은 현대언어 기능을 가질 수 있습니다."
+
+#: src/why-rust.md:19
+msgid ""
+"* Experience with Java, Go, Python, JavaSript...: You get the same memory "
+"safety\n"
+"  as in those languages, plus a similar high-level language feeling. In "
+"addition\n"
+"  you get fast and predictable performance like C and C++ (no garbage "
+"collector)\n"
+"  as well as access to low-level hardware (should you need it)"
+msgstr ""
+"* Java, Go, Python, JaveScript : 해당 언어들과 동일한 메모리 안정성과 '하이레"
+"벨'언어의 느낌을 느낄 수 있습니다. 또한, GC가 없는 C/C++과 같이 빠르고 예측 "
+"가능한 성능을 얻을 수 있고 필요한 경우 하드웨어의 로우레벨까지 접근 할 수 있"
+"습니다. "
+
+#: src/why-rust/compile-time.md:1
+msgid "# Compile Time Guarantees"
+msgstr "# 컴파일 보증"
+
+#: src/why-rust/compile-time.md:3
+msgid "Static memory management at compile time:"
+msgstr "컴파일 시 정적 메모리 관리:"
+
+#: src/why-rust/compile-time.md:5
+msgid ""
+"* No uninitialized variables.\n"
+"* No memory leaks (_mostly_, see notes).\n"
+"* No double-frees.\n"
+"* No use-after-free.\n"
+"* No `NULL` pointers.\n"
+"* No forgotten locked mutexes.\n"
+"* No data races between threads.\n"
+"* No iterator invalidation."
+msgstr ""
+"* 초기화되지 않는 변수가 없습니다.\n"
+"* 메모리 누수 없음(_거의_. 강의참조노트 참고.)\n"
+"* 메모리 이중 해제는 안됩니다. \n"
+"* 메모리 해제 후 사용 안됩니다.\n"
+"* `NULL`포인터는 없습니다.\n"
+"* 잠긴 뮤텍스를 잊을 수 없습니다.\n"
+"* 스레드간 데이터레이스가 없습니다. \n"
+"* 이터레이터(반복자, iterator) 무효화가 없습니다."
+
+#: src/why-rust/compile-time.md:16
+msgid ""
+"It is possible to produce memory leaks in (safe) Rust. Some examples\n"
+"are:"
+msgstr ""
+"안전한 러스트에서도 메모리 누수가 발생하는 몇가지 예는 다음과 같습니다:"
+
+#: src/why-rust/compile-time.md:19
+msgid ""
+"* You can for use [`Box::leak`] to leak a pointer. A use of this could\n"
+"  be to get runtime-initialized and runtime-sized static variables\n"
+"* You can use [`std::mem::forget`] to make the compiler \"forget\" about\n"
+"  a value (meaning the destructor is never run).\n"
+"* You can also accidentally create a [reference cycle] with `Rc` or\n"
+"  `Arc`."
+msgstr ""
+"* [`Box::leak`]을 사용하여 런타임 초기화 및 런타임 크기 정적 변수를 가져올 "
+"수 있습니다. 이를 통해 포인터 누수를 발생시킬 수 있습니다. \n"
+"* [`std::mem::forget`]을 사용하여 컴파일러가 값에 대해 \"잊도록\" 만들 수 있"
+"습니다(소멸자가 실행되지 않음을 의미합니다).\n"
+"* `Rc` 또는 `Arc`를 사용하여 실수로 [reference cycle]을 생성할 수도 있습니다."
+
+#: src/why-rust/compile-time.md:26
+msgid ""
+"For the purpose of this course, \"No memory leaks\" should be understood\n"
+"as \"Pretty much no *accidental* memory leaks\"."
+msgstr ""
+"본 코스에서는 \"메모리 누출 없음\"을 \"우발적인 메모리 누출 없음\"으로 이해해"
+"야 합니다. \n"
+"\n"
+"---\n"
+"역주\n"
+"* mutexes : 멀티스레딩에서 자원을 선점한 작업자가 잠그면(lock) 다른 작업자들"
+"은  lock이 해제될때까지 자원에 대해 접근을 할 수 없도록 막는 방식.\n"
+"  * cf. semaphore: 자원에 접근 할 수 있는 작업자(스레드,프로세스)의 수를 나타"
+"내는  값을 둬서 상호 배제하는 방식."
+
+#: src/why-rust/compile-time.md:29
+msgid ""
+"[`Box::leak`]: https://doc.rust-lang.org/std/boxed/struct.Box.html#method."
+"leak\n"
+"[`std::mem::forget`]: https://doc.rust-lang.org/std/mem/fn.forget.html\n"
+"[reference cycle]: https://doc.rust-lang.org/book/ch15-06-reference-cycles."
+"html"
+msgstr ""
+
+#: src/why-rust/runtime.md:1
+msgid "# Runtime Guarantees"
+msgstr "# 런타임 보증"
+
+#: src/why-rust/runtime.md:3
+msgid "No undefined behavior at runtime:"
+msgstr "런타임 시 정의되지 않음(undefined) 동작 없음:"
+
+#: src/why-rust/runtime.md:5
+msgid ""
+"* Array access is bounds checked.\n"
+"* Integer overflow is defined."
+msgstr ""
+"* 배열 접근시 경계 체크\n"
+"* 정수형의 오버플로우가 정의되어있습니다. "
+
+#: src/why-rust/runtime.md:12
+msgid ""
+"* Integer overflow is defined via a compile-time flag. The options are\n"
+"  either a panic (a controlled crash of the program) or wrap-around\n"
+"  semantics. By default, you get panics in debug mode (`cargo build`)\n"
+"  and wrap-around in release mode (`cargo build --release`)."
+msgstr ""
+"* 정수형 오버플로우는 컴파일 타임 플레그를 통해 정의됩니다. 옵션은 패닉(프로"
+"그램 크레시) 혹은 wrap-around semantics입니다. 기본적으로 디버그 모드(`cargo "
+"build`)에서는 패닉이, 릴리즈 모드(`cargo build --release`)에서는  wrap-around"
+"가 발생합니다."
+
+#: src/why-rust/runtime.md:17
+msgid ""
+"* Bounds checking cannot be disabled with a compiler flag. It can also\n"
+"  not be disabled directly with the `unsafe` keyword. However,\n"
+"  `unsafe` allows you to call functions such as `slice::get_unchecked`\n"
+"  which does not do bounds checking."
+msgstr ""
+"* 컴파일 플레그를 사용하여 경계체크를 무력화 할 수 없습니다. `unsafe`를  사용"
+"하더라도 마찬가지입니다. 하지만 `unsafe`에서 호출 가능한 `slice::"
+"get_unchecked`같은 함수는 경계 검사를 수행하지 않습니다."
+
+#: src/why-rust/modern.md:1
+msgid "# Modern Features"
+msgstr "# 현대적인 특징"
+
+#: src/why-rust/modern.md:3
+msgid "Rust is built with all the experience gained in the last 40 years."
+msgstr ""
+"러스트는 지난 40년간의 모든 (프로그래밍 언어들의) 경험으로  만들어졌습니다."
+
+#: src/why-rust/modern.md:5
+msgid "## Language Features"
+msgstr "## 언어적 특징"
+
+#: src/why-rust/modern.md:7
+msgid ""
+"* Enums and pattern matching.\n"
+"* Generics.\n"
+"* No overhead FFI."
+msgstr ""
+"* 열거형과 패턴 매칭\n"
+"* 제너릭\n"
+"* FFI 런타임 오버헤드 없음.\n"
+"  * _역주: FFI: Foreign Function Interface. 타 언어 코드를 호출하기 위한   인"
+"터페이스_"
+
+#: src/why-rust/modern.md:11
+msgid "## Tooling"
+msgstr "## 도구들"
+
+#: src/why-rust/modern.md:13
+msgid ""
+"* Great compiler errors.\n"
+"* Built-in dependency manager.\n"
+"* Built-in support for testing."
+msgstr ""
+"* 엄청난 컴파일러 오류 검사기\n"
+"* 내장 종속성 관리자\n"
+"* 내장 테스트 지원"
+
+#: src/why-rust/modern.md:21
+msgid ""
+"* Remind people to read the errors --- many developers have gotten used to\n"
+"  ignore lengthly compiler output. The Rust compiler is significantly more\n"
+"  talkative than other compilers. It will often provide you with "
+"_actionable_\n"
+"  feedback, ready to copy-paste into your code."
+msgstr ""
+"* 오류를 읽어보시기 바랍니다 --- 오랜기간 많은 개발자들이 컴파일러 출력을 무"
+"시하는데 익숙해져 있습니다. 러스트 컴파일러는 다른 컴파일러보다 더 수다스럽"
+"고, 복사-붙여넣기 할 수 있는 정도의 코드 피드백을 제공하는 경우가 많습니다. "
+
+#: src/why-rust/modern.md:26
+msgid ""
+"* The Rust standard library is small compared to languages like Java, "
+"Python,\n"
+"  and Go. Rust does not come with several things you might consider standard "
+"and\n"
+"  essential:"
+msgstr ""
+"* 러스트 표준 라이브러리는 Java, Python이나 Go와 같은 언어에 비해서는 규모가 "
+"작습니다. 표준이나 기본적이라고 생각되는 아래와 같은 라이브러리가 포함되있지 "
+"않습니다: "
+
+#: src/why-rust/modern.md:30
+msgid ""
+"  * a random number generator, but see [rand].\n"
+"  * support for SSL or TLS, but see [rusttls].\n"
+"  * support for JSON, but see [serde_json]."
+msgstr ""
+"  * 난수 생성기, 하지만 [rand]문서를 참조하시기 바랍니다.\n"
+"  * SSL 또는 TLS지원, 하지만 [rusttls]문서를 참조하시기 바랍니다.\n"
+"  * JSON 지원, 하지만 [serde_json] 문서를 참조하시기 바랍니다."
+
+#: src/why-rust/modern.md:34
+msgid ""
+"  The reasoning behind this is that functionality in the standard library "
+"cannot\n"
+"  go away, so it has to be very stable. For the examples above, the Rust\n"
+"  community is still working on finding the best solution --- and perhaps "
+"there\n"
+"  isn't a single \"best solution\" for some of these things."
+msgstr ""
+"이러한 배경에는 표준 라이브러리의 기능은 사라질 수 없어서 매우 안정적이어야  "
+"하기 때문입니다. 위의 예시들에서 러스트 커뮤니티는 가장 좋은 방법을 여전히  "
+"찾고 있고 그렇기 때문에 여기에 대한 '최상의 솔루션'이 아직 없습니다. "
+
+#: src/why-rust/modern.md:39
+msgid ""
+"  Rust comes with a built-in package manager in the form of Cargo and this "
+"makes\n"
+"  it trivial to download and compile third-party crates. A consequence of "
+"this\n"
+"  is that the standard library can be smaller."
+msgstr ""
+"러스트는 카고라는 패키지 관리자가 내장되어 있고, 서드파티 크레이트를  다운로"
+"드, 컴파일 하기 매우 쉽습니다. 이 또한 표준 라이브러리가 작은 이유가  될 수 "
+"있습니다. "
+
+#: src/why-rust/modern.md:43
+msgid ""
+"  Discovering good third-party crates can be a problem. Sites like\n"
+"  <https://lib.rs/> help with this by letting you compare health metrics "
+"for\n"
+"  crates to find a good and trusted one."
+msgstr ""
+"좋은 서드파티 크레이트를 찾는 것 자체가 문제가 될 수 있습니다. <https://lib."
+"rs> 와 같은 사이트가 신뢰할수 있는 좋은 크레이트를 비교하여 찾는데 도움을  "
+"줄 수 있습니다. "
+
+#: src/why-rust/modern.md:47
+msgid ""
+"[rand]: https://docs.rs/rand/\n"
+"[rusttls]: https://docs.rs/rustls/\n"
+"[serde_json]: https://docs.rs/serde_json/"
+msgstr ""
+
+#: src/basic-syntax.md:1
+msgid "# Basic Syntax"
+msgstr "# 기본 문법"
+
+#: src/basic-syntax.md:3
+msgid "Much of the Rust syntax will be familiar to you from C or C++:"
+msgstr "대부분의 러스트 문법은 C/C++과 유사합니다:"
+
+#: src/basic-syntax.md:5
+msgid ""
+"* Blocks and scopes are delimited by curly braces.\n"
+"* Line comments are started with `//`, block comments are delimited by `/"
+"* ...\n"
+"  */`.\n"
+"* Keywords like `if` and `while` work the same.\n"
+"* Variable assignment is done with `=`, comparison is done with `==`."
+msgstr ""
+"* 블록과 스코프 범위는 중괄호`{}`로 표현합니다. \n"
+"* 인라인 주석은 `//`, 블록 주석은 `/* ... */`로 사용합니다. \n"
+"* `if`나 `while`같은 키워드도 동일합니다. \n"
+"* 변수 할당은 `=`, 비교는 `==`를 사용합니다."
+
+#: src/basic-syntax/scalar-types.md:1
+msgid "# Scalar Types"
+msgstr "# 스칼라 타입"
+
+#: src/basic-syntax/scalar-types.md:3
+msgid ""
+"|                        | Types                                      | "
+"Literals                      |\n"
+"|------------------------|--------------------------------------------|-------------------------------|\n"
+"| Signed integers        | `i8`, `i16`, `i32`, `i64`, `i128`, `isize` | "
+"`-10`, `0`, `1_000`, `123i64` |\n"
+"| Unsigned integers      | `u8`, `u16`, `u32`, `u64`, `u128`, `usize` | `0`, "
+"`123`, `10u16`           |\n"
+"| Floating point numbers | `f32`, `f64`                               | "
+"`3.14`, `-10.0e20`, `2f32`    |\n"
+"| Strings                | `&str`                                     | "
+"`\"foo\"`, `r#\"\\\\\"#`            |\n"
+"| Unicode scalar values  | `char`                                     | "
+"`'a'`, `'α'`, `'∞'`           |\n"
+"| Byte strings           | `&[u8]`                                    | "
+"`b\"abc\"`, `br#\" \" \"#`         |\n"
+"| Booleans               | `bool`                                     | "
+"`true`, `false`               |"
+msgstr ""
+"|                 | 타입                                       | 스칼라 리터"
+"럴 값              |\n"
+"|-----------------|--------------------------------------------|-------------------------------|\n"
+"| 부호있는 정수   | `i8`, `i16`, `i32`, `i64`, `i128`, `isize` | `-10`, `0`, "
+"`1_000`, `123i64` |\n"
+"| 부호없는 정수   | `u8`, `u16`, `u32`, `u64`, `u128`, `usize` | `0`, `123`, "
+"`10u16`           |\n"
+"| 부동소수        | `f32`, `f64`                               | `3.14`, "
+"`-10.0e20`, `2f32`    |\n"
+"| 문자열          | `&str`                                     | `\"foo\"`, "
+"`r#\"\\\\\"#`      |\n"
+"| 유니코드 문자   | `char`                                     | `'a'`, "
+"`'α'`, `'∞'`           |\n"
+"| 바이트 문자     | `&[u8]`                                    | `b\"abc\"`, "
+"`br#\" \" \"#`    |\n"
+"| 불리언          | `bool`                                     | `true`, "
+"`false`               |"
+
+#: src/basic-syntax/scalar-types.md:13
+msgid "The types have widths as follows:"
+msgstr "각 타입의 크기는 다음과 같습니다:"
+
+#: src/basic-syntax/scalar-types.md:15
+msgid ""
+"* `iN`, `uN`, and `fN` are _N_ bits wide,\n"
+"* `isize` and `usize` are the width of a pointer,\n"
+"* `char` is 32 bit wide,\n"
+"* `bool` is 8 bit wide."
+msgstr ""
+"* 정수(`i`) 및 부동소수형(`f`)은 뒤의 숫자와 같은 bits 입니다.(`i8`=8 bit)\n"
+"* `isize` 와 `usize` 는 포인터와 같은 크기입니다.\n"
+"  * _역주: 32비트 시스템에서는 32비트, 64비트 시스템에서는 64비트. C의 int와 "
+"같음._* 문자는 32 bit 입니다.\n"
+"* `bool`은 8 bit 입니다. "
+
+#: src/basic-syntax/compound-types.md:1
+msgid "# Compound Types"
+msgstr "# 복합 타입"
+
+#: src/basic-syntax/compound-types.md:3
+msgid ""
+"|        | Types                         | Literals                          "
+"|\n"
+"|--------|-------------------------------|-----------------------------------|\n"
+"| Arrays | `[T; N]`                      | `[20, 30, 40]`, `[0; 3]`          "
+"|\n"
+"| Tuples | `()`, `(T,)`, `(T1, T2)`, ... | `()`, `('x',)`, `('x', 1.2)`, ... "
+"|"
+msgstr ""
+"|        | Types                         | Literals                          "
+"|\n"
+"|--------|-------------------------------|-----------------------------------|\n"
+"| 배열(Arrays) | `[T; N]`                      | `[20, 30, 40]`, `[0; "
+"3]`          |\n"
+"| 튜플(Tuples) | `()`, `(T,)`, `(T1, T2)`, ... | `()`, `('x',)`, `('x', "
+"1.2)`, ... |"
+
+#: src/basic-syntax/compound-types.md:8
+msgid "Array assignment and access:"
+msgstr ""
+"* _역주: js기준으로 설명하면 튜플은 ‘순서가 중요해서 사이즈 N으로 고정된  불"
+"변(immutable) 배열’ 이라고 보면 됨._\n"
+" _정확히는 서수(순서가 의미가 있는 내용)의 묶음(모음).  갯수N개에 대해서 N-"
+"tuple이라고 부르며 2-tuple을 흔히 쓰긴 함.(cf. 열거형)_\n"
+"배열 선언과 접근:"
+
+#: src/basic-syntax/compound-types.md:10
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let mut a: [i8; 10] = [42; 10];\n"
+"    a[5] = 0;\n"
+"    println!(\"a: {:?}\", a);\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/basic-syntax/compound-types.md:18
+msgid "Tuple assignment and access:"
+msgstr "튜플 선언과 접근:"
+
+#: src/basic-syntax/compound-types.md:20
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let t: (i8, bool) = (7, true);\n"
+"    println!(\"1st index: {}\", t.0);\n"
+"    println!(\"2nd index: {}\", t.1);\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/basic-syntax/references.md:1
+msgid "# References"
+msgstr "# 참조"
+
+#: src/basic-syntax/references.md:3
+msgid "Like C++, Rust has references:"
+msgstr "C++과 마찬가지로 러스트도 참조형을 갖습니다:"
+
+#: src/basic-syntax/references.md:5
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let mut x: i32 = 10;\n"
+"    let ref_x: &mut i32 = &mut x;\n"
+"    *ref_x = 20;\n"
+"    println!(\"x: {x}\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/basic-syntax/references.md:14
+msgid "Some differences from C++:"
+msgstr "C++과의 차이점:"
+
+#: src/basic-syntax/references.md:16
+msgid ""
+"* We must dereference `ref_x` when assigning to it, similar to C pointers,\n"
+"* Rust will auto-dereference in some cases, in particular when invoking\n"
+"  methods (try `count_ones`).\n"
+"* References that are declared as `mut` can be bound to different values "
+"over their lifetime."
+msgstr ""
+"* C포인터와 유사하게 `ref_x`에 할당할 경우 참조를 해제해야 합니다. \n"
+"* 러스트는 특정한 경우(메서드 호출)에 자동으로 참조 해제를 합니다."
+"(`count_one`메서드를 만들어보세요)\n"
+"* `mut`로 선언된 참조는 수명에 따라 다른 값으로 할당될 수 있습니다."
+
+#: src/basic-syntax/references-dangling.md:1
+msgid "# Dangling References"
+msgstr "# 댕글링 참조"
+
+#: src/basic-syntax/references-dangling.md:3
+msgid "Rust will statically forbid dangling references:"
+msgstr ""
+"러스트는 댕글링 참조를 금지합니다:\n"
+"* _역주: 댕글링 참조: 참조 포인터가 더이상 유효하지 않은 값을 가르키게 되는 "
+"경우_"
+
+#: src/basic-syntax/references-dangling.md:5
+msgid ""
+"```rust,editable,compile_fail\n"
+"fn main() {\n"
+"    let ref_x: &i32;\n"
+"    {\n"
+"        let x: i32 = 10;\n"
+"        ref_x = &x;\n"
+"    }\n"
+"    println!(\"ref_x: {ref_x}\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/basic-syntax/references-dangling.md:16
+msgid ""
+"* A reference is said to \"borrow\" the value it refers to.\n"
+"* Rust is tracking the lifetimes of all references to ensure they live long\n"
+"  enough.\n"
+"* We will talk more about borrowing when we get to ownership."
+msgstr ""
+"* 참조형 값(참조)는 변수로부터 값을 `빌리는 것`을 말합니다. \n"
+"* 러스트는 모든 참조의 수명을 추적하여 참조가 충분히 오래 살아있음(참조가 사"
+"용될때까지)을 보장합니다. \n"
+"* 소유권 부분에서 `빌림`에 대해 좀 더 많은 것을 다룹니다."
+
+#: src/basic-syntax/slices.md:1
+msgid "# Slices"
+msgstr "# 슬라이스"
+
+#: src/basic-syntax/slices.md:3
+msgid "A slice gives you a view into a larger collection:"
+msgstr "슬라이스를 사용하면 큰 컬렉션의 일부분을 확인할 수 있습니다. "
+
+#: src/basic-syntax/slices.md:5
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let a: [i32; 6] = [10, 20, 30, 40, 50, 60];\n"
+"    println!(\"a: {a:?}\");"
+msgstr ""
+
+#: src/basic-syntax/slices.md:10
+msgid ""
+"    let s: &[i32] = &a[2..4];\n"
+"    println!(\"s: {s:?}\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/basic-syntax/slices.md:15
+msgid ""
+"* Slices borrow data from the sliced type.\n"
+"* Question: What happens if you modify `a[3]`?"
+msgstr ""
+"* 슬라이스는 슬라이스 타입으로부터 데이터를 '빌려'옵니다. \n"
+"* 질문: `a[3]`으로 수정하면 무슨 일이 있어날까요?"
+
+#: src/basic-syntax/string-slices.md:1
+msgid "# `String` vs `str`"
+msgstr "# 두가지 문자열(`String` vs `str`)"
+
+#: src/basic-syntax/string-slices.md:3
+msgid "We can now understand the two string types in Rust:"
+msgstr "이제 러스트의 두가지 문자열 타입에 대해서 이해해 보겠습니다.:"
+
+#: src/basic-syntax/string-slices.md:5
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let s1: &str = \"Hello\";\n"
+"    println!(\"s1: {s1}\");"
+msgstr ""
+
+#: src/basic-syntax/string-slices.md:10
+msgid ""
+"    let mut s2: String = String::from(\"Hello \");\n"
+"    println!(\"s2: {s2}\");\n"
+"    s2.push_str(s1);\n"
+"    println!(\"s2: {s2}\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/basic-syntax/string-slices.md:17
+msgid "Rust terminology:"
+msgstr "러스트 용어:"
+
+#: src/basic-syntax/string-slices.md:19
+msgid ""
+"* `&str` an immutable reference to a string slice.\n"
+"* `String` a mutable string buffer."
+msgstr ""
+"* `&str` 타입은 문자열 슬라이스의 불변참조입니다.\n"
+"  * _역주: str은 문자 리터럴, &은 참조 타입입니다._\n"
+"* `String` 타입은 가변 문자열 버퍼입니다."
+
+#: src/basic-syntax/functions.md:1
+msgid "# Functions"
+msgstr "# 함수"
+
+#: src/basic-syntax/functions.md:3
+msgid ""
+"A Rust version of the famous [FizzBuzz](https://en.wikipedia.org/wiki/"
+"Fizz_buzz) interview question:"
+msgstr ""
+"러스트 버전의 [FizzBuzz](https://en.wikipedia.org/wiki/Fizz_buzz) 함수입니"
+"다: \n"
+"* _역주_\n"
+"  * _corner case: 복합 경계 조건. 변수와 환경적인 요소로 인해서 로직에 문제"
+"가  있는 경우.(나누기 로직에서 0으로 나누는 경우.)_\n"
+"    * _edge case: 경계조건. 매개변수 값이 극단적인 최대/최소값  (로직 유효범"
+"위 끝) 이상인 경우._\n"
+"  * _fizzbuzz: 숫자를 입력받아서 3으로 나뉘면 fizz, 5으로 나뉘면 buss, 둘다  "
+"나뉘면 fizzbuzz, 안나뉘면 입력값을 출력하는 테스트로 자주 쓰는 문제입니다._"
+
+#: src/basic-syntax/functions.md:5
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    fizzbuzz_to(20);   // Defined below, no forward declaration needed\n"
+"}"
+msgstr ""
+"```rust,editable\n"
+"fn main() {\n"
+"    fizzbuzz_to(20);   //C/C++와 달리 호출부 하단에 정의해도 문제 없습니다.\n"
+"}"
+
+#: src/basic-syntax/functions.md:10
+msgid ""
+"fn is_divisible_by(lhs: u32, rhs: u32) -> bool {\n"
+"    if rhs == 0 {\n"
+"        return false;  // Corner case, early return\n"
+"    }\n"
+"    lhs % rhs == 0     // The last expression is the return value\n"
+"}"
+msgstr ""
+"fn is_divisible_by(lhs: u32, rhs: u32) -> bool {\n"
+"    if rhs == 0 {\n"
+"        return false;  // Corner case이므로 반환합니다.\n"
+"    }\n"
+"    lhs % rhs == 0     // 마지막 표현식은 반환 값입니다.(;없음에 주목)\n"
+"}"
+
+#: src/basic-syntax/functions.md:17
+msgid ""
+"fn fizzbuzz(n: u32) -> () {  // No return value means returning the unit "
+"type `()`\n"
+"    match (is_divisible_by(n, 3), is_divisible_by(n, 5)) {\n"
+"        (true,  true)  => println!(\"fizzbuzz\"),\n"
+"        (true,  false) => println!(\"fizz\"),\n"
+"        (false, true)  => println!(\"buzz\"),\n"
+"        (false, false) => println!(\"{n}\"),\n"
+"    }\n"
+"}"
+msgstr ""
+"fn fizzbuzz(n: u32) -> () {  // `()`는 반환값이 없다는 것을 의미합니다. \n"
+"    match (is_divisible_by(n, 3), is_divisible_by(n, 5)) {\n"
+"        (true,  true)  => println!(\"fizzbuzz\"),\n"
+"        (true,  false) => println!(\"fizz\"),\n"
+"        (false, true)  => println!(\"buzz\"),\n"
+"        (false, false) => println!(\"{n}\"),\n"
+"    }\n"
+"}"
+
+#: src/basic-syntax/functions.md:26
+msgid ""
+"fn fizzbuzz_to(n: u32) {  // `-> ()` is normally omitted\n"
+"    for n in 1..=n {\n"
+"        fizzbuzz(n);\n"
+"    }\n"
+"}\n"
+"```"
+msgstr ""
+"fn fizzbuzz_to(n: u32) {  // `-> ()` 는 일반적으로 생략합니다.\n"
+"    for n in 1..=n {\n"
+"        fizzbuzz(n);\n"
+"    }\n"
+"}\n"
+"```"
+
+#: src/basic-syntax/methods.md:1 src/methods.md:1
+msgid "# Methods"
+msgstr "# 메서드"
+
+#: src/basic-syntax/methods.md:3
+msgid ""
+"Rust has methods, they are simply functions that are associated with a "
+"particular type. The\n"
+"first argument of a method is an instance of the type it is associated with:"
+msgstr ""
+"러스트는 메서드(특정 타입과 관계된 간단한 함수)를 가집니다. \n"
+"메서드의 첫번째 인수는 호출부 타입의 인스턴스 입니다.(self, this 같은)"
+
+#: src/basic-syntax/methods.md:6
+msgid ""
+"```rust,editable\n"
+"struct Rectangle {\n"
+"    width: u32,\n"
+"    height: u32,\n"
+"}"
+msgstr ""
+
+#: src/basic-syntax/methods.md:12
+msgid ""
+"impl Rectangle {\n"
+"    fn area(&self) -> u32 {\n"
+"        self.width * self.height\n"
+"    }"
+msgstr ""
+
+#: src/basic-syntax/methods.md:17
+msgid ""
+"    fn inc_width(&mut self, delta: u32) {\n"
+"        self.width += delta;\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/basic-syntax/methods.md:22
+msgid ""
+"fn main() {\n"
+"    let mut rect = Rectangle { width: 10, height: 5 };\n"
+"    println!(\"old area: {}\", rect.area());\n"
+"    rect.inc_width(5);\n"
+"    println!(\"new area: {}\", rect.area());\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/basic-syntax/methods.md:30
+msgid ""
+"* We will look much more at methods in today's exercise and in tomorrow's "
+"class."
+msgstr "* 오늘과 내일 강의에서 더 많은 메서드 사용법을 다룰 것입니다."
+
+#: src/basic-syntax/functions-interlude.md:1
+msgid "# Function Overloading"
+msgstr "# (함수) 오버로딩"
+
+#: src/basic-syntax/functions-interlude.md:3
+msgid "Overloading is not supported:"
+msgstr "오버로딩은 지원되지 않습니다: "
+
+#: src/basic-syntax/functions-interlude.md:5
+msgid ""
+"* Each function has a single implementation:\n"
+"  * Always takes a fixed number of parameters.\n"
+"  * Always takes a single set of parameter types.\n"
+"* Default values are not supported:\n"
+"  * All call sites have the same number of arguments.\n"
+"  * Macros are sometimes used as an alternative."
+msgstr ""
+"* 개별함수는 단일 구현만 갖습니다. \n"
+"  * 항상 고정된 수의 매개변수만 갖습니다. \n"
+"  * 항상 고정된 단일 타입 집합을 사용합니다. \n"
+"* 매개변수의 기본 값은 지원되지 않습니다. \n"
+"  * 모든 호출부에서는 동일한 수의 인자를 설정해야합니다. \n"
+"  * 대안으로 매크로를 사용하기도 합니다. "
+
+#: src/basic-syntax/functions-interlude.md:12
+msgid "However, function parameters can be generic:"
+msgstr "하지만, 함수의 매개변수는 제너릭을 적용할 수 있습니다:"
+
+#: src/basic-syntax/functions-interlude.md:14
+msgid ""
+"```rust,editable\n"
+"fn pick_one<T>(a: T, b: T) -> T {\n"
+"    if std::process::id() % 2 == 0 { a } else { b }\n"
+"}"
+msgstr ""
+
+#: src/basic-syntax/functions-interlude.md:19
+msgid ""
+"fn main() {\n"
+"    println!(\"coin toss: {}\", pick_one(\"heads\", \"tails\"));\n"
+"    println!(\"cash prize: {}\", pick_one(500, 1000));\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/exercises/day-1/morning.md:1
+msgid "# Day 1: Morning Exercises"
+msgstr "# 1일차 오전 연습문제"
+
+#: src/exercises/day-1/morning.md:3
+msgid "In these exercises, we will explore two parts of Rust:"
+msgstr "이번 연습문제는 러스트의 두 부분을 알아볼 것입니다:"
+
+#: src/exercises/day-1/morning.md:5
+msgid "* Implicit conversions between types."
+msgstr "* 타입의 암묵적 변환 "
+
+#: src/exercises/day-1/morning.md:7
+msgid "* Arrays and `for` loops."
+msgstr "* 배열과 `for` loops"
+
+#: src/exercises/day-1/morning.md:11
+msgid "A few things to consider while solving the exercises:"
+msgstr "연습문제를 해결하는데 고려해야 할 사항들: "
+
+#: src/exercises/day-1/morning.md:13
+msgid ""
+"* Use a local Rust installation, if possible. This way you can get\n"
+"  auto-completion in your editor. See the page about [Using Cargo] for "
+"details\n"
+"  on installing Rust."
+msgstr ""
+"* 가능한 경우 로컬 환경에서 진행하면 텍스트 에디터의 도움을 받을 수 있습니"
+"다.   [카고 사용하기:Using Cargo] 을 참조하시기 바랍니다."
+
+#: src/exercises/day-1/morning.md:17
+msgid "* Alternatively, use the Rust Playground."
+msgstr "* 혹은 러스트 플레이그라운드를 이용할 수 있습니다. "
+
+#: src/exercises/day-1/morning.md:19
+msgid ""
+"The code snippets are not editable on purpose: the inline code snippets "
+"lose\n"
+"their state if you navigate away from the page."
+msgstr ""
+"페이지 밖으로 이동할 경우 작성한 내용이 소실되기 때문에 제공되는 코드  스니펫"
+"은 의도적으로 편집할 수 없습니다.  "
+
+#: src/exercises/day-1/morning.md:22
+msgid "[Using Cargo]: ../../cargo.md"
+msgstr ""
+
+#: src/exercises/day-1/implicit-conversions.md:1
+msgid "# Implicit Conversions"
+msgstr "# 명시적 형변환"
+
+#: src/exercises/day-1/implicit-conversions.md:3
+msgid ""
+"Rust will not automatically apply _implicit conversions_ between types "
+"([unlike\n"
+"C++][3]). You can see this in a program like this:"
+msgstr ""
+"러스트는 [C++과 다르게][3] 타입 간 _암묵적 변환_을 자동으로 적용하지  않습니"
+"다.\n"
+"아래 예시를 확인해 보세요:"
+
+#: src/exercises/day-1/implicit-conversions.md:6
+msgid ""
+"```rust,editable,compile_fail\n"
+"fn multiply(x: i16, y: i16) -> i16 {\n"
+"    x * y\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-1/implicit-conversions.md:11
+msgid ""
+"fn main() {\n"
+"    let x: i8 = 15;\n"
+"    let y: i16 = 1000;"
+msgstr ""
+
+#: src/exercises/day-1/implicit-conversions.md:15
+msgid ""
+"    println!(\"{x} * {y} = {}\", multiply(x, y));\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/exercises/day-1/implicit-conversions.md:19
+msgid ""
+"The Rust integer types all implement the [`From<T>`][1] and [`Into<T>`][2]\n"
+"traits to let us convert between them. The `From<T>` trait has a single "
+"`from()`\n"
+"method and similarly, the `Into<T>` trait has a single `into()` method.\n"
+"Implementing these traits is how a type expresses that it can be converted "
+"into\n"
+"another type."
+msgstr ""
+"러스트의 정수형 타입은 모두 [`From<T>`][1] 와 [`Into<T>`][2] 트레이트를  구현"
+"하여 둘 사이를 변환 할 수 있습니다.\n"
+"`From<T>` 트레이트는 단일 `from()` 메서드를 가지고 있고, `Into<T>`트레이트"
+"는  단일 `into()`메서드를 가지고 있습니다.\n"
+"이러한 트레이트를 구현하는 것은 타입이 다른 타입으로 변환하는 것을 표현하는  "
+"방법입니다."
+
+#: src/exercises/day-1/implicit-conversions.md:25
+msgid ""
+"The standard library has an implementation of `From<i8> for i16`, which "
+"means\n"
+"that we can convert a variable `x` of type `i8` to an `i16` by calling \n"
+"`i16::from(x)`. Or, simpler, with `x.into()`, because `From<i8> for i16`\n"
+"implementation automatically create an implementation of `Into<i16> for i8`."
+msgstr ""
+"표준 라이브러리에는 `From<i8> for i16`가 구현되어 있는데 이것은 우리가 `i8` "
+"타입의 변수 `x`를 `i16::from(x)`를 호출하여 `i16`타입으로 변환할 수 있다는  "
+"의미입니다. \n"
+"(혹은 더 간단하게 `x.into()`를 사용합니다.)\n"
+"`From<i8> for i16`의 구현은 자동으로 `Into<i16> for i8`를 생성하기 때문입니"
+"다."
+
+#: src/exercises/day-1/implicit-conversions.md:30
+msgid "1. Execute the above program and look at the compiler error."
+msgstr "1. 위 예제코드를 실행해서 발생한 오류를 확인해 보세요"
+
+#: src/exercises/day-1/implicit-conversions.md:32
+msgid "2. Update the code above to use `into()` to do the conversion."
+msgstr "2. `into()` 메서드를 사용하여 코드를 수정하세요"
+
+#: src/exercises/day-1/implicit-conversions.md:34
+msgid ""
+"3. Change the types of `x` and `y` to other things (such as `f32`, `bool`,\n"
+"   `i128`) to see which types you can convert to which other types. Try\n"
+"   converting small types to big types and the other way around. Check the\n"
+"   [standard library documentation][1] to see if `From<T>` is implemented "
+"for\n"
+"   the pairs you check."
+msgstr ""
+"3. `x`와 `y`를 `f32'이나 'bool', 'i128' 등으로 바꿔서 해당 타입들로 변환이 되"
+"는지 확인해보세요 \n"
+"  - 작은 사이즈 타입에서 큰 사이즈로 변경해보시고 그 반대로도 해보세요 \n"
+"  - [표준 라이브러리 문서][1]에서 시도해 본 케이스가 구현되어 있는지 확인해 "
+"보세요."
+
+#: src/exercises/day-1/implicit-conversions.md:40
+msgid ""
+"[1]: https://doc.rust-lang.org/std/convert/trait.From.html\n"
+"[2]: https://doc.rust-lang.org/std/convert/trait.Into.html\n"
+"[3]: https://en.cppreference.com/w/cpp/language/implicit_conversion"
+msgstr ""
+
+#: src/exercises/day-1/for-loops.md:1
+msgid "# Arrays and `for` Loops"
+msgstr "# 배열과 `for`반복문"
+
+#: src/exercises/day-1/for-loops.md:3
+msgid "We saw that an array can be declared like this:"
+msgstr "우리는 배열을 아래와 같이 선언 할 수 있음을 보았습니다:"
+
+#: src/exercises/day-1/for-loops.md:5
+msgid ""
+"```rust\n"
+"let array = [10, 20, 30];\n"
+"```"
+msgstr ""
+
+#: src/exercises/day-1/for-loops.md:9
+msgid ""
+"You can print such an array by asking for its debug representation with `{:?}"
+"`:"
+msgstr "배열은 `{:?}` 형태로 표시하여 출력할 수 있습니다."
+
+#: src/exercises/day-1/for-loops.md:11
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let array = [10, 20, 30];\n"
+"    println!(\"array: {array:?}\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/exercises/day-1/for-loops.md:18
+msgid ""
+"Rust lets you iterate over things like arrays and ranges using the `for`\n"
+"keyword:"
+msgstr "러스트에서는 `for`키워드를 사용해 배열이나 범위를 반복할 수 있습니다:"
+
+#: src/exercises/day-1/for-loops.md:21
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let array = [10, 20, 30];\n"
+"    print!(\"Iterating over array:\");\n"
+"    for n in array {\n"
+"        print!(\" {n}\");\n"
+"    }\n"
+"    println!();"
+msgstr ""
+
+#: src/exercises/day-1/for-loops.md:30
+msgid ""
+"    print!(\"Iterating over range:\");\n"
+"    for i in 0..3 {\n"
+"        print!(\" {}\", array[i]);\n"
+"    }\n"
+"    println!();\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/exercises/day-1/for-loops.md:38
+msgid ""
+"Use the above to write a function `pretty_print` which pretty-print a matrix "
+"and\n"
+"a function `transpose` which will transpose a matrix (turn rows into "
+"columns):"
+msgstr ""
+"위의 예제에서 행렬을 예쁘게 출력하는 `pretty_print`함수와 행렬을 전치(행과  "
+"열을 변경)시키는 `transpose`함수를 작성해 보시기 바랍니다."
+
+#: src/exercises/day-1/for-loops.md:41
+msgid ""
+"```bob\n"
+"           ⎛⎡1 2 3⎤⎞      ⎡1 4 7⎤\n"
+"\"transpose\"⎜⎢4 5 6⎥⎟  \"==\"⎢2 5 8⎥\n"
+"           ⎝⎣7 8 9⎦⎠      ⎣3 6 9⎦\n"
+"```"
+msgstr ""
+
+#: src/exercises/day-1/for-loops.md:47
+msgid "Hard-code both functions to operate on 3 × 3 matrices."
+msgstr "두 함수 모두 3×3 행렬에서 작동하도록 하드 코딩합니다."
+
+#: src/exercises/day-1/for-loops.md:49
+msgid ""
+"Copy the code below to <https://play.rust-lang.org/> and implement the\n"
+"functions:"
+msgstr ""
+"아래 코드를 <https://play.rust-lang.org/>에 복사해서 구현하시면 됩니다."
+
+#: src/exercises/day-1/for-loops.md:52 src/exercises/day-1/book-library.md:20
+#: src/exercises/day-2/health-statistics.md:13
+msgid ""
+"```rust,should_panic\n"
+"// TODO: remove this when you're done with your implementation.\n"
+"#![allow(unused_variables, dead_code)]"
+msgstr ""
+"```rust,should_panic\n"
+"// TODO: 구현이 완료되면 아래 줄은 삭제합니다.\n"
+"#![allow(unused_variables, dead_code)]"
+
+#: src/exercises/day-1/for-loops.md:56
+msgid ""
+"fn transpose(matrix: [[i32; 3]; 3]) -> [[i32; 3]; 3] {\n"
+"    unimplemented!()\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-1/for-loops.md:60
+msgid ""
+"fn pretty_print(matrix: &[[i32; 3]; 3]) {\n"
+"    unimplemented!()\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-1/for-loops.md:64
+msgid ""
+"fn main() {\n"
+"    let matrix = [\n"
+"        [101, 102, 103], // <-- the comment makes rustfmt add a newline\n"
+"        [201, 202, 203],\n"
+"        [301, 302, 303],\n"
+"    ];"
+msgstr ""
+
+#: src/exercises/day-1/for-loops.md:71
+#: src/exercises/day-1/solutions-morning.md:70
+msgid ""
+"    println!(\"matrix:\");\n"
+"    pretty_print(&matrix);"
+msgstr ""
+
+#: src/exercises/day-1/for-loops.md:74
+msgid ""
+"    let transposed = transpose(matrix);\n"
+"    println!(\"transposed:\");\n"
+"    pretty_print(&transposed);\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/exercises/day-1/for-loops.md:80
+msgid "## Bonus Question"
+msgstr "## 추가 문제"
+
+#: src/exercises/day-1/for-loops.md:82
+msgid ""
+"Could you use `&[i32]` slices instead of hard-coded 3 × 3 matrices for your\n"
+"argument and return types? Something like `&[&[i32]]` for a two-dimensional\n"
+"slice-of-slices. Why or why not?"
+msgstr ""
+"하드코딩된 3×3 행렬 입력을 `&[i32]` 슬라이스를 통해 인수와 반환값의 정의가 가"
+"능한가요? 예컨데 `&[&[i32]]`는 2차원 슬라이스의 슬라이스 입니다.  가능하다면/"
+"하지 않다면 왜 그런가요?"
+
+#: src/exercises/day-1/for-loops.md:87
+msgid ""
+"See the [`ndarray` crate](https://docs.rs/ndarray/) for a production "
+"quality\n"
+"implementation."
+msgstr ""
+"프로덕션 품질의 구현에 대해서는 [`ndarray` 크레이트](https://docs.rs/"
+"ndarray/)를 참조하시기 바랍니다."
+
+#: src/basic-syntax/variables.md:1
+msgid "# Variables"
+msgstr "# 변수"
+
+#: src/basic-syntax/variables.md:3
+msgid ""
+"Rust provides type safety via static typing. Variable bindings are immutable "
+"by\n"
+"default:"
+msgstr ""
+"러스트는 정적 타이핑을 통해 타입 세이프티(타입 안전)을 제공합니다.  \n"
+"변수 바인딩은 기본적으로 불변(immutable)합니다.: "
+
+#: src/basic-syntax/variables.md:6
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let x: i32 = 10;\n"
+"    println!(\"x: {x}\");\n"
+"    // x = 20;\n"
+"    // println!(\"x: {x}\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/basic-syntax/variables.md:17
+msgid ""
+"* Due to type inference the `i32` is optional. We will gradually show the "
+"types less and less as the type progresses.\n"
+"* Note that since `println!` is a macro, `x` is not moved, even using the "
+"function like syntax of `println!(\"x: {}\", x)`"
+msgstr ""
+"* 유형 추론에 의해서 `i32`는 생략 가능합니다. 강의가 진행될 수록 생략 가능"
+"한  부분은 점점 생략할 것입니다.\n"
+"* `println!(\"x: {}\", x)`는 함수 문법처럼 보이지만 `println!`은 매크로이므"
+"로  `x`는 이동되지 않습니다."
+
+#: src/basic-syntax/type-inference.md:1
+msgid "# Type Inference"
+msgstr "# 타입 추론"
+
+#: src/basic-syntax/type-inference.md:3
+msgid "Rust will look at how the variable is _used_ to determine the type:"
+msgstr "러스트는 변수가 어떻게 사용되는지 확인하여 타입 추론을 제공합니다. "
+
+#: src/basic-syntax/type-inference.md:5
+msgid ""
+"```rust,editable\n"
+"fn takes_u32(x: u32) {\n"
+"    println!(\"u32: {x}\");\n"
+"}"
+msgstr ""
+
+#: src/basic-syntax/type-inference.md:10
+msgid ""
+"fn takes_i8(y: i8) {\n"
+"    println!(\"i8: {y}\");\n"
+"}"
+msgstr ""
+
+#: src/basic-syntax/type-inference.md:14
+msgid ""
+"fn main() {\n"
+"    let x = 10;\n"
+"    let y = 20;"
+msgstr ""
+
+#: src/basic-syntax/type-inference.md:18
+msgid ""
+"    takes_u32(x);\n"
+"    takes_i8(y);\n"
+"    // takes_u32(y);\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/basic-syntax/type-inference.md:26
+msgid ""
+"This slide demonstrates how the Rust compiler infers types based on "
+"constraints given by variable declarations and usages."
+msgstr ""
+"이 슬라이드는 러스트 컴파일러가 변수의 선언 및 사용에 의해 주어진 제약 조건"
+"을  기반으로 타입을 추론하는 것을 보여줍니다."
+
+#: src/basic-syntax/type-inference.md:28
+msgid ""
+"The following code tells the compiler to copy into a certain generic "
+"container without the code ever explicitly specifying the contained type, "
+"using `_` as a placeholder:"
+msgstr ""
+"아래 코드는 컴파일러가 타입 미지정(`_`)으로 추론을 통해 변수에 할당 시킴니"
+"다. "
+
+#: src/basic-syntax/type-inference.md:30
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let mut v = Vec::new();\n"
+"    v.push((10, false));\n"
+"    v.push((20, true));\n"
+"    println!(\"v: {v:?}\");"
+msgstr ""
+
+#: src/basic-syntax/type-inference.md:37
+msgid ""
+"    let vv = v.iter().collect::<std::collections::HashSet<_>>();\n"
+"    println!(\"vv: {vv:?}\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/basic-syntax/type-inference.md:42
+msgid ""
+"[`collect`](https://doc.rust-lang.org/stable/std/iter/trait.Iterator."
+"html#method.collect) relies on `FromIterator`, which [`HashSet`](https://doc."
+"rust-lang.org/std/iter/trait.FromIterator.html) implements."
+msgstr ""
+"[`collect`](https://doc.rust-lang.org/stable/std/iter/trait.Iterator."
+"html#method.collect)은 [`HashSet`](https://doc.rust-lang.org/std/iter/trait."
+"FromIterator.html)을 구현한 `FromIterator`에 의존합니다."
+
+#: src/basic-syntax/static-and-const.md:1
+msgid "# Static and Constant Variables"
+msgstr "# 정적 변수와 상수"
+
+#: src/basic-syntax/static-and-const.md:3
+msgid "Global state is managed with static and constant variables."
+msgstr "전역 상태(state) 정적 변수와 상수로 관리됩니다."
+
+#: src/basic-syntax/static-and-const.md:5
+msgid "## `const`"
+msgstr "## 상수(`const`)"
+
+#: src/basic-syntax/static-and-const.md:7
+msgid "You can declare compile-time constants:"
+msgstr "컴파일 시점의 상수를 선언할 수 있습니다."
+
+#: src/basic-syntax/static-and-const.md:9
+msgid ""
+"```rust,editable\n"
+"const DIGEST_SIZE: usize = 3;\n"
+"const ZERO: Option<u8> = Some(42);"
+msgstr ""
+
+#: src/basic-syntax/static-and-const.md:13
+msgid ""
+"fn compute_digest(text: &str) -> [u8; DIGEST_SIZE] {\n"
+"    let mut digest = [ZERO.unwrap_or(0); DIGEST_SIZE];\n"
+"    for (idx, &b) in text.as_bytes().iter().enumerate() {\n"
+"        digest[idx % DIGEST_SIZE] = digest[idx % DIGEST_SIZE]."
+"wrapping_add(b);\n"
+"    }\n"
+"    digest\n"
+"}"
+msgstr ""
+
+#: src/basic-syntax/static-and-const.md:21
+msgid ""
+"fn main() {\n"
+"    let digest = compute_digest(\"Hello\");\n"
+"    println!(\"Digest: {digest:?}\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/basic-syntax/static-and-const.md:27
+msgid "## `static`"
+msgstr "## 정적변수(`static`)"
+
+#: src/basic-syntax/static-and-const.md:29
+msgid "You can also declare static variables:"
+msgstr "마찬가지로 정적 변수도 선언할 수 있습니다."
+
+#: src/basic-syntax/static-and-const.md:31
+msgid ""
+"```rust,editable\n"
+"static BANNER: &str = \"Welcome to RustOS 3.14\";"
+msgstr ""
+
+#: src/basic-syntax/static-and-const.md:34
+msgid ""
+"fn main() {\n"
+"    println!(\"{BANNER}\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/basic-syntax/static-and-const.md:39
+msgid ""
+"We will look at mutating static data in the [chapter on Unsafe Rust](../"
+"unsafe.md)."
+msgstr ""
+"가변 정적 데이터에 대해서는 안전하지 않은 [러스트 파트](../unsafe.md)에서 살"
+"펴봅니다."
+
+#: src/basic-syntax/scopes-shadowing.md:1
+msgid "# Scopes and Shadowing"
+msgstr "# 스코프 범위(Scopes)와 쉐도잉(Shadowing)"
+
+#: src/basic-syntax/scopes-shadowing.md:3
+msgid ""
+"You can shadow variables, both those from outer scopes and variables from "
+"the\n"
+"same scope:"
+msgstr "외부 스코프와 동일 스코프 범위의 변수를 가릴 수 있습니다.(변수 쉐도잉)"
+
+#: src/basic-syntax/scopes-shadowing.md:6
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let a = 10;\n"
+"    println!(\"before: {a}\");"
+msgstr ""
+
+#: src/basic-syntax/scopes-shadowing.md:11
+msgid ""
+"    {\n"
+"        let a = \"hello\";\n"
+"        println!(\"inner scope: {a}\");"
+msgstr ""
+
+#: src/basic-syntax/scopes-shadowing.md:15
+msgid ""
+"        let a = true;\n"
+"        println!(\"shadowed in inner scope: {a}\");\n"
+"    }"
+msgstr ""
+
+#: src/basic-syntax/scopes-shadowing.md:19
+msgid ""
+"    println!(\"after: {a}\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/basic-syntax/scopes-shadowing.md:25
+msgid ""
+"* Shadowing looks obscure at first, but is convenient for holding on to "
+"values after `.unwrap()`.\n"
+"* The following code demonstrates why the compiler can't simply reuse memory "
+"locations when shadowing an immutable variable in a scope, even if the type "
+"does not change."
+msgstr ""
+"* 쉐도잉은 모호해 보일 수 있지만 `.unwrap()` 이후의 값을 할당하는데 용이합니"
+"다. \n"
+"* 아래 코드는 컴파일러가 스포크에서 변경되지 않는 변수를 쉐도잉할때 타입이 동"
+"일하더라도 메모리 위치를 단순 재사용 할 수 없는 이유를 보여줍니다.(원본 a를 "
+"참조한 b와 쉐도잉 된 a(a+1) 둘다 살아있어야 하므로 메모리를 따로 할당합니다.)"
+
+#: src/basic-syntax/scopes-shadowing.md:28
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let a = 1;\n"
+"    let b = &a;\n"
+"    let a = a + 1;\n"
+"    println!(\"{a} {b}\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/memory-management.md:1
+msgid "# Memory Management"
+msgstr "# 메모리 관리"
+
+#: src/memory-management.md:3
+msgid "Traditionally, languages have fallen into two broad categories:"
+msgstr "전통적으로, 프로그래밍 언어는 크게 두가지로 분류 됩니다:"
+
+#: src/memory-management.md:5
+msgid ""
+"* Full control via manual memory management: C, C++, Pascal, ...\n"
+"* Full safety via automatic memory management at runtime: Java, Python, Go, "
+"Haskell, ..."
+msgstr ""
+"* 소스레벨 메모리 관리(수동 제어): C, C++, Pascal, ...\n"
+"* 런타임 시 자동 메모리 관리를 통한 안전성 제공(like GC): Java, Python, Go, "
+"Haskell, ... "
+
+#: src/memory-management.md:8
+msgid "Rust offers a new mix:"
+msgstr "러스트는 이 둘을 혼합한 새로운 형태를 제안합니다:"
+
+#: src/memory-management.md:10
+msgid ""
+"> Full control *and* safety via compile time enforcement of correct memory\n"
+"> management."
+msgstr "> 컴파일 시 메모리 관리를 통한 안전성과 제어 제공"
+
+#: src/memory-management.md:13
+msgid "It does this with an explicit ownership concept."
+msgstr "이것은 명시적인 소유권 컨셉을 통해 이뤄집니다."
+
+#: src/memory-management.md:15
+msgid "First, let's refresh how memory management works."
+msgstr "우선 메모리 관리가 이뤄지는 방식을 다시 살펴 보겠습니다."
+
+#: src/memory-management/stack-vs-heap.md:1
+msgid "# The Stack vs The Heap"
+msgstr "# 스택과 힙"
+
+#: src/memory-management/stack-vs-heap.md:3
+msgid ""
+"* Stack: Continuous area of memory for local variables.\n"
+"  * Values have fixed sizes known at compile time.\n"
+"  * Extremely fast: just move a stack pointer.\n"
+"  * Easy to manage: follows function calls.\n"
+"  * Great memory locality."
+msgstr ""
+"* 스택: 지역변수를 위한 메모리 상 연속적인 영역\n"
+"  * 값은 사전 정의된 고정 크기를 갖습니다. \n"
+"  * 극도로 빠름: 단지 스택 포인트만 이동됩니다. \n"
+"  * 관리가 쉬움: 함수 호출을 따릅니다.\n"
+"  * 메모리 인접성"
+
+#: src/memory-management/stack-vs-heap.md:9
+msgid ""
+"* Heap: Storage of values outside of function calls.\n"
+"  * Values have dynamic sizes determined at runtime.\n"
+"  * Slightly slower than the stack: some book-keeping needed.\n"
+"  * No guarantee of memory locality."
+msgstr ""
+"* 힙: 함수 호출 외부의 값이 저장되는 곳\n"
+"  * 값은 런타임 시 결정되는 동적 크기를 갖습니다. \n"
+"  * 스택에 비해서는 약간 느림: 약간의 추가 기록(힙 주소를 스택에 저장)이  필"
+"요함.\n"
+"  * 메모리 인접성을 보장하지 않음."
+
+#: src/memory-management/stack.md:1
+msgid "# Stack Memory"
+msgstr "# 스택 메모리"
+
+#: src/memory-management/stack.md:3
+msgid ""
+"Creating a `String` puts fixed-sized data on the stack and dynamically "
+"sized\n"
+"data on the heap:"
+msgstr ""
+"`String` 타입은 힙에 동적으로 데이터를 저장하고 크기 고정된 데이터(힙 데이터"
+"에 대한 정보)를 스택에 저장합니다."
+
+#: src/memory-management/stack.md:6
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let s1 = String::from(\"Hello\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/memory-management/stack.md:12
+msgid ""
+"```bob\n"
+" Stack                             Heap\n"
+".- - - - - - - - - - - - - -.     .- - - - - - - - - - - - - - - -.\n"
+":                           :     :                               :\n"
+":    s1                     :     :                               :\n"
+":   +-----------+-------+   :     :   +----+----+----+----+----+  :\n"
+":   | ptr       |   o---+---+-----+-->| H  | e  | l  | l  | o  |  :\n"
+":   | len       |     5 |   :     :   +----+----+----+----+----+  :\n"
+":   | capacity  |     5 |   :     :                               :\n"
+":   +-----------+-------+   :     :                               :\n"
+":                           :     `- - - - - - - - - - - - - - - -'\n"
+"`- - - - - - - - - - - - - -'\n"
+"```"
+msgstr ""
+
+#: src/memory-management/manual.md:1
+msgid "# Manual Memory Management"
+msgstr "# 수동 메모리 관리"
+
+#: src/memory-management/manual.md:3
+msgid "You allocate and deallocate heap memory yourself."
+msgstr "사용자가 직접 메모리를 할당, 해제 합니다."
+
+#: src/memory-management/manual.md:5
+msgid "## C Example"
+msgstr "## C언어 예제"
+
+#: src/memory-management/manual.md:7
+msgid "You must call `free` on every pointer you allocate with `malloc`:"
+msgstr "`malloc`로 할당하는 포인터마다 `free`를 호출해야 합니다: "
+
+#: src/memory-management/manual.md:9
+msgid ""
+"```c\n"
+"void foo(size_t n) {\n"
+"    int* int_array = (int*)malloc(n * sizeof(int));\n"
+"    //\n"
+"    // ... lots of code\n"
+"    //\n"
+"    free(int_array);\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/memory-management/manual.md:19
+msgid ""
+"Memory is leaked if the function returns early between `malloc` and `free`: "
+"the\n"
+"pointer is lost and we cannot deallocate the memory."
+msgstr ""
+"만약`malloc` 과 `free` 사이에서 함수가 먼저 반환되면 메모리 누수가 일어납니"
+"다:  \n"
+" 포인터가 손실되어 메모리 할당을 해제할 수 없게 됩니다."
+
+#: src/memory-management/scope-based.md:1
+msgid "# Scope-Based Memory Management"
+msgstr "# 범위기반 메모리 관리"
+
+#: src/memory-management/scope-based.md:3
+msgid ""
+"Constructors and destructors let you hook into the lifetime of an object."
+msgstr "생성자와 소멸자를 사용하여 객체의 수명에 연결(hook)할 수 있습니다. "
+
+#: src/memory-management/scope-based.md:5
+msgid ""
+"By wrapping a pointer in an object, you can free memory when the object is\n"
+"destroyed. The compiler guarantees that this happens, even if an exception "
+"is\n"
+"raised."
+msgstr ""
+"포인터를 객체에 래핑하여 객체가 소멸될 때 메모리를 해제 할 수 있습니다. \n"
+"컴파일러는 예외(exception)가 발생하더라도 이를 보장합니다. "
+
+#: src/memory-management/scope-based.md:9
+msgid ""
+"This is often called _resource acquisition is initialization_ (RAII) and "
+"gives\n"
+"you smart pointers."
+msgstr ""
+"이를 종종 RAII(Resource Acquisition Is Initialization, 리소스 획득은 초기화"
+"다)이라고 하며, RAII패턴의 스마트 포인터를 제공합니다."
+
+#: src/memory-management/scope-based.md:12
+msgid "## C++ Example"
+msgstr "## C++ 예제"
+
+#: src/memory-management/scope-based.md:14
+msgid ""
+"```c++\n"
+"void say_hello(std::unique_ptr<Person> person) {\n"
+"  std::cout << \"Hello \" << person->name << std::endl;\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/memory-management/scope-based.md:20
+msgid ""
+"* The `std::unique_ptr` object is allocated on the stack, and points to\n"
+"  memory allocated on the heap.\n"
+"* At the end of `say_hello`, the `std::unique_ptr` destructor will run.\n"
+"* The destructor frees the `Person` object it points to."
+msgstr ""
+"* `std::unique_ptr`객체는 스택에 할당되며, 힙에 할당된 메모리를 가리킵니다"
+"(point).\n"
+"* `say_hello`함수가 끝나면 `std::unique_ptr`의 소멸자가 실행됩니다.\n"
+"* 소멸자는 `Person` 객체가 가르키는(point) 곳을 해제합니다."
+
+#: src/memory-management/scope-based.md:25
+msgid ""
+"Special move constructors are used when passing ownership to a function:"
+msgstr "특별한 이동 생성자는 소유권을 함수로 전달할때 사용됩니다."
+
+#: src/memory-management/scope-based.md:27
+msgid ""
+"```c++\n"
+"std::unique_ptr<Person> person = find_person(\"Carla\");\n"
+"say_hello(std::move(person));\n"
+"```"
+msgstr ""
+
+#: src/memory-management/garbage-collection.md:1
+msgid "# Automatic Memory Management"
+msgstr "# 자동 메모리 관리"
+
+#: src/memory-management/garbage-collection.md:3
+msgid ""
+"An alternative to manual and scope-based memory management is automatic "
+"memory\n"
+"management:"
+msgstr "수동, 스코프기반 메모리 관리의 대안인 자동 메모리 관리 방식입니다:"
+
+#: src/memory-management/garbage-collection.md:6
+msgid ""
+"* The programmer never allocates or deallocates memory explicitly.\n"
+"* A garbage collector finds unused memory and deallocates it for the "
+"programmer."
+msgstr ""
+"* 개발자는 메모리를 명시적으로 할당/해제 하지 않습니다. \n"
+"* 가비지 컬렉터(GC)는 개발자 대신 사용되지 않는 메모리를 찾아 해제합니다."
+
+#: src/memory-management/garbage-collection.md:9
+msgid "## Java Example"
+msgstr "## Jave 예제"
+
+#: src/memory-management/garbage-collection.md:11
+msgid "The `person` object is not deallocated after `sayHello` returns:"
+msgstr ""
+"`person`객체는 `sayHello`함수 반환 후에도 해제되지 않습니다. (GC가 나중에 알"
+"아서 해제합니다.)"
+
+#: src/memory-management/garbage-collection.md:13
+msgid ""
+"```java\n"
+"void sayHello(Person person) {\n"
+"  System.out.println(\"Hello \" + person.getName());\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/memory-management/rust.md:1
+msgid "# Memory Management in Rust"
+msgstr "# 러스트에서의 메모리 관리"
+
+#: src/memory-management/rust.md:3
+msgid "Memory management in Rust is a mix:"
+msgstr "러스트의 메모리 관리는 이전 방식들을 혼합해서 사용합니다:"
+
+#: src/memory-management/rust.md:5
+msgid ""
+"* Safe and correct like Java, but without a garbage collector.\n"
+"* Scope-based like C++, but the compiler enforces full adherence.\n"
+"* Has no runtime overhead like in C and C++."
+msgstr ""
+"* 자바처럼 안전하고 정확합니다. 하지만 GC는 없습니다. \n"
+"* C++처럼 범위(스코프)기반입니다. 하지만 컴파일러가 엄격하게 적용합니다.\n"
+"* C/C++처럼 런타임 오버헤드가 없습니다. \n"
+"  * _역주: 런타임에서 GC 동작시 부하 발생으로 느려지거나 hang이 발생하는   "
+"~~[더월드](https://namu.wiki/w/"
+"%EB%8D%94%20%EC%9B%94%EB%93%9C(%EC%A3%A0%EC%A3%A0%EC%9D%98%20%EA%B8%B0%EB%AC%98%ED%95%9C%20%EB%AA%A8%ED%97%98)#s-3.2)~~ "
+"현상이 있을 수 있습니다._"
+
+#: src/memory-management/rust.md:9
+msgid "It achieves this by modeling _ownership_ explicitly."
+msgstr "이는 러스트의 명시적인 `소유권` 설계를 통해 이뤄집니다."
+
+#: src/memory-management/comparison.md:1
+msgid "# Comparison"
+msgstr "# 비교"
+
+#: src/memory-management/comparison.md:3
+msgid "Here is a rough comparison of the memory management techniques."
+msgstr "메모리 관리 기술의 대략적인 비교입니다."
+
+#: src/memory-management/comparison.md:5
+msgid "## Pros of Different Memory Management Techniques"
+msgstr "## 메모리 관리 방법 별 장점"
+
+#: src/memory-management/comparison.md:7
+msgid ""
+"* Manual like C:\n"
+"  * No runtime overhead.\n"
+"* Automatic like Java:\n"
+"  * Fully automatic.\n"
+"  * Safe and correct.\n"
+"* Scope-based like C++:\n"
+"  * Partially automatic.\n"
+"  * No runtime overhead.\n"
+"* Compiler-enforced scope-based like Rust:\n"
+"  * Enforced by compiler.\n"
+"  * No runtime overhead.\n"
+"  * Safe and correct."
+msgstr ""
+"* C와 같은 수동 관리: \n"
+"  * 런타임 오버헤드가 없음. \n"
+"* JAVA와 같은 자동화 관리: \n"
+"  * 완전한 자동화.\n"
+"  * 안전하고 정확함.\n"
+"* C++과 같은 범위 기반 관리: \n"
+"  * 부분 자동화\n"
+"  * 런타임 오버헤드가 없음.\n"
+"* 러스트와 같은 컴파일러 수행 범위 기반 관리: \n"
+"  * 컴파일러에 의해 수행됩니다.\n"
+"  * 런타임 오버헤드가 없습니다. \n"
+"  * 안전하고 정확합니다. "
+
+#: src/memory-management/comparison.md:20
+msgid "## Cons of Different Memory Management Techniques"
+msgstr "## 메모리 관리 방법 별 단점"
+
+#: src/memory-management/comparison.md:22
+msgid ""
+"* Manual like C:\n"
+"  * Use-after-free.\n"
+"  * Double-frees.\n"
+"  * Memory leaks.\n"
+"* Automatic like Java:\n"
+"  * Garbage collection pauses.\n"
+"  * Destructor delays.\n"
+"* Scope-based like C++:\n"
+"  * Complex, opt-in by programmer.\n"
+"  * Potential for use-after-free.\n"
+"* Compiler-enforced and scope-based like Rust:\n"
+"  * Some upfront complexity.\n"
+"  * Can reject valid programs."
+msgstr ""
+"* C와 같은 수동 관리: \n"
+"  * 사용 후 해제 문제\n"
+"  * 이중 해제 문제\n"
+"  * 메모리 누수 문제\n"
+"* JAVA와 같은 자동화 관리: \n"
+"  * GC동작으로 인한 멈춤\n"
+"  * 소멸자 지연 동작\n"
+"* C++과 같은 범위 기반 관리: \n"
+"  * 복잡하며 개발자에 의해서 최적화가 필요함\n"
+"  * 사용 후 해제 문제 가능성 있음\n"
+"* 러스트와 같은 컴파일러 수행 범위 기반 관리: \n"
+"  * 약간의 초기 복잡성\n"
+"  * 유효한 프로그램(로직)이 거부 될 수 있음"
+
+#: src/ownership.md:1
+msgid "# Ownership"
+msgstr "# 소유권"
+
+#: src/ownership.md:3
+msgid ""
+"All variable bindings have a _scope_ where they are valid and it is an error "
+"to\n"
+"use a variable outside its scope:"
+msgstr ""
+"모든 변수 바인딩은 유효한 _범위를_ 가지며, 범위 밖에서 변수 사용은 오류입니"
+"다:"
+
+#: src/ownership.md:6
+msgid ""
+"```rust,editable,compile_fail\n"
+"struct Point(i32, i32);"
+msgstr ""
+
+#: src/ownership.md:9
+msgid ""
+"fn main() {\n"
+"    {\n"
+"        let p = Point(3, 4);\n"
+"        println!(\"x: {}\", p.0);\n"
+"    }\n"
+"    println!(\"y: {}\", p.1);\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/ownership.md:18
+msgid ""
+"* At the end of the scope, the variable is _dropped_ and the data is freed.\n"
+"* A destructor can run here to free up resources.\n"
+"* We say that the variable _owns_ the value."
+msgstr ""
+"* 스코프가 종료되면 변수는 _삭제되고_ 데이터 메모리는 해제됩니다.\n"
+"* 소멸자는 여기(스코프 종료지점)에서 메모리 자원을 해제 합니다. \n"
+"* 이것을 두고 변수가 값을 _소유한다고_ 표현합니다."
+
+#: src/ownership/move-semantics.md:1
+msgid "# Move Semantics"
+msgstr "# 의미 이동"
+
+#: src/ownership/move-semantics.md:3
+msgid "An assignment will transfer ownership between variables:"
+msgstr "(변수의)할당은 변수 간 소유권을 이동시킵니다:"
+
+#: src/ownership/move-semantics.md:5
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let s1: String = String::from(\"Hello!\");\n"
+"    let s2: String = s1;\n"
+"    println!(\"s2: {s2}\");\n"
+"    // println!(\"s1: {s1}\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/ownership/move-semantics.md:14
+msgid ""
+"* The assignment of `s1` to `s2` transfers ownership.\n"
+"* The data was _moved_ from `s1` and `s1` is no longer accessible.\n"
+"* When `s1` goes out of scope, nothing happens: it has no ownership.\n"
+"* When `s2` goes out of scope, the string data is freed.\n"
+"* There is always _exactly_ one variable binding which owns a value."
+msgstr ""
+"* s1을 s2에 할당하여 소유권을 이전시킵니다.\n"
+"* 데이터는 s1에서 _이동_됩니다. 따라서 s1은 더이상 접근 할 수 없습니다.\n"
+"* `s1`의 스코프가 종료되면 아무 일도 없습니다: 아무런 소유권이 없습니다.\n"
+"* `s2`의 스코프가 종료되면 문자열 데이터는 해제됩니다.\n"
+"* 값(데이터)의 소유권을 갖는 변수는 항상 _정확히_ 하나 입니다."
+
+#: src/ownership/moved-strings-rust.md:1
+msgid "# Moved Strings in Rust"
+msgstr "# 러스트의 이동된 문자열"
+
+#: src/ownership/moved-strings-rust.md:3
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let s1: String = String::from(\"Rust\");\n"
+"    let s2: String = s1;\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/ownership/moved-strings-rust.md:10
+msgid ""
+"* The heap data from `s1` is reused for `s2`.\n"
+"* When `s1` goes out of scope, nothing happens (it has been moved from)."
+msgstr ""
+"* `s1`의 힙 데이터는 `s2`에서 재사용 됩니다. \n"
+"* `s1`의 스코프가 종료되면 아무일도 일어나지 않습니다.(이미 이동되었습니다.)"
+
+#: src/ownership/moved-strings-rust.md:13
+msgid "Before move to `s2`:"
+msgstr "`s2`이동 전 메모리:"
+
+#: src/ownership/moved-strings-rust.md:15
+msgid ""
+"```bob\n"
+" Stack                             Heap\n"
+".- - - - - - - - - - - - - -.     .- - - - - - - - - - - - - -.\n"
+":                           :     :                           :\n"
+":    s1                     :     :                           :\n"
+":   +-----------+-------+   :     :   +----+----+----+----+   :\n"
+":   | ptr       |   o---+---+-----+-->| R  | u  | s  | t  |   :\n"
+":   | len       |     4 |   :     :   +----+----+----+----+   :\n"
+":   | capacity  |     4 |   :     :                           :\n"
+":   +-----------+-------+   :     :                           :\n"
+":                           :     `- - - - - - - - - - - - - -'\n"
+":                           :\n"
+"`- - - - - - - - - - - - - -'\n"
+"```"
+msgstr ""
+
+#: src/ownership/moved-strings-rust.md:30
+msgid "After move to `s2`:"
+msgstr "`s2`이동 후 메모리:"
+
+#: src/ownership/moved-strings-rust.md:32
+msgid ""
+"```bob\n"
+" Stack                             Heap\n"
+".- - - - - - - - - - - - - -.     .- - - - - - - - - - - - - -.\n"
+":                           :     :                           :\n"
+":    s1 \"(inaccessible)\"    :     :                           :\n"
+":   +-----------+-------+   :     :   +----+----+----+----+   :\n"
+":   | ptr       |   o---+---+--+--+-->| R  | u  | s  | t  |   :\n"
+":   | len       |     4 |   :  |  :   +----+----+----+----+   :\n"
+":   | capacity  |     4 |   :  |  :                           :\n"
+":   +-----------+-------+   :  |  :                           :\n"
+":                           :  |  `- - - - - - - - - - - - - -'\n"
+":    s2                     :  |\n"
+":   +-----------+-------+   :  |\n"
+":   | ptr       |   o---+---+--'\n"
+":   | len       |     4 |   :\n"
+":   | capacity  |     4 |   :\n"
+":   +-----------+-------+   :\n"
+":                           :\n"
+"`- - - - - - - - - - - - - -'\n"
+"```"
+msgstr ""
+
+#: src/ownership/double-free-modern-cpp.md:1
+msgid "# Double Frees in Modern C++"
+msgstr "# Modern C++에서 이중해제 문제"
+
+#: src/ownership/double-free-modern-cpp.md:3
+msgid "Modern C++ solves this differently:"
+msgstr "Modern C++은 이 문제를 다르게 해결합니다:"
+
+#: src/ownership/double-free-modern-cpp.md:5
+msgid ""
+"```c++\n"
+"std::string s1 = \"Cpp\";\n"
+"std::string s2 = s1;  // Duplicate the data in s1.\n"
+"```"
+msgstr ""
+
+#: src/ownership/double-free-modern-cpp.md:10
+msgid ""
+"* The heap data from `s1` is duplicated and `s2` gets its own independent "
+"copy.\n"
+"* When `s1` and `s2` go out of scope, they each free their own memory."
+msgstr ""
+"* `s1`의 힙 데이터는 복제되고, `s2`는 독립적인 복사본을 얻습니다.\n"
+"* `s1` 와 `s2`의 스코프가 종료되면 각각의 메모리가 해제됩니다."
+
+#: src/ownership/double-free-modern-cpp.md:13
+msgid "Before copy-assignment:"
+msgstr "복사 전"
+
+#: src/ownership/double-free-modern-cpp.md:16
+msgid ""
+"```bob\n"
+" Stack                             Heap\n"
+".- - - - - - - - - - - - - -.     .- - - - - - - - - - - -.\n"
+":                           :     :                       :\n"
+":    s1                     :     :                       :\n"
+":   +-----------+-------+   :     :   +----+----+----+    :\n"
+":   | ptr       |   o---+---+--+--+-->| C  | p  | p  |    :\n"
+":   | len       |     3 |   :     :   +----+----+----+    :\n"
+":   | capacity  |     3 |   :     :                       :\n"
+":   +-----------+-------+   :     :                       :\n"
+":                           :     `- - - - - - - - - - - -'\n"
+"`- - - - - - - - - - - - - -'\n"
+"```"
+msgstr ""
+
+#: src/ownership/double-free-modern-cpp.md:30
+msgid "After copy-assignment:"
+msgstr "복사 후"
+
+#: src/ownership/double-free-modern-cpp.md:32
+msgid ""
+"```bob\n"
+" Stack                             Heap\n"
+".- - - - - - - - - - - - - -.     .- - - - - - - - - - - -.\n"
+":                           :     :                       :\n"
+":    s1                     :     :                       :\n"
+":   +-----------+-------+   :     :   +----+----+----+    :\n"
+":   | ptr       |   o---+---+--+--+-->| C  | p  | p  |    :\n"
+":   | len       |     3 |   :     :   +----+----+----+    :\n"
+":   | capacity  |     3 |   :     :                       :\n"
+":   +-----------+-------+   :     :                       :\n"
+":                           :     :                       :\n"
+":    s2                     :     :                       :\n"
+":   +-----------+-------+   :     :   +----+----+----+    :\n"
+":   | ptr       |   o---+---+-----+-->| C  | p  | p  |    :\n"
+":   | len       |     3 |   :     :   +----+----+----+    :\n"
+":   | capacity  |     3 |   :     :                       :\n"
+":   +-----------+-------+   :     :                       :\n"
+":                           :     `- - - - - - - - - - - -'\n"
+"`- - - - - - - - - - - - - -'\n"
+"```"
+msgstr ""
+
+#: src/ownership/moves-function-calls.md:1
+msgid "# Moves in Function Calls"
+msgstr "# 함수호출에서의 이동"
+
+#: src/ownership/moves-function-calls.md:3
+msgid ""
+"When you pass a value to a function, the value is assigned to the function\n"
+"parameter. This transfers ownership:"
+msgstr ""
+"값을 함수에 전달할때, 값은 함수 매개변수에 할당됩니다. 이것은 소유권을 이동시"
+"킵니다:"
+
+#: src/ownership/moves-function-calls.md:6
+msgid ""
+"```rust,editable\n"
+"fn say_hello(name: String) {\n"
+"    println!(\"Hello {name}\")\n"
+"}"
+msgstr ""
+
+#: src/ownership/moves-function-calls.md:11
+msgid ""
+"fn main() {\n"
+"    let name = String::from(\"Alice\");\n"
+"    say_hello(name);\n"
+"    // say_hello(name);\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/ownership/copy-clone.md:1
+msgid "# Copying and Cloning"
+msgstr "# 복사와 복제"
+
+#: src/ownership/copy-clone.md:3
+msgid ""
+"While move semantics are the default, certain types are copied by default:"
+msgstr "의미구조(Semantics)가 이동할때, 특정 타입은 기본적으로 복사됩니다:"
+
+#: src/ownership/copy-clone.md:5
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let x = 42;\n"
+"    let y = x;\n"
+"    println!(\"x: {x}\");\n"
+"    println!(\"y: {y}\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/ownership/copy-clone.md:14
+msgid "These types implement the `Copy` trait."
+msgstr "이러한 유형들은 `Copy` 트레이트를 구현합니다. "
+
+#: src/ownership/copy-clone.md:16
+msgid "You can opt-in your own types to use copy semantics:"
+msgstr ""
+"직접 만든 타입들도 `Copy`트레이트를 구현하여 의미복사를 할 수 있습니다:"
+
+#: src/ownership/copy-clone.md:18
+msgid ""
+"```rust,editable\n"
+"#[derive(Copy, Clone, Debug)]\n"
+"struct Point(i32, i32);"
+msgstr ""
+
+#: src/ownership/copy-clone.md:22
+msgid ""
+"fn main() {\n"
+"    let p1 = Point(3, 4);\n"
+"    let p2 = p1;\n"
+"    println!(\"p1: {p1:?}\");\n"
+"    println!(\"p2: {p2:?}\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/ownership/copy-clone.md:30
+msgid ""
+"* After the assignment, both `p1` and `p2` own their own data.\n"
+"* We can also use `p1.clone()` to explicitly copy the data."
+msgstr ""
+"* 할당 후, `p1`와 `p2`는 자신의 데이터를 소유합니다.\n"
+"* 명시적으로 `p1.clone()`를 사용하여 데이터를 복사할 수 있습니다."
+
+#: src/ownership/copy-clone.md:35
+msgid "Copying and cloning are not the same thing:"
+msgstr "복사와 복제는 같지 않습니다: "
+
+#: src/ownership/copy-clone.md:37
+msgid ""
+"* Copying refers to bitwise copies of memory regions and does not work on "
+"arbitrary objects.\n"
+"* Copying does not allow for custom logic (unlike copy constructors in C+"
+"+).\n"
+"* Cloning is a more general operation and also allows for custom behavior by "
+"implementing the `Clone` trait.\n"
+"* Copying does not work on types that implement the `Drop` trait."
+msgstr ""
+"* 복사는 메모리 영역의 비트단위 복사본으로 임의의 객체에서는 동작하지 않습니"
+"다. \n"
+"* 복제는 보다 일반적인 작업으로 `Clone`트레이트를 구현하여 사용자 지정동작을 "
+"허용합니다.\n"
+"* `Drop` 트레이트를 구현한 타입에서 복사는 동작하지 않습니다."
+
+#: src/ownership/copy-clone.md:42 src/ownership/lifetimes-function-calls.md:29
+msgid "In the above example, try the following:"
+msgstr "위의 예시에서 다음을 시도해 보시기 바랍니다:"
+
+#: src/ownership/copy-clone.md:44
+msgid ""
+"* Add a `String` field to `struct Point`. It will not compile because "
+"`String` is not a `Copy` type.\n"
+"* Remove `Copy` from the `derive` attribute. The compiler error is now in "
+"the `println!` for  `p1`.\n"
+"* Show that it works if you clone `p1` instead."
+msgstr ""
+"* `Point 구조체`에 `String`필드를 추가하면 어떻게 됩니까?\n"
+"* `derive` 속성에서 `Copy`를 제거해도 동작합니까?\n"
+"* Copy를 제거 한 후, `p1`을 이동해도 여전히 출력 됩니까?"
+
+#: src/ownership/borrowing.md:1
+msgid "# Borrowing"
+msgstr "# 빌림(Borrowing)"
+
+#: src/ownership/borrowing.md:3
+msgid ""
+"Instead of transferring ownership when calling a function, you can let a\n"
+"function _borrow_ the value:"
+msgstr ""
+"함수 호출시 값의 소유권을 이동하는 대신의 함수가 값을 _빌려올 수_ 있습니다:"
+
+#: src/ownership/borrowing.md:6 src/ownership/lifetimes-function-calls.md:5
+msgid ""
+"```rust,editable\n"
+"#[derive(Debug)]\n"
+"struct Point(i32, i32);"
+msgstr ""
+
+#: src/ownership/borrowing.md:10
+msgid ""
+"fn add(p1: &Point, p2: &Point) -> Point {\n"
+"    Point(p1.0 + p2.0, p1.1 + p2.1)\n"
+"}"
+msgstr ""
+
+#: src/ownership/borrowing.md:14
+msgid ""
+"fn main() {\n"
+"    let p1 = Point(3, 4);\n"
+"    let p2 = Point(10, 20);\n"
+"    let p3 = add(&p1, &p2);\n"
+"    println!(\"{p1:?} + {p2:?} = {p3:?}\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/ownership/borrowing.md:22
+msgid ""
+"* The `add` function _borrows_ two points and returns a new point.\n"
+"* The caller retains ownership of the inputs."
+msgstr ""
+"* `add` 함수는 두 Point객체 값을 _빌려_오와서 새로운 Point객체를 반환합니"
+"다.\n"
+"* 호출자(main 함수)는 여전히 p1, p2의 소유권을 유지합니다."
+
+#: src/ownership/borrowing.md:27
+msgid ""
+"Notes on stack returns:\n"
+"* Demonstrate that the return from `add` is cheap because the compiler can "
+"eliminate the copy operation. Change the above code to print stack addresses "
+"and run it on the [Playground](https://play.rust-lang.org/). In the "
+"\"DEBUG\" optimization level, the addresses should change, while the stay "
+"the same when changning to the \"RELEASE\" setting:"
+msgstr ""
+"스택 반환에 대한 참고: \n"
+"* 컴파일러가 복사 동작을 제거할 수 있기 때문에 `add`에서의 반환 코스트가 낮습"
+"니다.\n"
+" 아래는 스택주소를 출력하도록 수정한 예제입니다.\n"
+" `DEBUG` 최적화 레벨에서 주소는 변경되지만 `RELEASE`에서는 그렇지 않습니다."
+
+#: src/ownership/borrowing.md:30
+msgid ""
+"  ```rust,editable\n"
+"  #[derive(Debug)]\n"
+"  struct Point(i32, i32);"
+msgstr ""
+
+#: src/ownership/borrowing.md:34
+msgid ""
+"  fn add(p1: &Point, p2: &Point) -> Point {\n"
+"      let p = Point(p1.0 + p2.0, p1.1 + p2.1);\n"
+"      println!(\"&p.0: {:p}\", &p.0);\n"
+"      p\n"
+"  }"
+msgstr ""
+
+#: src/ownership/borrowing.md:40
+msgid ""
+"  fn main() {\n"
+"      let p1 = Point(3, 4);\n"
+"      let p2 = Point(10, 20);\n"
+"      let p3 = add(&p1, &p2);\n"
+"      println!(\"&p3.0: {:p}\", &p3.0);\n"
+"      println!(\"{p1:?} + {p2:?} = {p3:?}\");\n"
+"  }\n"
+"  ```\n"
+"* The Rust compiler can do return value optimization (RVO).\n"
+"* In C++, copy elision has to be defined in the language specification "
+"because constructors can have side effects. In Rust, this is not an issue at "
+"all."
+msgstr ""
+"  fn main() {\n"
+"      let p1 = Point(3, 4);\n"
+"      let p2 = Point(10, 20);\n"
+"      let p3 = add(&p1, &p2);\n"
+"      println!(\"&p3.0: {:p}\", &p3.0);\n"
+"      println!(\"{p1:?} + {p2:?} = {p3:?}\");\n"
+"  }\n"
+"  ```\n"
+"* 러스트 컴파일러는 반환값 최적화(RVO)를 수행할 수 있습니다.\n"
+"* C++에서 copy elision은 생성자의 부수효과 가능성이 있어 언어레벨의 정의가   "
+"필요하지만 러스트에서는 문제가 되지 않습니다."
+
+#: src/ownership/shared-unique-borrows.md:1
+msgid "# Shared and Unique Borrows"
+msgstr "# 공유와 고유 빌림"
+
+#: src/ownership/shared-unique-borrows.md:3
+msgid "Rust puts constraints on the ways you can borrow values:"
+msgstr "러스트는 값을 빌려오는 방법에 대한 제약이 존재합니다:"
+
+#: src/ownership/shared-unique-borrows.md:5
+msgid ""
+"* You can have one or more `&T` values at any given time, _or_\n"
+"* You can have exactly one `&mut T` value."
+msgstr ""
+"* 한번에 하나 이상의 `&T` 값을 가질 수 있습니다.(1~N개의 불변 변수)  _또는"
+"_ \n"
+"* 정확히 하나의 `&mut T` 값을 가질 수 있습니다.(1개의 가변 변수)"
+
+#: src/ownership/shared-unique-borrows.md:8
+msgid ""
+"```rust,editable,compile_fail\n"
+"fn main() {\n"
+"    let mut a: i32 = 10;\n"
+"    let b: &i32 = &a;"
+msgstr ""
+
+#: src/ownership/shared-unique-borrows.md:13
+msgid ""
+"    {\n"
+"        let c: &mut i32 = &mut a;\n"
+"        *c = 20;\n"
+"    }"
+msgstr ""
+
+#: src/ownership/shared-unique-borrows.md:18 src/std/rc.md:13
+msgid ""
+"    println!(\"a: {a}\");\n"
+"    println!(\"b: {b}\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/ownership/shared-unique-borrows.md:25
+msgid ""
+"* The above code does not compile because `a` is borrowed as mutable "
+"(through `c`) and as immutable (through `b`) at the same time.\n"
+"* Move the `println!` statement for `b` before the scope that introduces `c` "
+"to make the code compile.\n"
+"* After that change, the compiler realizes that `b` is only ever used before "
+"the new mutable borrow of `a` through `c`. This is a feature of the borrow "
+"checker called \"non-lexical lifetimes\"."
+msgstr ""
+"* 상기 코드는 `a`는 가변변수`c`와 불변변수`b`에 동시에 빌림이 되어 컴파일이  "
+"되지 않습니다. \n"
+"* 코드 컴파일을 위해 `c` 선언 범위 앞으로 `b`에 대한 `println!`구문을   이동"
+"합니다.\n"
+"* 이 변경 후에 컴파일러는 `b`가 `c` 나 `a` 의 사용전까지만 이용되는 것을 알"
+"게 되어 컴파일이 됩니다. 이러한 기능을 `비 어휘적 수명(non-lexical lifetime)`"
+"라고 합니다."
+
+#: src/ownership/lifetimes.md:1
+msgid "# Lifetimes"
+msgstr "# 수명"
+
+#: src/ownership/lifetimes.md:3
+msgid "A borrowed value has a _lifetime_:"
+msgstr "빌려온 값은 _수명을_ 갖습니다:"
+
+#: src/ownership/lifetimes.md:5
+msgid ""
+"* The lifetime can be elided: `add(p1: &Point, p2: &Point) -> Point`.\n"
+"* Lifetimes can also be explicit: `&'a Point`, `&'document str`.\n"
+"* Read `&'a Point` as \"a borrowed `Point` which is valid for at least the\n"
+"  lifetime `a`\".\n"
+"* Lifetimes are always inferred by the compiler: you cannot assign a "
+"lifetime\n"
+"  yourself.\n"
+"  * Lifetime annotations create constraints; the compiler verifies that "
+"there is\n"
+"    a valid solution."
+msgstr ""
+"* 수명는 생략할 수 있습니다: `add(p1: &Point, p2: &Point) -> Point`.\n"
+"* 물론 명시할 수도 있습니다: `&'a Point`, `&'document str`.\n"
+"* `&'a Point` 는 as `a`가 유효한 동안 빌려온 `Point` 입니다.\n"
+"* 수명는 항상 컴파일러에 의해 추론됩니다: 직접 수명을 설정할 수는 없습니다.\n"
+"  * 수명 표기(`'`)은 제약조건을 생성합니다.\n"
+"  * 컴파일러는 유효한 솔루션(추론가능한 수명)이 있는지 검증합니다."
+
+#: src/ownership/lifetimes-function-calls.md:1
+msgid "# Lifetimes in Function Calls"
+msgstr "# 함수호출에서의 수명"
+
+#: src/ownership/lifetimes-function-calls.md:3
+msgid ""
+"In addition to borrowing its arguments, a function can return a borrowed "
+"value:"
+msgstr "함수는 인수를 빌리는 것 외에도 빌린 값을 반환할 수 있습니다:"
+
+#: src/ownership/lifetimes-function-calls.md:9
+msgid ""
+"fn left_most<'a>(p1: &'a Point, p2: &'a Point) -> &'a Point {\n"
+"    if p1.0 < p2.0 { p1 } else { p2 }\n"
+"}"
+msgstr ""
+
+#: src/ownership/lifetimes-function-calls.md:13
+msgid ""
+"fn main() {\n"
+"    let p1: Point = Point(10, 10);\n"
+"    let p2: Point = Point(20, 20);\n"
+"    let p3: &Point = left_most(&p1, &p2);\n"
+"    println!(\"left-most point: {:?}\", p3);\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/ownership/lifetimes-function-calls.md:21
+msgid ""
+"* `'a` is a generic parameter, it is inferred by the compiler.\n"
+"* Lifetimes start with `'` and `'a` is a typical default name.\n"
+"* Read `&'a Point` as \"a borrowed `Point` which is valid for at least the\n"
+"  lifetime `a`\".\n"
+"  * The _at least_ part is important when parameters are in different scopes."
+msgstr ""
+"* `'a`는 제너릭 매개변수로 컴파일러로에 의해 추론됩니다.\n"
+"* 수명은 `'` 로 표기하며 러스트에서는 일반적으로 `'a` 라고 표현합니다.\n"
+"* `&'a Point` 는 as  `a`와 동일한 수명을 가지는 빌려온 `Point` 입니다.\n"
+"  * **중요** : 다른 스코프에 있어도 적용 됩니다."
+
+#: src/ownership/lifetimes-function-calls.md:31
+msgid ""
+"* Move the declaration of `p2` and `p3` into a a new scope (`{ ... }`), "
+"resulting in the following code:\n"
+"  ```rust,ignore\n"
+"  #[derive(Debug)]\n"
+"  struct Point(i32, i32);"
+msgstr ""
+"* p2와 p3를 새로운 범위(`{...}`)로 아래 코드와 같이 이동해 봅니다:\n"
+"  ```rust,ignore\n"
+"  #[derive(Debug)]\n"
+"  struct Point(i32, i32);"
+
+#: src/ownership/lifetimes-function-calls.md:36
+msgid ""
+"  fn left_most<'a>(p1: &'a Point, p2: &'a Point) -> &'a Point {\n"
+"      if p1.0 < p2.0 { p1 } else { p2 }\n"
+"  }"
+msgstr ""
+
+#: src/ownership/lifetimes-function-calls.md:40
+msgid ""
+"  fn main() {\n"
+"      let p1: Point = Point(10, 10);\n"
+"      let p3: &Point;\n"
+"      {\n"
+"          let p2: Point = Point(20, 20);\n"
+"          p3 = left_most(&p1, &p2);\n"
+"      }\n"
+"      println!(\"left-most point: {:?}\", p3);\n"
+"  }\n"
+"  ```\n"
+"  Note how this does not compile since `p3` outlives `p2`."
+msgstr ""
+"  fn main() {\n"
+"      let p1: Point = Point(10, 10);\n"
+"      let p3: &Point;\n"
+"      {\n"
+"          let p2: Point = Point(20, 20);\n"
+"          p3 = left_most(&p1, &p2);\n"
+"      }\n"
+"      println!(\"left-most point: {:?}\", p3);\n"
+"  }\n"
+"  ```\n"
+"  p3가 p2보다 오래 지속되기 때문에 이 예제는 컴파일되지 않음을 확인하시기   "
+"바랍니다."
+
+#: src/ownership/lifetimes-function-calls.md:52
+msgid ""
+"* Reset the workspace and change the function signature to `fn left_most<'a, "
+"'b>(p1: &'a Point, p2: &'a Point) -> &'b Point`. This will not compile "
+"because the relationship between the lifetimes `'a` and `'b` is unclear."
+msgstr ""
+"* 워크스페이스을 초기화하고 함수 시그니처를 `fn left_most<'a, 'b>(p1:&'a "
+"Point, p2:&'a Point) -> &'b Point`로 변경합니다. `'a`와 `'b`의 수명 사이가 불"
+"분명하기 때문에 이것은 컴파일되지 않습니다."
+
+#: src/ownership/lifetimes-data-structures.md:1
+msgid "# Lifetimes in Data Structures"
+msgstr "# 자료 구조에서의 수명"
+
+#: src/ownership/lifetimes-data-structures.md:3
+msgid ""
+"If a data type stores borrowed data, it must be annotated with a lifetime:"
+msgstr ""
+"만약 빌려온 데이터를 저장하는 타입(구조체 같은)인 경우, 반드시 수명 표기를 해"
+"야합니다."
+
+#: src/ownership/lifetimes-data-structures.md:5
+msgid ""
+"```rust,editable\n"
+"#[derive(Debug)]\n"
+"struct Highlight<'doc>(&'doc str);"
+msgstr ""
+
+#: src/ownership/lifetimes-data-structures.md:9
+msgid ""
+"fn erase(text: String) {\n"
+"    println!(\"Bye {text}!\");\n"
+"}"
+msgstr ""
+
+#: src/ownership/lifetimes-data-structures.md:13
+msgid ""
+"fn main() {\n"
+"    let text = String::from(\"The quick brown fox jumps over the lazy dog."
+"\");\n"
+"    let fox = Highlight(&text[4..19]);\n"
+"    let dog = Highlight(&text[35..43]);\n"
+"    // erase(text);\n"
+"    println!(\"{fox:?}\");\n"
+"    println!(\"{dog:?}\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/exercises/day-1/afternoon.md:1
+msgid "# Day 1: Afternoon Exercises"
+msgstr "# 1일차 오후 연습문제"
+
+#: src/exercises/day-1/afternoon.md:3
+msgid "We will look at two things:"
+msgstr "이번 연습문제는 아래 두가지입니다:"
+
+#: src/exercises/day-1/afternoon.md:5
+msgid "* A small book library,"
+msgstr "* 작은 도서관"
+
+#: src/exercises/day-1/afternoon.md:7
+msgid "* Iterators and ownership (hard)."
+msgstr "* 반복자와 소유권(어려움!)"
+
+#: src/exercises/day-1/book-library.md:1
+msgid "# Designing a Library"
+msgstr "# 도서관 설계"
+
+#: src/exercises/day-1/book-library.md:3
+msgid ""
+"We will learn much more about structs and the `Vec<T>` type tomorrow. For "
+"now,\n"
+"you just need to know part of its API:"
+msgstr ""
+"우리는 내일 구조체와 Vec<T>에 대해 더 많은 것을 배울 것입니다.  \n"
+"일단 오늘은 API의 일부만 알면 됩니다:"
+
+#: src/exercises/day-1/book-library.md:6
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let mut vec = vec![10, 20];\n"
+"    vec.push(30);\n"
+"    println!(\"middle value: {}\", vec[vec.len() / 2]);\n"
+"    for item in vec.iter() {\n"
+"        println!(\"item: {item}\");\n"
+"    }\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/exercises/day-1/book-library.md:17
+msgid ""
+"Use this to create a library application. Copy the code below to\n"
+"<https://play.rust-lang.org/> and update the types to make it compile:"
+msgstr ""
+"도서관 프로그램을 만들기 위해 아래 코드를 <https://play.rust-lang.org/>에 복"
+"사해서 구현하시면 됩니다.\n"
+" *  _역주: 아래 소스 주석에 번역이 적용되지 않지만 이해가 어렵진 않습니다_\n"
+"   * _self가 추가되야할 메서드도 있고 impl 자체도 구현할게 있습니다._"
+
+#: src/exercises/day-1/book-library.md:24
+msgid ""
+"struct Library {\n"
+"    books: Vec<Book>,\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-1/book-library.md:28
+#: src/exercises/day-1/solutions-afternoon.md:27
+msgid ""
+"struct Book {\n"
+"    title: String,\n"
+"    year: u16,\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-1/book-library.md:33
+#: src/exercises/day-1/solutions-afternoon.md:32
+msgid ""
+"impl Book {\n"
+"    // This is a constructor, used below.\n"
+"    fn new(title: &str, year: u16) -> Book {\n"
+"        Book {\n"
+"            title: String::from(title),\n"
+"            year,\n"
+"        }\n"
+"    }\n"
+"}"
+msgstr ""
+"impl Book {\n"
+"    // 아래는 Book 구조체의 생성자입니다.\n"
+"    fn new(title: &str, year: u16) -> Book {\n"
+"        Book {\n"
+"            title: String::from(title),\n"
+"            year,\n"
+"        }\n"
+"    }\n"
+"}"
+
+#: src/exercises/day-1/book-library.md:43
+msgid ""
+"// This makes it possible to print Book values with {}.\n"
+"impl std::fmt::Display for Book {\n"
+"    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {\n"
+"        write!(f, \"{} ({})\", self.title, self.year)\n"
+"    }\n"
+"}"
+msgstr ""
+"// 이 구현메서드는 {} 포맷으로 출력할 수 있게 도와줍니다.\n"
+"impl std::fmt::Display for Book {\n"
+"    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {\n"
+"        write!(f, \"{} ({})\", self.title, self.year)\n"
+"    }\n"
+"}"
+
+#: src/exercises/day-1/book-library.md:50
+msgid ""
+"impl Library {\n"
+"    fn new() -> Library {\n"
+"        unimplemented!()\n"
+"    }"
+msgstr ""
+
+#: src/exercises/day-1/book-library.md:55
+msgid ""
+"    //fn len(self) -> usize {\n"
+"    //    unimplemented!()\n"
+"    //}"
+msgstr ""
+
+#: src/exercises/day-1/book-library.md:59
+msgid ""
+"    //fn is_empty(self) -> bool {\n"
+"    //    unimplemented!()\n"
+"    //}"
+msgstr ""
+
+#: src/exercises/day-1/book-library.md:63
+msgid ""
+"    //fn add_book(self, book: Book) {\n"
+"    //    unimplemented!()\n"
+"    //}"
+msgstr ""
+
+#: src/exercises/day-1/book-library.md:67
+msgid ""
+"    //fn print_books(self) {\n"
+"    //    unimplemented!()\n"
+"    //}"
+msgstr ""
+
+#: src/exercises/day-1/book-library.md:71
+msgid ""
+"    //fn oldest_book(self) -> Option<&Book> {\n"
+"    //    unimplemented!()\n"
+"    //}\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-1/book-library.md:76
+msgid ""
+"// This shows the desired behavior. Uncomment the code below and\n"
+"// implement the missing methods. You will need to update the\n"
+"// method signatures, including the \"self\" parameter!\n"
+"fn main() {\n"
+"    let library = Library::new();"
+msgstr ""
+"// 아래 소스 주석을 제거하고 누락된 메서드를 구현하세요\n"
+"// 미구현 메서드도 존재하므로 메서드 시그니처를 업데이트 하세요(self 포함)\n"
+"fn main() {\n"
+"    let library = Library::new();"
+
+#: src/exercises/day-1/book-library.md:82
+msgid ""
+"    //println!(\"Our library is empty: {}\", library.is_empty());\n"
+"    //\n"
+"    //library.add_book(Book::new(\"Lord of the Rings\", 1954));\n"
+"    //library.add_book(Book::new(\"Alice's Adventures in Wonderland\", "
+"1865));\n"
+"    //\n"
+"    //library.print_books();\n"
+"    //\n"
+"    //match library.oldest_book() {\n"
+"    //    Some(book) => println!(\"My oldest book is {book}\"),\n"
+"    //    None => println!(\"My library is empty!\"),\n"
+"    //}\n"
+"    //\n"
+"    //println!(\"Our library has {} books\", library.len());\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/exercises/day-1/iterators-and-ownership.md:1
+msgid "# Iterators and Ownership"
+msgstr "# 반복자와 소유권"
+
+#: src/exercises/day-1/iterators-and-ownership.md:3
+msgid ""
+"The ownership model of Rust affects many APIs. An example of this is the\n"
+"[`Iterator`](https://doc.rust-lang.org/std/iter/trait.Iterator.html) and\n"
+"[`IntoIterator`](https://doc.rust-lang.org/std/iter/trait.IntoIterator."
+"html)\n"
+"traits."
+msgstr ""
+"러스트의 소유권 모델은 많은 API에 영향을 줍니다.  \n"
+"예를들어 [`Iterator`](https://doc.rust-lang.org/std/iter/trait.Iterator."
+"html) 와 [`IntoIterator`](https://doc.rust-lang.org/std/iter/trait."
+"IntoIterator.html) 같은 트레이트가 있습니다."
+
+#: src/exercises/day-1/iterators-and-ownership.md:8
+msgid "## `Iterator`"
+msgstr ""
+
+#: src/exercises/day-1/iterators-and-ownership.md:10
+msgid ""
+"Traits are like interfaces: they describe behavior (methods) for a type. "
+"The\n"
+"`Iterator` trait simply says that you can call `next` until you get `None` "
+"back:"
+msgstr ""
+"트레이트는 타입에 대한 행동(메서드)를 설명한다는 점에서 인터페이스와  유사합"
+"니다.`Iterator`는 단순히 `None`가 나올때까지 `next`를 호출하는 트레이트입니"
+"다."
+
+#: src/exercises/day-1/iterators-and-ownership.md:13
+msgid ""
+"```rust\n"
+"pub trait Iterator {\n"
+"    type Item;\n"
+"    fn next(&mut self) -> Option<Self::Item>;\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/exercises/day-1/iterators-and-ownership.md:20
+msgid "You use this trait like this:"
+msgstr "`Iterator`트레이트는 이렇게 사용합니다:"
+
+#: src/exercises/day-1/iterators-and-ownership.md:22
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let v: Vec<i8> = vec![10, 20, 30];\n"
+"    let mut iter = v.iter();"
+msgstr ""
+
+#: src/exercises/day-1/iterators-and-ownership.md:27
+msgid ""
+"    println!(\"v[0]: {:?}\", iter.next());\n"
+"    println!(\"v[1]: {:?}\", iter.next());\n"
+"    println!(\"v[2]: {:?}\", iter.next());\n"
+"    println!(\"No more items: {:?}\", iter.next());\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/exercises/day-1/iterators-and-ownership.md:34
+msgid "What is the type returned by the iterator? Test your answer here:"
+msgstr ""
+"질문) 반복자(이터레이터)가 반환하는 타입은 무엇입니까? 아래 코드를 수정해보세"
+"요:"
+
+#: src/exercises/day-1/iterators-and-ownership.md:36
+msgid ""
+"```rust,editable,compile_fail\n"
+"fn main() {\n"
+"    let v: Vec<i8> = vec![10, 20, 30];\n"
+"    let mut iter = v.iter();"
+msgstr ""
+
+#: src/exercises/day-1/iterators-and-ownership.md:41
+#: src/exercises/day-1/iterators-and-ownership.md:78
+msgid ""
+"    let v0: Option<..> = iter.next();\n"
+"    println!(\"v0: {v0:?}\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/exercises/day-1/iterators-and-ownership.md:46
+msgid "Why is this type used?"
+msgstr "왜 이런 것을 사용해야 합니까?"
+
+#: src/exercises/day-1/iterators-and-ownership.md:48
+msgid "## `IntoIterator`"
+msgstr ""
+
+#: src/exercises/day-1/iterators-and-ownership.md:50
+msgid ""
+"The `Iterator` trait tells you how to _iterate_ once you have created an\n"
+"iterator. The related trait `IntoIterator` tells you how to create the "
+"iterator:"
+msgstr ""
+"Iterator 트레이트는 생성된 반복자를 \"어떻게 반복 하는지\" 알려줍니다.  \n"
+"이와 관련된 `IntoIterator` 트레이트는 \"반복자를 어떻게 만드는지\" 알려줍니"
+"다."
+
+#: src/exercises/day-1/iterators-and-ownership.md:53
+msgid ""
+"```rust\n"
+"pub trait IntoIterator {\n"
+"    type Item;\n"
+"    type IntoIter: Iterator<Item = Self::Item>;"
+msgstr ""
+
+#: src/exercises/day-1/iterators-and-ownership.md:58
+msgid ""
+"    fn into_iter(self) -> Self::IntoIter;\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/exercises/day-1/iterators-and-ownership.md:62
+msgid ""
+"The syntax here means that every implementation of `IntoIterator` must\n"
+"declare two types:"
+msgstr "IntoIterator의 모든 구현은 반드시 두 타입을 선언해야합니다:"
+
+#: src/exercises/day-1/iterators-and-ownership.md:65
+msgid ""
+"* `Item`: the type we iterate over, such as `i8`,\n"
+"* `IntoIter`: the `Iterator` type returned by the `into_iter` method."
+msgstr ""
+"* `Item`: `i8`과 같이 반복되는 요소의 유형\n"
+"* `IntoIter`:  `into_iter`메서드에서 반환되는 `Iterator`타입."
+
+#: src/exercises/day-1/iterators-and-ownership.md:68
+msgid ""
+"Note that `IntoIter` and `Item` are linked: the iterator must have the same\n"
+"`Item` type, which means that it returns `Option<Item>`"
+msgstr ""
+"IntoIter와 Item는 링크되어 있습니다: 반복자와 Item 타입은 동일해야합니다. "
+"즉, Option<Item>를 반환해야 합니다."
+
+#: src/exercises/day-1/iterators-and-ownership.md:71
+msgid "Like before, what  is the type returned by the iterator?"
+msgstr ""
+"질문) (이전과 마찬가지로) 반복자(이터레이터)가 반환하는 타입은 무엇입니까? 아"
+"래 코드를 수정해보세요:"
+
+#: src/exercises/day-1/iterators-and-ownership.md:73
+msgid ""
+"```rust,editable,compile_fail\n"
+"fn main() {\n"
+"    let v: Vec<String> = vec![String::from(\"foo\"), String::"
+"from(\"bar\")];\n"
+"    let mut iter = v.into_iter();"
+msgstr ""
+
+#: src/exercises/day-1/iterators-and-ownership.md:83
+msgid "## `for` Loops"
+msgstr "## 배열과 `for`반복문"
+
+#: src/exercises/day-1/iterators-and-ownership.md:85
+msgid ""
+"Now that we know both `Iterator` and `IntoIterator`, we can build `for` "
+"loops.\n"
+"They call `into_iter()` on an expression and iterates over the resulting\n"
+"iterator:"
+msgstr ""
+"자, 이제 우리는 `Iterator`와 `IntoIterator`를 알았으므로 `for` 루프를 만들 "
+"수 있습니다. \n"
+"`for` 루프는 `into_iter()`를 호출하여 결과를 반환하는 것을 반복합니다:"
+
+#: src/exercises/day-1/iterators-and-ownership.md:89
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let v: Vec<String> = vec![String::from(\"foo\"), String::from(\"bar\")];"
+msgstr ""
+
+#: src/exercises/day-1/iterators-and-ownership.md:93
+msgid ""
+"    for word in &v {\n"
+"        println!(\"word: {word}\");\n"
+"    }"
+msgstr ""
+
+#: src/exercises/day-1/iterators-and-ownership.md:97
+msgid ""
+"    for word in v {\n"
+"        println!(\"word: {word}\");\n"
+"    }\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/exercises/day-1/iterators-and-ownership.md:103
+msgid "What is the type of `word` in each loop?"
+msgstr "질문) 매 루프에서 `word`의 타입은 무엇입니까? "
+
+#: src/exercises/day-1/iterators-and-ownership.md:105
+msgid ""
+"Experiment with the code above and then consult the documentation for "
+"[`impl\n"
+"IntoIterator for\n"
+"&Vec<T>`](https://doc.rust-lang.org/std/vec/struct.Vec.html#impl-"
+"IntoIterator-for-%26%27a%20Vec%3CT%2C%20A%3E)\n"
+"and [`impl IntoIterator for\n"
+"Vec<T>`](https://doc.rust-lang.org/std/vec/struct.Vec.html#impl-IntoIterator-"
+"for-%26%27a%20Vec%3CT%2C%20A%3E)\n"
+"to check your answers."
+msgstr ""
+"위 코드에서 실험 해 본 후 다음 문서를 참조해서 답변을 확인하시기 바랍니다.\n"
+"* [`impl IntoIterator for &Vec<T>`](https://doc.rust-lang.org/std/vec/struct."
+"Vec.html#impl-IntoIterator-for-%26%27a%20Vec%3CT%2C%20A%3E)\n"
+"* [`impl IntoIterator for Vec<T>`](https://doc.rust-lang.org/std/vec/struct."
+"Vec.html#impl-IntoIterator-for-%26%27a%20Vec%3CT%2C%20A%3E)"
+
+#: src/welcome-day-2.md:1
+msgid "# Welcome to Day 2"
+msgstr "# 2일차 개요"
+
+#: src/welcome-day-2.md:3
+msgid "Now that we have seen a fair amount of Rust, we will continue with:"
+msgstr "상당한 분량의 러스트에 대해 보았고, 이어서 오늘 강의를 진행하겠습니다:"
+
+#: src/welcome-day-2.md:5
+msgid "* Structs, enums, methods."
+msgstr "* 구조체, 열거형, 메서드"
+
+#: src/welcome-day-2.md:7
+msgid "* Pattern matching: destructuring enums, structs, and arrays."
+msgstr "* 패턴 매칭: 열거형, 구조체 그리고 배열 분해"
+
+#: src/welcome-day-2.md:9
+msgid ""
+"* Control flow constructs: `if`, `if let`, `while`, `while let`, `break`, "
+"and\n"
+"  `continue`."
+msgstr ""
+"* 흐름 제어: `if`, `if let`, `while`, `while let`, `break`, 그리고 "
+"`continue`."
+
+#: src/welcome-day-2.md:12
+msgid ""
+"* The Standard Library: `String`, `Option` and `Result`, `Vec`, `HashMap`, "
+"`Rc`\n"
+"  and `Arc`."
+msgstr ""
+"* 표준 라이브러리:: `String`, `Option` 과 `Result`, `Vec`, `HashMap`, `Rc`  "
+"그리고 `Arc`."
+
+#: src/welcome-day-2.md:15
+msgid "* Modules: visibility, paths, and filesystem hierarchy."
+msgstr "* 모듈: 가시성, 경로 및 파일 시스템 계층."
+
+#: src/structs.md:1
+msgid "# Structs"
+msgstr "# 구조체"
+
+#: src/structs.md:3
+msgid "Like C and C++, Rust has support for custom structs:"
+msgstr "C/C++과 마찬가지로 러스트는 커스텀 구조체를 지원합니다:"
+
+#: src/structs.md:5
+msgid ""
+"```rust,editable\n"
+"struct Person {\n"
+"    name: String,\n"
+"    age: u8,\n"
+"}"
+msgstr ""
+
+#: src/structs.md:11
+msgid ""
+"fn main() {\n"
+"    let peter = Person {\n"
+"        name: String::from(\"Peter\"),\n"
+"        age: 27,\n"
+"    };"
+msgstr ""
+
+#: src/structs.md:17
+msgid ""
+"    println!(\"{} is {} years old\", peter.name, peter.age);\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/structs/tuple-structs.md:1
+msgid "# Tuple Structs"
+msgstr "# 튜플"
+
+#: src/structs/tuple-structs.md:3
+msgid "If the field names are unimportant, you can use a tuple struct:"
+msgstr "각 값의 이름이 중요하지 않다면 튜블 구조체를 사용할 수 있습니다:"
+
+#: src/structs/tuple-structs.md:5
+msgid ""
+"```rust,editable\n"
+"struct Point(i32, i32);"
+msgstr ""
+
+#: src/structs/tuple-structs.md:8
+msgid ""
+"fn main() {\n"
+"    let p = Point(17, 23);\n"
+"    println!(\"({}, {})\", p.0, p.1);\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/structs/tuple-structs.md:14
+msgid "This is often used for single-field wrappers (called newtypes):"
+msgstr ""
+"종종 단일 필드(cm, mm, 뉴턴, 파운트(힘))의 래퍼(wrapper)로 사용됩니다.(러스트"
+"에서 newtypes 패턴이라 부릅니다): "
+
+#: src/structs/tuple-structs.md:16
+msgid ""
+"```rust,editable,compile_fail\n"
+"struct PoundOfForce(f64);\n"
+"struct Newtons(f64);"
+msgstr ""
+
+#: src/structs/tuple-structs.md:20
+msgid ""
+"fn compute_thruster_force() -> PoundOfForce {\n"
+"    todo!(\"Ask a rocket scientist at NASA\")\n"
+"}"
+msgstr ""
+
+#: src/structs/tuple-structs.md:24
+msgid ""
+"fn set_thruster_force(force: Newtons) {\n"
+"    // ...\n"
+"}"
+msgstr ""
+
+#: src/structs/tuple-structs.md:28
+msgid ""
+"fn main() {\n"
+"    let force = compute_thruster_force();\n"
+"    set_thruster_force(force);\n"
+"}"
+msgstr ""
+
+#: src/structs/tuple-structs.md:33 src/generics/trait-objects.md:86
+msgid "```"
+msgstr ""
+
+#: src/structs/field-shorthand.md:1
+msgid "# Field Shorthand Syntax"
+msgstr "# 필드 할당 단축 문법(Field Shorthand Syntax)"
+
+#: src/structs/field-shorthand.md:3
+msgid ""
+"If you already have variables with the right names, then you can create the\n"
+"struct using a shorthand:"
+msgstr ""
+"구조체 필드와 동일한 이름의 변수가 있다면 아래와 같이 _짧은 문법_ 으로 구조체"
+"를 생성할 수 있습니다:"
+
+#: src/structs/field-shorthand.md:6 src/methods.md:6
+msgid ""
+"```rust,editable\n"
+"#[derive(Debug)]\n"
+"struct Person {\n"
+"    name: String,\n"
+"    age: u8,\n"
+"}"
+msgstr ""
+
+#: src/structs/field-shorthand.md:13
+msgid ""
+"impl Person {\n"
+"    fn new(name: String, age: u8) -> Person {\n"
+"        Person { name, age }\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/structs/field-shorthand.md:19
+msgid ""
+"fn main() {\n"
+"    let peter = Person::new(String::from(\"Peter\"), 27);\n"
+"    println!(\"{peter:?}\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/enums.md:1
+msgid "# Enums"
+msgstr "# 열거형"
+
+#: src/enums.md:3
+msgid ""
+"The `enum` keyword allows the creation of a type which has a few\n"
+"different variants:"
+msgstr "`enum` 키워드는 열거형 타입을 생성합니다:"
+
+#: src/enums.md:6
+msgid ""
+"```rust,editable\n"
+"fn generate_random_number() -> i32 {\n"
+"    4  // Chosen by fair dice roll. Guaranteed to be random.\n"
+"}"
+msgstr ""
+
+#: src/enums.md:11
+msgid ""
+"#[derive(Debug)]\n"
+"enum CoinFlip {\n"
+"    Heads,\n"
+"    Tails,\n"
+"}"
+msgstr ""
+
+#: src/enums.md:17
+msgid ""
+"fn flip_coin() -> CoinFlip {\n"
+"    let random_number = generate_random_number();\n"
+"    if random_number % 2 == 0 {\n"
+"        return CoinFlip::Heads;\n"
+"    } else {\n"
+"        return CoinFlip::Tails;\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/enums.md:26
+msgid ""
+"fn main() {\n"
+"    println!(\"You got: {:?}\", flip_coin());\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/enums/variant-payloads.md:1
+msgid "# Variant Payloads"
+msgstr ""
+
+#: src/enums/variant-payloads.md:3
+msgid ""
+"You can define richer enums where the variants carry data. You can then use "
+"the\n"
+"`match` statement to extract the data from each variant:"
+msgstr ""
+"다양한 데이터를 가진 `variants`를 열거형에 정의하고, `match` 구문을 이용해 이"
+"를 추출할 수 있습니다:"
+
+#: src/enums/variant-payloads.md:6
+msgid ""
+"```rust,editable\n"
+"enum WebEvent {\n"
+"    PageLoad,                 // Variant without payload\n"
+"    KeyPress(char),           // Tuple struct variant\n"
+"    Click { x: i64, y: i64 }, // Full struct variant\n"
+"}"
+msgstr ""
+
+#: src/enums/variant-payloads.md:13
+msgid ""
+"#[rustfmt::skip]\n"
+"fn inspect(event: WebEvent) {\n"
+"    match event {\n"
+"        WebEvent::PageLoad       => println!(\"page loaded\"),\n"
+"        WebEvent::KeyPress(c)    => println!(\"pressed '{c}'\"),\n"
+"        WebEvent::Click { x, y } => println!(\"clicked at x={x}, y={y}\"),\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/enums/variant-payloads.md:22
+msgid ""
+"fn main() {\n"
+"    let load = WebEvent::PageLoad;\n"
+"    let press = WebEvent::KeyPress('x');\n"
+"    let click = WebEvent::Click { x: 20, y: 80 };"
+msgstr ""
+
+#: src/enums/variant-payloads.md:27
+msgid ""
+"    inspect(load);\n"
+"    inspect(press);\n"
+"    inspect(click);\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/enums/variant-payloads.md:35
+msgid ""
+"* In the above example, accessing the `char` in `KeyPress`, or `x` and `y` "
+"in `Click` only works within a `match` statement.\n"
+"* `match` inspects a hidden discriminant field in the `enum`.\n"
+"* `WebEvent::Click { ... }` is not exactly the same as `WebEvent::"
+"Click(Click)` with a top level `struct Click { ... }`. The inlined version "
+"cannot implement traits, for example."
+msgstr ""
+"* 위의 예제에서 `keyPress`의 `char`, `Cilck`의 `x`와 `y`의 접근은 `match`구"
+"문   안에서만 동작 합니다.\n"
+"* `match`는 열거형에서 숨겨진 판별필드까지 검사합니다.\n"
+"* `WebEvent::Click { ... }`은 최상위 레벨 구조체 `Click {...}`이 있는   "
+"`WebEvent::Click(Click)`와 정확히 같진 않습니다. 예를 들어 인라인   버전에서"
+"는 트레이트를 구현 할 수 없습니다."
+
+#: src/enums/sizes.md:1
+msgid "# Enum Sizes"
+msgstr "# 열거형 크기"
+
+#: src/enums/sizes.md:3
+msgid ""
+"Rust enums are packed tightly, taking constraints due to alignment into "
+"account:"
+msgstr "러스트의 열거형은 정렬로 인한 제약을 고려하여 크기를 빽빽하게 잡습니다"
+
+#: src/enums/sizes.md:5
+msgid ""
+"```rust,editable\n"
+"use std::mem::{align_of, size_of};"
+msgstr ""
+
+#: src/enums/sizes.md:8
+msgid ""
+"macro_rules! dbg_size {\n"
+"    ($t:ty) => {\n"
+"        println!(\"{}: size {} bytes, align: {} bytes\",\n"
+"                 stringify!($t), size_of::<$t>(), align_of::<$t>());\n"
+"    };\n"
+"}"
+msgstr ""
+
+#: src/enums/sizes.md:15
+msgid ""
+"enum Foo {\n"
+"    A,\n"
+"    B,\n"
+"}"
+msgstr ""
+
+#: src/enums/sizes.md:20
+msgid ""
+"fn main() {\n"
+"    dbg_size!(Foo);\n"
+"    dbg_size!(bool);\n"
+"    dbg_size!(Option<bool>);\n"
+"    dbg_size!(&i32);\n"
+"    dbg_size!(Option<&i32>);\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/enums/sizes.md:29
+msgid ""
+"* See the [Rust Reference](https://doc.rust-lang.org/reference/type-layout."
+"html)."
+msgstr ""
+"- 자세한 사항은 [공식문서](https://doc.rust-lang.org/reference/type-layout."
+"htm)를 확인하세요."
+
+#: src/enums/sizes.md:33
+msgid ""
+"* `Option<bool>` is another example of tight packing.\n"
+"* For [some types](https://doc.rust-lang.org/std/option/#representation), "
+"Rust guarantees that `size_of::<T>()` equals `size_of::<Option<T>>()`.\n"
+"* Zero-sized types allow for efficient implementation of `HashSet` using "
+"`HashMap` with `()` as the value."
+msgstr ""
+"* `Option<bool>` 역시 크기를 타이트하게 잡는 또 다른 예시입니다.\n"
+"* [some types](https://doc.rust-lang.org/std/option/#representation)의 경"
+"우,  러스트는 `size_of::<T>()`와 `size_of::<Option<T>>()`의 동일함을 보장합니"
+"다.\n"
+"* 크기 0인 타입을 사용하면 `()`을 값으로 갖는 `HashMap`을 사용하여 "
+"`HashSet`  을 효율적으로 구현할 수 있습니다."
+
+#: src/methods.md:3
+msgid ""
+"Rust allows you to associate functions with your new types. You do this with "
+"an\n"
+"`impl` block:"
+msgstr ""
+"러스트에서 선언된 타입에 대해 `impl`블록에 함수를 선언하여 메서드를 연결 할 "
+"수 있습니다:"
+
+#: src/methods.md:13
+msgid ""
+"impl Person {\n"
+"    fn say_hello(&self) {\n"
+"        println!(\"Hello, my name is {}\", self.name);\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/methods.md:19
+msgid ""
+"fn main() {\n"
+"    let peter = Person {\n"
+"        name: String::from(\"Peter\"),\n"
+"        age: 27,\n"
+"    };\n"
+"    peter.say_hello();\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/methods/receiver.md:1
+msgid "# Method Receiver"
+msgstr "# 메서드 인자"
+
+#: src/methods/receiver.md:3
+msgid ""
+"The `&self` above indicates that the method borrows the object immutably. "
+"There\n"
+"are other possible receivers for a method:"
+msgstr ""
+"`&self`는 메서드가 객체를 불변하게 빌려옴을 나타냅니다. 그 외에 메서드가 받아"
+"올 수 있는 인자는 다음과 같습니다:"
+
+#: src/methods/receiver.md:6
+msgid ""
+"* `&self`: borrows the object from the caller using a shared and immutable\n"
+"  reference. The object can be used again afterwards.\n"
+"* `&mut self`: borrows the object from the caller using a unique and "
+"mutable\n"
+"  reference. The object can be used again afterwards.\n"
+"* `self`: takes ownership of the object and moves it away from the caller. "
+"The\n"
+"  method becomes the owner of the object. The object will be dropped "
+"(deallocated)\n"
+"  when the method returns, unless its ownership is explicitly\n"
+"  transmitted.\n"
+"* No receiver: this becomes a static method on the struct. Typically used "
+"to\n"
+"  create constructors which are called `new` by convention."
+msgstr ""
+"* `&self`: 호출자로부터 불변참조객체를 빌려옴을 나타냅니다. 객체는 나중에 다"
+"시 사용 될 수 있습니다.\n"
+"* `&mut self`: 호출자로부터 가변참조객체를 빌려옴을 나타냅니다. 객체는 나중"
+"에 다시 사용 될 수 있습니다.\n"
+"* `self`: 호출자의 객체가 이동되어 메서드가 객체의 소유권을 가져옵니다. 따라"
+"서 명시적으로 소유권을 반환하지 않으면 (메서드 종료 후)객체는 삭제(해제)됩니"
+"다.\n"
+"* 인자 없음: 구조체의 정적 메서드가 됩니다. 관습적으로 `new`라고 지정되는 생"
+"성자를 만들때 사용합니다. "
+
+#: src/methods/receiver.md:17
+msgid ""
+"Beyond variants on `self`, there are also\n"
+"[special wrapper types](https://doc.rust-lang.org/reference/special-types-"
+"and-traits.html)\n"
+"allowed to be receiver types, such as `Box<Self>`."
+msgstr ""
+"`self`에 대한 variants 외에도 `Box<Self>`와 같이 인자 유형으로 허용되는 "
+"[special wrapper types](https://doc.rust-lang.org/reference/special-types-"
+"and-traits.html)도 있습니다."
+
+#: src/methods/example.md:1 src/concurrency/shared_state/example.md:1
+msgid "# Example"
+msgstr "# 예제"
+
+#: src/methods/example.md:3
+msgid ""
+"```rust,editable\n"
+"#[derive(Debug)]\n"
+"struct Race {\n"
+"    name: String,\n"
+"    laps: Vec<i32>,\n"
+"}"
+msgstr ""
+
+#: src/methods/example.md:10
+msgid ""
+"impl Race {\n"
+"    fn new(name: &str) -> Race {  // No receiver, a static method\n"
+"        Race { name: String::from(name), laps: Vec::new() }\n"
+"    }"
+msgstr ""
+"impl Race {\n"
+"    fn new(name: &str) -> Race {  // 정적 메서드(static method)는 self가  없"
+"습니다.\n"
+"        Race { name: String::from(name), laps: Vec::new() }\n"
+"    }"
+
+#: src/methods/example.md:15
+msgid ""
+"    fn add_lap(&mut self, lap: i32) {  // Exclusive borrowed read-write "
+"access to self\n"
+"        self.laps.push(lap);\n"
+"    }"
+msgstr ""
+"    fn add_lap(&mut self, lap: i32) {  // self에 대한 배타적인 빌림 읽기-쓰"
+"기\n"
+"        self.laps.push(lap);\n"
+"    }"
+
+#: src/methods/example.md:19
+msgid ""
+"    fn print_laps(&self) {  // Shared and read-only borrowed access to self\n"
+"        println!(\"Recorded {} laps for {}:\", self.laps.len(), self.name);\n"
+"        for (idx, lap) in self.laps.iter().enumerate() {\n"
+"            println!(\"Lap {idx}: {lap} sec\");\n"
+"        }\n"
+"    }"
+msgstr ""
+"    fn print_laps(&self) {  // self에 대한 읽기 전용 빌림 & 공유 \n"
+"        println!(\"Recorded {} laps for {}:\", self.laps.len(), self.name);\n"
+"        for (idx, lap) in self.laps.iter().enumerate() {\n"
+"            println!(\"Lap {idx}: {lap} sec\");\n"
+"        }\n"
+"    }"
+
+#: src/methods/example.md:26
+msgid ""
+"    fn finish(self) {  // Exclusive ownership of self\n"
+"        let total = self.laps.iter().sum::<i32>();\n"
+"        println!(\"Race {} is finished, total lap time: {}\", self.name, "
+"total);\n"
+"    }\n"
+"}"
+msgstr ""
+"    fn finish(self) {  // 배타적 self 소유권\n"
+"        let total = self.laps.iter().sum::<i32>();\n"
+"        println!(\"Race {} is finished, total lap time: {}\", self.name, "
+"total);\n"
+"    }\n"
+"}"
+
+#: src/methods/example.md:32
+msgid ""
+"fn main() {\n"
+"    let mut race = Race::new(\"Monaco Grand Prix\");\n"
+"    race.add_lap(70);\n"
+"    race.add_lap(68);\n"
+"    race.print_laps();\n"
+"    race.add_lap(71);\n"
+"    race.print_laps();\n"
+"    race.finish();\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/pattern-matching.md:1
+msgid "# Pattern Matching"
+msgstr "# 패턴 매칭"
+
+#: src/pattern-matching.md:3
+msgid ""
+"The `match` keyword let you match a value against one or more _patterns_. "
+"The\n"
+"comparisons are done from top to bottom and the first match wins."
+msgstr ""
+"`match`키워드는 C/C++의 `switch`와 유사하게 하나 이상의 패턴과 일치 시킬 수 "
+"있습니다."
+
+#: src/pattern-matching.md:6
+msgid "The patterns can be simple values, similarly to `switch` in C and C++:"
+msgstr "비교동작은 위에서 아래로 진행되며 처음 일치하는 패턴이 실행됩니다. "
+
+#: src/pattern-matching.md:8
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let input = 'x';"
+msgstr ""
+
+#: src/pattern-matching.md:12
+msgid ""
+"    match input {\n"
+"        'q'                   => println!(\"Quitting\"),\n"
+"        'a' | 's' | 'w' | 'd' => println!(\"Moving around\"),\n"
+"        '0'..='9'             => println!(\"Number input\"),\n"
+"        _                     => println!(\"Something else\"),\n"
+"    }\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/pattern-matching.md:21
+msgid "The `_` pattern is a wildcard pattern which matches any value."
+msgstr "`_`패턴은 어떤 패턴과도 매칭되는 와일드 카드입니다.(default)"
+
+#: src/pattern-matching/destructuring-enums.md:1
+msgid "# Destructuring Enums"
+msgstr "# 열거형 분해(역구조화)"
+
+#: src/pattern-matching/destructuring-enums.md:3
+msgid ""
+"Patterns can also be used to bind variables to parts of your values. This is "
+"how\n"
+"you inspect the structure of your types. Let us start with a simple `enum` "
+"type:"
+msgstr ""
+"구조체의 바인딩된 값을 패턴으로 사용할 수 있습니다. 간단한 `enum` 타입의 예시"
+"입니다:"
+
+#: src/pattern-matching/destructuring-enums.md:6
+msgid ""
+"```rust,editable\n"
+"enum Result {\n"
+"    Ok(i32),\n"
+"    Err(String),\n"
+"}"
+msgstr ""
+
+#: src/pattern-matching/destructuring-enums.md:12
+msgid ""
+"fn divide_in_two(n: i32) -> Result {\n"
+"    if n % 2 == 0 {\n"
+"        Result::Ok(n / 2)\n"
+"    } else {\n"
+"        Result::Err(format!(\"cannot divide {} into two equal parts\", n))\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/pattern-matching/destructuring-enums.md:20
+msgid ""
+"fn main() {\n"
+"    let n = 100;\n"
+"    match divide_in_two(n) {\n"
+"        Result::Ok(half) => println!(\"{n} divided in two is {half}\"),\n"
+"        Result::Err(msg) => println!(\"sorry, an error happened: {msg}\"),\n"
+"    }\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/pattern-matching/destructuring-enums.md:29
+msgid ""
+"Here we have used the arms to _destructure_ the `Result` value. In the "
+"first\n"
+"arm, `half` is bound to the value inside the `Ok` variant. In the second "
+"arm,\n"
+"`msg` is bound to the error message."
+msgstr ""
+"위의 `match`구문을 `divide_in_two`함수에서 반환되는 `Result` 값을 arm(패턴  "
+"단위)으로 분해합니다. \n"
+"* 첫번째 arm의 `half`는 `Ok` variant에 바인딩된 값입니다.`(n/2)`\n"
+"* 두번째 amr의 `msg`는 `Err` variant에 바인딩 된 에러 메시지 입니다."
+
+#: src/pattern-matching/destructuring-structs.md:1
+msgid "# Destructuring Structs"
+msgstr "# 구조체 분해(역구조화)"
+
+#: src/pattern-matching/destructuring-structs.md:3
+msgid "You can also destructure `structs`:"
+msgstr "`구조체`역시 분해할 수 있습니다:"
+
+#: src/pattern-matching/destructuring-structs.md:5
+msgid ""
+"```rust,editable\n"
+"struct Foo {\n"
+"    x: (u32, u32),\n"
+"    y: u32,\n"
+"}"
+msgstr ""
+
+#: src/pattern-matching/destructuring-structs.md:11
+msgid ""
+"#[rustfmt::skip]\n"
+"fn main() {\n"
+"    let foo = Foo { x: (1, 2), y: 3 };\n"
+"    match foo {\n"
+"        Foo { x: (1, b), y } => println!(\"x.0 = 1, b = {b}, y = {y}\"),\n"
+"        Foo { y: 2, x: i }   => println!(\"y = 2, i = {i:?}\"),\n"
+"        Foo { y, .. }        => println!(\"y = {y}, other fields were "
+"ignored\"),\n"
+"    }\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/pattern-matching/destructuring-arrays.md:1
+msgid "# Destructuring Arrays"
+msgstr "# 배열 분해(역구조화)"
+
+#: src/pattern-matching/destructuring-arrays.md:3
+msgid ""
+"You can destructure arrays, tuples, and slices by matching on their elements:"
+msgstr "배역 역시 분해가 가능하고, 슬라이스를 적용할 수 있습니다."
+
+#: src/pattern-matching/destructuring-arrays.md:5
+msgid ""
+"```rust,editable\n"
+"#[rustfmt::skip]\n"
+"fn main() {\n"
+"    let triple = [0, -2, 3];\n"
+"    println!(\"Tell me about {triple:?}\");\n"
+"    match triple {\n"
+"        [0, y, z] => println!(\"First is 0, y = {y}, and z = {z}\"),\n"
+"        [1, ..]   => println!(\"First is 1 and the rest were ignored\"),\n"
+"        _         => println!(\"All elements were ignored\"),\n"
+"    }\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/pattern-matching/match-guards.md:1
+msgid "# Match Guards"
+msgstr "# 검사식(Match Guards)"
+
+#: src/pattern-matching/match-guards.md:3
+msgid ""
+"When matching, you can add a _guard_ to a pattern. This is an arbitrary "
+"Boolean\n"
+"expression which will be executed if the pattern matches:"
+msgstr ""
+"match를 사용할때 각 패턴에 대해서 불리언으로 반환되는 검사식(guard)를 추가할 "
+"수 있습니다. "
+
+#: src/pattern-matching/match-guards.md:6
+msgid ""
+"```rust,editable\n"
+"#[rustfmt::skip]\n"
+"fn main() {\n"
+"    let pair = (2, -2);\n"
+"    println!(\"Tell me about {pair:?}\");\n"
+"    match pair {\n"
+"        (x, y) if x == y     => println!(\"These are twins\"),\n"
+"        (x, y) if x + y == 0 => println!(\"Antimatter, kaboom!\"),\n"
+"        (x, _) if x % 2 == 1 => println!(\"The first one is odd\"),\n"
+"        _                    => println!(\"No correlation...\"),\n"
+"    }\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/exercises/day-2/morning.md:1
+msgid "# Day 2: Morning Exercises"
+msgstr "# 2일차 오전 연습문제"
+
+#: src/exercises/day-2/morning.md:3
+msgid "We will look at implementing methods in two contexts:"
+msgstr "이번 연습문제들은 두가지 맥락에서 메서드 구현방법을 다룹니다:"
+
+#: src/exercises/day-2/morning.md:5
+msgid "* Simple struct which tracks health statistics."
+msgstr "* 건강 상태 통계를 추적하는 프로그램의 간단한 구조체."
+
+#: src/exercises/day-2/morning.md:7
+msgid "* Multiple structs and enums for a drawing library."
+msgstr "* 드로잉 라이브러리를 위한 다중 구조체 및 열거헝."
+
+#: src/exercises/day-2/health-statistics.md:1
+msgid "# Health Statistics"
+msgstr ""
+"# 건강상태 통계\n"
+"당신은 건강 상태를 모니터링하는 시스템을 구현하는 일을 하고 있습니다.\n"
+" 그 일환으로 당신은 사용자의 건강 상태 통계를 추적해야합니다.  \n"
+"당신의 목표는 User구조체의 impl블록의 빈 함수를 구현하는 것입니다.  \n"
+"* _gettext 이슈로 아래 문구 교체가 안되 병기됨_"
+
+# 아래 두 블럭 반영이 안됨...
+#: src/exercises/day-2/health-statistics.md:3
+msgid ""
+"You're working on implementing a health-monitoring system. As part of that, "
+"you\n"
+"need to keep track of users' health statistics."
+msgstr "1"
+
+#: src/exercises/day-2/health-statistics.md:6
+msgid ""
+"You'll start with some stubbed functions in an `impl` block as well as a "
+"`User`\n"
+"struct definition. Your goal is to implement the stubbed out methods on the\n"
+"`User` `struct` defined in the `impl` block."
+msgstr "?"
+
+#: src/exercises/day-2/health-statistics.md:10
+msgid ""
+"Copy the code below to <https://play.rust-lang.org/> and fill in the "
+"missing\n"
+"methods:"
+msgstr ""
+"아래 코드를 <https://play.rust-lang.org/>에 복사해서 빠진 메서드를 구현하면 "
+"됩니다: "
+
+#: src/exercises/day-2/health-statistics.md:17
+msgid ""
+"struct User {\n"
+"    name: String,\n"
+"    age: u32,\n"
+"    weight: f32,\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-2/health-statistics.md:23
+msgid ""
+"impl User {\n"
+"    pub fn new(name: String, age: u32, weight: f32) -> Self {\n"
+"        unimplemented!()\n"
+"    }"
+msgstr ""
+
+#: src/exercises/day-2/health-statistics.md:28
+msgid ""
+"    pub fn name(&self) -> &str {\n"
+"        unimplemented!()\n"
+"    }"
+msgstr ""
+
+#: src/exercises/day-2/health-statistics.md:32
+msgid ""
+"    pub fn age(&self) -> u32 {\n"
+"        unimplemented!()\n"
+"    }"
+msgstr ""
+
+#: src/exercises/day-2/health-statistics.md:36
+msgid ""
+"    pub fn weight(&self) -> f32 {\n"
+"        unimplemented!()\n"
+"    }"
+msgstr ""
+
+#: src/exercises/day-2/health-statistics.md:40
+msgid ""
+"    pub fn set_age(&mut self, new_age: u32) {\n"
+"        unimplemented!()\n"
+"    }"
+msgstr ""
+
+#: src/exercises/day-2/health-statistics.md:44
+msgid ""
+"    pub fn set_weight(&mut self, new_weight: f32) {\n"
+"        unimplemented!()\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-2/health-statistics.md:49
+msgid ""
+"fn main() {\n"
+"    let bob = User::new(String::from(\"Bob\"), 32, 155.2);\n"
+"    println!(\"I'm {} and my age is {}\", bob.name(), bob.age());\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-2/health-statistics.md:54
+msgid ""
+"#[test]\n"
+"fn test_weight() {\n"
+"    let bob = User::new(String::from(\"Bob\"), 32, 155.2);\n"
+"    assert_eq!(bob.weight(), 155.2);\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-2/health-statistics.md:60
+msgid ""
+"#[test]\n"
+"fn test_set_age() {\n"
+"    let mut bob = User::new(String::from(\"Bob\"), 32, 155.2);\n"
+"    assert_eq!(bob.age(), 32);\n"
+"    bob.set_age(33);\n"
+"    assert_eq!(bob.age(), 33);\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/exercises/day-2/points-polygons.md:1
+msgid "# Polygon Struct"
+msgstr "# 다면체 구조"
+
+#: src/exercises/day-2/points-polygons.md:3
+msgid ""
+"We will create a `Polygon` struct which contain some points. Copy the code "
+"below\n"
+"to <https://play.rust-lang.org/> and fill in the missing methods to make "
+"the\n"
+"tests pass:"
+msgstr ""
+"우리는 몇개의 꼭지점을 가진 다각형을 표현하는 구조체를 만들 것입니다.  \n"
+"아래 코드를 <https://play.rust-lang.org/>에 복사해서 테스트가 통과하도록 빠"
+"진 메서드를 구현하시면 됩니다: "
+
+#: src/exercises/day-2/points-polygons.md:7 src/exercises/day-2/luhn.md:23
+#: src/exercises/day-2/strings-iterators.md:12
+msgid ""
+"```rust\n"
+"// TODO: remove this when you're done with your implementation.\n"
+"#![allow(unused_variables, dead_code)]"
+msgstr ""
+
+#: src/exercises/day-2/points-polygons.md:11
+msgid ""
+"pub struct Point {\n"
+"    // add fields\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-2/points-polygons.md:15
+msgid ""
+"impl Point {\n"
+"    // add methods\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-2/points-polygons.md:19
+msgid ""
+"pub struct Polygon {\n"
+"    // add fields\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-2/points-polygons.md:23
+msgid ""
+"impl Polygon {\n"
+"    // add methods\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-2/points-polygons.md:27
+msgid ""
+"pub struct Circle {\n"
+"    // add fields\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-2/points-polygons.md:31
+msgid ""
+"impl Circle {\n"
+"    // add methods\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-2/points-polygons.md:35
+msgid ""
+"pub enum Shape {\n"
+"    Polygon(Polygon),\n"
+"    Circle(Circle),\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-2/points-polygons.md:40 src/testing/test-modules.md:15
+msgid ""
+"#[cfg(test)]\n"
+"mod tests {\n"
+"    use super::*;"
+msgstr ""
+
+#: src/exercises/day-2/points-polygons.md:44
+#: src/exercises/day-2/solutions-morning.md:165
+msgid ""
+"    fn round_two_digits(x: f64) -> f64 {\n"
+"        (x * 100.0).round() / 100.0\n"
+"    }"
+msgstr ""
+
+#: src/exercises/day-2/points-polygons.md:48
+#: src/exercises/day-2/solutions-morning.md:169
+msgid ""
+"    #[test]\n"
+"    fn test_point_magnitude() {\n"
+"        let p1 = Point::new(12, 13);\n"
+"        assert_eq!(round_two_digits(p1.magnitude()), 17.69);\n"
+"    }"
+msgstr ""
+
+#: src/exercises/day-2/points-polygons.md:54
+#: src/exercises/day-2/solutions-morning.md:175
+msgid ""
+"    #[test]\n"
+"    fn test_point_dist() {\n"
+"        let p1 = Point::new(10, 10);\n"
+"        let p2 = Point::new(14, 13);\n"
+"        assert_eq!(round_two_digits(p1.dist(p2)), 5.00);\n"
+"    }"
+msgstr ""
+
+#: src/exercises/day-2/points-polygons.md:61
+#: src/exercises/day-2/solutions-morning.md:182
+msgid ""
+"    #[test]\n"
+"    fn test_point_add() {\n"
+"        let p1 = Point::new(16, 16);\n"
+"        let p2 = p1 + Point::new(-4, 3);\n"
+"        assert_eq!(p2, Point::new(12, 19));\n"
+"    }"
+msgstr ""
+
+#: src/exercises/day-2/points-polygons.md:68
+#: src/exercises/day-2/solutions-morning.md:189
+msgid ""
+"    #[test]\n"
+"    fn test_polygon_left_most_point() {\n"
+"        let p1 = Point::new(12, 13);\n"
+"        let p2 = Point::new(16, 16);"
+msgstr ""
+
+#: src/exercises/day-2/points-polygons.md:73
+#: src/exercises/day-2/solutions-morning.md:194
+msgid ""
+"        let mut poly = Polygon::new();\n"
+"        poly.add_point(p1);\n"
+"        poly.add_point(p2);\n"
+"        assert_eq!(poly.left_most_point(), Some(p1));\n"
+"    }"
+msgstr ""
+
+#: src/exercises/day-2/points-polygons.md:79
+#: src/exercises/day-2/solutions-morning.md:200
+msgid ""
+"    #[test]\n"
+"    fn test_polygon_iter() {\n"
+"        let p1 = Point::new(12, 13);\n"
+"        let p2 = Point::new(16, 16);"
+msgstr ""
+
+#: src/exercises/day-2/points-polygons.md:84
+#: src/exercises/day-2/solutions-morning.md:205
+msgid ""
+"        let mut poly = Polygon::new();\n"
+"        poly.add_point(p1);\n"
+"        poly.add_point(p2);"
+msgstr ""
+
+#: src/exercises/day-2/points-polygons.md:88
+#: src/exercises/day-2/solutions-morning.md:209
+msgid ""
+"        let points = poly.iter().cloned().collect::<Vec<_>>();\n"
+"        assert_eq!(points, vec![Point::new(12, 13), Point::new(16, 16)]);\n"
+"    }"
+msgstr ""
+
+#: src/exercises/day-2/points-polygons.md:92
+msgid ""
+"    #[test]\n"
+"    fn test_shape_circumferences() {\n"
+"        let mut poly = Polygon::new();\n"
+"        poly.add_point(Point::new(12, 13));\n"
+"        poly.add_point(Point::new(17, 11));\n"
+"        poly.add_point(Point::new(16, 16));\n"
+"        let shapes = vec![\n"
+"            Shape::from(poly),\n"
+"            Shape::from(Circle::new(Point::new(10, 20), 5)),\n"
+"        ];\n"
+"        let circumferences = shapes\n"
+"            .iter()\n"
+"            .map(Shape::circumference)\n"
+"            .map(round_two_digits)\n"
+"            .collect::<Vec<_>>();\n"
+"        assert_eq!(circumferences, vec![15.48, 31.42]);\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-2/points-polygons.md:111 src/exercises/day-2/luhn.md:68
+#: src/exercises/day-2/solutions-morning.md:233
+msgid ""
+"#[allow(dead_code)]\n"
+"fn main() {}\n"
+"```"
+msgstr ""
+
+#: src/control-flow.md:1
+msgid "# Control Flow"
+msgstr "# 흐름 제어"
+
+#: src/control-flow.md:3
+msgid ""
+"As we have seen, `if` is an expression in Rust. It is used to conditionally\n"
+"evaluate one of two blocks, but the blocks can have a value which then "
+"becomes\n"
+"the value of the `if` expression. Other control flow expressions work "
+"similarly\n"
+"in Rust."
+msgstr ""
+"앞에서 살펴본 바와 같이 러스트의 표현식으로써 `if`는 두 블록 중 하나를 조건"
+"에 따라 평가(반환)하며, 블록은 `if` 표현식의 값이 되는 값을 가질 수 있습니"
+"다. 다른 흐름제어 표현식도 러스트에서 유사하게 작동합니다. "
+
+#: src/control-flow/blocks.md:1
+msgid "# Blocks"
+msgstr "# 블록"
+
+#: src/control-flow/blocks.md:3
+msgid ""
+"A block in Rust has a value and a type: the value is the last expression of "
+"the\n"
+"block:"
+msgstr "러스트에서 블록은 값과 타입을 갖습니다: 블록의 표현식이 값이 됩니다."
+
+#: src/control-flow/blocks.md:6
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let x = {\n"
+"        let y = 10;\n"
+"        println!(\"y: {y}\");\n"
+"        let z = {\n"
+"            let w = {\n"
+"                3 + 4\n"
+"            };\n"
+"            println!(\"w: {w}\");\n"
+"            y * w\n"
+"        };\n"
+"        println!(\"z: {z}\");\n"
+"        z - y\n"
+"    };\n"
+"    println!(\"x: {x}\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/control-flow/blocks.md:25
+msgid ""
+"The same rule is used for functions: the value of the function body is the\n"
+"return value:"
+msgstr ""
+"함수에도 동일한 규칙이 적용됩니다: 함수 바디의 (마지막) 값이 반환 값이 됩니"
+"다."
+
+#: src/control-flow/blocks.md:28
+msgid ""
+"```rust,editable\n"
+"fn double(x: i32) -> i32 {\n"
+"    x + x\n"
+"}"
+msgstr ""
+
+#: src/control-flow/blocks.md:33
+msgid ""
+"fn main() {\n"
+"    println!(\"doubled: {}\", double(7));\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/control-flow/if-expressions.md:1
+msgid "# `if` expressions"
+msgstr "# `if` 표현식"
+
+#: src/control-flow/if-expressions.md:3
+msgid "You use `if` very similarly to how you would in other languages:"
+msgstr "`if`문은 다른 언어와 동일하게 사용할수 있습니다(조건의 ()는 없습니다):"
+
+#: src/control-flow/if-expressions.md:5
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let mut x = 10;\n"
+"    if x % 2 == 0 {\n"
+"        x = x / 2;\n"
+"    } else {\n"
+"        x = 3 * x + 1;\n"
+"    }\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/control-flow/if-expressions.md:16
+msgid ""
+"In addition, you can use it as an expression. This does the same as above:"
+msgstr ""
+"게다가 `if`는 표현식(할당가능)으로 사용 될수도 있습니다.\n"
+"아래 코드는 위와 동일한 결과 입니다."
+
+#: src/control-flow/if-expressions.md:18
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let mut x = 10;\n"
+"    x = if x % 2 == 0 {\n"
+"        x / 2\n"
+"    } else {\n"
+"        3 * x + 1\n"
+"    };\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/control-flow/if-let-expressions.md:1
+msgid "# `if let` expressions"
+msgstr "# `if let` 표현식"
+
+#: src/control-flow/if-let-expressions.md:3
+msgid "If you want to match a value against a pattern, you can use `if let`:"
+msgstr "`if let`문을 사용하면 값을 패턴매칭에 사용할 수 있습니다:"
+
+#: src/control-flow/if-let-expressions.md:5
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let arg = std::env::args().next();\n"
+"    if let Some(value) = arg {\n"
+"        println!(\"Program name: {value}\");\n"
+"    } else {\n"
+"        println!(\"Missing name?\");\n"
+"    }\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/control-flow/if-let-expressions.md:16
+#: src/control-flow/while-let-expressions.md:21
+#: src/control-flow/match-expressions.md:22
+msgid ""
+"See [pattern matching](../pattern-matching.md) for more details on patterns "
+"in\n"
+"Rust."
+msgstr "러스트의 [패턴매칭](../pattern-matching.md)을 참조하세요"
+
+#: src/control-flow/while-expressions.md:1
+msgid "# `while` expressions"
+msgstr "# `while` 표현식"
+
+#: src/control-flow/while-expressions.md:3
+msgid "The `while` keyword works very similar to other languages:"
+msgstr "`while` 역시 다른 언어와 동일한 사용법을 갖습니다:"
+
+#: src/control-flow/while-expressions.md:5
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let mut x = 10;\n"
+"    while x != 1 {\n"
+"        x = if x % 2 == 0 {\n"
+"            x / 2\n"
+"        } else {\n"
+"            3 * x + 1\n"
+"        };\n"
+"    }\n"
+"    println!(\"Final x: {x}\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/control-flow/while-let-expressions.md:1
+msgid "# `while let` expressions"
+msgstr "# `while let` 표현식"
+
+#: src/control-flow/while-let-expressions.md:3
+msgid ""
+"Like with `if`, there is a `while let` variant which repeatedly tests a "
+"value\n"
+"against a pattern:"
+msgstr "`if`와 동일하게 `while let`구문 역시 패턴매칭에 사용 할 수 있습니다."
+
+#: src/control-flow/while-let-expressions.md:6
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let v = vec![10, 20, 30];\n"
+"    let mut iter = v.into_iter();"
+msgstr ""
+
+#: src/control-flow/while-let-expressions.md:11
+msgid ""
+"    while let Some(x) = iter.next() {\n"
+"        println!(\"x: {x}\");\n"
+"    }\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/control-flow/while-let-expressions.md:17
+msgid ""
+"Here the iterator returned by `v.iter()` will return a `Option<i32>` on "
+"every\n"
+"call to `next()`. It returns `Some(x)` until it is done, after which it "
+"will\n"
+"return `None`. The `while let` lets us keep iterating through all items."
+msgstr ""
+"`v.iter()`가 반환한 반복자는 `next()`가 호출될 때마다 `Option<i32>`를 반환합"
+"니다.\n"
+"이는 `None`이 호출되기 전까지 `Some(x)`를 반환한다는 의미로 결과적으로 "
+"`while let`은 반복자의 모든 아이템을 반복하도록 하게 해줍니다."
+
+#: src/control-flow/for-expressions.md:1
+msgid "# `for` expressions"
+msgstr "# `for` 표현식"
+
+#: src/control-flow/for-expressions.md:3
+msgid ""
+"The `for` expression is closely related to the `while let` expression. It "
+"will\n"
+"automatically call `into_iter()` on the expression and then iterate over it:"
+msgstr ""
+"`for`표현식은 `while let` 표현식과 매우 유사합니다. `for`표현식은 자동으로 "
+"`into_iter()`를 호출한 다음 이를 반복합니다."
+
+#: src/control-flow/for-expressions.md:6
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let v = vec![10, 20, 30];"
+msgstr ""
+
+#: src/control-flow/for-expressions.md:10
+msgid ""
+"    for x in v {\n"
+"        println!(\"x: {x}\");\n"
+"    }\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/control-flow/for-expressions.md:16
+msgid "You can use `break` and `continue` here as usual."
+msgstr "역시 다른언어와 마찬가지로 `break` 와 `continue`를 사용할 수 있습니다."
+
+#: src/control-flow/loop-expressions.md:1
+msgid "# `loop` expressions"
+msgstr "# `loop` 표현식"
+
+#: src/control-flow/loop-expressions.md:3
+msgid ""
+"Finally, there is a `loop` keyword which creates an endless loop. Here you "
+"must\n"
+"either `break` or `return` to stop the loop:"
+msgstr ""
+"마지막으로 `loop`키워드는 무한한 루프를 생성합니다. 따라서 반드시 `break` 또"
+"는 `return`를 사용해서 루프를 정지해야 합니다:"
+
+#: src/control-flow/loop-expressions.md:6
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let mut x = 10;\n"
+"    loop {\n"
+"        x = if x % 2 == 0 {\n"
+"            x / 2\n"
+"        } else {\n"
+"            3 * x + 1\n"
+"        };\n"
+"        if x == 1 {\n"
+"            break;\n"
+"        }\n"
+"    }\n"
+"    println!(\"Final x: {x}\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/control-flow/match-expressions.md:1
+msgid "# `match` expressions"
+msgstr "# `match` 표현식"
+
+#: src/control-flow/match-expressions.md:3
+msgid ""
+"The `match` keyword is used to match a value against one or more patterns. "
+"In\n"
+"that sense, it works like a series of `if let` expressions:"
+msgstr ""
+"마치 `if let`를 여러개 적용한 것과 같이 `match`키워드는 하나 이상의 패턴을 찾"
+"는데 사용됩니다."
+
+#: src/control-flow/match-expressions.md:6
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    match std::env::args().next().as_deref() {\n"
+"        Some(\"cat\") => println!(\"Will do cat things\"),\n"
+"        Some(\"ls\")  => println!(\"Will ls some files\"),\n"
+"        Some(\"mv\")  => println!(\"Let's move some files\"),\n"
+"        Some(\"rm\")  => println!(\"Uh, dangerous!\"),\n"
+"        None        => println!(\"Hmm, no program name?\"),\n"
+"        _           => println!(\"Unknown program name!\"),\n"
+"    }\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/control-flow/match-expressions.md:19
+msgid ""
+"Like `if let`, each match arm must have the same type. The type is the last\n"
+"expression of the block, if any. In the example above, the type is `()`."
+msgstr ""
+"`if let`처럼 각 매치 암(match arm)의 마지막 표현식이 타입이 되며 모든 암은 동"
+"일한 타입이어야 합니다. 위의 예제에서 타입은 `()`(반환값 없음)입니다.\n"
+"* _역주: 예시에서 각 arm의 리턴 타입은 리턴없음(`()`)"
+
+#: src/control-flow/break-continue.md:1
+msgid "# `break` and `continue`"
+msgstr ""
+
+#: src/control-flow/break-continue.md:3
+msgid ""
+"If you want to exit a loop early, use `break`, if you want to immediately "
+"start\n"
+"the next iteration use `continue`. Both `continue` and `break` can "
+"optionally\n"
+"take a label argument which is used to break out of nested loops:"
+msgstr ""
+"만약 루프를 중간에 멈추고 십다면 `break`를, 바로 다음 반복으로 넘어가기 위해"
+"서는 `continue`를 사용합니다. 두 키워드 모두 중첩 루프에서 label로 표기한 인"
+"수를 취하여 제어 할 수 있습니다."
+
+#: src/control-flow/break-continue.md:7
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let v = vec![10, 20, 30];\n"
+"    let mut iter = v.into_iter();\n"
+"    'outer: while let Some(x) = iter.next() {\n"
+"        println!(\"x: {x}\");\n"
+"        let mut i = 0;\n"
+"        while i < x {\n"
+"            println!(\"x: {x}, i: {i}\");\n"
+"            i += 1;\n"
+"            if i == 3 {\n"
+"                break 'outer;\n"
+"            }\n"
+"        }\n"
+"    }\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/control-flow/break-continue.md:25
+msgid ""
+"In this case we break the outer loop after 3 iterations of the inner loop."
+msgstr ""
+"위 예제는 중접루프를 3회 반복한 후 바깥루프('outer' 레이블)을 정지합니다.(종"
+"료)"
+
+#: src/std.md:1
+msgid "# Standard Library"
+msgstr "# 표준 라이브러리"
+
+#: src/std.md:3
+msgid ""
+"Rust comes with a standard library which helps establish a set of common "
+"types\n"
+"used by Rust library and programs. This way, two libraries can work "
+"together\n"
+"smoothly because they both use the same `String` type."
+msgstr ""
+"러스트는 러스트 라이브러리와 프로그램에서 사용되는 공통 타입을 설정하는 데 도"
+"움을 주는 표준 라이브러리와 함께 제공 됩니다. 이렇게 하면 두 라이브러리 모두 "
+"같은 `String` 타입을 사용하기 때문에 원활하게 함께 작동할 수 있습니다."
+
+#: src/std.md:7
+msgid "The common vocabulary types include:"
+msgstr "일반적인 타입은 아래와 같습니다:"
+
+#: src/std.md:9
+msgid ""
+"* [`Option` and `Result`](std/option-result.md) types: used for optional "
+"values\n"
+"  and [error handling](error-handling.md)."
+msgstr ""
+"* [Option and Result 타입](std/option-result.md) : 선택적 옵션 값과   [error "
+"handling](error-handling.md)에 사용됩니다."
+
+#: src/std.md:12
+msgid ""
+"* [`String`](std/string.md): the default string type used for owned data."
+msgstr ""
+"* [`String`](std/string.md): 소유 데이터에서 사용되는 기본적인 문자열   타입"
+"입니다."
+
+#: src/std.md:14
+msgid "* [`Vec`](std/vec.md): a standard extensible vector."
+msgstr "* [`Vec`](std/vec.md): 확장가능한 표준 벡터 타입입니다."
+
+#: src/std.md:16
+msgid ""
+"* [`HashMap`](std/hashmap.md): a hash map type with a configurable hashing\n"
+"  algorithm."
+msgstr ""
+"* [`HashMap`](std/hashmap.md): 구성 가능한 해시 알고리즘을 가지는 해쉬 맵   "
+"타입입니다"
+
+#: src/std.md:19
+msgid "* [`Box`](std/box.md): an owned pointer for heap-allocated data."
+msgstr "* [`Box`](std/box.md): 힙 데이터에 대한 소유 포인터입니다:"
+
+#: src/std.md:21
+msgid ""
+"* [`Rc`](std/rc.md): a shared reference-counted pointer for heap-allocated "
+"data."
+msgstr ""
+"* [`Rc`](std/rc.md): 힙에 할당된 데이터에 대한 참조 카운팅 공유 포인트입니"
+
+#: src/std/string.md:1
+msgid "# String"
+msgstr ""
+
+#: src/std/string.md:3
+msgid ""
+"[`String`][1] is the standard heap-allocated growable UTF-8 string buffer:"
+msgstr "[`String`][1]은 힙에 할당된 확장가능한 표준 UTF-8 문자열 버퍼입니다."
+
+#: src/std/string.md:5
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let mut s1 = String::new();\n"
+"    s1.push_str(\"Hello\");\n"
+"    println!(\"s1: len = {}, capacity = {}\", s1.len(), s1.capacity());"
+msgstr ""
+
+#: src/std/string.md:11
+msgid ""
+"    let mut s2 = String::with_capacity(s1.len() + 1);\n"
+"    s2.push_str(&s1);\n"
+"    s2.push('!');\n"
+"    println!(\"s2: len = {}, capacity = {}\", s2.len(), s2.capacity());\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/std/string.md:18
+msgid ""
+"`String` implements [`Deref<Target = str>`][2], which means that you can "
+"call all\n"
+"`str` methods on a `String`."
+msgstr ""
+"`String`은 [`Deref<Target = str>`][2]을 구현합니다.\n"
+"이는 , `String`에서 모든 `str`관련 메서드를 호출 할 수 있다는 의미 입니다."
+
+#: src/std/string.md:21
+msgid ""
+"[1]: https://doc.rust-lang.org/std/string/struct.String.html\n"
+"[2]: https://doc.rust-lang.org/std/string/struct.String.html#deref-methods-"
+"str"
+msgstr ""
+
+#: src/std/option-result.md:1
+msgid "# `Option` and `Result`"
+msgstr "# `Option`과 `Result`"
+
+#: src/std/option-result.md:3
+msgid "The types represent optional data:"
+msgstr "이 타입은 선택가능한 데이터를 표시합니다: "
+
+#: src/std/option-result.md:5
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let numbers = vec![10, 20, 30];\n"
+"    let first: Option<&i8> = numbers.first();\n"
+"    println!(\"first: {first:?}\");"
+msgstr ""
+
+#: src/std/option-result.md:11
+msgid ""
+"    let idx: Result<usize, usize> = numbers.binary_search(&10);\n"
+"    println!(\"idx: {idx:?}\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/std/vec.md:1
+msgid "# `Vec`"
+msgstr ""
+
+#: src/std/vec.md:3
+msgid "[`Vec`][1] is the standard resizable heap-allocated buffer:"
+msgstr "[`Vec`][1] 는 힙에 할당된 표준 가변크기 버퍼입니다."
+
+#: src/std/vec.md:5
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let mut numbers = Vec::new();\n"
+"    numbers.push(42);"
+msgstr ""
+
+#: src/std/vec.md:10
+msgid ""
+"    let mut v1 = Vec::new();\n"
+"    v1.push(42);\n"
+"    println!(\"v1: len = {}, capacity = {}\", v1.len(), v1.capacity());"
+msgstr ""
+
+#: src/std/vec.md:14
+msgid ""
+"    let mut v2 = Vec::with_capacity(v1.len() + 1);\n"
+"    v2.extend(v1.iter());\n"
+"    v2.push(9999);\n"
+"    println!(\"v2: len = {}, capacity = {}\", v2.len(), v2.capacity());\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/std/vec.md:21
+msgid ""
+"`Vec` implements [`Deref<Target = [T]>`][2], which means that you can call "
+"slice\n"
+"methods on a `Vec`."
+msgstr ""
+"`Vec`은 [`Deref<Target = [T]>`][2]를 구현합니다. \n"
+"이는 `Vec`에서 슬라이스 메서드(배열 관련 메서드)를 호출 할 수 있다는 의미입니"
+"다."
+
+#: src/std/vec.md:24
+msgid ""
+"[1]: https://doc.rust-lang.org/std/vec/struct.Vec.html\n"
+"[2]: https://doc.rust-lang.org/std/vec/struct.Vec.html#deref-methods-[T]"
+msgstr ""
+
+#: src/std/hashmap.md:1
+msgid "# `HashMap`"
+msgstr ""
+
+#: src/std/hashmap.md:3
+msgid "Standard hash map with protection against HashDoS attacks:"
+msgstr ""
+"HashDoS[^역주1] 공격으로부터 보호되는 표준 해시 맵입니다.\n"
+"* _역주: HashDoS: Hash table을 사용하는 웹서버에 파라미터가 많은 POST를   호"
+"출하여 Hash table 충돌을 유도하여 CPU 부하를 발생시키는 공격 방법."
+
+#: src/std/hashmap.md:5
+msgid ""
+"```rust,editable\n"
+"use std::collections::HashMap;"
+msgstr ""
+
+#: src/std/hashmap.md:8
+msgid ""
+"fn main() {\n"
+"    let mut page_counts = HashMap::new();\n"
+"    page_counts.insert(\"Adventures of Huckleberry Finn\".to_string(), "
+"207);\n"
+"    page_counts.insert(\"Grimms' Fairy Tales\".to_string(), 751);\n"
+"    page_counts.insert(\"Pride and Prejudice\".to_string(), 303);"
+msgstr ""
+
+#: src/std/hashmap.md:14
+msgid ""
+"    if !page_counts.contains_key(\"Les Misérables\") {\n"
+"        println!(\"We've know about {} books, but not Les Misérables.\",\n"
+"                 page_counts.len());\n"
+"    }"
+msgstr ""
+
+#: src/std/hashmap.md:19
+msgid ""
+"    for book in [\"Pride and Prejudice\", \"Alice's Adventure in "
+"Wonderland\"] {\n"
+"        match page_counts.get(book) {\n"
+"            Some(count) => println!(\"{book}: {count} pages\"),\n"
+"            None => println!(\"{book} is unknown.\")\n"
+"        }\n"
+"    }\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/std/box.md:1
+msgid "# `Box`"
+msgstr ""
+
+#: src/std/box.md:3
+msgid "[`Box`][1] is an owned pointer to data on the heap:"
+msgstr "[`Box`][1]는 힙 데이터에 대한 소유 포인터입니다:"
+
+#: src/std/box.md:5
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let five = Box::new(5);\n"
+"    println!(\"five: {}\", *five);\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/std/box.md:13
+msgid ""
+"```bob\n"
+" Stack                     Heap\n"
+".- - - - - - -.     .- - - - - - -.\n"
+":             :     :             :\n"
+":    five     :     :             :\n"
+":   +-----+   :     :   +-----+   :\n"
+":   | o---|---+-----+-->|  5  |   :\n"
+":   +-----+   :     :   +-----+   :\n"
+":             :     :             :\n"
+":             :     :             :\n"
+"`- - - - - - -'     `- - - - - - -'\n"
+"```"
+msgstr ""
+
+#: src/std/box.md:26
+msgid ""
+"`Box<T>` implements `Deref<Target = T>`, which means that you can [call "
+"methods\n"
+"from `T` directly on a `Box<T>`][2]."
+msgstr ""
+"`Box<T>`은 [`Deref<Target = T>`][2]를 구현합니다. \n"
+"이는 [`Box<T>`에서 T 관련 메서드를 직접 호출][2] 할 수 있다는 의미입니다."
+
+#: src/std/box.md:29
+msgid ""
+"[1]: https://doc.rust-lang.org/std/boxed/struct.Box.html\n"
+"[2]: https://doc.rust-lang.org/std/ops/trait.Deref.html#more-on-deref-"
+"coercion"
+msgstr ""
+
+#: src/std/box-recursive.md:1
+msgid "# Box with Recursive Data Structures"
+msgstr "재귀자료 구조에서의 `Box`"
+
+#: src/std/box-recursive.md:3
+msgid ""
+"Recursive data types or data types with dynamic sizes need to use a `Box`:"
+msgstr "재귀 데이터나 동적크기의 데이터 타입은 `Box`타입을 사용해야 합니다."
+
+#: src/std/box-recursive.md:5 src/std/box-niche.md:3
+msgid ""
+"```rust,editable\n"
+"#[derive(Debug)]\n"
+"enum List<T> {\n"
+"    Cons(T, Box<List<T>>),\n"
+"    Nil,\n"
+"}"
+msgstr ""
+
+#: src/std/box-recursive.md:12 src/std/box-niche.md:10
+msgid ""
+"fn main() {\n"
+"    let list: List<i32> = List::Cons(1, Box::new(List::Cons(2, Box::"
+"new(List::Nil))));\n"
+"    println!(\"{list:?}\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/std/box-recursive.md:18
+msgid ""
+"```bob\n"
+" Stack                           Heap\n"
+".- - - - - - - - - - - - -.     .- - - - - - - - - - - - - - - - - - - - - - "
+"- -.\n"
+":                         :     :                                               :\n"
+":    "
+"list                 :     :                                               :\n"
+":   +--------+-------+    :     :    +--------+--------+    +--------+------"
+"+   :\n"
+":   | Tag    | Cons  |    :     : .->| Tag    | Cons   | .->| Tag    | Nil  "
+"|   :\n"
+":   | 0      | 1     |    :     : |  | 0      | 2      | |  | ////// | //// "
+"|   :\n"
+":   | 1      | o-----+----+-----+-'  | 1      | o------+-'  | ////// | //// "
+"|   :\n"
+":   +--------+-------+    :     :    +--------+--------+    +--------+------"
+"+   :\n"
+":                         :     :                                               :\n"
+":                         :     :                                               :\n"
+"`- - - - - - - - - - - - -'     '- - - - - - - - - - - - - - - - - - - - - - "
+"- -'\n"
+"```"
+msgstr ""
+
+#: src/std/box-niche.md:1
+msgid "# Niche Optimization"
+msgstr ""
+
+#: src/std/box-niche.md:16
+msgid ""
+"A `Box` cannot be empty, so the pointer is always valid and non-`null`. "
+"This\n"
+"allows the compiler to optimize the memory layout:"
+msgstr ""
+"`Box`는 비어있을 수 없습니다. 따라서 포인트는 항상 유효하고 `null`이 아닙니"
+"다.\n"
+"이는 컴파일러가 메모리 레이아웃을 최적화 할 수 있게 해줍니다."
+
+#: src/std/box-niche.md:19
+msgid ""
+"```bob\n"
+" Stack                           Heap\n"
+".- - - - - - - - - - - - -.     .- - - - - - - - - - - - - - - - - - - - - - "
+"- -.\n"
+":                         :     :                                               :\n"
+":    "
+"list                 :     :                                               :\n"
+":   +--------+-------+    :     :    +--------+--------+    +--------+------"
+"+   :\n"
+":   | 0      | 1     |    :     : .->| 0      |  2     | .->| ////// | //// "
+"|   :\n"
+":   | \"1/Tag\"| o-----+----+-----+-'  | \"1/Tag\"|  o-----+-'  | \"1/Tag\"| "
+"null |   :\n"
+":   +--------+-------+    :     :    +--------+--------+    +--------+------"
+"+   :\n"
+":                         :     :                                               :\n"
+":                         :     :                                               :\n"
+"`- - - - - - - - - - - - -'     '- - - - - - - - - - - - - - - - - - - - - - "
+"- -'\n"
+"```"
+msgstr ""
+
+#: src/std/rc.md:1
+msgid "# `Rc`"
+msgstr ""
+
+#: src/std/rc.md:3
+msgid ""
+"[`Rc`][1] is a reference-counted shared pointer. Use this when you need to "
+"refer\n"
+"to the same data from multiple places:"
+msgstr ""
+"[`Rc`][1]는 참조 카운팅 공유 포인트입니다. \n"
+"여러 위치의 동일한 데이터를 참조해야할 경우 사용합니다:"
+
+#: src/std/rc.md:6
+msgid ""
+"```rust,editable\n"
+"use std::rc::Rc;"
+msgstr ""
+
+#: src/std/rc.md:9
+msgid ""
+"fn main() {\n"
+"    let mut a = Rc::new(10);\n"
+"    let mut b = a.clone();"
+msgstr ""
+
+#: src/std/rc.md:18
+msgid ""
+"If you need to mutate the data inside an `Rc`, you will need to wrap the "
+"data in\n"
+"a type such as [`Cell` or `RefCell`][2]. See [`Arc`][3] if you are in a "
+"multi-threaded\n"
+"context."
+msgstr ""
+"`Rc`내부의 데이터를 변경해야 하는 경우, 데이터를 [`Cell` 또는 `RefCell`][2]"
+"로 래핑해야합니다.\n"
+"멀티스레드인 경우 [`Arc`][3]를 참조하시기 바랍니다."
+
+#: src/std/rc.md:22
+msgid ""
+"[1]: https://doc.rust-lang.org/std/rc/struct.Rc.html\n"
+"[2]: https://doc.rust-lang.org/std/cell/index.html\n"
+"[3]: ../concurrency/shared_state/arc.md"
+msgstr ""
+
+#: src/modules.md:1
+msgid "# Modules"
+msgstr "# 모듈"
+
+#: src/modules.md:3
+msgid "We have seen how `impl` blocks let us namespace functions to a type."
+msgstr "`impl`블록은 네임스페이스함수를 타입으로 제공합니다."
+
+#: src/modules.md:5
+msgid "Similarly, `mod` lets us namespace types and functions:"
+msgstr "`mod` 역시 네임스페이스 타입과 함수를 제공합니다: "
+
+#: src/modules.md:7
+msgid ""
+"```rust,editable\n"
+"mod foo {\n"
+"    pub fn do_something() {\n"
+"        println!(\"In the foo module\");\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/modules.md:14
+msgid ""
+"mod bar {\n"
+"    pub fn do_something() {\n"
+"        println!(\"In the bar module\");\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/modules.md:20
+msgid ""
+"fn main() {\n"
+"    foo::do_something();\n"
+"    bar::do_something();\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/modules/visibility.md:1
+msgid "# Visibility"
+msgstr "# 접근자"
+
+#: src/modules/visibility.md:3
+msgid "Modules are a privacy boundary:"
+msgstr "모듈의 기본 접근자는 private 입니다:"
+
+#: src/modules/visibility.md:5
+msgid ""
+"* Module items are private by default (hides implementation details).\n"
+"* Parent and sibling items are always visible."
+msgstr ""
+"* 모듈의 항목은 기본적으로 private 입니다.(구현에서 숨겨짐)\n"
+"* 부모와 이웃 항목에서는 접근 가능합니다."
+
+#: src/modules/visibility.md:8
+msgid ""
+"```rust,editable\n"
+"mod outer {\n"
+"    fn private() {\n"
+"        println!(\"outer::private\");\n"
+"    }"
+msgstr ""
+
+#: src/modules/visibility.md:14
+msgid ""
+"    pub fn public() {\n"
+"        println!(\"outer::public\");\n"
+"    }"
+msgstr ""
+
+#: src/modules/visibility.md:18
+msgid ""
+"    mod inner {\n"
+"        fn private() {\n"
+"            println!(\"outer::inner::private\");\n"
+"        }"
+msgstr ""
+
+#: src/modules/visibility.md:23
+msgid ""
+"        pub fn public() {\n"
+"            println!(\"outer::inner::public\");\n"
+"            super::private();\n"
+"        }\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/modules/visibility.md:30
+msgid ""
+"fn main() {\n"
+"    outer::public();\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/modules/paths.md:1
+msgid "# Paths"
+msgstr "# 경로"
+
+#: src/modules/paths.md:3
+msgid "Paths are resolved as follows:"
+msgstr "경로는 아래와 같이 구분합니다:"
+
+#: src/modules/paths.md:5
+msgid ""
+"1. As a relative path:\n"
+"   * `foo` or `self::foo` refers to `foo` in the current module,\n"
+"   * `super::foo` refers to `foo` in the parent module."
+msgstr ""
+"1. 상대경로\n"
+"  *  `foo` 또는 `self::foo`는 `foo`모듈 안에서 현재 모듈을 가리킵니다.\n"
+"  * `super::foo`는 `foo`모듈의 부모 모듈을 가리킵니다."
+
+#: src/modules/paths.md:9
+msgid ""
+"2. As an absolute path:\n"
+"   * `crate::foo` refers to `foo` in the root of the current crate,\n"
+"   * `bar::foo` refers to `foo` in the `bar` crate."
+msgstr ""
+"2. 절대 경로\n"
+"  * `crate::foo`는 현재 크레이트 루트의 있는 `foo`를 가리킵니다.\n"
+"  * `bar::foo`는 `bar`크레이트 안에 있는 `foo`를 가리킵니다."
+
+#: src/modules/filesystem.md:1
+msgid "# Filesystem Hierarchy"
+msgstr "# 파일시스템 계층"
+
+#: src/modules/filesystem.md:3
+msgid "The module content can be omitted:"
+msgstr "모듈의 내용은 생략될 수 있습니다:"
+
+#: src/modules/filesystem.md:5
+msgid ""
+"```rust,editable,compile_fail\n"
+"mod garden;\n"
+"```"
+msgstr ""
+
+#: src/modules/filesystem.md:9
+msgid "The `garden` module content is found at:"
+msgstr "`garden` 모듈의 내용은 아래 위치에서 확인 할 수 있습니다."
+
+#: src/modules/filesystem.md:11
+msgid ""
+"* `src/garden.rs` (modern Rust 2018 style)\n"
+"* `src/garden/mod.rs` (older Rust 2015 style)"
+msgstr ""
+
+#: src/modules/filesystem.md:14
+msgid "Similarly, a `garden::vegetables` module can be found at:"
+msgstr "유사하게 `garden::vegetables` 모듈은 아래 위치에서 확인할 수 있습니다."
+
+#: src/modules/filesystem.md:16
+msgid ""
+"* `src/garden/vegetables.rs` (modern Rust 2018 style)\n"
+"* `src/garden/vegetables/mod.rs` (older Rust 2015 style)"
+msgstr ""
+
+#: src/modules/filesystem.md:19
+msgid "The `crate` root is in:"
+msgstr "`crate(크레이트)`의 루트는 아래 경로 입니다:"
+
+#: src/modules/filesystem.md:21
+msgid ""
+"* `src/lib.rs` (for a library crate)\n"
+"* `src/main.rs` (for a binary crate)"
+msgstr ""
+
+#: src/exercises/day-2/afternoon.md:1
+msgid "# Day 2: Afternoon Exercises"
+msgstr "# 2일차 오후 연습문제"
+
+#: src/exercises/day-2/afternoon.md:3
+msgid "The exercises for this afternoon will focus on strings and iterators."
+msgstr "이번 연습문제는 문자열과 반복자에 초점을 맞출 것입니다."
+
+#: src/exercises/day-2/luhn.md:1
+msgid "# Luhn Algorithm"
+msgstr "# 룬 알고리즘"
+
+#: src/exercises/day-2/luhn.md:3
+msgid ""
+"The [Luhn algorithm](https://en.wikipedia.org/wiki/Luhn_algorithm) is used "
+"to\n"
+"validate credit card numbers. The algorithm takes a string as input and does "
+"the\n"
+"following to validate the credit card number:"
+msgstr ""
+"[룬 알고리즘](https://ko.wikipedia.org/wiki/"
+"%EB%A3%AC_%EC%95%8C%EA%B3%A0%EB%A6%AC%EC%A6%98)은 신용카드 번호 검증에 사용되"
+"는 알고리즘 입니다. \n"
+"이 알고리즘은 신용카드 번호를 `문자열`로 입력받고, 아래의 순서에 따라 신용카"
+"드 번호의 유효성을 확인합니다:"
+
+#: src/exercises/day-2/luhn.md:7
+msgid "* Ignore all spaces. Reject number with less than two digits."
+msgstr "* 모든 공백을 무시합니다, 2자리 미만 숫자는 무시합니다."
+
+#: src/exercises/day-2/luhn.md:9
+msgid ""
+"* Moving from right to left, double every second digit: for the number "
+"`1234`,\n"
+"  we double `3` and `1`."
+msgstr ""
+"* 오른쪽에서 왼쪽으로 이동하며 2번째 자리마다 숫자를 2배 증가시킵니다.   1234"
+"에서 3과 1을 두배로 만듭니다.(2464)"
+
+#: src/exercises/day-2/luhn.md:12
+msgid ""
+"* After doubling a digit, sum the digits. So doubling `7` becomes `14` "
+"which\n"
+"  becomes `5`."
+msgstr ""
+"* 두배로 만든 숫자가 2자리가 넘으면 각 자리를 더합니다: 7의 두배는 14이므로 5"
+"가   됩니다."
+
+#: src/exercises/day-2/luhn.md:15
+msgid "* Sum all the undoubled and doubled digits."
+msgstr "* 모든 자리의 숫자를 합합니다."
+
+#: src/exercises/day-2/luhn.md:17
+msgid "* The credit card number is valid if the sum is ends with `0`."
+msgstr "* 합계의 끝자리가 0인 경우 유효한 신용카드 번호 입니다."
+
+#: src/exercises/day-2/luhn.md:19
+msgid ""
+"Copy the following code to <https://play.rust-lang.org/> and implement the\n"
+"function:"
+msgstr ""
+"아래 코드를 <https://play.rust-lang.org/>에 복사하고 함수를 구현해 보시기 바"
+"랍니다."
+
+#: src/exercises/day-2/luhn.md:27
+msgid ""
+"pub fn luhn(cc_number: &str) -> bool {\n"
+"    unimplemented!()\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-2/luhn.md:31
+msgid ""
+"#[test]\n"
+"fn test_non_digit_cc_number() {\n"
+"    assert!(!luhn(\"foo\"));\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-2/luhn.md:36 src/exercises/day-2/solutions-afternoon.md:64
+msgid ""
+"#[test]\n"
+"fn test_empty_cc_number() {\n"
+"    assert!(!luhn(\"\"));\n"
+"    assert!(!luhn(\" \"));\n"
+"    assert!(!luhn(\"  \"));\n"
+"    assert!(!luhn(\"    \"));\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-2/luhn.md:44 src/exercises/day-2/solutions-afternoon.md:72
+msgid ""
+"#[test]\n"
+"fn test_single_digit_cc_number() {\n"
+"    assert!(!luhn(\"0\"));\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-2/luhn.md:49 src/exercises/day-2/solutions-afternoon.md:77
+msgid ""
+"#[test]\n"
+"fn test_two_digit_cc_number() {\n"
+"    assert!(luhn(\" 0 0 \"));\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-2/luhn.md:54 src/exercises/day-2/solutions-afternoon.md:82
+msgid ""
+"#[test]\n"
+"fn test_valid_cc_number() {\n"
+"    assert!(luhn(\"4263 9826 4026 9299\"));\n"
+"    assert!(luhn(\"4539 3195 0343 6467\"));\n"
+"    assert!(luhn(\"7992 7398 713\"));\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-2/luhn.md:61
+msgid ""
+"#[test]\n"
+"fn test_invalid_cc_number() {\n"
+"    assert!(!luhn(\"4223 9826 4026 9299\"));\n"
+"    assert!(!luhn(\"4539 3195 0343 6476\"));\n"
+"    assert!(!luhn(\"8273 1232 7352 0569\"));\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-2/strings-iterators.md:1
+msgid "# Strings and Iterators"
+msgstr "# 문자열과 반복자"
+
+#: src/exercises/day-2/strings-iterators.md:3
+msgid ""
+"In this exercise, you are implementing a routing component of a web server. "
+"The\n"
+"server is configured with a number of _path prefixes_ which are matched "
+"against\n"
+"_request paths_. The path prefixes can contain a wildcard character which\n"
+"matches a full segment. See the unit tests below."
+msgstr ""
+"이번 훈련은 웹 서버의 라우팅 컴포넌트를 구현합니다. \n"
+"서버는 _요청경로(request path)와_ 일치하는 여러개의 _경로 접두사(path "
+"prefixes)로_ 구성되어 있습니다. 경로 접두사에는 와일드카드문자를 포함할 수 있"
+"습니다.  아래 테스트 코드를 참조하세요"
+
+#: src/exercises/day-2/strings-iterators.md:8
+msgid ""
+"Copy the following code to <https://play.rust-lang.org/> and make the tests\n"
+"pass. Try avoiding allocating a `Vec` for your intermediate results:"
+msgstr ""
+"아래 코드를 <https://play.rust-lang.org/>에 복사하고 테스트를 통과해 보시기 "
+"바랍니다. 중간 결과값을 `Vec`에 할당하지 않도록 주의 하시기 바랍니다."
+
+#: src/exercises/day-2/strings-iterators.md:16
+msgid ""
+"pub fn prefix_matches(prefix: &str, request_path: &str) -> bool {\n"
+"    unimplemented!()\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-2/strings-iterators.md:20
+msgid ""
+"#[test]\n"
+"fn test_matches_without_wildcard() {\n"
+"    assert!(prefix_matches(\"/v1/publishers\", \"/v1/publishers\"));\n"
+"    assert!(prefix_matches(\"/v1/publishers\", \"/v1/publishers/"
+"abc-123\"));\n"
+"    assert!(prefix_matches(\"/v1/publishers\", \"/v1/publishers/abc/"
+"books\"));"
+msgstr ""
+
+#: src/exercises/day-2/strings-iterators.md:26
+#: src/exercises/day-2/solutions-afternoon.md:146
+msgid ""
+"    assert!(!prefix_matches(\"/v1/publishers\", \"/v1\"));\n"
+"    assert!(!prefix_matches(\"/v1/publishers\", \"/v1/publishersBooks\"));\n"
+"    assert!(!prefix_matches(\"/v1/publishers\", \"/v1/parent/"
+"publishers\"));\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-2/strings-iterators.md:31
+#: src/exercises/day-2/solutions-afternoon.md:151
+msgid ""
+"#[test]\n"
+"fn test_matches_with_wildcard() {\n"
+"    assert!(prefix_matches(\n"
+"        \"/v1/publishers/*/books\",\n"
+"        \"/v1/publishers/foo/books\"\n"
+"    ));\n"
+"    assert!(prefix_matches(\n"
+"        \"/v1/publishers/*/books\",\n"
+"        \"/v1/publishers/bar/books\"\n"
+"    ));\n"
+"    assert!(prefix_matches(\n"
+"        \"/v1/publishers/*/books\",\n"
+"        \"/v1/publishers/foo/books/book1\"\n"
+"    ));"
+msgstr ""
+
+#: src/exercises/day-2/strings-iterators.md:46
+msgid ""
+"    assert!(!prefix_matches(\"/v1/publishers/*/books\", \"/v1/"
+"publishers\"));\n"
+"    assert!(!prefix_matches(\n"
+"        \"/v1/publishers/*/books\",\n"
+"        \"/v1/publishers/foo/booksByAuthor\"\n"
+"    ));\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/welcome-day-3.md:1
+msgid "# Welcome to Day 3"
+msgstr "# 3일차 개요"
+
+#: src/welcome-day-3.md:3
+msgid "Today, we will cover some more advanced topics of Rust:"
+msgstr "오늘은 러스트의 몇가지 고급 주제를 다룹니다:"
+
+#: src/welcome-day-3.md:5
+msgid ""
+"* Traits: deriving traits, default methods, and important standard library\n"
+"  traits."
+msgstr ""
+"* 트레이트: 트레이트 파생(derive), 기본 메서드, 주요 표준라이브러리 트레이트"
+
+#: src/welcome-day-3.md:8
+msgid ""
+"* Generics: generic data types, generic methods, monomorphization, and "
+"trait\n"
+"  objects."
+msgstr ""
+"* 제너릭: 제너릭 데이터 타입, 제너릭 메서드, 단형화(monomorphization),   그리"
+"고 트레이트 객체"
+
+#: src/welcome-day-3.md:11
+msgid "* Error handling: panics, `Result`, and the try operator `?`."
+msgstr "* 오류처리(에러 핸들링): 패닉, Result, ?연산자(시행 연산자)"
+
+#: src/welcome-day-3.md:13
+msgid "* Testing: unit tests, documentation tests, and integration tests."
+msgstr "* 테스트: 단위 테스트, 문서 테스트 및 통합 테스트"
+
+#: src/welcome-day-3.md:15
+msgid ""
+"* Unsafe Rust: raw pointers, static variables, unsafe functions, and extern\n"
+"  functions."
+msgstr ""
+"* 안전하지 않은 러스트: 원시(raw) 포인터, 정적 변수, 안전하지 않은 함수,   외"
+"부 함수"
+
+#: src/traits.md:1
+msgid "# Traits"
+msgstr "# 트레이트(Traits)"
+
+#: src/traits.md:3
+msgid ""
+"Rust lets you abstract over types with traits. They're similar to interfaces:"
+msgstr ""
+"러스트는 인터페이스 처럼 트레이트가 있는 타입을 추상화 할 수 있습니다: "
+
+#: src/traits.md:5
+msgid ""
+"```rust,editable\n"
+"trait Greet {\n"
+"    fn say_hello(&self);\n"
+"}"
+msgstr ""
+
+#: src/traits.md:10
+msgid ""
+"struct Dog {\n"
+"    name: String,\n"
+"}"
+msgstr ""
+
+#: src/traits.md:14
+msgid "struct Cat;  // No name, cats won't respond to it anyway."
+msgstr ""
+"struct Cat;  // 이름속성이 없습니다. 고양이는 어쨌든 반응하지 않습니다:)"
+
+#: src/traits.md:16
+msgid ""
+"impl Greet for Dog {\n"
+"    fn say_hello(&self) {\n"
+"        println!(\"Wuf, my name is {}!\", self.name);\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/traits.md:22
+msgid ""
+"impl Greet for Cat {\n"
+"    fn say_hello(&self) {\n"
+"        println!(\"Miau!\");\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/traits.md:28
+msgid ""
+"fn main() {\n"
+"    let pets: Vec<Box<dyn Greet>> = vec![\n"
+"        Box::new(Dog { name: String::from(\"Fido\") }),\n"
+"        Box::new(Cat),\n"
+"    ];\n"
+"    for pet in pets {\n"
+"        pet.say_hello();\n"
+"    }\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/traits/deriving-traits.md:1
+msgid "# Deriving Traits"
+msgstr "# 트레이트 파생(Deriving Traits)"
+
+#: src/traits/deriving-traits.md:3
+msgid "You can let the compiler derive a number of traits:"
+msgstr ""
+"컴파일러가 여러가지 트레이트를 파생(derive)하도록 할 수 있습니다:\n"
+"* _역주: derive 메타주석 이야기 입니다._"
+
+#: src/traits/deriving-traits.md:5
+msgid ""
+"```rust,editable\n"
+"#[derive(Debug, Clone, PartialEq, Eq, Default)]\n"
+"struct Player {\n"
+"    name: String,\n"
+"    strength: u8,\n"
+"    hit_points: u8,\n"
+"}"
+msgstr ""
+
+#: src/traits/deriving-traits.md:13
+msgid ""
+"fn main() {\n"
+"    let p1 = Player::default();\n"
+"    let p2 = p1.clone();\n"
+"    println!(\"Is {:?}\\nequal to {:?}?\\nThe answer is {}!\", &p1, &p2,\n"
+"             if p1 == p2 { \"yes\" } else { \"no\" });\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/traits/default-methods.md:1
+msgid "# Default Methods"
+msgstr "# 기본 메서드"
+
+#: src/traits/default-methods.md:3
+msgid "Traits can implement behavior in terms of other trait methods:"
+msgstr ""
+"트레이트는 다른 트레이트 메서드에서의 동작을 구현할 수 있습니다.\n"
+"* 역주: \n"
+"  * Equals 트레이트에서 equal은 선언만 되어있고 not_equal에서 이를 호출하"
+"고     있습니다. (추상 메서드)\n"
+"  * impl에서 equal 메서드를 정의하고 있어서 Centimeter에서의 equal 메서드"
+"를     구현되어 있습니다.(추상 메서드 구현)"
+
+#: src/traits/default-methods.md:5
+msgid ""
+"```rust,editable\n"
+"trait Equals {\n"
+"    fn equal(&self, other: &Self) -> bool;\n"
+"    fn not_equal(&self, other: &Self) -> bool {\n"
+"        !self.equal(other)\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/traits/default-methods.md:13
+msgid ""
+"#[derive(Debug)]\n"
+"struct Centimeter(i16);"
+msgstr ""
+
+#: src/traits/default-methods.md:16
+msgid ""
+"impl Equals for Centimeter {\n"
+"    fn equal(&self, other: &Centimeter) -> bool {\n"
+"        self.0 == other.0\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/traits/default-methods.md:22
+msgid ""
+"fn main() {\n"
+"    let a = Centimeter(10);\n"
+"    let b = Centimeter(20);\n"
+"    println!(\"{a:?} equals {b:?}: {}\", a.equal(&b));\n"
+"    println!(\"{a:?} not_equals {b:?}: {}\", a.not_equal(&b));\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/traits/important-traits.md:1
+msgid "# Important Traits"
+msgstr "# 중요 트레이트"
+
+#: src/traits/important-traits.md:3
+msgid ""
+"We will now look at some of the most common traits of the Rust standard "
+"library:"
+msgstr "러스트 표준 라이브러리의 자주 사용하는 몇가지 트레이트 예시입니다:"
+
+#: src/traits/important-traits.md:5
+msgid ""
+"* `Iterator` and `IntoIterator` used in `for` loops,\n"
+"* `From` and `Into` used to convert values,\n"
+"* `Read` and `Write` used for IO,\n"
+"* `Add`, `Mul`, ... used for operator overloading, and\n"
+"* `Drop` used for defining destructors."
+msgstr ""
+"* `Iterator`와 `IntoIterator` 트레이트는 `for` 루프에서 사용됩니다.\n"
+"* `From`과 `Into` 트레이트는 타입변환시 사용됩니다.\n"
+"* `Read`와 `Write` 트레이트는 I/O에 사용됩니다.\n"
+"* `Add`, `Mul` 등의 트레이트들은 연산자 오버로딩(overloading)에 사용됩니다.\n"
+"* `Drop` 트레이트는 소멸자 정의에 사용됩니다."
+
+#: src/traits/iterator.md:1
+msgid "# Iterators"
+msgstr ""
+
+#: src/traits/iterator.md:3
+msgid "You can implement the `Iterator` trait on your own types:"
+msgstr "`Iterator`를 커스텀 타입에 구현할 수 있습니다: "
+
+#: src/traits/iterator.md:5
+msgid ""
+"```rust,editable\n"
+"struct Fibonacci {\n"
+"    curr: u32,\n"
+"    next: u32,\n"
+"}"
+msgstr ""
+
+#: src/traits/iterator.md:11
+msgid ""
+"impl Iterator for Fibonacci {\n"
+"    type Item = u32;"
+msgstr ""
+
+#: src/traits/iterator.md:14
+msgid ""
+"    fn next(&mut self) -> Option<Self::Item> {\n"
+"        let new_next = self.curr + self.next;\n"
+"        self.curr = self.next;\n"
+"        self.next = new_next;\n"
+"        Some(self.curr)\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/traits/iterator.md:22
+msgid ""
+"fn main() {\n"
+"    let fib = Fibonacci { curr: 0, next: 1 };\n"
+"    for (i, n) in fib.enumerate().take(5) {\n"
+"        println!(\"fib({i}): {n}\");\n"
+"    }\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/traits/from-into.md:1
+msgid "# `From` and `Into`"
+msgstr ""
+
+#: src/traits/from-into.md:3
+msgid "Types implement `From` and `Into` to facilitate type conversions:"
+msgstr "타입은 용이한 형변환을 위해 `From`과 `Into`를 구현합니다:"
+
+#: src/traits/from-into.md:5
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let s = String::from(\"hello\");\n"
+"    let addr = std::net::Ipv4Addr::from([127, 0, 0, 1]);\n"
+"    let one = i16::from(true);\n"
+"    let bigger = i32::from(123i16);\n"
+"    println!(\"{s}, {addr}, {one}, {bigger}\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/traits/from-into.md:15
+msgid "`Into` is automatically implemented when `From` is implemented:"
+msgstr "`From`이 구현되면 `Into` 역시 자동으로 구현됩니다:"
+
+#: src/traits/from-into.md:17
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let s: String = \"hello\".into();\n"
+"    let addr: std::net::Ipv4Addr = [127, 0, 0, 1].into();\n"
+"    let one: i16 = true.into();\n"
+"    let bigger: i32 = 123i16.into();\n"
+"    println!(\"{s}, {addr}, {one}, {bigger}\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/traits/read-write.md:1
+msgid "# `Read` and `Write`"
+msgstr ""
+
+#: src/traits/read-write.md:3
+msgid "Using `Read` and `BufRead`, you can abstract over `u8` sources:"
+msgstr "`Read`와 `BufRead`를 사용하면 `u8` 소스로부터 읽을 수 있습니다:"
+
+#: src/traits/read-write.md:5
+msgid ""
+"```rust,editable\n"
+"use std::io::{BufRead, BufReader, Read, Result};"
+msgstr ""
+
+#: src/traits/read-write.md:8
+msgid ""
+"fn count_lines<R: Read>(reader: R) -> usize {\n"
+"    let buf_reader = BufReader::new(reader);\n"
+"    buf_reader.lines().count()\n"
+"}"
+msgstr ""
+
+#: src/traits/read-write.md:13
+msgid ""
+"fn main() -> Result<()> {\n"
+"    let slice: &[u8] = b\"foo\\nbar\\nbaz\\n\";\n"
+"    println!(\"lines in slice: {}\", count_lines(slice));"
+msgstr ""
+
+#: src/traits/read-write.md:17
+msgid ""
+"    let file = std::fs::File::open(std::env::current_exe()?)?;\n"
+"    println!(\"lines in file: {}\", count_lines(file));\n"
+"    Ok(())\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/traits/read-write.md:23
+msgid "Similarly, `Write` lets you abstract over `u8` sinks:"
+msgstr "유사하게 `Write`를 통해 `u8`소스로 출력할 수 있습니다:"
+
+#: src/traits/read-write.md:25
+msgid ""
+"```rust,editable\n"
+"use std::io::{Result, Write};"
+msgstr ""
+
+#: src/traits/read-write.md:28
+msgid ""
+"fn log<W: Write>(writer: &mut W, msg: &str) -> Result<()> {\n"
+"    writer.write_all(msg.as_bytes())?;\n"
+"    writer.write_all(\"\\n\".as_bytes())\n"
+"}"
+msgstr ""
+
+#: src/traits/read-write.md:33
+msgid ""
+"fn main() -> Result<()> {\n"
+"    let mut buffer = Vec::new();\n"
+"    log(&mut buffer, \"Hello\")?;\n"
+"    log(&mut buffer, \"World\")?;\n"
+"    println!(\"Logged: {:?}\", buffer);\n"
+"    Ok(())\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/traits/operators.md:1
+msgid "# `Add`, `Mul`, ..."
+msgstr ""
+
+#: src/traits/operators.md:3
+msgid "Operator overloading is implemented via traits in `std::ops`:"
+msgstr "연산자 오버로드는 `std::ops` 트레이트을 통해 구현됩니다:"
+
+#: src/traits/operators.md:5
+msgid ""
+"```rust,editable\n"
+"#[derive(Debug, Copy, Clone)]\n"
+"struct Point { x: i32, y: i32 }"
+msgstr ""
+
+#: src/traits/operators.md:9 src/exercises/day-2/solutions-morning.md:46
+msgid ""
+"impl std::ops::Add for Point {\n"
+"    type Output = Self;"
+msgstr ""
+
+#: src/traits/operators.md:12
+msgid ""
+"    fn add(self, other: Self) -> Self {\n"
+"        Self {x: self.x + other.x, y: self.y + other.y}\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/traits/operators.md:17
+msgid ""
+"fn main() {\n"
+"    let p1 = Point { x: 10, y: 20 };\n"
+"    let p2 = Point { x: 100, y: 200 };\n"
+"    println!(\"{:?} + {:?} = {:?}\", p1, p2, p1 + p2);\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/traits/drop.md:1
+msgid "# The `Drop` Trait"
+msgstr ""
+
+#: src/traits/drop.md:3
+msgid ""
+"Values which implement `Drop` can specify code to run when they go out of "
+"scope:"
+msgstr ""
+"`Drop`트레이트는 값이 스코프 밖으로 나갈때 실행하는 코드를 작성할 수 있습니"
+"다:"
+
+#: src/traits/drop.md:5
+msgid ""
+"```rust,editable\n"
+"struct Droppable {\n"
+"    name: &'static str,\n"
+"}"
+msgstr ""
+
+#: src/traits/drop.md:10
+msgid ""
+"impl Drop for Droppable {\n"
+"    fn drop(&mut self) {\n"
+"        println!(\"Dropping {}\", self.name);\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/traits/drop.md:16
+msgid ""
+"fn main() {\n"
+"    let a = Droppable { name: \"a\" };\n"
+"    {\n"
+"        let b = Droppable { name: \"b\" };\n"
+"        {\n"
+"            let c = Droppable { name: \"c\" };\n"
+"            let d = Droppable { name: \"d\" };\n"
+"            println!(\"Exiting block B\");\n"
+"        }\n"
+"        println!(\"Exiting block A\");\n"
+"    }\n"
+"    drop(a);\n"
+"    println!(\"Exiting main\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/generics.md:1
+msgid "# Generics"
+msgstr "# 제너릭"
+
+#: src/generics.md:3
+msgid ""
+"Rust support generics, which lets you abstract an algorithm (such as "
+"sorting)\n"
+"over the types used in the algorithm."
+msgstr ""
+"러스트는 제너릭을 지원하여 정렬과 같은 알고리즘에 적용되는 타입을 추상화 할 "
+"수 있습니다."
+
+#: src/generics/data-types.md:1
+msgid "# Generic Data Types"
+msgstr "# 제너릭 데이터 타입"
+
+#: src/generics/data-types.md:3
+msgid "You can use generics to abstract over the concrete field type:"
+msgstr "제너릭을 사용하여 구체적인 타입을 추상화할 수 있습니다:"
+
+#: src/generics/data-types.md:5
+msgid ""
+"```rust,editable\n"
+"#[derive(Debug)]\n"
+"struct Point<T> {\n"
+"    x: T,\n"
+"    y: T,\n"
+"}"
+msgstr ""
+
+#: src/generics/data-types.md:12
+msgid ""
+"fn main() {\n"
+"    let integer = Point { x: 5, y: 10 };\n"
+"    let float = Point { x: 1.0, y: 4.0 };\n"
+"    println!(\"{integer:?} and {float:?}\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/generics/methods.md:1
+msgid "# Generic Methods"
+msgstr "# 제너릭 메서드"
+
+#: src/generics/methods.md:3
+msgid "You can declare a generic type on your `impl` block:"
+msgstr "`impl` 블록에서도 제너릭 타입을 선언할 수 있습니다:"
+
+#: src/generics/methods.md:5
+msgid ""
+"```rust,editable\n"
+"#[derive(Debug)]\n"
+"struct Point<T>(T, T);"
+msgstr ""
+
+#: src/generics/methods.md:9
+msgid ""
+"impl<T> Point<T> {\n"
+"    fn x(&self) -> &T {\n"
+"        &self.0  // + 10\n"
+"    }"
+msgstr ""
+
+#: src/generics/methods.md:14
+msgid ""
+"    // fn set_x(&mut self, x: T)\n"
+"}"
+msgstr ""
+
+#: src/generics/methods.md:17
+msgid ""
+"fn main() {\n"
+"    let p = Point(5, 10);\n"
+"    println!(\"p.x = {}\", p.x());\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/generics/trait-bounds.md:1
+msgid "# Trait Bounds"
+msgstr "# 제너릭 타입 제한(트레이트 경계, Trait Bounds)"
+
+#: src/generics/trait-bounds.md:3
+msgid ""
+"When working with generics, you often want to limit the types. You can do "
+"this\n"
+"with `T: Trait` or `impl Trait`:"
+msgstr ""
+"`T:` 혹은 `impl` 트레이트를 사용하여 제너릭을 사용할 때 타입을 제한할 수 있습"
+"니다:"
+
+#: src/generics/trait-bounds.md:6
+msgid ""
+"```rust,editable\n"
+"fn duplicate<T: Clone>(a: T) -> (T, T) {\n"
+"    (a.clone(), a.clone())\n"
+"}"
+msgstr ""
+
+#: src/generics/trait-bounds.md:11
+msgid "// struct NotClonable;"
+msgstr ""
+
+#: src/generics/trait-bounds.md:13
+msgid ""
+"fn main() {\n"
+"    let foo = String::from(\"foo\");\n"
+"    let pair = duplicate(foo);\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/generics/impl-trait.md:1
+msgid "# `impl Trait`"
+msgstr ""
+
+#: src/generics/impl-trait.md:3
+msgid ""
+"Similar to trait bounds, an `impl Trait` syntax can be used in function\n"
+"arguments and return values:"
+msgstr ""
+"트레이트 바운드와 유사하게 `impl`트레이트 문법은 함수의 인자와 반환값에 적용 "
+"가능합니다:"
+
+#: src/generics/impl-trait.md:6 src/generics/trait-objects.md:5
+#: src/generics/trait-objects.md:28
+msgid ""
+"```rust,editable\n"
+"use std::fmt::Display;"
+msgstr ""
+
+#: src/generics/impl-trait.md:9
+msgid ""
+"fn get_x(name: impl Display) -> impl Display {\n"
+"    format!(\"Hello {name}\")\n"
+"}"
+msgstr ""
+
+#: src/generics/impl-trait.md:13
+msgid ""
+"fn main() {\n"
+"    let x = get_x(\"foo\");\n"
+"    println!(\"{x}\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/generics/impl-trait.md:19
+msgid ""
+"* `impl Trait` cannot be used with the `::<>` turbo fish syntax.\n"
+"* `impl Trait` allows you to work with types which you cannot name."
+msgstr ""
+"* `impl` 트레이트는 터보피쉬문법(`::<>`)에는 사용할 수 없습니다.\n"
+"* `impl` 트레이트는 익명타입과 사용할 수 있습니다."
+
+#: src/generics/closures.md:1
+msgid "# Closures"
+msgstr "클로저(Closures)"
+
+#: src/generics/closures.md:3
+msgid ""
+"Closures or lambda expressions have types which cannot be named. However, "
+"they\n"
+"implement special [`Fn`](https://doc.rust-lang.org/std/ops/trait.Fn.html),\n"
+"[`FnMut`](https://doc.rust-lang.org/std/ops/trait.FnMut.html), and\n"
+"[`FnOnce`](https://doc.rust-lang.org/std/ops/trait.FnOnce.html) traits:"
+msgstr ""
+"클로저 혹은 람다표현식은 익명타입입니다. 이들은 \n"
+"[`Fn`](https://doc.rust-lang.org/std/ops/trait.Fn.html),\n"
+"[`FnMut`](https://doc.rust-lang.org/std/ops/trait.FnMut.html), \n"
+"[`FnOnce`](https://doc.rust-lang.org/std/ops/trait.FnOnce.html) 라는 특별한 "
+"트레이트를 구현합니다."
+
+#: src/generics/closures.md:8
+msgid ""
+"```rust,editable\n"
+"fn apply_with_log(func: impl FnOnce(i32) -> i32, input: i32) -> i32 {\n"
+"    println!(\"Calling function on {input}\");\n"
+"    func(input)\n"
+"}"
+msgstr ""
+
+#: src/generics/closures.md:14
+msgid ""
+"fn main() {\n"
+"    let add_3 = |x| x + 3;\n"
+"    let mul_5 = |x| x * 5;"
+msgstr ""
+
+#: src/generics/closures.md:18
+msgid ""
+"    println!(\"add_3: {}\", apply_with_log(add_3, 10));\n"
+"    println!(\"mul_5: {}\", apply_with_log(mul_5, 20));\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/generics/monomorphization.md:1
+msgid "# Monomorphization"
+msgstr "# 단형화(Monomorphization)"
+
+#: src/generics/monomorphization.md:3
+msgid "Generic code is turned into non-generic code based on the call sites:"
+msgstr "제너릭 코드는 호출부에서 비 제너릭 코드로 전환됩니다:"
+
+#: src/generics/monomorphization.md:5
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let integer = Some(5);\n"
+"    let float = Some(5.0);\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/generics/monomorphization.md:12
+msgid "behaves as if you wrote"
+msgstr "위 코드는 아래와 같이 동작합니다."
+
+#: src/generics/monomorphization.md:14
+msgid ""
+"```rust,editable\n"
+"enum Option_i32 {\n"
+"    Some(i32),\n"
+"    None,\n"
+"}"
+msgstr ""
+
+#: src/generics/monomorphization.md:20
+msgid ""
+"enum Option_f64 {\n"
+"    Some(f64),\n"
+"    None,\n"
+"}"
+msgstr ""
+
+#: src/generics/monomorphization.md:25
+msgid ""
+"fn main() {\n"
+"    let integer = Option_i32::Some(5);\n"
+"    let float = Option_f64::Some(5.0);\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/generics/monomorphization.md:31
+msgid ""
+"This is a zero-cost abstraction: you get exactly the same result as if you "
+"had\n"
+"hand-coded the data structures without the abstraction."
+msgstr ""
+"이것은 (런타임)코스트가 들지 않는 추상화입니다: 추상화 없이 직접 코딩한 것과 "
+"정확히 같은 결과입니다."
+
+#: src/generics/trait-objects.md:1
+msgid "# Trait Objects"
+msgstr "# 트레이트 객체"
+
+#: src/generics/trait-objects.md:3
+msgid "We've seen how a function can take arguments which implement a trait:"
+msgstr "트레이트를 구현할 때 인수를 취하는 방법:"
+
+#: src/generics/trait-objects.md:8
+msgid ""
+"fn print<T: Display>(x: T) {\n"
+"    println!(\"Your value: {}\", x);\n"
+"}"
+msgstr ""
+
+#: src/generics/trait-objects.md:12
+msgid ""
+"fn main() {\n"
+"    print(123);\n"
+"    print(\"Hello\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/generics/trait-objects.md:18
+msgid ""
+"However, how can we store a collection of mixed types which implement "
+"`Display`?"
+msgstr "아래와 같이 여러가지 타입을 혼합하여 인수로 받려면 어떻게 해야 합니까?"
+
+#: src/generics/trait-objects.md:20
+msgid ""
+"```rust,editable,compile_fail\n"
+"fn main() {\n"
+"    let xs = vec![123, \"Hello\"];\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/generics/trait-objects.md:26
+msgid "For this, we need _trait objects_:"
+msgstr "이를 위해서 _트레이트 객체가_ 필요합니다:"
+
+#: src/generics/trait-objects.md:31
+msgid ""
+"fn main() {\n"
+"    let xs: Vec<Box<dyn Display>> = vec![Box::new(123), Box::"
+"new(\"Hello\")];\n"
+"    for x in xs {\n"
+"        println!(\"x: {x}\");\n"
+"    }\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/generics/trait-objects.md:39
+msgid "Memory layout after allocating `xs`:"
+msgstr "`xs`가 할당될때 메모리 레이아웃:"
+
+#: src/generics/trait-objects.md:41
+msgid ""
+"```bob\n"
+" Stack                             Heap\n"
+".- - - - - - - - - - - - - -.     .- - - - - - - - - - - - - - - - - - - - - "
+"- - -.\n"
+":                           :     :                                               :\n"
+":    "
+"xs                     :     :                                               :\n"
+":   +-----------+-------+   :     :   +-----+-----"
+"+                               :\n"
+":   | ptr       |   o---+---+-----+-->| o o | o o "
+"|                               :\n"
+":   | len       |     2 |   :     :   +-|-|-+-|-|-"
+"+                               :\n"
+":   | capacity  |     2 |   :     :     | |   | |   +----+----+----+----+----"
+"+    :\n"
+":   +-----------+-------+   :     :     | |   | '-->| H  | e  | l  | l  | o  "
+"|    :\n"
+":                           :     :     | |   |     +----+----+----+----+----"
+"+    :\n"
+"`- - - - - - - - - - - - - -'     :     | |   "
+"|                                   :\n"
+"                                  :     | |   |     "
+"+-------------------------+   :\n"
+"                                  :     | |   '---->| \"<str as Display>::"
+"fmt\" |   :\n"
+"                                  :     | |         "
+"+-------------------------+   :\n"
+"                                  :     | "
+"|                                       :\n"
+"                                  :     | |   +-------------------------"
+"+         :\n"
+"                                  :     | '-->| \"<i32 as Display>::fmt\" "
+"|         :\n"
+"                                  :     |     +-------------------------"
+"+         :\n"
+"                                  :     "
+"|                                         :\n"
+"                                  :     |     +----+----+----+----"
+"+               :\n"
+"                                  :     '---->| 7b | 00 | 00 | 00 "
+"|               :\n"
+"                                  :           +----+----+----+----"
+"+               :\n"
+"                                  :                                               :\n"
+"                                  :                                               :\n"
+"                                  '- - - - - - - - - - - - - - - - - - - - - "
+"- - -'\n"
+"```"
+msgstr ""
+
+#: src/generics/trait-objects.md:69
+msgid ""
+"Similarly, you need a trait object if you want to return different values\n"
+"implementing a trait:"
+msgstr ""
+"마찬가지로 트레이트를 구현한 다른 값을 반환할 때도 트레이트 객체가 필요합니"
+"다:"
+
+#: src/generics/trait-objects.md:72
+msgid ""
+"```rust,editable\n"
+"fn numbers(n: i32) -> Box<dyn Iterator<Item=i32>> {\n"
+"    if n > 0 {\n"
+"        Box::new(0..n)\n"
+"    } else {\n"
+"        Box::new((n..0).rev())\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/generics/trait-objects.md:81
+msgid ""
+"fn main() {\n"
+"    println!(\"{:?}\", numbers(-5).collect::<Vec<_>>());\n"
+"    println!(\"{:?}\", numbers(5).collect::<Vec<_>>());\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-3/morning.md:1
+msgid "# Day 3: Morning Exercises"
+msgstr "# 3일차 오전 연습문제"
+
+#: src/exercises/day-3/morning.md:3
+msgid "We will design a classical GUI library traits and trait objects."
+msgstr ""
+"이번 연습문제에서는 트레이트와 트레이트 객체를 통해 고전적인 GUI라이브러리를 "
+"설계할 것입니다."
+
+#: src/exercises/day-3/simple-gui.md:1
+msgid "# A Simple GUI Library"
+msgstr "# 간단한 GUI 라이브러리"
+
+#: src/exercises/day-3/simple-gui.md:3
+msgid ""
+"Let us design a classical GUI library using our new knowledge of traits and\n"
+"trait objects."
+msgstr ""
+"이번 연습문제에서는 트레이트와 트레이트 객체 지식을 활용하여 고전적인  GUI라"
+"이브러리를 설계할 것입니다."
+
+#: src/exercises/day-3/simple-gui.md:6
+msgid "We will have a number of widgets in our library:"
+msgstr "라이브러리에는 몇가지 위젯이 있습니다:"
+
+#: src/exercises/day-3/simple-gui.md:8
+msgid ""
+"* `Window`: has a `title` and contains other widgets.\n"
+"* `Button`: has a `label` and a callback function which is invoked when the\n"
+"  button is pressed.\n"
+"* `Label`: has a `label`."
+msgstr ""
+"* `Window`: `title` 속성과 다른 위젯이 포함됩니다.\n"
+"* `Button`: `label`위젯과 버튼이 눌렸을때 실행되는 콜백 함수가 있습니다.\n"
+"* `Label`: `label` 위젯 입니다."
+
+#: src/exercises/day-3/simple-gui.md:13
+msgid "The widgets will implement a `Widget` trait, see below."
+msgstr "위젯은 `Widget` 트레이트를 구현합니다. 아래 코드를 참조하세요"
+
+#: src/exercises/day-3/simple-gui.md:15
+msgid ""
+"Copy the code below to <https://play.rust-lang.org/>, fill in the missing\n"
+"`draw_into` methods so that you implement the `Widget` trait:"
+msgstr ""
+"아래 코드를 <https://play.rust-lang.org/>에 복사하고 누락된 `draw_into`메서드"
+"를 채워 넣어 `Widget` 트레이트를 완성해봅시다:"
+
+#: src/exercises/day-3/simple-gui.md:18
+#: src/exercises/day-3/safe-ffi-wrapper.md:25
+msgid ""
+"```rust,should_panic\n"
+"// TODO: remove this when you're done with your implementation.\n"
+"#![allow(unused_imports, unused_variables, dead_code)]"
+msgstr ""
+
+#: src/exercises/day-3/simple-gui.md:22
+msgid ""
+"pub trait Widget {\n"
+"    /// Natural width of `self`.\n"
+"    fn width(&self) -> usize;"
+msgstr ""
+
+#: src/exercises/day-3/simple-gui.md:26
+#: src/exercises/day-3/solutions-morning.md:27
+msgid ""
+"    /// Draw the widget into a buffer.\n"
+"    fn draw_into(&self, buffer: &mut dyn std::fmt::Write);"
+msgstr ""
+
+#: src/exercises/day-3/simple-gui.md:29
+#: src/exercises/day-3/solutions-morning.md:30
+msgid ""
+"    /// Draw the widget on standard output.\n"
+"    fn draw(&self) {\n"
+"        let mut buffer = String::new();\n"
+"        self.draw_into(&mut buffer);\n"
+"        println!(\"{}\", &buffer);\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-3/simple-gui.md:37
+#: src/exercises/day-3/solutions-morning.md:38
+msgid ""
+"pub struct Label {\n"
+"    label: String,\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-3/simple-gui.md:41
+#: src/exercises/day-3/solutions-morning.md:42
+msgid ""
+"impl Label {\n"
+"    fn new(label: &str) -> Label {\n"
+"        Label {\n"
+"            label: label.to_owned(),\n"
+"        }\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-3/simple-gui.md:49
+#: src/exercises/day-3/solutions-morning.md:50
+msgid ""
+"pub struct Button {\n"
+"    label: Label,\n"
+"    callback: Box<dyn FnMut()>,\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-3/simple-gui.md:54
+#: src/exercises/day-3/solutions-morning.md:55
+msgid ""
+"impl Button {\n"
+"    fn new(label: &str, callback: Box<dyn FnMut()>) -> Button {\n"
+"        Button {\n"
+"            label: Label::new(label),\n"
+"            callback,\n"
+"        }\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-3/simple-gui.md:63
+#: src/exercises/day-3/solutions-morning.md:64
+msgid ""
+"pub struct Window {\n"
+"    title: String,\n"
+"    widgets: Vec<Box<dyn Widget>>,\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-3/simple-gui.md:68
+#: src/exercises/day-3/solutions-morning.md:69
+msgid ""
+"impl Window {\n"
+"    fn new(title: &str) -> Window {\n"
+"        Window {\n"
+"            title: title.to_owned(),\n"
+"            widgets: Vec::new(),\n"
+"        }\n"
+"    }"
+msgstr ""
+
+#: src/exercises/day-3/simple-gui.md:76
+#: src/exercises/day-3/solutions-morning.md:77
+msgid ""
+"    fn add_widget(&mut self, widget: Box<dyn Widget>) {\n"
+"        self.widgets.push(widget);\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-3/simple-gui.md:82
+msgid ""
+"impl Widget for Label {\n"
+"    fn width(&self) -> usize {\n"
+"        unimplemented!()\n"
+"    }"
+msgstr ""
+
+#: src/exercises/day-3/simple-gui.md:87 src/exercises/day-3/simple-gui.md:97
+#: src/exercises/day-3/simple-gui.md:107
+msgid ""
+"    fn draw_into(&self, buffer: &mut dyn std::fmt::Write) {\n"
+"        unimplemented!()\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-3/simple-gui.md:92
+msgid ""
+"impl Widget for Button {\n"
+"    fn width(&self) -> usize {\n"
+"        unimplemented!()\n"
+"    }"
+msgstr ""
+
+#: src/exercises/day-3/simple-gui.md:102
+msgid ""
+"impl Widget for Window {\n"
+"    fn width(&self) -> usize {\n"
+"        unimplemented!()\n"
+"    }"
+msgstr ""
+
+#: src/exercises/day-3/simple-gui.md:112
+msgid ""
+"fn main() {\n"
+"    let mut window = Window::new(\"Rust GUI Demo 1.23\");\n"
+"    window.add_widget(Box::new(Label::new(\"This is a small text GUI demo."
+"\")));\n"
+"    window.add_widget(Box::new(Button::new(\n"
+"        \"Click me!\",\n"
+"        Box::new(|| println!(\"You clicked the button!\")),\n"
+"    )));\n"
+"    window.draw();\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/exercises/day-3/simple-gui.md:123
+msgid "The output of the above program can be something simple like this:"
+msgstr "위 프로그램의 출력은 아래와 같습니다:"
+
+#: src/exercises/day-3/simple-gui.md:125
+msgid ""
+"```text\n"
+"========\n"
+"Rust GUI Demo 1.23\n"
+"========"
+msgstr ""
+
+#: src/exercises/day-3/simple-gui.md:130
+msgid "This is a small text GUI demo."
+msgstr ""
+
+#: src/exercises/day-3/simple-gui.md:132
+msgid ""
+"| Click me! |\n"
+"```"
+msgstr ""
+
+#: src/exercises/day-3/simple-gui.md:135
+msgid ""
+"If you want to draw aligned text, you can use the\n"
+"[fill/alignment](https://doc.rust-lang.org/std/fmt/index."
+"html#fillalignment)\n"
+"formatting operators. In particular, notice how you can pad with different\n"
+"characters (here a `'/'`) and how you can control alignment:"
+msgstr ""
+"정렬된 글자를 그리기 위해서는 [fill/alignment](https://doc.rust-lang.org/std/"
+"fmt/index.html#fillalignment)를 참조하시기 바랍니다. \n"
+"특수 문자(여기서는 '/')로 패딩을 주는 방법과 정렬을 제어하는 방법을 확인하시"
+"기 바랍니다."
+
+#: src/exercises/day-3/simple-gui.md:140
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let width = 10;\n"
+"    println!(\"left aligned:  |{:/<width$}|\", \"foo\");\n"
+"    println!(\"centered:      |{:/^width$}|\", \"foo\");\n"
+"    println!(\"right aligned: |{:/>width$}|\", \"foo\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/exercises/day-3/simple-gui.md:149
+msgid ""
+"Using such alignment tricks, you can for example produce output like this:"
+msgstr "위의 정렬 트릭을 사용하여 다음과 같은 출력을 생성할 수 있습니다."
+
+#: src/exercises/day-3/simple-gui.md:151
+msgid ""
+"```text\n"
+"+--------------------------------+\n"
+"|       Rust GUI Demo 1.23       |\n"
+"+================================+\n"
+"| This is a small text GUI demo. |\n"
+"| +-----------+                  |\n"
+"| | Click me! |                  |\n"
+"| +-----------+                  |\n"
+"+--------------------------------+\n"
+"```"
+msgstr ""
+
+#: src/error-handling.md:1
+msgid "# Error Handling"
+msgstr "# 오류처리"
+
+#: src/error-handling.md:3
+msgid "Error handling in Rust is done using explicit control flow:"
+msgstr "러스트의 오류 처리는 명시적인 흐름제어로 처리됩니다:"
+
+#: src/error-handling.md:5
+msgid ""
+"* Functions that can have errors list this in their return type,\n"
+"* There are no exceptions."
+msgstr ""
+"* 오류를 발생할 수 있는 함수는 반환 타입에 명시합니다. \n"
+"* 예외는 없습니다."
+
+#: src/error-handling/panics.md:1
+msgid "# Panics"
+msgstr "# 패닉"
+
+#: src/error-handling/panics.md:3
+msgid "Rust will trigger a panic if a fatal error happens at runtime:"
+msgstr "러스트는 런타임에서 치명적인 오류를 만나면 패닉을 발생할 것입니다:"
+
+#: src/error-handling/panics.md:5
+msgid ""
+"```rust,editable,should_panic\n"
+"fn main() {\n"
+"    let v = vec![10, 20, 30];\n"
+"    println!(\"v[100]: {}\", v[100]);\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/error-handling/panics.md:12
+msgid ""
+"* Panics are for unrecoverable and unexpected errors.\n"
+"  * Panics are symptoms of bugs in the program.\n"
+"* Use non-panicking APIs (such as `Vec::get`) if crashing is not acceptable."
+msgstr ""
+"* 패닉은 복구할 수 없고 예상치 못한 오류입니다.\n"
+"  * 패닉은 프로그램 버그의 증상입니다.\n"
+"* 충돌(크래시)를 허용하지 않아야 하는 경우 패닉을 유발하지 않는(non-"
+"panicking) API를 사용합니다.(`Vec::get` 등)"
+
+#: src/error-handling/panic-unwind.md:1
+msgid "# Catching the Stack Unwinding"
+msgstr "# 스택 해제 추적"
+
+#: src/error-handling/panic-unwind.md:3
+msgid ""
+"By default, a panic will cause the stack to unwind. The unwinding can be "
+"caught:"
+msgstr ""
+"기본적으로, 패닉이 발생하면 스택은 해제됩니다. 스택 해제는 다음과 같이 캐치"
+"가 가능합니다: "
+
+#: src/error-handling/panic-unwind.md:5
+msgid ""
+"```rust\n"
+"use std::panic;"
+msgstr ""
+
+#: src/error-handling/panic-unwind.md:8
+msgid ""
+"let result = panic::catch_unwind(|| {\n"
+"    println!(\"hello!\");\n"
+"});\n"
+"assert!(result.is_ok());"
+msgstr ""
+
+#: src/error-handling/panic-unwind.md:13
+msgid ""
+"let result = panic::catch_unwind(|| {\n"
+"    panic!(\"oh no!\");\n"
+"});\n"
+"assert!(result.is_err());\n"
+"```"
+msgstr ""
+
+#: src/error-handling/panic-unwind.md:19
+msgid ""
+"* This can be useful in servers which should keep running even if a single\n"
+"  request crashes.\n"
+"* This does not work if `panic = abort` is set in your `Cargo.toml`."
+msgstr ""
+"* 이것은 단일 요청이 크래시 되더라도 계속 실행되야 하는 서버에 유용합니다.\n"
+"*  `Cargo.toml`설정파일에 `panic = abort`을 설정하면 동작하지 않습니다."
+
+#: src/error-handling/result.md:1
+msgid "# Structured Error Handling with `Result`"
+msgstr "# 구조화된 오류처리"
+
+#: src/error-handling/result.md:3
+msgid ""
+"We have already seen the `Result` enum. This is used pervasively when errors "
+"are\n"
+"expected as part of normal operation:"
+msgstr "`Result` enum은 흔히 오류를 예상되는 경우 사용됩니다: "
+
+#: src/error-handling/result.md:6
+msgid ""
+"```rust\n"
+"use std::fs::File;\n"
+"use std::io::Read;"
+msgstr ""
+
+#: src/error-handling/result.md:10
+msgid ""
+"fn main() {\n"
+"    let file = File::open(\"diary.txt\");\n"
+"    match file {\n"
+"        Ok(mut file) => {\n"
+"            let mut contents = String::new();\n"
+"            file.read_to_string(&mut contents);\n"
+"            println!(\"Dear diary: {contents}\");\n"
+"        },\n"
+"        Err(err) => {\n"
+"            println!(\"The diary could not be opened: {err}\");\n"
+"        }\n"
+"    }\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/error-handling/try-operator.md:1
+msgid "# Propagating Errors with `?`"
+msgstr "# '?'를 이용한 오류 전파"
+
+#: src/error-handling/try-operator.md:3
+msgid ""
+"The try-operator `?` is used to return errors to the caller. It lets you "
+"turn\n"
+"the common"
+msgstr "시도(시행)연산자 `?`는 호출자에게 오류를 반환할 때 사용합니다. "
+
+#: src/error-handling/try-operator.md:6
+msgid ""
+"```rust,ignore\n"
+"match some_expression {\n"
+"    Ok(value) => value,\n"
+"    Err(err) => return Err(err),\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/error-handling/try-operator.md:13
+msgid "into the much simpler"
+msgstr "훨씬 간단한 방식으로"
+
+#: src/error-handling/try-operator.md:15
+msgid ""
+"```rust,ignore\n"
+"some_expression?\n"
+"```"
+msgstr ""
+
+#: src/error-handling/try-operator.md:19
+msgid "We can use this to simplify our error handing code:"
+msgstr "이를 사용하면 오류를 처리할 수 단순화 할 수 있습니다:"
+
+#: src/error-handling/try-operator.md:21
+msgid ""
+"```rust,editable\n"
+"use std::fs;\n"
+"use std::io::{self, Read};"
+msgstr ""
+
+#: src/error-handling/try-operator.md:25
+msgid ""
+"fn read_username(path: &str) -> Result<String, io::Error> {\n"
+"    let username_file_result = fs::File::open(path);"
+msgstr ""
+
+#: src/error-handling/try-operator.md:28
+msgid ""
+"    let mut username_file = match username_file_result {\n"
+"        Ok(file) => file,\n"
+"        Err(e) => return Err(e),\n"
+"    };"
+msgstr ""
+
+#: src/error-handling/try-operator.md:33
+msgid "    let mut username = String::new();"
+msgstr ""
+
+#: src/error-handling/try-operator.md:35
+msgid ""
+"    match username_file.read_to_string(&mut username) {\n"
+"        Ok(_) => Ok(username),\n"
+"        Err(e) => Err(e),\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/error-handling/try-operator.md:41
+msgid ""
+"fn main() {\n"
+"    //fs::write(\"config.dat\", \"alice\").unwrap();\n"
+"    let username = read_username(\"config.dat\");\n"
+"    println!(\"username or error: {username:?}\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/error-handling/converting-error-types.md:1
+msgid "# Converting Error Types"
+msgstr "# 오류타입 변환"
+
+#: src/error-handling/converting-error-types.md:3
+msgid ""
+"The effective expansion of `?` is a little more complicated than previously "
+"indicated:"
+msgstr "`?`의 효과적인 적용은 좀 더 복잡하긴 합니다:"
+
+#: src/error-handling/converting-error-types.md:5
+msgid ""
+"```rust,ignore\n"
+"expression?\n"
+"```"
+msgstr ""
+
+#: src/error-handling/converting-error-types.md:9
+msgid "works the same as"
+msgstr "위 표현은 아래와 같습니다."
+
+#: src/error-handling/converting-error-types.md:11
+msgid ""
+"```rust,ignore\n"
+"match expression {\n"
+"    Ok(value) => value,\n"
+"    Err(err)  => return Err(From::from(err)),\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/error-handling/converting-error-types.md:18
+msgid ""
+"The `From::from` call here means we attempt to convert the error type to "
+"the\n"
+"type returned by the function:"
+msgstr "`From::from` 호출은 오류타입을 함수에서 반환하는 타입으로 변환합니다: "
+
+#: src/error-handling/converting-error-types.md:21
+msgid ""
+"```rust,editable\n"
+"use std::{fs, io};\n"
+"use std::io::Read;"
+msgstr ""
+
+#: src/error-handling/converting-error-types.md:25
+msgid ""
+"#[derive(Debug)]\n"
+"enum ReadUsernameError {\n"
+"    IoError(io::Error),\n"
+"    EmptyUsername(String),\n"
+"}"
+msgstr ""
+
+#: src/error-handling/converting-error-types.md:31
+msgid ""
+"impl From<io::Error> for ReadUsernameError {\n"
+"    fn from(err: io::Error) -> ReadUsernameError {\n"
+"        ReadUsernameError::IoError(err)\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/error-handling/converting-error-types.md:37
+#: src/error-handling/deriving-error-enums.md:19
+msgid ""
+"fn read_username(path: &str) -> Result<String, ReadUsernameError> {\n"
+"    let mut username = String::with_capacity(100);\n"
+"    fs::File::open(path)?.read_to_string(&mut username)?;\n"
+"    if username.is_empty() {\n"
+"        return Err(ReadUsernameError::EmptyUsername(String::from(path)));\n"
+"    }\n"
+"    Ok(username)\n"
+"}"
+msgstr ""
+
+#: src/error-handling/converting-error-types.md:46
+msgid ""
+"fn main() {\n"
+"    //fs::write(\"config.dat\", \"\").unwrap();\n"
+"    let username = read_username(\"config.dat\");\n"
+"    println!(\"username or error: {username:?}\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/error-handling/deriving-error-enums.md:1
+msgid "# Deriving Error Enums"
+msgstr "# 파생 오류 Enums"
+
+#: src/error-handling/deriving-error-enums.md:3
+msgid ""
+"The [thiserror](https://docs.rs/thiserror/) crate is a popular way to create "
+"an\n"
+"error enum like we did on the previous page:"
+msgstr ""
+"[thiserror](https://docs.rs/thiserror/) 크레이트는 전페이지에서 처럼 \n"
+"오류 enum을 만드는 일반적인 방법입니다."
+
+#: src/error-handling/deriving-error-enums.md:6
+msgid ""
+"```rust,editable,compile_fail\n"
+"use std::{fs, io};\n"
+"use std::io::Read;\n"
+"use thiserror::Error;"
+msgstr ""
+
+#: src/error-handling/deriving-error-enums.md:11
+msgid ""
+"#[derive(Error, Debug)]\n"
+"enum ReadUsernameError {\n"
+"    #[error(\"Could not read: {0}\")]\n"
+"    IoError(#[from] io::Error),\n"
+"    #[error(\"Found no username in {0}\")]\n"
+"    EmptyUsername(String),\n"
+"}"
+msgstr ""
+
+#: src/error-handling/deriving-error-enums.md:28
+msgid ""
+"fn main() {\n"
+"    //fs::write(\"config.dat\", \"\").unwrap();\n"
+"    match read_username(\"config.dat\") {\n"
+"        Ok(username) => println!(\"Username: {username}\"),\n"
+"        Err(err)     => println!(\"Error: {err}\"),\n"
+"    }\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/error-handling/error-contexts.md:1
+msgid "# Adding Context to Errors"
+msgstr "# 오류에 상황정보 추가"
+
+#: src/error-handling/error-contexts.md:3
+msgid ""
+"The widely used [anyhow](https://docs.rs/anyhow/) crate can help you add\n"
+"contextual information to your errors and allows you to have fewer\n"
+"custom error types:"
+msgstr ""
+"[anyhow](https://docs.rs/anyhow/) 크레이트는 오류에 대한 상황정보를 추가하기 "
+"위해 널리 사용되며 사용자 정의 오류 유형을 줄일 수 있습니다: "
+
+#: src/error-handling/error-contexts.md:7
+msgid ""
+"```rust,editable,compile_fail\n"
+"use std::{fs, io};\n"
+"use std::io::Read;\n"
+"use thiserror::Error;\n"
+"use anyhow::{Context, Result};"
+msgstr ""
+
+#: src/error-handling/error-contexts.md:13
+msgid ""
+"#[derive(Error, Debug)]\n"
+"enum ReadUsernameError {\n"
+"    #[error(\"Found no username in {0}\")]\n"
+"    EmptyUsername(String),\n"
+"}"
+msgstr ""
+
+#: src/error-handling/error-contexts.md:19
+msgid ""
+"fn read_username(path: &str) -> Result<String> {\n"
+"    let mut username = String::with_capacity(100);\n"
+"    fs::File::open(path)\n"
+"        .context(format!(\"Failed to open {path}\"))?\n"
+"        .read_to_string(&mut username)\n"
+"        .context(\"Failed to read\")?;\n"
+"    if username.is_empty() {\n"
+"        return Err(ReadUsernameError::EmptyUsername(String::from(path)))?;\n"
+"    }\n"
+"    Ok(username)\n"
+"}"
+msgstr ""
+
+#: src/error-handling/error-contexts.md:31
+msgid ""
+"fn main() {\n"
+"    //fs::write(\"config.dat\", \"\").unwrap();\n"
+"    match read_username(\"config.dat\") {\n"
+"        Ok(username) => println!(\"Username: {username}\"),\n"
+"        Err(err)     => println!(\"Error: {err:?}\"),\n"
+"    }\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/testing.md:1
+msgid "# Testing"
+msgstr "# 테스트"
+
+#: src/testing.md:3
+msgid "Rust and Cargo come with a simple unit test framework:"
+msgstr "러스트와 카고(cargo)는 간단한 테스트 프레임워크와 함께 제공됩니다:"
+
+#: src/testing.md:5
+msgid "* Unit tests are supported throughout your code."
+msgstr "* 단위 테스트는 코드 전반에서 지원됩니다."
+
+#: src/testing.md:7
+msgid "* Integration tests are supported via the `tests/` directory."
+msgstr "* 통합테스트는 `test/` 폴더를 통해 지원됩니다."
+
+#: src/testing/unit-tests.md:1
+msgid "# Unit Tests"
+msgstr "# 단위 테스트"
+
+#: src/testing/unit-tests.md:3
+msgid "Mark unit tests with `#[test]`:"
+msgstr "단위 테스트는 `#[test]` 표기로 이뤄집니다:"
+
+#: src/testing/unit-tests.md:5
+msgid ""
+"```rust,editable\n"
+"fn first_word(text: &str) -> &str {\n"
+"    match text.find(' ') {\n"
+"        Some(idx) => &text[..idx],\n"
+"        None => &text,\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/testing/unit-tests.md:13
+msgid ""
+"#[test]\n"
+"fn test_empty() {\n"
+"    assert_eq!(first_word(\"\"), \"\");\n"
+"}"
+msgstr ""
+
+#: src/testing/unit-tests.md:18
+msgid ""
+"#[test]\n"
+"fn test_single_word() {\n"
+"    assert_eq!(first_word(\"Hello\"), \"Hello\");\n"
+"}"
+msgstr ""
+
+#: src/testing/unit-tests.md:23
+msgid ""
+"#[test]\n"
+"fn test_multiple_words() {\n"
+"    assert_eq!(first_word(\"Hello World\"), \"Hello\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/testing/unit-tests.md:29
+msgid "Use `cargo test` to find and run the unit tests."
+msgstr "`cargo test` 커맨드를 사용하면 단위 테스트를 찾아서 실행합니다."
+
+#: src/testing/test-modules.md:1
+msgid "# Test Modules"
+msgstr "# 테스트모듈"
+
+#: src/testing/test-modules.md:3
+msgid ""
+"Unit tests are often put in a nested module (run tests on the\n"
+"[Playground](https://play.rust-lang.org/)):"
+msgstr ""
+"단위 테스트는 종종 중첩 모듈 안에 존재합니다. [플레이그라운드](https://play."
+"rust-lang.org/)에서 실행하시기 바랍니다)  \n"
+"--> 단위 테스트는 모듈로 분리해서 선언 가능합니다."
+
+#: src/testing/test-modules.md:6
+msgid ""
+"```rust,editable\n"
+"fn helper(a: &str, b: &str) -> String {\n"
+"    format!(\"{a} {b}\")\n"
+"}"
+msgstr ""
+
+#: src/testing/test-modules.md:11
+msgid ""
+"pub fn main() {\n"
+"    println!(\"{}\", helper(\"Hello\", \"World\"));\n"
+"}"
+msgstr ""
+
+#: src/testing/test-modules.md:19
+msgid ""
+"    #[test]\n"
+"    fn test_helper() {\n"
+"        assert_eq!(helper(\"foo\", \"bar\"), \"foo bar\");\n"
+"    }\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/testing/test-modules.md:26
+msgid ""
+"* This lets you unit test private helpers.\n"
+"* The `#[cfg(test)]` attribute is only active when you run `cargo test`."
+msgstr ""
+"* 개별화된 헬퍼모듈을 통해 단위테스트를 수행할 수 있습니다.\n"
+"* `#[cfg(test)]` 속성은 오직 `cargo test` 커맨드 실행인 경우에만 동작합니다."
+
+#: src/testing/doc-tests.md:1
+msgid "# Documentation Tests"
+msgstr "문서화 테스트"
+
+#: src/testing/doc-tests.md:3
+msgid "Rust has built-in support for documentation tests:"
+msgstr "러스트는 문서화 테스트를 내장하여 제공합니다:"
+
+#: src/testing/doc-tests.md:5
+msgid ""
+"```rust\n"
+"/// Shorten string will trip the string to the given length.\n"
+"///\n"
+"/// ```\n"
+"/// use playground::shorten_string;\n"
+"/// assert_eq!(shorten_string(\"Hello World\", 5), \"Hello\");\n"
+"/// assert_eq!(shorten_string(\"Hello World\", 20), \"Hello World\");\n"
+"/// ```\n"
+"pub fn shorten_string(s: &str, length: usize) -> &str {\n"
+"    &s[..std::cmp::min(length, s.len())]\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/testing/doc-tests.md:18
+msgid ""
+"* Code blocks in `///` comments are automatically seen as Rust code.\n"
+"* The code will be compiled and executed as part of `cargo test`.\n"
+"* Test the above code on the [Rust Playground](https://play.rust-lang.org/?"
+"version=stable&mode=debug&edition=2021&gist=c8ce535a3778218fed50c2b4c317d15d)."
+msgstr ""
+"* `///` 주석안의 코드 블록은 자동으로 러스트 코드로 인식됩니다.\n"
+"* 코드 블록은 `cargo test` 커맨드 구동시 컴파일되고 실행됩니다.\n"
+"* 위 코드를 테스트 해 보시기 바랍니다.[Rust Playground](https://play.rust-"
+"lang.org/?"
+"version=stable&mode=debug&edition=2021&gist=c8ce535a3778218fed50c2b4c317d15d)."
+
+#: src/testing/integration-tests.md:1
+msgid "# Integration Tests"
+msgstr "# 통합 테스트"
+
+#: src/testing/integration-tests.md:3
+msgid "If you want to test your library as a client, use an integration test."
+msgstr ""
+"라이브러리를 실제 테스트 하기위한 통합테스트는 `test/` 폴더 내에 `.rs`를 작성"
+"하여 수행합니다: "
+
+#: src/testing/integration-tests.md:5
+msgid "Create a `.rs` file under `tests/`:"
+msgstr " "
+
+#: src/testing/integration-tests.md:7
+msgid ""
+"```rust,ignore\n"
+"use my_library::init;"
+msgstr ""
+
+#: src/testing/integration-tests.md:10
+msgid ""
+"#[test]\n"
+"fn test_init() {\n"
+"    assert!(init().is_ok());\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/testing/integration-tests.md:16
+msgid "These tests only have access to the public API of your crate."
+msgstr "이 테스트는 크레이트의 공개 API에만 접근할 수 있습니다."
+
+#: src/unsafe.md:1
+msgid "# Unsafe Rust"
+msgstr "# 안전하지 않은 러스트"
+
+#: src/unsafe.md:3
+msgid "The Rust language has two parts:"
+msgstr "러스트의 문법은 크게 두가지 부분으로 나뉩니다:"
+
+#: src/unsafe.md:5
+msgid ""
+"* **Safe Rust:** memory safe, no undefined behavior possible.\n"
+"* **Unsafe Rust:** can trigger undefined behavior if preconditions are "
+"violated."
+msgstr ""
+"* **안전한 러스트:** 안전한 메모리, 정의되지 않은 동작 가능성 없음.\n"
+"* **안전하지 않은 러스트:** 사전 조건을 위반하는 경우 정의되지 않은 동작을   "
+"수행할 수 있습니다."
+
+#: src/unsafe.md:8
+msgid ""
+"We will be seeing mostly safe Rust in this course, but it's important to "
+"know\n"
+"what Unsafe Rust is."
+msgstr ""
+"이 강의는 대부분 안전한 러스트에 대해 다루지만 **안전하지 않은 러스트가** 무"
+"엇인지는 알아 두어야 합니다."
+
+#: src/unsafe.md:11
+msgid "Unsafe Rust gives you access to five new capabilities:"
+msgstr "안전하지 않은 러스트는 다음과 같은 5가지 새로운 기능을 제공합니다:"
+
+#: src/unsafe.md:13
+msgid ""
+"* Dereference raw pointers.\n"
+"* Access or modify mutable static variables.\n"
+"* Access `union` fields.\n"
+"* Call `unsafe` functions, including `extern` functions.\n"
+"* Implement `unsafe` traits."
+msgstr ""
+"* 원시포인트 역참조\n"
+"* 정적 가변변수 접근 및 수정\n"
+"* `union` 필드 접근\n"
+"* `extern` 함수를 포함한 `unsafe` 함수 호출\n"
+"* `unsafe` 트레이트 구현"
+
+#: src/unsafe.md:19
+msgid ""
+"We will briefly cover these capabilities next. For full details, please see\n"
+"[Chapter 19.1 in the Rust Book](https://doc.rust-lang.org/book/ch19-01-"
+"unsafe-rust.html)\n"
+"and the [Rustonomicon](https://doc.rust-lang.org/nomicon/)."
+msgstr ""
+"위 기능에 대해 간략히 살펴보겠습니다. 자세한 내용은 [Chapter 19.1 in the "
+"Rust Book](https://doc.rust-lang.org/book/ch19-01-unsafe-rust.html)\n"
+"와 [Rustonomicon](https://doc.rust-lang.org/nomicon/)를 참조하세요"
+
+#: src/unsafe/raw-pointers.md:1
+msgid "# Dereferencing Raw Pointers"
+msgstr "원시포인트 역참조"
+
+#: src/unsafe/raw-pointers.md:3
+msgid "Creating pointers is safe, but dereferencing them requires `unsafe`:"
+msgstr "포인트 생성은 안전합니다. 하지만 역참조할 경우 `unsafe`가 필요합니다:"
+
+#: src/unsafe/raw-pointers.md:5
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let mut num = 5;"
+msgstr ""
+
+#: src/unsafe/raw-pointers.md:9
+msgid ""
+"    let r1 = &mut num as *mut i32;\n"
+"    let r2 = &num as *const i32;"
+msgstr ""
+
+#: src/unsafe/raw-pointers.md:12
+msgid ""
+"    unsafe {\n"
+"        println!(\"r1 is: {}\", *r1);\n"
+"        *r1 = 10;  // Data race if r1 is being written concurrently!\n"
+"        println!(\"r2 is: {}\", *r2);\n"
+"    }\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/unsafe/mutable-static-variables.md:1
+msgid "# Mutable Static Variables"
+msgstr "# 정적 가변 변수"
+
+#: src/unsafe/mutable-static-variables.md:3
+msgid "It is safe to read an immutable static variable:"
+msgstr "불변 정적변수를 읽는 것은 '안전'합니다:"
+
+#: src/unsafe/mutable-static-variables.md:5
+msgid ""
+"```rust,editable\n"
+"static HELLO_WORLD: &str = \"Hello, world!\";"
+msgstr ""
+
+#: src/unsafe/mutable-static-variables.md:8
+msgid ""
+"fn main() {\n"
+"    println!(\"name is: {}\", HELLO_WORLD);\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/unsafe/mutable-static-variables.md:13
+msgid ""
+"However, since data races can occur, it is unsafe to read and write mutable\n"
+"static variables:"
+msgstr ""
+"하지만, 데이터 레이스가 발생할 수 있으므로 정적 가변변수를 읽고 쓰는 것은 '안"
+"전하지 않습니다':"
+
+#: src/unsafe/mutable-static-variables.md:16
+msgid ""
+"```rust,editable\n"
+"static mut COUNTER: u32 = 0;"
+msgstr ""
+
+#: src/unsafe/mutable-static-variables.md:19
+msgid ""
+"fn add_to_counter(inc: u32) {\n"
+"    unsafe { COUNTER += inc; }  // Potential data race!\n"
+"}"
+msgstr ""
+
+#: src/unsafe/mutable-static-variables.md:23
+msgid ""
+"fn main() {\n"
+"    add_to_counter(42);"
+msgstr ""
+
+#: src/unsafe/mutable-static-variables.md:26
+msgid ""
+"    unsafe { println!(\"COUNTER: {}\", COUNTER); }  // Potential data race!\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/unsafe/unsafe-functions.md:1
+msgid "# Calling Unsafe Functions"
+msgstr "# '안전하지 않은' 함수 호출"
+
+#: src/unsafe/unsafe-functions.md:3
+msgid ""
+"A function or method can be marked `unsafe` if it has extra preconditions "
+"you\n"
+"must uphold:"
+msgstr ""
+"다음과 같은 추가 전제 조건이 있는 경우 함수나 메서드는 `unsafe` 표시할 수 있"
+"습니다:"
+
+#: src/unsafe/unsafe-functions.md:6
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let emojis = \"🗻∈🌏\";\n"
+"    unsafe {\n"
+"        // Undefined behavior if indices do not lie on UTF-8 sequence "
+"boundaries.\n"
+"        println!(\"{}\", emojis.get_unchecked(0..4));\n"
+"        println!(\"{}\", emojis.get_unchecked(4..7));\n"
+"        println!(\"{}\", emojis.get_unchecked(7..11));\n"
+"    }\n"
+"}\n"
+"```"
+msgstr ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let emojis = \"🗻∈🌏\";\n"
+"    unsafe {\n"
+"        // 인덱스가 UTF-8 시퀀스 경계에 있지 않은경우 정의되지 않은"
+"(undefined) 동작입니다.\n"
+"        println!(\"{}\", emojis.get_unchecked(0..4));\n"
+"        println!(\"{}\", emojis.get_unchecked(4..7));\n"
+"        println!(\"{}\", emojis.get_unchecked(7..11));\n"
+"    }\n"
+"}\n"
+"```"
+
+#: src/unsafe/extern-functions.md:1
+msgid "# Calling External Code"
+msgstr "# 외부 코드 호출(Calling External Code)"
+
+#: src/unsafe/extern-functions.md:3
+msgid ""
+"Functions from other languages might violate the guarantees of Rust. "
+"Calling\n"
+"them is thus unsafe:"
+msgstr ""
+"다른 언어의 함수는 러스트의 보증을 위반할 수 있습니다. 따라서 이를 호출하는 "
+"것은 '안전하지 않습니다':"
+
+#: src/unsafe/extern-functions.md:6
+msgid ""
+"```rust,editable\n"
+"extern \"C\" {\n"
+"    fn abs(input: i32) -> i32;\n"
+"}"
+msgstr ""
+
+#: src/unsafe/extern-functions.md:11
+msgid ""
+"fn main() {\n"
+"    unsafe {\n"
+"        // Undefined behavior if abs misbehaves.\n"
+"        println!(\"Absolute value of -3 according to C: {}\", abs(-3));\n"
+"    }\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/unsafe/unions.md:1
+msgid "# Unions"
+msgstr ""
+
+#: src/unsafe/unions.md:3
+msgid "Unions are like enums, but you need to track the active field yourself:"
+msgstr "유니온타입은 열거형(enum)과 같지만 직접 활성 필드를 추척해야 합니다:"
+
+#: src/unsafe/unions.md:5
+msgid ""
+"```rust,editable\n"
+"#[repr(C)]\n"
+"union MyUnion {\n"
+"    i: u8,\n"
+"    b: bool,\n"
+"}"
+msgstr ""
+
+#: src/unsafe/unions.md:12
+msgid ""
+"fn main() {\n"
+"    let u = MyUnion { i: 42 };\n"
+"    println!(\"int: {}\", unsafe { u.i });\n"
+"    println!(\"bool: {}\", unsafe { u.b });  // Undefined behavior!\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/exercises/day-3/afternoon.md:1
+msgid "# Day 3: Afternoon Exercises"
+msgstr "# 3일차 오후 연습문제"
+
+#: src/exercises/day-3/afternoon.md:3
+msgid "Let us build a safe wrapper for reading directory content!"
+msgstr ""
+"이번 연습문제에서는 파일 폴더를 안전하게 읽을 수 있는 래퍼를 만들어 봅니다."
+
+#: src/exercises/day-3/safe-ffi-wrapper.md:1
+msgid "# Safe FFI Wrapper"
+msgstr "# FFI래퍼"
+
+#: src/exercises/day-3/safe-ffi-wrapper.md:3
+msgid ""
+"Rust has great support for calling functions through a _foreign function\n"
+"interface_ (FFI). We will use this to build a safe wrapper the `glibc` "
+"functions\n"
+"you would use from C to read the filenames of a directory."
+msgstr ""
+"러스트는 _외부 기능 호출(FFI)_을 지원합니다. 이를 이용하여 C에서 사용할 폴더 "
+"내 파일이름을 읽어오는 `glibc`함수를  만들 것입니다."
+
+#: src/exercises/day-3/safe-ffi-wrapper.md:7
+msgid "You will want to consult the manual pages:"
+msgstr "아래 리눅스 메뉴얼 문서들을 참조하시기 바랍니다:"
+
+#: src/exercises/day-3/safe-ffi-wrapper.md:9
+msgid ""
+"* [`opendir(3)`](https://man7.org/linux/man-pages/man3/opendir.3.html)\n"
+"* [`readdir(3)`](https://man7.org/linux/man-pages/man3/readdir.3.html)\n"
+"* [`closedir(3)`](https://man7.org/linux/man-pages/man3/closedir.3.html)"
+msgstr ""
+
+#: src/exercises/day-3/safe-ffi-wrapper.md:13
+msgid ""
+"You will also want to browse the [`std::ffi`] module, particular for "
+"[`CStr`]\n"
+"and [`CString`] types which are used to hold NUL-terminated strings coming "
+"from\n"
+"C. The [Nomicon] also has a very useful chapter about FFI."
+msgstr ""
+"C에서 오는 NUL-terminated 문자열을 보유하는 [`CStr`]과 [`CString`] 타입 등"
+"을  확인 하기 위해 또한 `std::ffi`모듈을 탐색할 수도 있습니다. [Nomicon]문서 "
+"또한 FFI에 대한 유용한 내용을 담고 있습니다."
+
+#: src/exercises/day-3/safe-ffi-wrapper.md:17
+msgid ""
+"[`std::ffi`]: https://doc.rust-lang.org/std/ffi/\n"
+"[`CStr`]: https://doc.rust-lang.org/std/ffi/struct.CStr.html\n"
+"[`CString`]: https://doc.rust-lang.org/std/ffi/struct.CString.html\n"
+"[Nomicon]: https://doc.rust-lang.org/nomicon/ffi.html"
+msgstr ""
+
+#: src/exercises/day-3/safe-ffi-wrapper.md:22
+msgid ""
+"Copy the code below to <https://play.rust-lang.org/> and fill in the "
+"missing\n"
+"functions and methods:"
+msgstr ""
+"아래 코드를 <https://play.rust-lang.org/>에 복사하고 빠진 함수와 메서드를 채"
+"워봅니다."
+
+#: src/exercises/day-3/safe-ffi-wrapper.md:29
+msgid ""
+"mod ffi {\n"
+"    use std::os::raw::{c_char, c_int, c_long, c_ulong, c_ushort};"
+msgstr ""
+
+#: src/exercises/day-3/safe-ffi-wrapper.md:32
+#: src/exercises/day-3/solutions-afternoon.md:26
+msgid ""
+"    // Opaque type. See https://doc.rust-lang.org/nomicon/ffi.html.\n"
+"    #[repr(C)]\n"
+"    pub struct DIR {\n"
+"        _data: [u8; 0],\n"
+"        _marker: core::marker::PhantomData<(*mut u8, core::marker::"
+"PhantomPinned)>,\n"
+"    }"
+msgstr ""
+
+#: src/exercises/day-3/safe-ffi-wrapper.md:39
+#: src/exercises/day-3/solutions-afternoon.md:33
+msgid ""
+"    // Layout as per readdir(3) and definitions in /usr/include/x86_64-linux-"
+"gnu.\n"
+"    #[repr(C)]\n"
+"    pub struct dirent {\n"
+"        pub d_ino: c_long,\n"
+"        pub d_off: c_ulong,\n"
+"        pub d_reclen: c_ushort,\n"
+"        pub d_type: c_char,\n"
+"        pub d_name: [c_char; 256],\n"
+"    }"
+msgstr ""
+
+#: src/exercises/day-3/safe-ffi-wrapper.md:49
+#: src/exercises/day-3/solutions-afternoon.md:43
+msgid ""
+"    extern \"C\" {\n"
+"        pub fn opendir(s: *const c_char) -> *mut DIR;\n"
+"        pub fn readdir(s: *mut DIR) -> *const dirent;\n"
+"        pub fn closedir(s: *mut DIR) -> c_int;\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-3/safe-ffi-wrapper.md:56
+#: src/exercises/day-3/solutions-afternoon.md:50
+msgid ""
+"use std::ffi::{CStr, CString, OsStr, OsString};\n"
+"use std::os::unix::ffi::OsStrExt;"
+msgstr ""
+
+#: src/exercises/day-3/safe-ffi-wrapper.md:59
+msgid ""
+"#[derive(Debug)]\n"
+"struct DirectoryIterator {\n"
+"    path: CString,\n"
+"    dir: *mut ffi::DIR,\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-3/safe-ffi-wrapper.md:65
+msgid ""
+"impl DirectoryIterator {\n"
+"    fn new(path: &str) -> Result<DirectoryIterator, String> {\n"
+"        // Call opendir and return a Ok value if that worked,\n"
+"        // otherwise return Err with a message.\n"
+"        unimplemented!()\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-3/safe-ffi-wrapper.md:73
+msgid ""
+"impl Iterator for DirectoryIterator {\n"
+"    type Item = OsString;\n"
+"    fn next(&mut self) -> Option<OsString> {\n"
+"        // Keep calling readdir until we get a NULL pointer back.\n"
+"        unimplemented!()\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-3/safe-ffi-wrapper.md:81
+msgid ""
+"impl Drop for DirectoryIterator {\n"
+"    fn drop(&mut self) {\n"
+"        // Call closedir as needed.\n"
+"        unimplemented!()\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-3/safe-ffi-wrapper.md:88
+msgid ""
+"fn main() -> Result<(), String> {\n"
+"    let iter = DirectoryIterator::new(\".\")?;\n"
+"    println!(\"files: {:#?}\", iter.collect::<Vec<_>>());\n"
+"    Ok(())\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/welcome-day-4.md:1
+msgid "# Welcome to Day 4"
+msgstr "# 4일차 개요"
+
+#: src/welcome-day-4.md:3
+msgid "Today we will look at two main topics:"
+msgstr "오늘 강의는 두가지 주제를 다룹니다:"
+
+#: src/welcome-day-4.md:5
+msgid "* Concurrency: threads, channels, shared state, `Send` and `Sync`."
+msgstr "* 동시성: 쓰레드, 채널, 상태 공유(쉐어 스테이트), `Send`와 `Sync`"
+
+#: src/welcome-day-4.md:7
+msgid ""
+"* Android: building binaries and libraries, using AIDL, logging, and\n"
+"  interoperability with C, C++, and Java."
+msgstr ""
+"* 안드로이드: 바이너리와 라이브러리 작성, AIDL 사용, 로깅과 C/C++, 자바와의 "
+"상호 운용성"
+
+#: src/welcome-day-4.md:10
+msgid ""
+"> We will attempt to call Rust from one of your own projects today. So try "
+"to\n"
+"> find a little corner of your code base where we can move some lines of "
+"code to\n"
+"> Rust. The fewer dependencies and \"exotic\" types the better. Something "
+"that\n"
+"> parses some raw bytes would be ideal."
+msgstr ""
+"> 우리는 오늘 당신의 프로젝트를 호출해볼 것입니다. 따라서 가지고 있는 코드 중"
+"에 작은 부분을 찾아보세요\n"
+"> 종속성이 적고 특이 타입이 적을 수록 좋습니다. raw byte를 분석하는 종류의 것"
+"이 이상적입니다."
+
+#: src/concurrency.md:1
+msgid "# Fearless Concurrency"
+msgstr "# 겂없는 동시성"
+
+#: src/concurrency.md:3
+msgid ""
+"Rust has full support for concurrency using OS threads with mutexes and\n"
+"channels."
+msgstr ""
+"러스트는 뮤텍스와 채널이 있는 OS 스레드를 사용하여 동시성을 완전히 지원합니"
+"다."
+
+#: src/concurrency.md:6
+msgid ""
+"The Rust type system plays an important role in making many concurrency "
+"bugs\n"
+"compile time bugs. This is often referred to as _fearless concurrency_ since "
+"you\n"
+"can rely on the compiler to ensure correctness at runtime."
+msgstr ""
+"러스트의 타입 시스템은 많은 동시성 버그가 컴파일 시 버그를 일으키는 중요한  "
+"역할을 합니다. 이는 컴파일러를 사용하여 런타임의 정확성을 보장할 수 있기  때"
+"문에 종종 _겁없는 동시성(fearless concurrency)_라고 합니다."
+
+#: src/concurrency/threads.md:1
+msgid "# Threads"
+msgstr "# 스레드"
+
+#: src/concurrency/threads.md:3
+msgid "Rust threads work similarly to threads in other languages:"
+msgstr "러스트의 스레드는 다른 언어의 스레드와 유사하게 동작합니다:"
+
+#: src/concurrency/threads.md:5
+msgid ""
+"```rust,editable\n"
+"use std::thread;\n"
+"use std::time::Duration;"
+msgstr ""
+
+#: src/concurrency/threads.md:9
+msgid ""
+"fn main() {\n"
+"    thread::spawn(|| {\n"
+"        for i in 1..10 {\n"
+"            println!(\"Count in thread: {i}!\");\n"
+"            thread::sleep(Duration::from_millis(5));\n"
+"        }\n"
+"    });"
+msgstr ""
+
+#: src/concurrency/threads.md:17
+msgid ""
+"    for i in 1..5 {\n"
+"        println!(\"Main thread: {i}\");\n"
+"        thread::sleep(Duration::from_millis(5));\n"
+"    }\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/concurrency/threads.md:24
+msgid ""
+"* Threads are all daemon threads, the main thread does not wait for them.\n"
+"* Thread panics are independent of each other.\n"
+"  * Panics can carry a payload, which can be unpacked with `downcast_ref`."
+msgstr ""
+"* 스레드는 모두 데몬 스레드입니다. 따라서 주 스레드는 이를 기다리지 않습니"
+"다.\n"
+"* 스레드의 패닉은 서로 독립적으로 발생합니다.\n"
+"  * (스레드의) 패닉은 (주 스레드에게) 페이로드를 전달하고, 이는 "
+"`downcast_ref`로 풀어볼 수 있습니다."
+
+#: src/concurrency/threads.md:32
+msgid ""
+"* Notice that the thread is stopped before it reaches 10 — the main thread "
+"is\n"
+"  not waiting."
+msgstr ""
+"* 주 스레드가 기다리지 않기 때문에 생성된 스레드의 for문은 10까지 가지 않습니"
+"다."
+
+#: src/concurrency/threads.md:35
+msgid ""
+"* Use `let handle = thread::spawn(...)` and later `handle.join()` to wait "
+"for\n"
+"  the thread to finish."
+msgstr ""
+"* 만약 주 스레드가 스레드 동작을 대기 하기 원한다면 `let handle = thread::"
+"spawn(...)`으로 스레드를 선언한 후 `handle.join()`로 연결하여 사용합니다."
+
+#: src/concurrency/threads.md:38
+msgid "* Trigger a panic in the thread, notice how this doesn't affect `main`."
+msgstr ""
+"* 스레드에서 유발된 패닉(for 강제 종료)이 주 스레드에는 영향이 없음을 확인하"
+"시기 바랍니다."
+
+#: src/concurrency/threads.md:40
+msgid ""
+"* Use the `Result` return value from `handle.join()` to get access to the "
+"panic\n"
+"  payload. This is a good time to talk about [`Any`]."
+msgstr ""
+"* `handle.join()`사용시 `Result` 반환값을 통해 패닉 페이로드에 접근할 수 있습"
+"니다. [`Any`]를 참조하시기 바랍니다."
+
+#: src/concurrency/threads.md:43
+msgid "[`Any`]: https://doc.rust-lang.org/std/any/index.html"
+msgstr ""
+
+#: src/concurrency/scoped-threads.md:1
+msgid "# Scoped Threads"
+msgstr "# 범위 스레드(Scoped Threads)"
+
+#: src/concurrency/scoped-threads.md:3
+msgid "Normal threads cannot borrow from their environment:"
+msgstr "일반 스레드는 그들의 환경(주 스레드)에서 빌릴수 없습니다:"
+
+#: src/concurrency/scoped-threads.md:5
+msgid ""
+"```rust,editable,compile_fail\n"
+"use std::thread;"
+msgstr ""
+
+#: src/concurrency/scoped-threads.md:8 src/concurrency/scoped-threads.md:22
+msgid ""
+"fn main() {\n"
+"    let s = String::from(\"Hello\");"
+msgstr ""
+
+#: src/concurrency/scoped-threads.md:11
+msgid ""
+"    thread::spawn(|| {\n"
+"        println!(\"Length: {}\", s.len());\n"
+"    });\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/concurrency/scoped-threads.md:17
+msgid "However, you can use a [scoped thread][1] for this:"
+msgstr "하지만, [scoped thread][1]에서는 가능합니다:"
+
+#: src/concurrency/scoped-threads.md:19
+msgid ""
+"```rust,editable\n"
+"use std::thread;"
+msgstr ""
+
+#: src/concurrency/scoped-threads.md:25
+msgid ""
+"    thread::scope(|scope| {\n"
+"        scope.spawn(|| {\n"
+"            println!(\"Length: {}\", s.len());\n"
+"        });\n"
+"    });\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/concurrency/scoped-threads.md:33
+msgid "[1]: https://doc.rust-lang.org/std/thread/fn.scope.html"
+msgstr ""
+
+#: src/concurrency/channels.md:1
+msgid "# Channels"
+msgstr "# 채널"
+
+#: src/concurrency/channels.md:3
+msgid ""
+"Rust channels have two parts: a `Sender<T>` and a `Receiver<T>`. The two "
+"parts\n"
+"are connected via the channel, but you only see the end-points."
+msgstr ""
+"러스트의 채널은 `Sender<T>` 와 `Receiver<T>` 두 부분으로 구성됩니다.\n"
+"두 부분은 채널을 통해 연결되지만 우리는 종단만을 확인할 수 있습니다."
+
+#: src/concurrency/channels.md:6
+msgid ""
+"```rust,editable\n"
+"use std::sync::mpsc;\n"
+"use std::thread;"
+msgstr ""
+
+#: src/concurrency/channels.md:10 src/concurrency/channels/unbounded.md:10
+msgid ""
+"fn main() {\n"
+"    let (tx, rx) = mpsc::channel();"
+msgstr ""
+
+#: src/concurrency/channels.md:13
+msgid ""
+"    tx.send(10).unwrap();\n"
+"    tx.send(20).unwrap();"
+msgstr ""
+
+#: src/concurrency/channels.md:16
+msgid ""
+"    println!(\"Received: {:?}\", rx.recv());\n"
+"    println!(\"Received: {:?}\", rx.recv());"
+msgstr ""
+
+#: src/concurrency/channels.md:19
+msgid ""
+"    let tx2 = tx.clone();\n"
+"    tx2.send(30).unwrap();\n"
+"    println!(\"Received: {:?}\", rx.recv());\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/concurrency/channels/unbounded.md:1
+msgid "# Unbounded Channels"
+msgstr "# 무경계 채널(Unbounded Channels)"
+
+#: src/concurrency/channels/unbounded.md:3
+msgid "You get an unbounded and asynchronous channel with `mpsc::channel()`:"
+msgstr "`mpsc::channel()`함수는 무제한, 비동기 채널을 생성합니다: "
+
+#: src/concurrency/channels/unbounded.md:5
+#: src/concurrency/channels/bounded.md:5
+msgid ""
+"```rust,editable\n"
+"use std::sync::mpsc;\n"
+"use std::thread;\n"
+"use std::time::Duration;"
+msgstr ""
+
+#: src/concurrency/channels/unbounded.md:13
+#: src/concurrency/channels/bounded.md:13
+msgid ""
+"    thread::spawn(move || {\n"
+"        let thread_id = thread::current().id();\n"
+"        for i in 1..10 {\n"
+"            tx.send(format!(\"Message {i}\")).unwrap();\n"
+"            println!(\"{thread_id:?}: sent Message {i}\");\n"
+"        }\n"
+"        println!(\"{thread_id:?}: done\");\n"
+"    });\n"
+"    thread::sleep(Duration::from_millis(100));"
+msgstr ""
+
+#: src/concurrency/channels/unbounded.md:23
+#: src/concurrency/channels/bounded.md:23
+msgid ""
+"    for msg in rx.iter() {\n"
+"        println!(\"Main: got {}\", msg);\n"
+"    }\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/concurrency/channels/bounded.md:1
+msgid "# Bounded Channels"
+msgstr "# 경계 채널(Bounded Channels)"
+
+#: src/concurrency/channels/bounded.md:3
+msgid "Bounded and synchronous channels make `send` block the current thread:"
+msgstr "경계가 있는 동기 채널은 `send`가 주 스레드를 차단하도록 만듭니다:"
+
+#: src/concurrency/channels/bounded.md:10
+msgid ""
+"fn main() {\n"
+"    let (tx, rx) = mpsc::sync_channel(3);"
+msgstr ""
+
+#: src/concurrency/shared_state.md:1
+msgid "# Shared State"
+msgstr "# 상태 공유(Shared State)"
+
+#: src/concurrency/shared_state.md:3
+msgid ""
+"Rust uses the type system to enforce synchronization of shared data. This "
+"is\n"
+"primarily done via two types:"
+msgstr ""
+"러스트는 주로 아래 두 가지 타입 시스템을 이용해서 공유 데이터 동기화를 수행합"
+"니다: "
+
+#: src/concurrency/shared_state.md:6
+msgid ""
+"* [`Arc<T>`][1], atomic reference counted `T`: handled sharing between "
+"threads and\n"
+"  takes care to deallocate `T` when the last thread exits,\n"
+"* [`Mutex<T>`][2]: ensures mutual exclusion access to the `T` value."
+msgstr ""
+"* [`Arc<T>`][1], atomic[^역주1] 참조 카운트 `T`: 스레드 사이의 공유를 담당하"
+"고, 마지막 스레드 종료시 T를 해제합니다.\n"
+"* [`Mutex<T>`][2]: `T`값에 대한 상호배제 엑세스를 보장합니다."
+
+#: src/concurrency/shared_state.md:10
+msgid ""
+"[1]: https://doc.rust-lang.org/std/sync/struct.Arc.html\n"
+"[2]: https://doc.rust-lang.org/std/sync/struct.Mutex.html"
+msgstr ""
+"[1]: https://doc.rust-lang.org/std/sync/struct.Arc.html\n"
+"[2]: https://doc.rust-lang.org/std/sync/struct.Mutex.html\n"
+"[^역주1]: C++의 atomic을 구현했다고 합니다. 원자적 연산(한번에 일어나는 명령"
+"어 연산)으로 1개의 명령어로 처리했다/안했다로만 존재합니다."
+
+#: src/concurrency/shared_state/arc.md:1
+msgid "# `Arc`"
+msgstr ""
+
+#: src/concurrency/shared_state/arc.md:3
+msgid "[`Arc<T>`][1] allows shared read-only access via its `clone` method:"
+msgstr "[`Arc<T>`][1]는 `clone` 메서드를 통해 읽기전용 접근을 허용합니다:"
+
+#: src/concurrency/shared_state/arc.md:5
+msgid ""
+"```rust,editable\n"
+"use std::thread;\n"
+"use std::sync::Arc;"
+msgstr ""
+
+#: src/concurrency/shared_state/arc.md:9
+msgid ""
+"fn main() {\n"
+"    let v = Arc::new(vec![10, 20, 30]);\n"
+"    let mut handles = Vec::new();\n"
+"    for _ in 1..5 {\n"
+"        let v = v.clone();\n"
+"        handles.push(thread::spawn(move || {\n"
+"            let thread_id = thread::current().id();\n"
+"            println!(\"{thread_id:?}: {v:?}\");\n"
+"        }));\n"
+"    }"
+msgstr ""
+
+#: src/concurrency/shared_state/arc.md:20
+msgid ""
+"    handles.into_iter().for_each(|h| h.join().unwrap());\n"
+"    println!(\"v: {v:?}\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/concurrency/shared_state/arc.md:25
+msgid "[1]: https://doc.rust-lang.org/std/sync/struct.Arc.html"
+msgstr ""
+
+#: src/concurrency/shared_state/mutex.md:1
+msgid "# `Mutex`"
+msgstr ""
+
+#: src/concurrency/shared_state/mutex.md:3
+msgid ""
+"[`Mutex<T>`][1] ensures mutual exclusion _and_ allows mutable access to `T`\n"
+"behind a read-only interface:"
+msgstr ""
+"[`Mutex<T>`][1]는 상호배제를 보장하고, 일기전용 인터페이스 뒤에서 `T`에 대한 "
+"가변 접근을 허용합니다:"
+
+#: src/concurrency/shared_state/mutex.md:6
+msgid ""
+"```rust,editable\n"
+"use std::sync::Mutex;"
+msgstr ""
+
+#: src/concurrency/shared_state/mutex.md:9
+msgid ""
+"fn main() {\n"
+"    let v: Mutex<Vec<i32>> = Mutex::new(vec![10, 20, 30]);\n"
+"    println!(\"v: {:?}\", v.lock().unwrap());"
+msgstr ""
+
+#: src/concurrency/shared_state/mutex.md:13
+msgid ""
+"    {\n"
+"        let v: &Mutex<Vec<i32>> = &v;\n"
+"        let mut guard = v.lock().unwrap();\n"
+"        guard.push(40);\n"
+"    }"
+msgstr ""
+
+#: src/concurrency/shared_state/mutex.md:19
+msgid ""
+"    println!(\"v: {:?}\", v.lock().unwrap());\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/concurrency/shared_state/mutex.md:23
+msgid ""
+"Notice how we have a [`impl<T: Send> Sync for Mutex<T>`][2] blanket\n"
+"implementation."
+msgstr "[`impl<T: Send> Sync for Mutex<T>`][2]를 참조하시기 바랍니다"
+
+#: src/concurrency/shared_state/mutex.md:26
+msgid ""
+"[1]: https://doc.rust-lang.org/std/sync/struct.Mutex.html\n"
+"[2]: https://doc.rust-lang.org/std/sync/struct.Mutex.html#impl-Sync-for-"
+"Mutex%3CT%3E\n"
+"[3]: https://doc.rust-lang.org/std/sync/struct.Arc.html"
+msgstr ""
+
+#: src/concurrency/shared_state/example.md:3
+msgid "Let us see `Arc` and `Mutex` in action:"
+msgstr "`Arc`와 `Mutex`의 동작을 살펴봅니다:(동작하도록 수정해보세요)"
+
+#: src/concurrency/shared_state/example.md:5
+msgid ""
+"```rust,editable,compile_fail\n"
+"use std::thread;\n"
+"// use std::sync::{Arc, Mutex};"
+msgstr ""
+
+#: src/concurrency/shared_state/example.md:9
+msgid ""
+"fn main() {\n"
+"    let mut v = vec![10, 20, 30];\n"
+"    let handle = thread::spawn(|| {\n"
+"        v.push(10);\n"
+"    });\n"
+"    v.push(1000);"
+msgstr ""
+
+#: src/concurrency/shared_state/example.md:16
+msgid ""
+"    handle.join().unwrap();\n"
+"    println!(\"v: {v:?}\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/concurrency/send-sync.md:1
+msgid "# `Send` and `Sync`"
+msgstr "# `Send`와 `Sync`"
+
+#: src/concurrency/send-sync.md:3
+msgid ""
+"How does Rust know to forbid shared access across thread? The answer is in "
+"two traits:"
+msgstr ""
+"러스트는 아래 두가지 트레이트를 이용하여 스레드 간 공유 접근을 금지된 것을 "
+"알 수 있습니다:"
+
+#: src/concurrency/send-sync.md:5
+msgid ""
+"* [`Send`][1]: a type `T` is `Send` if it is safe to move a `T` across a "
+"thread\n"
+"  boundary.\n"
+"* [`Sync`][2]: a type `T` is `Sync` if it is safe to move a `&T` across a "
+"thread\n"
+"  boundary."
+msgstr ""
+"* [`Send`][1]: `T`가 스레드 간 이동이 안전하다면, `T`의 타입은 `Send`입니"
+"다.\n"
+"* [`Sync`][2]: `&T`가 스레드 간 이동이 안전하다면, `&T`의 타입은 `Sync`입니"
+"다."
+
+#: src/concurrency/send-sync.md:10
+msgid ""
+"[1]: https://doc.rust-lang.org/std/marker/trait.Send.html\n"
+"[2]: https://doc.rust-lang.org/std/marker/trait.Sync.html"
+msgstr ""
+
+#: src/concurrency/send-sync/send.md:1
+msgid "# `Send`"
+msgstr ""
+
+#: src/concurrency/send-sync/send.md:3
+msgid ""
+"> A type `T` is [`Send`][1] if it is safe to move a `T` value to another "
+"thread."
+msgstr "> `T`가 스레드 간 이동이 안전하다면, `T`의 타입은 `Send`입니다."
+
+#: src/concurrency/send-sync/send.md:5
+msgid ""
+"The effect of moving ownership to another thread is that _destructors_ will "
+"run\n"
+"in that thread. So the question is when you can allocate a value in one "
+"thread\n"
+"and deallocate it in another."
+msgstr ""
+"소유권을 다른 스레드로 이동하면 소멸자가 해당 스레드에서 실행됩니다.  \n"
+"여기서 의문은 \"언제 한 스레드에서 값을 할당하고 다른 스레드에서 값을 할당 해"
+"제할 수 있는가\" 입니다. "
+
+#: src/concurrency/send-sync/send.md:9
+msgid "[1]: https://doc.rust-lang.org/std/marker/trait.Send.html"
+msgstr ""
+
+#: src/concurrency/send-sync/sync.md:1
+msgid "# `Sync`"
+msgstr ""
+
+#: src/concurrency/send-sync/sync.md:3
+msgid ""
+"> A type `T` is [`Sync`][1] if it is safe to access a `T` value from "
+"multiple\n"
+"> threads at the same time."
+msgstr ""
+"> `&T`가 여러 스레드에서 접근이 안전하다면, `&T`의 타입은 `Sync`입니다."
+
+#: src/concurrency/send-sync/sync.md:6
+msgid "More precisely, the definition is:"
+msgstr "좀 더 정확한 정의는 다음과 같습니다:"
+
+#: src/concurrency/send-sync/sync.md:8
+msgid "> `T` is `Sync` if and only if `&T` is `Send`"
+msgstr "`&T`만 `Send`인 경우, `T`의 타입은 `Sync`입니다."
+
+#: src/concurrency/send-sync/sync.md:10
+msgid "[1]: https://doc.rust-lang.org/std/marker/trait.Sync.html"
+msgstr ""
+
+#: src/concurrency/send-sync/examples.md:1
+msgid "# Examples"
+msgstr "# 예제"
+
+#: src/concurrency/send-sync/examples.md:3
+msgid "## `Send + Sync`"
+msgstr ""
+
+#: src/concurrency/send-sync/examples.md:5
+msgid "Most types you come across are `Send + Sync`:"
+msgstr "대부분의 타입은 Send + Sync입니다:"
+
+#: src/concurrency/send-sync/examples.md:7
+msgid ""
+"* `i8`, `f32`, `bool`, `char`, `&str`, ...\n"
+"* `(T1, T2)`, `[T; N]`, `&[T]`, `struct { x: T }`, ...\n"
+"* `String`, `Option<T>`, `Vec<T>`, `Box<T>`, ...\n"
+"* `Arc<T>`: Explicitly thread-safe via atomic reference count.\n"
+"* `Mutex<T>`: Explicitly thread-safe via internal locking.\n"
+"* `AtomicBool`, `AtomicU8`, ...: Uses special atomic instructions."
+msgstr ""
+"* `i8`, `f32`, `bool`, `char`, `&str`, ...\n"
+"* `(T1, T2)`, `[T; N]`, `&[T]`, `struct { x: T }`, ...\n"
+"* `String`, `Option<T>`, `Vec<T>`, `Box<T>`, ...\n"
+"* `Arc<T>`: atomic 참조 카운트로 명시적 스레드-세이프.\n"
+"* `Mutex<T>`: 내부 잠금을 통해 명시적 스레드-세이프.\n"
+"* `AtomicBool`, `AtomicU8`, ...: 특별한 atomic 명령을 사용합니다."
+
+#: src/concurrency/send-sync/examples.md:14
+msgid ""
+"The generic types are typically `Send + Sync` when the type parameters are\n"
+"`Send + Sync`."
+msgstr ""
+"제너릭 타입은 일반적으로 타입파라메터가 `Send + Sync`이면 `Send + Sync` 입니"
+"다."
+
+#: src/concurrency/send-sync/examples.md:17
+msgid "## `Send + !Sync`"
+msgstr ""
+
+#: src/concurrency/send-sync/examples.md:19
+msgid ""
+"These types can be moved to other threads, but they're not thread-safe.\n"
+"Typically because of interior mutability:"
+msgstr ""
+"아래 타입들은 일반적으로 내부 가변성으로 인해 다른 스레드로 이동될 수 있지만 "
+"스레드-세이프 하지 않습니다."
+
+#: src/concurrency/send-sync/examples.md:22
+msgid ""
+"* `mpsc::Sender<T>`\n"
+"* `mpsc::Receiver<T>`\n"
+"* `Cell<T>`\n"
+"* `RefCell<T>`"
+msgstr ""
+
+#: src/concurrency/send-sync/examples.md:27
+msgid "## `!Send + Sync`"
+msgstr ""
+
+#: src/concurrency/send-sync/examples.md:29
+msgid ""
+"These types are thread-safe, but they cannot be moved to another thread:"
+msgstr "아래 타입들은 스레드-세이프 하지만 다른 스레드로 이동될 수 없습니다:"
+
+#: src/concurrency/send-sync/examples.md:31
+msgid ""
+"* `MutexGuard<T>`: Uses OS level primitives which must be deallocated on "
+"the\n"
+"  thread which created them."
+msgstr "* `MutexGuard<T>`: OS레벨에서 생성한 스레드에서 할당해제해야합니다"
+
+#: src/concurrency/send-sync/examples.md:34
+msgid "## `!Send + !Sync`"
+msgstr ""
+
+#: src/concurrency/send-sync/examples.md:36
+msgid "These types are not thread-safe and cannot be moved to other threads:"
+msgstr ""
+"아래 타입들은 스레드-세이프 하지도 않고 다른 스레드로 이동될 수도 없습니다:"
+
+#: src/concurrency/send-sync/examples.md:38
+msgid ""
+"* `Rc<T>`: each `Rc<T>` has a reference to an `RcBox<T>`, which contains a\n"
+"  non-atomic reference count.\n"
+"* `*const T`, `*mut T`: Rust assumes raw pointers may have special\n"
+"  concurrency considerations."
+msgstr ""
+"* `Rc<T>`: 각 `Rc<T>` 는 비 atomic 참조 카운트를 포함하는 `RcBox<T>`를 참조합"
+"니다.\n"
+"* `*const T`, `*mut T`: 러스트는 raw 포인터가 특별한 동시성 고려사항을 가질 "
+"수 있다고 가정합니다."
+
+#: src/exercises/day-4/morning.md:1 src/exercises/day-4/afternoon.md:1
+msgid "# Exercises"
+msgstr "# 연습문제"
+
+#: src/exercises/day-4/morning.md:3
+msgid "Let us practice our new concurrency skills with"
+msgstr "이번 훈련에서는 동시성 기술을 연습합니다:"
+
+#: src/exercises/day-4/morning.md:5
+msgid "* Dining philosophers: a classic problem in concurrency."
+msgstr "* 식사하는 철학자 문제: 고적적인 동시성 문제입니다."
+
+#: src/exercises/day-4/morning.md:7
+msgid ""
+"* Multi-threaded link checker: a larger project where you'll use Cargo to\n"
+"  download dependencies and then check links in parallel."
+msgstr ""
+"* 멀티 스레드 링크 검사: 카고를 사용하여 종속성을 다운로드하면서 링크를 체크"
+"하는 큰 프로젝트입니다"
+
+#: src/exercises/day-4/dining-philosophers.md:1
+msgid "# Dining Philosophers"
+msgstr "# 식사하는 철학자들"
+
+#: src/exercises/day-4/dining-philosophers.md:3
+msgid "The dining philosophers problem is a classic problem in concurrency:"
+msgstr "식사하는 철학자 문제는 동시성에 있어서 고전적인 문제입니다:"
+
+#: src/exercises/day-4/dining-philosophers.md:5
+msgid ""
+"> Five philosophers dine together at the same table. Each philosopher has "
+"their\n"
+"> own place at the table. There is a fork between each plate. The dish "
+"served is\n"
+"> a kind of spaghetti which has to be eaten with two forks. Each philosopher "
+"can\n"
+"> only alternately think and eat. Moreover, a philosopher can only eat "
+"their\n"
+"> spaghetti when they have both a left and right fork. Thus two forks will "
+"only\n"
+"> be available when their two nearest neighbors are thinking, not eating. "
+"After\n"
+"> an individual philosopher finishes eating, they will put down both forks."
+msgstr ""
+"> 5명의 철학자가 원탁에서 식사를 하고 있습니다. \n"
+"> 철학자는 원탁에서 자신의 자리에 앉아있습니다.\n"
+"> 포크는 각 접시 사이에 있습니다. \n"
+"> 제공되는 요리를 먹기 위해서는 2개의 포크를 모두 사용해야합니다.\n"
+"> 철학자는 생각을 하다가 배가 고프면 자신의 좌우의 포크를 들어 요리를 먹습니"
+"다.\n"
+"> 철학자는 요리를 먹은 후에는 포크를 다시 자리에 내려놓습니다.\n"
+"> 철학자는 자신의 좌,우에 포크가 있을때만 요리를 먹을 수 있습니다.\n"
+"> 따라서 두개의 포크는 오직 자신의 좌,우 철학자가 생각을 할 때만 사용할 수 있"
+"습니다."
+
+#: src/exercises/day-4/dining-philosophers.md:13
+msgid ""
+"You will need a local [Cargo installation](../../cargo/running-locally.md) "
+"for\n"
+"this exercise. Copy the code below to `src/main.rs` file, fill out the "
+"blanks,\n"
+"and test that `cargo run` does not deadlock:"
+msgstr ""
+"이번 훈련에서는 [로컬 카고 설치](../../cargo/running-locally.md)가 필요합니"
+"다.\n"
+"아래 코드를 복사해서 `src/main.rs`에 붙여놓고 빈 부분을 채우고, `cargo run` "
+"커맨드로 테스트 해서 교착상태(데드락)이 되지 않는지 확인합니다:"
+
+#: src/exercises/day-4/dining-philosophers.md:17
+msgid ""
+"```rust,compile_fail\n"
+"use std::sync::mpsc;\n"
+"use std::sync::{Arc, Mutex};\n"
+"use std::thread;\n"
+"use std::time::Duration;"
+msgstr ""
+
+#: src/exercises/day-4/dining-philosophers.md:23
+#: src/exercises/day-4/solutions-morning.md:28
+msgid "struct Fork;"
+msgstr ""
+
+#: src/exercises/day-4/dining-philosophers.md:25
+msgid ""
+"struct Philosopher {\n"
+"    name: String,\n"
+"    // left_fork: ...\n"
+"    // right_fork: ...\n"
+"    // thoughts: ...\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-4/dining-philosophers.md:32
+msgid ""
+"impl Philosopher {\n"
+"    fn think(&self) {\n"
+"        self.thoughts\n"
+"            .send(format!(\"Eureka! {} has a new idea!\", &self.name))\n"
+"            .unwrap();\n"
+"    }"
+msgstr ""
+
+#: src/exercises/day-4/dining-philosophers.md:39
+msgid ""
+"    fn eat(&self) {\n"
+"        // Pick up forks...\n"
+"        println!(\"{} is eating...\", &self.name);\n"
+"        thread::sleep(Duration::from_millis(10));\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-4/dining-philosophers.md:46
+#: src/exercises/day-4/solutions-morning.md:60
+msgid ""
+"static PHILOSOPHERS: &[&str] =\n"
+"    &[\"Socrates\", \"Plato\", \"Aristotle\", \"Thales\", \"Pythagoras\"];"
+msgstr ""
+
+#: src/exercises/day-4/dining-philosophers.md:49
+msgid ""
+"fn main() {\n"
+"    // Create forks"
+msgstr ""
+
+#: src/exercises/day-4/dining-philosophers.md:52
+msgid "    // Create philosophers"
+msgstr ""
+
+#: src/exercises/day-4/dining-philosophers.md:54
+msgid "    // Make them think and eat"
+msgstr ""
+
+#: src/exercises/day-4/dining-philosophers.md:56
+msgid ""
+"    // Output their thoughts\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/exercises/day-4/link-checker.md:1
+msgid "# Multi-threaded Link Checker"
+msgstr "# 멀티스레드 링크 검사기"
+
+#: src/exercises/day-4/link-checker.md:3
+msgid ""
+"Let us use our new knowledge to create a multi-threaded link checker. It "
+"should\n"
+"start at a webpage and check that links on the page are valid. It should\n"
+"recursively check other pages on the same domain and keep doing this until "
+"all\n"
+"pages have been validated."
+msgstr ""
+"새로 배운것들을 활용해서 멀티 스레드 링크 검사기를 만듭니다. \n"
+"검사기는 웹페이지가 유효한지 확인합니다. \n"
+"그리고 재귀적으로 동일 도메인의 다른 모든 페이지가 유효한지 확인합니다."
+
+#: src/exercises/day-4/link-checker.md:8
+msgid ""
+"For this, you will need an HTTP client such as [`reqwest`][1]. Create a new\n"
+"Cargo project and `reqwest` it as a dependency with:"
+msgstr ""
+"이를 위해서 [`reqwest`][1]와 같은 HTTP 클라이언트가 필요합니다. 새로운 로컬 "
+"프로젝트를 만들고 [`reqwest`][1]를 종속성에 추가하십시요"
+
+#: src/exercises/day-4/link-checker.md:11
+msgid ""
+"```shell\n"
+"$ cargo new link-checker\n"
+"$ cd link-checker\n"
+"$ cargo add --features blocking,rustls-tls reqwest\n"
+"```"
+msgstr ""
+
+#: src/exercises/day-4/link-checker.md:17
+msgid ""
+"> If `cargo add` fails with `error: no such subcommand`, then please edit "
+"the\n"
+"> `Cargo.toml` file by hand. Add the dependencies listed below."
+msgstr ""
+"> 만일 `cargo add` 커맨드가 `error: no such subcommand` 로 실패한다면 \n"
+"> `Cargo.toml` 파일을 직접 수정해도 됩니다. 아래에 전체 종속성 내용이 있습니"
+"다."
+
+#: src/exercises/day-4/link-checker.md:20
+msgid ""
+"You will also need a way to find links. We can use [`scraper`][2] for that:"
+msgstr "링크를 찾기 위해서 [`scraper`][2]도 추가합니다:"
+
+#: src/exercises/day-4/link-checker.md:22
+msgid ""
+"```shell\n"
+"$ cargo add scraper\n"
+"```"
+msgstr ""
+
+#: src/exercises/day-4/link-checker.md:26
+msgid ""
+"Finally, we'll need some way of handling errors. We [`thiserror`][3] for "
+"that:"
+msgstr "마지막으로 오류 처리하는 방법으로 [`thiserror`][3]도 추가합니다:"
+
+#: src/exercises/day-4/link-checker.md:28
+msgid ""
+"```shell\n"
+"$ cargo add thiserror\n"
+"```"
+msgstr ""
+
+#: src/exercises/day-4/link-checker.md:32
+msgid ""
+"The `cargo add` calls will update the `Cargo.toml` file to look like this:"
+msgstr "모든 `cargo add`이 끝나면 `Cargo.toml`에 아래 내용이 추가 되있습니다:"
+
+#: src/exercises/day-4/link-checker.md:34
+msgid ""
+"```toml\n"
+"[dependencies]\n"
+"reqwest = { version = \"0.11.12\", features = [\"blocking\", \"rustls-"
+"tls\"] }\n"
+"scraper = \"0.13.0\"\n"
+"thiserror = \"1.0.37\"\n"
+"```"
+msgstr ""
+
+#: src/exercises/day-4/link-checker.md:41
+msgid ""
+"You can now download the start page. Try with a small site such as\n"
+"`https://www.google.org/`."
+msgstr "이제 `https://www.google.org/` 같은 웹 페이지를 탐색할 수 있습니다. "
+
+#: src/exercises/day-4/link-checker.md:44
+msgid "Your `src/main.rs` file should look something like this:"
+msgstr "`rc/main.rs`파일은 아래와 같습니다:"
+
+#: src/exercises/day-4/link-checker.md:46
+msgid ""
+"```rust,compile_fail\n"
+"use reqwest::blocking::{get, Response};\n"
+"use reqwest::Url;\n"
+"use scraper::{Html, Selector};\n"
+"use thiserror::Error;"
+msgstr ""
+
+#: src/exercises/day-4/link-checker.md:52
+msgid ""
+"#[derive(Error, Debug)]\n"
+"enum Error {\n"
+"    #[error(\"request error: {0}\")]\n"
+"    ReqwestError(#[from] reqwest::Error),\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-4/link-checker.md:58
+msgid ""
+"fn extract_links(response: Response) -> Result<Vec<Url>, Error> {\n"
+"    let base_url = response.url().to_owned();\n"
+"    let document = response.text()?;\n"
+"    let html = Html::parse_document(&document);\n"
+"    let selector = Selector::parse(\"a\").unwrap();"
+msgstr ""
+
+#: src/exercises/day-4/link-checker.md:64
+msgid ""
+"    let mut valid_urls = Vec::new();\n"
+"    for element in html.select(&selector) {\n"
+"        if let Some(href) = element.value().attr(\"href\") {\n"
+"            match base_url.join(href) {\n"
+"                Ok(url) => valid_urls.push(url),\n"
+"                Err(err) => {\n"
+"                    println!(\"On {base_url}: could not parse {href:?}: "
+"{err} (ignored)\",);\n"
+"                }\n"
+"            }\n"
+"        }\n"
+"    }"
+msgstr ""
+
+#: src/exercises/day-4/link-checker.md:76
+msgid ""
+"    Ok(valid_urls)\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-4/link-checker.md:79
+msgid ""
+"fn main() {\n"
+"    let start_url = Url::parse(\"https://www.google.org\").unwrap();\n"
+"    let response = get(start_url).unwrap();\n"
+"    match extract_links(response) {\n"
+"        Ok(links) => println!(\"Links: {links:#?}\"),\n"
+"        Err(err) => println!(\"Could not extract links: {err:#}\"),\n"
+"    }\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/exercises/day-4/link-checker.md:89
+msgid "Run the code in `src/main.rs` with"
+msgstr "아래 커맨드로 소스를 실행합니다: "
+
+#: src/exercises/day-4/link-checker.md:91
+msgid ""
+"```shell\n"
+"$ cargo run\n"
+"```"
+msgstr ""
+
+#: src/exercises/day-4/link-checker.md:95
+msgid "## Tasks"
+msgstr ""
+
+#: src/exercises/day-4/link-checker.md:97
+msgid ""
+"* Use threads to check the links in parallel: send the URLs to be checked to "
+"a\n"
+"  channel and let a few threads check the URLs in parallel.\n"
+"* Extend this to recursively extract links from all pages on the\n"
+"  `www.google.org` domain. Put an upper limit of 100 pages or so so that "
+"you\n"
+"  don't end up being blocked by the site."
+msgstr ""
+"* 스레드를 사용하여 링크를 병렬로 확인합니다: URL을 채널로 보내서 몇 개의 스"
+"레드가 URL을 병렬로 체크하도록 합니다.\n"
+"* `www.google.org`도메인의 모든 페이지를 재귀적으로 확인하기 위해 코드를 확장"
+"해서 작성합니다: 사이트에 의해 차단되지 않도록 100페이지 정도로 제한을 두시"
+"기 바랍니다."
+
+#: src/exercises/day-4/link-checker.md:103
+msgid ""
+"[1]: https://docs.rs/reqwest/\n"
+"[2]: https://docs.rs/scraper/\n"
+"[3]: https://docs.rs/thiserror/"
+msgstr ""
+
+#: src/android.md:1
+msgid "# Android"
+msgstr "# 안드로이드"
+
+#: src/android.md:3
+msgid ""
+"Rust is supported for native platform development on Android. This means "
+"that\n"
+"you can write new operating system services in Rust, as well as extending\n"
+"existing services."
+msgstr ""
+"러스트는 안드로이드 네이티브 플랫폼 개발을 지원합니다. 즉, 기존 서비스를 확"
+"장 할 뿐 아니라 새로운 OS서비스를 작성할 수 있음을 뜻합니다."
+
+#: src/android/setup.md:1
+msgid "# Setup"
+msgstr "# 설치"
+
+#: src/android/setup.md:3
+msgid ""
+"We will be using an Android Virtual Device to test our code. Make sure you "
+"have\n"
+"access to one or create a new one with:"
+msgstr ""
+"Android Virtual Device를 사용하여 코드를 테스트합니다. \n"
+"액세스 권한이 있는지 확인하거나 다음을 사용하여 새 액세스 권한을 만드십시오:"
+
+#: src/android/setup.md:6
+msgid ""
+"```shell\n"
+"$ source build/envsetup.sh\n"
+"$ lunch aosp_cf_x86_64_phone-userdebug\n"
+"$ acloud create\n"
+"```"
+msgstr ""
+
+#: src/android/setup.md:12
+msgid ""
+"Please see the [Android Developer\n"
+"Codelab](https://source.android.com/docs/setup/start) for details."
+msgstr ""
+"자세한 내용은  [Android Developer\n"
+"Codelab](https://source.android.com/docs/setup/start)을 참조하십시오."
+
+#: src/android/build-rules.md:1
+msgid "# Build Rules"
+msgstr "# 빌드 규칙(Build Rules)"
+
+#: src/android/build-rules.md:3
+msgid "The Android build system (Soong) supports Rust via a number of modules:"
+msgstr ""
+"안드로이드 빌드 시스템(Soong)은 다음과 같은 여러 모듈을 통해 러스트를  지원합"
+"니다:"
+
+#: src/android/build-rules.md:5
+msgid ""
+"| Module Type       | "
+"Description                                                                                        "
+"|\n"
+"|-------------------|----------------------------------------------------------------------------------------------------|\n"
+"| `rust_binary`     | Produces a Rust "
+"binary.                                                                            "
+"|\n"
+"| `rust_library`    | Produces a Rust library, and provides both `rlib` and "
+"`dylib` variants.                            |\n"
+"| `rust_ffi`        | Produces a Rust C library usable by `cc` modules, and "
+"provides both static and shared variants.    |\n"
+"| `rust_proc_macro` | Produces a `proc-macro` Rust library. These are "
+"analogous to compiler plugins.                     |\n"
+"| `rust_test`       | Produces a Rust test binary that uses the standard "
+"Rust test harness.                              |\n"
+"| `rust_fuzz`       | Produces a Rust fuzz binary leveraging "
+"`libfuzzer`.                                                |\n"
+"| `rust_protobuf`   | Generates source and produces a Rust library that "
+"provides an interface for a particular protobuf. |\n"
+"| `rust_bindgen`    | Generates source and produces a Rust library "
+"containing Rust bindings to C libraries.              |"
+msgstr ""
+"| Module Type       | Description                                          "
+"|\n"
+"|-------------------|------------------------------------------------------|\n"
+"| `rust_binary`     | 러스트 바이너리(Rust binary)를 생성합니다.           "
+"|\n"
+"| `rust_library`    | 러스트 라이브러리를 생성하고, rlib와 dylib variants"
+"를                       제공합니"
+"다.                                          |\n"
+"| `rust_ffi`        | cc모듈에서 사용할 수 있는 Rust C library를 생성하"
+"고,                       static and shared variants를 제공합니"
+"다.             |\n"
+"| `rust_proc_macro` | proc-macro Rust library를 생성합니다. 컴파일"
+"러                       플러그인과 유사합니"
+"다.                               |\n"
+"| `rust_test`       | standard Rust test harness를 사용하는 러스트 테스"
+"트                       바이너리를 생성합니"
+"다.                               |\n"
+"| `rust_fuzz`       | libfuzzer를 사용하여 Rust fuzz 바이너리를 생성합니"
+"다.|\n"
+"| `rust_protobuf`   | 소스를 생성하고 특정 protobuf에 대한 인터페이스"
+"를                       제공하는 러스트 라이브러리를 생성합니"
+"다.             |\n"
+"| `rust_bindgen`    | 소스를 생성하고 C 라이브러리에 대한 러스트 바인딩"
+"을                       포함하는 러스트 라이브러리를 생성합니"
+"다               |"
+
+#: src/android/build-rules.md:16
+msgid "We will look at `rust_binary` and `rust_library` next."
+msgstr "다음은 `rust_binary`와 `rust_library`를 살펴봅니다."
+
+#: src/android/build-rules/binary.md:1
+msgid "# Rust Binaries"
+msgstr ""
+
+#: src/android/build-rules/binary.md:3
+msgid ""
+"Let us start with a simple application. At the root of an AOSP checkout, "
+"create\n"
+"the following files:"
+msgstr ""
+"간단한 응용 프로그램으로 시작해 보겠습니다. AOSP 체크아웃의 루트에서 다음 파"
+"일을 생성합니다:"
+
+#: src/android/build-rules/binary.md:6 src/android/build-rules/library.md:13
+msgid "_hello_rust/Android.bp_:"
+msgstr ""
+
+#: src/android/build-rules/binary.md:8
+msgid ""
+"```javascript\n"
+"rust_binary {\n"
+"    name: \"hello_rust\",\n"
+"    crate_name: \"hello_rust\",\n"
+"    srcs: [\"src/main.rs\"],\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/android/build-rules/binary.md:16 src/android/build-rules/library.md:34
+msgid "_hello_rust/src/main.rs_:"
+msgstr ""
+
+#: src/android/build-rules/binary.md:18
+msgid ""
+"```rust\n"
+"//! Rust demo."
+msgstr ""
+
+#: src/android/build-rules/binary.md:21
+msgid ""
+"/// Prints a greeting to standard output.\n"
+"fn main() {\n"
+"    println!(\"Hello from Rust!\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/android/build-rules/binary.md:27
+msgid "You can now build, push, and run the binary:"
+msgstr "이제 바이너리를 빌드, 푸시, 실행할 수 있습니다:"
+
+#: src/android/build-rules/binary.md:29
+msgid ""
+"```shell\n"
+"$ m hello_rust\n"
+"$ adb push $ANDROID_PRODUCT_OUT/system/bin/hello_rust /data/local/tmp\n"
+"$ adb shell /data/local/tmp/hello_rust\n"
+"Hello from Rust!\n"
+"```"
+msgstr ""
+
+#: src/android/build-rules/library.md:1
+msgid "# Rust Libraries"
+msgstr ""
+
+#: src/android/build-rules/library.md:3
+msgid "You use `rust_library` to create a new Rust library for Android."
+msgstr "`rust_library`를 사용하여 Android용 새 Rust 라이브러리를 만듭니다."
+
+#: src/android/build-rules/library.md:5
+msgid "Here we declare a dependency on two libraries:"
+msgstr "여기서 2개의 라이브러리 의존성을 선언합니다."
+
+#: src/android/build-rules/library.md:7
+msgid ""
+"* `libgreeting`, which we define below,\n"
+"* `libtextwrap`, which is a crate already vendored in\n"
+"  [`external/rust/crates/`][crates]."
+msgstr ""
+"* 아래에 정의한 libgreeting.\n"
+"* [`external/rust/crates/`][crates]에 존재하는 libtextwrap"
+
+#: src/android/build-rules/library.md:11
+msgid ""
+"[crates]: https://cs.android.com/android/platform/superproject/+/master:"
+"external/rust/crates/"
+msgstr ""
+
+#: src/android/build-rules/library.md:15
+msgid ""
+"```javascript\n"
+"rust_binary {\n"
+"    name: \"hello_rust_with_dep\",\n"
+"    crate_name: \"hello_rust_with_dep\",\n"
+"    srcs: [\"src/main.rs\"],\n"
+"    rustlibs: [\n"
+"        \"libgreetings\",\n"
+"        \"libtextwrap\",\n"
+"    ],\n"
+"    prefer_rlib: true,\n"
+"}"
+msgstr ""
+
+#: src/android/build-rules/library.md:27
+msgid ""
+"rust_library {\n"
+"    name: \"libgreetings\",\n"
+"    crate_name: \"greetings\",\n"
+"    srcs: [\"src/lib.rs\"],\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/android/build-rules/library.md:36
+msgid ""
+"```rust,ignore\n"
+"//! Rust demo."
+msgstr ""
+
+#: src/android/build-rules/library.md:39
+msgid ""
+"use greetings::greeting;\n"
+"use textwrap::fill;"
+msgstr ""
+
+#: src/android/build-rules/library.md:42
+msgid ""
+"/// Prints a greeting to standard output.\n"
+"fn main() {\n"
+"    println!(\"{}\", fill(&greeting(\"Bob\"), 24));\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/android/build-rules/library.md:48
+msgid "_hello_rust/src/lib.rs_:"
+msgstr ""
+
+#: src/android/build-rules/library.md:50
+msgid ""
+"```rust,ignore\n"
+"//! Greeting library."
+msgstr ""
+
+#: src/android/build-rules/library.md:53
+msgid ""
+"/// Greet `name`.\n"
+"pub fn greeting(name: &str) -> String {\n"
+"    format!(\"Hello {name}, it is very nice to meet you!\")\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/android/build-rules/library.md:59
+msgid "You build, push, and run the binary like before:"
+msgstr "이제 이전과 같이 바이너리를 빌드, 푸시, 실행할 수 있습니다:"
+
+#: src/android/build-rules/library.md:61
+msgid ""
+"```shell\n"
+"$ m hello_rust_with_dep\n"
+"$ adb push $ANDROID_PRODUCT_OUT/system/bin/hello_rust_with_dep /data/local/"
+"tmp\n"
+"$ adb shell /data/local/tmp/hello_rust_with_dep\n"
+"Hello Bob, it is very\n"
+"nice to meet you!\n"
+"```"
+msgstr ""
+
+#: src/android/aidl.md:1
+msgid "# AIDL"
+msgstr ""
+
+#: src/android/aidl.md:3
+msgid ""
+"The [Android Interface Definition Language\n"
+"(AIDL)](https://developer.android.com/guide/components/aidl) is supported in "
+"Rust:"
+msgstr ""
+"러스트는 안드로이드 [인터페이스 정의 언어(AIDL)](https://developer.android."
+"com/guide/components/aidl)을 지원합니다:"
+
+#: src/android/aidl.md:6
+msgid ""
+"* Rust code can call existing AIDL servers,\n"
+"* You can create new AIDL servers in Rust."
+msgstr ""
+"* 러스트 코드는 기존 AIDL 서버를 호출 할 수 있습니다. \n"
+"* 러스트에서 새로운 AIDL 서버를 생성할 수 있습니다."
+
+#: src/android/aidl/interface.md:1
+msgid "# AIDL Interfaces"
+msgstr ""
+
+#: src/android/aidl/interface.md:3
+msgid "You declare the API of your service using an AIDL interface:"
+msgstr "AIDL 인터페이스를 이용해서 서비스의 API를 선언합니다: "
+
+#: src/android/aidl/interface.md:5
+msgid ""
+"*birthday_service/aidl/com/example/birthdayservice/IBirthdayService.aidl*:"
+msgstr ""
+
+#: src/android/aidl/interface.md:7 src/android/aidl/changing.md:6
+msgid ""
+"```java\n"
+"package com.example.birthdayservice;"
+msgstr ""
+
+#: src/android/aidl/interface.md:10
+msgid ""
+"/** Birthday service interface. */\n"
+"interface IBirthdayService {\n"
+"    /** Generate a Happy Birthday message. */\n"
+"    String wishHappyBirthday(String name, int years);\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/android/aidl/interface.md:17
+msgid "*birthday_service/aidl/Android.bp*:"
+msgstr ""
+
+#: src/android/aidl/interface.md:19
+msgid ""
+"```javascript\n"
+"aidl_interface {\n"
+"    name: \"com.example.birthdayservice\",\n"
+"    srcs: [\"com/example/birthdayservice/*.aidl\"],\n"
+"    unstable: true,\n"
+"    backend: {\n"
+"        rust: { // Rust is not enabled by default\n"
+"            enabled: true,\n"
+"        },\n"
+"    },\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/android/aidl/interface.md:32
+msgid ""
+"Add `vendor_available: true` if your AIDL file is used by a binary in the "
+"vendor\n"
+"partition."
+msgstr ""
+"AIDL 파일이 벤더 파티션의 바이너리에서 사용되는 경우 `vendor_available: true`"
+"를 추가합니다."
+
+#: src/android/aidl/implementation.md:1
+msgid "# Service Implementation"
+msgstr ""
+
+#: src/android/aidl/implementation.md:3
+msgid "We can now implement the AIDL service:"
+msgstr "이제 AIDL서비스를 구현할 수 있습니다:"
+
+#: src/android/aidl/implementation.md:5
+msgid "*birthday_service/src/lib.rs*:"
+msgstr ""
+
+#: src/android/aidl/implementation.md:7
+msgid ""
+"```rust,ignore\n"
+"//! Implementation of the `IBirthdayService` AIDL interface.\n"
+"use com_example_birthdayservice::aidl::com::example::birthdayservice::"
+"IBirthdayService::IBirthdayService;\n"
+"use com_example_birthdayservice::binder;"
+msgstr ""
+
+#: src/android/aidl/implementation.md:12
+msgid ""
+"/// The `IBirthdayService` implementation.\n"
+"pub struct BirthdayService;"
+msgstr ""
+
+#: src/android/aidl/implementation.md:15
+msgid "impl binder::Interface for BirthdayService {}"
+msgstr ""
+
+#: src/android/aidl/implementation.md:17
+msgid ""
+"impl IBirthdayService for BirthdayService {\n"
+"    fn wishHappyBirthday(&self, name: &str, years: i32) -> binder::"
+"Result<String> {\n"
+"        Ok(format!(\n"
+"            \"Happy Birthday {name}, congratulations with the {years} years!"
+"\"\n"
+"        ))\n"
+"    }\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/android/aidl/implementation.md:26 src/android/aidl/server.md:28
+#: src/android/aidl/client.md:37
+msgid "*birthday_service/Android.bp*:"
+msgstr ""
+
+#: src/android/aidl/implementation.md:28
+msgid ""
+"```javascript\n"
+"rust_library {\n"
+"    name: \"libbirthdayservice\",\n"
+"    srcs: [\"src/lib.rs\"],\n"
+"    crate_name: \"birthdayservice\",\n"
+"    rustlibs: [\n"
+"        \"com.example.birthdayservice-rust\",\n"
+"        \"libbinder_rs\",\n"
+"    ],\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/android/aidl/server.md:1
+msgid "# AIDL Server"
+msgstr ""
+
+#: src/android/aidl/server.md:3
+msgid "Finally, we can create a server which exposes the service:"
+msgstr "마지막으로 서비스를 제공하는 서버를 만들 수 있습니다:"
+
+#: src/android/aidl/server.md:5
+msgid "*birthday_service/src/server.rs*:"
+msgstr ""
+
+#: src/android/aidl/server.md:7
+msgid ""
+"```rust,ignore\n"
+"//! Birthday service.\n"
+"use birthdayservice::BirthdayService;\n"
+"use com_example_birthdayservice::aidl::com::example::birthdayservice::"
+"IBirthdayService::BnBirthdayService;\n"
+"use com_example_birthdayservice::binder;"
+msgstr ""
+
+#: src/android/aidl/server.md:13 src/android/aidl/client.md:12
+msgid "const SERVICE_IDENTIFIER: &str = \"birthdayservice\";"
+msgstr ""
+
+#: src/android/aidl/server.md:15
+msgid ""
+"/// Entry point for birthday service.\n"
+"fn main() {\n"
+"    let birthday_service = BirthdayService;\n"
+"    let birthday_service_binder = BnBirthdayService::new_binder(\n"
+"        birthday_service,\n"
+"        binder::BinderFeatures::default(),\n"
+"    );\n"
+"    binder::add_service(SERVICE_IDENTIFIER, birthday_service_binder."
+"as_binder())\n"
+"        .expect(\"Failed to register service\");\n"
+"    binder::ProcessState::join_thread_pool()\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/android/aidl/server.md:30
+msgid ""
+"```javascript\n"
+"rust_binary {\n"
+"    name: \"birthday_server\",\n"
+"    crate_name: \"birthday_server\",\n"
+"    srcs: [\"src/server.rs\"],\n"
+"    rustlibs: [\n"
+"        \"com.example.birthdayservice-rust\",\n"
+"        \"libbinder_rs\",\n"
+"        \"libbirthdayservice\",\n"
+"    ],\n"
+"    prefer_rlib: true,\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/android/aidl/deploy.md:1
+msgid "# Deploy"
+msgstr ""
+
+#: src/android/aidl/deploy.md:3
+msgid "We can now build, push, and start the service:"
+msgstr "서비스를 빌드, 푸시, 시작 할 수 있습니다:"
+
+#: src/android/aidl/deploy.md:5
+msgid ""
+"```shell\n"
+"$ m birthday_server\n"
+"$ adb push $ANDROID_PRODUCT_OUT/system/bin/birthday_server /data/local/tmp\n"
+"$ adb shell /data/local/tmp/birthday_server\n"
+"```"
+msgstr ""
+
+#: src/android/aidl/deploy.md:11
+msgid "In another terminal, check that the service runs:"
+msgstr "다른 터미널에서 서비스 구동을 확인합니다:"
+
+#: src/android/aidl/deploy.md:13
+msgid ""
+"```shell\n"
+"$ adb shell service check birthdayservice\n"
+"Service birthdayservice: found\n"
+"```"
+msgstr ""
+
+#: src/android/aidl/deploy.md:18
+msgid "You can also call the service with `service call`:"
+msgstr "`service call`로 서비스를 호출할 수도 있습니다:"
+
+#: src/android/aidl/deploy.md:20
+msgid ""
+"```shell\n"
+"$ $ adb shell service call birthdayservice 1 s16 Bob i32 24\n"
+"Result: Parcel(\n"
+"  0x00000000: 00000000 00000036 00610048 00700070 '....6...H.a.p.p.'\n"
+"  0x00000010: 00200079 00690042 00740072 00640068 'y. .B.i.r.t.h.d.'\n"
+"  0x00000020: 00790061 00420020 0062006f 0020002c 'a.y. .B.o.b.,. .'\n"
+"  0x00000030: 006f0063 0067006e 00610072 00750074 'c.o.n.g.r.a.t.u.'\n"
+"  0x00000040: 0061006c 00690074 006e006f 00200073 'l.a.t.i.o.n.s. .'\n"
+"  0x00000050: 00690077 00680074 00740020 00650068 'w.i.t.h. .t.h.e.'\n"
+"  0x00000060: 00320020 00200034 00650079 00720061 ' .2.4. .y.e.a.r.'\n"
+"  0x00000070: 00210073 00000000                   's.!.....        ')\n"
+"```"
+msgstr ""
+
+#: src/android/aidl/client.md:1
+msgid "# AIDL Client"
+msgstr ""
+
+#: src/android/aidl/client.md:3
+msgid "Finally, we can create a Rust client for our new service."
+msgstr "마지막으로, 새로운 서비스를 위한 러스트 클라이언트를 만들 수 있습니다."
+
+#: src/android/aidl/client.md:5
+msgid "*birthday_service/src/client.rs*:"
+msgstr ""
+
+#: src/android/aidl/client.md:7
+msgid ""
+"```rust,ignore\n"
+"//! Birthday service.\n"
+"use com_example_birthdayservice::aidl::com::example::birthdayservice::"
+"IBirthdayService::IBirthdayService;\n"
+"use com_example_birthdayservice::binder;"
+msgstr ""
+
+#: src/android/aidl/client.md:14
+msgid ""
+"/// Connect to the BirthdayService.\n"
+"pub fn connect() -> Result<binder::Strong<dyn IBirthdayService>, binder::"
+"StatusCode> {\n"
+"    binder::get_interface(SERVICE_IDENTIFIER)\n"
+"}"
+msgstr ""
+
+#: src/android/aidl/client.md:19
+msgid ""
+"/// Call the birthday service.\n"
+"fn main() -> Result<(), binder::Status> {\n"
+"    let name = std::env::args()\n"
+"        .nth(1)\n"
+"        .unwrap_or_else(|| String::from(\"Bob\"));\n"
+"    let years = std::env::args()\n"
+"        .nth(2)\n"
+"        .and_then(|arg| arg.parse::<i32>().ok())\n"
+"        .unwrap_or(42);"
+msgstr ""
+
+#: src/android/aidl/client.md:29
+msgid ""
+"    binder::ProcessState::start_thread_pool();\n"
+"    let service = connect().expect(\"Failed to connect to "
+"BirthdayService\");\n"
+"    let msg = service.wishHappyBirthday(&name, years)?;\n"
+"    println!(\"{msg}\");\n"
+"    Ok(())\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/android/aidl/client.md:39
+msgid ""
+"```javascript\n"
+"rust_binary {\n"
+"    name: \"birthday_client\",\n"
+"    crate_name: \"birthday_client\",\n"
+"    srcs: [\"src/client.rs\"],\n"
+"    rustlibs: [\n"
+"        \"com.example.birthdayservice-rust\",\n"
+"        \"libbinder_rs\",\n"
+"    ],\n"
+"    prefer_rlib: true,\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/android/aidl/client.md:52
+msgid "Notice that the client does not depend on `libbirthdayservice`."
+msgstr "클라이언트는 `libbirthdayservice`에 의존하지 않습니다. "
+
+#: src/android/aidl/client.md:54
+msgid "Build, push, and run the client on your device:"
+msgstr "장치에서 빌드, 푸시, 실행합니다: "
+
+#: src/android/aidl/client.md:56
+msgid ""
+"```shell\n"
+"$ m birthday_client\n"
+"$ adb push $ANDROID_PRODUCT_OUT/system/bin/birthday_client /data/local/tmp\n"
+"$ adb shell /data/local/tmp/birthday_client Charlie 60\n"
+"Happy Birthday Charlie, congratulations with the 60 years!\n"
+"```"
+msgstr ""
+
+#: src/android/aidl/changing.md:1
+msgid "# Changing API"
+msgstr ""
+
+#: src/android/aidl/changing.md:3
+msgid ""
+"Let us extend the API with more functionality: we want to let clients "
+"specify a\n"
+"list of lines for the birthday card:"
+msgstr ""
+"API를 확장하여 더 많은 기능을 제공합니다. 클라이언트가 생일 카드에 대한 줄 목"
+"록을 지정할 수 있도록 합니다:"
+
+#: src/android/aidl/changing.md:9
+msgid ""
+"/** Birthday service interface. */\n"
+"interface IBirthdayService {\n"
+"    /** Generate a Happy Birthday message. */\n"
+"    String wishHappyBirthday(String name, int years, in String[] text);\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/android/logging.md:1
+msgid "# Logging"
+msgstr ""
+
+#: src/android/logging.md:3
+msgid ""
+"You should use the `log` crate to automatically log to `logcat` (on-device) "
+"or\n"
+"`stdout` (on-host):"
+msgstr ""
+"`log`크레이트를 사용하여 `logcat`(장치)나 `stdout`(호스트)에서 자동으로 로그"
+"를 기록하도록 합니다:"
+
+#: src/android/logging.md:6
+msgid "_hello_rust_logs/Android.bp_:"
+msgstr ""
+
+#: src/android/logging.md:8
+msgid ""
+"```javascript\n"
+"rust_binary {\n"
+"    name: \"hello_rust_logs\",\n"
+"    crate_name: \"hello_rust_logs\",\n"
+"    srcs: [\"src/main.rs\"],\n"
+"    rustlibs: [\n"
+"        \"liblog_rust\",\n"
+"        \"liblogger\",\n"
+"    ],\n"
+"    prefer_rlib: true,\n"
+"    host_supported: true,\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/android/logging.md:22
+msgid "_hello_rust_logs/src/main.rs_:"
+msgstr ""
+
+#: src/android/logging.md:24
+msgid ""
+"```rust,ignore\n"
+"//! Rust logging demo."
+msgstr ""
+
+#: src/android/logging.md:27
+msgid "use log::{debug, error};"
+msgstr ""
+
+#: src/android/logging.md:29
+msgid ""
+"/// Logs a greeting.\n"
+"fn main() {\n"
+"    logger::init(\n"
+"        logger::Config::default()\n"
+"            .with_tag_on_device(\"rust\")\n"
+"            .with_min_level(log::Level::Trace),\n"
+"    );\n"
+"    debug!(\"Starting program.\");\n"
+"    error!(\"Something went wrong!\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/android/logging.md:41 src/android/interoperability/with-c/bindgen.md:98
+#: src/android/interoperability/with-c/rust.md:73
+msgid "Build, push, and run the binary on your device:"
+msgstr "장치에서 바이너리를 빌드, 푸시, 실행합니다:"
+
+#: src/android/logging.md:43
+msgid ""
+"```shell\n"
+"$ m hello_rust_logs\n"
+"$ adb push $ANDROID_PRODUCT_OUT/system/bin/hello_rust_logs /data/local/tmp\n"
+"$ adb shell /data/local/tmp/hello_rust_logs\n"
+"```"
+msgstr ""
+
+#: src/android/logging.md:49
+msgid "The logs show up in `adb logcat`:"
+msgstr "`adb logcat`커맨드로 로그를 확인합니다:"
+
+#: src/android/logging.md:51
+msgid ""
+"```shell\n"
+"$ adb logcat -s rust\n"
+"09-08 08:38:32.454  2420  2420 D rust: hello_rust_logs: Starting program.\n"
+"09-08 08:38:32.454  2420  2420 I rust: hello_rust_logs: Things are going "
+"fine.\n"
+"09-08 08:38:32.454  2420  2420 E rust: hello_rust_logs: Something went "
+"wrong!\n"
+"```"
+msgstr ""
+
+#: src/android/interoperability.md:1
+msgid "# Interoperability"
+msgstr "# 상호운용성(Interoperability)"
+
+#: src/android/interoperability.md:3
+msgid ""
+"Rust has excellent support for interoperability with other languages. This "
+"means\n"
+"that you can:"
+msgstr ""
+"러스트는 다른 언어와의 상호운용성을 훌륭히 지원합니다. 즉, 다음을 수행할 수 "
+"있습니다:"
+
+#: src/android/interoperability.md:6
+msgid ""
+"* Call Rust functions from other languages.\n"
+"* Call functions written in other languages from Rust."
+msgstr ""
+"* 타 언어에서 rust 함수를 호출합니다. \n"
+"* 타 언어의 함수를 러스트에서 호출합니다."
+
+#: src/android/interoperability.md:9
+msgid ""
+"When you call functions in a foreign language we say that you're using a\n"
+"_foreign function interface_, also known as FFI."
+msgstr ""
+"타 언어의 함수를 호출해서 사용하는 것을 FFI(foreign function interface)라고 "
+"합니다."
+
+#: src/android/interoperability/with-c.md:1
+msgid "# Interoperability with C"
+msgstr "# C와의 상호운용성"
+
+#: src/android/interoperability/with-c.md:3
+msgid ""
+"Rust has full support for linking object files with a C calling convention.\n"
+"Similarly, you can export Rust functions and call them from C."
+msgstr ""
+"러스트는 C 호출규약과 함께 객체 파일을 연결하는 것을 완벽하게 지원합니다. \n"
+"반대로 러스트 함수를 내보내서 C에서 호출 할 수 있습니다. "
+
+#: src/android/interoperability/with-c.md:6
+msgid "You can do it by hand if you want:"
+msgstr "원하는 경우 직접 코딩할 수 있습니다: "
+
+#: src/android/interoperability/with-c.md:8
+msgid ""
+"```rust\n"
+"extern \"C\" {\n"
+"    fn abs(x: i32) -> i32;\n"
+"}"
+msgstr ""
+
+#: src/android/interoperability/with-c.md:13
+msgid ""
+"fn main() {\n"
+"    let x = -42;\n"
+"    let abs_x = unsafe { abs(x) };\n"
+"    println!(\"{x}, {abs_x}\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/android/interoperability/with-c.md:20
+msgid ""
+"We already saw this in the [Safe FFI Wrapper\n"
+"exercise](../../exercises/day-3/safe-ffi-wrapper.md)."
+msgstr ""
+"우리는 이미 [Safe FFI 래퍼 연습문제](../../exercises/day-3/safe-ffi-wrapper."
+"md)에서 이를 다루었습니다. "
+
+#: src/android/interoperability/with-c.md:23
+msgid ""
+"> This assumes full knowledge of the target platform. Not recommended for\n"
+"> production."
+msgstr ""
+"> 이는 대상 플랫폼에 대한 완전한 지식을 전제로 합니다. 실 제품에는 권장하진 "
+"않습니다."
+
+#: src/android/interoperability/with-c.md:26
+msgid "We will look at better options next."
+msgstr "다음으로 좀 더 나은 옵션을 살펴보겠습니다."
+
+#: src/android/interoperability/with-c/bindgen.md:1
+msgid "# Using Bindgen"
+msgstr ""
+
+#: src/android/interoperability/with-c/bindgen.md:3
+msgid ""
+"The [bindgen](https://rust-lang.github.io/rust-bindgen/introduction.html) "
+"tool\n"
+"can auto-generate bindings from a C header file."
+msgstr ""
+"[bindgen](https://rust-lang.github.io/rust-bindgen/introduction.html)는 C 헤"
+"더파일에서 자동으로 생성하는 도구입니다."
+
+#: src/android/interoperability/with-c/bindgen.md:6
+msgid "First create a small C library:"
+msgstr "작은 C라이브러리를 생성합니다."
+
+#: src/android/interoperability/with-c/bindgen.md:8
+msgid "_interoperability/bindgen/libbirthday.h_:"
+msgstr ""
+
+#: src/android/interoperability/with-c/bindgen.md:10
+msgid ""
+"```c\n"
+"typedef struct card {\n"
+"  const char* name;\n"
+"  int years;\n"
+"} card;"
+msgstr ""
+
+#: src/android/interoperability/with-c/bindgen.md:16
+msgid ""
+"void print_card(const card* card);\n"
+"```"
+msgstr ""
+
+#: src/android/interoperability/with-c/bindgen.md:19
+msgid "_interoperability/bindgen/libbirthday.c_:"
+msgstr ""
+
+#: src/android/interoperability/with-c/bindgen.md:21
+msgid ""
+"```c\n"
+"#include <stdio.h>\n"
+"#include \"libbirthday.h\""
+msgstr ""
+
+#: src/android/interoperability/with-c/bindgen.md:25
+msgid ""
+"void print_card(const card* card) {\n"
+"  printf(\"+--------------\\n\");\n"
+"  printf(\"| Happy Birthday %s!\\n\", card->name);\n"
+"  printf(\"| Congratulations with the %i years!\\n\", card->years);\n"
+"  printf(\"+--------------\\n\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/android/interoperability/with-c/bindgen.md:33
+msgid "Add this to your `Android.bp` file:"
+msgstr "`Android.bp` 파일에 아래를 추가합니다:"
+
+#: src/android/interoperability/with-c/bindgen.md:35
+#: src/android/interoperability/with-c/bindgen.md:55
+#: src/android/interoperability/with-c/bindgen.md:69
+#: src/android/interoperability/with-c/bindgen.md:108
+msgid "_interoperability/bindgen/Android.bp_:"
+msgstr ""
+
+#: src/android/interoperability/with-c/bindgen.md:37
+msgid ""
+"```javascript\n"
+"cc_library {\n"
+"    name: \"libbirthday\",\n"
+"    srcs: [\"libbirthday.c\"],\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/android/interoperability/with-c/bindgen.md:44
+msgid ""
+"Create a wrapper header file for the library (not strictly needed in this\n"
+"example):"
+msgstr ""
+"라이브러리에 대한 래퍼 헤더 파일을 만듭니다(이 예시에서는 필요하지 않습니다):"
+
+#: src/android/interoperability/with-c/bindgen.md:47
+msgid "_interoperability/bindgen/libbirthday_wrapper.h_:"
+msgstr ""
+
+#: src/android/interoperability/with-c/bindgen.md:49
+msgid ""
+"```c\n"
+"#include \"libbirthday.h\"\n"
+"```"
+msgstr ""
+
+#: src/android/interoperability/with-c/bindgen.md:53
+msgid "You can now auto-generate the bindings:"
+msgstr "이제 바인딩을 자동으로 생성할 수 있습니다:"
+
+#: src/android/interoperability/with-c/bindgen.md:57
+msgid ""
+"```javascript\n"
+"rust_bindgen {\n"
+"    name: \"libbirthday_bindgen\",\n"
+"    crate_name: \"birthday_bindgen\",\n"
+"    wrapper_src: \"libbirthday_wrapper.h\",\n"
+"    source_stem: \"bindings\",\n"
+"    static_libs: [\"libbirthday\"],\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/android/interoperability/with-c/bindgen.md:67
+msgid "Finally, we can use the bindings in our Rust program:"
+msgstr "마침내, 러스트 프로그램에서 바인딩을 사용할 수 있습니다:"
+
+#: src/android/interoperability/with-c/bindgen.md:71
+msgid ""
+"```javascript\n"
+"rust_binary {\n"
+"    name: \"print_birthday_card\",\n"
+"    srcs: [\"main.rs\"],\n"
+"    rustlibs: [\"libbirthday_bindgen\"],\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/android/interoperability/with-c/bindgen.md:79
+msgid "_interoperability/bindgen/main.rs_:"
+msgstr ""
+
+#: src/android/interoperability/with-c/bindgen.md:81
+msgid ""
+"```rust,compile_fail\n"
+"//! Bindgen demo."
+msgstr ""
+
+#: src/android/interoperability/with-c/bindgen.md:84
+msgid "use birthday_bindgen::{card, print_card};"
+msgstr ""
+
+#: src/android/interoperability/with-c/bindgen.md:86
+msgid ""
+"fn main() {\n"
+"    let name = std::ffi::CString::new(\"Peter\").unwrap();\n"
+"    let card = card {\n"
+"        name: name.as_ptr(),\n"
+"        years: 42,\n"
+"    };\n"
+"    unsafe {\n"
+"        print_card(&card as *const card);\n"
+"    }\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/android/interoperability/with-c/bindgen.md:100
+msgid ""
+"```shell\n"
+"$ m print_birthday_card\n"
+"$ adb push $ANDROID_PRODUCT_OUT/system/bin/print_birthday_card /data/local/"
+"tmp\n"
+"$ adb shell /data/local/tmp/print_birthday_card\n"
+"```"
+msgstr ""
+
+#: src/android/interoperability/with-c/bindgen.md:106
+msgid "Finally, we can run auto-generated tests to ensure the bindings work:"
+msgstr "마지막으로, 바인딩이 작동하는지 자동생성 테스트를 실행할 수 있습니다:"
+
+#: src/android/interoperability/with-c/bindgen.md:110
+msgid ""
+"```javascript\n"
+"rust_test {\n"
+"    name: \"libbirthday_bindgen_test\",\n"
+"    srcs: [\":libbirthday_bindgen\"],\n"
+"    crate_name: \"libbirthday_bindgen_test\",\n"
+"    test_suites: [\"general-tests\"],\n"
+"    auto_gen_config: true,\n"
+"    clippy_lints: \"none\", // Generated file, skip linting\n"
+"    lints: \"none\",\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/android/interoperability/with-c/bindgen.md:122
+msgid ""
+"```shell\n"
+"$ atest libbirthday_bindgen_test\n"
+"```"
+msgstr ""
+
+#: src/android/interoperability/with-c/rust.md:1
+msgid "# Calling Rust"
+msgstr "# C에서 러스트 호출"
+
+#: src/android/interoperability/with-c/rust.md:3
+msgid "Exporting Rust functions and types to C is easy:"
+msgstr "러스트에서 타입과 함수를 C로 내보내는 것은 간단합니다:"
+
+#: src/android/interoperability/with-c/rust.md:5
+msgid "_interoperability/rust/libanalyze/analyze.rs_"
+msgstr ""
+
+#: src/android/interoperability/with-c/rust.md:7
+msgid ""
+"```rust,editable\n"
+"//! Rust FFI demo.\n"
+"#![deny(improper_ctypes_definitions)]"
+msgstr ""
+
+#: src/android/interoperability/with-c/rust.md:11
+msgid "use std::os::raw::c_int;"
+msgstr ""
+
+#: src/android/interoperability/with-c/rust.md:13
+msgid ""
+"/// Analyze the numbers.\n"
+"#[no_mangle]\n"
+"pub extern \"C\" fn analyze_numbers(x: c_int, y: c_int) {\n"
+"    if x < y {\n"
+"        println!(\"x ({x}) is smallest!\");\n"
+"    } else {\n"
+"        println!(\"y ({y}) is probably larger than x ({x})\");\n"
+"    }\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/android/interoperability/with-c/rust.md:24
+msgid "_interoperability/rust/libanalyze/analyze.h_"
+msgstr ""
+
+#: src/android/interoperability/with-c/rust.md:26
+msgid ""
+"```c\n"
+"#ifndef ANALYSE_H\n"
+"#define ANALYSE_H"
+msgstr ""
+
+#: src/android/interoperability/with-c/rust.md:30
+msgid ""
+"extern \"C\" {\n"
+"void analyze_numbers(int x, int y);\n"
+"}"
+msgstr ""
+
+#: src/android/interoperability/with-c/rust.md:34
+msgid ""
+"#endif\n"
+"```"
+msgstr ""
+
+#: src/android/interoperability/with-c/rust.md:37
+msgid "_interoperability/rust/libanalyze/Android.bp_"
+msgstr ""
+
+#: src/android/interoperability/with-c/rust.md:39
+msgid ""
+"```javascript\n"
+"rust_ffi {\n"
+"    name: \"libanalyze_ffi\",\n"
+"    crate_name: \"analyze_ffi\",\n"
+"    srcs: [\"analyze.rs\"],\n"
+"    include_dirs: [\".\"],\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/android/interoperability/with-c/rust.md:48
+msgid "We can now call this from a C binary:"
+msgstr "이제 C바이너리에서 호출할 수 있습니다:"
+
+#: src/android/interoperability/with-c/rust.md:50
+msgid "_interoperability/rust/analyze/main.c_"
+msgstr ""
+
+#: src/android/interoperability/with-c/rust.md:52
+msgid ""
+"```c\n"
+"#include \"analyze.h\""
+msgstr ""
+
+#: src/android/interoperability/with-c/rust.md:55
+msgid ""
+"int main() {\n"
+"  analyze_numbers(10, 20);\n"
+"  analyze_numbers(123, 123);\n"
+"  return 0;\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/android/interoperability/with-c/rust.md:62
+msgid "_interoperability/rust/analyze/Android.bp_"
+msgstr ""
+
+#: src/android/interoperability/with-c/rust.md:64
+msgid ""
+"```javascript\n"
+"cc_binary {\n"
+"    name: \"analyze_numbers\",\n"
+"    srcs: [\"main.c\"],\n"
+"    static_libs: [\"libanalyze_ffi\"],\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/android/interoperability/with-c/rust.md:75
+msgid ""
+"```shell\n"
+"$ m analyze_numbers\n"
+"$ adb push $ANDROID_PRODUCT_OUT/system/bin/analyze_numbers /data/local/tmp\n"
+"$ adb shell /data/local/tmp/analyze_numbers\n"
+"```"
+msgstr ""
+
+#: src/android/interoperability/cpp.md:1
+msgid "# With C++"
+msgstr "# C++과의 상호운용성"
+
+#: src/android/interoperability/cpp.md:3
+msgid ""
+"The [CXX crate][1] makes it possible to do safe interoperability between "
+"Rust\n"
+"and C++."
+msgstr ""
+"[CXX 크레이트][1]는 러스트와 C++ 사이의 안전한 상호운용성을 가능하게 해줍니"
+"다."
+
+#: src/android/interoperability/cpp.md:6
+msgid "The overall approach looks like this:"
+msgstr "전체적인 접근 방법은 다음과 같습니다. "
+
+#: src/android/interoperability/cpp.md:8
+msgid "<img src=\"cpp/overview.svg\">"
+msgstr ""
+
+#: src/android/interoperability/cpp.md:10
+msgid "See the [CXX tutorial][2] for an full example of using this."
+msgstr "사용하는 방법에 대해서는[CXX 튜토리얼][2] 를 참조합니다."
+
+#: src/android/interoperability/cpp.md:12
+msgid ""
+"[1]: https://cxx.rs/\n"
+"[2]: https://cxx.rs/tutorial.html"
+msgstr ""
+
+#: src/android/interoperability/java.md:1
+msgid "# Interoperability with Java"
+msgstr "# Java와의 상호운용성"
+
+#: src/android/interoperability/java.md:3
+msgid ""
+"Java can load shared objects via [Java Native Interface\n"
+"(JNI)](https://en.wikipedia.org/wiki/Java_Native_Interface). The [`jni`\n"
+"crate](https://docs.rs/jni/) allows you to create a compatible library."
+msgstr ""
+"자바는 [Java Native Interface(JNI)](https://en.wikipedia.org/wiki/"
+"Java_Native_Interface)를 통해 공유 객체를 로드할 수 있습니다. [`jni` 크레이"
+"트](https://docs.rs/jni/)를 사용하여 호환 라이브러리를 만들 수 있습니다."
+
+#: src/android/interoperability/java.md:7
+msgid "First, we create a Rust function to export to Java:"
+msgstr "먼저, 자바로 내보낼 러스트 함수를 생성합니다:"
+
+#: src/android/interoperability/java.md:9
+msgid "_interoperability/java/src/lib.rs_:"
+msgstr ""
+
+#: src/android/interoperability/java.md:11
+msgid ""
+"```rust,compile_fail\n"
+"//! Rust <-> Java FFI demo."
+msgstr ""
+
+#: src/android/interoperability/java.md:14
+msgid ""
+"use jni::objects::{JClass, JString};\n"
+"use jni::sys::jstring;\n"
+"use jni::JNIEnv;"
+msgstr ""
+
+#: src/android/interoperability/java.md:18
+msgid ""
+"/// HelloWorld::hello method implementation.\n"
+"#[no_mangle]\n"
+"pub extern \"system\" fn Java_HelloWorld_hello(\n"
+"    env: JNIEnv,\n"
+"    _class: JClass,\n"
+"    name: JString,\n"
+") -> jstring {\n"
+"    let input: String = env.get_string(name).unwrap().into();\n"
+"    let greeting = format!(\"Hello, {input}!\");\n"
+"    let output = env.new_string(greeting).unwrap();\n"
+"    output.into_inner()\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/android/interoperability/java.md:32
+#: src/android/interoperability/java.md:62
+msgid "_interoperability/java/Android.bp_:"
+msgstr ""
+
+#: src/android/interoperability/java.md:34
+msgid ""
+"```javascript\n"
+"rust_ffi_shared {\n"
+"    name: \"libhello_jni\",\n"
+"    crate_name: \"hello_jni\",\n"
+"    srcs: [\"src/lib.rs\"],\n"
+"    rustlibs: [\"libjni\"],\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/android/interoperability/java.md:43
+msgid "Finally, we can call this function from Java:"
+msgstr "마침내, 자바에서 이 함수를 호출 할 수 있습니다:"
+
+#: src/android/interoperability/java.md:45
+msgid "_interoperability/java/HelloWorld.java_:"
+msgstr ""
+
+#: src/android/interoperability/java.md:47
+msgid ""
+"```java\n"
+"class HelloWorld {\n"
+"    private static native String hello(String name);"
+msgstr ""
+
+#: src/android/interoperability/java.md:51
+msgid ""
+"    static {\n"
+"        System.loadLibrary(\"hello_jni\");\n"
+"    }"
+msgstr ""
+
+#: src/android/interoperability/java.md:55
+msgid ""
+"    public static void main(String[] args) {\n"
+"        String output = HelloWorld.hello(\"Alice\");\n"
+"        System.out.println(output);\n"
+"    }\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/android/interoperability/java.md:64
+msgid ""
+"```javascript\n"
+"java_binary {\n"
+"    name: \"helloworld_jni\",\n"
+"    srcs: [\"HelloWorld.java\"],\n"
+"    main_class: \"HelloWorld\",\n"
+"    required: [\"libhello_jni\"],\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/android/interoperability/java.md:73
+msgid "Finally, you can build, sync, and run the binary:"
+msgstr "마지막으로 바이너리를 빌드, 싱크, 실행합니다: "
+
+#: src/android/interoperability/java.md:75
+msgid ""
+"```shell\n"
+"$ m helloworld_jni\n"
+"$ adb sync  # requires adb root && adb remount\n"
+"$ adb shell /system/bin/helloworld_jni\n"
+"```"
+msgstr ""
+
+#: src/exercises/day-4/afternoon.md:3
+msgid ""
+"For the last exercise, we will look at one of the projects you work with. "
+"Let us\n"
+"group up and do this together. Some suggestions:"
+msgstr ""
+"마지막 연습문제는 당신의 프로젝트 중 하나를 FFI로 러스트와 연계 해보는 것입니"
+"다. 몇가지 예시입니다: "
+
+#: src/exercises/day-4/afternoon.md:6
+msgid "* Call your AIDL service with a client written in Rust."
+msgstr "* 당신의 AIDL서비스를 러스트 클라이언트에서 호출해봅니다."
+
+#: src/exercises/day-4/afternoon.md:8
+msgid "* Move a function from your project to Rust and call it."
+msgstr "* 당신의 프로젝트의 함수를 러스트로 옮기고 호출해봅니다."
+
+#: src/thanks.md:1
+msgid "# Thanks!"
+msgstr ""
+
+#: src/thanks.md:3
+msgid ""
+"_Thank you for taking Comprehensive Rust 🦀!_ We hope you enjoyed it and "
+"that it\n"
+"was useful."
+msgstr ""
+"Comprehensive Rust 🦀를 이용해 주셔서 감사합니다. 즐겁고 유익한 시간이었기를 "
+"바랍니다."
+
+#: src/thanks.md:6
+msgid ""
+"We've had a lot of fun putting the course together. The course is not "
+"perfect,\n"
+"so if you spotted any mistakes or have ideas for improvements, please get "
+"in\n"
+"[contact with us on\n"
+"GitHub](https://github.com/google/comprehensive-rust/discussions). We would "
+"love\n"
+"to hear from you."
+msgstr ""
+"강의가 완벽하진 않으니 실수나 개선점이 있다면 언제든지 [깃허브](https://"
+"github.com/google/comprehensive-rust/discussions)로 연락주세요"
+
+#: src/other-resources.md:1
+msgid "# Other Rust Resources"
+msgstr "# 러스트 참고 자료"
+
+#: src/other-resources.md:3
+msgid ""
+"The Rust community has created a wealth of high-quality and free resources\n"
+"online."
+msgstr "러스트 커뮤니티는 온라인에서 고품질의 무료 소스를 만들었습니다."
+
+#: src/other-resources.md:6
+msgid "## Official Documentation"
+msgstr "## 공식 문서들"
+
+#: src/other-resources.md:8
+msgid "The Rust project hosts many resources. These cover Rust in general:"
+msgstr ""
+"러스트 프로젝트는 여러 리소스를 호스팅합니다. 일반적인 내용을 다루는 몇가지 "
+"참고 문서들입니다:"
+
+#: src/other-resources.md:10
+msgid ""
+"* [The Rust Programming Language](https://doc.rust-lang.org/book/): the\n"
+"  canonical free book about Rust. Covers the language in detail and includes "
+"a\n"
+"  few projects for people to build.\n"
+"* [Rust By Example](https://doc.rust-lang.org/rust-by-example/): covers the "
+"Rust\n"
+"  syntax via a series of examples which showcase different constructs. "
+"Sometimes\n"
+"  includes small exercises where you are asked to expand on the code in the\n"
+"  examples.\n"
+"* [Rust Standard Library](https://doc.rust-lang.org/std/): full "
+"documentation of\n"
+"  the standard library for Rust.\n"
+"* [The Rust Reference](https://doc.rust-lang.org/reference/): an incomplete "
+"book\n"
+"  which describes the Rust grammar and memory model."
+msgstr ""
+"* [The Rust Programming Language](https://doc.rust-lang.org/book/): 러스트에 "
+"대한 무료 표준 서적입니다. 언어에 대한 자세한 설명과 사람들이 빌드 할수 있는 "
+"몇가지 프로젝트를 포함합니다.\n"
+"* [Rust By Example](https://doc.rust-lang.org/rust-by-example/): 여러 예제를 "
+"통해 러스트의 문법을 보여주며 때때로 코드를 확장하는 약간의 연습문제들이 포함"
+"되어 있습니다.\n"
+"* [Rust Standard Library](https://doc.rust-lang.org/std/): 러스트 표준 라이브"
+"러리 전체 문서입니다.\n"
+"* [The Rust Reference](https://doc.rust-lang.org/reference/): 메모리 모델링"
+"과 러스트 문법을 설명하는 문서입니다.(아직 불완전하다함)"
+
+#: src/other-resources.md:22
+msgid "More specialized guides hosted on the official Rust site:"
+msgstr "좀 더 전문적인 공식 가이드입니다:"
+
+#: src/other-resources.md:24
+msgid ""
+"* [The Rustonomicon](https://doc.rust-lang.org/nomicon/): covers unsafe "
+"Rust,\n"
+"  including working with raw pointers and interfacing with other languages\n"
+"  (FFI).\n"
+"* [Asynchronous Programming in Rust](https://rust-lang.github.io/async-"
+"book/):\n"
+"  covers the new asynchronous programming model which was introduced after "
+"the\n"
+"  Rust Book was written.\n"
+"* [The Embedded Rust Book](https://doc.rust-lang.org/stable/embedded-book/): "
+"an\n"
+"  introduction to using Rust on embedded devices without an operating system."
+msgstr ""
+"* [The Rustonomicon](https://doc.rust-lang.org/nomicon/): 안전하지 않은 러스"
+"트, FFI, raw포인터 작업을 다룹니다.\n"
+"* [Asynchronous Programming in Rust](https://rust-lang.github.io/async-"
+"book/): 러스트 북이 작성 된 이후 도입된 새로운 비동기 프로그래밍 모델을 다룹"
+"니다.\n"
+"* [The Embedded Rust Book](https://doc.rust-lang.org/stable/embedded-book/): "
+"운영체제가 없는 임베디드 장치에서의 러스트 사용법을 소개합니다."
+
+#: src/other-resources.md:33
+msgid "## Unofficial Learning Material"
+msgstr "## 비공식적 학습 자료"
+
+#: src/other-resources.md:35
+msgid "A small selection of other guides and tutorial for Rust:"
+msgstr "러스트에 대한 기타 안내서와 튜토리얼의 일부입니다:"
+
+#: src/other-resources.md:37
+msgid ""
+"* [Learn Rust the Dangerous Way](http://cliffle.com/p/dangerust/): covers "
+"Rust\n"
+"  from the perspective of low-level C programmers.\n"
+"* [Rust for Embedded C\n"
+"  Programmers](https://docs.opentitan.org/doc/ug/rust_for_c/): covers Rust "
+"from\n"
+"  the perspective of developers who write firmware in C.\n"
+"* [Rust for professionals](https://overexact.com/rust-for-professionals/):\n"
+"  covers the syntax of Rust using side-by-side comparisons with other "
+"languages\n"
+"  such as C, C++, Java, JavaScript, and Python.\n"
+"* [Rust on Exercism](https://exercism.org/tracks/rust): 100+ exercises to "
+"help\n"
+"  you learn Rust.\n"
+"* [Ferrous Teaching\n"
+"  Material](https://ferrous-systems.github.io/teaching-material/index.html): "
+"a\n"
+"  series of small presentations covering both basic and advanced part of "
+"the\n"
+"  Rust language. Other topics such as WebAssembly, and async/await are also\n"
+"  covered.\n"
+"* [Beginner's Series to\n"
+"  Rust](https://docs.microsoft.com/en-us/shows/beginners-series-to-rust/) "
+"and\n"
+"  [Take your first steps with\n"
+"  Rust](https://docs.microsoft.com/en-us/learn/paths/rust-first-steps/): "
+"two\n"
+"  Rust guides aimed at new developers. The first is a set of 35 videos and "
+"the\n"
+"  second is a set of 11 modules which covers Rust syntax and basic "
+"constructs."
+msgstr ""
+"* [Learn Rust the Dangerous Way](http://cliffle.com/p/dangerust/): C언어 프로"
+"그래머 관점에서 러스트를 다룹니다.\n"
+"* [Rust for Embedded C Programmers](https://docs.opentitan.org/doc/ug/"
+"rust_for_c/): 임베디드 C개발자(펌웨어 개발자)를 위한 러스트 가이드입니다.\n"
+"* [Rust for professionals](https://overexact.com/rust-for-professionals/): 다"
+"른 언어(C/C++, Java, Python, Javascript)와의 병렬비교를 사용하여 러스트 문법"
+"을 다룹니다.\n"
+"* [Rust on Exercism](https://exercism.org/tracks/rust): 러스트를 배우는데 도"
+"움이 되는 100개 이상의 연습문제\n"
+"* [Ferrous Teaching Material](https://ferrous-systems.github.io/teaching-"
+"material/index.html): 러스트 언어의 기본부터 고급을 전부 다루는 일련의 작은 "
+"프레젠테이션, 웹 어셈블리, async/await 같은 부분도 함께 다룹니다.\n"
+"* [Beginner's Series to Rust](https://docs.microsoft.com/en-us/shows/"
+"beginners-series-to-rust/), [Take your first steps with Rust](https://docs."
+"microsoft.com/en-us/learn/paths/rust-first-steps/): 첫번째는 35개의 시리즈 영"
+"상이며 두번째는 러스트의 문법과 구조를 다루는 11개의 모듈 세트입니다."
+
+#: src/other-resources.md:59
+msgid ""
+"Please see the [Little Book of Rust Books](https://lborb.github.io/book/) "
+"for\n"
+"even more Rust books."
+msgstr ""
+"[Little Book of Rust Books](https://lborb.github.io/book/)에서 더 많은 러스"
+"트 북을 확인해보세요."
+
+#: src/credits.md:1
+msgid "# Credits"
+msgstr ""
+
+#: src/credits.md:3
+msgid ""
+"The material here builds on top of the many great sources of Rust "
+"documentation.\n"
+"See the page on [other resources](other-resources.md) for a full list of "
+"useful\n"
+"resources."
+msgstr ""
+"이 자료는 많은 훌륭한 러스트 문서들의 도움을 받아 작성되었습니다. \n"
+"유용한 자료의 전체 목록은 [other resources](other-resources.md)에서 살펴보시"
+"기 바랍니다."
+
+#: src/credits.md:7
+msgid ""
+"The material of Comprehensive Rust is licensed under the terms of the Apache "
+"2.0\n"
+"license, please see [`LICENSE.txt`](../LICENSE.txt) for details."
+msgstr ""
+"Comprehensive Rust의 자료는 Apache 2.0 라이선스를 따릅니다. 자세한건 "
+"[`LICENSE.txt`](../LICENSE.txt) 확인해 보시기 바랍니다."
+
+#: src/credits.md:10
+msgid "## Rust by Example"
+msgstr ""
+
+#: src/credits.md:12
+msgid ""
+"Some examples and exercises have been copied and adapted from [Rust by\n"
+"Example](https://doc.rust-lang.org/rust-by-example/). Please see the\n"
+"`third_party/rust-by-example/` directory for details, including the license\n"
+"terms."
+msgstr ""
+"일부 예제와 연습문제는 [Rust by Example](https://doc.rust-lang.org/rust-by-"
+"example/)을 참조하였습니다. 라이선스 조항을 포함하여 저장소의 `third_party/"
+"rust-by-example/` 폴더를 참조하시기 바랍니다."
+
+#: src/credits.md:17
+msgid "## Rust on Exercism"
+msgstr ""
+
+#: src/credits.md:19
+msgid ""
+"Some exercises have been copied and adapted from [Rust on\n"
+"Exercism](https://exercism.org/tracks/rust). Please see the\n"
+"`third_party/rust-on-exercism/` directory for details, including the "
+"license\n"
+"terms."
+msgstr ""
+"일부 연습문제는 [Rust on Exercism](https://exercism.org/tracks/rust)을 참조하"
+"였습니다.\n"
+"라이선스 조항을 포함하여 저장소의 `third_party/rust-on-exercism/`폴더를 참조"
+"하시기 바랍니다."
+
+#: src/credits.md:24
+msgid "## CXX"
+msgstr ""
+
+#: src/credits.md:26
+msgid ""
+"The [Interoperability with C++](android/interoperability/cpp.md) section "
+"uses an\n"
+"image from [CXX](https://cxx.rs/). Please see the `third_party/cxx/` "
+"directory\n"
+"for details, including the license terms."
+msgstr ""
+"4일차 오후 강의 중 [Interoperability with C++](android/interoperability/cpp."
+"md)에서는 [CXX](https://cxx.rs/)의 이미지를 사용하였습니다. \n"
+"라이선스 조항을 포함하여 저장소의 `third_party/cxx/`폴더를 참조하시기 바랍니"
+"다."
+
+#: src/exercises/solutions.md:1
+msgid "# Solutions"
+msgstr "# 정답"
+
+#: src/exercises/solutions.md:3
+msgid "You will find solutions to the exercises on the following pages."
+msgstr "연습문제의 정답은 다음 페이지에서 확인할 수 있습니다."
+
+#: src/exercises/solutions.md:5
+msgid ""
+"Feel free to ask questions about the solutions [on\n"
+"GitHub](https://github.com/google/comprehensive-rust/discussions). Let us "
+"know\n"
+"if you have a different or better solution than what is presented here."
+msgstr ""
+"[깃허브](https://github.com/google/comprehensive-rust/discussions)에서 이에 "
+"대해 자유롭게 질문하시고 더 나은 솔루션이 있다면 알려주시기 바랍니다."
+
+#: src/exercises/solutions.md:10
+msgid ""
+"> **Note:** Please ignore the `// ANCHOR: label` and `// ANCHOR_END: label`\n"
+"> comments you see in the solutions. They are there to make it possible to\n"
+"> re-use parts of the solutions as the exercises."
+msgstr ""
+"> **참고:** `// ANCHOR: label`과  `// ANCHOR_END: label` 주석은 문제를 구성하"
+"기 위한 메타 주석으로 무시하시면 됩니다."
+
+#: src/exercises/day-1/solutions-morning.md:1
+msgid "# Day 1 Morning Exercises"
+msgstr "# 1일차 오전 연습문제"
+
+#: src/exercises/day-1/solutions-morning.md:3
+msgid "## Arrays and `for` Loops"
+msgstr "## 배열과 `for`반복문"
+
+#: src/exercises/day-1/solutions-morning.md:5
+msgid "([back to exercise](for-loops.md))"
+msgstr ""
+
+#: src/exercises/day-1/solutions-morning.md:7
+#: src/exercises/day-1/solutions-afternoon.md:7
+#: src/exercises/day-2/solutions-morning.md:7
+#: src/exercises/day-2/solutions-afternoon.md:7
+#: src/exercises/day-2/solutions-afternoon.md:102
+#: src/exercises/day-3/solutions-morning.md:7
+#: src/exercises/day-3/solutions-afternoon.md:7
+#: src/exercises/day-4/solutions-morning.md:7
+msgid ""
+"```rust\n"
+"// Copyright 2022 Google LLC\n"
+"//\n"
+"// Licensed under the Apache License, Version 2.0 (the \"License\");\n"
+"// you may not use this file except in compliance with the License.\n"
+"// You may obtain a copy of the License at\n"
+"//\n"
+"//      http://www.apache.org/licenses/LICENSE-2.0\n"
+"//\n"
+"// Unless required by applicable law or agreed to in writing, software\n"
+"// distributed under the License is distributed on an \"AS IS\" BASIS,\n"
+"// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n"
+"// See the License for the specific language governing permissions and\n"
+"// limitations under the License."
+msgstr ""
+
+#: src/exercises/day-1/solutions-morning.md:22
+msgid ""
+"// ANCHOR: transpose\n"
+"fn transpose(matrix: [[i32; 3]; 3]) -> [[i32; 3]; 3] {\n"
+"    // ANCHOR_END: transpose\n"
+"    let mut result = [[0; 3]; 3];\n"
+"    for i in 0..3 {\n"
+"        for j in 0..3 {\n"
+"            result[j][i] = matrix[i][j];\n"
+"        }\n"
+"    }\n"
+"    return result;\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-1/solutions-morning.md:34
+msgid ""
+"// ANCHOR: pretty_print\n"
+"fn pretty_print(matrix: &[[i32; 3]; 3]) {\n"
+"    // ANCHOR_END: pretty_print\n"
+"    for row in matrix {\n"
+"        println!(\"{row:?}\");\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-1/solutions-morning.md:42
+msgid ""
+"// ANCHOR: tests\n"
+"#[test]\n"
+"fn test_transpose() {\n"
+"    let matrix = [\n"
+"        [101, 102, 103], //\n"
+"        [201, 202, 203],\n"
+"        [301, 302, 303],\n"
+"    ];\n"
+"    let transposed = transpose(matrix);\n"
+"    assert_eq!(\n"
+"        transposed,\n"
+"        [\n"
+"            [101, 201, 301], //\n"
+"            [102, 202, 302],\n"
+"            [103, 203, 303],\n"
+"        ]\n"
+"    );\n"
+"}\n"
+"// ANCHOR_END: tests"
+msgstr ""
+
+#: src/exercises/day-1/solutions-morning.md:62
+msgid ""
+"// ANCHOR: main\n"
+"fn main() {\n"
+"    let matrix = [\n"
+"        [101, 102, 103], // <-- the comment makes rustfmt add a newline\n"
+"        [201, 202, 203],\n"
+"        [301, 302, 303],\n"
+"    ];"
+msgstr ""
+
+#: src/exercises/day-1/solutions-morning.md:73
+msgid ""
+"    let transposed = transpose(matrix);\n"
+"    println!(\"transposed:\");\n"
+"    pretty_print(&transposed);\n"
+"}\n"
+"```\n"
+"### Bonus question"
+msgstr ""
+
+#: src/exercises/day-1/solutions-morning.md:80
+msgid ""
+"It honestly doesn't work so well. It might seem that we could use a slice-of-"
+"slices (`&[&[i32]]`) as the input type to transpose and thus make our "
+"function handle any size of matrix. However, this quickly breaks down: the "
+"return type cannot be `&[&[i32]]` since it needs to own the data you return."
+msgstr ""
+"사실 잘 동작하진 않습니다. slice-of-slices (`&[&[i32]]`)을 입력 타입으로 사용"
+"하여 모든 크기의 행렬을 처리할 수 있습니다. 하지만 리턴 값을 소유해야 하기때"
+"문에 `&[&[i32]]` 타입을 사용할 순 없습니다. "
+
+#: src/exercises/day-1/solutions-morning.md:82
+msgid ""
+"You can attempt to use something like `Vec<Vec<i32>>`, but this doesn't work "
+"very well either: it's hard to convert from `Vec<Vec<i32>>` to `&[&[i32]]` "
+"so now you cannot easily use `pretty_print` either."
+msgstr ""
+"`Vec<Vec<i32>>`와 같은 타입을 사용하려고 시도할 수도 있지만 역시 잘 동작하진 "
+"않습니다:  `Vec<Vec<i32>>` 타입을 `&[&[i32]]`로 변환하는 것이 어렵기 때문에 "
+"`pretty_print`을 사용하는데 어려움이 있습니다."
+
+#: src/exercises/day-1/solutions-afternoon.md:1
+msgid "# Day 1 Afternoon Exercises"
+msgstr "# 1일차 오후 연습문제"
+
+#: src/exercises/day-1/solutions-afternoon.md:3
+msgid "## Designing a Library"
+msgstr "## 도서관 설계"
+
+#: src/exercises/day-1/solutions-afternoon.md:5
+msgid "([back to exercise](book-library.md))"
+msgstr ""
+
+#: src/exercises/day-1/solutions-afternoon.md:22
+msgid ""
+"// ANCHOR: setup\n"
+"struct Library {\n"
+"    books: Vec<Book>,\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-1/solutions-afternoon.md:42
+msgid ""
+"// This makes it possible to print Book values with {}.\n"
+"impl std::fmt::Display for Book {\n"
+"    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {\n"
+"        write!(f, \"{} ({})\", self.title, self.year)\n"
+"    }\n"
+"}\n"
+"// ANCHOR_END: setup"
+msgstr ""
+
+#: src/exercises/day-1/solutions-afternoon.md:50
+msgid ""
+"// ANCHOR: Library_new\n"
+"impl Library {\n"
+"    fn new() -> Library {\n"
+"        // ANCHOR_END: Library_new\n"
+"        Library { books: Vec::new() }\n"
+"    }"
+msgstr ""
+
+#: src/exercises/day-1/solutions-afternoon.md:57
+msgid ""
+"    // ANCHOR: Library_len\n"
+"    //fn len(self) -> usize {\n"
+"    //    unimplemented!()\n"
+"    //}\n"
+"    // ANCHOR_END: Library_len\n"
+"    fn len(&self) -> usize {\n"
+"        self.books.len()\n"
+"    }"
+msgstr ""
+
+#: src/exercises/day-1/solutions-afternoon.md:66
+msgid ""
+"    // ANCHOR: Library_is_empty\n"
+"    //fn is_empty(self) -> bool {\n"
+"    //    unimplemented!()\n"
+"    //}\n"
+"    // ANCHOR_END: Library_is_empty\n"
+"    fn is_empty(&self) -> bool {\n"
+"        self.books.is_empty()\n"
+"    }"
+msgstr ""
+
+#: src/exercises/day-1/solutions-afternoon.md:75
+msgid ""
+"    // ANCHOR: Library_add_book\n"
+"    //fn add_book(self, book: Book) {\n"
+"    //    unimplemented!()\n"
+"    //}\n"
+"    // ANCHOR_END: Library_add_book\n"
+"    fn add_book(&mut self, book: Book) {\n"
+"        self.books.push(book)\n"
+"    }"
+msgstr ""
+
+#: src/exercises/day-1/solutions-afternoon.md:84
+msgid ""
+"    // ANCHOR: Library_print_books\n"
+"    //fn print_books(self) {\n"
+"    //    unimplemented!()\n"
+"    //}\n"
+"    // ANCHOR_END: Library_print_books\n"
+"    fn print_books(&self) {\n"
+"        for book in &self.books {\n"
+"            println!(\"{}\", book);\n"
+"        }\n"
+"    }"
+msgstr ""
+
+#: src/exercises/day-1/solutions-afternoon.md:95
+msgid ""
+"    // ANCHOR: Library_oldest_book\n"
+"    //fn oldest_book(self) -> Option<&Book> {\n"
+"    //    unimplemented!()\n"
+"    //}\n"
+"    // ANCHOR_END: Library_oldest_book\n"
+"    fn oldest_book(&self) -> Option<&Book> {\n"
+"        self.books.iter().min_by_key(|book| book.year)\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-1/solutions-afternoon.md:105
+msgid ""
+"// ANCHOR: main\n"
+"// This shows the desired behavior. Uncomment the code below and\n"
+"// implement the missing methods. You will need to update the\n"
+"// method signatures, including the \"self\" parameter!\n"
+"fn main() {\n"
+"    let library = Library::new();"
+msgstr ""
+
+#: src/exercises/day-1/solutions-afternoon.md:112
+msgid ""
+"    //println!(\"Our library is empty: {}\", library.is_empty());\n"
+"    //\n"
+"    //library.add_book(Book::new(\"Lord of the Rings\", 1954));\n"
+"    //library.add_book(Book::new(\"Alice's Adventures in Wonderland\", "
+"1865));\n"
+"    //\n"
+"    //library.print_books();\n"
+"    //\n"
+"    //match library.oldest_book() {\n"
+"    //    Some(book) => println!(\"My oldest book is {book}\"),\n"
+"    //    None => println!(\"My library is empty!\"),\n"
+"    //}\n"
+"    //\n"
+"    //println!(\"Our library has {} books\", library.len());\n"
+"}\n"
+"// ANCHOR_END: main"
+msgstr ""
+
+#: src/exercises/day-1/solutions-afternoon.md:128
+msgid ""
+"#[test]\n"
+"fn test_library_len() {\n"
+"    let mut library = Library::new();\n"
+"    assert_eq!(library.len(), 0);\n"
+"    assert!(library.is_empty());"
+msgstr ""
+
+#: src/exercises/day-1/solutions-afternoon.md:134
+msgid ""
+"    library.add_book(Book::new(\"Lord of the Rings\", 1954));\n"
+"    library.add_book(Book::new(\"Alice's Adventures in Wonderland\", "
+"1865));\n"
+"    assert_eq!(library.len(), 2);\n"
+"    assert!(!library.is_empty());\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-1/solutions-afternoon.md:140
+msgid ""
+"#[test]\n"
+"fn test_library_is_empty() {\n"
+"    let mut library = Library::new();\n"
+"    assert!(library.is_empty());"
+msgstr ""
+
+#: src/exercises/day-1/solutions-afternoon.md:145
+msgid ""
+"    library.add_book(Book::new(\"Lord of the Rings\", 1954));\n"
+"    assert!(!library.is_empty());\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-1/solutions-afternoon.md:149
+msgid ""
+"#[test]\n"
+"fn test_library_print_books() {\n"
+"    let mut library = Library::new();\n"
+"    library.add_book(Book::new(\"Lord of the Rings\", 1954));\n"
+"    library.add_book(Book::new(\"Alice's Adventures in Wonderland\", "
+"1865));\n"
+"    // We could try and capture stdout, but let us just call the\n"
+"    // method to start with.\n"
+"    library.print_books();\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-1/solutions-afternoon.md:159
+msgid ""
+"#[test]\n"
+"fn test_library_oldest_book() {\n"
+"    let mut library = Library::new();\n"
+"    assert!(library.oldest_book().is_none());"
+msgstr ""
+
+#: src/exercises/day-1/solutions-afternoon.md:164
+msgid ""
+"    library.add_book(Book::new(\"Lord of the Rings\", 1954));\n"
+"    assert_eq!(\n"
+"        library.oldest_book().map(|b| b.title.as_str()),\n"
+"        Some(\"Lord of the Rings\")\n"
+"    );"
+msgstr ""
+
+#: src/exercises/day-1/solutions-afternoon.md:170
+msgid ""
+"    library.add_book(Book::new(\"Alice's Adventures in Wonderland\", "
+"1865));\n"
+"    assert_eq!(\n"
+"        library.oldest_book().map(|b| b.title.as_str()),\n"
+"        Some(\"Alice's Adventures in Wonderland\")\n"
+"    );\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/exercises/day-2/solutions-morning.md:1
+msgid "# Day 2 Morning Exercises"
+msgstr "# 2일차 오전 연습문제"
+
+#: src/exercises/day-2/solutions-morning.md:3
+msgid "## Points and Polygons"
+msgstr "## 점과 다각형"
+
+#: src/exercises/day-2/solutions-morning.md:5
+msgid "([back to exercise](points-polygons.md))"
+msgstr ""
+
+#: src/exercises/day-2/solutions-morning.md:22
+msgid ""
+"#[derive(Debug, Copy, Clone, PartialEq, Eq)]\n"
+"// ANCHOR: Point\n"
+"pub struct Point {\n"
+"    // ANCHOR_END: Point\n"
+"    x: i32,\n"
+"    y: i32,\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-2/solutions-morning.md:30
+msgid ""
+"// ANCHOR: Point-impl\n"
+"impl Point {\n"
+"    // ANCHOR_END: Point-impl\n"
+"    pub fn new(x: i32, y: i32) -> Point {\n"
+"        Point { x, y }\n"
+"    }"
+msgstr ""
+
+#: src/exercises/day-2/solutions-morning.md:37
+msgid ""
+"    pub fn magnitude(self) -> f64 {\n"
+"        f64::from(self.x.pow(2) + self.y.pow(2)).sqrt()\n"
+"    }"
+msgstr ""
+
+#: src/exercises/day-2/solutions-morning.md:41
+msgid ""
+"    pub fn dist(self, other: Point) -> f64 {\n"
+"        (self - other).magnitude()\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-2/solutions-morning.md:49
+msgid ""
+"    fn add(self, other: Self) -> Self::Output {\n"
+"        Self {\n"
+"            x: self.x + other.x,\n"
+"            y: self.y + other.y,\n"
+"        }\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-2/solutions-morning.md:57
+msgid ""
+"impl std::ops::Sub for Point {\n"
+"    type Output = Self;"
+msgstr ""
+
+#: src/exercises/day-2/solutions-morning.md:60
+msgid ""
+"    fn sub(self, other: Self) -> Self::Output {\n"
+"        Self {\n"
+"            x: self.x - other.x,\n"
+"            y: self.y - other.y,\n"
+"        }\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-2/solutions-morning.md:68
+msgid ""
+"// ANCHOR: Polygon\n"
+"pub struct Polygon {\n"
+"    // ANCHOR_END: Polygon\n"
+"    points: Vec<Point>,\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-2/solutions-morning.md:74
+msgid ""
+"// ANCHOR: Polygon-impl\n"
+"impl Polygon {\n"
+"    // ANCHOR_END: Polygon-impl\n"
+"    pub fn new() -> Polygon {\n"
+"        Polygon { points: Vec::new() }\n"
+"    }"
+msgstr ""
+
+#: src/exercises/day-2/solutions-morning.md:81
+msgid ""
+"    pub fn add_point(&mut self, point: Point) {\n"
+"        self.points.push(point);\n"
+"    }"
+msgstr ""
+
+#: src/exercises/day-2/solutions-morning.md:85
+msgid ""
+"    pub fn left_most_point(&self) -> Option<Point> {\n"
+"        self.points.iter().min_by_key(|p| p.x).copied()\n"
+"    }"
+msgstr ""
+
+#: src/exercises/day-2/solutions-morning.md:89
+msgid ""
+"    pub fn iter(&self) -> impl Iterator<Item = &Point> {\n"
+"        self.points.iter()\n"
+"    }"
+msgstr ""
+
+#: src/exercises/day-2/solutions-morning.md:93
+msgid ""
+"    pub fn length(&self) -> f64 {\n"
+"        if self.points.is_empty() {\n"
+"            return 0.0;\n"
+"        }"
+msgstr ""
+
+#: src/exercises/day-2/solutions-morning.md:98
+msgid ""
+"        let mut result = 0.0;\n"
+"        let mut last_point = self.points[0];\n"
+"        for point in &self.points[1..] {\n"
+"            result += last_point.dist(*point);\n"
+"            last_point = *point;\n"
+"        }\n"
+"        result += last_point.dist(self.points[0]);\n"
+"        result\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-2/solutions-morning.md:109
+msgid ""
+"// ANCHOR: Circle\n"
+"pub struct Circle {\n"
+"    // ANCHOR_END: Circle\n"
+"    center: Point,\n"
+"    radius: i32,\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-2/solutions-morning.md:116
+msgid ""
+"// ANCHOR: Circle-impl\n"
+"impl Circle {\n"
+"    // ANCHOR_END: Circle-impl\n"
+"    pub fn new(center: Point, radius: i32) -> Circle {\n"
+"        Circle { center, radius }\n"
+"    }"
+msgstr ""
+
+#: src/exercises/day-2/solutions-morning.md:123
+msgid ""
+"    pub fn circumference(&self) -> f64 {\n"
+"        2.0 * std::f64::consts::PI * f64::from(self.radius)\n"
+"    }"
+msgstr ""
+
+#: src/exercises/day-2/solutions-morning.md:127
+msgid ""
+"    pub fn dist(&self, other: &Self) -> f64 {\n"
+"        self.center.dist(other.center)\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-2/solutions-morning.md:132
+msgid ""
+"// ANCHOR: Shape\n"
+"pub enum Shape {\n"
+"    Polygon(Polygon),\n"
+"    Circle(Circle),\n"
+"}\n"
+"// ANCHOR_END: Shape"
+msgstr ""
+
+#: src/exercises/day-2/solutions-morning.md:139
+msgid ""
+"impl From<Polygon> for Shape {\n"
+"    fn from(poly: Polygon) -> Self {\n"
+"        Shape::Polygon(poly)\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-2/solutions-morning.md:145
+msgid ""
+"impl From<Circle> for Shape {\n"
+"    fn from(circle: Circle) -> Self {\n"
+"        Shape::Circle(circle)\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-2/solutions-morning.md:151
+msgid ""
+"impl Shape {\n"
+"    pub fn circumference(&self) -> f64 {\n"
+"        match self {\n"
+"            Shape::Polygon(poly) => poly.length(),\n"
+"            Shape::Circle(circle) => circle.circumference(),\n"
+"        }\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-2/solutions-morning.md:160
+msgid ""
+"// ANCHOR: unit-tests\n"
+"#[cfg(test)]\n"
+"mod tests {\n"
+"    use super::*;"
+msgstr ""
+
+#: src/exercises/day-2/solutions-morning.md:213
+msgid ""
+"    #[test]\n"
+"    fn test_shape_circumferences() {\n"
+"        let mut poly = Polygon::new();\n"
+"        poly.add_point(Point::new(12, 13));\n"
+"        poly.add_point(Point::new(17, 11));\n"
+"        poly.add_point(Point::new(16, 16));\n"
+"        let shapes = vec![\n"
+"            Shape::from(poly),\n"
+"            Shape::from(Circle::new(Point::new(10, 20), 5)),\n"
+"        ];\n"
+"        let circumferences = shapes\n"
+"            .iter()\n"
+"            .map(Shape::circumference)\n"
+"            .map(round_two_digits)\n"
+"            .collect::<Vec<_>>();\n"
+"        assert_eq!(circumferences, vec![15.48, 31.42]);\n"
+"    }\n"
+"}\n"
+"// ANCHOR_END: unit-tests"
+msgstr ""
+
+#: src/exercises/day-2/solutions-afternoon.md:1
+msgid "# Day 2 Afternoon Exercises"
+msgstr "# 2일차 오후 연습문제"
+
+#: src/exercises/day-2/solutions-afternoon.md:3
+msgid "## Luhn Algorithm"
+msgstr "## 룬 알고리즘"
+
+#: src/exercises/day-2/solutions-afternoon.md:5
+msgid "([back to exercise](luhn.md))"
+msgstr ""
+
+#: src/exercises/day-2/solutions-afternoon.md:22
+msgid ""
+"// ANCHOR: luhn\n"
+"pub fn luhn(cc_number: &str) -> bool {\n"
+"    // ANCHOR_END: luhn\n"
+"    let mut digits_seen = 0;\n"
+"    let mut sum = 0;\n"
+"    for (i, ch) in cc_number.chars().rev().filter(|&ch| ch != ' ')."
+"enumerate() {\n"
+"        match ch.to_digit(10) {\n"
+"            Some(d) => {\n"
+"                sum += if i % 2 == 1 {\n"
+"                    let dd = d * 2;\n"
+"                    dd / 10 + dd % 10\n"
+"                } else {\n"
+"                    d\n"
+"                };\n"
+"                digits_seen += 1;\n"
+"            }\n"
+"            None => return false,\n"
+"        }\n"
+"    }"
+msgstr ""
+
+#: src/exercises/day-2/solutions-afternoon.md:42
+msgid ""
+"    if digits_seen < 2 {\n"
+"        return false;\n"
+"    }"
+msgstr ""
+
+#: src/exercises/day-2/solutions-afternoon.md:46
+msgid ""
+"    sum % 10 == 0\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-2/solutions-afternoon.md:49
+msgid ""
+"fn main() {\n"
+"    let cc_number = \"1234 5678 1234 5670\";\n"
+"    println!(\n"
+"        \"Is {} a valid credit card number? {}\",\n"
+"        cc_number,\n"
+"        if luhn(cc_number) { \"yes\" } else { \"no\" }\n"
+"    );\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-2/solutions-afternoon.md:58
+msgid ""
+"// ANCHOR: unit-tests\n"
+"#[test]\n"
+"fn test_non_digit_cc_number() {\n"
+"    assert!(!luhn(\"foo\"));\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-2/solutions-afternoon.md:89
+msgid ""
+"#[test]\n"
+"fn test_invalid_cc_number() {\n"
+"    assert!(!luhn(\"4223 9826 4026 9299\"));\n"
+"    assert!(!luhn(\"4539 3195 0343 6476\"));\n"
+"    assert!(!luhn(\"8273 1232 7352 0569\"));\n"
+"}\n"
+"// ANCHOR_END: unit-tests\n"
+"```"
+msgstr ""
+
+#: src/exercises/day-2/solutions-afternoon.md:98
+msgid "## Strings and Iterators"
+msgstr "## 문자열과 반복자"
+
+#: src/exercises/day-2/solutions-afternoon.md:100
+msgid "([back to exercise](strings-iterators.md))"
+msgstr ""
+
+#: src/exercises/day-2/solutions-afternoon.md:117
+msgid ""
+"// ANCHOR: prefix_matches\n"
+"pub fn prefix_matches(prefix: &str, request_path: &str) -> bool {\n"
+"    // ANCHOR_END: prefix_matches\n"
+"    let prefixes = prefix.split('/');\n"
+"    let request_paths = request_path\n"
+"        .split('/')\n"
+"        .map(|p| Some(p))\n"
+"        .chain(std::iter::once(None));"
+msgstr ""
+
+#: src/exercises/day-2/solutions-afternoon.md:126
+msgid ""
+"    for (prefix, request_path) in prefixes.zip(request_paths) {\n"
+"        match request_path {\n"
+"            Some(request_path) => {\n"
+"                if (prefix != \"*\") && (prefix != request_path) {\n"
+"                    return false;\n"
+"                }\n"
+"            }\n"
+"            None => return false,\n"
+"        }\n"
+"    }\n"
+"    true\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-2/solutions-afternoon.md:139
+msgid ""
+"// ANCHOR: unit-tests\n"
+"#[test]\n"
+"fn test_matches_without_wildcard() {\n"
+"    assert!(prefix_matches(\"/v1/publishers\", \"/v1/publishers\"));\n"
+"    assert!(prefix_matches(\"/v1/publishers\", \"/v1/publishers/"
+"abc-123\"));\n"
+"    assert!(prefix_matches(\"/v1/publishers\", \"/v1/publishers/abc/"
+"books\"));"
+msgstr ""
+
+#: src/exercises/day-2/solutions-afternoon.md:166
+msgid ""
+"    assert!(!prefix_matches(\"/v1/publishers/*/books\", \"/v1/"
+"publishers\"));\n"
+"    assert!(!prefix_matches(\n"
+"        \"/v1/publishers/*/books\",\n"
+"        \"/v1/publishers/foo/booksByAuthor\"\n"
+"    ));\n"
+"}\n"
+"// ANCHOR_END: unit-tests\n"
+"```"
+msgstr ""
+
+#: src/exercises/day-3/solutions-morning.md:1
+msgid "# Day 3 Morning Exercise"
+msgstr "# 3일차 오전 연습문제"
+
+#: src/exercises/day-3/solutions-morning.md:3
+msgid "## A Simple GUI Library"
+msgstr "## 간단한 GUI 라이브러리"
+
+#: src/exercises/day-3/solutions-morning.md:5
+msgid "([back to exercise](simple-gui.md))"
+msgstr ""
+
+#: src/exercises/day-3/solutions-morning.md:22
+msgid ""
+"// ANCHOR: setup\n"
+"pub trait Widget {\n"
+"    /// Natural width of `self`.\n"
+"    fn width(&self) -> usize;"
+msgstr ""
+
+#: src/exercises/day-3/solutions-morning.md:82
+msgid "// ANCHOR_END: setup"
+msgstr ""
+
+#: src/exercises/day-3/solutions-morning.md:84
+msgid ""
+"// ANCHOR: Window-width\n"
+"impl Widget for Window {\n"
+"    fn width(&self) -> usize {\n"
+"        // ANCHOR_END: Window-width\n"
+"        std::cmp::max(\n"
+"            self.title.chars().count(),\n"
+"            self.widgets.iter().map(|w| w.width()).max().unwrap_or(0),\n"
+"        )\n"
+"    }"
+msgstr ""
+
+#: src/exercises/day-3/solutions-morning.md:94
+msgid ""
+"    // ANCHOR: Window-draw_into\n"
+"    fn draw_into(&self, buffer: &mut dyn std::fmt::Write) {\n"
+"        // ANCHOR_END: Window-draw_into\n"
+"        let mut inner = String::new();\n"
+"        for widget in &self.widgets {\n"
+"            widget.draw_into(&mut inner);\n"
+"        }"
+msgstr ""
+
+#: src/exercises/day-3/solutions-morning.md:102
+msgid "        let window_width = self.width();"
+msgstr ""
+
+#: src/exercises/day-3/solutions-morning.md:104
+msgid ""
+"        // TODO: after learning about error handling, you can change\n"
+"        // draw_into to return Result<(), std::fmt::Error>. Then use\n"
+"        // the ?-operator here instead of .unwrap().\n"
+"        writeln!(buffer, \"+-{:-<window_width$}-+\", \"\").unwrap();\n"
+"        writeln!(buffer, \"| {:^window_width$} |\", &self.title).unwrap();\n"
+"        writeln!(buffer, \"+={:=<window_width$}=+\", \"\").unwrap();\n"
+"        for line in inner.lines() {\n"
+"            writeln!(buffer, \"| {:window_width$} |\", line).unwrap();\n"
+"        }\n"
+"        writeln!(buffer, \"+-{:-<window_width$}-+\", \"\").unwrap();\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-3/solutions-morning.md:117
+msgid ""
+"// ANCHOR: Button-width\n"
+"impl Widget for Button {\n"
+"    fn width(&self) -> usize {\n"
+"        // ANCHOR_END: Button-width\n"
+"        self.label.width() + 8 // add a bit of padding\n"
+"    }"
+msgstr ""
+
+#: src/exercises/day-3/solutions-morning.md:124
+msgid ""
+"    // ANCHOR: Button-draw_into\n"
+"    fn draw_into(&self, buffer: &mut dyn std::fmt::Write) {\n"
+"        // ANCHOR_END: Button-draw_into\n"
+"        let width = self.width();\n"
+"        let mut label = String::new();\n"
+"        self.label.draw_into(&mut label);"
+msgstr ""
+
+#: src/exercises/day-3/solutions-morning.md:131
+msgid ""
+"        writeln!(buffer, \"+{:-<width$}+\", \"\").unwrap();\n"
+"        for line in label.lines() {\n"
+"            writeln!(buffer, \"|{:^width$}|\", &line).unwrap();\n"
+"        }\n"
+"        writeln!(buffer, \"+{:-<width$}+\", \"\").unwrap();\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-3/solutions-morning.md:139
+msgid ""
+"// ANCHOR: Label-width\n"
+"impl Widget for Label {\n"
+"    fn width(&self) -> usize {\n"
+"        // ANCHOR_END: Label-width\n"
+"        self.label\n"
+"            .lines()\n"
+"            .map(|line| line.chars().count())\n"
+"            .max()\n"
+"            .unwrap_or(0)\n"
+"    }"
+msgstr ""
+
+#: src/exercises/day-3/solutions-morning.md:150
+msgid ""
+"    // ANCHOR: Label-draw_into\n"
+"    fn draw_into(&self, buffer: &mut dyn std::fmt::Write) {\n"
+"        // ANCHOR_END: Label-draw_into\n"
+"        writeln!(buffer, \"{}\", &self.label).unwrap();\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-3/solutions-morning.md:157
+msgid ""
+"// ANCHOR: main\n"
+"fn main() {\n"
+"    let mut window = Window::new(\"Rust GUI Demo 1.23\");\n"
+"    window.add_widget(Box::new(Label::new(\"This is a small text GUI demo."
+"\")));\n"
+"    window.add_widget(Box::new(Button::new(\n"
+"        \"Click me!\",\n"
+"        Box::new(|| println!(\"You clicked the button!\")),\n"
+"    )));\n"
+"    window.draw();\n"
+"}\n"
+"// ANCHOR_END: main\n"
+"```"
+msgstr ""
+
+#: src/exercises/day-3/solutions-afternoon.md:1
+msgid "# Day 3 Afternoon Exercises"
+msgstr "# 3일차 오후 연습문제"
+
+#: src/exercises/day-3/solutions-afternoon.md:3
+msgid "## Safe FFI Wrapper"
+msgstr "## FFI래퍼"
+
+#: src/exercises/day-3/solutions-afternoon.md:5
+msgid "([back to exercise](safe-ffi-wrapper.md))"
+msgstr ""
+
+#: src/exercises/day-3/solutions-afternoon.md:22
+msgid ""
+"// ANCHOR: ffi\n"
+"mod ffi {\n"
+"    use std::os::raw::{c_char, c_int, c_long, c_ulong, c_ushort};"
+msgstr ""
+
+#: src/exercises/day-3/solutions-afternoon.md:53
+msgid ""
+"#[derive(Debug)]\n"
+"struct DirectoryIterator {\n"
+"    path: CString,\n"
+"    dir: *mut ffi::DIR,\n"
+"}\n"
+"// ANCHOR_END: ffi"
+msgstr ""
+
+#: src/exercises/day-3/solutions-afternoon.md:60
+msgid ""
+"// ANCHOR: DirectoryIterator\n"
+"impl DirectoryIterator {\n"
+"    fn new(path: &str) -> Result<DirectoryIterator, String> {\n"
+"        // Call opendir and return a Ok value if that worked,\n"
+"        // otherwise return Err with a message.\n"
+"        // ANCHOR_END: DirectoryIterator\n"
+"        let path = CString::new(path).map_err(|err| format!(\"Invalid path: "
+"{err}\"))?;\n"
+"        // SAFETY: path.as_ptr() cannot be NULL.\n"
+"        let dir = unsafe { ffi::opendir(path.as_ptr()) };\n"
+"        if dir.is_null() {\n"
+"            Err(format!(\"Could not open {:?}\", path))\n"
+"        } else {\n"
+"            Ok(DirectoryIterator { path, dir })\n"
+"        }\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-3/solutions-afternoon.md:77
+msgid ""
+"// ANCHOR: Iterator\n"
+"impl Iterator for DirectoryIterator {\n"
+"    type Item = OsString;\n"
+"    fn next(&mut self) -> Option<OsString> {\n"
+"        // Keep calling readdir until we get a NULL pointer back.\n"
+"        // ANCHOR_END: Iterator\n"
+"        // SAFETY: self.dir is never NULL.\n"
+"        let dirent = unsafe { ffi::readdir(self.dir) };\n"
+"        if dirent.is_null() {\n"
+"            // We have reached the end of the directory.\n"
+"            return None;\n"
+"        }\n"
+"        // SAFETY: dirent is not NULL and dirent.d_name is NUL\n"
+"        // terminated.\n"
+"        let d_name = unsafe { CStr::from_ptr((*dirent).d_name.as_ptr()) };\n"
+"        let os_str = OsStr::from_bytes(d_name.to_bytes());\n"
+"        Some(os_str.to_owned())\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-3/solutions-afternoon.md:97
+msgid ""
+"// ANCHOR: Drop\n"
+"impl Drop for DirectoryIterator {\n"
+"    fn drop(&mut self) {\n"
+"        // Call closedir as needed.\n"
+"        // ANCHOR_END: Drop\n"
+"        if !self.dir.is_null() {\n"
+"            // SAFETY: self.dir is not NULL.\n"
+"            if unsafe { ffi::closedir(self.dir) } != 0 {\n"
+"                panic!(\"Could not close {:?}\", self.path);\n"
+"            }\n"
+"        }\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-3/solutions-afternoon.md:111
+msgid ""
+"// ANCHOR: main\n"
+"fn main() -> Result<(), String> {\n"
+"    let iter = DirectoryIterator::new(\".\")?;\n"
+"    println!(\"files: {:#?}\", iter.collect::<Vec<_>>());\n"
+"    Ok(())\n"
+"}\n"
+"// ANCHOR_END: main\n"
+"```"
+msgstr ""
+
+#: src/exercises/day-4/solutions-morning.md:1
+msgid "# Day 4 Morning Exercise"
+msgstr "# 4일차 오전 연습문제"
+
+#: src/exercises/day-4/solutions-morning.md:3
+msgid "## Dining Philosophers"
+msgstr "## 식사하는 철학자들"
+
+#: src/exercises/day-4/solutions-morning.md:5
+msgid "([back to exercise](dining-philosophers.md))"
+msgstr ""
+
+#: src/exercises/day-4/solutions-morning.md:22
+msgid ""
+"// ANCHOR: Philosopher\n"
+"use std::sync::mpsc;\n"
+"use std::sync::{Arc, Mutex};\n"
+"use std::thread;\n"
+"use std::time::Duration;"
+msgstr ""
+
+#: src/exercises/day-4/solutions-morning.md:30
+msgid ""
+"struct Philosopher {\n"
+"    name: String,\n"
+"    // ANCHOR_END: Philosopher\n"
+"    left_fork: Arc<Mutex<Fork>>,\n"
+"    right_fork: Arc<Mutex<Fork>>,\n"
+"    thoughts: mpsc::SyncSender<String>,\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-4/solutions-morning.md:38
+msgid ""
+"// ANCHOR: Philosopher-think\n"
+"impl Philosopher {\n"
+"    fn think(&self) {\n"
+"        self.thoughts\n"
+"            .send(format!(\"Eureka! {} has a new idea!\", &self.name))\n"
+"            .unwrap();\n"
+"    }\n"
+"    // ANCHOR_END: Philosopher-think"
+msgstr ""
+
+#: src/exercises/day-4/solutions-morning.md:47
+msgid ""
+"    // ANCHOR: Philosopher-eat\n"
+"    fn eat(&self) {\n"
+"        // ANCHOR_END: Philosopher-eat\n"
+"        println!(\"{} is trying to eat\", &self.name);\n"
+"        let left = self.left_fork.lock().unwrap();\n"
+"        let right = self.right_fork.lock().unwrap();"
+msgstr ""
+
+#: src/exercises/day-4/solutions-morning.md:54
+msgid ""
+"        // ANCHOR: Philosopher-eat-end\n"
+"        println!(\"{} is eating...\", &self.name);\n"
+"        thread::sleep(Duration::from_millis(10));\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-4/solutions-morning.md:63
+msgid ""
+"fn main() {\n"
+"    // ANCHOR_END: Philosopher-eat-end\n"
+"    let (tx, rx) = mpsc::sync_channel(10);"
+msgstr ""
+
+#: src/exercises/day-4/solutions-morning.md:67
+msgid ""
+"    let forks = (0..PHILOSOPHERS.len())\n"
+"        .map(|_| Arc::new(Mutex::new(Fork)))\n"
+"        .collect::<Vec<_>>();"
+msgstr ""
+
+#: src/exercises/day-4/solutions-morning.md:71
+msgid ""
+"    for i in 0..forks.len() {\n"
+"        let tx = tx.clone();\n"
+"        let mut left_fork = forks[i].clone();\n"
+"        let mut right_fork = forks[(i + 1) % forks.len()].clone();"
+msgstr ""
+
+#: src/exercises/day-4/solutions-morning.md:76
+msgid ""
+"        // To avoid a deadlock, we have to break the symmetry\n"
+"        // somewhere. This will swap the forks without deinitializing\n"
+"        // either of them.\n"
+"        if i == forks.len() - 1 {\n"
+"            std::mem::swap(&mut left_fork, &mut right_fork);\n"
+"        }"
+msgstr ""
+
+#: src/exercises/day-4/solutions-morning.md:83
+msgid ""
+"        let philosopher = Philosopher {\n"
+"            name: PHILOSOPHERS[i].to_string(),\n"
+"            thoughts: tx,\n"
+"            left_fork,\n"
+"            right_fork,\n"
+"        };"
+msgstr ""
+
+#: src/exercises/day-4/solutions-morning.md:90
+msgid ""
+"        thread::spawn(move || {\n"
+"            for _ in 0..100 {\n"
+"                philosopher.eat();\n"
+"                philosopher.think();\n"
+"            }\n"
+"        });\n"
+"    }"
+msgstr ""
+
+#: src/exercises/day-4/solutions-morning.md:98
+msgid ""
+"    drop(tx);\n"
+"    for thought in rx {\n"
+"        println!(\"{}\", thought);\n"
+"    }\n"
+"}\n"
+"```"
+msgstr ""
diff --git a/po/messages.pot b/po/messages.pot
new file mode 100644
index 000000000000..dbacc67c0a53
--- /dev/null
+++ b/po/messages.pot
@@ -0,0 +1,11283 @@
+
+msgid ""
+msgstr ""
+"Project-Id-Version: Comprehensive Rust 🦀\n"
+"POT-Creation-Date: \n"
+"PO-Revision-Date: \n"
+"Last-Translator: \n"
+"Language-Team: \n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Language: kr\n"
+"Plural-Forms: nplurals=1; plural=0;\n"
+
+#: src/SUMMARY.md:3
+msgid "Welcome to Comprehensive Rust 🦀"
+msgstr ""
+
+#: src/SUMMARY.md:4
+msgid "Using Cargo"
+msgstr ""
+
+#: src/SUMMARY.md:5
+msgid "Rust Ecosystem"
+msgstr ""
+
+#: src/SUMMARY.md:6
+msgid "Code Samples"
+msgstr ""
+
+#: src/SUMMARY.md:7
+msgid "Running Cargo Locally"
+msgstr ""
+
+#: src/SUMMARY.md:8
+msgid "Course Structure"
+msgstr ""
+
+#: src/SUMMARY.md:11
+msgid "Day 1: Morning"
+msgstr ""
+
+#: src/SUMMARY.md:15
+#: src/SUMMARY.md:71
+#: src/SUMMARY.md:124
+#: src/SUMMARY.md:174
+msgid "Welcome"
+msgstr ""
+
+#: src/SUMMARY.md:16
+msgid "What is Rust?"
+msgstr ""
+
+#: src/SUMMARY.md:17
+msgid "Hello World!"
+msgstr ""
+
+#: src/SUMMARY.md:18
+msgid "Small Example"
+msgstr ""
+
+#: src/SUMMARY.md:19
+msgid "Why Rust?"
+msgstr ""
+
+#: src/SUMMARY.md:20
+msgid "Compile Time Guarantees"
+msgstr ""
+
+#: src/SUMMARY.md:21
+msgid "Runtime Guarantees"
+msgstr ""
+
+#: src/SUMMARY.md:22
+msgid "Modern Features"
+msgstr ""
+
+#: src/SUMMARY.md:23
+msgid "Basic Syntax"
+msgstr ""
+
+#: src/SUMMARY.md:24
+msgid "Scalar Types"
+msgstr ""
+
+#: src/SUMMARY.md:25
+msgid "Compound Types"
+msgstr ""
+
+#: src/SUMMARY.md:26
+msgid "References"
+msgstr ""
+
+#: src/SUMMARY.md:27
+msgid "Dangling References"
+msgstr ""
+
+#: src/SUMMARY.md:28
+msgid "Slices"
+msgstr ""
+
+#: src/SUMMARY.md:29
+msgid "String vs str"
+msgstr ""
+
+#: src/SUMMARY.md:30
+msgid "Functions"
+msgstr ""
+
+#: src/SUMMARY.md:31
+#: src/SUMMARY.md:78
+msgid "Methods"
+msgstr ""
+
+#: src/SUMMARY.md:32
+msgid "Overloading"
+msgstr ""
+
+#: src/SUMMARY.md:33
+#: src/SUMMARY.md:62
+#: src/SUMMARY.md:86
+#: src/SUMMARY.md:115
+#: src/SUMMARY.md:142
+#: src/SUMMARY.md:166
+#: src/SUMMARY.md:189
+#: src/SUMMARY.md:216
+msgid "Exercises"
+msgstr ""
+
+#: src/SUMMARY.md:34
+msgid "Implicit Conversions"
+msgstr ""
+
+#: src/SUMMARY.md:35
+msgid "Arrays and for Loops"
+msgstr ""
+
+#: src/SUMMARY.md:37
+msgid "Day 1: Afternoon"
+msgstr ""
+
+#: src/SUMMARY.md:39
+msgid "Variables"
+msgstr ""
+
+#: src/SUMMARY.md:40
+msgid "Type Inference"
+msgstr ""
+
+#: src/SUMMARY.md:41
+msgid "static & const"
+msgstr ""
+
+#: src/SUMMARY.md:42
+msgid "Scopes and Shadowing"
+msgstr ""
+
+#: src/SUMMARY.md:43
+msgid "Memory Management"
+msgstr ""
+
+#: src/SUMMARY.md:44
+msgid "Stack vs Heap"
+msgstr ""
+
+#: src/SUMMARY.md:45
+msgid "Stack Memory"
+msgstr ""
+
+#: src/SUMMARY.md:46
+msgid "Manual Memory Management"
+msgstr ""
+
+#: src/SUMMARY.md:47
+msgid "Scope-Based Memory Management"
+msgstr ""
+
+#: src/SUMMARY.md:48
+msgid "Garbage Collection"
+msgstr ""
+
+#: src/SUMMARY.md:49
+msgid "Rust Memory Management"
+msgstr ""
+
+#: src/SUMMARY.md:50
+msgid "Comparison"
+msgstr ""
+
+#: src/SUMMARY.md:51
+msgid "Ownership"
+msgstr ""
+
+#: src/SUMMARY.md:52
+msgid "Move Semantics"
+msgstr ""
+
+#: src/SUMMARY.md:53
+msgid "Moved Strings in Rust"
+msgstr ""
+
+#: src/SUMMARY.md:54
+msgid "Double Frees in Modern C++"
+msgstr ""
+
+#: src/SUMMARY.md:55
+msgid "Moves in Function Calls"
+msgstr ""
+
+#: src/SUMMARY.md:56
+msgid "Copying and Cloning"
+msgstr ""
+
+#: src/SUMMARY.md:57
+msgid "Borrowing"
+msgstr ""
+
+#: src/SUMMARY.md:58
+msgid "Shared and Unique Borrows"
+msgstr ""
+
+#: src/SUMMARY.md:59
+msgid "Lifetimes"
+msgstr ""
+
+#: src/SUMMARY.md:60
+msgid "Lifetimes in Function Calls"
+msgstr ""
+
+#: src/SUMMARY.md:61
+msgid "Lifetimes in Data Structures"
+msgstr ""
+
+#: src/SUMMARY.md:63
+msgid "Designing a Library"
+msgstr ""
+
+#: src/SUMMARY.md:64
+msgid "Iterators and Ownership"
+msgstr ""
+
+#: src/SUMMARY.md:67
+msgid "Day 2: Morning"
+msgstr ""
+
+#: src/SUMMARY.md:72
+msgid "Structs"
+msgstr ""
+
+#: src/SUMMARY.md:73
+msgid "Tuple Structs"
+msgstr ""
+
+#: src/SUMMARY.md:74
+msgid "Field Shorthand Syntax"
+msgstr ""
+
+#: src/SUMMARY.md:75
+msgid "Enums"
+msgstr ""
+
+#: src/SUMMARY.md:76
+msgid "Variant Payloads"
+msgstr ""
+
+#: src/SUMMARY.md:77
+msgid "Enum Sizes"
+msgstr ""
+
+#: src/SUMMARY.md:79
+msgid "Method Receiver"
+msgstr ""
+
+#: src/SUMMARY.md:80
+#: src/SUMMARY.md:184
+msgid "Example"
+msgstr ""
+
+#: src/SUMMARY.md:81
+msgid "Pattern Matching"
+msgstr ""
+
+#: src/SUMMARY.md:82
+msgid "Destructuring Enums"
+msgstr ""
+
+#: src/SUMMARY.md:83
+msgid "Destructuring Structs"
+msgstr ""
+
+#: src/SUMMARY.md:84
+msgid "Destructuring Arrays"
+msgstr ""
+
+#: src/SUMMARY.md:85
+msgid "Match Guards"
+msgstr ""
+
+#: src/SUMMARY.md:87
+msgid "Health Statistics"
+msgstr ""
+
+#: src/SUMMARY.md:88
+msgid "Points and Polygons"
+msgstr ""
+
+#: src/SUMMARY.md:90
+msgid "Day 2: Afternoon"
+msgstr ""
+
+#: src/SUMMARY.md:92
+msgid "Control Flow"
+msgstr ""
+
+#: src/SUMMARY.md:93
+msgid "Blocks"
+msgstr ""
+
+#: src/SUMMARY.md:94
+msgid "if expressions"
+msgstr ""
+
+#: src/SUMMARY.md:95
+msgid "if let expressions"
+msgstr ""
+
+#: src/SUMMARY.md:96
+msgid "while expressions"
+msgstr ""
+
+#: src/SUMMARY.md:97
+msgid "while let expressions"
+msgstr ""
+
+#: src/SUMMARY.md:98
+msgid "for expressions"
+msgstr ""
+
+#: src/SUMMARY.md:99
+msgid "loop expressions"
+msgstr ""
+
+#: src/SUMMARY.md:100
+msgid "match expressions"
+msgstr ""
+
+#: src/SUMMARY.md:101
+msgid "break & continue"
+msgstr ""
+
+#: src/SUMMARY.md:102
+msgid "Standard Library"
+msgstr ""
+
+#: src/SUMMARY.md:103
+msgid "String"
+msgstr ""
+
+#: src/SUMMARY.md:104
+msgid "Option and Result"
+msgstr ""
+
+#: src/SUMMARY.md:105
+msgid "Vec"
+msgstr ""
+
+#: src/SUMMARY.md:106
+msgid "HashMap"
+msgstr ""
+
+#: src/SUMMARY.md:107
+msgid "Box"
+msgstr ""
+
+#: src/SUMMARY.md:108
+msgid "Recursive Data Types"
+msgstr ""
+
+#: src/SUMMARY.md:109
+msgid "Niche Optimization"
+msgstr ""
+
+#: src/SUMMARY.md:110
+msgid "Rc"
+msgstr ""
+
+#: src/SUMMARY.md:111
+msgid "Modules"
+msgstr ""
+
+#: src/SUMMARY.md:112
+msgid "Visibility"
+msgstr ""
+
+#: src/SUMMARY.md:113
+msgid "Paths"
+msgstr ""
+
+#: src/SUMMARY.md:114
+msgid "Filesystem Hierarchy"
+msgstr ""
+
+#: src/SUMMARY.md:116
+msgid "Luhn Algorithm"
+msgstr ""
+
+#: src/SUMMARY.md:117
+msgid "Strings and Iterators"
+msgstr ""
+
+#: src/SUMMARY.md:120
+msgid "Day 3: Morning"
+msgstr ""
+
+#: src/SUMMARY.md:125
+msgid "Traits"
+msgstr ""
+
+#: src/SUMMARY.md:126
+msgid "Deriving Traits"
+msgstr ""
+
+#: src/SUMMARY.md:127
+msgid "Default Methods"
+msgstr ""
+
+#: src/SUMMARY.md:128
+msgid "Important Traits"
+msgstr ""
+
+#: src/SUMMARY.md:129
+msgid "Iterator"
+msgstr ""
+
+#: src/SUMMARY.md:130
+msgid "From and Into"
+msgstr ""
+
+#: src/SUMMARY.md:131
+msgid "Read and Write"
+msgstr ""
+
+#: src/SUMMARY.md:132
+msgid "Add, Mul, ..."
+msgstr ""
+
+#: src/SUMMARY.md:133
+msgid "Drop"
+msgstr ""
+
+#: src/SUMMARY.md:134
+msgid "Generics"
+msgstr ""
+
+#: src/SUMMARY.md:135
+msgid "Generic Data Types"
+msgstr ""
+
+#: src/SUMMARY.md:136
+msgid "Generic Methods"
+msgstr ""
+
+#: src/SUMMARY.md:137
+msgid "Trait Bounds"
+msgstr ""
+
+#: src/SUMMARY.md:138
+msgid "impl Trait"
+msgstr ""
+
+#: src/SUMMARY.md:139
+msgid "Closures"
+msgstr ""
+
+#: src/SUMMARY.md:140
+msgid "Monomorphization"
+msgstr ""
+
+#: src/SUMMARY.md:141
+msgid "Trait Objects"
+msgstr ""
+
+#: src/SUMMARY.md:143
+msgid "A Simple GUI Library"
+msgstr ""
+
+#: src/SUMMARY.md:145
+msgid "Day 3: Afternoon"
+msgstr ""
+
+#: src/SUMMARY.md:147
+msgid "Error Handling"
+msgstr ""
+
+#: src/SUMMARY.md:148
+msgid "Panics"
+msgstr ""
+
+#: src/SUMMARY.md:149
+msgid "Catching Stack Unwinding"
+msgstr ""
+
+#: src/SUMMARY.md:150
+msgid "Structured Error Handling"
+msgstr ""
+
+#: src/SUMMARY.md:151
+msgid "Propagating Errors with ?"
+msgstr ""
+
+#: src/SUMMARY.md:152
+msgid "Converting Error Types"
+msgstr ""
+
+#: src/SUMMARY.md:153
+msgid "Deriving Error Enums"
+msgstr ""
+
+#: src/SUMMARY.md:154
+msgid "Adding Context to Errors"
+msgstr ""
+
+#: src/SUMMARY.md:155
+msgid "Testing"
+msgstr ""
+
+#: src/SUMMARY.md:156
+msgid "Unit Tests"
+msgstr ""
+
+#: src/SUMMARY.md:157
+msgid "Test Modules"
+msgstr ""
+
+#: src/SUMMARY.md:158
+msgid "Documentation Tests"
+msgstr ""
+
+#: src/SUMMARY.md:159
+msgid "Integration Tests"
+msgstr ""
+
+#: src/SUMMARY.md:160
+msgid "Unsafe Rust"
+msgstr ""
+
+#: src/SUMMARY.md:161
+msgid "Dereferencing Raw Pointers"
+msgstr ""
+
+#: src/SUMMARY.md:162
+msgid "Mutable Static Variables"
+msgstr ""
+
+#: src/SUMMARY.md:163
+msgid "Calling Unsafe Functions"
+msgstr ""
+
+#: src/SUMMARY.md:164
+msgid "Extern Functions"
+msgstr ""
+
+#: src/SUMMARY.md:165
+msgid "Unions"
+msgstr ""
+
+#: src/SUMMARY.md:167
+msgid "Safe FFI Wrapper"
+msgstr ""
+
+#: src/SUMMARY.md:170
+msgid "Day 4: Morning"
+msgstr ""
+
+#: src/SUMMARY.md:175
+msgid "Concurrency"
+msgstr ""
+
+#: src/SUMMARY.md:176
+msgid "Threads"
+msgstr ""
+
+#: src/SUMMARY.md:177
+msgid "Scoped Threads"
+msgstr ""
+
+#: src/SUMMARY.md:178
+msgid "Channels"
+msgstr ""
+
+#: src/SUMMARY.md:179
+msgid "Unbounded Channels"
+msgstr ""
+
+#: src/SUMMARY.md:180
+msgid "Bounded Channels"
+msgstr ""
+
+#: src/SUMMARY.md:181
+msgid "Shared State"
+msgstr ""
+
+#: src/SUMMARY.md:182
+msgid "Arc"
+msgstr ""
+
+#: src/SUMMARY.md:183
+msgid "Mutex"
+msgstr ""
+
+#: src/SUMMARY.md:185
+msgid "Send and Sync"
+msgstr ""
+
+#: src/SUMMARY.md:185
+msgid "Send"
+msgstr ""
+
+#: src/SUMMARY.md:185
+msgid "Sync"
+msgstr ""
+
+#: src/SUMMARY.md:188
+msgid "Examples"
+msgstr ""
+
+#: src/SUMMARY.md:190
+msgid "Dining Philosophers"
+msgstr ""
+
+#: src/SUMMARY.md:191
+msgid "Multi-threaded Link Checker"
+msgstr ""
+
+#: src/SUMMARY.md:193
+msgid "Day 4: Afternoon"
+msgstr ""
+
+#: src/SUMMARY.md:197
+msgid "Android"
+msgstr ""
+
+#: src/SUMMARY.md:198
+msgid "Setup"
+msgstr ""
+
+#: src/SUMMARY.md:199
+msgid "Build Rules"
+msgstr ""
+
+#: src/SUMMARY.md:200
+msgid "Binary"
+msgstr ""
+
+#: src/SUMMARY.md:201
+msgid "Library"
+msgstr ""
+
+#: src/SUMMARY.md:202
+msgid "AIDL"
+msgstr ""
+
+#: src/SUMMARY.md:203
+msgid "Interface"
+msgstr ""
+
+#: src/SUMMARY.md:204
+msgid "Implementation"
+msgstr ""
+
+#: src/SUMMARY.md:205
+msgid "Server"
+msgstr ""
+
+#: src/SUMMARY.md:206
+msgid "Deploy"
+msgstr ""
+
+#: src/SUMMARY.md:207
+msgid "Client"
+msgstr ""
+
+#: src/SUMMARY.md:208
+msgid "Changing API"
+msgstr ""
+
+#: src/SUMMARY.md:209
+msgid "Logging"
+msgstr ""
+
+#: src/SUMMARY.md:210
+msgid "Interoperability"
+msgstr ""
+
+#: src/SUMMARY.md:211
+msgid "With C"
+msgstr ""
+
+#: src/SUMMARY.md:212
+msgid "Calling C with Bindgen"
+msgstr ""
+
+#: src/SUMMARY.md:213
+msgid "Calling Rust from C"
+msgstr ""
+
+#: src/SUMMARY.md:214
+msgid "With C++"
+msgstr ""
+
+#: src/SUMMARY.md:215
+msgid "With Java"
+msgstr ""
+
+#: src/SUMMARY.md:218
+msgid "Final Words"
+msgstr ""
+
+#: src/SUMMARY.md:220
+msgid "Thanks!"
+msgstr ""
+
+#: src/SUMMARY.md:221
+msgid "Other Resources"
+msgstr ""
+
+#: src/SUMMARY.md:222
+msgid "Credits"
+msgstr ""
+
+#: src/SUMMARY.md:226
+#: src/SUMMARY.md:226
+msgid "Solutions"
+msgstr ""
+
+#: src/SUMMARY.md:231
+msgid "Day 1 Morning"
+msgstr ""
+
+#: src/SUMMARY.md:232
+msgid "Day 1 Afternoon"
+msgstr ""
+
+#: src/SUMMARY.md:233
+msgid "Day 2 Morning"
+msgstr ""
+
+#: src/SUMMARY.md:234
+msgid "Day 2 Afternoon"
+msgstr ""
+
+#: src/SUMMARY.md:235
+msgid "Day 3 Morning"
+msgstr ""
+
+#: src/SUMMARY.md:236
+msgid "Day 3 Afternoon"
+msgstr ""
+
+#: src/SUMMARY.md:237
+msgid "Day 4 Morning"
+msgstr ""
+
+#: src/welcome.md:1
+msgid "# Welcome to Comprehensive Rust 🦀"
+msgstr ""
+
+#: src/welcome.md:3
+msgid ""
+"This is a four day Rust course developed by the Android team. The course "
+"covers\n"
+"the full spectrum of Rust, from basic syntax to advanced topics like "
+"generics\n"
+"and error handling. It also includes Android-specific content on the last "
+"day."
+msgstr ""
+
+#: src/welcome.md:7
+msgid ""
+"The goal of the course is to teach you Rust. We assume you don't know "
+"anything\n"
+"about Rust and hope to:"
+msgstr ""
+
+#: src/welcome.md:10
+msgid ""
+"* Give you a comprehensive understanding of the Rust syntax and language.\n"
+"* Enable you to modify existing programs and write new programs in Rust.\n"
+"* Show you common Rust idioms."
+msgstr ""
+
+#: src/welcome.md:14
+msgid "On Day 4, we will cover Android-specific things such as:"
+msgstr ""
+
+#: src/welcome.md:16
+msgid ""
+"* Building Android components in Rust.\n"
+"* AIDL servers and clients.\n"
+"* Interoperability with C, C++, and Java."
+msgstr ""
+
+#: src/welcome.md:20
+msgid ""
+"It is important to note that this course does not cover Android "
+"**application** \n"
+"development in Rust, and that the Android-specific parts are specifically "
+"about\n"
+"writing code for Android itself, the operating system. "
+msgstr ""
+
+#: src/welcome.md:24
+msgid "## Non-Goals"
+msgstr ""
+
+#: src/welcome.md:26
+msgid ""
+"Rust is a large language and we won't be able to cover all of it in a few "
+"days.\n"
+"Some non-goals of this course are:"
+msgstr ""
+
+#: src/welcome.md:29
+msgid ""
+"* Learn how to use async Rust --- we'll only mention async Rust when\n"
+"  covering traditional concurrency primitives. Please see [Asynchronous\n"
+"  Programming in Rust](https://rust-lang.github.io/async-book/) instead for\n"
+"  details on this topic.\n"
+"* Learn how to develop macros, please see [Chapter 19.5 in the Rust\n"
+"  Book](https://doc.rust-lang.org/book/ch19-06-macros.html) and [Rust by\n"
+"  Example](https://doc.rust-lang.org/rust-by-example/macros.html) instead."
+msgstr ""
+
+#: src/welcome.md:37
+msgid "## Assumptions"
+msgstr ""
+
+#: src/welcome.md:39
+msgid ""
+"The course assumes that you already know how to program. Rust is a "
+"statically\n"
+"typed language and we will sometimes make comparisons with C and C++ to "
+"better\n"
+"explain or contrast the Rust approach."
+msgstr ""
+
+#: src/welcome.md:43
+msgid ""
+"If you know how to program in a dynamically typed language such as Python "
+"or\n"
+"JavaScript, then you will be able to follow along just fine too."
+msgstr ""
+
+#: src/welcome.md:46
+#: src/cargo/rust-ecosystem.md:19
+#: src/cargo/code-samples.md:22
+#: src/cargo/running-locally.md:68
+#: src/welcome-day-1.md:14
+#: src/welcome-day-1/what-is-rust.md:19
+#: src/hello-world.md:20
+#: src/hello-world/small-example.md:21
+#: src/why-rust.md:9
+#: src/why-rust/compile-time.md:14
+#: src/why-rust/runtime.md:8
+#: src/why-rust/modern.md:17
+#: src/exercises/day-1/morning.md:9
+#: src/basic-syntax/variables.md:15
+#: src/basic-syntax/type-inference.md:24
+#: src/basic-syntax/scopes-shadowing.md:23
+#: src/ownership/copy-clone.md:33
+#: src/ownership/borrowing.md:25
+#: src/ownership/shared-unique-borrows.md:23
+#: src/ownership/lifetimes-function-calls.md:27
+#: src/enums/variant-payloads.md:33
+#: src/enums/sizes.md:31
+#: src/concurrency/threads.md:28
+msgid "<details>"
+msgstr ""
+
+#: src/welcome.md:48
+msgid ""
+"This is an example of a _speaker note_. We will use these to add additional\n"
+"information to the slides. This could be key points which the instructor "
+"should\n"
+"cover as well as answers to typical questions which come up in class."
+msgstr ""
+
+#: src/welcome.md:52
+#: src/cargo/rust-ecosystem.md:67
+#: src/cargo/code-samples.md:35
+#: src/cargo/running-locally.md:74
+#: src/welcome-day-1.md:29
+#: src/welcome-day-1/what-is-rust.md:27
+#: src/hello-world.md:36
+#: src/hello-world/small-example.md:44
+#: src/why-rust.md:24
+#: src/why-rust/compile-time.md:33
+#: src/why-rust/runtime.md:22
+#: src/why-rust/modern.md:51
+#: src/exercises/day-1/morning.md:24
+#: src/basic-syntax/variables.md:20
+#: src/basic-syntax/type-inference.md:44
+#: src/basic-syntax/scopes-shadowing.md:37
+#: src/ownership/copy-clone.md:48
+#: src/ownership/borrowing.md:51
+#: src/ownership/shared-unique-borrows.md:29
+#: src/ownership/lifetimes-function-calls.md:54
+#: src/enums/variant-payloads.md:39
+#: src/enums/sizes.md:37
+#: src/concurrency/threads.md:45
+msgid "</details>"
+msgstr ""
+
+#: src/cargo.md:1
+msgid "# Using Cargo"
+msgstr ""
+
+#: src/cargo.md:3
+msgid ""
+"When you start reading about Rust, you will soon meet "
+"[Cargo](https://doc.rust-lang.org/cargo/), the standard tool\n"
+"used in the Rust ecosystem to build and run Rust applications. Here we want "
+"to\n"
+"give a brief overview of what Cargo is and how it fits into the wider "
+"ecosystem\n"
+"and how it fits into this training."
+msgstr ""
+
+#: src/cargo.md:8
+msgid "## Installation"
+msgstr ""
+
+#: src/cargo.md:10
+msgid "### Rustup (Recommended)"
+msgstr ""
+
+#: src/cargo.md:12
+msgid ""
+"You can follow the instructions to install cargo and rust compiler, among "
+"other standard ecosystem tools with the [rustup][3] tool, which is "
+"maintained by the Rust Foundation."
+msgstr ""
+
+#: src/cargo.md:14
+msgid ""
+"Along with cargo and rustc, Rustup will install itself as a command line "
+"utility that you can use to install/switch toolchains, setup cross "
+"compilation, etc."
+msgstr ""
+
+#: src/cargo.md:16
+msgid "### Package Managers"
+msgstr ""
+
+#: src/cargo.md:18
+msgid "#### Debian"
+msgstr ""
+
+#: src/cargo.md:20
+msgid "On Debian/Ubuntu, you can install Cargo and the Rust source with"
+msgstr ""
+
+#: src/cargo.md:22
+msgid ""
+"```shell\n"
+"$ sudo apt install cargo rust-src\n"
+"```"
+msgstr ""
+
+#: src/cargo.md:26
+msgid ""
+"This will allow [rust-analyzer][1] to jump to the definitions. We suggest "
+"using\n"
+"[VS Code][2] to edit the code (but any LSP compatible editor works)."
+msgstr ""
+
+#: src/cargo.md:29
+msgid ""
+"Some folks also like to use the [Jetbrains][4] family of IDEs, which do "
+"their own analysis but have their own tradeoffs. If you prefer them, you can "
+"install the [Rust Plugin][5]. Please take note that as of January 2023 "
+"debugging only works on the CLion version of the Jetbrains IDEA suite."
+msgstr ""
+
+#: src/cargo.md:31
+msgid ""
+"[1]: https://rust-analyzer.github.io/\n"
+"[2]: https://code.visualstudio.com/\n"
+"[3]: https://rustup.rs/\n"
+"[4]: https://www.jetbrains.com/clion/\n"
+"[5]: https://www.jetbrains.com/rust/"
+msgstr ""
+
+#: src/cargo/rust-ecosystem.md:1
+msgid "# The Rust Ecosystem"
+msgstr ""
+
+#: src/cargo/rust-ecosystem.md:3
+msgid ""
+"The Rust ecosystem consists of a number of tools, of which the main ones are:"
+msgstr ""
+
+#: src/cargo/rust-ecosystem.md:5
+msgid ""
+"* `rustc`: the Rust compiler which turns `.rs` files into binaries and "
+"other\n"
+"  intermediate formats[^rustc]."
+msgstr ""
+
+#: src/cargo/rust-ecosystem.md:8
+msgid ""
+"* `cargo`: the Rust dependency manager and build tool. Cargo knows how to\n"
+"  download dependencies hosted on <https://crates.io> and it will pass them "
+"to\n"
+"  `rustc` when building your project. Cargo also comes with a built-in test\n"
+"  runner which is used to execute unit tests[^cargo]."
+msgstr ""
+
+#: src/cargo/rust-ecosystem.md:13
+msgid ""
+"* `rustup`: the Rust toolchain installer and updater. This tool is used to\n"
+"  install and update `rustc` and `cargo` when new versions of Rust is "
+"released.\n"
+"  In addition, `rustup` can also download documentation for the standard\n"
+"  library. You can have multiple versions of Rust installed at once and "
+"`rustup`\n"
+"  will let you switch between them as needed."
+msgstr ""
+
+#: src/cargo/rust-ecosystem.md:21
+#: src/hello-world.md:25
+#: src/hello-world/small-example.md:27
+#: src/why-rust/runtime.md:10
+#: src/why-rust/modern.md:19
+#: src/concurrency/threads.md:30
+msgid "Key points:"
+msgstr ""
+
+#: src/cargo/rust-ecosystem.md:23
+msgid ""
+"* Rust has a rapid release schedule with a new release coming out\n"
+"  every six weeks. New releases maintain backwards compatibility with\n"
+"  old releases --- plus they enable new functionality."
+msgstr ""
+
+#: src/cargo/rust-ecosystem.md:27
+msgid ""
+"* There are three release channels: \"stable\", \"beta\", and \"nightly\"."
+msgstr ""
+
+#: src/cargo/rust-ecosystem.md:29
+msgid ""
+"* New features are being tested on \"nightly\", \"beta\" is what becomes\n"
+"  \"stable\" every six weeks."
+msgstr ""
+
+#: src/cargo/rust-ecosystem.md:32
+msgid ""
+"* Rust also has [editions]: the current edition is Rust 2021. Previous\n"
+"  editions were Rust 2015 and Rust 2018."
+msgstr ""
+
+#: src/cargo/rust-ecosystem.md:35
+msgid ""
+"  * The editions are allowed to make backwards incompatible changes to\n"
+"    the language."
+msgstr ""
+
+#: src/cargo/rust-ecosystem.md:38
+msgid ""
+"  * To prevent breaking code, editions are opt-in: you select the\n"
+"    edition for your crate via the `Cargo.toml` file."
+msgstr ""
+
+#: src/cargo/rust-ecosystem.md:41
+msgid ""
+"  * To avoid splitting the ecosystem, Rust compilers can mix code\n"
+"    written for different editions."
+msgstr ""
+
+#: src/cargo/rust-ecosystem.md:44
+msgid ""
+"  * Mention that it is quite rare to ever use the compiler directly not "
+"through `cargo` (most users never do)."
+msgstr ""
+
+#: src/cargo/rust-ecosystem.md:46
+msgid ""
+"  * It might be worth alluding that Cargo itself is an extremely powerful "
+"and comprehensive tool.  It is capable of many advanced features including "
+"but not limited to: \n"
+"      * Project/package structure\n"
+"      * [workspaces]\n"
+"      * Dev Dependencies and Runtime Dependency management/caching\n"
+"      * [build scripting]\n"
+"      * [global installation]\n"
+"      * It is also extensible with sub command plugins as well (such as "
+"[cargo clippy]).\n"
+"  * Read more from the [official Cargo Book]"
+msgstr ""
+
+#: src/cargo/rust-ecosystem.md:55
+msgid "[editions]: https://doc.rust-lang.org/edition-guide/"
+msgstr ""
+
+#: src/cargo/rust-ecosystem.md:57
+msgid "[workspaces]: https://doc.rust-lang.org/cargo/reference/workspaces.html"
+msgstr ""
+
+#: src/cargo/rust-ecosystem.md:59
+msgid ""
+"[build scripting]: "
+"https://doc.rust-lang.org/cargo/reference/build-scripts.html"
+msgstr ""
+
+#: src/cargo/rust-ecosystem.md:61
+msgid ""
+"[global installation]: "
+"https://doc.rust-lang.org/cargo/commands/cargo-install.html"
+msgstr ""
+
+#: src/cargo/rust-ecosystem.md:63
+msgid "[cargo clippy]: https://github.com/rust-lang/rust-clippy"
+msgstr ""
+
+#: src/cargo/rust-ecosystem.md:65
+msgid "[official Cargo Book]: https://doc.rust-lang.org/cargo/"
+msgstr ""
+
+#: src/cargo/code-samples.md:1
+msgid "# Code Samples in This Training"
+msgstr ""
+
+#: src/cargo/code-samples.md:3
+msgid ""
+"For this training, we will mostly explore the Rust language through "
+"examples\n"
+"which can be executed through your browser. This makes the setup much easier "
+"and\n"
+"ensures a consistent experience for everyone."
+msgstr ""
+
+#: src/cargo/code-samples.md:7
+msgid ""
+"Installing Cargo is still encouraged: it will make it easier for you to do "
+"the\n"
+"exercises. On the last day, we will do a larger exercise which shows you how "
+"to\n"
+"work with dependencies and for that you need Cargo."
+msgstr ""
+
+#: src/cargo/code-samples.md:11
+msgid "The code blocks in this course are fully interactive:"
+msgstr ""
+
+#: src/cargo/code-samples.md:13
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    println!(\"Edit me!\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/cargo/code-samples.md:19
+msgid ""
+"You can use <kbd>Ctrl-Enter</kbd> to execute the code when focus is in the "
+"text\n"
+"box."
+msgstr ""
+
+#: src/cargo/code-samples.md:24
+msgid ""
+"Most code samples are editable like shown above. A few code samples\n"
+"are not editable for various reasons:"
+msgstr ""
+
+#: src/cargo/code-samples.md:27
+msgid ""
+"* The embedded playgrounds cannot execute unit tests. Copy-paste the\n"
+"  code and open it in the real Playground to demonstrate unit tests."
+msgstr ""
+
+#: src/cargo/code-samples.md:30
+msgid ""
+"* The embedded playgrounds lose their state the moment you navigate\n"
+"  away from the page! This is the reason that the students should\n"
+"  solve the exercises using a local Rust installation or via the\n"
+"  Playground."
+msgstr ""
+
+#: src/cargo/running-locally.md:1
+msgid "# Running Code Locally with Cargo"
+msgstr ""
+
+#: src/cargo/running-locally.md:3
+msgid ""
+"If you want to experiment with the code on your own system, then you will "
+"need\n"
+"to first install Rust. Do this by following the [instructions in the Rust\n"
+"Book][1]. This should give you a working `rustc` and `cargo`. At the time "
+"of\n"
+"writing, the latest stable Rust release has these version numbers:"
+msgstr ""
+
+#: src/cargo/running-locally.md:8
+msgid ""
+"```shell\n"
+"% rustc --version\n"
+"rustc 1.61.0 (fe5b13d68 2022-05-18)\n"
+"% cargo --version\n"
+"cargo 1.61.0 (a028ae4 2022-04-29)\n"
+"```"
+msgstr ""
+
+#: src/cargo/running-locally.md:15
+msgid ""
+"With this is in place, then follow these steps to build a Rust binary from "
+"one\n"
+"of the examples in this training:"
+msgstr ""
+
+#: src/cargo/running-locally.md:18
+msgid ""
+"1. Click the \"Copy to clipboard\" button on the example you want to copy."
+msgstr ""
+
+#: src/cargo/running-locally.md:20
+msgid ""
+"2. Use `cargo new exercise` to create a new `exercise/` directory for your "
+"code:"
+msgstr ""
+
+#: src/cargo/running-locally.md:22
+msgid ""
+"    ```shell\n"
+"    $ cargo new exercise\n"
+"         Created binary (application) `exercise` package\n"
+"    ```"
+msgstr ""
+
+#: src/cargo/running-locally.md:27
+msgid ""
+"3. Navigate into `exercise/` and use `cargo run` to build and run your "
+"binary:"
+msgstr ""
+
+#: src/cargo/running-locally.md:29
+msgid ""
+"    ```shell\n"
+"    $ cd exercise\n"
+"    $ cargo run\n"
+"       Compiling exercise v0.1.0 (/home/mgeisler/tmp/exercise)\n"
+"        Finished dev [unoptimized + debuginfo] target(s) in 0.75s\n"
+"         Running `target/debug/exercise`\n"
+"    Hello, world!\n"
+"    ```"
+msgstr ""
+
+#: src/cargo/running-locally.md:38
+msgid ""
+"4. Replace the boiler-plate code in `src/main.rs` with your own code. For\n"
+"   example, using the example on the previous page, make `src/main.rs` look "
+"like"
+msgstr ""
+
+#: src/cargo/running-locally.md:41
+msgid ""
+"    ```rust\n"
+"    fn main() {\n"
+"        println!(\"Edit me!\");\n"
+"    }\n"
+"    ```"
+msgstr ""
+
+#: src/cargo/running-locally.md:47
+msgid "5. Use `cargo run` to build and run your updated binary:"
+msgstr ""
+
+#: src/cargo/running-locally.md:49
+msgid ""
+"    ```shell\n"
+"    $ cargo run\n"
+"       Compiling exercise v0.1.0 (/home/mgeisler/tmp/exercise)\n"
+"        Finished dev [unoptimized + debuginfo] target(s) in 0.24s\n"
+"         Running `target/debug/exercise`\n"
+"    Edit me!\n"
+"    ```"
+msgstr ""
+
+#: src/cargo/running-locally.md:57
+msgid ""
+"6. Use `cargo check` to quickly check your project for errors, use `cargo "
+"build`\n"
+"   to compile it without running it. You will find the output in "
+"`target/debug/`\n"
+"   for a normal debug build. Use `cargo build --release` to produce an "
+"optimized\n"
+"   release build in `target/release/`."
+msgstr ""
+
+#: src/cargo/running-locally.md:62
+msgid ""
+"7. You can add dependencies for your project by editing `Cargo.toml`. When "
+"you\n"
+"   run `cargo` commands, it will automatically download and compile missing\n"
+"   dependencies for you."
+msgstr ""
+
+#: src/cargo/running-locally.md:66
+msgid "[1]: https://doc.rust-lang.org/book/ch01-01-installation.html"
+msgstr ""
+
+#: src/cargo/running-locally.md:70
+msgid ""
+"Try to encourage the class participants to install Cargo and use a\n"
+"local editor. It will make their life easier since they will have a\n"
+"normal development environment."
+msgstr ""
+
+#: src/structure.md:1
+msgid "# Course Structure"
+msgstr ""
+
+#: src/structure.md:3
+msgid ""
+"The course is fast paced and we will cover a lot of ground over the next "
+"3--4\n"
+"days:"
+msgstr ""
+
+#: src/structure.md:6
+msgid ""
+"* Day 1: Basic Rust, ownership and the borrow checker.\n"
+"* Day 2: Compound data types,  pattern matching, the standard library.\n"
+"* Day 3: Traits and generics, error handling, testing, unsafe Rust.\n"
+"* Day 4: Concurrency in Rust and interoperability with other languages"
+msgstr ""
+
+#: src/structure.md:11
+msgid ""
+"> **Exercise for Day 4:** Do you interface with some C/C++ code in your "
+"project\n"
+"> which we could attempt to move to Rust? The fewer dependencies the "
+"better.\n"
+"> Parsing code would be ideal."
+msgstr ""
+
+#: src/structure.md:15
+msgid "## Format"
+msgstr ""
+
+#: src/structure.md:17
+msgid ""
+"The course is interactive and your questions will drive our exploration of "
+"Rust!"
+msgstr ""
+
+#: src/structure.md:19
+msgid ""
+"* Please ask questions when you get them, don't save them to the end.\n"
+"* Discussions are very much encouraged!\n"
+"* We will likely talk about things ahead of the slides.\n"
+"  * The slides are just a support and we are free to skip them as we like."
+msgstr ""
+
+#: src/welcome-day-1.md:1
+msgid "# Welcome to Day 1"
+msgstr ""
+
+#: src/welcome-day-1.md:3
+msgid ""
+"This is the first day of Comprehensive Rust. We will cover a lot of ground\n"
+"today:"
+msgstr ""
+
+#: src/welcome-day-1.md:6
+msgid ""
+"* Basic Rust syntax: variables, scalar and compound types, enums, structs,\n"
+"  references, functions, and methods."
+msgstr ""
+
+#: src/welcome-day-1.md:9
+msgid ""
+"* Memory management: stack vs heap, manual memory management, scope-based "
+"memory\n"
+"  management, and garbage collection."
+msgstr ""
+
+#: src/welcome-day-1.md:12
+msgid ""
+"* Ownership: move semantics, copying and cloning, borrowing, and lifetimes."
+msgstr ""
+
+#: src/welcome-day-1.md:16
+msgid ""
+"The idea for the first day is to show _just enough_ of Rust to be able to "
+"speak\n"
+"about the famous borrow checker. The way Rust handles memory is a major "
+"feature\n"
+"and we should show students this right away."
+msgstr ""
+
+#: src/welcome-day-1.md:20
+msgid ""
+"If you're teaching this in a classroom, this is a good place to go over the\n"
+"schedule. We suggest splitting the day into two parts (following the slides):"
+msgstr ""
+
+#: src/welcome-day-1.md:23
+msgid "* Morning: 9:00 to 12:00,\n* Afternoon: 13:00 to 16:00."
+msgstr ""
+
+#: src/welcome-day-1.md:26
+msgid ""
+"You can of course adjust this as necessary. Please make sure to include "
+"breaks,\n"
+"we recommend a break every hour!"
+msgstr ""
+
+#: src/welcome-day-1/what-is-rust.md:1
+msgid "# What is Rust?"
+msgstr ""
+
+#: src/welcome-day-1/what-is-rust.md:3
+msgid "Rust is a new programming language which had its 1.0 release in 2015:"
+msgstr ""
+
+#: src/welcome-day-1/what-is-rust.md:5
+msgid ""
+"* Rust is a statically compiled language in a similar role as C++\n"
+"  * `rustc` uses LLVM as its backend.\n"
+"* Rust supports many [platforms and\n"
+"  "
+"architectures](https://doc.rust-lang.org/nightly/rustc/platform-support.html):\n"
+"  * x86, ARM, WebAssembly, ...\n"
+"  * Linux, Mac, Windows, ...\n"
+"* Rust is used for a wide range of devices:\n"
+"  * firmware and boot loaders,\n"
+"  * smart displays,\n"
+"  * mobile phones,\n"
+"  * desktops,\n"
+"  * servers."
+msgstr ""
+
+#: src/welcome-day-1/what-is-rust.md:21
+msgid "Rust fits in the same area as C++:"
+msgstr ""
+
+#: src/welcome-day-1/what-is-rust.md:23
+msgid ""
+"* High flexibility.\n"
+"* High level of control.\n"
+"* Can be scaled down to very constrained devices like mobile phones."
+msgstr ""
+
+#: src/hello-world.md:1
+msgid "# Hello World!"
+msgstr ""
+
+#: src/hello-world.md:3
+msgid ""
+"Let us jump into the simplest possible Rust program, a classic Hello World\n"
+"program:"
+msgstr ""
+
+#: src/hello-world.md:6
+msgid ""
+"```rust\n"
+"fn main() {\n"
+"    println!(\"Hello 🌍!\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/hello-world.md:12
+msgid "What you see:"
+msgstr ""
+
+#: src/hello-world.md:14
+msgid ""
+"* Functions are introduced with `fn`.\n"
+"* Blocks are delimited by curly braces like in C and C++.\n"
+"* The `main` function is the entry point of the program.\n"
+"* Rust has hygienic macros, `println!` is an example of this.\n"
+"* Rust strings are UTF-8 encoded and can contain any Unicode character."
+msgstr ""
+
+#: src/hello-world.md:22
+msgid ""
+"This slide tries to make the students comfortable with Rust code. They will "
+"see\n"
+"a ton of it over the next four days so we start small with something "
+"familiar."
+msgstr ""
+
+#: src/hello-world.md:27
+msgid ""
+"* Rust is very much like other languages in the C/C++/Java tradition. It is\n"
+"  imperative (not functional) and it doesn't try to reinvent things unless\n"
+"  absolutely necessary."
+msgstr ""
+
+#: src/hello-world.md:31
+msgid "* Rust is modern with full support for things like Unicode."
+msgstr ""
+
+#: src/hello-world.md:33
+msgid ""
+"* Rust uses macros for situations where you want to have a variable number "
+"of\n"
+"  arguments (no function [overloading](basic-syntax/functions-interlude.md))."
+msgstr ""
+
+#: src/hello-world/small-example.md:1
+msgid "# Small Example"
+msgstr ""
+
+#: src/hello-world/small-example.md:3
+msgid "Here is a small example program in Rust:"
+msgstr ""
+
+#: src/hello-world/small-example.md:5
+msgid ""
+"```rust,editable\n"
+"fn main() {              // Program entry point\n"
+"    let mut x: i32 = 6;  // Mutable variable binding\n"
+"    print!(\"{x}\");       // Macro for printing, like printf\n"
+"    while x != 1 {       // No parenthesis around expression\n"
+"        if x % 2 == 0 {  // Math like in other languages\n"
+"            x = x / 2;\n"
+"        } else {\n"
+"            x = 3 * x + 1;\n"
+"        }\n"
+"        print!(\" -> {x}\");\n"
+"    }\n"
+"    println!();\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/hello-world/small-example.md:23
+msgid ""
+"The code implements the Collatz conjecture: it is believed that the loop "
+"will\n"
+"always end, but this is not yet proved. Edit the code and play with "
+"different\n"
+"inputs."
+msgstr ""
+
+#: src/hello-world/small-example.md:29
+msgid ""
+"* Explain that all variables are statically typed. Try removing `i32` to "
+"trigger\n"
+"  type inference. Try with `i8` instead and trigger a runtime integer "
+"overflow."
+msgstr ""
+
+#: src/hello-world/small-example.md:32
+msgid "* Change `let mut x` to `let x`, discuss the compiler error."
+msgstr ""
+
+#: src/hello-world/small-example.md:34
+msgid ""
+"* Show how `print!` gives a compilation error if the arguments don't match "
+"the\n"
+"  format string."
+msgstr ""
+
+#: src/hello-world/small-example.md:37
+msgid ""
+"* Show how you need to use `{}` as a placeholder if you want to print an\n"
+"  expression which is more complex than just a single variable."
+msgstr ""
+
+#: src/hello-world/small-example.md:40
+msgid ""
+"* Show the students the standard library, show them how to search for "
+"`std::fmt`\n"
+"  which has the rules of the formatting mini-language. It's important that "
+"the\n"
+"  students become familiar with searching in the standard library."
+msgstr ""
+
+#: src/why-rust.md:1
+msgid "# Why Rust?"
+msgstr ""
+
+#: src/why-rust.md:3
+msgid "Some unique selling points of Rust:"
+msgstr ""
+
+#: src/why-rust.md:5
+msgid ""
+"* Compile time memory safety.\n"
+"* Lack of undefined runtime behavior.\n"
+"* Modern language features."
+msgstr ""
+
+#: src/why-rust.md:11
+msgid ""
+"Make sure to ask the class which languages they have experience with. "
+"Depending\n"
+"on the answer you can highlight different features of Rust:"
+msgstr ""
+
+#: src/why-rust.md:14
+msgid ""
+"* Experience with C or C++: Rust eliminates a whole class of _runtime "
+"errors_\n"
+"  via the borrow checker. You get performance like in C and C++, but you "
+"don't\n"
+"  have the memory unsafety issues. In addition, you get a modern language "
+"with\n"
+"  constructs like pattern matching and built-in dependency management."
+msgstr ""
+
+#: src/why-rust.md:19
+msgid ""
+"* Experience with Java, Go, Python, JavaSript...: You get the same memory "
+"safety\n"
+"  as in those languages, plus a similar high-level language feeling. In "
+"addition\n"
+"  you get fast and predictable performance like C and C++ (no garbage "
+"collector)\n"
+"  as well as access to low-level hardware (should you need it)"
+msgstr ""
+
+#: src/why-rust/compile-time.md:1
+msgid "# Compile Time Guarantees"
+msgstr ""
+
+#: src/why-rust/compile-time.md:3
+msgid "Static memory management at compile time:"
+msgstr ""
+
+#: src/why-rust/compile-time.md:5
+msgid ""
+"* No uninitialized variables.\n"
+"* No memory leaks (_mostly_, see notes).\n"
+"* No double-frees.\n"
+"* No use-after-free.\n"
+"* No `NULL` pointers.\n"
+"* No forgotten locked mutexes.\n"
+"* No data races between threads.\n"
+"* No iterator invalidation."
+msgstr ""
+
+#: src/why-rust/compile-time.md:16
+msgid ""
+"It is possible to produce memory leaks in (safe) Rust. Some examples\n"
+"are:"
+msgstr ""
+
+#: src/why-rust/compile-time.md:19
+msgid ""
+"* You can for use [`Box::leak`] to leak a pointer. A use of this could\n"
+"  be to get runtime-initialized and runtime-sized static variables\n"
+"* You can use [`std::mem::forget`] to make the compiler \"forget\" about\n"
+"  a value (meaning the destructor is never run).\n"
+"* You can also accidentally create a [reference cycle] with `Rc` or\n"
+"  `Arc`."
+msgstr ""
+
+#: src/why-rust/compile-time.md:26
+msgid ""
+"For the purpose of this course, \"No memory leaks\" should be understood\n"
+"as \"Pretty much no *accidental* memory leaks\"."
+msgstr ""
+
+#: src/why-rust/compile-time.md:29
+msgid ""
+"[`Box::leak`]: "
+"https://doc.rust-lang.org/std/boxed/struct.Box.html#method.leak\n"
+"[`std::mem::forget`]: https://doc.rust-lang.org/std/mem/fn.forget.html\n"
+"[reference cycle]: "
+"https://doc.rust-lang.org/book/ch15-06-reference-cycles.html"
+msgstr ""
+
+#: src/why-rust/runtime.md:1
+msgid "# Runtime Guarantees"
+msgstr ""
+
+#: src/why-rust/runtime.md:3
+msgid "No undefined behavior at runtime:"
+msgstr ""
+
+#: src/why-rust/runtime.md:5
+msgid "* Array access is bounds checked.\n* Integer overflow is defined."
+msgstr ""
+
+#: src/why-rust/runtime.md:12
+msgid ""
+"* Integer overflow is defined via a compile-time flag. The options are\n"
+"  either a panic (a controlled crash of the program) or wrap-around\n"
+"  semantics. By default, you get panics in debug mode (`cargo build`)\n"
+"  and wrap-around in release mode (`cargo build --release`)."
+msgstr ""
+
+#: src/why-rust/runtime.md:17
+msgid ""
+"* Bounds checking cannot be disabled with a compiler flag. It can also\n"
+"  not be disabled directly with the `unsafe` keyword. However,\n"
+"  `unsafe` allows you to call functions such as `slice::get_unchecked`\n"
+"  which does not do bounds checking."
+msgstr ""
+
+#: src/why-rust/modern.md:1
+msgid "# Modern Features"
+msgstr ""
+
+#: src/why-rust/modern.md:3
+msgid "Rust is built with all the experience gained in the last 40 years."
+msgstr ""
+
+#: src/why-rust/modern.md:5
+msgid "## Language Features"
+msgstr ""
+
+#: src/why-rust/modern.md:7
+msgid ""
+"* Enums and pattern matching.\n"
+"* Generics.\n"
+"* No overhead FFI."
+msgstr ""
+
+#: src/why-rust/modern.md:11
+msgid "## Tooling"
+msgstr ""
+
+#: src/why-rust/modern.md:13
+msgid ""
+"* Great compiler errors.\n"
+"* Built-in dependency manager.\n"
+"* Built-in support for testing."
+msgstr ""
+
+#: src/why-rust/modern.md:21
+msgid ""
+"* Remind people to read the errors --- many developers have gotten used to\n"
+"  ignore lengthly compiler output. The Rust compiler is significantly more\n"
+"  talkative than other compilers. It will often provide you with "
+"_actionable_\n"
+"  feedback, ready to copy-paste into your code."
+msgstr ""
+
+#: src/why-rust/modern.md:26
+msgid ""
+"* The Rust standard library is small compared to languages like Java, "
+"Python,\n"
+"  and Go. Rust does not come with several things you might consider standard "
+"and\n"
+"  essential:"
+msgstr ""
+
+#: src/why-rust/modern.md:30
+msgid ""
+"  * a random number generator, but see [rand].\n"
+"  * support for SSL or TLS, but see [rusttls].\n"
+"  * support for JSON, but see [serde_json]."
+msgstr ""
+
+#: src/why-rust/modern.md:34
+msgid ""
+"  The reasoning behind this is that functionality in the standard library "
+"cannot\n"
+"  go away, so it has to be very stable. For the examples above, the Rust\n"
+"  community is still working on finding the best solution --- and perhaps "
+"there\n"
+"  isn't a single \"best solution\" for some of these things."
+msgstr ""
+
+#: src/why-rust/modern.md:39
+msgid ""
+"  Rust comes with a built-in package manager in the form of Cargo and this "
+"makes\n"
+"  it trivial to download and compile third-party crates. A consequence of "
+"this\n"
+"  is that the standard library can be smaller."
+msgstr ""
+
+#: src/why-rust/modern.md:43
+msgid ""
+"  Discovering good third-party crates can be a problem. Sites like\n"
+"  <https://lib.rs/> help with this by letting you compare health metrics "
+"for\n"
+"  crates to find a good and trusted one."
+msgstr ""
+
+#: src/why-rust/modern.md:47
+msgid ""
+"[rand]: https://docs.rs/rand/\n"
+"[rusttls]: https://docs.rs/rustls/\n"
+"[serde_json]: https://docs.rs/serde_json/"
+msgstr ""
+
+#: src/basic-syntax.md:1
+msgid "# Basic Syntax"
+msgstr ""
+
+#: src/basic-syntax.md:3
+msgid "Much of the Rust syntax will be familiar to you from C or C++:"
+msgstr ""
+
+#: src/basic-syntax.md:5
+msgid ""
+"* Blocks and scopes are delimited by curly braces.\n"
+"* Line comments are started with `//`, block comments are delimited by `/* "
+"...\n"
+"  */`.\n"
+"* Keywords like `if` and `while` work the same.\n"
+"* Variable assignment is done with `=`, comparison is done with `==`."
+msgstr ""
+
+#: src/basic-syntax/scalar-types.md:1
+msgid "# Scalar Types"
+msgstr ""
+
+#: src/basic-syntax/scalar-types.md:3
+msgid ""
+"|                        | Types                                      | "
+"Literals                      |\n"
+"|------------------------|--------------------------------------------|-------------------------------|\n"
+"| Signed integers        | `i8`, `i16`, `i32`, `i64`, `i128`, `isize` | "
+"`-10`, `0`, `1_000`, `123i64` |\n"
+"| Unsigned integers      | `u8`, `u16`, `u32`, `u64`, `u128`, `usize` | `0`, "
+"`123`, `10u16`           |\n"
+"| Floating point numbers | `f32`, `f64`                               | "
+"`3.14`, `-10.0e20`, `2f32`    |\n"
+"| Strings                | `&str`                                     | "
+"`\"foo\"`, `r#\"\\\\\"#`            |\n"
+"| Unicode scalar values  | `char`                                     | "
+"`'a'`, `'α'`, `'∞'`           |\n"
+"| Byte strings           | `&[u8]`                                    | "
+"`b\"abc\"`, `br#\" \" \"#`         |\n"
+"| Booleans               | `bool`                                     | "
+"`true`, `false`               |"
+msgstr ""
+
+#: src/basic-syntax/scalar-types.md:13
+msgid "The types have widths as follows:"
+msgstr ""
+
+#: src/basic-syntax/scalar-types.md:15
+msgid ""
+"* `iN`, `uN`, and `fN` are _N_ bits wide,\n"
+"* `isize` and `usize` are the width of a pointer,\n"
+"* `char` is 32 bit wide,\n"
+"* `bool` is 8 bit wide."
+msgstr ""
+
+#: src/basic-syntax/compound-types.md:1
+msgid "# Compound Types"
+msgstr ""
+
+#: src/basic-syntax/compound-types.md:3
+msgid ""
+"|        | Types                         | Literals                          "
+"|\n"
+"|--------|-------------------------------|-----------------------------------|\n"
+"| Arrays | `[T; N]`                      | `[20, 30, 40]`, `[0; 3]`          "
+"|\n"
+"| Tuples | `()`, `(T,)`, `(T1, T2)`, ... | `()`, `('x',)`, `('x', 1.2)`, ... "
+"|"
+msgstr ""
+
+#: src/basic-syntax/compound-types.md:8
+msgid "Array assignment and access:"
+msgstr ""
+
+#: src/basic-syntax/compound-types.md:10
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let mut a: [i8; 10] = [42; 10];\n"
+"    a[5] = 0;\n"
+"    println!(\"a: {:?}\", a);\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/basic-syntax/compound-types.md:18
+msgid "Tuple assignment and access:"
+msgstr ""
+
+#: src/basic-syntax/compound-types.md:20
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let t: (i8, bool) = (7, true);\n"
+"    println!(\"1st index: {}\", t.0);\n"
+"    println!(\"2nd index: {}\", t.1);\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/basic-syntax/references.md:1
+msgid "# References"
+msgstr ""
+
+#: src/basic-syntax/references.md:3
+msgid "Like C++, Rust has references:"
+msgstr ""
+
+#: src/basic-syntax/references.md:5
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let mut x: i32 = 10;\n"
+"    let ref_x: &mut i32 = &mut x;\n"
+"    *ref_x = 20;\n"
+"    println!(\"x: {x}\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/basic-syntax/references.md:14
+msgid "Some differences from C++:"
+msgstr ""
+
+#: src/basic-syntax/references.md:16
+msgid ""
+"* We must dereference `ref_x` when assigning to it, similar to C pointers,\n"
+"* Rust will auto-dereference in some cases, in particular when invoking\n"
+"  methods (try `count_ones`).\n"
+"* References that are declared as `mut` can be bound to different values "
+"over their lifetime."
+msgstr ""
+
+#: src/basic-syntax/references-dangling.md:1
+msgid "# Dangling References"
+msgstr ""
+
+#: src/basic-syntax/references-dangling.md:3
+msgid "Rust will statically forbid dangling references:"
+msgstr ""
+
+#: src/basic-syntax/references-dangling.md:5
+msgid ""
+"```rust,editable,compile_fail\n"
+"fn main() {\n"
+"    let ref_x: &i32;\n"
+"    {\n"
+"        let x: i32 = 10;\n"
+"        ref_x = &x;\n"
+"    }\n"
+"    println!(\"ref_x: {ref_x}\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/basic-syntax/references-dangling.md:16
+msgid ""
+"* A reference is said to \"borrow\" the value it refers to.\n"
+"* Rust is tracking the lifetimes of all references to ensure they live long\n"
+"  enough.\n"
+"* We will talk more about borrowing when we get to ownership."
+msgstr ""
+
+#: src/basic-syntax/slices.md:1
+msgid "# Slices"
+msgstr ""
+
+#: src/basic-syntax/slices.md:3
+msgid "A slice gives you a view into a larger collection:"
+msgstr ""
+
+#: src/basic-syntax/slices.md:5
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let a: [i32; 6] = [10, 20, 30, 40, 50, 60];\n"
+"    println!(\"a: {a:?}\");"
+msgstr ""
+
+#: src/basic-syntax/slices.md:10
+msgid ""
+"    let s: &[i32] = &a[2..4];\n"
+"    println!(\"s: {s:?}\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/basic-syntax/slices.md:15
+msgid ""
+"* Slices borrow data from the sliced type.\n"
+"* Question: What happens if you modify `a[3]`?"
+msgstr ""
+
+#: src/basic-syntax/string-slices.md:1
+msgid "# `String` vs `str`"
+msgstr ""
+
+#: src/basic-syntax/string-slices.md:3
+msgid "We can now understand the two string types in Rust:"
+msgstr ""
+
+#: src/basic-syntax/string-slices.md:5
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let s1: &str = \"Hello\";\n"
+"    println!(\"s1: {s1}\");"
+msgstr ""
+
+#: src/basic-syntax/string-slices.md:10
+msgid ""
+"    let mut s2: String = String::from(\"Hello \");\n"
+"    println!(\"s2: {s2}\");\n"
+"    s2.push_str(s1);\n"
+"    println!(\"s2: {s2}\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/basic-syntax/string-slices.md:17
+msgid "Rust terminology:"
+msgstr ""
+
+#: src/basic-syntax/string-slices.md:19
+msgid ""
+"* `&str` an immutable reference to a string slice.\n"
+"* `String` a mutable string buffer."
+msgstr ""
+
+#: src/basic-syntax/functions.md:1
+msgid "# Functions"
+msgstr ""
+
+#: src/basic-syntax/functions.md:3
+msgid ""
+"A Rust version of the famous "
+"[FizzBuzz](https://en.wikipedia.org/wiki/Fizz_buzz) interview question:"
+msgstr ""
+
+#: src/basic-syntax/functions.md:5
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    fizzbuzz_to(20);   // Defined below, no forward declaration needed\n"
+"}"
+msgstr ""
+
+#: src/basic-syntax/functions.md:10
+msgid ""
+"fn is_divisible_by(lhs: u32, rhs: u32) -> bool {\n"
+"    if rhs == 0 {\n"
+"        return false;  // Corner case, early return\n"
+"    }\n"
+"    lhs % rhs == 0     // The last expression is the return value\n"
+"}"
+msgstr ""
+
+#: src/basic-syntax/functions.md:17
+msgid ""
+"fn fizzbuzz(n: u32) -> () {  // No return value means returning the unit "
+"type `()`\n"
+"    match (is_divisible_by(n, 3), is_divisible_by(n, 5)) {\n"
+"        (true,  true)  => println!(\"fizzbuzz\"),\n"
+"        (true,  false) => println!(\"fizz\"),\n"
+"        (false, true)  => println!(\"buzz\"),\n"
+"        (false, false) => println!(\"{n}\"),\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/basic-syntax/functions.md:26
+msgid ""
+"fn fizzbuzz_to(n: u32) {  // `-> ()` is normally omitted\n"
+"    for n in 1..=n {\n"
+"        fizzbuzz(n);\n"
+"    }\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/basic-syntax/methods.md:1
+#: src/methods.md:1
+msgid "# Methods"
+msgstr ""
+
+#: src/basic-syntax/methods.md:3
+msgid ""
+"Rust has methods, they are simply functions that are associated with a "
+"particular type. The\n"
+"first argument of a method is an instance of the type it is associated with:"
+msgstr ""
+
+#: src/basic-syntax/methods.md:6
+msgid ""
+"```rust,editable\n"
+"struct Rectangle {\n"
+"    width: u32,\n"
+"    height: u32,\n"
+"}"
+msgstr ""
+
+#: src/basic-syntax/methods.md:12
+msgid ""
+"impl Rectangle {\n"
+"    fn area(&self) -> u32 {\n"
+"        self.width * self.height\n"
+"    }"
+msgstr ""
+
+#: src/basic-syntax/methods.md:17
+msgid ""
+"    fn inc_width(&mut self, delta: u32) {\n"
+"        self.width += delta;\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/basic-syntax/methods.md:22
+msgid ""
+"fn main() {\n"
+"    let mut rect = Rectangle { width: 10, height: 5 };\n"
+"    println!(\"old area: {}\", rect.area());\n"
+"    rect.inc_width(5);\n"
+"    println!(\"new area: {}\", rect.area());\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/basic-syntax/methods.md:30
+msgid ""
+"* We will look much more at methods in today's exercise and in tomorrow's "
+"class."
+msgstr ""
+
+#: src/basic-syntax/functions-interlude.md:1
+msgid "# Function Overloading"
+msgstr ""
+
+#: src/basic-syntax/functions-interlude.md:3
+msgid "Overloading is not supported:"
+msgstr ""
+
+#: src/basic-syntax/functions-interlude.md:5
+msgid ""
+"* Each function has a single implementation:\n"
+"  * Always takes a fixed number of parameters.\n"
+"  * Always takes a single set of parameter types.\n"
+"* Default values are not supported:\n"
+"  * All call sites have the same number of arguments.\n"
+"  * Macros are sometimes used as an alternative."
+msgstr ""
+
+#: src/basic-syntax/functions-interlude.md:12
+msgid "However, function parameters can be generic:"
+msgstr ""
+
+#: src/basic-syntax/functions-interlude.md:14
+msgid ""
+"```rust,editable\n"
+"fn pick_one<T>(a: T, b: T) -> T {\n"
+"    if std::process::id() % 2 == 0 { a } else { b }\n"
+"}"
+msgstr ""
+
+#: src/basic-syntax/functions-interlude.md:19
+msgid ""
+"fn main() {\n"
+"    println!(\"coin toss: {}\", pick_one(\"heads\", \"tails\"));\n"
+"    println!(\"cash prize: {}\", pick_one(500, 1000));\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/exercises/day-1/morning.md:1
+msgid "# Day 1: Morning Exercises"
+msgstr ""
+
+#: src/exercises/day-1/morning.md:3
+msgid "In these exercises, we will explore two parts of Rust:"
+msgstr ""
+
+#: src/exercises/day-1/morning.md:5
+msgid "* Implicit conversions between types."
+msgstr ""
+
+#: src/exercises/day-1/morning.md:7
+msgid "* Arrays and `for` loops."
+msgstr ""
+
+#: src/exercises/day-1/morning.md:11
+msgid "A few things to consider while solving the exercises:"
+msgstr ""
+
+#: src/exercises/day-1/morning.md:13
+msgid ""
+"* Use a local Rust installation, if possible. This way you can get\n"
+"  auto-completion in your editor. See the page about [Using Cargo] for "
+"details\n"
+"  on installing Rust."
+msgstr ""
+
+#: src/exercises/day-1/morning.md:17
+msgid "* Alternatively, use the Rust Playground."
+msgstr ""
+
+#: src/exercises/day-1/morning.md:19
+msgid ""
+"The code snippets are not editable on purpose: the inline code snippets "
+"lose\n"
+"their state if you navigate away from the page."
+msgstr ""
+
+#: src/exercises/day-1/morning.md:22
+msgid "[Using Cargo]: ../../cargo.md"
+msgstr ""
+
+#: src/exercises/day-1/implicit-conversions.md:1
+msgid "# Implicit Conversions"
+msgstr ""
+
+#: src/exercises/day-1/implicit-conversions.md:3
+msgid ""
+"Rust will not automatically apply _implicit conversions_ between types "
+"([unlike\n"
+"C++][3]). You can see this in a program like this:"
+msgstr ""
+
+#: src/exercises/day-1/implicit-conversions.md:6
+msgid ""
+"```rust,editable,compile_fail\n"
+"fn multiply(x: i16, y: i16) -> i16 {\n"
+"    x * y\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-1/implicit-conversions.md:11
+msgid ""
+"fn main() {\n"
+"    let x: i8 = 15;\n"
+"    let y: i16 = 1000;"
+msgstr ""
+
+#: src/exercises/day-1/implicit-conversions.md:15
+msgid ""
+"    println!(\"{x} * {y} = {}\", multiply(x, y));\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/exercises/day-1/implicit-conversions.md:19
+msgid ""
+"The Rust integer types all implement the [`From<T>`][1] and [`Into<T>`][2]\n"
+"traits to let us convert between them. The `From<T>` trait has a single "
+"`from()`\n"
+"method and similarly, the `Into<T>` trait has a single `into()` method.\n"
+"Implementing these traits is how a type expresses that it can be converted "
+"into\n"
+"another type."
+msgstr ""
+
+#: src/exercises/day-1/implicit-conversions.md:25
+msgid ""
+"The standard library has an implementation of `From<i8> for i16`, which "
+"means\n"
+"that we can convert a variable `x` of type `i8` to an `i16` by calling \n"
+"`i16::from(x)`. Or, simpler, with `x.into()`, because `From<i8> for i16`\n"
+"implementation automatically create an implementation of `Into<i16> for i8`."
+msgstr ""
+
+#: src/exercises/day-1/implicit-conversions.md:30
+msgid "1. Execute the above program and look at the compiler error."
+msgstr ""
+
+#: src/exercises/day-1/implicit-conversions.md:32
+msgid "2. Update the code above to use `into()` to do the conversion."
+msgstr ""
+
+#: src/exercises/day-1/implicit-conversions.md:34
+msgid ""
+"3. Change the types of `x` and `y` to other things (such as `f32`, `bool`,\n"
+"   `i128`) to see which types you can convert to which other types. Try\n"
+"   converting small types to big types and the other way around. Check the\n"
+"   [standard library documentation][1] to see if `From<T>` is implemented "
+"for\n"
+"   the pairs you check."
+msgstr ""
+
+#: src/exercises/day-1/implicit-conversions.md:40
+msgid ""
+"[1]: https://doc.rust-lang.org/std/convert/trait.From.html\n"
+"[2]: https://doc.rust-lang.org/std/convert/trait.Into.html\n"
+"[3]: https://en.cppreference.com/w/cpp/language/implicit_conversion"
+msgstr ""
+
+#: src/exercises/day-1/for-loops.md:1
+msgid "# Arrays and `for` Loops"
+msgstr ""
+
+#: src/exercises/day-1/for-loops.md:3
+msgid "We saw that an array can be declared like this:"
+msgstr ""
+
+#: src/exercises/day-1/for-loops.md:5
+msgid ""
+"```rust\n"
+"let array = [10, 20, 30];\n"
+"```"
+msgstr ""
+
+#: src/exercises/day-1/for-loops.md:9
+msgid ""
+"You can print such an array by asking for its debug representation with "
+"`{:?}`:"
+msgstr ""
+
+#: src/exercises/day-1/for-loops.md:11
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let array = [10, 20, 30];\n"
+"    println!(\"array: {array:?}\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/exercises/day-1/for-loops.md:18
+msgid ""
+"Rust lets you iterate over things like arrays and ranges using the `for`\n"
+"keyword:"
+msgstr ""
+
+#: src/exercises/day-1/for-loops.md:21
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let array = [10, 20, 30];\n"
+"    print!(\"Iterating over array:\");\n"
+"    for n in array {\n"
+"        print!(\" {n}\");\n"
+"    }\n"
+"    println!();"
+msgstr ""
+
+#: src/exercises/day-1/for-loops.md:30
+msgid ""
+"    print!(\"Iterating over range:\");\n"
+"    for i in 0..3 {\n"
+"        print!(\" {}\", array[i]);\n"
+"    }\n"
+"    println!();\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/exercises/day-1/for-loops.md:38
+msgid ""
+"Use the above to write a function `pretty_print` which pretty-print a matrix "
+"and\n"
+"a function `transpose` which will transpose a matrix (turn rows into "
+"columns):"
+msgstr ""
+
+#: src/exercises/day-1/for-loops.md:41
+msgid ""
+"```bob\n"
+"           ⎛⎡1 2 3⎤⎞      ⎡1 4 7⎤\n"
+"\"transpose\"⎜⎢4 5 6⎥⎟  \"==\"⎢2 5 8⎥\n"
+"           ⎝⎣7 8 9⎦⎠      ⎣3 6 9⎦\n"
+"```"
+msgstr ""
+
+#: src/exercises/day-1/for-loops.md:47
+msgid "Hard-code both functions to operate on 3 × 3 matrices."
+msgstr ""
+
+#: src/exercises/day-1/for-loops.md:49
+msgid ""
+"Copy the code below to <https://play.rust-lang.org/> and implement the\n"
+"functions:"
+msgstr ""
+
+#: src/exercises/day-1/for-loops.md:52
+#: src/exercises/day-1/book-library.md:20
+#: src/exercises/day-2/health-statistics.md:13
+msgid ""
+"```rust,should_panic\n"
+"// TODO: remove this when you're done with your implementation.\n"
+"#![allow(unused_variables, dead_code)]"
+msgstr ""
+
+#: src/exercises/day-1/for-loops.md:56
+msgid ""
+"fn transpose(matrix: [[i32; 3]; 3]) -> [[i32; 3]; 3] {\n"
+"    unimplemented!()\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-1/for-loops.md:60
+msgid ""
+"fn pretty_print(matrix: &[[i32; 3]; 3]) {\n"
+"    unimplemented!()\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-1/for-loops.md:64
+msgid ""
+"fn main() {\n"
+"    let matrix = [\n"
+"        [101, 102, 103], // <-- the comment makes rustfmt add a newline\n"
+"        [201, 202, 203],\n"
+"        [301, 302, 303],\n"
+"    ];"
+msgstr ""
+
+#: src/exercises/day-1/for-loops.md:71
+#: src/exercises/day-1/solutions-morning.md:70
+msgid "    println!(\"matrix:\");\n    pretty_print(&matrix);"
+msgstr ""
+
+#: src/exercises/day-1/for-loops.md:74
+msgid ""
+"    let transposed = transpose(matrix);\n"
+"    println!(\"transposed:\");\n"
+"    pretty_print(&transposed);\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/exercises/day-1/for-loops.md:80
+msgid "## Bonus Question"
+msgstr ""
+
+#: src/exercises/day-1/for-loops.md:82
+msgid ""
+"Could you use `&[i32]` slices instead of hard-coded 3 × 3 matrices for your\n"
+"argument and return types? Something like `&[&[i32]]` for a two-dimensional\n"
+"slice-of-slices. Why or why not?"
+msgstr ""
+
+#: src/exercises/day-1/for-loops.md:87
+msgid ""
+"See the [`ndarray` crate](https://docs.rs/ndarray/) for a production "
+"quality\n"
+"implementation."
+msgstr ""
+
+#: src/basic-syntax/variables.md:1
+msgid "# Variables"
+msgstr ""
+
+#: src/basic-syntax/variables.md:3
+msgid ""
+"Rust provides type safety via static typing. Variable bindings are immutable "
+"by\n"
+"default:"
+msgstr ""
+
+#: src/basic-syntax/variables.md:6
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let x: i32 = 10;\n"
+"    println!(\"x: {x}\");\n"
+"    // x = 20;\n"
+"    // println!(\"x: {x}\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/basic-syntax/variables.md:17
+msgid ""
+"* Due to type inference the `i32` is optional. We will gradually show the "
+"types less and less as the type progresses.\n"
+"* Note that since `println!` is a macro, `x` is not moved, even using the "
+"function like syntax of `println!(\"x: {}\", x)`"
+msgstr ""
+
+#: src/basic-syntax/type-inference.md:1
+msgid "# Type Inference"
+msgstr ""
+
+#: src/basic-syntax/type-inference.md:3
+msgid "Rust will look at how the variable is _used_ to determine the type:"
+msgstr ""
+
+#: src/basic-syntax/type-inference.md:5
+msgid ""
+"```rust,editable\n"
+"fn takes_u32(x: u32) {\n"
+"    println!(\"u32: {x}\");\n"
+"}"
+msgstr ""
+
+#: src/basic-syntax/type-inference.md:10
+msgid ""
+"fn takes_i8(y: i8) {\n"
+"    println!(\"i8: {y}\");\n"
+"}"
+msgstr ""
+
+#: src/basic-syntax/type-inference.md:14
+msgid ""
+"fn main() {\n"
+"    let x = 10;\n"
+"    let y = 20;"
+msgstr ""
+
+#: src/basic-syntax/type-inference.md:18
+msgid ""
+"    takes_u32(x);\n"
+"    takes_i8(y);\n"
+"    // takes_u32(y);\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/basic-syntax/type-inference.md:26
+msgid ""
+"This slide demonstrates how the Rust compiler infers types based on "
+"constraints given by variable declarations and usages."
+msgstr ""
+
+#: src/basic-syntax/type-inference.md:28
+msgid ""
+"The following code tells the compiler to copy into a certain generic "
+"container without the code ever explicitly specifying the contained type, "
+"using `_` as a placeholder:"
+msgstr ""
+
+#: src/basic-syntax/type-inference.md:30
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let mut v = Vec::new();\n"
+"    v.push((10, false));\n"
+"    v.push((20, true));\n"
+"    println!(\"v: {v:?}\");"
+msgstr ""
+
+#: src/basic-syntax/type-inference.md:37
+msgid ""
+"    let vv = v.iter().collect::<std::collections::HashSet<_>>();\n"
+"    println!(\"vv: {vv:?}\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/basic-syntax/type-inference.md:42
+msgid ""
+"[`collect`](https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#method.collect) "
+"relies on `FromIterator`, which "
+"[`HashSet`](https://doc.rust-lang.org/std/iter/trait.FromIterator.html) "
+"implements."
+msgstr ""
+
+#: src/basic-syntax/static-and-const.md:1
+msgid "# Static and Constant Variables"
+msgstr ""
+
+#: src/basic-syntax/static-and-const.md:3
+msgid "Global state is managed with static and constant variables."
+msgstr ""
+
+#: src/basic-syntax/static-and-const.md:5
+msgid "## `const`"
+msgstr ""
+
+#: src/basic-syntax/static-and-const.md:7
+msgid "You can declare compile-time constants:"
+msgstr ""
+
+#: src/basic-syntax/static-and-const.md:9
+msgid ""
+"```rust,editable\n"
+"const DIGEST_SIZE: usize = 3;\n"
+"const ZERO: Option<u8> = Some(42);"
+msgstr ""
+
+#: src/basic-syntax/static-and-const.md:13
+msgid ""
+"fn compute_digest(text: &str) -> [u8; DIGEST_SIZE] {\n"
+"    let mut digest = [ZERO.unwrap_or(0); DIGEST_SIZE];\n"
+"    for (idx, &b) in text.as_bytes().iter().enumerate() {\n"
+"        digest[idx % DIGEST_SIZE] = digest[idx % "
+"DIGEST_SIZE].wrapping_add(b);\n"
+"    }\n"
+"    digest\n"
+"}"
+msgstr ""
+
+#: src/basic-syntax/static-and-const.md:21
+msgid ""
+"fn main() {\n"
+"    let digest = compute_digest(\"Hello\");\n"
+"    println!(\"Digest: {digest:?}\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/basic-syntax/static-and-const.md:27
+msgid "## `static`"
+msgstr ""
+
+#: src/basic-syntax/static-and-const.md:29
+msgid "You can also declare static variables:"
+msgstr ""
+
+#: src/basic-syntax/static-and-const.md:31
+msgid "```rust,editable\nstatic BANNER: &str = \"Welcome to RustOS 3.14\";"
+msgstr ""
+
+#: src/basic-syntax/static-and-const.md:34
+msgid ""
+"fn main() {\n"
+"    println!(\"{BANNER}\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/basic-syntax/static-and-const.md:39
+msgid ""
+"We will look at mutating static data in the [chapter on Unsafe "
+"Rust](../unsafe.md)."
+msgstr ""
+
+#: src/basic-syntax/scopes-shadowing.md:1
+msgid "# Scopes and Shadowing"
+msgstr ""
+
+#: src/basic-syntax/scopes-shadowing.md:3
+msgid ""
+"You can shadow variables, both those from outer scopes and variables from "
+"the\n"
+"same scope:"
+msgstr ""
+
+#: src/basic-syntax/scopes-shadowing.md:6
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let a = 10;\n"
+"    println!(\"before: {a}\");"
+msgstr ""
+
+#: src/basic-syntax/scopes-shadowing.md:11
+msgid ""
+"    {\n"
+"        let a = \"hello\";\n"
+"        println!(\"inner scope: {a}\");"
+msgstr ""
+
+#: src/basic-syntax/scopes-shadowing.md:15
+msgid ""
+"        let a = true;\n"
+"        println!(\"shadowed in inner scope: {a}\");\n"
+"    }"
+msgstr ""
+
+#: src/basic-syntax/scopes-shadowing.md:19
+msgid ""
+"    println!(\"after: {a}\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/basic-syntax/scopes-shadowing.md:25
+msgid ""
+"* Shadowing looks obscure at first, but is convenient for holding on to "
+"values after `.unwrap()`.\n"
+"* The following code demonstrates why the compiler can't simply reuse memory "
+"locations when shadowing an immutable variable in a scope, even if the type "
+"does not change."
+msgstr ""
+
+#: src/basic-syntax/scopes-shadowing.md:28
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let a = 1;\n"
+"    let b = &a;\n"
+"    let a = a + 1;\n"
+"    println!(\"{a} {b}\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/memory-management.md:1
+msgid "# Memory Management"
+msgstr ""
+
+#: src/memory-management.md:3
+msgid "Traditionally, languages have fallen into two broad categories:"
+msgstr ""
+
+#: src/memory-management.md:5
+msgid ""
+"* Full control via manual memory management: C, C++, Pascal, ...\n"
+"* Full safety via automatic memory management at runtime: Java, Python, Go, "
+"Haskell, ..."
+msgstr ""
+
+#: src/memory-management.md:8
+msgid "Rust offers a new mix:"
+msgstr ""
+
+#: src/memory-management.md:10
+msgid ""
+"> Full control *and* safety via compile time enforcement of correct memory\n"
+"> management."
+msgstr ""
+
+#: src/memory-management.md:13
+msgid "It does this with an explicit ownership concept."
+msgstr ""
+
+#: src/memory-management.md:15
+msgid "First, let's refresh how memory management works."
+msgstr ""
+
+#: src/memory-management/stack-vs-heap.md:1
+msgid "# The Stack vs The Heap"
+msgstr ""
+
+#: src/memory-management/stack-vs-heap.md:3
+msgid ""
+"* Stack: Continuous area of memory for local variables.\n"
+"  * Values have fixed sizes known at compile time.\n"
+"  * Extremely fast: just move a stack pointer.\n"
+"  * Easy to manage: follows function calls.\n"
+"  * Great memory locality."
+msgstr ""
+
+#: src/memory-management/stack-vs-heap.md:9
+msgid ""
+"* Heap: Storage of values outside of function calls.\n"
+"  * Values have dynamic sizes determined at runtime.\n"
+"  * Slightly slower than the stack: some book-keeping needed.\n"
+"  * No guarantee of memory locality."
+msgstr ""
+
+#: src/memory-management/stack.md:1
+msgid "# Stack Memory"
+msgstr ""
+
+#: src/memory-management/stack.md:3
+msgid ""
+"Creating a `String` puts fixed-sized data on the stack and dynamically "
+"sized\n"
+"data on the heap:"
+msgstr ""
+
+#: src/memory-management/stack.md:6
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let s1 = String::from(\"Hello\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/memory-management/stack.md:12
+msgid ""
+"```bob\n"
+" Stack                             Heap\n"
+".- - - - - - - - - - - - - -.     .- - - - - - - - - - - - - - - -.\n"
+":                           :     :                               :\n"
+":    s1                     :     :                               :\n"
+":   +-----------+-------+   :     :   +----+----+----+----+----+  :\n"
+":   | ptr       |   o---+---+-----+-->| H  | e  | l  | l  | o  |  :\n"
+":   | len       |     5 |   :     :   +----+----+----+----+----+  :\n"
+":   | capacity  |     5 |   :     :                               :\n"
+":   +-----------+-------+   :     :                               :\n"
+":                           :     `- - - - - - - - - - - - - - - -'\n"
+"`- - - - - - - - - - - - - -'\n"
+"```"
+msgstr ""
+
+#: src/memory-management/manual.md:1
+msgid "# Manual Memory Management"
+msgstr ""
+
+#: src/memory-management/manual.md:3
+msgid "You allocate and deallocate heap memory yourself."
+msgstr ""
+
+#: src/memory-management/manual.md:5
+msgid "## C Example"
+msgstr ""
+
+#: src/memory-management/manual.md:7
+msgid "You must call `free` on every pointer you allocate with `malloc`:"
+msgstr ""
+
+#: src/memory-management/manual.md:9
+msgid ""
+"```c\n"
+"void foo(size_t n) {\n"
+"    int* int_array = (int*)malloc(n * sizeof(int));\n"
+"    //\n"
+"    // ... lots of code\n"
+"    //\n"
+"    free(int_array);\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/memory-management/manual.md:19
+msgid ""
+"Memory is leaked if the function returns early between `malloc` and `free`: "
+"the\n"
+"pointer is lost and we cannot deallocate the memory."
+msgstr ""
+
+#: src/memory-management/scope-based.md:1
+msgid "# Scope-Based Memory Management"
+msgstr ""
+
+#: src/memory-management/scope-based.md:3
+msgid "Constructors and destructors let you hook into the lifetime of an object."
+msgstr ""
+
+#: src/memory-management/scope-based.md:5
+msgid ""
+"By wrapping a pointer in an object, you can free memory when the object is\n"
+"destroyed. The compiler guarantees that this happens, even if an exception "
+"is\n"
+"raised."
+msgstr ""
+
+#: src/memory-management/scope-based.md:9
+msgid ""
+"This is often called _resource acquisition is initialization_ (RAII) and "
+"gives\n"
+"you smart pointers."
+msgstr ""
+
+#: src/memory-management/scope-based.md:12
+msgid "## C++ Example"
+msgstr ""
+
+#: src/memory-management/scope-based.md:14
+msgid ""
+"```c++\n"
+"void say_hello(std::unique_ptr<Person> person) {\n"
+"  std::cout << \"Hello \" << person->name << std::endl;\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/memory-management/scope-based.md:20
+msgid ""
+"* The `std::unique_ptr` object is allocated on the stack, and points to\n"
+"  memory allocated on the heap.\n"
+"* At the end of `say_hello`, the `std::unique_ptr` destructor will run.\n"
+"* The destructor frees the `Person` object it points to."
+msgstr ""
+
+#: src/memory-management/scope-based.md:25
+msgid "Special move constructors are used when passing ownership to a function:"
+msgstr ""
+
+#: src/memory-management/scope-based.md:27
+msgid ""
+"```c++\n"
+"std::unique_ptr<Person> person = find_person(\"Carla\");\n"
+"say_hello(std::move(person));\n"
+"```"
+msgstr ""
+
+#: src/memory-management/garbage-collection.md:1
+msgid "# Automatic Memory Management"
+msgstr ""
+
+#: src/memory-management/garbage-collection.md:3
+msgid ""
+"An alternative to manual and scope-based memory management is automatic "
+"memory\n"
+"management:"
+msgstr ""
+
+#: src/memory-management/garbage-collection.md:6
+msgid ""
+"* The programmer never allocates or deallocates memory explicitly.\n"
+"* A garbage collector finds unused memory and deallocates it for the "
+"programmer."
+msgstr ""
+
+#: src/memory-management/garbage-collection.md:9
+msgid "## Java Example"
+msgstr ""
+
+#: src/memory-management/garbage-collection.md:11
+msgid "The `person` object is not deallocated after `sayHello` returns:"
+msgstr ""
+
+#: src/memory-management/garbage-collection.md:13
+msgid ""
+"```java\n"
+"void sayHello(Person person) {\n"
+"  System.out.println(\"Hello \" + person.getName());\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/memory-management/rust.md:1
+msgid "# Memory Management in Rust"
+msgstr ""
+
+#: src/memory-management/rust.md:3
+msgid "Memory management in Rust is a mix:"
+msgstr ""
+
+#: src/memory-management/rust.md:5
+msgid ""
+"* Safe and correct like Java, but without a garbage collector.\n"
+"* Scope-based like C++, but the compiler enforces full adherence.\n"
+"* Has no runtime overhead like in C and C++."
+msgstr ""
+
+#: src/memory-management/rust.md:9
+msgid "It achieves this by modeling _ownership_ explicitly."
+msgstr ""
+
+#: src/memory-management/comparison.md:1
+msgid "# Comparison"
+msgstr ""
+
+#: src/memory-management/comparison.md:3
+msgid "Here is a rough comparison of the memory management techniques."
+msgstr ""
+
+#: src/memory-management/comparison.md:5
+msgid "## Pros of Different Memory Management Techniques"
+msgstr ""
+
+#: src/memory-management/comparison.md:7
+msgid ""
+"* Manual like C:\n"
+"  * No runtime overhead.\n"
+"* Automatic like Java:\n"
+"  * Fully automatic.\n"
+"  * Safe and correct.\n"
+"* Scope-based like C++:\n"
+"  * Partially automatic.\n"
+"  * No runtime overhead.\n"
+"* Compiler-enforced scope-based like Rust:\n"
+"  * Enforced by compiler.\n"
+"  * No runtime overhead.\n"
+"  * Safe and correct."
+msgstr ""
+
+#: src/memory-management/comparison.md:20
+msgid "## Cons of Different Memory Management Techniques"
+msgstr ""
+
+#: src/memory-management/comparison.md:22
+msgid ""
+"* Manual like C:\n"
+"  * Use-after-free.\n"
+"  * Double-frees.\n"
+"  * Memory leaks.\n"
+"* Automatic like Java:\n"
+"  * Garbage collection pauses.\n"
+"  * Destructor delays.\n"
+"* Scope-based like C++:\n"
+"  * Complex, opt-in by programmer.\n"
+"  * Potential for use-after-free.\n"
+"* Compiler-enforced and scope-based like Rust:\n"
+"  * Some upfront complexity.\n"
+"  * Can reject valid programs."
+msgstr ""
+
+#: src/ownership.md:1
+msgid "# Ownership"
+msgstr ""
+
+#: src/ownership.md:3
+msgid ""
+"All variable bindings have a _scope_ where they are valid and it is an error "
+"to\n"
+"use a variable outside its scope:"
+msgstr ""
+
+#: src/ownership.md:6
+msgid "```rust,editable,compile_fail\nstruct Point(i32, i32);"
+msgstr ""
+
+#: src/ownership.md:9
+msgid ""
+"fn main() {\n"
+"    {\n"
+"        let p = Point(3, 4);\n"
+"        println!(\"x: {}\", p.0);\n"
+"    }\n"
+"    println!(\"y: {}\", p.1);\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/ownership.md:18
+msgid ""
+"* At the end of the scope, the variable is _dropped_ and the data is freed.\n"
+"* A destructor can run here to free up resources.\n"
+"* We say that the variable _owns_ the value."
+msgstr ""
+
+#: src/ownership/move-semantics.md:1
+msgid "# Move Semantics"
+msgstr ""
+
+#: src/ownership/move-semantics.md:3
+msgid "An assignment will transfer ownership between variables:"
+msgstr ""
+
+#: src/ownership/move-semantics.md:5
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let s1: String = String::from(\"Hello!\");\n"
+"    let s2: String = s1;\n"
+"    println!(\"s2: {s2}\");\n"
+"    // println!(\"s1: {s1}\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/ownership/move-semantics.md:14
+msgid ""
+"* The assignment of `s1` to `s2` transfers ownership.\n"
+"* The data was _moved_ from `s1` and `s1` is no longer accessible.\n"
+"* When `s1` goes out of scope, nothing happens: it has no ownership.\n"
+"* When `s2` goes out of scope, the string data is freed.\n"
+"* There is always _exactly_ one variable binding which owns a value."
+msgstr ""
+
+#: src/ownership/moved-strings-rust.md:1
+msgid "# Moved Strings in Rust"
+msgstr ""
+
+#: src/ownership/moved-strings-rust.md:3
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let s1: String = String::from(\"Rust\");\n"
+"    let s2: String = s1;\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/ownership/moved-strings-rust.md:10
+msgid ""
+"* The heap data from `s1` is reused for `s2`.\n"
+"* When `s1` goes out of scope, nothing happens (it has been moved from)."
+msgstr ""
+
+#: src/ownership/moved-strings-rust.md:13
+msgid "Before move to `s2`:"
+msgstr ""
+
+#: src/ownership/moved-strings-rust.md:15
+msgid ""
+"```bob\n"
+" Stack                             Heap\n"
+".- - - - - - - - - - - - - -.     .- - - - - - - - - - - - - -.\n"
+":                           :     :                           :\n"
+":    s1                     :     :                           :\n"
+":   +-----------+-------+   :     :   +----+----+----+----+   :\n"
+":   | ptr       |   o---+---+-----+-->| R  | u  | s  | t  |   :\n"
+":   | len       |     4 |   :     :   +----+----+----+----+   :\n"
+":   | capacity  |     4 |   :     :                           :\n"
+":   +-----------+-------+   :     :                           :\n"
+":                           :     `- - - - - - - - - - - - - -'\n"
+":                           :\n"
+"`- - - - - - - - - - - - - -'\n"
+"```"
+msgstr ""
+
+#: src/ownership/moved-strings-rust.md:30
+msgid "After move to `s2`:"
+msgstr ""
+
+#: src/ownership/moved-strings-rust.md:32
+msgid ""
+"```bob\n"
+" Stack                             Heap\n"
+".- - - - - - - - - - - - - -.     .- - - - - - - - - - - - - -.\n"
+":                           :     :                           :\n"
+":    s1 \"(inaccessible)\"    :     :                           :\n"
+":   +-----------+-------+   :     :   +----+----+----+----+   :\n"
+":   | ptr       |   o---+---+--+--+-->| R  | u  | s  | t  |   :\n"
+":   | len       |     4 |   :  |  :   +----+----+----+----+   :\n"
+":   | capacity  |     4 |   :  |  :                           :\n"
+":   +-----------+-------+   :  |  :                           :\n"
+":                           :  |  `- - - - - - - - - - - - - -'\n"
+":    s2                     :  |\n"
+":   +-----------+-------+   :  |\n"
+":   | ptr       |   o---+---+--'\n"
+":   | len       |     4 |   :\n"
+":   | capacity  |     4 |   :\n"
+":   +-----------+-------+   :\n"
+":                           :\n"
+"`- - - - - - - - - - - - - -'\n"
+"```"
+msgstr ""
+
+#: src/ownership/double-free-modern-cpp.md:1
+msgid "# Double Frees in Modern C++"
+msgstr ""
+
+#: src/ownership/double-free-modern-cpp.md:3
+msgid "Modern C++ solves this differently:"
+msgstr ""
+
+#: src/ownership/double-free-modern-cpp.md:5
+msgid ""
+"```c++\n"
+"std::string s1 = \"Cpp\";\n"
+"std::string s2 = s1;  // Duplicate the data in s1.\n"
+"```"
+msgstr ""
+
+#: src/ownership/double-free-modern-cpp.md:10
+msgid ""
+"* The heap data from `s1` is duplicated and `s2` gets its own independent "
+"copy.\n"
+"* When `s1` and `s2` go out of scope, they each free their own memory."
+msgstr ""
+
+#: src/ownership/double-free-modern-cpp.md:13
+msgid "Before copy-assignment:"
+msgstr ""
+
+#: src/ownership/double-free-modern-cpp.md:16
+msgid ""
+"```bob\n"
+" Stack                             Heap\n"
+".- - - - - - - - - - - - - -.     .- - - - - - - - - - - -.\n"
+":                           :     :                       :\n"
+":    s1                     :     :                       :\n"
+":   +-----------+-------+   :     :   +----+----+----+    :\n"
+":   | ptr       |   o---+---+--+--+-->| C  | p  | p  |    :\n"
+":   | len       |     3 |   :     :   +----+----+----+    :\n"
+":   | capacity  |     3 |   :     :                       :\n"
+":   +-----------+-------+   :     :                       :\n"
+":                           :     `- - - - - - - - - - - -'\n"
+"`- - - - - - - - - - - - - -'\n"
+"```"
+msgstr ""
+
+#: src/ownership/double-free-modern-cpp.md:30
+msgid "After copy-assignment:"
+msgstr ""
+
+#: src/ownership/double-free-modern-cpp.md:32
+msgid ""
+"```bob\n"
+" Stack                             Heap\n"
+".- - - - - - - - - - - - - -.     .- - - - - - - - - - - -.\n"
+":                           :     :                       :\n"
+":    s1                     :     :                       :\n"
+":   +-----------+-------+   :     :   +----+----+----+    :\n"
+":   | ptr       |   o---+---+--+--+-->| C  | p  | p  |    :\n"
+":   | len       |     3 |   :     :   +----+----+----+    :\n"
+":   | capacity  |     3 |   :     :                       :\n"
+":   +-----------+-------+   :     :                       :\n"
+":                           :     :                       :\n"
+":    s2                     :     :                       :\n"
+":   +-----------+-------+   :     :   +----+----+----+    :\n"
+":   | ptr       |   o---+---+-----+-->| C  | p  | p  |    :\n"
+":   | len       |     3 |   :     :   +----+----+----+    :\n"
+":   | capacity  |     3 |   :     :                       :\n"
+":   +-----------+-------+   :     :                       :\n"
+":                           :     `- - - - - - - - - - - -'\n"
+"`- - - - - - - - - - - - - -'\n"
+"```"
+msgstr ""
+
+#: src/ownership/moves-function-calls.md:1
+msgid "# Moves in Function Calls"
+msgstr ""
+
+#: src/ownership/moves-function-calls.md:3
+msgid ""
+"When you pass a value to a function, the value is assigned to the function\n"
+"parameter. This transfers ownership:"
+msgstr ""
+
+#: src/ownership/moves-function-calls.md:6
+msgid ""
+"```rust,editable\n"
+"fn say_hello(name: String) {\n"
+"    println!(\"Hello {name}\")\n"
+"}"
+msgstr ""
+
+#: src/ownership/moves-function-calls.md:11
+msgid ""
+"fn main() {\n"
+"    let name = String::from(\"Alice\");\n"
+"    say_hello(name);\n"
+"    // say_hello(name);\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/ownership/copy-clone.md:1
+msgid "# Copying and Cloning"
+msgstr ""
+
+#: src/ownership/copy-clone.md:3
+msgid ""
+"While move semantics are the default, certain types are copied by default:"
+msgstr ""
+
+#: src/ownership/copy-clone.md:5
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let x = 42;\n"
+"    let y = x;\n"
+"    println!(\"x: {x}\");\n"
+"    println!(\"y: {y}\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/ownership/copy-clone.md:14
+msgid "These types implement the `Copy` trait."
+msgstr ""
+
+#: src/ownership/copy-clone.md:16
+msgid "You can opt-in your own types to use copy semantics:"
+msgstr ""
+
+#: src/ownership/copy-clone.md:18
+msgid ""
+"```rust,editable\n"
+"#[derive(Copy, Clone, Debug)]\n"
+"struct Point(i32, i32);"
+msgstr ""
+
+#: src/ownership/copy-clone.md:22
+msgid ""
+"fn main() {\n"
+"    let p1 = Point(3, 4);\n"
+"    let p2 = p1;\n"
+"    println!(\"p1: {p1:?}\");\n"
+"    println!(\"p2: {p2:?}\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/ownership/copy-clone.md:30
+msgid ""
+"* After the assignment, both `p1` and `p2` own their own data.\n"
+"* We can also use `p1.clone()` to explicitly copy the data."
+msgstr ""
+
+#: src/ownership/copy-clone.md:35
+msgid "Copying and cloning are not the same thing:"
+msgstr ""
+
+#: src/ownership/copy-clone.md:37
+msgid ""
+"* Copying refers to bitwise copies of memory regions and does not work on "
+"arbitrary objects.\n"
+"* Copying does not allow for custom logic (unlike copy constructors in "
+"C++).\n"
+"* Cloning is a more general operation and also allows for custom behavior by "
+"implementing the `Clone` trait.\n"
+"* Copying does not work on types that implement the `Drop` trait."
+msgstr ""
+
+#: src/ownership/copy-clone.md:42
+#: src/ownership/lifetimes-function-calls.md:29
+msgid "In the above example, try the following:"
+msgstr ""
+
+#: src/ownership/copy-clone.md:44
+msgid ""
+"* Add a `String` field to `struct Point`. It will not compile because "
+"`String` is not a `Copy` type.\n"
+"* Remove `Copy` from the `derive` attribute. The compiler error is now in "
+"the `println!` for  `p1`.\n"
+"* Show that it works if you clone `p1` instead."
+msgstr ""
+
+#: src/ownership/borrowing.md:1
+msgid "# Borrowing"
+msgstr ""
+
+#: src/ownership/borrowing.md:3
+msgid ""
+"Instead of transferring ownership when calling a function, you can let a\n"
+"function _borrow_ the value:"
+msgstr ""
+
+#: src/ownership/borrowing.md:6
+#: src/ownership/lifetimes-function-calls.md:5
+msgid ""
+"```rust,editable\n"
+"#[derive(Debug)]\n"
+"struct Point(i32, i32);"
+msgstr ""
+
+#: src/ownership/borrowing.md:10
+msgid ""
+"fn add(p1: &Point, p2: &Point) -> Point {\n"
+"    Point(p1.0 + p2.0, p1.1 + p2.1)\n"
+"}"
+msgstr ""
+
+#: src/ownership/borrowing.md:14
+msgid ""
+"fn main() {\n"
+"    let p1 = Point(3, 4);\n"
+"    let p2 = Point(10, 20);\n"
+"    let p3 = add(&p1, &p2);\n"
+"    println!(\"{p1:?} + {p2:?} = {p3:?}\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/ownership/borrowing.md:22
+msgid ""
+"* The `add` function _borrows_ two points and returns a new point.\n"
+"* The caller retains ownership of the inputs."
+msgstr ""
+
+#: src/ownership/borrowing.md:27
+msgid ""
+"Notes on stack returns:\n"
+"* Demonstrate that the return from `add` is cheap because the compiler can "
+"eliminate the copy operation. Change the above code to print stack addresses "
+"and run it on the [Playground](https://play.rust-lang.org/). In the "
+"\"DEBUG\" optimization level, the addresses should change, while the stay "
+"the same when changning to the \"RELEASE\" setting:"
+msgstr ""
+
+#: src/ownership/borrowing.md:30
+msgid ""
+"  ```rust,editable\n"
+"  #[derive(Debug)]\n"
+"  struct Point(i32, i32);"
+msgstr ""
+
+#: src/ownership/borrowing.md:34
+msgid ""
+"  fn add(p1: &Point, p2: &Point) -> Point {\n"
+"      let p = Point(p1.0 + p2.0, p1.1 + p2.1);\n"
+"      println!(\"&p.0: {:p}\", &p.0);\n"
+"      p\n"
+"  }"
+msgstr ""
+
+#: src/ownership/borrowing.md:40
+msgid ""
+"  fn main() {\n"
+"      let p1 = Point(3, 4);\n"
+"      let p2 = Point(10, 20);\n"
+"      let p3 = add(&p1, &p2);\n"
+"      println!(\"&p3.0: {:p}\", &p3.0);\n"
+"      println!(\"{p1:?} + {p2:?} = {p3:?}\");\n"
+"  }\n"
+"  ```\n"
+"* The Rust compiler can do return value optimization (RVO).\n"
+"* In C++, copy elision has to be defined in the language specification "
+"because constructors can have side effects. In Rust, this is not an issue at "
+"all."
+msgstr ""
+
+#: src/ownership/shared-unique-borrows.md:1
+msgid "# Shared and Unique Borrows"
+msgstr ""
+
+#: src/ownership/shared-unique-borrows.md:3
+msgid "Rust puts constraints on the ways you can borrow values:"
+msgstr ""
+
+#: src/ownership/shared-unique-borrows.md:5
+msgid ""
+"* You can have one or more `&T` values at any given time, _or_\n"
+"* You can have exactly one `&mut T` value."
+msgstr ""
+
+#: src/ownership/shared-unique-borrows.md:8
+msgid ""
+"```rust,editable,compile_fail\n"
+"fn main() {\n"
+"    let mut a: i32 = 10;\n"
+"    let b: &i32 = &a;"
+msgstr ""
+
+#: src/ownership/shared-unique-borrows.md:13
+msgid ""
+"    {\n"
+"        let c: &mut i32 = &mut a;\n"
+"        *c = 20;\n"
+"    }"
+msgstr ""
+
+#: src/ownership/shared-unique-borrows.md:18
+#: src/std/rc.md:13
+msgid ""
+"    println!(\"a: {a}\");\n"
+"    println!(\"b: {b}\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/ownership/shared-unique-borrows.md:25
+msgid ""
+"* The above code does not compile because `a` is borrowed as mutable "
+"(through `c`) and as immutable (through `b`) at the same time.\n"
+"* Move the `println!` statement for `b` before the scope that introduces `c` "
+"to make the code compile.\n"
+"* After that change, the compiler realizes that `b` is only ever used before "
+"the new mutable borrow of `a` through `c`. This is a feature of the borrow "
+"checker called \"non-lexical lifetimes\"."
+msgstr ""
+
+#: src/ownership/lifetimes.md:1
+msgid "# Lifetimes"
+msgstr ""
+
+#: src/ownership/lifetimes.md:3
+msgid "A borrowed value has a _lifetime_:"
+msgstr ""
+
+#: src/ownership/lifetimes.md:5
+msgid ""
+"* The lifetime can be elided: `add(p1: &Point, p2: &Point) -> Point`.\n"
+"* Lifetimes can also be explicit: `&'a Point`, `&'document str`.\n"
+"* Read `&'a Point` as \"a borrowed `Point` which is valid for at least the\n"
+"  lifetime `a`\".\n"
+"* Lifetimes are always inferred by the compiler: you cannot assign a "
+"lifetime\n"
+"  yourself.\n"
+"  * Lifetime annotations create constraints; the compiler verifies that "
+"there is\n"
+"    a valid solution."
+msgstr ""
+
+#: src/ownership/lifetimes-function-calls.md:1
+msgid "# Lifetimes in Function Calls"
+msgstr ""
+
+#: src/ownership/lifetimes-function-calls.md:3
+msgid ""
+"In addition to borrowing its arguments, a function can return a borrowed "
+"value:"
+msgstr ""
+
+#: src/ownership/lifetimes-function-calls.md:9
+msgid ""
+"fn left_most<'a>(p1: &'a Point, p2: &'a Point) -> &'a Point {\n"
+"    if p1.0 < p2.0 { p1 } else { p2 }\n"
+"}"
+msgstr ""
+
+#: src/ownership/lifetimes-function-calls.md:13
+msgid ""
+"fn main() {\n"
+"    let p1: Point = Point(10, 10);\n"
+"    let p2: Point = Point(20, 20);\n"
+"    let p3: &Point = left_most(&p1, &p2);\n"
+"    println!(\"left-most point: {:?}\", p3);\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/ownership/lifetimes-function-calls.md:21
+msgid ""
+"* `'a` is a generic parameter, it is inferred by the compiler.\n"
+"* Lifetimes start with `'` and `'a` is a typical default name.\n"
+"* Read `&'a Point` as \"a borrowed `Point` which is valid for at least the\n"
+"  lifetime `a`\".\n"
+"  * The _at least_ part is important when parameters are in different scopes."
+msgstr ""
+
+#: src/ownership/lifetimes-function-calls.md:31
+msgid ""
+"* Move the declaration of `p2` and `p3` into a a new scope (`{ ... }`), "
+"resulting in the following code:\n"
+"  ```rust,ignore\n"
+"  #[derive(Debug)]\n"
+"  struct Point(i32, i32);"
+msgstr ""
+
+#: src/ownership/lifetimes-function-calls.md:36
+msgid ""
+"  fn left_most<'a>(p1: &'a Point, p2: &'a Point) -> &'a Point {\n"
+"      if p1.0 < p2.0 { p1 } else { p2 }\n"
+"  }"
+msgstr ""
+
+#: src/ownership/lifetimes-function-calls.md:40
+msgid ""
+"  fn main() {\n"
+"      let p1: Point = Point(10, 10);\n"
+"      let p3: &Point;\n"
+"      {\n"
+"          let p2: Point = Point(20, 20);\n"
+"          p3 = left_most(&p1, &p2);\n"
+"      }\n"
+"      println!(\"left-most point: {:?}\", p3);\n"
+"  }\n"
+"  ```\n"
+"  Note how this does not compile since `p3` outlives `p2`."
+msgstr ""
+
+#: src/ownership/lifetimes-function-calls.md:52
+msgid ""
+"* Reset the workspace and change the function signature to `fn left_most<'a, "
+"'b>(p1: &'a Point, p2: &'a Point) -> &'b Point`. This will not compile "
+"because the relationship between the lifetimes `'a` and `'b` is unclear."
+msgstr ""
+
+#: src/ownership/lifetimes-data-structures.md:1
+msgid "# Lifetimes in Data Structures"
+msgstr ""
+
+#: src/ownership/lifetimes-data-structures.md:3
+msgid ""
+"If a data type stores borrowed data, it must be annotated with a lifetime:"
+msgstr ""
+
+#: src/ownership/lifetimes-data-structures.md:5
+msgid ""
+"```rust,editable\n"
+"#[derive(Debug)]\n"
+"struct Highlight<'doc>(&'doc str);"
+msgstr ""
+
+#: src/ownership/lifetimes-data-structures.md:9
+msgid ""
+"fn erase(text: String) {\n"
+"    println!(\"Bye {text}!\");\n"
+"}"
+msgstr ""
+
+#: src/ownership/lifetimes-data-structures.md:13
+msgid ""
+"fn main() {\n"
+"    let text = String::from(\"The quick brown fox jumps over the lazy "
+"dog.\");\n"
+"    let fox = Highlight(&text[4..19]);\n"
+"    let dog = Highlight(&text[35..43]);\n"
+"    // erase(text);\n"
+"    println!(\"{fox:?}\");\n"
+"    println!(\"{dog:?}\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/exercises/day-1/afternoon.md:1
+msgid "# Day 1: Afternoon Exercises"
+msgstr ""
+
+#: src/exercises/day-1/afternoon.md:3
+msgid "We will look at two things:"
+msgstr ""
+
+#: src/exercises/day-1/afternoon.md:5
+msgid "* A small book library,"
+msgstr ""
+
+#: src/exercises/day-1/afternoon.md:7
+msgid "* Iterators and ownership (hard)."
+msgstr ""
+
+#: src/exercises/day-1/book-library.md:1
+msgid "# Designing a Library"
+msgstr ""
+
+#: src/exercises/day-1/book-library.md:3
+msgid ""
+"We will learn much more about structs and the `Vec<T>` type tomorrow. For "
+"now,\n"
+"you just need to know part of its API:"
+msgstr ""
+
+#: src/exercises/day-1/book-library.md:6
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let mut vec = vec![10, 20];\n"
+"    vec.push(30);\n"
+"    println!(\"middle value: {}\", vec[vec.len() / 2]);\n"
+"    for item in vec.iter() {\n"
+"        println!(\"item: {item}\");\n"
+"    }\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/exercises/day-1/book-library.md:17
+msgid ""
+"Use this to create a library application. Copy the code below to\n"
+"<https://play.rust-lang.org/> and update the types to make it compile:"
+msgstr ""
+
+#: src/exercises/day-1/book-library.md:24
+msgid ""
+"struct Library {\n"
+"    books: Vec<Book>,\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-1/book-library.md:28
+#: src/exercises/day-1/solutions-afternoon.md:27
+msgid ""
+"struct Book {\n"
+"    title: String,\n"
+"    year: u16,\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-1/book-library.md:33
+#: src/exercises/day-1/solutions-afternoon.md:32
+msgid ""
+"impl Book {\n"
+"    // This is a constructor, used below.\n"
+"    fn new(title: &str, year: u16) -> Book {\n"
+"        Book {\n"
+"            title: String::from(title),\n"
+"            year,\n"
+"        }\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-1/book-library.md:43
+msgid ""
+"// This makes it possible to print Book values with {}.\n"
+"impl std::fmt::Display for Book {\n"
+"    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {\n"
+"        write!(f, \"{} ({})\", self.title, self.year)\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-1/book-library.md:50
+msgid ""
+"impl Library {\n"
+"    fn new() -> Library {\n"
+"        unimplemented!()\n"
+"    }"
+msgstr ""
+
+#: src/exercises/day-1/book-library.md:55
+msgid ""
+"    //fn len(self) -> usize {\n"
+"    //    unimplemented!()\n"
+"    //}"
+msgstr ""
+
+#: src/exercises/day-1/book-library.md:59
+msgid ""
+"    //fn is_empty(self) -> bool {\n"
+"    //    unimplemented!()\n"
+"    //}"
+msgstr ""
+
+#: src/exercises/day-1/book-library.md:63
+msgid ""
+"    //fn add_book(self, book: Book) {\n"
+"    //    unimplemented!()\n"
+"    //}"
+msgstr ""
+
+#: src/exercises/day-1/book-library.md:67
+msgid ""
+"    //fn print_books(self) {\n"
+"    //    unimplemented!()\n"
+"    //}"
+msgstr ""
+
+#: src/exercises/day-1/book-library.md:71
+msgid ""
+"    //fn oldest_book(self) -> Option<&Book> {\n"
+"    //    unimplemented!()\n"
+"    //}\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-1/book-library.md:76
+msgid ""
+"// This shows the desired behavior. Uncomment the code below and\n"
+"// implement the missing methods. You will need to update the\n"
+"// method signatures, including the \"self\" parameter!\n"
+"fn main() {\n"
+"    let library = Library::new();"
+msgstr ""
+
+#: src/exercises/day-1/book-library.md:82
+msgid ""
+"    //println!(\"Our library is empty: {}\", library.is_empty());\n"
+"    //\n"
+"    //library.add_book(Book::new(\"Lord of the Rings\", 1954));\n"
+"    //library.add_book(Book::new(\"Alice's Adventures in Wonderland\", "
+"1865));\n"
+"    //\n"
+"    //library.print_books();\n"
+"    //\n"
+"    //match library.oldest_book() {\n"
+"    //    Some(book) => println!(\"My oldest book is {book}\"),\n"
+"    //    None => println!(\"My library is empty!\"),\n"
+"    //}\n"
+"    //\n"
+"    //println!(\"Our library has {} books\", library.len());\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/exercises/day-1/iterators-and-ownership.md:1
+msgid "# Iterators and Ownership"
+msgstr ""
+
+#: src/exercises/day-1/iterators-and-ownership.md:3
+msgid ""
+"The ownership model of Rust affects many APIs. An example of this is the\n"
+"[`Iterator`](https://doc.rust-lang.org/std/iter/trait.Iterator.html) and\n"
+"[`IntoIterator`](https://doc.rust-lang.org/std/iter/trait.IntoIterator.html)\n"
+"traits."
+msgstr ""
+
+#: src/exercises/day-1/iterators-and-ownership.md:8
+msgid "## `Iterator`"
+msgstr ""
+
+#: src/exercises/day-1/iterators-and-ownership.md:10
+msgid ""
+"Traits are like interfaces: they describe behavior (methods) for a type. "
+"The\n"
+"`Iterator` trait simply says that you can call `next` until you get `None` "
+"back:"
+msgstr ""
+
+#: src/exercises/day-1/iterators-and-ownership.md:13
+msgid ""
+"```rust\n"
+"pub trait Iterator {\n"
+"    type Item;\n"
+"    fn next(&mut self) -> Option<Self::Item>;\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/exercises/day-1/iterators-and-ownership.md:20
+msgid "You use this trait like this:"
+msgstr ""
+
+#: src/exercises/day-1/iterators-and-ownership.md:22
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let v: Vec<i8> = vec![10, 20, 30];\n"
+"    let mut iter = v.iter();"
+msgstr ""
+
+#: src/exercises/day-1/iterators-and-ownership.md:27
+msgid ""
+"    println!(\"v[0]: {:?}\", iter.next());\n"
+"    println!(\"v[1]: {:?}\", iter.next());\n"
+"    println!(\"v[2]: {:?}\", iter.next());\n"
+"    println!(\"No more items: {:?}\", iter.next());\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/exercises/day-1/iterators-and-ownership.md:34
+msgid "What is the type returned by the iterator? Test your answer here:"
+msgstr ""
+
+#: src/exercises/day-1/iterators-and-ownership.md:36
+msgid ""
+"```rust,editable,compile_fail\n"
+"fn main() {\n"
+"    let v: Vec<i8> = vec![10, 20, 30];\n"
+"    let mut iter = v.iter();"
+msgstr ""
+
+#: src/exercises/day-1/iterators-and-ownership.md:41
+#: src/exercises/day-1/iterators-and-ownership.md:78
+msgid ""
+"    let v0: Option<..> = iter.next();\n"
+"    println!(\"v0: {v0:?}\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/exercises/day-1/iterators-and-ownership.md:46
+msgid "Why is this type used?"
+msgstr ""
+
+#: src/exercises/day-1/iterators-and-ownership.md:48
+msgid "## `IntoIterator`"
+msgstr ""
+
+#: src/exercises/day-1/iterators-and-ownership.md:50
+msgid ""
+"The `Iterator` trait tells you how to _iterate_ once you have created an\n"
+"iterator. The related trait `IntoIterator` tells you how to create the "
+"iterator:"
+msgstr ""
+
+#: src/exercises/day-1/iterators-and-ownership.md:53
+msgid ""
+"```rust\n"
+"pub trait IntoIterator {\n"
+"    type Item;\n"
+"    type IntoIter: Iterator<Item = Self::Item>;"
+msgstr ""
+
+#: src/exercises/day-1/iterators-and-ownership.md:58
+msgid ""
+"    fn into_iter(self) -> Self::IntoIter;\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/exercises/day-1/iterators-and-ownership.md:62
+msgid ""
+"The syntax here means that every implementation of `IntoIterator` must\n"
+"declare two types:"
+msgstr ""
+
+#: src/exercises/day-1/iterators-and-ownership.md:65
+msgid ""
+"* `Item`: the type we iterate over, such as `i8`,\n"
+"* `IntoIter`: the `Iterator` type returned by the `into_iter` method."
+msgstr ""
+
+#: src/exercises/day-1/iterators-and-ownership.md:68
+msgid ""
+"Note that `IntoIter` and `Item` are linked: the iterator must have the same\n"
+"`Item` type, which means that it returns `Option<Item>`"
+msgstr ""
+
+#: src/exercises/day-1/iterators-and-ownership.md:71
+msgid "Like before, what  is the type returned by the iterator?"
+msgstr ""
+
+#: src/exercises/day-1/iterators-and-ownership.md:73
+msgid ""
+"```rust,editable,compile_fail\n"
+"fn main() {\n"
+"    let v: Vec<String> = vec![String::from(\"foo\"), "
+"String::from(\"bar\")];\n"
+"    let mut iter = v.into_iter();"
+msgstr ""
+
+#: src/exercises/day-1/iterators-and-ownership.md:83
+msgid "## `for` Loops"
+msgstr ""
+
+#: src/exercises/day-1/iterators-and-ownership.md:85
+msgid ""
+"Now that we know both `Iterator` and `IntoIterator`, we can build `for` "
+"loops.\n"
+"They call `into_iter()` on an expression and iterates over the resulting\n"
+"iterator:"
+msgstr ""
+
+#: src/exercises/day-1/iterators-and-ownership.md:89
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let v: Vec<String> = vec![String::from(\"foo\"), String::from(\"bar\")];"
+msgstr ""
+
+#: src/exercises/day-1/iterators-and-ownership.md:93
+msgid ""
+"    for word in &v {\n"
+"        println!(\"word: {word}\");\n"
+"    }"
+msgstr ""
+
+#: src/exercises/day-1/iterators-and-ownership.md:97
+msgid ""
+"    for word in v {\n"
+"        println!(\"word: {word}\");\n"
+"    }\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/exercises/day-1/iterators-and-ownership.md:103
+msgid "What is the type of `word` in each loop?"
+msgstr ""
+
+#: src/exercises/day-1/iterators-and-ownership.md:105
+msgid ""
+"Experiment with the code above and then consult the documentation for "
+"[`impl\n"
+"IntoIterator for\n"
+"&Vec<T>`](https://doc.rust-lang.org/std/vec/struct.Vec.html#impl-IntoIterator-for-%26%27a%20Vec%3CT%2C%20A%3E)\n"
+"and [`impl IntoIterator for\n"
+"Vec<T>`](https://doc.rust-lang.org/std/vec/struct.Vec.html#impl-IntoIterator-for-%26%27a%20Vec%3CT%2C%20A%3E)\n"
+"to check your answers."
+msgstr ""
+
+#: src/welcome-day-2.md:1
+msgid "# Welcome to Day 2"
+msgstr ""
+
+#: src/welcome-day-2.md:3
+msgid "Now that we have seen a fair amount of Rust, we will continue with:"
+msgstr ""
+
+#: src/welcome-day-2.md:5
+msgid "* Structs, enums, methods."
+msgstr ""
+
+#: src/welcome-day-2.md:7
+msgid "* Pattern matching: destructuring enums, structs, and arrays."
+msgstr ""
+
+#: src/welcome-day-2.md:9
+msgid ""
+"* Control flow constructs: `if`, `if let`, `while`, `while let`, `break`, "
+"and\n"
+"  `continue`."
+msgstr ""
+
+#: src/welcome-day-2.md:12
+msgid ""
+"* The Standard Library: `String`, `Option` and `Result`, `Vec`, `HashMap`, "
+"`Rc`\n"
+"  and `Arc`."
+msgstr ""
+
+#: src/welcome-day-2.md:15
+msgid "* Modules: visibility, paths, and filesystem hierarchy."
+msgstr ""
+
+#: src/structs.md:1
+msgid "# Structs"
+msgstr ""
+
+#: src/structs.md:3
+msgid "Like C and C++, Rust has support for custom structs:"
+msgstr ""
+
+#: src/structs.md:5
+msgid ""
+"```rust,editable\n"
+"struct Person {\n"
+"    name: String,\n"
+"    age: u8,\n"
+"}"
+msgstr ""
+
+#: src/structs.md:11
+msgid ""
+"fn main() {\n"
+"    let peter = Person {\n"
+"        name: String::from(\"Peter\"),\n"
+"        age: 27,\n"
+"    };"
+msgstr ""
+
+#: src/structs.md:17
+msgid ""
+"    println!(\"{} is {} years old\", peter.name, peter.age);\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/structs/tuple-structs.md:1
+msgid "# Tuple Structs"
+msgstr ""
+
+#: src/structs/tuple-structs.md:3
+msgid "If the field names are unimportant, you can use a tuple struct:"
+msgstr ""
+
+#: src/structs/tuple-structs.md:5
+msgid "```rust,editable\nstruct Point(i32, i32);"
+msgstr ""
+
+#: src/structs/tuple-structs.md:8
+msgid ""
+"fn main() {\n"
+"    let p = Point(17, 23);\n"
+"    println!(\"({}, {})\", p.0, p.1);\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/structs/tuple-structs.md:14
+msgid "This is often used for single-field wrappers (called newtypes):"
+msgstr ""
+
+#: src/structs/tuple-structs.md:16
+msgid ""
+"```rust,editable,compile_fail\n"
+"struct PoundOfForce(f64);\n"
+"struct Newtons(f64);"
+msgstr ""
+
+#: src/structs/tuple-structs.md:20
+msgid ""
+"fn compute_thruster_force() -> PoundOfForce {\n"
+"    todo!(\"Ask a rocket scientist at NASA\")\n"
+"}"
+msgstr ""
+
+#: src/structs/tuple-structs.md:24
+msgid ""
+"fn set_thruster_force(force: Newtons) {\n"
+"    // ...\n"
+"}"
+msgstr ""
+
+#: src/structs/tuple-structs.md:28
+msgid ""
+"fn main() {\n"
+"    let force = compute_thruster_force();\n"
+"    set_thruster_force(force);\n"
+"}"
+msgstr ""
+
+#: src/structs/tuple-structs.md:33
+#: src/generics/trait-objects.md:86
+msgid "```"
+msgstr ""
+
+#: src/structs/field-shorthand.md:1
+msgid "# Field Shorthand Syntax"
+msgstr ""
+
+#: src/structs/field-shorthand.md:3
+msgid ""
+"If you already have variables with the right names, then you can create the\n"
+"struct using a shorthand:"
+msgstr ""
+
+#: src/structs/field-shorthand.md:6
+#: src/methods.md:6
+msgid ""
+"```rust,editable\n"
+"#[derive(Debug)]\n"
+"struct Person {\n"
+"    name: String,\n"
+"    age: u8,\n"
+"}"
+msgstr ""
+
+#: src/structs/field-shorthand.md:13
+msgid ""
+"impl Person {\n"
+"    fn new(name: String, age: u8) -> Person {\n"
+"        Person { name, age }\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/structs/field-shorthand.md:19
+msgid ""
+"fn main() {\n"
+"    let peter = Person::new(String::from(\"Peter\"), 27);\n"
+"    println!(\"{peter:?}\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/enums.md:1
+msgid "# Enums"
+msgstr ""
+
+#: src/enums.md:3
+msgid ""
+"The `enum` keyword allows the creation of a type which has a few\n"
+"different variants:"
+msgstr ""
+
+#: src/enums.md:6
+msgid ""
+"```rust,editable\n"
+"fn generate_random_number() -> i32 {\n"
+"    4  // Chosen by fair dice roll. Guaranteed to be random.\n"
+"}"
+msgstr ""
+
+#: src/enums.md:11
+msgid ""
+"#[derive(Debug)]\n"
+"enum CoinFlip {\n"
+"    Heads,\n"
+"    Tails,\n"
+"}"
+msgstr ""
+
+#: src/enums.md:17
+msgid ""
+"fn flip_coin() -> CoinFlip {\n"
+"    let random_number = generate_random_number();\n"
+"    if random_number % 2 == 0 {\n"
+"        return CoinFlip::Heads;\n"
+"    } else {\n"
+"        return CoinFlip::Tails;\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/enums.md:26
+msgid ""
+"fn main() {\n"
+"    println!(\"You got: {:?}\", flip_coin());\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/enums/variant-payloads.md:1
+msgid "# Variant Payloads"
+msgstr ""
+
+#: src/enums/variant-payloads.md:3
+msgid ""
+"You can define richer enums where the variants carry data. You can then use "
+"the\n"
+"`match` statement to extract the data from each variant:"
+msgstr ""
+
+#: src/enums/variant-payloads.md:6
+msgid ""
+"```rust,editable\n"
+"enum WebEvent {\n"
+"    PageLoad,                 // Variant without payload\n"
+"    KeyPress(char),           // Tuple struct variant\n"
+"    Click { x: i64, y: i64 }, // Full struct variant\n"
+"}"
+msgstr ""
+
+#: src/enums/variant-payloads.md:13
+msgid ""
+"#[rustfmt::skip]\n"
+"fn inspect(event: WebEvent) {\n"
+"    match event {\n"
+"        WebEvent::PageLoad       => println!(\"page loaded\"),\n"
+"        WebEvent::KeyPress(c)    => println!(\"pressed '{c}'\"),\n"
+"        WebEvent::Click { x, y } => println!(\"clicked at x={x}, y={y}\"),\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/enums/variant-payloads.md:22
+msgid ""
+"fn main() {\n"
+"    let load = WebEvent::PageLoad;\n"
+"    let press = WebEvent::KeyPress('x');\n"
+"    let click = WebEvent::Click { x: 20, y: 80 };"
+msgstr ""
+
+#: src/enums/variant-payloads.md:27
+msgid ""
+"    inspect(load);\n"
+"    inspect(press);\n"
+"    inspect(click);\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/enums/variant-payloads.md:35
+msgid ""
+"* In the above example, accessing the `char` in `KeyPress`, or `x` and `y` "
+"in `Click` only works within a `match` statement.\n"
+"* `match` inspects a hidden discriminant field in the `enum`.\n"
+"* `WebEvent::Click { ... }` is not exactly the same as "
+"`WebEvent::Click(Click)` with a top level `struct Click { ... }`. The "
+"inlined version cannot implement traits, for example."
+msgstr ""
+
+#: src/enums/sizes.md:1
+msgid "# Enum Sizes"
+msgstr ""
+
+#: src/enums/sizes.md:3
+msgid ""
+"Rust enums are packed tightly, taking constraints due to alignment into "
+"account:"
+msgstr ""
+
+#: src/enums/sizes.md:5
+msgid "```rust,editable\nuse std::mem::{align_of, size_of};"
+msgstr ""
+
+#: src/enums/sizes.md:8
+msgid ""
+"macro_rules! dbg_size {\n"
+"    ($t:ty) => {\n"
+"        println!(\"{}: size {} bytes, align: {} bytes\",\n"
+"                 stringify!($t), size_of::<$t>(), align_of::<$t>());\n"
+"    };\n"
+"}"
+msgstr ""
+
+#: src/enums/sizes.md:15
+msgid ""
+"enum Foo {\n"
+"    A,\n"
+"    B,\n"
+"}"
+msgstr ""
+
+#: src/enums/sizes.md:20
+msgid ""
+"fn main() {\n"
+"    dbg_size!(Foo);\n"
+"    dbg_size!(bool);\n"
+"    dbg_size!(Option<bool>);\n"
+"    dbg_size!(&i32);\n"
+"    dbg_size!(Option<&i32>);\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/enums/sizes.md:29
+msgid ""
+"* See the [Rust "
+"Reference](https://doc.rust-lang.org/reference/type-layout.html)."
+msgstr ""
+
+#: src/enums/sizes.md:33
+msgid ""
+"* `Option<bool>` is another example of tight packing.\n"
+"* For [some types](https://doc.rust-lang.org/std/option/#representation), "
+"Rust guarantees that `size_of::<T>()` equals `size_of::<Option<T>>()`.\n"
+"* Zero-sized types allow for efficient implementation of `HashSet` using "
+"`HashMap` with `()` as the value."
+msgstr ""
+
+#: src/methods.md:3
+msgid ""
+"Rust allows you to associate functions with your new types. You do this with "
+"an\n"
+"`impl` block:"
+msgstr ""
+
+#: src/methods.md:13
+msgid ""
+"impl Person {\n"
+"    fn say_hello(&self) {\n"
+"        println!(\"Hello, my name is {}\", self.name);\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/methods.md:19
+msgid ""
+"fn main() {\n"
+"    let peter = Person {\n"
+"        name: String::from(\"Peter\"),\n"
+"        age: 27,\n"
+"    };\n"
+"    peter.say_hello();\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/methods/receiver.md:1
+msgid "# Method Receiver"
+msgstr ""
+
+#: src/methods/receiver.md:3
+msgid ""
+"The `&self` above indicates that the method borrows the object immutably. "
+"There\n"
+"are other possible receivers for a method:"
+msgstr ""
+
+#: src/methods/receiver.md:6
+msgid ""
+"* `&self`: borrows the object from the caller using a shared and immutable\n"
+"  reference. The object can be used again afterwards.\n"
+"* `&mut self`: borrows the object from the caller using a unique and "
+"mutable\n"
+"  reference. The object can be used again afterwards.\n"
+"* `self`: takes ownership of the object and moves it away from the caller. "
+"The\n"
+"  method becomes the owner of the object. The object will be dropped "
+"(deallocated)\n"
+"  when the method returns, unless its ownership is explicitly\n"
+"  transmitted.\n"
+"* No receiver: this becomes a static method on the struct. Typically used "
+"to\n"
+"  create constructors which are called `new` by convention."
+msgstr ""
+
+#: src/methods/receiver.md:17
+msgid ""
+"Beyond variants on `self`, there are also\n"
+"[special wrapper "
+"types](https://doc.rust-lang.org/reference/special-types-and-traits.html)\n"
+"allowed to be receiver types, such as `Box<Self>`."
+msgstr ""
+
+#: src/methods/example.md:1
+#: src/concurrency/shared_state/example.md:1
+msgid "# Example"
+msgstr ""
+
+#: src/methods/example.md:3
+msgid ""
+"```rust,editable\n"
+"#[derive(Debug)]\n"
+"struct Race {\n"
+"    name: String,\n"
+"    laps: Vec<i32>,\n"
+"}"
+msgstr ""
+
+#: src/methods/example.md:10
+msgid ""
+"impl Race {\n"
+"    fn new(name: &str) -> Race {  // No receiver, a static method\n"
+"        Race { name: String::from(name), laps: Vec::new() }\n"
+"    }"
+msgstr ""
+
+#: src/methods/example.md:15
+msgid ""
+"    fn add_lap(&mut self, lap: i32) {  // Exclusive borrowed read-write "
+"access to self\n"
+"        self.laps.push(lap);\n"
+"    }"
+msgstr ""
+
+#: src/methods/example.md:19
+msgid ""
+"    fn print_laps(&self) {  // Shared and read-only borrowed access to self\n"
+"        println!(\"Recorded {} laps for {}:\", self.laps.len(), self.name);\n"
+"        for (idx, lap) in self.laps.iter().enumerate() {\n"
+"            println!(\"Lap {idx}: {lap} sec\");\n"
+"        }\n"
+"    }"
+msgstr ""
+
+#: src/methods/example.md:26
+msgid ""
+"    fn finish(self) {  // Exclusive ownership of self\n"
+"        let total = self.laps.iter().sum::<i32>();\n"
+"        println!(\"Race {} is finished, total lap time: {}\", self.name, "
+"total);\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/methods/example.md:32
+msgid ""
+"fn main() {\n"
+"    let mut race = Race::new(\"Monaco Grand Prix\");\n"
+"    race.add_lap(70);\n"
+"    race.add_lap(68);\n"
+"    race.print_laps();\n"
+"    race.add_lap(71);\n"
+"    race.print_laps();\n"
+"    race.finish();\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/pattern-matching.md:1
+msgid "# Pattern Matching"
+msgstr ""
+
+#: src/pattern-matching.md:3
+msgid ""
+"The `match` keyword let you match a value against one or more _patterns_. "
+"The\n"
+"comparisons are done from top to bottom and the first match wins."
+msgstr ""
+
+#: src/pattern-matching.md:6
+msgid "The patterns can be simple values, similarly to `switch` in C and C++:"
+msgstr ""
+
+#: src/pattern-matching.md:8
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let input = 'x';"
+msgstr ""
+
+#: src/pattern-matching.md:12
+msgid ""
+"    match input {\n"
+"        'q'                   => println!(\"Quitting\"),\n"
+"        'a' | 's' | 'w' | 'd' => println!(\"Moving around\"),\n"
+"        '0'..='9'             => println!(\"Number input\"),\n"
+"        _                     => println!(\"Something else\"),\n"
+"    }\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/pattern-matching.md:21
+msgid "The `_` pattern is a wildcard pattern which matches any value."
+msgstr ""
+
+#: src/pattern-matching/destructuring-enums.md:1
+msgid "# Destructuring Enums"
+msgstr ""
+
+#: src/pattern-matching/destructuring-enums.md:3
+msgid ""
+"Patterns can also be used to bind variables to parts of your values. This is "
+"how\n"
+"you inspect the structure of your types. Let us start with a simple `enum` "
+"type:"
+msgstr ""
+
+#: src/pattern-matching/destructuring-enums.md:6
+msgid ""
+"```rust,editable\n"
+"enum Result {\n"
+"    Ok(i32),\n"
+"    Err(String),\n"
+"}"
+msgstr ""
+
+#: src/pattern-matching/destructuring-enums.md:12
+msgid ""
+"fn divide_in_two(n: i32) -> Result {\n"
+"    if n % 2 == 0 {\n"
+"        Result::Ok(n / 2)\n"
+"    } else {\n"
+"        Result::Err(format!(\"cannot divide {} into two equal parts\", n))\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/pattern-matching/destructuring-enums.md:20
+msgid ""
+"fn main() {\n"
+"    let n = 100;\n"
+"    match divide_in_two(n) {\n"
+"        Result::Ok(half) => println!(\"{n} divided in two is {half}\"),\n"
+"        Result::Err(msg) => println!(\"sorry, an error happened: {msg}\"),\n"
+"    }\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/pattern-matching/destructuring-enums.md:29
+msgid ""
+"Here we have used the arms to _destructure_ the `Result` value. In the "
+"first\n"
+"arm, `half` is bound to the value inside the `Ok` variant. In the second "
+"arm,\n"
+"`msg` is bound to the error message."
+msgstr ""
+
+#: src/pattern-matching/destructuring-structs.md:1
+msgid "# Destructuring Structs"
+msgstr ""
+
+#: src/pattern-matching/destructuring-structs.md:3
+msgid "You can also destructure `structs`:"
+msgstr ""
+
+#: src/pattern-matching/destructuring-structs.md:5
+msgid ""
+"```rust,editable\n"
+"struct Foo {\n"
+"    x: (u32, u32),\n"
+"    y: u32,\n"
+"}"
+msgstr ""
+
+#: src/pattern-matching/destructuring-structs.md:11
+msgid ""
+"#[rustfmt::skip]\n"
+"fn main() {\n"
+"    let foo = Foo { x: (1, 2), y: 3 };\n"
+"    match foo {\n"
+"        Foo { x: (1, b), y } => println!(\"x.0 = 1, b = {b}, y = {y}\"),\n"
+"        Foo { y: 2, x: i }   => println!(\"y = 2, i = {i:?}\"),\n"
+"        Foo { y, .. }        => println!(\"y = {y}, other fields were "
+"ignored\"),\n"
+"    }\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/pattern-matching/destructuring-arrays.md:1
+msgid "# Destructuring Arrays"
+msgstr ""
+
+#: src/pattern-matching/destructuring-arrays.md:3
+msgid ""
+"You can destructure arrays, tuples, and slices by matching on their elements:"
+msgstr ""
+
+#: src/pattern-matching/destructuring-arrays.md:5
+msgid ""
+"```rust,editable\n"
+"#[rustfmt::skip]\n"
+"fn main() {\n"
+"    let triple = [0, -2, 3];\n"
+"    println!(\"Tell me about {triple:?}\");\n"
+"    match triple {\n"
+"        [0, y, z] => println!(\"First is 0, y = {y}, and z = {z}\"),\n"
+"        [1, ..]   => println!(\"First is 1 and the rest were ignored\"),\n"
+"        _         => println!(\"All elements were ignored\"),\n"
+"    }\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/pattern-matching/match-guards.md:1
+msgid "# Match Guards"
+msgstr ""
+
+#: src/pattern-matching/match-guards.md:3
+msgid ""
+"When matching, you can add a _guard_ to a pattern. This is an arbitrary "
+"Boolean\n"
+"expression which will be executed if the pattern matches:"
+msgstr ""
+
+#: src/pattern-matching/match-guards.md:6
+msgid ""
+"```rust,editable\n"
+"#[rustfmt::skip]\n"
+"fn main() {\n"
+"    let pair = (2, -2);\n"
+"    println!(\"Tell me about {pair:?}\");\n"
+"    match pair {\n"
+"        (x, y) if x == y     => println!(\"These are twins\"),\n"
+"        (x, y) if x + y == 0 => println!(\"Antimatter, kaboom!\"),\n"
+"        (x, _) if x % 2 == 1 => println!(\"The first one is odd\"),\n"
+"        _                    => println!(\"No correlation...\"),\n"
+"    }\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/exercises/day-2/morning.md:1
+msgid "# Day 2: Morning Exercises"
+msgstr ""
+
+#: src/exercises/day-2/morning.md:3
+msgid "We will look at implementing methods in two contexts:"
+msgstr ""
+
+#: src/exercises/day-2/morning.md:5
+msgid "* Simple struct which tracks health statistics."
+msgstr ""
+
+#: src/exercises/day-2/morning.md:7
+msgid "* Multiple structs and enums for a drawing library."
+msgstr ""
+
+#: src/exercises/day-2/health-statistics.md:1
+msgid "# Health Statistics"
+msgstr ""
+
+#: src/exercises/day-2/health-statistics.md:3
+msgid ""
+"You're working on implementing a health-monitoring system. As part of that, "
+"you\n"
+"need to keep track of users' health statistics."
+msgstr ""
+
+#: src/exercises/day-2/health-statistics.md:6
+msgid ""
+"You'll start with some stubbed functions in an `impl` block as well as a "
+"`User`\n"
+"struct definition. Your goal is to implement the stubbed out methods on the\n"
+"`User` `struct` defined in the `impl` block."
+msgstr ""
+
+#: src/exercises/day-2/health-statistics.md:10
+msgid ""
+"Copy the code below to <https://play.rust-lang.org/> and fill in the "
+"missing\n"
+"methods:"
+msgstr ""
+
+#: src/exercises/day-2/health-statistics.md:17
+msgid ""
+"struct User {\n"
+"    name: String,\n"
+"    age: u32,\n"
+"    weight: f32,\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-2/health-statistics.md:23
+msgid ""
+"impl User {\n"
+"    pub fn new(name: String, age: u32, weight: f32) -> Self {\n"
+"        unimplemented!()\n"
+"    }"
+msgstr ""
+
+#: src/exercises/day-2/health-statistics.md:28
+msgid ""
+"    pub fn name(&self) -> &str {\n"
+"        unimplemented!()\n"
+"    }"
+msgstr ""
+
+#: src/exercises/day-2/health-statistics.md:32
+msgid ""
+"    pub fn age(&self) -> u32 {\n"
+"        unimplemented!()\n"
+"    }"
+msgstr ""
+
+#: src/exercises/day-2/health-statistics.md:36
+msgid ""
+"    pub fn weight(&self) -> f32 {\n"
+"        unimplemented!()\n"
+"    }"
+msgstr ""
+
+#: src/exercises/day-2/health-statistics.md:40
+msgid ""
+"    pub fn set_age(&mut self, new_age: u32) {\n"
+"        unimplemented!()\n"
+"    }"
+msgstr ""
+
+#: src/exercises/day-2/health-statistics.md:44
+msgid ""
+"    pub fn set_weight(&mut self, new_weight: f32) {\n"
+"        unimplemented!()\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-2/health-statistics.md:49
+msgid ""
+"fn main() {\n"
+"    let bob = User::new(String::from(\"Bob\"), 32, 155.2);\n"
+"    println!(\"I'm {} and my age is {}\", bob.name(), bob.age());\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-2/health-statistics.md:54
+msgid ""
+"#[test]\n"
+"fn test_weight() {\n"
+"    let bob = User::new(String::from(\"Bob\"), 32, 155.2);\n"
+"    assert_eq!(bob.weight(), 155.2);\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-2/health-statistics.md:60
+msgid ""
+"#[test]\n"
+"fn test_set_age() {\n"
+"    let mut bob = User::new(String::from(\"Bob\"), 32, 155.2);\n"
+"    assert_eq!(bob.age(), 32);\n"
+"    bob.set_age(33);\n"
+"    assert_eq!(bob.age(), 33);\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/exercises/day-2/points-polygons.md:1
+msgid "# Polygon Struct"
+msgstr ""
+
+#: src/exercises/day-2/points-polygons.md:3
+msgid ""
+"We will create a `Polygon` struct which contain some points. Copy the code "
+"below\n"
+"to <https://play.rust-lang.org/> and fill in the missing methods to make "
+"the\n"
+"tests pass:"
+msgstr ""
+
+#: src/exercises/day-2/points-polygons.md:7
+#: src/exercises/day-2/luhn.md:23
+#: src/exercises/day-2/strings-iterators.md:12
+msgid ""
+"```rust\n"
+"// TODO: remove this when you're done with your implementation.\n"
+"#![allow(unused_variables, dead_code)]"
+msgstr ""
+
+#: src/exercises/day-2/points-polygons.md:11
+msgid ""
+"pub struct Point {\n"
+"    // add fields\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-2/points-polygons.md:15
+msgid ""
+"impl Point {\n"
+"    // add methods\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-2/points-polygons.md:19
+msgid ""
+"pub struct Polygon {\n"
+"    // add fields\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-2/points-polygons.md:23
+msgid ""
+"impl Polygon {\n"
+"    // add methods\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-2/points-polygons.md:27
+msgid ""
+"pub struct Circle {\n"
+"    // add fields\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-2/points-polygons.md:31
+msgid ""
+"impl Circle {\n"
+"    // add methods\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-2/points-polygons.md:35
+msgid ""
+"pub enum Shape {\n"
+"    Polygon(Polygon),\n"
+"    Circle(Circle),\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-2/points-polygons.md:40
+#: src/testing/test-modules.md:15
+msgid ""
+"#[cfg(test)]\n"
+"mod tests {\n"
+"    use super::*;"
+msgstr ""
+
+#: src/exercises/day-2/points-polygons.md:44
+#: src/exercises/day-2/solutions-morning.md:165
+msgid ""
+"    fn round_two_digits(x: f64) -> f64 {\n"
+"        (x * 100.0).round() / 100.0\n"
+"    }"
+msgstr ""
+
+#: src/exercises/day-2/points-polygons.md:48
+#: src/exercises/day-2/solutions-morning.md:169
+msgid ""
+"    #[test]\n"
+"    fn test_point_magnitude() {\n"
+"        let p1 = Point::new(12, 13);\n"
+"        assert_eq!(round_two_digits(p1.magnitude()), 17.69);\n"
+"    }"
+msgstr ""
+
+#: src/exercises/day-2/points-polygons.md:54
+#: src/exercises/day-2/solutions-morning.md:175
+msgid ""
+"    #[test]\n"
+"    fn test_point_dist() {\n"
+"        let p1 = Point::new(10, 10);\n"
+"        let p2 = Point::new(14, 13);\n"
+"        assert_eq!(round_two_digits(p1.dist(p2)), 5.00);\n"
+"    }"
+msgstr ""
+
+#: src/exercises/day-2/points-polygons.md:61
+#: src/exercises/day-2/solutions-morning.md:182
+msgid ""
+"    #[test]\n"
+"    fn test_point_add() {\n"
+"        let p1 = Point::new(16, 16);\n"
+"        let p2 = p1 + Point::new(-4, 3);\n"
+"        assert_eq!(p2, Point::new(12, 19));\n"
+"    }"
+msgstr ""
+
+#: src/exercises/day-2/points-polygons.md:68
+#: src/exercises/day-2/solutions-morning.md:189
+msgid ""
+"    #[test]\n"
+"    fn test_polygon_left_most_point() {\n"
+"        let p1 = Point::new(12, 13);\n"
+"        let p2 = Point::new(16, 16);"
+msgstr ""
+
+#: src/exercises/day-2/points-polygons.md:73
+#: src/exercises/day-2/solutions-morning.md:194
+msgid ""
+"        let mut poly = Polygon::new();\n"
+"        poly.add_point(p1);\n"
+"        poly.add_point(p2);\n"
+"        assert_eq!(poly.left_most_point(), Some(p1));\n"
+"    }"
+msgstr ""
+
+#: src/exercises/day-2/points-polygons.md:79
+#: src/exercises/day-2/solutions-morning.md:200
+msgid ""
+"    #[test]\n"
+"    fn test_polygon_iter() {\n"
+"        let p1 = Point::new(12, 13);\n"
+"        let p2 = Point::new(16, 16);"
+msgstr ""
+
+#: src/exercises/day-2/points-polygons.md:84
+#: src/exercises/day-2/solutions-morning.md:205
+msgid ""
+"        let mut poly = Polygon::new();\n"
+"        poly.add_point(p1);\n"
+"        poly.add_point(p2);"
+msgstr ""
+
+#: src/exercises/day-2/points-polygons.md:88
+#: src/exercises/day-2/solutions-morning.md:209
+msgid ""
+"        let points = poly.iter().cloned().collect::<Vec<_>>();\n"
+"        assert_eq!(points, vec![Point::new(12, 13), Point::new(16, 16)]);\n"
+"    }"
+msgstr ""
+
+#: src/exercises/day-2/points-polygons.md:92
+msgid ""
+"    #[test]\n"
+"    fn test_shape_circumferences() {\n"
+"        let mut poly = Polygon::new();\n"
+"        poly.add_point(Point::new(12, 13));\n"
+"        poly.add_point(Point::new(17, 11));\n"
+"        poly.add_point(Point::new(16, 16));\n"
+"        let shapes = vec![\n"
+"            Shape::from(poly),\n"
+"            Shape::from(Circle::new(Point::new(10, 20), 5)),\n"
+"        ];\n"
+"        let circumferences = shapes\n"
+"            .iter()\n"
+"            .map(Shape::circumference)\n"
+"            .map(round_two_digits)\n"
+"            .collect::<Vec<_>>();\n"
+"        assert_eq!(circumferences, vec![15.48, 31.42]);\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-2/points-polygons.md:111
+#: src/exercises/day-2/luhn.md:68
+#: src/exercises/day-2/solutions-morning.md:233
+msgid ""
+"#[allow(dead_code)]\n"
+"fn main() {}\n"
+"```"
+msgstr ""
+
+#: src/control-flow.md:1
+msgid "# Control Flow"
+msgstr ""
+
+#: src/control-flow.md:3
+msgid ""
+"As we have seen, `if` is an expression in Rust. It is used to conditionally\n"
+"evaluate one of two blocks, but the blocks can have a value which then "
+"becomes\n"
+"the value of the `if` expression. Other control flow expressions work "
+"similarly\n"
+"in Rust."
+msgstr ""
+
+#: src/control-flow/blocks.md:1
+msgid "# Blocks"
+msgstr ""
+
+#: src/control-flow/blocks.md:3
+msgid ""
+"A block in Rust has a value and a type: the value is the last expression of "
+"the\n"
+"block:"
+msgstr ""
+
+#: src/control-flow/blocks.md:6
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let x = {\n"
+"        let y = 10;\n"
+"        println!(\"y: {y}\");\n"
+"        let z = {\n"
+"            let w = {\n"
+"                3 + 4\n"
+"            };\n"
+"            println!(\"w: {w}\");\n"
+"            y * w\n"
+"        };\n"
+"        println!(\"z: {z}\");\n"
+"        z - y\n"
+"    };\n"
+"    println!(\"x: {x}\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/control-flow/blocks.md:25
+msgid ""
+"The same rule is used for functions: the value of the function body is the\n"
+"return value:"
+msgstr ""
+
+#: src/control-flow/blocks.md:28
+msgid ""
+"```rust,editable\n"
+"fn double(x: i32) -> i32 {\n"
+"    x + x\n"
+"}"
+msgstr ""
+
+#: src/control-flow/blocks.md:33
+msgid ""
+"fn main() {\n"
+"    println!(\"doubled: {}\", double(7));\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/control-flow/if-expressions.md:1
+msgid "# `if` expressions"
+msgstr ""
+
+#: src/control-flow/if-expressions.md:3
+msgid "You use `if` very similarly to how you would in other languages:"
+msgstr ""
+
+#: src/control-flow/if-expressions.md:5
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let mut x = 10;\n"
+"    if x % 2 == 0 {\n"
+"        x = x / 2;\n"
+"    } else {\n"
+"        x = 3 * x + 1;\n"
+"    }\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/control-flow/if-expressions.md:16
+msgid ""
+"In addition, you can use it as an expression. This does the same as above:"
+msgstr ""
+
+#: src/control-flow/if-expressions.md:18
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let mut x = 10;\n"
+"    x = if x % 2 == 0 {\n"
+"        x / 2\n"
+"    } else {\n"
+"        3 * x + 1\n"
+"    };\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/control-flow/if-let-expressions.md:1
+msgid "# `if let` expressions"
+msgstr ""
+
+#: src/control-flow/if-let-expressions.md:3
+msgid "If you want to match a value against a pattern, you can use `if let`:"
+msgstr ""
+
+#: src/control-flow/if-let-expressions.md:5
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let arg = std::env::args().next();\n"
+"    if let Some(value) = arg {\n"
+"        println!(\"Program name: {value}\");\n"
+"    } else {\n"
+"        println!(\"Missing name?\");\n"
+"    }\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/control-flow/if-let-expressions.md:16
+#: src/control-flow/while-let-expressions.md:21
+#: src/control-flow/match-expressions.md:22
+msgid ""
+"See [pattern matching](../pattern-matching.md) for more details on patterns "
+"in\n"
+"Rust."
+msgstr ""
+
+#: src/control-flow/while-expressions.md:1
+msgid "# `while` expressions"
+msgstr ""
+
+#: src/control-flow/while-expressions.md:3
+msgid "The `while` keyword works very similar to other languages:"
+msgstr ""
+
+#: src/control-flow/while-expressions.md:5
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let mut x = 10;\n"
+"    while x != 1 {\n"
+"        x = if x % 2 == 0 {\n"
+"            x / 2\n"
+"        } else {\n"
+"            3 * x + 1\n"
+"        };\n"
+"    }\n"
+"    println!(\"Final x: {x}\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/control-flow/while-let-expressions.md:1
+msgid "# `while let` expressions"
+msgstr ""
+
+#: src/control-flow/while-let-expressions.md:3
+msgid ""
+"Like with `if`, there is a `while let` variant which repeatedly tests a "
+"value\n"
+"against a pattern:"
+msgstr ""
+
+#: src/control-flow/while-let-expressions.md:6
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let v = vec![10, 20, 30];\n"
+"    let mut iter = v.into_iter();"
+msgstr ""
+
+#: src/control-flow/while-let-expressions.md:11
+msgid ""
+"    while let Some(x) = iter.next() {\n"
+"        println!(\"x: {x}\");\n"
+"    }\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/control-flow/while-let-expressions.md:17
+msgid ""
+"Here the iterator returned by `v.iter()` will return a `Option<i32>` on "
+"every\n"
+"call to `next()`. It returns `Some(x)` until it is done, after which it "
+"will\n"
+"return `None`. The `while let` lets us keep iterating through all items."
+msgstr ""
+
+#: src/control-flow/for-expressions.md:1
+msgid "# `for` expressions"
+msgstr ""
+
+#: src/control-flow/for-expressions.md:3
+msgid ""
+"The `for` expression is closely related to the `while let` expression. It "
+"will\n"
+"automatically call `into_iter()` on the expression and then iterate over it:"
+msgstr ""
+
+#: src/control-flow/for-expressions.md:6
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let v = vec![10, 20, 30];"
+msgstr ""
+
+#: src/control-flow/for-expressions.md:10
+msgid ""
+"    for x in v {\n"
+"        println!(\"x: {x}\");\n"
+"    }\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/control-flow/for-expressions.md:16
+msgid "You can use `break` and `continue` here as usual."
+msgstr ""
+
+#: src/control-flow/loop-expressions.md:1
+msgid "# `loop` expressions"
+msgstr ""
+
+#: src/control-flow/loop-expressions.md:3
+msgid ""
+"Finally, there is a `loop` keyword which creates an endless loop. Here you "
+"must\n"
+"either `break` or `return` to stop the loop:"
+msgstr ""
+
+#: src/control-flow/loop-expressions.md:6
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let mut x = 10;\n"
+"    loop {\n"
+"        x = if x % 2 == 0 {\n"
+"            x / 2\n"
+"        } else {\n"
+"            3 * x + 1\n"
+"        };\n"
+"        if x == 1 {\n"
+"            break;\n"
+"        }\n"
+"    }\n"
+"    println!(\"Final x: {x}\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/control-flow/match-expressions.md:1
+msgid "# `match` expressions"
+msgstr ""
+
+#: src/control-flow/match-expressions.md:3
+msgid ""
+"The `match` keyword is used to match a value against one or more patterns. "
+"In\n"
+"that sense, it works like a series of `if let` expressions:"
+msgstr ""
+
+#: src/control-flow/match-expressions.md:6
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    match std::env::args().next().as_deref() {\n"
+"        Some(\"cat\") => println!(\"Will do cat things\"),\n"
+"        Some(\"ls\")  => println!(\"Will ls some files\"),\n"
+"        Some(\"mv\")  => println!(\"Let's move some files\"),\n"
+"        Some(\"rm\")  => println!(\"Uh, dangerous!\"),\n"
+"        None        => println!(\"Hmm, no program name?\"),\n"
+"        _           => println!(\"Unknown program name!\"),\n"
+"    }\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/control-flow/match-expressions.md:19
+msgid ""
+"Like `if let`, each match arm must have the same type. The type is the last\n"
+"expression of the block, if any. In the example above, the type is `()`."
+msgstr ""
+
+#: src/control-flow/break-continue.md:1
+msgid "# `break` and `continue`"
+msgstr ""
+
+#: src/control-flow/break-continue.md:3
+msgid ""
+"If you want to exit a loop early, use `break`, if you want to immediately "
+"start\n"
+"the next iteration use `continue`. Both `continue` and `break` can "
+"optionally\n"
+"take a label argument which is used to break out of nested loops:"
+msgstr ""
+
+#: src/control-flow/break-continue.md:7
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let v = vec![10, 20, 30];\n"
+"    let mut iter = v.into_iter();\n"
+"    'outer: while let Some(x) = iter.next() {\n"
+"        println!(\"x: {x}\");\n"
+"        let mut i = 0;\n"
+"        while i < x {\n"
+"            println!(\"x: {x}, i: {i}\");\n"
+"            i += 1;\n"
+"            if i == 3 {\n"
+"                break 'outer;\n"
+"            }\n"
+"        }\n"
+"    }\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/control-flow/break-continue.md:25
+msgid ""
+"In this case we break the outer loop after 3 iterations of the inner loop."
+msgstr ""
+
+#: src/std.md:1
+msgid "# Standard Library"
+msgstr ""
+
+#: src/std.md:3
+msgid ""
+"Rust comes with a standard library which helps establish a set of common "
+"types\n"
+"used by Rust library and programs. This way, two libraries can work "
+"together\n"
+"smoothly because they both use the same `String` type."
+msgstr ""
+
+#: src/std.md:7
+msgid "The common vocabulary types include:"
+msgstr ""
+
+#: src/std.md:9
+msgid ""
+"* [`Option` and `Result`](std/option-result.md) types: used for optional "
+"values\n"
+"  and [error handling](error-handling.md)."
+msgstr ""
+
+#: src/std.md:12
+msgid "* [`String`](std/string.md): the default string type used for owned data."
+msgstr ""
+
+#: src/std.md:14
+msgid "* [`Vec`](std/vec.md): a standard extensible vector."
+msgstr ""
+
+#: src/std.md:16
+msgid ""
+"* [`HashMap`](std/hashmap.md): a hash map type with a configurable hashing\n"
+"  algorithm."
+msgstr ""
+
+#: src/std.md:19
+msgid "* [`Box`](std/box.md): an owned pointer for heap-allocated data."
+msgstr ""
+
+#: src/std.md:21
+msgid ""
+"* [`Rc`](std/rc.md): a shared reference-counted pointer for heap-allocated "
+"data."
+msgstr ""
+
+#: src/std/string.md:1
+msgid "# String"
+msgstr ""
+
+#: src/std/string.md:3
+msgid ""
+"[`String`][1] is the standard heap-allocated growable UTF-8 string buffer:"
+msgstr ""
+
+#: src/std/string.md:5
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let mut s1 = String::new();\n"
+"    s1.push_str(\"Hello\");\n"
+"    println!(\"s1: len = {}, capacity = {}\", s1.len(), s1.capacity());"
+msgstr ""
+
+#: src/std/string.md:11
+msgid ""
+"    let mut s2 = String::with_capacity(s1.len() + 1);\n"
+"    s2.push_str(&s1);\n"
+"    s2.push('!');\n"
+"    println!(\"s2: len = {}, capacity = {}\", s2.len(), s2.capacity());\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/std/string.md:18
+msgid ""
+"`String` implements [`Deref<Target = str>`][2], which means that you can "
+"call all\n"
+"`str` methods on a `String`."
+msgstr ""
+
+#: src/std/string.md:21
+msgid ""
+"[1]: https://doc.rust-lang.org/std/string/struct.String.html\n"
+"[2]: "
+"https://doc.rust-lang.org/std/string/struct.String.html#deref-methods-str"
+msgstr ""
+
+#: src/std/option-result.md:1
+msgid "# `Option` and `Result`"
+msgstr ""
+
+#: src/std/option-result.md:3
+msgid "The types represent optional data:"
+msgstr ""
+
+#: src/std/option-result.md:5
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let numbers = vec![10, 20, 30];\n"
+"    let first: Option<&i8> = numbers.first();\n"
+"    println!(\"first: {first:?}\");"
+msgstr ""
+
+#: src/std/option-result.md:11
+msgid ""
+"    let idx: Result<usize, usize> = numbers.binary_search(&10);\n"
+"    println!(\"idx: {idx:?}\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/std/vec.md:1
+msgid "# `Vec`"
+msgstr ""
+
+#: src/std/vec.md:3
+msgid "[`Vec`][1] is the standard resizable heap-allocated buffer:"
+msgstr ""
+
+#: src/std/vec.md:5
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let mut numbers = Vec::new();\n"
+"    numbers.push(42);"
+msgstr ""
+
+#: src/std/vec.md:10
+msgid ""
+"    let mut v1 = Vec::new();\n"
+"    v1.push(42);\n"
+"    println!(\"v1: len = {}, capacity = {}\", v1.len(), v1.capacity());"
+msgstr ""
+
+#: src/std/vec.md:14
+msgid ""
+"    let mut v2 = Vec::with_capacity(v1.len() + 1);\n"
+"    v2.extend(v1.iter());\n"
+"    v2.push(9999);\n"
+"    println!(\"v2: len = {}, capacity = {}\", v2.len(), v2.capacity());\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/std/vec.md:21
+msgid ""
+"`Vec` implements [`Deref<Target = [T]>`][2], which means that you can call "
+"slice\n"
+"methods on a `Vec`."
+msgstr ""
+
+#: src/std/vec.md:24
+msgid ""
+"[1]: https://doc.rust-lang.org/std/vec/struct.Vec.html\n"
+"[2]: https://doc.rust-lang.org/std/vec/struct.Vec.html#deref-methods-[T]"
+msgstr ""
+
+#: src/std/hashmap.md:1
+msgid "# `HashMap`"
+msgstr ""
+
+#: src/std/hashmap.md:3
+msgid "Standard hash map with protection against HashDoS attacks:"
+msgstr ""
+
+#: src/std/hashmap.md:5
+msgid "```rust,editable\nuse std::collections::HashMap;"
+msgstr ""
+
+#: src/std/hashmap.md:8
+msgid ""
+"fn main() {\n"
+"    let mut page_counts = HashMap::new();\n"
+"    page_counts.insert(\"Adventures of Huckleberry Finn\".to_string(), "
+"207);\n"
+"    page_counts.insert(\"Grimms' Fairy Tales\".to_string(), 751);\n"
+"    page_counts.insert(\"Pride and Prejudice\".to_string(), 303);"
+msgstr ""
+
+#: src/std/hashmap.md:14
+msgid ""
+"    if !page_counts.contains_key(\"Les Misérables\") {\n"
+"        println!(\"We've know about {} books, but not Les Misérables.\",\n"
+"                 page_counts.len());\n"
+"    }"
+msgstr ""
+
+#: src/std/hashmap.md:19
+msgid ""
+"    for book in [\"Pride and Prejudice\", \"Alice's Adventure in "
+"Wonderland\"] {\n"
+"        match page_counts.get(book) {\n"
+"            Some(count) => println!(\"{book}: {count} pages\"),\n"
+"            None => println!(\"{book} is unknown.\")\n"
+"        }\n"
+"    }\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/std/box.md:1
+msgid "# `Box`"
+msgstr ""
+
+#: src/std/box.md:3
+msgid "[`Box`][1] is an owned pointer to data on the heap:"
+msgstr ""
+
+#: src/std/box.md:5
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let five = Box::new(5);\n"
+"    println!(\"five: {}\", *five);\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/std/box.md:13
+msgid ""
+"```bob\n"
+" Stack                     Heap\n"
+".- - - - - - -.     .- - - - - - -.\n"
+":             :     :             :\n"
+":    five     :     :             :\n"
+":   +-----+   :     :   +-----+   :\n"
+":   | o---|---+-----+-->|  5  |   :\n"
+":   +-----+   :     :   +-----+   :\n"
+":             :     :             :\n"
+":             :     :             :\n"
+"`- - - - - - -'     `- - - - - - -'\n"
+"```"
+msgstr ""
+
+#: src/std/box.md:26
+msgid ""
+"`Box<T>` implements `Deref<Target = T>`, which means that you can [call "
+"methods\n"
+"from `T` directly on a `Box<T>`][2]."
+msgstr ""
+
+#: src/std/box.md:29
+msgid ""
+"[1]: https://doc.rust-lang.org/std/boxed/struct.Box.html\n"
+"[2]: "
+"https://doc.rust-lang.org/std/ops/trait.Deref.html#more-on-deref-coercion"
+msgstr ""
+
+#: src/std/box-recursive.md:1
+msgid "# Box with Recursive Data Structures"
+msgstr ""
+
+#: src/std/box-recursive.md:3
+msgid ""
+"Recursive data types or data types with dynamic sizes need to use a `Box`:"
+msgstr ""
+
+#: src/std/box-recursive.md:5
+#: src/std/box-niche.md:3
+msgid ""
+"```rust,editable\n"
+"#[derive(Debug)]\n"
+"enum List<T> {\n"
+"    Cons(T, Box<List<T>>),\n"
+"    Nil,\n"
+"}"
+msgstr ""
+
+#: src/std/box-recursive.md:12
+#: src/std/box-niche.md:10
+msgid ""
+"fn main() {\n"
+"    let list: List<i32> = List::Cons(1, Box::new(List::Cons(2, "
+"Box::new(List::Nil))));\n"
+"    println!(\"{list:?}\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/std/box-recursive.md:18
+msgid ""
+"```bob\n"
+" Stack                           Heap\n"
+".- - - - - - - - - - - - -.     .- - - - - - - - - - - - - - - - - - - - - - "
+"- -.\n"
+":                         :     :                                            "
+"   :\n"
+":    list                 :     :                                            "
+"   :\n"
+":   +--------+-------+    :     :    +--------+--------+    "
+"+--------+------+   :\n"
+":   | Tag    | Cons  |    :     : .->| Tag    | Cons   | .->| Tag    | Nil  "
+"|   :\n"
+":   | 0      | 1     |    :     : |  | 0      | 2      | |  | ////// | //// "
+"|   :\n"
+":   | 1      | o-----+----+-----+-'  | 1      | o------+-'  | ////// | //// "
+"|   :\n"
+":   +--------+-------+    :     :    +--------+--------+    "
+"+--------+------+   :\n"
+":                         :     :                                            "
+"   :\n"
+":                         :     :                                            "
+"   :\n"
+"`- - - - - - - - - - - - -'     '- - - - - - - - - - - - - - - - - - - - - - "
+"- -'\n"
+"```"
+msgstr ""
+
+#: src/std/box-niche.md:1
+msgid "# Niche Optimization"
+msgstr ""
+
+#: src/std/box-niche.md:16
+msgid ""
+"A `Box` cannot be empty, so the pointer is always valid and non-`null`. "
+"This\n"
+"allows the compiler to optimize the memory layout:"
+msgstr ""
+
+#: src/std/box-niche.md:19
+msgid ""
+"```bob\n"
+" Stack                           Heap\n"
+".- - - - - - - - - - - - -.     .- - - - - - - - - - - - - - - - - - - - - - "
+"- -.\n"
+":                         :     :                                            "
+"   :\n"
+":    list                 :     :                                            "
+"   :\n"
+":   +--------+-------+    :     :    +--------+--------+    "
+"+--------+------+   :\n"
+":   | 0      | 1     |    :     : .->| 0      |  2     | .->| ////// | //// "
+"|   :\n"
+":   | \"1/Tag\"| o-----+----+-----+-'  | \"1/Tag\"|  o-----+-'  | \"1/Tag\"| "
+"null |   :\n"
+":   +--------+-------+    :     :    +--------+--------+    "
+"+--------+------+   :\n"
+":                         :     :                                            "
+"   :\n"
+":                         :     :                                            "
+"   :\n"
+"`- - - - - - - - - - - - -'     '- - - - - - - - - - - - - - - - - - - - - - "
+"- -'\n"
+"```"
+msgstr ""
+
+#: src/std/rc.md:1
+msgid "# `Rc`"
+msgstr ""
+
+#: src/std/rc.md:3
+msgid ""
+"[`Rc`][1] is a reference-counted shared pointer. Use this when you need to "
+"refer\n"
+"to the same data from multiple places:"
+msgstr ""
+
+#: src/std/rc.md:6
+msgid "```rust,editable\nuse std::rc::Rc;"
+msgstr ""
+
+#: src/std/rc.md:9
+msgid ""
+"fn main() {\n"
+"    let mut a = Rc::new(10);\n"
+"    let mut b = a.clone();"
+msgstr ""
+
+#: src/std/rc.md:18
+msgid ""
+"If you need to mutate the data inside an `Rc`, you will need to wrap the "
+"data in\n"
+"a type such as [`Cell` or `RefCell`][2]. See [`Arc`][3] if you are in a "
+"multi-threaded\n"
+"context."
+msgstr ""
+
+#: src/std/rc.md:22
+msgid ""
+"[1]: https://doc.rust-lang.org/std/rc/struct.Rc.html\n"
+"[2]: https://doc.rust-lang.org/std/cell/index.html\n"
+"[3]: ../concurrency/shared_state/arc.md"
+msgstr ""
+
+#: src/modules.md:1
+msgid "# Modules"
+msgstr ""
+
+#: src/modules.md:3
+msgid "We have seen how `impl` blocks let us namespace functions to a type."
+msgstr ""
+
+#: src/modules.md:5
+msgid "Similarly, `mod` lets us namespace types and functions:"
+msgstr ""
+
+#: src/modules.md:7
+msgid ""
+"```rust,editable\n"
+"mod foo {\n"
+"    pub fn do_something() {\n"
+"        println!(\"In the foo module\");\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/modules.md:14
+msgid ""
+"mod bar {\n"
+"    pub fn do_something() {\n"
+"        println!(\"In the bar module\");\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/modules.md:20
+msgid ""
+"fn main() {\n"
+"    foo::do_something();\n"
+"    bar::do_something();\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/modules/visibility.md:1
+msgid "# Visibility"
+msgstr ""
+
+#: src/modules/visibility.md:3
+msgid "Modules are a privacy boundary:"
+msgstr ""
+
+#: src/modules/visibility.md:5
+msgid ""
+"* Module items are private by default (hides implementation details).\n"
+"* Parent and sibling items are always visible."
+msgstr ""
+
+#: src/modules/visibility.md:8
+msgid ""
+"```rust,editable\n"
+"mod outer {\n"
+"    fn private() {\n"
+"        println!(\"outer::private\");\n"
+"    }"
+msgstr ""
+
+#: src/modules/visibility.md:14
+msgid ""
+"    pub fn public() {\n"
+"        println!(\"outer::public\");\n"
+"    }"
+msgstr ""
+
+#: src/modules/visibility.md:18
+msgid ""
+"    mod inner {\n"
+"        fn private() {\n"
+"            println!(\"outer::inner::private\");\n"
+"        }"
+msgstr ""
+
+#: src/modules/visibility.md:23
+msgid ""
+"        pub fn public() {\n"
+"            println!(\"outer::inner::public\");\n"
+"            super::private();\n"
+"        }\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/modules/visibility.md:30
+msgid ""
+"fn main() {\n"
+"    outer::public();\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/modules/paths.md:1
+msgid "# Paths"
+msgstr ""
+
+#: src/modules/paths.md:3
+msgid "Paths are resolved as follows:"
+msgstr ""
+
+#: src/modules/paths.md:5
+msgid ""
+"1. As a relative path:\n"
+"   * `foo` or `self::foo` refers to `foo` in the current module,\n"
+"   * `super::foo` refers to `foo` in the parent module."
+msgstr ""
+
+#: src/modules/paths.md:9
+msgid ""
+"2. As an absolute path:\n"
+"   * `crate::foo` refers to `foo` in the root of the current crate,\n"
+"   * `bar::foo` refers to `foo` in the `bar` crate."
+msgstr ""
+
+#: src/modules/filesystem.md:1
+msgid "# Filesystem Hierarchy"
+msgstr ""
+
+#: src/modules/filesystem.md:3
+msgid "The module content can be omitted:"
+msgstr ""
+
+#: src/modules/filesystem.md:5
+msgid ""
+"```rust,editable,compile_fail\n"
+"mod garden;\n"
+"```"
+msgstr ""
+
+#: src/modules/filesystem.md:9
+msgid "The `garden` module content is found at:"
+msgstr ""
+
+#: src/modules/filesystem.md:11
+msgid ""
+"* `src/garden.rs` (modern Rust 2018 style)\n"
+"* `src/garden/mod.rs` (older Rust 2015 style)"
+msgstr ""
+
+#: src/modules/filesystem.md:14
+msgid "Similarly, a `garden::vegetables` module can be found at:"
+msgstr ""
+
+#: src/modules/filesystem.md:16
+msgid ""
+"* `src/garden/vegetables.rs` (modern Rust 2018 style)\n"
+"* `src/garden/vegetables/mod.rs` (older Rust 2015 style)"
+msgstr ""
+
+#: src/modules/filesystem.md:19
+msgid "The `crate` root is in:"
+msgstr ""
+
+#: src/modules/filesystem.md:21
+msgid ""
+"* `src/lib.rs` (for a library crate)\n"
+"* `src/main.rs` (for a binary crate)"
+msgstr ""
+
+#: src/exercises/day-2/afternoon.md:1
+msgid "# Day 2: Afternoon Exercises"
+msgstr ""
+
+#: src/exercises/day-2/afternoon.md:3
+msgid "The exercises for this afternoon will focus on strings and iterators."
+msgstr ""
+
+#: src/exercises/day-2/luhn.md:1
+msgid "# Luhn Algorithm"
+msgstr ""
+
+#: src/exercises/day-2/luhn.md:3
+msgid ""
+"The [Luhn algorithm](https://en.wikipedia.org/wiki/Luhn_algorithm) is used "
+"to\n"
+"validate credit card numbers. The algorithm takes a string as input and does "
+"the\n"
+"following to validate the credit card number:"
+msgstr ""
+
+#: src/exercises/day-2/luhn.md:7
+msgid "* Ignore all spaces. Reject number with less than two digits."
+msgstr ""
+
+#: src/exercises/day-2/luhn.md:9
+msgid ""
+"* Moving from right to left, double every second digit: for the number "
+"`1234`,\n"
+"  we double `3` and `1`."
+msgstr ""
+
+#: src/exercises/day-2/luhn.md:12
+msgid ""
+"* After doubling a digit, sum the digits. So doubling `7` becomes `14` "
+"which\n"
+"  becomes `5`."
+msgstr ""
+
+#: src/exercises/day-2/luhn.md:15
+msgid "* Sum all the undoubled and doubled digits."
+msgstr ""
+
+#: src/exercises/day-2/luhn.md:17
+msgid "* The credit card number is valid if the sum is ends with `0`."
+msgstr ""
+
+#: src/exercises/day-2/luhn.md:19
+msgid ""
+"Copy the following code to <https://play.rust-lang.org/> and implement the\n"
+"function:"
+msgstr ""
+
+#: src/exercises/day-2/luhn.md:27
+msgid ""
+"pub fn luhn(cc_number: &str) -> bool {\n"
+"    unimplemented!()\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-2/luhn.md:31
+msgid ""
+"#[test]\n"
+"fn test_non_digit_cc_number() {\n"
+"    assert!(!luhn(\"foo\"));\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-2/luhn.md:36
+#: src/exercises/day-2/solutions-afternoon.md:64
+msgid ""
+"#[test]\n"
+"fn test_empty_cc_number() {\n"
+"    assert!(!luhn(\"\"));\n"
+"    assert!(!luhn(\" \"));\n"
+"    assert!(!luhn(\"  \"));\n"
+"    assert!(!luhn(\"    \"));\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-2/luhn.md:44
+#: src/exercises/day-2/solutions-afternoon.md:72
+msgid ""
+"#[test]\n"
+"fn test_single_digit_cc_number() {\n"
+"    assert!(!luhn(\"0\"));\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-2/luhn.md:49
+#: src/exercises/day-2/solutions-afternoon.md:77
+msgid ""
+"#[test]\n"
+"fn test_two_digit_cc_number() {\n"
+"    assert!(luhn(\" 0 0 \"));\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-2/luhn.md:54
+#: src/exercises/day-2/solutions-afternoon.md:82
+msgid ""
+"#[test]\n"
+"fn test_valid_cc_number() {\n"
+"    assert!(luhn(\"4263 9826 4026 9299\"));\n"
+"    assert!(luhn(\"4539 3195 0343 6467\"));\n"
+"    assert!(luhn(\"7992 7398 713\"));\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-2/luhn.md:61
+msgid ""
+"#[test]\n"
+"fn test_invalid_cc_number() {\n"
+"    assert!(!luhn(\"4223 9826 4026 9299\"));\n"
+"    assert!(!luhn(\"4539 3195 0343 6476\"));\n"
+"    assert!(!luhn(\"8273 1232 7352 0569\"));\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-2/strings-iterators.md:1
+msgid "# Strings and Iterators"
+msgstr ""
+
+#: src/exercises/day-2/strings-iterators.md:3
+msgid ""
+"In this exercise, you are implementing a routing component of a web server. "
+"The\n"
+"server is configured with a number of _path prefixes_ which are matched "
+"against\n"
+"_request paths_. The path prefixes can contain a wildcard character which\n"
+"matches a full segment. See the unit tests below."
+msgstr ""
+
+#: src/exercises/day-2/strings-iterators.md:8
+msgid ""
+"Copy the following code to <https://play.rust-lang.org/> and make the tests\n"
+"pass. Try avoiding allocating a `Vec` for your intermediate results:"
+msgstr ""
+
+#: src/exercises/day-2/strings-iterators.md:16
+msgid ""
+"pub fn prefix_matches(prefix: &str, request_path: &str) -> bool {\n"
+"    unimplemented!()\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-2/strings-iterators.md:20
+msgid ""
+"#[test]\n"
+"fn test_matches_without_wildcard() {\n"
+"    assert!(prefix_matches(\"/v1/publishers\", \"/v1/publishers\"));\n"
+"    assert!(prefix_matches(\"/v1/publishers\", "
+"\"/v1/publishers/abc-123\"));\n"
+"    assert!(prefix_matches(\"/v1/publishers\", "
+"\"/v1/publishers/abc/books\"));"
+msgstr ""
+
+#: src/exercises/day-2/strings-iterators.md:26
+#: src/exercises/day-2/solutions-afternoon.md:146
+msgid ""
+"    assert!(!prefix_matches(\"/v1/publishers\", \"/v1\"));\n"
+"    assert!(!prefix_matches(\"/v1/publishers\", \"/v1/publishersBooks\"));\n"
+"    assert!(!prefix_matches(\"/v1/publishers\", "
+"\"/v1/parent/publishers\"));\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-2/strings-iterators.md:31
+#: src/exercises/day-2/solutions-afternoon.md:151
+msgid ""
+"#[test]\n"
+"fn test_matches_with_wildcard() {\n"
+"    assert!(prefix_matches(\n"
+"        \"/v1/publishers/*/books\",\n"
+"        \"/v1/publishers/foo/books\"\n"
+"    ));\n"
+"    assert!(prefix_matches(\n"
+"        \"/v1/publishers/*/books\",\n"
+"        \"/v1/publishers/bar/books\"\n"
+"    ));\n"
+"    assert!(prefix_matches(\n"
+"        \"/v1/publishers/*/books\",\n"
+"        \"/v1/publishers/foo/books/book1\"\n"
+"    ));"
+msgstr ""
+
+#: src/exercises/day-2/strings-iterators.md:46
+msgid ""
+"    assert!(!prefix_matches(\"/v1/publishers/*/books\", "
+"\"/v1/publishers\"));\n"
+"    assert!(!prefix_matches(\n"
+"        \"/v1/publishers/*/books\",\n"
+"        \"/v1/publishers/foo/booksByAuthor\"\n"
+"    ));\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/welcome-day-3.md:1
+msgid "# Welcome to Day 3"
+msgstr ""
+
+#: src/welcome-day-3.md:3
+msgid "Today, we will cover some more advanced topics of Rust:"
+msgstr ""
+
+#: src/welcome-day-3.md:5
+msgid ""
+"* Traits: deriving traits, default methods, and important standard library\n"
+"  traits."
+msgstr ""
+
+#: src/welcome-day-3.md:8
+msgid ""
+"* Generics: generic data types, generic methods, monomorphization, and "
+"trait\n"
+"  objects."
+msgstr ""
+
+#: src/welcome-day-3.md:11
+msgid "* Error handling: panics, `Result`, and the try operator `?`."
+msgstr ""
+
+#: src/welcome-day-3.md:13
+msgid "* Testing: unit tests, documentation tests, and integration tests."
+msgstr ""
+
+#: src/welcome-day-3.md:15
+msgid ""
+"* Unsafe Rust: raw pointers, static variables, unsafe functions, and extern\n"
+"  functions."
+msgstr ""
+
+#: src/traits.md:1
+msgid "# Traits"
+msgstr ""
+
+#: src/traits.md:3
+msgid ""
+"Rust lets you abstract over types with traits. They're similar to interfaces:"
+msgstr ""
+
+#: src/traits.md:5
+msgid ""
+"```rust,editable\n"
+"trait Greet {\n"
+"    fn say_hello(&self);\n"
+"}"
+msgstr ""
+
+#: src/traits.md:10
+msgid ""
+"struct Dog {\n"
+"    name: String,\n"
+"}"
+msgstr ""
+
+#: src/traits.md:14
+msgid "struct Cat;  // No name, cats won't respond to it anyway."
+msgstr ""
+
+#: src/traits.md:16
+msgid ""
+"impl Greet for Dog {\n"
+"    fn say_hello(&self) {\n"
+"        println!(\"Wuf, my name is {}!\", self.name);\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/traits.md:22
+msgid ""
+"impl Greet for Cat {\n"
+"    fn say_hello(&self) {\n"
+"        println!(\"Miau!\");\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/traits.md:28
+msgid ""
+"fn main() {\n"
+"    let pets: Vec<Box<dyn Greet>> = vec![\n"
+"        Box::new(Dog { name: String::from(\"Fido\") }),\n"
+"        Box::new(Cat),\n"
+"    ];\n"
+"    for pet in pets {\n"
+"        pet.say_hello();\n"
+"    }\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/traits/deriving-traits.md:1
+msgid "# Deriving Traits"
+msgstr ""
+
+#: src/traits/deriving-traits.md:3
+msgid "You can let the compiler derive a number of traits:"
+msgstr ""
+
+#: src/traits/deriving-traits.md:5
+msgid ""
+"```rust,editable\n"
+"#[derive(Debug, Clone, PartialEq, Eq, Default)]\n"
+"struct Player {\n"
+"    name: String,\n"
+"    strength: u8,\n"
+"    hit_points: u8,\n"
+"}"
+msgstr ""
+
+#: src/traits/deriving-traits.md:13
+msgid ""
+"fn main() {\n"
+"    let p1 = Player::default();\n"
+"    let p2 = p1.clone();\n"
+"    println!(\"Is {:?}\\n"
+"equal to {:?}?\\n"
+"The answer is {}!\", &p1, &p2,\n"
+"             if p1 == p2 { \"yes\" } else { \"no\" });\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/traits/default-methods.md:1
+msgid "# Default Methods"
+msgstr ""
+
+#: src/traits/default-methods.md:3
+msgid "Traits can implement behavior in terms of other trait methods:"
+msgstr ""
+
+#: src/traits/default-methods.md:5
+msgid ""
+"```rust,editable\n"
+"trait Equals {\n"
+"    fn equal(&self, other: &Self) -> bool;\n"
+"    fn not_equal(&self, other: &Self) -> bool {\n"
+"        !self.equal(other)\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/traits/default-methods.md:13
+msgid "#[derive(Debug)]\nstruct Centimeter(i16);"
+msgstr ""
+
+#: src/traits/default-methods.md:16
+msgid ""
+"impl Equals for Centimeter {\n"
+"    fn equal(&self, other: &Centimeter) -> bool {\n"
+"        self.0 == other.0\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/traits/default-methods.md:22
+msgid ""
+"fn main() {\n"
+"    let a = Centimeter(10);\n"
+"    let b = Centimeter(20);\n"
+"    println!(\"{a:?} equals {b:?}: {}\", a.equal(&b));\n"
+"    println!(\"{a:?} not_equals {b:?}: {}\", a.not_equal(&b));\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/traits/important-traits.md:1
+msgid "# Important Traits"
+msgstr ""
+
+#: src/traits/important-traits.md:3
+msgid ""
+"We will now look at some of the most common traits of the Rust standard "
+"library:"
+msgstr ""
+
+#: src/traits/important-traits.md:5
+msgid ""
+"* `Iterator` and `IntoIterator` used in `for` loops,\n"
+"* `From` and `Into` used to convert values,\n"
+"* `Read` and `Write` used for IO,\n"
+"* `Add`, `Mul`, ... used for operator overloading, and\n"
+"* `Drop` used for defining destructors."
+msgstr ""
+
+#: src/traits/iterator.md:1
+msgid "# Iterators"
+msgstr ""
+
+#: src/traits/iterator.md:3
+msgid "You can implement the `Iterator` trait on your own types:"
+msgstr ""
+
+#: src/traits/iterator.md:5
+msgid ""
+"```rust,editable\n"
+"struct Fibonacci {\n"
+"    curr: u32,\n"
+"    next: u32,\n"
+"}"
+msgstr ""
+
+#: src/traits/iterator.md:11
+msgid "impl Iterator for Fibonacci {\n    type Item = u32;"
+msgstr ""
+
+#: src/traits/iterator.md:14
+msgid ""
+"    fn next(&mut self) -> Option<Self::Item> {\n"
+"        let new_next = self.curr + self.next;\n"
+"        self.curr = self.next;\n"
+"        self.next = new_next;\n"
+"        Some(self.curr)\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/traits/iterator.md:22
+msgid ""
+"fn main() {\n"
+"    let fib = Fibonacci { curr: 0, next: 1 };\n"
+"    for (i, n) in fib.enumerate().take(5) {\n"
+"        println!(\"fib({i}): {n}\");\n"
+"    }\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/traits/from-into.md:1
+msgid "# `From` and `Into`"
+msgstr ""
+
+#: src/traits/from-into.md:3
+msgid "Types implement `From` and `Into` to facilitate type conversions:"
+msgstr ""
+
+#: src/traits/from-into.md:5
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let s = String::from(\"hello\");\n"
+"    let addr = std::net::Ipv4Addr::from([127, 0, 0, 1]);\n"
+"    let one = i16::from(true);\n"
+"    let bigger = i32::from(123i16);\n"
+"    println!(\"{s}, {addr}, {one}, {bigger}\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/traits/from-into.md:15
+msgid "`Into` is automatically implemented when `From` is implemented:"
+msgstr ""
+
+#: src/traits/from-into.md:17
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let s: String = \"hello\".into();\n"
+"    let addr: std::net::Ipv4Addr = [127, 0, 0, 1].into();\n"
+"    let one: i16 = true.into();\n"
+"    let bigger: i32 = 123i16.into();\n"
+"    println!(\"{s}, {addr}, {one}, {bigger}\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/traits/read-write.md:1
+msgid "# `Read` and `Write`"
+msgstr ""
+
+#: src/traits/read-write.md:3
+msgid "Using `Read` and `BufRead`, you can abstract over `u8` sources:"
+msgstr ""
+
+#: src/traits/read-write.md:5
+msgid "```rust,editable\nuse std::io::{BufRead, BufReader, Read, Result};"
+msgstr ""
+
+#: src/traits/read-write.md:8
+msgid ""
+"fn count_lines<R: Read>(reader: R) -> usize {\n"
+"    let buf_reader = BufReader::new(reader);\n"
+"    buf_reader.lines().count()\n"
+"}"
+msgstr ""
+
+#: src/traits/read-write.md:13
+msgid ""
+"fn main() -> Result<()> {\n"
+"    let slice: &[u8] = b\"foo\\n"
+"bar\\n"
+"baz\\n"
+"\";\n"
+"    println!(\"lines in slice: {}\", count_lines(slice));"
+msgstr ""
+
+#: src/traits/read-write.md:17
+msgid ""
+"    let file = std::fs::File::open(std::env::current_exe()?)?;\n"
+"    println!(\"lines in file: {}\", count_lines(file));\n"
+"    Ok(())\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/traits/read-write.md:23
+msgid "Similarly, `Write` lets you abstract over `u8` sinks:"
+msgstr ""
+
+#: src/traits/read-write.md:25
+msgid "```rust,editable\nuse std::io::{Result, Write};"
+msgstr ""
+
+#: src/traits/read-write.md:28
+msgid ""
+"fn log<W: Write>(writer: &mut W, msg: &str) -> Result<()> {\n"
+"    writer.write_all(msg.as_bytes())?;\n"
+"    writer.write_all(\"\\n"
+"\".as_bytes())\n"
+"}"
+msgstr ""
+
+#: src/traits/read-write.md:33
+msgid ""
+"fn main() -> Result<()> {\n"
+"    let mut buffer = Vec::new();\n"
+"    log(&mut buffer, \"Hello\")?;\n"
+"    log(&mut buffer, \"World\")?;\n"
+"    println!(\"Logged: {:?}\", buffer);\n"
+"    Ok(())\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/traits/operators.md:1
+msgid "# `Add`, `Mul`, ..."
+msgstr ""
+
+#: src/traits/operators.md:3
+msgid "Operator overloading is implemented via traits in `std::ops`:"
+msgstr ""
+
+#: src/traits/operators.md:5
+msgid ""
+"```rust,editable\n"
+"#[derive(Debug, Copy, Clone)]\n"
+"struct Point { x: i32, y: i32 }"
+msgstr ""
+
+#: src/traits/operators.md:9
+#: src/exercises/day-2/solutions-morning.md:46
+msgid "impl std::ops::Add for Point {\n    type Output = Self;"
+msgstr ""
+
+#: src/traits/operators.md:12
+msgid ""
+"    fn add(self, other: Self) -> Self {\n"
+"        Self {x: self.x + other.x, y: self.y + other.y}\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/traits/operators.md:17
+msgid ""
+"fn main() {\n"
+"    let p1 = Point { x: 10, y: 20 };\n"
+"    let p2 = Point { x: 100, y: 200 };\n"
+"    println!(\"{:?} + {:?} = {:?}\", p1, p2, p1 + p2);\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/traits/drop.md:1
+msgid "# The `Drop` Trait"
+msgstr ""
+
+#: src/traits/drop.md:3
+msgid ""
+"Values which implement `Drop` can specify code to run when they go out of "
+"scope:"
+msgstr ""
+
+#: src/traits/drop.md:5
+msgid ""
+"```rust,editable\n"
+"struct Droppable {\n"
+"    name: &'static str,\n"
+"}"
+msgstr ""
+
+#: src/traits/drop.md:10
+msgid ""
+"impl Drop for Droppable {\n"
+"    fn drop(&mut self) {\n"
+"        println!(\"Dropping {}\", self.name);\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/traits/drop.md:16
+msgid ""
+"fn main() {\n"
+"    let a = Droppable { name: \"a\" };\n"
+"    {\n"
+"        let b = Droppable { name: \"b\" };\n"
+"        {\n"
+"            let c = Droppable { name: \"c\" };\n"
+"            let d = Droppable { name: \"d\" };\n"
+"            println!(\"Exiting block B\");\n"
+"        }\n"
+"        println!(\"Exiting block A\");\n"
+"    }\n"
+"    drop(a);\n"
+"    println!(\"Exiting main\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/generics.md:1
+msgid "# Generics"
+msgstr ""
+
+#: src/generics.md:3
+msgid ""
+"Rust support generics, which lets you abstract an algorithm (such as "
+"sorting)\n"
+"over the types used in the algorithm."
+msgstr ""
+
+#: src/generics/data-types.md:1
+msgid "# Generic Data Types"
+msgstr ""
+
+#: src/generics/data-types.md:3
+msgid "You can use generics to abstract over the concrete field type:"
+msgstr ""
+
+#: src/generics/data-types.md:5
+msgid ""
+"```rust,editable\n"
+"#[derive(Debug)]\n"
+"struct Point<T> {\n"
+"    x: T,\n"
+"    y: T,\n"
+"}"
+msgstr ""
+
+#: src/generics/data-types.md:12
+msgid ""
+"fn main() {\n"
+"    let integer = Point { x: 5, y: 10 };\n"
+"    let float = Point { x: 1.0, y: 4.0 };\n"
+"    println!(\"{integer:?} and {float:?}\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/generics/methods.md:1
+msgid "# Generic Methods"
+msgstr ""
+
+#: src/generics/methods.md:3
+msgid "You can declare a generic type on your `impl` block:"
+msgstr ""
+
+#: src/generics/methods.md:5
+msgid ""
+"```rust,editable\n"
+"#[derive(Debug)]\n"
+"struct Point<T>(T, T);"
+msgstr ""
+
+#: src/generics/methods.md:9
+msgid ""
+"impl<T> Point<T> {\n"
+"    fn x(&self) -> &T {\n"
+"        &self.0  // + 10\n"
+"    }"
+msgstr ""
+
+#: src/generics/methods.md:14
+msgid "    // fn set_x(&mut self, x: T)\n}"
+msgstr ""
+
+#: src/generics/methods.md:17
+msgid ""
+"fn main() {\n"
+"    let p = Point(5, 10);\n"
+"    println!(\"p.x = {}\", p.x());\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/generics/trait-bounds.md:1
+msgid "# Trait Bounds"
+msgstr ""
+
+#: src/generics/trait-bounds.md:3
+msgid ""
+"When working with generics, you often want to limit the types. You can do "
+"this\n"
+"with `T: Trait` or `impl Trait`:"
+msgstr ""
+
+#: src/generics/trait-bounds.md:6
+msgid ""
+"```rust,editable\n"
+"fn duplicate<T: Clone>(a: T) -> (T, T) {\n"
+"    (a.clone(), a.clone())\n"
+"}"
+msgstr ""
+
+#: src/generics/trait-bounds.md:11
+msgid "// struct NotClonable;"
+msgstr ""
+
+#: src/generics/trait-bounds.md:13
+msgid ""
+"fn main() {\n"
+"    let foo = String::from(\"foo\");\n"
+"    let pair = duplicate(foo);\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/generics/impl-trait.md:1
+msgid "# `impl Trait`"
+msgstr ""
+
+#: src/generics/impl-trait.md:3
+msgid ""
+"Similar to trait bounds, an `impl Trait` syntax can be used in function\n"
+"arguments and return values:"
+msgstr ""
+
+#: src/generics/impl-trait.md:6
+#: src/generics/trait-objects.md:5
+#: src/generics/trait-objects.md:28
+msgid "```rust,editable\nuse std::fmt::Display;"
+msgstr ""
+
+#: src/generics/impl-trait.md:9
+msgid ""
+"fn get_x(name: impl Display) -> impl Display {\n"
+"    format!(\"Hello {name}\")\n"
+"}"
+msgstr ""
+
+#: src/generics/impl-trait.md:13
+msgid ""
+"fn main() {\n"
+"    let x = get_x(\"foo\");\n"
+"    println!(\"{x}\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/generics/impl-trait.md:19
+msgid ""
+"* `impl Trait` cannot be used with the `::<>` turbo fish syntax.\n"
+"* `impl Trait` allows you to work with types which you cannot name."
+msgstr ""
+
+#: src/generics/closures.md:1
+msgid "# Closures"
+msgstr ""
+
+#: src/generics/closures.md:3
+msgid ""
+"Closures or lambda expressions have types which cannot be named. However, "
+"they\n"
+"implement special [`Fn`](https://doc.rust-lang.org/std/ops/trait.Fn.html),\n"
+"[`FnMut`](https://doc.rust-lang.org/std/ops/trait.FnMut.html), and\n"
+"[`FnOnce`](https://doc.rust-lang.org/std/ops/trait.FnOnce.html) traits:"
+msgstr ""
+
+#: src/generics/closures.md:8
+msgid ""
+"```rust,editable\n"
+"fn apply_with_log(func: impl FnOnce(i32) -> i32, input: i32) -> i32 {\n"
+"    println!(\"Calling function on {input}\");\n"
+"    func(input)\n"
+"}"
+msgstr ""
+
+#: src/generics/closures.md:14
+msgid ""
+"fn main() {\n"
+"    let add_3 = |x| x + 3;\n"
+"    let mul_5 = |x| x * 5;"
+msgstr ""
+
+#: src/generics/closures.md:18
+msgid ""
+"    println!(\"add_3: {}\", apply_with_log(add_3, 10));\n"
+"    println!(\"mul_5: {}\", apply_with_log(mul_5, 20));\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/generics/monomorphization.md:1
+msgid "# Monomorphization"
+msgstr ""
+
+#: src/generics/monomorphization.md:3
+msgid "Generic code is turned into non-generic code based on the call sites:"
+msgstr ""
+
+#: src/generics/monomorphization.md:5
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let integer = Some(5);\n"
+"    let float = Some(5.0);\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/generics/monomorphization.md:12
+msgid "behaves as if you wrote"
+msgstr ""
+
+#: src/generics/monomorphization.md:14
+msgid ""
+"```rust,editable\n"
+"enum Option_i32 {\n"
+"    Some(i32),\n"
+"    None,\n"
+"}"
+msgstr ""
+
+#: src/generics/monomorphization.md:20
+msgid ""
+"enum Option_f64 {\n"
+"    Some(f64),\n"
+"    None,\n"
+"}"
+msgstr ""
+
+#: src/generics/monomorphization.md:25
+msgid ""
+"fn main() {\n"
+"    let integer = Option_i32::Some(5);\n"
+"    let float = Option_f64::Some(5.0);\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/generics/monomorphization.md:31
+msgid ""
+"This is a zero-cost abstraction: you get exactly the same result as if you "
+"had\n"
+"hand-coded the data structures without the abstraction."
+msgstr ""
+
+#: src/generics/trait-objects.md:1
+msgid "# Trait Objects"
+msgstr ""
+
+#: src/generics/trait-objects.md:3
+msgid "We've seen how a function can take arguments which implement a trait:"
+msgstr ""
+
+#: src/generics/trait-objects.md:8
+msgid ""
+"fn print<T: Display>(x: T) {\n"
+"    println!(\"Your value: {}\", x);\n"
+"}"
+msgstr ""
+
+#: src/generics/trait-objects.md:12
+msgid ""
+"fn main() {\n"
+"    print(123);\n"
+"    print(\"Hello\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/generics/trait-objects.md:18
+msgid ""
+"However, how can we store a collection of mixed types which implement "
+"`Display`?"
+msgstr ""
+
+#: src/generics/trait-objects.md:20
+msgid ""
+"```rust,editable,compile_fail\n"
+"fn main() {\n"
+"    let xs = vec![123, \"Hello\"];\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/generics/trait-objects.md:26
+msgid "For this, we need _trait objects_:"
+msgstr ""
+
+#: src/generics/trait-objects.md:31
+msgid ""
+"fn main() {\n"
+"    let xs: Vec<Box<dyn Display>> = vec![Box::new(123), "
+"Box::new(\"Hello\")];\n"
+"    for x in xs {\n"
+"        println!(\"x: {x}\");\n"
+"    }\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/generics/trait-objects.md:39
+msgid "Memory layout after allocating `xs`:"
+msgstr ""
+
+#: src/generics/trait-objects.md:41
+msgid ""
+"```bob\n"
+" Stack                             Heap\n"
+".- - - - - - - - - - - - - -.     .- - - - - - - - - - - - - - - - - - - - - "
+"- - -.\n"
+":                           :     :                                          "
+"     :\n"
+":    xs                     :     :                                          "
+"     :\n"
+":   +-----------+-------+   :     :   +-----+-----+                          "
+"     :\n"
+":   | ptr       |   o---+---+-----+-->| o o | o o |                          "
+"     :\n"
+":   | len       |     2 |   :     :   +-|-|-+-|-|-+                          "
+"     :\n"
+":   | capacity  |     2 |   :     :     | |   | |   "
+"+----+----+----+----+----+    :\n"
+":   +-----------+-------+   :     :     | |   | '-->| H  | e  | l  | l  | o  "
+"|    :\n"
+":                           :     :     | |   |     "
+"+----+----+----+----+----+    :\n"
+"`- - - - - - - - - - - - - -'     :     | |   |                              "
+"     :\n"
+"                                  :     | |   |     "
+"+-------------------------+   :\n"
+"                                  :     | |   '---->| \"<str as "
+"Display>::fmt\" |   :\n"
+"                                  :     | |         "
+"+-------------------------+   :\n"
+"                                  :     | |                                  "
+"     :\n"
+"                                  :     | |   +-------------------------+    "
+"     :\n"
+"                                  :     | '-->| \"<i32 as Display>::fmt\" |  "
+"       :\n"
+"                                  :     |     +-------------------------+    "
+"     :\n"
+"                                  :     |                                    "
+"     :\n"
+"                                  :     |     +----+----+----+----+          "
+"     :\n"
+"                                  :     '---->| 7b | 00 | 00 | 00 |          "
+"     :\n"
+"                                  :           +----+----+----+----+          "
+"     :\n"
+"                                  :                                          "
+"     :\n"
+"                                  :                                          "
+"     :\n"
+"                                  '- - - - - - - - - - - - - - - - - - - - - "
+"- - -'\n"
+"```"
+msgstr ""
+
+#: src/generics/trait-objects.md:69
+msgid ""
+"Similarly, you need a trait object if you want to return different values\n"
+"implementing a trait:"
+msgstr ""
+
+#: src/generics/trait-objects.md:72
+msgid ""
+"```rust,editable\n"
+"fn numbers(n: i32) -> Box<dyn Iterator<Item=i32>> {\n"
+"    if n > 0 {\n"
+"        Box::new(0..n)\n"
+"    } else {\n"
+"        Box::new((n..0).rev())\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/generics/trait-objects.md:81
+msgid ""
+"fn main() {\n"
+"    println!(\"{:?}\", numbers(-5).collect::<Vec<_>>());\n"
+"    println!(\"{:?}\", numbers(5).collect::<Vec<_>>());\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-3/morning.md:1
+msgid "# Day 3: Morning Exercises"
+msgstr ""
+
+#: src/exercises/day-3/morning.md:3
+msgid "We will design a classical GUI library traits and trait objects."
+msgstr ""
+
+#: src/exercises/day-3/simple-gui.md:1
+msgid "# A Simple GUI Library"
+msgstr ""
+
+#: src/exercises/day-3/simple-gui.md:3
+msgid ""
+"Let us design a classical GUI library using our new knowledge of traits and\n"
+"trait objects."
+msgstr ""
+
+#: src/exercises/day-3/simple-gui.md:6
+msgid "We will have a number of widgets in our library:"
+msgstr ""
+
+#: src/exercises/day-3/simple-gui.md:8
+msgid ""
+"* `Window`: has a `title` and contains other widgets.\n"
+"* `Button`: has a `label` and a callback function which is invoked when the\n"
+"  button is pressed.\n"
+"* `Label`: has a `label`."
+msgstr ""
+
+#: src/exercises/day-3/simple-gui.md:13
+msgid "The widgets will implement a `Widget` trait, see below."
+msgstr ""
+
+#: src/exercises/day-3/simple-gui.md:15
+msgid ""
+"Copy the code below to <https://play.rust-lang.org/>, fill in the missing\n"
+"`draw_into` methods so that you implement the `Widget` trait:"
+msgstr ""
+
+#: src/exercises/day-3/simple-gui.md:18
+#: src/exercises/day-3/safe-ffi-wrapper.md:25
+msgid ""
+"```rust,should_panic\n"
+"// TODO: remove this when you're done with your implementation.\n"
+"#![allow(unused_imports, unused_variables, dead_code)]"
+msgstr ""
+
+#: src/exercises/day-3/simple-gui.md:22
+msgid ""
+"pub trait Widget {\n"
+"    /// Natural width of `self`.\n"
+"    fn width(&self) -> usize;"
+msgstr ""
+
+#: src/exercises/day-3/simple-gui.md:26
+#: src/exercises/day-3/solutions-morning.md:27
+msgid ""
+"    /// Draw the widget into a buffer.\n"
+"    fn draw_into(&self, buffer: &mut dyn std::fmt::Write);"
+msgstr ""
+
+#: src/exercises/day-3/simple-gui.md:29
+#: src/exercises/day-3/solutions-morning.md:30
+msgid ""
+"    /// Draw the widget on standard output.\n"
+"    fn draw(&self) {\n"
+"        let mut buffer = String::new();\n"
+"        self.draw_into(&mut buffer);\n"
+"        println!(\"{}\", &buffer);\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-3/simple-gui.md:37
+#: src/exercises/day-3/solutions-morning.md:38
+msgid ""
+"pub struct Label {\n"
+"    label: String,\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-3/simple-gui.md:41
+#: src/exercises/day-3/solutions-morning.md:42
+msgid ""
+"impl Label {\n"
+"    fn new(label: &str) -> Label {\n"
+"        Label {\n"
+"            label: label.to_owned(),\n"
+"        }\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-3/simple-gui.md:49
+#: src/exercises/day-3/solutions-morning.md:50
+msgid ""
+"pub struct Button {\n"
+"    label: Label,\n"
+"    callback: Box<dyn FnMut()>,\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-3/simple-gui.md:54
+#: src/exercises/day-3/solutions-morning.md:55
+msgid ""
+"impl Button {\n"
+"    fn new(label: &str, callback: Box<dyn FnMut()>) -> Button {\n"
+"        Button {\n"
+"            label: Label::new(label),\n"
+"            callback,\n"
+"        }\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-3/simple-gui.md:63
+#: src/exercises/day-3/solutions-morning.md:64
+msgid ""
+"pub struct Window {\n"
+"    title: String,\n"
+"    widgets: Vec<Box<dyn Widget>>,\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-3/simple-gui.md:68
+#: src/exercises/day-3/solutions-morning.md:69
+msgid ""
+"impl Window {\n"
+"    fn new(title: &str) -> Window {\n"
+"        Window {\n"
+"            title: title.to_owned(),\n"
+"            widgets: Vec::new(),\n"
+"        }\n"
+"    }"
+msgstr ""
+
+#: src/exercises/day-3/simple-gui.md:76
+#: src/exercises/day-3/solutions-morning.md:77
+msgid ""
+"    fn add_widget(&mut self, widget: Box<dyn Widget>) {\n"
+"        self.widgets.push(widget);\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-3/simple-gui.md:82
+msgid ""
+"impl Widget for Label {\n"
+"    fn width(&self) -> usize {\n"
+"        unimplemented!()\n"
+"    }"
+msgstr ""
+
+#: src/exercises/day-3/simple-gui.md:87
+#: src/exercises/day-3/simple-gui.md:97
+#: src/exercises/day-3/simple-gui.md:107
+msgid ""
+"    fn draw_into(&self, buffer: &mut dyn std::fmt::Write) {\n"
+"        unimplemented!()\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-3/simple-gui.md:92
+msgid ""
+"impl Widget for Button {\n"
+"    fn width(&self) -> usize {\n"
+"        unimplemented!()\n"
+"    }"
+msgstr ""
+
+#: src/exercises/day-3/simple-gui.md:102
+msgid ""
+"impl Widget for Window {\n"
+"    fn width(&self) -> usize {\n"
+"        unimplemented!()\n"
+"    }"
+msgstr ""
+
+#: src/exercises/day-3/simple-gui.md:112
+msgid ""
+"fn main() {\n"
+"    let mut window = Window::new(\"Rust GUI Demo 1.23\");\n"
+"    window.add_widget(Box::new(Label::new(\"This is a small text GUI "
+"demo.\")));\n"
+"    window.add_widget(Box::new(Button::new(\n"
+"        \"Click me!\",\n"
+"        Box::new(|| println!(\"You clicked the button!\")),\n"
+"    )));\n"
+"    window.draw();\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/exercises/day-3/simple-gui.md:123
+msgid "The output of the above program can be something simple like this:"
+msgstr ""
+
+#: src/exercises/day-3/simple-gui.md:125
+msgid ""
+"```text\n"
+"========\n"
+"Rust GUI Demo 1.23\n"
+"========"
+msgstr ""
+
+#: src/exercises/day-3/simple-gui.md:130
+msgid "This is a small text GUI demo."
+msgstr ""
+
+#: src/exercises/day-3/simple-gui.md:132
+msgid "| Click me! |\n```"
+msgstr ""
+
+#: src/exercises/day-3/simple-gui.md:135
+msgid ""
+"If you want to draw aligned text, you can use the\n"
+"[fill/alignment](https://doc.rust-lang.org/std/fmt/index.html#fillalignment)\n"
+"formatting operators. In particular, notice how you can pad with different\n"
+"characters (here a `'/'`) and how you can control alignment:"
+msgstr ""
+
+#: src/exercises/day-3/simple-gui.md:140
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let width = 10;\n"
+"    println!(\"left aligned:  |{:/<width$}|\", \"foo\");\n"
+"    println!(\"centered:      |{:/^width$}|\", \"foo\");\n"
+"    println!(\"right aligned: |{:/>width$}|\", \"foo\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/exercises/day-3/simple-gui.md:149
+msgid ""
+"Using such alignment tricks, you can for example produce output like this:"
+msgstr ""
+
+#: src/exercises/day-3/simple-gui.md:151
+msgid ""
+"```text\n"
+"+--------------------------------+\n"
+"|       Rust GUI Demo 1.23       |\n"
+"+================================+\n"
+"| This is a small text GUI demo. |\n"
+"| +-----------+                  |\n"
+"| | Click me! |                  |\n"
+"| +-----------+                  |\n"
+"+--------------------------------+\n"
+"```"
+msgstr ""
+
+#: src/error-handling.md:1
+msgid "# Error Handling"
+msgstr ""
+
+#: src/error-handling.md:3
+msgid "Error handling in Rust is done using explicit control flow:"
+msgstr ""
+
+#: src/error-handling.md:5
+msgid ""
+"* Functions that can have errors list this in their return type,\n"
+"* There are no exceptions."
+msgstr ""
+
+#: src/error-handling/panics.md:1
+msgid "# Panics"
+msgstr ""
+
+#: src/error-handling/panics.md:3
+msgid "Rust will trigger a panic if a fatal error happens at runtime:"
+msgstr ""
+
+#: src/error-handling/panics.md:5
+msgid ""
+"```rust,editable,should_panic\n"
+"fn main() {\n"
+"    let v = vec![10, 20, 30];\n"
+"    println!(\"v[100]: {}\", v[100]);\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/error-handling/panics.md:12
+msgid ""
+"* Panics are for unrecoverable and unexpected errors.\n"
+"  * Panics are symptoms of bugs in the program.\n"
+"* Use non-panicking APIs (such as `Vec::get`) if crashing is not acceptable."
+msgstr ""
+
+#: src/error-handling/panic-unwind.md:1
+msgid "# Catching the Stack Unwinding"
+msgstr ""
+
+#: src/error-handling/panic-unwind.md:3
+msgid ""
+"By default, a panic will cause the stack to unwind. The unwinding can be "
+"caught:"
+msgstr ""
+
+#: src/error-handling/panic-unwind.md:5
+msgid "```rust\nuse std::panic;"
+msgstr ""
+
+#: src/error-handling/panic-unwind.md:8
+msgid ""
+"let result = panic::catch_unwind(|| {\n"
+"    println!(\"hello!\");\n"
+"});\n"
+"assert!(result.is_ok());"
+msgstr ""
+
+#: src/error-handling/panic-unwind.md:13
+msgid ""
+"let result = panic::catch_unwind(|| {\n"
+"    panic!(\"oh no!\");\n"
+"});\n"
+"assert!(result.is_err());\n"
+"```"
+msgstr ""
+
+#: src/error-handling/panic-unwind.md:19
+msgid ""
+"* This can be useful in servers which should keep running even if a single\n"
+"  request crashes.\n"
+"* This does not work if `panic = abort` is set in your `Cargo.toml`."
+msgstr ""
+
+#: src/error-handling/result.md:1
+msgid "# Structured Error Handling with `Result`"
+msgstr ""
+
+#: src/error-handling/result.md:3
+msgid ""
+"We have already seen the `Result` enum. This is used pervasively when errors "
+"are\n"
+"expected as part of normal operation:"
+msgstr ""
+
+#: src/error-handling/result.md:6
+msgid ""
+"```rust\n"
+"use std::fs::File;\n"
+"use std::io::Read;"
+msgstr ""
+
+#: src/error-handling/result.md:10
+msgid ""
+"fn main() {\n"
+"    let file = File::open(\"diary.txt\");\n"
+"    match file {\n"
+"        Ok(mut file) => {\n"
+"            let mut contents = String::new();\n"
+"            file.read_to_string(&mut contents);\n"
+"            println!(\"Dear diary: {contents}\");\n"
+"        },\n"
+"        Err(err) => {\n"
+"            println!(\"The diary could not be opened: {err}\");\n"
+"        }\n"
+"    }\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/error-handling/try-operator.md:1
+msgid "# Propagating Errors with `?`"
+msgstr ""
+
+#: src/error-handling/try-operator.md:3
+msgid ""
+"The try-operator `?` is used to return errors to the caller. It lets you "
+"turn\n"
+"the common"
+msgstr ""
+
+#: src/error-handling/try-operator.md:6
+msgid ""
+"```rust,ignore\n"
+"match some_expression {\n"
+"    Ok(value) => value,\n"
+"    Err(err) => return Err(err),\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/error-handling/try-operator.md:13
+msgid "into the much simpler"
+msgstr ""
+
+#: src/error-handling/try-operator.md:15
+msgid ""
+"```rust,ignore\n"
+"some_expression?\n"
+"```"
+msgstr ""
+
+#: src/error-handling/try-operator.md:19
+msgid "We can use this to simplify our error handing code:"
+msgstr ""
+
+#: src/error-handling/try-operator.md:21
+msgid ""
+"```rust,editable\n"
+"use std::fs;\n"
+"use std::io::{self, Read};"
+msgstr ""
+
+#: src/error-handling/try-operator.md:25
+msgid ""
+"fn read_username(path: &str) -> Result<String, io::Error> {\n"
+"    let username_file_result = fs::File::open(path);"
+msgstr ""
+
+#: src/error-handling/try-operator.md:28
+msgid ""
+"    let mut username_file = match username_file_result {\n"
+"        Ok(file) => file,\n"
+"        Err(e) => return Err(e),\n"
+"    };"
+msgstr ""
+
+#: src/error-handling/try-operator.md:33
+msgid "    let mut username = String::new();"
+msgstr ""
+
+#: src/error-handling/try-operator.md:35
+msgid ""
+"    match username_file.read_to_string(&mut username) {\n"
+"        Ok(_) => Ok(username),\n"
+"        Err(e) => Err(e),\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/error-handling/try-operator.md:41
+msgid ""
+"fn main() {\n"
+"    //fs::write(\"config.dat\", \"alice\").unwrap();\n"
+"    let username = read_username(\"config.dat\");\n"
+"    println!(\"username or error: {username:?}\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/error-handling/converting-error-types.md:1
+msgid "# Converting Error Types"
+msgstr ""
+
+#: src/error-handling/converting-error-types.md:3
+msgid ""
+"The effective expansion of `?` is a little more complicated than previously "
+"indicated:"
+msgstr ""
+
+#: src/error-handling/converting-error-types.md:5
+msgid ""
+"```rust,ignore\n"
+"expression?\n"
+"```"
+msgstr ""
+
+#: src/error-handling/converting-error-types.md:9
+msgid "works the same as"
+msgstr ""
+
+#: src/error-handling/converting-error-types.md:11
+msgid ""
+"```rust,ignore\n"
+"match expression {\n"
+"    Ok(value) => value,\n"
+"    Err(err)  => return Err(From::from(err)),\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/error-handling/converting-error-types.md:18
+msgid ""
+"The `From::from` call here means we attempt to convert the error type to "
+"the\n"
+"type returned by the function:"
+msgstr ""
+
+#: src/error-handling/converting-error-types.md:21
+msgid ""
+"```rust,editable\n"
+"use std::{fs, io};\n"
+"use std::io::Read;"
+msgstr ""
+
+#: src/error-handling/converting-error-types.md:25
+msgid ""
+"#[derive(Debug)]\n"
+"enum ReadUsernameError {\n"
+"    IoError(io::Error),\n"
+"    EmptyUsername(String),\n"
+"}"
+msgstr ""
+
+#: src/error-handling/converting-error-types.md:31
+msgid ""
+"impl From<io::Error> for ReadUsernameError {\n"
+"    fn from(err: io::Error) -> ReadUsernameError {\n"
+"        ReadUsernameError::IoError(err)\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/error-handling/converting-error-types.md:37
+#: src/error-handling/deriving-error-enums.md:19
+msgid ""
+"fn read_username(path: &str) -> Result<String, ReadUsernameError> {\n"
+"    let mut username = String::with_capacity(100);\n"
+"    fs::File::open(path)?.read_to_string(&mut username)?;\n"
+"    if username.is_empty() {\n"
+"        return Err(ReadUsernameError::EmptyUsername(String::from(path)));\n"
+"    }\n"
+"    Ok(username)\n"
+"}"
+msgstr ""
+
+#: src/error-handling/converting-error-types.md:46
+msgid ""
+"fn main() {\n"
+"    //fs::write(\"config.dat\", \"\").unwrap();\n"
+"    let username = read_username(\"config.dat\");\n"
+"    println!(\"username or error: {username:?}\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/error-handling/deriving-error-enums.md:1
+msgid "# Deriving Error Enums"
+msgstr ""
+
+#: src/error-handling/deriving-error-enums.md:3
+msgid ""
+"The [thiserror](https://docs.rs/thiserror/) crate is a popular way to create "
+"an\n"
+"error enum like we did on the previous page:"
+msgstr ""
+
+#: src/error-handling/deriving-error-enums.md:6
+msgid ""
+"```rust,editable,compile_fail\n"
+"use std::{fs, io};\n"
+"use std::io::Read;\n"
+"use thiserror::Error;"
+msgstr ""
+
+#: src/error-handling/deriving-error-enums.md:11
+msgid ""
+"#[derive(Error, Debug)]\n"
+"enum ReadUsernameError {\n"
+"    #[error(\"Could not read: {0}\")]\n"
+"    IoError(#[from] io::Error),\n"
+"    #[error(\"Found no username in {0}\")]\n"
+"    EmptyUsername(String),\n"
+"}"
+msgstr ""
+
+#: src/error-handling/deriving-error-enums.md:28
+msgid ""
+"fn main() {\n"
+"    //fs::write(\"config.dat\", \"\").unwrap();\n"
+"    match read_username(\"config.dat\") {\n"
+"        Ok(username) => println!(\"Username: {username}\"),\n"
+"        Err(err)     => println!(\"Error: {err}\"),\n"
+"    }\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/error-handling/error-contexts.md:1
+msgid "# Adding Context to Errors"
+msgstr ""
+
+#: src/error-handling/error-contexts.md:3
+msgid ""
+"The widely used [anyhow](https://docs.rs/anyhow/) crate can help you add\n"
+"contextual information to your errors and allows you to have fewer\n"
+"custom error types:"
+msgstr ""
+
+#: src/error-handling/error-contexts.md:7
+msgid ""
+"```rust,editable,compile_fail\n"
+"use std::{fs, io};\n"
+"use std::io::Read;\n"
+"use thiserror::Error;\n"
+"use anyhow::{Context, Result};"
+msgstr ""
+
+#: src/error-handling/error-contexts.md:13
+msgid ""
+"#[derive(Error, Debug)]\n"
+"enum ReadUsernameError {\n"
+"    #[error(\"Found no username in {0}\")]\n"
+"    EmptyUsername(String),\n"
+"}"
+msgstr ""
+
+#: src/error-handling/error-contexts.md:19
+msgid ""
+"fn read_username(path: &str) -> Result<String> {\n"
+"    let mut username = String::with_capacity(100);\n"
+"    fs::File::open(path)\n"
+"        .context(format!(\"Failed to open {path}\"))?\n"
+"        .read_to_string(&mut username)\n"
+"        .context(\"Failed to read\")?;\n"
+"    if username.is_empty() {\n"
+"        return Err(ReadUsernameError::EmptyUsername(String::from(path)))?;\n"
+"    }\n"
+"    Ok(username)\n"
+"}"
+msgstr ""
+
+#: src/error-handling/error-contexts.md:31
+msgid ""
+"fn main() {\n"
+"    //fs::write(\"config.dat\", \"\").unwrap();\n"
+"    match read_username(\"config.dat\") {\n"
+"        Ok(username) => println!(\"Username: {username}\"),\n"
+"        Err(err)     => println!(\"Error: {err:?}\"),\n"
+"    }\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/testing.md:1
+msgid "# Testing"
+msgstr ""
+
+#: src/testing.md:3
+msgid "Rust and Cargo come with a simple unit test framework:"
+msgstr ""
+
+#: src/testing.md:5
+msgid "* Unit tests are supported throughout your code."
+msgstr ""
+
+#: src/testing.md:7
+msgid "* Integration tests are supported via the `tests/` directory."
+msgstr ""
+
+#: src/testing/unit-tests.md:1
+msgid "# Unit Tests"
+msgstr ""
+
+#: src/testing/unit-tests.md:3
+msgid "Mark unit tests with `#[test]`:"
+msgstr ""
+
+#: src/testing/unit-tests.md:5
+msgid ""
+"```rust,editable\n"
+"fn first_word(text: &str) -> &str {\n"
+"    match text.find(' ') {\n"
+"        Some(idx) => &text[..idx],\n"
+"        None => &text,\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/testing/unit-tests.md:13
+msgid ""
+"#[test]\n"
+"fn test_empty() {\n"
+"    assert_eq!(first_word(\"\"), \"\");\n"
+"}"
+msgstr ""
+
+#: src/testing/unit-tests.md:18
+msgid ""
+"#[test]\n"
+"fn test_single_word() {\n"
+"    assert_eq!(first_word(\"Hello\"), \"Hello\");\n"
+"}"
+msgstr ""
+
+#: src/testing/unit-tests.md:23
+msgid ""
+"#[test]\n"
+"fn test_multiple_words() {\n"
+"    assert_eq!(first_word(\"Hello World\"), \"Hello\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/testing/unit-tests.md:29
+msgid "Use `cargo test` to find and run the unit tests."
+msgstr ""
+
+#: src/testing/test-modules.md:1
+msgid "# Test Modules"
+msgstr ""
+
+#: src/testing/test-modules.md:3
+msgid ""
+"Unit tests are often put in a nested module (run tests on the\n"
+"[Playground](https://play.rust-lang.org/)):"
+msgstr ""
+
+#: src/testing/test-modules.md:6
+msgid ""
+"```rust,editable\n"
+"fn helper(a: &str, b: &str) -> String {\n"
+"    format!(\"{a} {b}\")\n"
+"}"
+msgstr ""
+
+#: src/testing/test-modules.md:11
+msgid ""
+"pub fn main() {\n"
+"    println!(\"{}\", helper(\"Hello\", \"World\"));\n"
+"}"
+msgstr ""
+
+#: src/testing/test-modules.md:19
+msgid ""
+"    #[test]\n"
+"    fn test_helper() {\n"
+"        assert_eq!(helper(\"foo\", \"bar\"), \"foo bar\");\n"
+"    }\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/testing/test-modules.md:26
+msgid ""
+"* This lets you unit test private helpers.\n"
+"* The `#[cfg(test)]` attribute is only active when you run `cargo test`."
+msgstr ""
+
+#: src/testing/doc-tests.md:1
+msgid "# Documentation Tests"
+msgstr ""
+
+#: src/testing/doc-tests.md:3
+msgid "Rust has built-in support for documentation tests:"
+msgstr ""
+
+#: src/testing/doc-tests.md:5
+msgid ""
+"```rust\n"
+"/// Shorten string will trip the string to the given length.\n"
+"///\n"
+"/// ```\n"
+"/// use playground::shorten_string;\n"
+"/// assert_eq!(shorten_string(\"Hello World\", 5), \"Hello\");\n"
+"/// assert_eq!(shorten_string(\"Hello World\", 20), \"Hello World\");\n"
+"/// ```\n"
+"pub fn shorten_string(s: &str, length: usize) -> &str {\n"
+"    &s[..std::cmp::min(length, s.len())]\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/testing/doc-tests.md:18
+msgid ""
+"* Code blocks in `///` comments are automatically seen as Rust code.\n"
+"* The code will be compiled and executed as part of `cargo test`.\n"
+"* Test the above code on the [Rust "
+"Playground](https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=c8ce535a3778218fed50c2b4c317d15d)."
+msgstr ""
+
+#: src/testing/integration-tests.md:1
+msgid "# Integration Tests"
+msgstr ""
+
+#: src/testing/integration-tests.md:3
+msgid "If you want to test your library as a client, use an integration test."
+msgstr ""
+
+#: src/testing/integration-tests.md:5
+msgid "Create a `.rs` file under `tests/`:"
+msgstr ""
+
+#: src/testing/integration-tests.md:7
+msgid "```rust,ignore\nuse my_library::init;"
+msgstr ""
+
+#: src/testing/integration-tests.md:10
+msgid ""
+"#[test]\n"
+"fn test_init() {\n"
+"    assert!(init().is_ok());\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/testing/integration-tests.md:16
+msgid "These tests only have access to the public API of your crate."
+msgstr ""
+
+#: src/unsafe.md:1
+msgid "# Unsafe Rust"
+msgstr ""
+
+#: src/unsafe.md:3
+msgid "The Rust language has two parts:"
+msgstr ""
+
+#: src/unsafe.md:5
+msgid ""
+"* **Safe Rust:** memory safe, no undefined behavior possible.\n"
+"* **Unsafe Rust:** can trigger undefined behavior if preconditions are "
+"violated."
+msgstr ""
+
+#: src/unsafe.md:8
+msgid ""
+"We will be seeing mostly safe Rust in this course, but it's important to "
+"know\n"
+"what Unsafe Rust is."
+msgstr ""
+
+#: src/unsafe.md:11
+msgid "Unsafe Rust gives you access to five new capabilities:"
+msgstr ""
+
+#: src/unsafe.md:13
+msgid ""
+"* Dereference raw pointers.\n"
+"* Access or modify mutable static variables.\n"
+"* Access `union` fields.\n"
+"* Call `unsafe` functions, including `extern` functions.\n"
+"* Implement `unsafe` traits."
+msgstr ""
+
+#: src/unsafe.md:19
+msgid ""
+"We will briefly cover these capabilities next. For full details, please see\n"
+"[Chapter 19.1 in the Rust "
+"Book](https://doc.rust-lang.org/book/ch19-01-unsafe-rust.html)\n"
+"and the [Rustonomicon](https://doc.rust-lang.org/nomicon/)."
+msgstr ""
+
+#: src/unsafe/raw-pointers.md:1
+msgid "# Dereferencing Raw Pointers"
+msgstr ""
+
+#: src/unsafe/raw-pointers.md:3
+msgid "Creating pointers is safe, but dereferencing them requires `unsafe`:"
+msgstr ""
+
+#: src/unsafe/raw-pointers.md:5
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let mut num = 5;"
+msgstr ""
+
+#: src/unsafe/raw-pointers.md:9
+msgid "    let r1 = &mut num as *mut i32;\n    let r2 = &num as *const i32;"
+msgstr ""
+
+#: src/unsafe/raw-pointers.md:12
+msgid ""
+"    unsafe {\n"
+"        println!(\"r1 is: {}\", *r1);\n"
+"        *r1 = 10;  // Data race if r1 is being written concurrently!\n"
+"        println!(\"r2 is: {}\", *r2);\n"
+"    }\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/unsafe/mutable-static-variables.md:1
+msgid "# Mutable Static Variables"
+msgstr ""
+
+#: src/unsafe/mutable-static-variables.md:3
+msgid "It is safe to read an immutable static variable:"
+msgstr ""
+
+#: src/unsafe/mutable-static-variables.md:5
+msgid "```rust,editable\nstatic HELLO_WORLD: &str = \"Hello, world!\";"
+msgstr ""
+
+#: src/unsafe/mutable-static-variables.md:8
+msgid ""
+"fn main() {\n"
+"    println!(\"name is: {}\", HELLO_WORLD);\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/unsafe/mutable-static-variables.md:13
+msgid ""
+"However, since data races can occur, it is unsafe to read and write mutable\n"
+"static variables:"
+msgstr ""
+
+#: src/unsafe/mutable-static-variables.md:16
+msgid "```rust,editable\nstatic mut COUNTER: u32 = 0;"
+msgstr ""
+
+#: src/unsafe/mutable-static-variables.md:19
+msgid ""
+"fn add_to_counter(inc: u32) {\n"
+"    unsafe { COUNTER += inc; }  // Potential data race!\n"
+"}"
+msgstr ""
+
+#: src/unsafe/mutable-static-variables.md:23
+msgid "fn main() {\n    add_to_counter(42);"
+msgstr ""
+
+#: src/unsafe/mutable-static-variables.md:26
+msgid ""
+"    unsafe { println!(\"COUNTER: {}\", COUNTER); }  // Potential data race!\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/unsafe/unsafe-functions.md:1
+msgid "# Calling Unsafe Functions"
+msgstr ""
+
+#: src/unsafe/unsafe-functions.md:3
+msgid ""
+"A function or method can be marked `unsafe` if it has extra preconditions "
+"you\n"
+"must uphold:"
+msgstr ""
+
+#: src/unsafe/unsafe-functions.md:6
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+"    let emojis = \"🗻∈🌏\";\n"
+"    unsafe {\n"
+"        // Undefined behavior if indices do not lie on UTF-8 sequence "
+"boundaries.\n"
+"        println!(\"{}\", emojis.get_unchecked(0..4));\n"
+"        println!(\"{}\", emojis.get_unchecked(4..7));\n"
+"        println!(\"{}\", emojis.get_unchecked(7..11));\n"
+"    }\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/unsafe/extern-functions.md:1
+msgid "# Calling External Code"
+msgstr ""
+
+#: src/unsafe/extern-functions.md:3
+msgid ""
+"Functions from other languages might violate the guarantees of Rust. "
+"Calling\n"
+"them is thus unsafe:"
+msgstr ""
+
+#: src/unsafe/extern-functions.md:6
+msgid ""
+"```rust,editable\n"
+"extern \"C\" {\n"
+"    fn abs(input: i32) -> i32;\n"
+"}"
+msgstr ""
+
+#: src/unsafe/extern-functions.md:11
+msgid ""
+"fn main() {\n"
+"    unsafe {\n"
+"        // Undefined behavior if abs misbehaves.\n"
+"        println!(\"Absolute value of -3 according to C: {}\", abs(-3));\n"
+"    }\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/unsafe/unions.md:1
+msgid "# Unions"
+msgstr ""
+
+#: src/unsafe/unions.md:3
+msgid "Unions are like enums, but you need to track the active field yourself:"
+msgstr ""
+
+#: src/unsafe/unions.md:5
+msgid ""
+"```rust,editable\n"
+"#[repr(C)]\n"
+"union MyUnion {\n"
+"    i: u8,\n"
+"    b: bool,\n"
+"}"
+msgstr ""
+
+#: src/unsafe/unions.md:12
+msgid ""
+"fn main() {\n"
+"    let u = MyUnion { i: 42 };\n"
+"    println!(\"int: {}\", unsafe { u.i });\n"
+"    println!(\"bool: {}\", unsafe { u.b });  // Undefined behavior!\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/exercises/day-3/afternoon.md:1
+msgid "# Day 3: Afternoon Exercises"
+msgstr ""
+
+#: src/exercises/day-3/afternoon.md:3
+msgid "Let us build a safe wrapper for reading directory content!"
+msgstr ""
+
+#: src/exercises/day-3/safe-ffi-wrapper.md:1
+msgid "# Safe FFI Wrapper"
+msgstr ""
+
+#: src/exercises/day-3/safe-ffi-wrapper.md:3
+msgid ""
+"Rust has great support for calling functions through a _foreign function\n"
+"interface_ (FFI). We will use this to build a safe wrapper the `glibc` "
+"functions\n"
+"you would use from C to read the filenames of a directory."
+msgstr ""
+
+#: src/exercises/day-3/safe-ffi-wrapper.md:7
+msgid "You will want to consult the manual pages:"
+msgstr ""
+
+#: src/exercises/day-3/safe-ffi-wrapper.md:9
+msgid ""
+"* [`opendir(3)`](https://man7.org/linux/man-pages/man3/opendir.3.html)\n"
+"* [`readdir(3)`](https://man7.org/linux/man-pages/man3/readdir.3.html)\n"
+"* [`closedir(3)`](https://man7.org/linux/man-pages/man3/closedir.3.html)"
+msgstr ""
+
+#: src/exercises/day-3/safe-ffi-wrapper.md:13
+msgid ""
+"You will also want to browse the [`std::ffi`] module, particular for "
+"[`CStr`]\n"
+"and [`CString`] types which are used to hold NUL-terminated strings coming "
+"from\n"
+"C. The [Nomicon] also has a very useful chapter about FFI."
+msgstr ""
+
+#: src/exercises/day-3/safe-ffi-wrapper.md:17
+msgid ""
+"[`std::ffi`]: https://doc.rust-lang.org/std/ffi/\n"
+"[`CStr`]: https://doc.rust-lang.org/std/ffi/struct.CStr.html\n"
+"[`CString`]: https://doc.rust-lang.org/std/ffi/struct.CString.html\n"
+"[Nomicon]: https://doc.rust-lang.org/nomicon/ffi.html"
+msgstr ""
+
+#: src/exercises/day-3/safe-ffi-wrapper.md:22
+msgid ""
+"Copy the code below to <https://play.rust-lang.org/> and fill in the "
+"missing\n"
+"functions and methods:"
+msgstr ""
+
+#: src/exercises/day-3/safe-ffi-wrapper.md:29
+msgid ""
+"mod ffi {\n"
+"    use std::os::raw::{c_char, c_int, c_long, c_ulong, c_ushort};"
+msgstr ""
+
+#: src/exercises/day-3/safe-ffi-wrapper.md:32
+#: src/exercises/day-3/solutions-afternoon.md:26
+msgid ""
+"    // Opaque type. See https://doc.rust-lang.org/nomicon/ffi.html.\n"
+"    #[repr(C)]\n"
+"    pub struct DIR {\n"
+"        _data: [u8; 0],\n"
+"        _marker: core::marker::PhantomData<(*mut u8, "
+"core::marker::PhantomPinned)>,\n"
+"    }"
+msgstr ""
+
+#: src/exercises/day-3/safe-ffi-wrapper.md:39
+#: src/exercises/day-3/solutions-afternoon.md:33
+msgid ""
+"    // Layout as per readdir(3) and definitions in "
+"/usr/include/x86_64-linux-gnu.\n"
+"    #[repr(C)]\n"
+"    pub struct dirent {\n"
+"        pub d_ino: c_long,\n"
+"        pub d_off: c_ulong,\n"
+"        pub d_reclen: c_ushort,\n"
+"        pub d_type: c_char,\n"
+"        pub d_name: [c_char; 256],\n"
+"    }"
+msgstr ""
+
+#: src/exercises/day-3/safe-ffi-wrapper.md:49
+#: src/exercises/day-3/solutions-afternoon.md:43
+msgid ""
+"    extern \"C\" {\n"
+"        pub fn opendir(s: *const c_char) -> *mut DIR;\n"
+"        pub fn readdir(s: *mut DIR) -> *const dirent;\n"
+"        pub fn closedir(s: *mut DIR) -> c_int;\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-3/safe-ffi-wrapper.md:56
+#: src/exercises/day-3/solutions-afternoon.md:50
+msgid ""
+"use std::ffi::{CStr, CString, OsStr, OsString};\n"
+"use std::os::unix::ffi::OsStrExt;"
+msgstr ""
+
+#: src/exercises/day-3/safe-ffi-wrapper.md:59
+msgid ""
+"#[derive(Debug)]\n"
+"struct DirectoryIterator {\n"
+"    path: CString,\n"
+"    dir: *mut ffi::DIR,\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-3/safe-ffi-wrapper.md:65
+msgid ""
+"impl DirectoryIterator {\n"
+"    fn new(path: &str) -> Result<DirectoryIterator, String> {\n"
+"        // Call opendir and return a Ok value if that worked,\n"
+"        // otherwise return Err with a message.\n"
+"        unimplemented!()\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-3/safe-ffi-wrapper.md:73
+msgid ""
+"impl Iterator for DirectoryIterator {\n"
+"    type Item = OsString;\n"
+"    fn next(&mut self) -> Option<OsString> {\n"
+"        // Keep calling readdir until we get a NULL pointer back.\n"
+"        unimplemented!()\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-3/safe-ffi-wrapper.md:81
+msgid ""
+"impl Drop for DirectoryIterator {\n"
+"    fn drop(&mut self) {\n"
+"        // Call closedir as needed.\n"
+"        unimplemented!()\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-3/safe-ffi-wrapper.md:88
+msgid ""
+"fn main() -> Result<(), String> {\n"
+"    let iter = DirectoryIterator::new(\".\")?;\n"
+"    println!(\"files: {:#?}\", iter.collect::<Vec<_>>());\n"
+"    Ok(())\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/welcome-day-4.md:1
+msgid "# Welcome to Day 4"
+msgstr ""
+
+#: src/welcome-day-4.md:3
+msgid "Today we will look at two main topics:"
+msgstr ""
+
+#: src/welcome-day-4.md:5
+msgid "* Concurrency: threads, channels, shared state, `Send` and `Sync`."
+msgstr ""
+
+#: src/welcome-day-4.md:7
+msgid ""
+"* Android: building binaries and libraries, using AIDL, logging, and\n"
+"  interoperability with C, C++, and Java."
+msgstr ""
+
+#: src/welcome-day-4.md:10
+msgid ""
+"> We will attempt to call Rust from one of your own projects today. So try "
+"to\n"
+"> find a little corner of your code base where we can move some lines of "
+"code to\n"
+"> Rust. The fewer dependencies and \"exotic\" types the better. Something "
+"that\n"
+"> parses some raw bytes would be ideal."
+msgstr ""
+
+#: src/concurrency.md:1
+msgid "# Fearless Concurrency"
+msgstr ""
+
+#: src/concurrency.md:3
+msgid ""
+"Rust has full support for concurrency using OS threads with mutexes and\n"
+"channels."
+msgstr ""
+
+#: src/concurrency.md:6
+msgid ""
+"The Rust type system plays an important role in making many concurrency "
+"bugs\n"
+"compile time bugs. This is often referred to as _fearless concurrency_ since "
+"you\n"
+"can rely on the compiler to ensure correctness at runtime."
+msgstr ""
+
+#: src/concurrency/threads.md:1
+msgid "# Threads"
+msgstr ""
+
+#: src/concurrency/threads.md:3
+msgid "Rust threads work similarly to threads in other languages:"
+msgstr ""
+
+#: src/concurrency/threads.md:5
+msgid ""
+"```rust,editable\n"
+"use std::thread;\n"
+"use std::time::Duration;"
+msgstr ""
+
+#: src/concurrency/threads.md:9
+msgid ""
+"fn main() {\n"
+"    thread::spawn(|| {\n"
+"        for i in 1..10 {\n"
+"            println!(\"Count in thread: {i}!\");\n"
+"            thread::sleep(Duration::from_millis(5));\n"
+"        }\n"
+"    });"
+msgstr ""
+
+#: src/concurrency/threads.md:17
+msgid ""
+"    for i in 1..5 {\n"
+"        println!(\"Main thread: {i}\");\n"
+"        thread::sleep(Duration::from_millis(5));\n"
+"    }\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/concurrency/threads.md:24
+msgid ""
+"* Threads are all daemon threads, the main thread does not wait for them.\n"
+"* Thread panics are independent of each other.\n"
+"  * Panics can carry a payload, which can be unpacked with `downcast_ref`."
+msgstr ""
+
+#: src/concurrency/threads.md:32
+msgid ""
+"* Notice that the thread is stopped before it reaches 10 — the main thread "
+"is\n"
+"  not waiting."
+msgstr ""
+
+#: src/concurrency/threads.md:35
+msgid ""
+"* Use `let handle = thread::spawn(...)` and later `handle.join()` to wait "
+"for\n"
+"  the thread to finish."
+msgstr ""
+
+#: src/concurrency/threads.md:38
+msgid "* Trigger a panic in the thread, notice how this doesn't affect `main`."
+msgstr ""
+
+#: src/concurrency/threads.md:40
+msgid ""
+"* Use the `Result` return value from `handle.join()` to get access to the "
+"panic\n"
+"  payload. This is a good time to talk about [`Any`]."
+msgstr ""
+
+#: src/concurrency/threads.md:43
+msgid "[`Any`]: https://doc.rust-lang.org/std/any/index.html"
+msgstr ""
+
+#: src/concurrency/scoped-threads.md:1
+msgid "# Scoped Threads"
+msgstr ""
+
+#: src/concurrency/scoped-threads.md:3
+msgid "Normal threads cannot borrow from their environment:"
+msgstr ""
+
+#: src/concurrency/scoped-threads.md:5
+msgid "```rust,editable,compile_fail\nuse std::thread;"
+msgstr ""
+
+#: src/concurrency/scoped-threads.md:8
+#: src/concurrency/scoped-threads.md:22
+msgid "fn main() {\n    let s = String::from(\"Hello\");"
+msgstr ""
+
+#: src/concurrency/scoped-threads.md:11
+msgid ""
+"    thread::spawn(|| {\n"
+"        println!(\"Length: {}\", s.len());\n"
+"    });\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/concurrency/scoped-threads.md:17
+msgid "However, you can use a [scoped thread][1] for this:"
+msgstr ""
+
+#: src/concurrency/scoped-threads.md:19
+msgid "```rust,editable\nuse std::thread;"
+msgstr ""
+
+#: src/concurrency/scoped-threads.md:25
+msgid ""
+"    thread::scope(|scope| {\n"
+"        scope.spawn(|| {\n"
+"            println!(\"Length: {}\", s.len());\n"
+"        });\n"
+"    });\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/concurrency/scoped-threads.md:33
+msgid "[1]: https://doc.rust-lang.org/std/thread/fn.scope.html"
+msgstr ""
+
+#: src/concurrency/channels.md:1
+msgid "# Channels"
+msgstr ""
+
+#: src/concurrency/channels.md:3
+msgid ""
+"Rust channels have two parts: a `Sender<T>` and a `Receiver<T>`. The two "
+"parts\n"
+"are connected via the channel, but you only see the end-points."
+msgstr ""
+
+#: src/concurrency/channels.md:6
+msgid ""
+"```rust,editable\n"
+"use std::sync::mpsc;\n"
+"use std::thread;"
+msgstr ""
+
+#: src/concurrency/channels.md:10
+#: src/concurrency/channels/unbounded.md:10
+msgid "fn main() {\n    let (tx, rx) = mpsc::channel();"
+msgstr ""
+
+#: src/concurrency/channels.md:13
+msgid "    tx.send(10).unwrap();\n    tx.send(20).unwrap();"
+msgstr ""
+
+#: src/concurrency/channels.md:16
+msgid ""
+"    println!(\"Received: {:?}\", rx.recv());\n"
+"    println!(\"Received: {:?}\", rx.recv());"
+msgstr ""
+
+#: src/concurrency/channels.md:19
+msgid ""
+"    let tx2 = tx.clone();\n"
+"    tx2.send(30).unwrap();\n"
+"    println!(\"Received: {:?}\", rx.recv());\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/concurrency/channels/unbounded.md:1
+msgid "# Unbounded Channels"
+msgstr ""
+
+#: src/concurrency/channels/unbounded.md:3
+msgid "You get an unbounded and asynchronous channel with `mpsc::channel()`:"
+msgstr ""
+
+#: src/concurrency/channels/unbounded.md:5
+#: src/concurrency/channels/bounded.md:5
+msgid ""
+"```rust,editable\n"
+"use std::sync::mpsc;\n"
+"use std::thread;\n"
+"use std::time::Duration;"
+msgstr ""
+
+#: src/concurrency/channels/unbounded.md:13
+#: src/concurrency/channels/bounded.md:13
+msgid ""
+"    thread::spawn(move || {\n"
+"        let thread_id = thread::current().id();\n"
+"        for i in 1..10 {\n"
+"            tx.send(format!(\"Message {i}\")).unwrap();\n"
+"            println!(\"{thread_id:?}: sent Message {i}\");\n"
+"        }\n"
+"        println!(\"{thread_id:?}: done\");\n"
+"    });\n"
+"    thread::sleep(Duration::from_millis(100));"
+msgstr ""
+
+#: src/concurrency/channels/unbounded.md:23
+#: src/concurrency/channels/bounded.md:23
+msgid ""
+"    for msg in rx.iter() {\n"
+"        println!(\"Main: got {}\", msg);\n"
+"    }\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/concurrency/channels/bounded.md:1
+msgid "# Bounded Channels"
+msgstr ""
+
+#: src/concurrency/channels/bounded.md:3
+msgid "Bounded and synchronous channels make `send` block the current thread:"
+msgstr ""
+
+#: src/concurrency/channels/bounded.md:10
+msgid "fn main() {\n    let (tx, rx) = mpsc::sync_channel(3);"
+msgstr ""
+
+#: src/concurrency/shared_state.md:1
+msgid "# Shared State"
+msgstr ""
+
+#: src/concurrency/shared_state.md:3
+msgid ""
+"Rust uses the type system to enforce synchronization of shared data. This "
+"is\n"
+"primarily done via two types:"
+msgstr ""
+
+#: src/concurrency/shared_state.md:6
+msgid ""
+"* [`Arc<T>`][1], atomic reference counted `T`: handled sharing between "
+"threads and\n"
+"  takes care to deallocate `T` when the last thread exits,\n"
+"* [`Mutex<T>`][2]: ensures mutual exclusion access to the `T` value."
+msgstr ""
+
+#: src/concurrency/shared_state.md:10
+msgid ""
+"[1]: https://doc.rust-lang.org/std/sync/struct.Arc.html\n"
+"[2]: https://doc.rust-lang.org/std/sync/struct.Mutex.html"
+msgstr ""
+
+#: src/concurrency/shared_state/arc.md:1
+msgid "# `Arc`"
+msgstr ""
+
+#: src/concurrency/shared_state/arc.md:3
+msgid "[`Arc<T>`][1] allows shared read-only access via its `clone` method:"
+msgstr ""
+
+#: src/concurrency/shared_state/arc.md:5
+msgid ""
+"```rust,editable\n"
+"use std::thread;\n"
+"use std::sync::Arc;"
+msgstr ""
+
+#: src/concurrency/shared_state/arc.md:9
+msgid ""
+"fn main() {\n"
+"    let v = Arc::new(vec![10, 20, 30]);\n"
+"    let mut handles = Vec::new();\n"
+"    for _ in 1..5 {\n"
+"        let v = v.clone();\n"
+"        handles.push(thread::spawn(move || {\n"
+"            let thread_id = thread::current().id();\n"
+"            println!(\"{thread_id:?}: {v:?}\");\n"
+"        }));\n"
+"    }"
+msgstr ""
+
+#: src/concurrency/shared_state/arc.md:20
+msgid ""
+"    handles.into_iter().for_each(|h| h.join().unwrap());\n"
+"    println!(\"v: {v:?}\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/concurrency/shared_state/arc.md:25
+msgid "[1]: https://doc.rust-lang.org/std/sync/struct.Arc.html"
+msgstr ""
+
+#: src/concurrency/shared_state/mutex.md:1
+msgid "# `Mutex`"
+msgstr ""
+
+#: src/concurrency/shared_state/mutex.md:3
+msgid ""
+"[`Mutex<T>`][1] ensures mutual exclusion _and_ allows mutable access to `T`\n"
+"behind a read-only interface:"
+msgstr ""
+
+#: src/concurrency/shared_state/mutex.md:6
+msgid "```rust,editable\nuse std::sync::Mutex;"
+msgstr ""
+
+#: src/concurrency/shared_state/mutex.md:9
+msgid ""
+"fn main() {\n"
+"    let v: Mutex<Vec<i32>> = Mutex::new(vec![10, 20, 30]);\n"
+"    println!(\"v: {:?}\", v.lock().unwrap());"
+msgstr ""
+
+#: src/concurrency/shared_state/mutex.md:13
+msgid ""
+"    {\n"
+"        let v: &Mutex<Vec<i32>> = &v;\n"
+"        let mut guard = v.lock().unwrap();\n"
+"        guard.push(40);\n"
+"    }"
+msgstr ""
+
+#: src/concurrency/shared_state/mutex.md:19
+msgid ""
+"    println!(\"v: {:?}\", v.lock().unwrap());\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/concurrency/shared_state/mutex.md:23
+msgid ""
+"Notice how we have a [`impl<T: Send> Sync for Mutex<T>`][2] blanket\n"
+"implementation."
+msgstr ""
+
+#: src/concurrency/shared_state/mutex.md:26
+msgid ""
+"[1]: https://doc.rust-lang.org/std/sync/struct.Mutex.html\n"
+"[2]: "
+"https://doc.rust-lang.org/std/sync/struct.Mutex.html#impl-Sync-for-Mutex%3CT%3E\n"
+"[3]: https://doc.rust-lang.org/std/sync/struct.Arc.html"
+msgstr ""
+
+#: src/concurrency/shared_state/example.md:3
+msgid "Let us see `Arc` and `Mutex` in action:"
+msgstr ""
+
+#: src/concurrency/shared_state/example.md:5
+msgid ""
+"```rust,editable,compile_fail\n"
+"use std::thread;\n"
+"// use std::sync::{Arc, Mutex};"
+msgstr ""
+
+#: src/concurrency/shared_state/example.md:9
+msgid ""
+"fn main() {\n"
+"    let mut v = vec![10, 20, 30];\n"
+"    let handle = thread::spawn(|| {\n"
+"        v.push(10);\n"
+"    });\n"
+"    v.push(1000);"
+msgstr ""
+
+#: src/concurrency/shared_state/example.md:16
+msgid ""
+"    handle.join().unwrap();\n"
+"    println!(\"v: {v:?}\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/concurrency/send-sync.md:1
+msgid "# `Send` and `Sync`"
+msgstr ""
+
+#: src/concurrency/send-sync.md:3
+msgid ""
+"How does Rust know to forbid shared access across thread? The answer is in "
+"two traits:"
+msgstr ""
+
+#: src/concurrency/send-sync.md:5
+msgid ""
+"* [`Send`][1]: a type `T` is `Send` if it is safe to move a `T` across a "
+"thread\n"
+"  boundary.\n"
+"* [`Sync`][2]: a type `T` is `Sync` if it is safe to move a `&T` across a "
+"thread\n"
+"  boundary."
+msgstr ""
+
+#: src/concurrency/send-sync.md:10
+msgid ""
+"[1]: https://doc.rust-lang.org/std/marker/trait.Send.html\n"
+"[2]: https://doc.rust-lang.org/std/marker/trait.Sync.html"
+msgstr ""
+
+#: src/concurrency/send-sync/send.md:1
+msgid "# `Send`"
+msgstr ""
+
+#: src/concurrency/send-sync/send.md:3
+msgid ""
+"> A type `T` is [`Send`][1] if it is safe to move a `T` value to another "
+"thread."
+msgstr ""
+
+#: src/concurrency/send-sync/send.md:5
+msgid ""
+"The effect of moving ownership to another thread is that _destructors_ will "
+"run\n"
+"in that thread. So the question is when you can allocate a value in one "
+"thread\n"
+"and deallocate it in another."
+msgstr ""
+
+#: src/concurrency/send-sync/send.md:9
+msgid "[1]: https://doc.rust-lang.org/std/marker/trait.Send.html"
+msgstr ""
+
+#: src/concurrency/send-sync/sync.md:1
+msgid "# `Sync`"
+msgstr ""
+
+#: src/concurrency/send-sync/sync.md:3
+msgid ""
+"> A type `T` is [`Sync`][1] if it is safe to access a `T` value from "
+"multiple\n"
+"> threads at the same time."
+msgstr ""
+
+#: src/concurrency/send-sync/sync.md:6
+msgid "More precisely, the definition is:"
+msgstr ""
+
+#: src/concurrency/send-sync/sync.md:8
+msgid "> `T` is `Sync` if and only if `&T` is `Send`"
+msgstr ""
+
+#: src/concurrency/send-sync/sync.md:10
+msgid "[1]: https://doc.rust-lang.org/std/marker/trait.Sync.html"
+msgstr ""
+
+#: src/concurrency/send-sync/examples.md:1
+msgid "# Examples"
+msgstr ""
+
+#: src/concurrency/send-sync/examples.md:3
+msgid "## `Send + Sync`"
+msgstr ""
+
+#: src/concurrency/send-sync/examples.md:5
+msgid "Most types you come across are `Send + Sync`:"
+msgstr ""
+
+#: src/concurrency/send-sync/examples.md:7
+msgid ""
+"* `i8`, `f32`, `bool`, `char`, `&str`, ...\n"
+"* `(T1, T2)`, `[T; N]`, `&[T]`, `struct { x: T }`, ...\n"
+"* `String`, `Option<T>`, `Vec<T>`, `Box<T>`, ...\n"
+"* `Arc<T>`: Explicitly thread-safe via atomic reference count.\n"
+"* `Mutex<T>`: Explicitly thread-safe via internal locking.\n"
+"* `AtomicBool`, `AtomicU8`, ...: Uses special atomic instructions."
+msgstr ""
+
+#: src/concurrency/send-sync/examples.md:14
+msgid ""
+"The generic types are typically `Send + Sync` when the type parameters are\n"
+"`Send + Sync`."
+msgstr ""
+
+#: src/concurrency/send-sync/examples.md:17
+msgid "## `Send + !Sync`"
+msgstr ""
+
+#: src/concurrency/send-sync/examples.md:19
+msgid ""
+"These types can be moved to other threads, but they're not thread-safe.\n"
+"Typically because of interior mutability:"
+msgstr ""
+
+#: src/concurrency/send-sync/examples.md:22
+msgid ""
+"* `mpsc::Sender<T>`\n"
+"* `mpsc::Receiver<T>`\n"
+"* `Cell<T>`\n"
+"* `RefCell<T>`"
+msgstr ""
+
+#: src/concurrency/send-sync/examples.md:27
+msgid "## `!Send + Sync`"
+msgstr ""
+
+#: src/concurrency/send-sync/examples.md:29
+msgid "These types are thread-safe, but they cannot be moved to another thread:"
+msgstr ""
+
+#: src/concurrency/send-sync/examples.md:31
+msgid ""
+"* `MutexGuard<T>`: Uses OS level primitives which must be deallocated on "
+"the\n"
+"  thread which created them."
+msgstr ""
+
+#: src/concurrency/send-sync/examples.md:34
+msgid "## `!Send + !Sync`"
+msgstr ""
+
+#: src/concurrency/send-sync/examples.md:36
+msgid "These types are not thread-safe and cannot be moved to other threads:"
+msgstr ""
+
+#: src/concurrency/send-sync/examples.md:38
+msgid ""
+"* `Rc<T>`: each `Rc<T>` has a reference to an `RcBox<T>`, which contains a\n"
+"  non-atomic reference count.\n"
+"* `*const T`, `*mut T`: Rust assumes raw pointers may have special\n"
+"  concurrency considerations."
+msgstr ""
+
+#: src/exercises/day-4/morning.md:1
+#: src/exercises/day-4/afternoon.md:1
+msgid "# Exercises"
+msgstr ""
+
+#: src/exercises/day-4/morning.md:3
+msgid "Let us practice our new concurrency skills with"
+msgstr ""
+
+#: src/exercises/day-4/morning.md:5
+msgid "* Dining philosophers: a classic problem in concurrency."
+msgstr ""
+
+#: src/exercises/day-4/morning.md:7
+msgid ""
+"* Multi-threaded link checker: a larger project where you'll use Cargo to\n"
+"  download dependencies and then check links in parallel."
+msgstr ""
+
+#: src/exercises/day-4/dining-philosophers.md:1
+msgid "# Dining Philosophers"
+msgstr ""
+
+#: src/exercises/day-4/dining-philosophers.md:3
+msgid "The dining philosophers problem is a classic problem in concurrency:"
+msgstr ""
+
+#: src/exercises/day-4/dining-philosophers.md:5
+msgid ""
+"> Five philosophers dine together at the same table. Each philosopher has "
+"their\n"
+"> own place at the table. There is a fork between each plate. The dish "
+"served is\n"
+"> a kind of spaghetti which has to be eaten with two forks. Each philosopher "
+"can\n"
+"> only alternately think and eat. Moreover, a philosopher can only eat "
+"their\n"
+"> spaghetti when they have both a left and right fork. Thus two forks will "
+"only\n"
+"> be available when their two nearest neighbors are thinking, not eating. "
+"After\n"
+"> an individual philosopher finishes eating, they will put down both forks."
+msgstr ""
+
+#: src/exercises/day-4/dining-philosophers.md:13
+msgid ""
+"You will need a local [Cargo installation](../../cargo/running-locally.md) "
+"for\n"
+"this exercise. Copy the code below to `src/main.rs` file, fill out the "
+"blanks,\n"
+"and test that `cargo run` does not deadlock:"
+msgstr ""
+
+#: src/exercises/day-4/dining-philosophers.md:17
+msgid ""
+"```rust,compile_fail\n"
+"use std::sync::mpsc;\n"
+"use std::sync::{Arc, Mutex};\n"
+"use std::thread;\n"
+"use std::time::Duration;"
+msgstr ""
+
+#: src/exercises/day-4/dining-philosophers.md:23
+#: src/exercises/day-4/solutions-morning.md:28
+msgid "struct Fork;"
+msgstr ""
+
+#: src/exercises/day-4/dining-philosophers.md:25
+msgid ""
+"struct Philosopher {\n"
+"    name: String,\n"
+"    // left_fork: ...\n"
+"    // right_fork: ...\n"
+"    // thoughts: ...\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-4/dining-philosophers.md:32
+msgid ""
+"impl Philosopher {\n"
+"    fn think(&self) {\n"
+"        self.thoughts\n"
+"            .send(format!(\"Eureka! {} has a new idea!\", &self.name))\n"
+"            .unwrap();\n"
+"    }"
+msgstr ""
+
+#: src/exercises/day-4/dining-philosophers.md:39
+msgid ""
+"    fn eat(&self) {\n"
+"        // Pick up forks...\n"
+"        println!(\"{} is eating...\", &self.name);\n"
+"        thread::sleep(Duration::from_millis(10));\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-4/dining-philosophers.md:46
+#: src/exercises/day-4/solutions-morning.md:60
+msgid ""
+"static PHILOSOPHERS: &[&str] =\n"
+"    &[\"Socrates\", \"Plato\", \"Aristotle\", \"Thales\", \"Pythagoras\"];"
+msgstr ""
+
+#: src/exercises/day-4/dining-philosophers.md:49
+msgid "fn main() {\n    // Create forks"
+msgstr ""
+
+#: src/exercises/day-4/dining-philosophers.md:52
+msgid "    // Create philosophers"
+msgstr ""
+
+#: src/exercises/day-4/dining-philosophers.md:54
+msgid "    // Make them think and eat"
+msgstr ""
+
+#: src/exercises/day-4/dining-philosophers.md:56
+msgid ""
+"    // Output their thoughts\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/exercises/day-4/link-checker.md:1
+msgid "# Multi-threaded Link Checker"
+msgstr ""
+
+#: src/exercises/day-4/link-checker.md:3
+msgid ""
+"Let us use our new knowledge to create a multi-threaded link checker. It "
+"should\n"
+"start at a webpage and check that links on the page are valid. It should\n"
+"recursively check other pages on the same domain and keep doing this until "
+"all\n"
+"pages have been validated."
+msgstr ""
+
+#: src/exercises/day-4/link-checker.md:8
+msgid ""
+"For this, you will need an HTTP client such as [`reqwest`][1]. Create a new\n"
+"Cargo project and `reqwest` it as a dependency with:"
+msgstr ""
+
+#: src/exercises/day-4/link-checker.md:11
+msgid ""
+"```shell\n"
+"$ cargo new link-checker\n"
+"$ cd link-checker\n"
+"$ cargo add --features blocking,rustls-tls reqwest\n"
+"```"
+msgstr ""
+
+#: src/exercises/day-4/link-checker.md:17
+msgid ""
+"> If `cargo add` fails with `error: no such subcommand`, then please edit "
+"the\n"
+"> `Cargo.toml` file by hand. Add the dependencies listed below."
+msgstr ""
+
+#: src/exercises/day-4/link-checker.md:20
+msgid ""
+"You will also need a way to find links. We can use [`scraper`][2] for that:"
+msgstr ""
+
+#: src/exercises/day-4/link-checker.md:22
+msgid ""
+"```shell\n"
+"$ cargo add scraper\n"
+"```"
+msgstr ""
+
+#: src/exercises/day-4/link-checker.md:26
+msgid ""
+"Finally, we'll need some way of handling errors. We [`thiserror`][3] for "
+"that:"
+msgstr ""
+
+#: src/exercises/day-4/link-checker.md:28
+msgid ""
+"```shell\n"
+"$ cargo add thiserror\n"
+"```"
+msgstr ""
+
+#: src/exercises/day-4/link-checker.md:32
+msgid ""
+"The `cargo add` calls will update the `Cargo.toml` file to look like this:"
+msgstr ""
+
+#: src/exercises/day-4/link-checker.md:34
+msgid ""
+"```toml\n"
+"[dependencies]\n"
+"reqwest = { version = \"0.11.12\", features = [\"blocking\", \"rustls-tls\"] "
+"}\n"
+"scraper = \"0.13.0\"\n"
+"thiserror = \"1.0.37\"\n"
+"```"
+msgstr ""
+
+#: src/exercises/day-4/link-checker.md:41
+msgid ""
+"You can now download the start page. Try with a small site such as\n"
+"`https://www.google.org/`."
+msgstr ""
+
+#: src/exercises/day-4/link-checker.md:44
+msgid "Your `src/main.rs` file should look something like this:"
+msgstr ""
+
+#: src/exercises/day-4/link-checker.md:46
+msgid ""
+"```rust,compile_fail\n"
+"use reqwest::blocking::{get, Response};\n"
+"use reqwest::Url;\n"
+"use scraper::{Html, Selector};\n"
+"use thiserror::Error;"
+msgstr ""
+
+#: src/exercises/day-4/link-checker.md:52
+msgid ""
+"#[derive(Error, Debug)]\n"
+"enum Error {\n"
+"    #[error(\"request error: {0}\")]\n"
+"    ReqwestError(#[from] reqwest::Error),\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-4/link-checker.md:58
+msgid ""
+"fn extract_links(response: Response) -> Result<Vec<Url>, Error> {\n"
+"    let base_url = response.url().to_owned();\n"
+"    let document = response.text()?;\n"
+"    let html = Html::parse_document(&document);\n"
+"    let selector = Selector::parse(\"a\").unwrap();"
+msgstr ""
+
+#: src/exercises/day-4/link-checker.md:64
+msgid ""
+"    let mut valid_urls = Vec::new();\n"
+"    for element in html.select(&selector) {\n"
+"        if let Some(href) = element.value().attr(\"href\") {\n"
+"            match base_url.join(href) {\n"
+"                Ok(url) => valid_urls.push(url),\n"
+"                Err(err) => {\n"
+"                    println!(\"On {base_url}: could not parse {href:?}: "
+"{err} (ignored)\",);\n"
+"                }\n"
+"            }\n"
+"        }\n"
+"    }"
+msgstr ""
+
+#: src/exercises/day-4/link-checker.md:76
+msgid "    Ok(valid_urls)\n}"
+msgstr ""
+
+#: src/exercises/day-4/link-checker.md:79
+msgid ""
+"fn main() {\n"
+"    let start_url = Url::parse(\"https://www.google.org\").unwrap();\n"
+"    let response = get(start_url).unwrap();\n"
+"    match extract_links(response) {\n"
+"        Ok(links) => println!(\"Links: {links:#?}\"),\n"
+"        Err(err) => println!(\"Could not extract links: {err:#}\"),\n"
+"    }\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/exercises/day-4/link-checker.md:89
+msgid "Run the code in `src/main.rs` with"
+msgstr ""
+
+#: src/exercises/day-4/link-checker.md:91
+msgid ""
+"```shell\n"
+"$ cargo run\n"
+"```"
+msgstr ""
+
+#: src/exercises/day-4/link-checker.md:95
+msgid "## Tasks"
+msgstr ""
+
+#: src/exercises/day-4/link-checker.md:97
+msgid ""
+"* Use threads to check the links in parallel: send the URLs to be checked to "
+"a\n"
+"  channel and let a few threads check the URLs in parallel.\n"
+"* Extend this to recursively extract links from all pages on the\n"
+"  `www.google.org` domain. Put an upper limit of 100 pages or so so that "
+"you\n"
+"  don't end up being blocked by the site."
+msgstr ""
+
+#: src/exercises/day-4/link-checker.md:103
+msgid ""
+"[1]: https://docs.rs/reqwest/\n"
+"[2]: https://docs.rs/scraper/\n"
+"[3]: https://docs.rs/thiserror/"
+msgstr ""
+
+#: src/android.md:1
+msgid "# Android"
+msgstr ""
+
+#: src/android.md:3
+msgid ""
+"Rust is supported for native platform development on Android. This means "
+"that\n"
+"you can write new operating system services in Rust, as well as extending\n"
+"existing services."
+msgstr ""
+
+#: src/android/setup.md:1
+msgid "# Setup"
+msgstr ""
+
+#: src/android/setup.md:3
+msgid ""
+"We will be using an Android Virtual Device to test our code. Make sure you "
+"have\n"
+"access to one or create a new one with:"
+msgstr ""
+
+#: src/android/setup.md:6
+msgid ""
+"```shell\n"
+"$ source build/envsetup.sh\n"
+"$ lunch aosp_cf_x86_64_phone-userdebug\n"
+"$ acloud create\n"
+"```"
+msgstr ""
+
+#: src/android/setup.md:12
+msgid ""
+"Please see the [Android Developer\n"
+"Codelab](https://source.android.com/docs/setup/start) for details."
+msgstr ""
+
+#: src/android/build-rules.md:1
+msgid "# Build Rules"
+msgstr ""
+
+#: src/android/build-rules.md:3
+msgid "The Android build system (Soong) supports Rust via a number of modules:"
+msgstr ""
+
+#: src/android/build-rules.md:5
+msgid ""
+"| Module Type       | Description                                            "
+"                                            |\n"
+"|-------------------|----------------------------------------------------------------------------------------------------|\n"
+"| `rust_binary`     | Produces a Rust binary.                                "
+"                                            |\n"
+"| `rust_library`    | Produces a Rust library, and provides both `rlib` and "
+"`dylib` variants.                            |\n"
+"| `rust_ffi`        | Produces a Rust C library usable by `cc` modules, and "
+"provides both static and shared variants.    |\n"
+"| `rust_proc_macro` | Produces a `proc-macro` Rust library. These are "
+"analogous to compiler plugins.                     |\n"
+"| `rust_test`       | Produces a Rust test binary that uses the standard "
+"Rust test harness.                              |\n"
+"| `rust_fuzz`       | Produces a Rust fuzz binary leveraging `libfuzzer`.    "
+"                                            |\n"
+"| `rust_protobuf`   | Generates source and produces a Rust library that "
+"provides an interface for a particular protobuf. |\n"
+"| `rust_bindgen`    | Generates source and produces a Rust library "
+"containing Rust bindings to C libraries.              |"
+msgstr ""
+
+#: src/android/build-rules.md:16
+msgid "We will look at `rust_binary` and `rust_library` next."
+msgstr ""
+
+#: src/android/build-rules/binary.md:1
+msgid "# Rust Binaries"
+msgstr ""
+
+#: src/android/build-rules/binary.md:3
+msgid ""
+"Let us start with a simple application. At the root of an AOSP checkout, "
+"create\n"
+"the following files:"
+msgstr ""
+
+#: src/android/build-rules/binary.md:6
+#: src/android/build-rules/library.md:13
+msgid "_hello_rust/Android.bp_:"
+msgstr ""
+
+#: src/android/build-rules/binary.md:8
+msgid ""
+"```javascript\n"
+"rust_binary {\n"
+"    name: \"hello_rust\",\n"
+"    crate_name: \"hello_rust\",\n"
+"    srcs: [\"src/main.rs\"],\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/android/build-rules/binary.md:16
+#: src/android/build-rules/library.md:34
+msgid "_hello_rust/src/main.rs_:"
+msgstr ""
+
+#: src/android/build-rules/binary.md:18
+msgid "```rust\n//! Rust demo."
+msgstr ""
+
+#: src/android/build-rules/binary.md:21
+msgid ""
+"/// Prints a greeting to standard output.\n"
+"fn main() {\n"
+"    println!(\"Hello from Rust!\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/android/build-rules/binary.md:27
+msgid "You can now build, push, and run the binary:"
+msgstr ""
+
+#: src/android/build-rules/binary.md:29
+msgid ""
+"```shell\n"
+"$ m hello_rust\n"
+"$ adb push $ANDROID_PRODUCT_OUT/system/bin/hello_rust /data/local/tmp\n"
+"$ adb shell /data/local/tmp/hello_rust\n"
+"Hello from Rust!\n"
+"```"
+msgstr ""
+
+#: src/android/build-rules/library.md:1
+msgid "# Rust Libraries"
+msgstr ""
+
+#: src/android/build-rules/library.md:3
+msgid "You use `rust_library` to create a new Rust library for Android."
+msgstr ""
+
+#: src/android/build-rules/library.md:5
+msgid "Here we declare a dependency on two libraries:"
+msgstr ""
+
+#: src/android/build-rules/library.md:7
+msgid ""
+"* `libgreeting`, which we define below,\n"
+"* `libtextwrap`, which is a crate already vendored in\n"
+"  [`external/rust/crates/`][crates]."
+msgstr ""
+
+#: src/android/build-rules/library.md:11
+msgid ""
+"[crates]: "
+"https://cs.android.com/android/platform/superproject/+/master:external/rust/crates/"
+msgstr ""
+
+#: src/android/build-rules/library.md:15
+msgid ""
+"```javascript\n"
+"rust_binary {\n"
+"    name: \"hello_rust_with_dep\",\n"
+"    crate_name: \"hello_rust_with_dep\",\n"
+"    srcs: [\"src/main.rs\"],\n"
+"    rustlibs: [\n"
+"        \"libgreetings\",\n"
+"        \"libtextwrap\",\n"
+"    ],\n"
+"    prefer_rlib: true,\n"
+"}"
+msgstr ""
+
+#: src/android/build-rules/library.md:27
+msgid ""
+"rust_library {\n"
+"    name: \"libgreetings\",\n"
+"    crate_name: \"greetings\",\n"
+"    srcs: [\"src/lib.rs\"],\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/android/build-rules/library.md:36
+msgid "```rust,ignore\n//! Rust demo."
+msgstr ""
+
+#: src/android/build-rules/library.md:39
+msgid "use greetings::greeting;\nuse textwrap::fill;"
+msgstr ""
+
+#: src/android/build-rules/library.md:42
+msgid ""
+"/// Prints a greeting to standard output.\n"
+"fn main() {\n"
+"    println!(\"{}\", fill(&greeting(\"Bob\"), 24));\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/android/build-rules/library.md:48
+msgid "_hello_rust/src/lib.rs_:"
+msgstr ""
+
+#: src/android/build-rules/library.md:50
+msgid "```rust,ignore\n//! Greeting library."
+msgstr ""
+
+#: src/android/build-rules/library.md:53
+msgid ""
+"/// Greet `name`.\n"
+"pub fn greeting(name: &str) -> String {\n"
+"    format!(\"Hello {name}, it is very nice to meet you!\")\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/android/build-rules/library.md:59
+msgid "You build, push, and run the binary like before:"
+msgstr ""
+
+#: src/android/build-rules/library.md:61
+msgid ""
+"```shell\n"
+"$ m hello_rust_with_dep\n"
+"$ adb push $ANDROID_PRODUCT_OUT/system/bin/hello_rust_with_dep "
+"/data/local/tmp\n"
+"$ adb shell /data/local/tmp/hello_rust_with_dep\n"
+"Hello Bob, it is very\n"
+"nice to meet you!\n"
+"```"
+msgstr ""
+
+#: src/android/aidl.md:1
+msgid "# AIDL"
+msgstr ""
+
+#: src/android/aidl.md:3
+msgid ""
+"The [Android Interface Definition Language\n"
+"(AIDL)](https://developer.android.com/guide/components/aidl) is supported in "
+"Rust:"
+msgstr ""
+
+#: src/android/aidl.md:6
+msgid ""
+"* Rust code can call existing AIDL servers,\n"
+"* You can create new AIDL servers in Rust."
+msgstr ""
+
+#: src/android/aidl/interface.md:1
+msgid "# AIDL Interfaces"
+msgstr ""
+
+#: src/android/aidl/interface.md:3
+msgid "You declare the API of your service using an AIDL interface:"
+msgstr ""
+
+#: src/android/aidl/interface.md:5
+msgid ""
+"*birthday_service/aidl/com/example/birthdayservice/IBirthdayService.aidl*:"
+msgstr ""
+
+#: src/android/aidl/interface.md:7
+#: src/android/aidl/changing.md:6
+msgid "```java\npackage com.example.birthdayservice;"
+msgstr ""
+
+#: src/android/aidl/interface.md:10
+msgid ""
+"/** Birthday service interface. */\n"
+"interface IBirthdayService {\n"
+"    /** Generate a Happy Birthday message. */\n"
+"    String wishHappyBirthday(String name, int years);\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/android/aidl/interface.md:17
+msgid "*birthday_service/aidl/Android.bp*:"
+msgstr ""
+
+#: src/android/aidl/interface.md:19
+msgid ""
+"```javascript\n"
+"aidl_interface {\n"
+"    name: \"com.example.birthdayservice\",\n"
+"    srcs: [\"com/example/birthdayservice/*.aidl\"],\n"
+"    unstable: true,\n"
+"    backend: {\n"
+"        rust: { // Rust is not enabled by default\n"
+"            enabled: true,\n"
+"        },\n"
+"    },\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/android/aidl/interface.md:32
+msgid ""
+"Add `vendor_available: true` if your AIDL file is used by a binary in the "
+"vendor\n"
+"partition."
+msgstr ""
+
+#: src/android/aidl/implementation.md:1
+msgid "# Service Implementation"
+msgstr ""
+
+#: src/android/aidl/implementation.md:3
+msgid "We can now implement the AIDL service:"
+msgstr ""
+
+#: src/android/aidl/implementation.md:5
+msgid "*birthday_service/src/lib.rs*:"
+msgstr ""
+
+#: src/android/aidl/implementation.md:7
+msgid ""
+"```rust,ignore\n"
+"//! Implementation of the `IBirthdayService` AIDL interface.\n"
+"use "
+"com_example_birthdayservice::aidl::com::example::birthdayservice::IBirthdayService::IBirthdayService;\n"
+"use com_example_birthdayservice::binder;"
+msgstr ""
+
+#: src/android/aidl/implementation.md:12
+msgid "/// The `IBirthdayService` implementation.\npub struct BirthdayService;"
+msgstr ""
+
+#: src/android/aidl/implementation.md:15
+msgid "impl binder::Interface for BirthdayService {}"
+msgstr ""
+
+#: src/android/aidl/implementation.md:17
+msgid ""
+"impl IBirthdayService for BirthdayService {\n"
+"    fn wishHappyBirthday(&self, name: &str, years: i32) -> "
+"binder::Result<String> {\n"
+"        Ok(format!(\n"
+"            \"Happy Birthday {name}, congratulations with the {years} "
+"years!\"\n"
+"        ))\n"
+"    }\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/android/aidl/implementation.md:26
+#: src/android/aidl/server.md:28
+#: src/android/aidl/client.md:37
+msgid "*birthday_service/Android.bp*:"
+msgstr ""
+
+#: src/android/aidl/implementation.md:28
+msgid ""
+"```javascript\n"
+"rust_library {\n"
+"    name: \"libbirthdayservice\",\n"
+"    srcs: [\"src/lib.rs\"],\n"
+"    crate_name: \"birthdayservice\",\n"
+"    rustlibs: [\n"
+"        \"com.example.birthdayservice-rust\",\n"
+"        \"libbinder_rs\",\n"
+"    ],\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/android/aidl/server.md:1
+msgid "# AIDL Server"
+msgstr ""
+
+#: src/android/aidl/server.md:3
+msgid "Finally, we can create a server which exposes the service:"
+msgstr ""
+
+#: src/android/aidl/server.md:5
+msgid "*birthday_service/src/server.rs*:"
+msgstr ""
+
+#: src/android/aidl/server.md:7
+msgid ""
+"```rust,ignore\n"
+"//! Birthday service.\n"
+"use birthdayservice::BirthdayService;\n"
+"use "
+"com_example_birthdayservice::aidl::com::example::birthdayservice::IBirthdayService::BnBirthdayService;\n"
+"use com_example_birthdayservice::binder;"
+msgstr ""
+
+#: src/android/aidl/server.md:13
+#: src/android/aidl/client.md:12
+msgid "const SERVICE_IDENTIFIER: &str = \"birthdayservice\";"
+msgstr ""
+
+#: src/android/aidl/server.md:15
+msgid ""
+"/// Entry point for birthday service.\n"
+"fn main() {\n"
+"    let birthday_service = BirthdayService;\n"
+"    let birthday_service_binder = BnBirthdayService::new_binder(\n"
+"        birthday_service,\n"
+"        binder::BinderFeatures::default(),\n"
+"    );\n"
+"    binder::add_service(SERVICE_IDENTIFIER, "
+"birthday_service_binder.as_binder())\n"
+"        .expect(\"Failed to register service\");\n"
+"    binder::ProcessState::join_thread_pool()\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/android/aidl/server.md:30
+msgid ""
+"```javascript\n"
+"rust_binary {\n"
+"    name: \"birthday_server\",\n"
+"    crate_name: \"birthday_server\",\n"
+"    srcs: [\"src/server.rs\"],\n"
+"    rustlibs: [\n"
+"        \"com.example.birthdayservice-rust\",\n"
+"        \"libbinder_rs\",\n"
+"        \"libbirthdayservice\",\n"
+"    ],\n"
+"    prefer_rlib: true,\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/android/aidl/deploy.md:1
+msgid "# Deploy"
+msgstr ""
+
+#: src/android/aidl/deploy.md:3
+msgid "We can now build, push, and start the service:"
+msgstr ""
+
+#: src/android/aidl/deploy.md:5
+msgid ""
+"```shell\n"
+"$ m birthday_server\n"
+"$ adb push $ANDROID_PRODUCT_OUT/system/bin/birthday_server /data/local/tmp\n"
+"$ adb shell /data/local/tmp/birthday_server\n"
+"```"
+msgstr ""
+
+#: src/android/aidl/deploy.md:11
+msgid "In another terminal, check that the service runs:"
+msgstr ""
+
+#: src/android/aidl/deploy.md:13
+msgid ""
+"```shell\n"
+"$ adb shell service check birthdayservice\n"
+"Service birthdayservice: found\n"
+"```"
+msgstr ""
+
+#: src/android/aidl/deploy.md:18
+msgid "You can also call the service with `service call`:"
+msgstr ""
+
+#: src/android/aidl/deploy.md:20
+msgid ""
+"```shell\n"
+"$ $ adb shell service call birthdayservice 1 s16 Bob i32 24\n"
+"Result: Parcel(\n"
+"  0x00000000: 00000000 00000036 00610048 00700070 '....6...H.a.p.p.'\n"
+"  0x00000010: 00200079 00690042 00740072 00640068 'y. .B.i.r.t.h.d.'\n"
+"  0x00000020: 00790061 00420020 0062006f 0020002c 'a.y. .B.o.b.,. .'\n"
+"  0x00000030: 006f0063 0067006e 00610072 00750074 'c.o.n.g.r.a.t.u.'\n"
+"  0x00000040: 0061006c 00690074 006e006f 00200073 'l.a.t.i.o.n.s. .'\n"
+"  0x00000050: 00690077 00680074 00740020 00650068 'w.i.t.h. .t.h.e.'\n"
+"  0x00000060: 00320020 00200034 00650079 00720061 ' .2.4. .y.e.a.r.'\n"
+"  0x00000070: 00210073 00000000                   's.!.....        ')\n"
+"```"
+msgstr ""
+
+#: src/android/aidl/client.md:1
+msgid "# AIDL Client"
+msgstr ""
+
+#: src/android/aidl/client.md:3
+msgid "Finally, we can create a Rust client for our new service."
+msgstr ""
+
+#: src/android/aidl/client.md:5
+msgid "*birthday_service/src/client.rs*:"
+msgstr ""
+
+#: src/android/aidl/client.md:7
+msgid ""
+"```rust,ignore\n"
+"//! Birthday service.\n"
+"use "
+"com_example_birthdayservice::aidl::com::example::birthdayservice::IBirthdayService::IBirthdayService;\n"
+"use com_example_birthdayservice::binder;"
+msgstr ""
+
+#: src/android/aidl/client.md:14
+msgid ""
+"/// Connect to the BirthdayService.\n"
+"pub fn connect() -> Result<binder::Strong<dyn IBirthdayService>, "
+"binder::StatusCode> {\n"
+"    binder::get_interface(SERVICE_IDENTIFIER)\n"
+"}"
+msgstr ""
+
+#: src/android/aidl/client.md:19
+msgid ""
+"/// Call the birthday service.\n"
+"fn main() -> Result<(), binder::Status> {\n"
+"    let name = std::env::args()\n"
+"        .nth(1)\n"
+"        .unwrap_or_else(|| String::from(\"Bob\"));\n"
+"    let years = std::env::args()\n"
+"        .nth(2)\n"
+"        .and_then(|arg| arg.parse::<i32>().ok())\n"
+"        .unwrap_or(42);"
+msgstr ""
+
+#: src/android/aidl/client.md:29
+msgid ""
+"    binder::ProcessState::start_thread_pool();\n"
+"    let service = connect().expect(\"Failed to connect to "
+"BirthdayService\");\n"
+"    let msg = service.wishHappyBirthday(&name, years)?;\n"
+"    println!(\"{msg}\");\n"
+"    Ok(())\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/android/aidl/client.md:39
+msgid ""
+"```javascript\n"
+"rust_binary {\n"
+"    name: \"birthday_client\",\n"
+"    crate_name: \"birthday_client\",\n"
+"    srcs: [\"src/client.rs\"],\n"
+"    rustlibs: [\n"
+"        \"com.example.birthdayservice-rust\",\n"
+"        \"libbinder_rs\",\n"
+"    ],\n"
+"    prefer_rlib: true,\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/android/aidl/client.md:52
+msgid "Notice that the client does not depend on `libbirthdayservice`."
+msgstr ""
+
+#: src/android/aidl/client.md:54
+msgid "Build, push, and run the client on your device:"
+msgstr ""
+
+#: src/android/aidl/client.md:56
+msgid ""
+"```shell\n"
+"$ m birthday_client\n"
+"$ adb push $ANDROID_PRODUCT_OUT/system/bin/birthday_client /data/local/tmp\n"
+"$ adb shell /data/local/tmp/birthday_client Charlie 60\n"
+"Happy Birthday Charlie, congratulations with the 60 years!\n"
+"```"
+msgstr ""
+
+#: src/android/aidl/changing.md:1
+msgid "# Changing API"
+msgstr ""
+
+#: src/android/aidl/changing.md:3
+msgid ""
+"Let us extend the API with more functionality: we want to let clients "
+"specify a\n"
+"list of lines for the birthday card:"
+msgstr ""
+
+#: src/android/aidl/changing.md:9
+msgid ""
+"/** Birthday service interface. */\n"
+"interface IBirthdayService {\n"
+"    /** Generate a Happy Birthday message. */\n"
+"    String wishHappyBirthday(String name, int years, in String[] text);\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/android/logging.md:1
+msgid "# Logging"
+msgstr ""
+
+#: src/android/logging.md:3
+msgid ""
+"You should use the `log` crate to automatically log to `logcat` (on-device) "
+"or\n"
+"`stdout` (on-host):"
+msgstr ""
+
+#: src/android/logging.md:6
+msgid "_hello_rust_logs/Android.bp_:"
+msgstr ""
+
+#: src/android/logging.md:8
+msgid ""
+"```javascript\n"
+"rust_binary {\n"
+"    name: \"hello_rust_logs\",\n"
+"    crate_name: \"hello_rust_logs\",\n"
+"    srcs: [\"src/main.rs\"],\n"
+"    rustlibs: [\n"
+"        \"liblog_rust\",\n"
+"        \"liblogger\",\n"
+"    ],\n"
+"    prefer_rlib: true,\n"
+"    host_supported: true,\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/android/logging.md:22
+msgid "_hello_rust_logs/src/main.rs_:"
+msgstr ""
+
+#: src/android/logging.md:24
+msgid "```rust,ignore\n//! Rust logging demo."
+msgstr ""
+
+#: src/android/logging.md:27
+msgid "use log::{debug, error};"
+msgstr ""
+
+#: src/android/logging.md:29
+msgid ""
+"/// Logs a greeting.\n"
+"fn main() {\n"
+"    logger::init(\n"
+"        logger::Config::default()\n"
+"            .with_tag_on_device(\"rust\")\n"
+"            .with_min_level(log::Level::Trace),\n"
+"    );\n"
+"    debug!(\"Starting program.\");\n"
+"    error!(\"Something went wrong!\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/android/logging.md:41
+#: src/android/interoperability/with-c/bindgen.md:98
+#: src/android/interoperability/with-c/rust.md:73
+msgid "Build, push, and run the binary on your device:"
+msgstr ""
+
+#: src/android/logging.md:43
+msgid ""
+"```shell\n"
+"$ m hello_rust_logs\n"
+"$ adb push $ANDROID_PRODUCT_OUT/system/bin/hello_rust_logs /data/local/tmp\n"
+"$ adb shell /data/local/tmp/hello_rust_logs\n"
+"```"
+msgstr ""
+
+#: src/android/logging.md:49
+msgid "The logs show up in `adb logcat`:"
+msgstr ""
+
+#: src/android/logging.md:51
+msgid ""
+"```shell\n"
+"$ adb logcat -s rust\n"
+"09-08 08:38:32.454  2420  2420 D rust: hello_rust_logs: Starting program.\n"
+"09-08 08:38:32.454  2420  2420 I rust: hello_rust_logs: Things are going "
+"fine.\n"
+"09-08 08:38:32.454  2420  2420 E rust: hello_rust_logs: Something went "
+"wrong!\n"
+"```"
+msgstr ""
+
+#: src/android/interoperability.md:1
+msgid "# Interoperability"
+msgstr ""
+
+#: src/android/interoperability.md:3
+msgid ""
+"Rust has excellent support for interoperability with other languages. This "
+"means\n"
+"that you can:"
+msgstr ""
+
+#: src/android/interoperability.md:6
+msgid ""
+"* Call Rust functions from other languages.\n"
+"* Call functions written in other languages from Rust."
+msgstr ""
+
+#: src/android/interoperability.md:9
+msgid ""
+"When you call functions in a foreign language we say that you're using a\n"
+"_foreign function interface_, also known as FFI."
+msgstr ""
+
+#: src/android/interoperability/with-c.md:1
+msgid "# Interoperability with C"
+msgstr ""
+
+#: src/android/interoperability/with-c.md:3
+msgid ""
+"Rust has full support for linking object files with a C calling convention.\n"
+"Similarly, you can export Rust functions and call them from C."
+msgstr ""
+
+#: src/android/interoperability/with-c.md:6
+msgid "You can do it by hand if you want:"
+msgstr ""
+
+#: src/android/interoperability/with-c.md:8
+msgid ""
+"```rust\n"
+"extern \"C\" {\n"
+"    fn abs(x: i32) -> i32;\n"
+"}"
+msgstr ""
+
+#: src/android/interoperability/with-c.md:13
+msgid ""
+"fn main() {\n"
+"    let x = -42;\n"
+"    let abs_x = unsafe { abs(x) };\n"
+"    println!(\"{x}, {abs_x}\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/android/interoperability/with-c.md:20
+msgid ""
+"We already saw this in the [Safe FFI Wrapper\n"
+"exercise](../../exercises/day-3/safe-ffi-wrapper.md)."
+msgstr ""
+
+#: src/android/interoperability/with-c.md:23
+msgid ""
+"> This assumes full knowledge of the target platform. Not recommended for\n"
+"> production."
+msgstr ""
+
+#: src/android/interoperability/with-c.md:26
+msgid "We will look at better options next."
+msgstr ""
+
+#: src/android/interoperability/with-c/bindgen.md:1
+msgid "# Using Bindgen"
+msgstr ""
+
+#: src/android/interoperability/with-c/bindgen.md:3
+msgid ""
+"The [bindgen](https://rust-lang.github.io/rust-bindgen/introduction.html) "
+"tool\n"
+"can auto-generate bindings from a C header file."
+msgstr ""
+
+#: src/android/interoperability/with-c/bindgen.md:6
+msgid "First create a small C library:"
+msgstr ""
+
+#: src/android/interoperability/with-c/bindgen.md:8
+msgid "_interoperability/bindgen/libbirthday.h_:"
+msgstr ""
+
+#: src/android/interoperability/with-c/bindgen.md:10
+msgid ""
+"```c\n"
+"typedef struct card {\n"
+"  const char* name;\n"
+"  int years;\n"
+"} card;"
+msgstr ""
+
+#: src/android/interoperability/with-c/bindgen.md:16
+msgid "void print_card(const card* card);\n```"
+msgstr ""
+
+#: src/android/interoperability/with-c/bindgen.md:19
+msgid "_interoperability/bindgen/libbirthday.c_:"
+msgstr ""
+
+#: src/android/interoperability/with-c/bindgen.md:21
+msgid ""
+"```c\n"
+"#include <stdio.h>\n"
+"#include \"libbirthday.h\""
+msgstr ""
+
+#: src/android/interoperability/with-c/bindgen.md:25
+msgid ""
+"void print_card(const card* card) {\n"
+"  printf(\"+--------------\\n"
+"\");\n"
+"  printf(\"| Happy Birthday %s!\\n"
+"\", card->name);\n"
+"  printf(\"| Congratulations with the %i years!\\n"
+"\", card->years);\n"
+"  printf(\"+--------------\\n"
+"\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/android/interoperability/with-c/bindgen.md:33
+msgid "Add this to your `Android.bp` file:"
+msgstr ""
+
+#: src/android/interoperability/with-c/bindgen.md:35
+#: src/android/interoperability/with-c/bindgen.md:55
+#: src/android/interoperability/with-c/bindgen.md:69
+#: src/android/interoperability/with-c/bindgen.md:108
+msgid "_interoperability/bindgen/Android.bp_:"
+msgstr ""
+
+#: src/android/interoperability/with-c/bindgen.md:37
+msgid ""
+"```javascript\n"
+"cc_library {\n"
+"    name: \"libbirthday\",\n"
+"    srcs: [\"libbirthday.c\"],\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/android/interoperability/with-c/bindgen.md:44
+msgid ""
+"Create a wrapper header file for the library (not strictly needed in this\n"
+"example):"
+msgstr ""
+
+#: src/android/interoperability/with-c/bindgen.md:47
+msgid "_interoperability/bindgen/libbirthday_wrapper.h_:"
+msgstr ""
+
+#: src/android/interoperability/with-c/bindgen.md:49
+msgid ""
+"```c\n"
+"#include \"libbirthday.h\"\n"
+"```"
+msgstr ""
+
+#: src/android/interoperability/with-c/bindgen.md:53
+msgid "You can now auto-generate the bindings:"
+msgstr ""
+
+#: src/android/interoperability/with-c/bindgen.md:57
+msgid ""
+"```javascript\n"
+"rust_bindgen {\n"
+"    name: \"libbirthday_bindgen\",\n"
+"    crate_name: \"birthday_bindgen\",\n"
+"    wrapper_src: \"libbirthday_wrapper.h\",\n"
+"    source_stem: \"bindings\",\n"
+"    static_libs: [\"libbirthday\"],\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/android/interoperability/with-c/bindgen.md:67
+msgid "Finally, we can use the bindings in our Rust program:"
+msgstr ""
+
+#: src/android/interoperability/with-c/bindgen.md:71
+msgid ""
+"```javascript\n"
+"rust_binary {\n"
+"    name: \"print_birthday_card\",\n"
+"    srcs: [\"main.rs\"],\n"
+"    rustlibs: [\"libbirthday_bindgen\"],\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/android/interoperability/with-c/bindgen.md:79
+msgid "_interoperability/bindgen/main.rs_:"
+msgstr ""
+
+#: src/android/interoperability/with-c/bindgen.md:81
+msgid "```rust,compile_fail\n//! Bindgen demo."
+msgstr ""
+
+#: src/android/interoperability/with-c/bindgen.md:84
+msgid "use birthday_bindgen::{card, print_card};"
+msgstr ""
+
+#: src/android/interoperability/with-c/bindgen.md:86
+msgid ""
+"fn main() {\n"
+"    let name = std::ffi::CString::new(\"Peter\").unwrap();\n"
+"    let card = card {\n"
+"        name: name.as_ptr(),\n"
+"        years: 42,\n"
+"    };\n"
+"    unsafe {\n"
+"        print_card(&card as *const card);\n"
+"    }\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/android/interoperability/with-c/bindgen.md:100
+msgid ""
+"```shell\n"
+"$ m print_birthday_card\n"
+"$ adb push $ANDROID_PRODUCT_OUT/system/bin/print_birthday_card "
+"/data/local/tmp\n"
+"$ adb shell /data/local/tmp/print_birthday_card\n"
+"```"
+msgstr ""
+
+#: src/android/interoperability/with-c/bindgen.md:106
+msgid "Finally, we can run auto-generated tests to ensure the bindings work:"
+msgstr ""
+
+#: src/android/interoperability/with-c/bindgen.md:110
+msgid ""
+"```javascript\n"
+"rust_test {\n"
+"    name: \"libbirthday_bindgen_test\",\n"
+"    srcs: [\":libbirthday_bindgen\"],\n"
+"    crate_name: \"libbirthday_bindgen_test\",\n"
+"    test_suites: [\"general-tests\"],\n"
+"    auto_gen_config: true,\n"
+"    clippy_lints: \"none\", // Generated file, skip linting\n"
+"    lints: \"none\",\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/android/interoperability/with-c/bindgen.md:122
+msgid ""
+"```shell\n"
+"$ atest libbirthday_bindgen_test\n"
+"```"
+msgstr ""
+
+#: src/android/interoperability/with-c/rust.md:1
+msgid "# Calling Rust"
+msgstr ""
+
+#: src/android/interoperability/with-c/rust.md:3
+msgid "Exporting Rust functions and types to C is easy:"
+msgstr ""
+
+#: src/android/interoperability/with-c/rust.md:5
+msgid "_interoperability/rust/libanalyze/analyze.rs_"
+msgstr ""
+
+#: src/android/interoperability/with-c/rust.md:7
+msgid ""
+"```rust,editable\n"
+"//! Rust FFI demo.\n"
+"#![deny(improper_ctypes_definitions)]"
+msgstr ""
+
+#: src/android/interoperability/with-c/rust.md:11
+msgid "use std::os::raw::c_int;"
+msgstr ""
+
+#: src/android/interoperability/with-c/rust.md:13
+msgid ""
+"/// Analyze the numbers.\n"
+"#[no_mangle]\n"
+"pub extern \"C\" fn analyze_numbers(x: c_int, y: c_int) {\n"
+"    if x < y {\n"
+"        println!(\"x ({x}) is smallest!\");\n"
+"    } else {\n"
+"        println!(\"y ({y}) is probably larger than x ({x})\");\n"
+"    }\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/android/interoperability/with-c/rust.md:24
+msgid "_interoperability/rust/libanalyze/analyze.h_"
+msgstr ""
+
+#: src/android/interoperability/with-c/rust.md:26
+msgid ""
+"```c\n"
+"#ifndef ANALYSE_H\n"
+"#define ANALYSE_H"
+msgstr ""
+
+#: src/android/interoperability/with-c/rust.md:30
+msgid ""
+"extern \"C\" {\n"
+"void analyze_numbers(int x, int y);\n"
+"}"
+msgstr ""
+
+#: src/android/interoperability/with-c/rust.md:34
+msgid "#endif\n```"
+msgstr ""
+
+#: src/android/interoperability/with-c/rust.md:37
+msgid "_interoperability/rust/libanalyze/Android.bp_"
+msgstr ""
+
+#: src/android/interoperability/with-c/rust.md:39
+msgid ""
+"```javascript\n"
+"rust_ffi {\n"
+"    name: \"libanalyze_ffi\",\n"
+"    crate_name: \"analyze_ffi\",\n"
+"    srcs: [\"analyze.rs\"],\n"
+"    include_dirs: [\".\"],\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/android/interoperability/with-c/rust.md:48
+msgid "We can now call this from a C binary:"
+msgstr ""
+
+#: src/android/interoperability/with-c/rust.md:50
+msgid "_interoperability/rust/analyze/main.c_"
+msgstr ""
+
+#: src/android/interoperability/with-c/rust.md:52
+msgid "```c\n#include \"analyze.h\""
+msgstr ""
+
+#: src/android/interoperability/with-c/rust.md:55
+msgid ""
+"int main() {\n"
+"  analyze_numbers(10, 20);\n"
+"  analyze_numbers(123, 123);\n"
+"  return 0;\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/android/interoperability/with-c/rust.md:62
+msgid "_interoperability/rust/analyze/Android.bp_"
+msgstr ""
+
+#: src/android/interoperability/with-c/rust.md:64
+msgid ""
+"```javascript\n"
+"cc_binary {\n"
+"    name: \"analyze_numbers\",\n"
+"    srcs: [\"main.c\"],\n"
+"    static_libs: [\"libanalyze_ffi\"],\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/android/interoperability/with-c/rust.md:75
+msgid ""
+"```shell\n"
+"$ m analyze_numbers\n"
+"$ adb push $ANDROID_PRODUCT_OUT/system/bin/analyze_numbers /data/local/tmp\n"
+"$ adb shell /data/local/tmp/analyze_numbers\n"
+"```"
+msgstr ""
+
+#: src/android/interoperability/cpp.md:1
+msgid "# With C++"
+msgstr ""
+
+#: src/android/interoperability/cpp.md:3
+msgid ""
+"The [CXX crate][1] makes it possible to do safe interoperability between "
+"Rust\n"
+"and C++."
+msgstr ""
+
+#: src/android/interoperability/cpp.md:6
+msgid "The overall approach looks like this:"
+msgstr ""
+
+#: src/android/interoperability/cpp.md:8
+msgid "<img src=\"cpp/overview.svg\">"
+msgstr ""
+
+#: src/android/interoperability/cpp.md:10
+msgid "See the [CXX tutorial][2] for an full example of using this."
+msgstr ""
+
+#: src/android/interoperability/cpp.md:12
+msgid "[1]: https://cxx.rs/\n[2]: https://cxx.rs/tutorial.html"
+msgstr ""
+
+#: src/android/interoperability/java.md:1
+msgid "# Interoperability with Java"
+msgstr ""
+
+#: src/android/interoperability/java.md:3
+msgid ""
+"Java can load shared objects via [Java Native Interface\n"
+"(JNI)](https://en.wikipedia.org/wiki/Java_Native_Interface). The [`jni`\n"
+"crate](https://docs.rs/jni/) allows you to create a compatible library."
+msgstr ""
+
+#: src/android/interoperability/java.md:7
+msgid "First, we create a Rust function to export to Java:"
+msgstr ""
+
+#: src/android/interoperability/java.md:9
+msgid "_interoperability/java/src/lib.rs_:"
+msgstr ""
+
+#: src/android/interoperability/java.md:11
+msgid "```rust,compile_fail\n//! Rust <-> Java FFI demo."
+msgstr ""
+
+#: src/android/interoperability/java.md:14
+msgid ""
+"use jni::objects::{JClass, JString};\n"
+"use jni::sys::jstring;\n"
+"use jni::JNIEnv;"
+msgstr ""
+
+#: src/android/interoperability/java.md:18
+msgid ""
+"/// HelloWorld::hello method implementation.\n"
+"#[no_mangle]\n"
+"pub extern \"system\" fn Java_HelloWorld_hello(\n"
+"    env: JNIEnv,\n"
+"    _class: JClass,\n"
+"    name: JString,\n"
+") -> jstring {\n"
+"    let input: String = env.get_string(name).unwrap().into();\n"
+"    let greeting = format!(\"Hello, {input}!\");\n"
+"    let output = env.new_string(greeting).unwrap();\n"
+"    output.into_inner()\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/android/interoperability/java.md:32
+#: src/android/interoperability/java.md:62
+msgid "_interoperability/java/Android.bp_:"
+msgstr ""
+
+#: src/android/interoperability/java.md:34
+msgid ""
+"```javascript\n"
+"rust_ffi_shared {\n"
+"    name: \"libhello_jni\",\n"
+"    crate_name: \"hello_jni\",\n"
+"    srcs: [\"src/lib.rs\"],\n"
+"    rustlibs: [\"libjni\"],\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/android/interoperability/java.md:43
+msgid "Finally, we can call this function from Java:"
+msgstr ""
+
+#: src/android/interoperability/java.md:45
+msgid "_interoperability/java/HelloWorld.java_:"
+msgstr ""
+
+#: src/android/interoperability/java.md:47
+msgid ""
+"```java\n"
+"class HelloWorld {\n"
+"    private static native String hello(String name);"
+msgstr ""
+
+#: src/android/interoperability/java.md:51
+msgid ""
+"    static {\n"
+"        System.loadLibrary(\"hello_jni\");\n"
+"    }"
+msgstr ""
+
+#: src/android/interoperability/java.md:55
+msgid ""
+"    public static void main(String[] args) {\n"
+"        String output = HelloWorld.hello(\"Alice\");\n"
+"        System.out.println(output);\n"
+"    }\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/android/interoperability/java.md:64
+msgid ""
+"```javascript\n"
+"java_binary {\n"
+"    name: \"helloworld_jni\",\n"
+"    srcs: [\"HelloWorld.java\"],\n"
+"    main_class: \"HelloWorld\",\n"
+"    required: [\"libhello_jni\"],\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/android/interoperability/java.md:73
+msgid "Finally, you can build, sync, and run the binary:"
+msgstr ""
+
+#: src/android/interoperability/java.md:75
+msgid ""
+"```shell\n"
+"$ m helloworld_jni\n"
+"$ adb sync  # requires adb root && adb remount\n"
+"$ adb shell /system/bin/helloworld_jni\n"
+"```"
+msgstr ""
+
+#: src/exercises/day-4/afternoon.md:3
+msgid ""
+"For the last exercise, we will look at one of the projects you work with. "
+"Let us\n"
+"group up and do this together. Some suggestions:"
+msgstr ""
+
+#: src/exercises/day-4/afternoon.md:6
+msgid "* Call your AIDL service with a client written in Rust."
+msgstr ""
+
+#: src/exercises/day-4/afternoon.md:8
+msgid "* Move a function from your project to Rust and call it."
+msgstr ""
+
+#: src/thanks.md:1
+msgid "# Thanks!"
+msgstr ""
+
+#: src/thanks.md:3
+msgid ""
+"_Thank you for taking Comprehensive Rust 🦀!_ We hope you enjoyed it and that "
+"it\n"
+"was useful."
+msgstr ""
+
+#: src/thanks.md:6
+msgid ""
+"We've had a lot of fun putting the course together. The course is not "
+"perfect,\n"
+"so if you spotted any mistakes or have ideas for improvements, please get "
+"in\n"
+"[contact with us on\n"
+"GitHub](https://github.com/google/comprehensive-rust/discussions). We would "
+"love\n"
+"to hear from you."
+msgstr ""
+
+#: src/other-resources.md:1
+msgid "# Other Rust Resources"
+msgstr ""
+
+#: src/other-resources.md:3
+msgid ""
+"The Rust community has created a wealth of high-quality and free resources\n"
+"online."
+msgstr ""
+
+#: src/other-resources.md:6
+msgid "## Official Documentation"
+msgstr ""
+
+#: src/other-resources.md:8
+msgid "The Rust project hosts many resources. These cover Rust in general:"
+msgstr ""
+
+#: src/other-resources.md:10
+msgid ""
+"* [The Rust Programming Language](https://doc.rust-lang.org/book/): the\n"
+"  canonical free book about Rust. Covers the language in detail and includes "
+"a\n"
+"  few projects for people to build.\n"
+"* [Rust By Example](https://doc.rust-lang.org/rust-by-example/): covers the "
+"Rust\n"
+"  syntax via a series of examples which showcase different constructs. "
+"Sometimes\n"
+"  includes small exercises where you are asked to expand on the code in the\n"
+"  examples.\n"
+"* [Rust Standard Library](https://doc.rust-lang.org/std/): full "
+"documentation of\n"
+"  the standard library for Rust.\n"
+"* [The Rust Reference](https://doc.rust-lang.org/reference/): an incomplete "
+"book\n"
+"  which describes the Rust grammar and memory model."
+msgstr ""
+
+#: src/other-resources.md:22
+msgid "More specialized guides hosted on the official Rust site:"
+msgstr ""
+
+#: src/other-resources.md:24
+msgid ""
+"* [The Rustonomicon](https://doc.rust-lang.org/nomicon/): covers unsafe "
+"Rust,\n"
+"  including working with raw pointers and interfacing with other languages\n"
+"  (FFI).\n"
+"* [Asynchronous Programming in "
+"Rust](https://rust-lang.github.io/async-book/):\n"
+"  covers the new asynchronous programming model which was introduced after "
+"the\n"
+"  Rust Book was written.\n"
+"* [The Embedded Rust Book](https://doc.rust-lang.org/stable/embedded-book/): "
+"an\n"
+"  introduction to using Rust on embedded devices without an operating system."
+msgstr ""
+
+#: src/other-resources.md:33
+msgid "## Unofficial Learning Material"
+msgstr ""
+
+#: src/other-resources.md:35
+msgid "A small selection of other guides and tutorial for Rust:"
+msgstr ""
+
+#: src/other-resources.md:37
+msgid ""
+"* [Learn Rust the Dangerous Way](http://cliffle.com/p/dangerust/): covers "
+"Rust\n"
+"  from the perspective of low-level C programmers.\n"
+"* [Rust for Embedded C\n"
+"  Programmers](https://docs.opentitan.org/doc/ug/rust_for_c/): covers Rust "
+"from\n"
+"  the perspective of developers who write firmware in C.\n"
+"* [Rust for professionals](https://overexact.com/rust-for-professionals/):\n"
+"  covers the syntax of Rust using side-by-side comparisons with other "
+"languages\n"
+"  such as C, C++, Java, JavaScript, and Python.\n"
+"* [Rust on Exercism](https://exercism.org/tracks/rust): 100+ exercises to "
+"help\n"
+"  you learn Rust.\n"
+"* [Ferrous Teaching\n"
+"  Material](https://ferrous-systems.github.io/teaching-material/index.html): "
+"a\n"
+"  series of small presentations covering both basic and advanced part of "
+"the\n"
+"  Rust language. Other topics such as WebAssembly, and async/await are also\n"
+"  covered.\n"
+"* [Beginner's Series to\n"
+"  Rust](https://docs.microsoft.com/en-us/shows/beginners-series-to-rust/) "
+"and\n"
+"  [Take your first steps with\n"
+"  Rust](https://docs.microsoft.com/en-us/learn/paths/rust-first-steps/): "
+"two\n"
+"  Rust guides aimed at new developers. The first is a set of 35 videos and "
+"the\n"
+"  second is a set of 11 modules which covers Rust syntax and basic "
+"constructs."
+msgstr ""
+
+#: src/other-resources.md:59
+msgid ""
+"Please see the [Little Book of Rust Books](https://lborb.github.io/book/) "
+"for\n"
+"even more Rust books."
+msgstr ""
+
+#: src/credits.md:1
+msgid "# Credits"
+msgstr ""
+
+#: src/credits.md:3
+msgid ""
+"The material here builds on top of the many great sources of Rust "
+"documentation.\n"
+"See the page on [other resources](other-resources.md) for a full list of "
+"useful\n"
+"resources."
+msgstr ""
+
+#: src/credits.md:7
+msgid ""
+"The material of Comprehensive Rust is licensed under the terms of the Apache "
+"2.0\n"
+"license, please see [`LICENSE.txt`](../LICENSE.txt) for details."
+msgstr ""
+
+#: src/credits.md:10
+msgid "## Rust by Example"
+msgstr ""
+
+#: src/credits.md:12
+msgid ""
+"Some examples and exercises have been copied and adapted from [Rust by\n"
+"Example](https://doc.rust-lang.org/rust-by-example/). Please see the\n"
+"`third_party/rust-by-example/` directory for details, including the license\n"
+"terms."
+msgstr ""
+
+#: src/credits.md:17
+msgid "## Rust on Exercism"
+msgstr ""
+
+#: src/credits.md:19
+msgid ""
+"Some exercises have been copied and adapted from [Rust on\n"
+"Exercism](https://exercism.org/tracks/rust). Please see the\n"
+"`third_party/rust-on-exercism/` directory for details, including the "
+"license\n"
+"terms."
+msgstr ""
+
+#: src/credits.md:24
+msgid "## CXX"
+msgstr ""
+
+#: src/credits.md:26
+msgid ""
+"The [Interoperability with C++](android/interoperability/cpp.md) section "
+"uses an\n"
+"image from [CXX](https://cxx.rs/). Please see the `third_party/cxx/` "
+"directory\n"
+"for details, including the license terms."
+msgstr ""
+
+#: src/exercises/solutions.md:1
+msgid "# Solutions"
+msgstr ""
+
+#: src/exercises/solutions.md:3
+msgid "You will find solutions to the exercises on the following pages."
+msgstr ""
+
+#: src/exercises/solutions.md:5
+msgid ""
+"Feel free to ask questions about the solutions [on\n"
+"GitHub](https://github.com/google/comprehensive-rust/discussions). Let us "
+"know\n"
+"if you have a different or better solution than what is presented here."
+msgstr ""
+
+#: src/exercises/solutions.md:10
+msgid ""
+"> **Note:** Please ignore the `// ANCHOR: label` and `// ANCHOR_END: label`\n"
+"> comments you see in the solutions. They are there to make it possible to\n"
+"> re-use parts of the solutions as the exercises."
+msgstr ""
+
+#: src/exercises/day-1/solutions-morning.md:1
+msgid "# Day 1 Morning Exercises"
+msgstr ""
+
+#: src/exercises/day-1/solutions-morning.md:3
+msgid "## Arrays and `for` Loops"
+msgstr ""
+
+#: src/exercises/day-1/solutions-morning.md:5
+msgid "([back to exercise](for-loops.md))"
+msgstr ""
+
+#: src/exercises/day-1/solutions-morning.md:7
+#: src/exercises/day-1/solutions-afternoon.md:7
+#: src/exercises/day-2/solutions-morning.md:7
+#: src/exercises/day-2/solutions-afternoon.md:7
+#: src/exercises/day-2/solutions-afternoon.md:102
+#: src/exercises/day-3/solutions-morning.md:7
+#: src/exercises/day-3/solutions-afternoon.md:7
+#: src/exercises/day-4/solutions-morning.md:7
+msgid ""
+"```rust\n"
+"// Copyright 2022 Google LLC\n"
+"//\n"
+"// Licensed under the Apache License, Version 2.0 (the \"License\");\n"
+"// you may not use this file except in compliance with the License.\n"
+"// You may obtain a copy of the License at\n"
+"//\n"
+"//      http://www.apache.org/licenses/LICENSE-2.0\n"
+"//\n"
+"// Unless required by applicable law or agreed to in writing, software\n"
+"// distributed under the License is distributed on an \"AS IS\" BASIS,\n"
+"// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n"
+"// See the License for the specific language governing permissions and\n"
+"// limitations under the License."
+msgstr ""
+
+#: src/exercises/day-1/solutions-morning.md:22
+msgid ""
+"// ANCHOR: transpose\n"
+"fn transpose(matrix: [[i32; 3]; 3]) -> [[i32; 3]; 3] {\n"
+"    // ANCHOR_END: transpose\n"
+"    let mut result = [[0; 3]; 3];\n"
+"    for i in 0..3 {\n"
+"        for j in 0..3 {\n"
+"            result[j][i] = matrix[i][j];\n"
+"        }\n"
+"    }\n"
+"    return result;\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-1/solutions-morning.md:34
+msgid ""
+"// ANCHOR: pretty_print\n"
+"fn pretty_print(matrix: &[[i32; 3]; 3]) {\n"
+"    // ANCHOR_END: pretty_print\n"
+"    for row in matrix {\n"
+"        println!(\"{row:?}\");\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-1/solutions-morning.md:42
+msgid ""
+"// ANCHOR: tests\n"
+"#[test]\n"
+"fn test_transpose() {\n"
+"    let matrix = [\n"
+"        [101, 102, 103], //\n"
+"        [201, 202, 203],\n"
+"        [301, 302, 303],\n"
+"    ];\n"
+"    let transposed = transpose(matrix);\n"
+"    assert_eq!(\n"
+"        transposed,\n"
+"        [\n"
+"            [101, 201, 301], //\n"
+"            [102, 202, 302],\n"
+"            [103, 203, 303],\n"
+"        ]\n"
+"    );\n"
+"}\n"
+"// ANCHOR_END: tests"
+msgstr ""
+
+#: src/exercises/day-1/solutions-morning.md:62
+msgid ""
+"// ANCHOR: main\n"
+"fn main() {\n"
+"    let matrix = [\n"
+"        [101, 102, 103], // <-- the comment makes rustfmt add a newline\n"
+"        [201, 202, 203],\n"
+"        [301, 302, 303],\n"
+"    ];"
+msgstr ""
+
+#: src/exercises/day-1/solutions-morning.md:73
+msgid ""
+"    let transposed = transpose(matrix);\n"
+"    println!(\"transposed:\");\n"
+"    pretty_print(&transposed);\n"
+"}\n"
+"```\n"
+"### Bonus question"
+msgstr ""
+
+#: src/exercises/day-1/solutions-morning.md:80
+msgid ""
+"It honestly doesn't work so well. It might seem that we could use a "
+"slice-of-slices (`&[&[i32]]`) as the input type to transpose and thus make "
+"our function handle any size of matrix. However, this quickly breaks down: "
+"the return type cannot be `&[&[i32]]` since it needs to own the data you "
+"return."
+msgstr ""
+
+#: src/exercises/day-1/solutions-morning.md:82
+msgid ""
+"You can attempt to use something like `Vec<Vec<i32>>`, but this doesn't work "
+"very well either: it's hard to convert from `Vec<Vec<i32>>` to `&[&[i32]]` "
+"so now you cannot easily use `pretty_print` either."
+msgstr ""
+
+#: src/exercises/day-1/solutions-afternoon.md:1
+msgid "# Day 1 Afternoon Exercises"
+msgstr ""
+
+#: src/exercises/day-1/solutions-afternoon.md:3
+msgid "## Designing a Library"
+msgstr ""
+
+#: src/exercises/day-1/solutions-afternoon.md:5
+msgid "([back to exercise](book-library.md))"
+msgstr ""
+
+#: src/exercises/day-1/solutions-afternoon.md:22
+msgid ""
+"// ANCHOR: setup\n"
+"struct Library {\n"
+"    books: Vec<Book>,\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-1/solutions-afternoon.md:42
+msgid ""
+"// This makes it possible to print Book values with {}.\n"
+"impl std::fmt::Display for Book {\n"
+"    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {\n"
+"        write!(f, \"{} ({})\", self.title, self.year)\n"
+"    }\n"
+"}\n"
+"// ANCHOR_END: setup"
+msgstr ""
+
+#: src/exercises/day-1/solutions-afternoon.md:50
+msgid ""
+"// ANCHOR: Library_new\n"
+"impl Library {\n"
+"    fn new() -> Library {\n"
+"        // ANCHOR_END: Library_new\n"
+"        Library { books: Vec::new() }\n"
+"    }"
+msgstr ""
+
+#: src/exercises/day-1/solutions-afternoon.md:57
+msgid ""
+"    // ANCHOR: Library_len\n"
+"    //fn len(self) -> usize {\n"
+"    //    unimplemented!()\n"
+"    //}\n"
+"    // ANCHOR_END: Library_len\n"
+"    fn len(&self) -> usize {\n"
+"        self.books.len()\n"
+"    }"
+msgstr ""
+
+#: src/exercises/day-1/solutions-afternoon.md:66
+msgid ""
+"    // ANCHOR: Library_is_empty\n"
+"    //fn is_empty(self) -> bool {\n"
+"    //    unimplemented!()\n"
+"    //}\n"
+"    // ANCHOR_END: Library_is_empty\n"
+"    fn is_empty(&self) -> bool {\n"
+"        self.books.is_empty()\n"
+"    }"
+msgstr ""
+
+#: src/exercises/day-1/solutions-afternoon.md:75
+msgid ""
+"    // ANCHOR: Library_add_book\n"
+"    //fn add_book(self, book: Book) {\n"
+"    //    unimplemented!()\n"
+"    //}\n"
+"    // ANCHOR_END: Library_add_book\n"
+"    fn add_book(&mut self, book: Book) {\n"
+"        self.books.push(book)\n"
+"    }"
+msgstr ""
+
+#: src/exercises/day-1/solutions-afternoon.md:84
+msgid ""
+"    // ANCHOR: Library_print_books\n"
+"    //fn print_books(self) {\n"
+"    //    unimplemented!()\n"
+"    //}\n"
+"    // ANCHOR_END: Library_print_books\n"
+"    fn print_books(&self) {\n"
+"        for book in &self.books {\n"
+"            println!(\"{}\", book);\n"
+"        }\n"
+"    }"
+msgstr ""
+
+#: src/exercises/day-1/solutions-afternoon.md:95
+msgid ""
+"    // ANCHOR: Library_oldest_book\n"
+"    //fn oldest_book(self) -> Option<&Book> {\n"
+"    //    unimplemented!()\n"
+"    //}\n"
+"    // ANCHOR_END: Library_oldest_book\n"
+"    fn oldest_book(&self) -> Option<&Book> {\n"
+"        self.books.iter().min_by_key(|book| book.year)\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-1/solutions-afternoon.md:105
+msgid ""
+"// ANCHOR: main\n"
+"// This shows the desired behavior. Uncomment the code below and\n"
+"// implement the missing methods. You will need to update the\n"
+"// method signatures, including the \"self\" parameter!\n"
+"fn main() {\n"
+"    let library = Library::new();"
+msgstr ""
+
+#: src/exercises/day-1/solutions-afternoon.md:112
+msgid ""
+"    //println!(\"Our library is empty: {}\", library.is_empty());\n"
+"    //\n"
+"    //library.add_book(Book::new(\"Lord of the Rings\", 1954));\n"
+"    //library.add_book(Book::new(\"Alice's Adventures in Wonderland\", "
+"1865));\n"
+"    //\n"
+"    //library.print_books();\n"
+"    //\n"
+"    //match library.oldest_book() {\n"
+"    //    Some(book) => println!(\"My oldest book is {book}\"),\n"
+"    //    None => println!(\"My library is empty!\"),\n"
+"    //}\n"
+"    //\n"
+"    //println!(\"Our library has {} books\", library.len());\n"
+"}\n"
+"// ANCHOR_END: main"
+msgstr ""
+
+#: src/exercises/day-1/solutions-afternoon.md:128
+msgid ""
+"#[test]\n"
+"fn test_library_len() {\n"
+"    let mut library = Library::new();\n"
+"    assert_eq!(library.len(), 0);\n"
+"    assert!(library.is_empty());"
+msgstr ""
+
+#: src/exercises/day-1/solutions-afternoon.md:134
+msgid ""
+"    library.add_book(Book::new(\"Lord of the Rings\", 1954));\n"
+"    library.add_book(Book::new(\"Alice's Adventures in Wonderland\", "
+"1865));\n"
+"    assert_eq!(library.len(), 2);\n"
+"    assert!(!library.is_empty());\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-1/solutions-afternoon.md:140
+msgid ""
+"#[test]\n"
+"fn test_library_is_empty() {\n"
+"    let mut library = Library::new();\n"
+"    assert!(library.is_empty());"
+msgstr ""
+
+#: src/exercises/day-1/solutions-afternoon.md:145
+msgid ""
+"    library.add_book(Book::new(\"Lord of the Rings\", 1954));\n"
+"    assert!(!library.is_empty());\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-1/solutions-afternoon.md:149
+msgid ""
+"#[test]\n"
+"fn test_library_print_books() {\n"
+"    let mut library = Library::new();\n"
+"    library.add_book(Book::new(\"Lord of the Rings\", 1954));\n"
+"    library.add_book(Book::new(\"Alice's Adventures in Wonderland\", "
+"1865));\n"
+"    // We could try and capture stdout, but let us just call the\n"
+"    // method to start with.\n"
+"    library.print_books();\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-1/solutions-afternoon.md:159
+msgid ""
+"#[test]\n"
+"fn test_library_oldest_book() {\n"
+"    let mut library = Library::new();\n"
+"    assert!(library.oldest_book().is_none());"
+msgstr ""
+
+#: src/exercises/day-1/solutions-afternoon.md:164
+msgid ""
+"    library.add_book(Book::new(\"Lord of the Rings\", 1954));\n"
+"    assert_eq!(\n"
+"        library.oldest_book().map(|b| b.title.as_str()),\n"
+"        Some(\"Lord of the Rings\")\n"
+"    );"
+msgstr ""
+
+#: src/exercises/day-1/solutions-afternoon.md:170
+msgid ""
+"    library.add_book(Book::new(\"Alice's Adventures in Wonderland\", "
+"1865));\n"
+"    assert_eq!(\n"
+"        library.oldest_book().map(|b| b.title.as_str()),\n"
+"        Some(\"Alice's Adventures in Wonderland\")\n"
+"    );\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/exercises/day-2/solutions-morning.md:1
+msgid "# Day 2 Morning Exercises"
+msgstr ""
+
+#: src/exercises/day-2/solutions-morning.md:3
+msgid "## Points and Polygons"
+msgstr ""
+
+#: src/exercises/day-2/solutions-morning.md:5
+msgid "([back to exercise](points-polygons.md))"
+msgstr ""
+
+#: src/exercises/day-2/solutions-morning.md:22
+msgid ""
+"#[derive(Debug, Copy, Clone, PartialEq, Eq)]\n"
+"// ANCHOR: Point\n"
+"pub struct Point {\n"
+"    // ANCHOR_END: Point\n"
+"    x: i32,\n"
+"    y: i32,\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-2/solutions-morning.md:30
+msgid ""
+"// ANCHOR: Point-impl\n"
+"impl Point {\n"
+"    // ANCHOR_END: Point-impl\n"
+"    pub fn new(x: i32, y: i32) -> Point {\n"
+"        Point { x, y }\n"
+"    }"
+msgstr ""
+
+#: src/exercises/day-2/solutions-morning.md:37
+msgid ""
+"    pub fn magnitude(self) -> f64 {\n"
+"        f64::from(self.x.pow(2) + self.y.pow(2)).sqrt()\n"
+"    }"
+msgstr ""
+
+#: src/exercises/day-2/solutions-morning.md:41
+msgid ""
+"    pub fn dist(self, other: Point) -> f64 {\n"
+"        (self - other).magnitude()\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-2/solutions-morning.md:49
+msgid ""
+"    fn add(self, other: Self) -> Self::Output {\n"
+"        Self {\n"
+"            x: self.x + other.x,\n"
+"            y: self.y + other.y,\n"
+"        }\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-2/solutions-morning.md:57
+msgid "impl std::ops::Sub for Point {\n    type Output = Self;"
+msgstr ""
+
+#: src/exercises/day-2/solutions-morning.md:60
+msgid ""
+"    fn sub(self, other: Self) -> Self::Output {\n"
+"        Self {\n"
+"            x: self.x - other.x,\n"
+"            y: self.y - other.y,\n"
+"        }\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-2/solutions-morning.md:68
+msgid ""
+"// ANCHOR: Polygon\n"
+"pub struct Polygon {\n"
+"    // ANCHOR_END: Polygon\n"
+"    points: Vec<Point>,\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-2/solutions-morning.md:74
+msgid ""
+"// ANCHOR: Polygon-impl\n"
+"impl Polygon {\n"
+"    // ANCHOR_END: Polygon-impl\n"
+"    pub fn new() -> Polygon {\n"
+"        Polygon { points: Vec::new() }\n"
+"    }"
+msgstr ""
+
+#: src/exercises/day-2/solutions-morning.md:81
+msgid ""
+"    pub fn add_point(&mut self, point: Point) {\n"
+"        self.points.push(point);\n"
+"    }"
+msgstr ""
+
+#: src/exercises/day-2/solutions-morning.md:85
+msgid ""
+"    pub fn left_most_point(&self) -> Option<Point> {\n"
+"        self.points.iter().min_by_key(|p| p.x).copied()\n"
+"    }"
+msgstr ""
+
+#: src/exercises/day-2/solutions-morning.md:89
+msgid ""
+"    pub fn iter(&self) -> impl Iterator<Item = &Point> {\n"
+"        self.points.iter()\n"
+"    }"
+msgstr ""
+
+#: src/exercises/day-2/solutions-morning.md:93
+msgid ""
+"    pub fn length(&self) -> f64 {\n"
+"        if self.points.is_empty() {\n"
+"            return 0.0;\n"
+"        }"
+msgstr ""
+
+#: src/exercises/day-2/solutions-morning.md:98
+msgid ""
+"        let mut result = 0.0;\n"
+"        let mut last_point = self.points[0];\n"
+"        for point in &self.points[1..] {\n"
+"            result += last_point.dist(*point);\n"
+"            last_point = *point;\n"
+"        }\n"
+"        result += last_point.dist(self.points[0]);\n"
+"        result\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-2/solutions-morning.md:109
+msgid ""
+"// ANCHOR: Circle\n"
+"pub struct Circle {\n"
+"    // ANCHOR_END: Circle\n"
+"    center: Point,\n"
+"    radius: i32,\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-2/solutions-morning.md:116
+msgid ""
+"// ANCHOR: Circle-impl\n"
+"impl Circle {\n"
+"    // ANCHOR_END: Circle-impl\n"
+"    pub fn new(center: Point, radius: i32) -> Circle {\n"
+"        Circle { center, radius }\n"
+"    }"
+msgstr ""
+
+#: src/exercises/day-2/solutions-morning.md:123
+msgid ""
+"    pub fn circumference(&self) -> f64 {\n"
+"        2.0 * std::f64::consts::PI * f64::from(self.radius)\n"
+"    }"
+msgstr ""
+
+#: src/exercises/day-2/solutions-morning.md:127
+msgid ""
+"    pub fn dist(&self, other: &Self) -> f64 {\n"
+"        self.center.dist(other.center)\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-2/solutions-morning.md:132
+msgid ""
+"// ANCHOR: Shape\n"
+"pub enum Shape {\n"
+"    Polygon(Polygon),\n"
+"    Circle(Circle),\n"
+"}\n"
+"// ANCHOR_END: Shape"
+msgstr ""
+
+#: src/exercises/day-2/solutions-morning.md:139
+msgid ""
+"impl From<Polygon> for Shape {\n"
+"    fn from(poly: Polygon) -> Self {\n"
+"        Shape::Polygon(poly)\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-2/solutions-morning.md:145
+msgid ""
+"impl From<Circle> for Shape {\n"
+"    fn from(circle: Circle) -> Self {\n"
+"        Shape::Circle(circle)\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-2/solutions-morning.md:151
+msgid ""
+"impl Shape {\n"
+"    pub fn circumference(&self) -> f64 {\n"
+"        match self {\n"
+"            Shape::Polygon(poly) => poly.length(),\n"
+"            Shape::Circle(circle) => circle.circumference(),\n"
+"        }\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-2/solutions-morning.md:160
+msgid ""
+"// ANCHOR: unit-tests\n"
+"#[cfg(test)]\n"
+"mod tests {\n"
+"    use super::*;"
+msgstr ""
+
+#: src/exercises/day-2/solutions-morning.md:213
+msgid ""
+"    #[test]\n"
+"    fn test_shape_circumferences() {\n"
+"        let mut poly = Polygon::new();\n"
+"        poly.add_point(Point::new(12, 13));\n"
+"        poly.add_point(Point::new(17, 11));\n"
+"        poly.add_point(Point::new(16, 16));\n"
+"        let shapes = vec![\n"
+"            Shape::from(poly),\n"
+"            Shape::from(Circle::new(Point::new(10, 20), 5)),\n"
+"        ];\n"
+"        let circumferences = shapes\n"
+"            .iter()\n"
+"            .map(Shape::circumference)\n"
+"            .map(round_two_digits)\n"
+"            .collect::<Vec<_>>();\n"
+"        assert_eq!(circumferences, vec![15.48, 31.42]);\n"
+"    }\n"
+"}\n"
+"// ANCHOR_END: unit-tests"
+msgstr ""
+
+#: src/exercises/day-2/solutions-afternoon.md:1
+msgid "# Day 2 Afternoon Exercises"
+msgstr ""
+
+#: src/exercises/day-2/solutions-afternoon.md:3
+msgid "## Luhn Algorithm"
+msgstr ""
+
+#: src/exercises/day-2/solutions-afternoon.md:5
+msgid "([back to exercise](luhn.md))"
+msgstr ""
+
+#: src/exercises/day-2/solutions-afternoon.md:22
+msgid ""
+"// ANCHOR: luhn\n"
+"pub fn luhn(cc_number: &str) -> bool {\n"
+"    // ANCHOR_END: luhn\n"
+"    let mut digits_seen = 0;\n"
+"    let mut sum = 0;\n"
+"    for (i, ch) in cc_number.chars().rev().filter(|&ch| ch != ' "
+"').enumerate() {\n"
+"        match ch.to_digit(10) {\n"
+"            Some(d) => {\n"
+"                sum += if i % 2 == 1 {\n"
+"                    let dd = d * 2;\n"
+"                    dd / 10 + dd % 10\n"
+"                } else {\n"
+"                    d\n"
+"                };\n"
+"                digits_seen += 1;\n"
+"            }\n"
+"            None => return false,\n"
+"        }\n"
+"    }"
+msgstr ""
+
+#: src/exercises/day-2/solutions-afternoon.md:42
+msgid ""
+"    if digits_seen < 2 {\n"
+"        return false;\n"
+"    }"
+msgstr ""
+
+#: src/exercises/day-2/solutions-afternoon.md:46
+msgid "    sum % 10 == 0\n}"
+msgstr ""
+
+#: src/exercises/day-2/solutions-afternoon.md:49
+msgid ""
+"fn main() {\n"
+"    let cc_number = \"1234 5678 1234 5670\";\n"
+"    println!(\n"
+"        \"Is {} a valid credit card number? {}\",\n"
+"        cc_number,\n"
+"        if luhn(cc_number) { \"yes\" } else { \"no\" }\n"
+"    );\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-2/solutions-afternoon.md:58
+msgid ""
+"// ANCHOR: unit-tests\n"
+"#[test]\n"
+"fn test_non_digit_cc_number() {\n"
+"    assert!(!luhn(\"foo\"));\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-2/solutions-afternoon.md:89
+msgid ""
+"#[test]\n"
+"fn test_invalid_cc_number() {\n"
+"    assert!(!luhn(\"4223 9826 4026 9299\"));\n"
+"    assert!(!luhn(\"4539 3195 0343 6476\"));\n"
+"    assert!(!luhn(\"8273 1232 7352 0569\"));\n"
+"}\n"
+"// ANCHOR_END: unit-tests\n"
+"```"
+msgstr ""
+
+#: src/exercises/day-2/solutions-afternoon.md:98
+msgid "## Strings and Iterators"
+msgstr ""
+
+#: src/exercises/day-2/solutions-afternoon.md:100
+msgid "([back to exercise](strings-iterators.md))"
+msgstr ""
+
+#: src/exercises/day-2/solutions-afternoon.md:117
+msgid ""
+"// ANCHOR: prefix_matches\n"
+"pub fn prefix_matches(prefix: &str, request_path: &str) -> bool {\n"
+"    // ANCHOR_END: prefix_matches\n"
+"    let prefixes = prefix.split('/');\n"
+"    let request_paths = request_path\n"
+"        .split('/')\n"
+"        .map(|p| Some(p))\n"
+"        .chain(std::iter::once(None));"
+msgstr ""
+
+#: src/exercises/day-2/solutions-afternoon.md:126
+msgid ""
+"    for (prefix, request_path) in prefixes.zip(request_paths) {\n"
+"        match request_path {\n"
+"            Some(request_path) => {\n"
+"                if (prefix != \"*\") && (prefix != request_path) {\n"
+"                    return false;\n"
+"                }\n"
+"            }\n"
+"            None => return false,\n"
+"        }\n"
+"    }\n"
+"    true\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-2/solutions-afternoon.md:139
+msgid ""
+"// ANCHOR: unit-tests\n"
+"#[test]\n"
+"fn test_matches_without_wildcard() {\n"
+"    assert!(prefix_matches(\"/v1/publishers\", \"/v1/publishers\"));\n"
+"    assert!(prefix_matches(\"/v1/publishers\", "
+"\"/v1/publishers/abc-123\"));\n"
+"    assert!(prefix_matches(\"/v1/publishers\", "
+"\"/v1/publishers/abc/books\"));"
+msgstr ""
+
+#: src/exercises/day-2/solutions-afternoon.md:166
+msgid ""
+"    assert!(!prefix_matches(\"/v1/publishers/*/books\", "
+"\"/v1/publishers\"));\n"
+"    assert!(!prefix_matches(\n"
+"        \"/v1/publishers/*/books\",\n"
+"        \"/v1/publishers/foo/booksByAuthor\"\n"
+"    ));\n"
+"}\n"
+"// ANCHOR_END: unit-tests\n"
+"```"
+msgstr ""
+
+#: src/exercises/day-3/solutions-morning.md:1
+msgid "# Day 3 Morning Exercise"
+msgstr ""
+
+#: src/exercises/day-3/solutions-morning.md:3
+msgid "## A Simple GUI Library"
+msgstr ""
+
+#: src/exercises/day-3/solutions-morning.md:5
+msgid "([back to exercise](simple-gui.md))"
+msgstr ""
+
+#: src/exercises/day-3/solutions-morning.md:22
+msgid ""
+"// ANCHOR: setup\n"
+"pub trait Widget {\n"
+"    /// Natural width of `self`.\n"
+"    fn width(&self) -> usize;"
+msgstr ""
+
+#: src/exercises/day-3/solutions-morning.md:82
+msgid "// ANCHOR_END: setup"
+msgstr ""
+
+#: src/exercises/day-3/solutions-morning.md:84
+msgid ""
+"// ANCHOR: Window-width\n"
+"impl Widget for Window {\n"
+"    fn width(&self) -> usize {\n"
+"        // ANCHOR_END: Window-width\n"
+"        std::cmp::max(\n"
+"            self.title.chars().count(),\n"
+"            self.widgets.iter().map(|w| w.width()).max().unwrap_or(0),\n"
+"        )\n"
+"    }"
+msgstr ""
+
+#: src/exercises/day-3/solutions-morning.md:94
+msgid ""
+"    // ANCHOR: Window-draw_into\n"
+"    fn draw_into(&self, buffer: &mut dyn std::fmt::Write) {\n"
+"        // ANCHOR_END: Window-draw_into\n"
+"        let mut inner = String::new();\n"
+"        for widget in &self.widgets {\n"
+"            widget.draw_into(&mut inner);\n"
+"        }"
+msgstr ""
+
+#: src/exercises/day-3/solutions-morning.md:102
+msgid "        let window_width = self.width();"
+msgstr ""
+
+#: src/exercises/day-3/solutions-morning.md:104
+msgid ""
+"        // TODO: after learning about error handling, you can change\n"
+"        // draw_into to return Result<(), std::fmt::Error>. Then use\n"
+"        // the ?-operator here instead of .unwrap().\n"
+"        writeln!(buffer, \"+-{:-<window_width$}-+\", \"\").unwrap();\n"
+"        writeln!(buffer, \"| {:^window_width$} |\", &self.title).unwrap();\n"
+"        writeln!(buffer, \"+={:=<window_width$}=+\", \"\").unwrap();\n"
+"        for line in inner.lines() {\n"
+"            writeln!(buffer, \"| {:window_width$} |\", line).unwrap();\n"
+"        }\n"
+"        writeln!(buffer, \"+-{:-<window_width$}-+\", \"\").unwrap();\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-3/solutions-morning.md:117
+msgid ""
+"// ANCHOR: Button-width\n"
+"impl Widget for Button {\n"
+"    fn width(&self) -> usize {\n"
+"        // ANCHOR_END: Button-width\n"
+"        self.label.width() + 8 // add a bit of padding\n"
+"    }"
+msgstr ""
+
+#: src/exercises/day-3/solutions-morning.md:124
+msgid ""
+"    // ANCHOR: Button-draw_into\n"
+"    fn draw_into(&self, buffer: &mut dyn std::fmt::Write) {\n"
+"        // ANCHOR_END: Button-draw_into\n"
+"        let width = self.width();\n"
+"        let mut label = String::new();\n"
+"        self.label.draw_into(&mut label);"
+msgstr ""
+
+#: src/exercises/day-3/solutions-morning.md:131
+msgid ""
+"        writeln!(buffer, \"+{:-<width$}+\", \"\").unwrap();\n"
+"        for line in label.lines() {\n"
+"            writeln!(buffer, \"|{:^width$}|\", &line).unwrap();\n"
+"        }\n"
+"        writeln!(buffer, \"+{:-<width$}+\", \"\").unwrap();\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-3/solutions-morning.md:139
+msgid ""
+"// ANCHOR: Label-width\n"
+"impl Widget for Label {\n"
+"    fn width(&self) -> usize {\n"
+"        // ANCHOR_END: Label-width\n"
+"        self.label\n"
+"            .lines()\n"
+"            .map(|line| line.chars().count())\n"
+"            .max()\n"
+"            .unwrap_or(0)\n"
+"    }"
+msgstr ""
+
+#: src/exercises/day-3/solutions-morning.md:150
+msgid ""
+"    // ANCHOR: Label-draw_into\n"
+"    fn draw_into(&self, buffer: &mut dyn std::fmt::Write) {\n"
+"        // ANCHOR_END: Label-draw_into\n"
+"        writeln!(buffer, \"{}\", &self.label).unwrap();\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-3/solutions-morning.md:157
+msgid ""
+"// ANCHOR: main\n"
+"fn main() {\n"
+"    let mut window = Window::new(\"Rust GUI Demo 1.23\");\n"
+"    window.add_widget(Box::new(Label::new(\"This is a small text GUI "
+"demo.\")));\n"
+"    window.add_widget(Box::new(Button::new(\n"
+"        \"Click me!\",\n"
+"        Box::new(|| println!(\"You clicked the button!\")),\n"
+"    )));\n"
+"    window.draw();\n"
+"}\n"
+"// ANCHOR_END: main\n"
+"```"
+msgstr ""
+
+#: src/exercises/day-3/solutions-afternoon.md:1
+msgid "# Day 3 Afternoon Exercises"
+msgstr ""
+
+#: src/exercises/day-3/solutions-afternoon.md:3
+msgid "## Safe FFI Wrapper"
+msgstr ""
+
+#: src/exercises/day-3/solutions-afternoon.md:5
+msgid "([back to exercise](safe-ffi-wrapper.md))"
+msgstr ""
+
+#: src/exercises/day-3/solutions-afternoon.md:22
+msgid ""
+"// ANCHOR: ffi\n"
+"mod ffi {\n"
+"    use std::os::raw::{c_char, c_int, c_long, c_ulong, c_ushort};"
+msgstr ""
+
+#: src/exercises/day-3/solutions-afternoon.md:53
+msgid ""
+"#[derive(Debug)]\n"
+"struct DirectoryIterator {\n"
+"    path: CString,\n"
+"    dir: *mut ffi::DIR,\n"
+"}\n"
+"// ANCHOR_END: ffi"
+msgstr ""
+
+#: src/exercises/day-3/solutions-afternoon.md:60
+msgid ""
+"// ANCHOR: DirectoryIterator\n"
+"impl DirectoryIterator {\n"
+"    fn new(path: &str) -> Result<DirectoryIterator, String> {\n"
+"        // Call opendir and return a Ok value if that worked,\n"
+"        // otherwise return Err with a message.\n"
+"        // ANCHOR_END: DirectoryIterator\n"
+"        let path = CString::new(path).map_err(|err| format!(\"Invalid path: "
+"{err}\"))?;\n"
+"        // SAFETY: path.as_ptr() cannot be NULL.\n"
+"        let dir = unsafe { ffi::opendir(path.as_ptr()) };\n"
+"        if dir.is_null() {\n"
+"            Err(format!(\"Could not open {:?}\", path))\n"
+"        } else {\n"
+"            Ok(DirectoryIterator { path, dir })\n"
+"        }\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-3/solutions-afternoon.md:77
+msgid ""
+"// ANCHOR: Iterator\n"
+"impl Iterator for DirectoryIterator {\n"
+"    type Item = OsString;\n"
+"    fn next(&mut self) -> Option<OsString> {\n"
+"        // Keep calling readdir until we get a NULL pointer back.\n"
+"        // ANCHOR_END: Iterator\n"
+"        // SAFETY: self.dir is never NULL.\n"
+"        let dirent = unsafe { ffi::readdir(self.dir) };\n"
+"        if dirent.is_null() {\n"
+"            // We have reached the end of the directory.\n"
+"            return None;\n"
+"        }\n"
+"        // SAFETY: dirent is not NULL and dirent.d_name is NUL\n"
+"        // terminated.\n"
+"        let d_name = unsafe { CStr::from_ptr((*dirent).d_name.as_ptr()) };\n"
+"        let os_str = OsStr::from_bytes(d_name.to_bytes());\n"
+"        Some(os_str.to_owned())\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-3/solutions-afternoon.md:97
+msgid ""
+"// ANCHOR: Drop\n"
+"impl Drop for DirectoryIterator {\n"
+"    fn drop(&mut self) {\n"
+"        // Call closedir as needed.\n"
+"        // ANCHOR_END: Drop\n"
+"        if !self.dir.is_null() {\n"
+"            // SAFETY: self.dir is not NULL.\n"
+"            if unsafe { ffi::closedir(self.dir) } != 0 {\n"
+"                panic!(\"Could not close {:?}\", self.path);\n"
+"            }\n"
+"        }\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-3/solutions-afternoon.md:111
+msgid ""
+"// ANCHOR: main\n"
+"fn main() -> Result<(), String> {\n"
+"    let iter = DirectoryIterator::new(\".\")?;\n"
+"    println!(\"files: {:#?}\", iter.collect::<Vec<_>>());\n"
+"    Ok(())\n"
+"}\n"
+"// ANCHOR_END: main\n"
+"```"
+msgstr ""
+
+#: src/exercises/day-4/solutions-morning.md:1
+msgid "# Day 4 Morning Exercise"
+msgstr ""
+
+#: src/exercises/day-4/solutions-morning.md:3
+msgid "## Dining Philosophers"
+msgstr ""
+
+#: src/exercises/day-4/solutions-morning.md:5
+msgid "([back to exercise](dining-philosophers.md))"
+msgstr ""
+
+#: src/exercises/day-4/solutions-morning.md:22
+msgid ""
+"// ANCHOR: Philosopher\n"
+"use std::sync::mpsc;\n"
+"use std::sync::{Arc, Mutex};\n"
+"use std::thread;\n"
+"use std::time::Duration;"
+msgstr ""
+
+#: src/exercises/day-4/solutions-morning.md:30
+msgid ""
+"struct Philosopher {\n"
+"    name: String,\n"
+"    // ANCHOR_END: Philosopher\n"
+"    left_fork: Arc<Mutex<Fork>>,\n"
+"    right_fork: Arc<Mutex<Fork>>,\n"
+"    thoughts: mpsc::SyncSender<String>,\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-4/solutions-morning.md:38
+msgid ""
+"// ANCHOR: Philosopher-think\n"
+"impl Philosopher {\n"
+"    fn think(&self) {\n"
+"        self.thoughts\n"
+"            .send(format!(\"Eureka! {} has a new idea!\", &self.name))\n"
+"            .unwrap();\n"
+"    }\n"
+"    // ANCHOR_END: Philosopher-think"
+msgstr ""
+
+#: src/exercises/day-4/solutions-morning.md:47
+msgid ""
+"    // ANCHOR: Philosopher-eat\n"
+"    fn eat(&self) {\n"
+"        // ANCHOR_END: Philosopher-eat\n"
+"        println!(\"{} is trying to eat\", &self.name);\n"
+"        let left = self.left_fork.lock().unwrap();\n"
+"        let right = self.right_fork.lock().unwrap();"
+msgstr ""
+
+#: src/exercises/day-4/solutions-morning.md:54
+msgid ""
+"        // ANCHOR: Philosopher-eat-end\n"
+"        println!(\"{} is eating...\", &self.name);\n"
+"        thread::sleep(Duration::from_millis(10));\n"
+"    }\n"
+"}"
+msgstr ""
+
+#: src/exercises/day-4/solutions-morning.md:63
+msgid ""
+"fn main() {\n"
+"    // ANCHOR_END: Philosopher-eat-end\n"
+"    let (tx, rx) = mpsc::sync_channel(10);"
+msgstr ""
+
+#: src/exercises/day-4/solutions-morning.md:67
+msgid ""
+"    let forks = (0..PHILOSOPHERS.len())\n"
+"        .map(|_| Arc::new(Mutex::new(Fork)))\n"
+"        .collect::<Vec<_>>();"
+msgstr ""
+
+#: src/exercises/day-4/solutions-morning.md:71
+msgid ""
+"    for i in 0..forks.len() {\n"
+"        let tx = tx.clone();\n"
+"        let mut left_fork = forks[i].clone();\n"
+"        let mut right_fork = forks[(i + 1) % forks.len()].clone();"
+msgstr ""
+
+#: src/exercises/day-4/solutions-morning.md:76
+msgid ""
+"        // To avoid a deadlock, we have to break the symmetry\n"
+"        // somewhere. This will swap the forks without deinitializing\n"
+"        // either of them.\n"
+"        if i == forks.len() - 1 {\n"
+"            std::mem::swap(&mut left_fork, &mut right_fork);\n"
+"        }"
+msgstr ""
+
+#: src/exercises/day-4/solutions-morning.md:83
+msgid ""
+"        let philosopher = Philosopher {\n"
+"            name: PHILOSOPHERS[i].to_string(),\n"
+"            thoughts: tx,\n"
+"            left_fork,\n"
+"            right_fork,\n"
+"        };"
+msgstr ""
+
+#: src/exercises/day-4/solutions-morning.md:90
+msgid ""
+"        thread::spawn(move || {\n"
+"            for _ in 0..100 {\n"
+"                philosopher.eat();\n"
+"                philosopher.think();\n"
+"            }\n"
+"        });\n"
+"    }"
+msgstr ""
+
+#: src/exercises/day-4/solutions-morning.md:98
+msgid ""
+"    drop(tx);\n"
+"    for thought in rx {\n"
+"        println!(\"{}\", thought);\n"
+"    }\n"
+"}\n"
+"```"
+msgstr ""
+