diff --git a/priprava/rust_priprava13.md b/priprava/rust_priprava13.md
new file mode 100644
index 0000000..b888a7c
--- /dev/null
+++ b/priprava/rust_priprava13.md
@@ -0,0 +1,820 @@
+# I/O v Ruste — krok za krokom
+
+Každá kapitola: prečítaj, pozri príklady, urob úlohy. Až potom choď ďalej.
+
+---
+
+## Kapitola 1: println! a print! — výstup
+
+```rust
+// println! — vypíše + nový riadok
+println!("Ahoj svet");
+// Ahoj svet\n
+
+// print! — vypíše BEZ nového riadku
+print!("Zadaj meno: ");
+// Zadaj meno: _   (kurzor zostane na tom istom riadku)
+```
+
+### Formátovanie
+
+```rust
+let meno = "Anna";
+let vek = 25;
+let priemer = 1.847;
+
+// Základné
+println!("{} má {} rokov", meno, vek);
+// Anna má 25 rokov
+
+// Zaokrúhlenie na 2 desatinné
+println!("Priemer: {:.2}", priemer);
+// Priemer: 1.85
+
+// Zarovnanie
+println!("{:<10} | {:>5}", "Meno", "Vek");
+println!("{:<10} | {:>5}", "Anna", 25);
+println!("{:<10} | {:>5}", "Boris", 30);
+// Meno       |   Vek
+// Anna       |    25
+// Boris      |    30
+
+// Padding znakom
+println!("{:-^20}", "MENU");
+// --------MENU--------
+
+// Debug výpis
+let vektor = vec![1, 2, 3];
+println!("{:?}", vektor);     // [1, 2, 3]
+println!("{:#?}", vektor);    // pekný formát na viac riadkov
+```
+
+### eprintln! — chybový výstup
+
+```rust
+// eprintln! ide na stderr (nie stdout)
+eprintln!("Chyba: súbor neexistuje");
+
+// V praxi: normálne správy cez println!, chyby cez eprintln!
+```
+
+### Úlohy 1
+
+**1a.** Vypíš tabuľku 3 produktov s názvom (zarovnaný vľavo na 15), cenou (zarovnaná vpravo na 8, 2 desatinné) a počtom (zarovnaný vpravo na 5):
+```
+Chlieb          |     1.20 |    50
+Mlieko          |     0.89 |   120
+Maslo           |     2.49 |    30
+```
+
+**1b.** Máš Vec<(String, f64)> — mená a priemery. Vypíš ich zoradené podľa priemeru, formátované na 1 desatinné miesto.
+
+---
+
+## Kapitola 2: stdin — čítanie vstupu
+
+```rust
+use std::io;
+
+fn main() {
+    // Základné čítanie riadku
+    let mut vstup = String::new();
+    io::stdin().read_line(&mut vstup).unwrap();
+    // vstup teraz obsahuje text + '\n' na konci!
+
+    let vstup = vstup.trim();  // odstráň \n a medzery
+    println!("Napísal si: {}", vstup);
+}
+```
+
+### Krok po kroku
+
+```rust
+// 1. Vytvor prázdny String (buffer)
+let mut vstup = String::new();
+
+// 2. Prečítaj riadok do bufferu
+//    read_line PRIDÁVA do stringu (neprepisuje!)
+//    Vracia Result<usize, io::Error>  (počet prečítaných bajtov)
+io::stdin().read_line(&mut vstup).unwrap();
+
+// 3. VŽDY trimni — read_line pridáva '\n'
+let vstup = vstup.trim();
+```
+
+### Čítanie čísla
+
+```rust
+fn nacitaj_cislo() -> Option<i32> {
+    let mut vstup = String::new();
+    io::stdin().read_line(&mut vstup).ok()?;
+    vstup.trim().parse().ok()
+}
+
+// Použitie:
+match nacitaj_cislo() {
+    Some(n) => println!("Číslo: {}", n),
+    None => println!("To nie je číslo"),
+}
+```
+
+### Čítanie jedného znaku
+
+```rust
+fn nacitaj_znak() -> Option<char> {
+    let mut vstup = String::new();
+    std::io::stdin().read_line(&mut vstup).ok()?;
+    vstup.trim().chars().next()
+}
+
+// Použitie:
+match nacitaj_znak() {
+    Some(c) => println!("Znak: {}", c),
+    None => println!("Prázdny vstup"),
+}
+```
+
+### Pozor: read_line pridáva, neprepisuje!
+
+```rust
+let mut vstup = String::new();
+io::stdin().read_line(&mut vstup).unwrap();  // "ahoj\n"
+io::stdin().read_line(&mut vstup).unwrap();  // "ahoj\nsvet\n" — PRIDALO!
+
+// Ak chceš čítať viackrát, buď trimuj alebo vytvor nový String
+let mut vstup = String::new();
+io::stdin().read_line(&mut vstup).unwrap();
+let prvy = vstup.trim().to_string();
+
+vstup.clear();  // VYMAŽ pred ďalším čítaním!
+io::stdin().read_line(&mut vstup).unwrap();
+let druhy = vstup.trim().to_string();
+```
+
+### Úlohy 2
+
+**2a.** Napíš program, ktorý prečíta meno a vek od používateľa a vypíše `"Ahoj Anna, máš 25 rokov"`. Vek parsuj na u32.
+
+**2b.** Napíš funkciu `nacitaj_riadok() -> Option<String>` — prečíta riadok, trimne, vráti None ak je prázdny.
+
+**2c.** Napíš funkciu `nacitaj_float() -> Option<f64>` — prečíta riadok, trimne, parsne na f64.
+
+**2d.** Napíš program, ktorý opakovane číta čísla od používateľa kým nezadá "koniec". Na konci vypíše súčet.
+
+---
+
+## Kapitola 3: Game loop — opakované čítanie
+
+Na skúške je typický vzor: čítaj vstup v cykle, reaguj, skonči keď podmienka.
+
+### Základný game loop
+
+```rust
+use std::io;
+
+fn main() {
+    loop {
+        print!("Zadaj príkaz: ");
+
+        let mut vstup = String::new();
+        io::stdin().read_line(&mut vstup).unwrap();
+        let vstup = vstup.trim();
+
+        match vstup {
+            "koniec" => {
+                println!("Zbohom!");
+                break;
+            }
+            "pomoc" => {
+                println!("Príkazy: koniec, pomoc");
+            }
+            _ => {
+                println!("Neznámy príkaz: {}", vstup);
+            }
+        }
+    }
+}
+```
+
+### Game loop s parsovaním
+
+```rust
+loop {
+    print!("> ");
+    let mut vstup = String::new();
+    io::stdin().read_line(&mut vstup).unwrap();
+    let casti: Vec<&str> = vstup.trim().split_whitespace().collect();
+
+    if casti.is_empty() { continue; }
+
+    match casti[0] {
+        "pridaj" => {
+            if casti.len() < 2 {
+                println!("Použitie: pridaj <meno>");
+                continue;
+            }
+            let meno = casti[1];
+            println!("Pridávam: {}", meno);
+        }
+        "vypis" => {
+            println!("Výpis...");
+        }
+        "koniec" => break,
+        _ => println!("Neznámy príkaz"),
+    }
+}
+```
+
+### Úlohy 3
+
+**3a.** Napíš jednoduchý kalkulátor. Používateľ zadáva `"5 + 3"`, `"10 - 4"`, `"koniec"`. Program počíta a vypisuje výsledok.
+
+**3b.** Napíš program, kde používateľ opakovane háda číslo 1-100. Program povie "viac", "menej" alebo "správne". Použi `rand::Rng`.
+
+---
+
+## Kapitola 4: Súborové I/O — čítanie
+
+```rust
+use std::fs;
+
+// Prečítaj celý súbor naraz do String
+let obsah: Result<String, std::io::Error> = fs::read_to_string("data.txt");
+
+match obsah {
+    Ok(text) => println!("Obsah: {}", text),
+    Err(e) => println!("Chyba: {}", e),
+}
+
+// Skrátene s .ok()? v funkcii
+fn nacitaj(cesta: &str) -> Option<String> {
+    fs::read_to_string(cesta).ok()
+}
+```
+
+### Čítanie po riadkoch
+
+```rust
+use std::fs;
+
+fn spracuj_subor(cesta: &str) {
+    let obsah = fs::read_to_string(cesta).unwrap();
+    for (i, riadok) in obsah.lines().enumerate() {
+        println!("{}: {}", i + 1, riadok);
+    }
+}
+```
+
+### BufReader — efektívne čítanie po riadkoch
+
+Pre veľké súbory je lepší BufReader — nečíta celý súbor do pamäte:
+
+```rust
+use std::fs::File;
+use std::io::{BufRead, BufReader};
+
+fn citaj_po_riadkoch(cesta: &str) -> Result<(), std::io::Error> {
+    let subor = File::open(cesta)?;
+    let citac = BufReader::new(subor);
+
+    for riadok in citac.lines() {
+        let riadok = riadok?;  // každý riadok je Result
+        println!("{}", riadok);
+    }
+    Ok(())
+}
+```
+
+### Čítanie bajtov
+
+```rust
+// Celý súbor ako bajty
+let bajty: Vec<u8> = fs::read("obrazok.png").unwrap();
+println!("Veľkosť: {} bajtov", bajty.len());
+```
+
+### Úlohy 4
+
+**4a.** Napíš funkciu `pocet_riadkov(cesta: &str) -> Option<usize>` — prečíta súbor a vráti počet riadkov.
+
+**4b.** Napíš funkciu `najdi_v_subore(cesta: &str, hladany: &str) -> Vec<String>` — vráti riadky, ktoré obsahujú hľadaný text.
+
+**4c.** Napíš funkciu `nacitaj_cisla(cesta: &str) -> Option<Vec<i32>>` — súbor obsahuje jedno číslo na riadok. Prečítaj, parsuj, vráť Vec.
+
+---
+
+## Kapitola 5: Súborové I/O — zápis
+
+```rust
+use std::fs;
+
+// Zapíš celý String do súboru (prepíše ak existuje!)
+fs::write("data.txt", "Ahoj svet\nDruhý riadok\n").unwrap();
+
+// Bezpečná verzia v funkcii
+fn uloz(cesta: &str, obsah: &str) -> bool {
+    fs::write(cesta, obsah).is_ok()
+}
+```
+
+### Pridávanie na koniec (append)
+
+```rust
+use std::fs::OpenOptions;
+use std::io::Write;
+
+fn pripis(cesta: &str, text: &str) -> bool {
+    let vysledok = OpenOptions::new()
+        .create(true)     // vytvor ak neexistuje
+        .append(true)     // pridávaj na koniec
+        .open(cesta);
+
+    match vysledok {
+        Ok(mut subor) => {
+            writeln!(subor, "{}", text).is_ok()
+        }
+        Err(_) => false,
+    }
+}
+```
+
+### BufWriter — efektívny zápis
+
+```rust
+use std::fs::File;
+use std::io::{BufWriter, Write};
+
+fn zapis_vela_riadkov(cesta: &str, riadky: &[String]) -> bool {
+    let Ok(subor) = File::create(cesta) else {
+        return false;
+    };
+    let mut writer = BufWriter::new(subor);
+    for riadok in riadky {
+        if writeln!(writer, "{}", riadok).is_err() {
+            return false;
+        }
+    }
+    true
+}
+```
+
+### Úlohy 5
+
+**5a.** Napíš funkciu `uloz_riadky(cesta: &str, riadky: &[String]) -> bool` — ulož vektor riadkov do súboru, každý na nový riadok.
+
+**5b.** Napíš funkciu `pridaj_riadok(cesta: &str, riadok: &str) -> bool` — pridaj riadok na koniec súboru.
+
+**5c.** Napíš program, ktorý číta mená od používateľa a ukladá ich do `"mena.txt"`. Keď zadá "koniec", skončí.
+
+---
+
+## Kapitola 6: PathBuf a Path
+
+`PathBuf` je ako `String` pre cesty k súborom. `Path` je ako `&str`.
+
+```rust
+use std::path::{PathBuf, Path};
+
+// Vytváranie PathBuf
+let cesta = PathBuf::from("data/subory/kniznica.json");
+let cesta: PathBuf = "data.json".into();
+
+// Z &str
+let cesta = Path::new("data.json");
+
+// Konverzia
+let pathbuf = PathBuf::from("data.json");
+let path: &Path = &pathbuf;           // PathBuf → &Path
+let path: &Path = pathbuf.as_path();   // to isté
+
+// Užitočné metódy
+let cesta = PathBuf::from("/home/user/data.json");
+cesta.exists();                   // existuje súbor?
+cesta.is_file();                  // je to súbor?
+cesta.is_dir();                   // je to priečinok?
+cesta.extension();                // Some("json")
+cesta.file_name();                // Some("data.json")
+cesta.parent();                   // Some("/home/user")
+
+// Skladanie ciest
+let mut cesta = PathBuf::from("/home/user");
+cesta.push("dokumenty");
+cesta.push("subor.txt");
+// /home/user/dokumenty/subor.txt
+```
+
+### Na skúške — PathBuf v clape
+
+```rust
+use clap::Parser;
+use std::path::PathBuf;
+
+#[derive(Parser)]
+struct Args {
+    #[arg(short, long, default_value = "data.json")]
+    subor: PathBuf,
+}
+
+fn main() {
+    let args = Args::parse();
+    // args.subor je PathBuf — predávaš priamo do funkcií
+    let kniznica = Kniznica::nacitaj_zo_suboru(&args.subor)
+        .unwrap_or_default();
+}
+```
+
+### Funkcie berúce cestu
+
+```rust
+// Berie &PathBuf — funguje s PathBuf
+fn nacitaj(cesta: &PathBuf) -> Option<String> {
+    std::fs::read_to_string(cesta).ok()
+}
+
+// Lepšie: berie &Path — funguje s PathBuf aj &str
+fn nacitaj(cesta: &Path) -> Option<String> {
+    std::fs::read_to_string(cesta).ok()
+}
+
+// fs::read_to_string berie impl AsRef<Path> — prijme takmer čokoľvek
+// Preto funguje:
+fs::read_to_string("data.json");           // &str
+fs::read_to_string(String::from("data.json")); // String
+fs::read_to_string(PathBuf::from("data.json")); // PathBuf
+fs::read_to_string(&pathbuf);             // &PathBuf
+```
+
+### Úlohy 6
+
+**6a.** Vytvor PathBuf z `"/home/user/docs"`. Pridaj `"projekt"` a `"data.json"`. Vypíš celú cestu.
+
+**6b.** Máš PathBuf. Vypíš: existuje? Je súbor? Prípona? Názov súboru? Rodičovský priečinok?
+
+**6c.** Prečo na skúške metóda `nacitaj_zo_suboru` berie `&PathBuf` a nie `&str`?
+
+---
+
+## Kapitola 7: serde JSON I/O — kompletný vzor
+
+Toto je vzor na každej skúške. Kombinácia fs + serde_json.
+
+```rust
+use std::fs;
+use std::path::PathBuf;
+use serde::{Serialize, Deserialize};
+
+#[derive(Serialize, Deserialize, Default)]
+struct Kniznica {
+    knihy: Vec<Kniha>,
+}
+
+#[derive(Serialize, Deserialize, Clone)]
+struct Kniha {
+    nazov: String,
+    autor: String,
+}
+
+impl Kniznica {
+    // ČÍTANIE: súbor → String → štruktúra
+    fn nacitaj_zo_suboru(cesta: &PathBuf) -> Option<Kniznica> {
+        //  1. fs::read_to_string  — súbor → String
+        let raw = fs::read_to_string(cesta).ok()?;
+        //  2. serde_json::from_str — String → štruktúra
+        serde_json::from_str(&raw).ok()
+    }
+
+    // ZÁPIS: štruktúra → String → súbor
+    fn uloz_do_suboru(&self, cesta: &PathBuf) -> bool {
+        //  1. serde_json::to_string_pretty — štruktúra → String
+        let Ok(json) = serde_json::to_string_pretty(&self) else {
+            return false;
+        };
+        //  2. fs::write — String → súbor
+        fs::write(cesta, json).is_ok()
+    }
+}
+```
+
+Celý tok dát:
+
+```
+ČÍTANIE:
+  súbor na disku
+    → fs::read_to_string → String s JSON textom
+    → serde_json::from_str → Rust štruktúra
+
+ZÁPIS:
+  Rust štruktúra
+    → serde_json::to_string_pretty → String s JSON textom
+    → fs::write → súbor na disku
+```
+
+### Použitie v main
+
+```rust
+fn main() {
+    let cesta = PathBuf::from("kniznica.json");
+
+    // Načítaj alebo vytvor prázdnu
+    let mut kniznica = Kniznica::nacitaj_zo_suboru(&cesta)
+        .unwrap_or_default();
+
+    // Urob niečo...
+    kniznica.knihy.push(Kniha {
+        nazov: "Duna".into(),
+        autor: "Herbert".into(),
+    });
+
+    // Ulož
+    kniznica.uloz_do_suboru(&cesta);
+}
+```
+
+### Čo sa deje keď súbor neexistuje
+
+```rust
+// fs::read_to_string("neexistuje.json")
+//   → Err(io::Error)
+//   → .ok()  → None
+//   → ?      → vráti None z funkcie
+
+// Preto:
+Kniznica::nacitaj_zo_suboru(&PathBuf::from("neexistuje.json"))
+// → None
+
+// A v main:
+let mut kniznica = Kniznica::nacitaj_zo_suboru(&cesta)
+    .unwrap_or_default();
+// None → unwrap_or_default() → Kniznica::default() → Kniznica { knihy: vec![] }
+```
+
+### Úlohy 7
+
+**7a.** Napíš `nacitaj_zo_suboru` a `uloz_do_suboru` pre:
+```rust
+#[derive(Serialize, Deserialize, Default)]
+struct TodoList {
+    ulohy: Vec<Todo>,
+}
+#[derive(Serialize, Deserialize, Clone)]
+struct Todo {
+    text: String,
+    hotova: bool,
+}
+```
+
+**7b.** Napíš program, ktorý:
+1. Načíta TodoList z "todo.json"
+2. Pridá novú úlohu
+3. Uloží späť
+4. Znova načíta a vypíše počet úloh (overenie)
+
+**7c.** Čo sa stane ak `serde_json::to_string_pretty` zlyhá? Kedy sa to stane? (Hint: takmer nikdy pre bežné štruktúry.)
+
+---
+
+## Kapitola 8: IOManager trait — vzor zo skúšky
+
+Na skúške sa I/O abstrahuje cez trait. Toto umožňuje testovanie bez konzoly.
+
+### Prečo nie priamo stdin?
+
+```rust
+// PROBLÉM: toto nejde testovať automaticky
+fn hraj(hra: &mut Hra) {
+    let mut vstup = String::new();
+    io::stdin().read_line(&mut vstup).unwrap();  // čaká na konzolu
+    // ...
+}
+```
+
+### Riešenie: IOManager trait
+
+```rust
+// 1. Definuj trait — AKO získať vstup
+pub trait IOManager {
+    fn ziskaj_pismeno(&mut self) -> char;
+}
+
+// 2. Reálna implementácia — čítaj z konzoly
+pub struct ConsoleIOManager;
+
+impl IOManager for ConsoleIOManager {
+    fn ziskaj_pismeno(&mut self) -> char {
+        let mut vstup = String::new();
+        std::io::stdin().read_line(&mut vstup).unwrap();
+        vstup.trim().chars().next().unwrap_or(' ')
+    }
+}
+
+// 3. Metóda berie impl IOManager — funguje s čímkoľvek
+impl Hra {
+    pub fn hraj(&mut self, mut io: impl IOManager) {
+        while !self.je_koniec_hry() {
+            println!("Slovo: {}", self.daj_slovo_skryto());
+            let pismeno = io.ziskaj_pismeno();
+            let vysledok = self.tipni_pismeno(pismeno);
+            println!("{}", vysledok);
+        }
+    }
+}
+
+// 4. Volanie v main
+fn main() {
+    let mut hra = Hra::new("rust");
+    hra.hraj(ConsoleIOManager);  // predáme implementáciu
+}
+```
+
+### ConsoleIOManager — prázdna štruktúra
+
+```rust
+// Prázdna štruktúra — žiadne členy
+pub struct ConsoleIOManager;
+
+// Toto nie je typ s poľami. Je to "unit struct".
+// Vytváraš ju bez {} :
+let io = ConsoleIOManager;       // OK
+// let io = ConsoleIOManager {};  // tiež OK ale zbytočné
+```
+
+### Rozšírený IOManager
+
+Niekedy trait má viac metód:
+
+```rust
+pub trait IOManager {
+    fn ziskaj_pismeno(&mut self) -> char;
+    fn zobraz_spravu(&self, sprava: &str);
+    fn zobraz_stav(&self, zivoty: u8, slovo: &str, skusane: &[char]);
+}
+
+pub struct ConsoleIOManager;
+
+impl IOManager for ConsoleIOManager {
+    fn ziskaj_pismeno(&mut self) -> char {
+        print!("Zadaj písmeno: ");
+        let mut vstup = String::new();
+        std::io::stdin().read_line(&mut vstup).unwrap();
+        vstup.trim().chars().next().unwrap_or(' ')
+    }
+
+    fn zobraz_spravu(&self, sprava: &str) {
+        println!("{}", sprava);
+    }
+
+    fn zobraz_stav(&self, zivoty: u8, slovo: &str, skusane: &[char]) {
+        println!("Životov: {}", zivoty);
+        println!("Slovo: {}", slovo);
+        println!("Skúšané: {:?}", skusane);
+    }
+}
+```
+
+### Úlohy 8
+
+**8a.** Napíš trait `Vstup` s metódou `nacitaj_cislo(&mut self) -> Option<i32>`. Implementuj:
+- `KonzolaVstup` — číta z stdin
+- `TestovaciVstup { cisla: Vec<i32>, index: usize }` — vracia predpripravené čísla
+
+**8b.** Napíš funkciu `hadaj_cislo(tajne: i32, mut vstup: impl Vstup)` — hra na hádanie čísla. Používa trait namiesto priameho stdin.
+
+**8c.** Máš IOManager z príkladu vyššie. Napíš `TestIOManager`:
+```rust
+struct TestIOManager {
+    odpovede: Vec<char>,
+    index: usize,
+}
+```
+Implementuj IOManager — `ziskaj_pismeno` vráti ďalšie písmeno z `odpovede`.
+
+---
+
+## Kapitola 9: flush — print! bez nového riadku
+
+`print!` nevyprázdni buffer automaticky. Ak chceš aby sa text zobrazil okamžite pred čítaním vstupu:
+
+```rust
+use std::io::{self, Write};
+
+fn main() {
+    print!("Zadaj meno: ");
+    io::stdout().flush().unwrap();  // DÔLEŽITÉ! Vynúti výpis
+
+    let mut vstup = String::new();
+    io::stdin().read_line(&mut vstup).unwrap();
+    println!("Ahoj, {}!", vstup.trim());
+}
+```
+
+Bez `flush()` sa "Zadaj meno: " môže zobraziť až po tom, čo zadáš vstup. S `flush()` sa zobrazí hneď.
+
+```rust
+// Kompletný vzor pre prompt
+fn prompt(text: &str) -> String {
+    print!("{}", text);
+    io::stdout().flush().unwrap();
+    let mut vstup = String::new();
+    io::stdin().read_line(&mut vstup).unwrap();
+    vstup.trim().to_string()
+}
+
+// Použitie:
+let meno = prompt("Meno: ");
+let vek = prompt("Vek: ");
+```
+
+### Úlohy 9
+
+**9a.** Napíš funkciu `prompt(text: &str) -> String` s flush. Použi ju na prečítanie mena a veku.
+
+**9b.** Napíš funkciu `prompt_cislo(text: &str) -> Option<i32>` — zobrazí text, prečíta, parsne.
+
+**9c.** Napíš interaktívny program, ktorý používa prompt funkciu na čítanie príkazov v cykle.
+
+---
+
+## Kapitola 10: Prehľad a vzory
+
+### Rýchly prehľad: čo kedy použiť
+
+| Chcem... | Použi |
+|----------|-------|
+| Čítať celý súbor | `fs::read_to_string(cesta)` |
+| Zapísať celý súbor | `fs::write(cesta, obsah)` |
+| Čítať po riadkoch (malý súbor) | `fs::read_to_string` + `.lines()` |
+| Čítať po riadkoch (veľký súbor) | `BufReader::new(File::open)` + `.lines()` |
+| Pripísať na koniec | `OpenOptions::new().append(true)` |
+| Čítať z konzoly | `io::stdin().read_line(&mut buf)` |
+| Prompt bez newline | `print!()` + `io::stdout().flush()` |
+| JSON: súbor → štruktúra | `fs::read_to_string` + `serde_json::from_str` |
+| JSON: štruktúra → súbor | `serde_json::to_string_pretty` + `fs::write` |
+| Testovateľný I/O | `trait IOManager` + `impl IOManager for ...` |
+
+### Vzor: kompletné menu programu
+
+```rust
+use std::io::{self, Write};
+use std::path::PathBuf;
+
+fn prompt(text: &str) -> String {
+    print!("{}", text);
+    io::stdout().flush().unwrap();
+    let mut vstup = String::new();
+    io::stdin().read_line(&mut vstup).unwrap();
+    vstup.trim().to_string()
+}
+
+fn main() {
+    let cesta = PathBuf::from("data.json");
+    let mut kniznica = Kniznica::nacitaj_zo_suboru(&cesta)
+        .unwrap_or_default();
+
+    loop {
+        println!("\n--- KNIŽNICA ---");
+        println!("1. Pridaj knihu");
+        println!("2. Vypíš knihy");
+        println!("3. Hľadaj");
+        println!("4. Koniec");
+
+        let volba = prompt("Vyber: ");
+
+        match volba.as_str() {
+            "1" => {
+                let nazov = prompt("Názov: ");
+                let autor = prompt("Autor: ");
+                // ... pridaj knihu
+                kniznica.uloz_do_suboru(&cesta);
+                println!("Pridané.");
+            }
+            "2" => {
+                for kniha in &kniznica.knihy {
+                    println!("{}", kniha);
+                }
+            }
+            "3" => {
+                let vyraz = prompt("Hľadaj: ");
+                // ... hľadaj
+            }
+            "4" => {
+                println!("Zbohom!");
+                break;
+            }
+            _ => println!("Neznáma voľba"),
+        }
+    }
+}
+```
+
+### Úlohy 10
+
+**10a.** Napíš kompletný interaktívny program pre TODO list:
+- Pridaj úlohu (prompt názov)
+- Označ ako hotovú (prompt index)
+- Vypíš všetky
+- Ulož do JSON
+- Koniec
+
+**10b.** Napíš program, ktorý prečíta CSV súbor (meno,vek,mesto), sparsuje riadky do Vec štruktúr, a umožní hľadanie podľa mesta.
+
+**10c.** Implementuj kompletný IOManager trait pre hru Obesenec. Vytvor aj TestIOManager, ktorý automaticky „hrá" hru s predpripravenými písmenami.