diff --git a/.github/workflows/manual-generate-release.yml b/.github/workflows/manual-generate-release.yml index 25cdaf714..90ec4c19a 100644 --- a/.github/workflows/manual-generate-release.yml +++ b/.github/workflows/manual-generate-release.yml @@ -156,6 +156,18 @@ jobs: -PinMemoryDb=false \ --no-daemon --stacktrace + # ─── Compact seforim.db: what ships (COMPACT_DB.md) ──────────────────── + # The line texts deflated with the packaging's dictionaries, the dev-only + # indexes dropped, 4 KiB pages: ~2.4x smaller. The bundle and the patch + # fan below both use it (the previous releases are compact too). + - name: Compact Seforim Database + run: | + set -euo pipefail + ./gradlew :packaging:compactDb -PcompactDb=$PWD/build/seforim.compact.db --no-daemon --stacktrace + rm -f build/seforim.db-wal build/seforim.db-shm + mv build/seforim.compact.db build/seforim.db + ls -lh build/seforim.db + - name: Package Seforim Bundle (split tar.zst) run: ./gradlew packageSeforimBundle --no-daemon --stacktrace diff --git a/COMPACT_DB.md b/COMPACT_DB.md new file mode 100644 index 000000000..ae3914afb --- /dev/null +++ b/COMPACT_DB.md @@ -0,0 +1,76 @@ +# The compact seforim.db + +The database that ships is not the generator's: `:packaging:compactDb` rewrites it, 2.5x smaller and faster to read, +for the phones (small storage, little RAM for the page cache, slow flash) as for the desktop. + +```bash +./gradlew :packaging:compactDb # build/seforim.db → build/seforim.compact.db (about 70 s) +./gradlew :packaging:compactDb -PseforimDb=… -PcompactDb=… +``` + +## What changes + +- **Line texts compressed** (`LineTextCodec`, dao, common code): one byte per Hebrew letter, nikud or taam (UTF-8 + takes two), then LZ77 against 60 KiB of the corpus' own text, LZ4's block format. 3.1x on lines of 750 bytes on + average, as much as deflate with a dictionary, but decoding is copies only: no entropy decoding, nothing to set up + per line, no native call, the same Kotlin on the JVM, Android and iOS. Deflate cost 5 µs a line on ART (JNI, the + dictionary's install, the inflate, the UTF-8), more than plain text's reading saved; this reads faster than plain + UTF-8 (2 to 3 times fewer bytes from SQLite, chars straight from a table). Each line still reads on its own, + through the same queries: `content` is `BLOB AS String`, and SQLDelight's adapter decodes it. + - A compressed value is `0xFF`, the dictionary's id, the length in Hebrew bytes, then the LZ sequences; anything + else is plain UTF-8 (the generator writes plain text, so do older databases, and both read the same way). + - The dictionary is in the database (`line_codec_dict`) and in the packaging's resources (`line_codec_dict/1.bin`): + every release compresses with the same one, so deltas carry texts that read with the client's. + `-PtrainDictionaries=` builds a new one (a release with it can't be reached by a delta: the logical hash + covers the dictionaries). + - `heRef` stays plain TEXT: short (36 bytes), compressing it would save 180 MB for a second decode per line. +- **Indexes**: `idx_line_book_index` covers `charCount` (a book's scrollbar no longer reads all its texts), + `idx_line_toc` is partial (a tenth of the lines name their TOC entry), and the indexes no query used go + (`idx_line_heref`, 313 MB; `idx_link_source_line` and `idx_link_type`, prefixes of others; `idx_toc_text`, the + UNIQUE constraint's twin). +- **Pages**: written once, in order and full (the generator's had 13% free space), 16 KiB: on flash a 16 KiB read + costs about a 4 KiB one's latency and holds 50 compressed lines, a page of the reader (4 KiB pages read 3 times + more often below). No `ANALYZE`: the queries are tuned on plans without statistics. +- **SQLite's memory per platform** (`SqliteTuning`): the desktop keeps its 256 MB cache and 512 MB map; Android + takes a 16 MB cache and no map (mapped pages count in the memory Android kills apps by); iOS 32 MB and 256 MB. +- `PatchDbSchema.CURRENT_VERSION` is 2: a client with a version 1 database takes the full bundle, and an applier of + version 1 refuses version 2 patches. **An app version that predates `LineTextCodec` can't read a compact + database**: the release that ships it needs a minimum app version. + +## Results (the 2026-10 corpus: 7,019,636 lines, 4,428,487 links) + +| | generator's | compact | | +|---|---:|---:|---:| +| file | 8,022 MB | 3,253 MB | **2.47x** | +| `line` | 6,184 MiB | 2,088 MiB | 3.0x | +| line indexes | 575 MiB | 223 MiB | 2.6x | +| links and their indexes | 545 MiB | 448 MiB | 1.2x | + +Every line reads back byte for byte (`CompactDbVerification`, and an independent decoder on a sample). A delta +between two compact releases (20 lines changed) carries those 20 lines, 150 KB, and its apply reproduces the new +release's hash (`producePatchAndVerify`). + +Reads through the repository (`DbReadWorkload`), each phase cold (the file dropped from the page cache) then warm. +Cold / warm, in ms: + +| | Android 10 (emulator) | small phone (simulated) | desktop (JVM, NVMe) | +|---|---:|---:|---:| +| open 150 books (char counts + 50 lines) | 407–480 / 221–262 → 213–223 / 151–171 | 5,025 / 4,678 → 473 / 58 | 431 / 79 → 177 / 67 | +| jump to 300 pages of random books | 260–268 / 142–144 → 199–204 / 124–131 | 814 / 102 → 476 / 130 | 168 / 59 → 144 / 57 | +| scroll 20 books, 30 pages each | 296–301 / 250–255 → 271–283 / 218–229 | 824 / 140 → 340 / 78 | 122 / 73 → 116 / 87 | +| 3,000 lines at random | 580–626 / 240–252 → 512–517 / 249–258 | 1,559 / 78 → 1,463 / 123 | 380 / 50 → 349 / 54 | +| commentaries of 300 lines | 124–178 / 58–60 → 85–87 / 54 | 200 / 9 → 152 / 9 | 39 / 5 → 45 / 8 | + +- **Android 10**: SQLDelight's Android driver on ART, in an x86_64 emulator (2 GB) reading the host's NVMe, two + rounds each: faster cold everywhere, warm as fast or faster. +- **Small phone**: the JVM with Android's SQLite memory over a simulated storage (`LD_PRELOAD`: a 128 MB page + cache, each miss 0.2 ms plus 150 MB/s, an entry-level eMMC): the old database's working set no longer fits. +- **Desktop**: faster cold but for the commentaries (mmap reads ahead), warm within 15 ms. +- Slower: warm random lines on the small phone (78 → 123 ms, the old pages fit its cache there), the desktop's + commentaries (+6 ms cold) and warm scrolling (+14 ms for 1,500 pages). + +```bash +BENCH_DB=/path/seforim.db ./gradlew :dao:jvmTest --tests '*DbReadBenchmark*' --rerun -i # BENCH_PROFILE=android +# Android: see AndroidDbReadBenchmark (adb push, then am instrument per phase) +SOURCE_DB=build/seforim.db COMPACT_DB=build/seforim.compact.db ./gradlew :packaging:jvmTest --tests '*CompactDbVerification*' --rerun +``` diff --git a/dao/build.gradle.kts b/dao/build.gradle.kts index 51c32dffd..cbac22c0c 100644 --- a/dao/build.gradle.kts +++ b/dao/build.gradle.kts @@ -17,6 +17,10 @@ kotlin { namespace = "io.github.kdroidfilter.seforimlibrary.dao" compileSdk = 35 minSdk = 21 + // The reads on a real database, on a device or an emulator (AndroidDbReadBenchmark) + withDeviceTestBuilder { sourceSetTreeName = "test" }.configure { + instrumentationRunner = "androidx.test.runner.AndroidJUnitRunner" + } } jvm() iosArm64() @@ -56,6 +60,12 @@ kotlin { implementation(libs.sqlDelight.driver.native) } + getByName("androidDeviceTest").dependencies { + implementation(kotlin("test")) + implementation(libs.androidx.test.runner) + implementation(libs.androidx.test.junit) + } + } } diff --git a/dao/src/androidDeviceTest/kotlin/io/github/kdroidfilter/seforimlibrary/dao/repository/AndroidDbReadBenchmark.kt b/dao/src/androidDeviceTest/kotlin/io/github/kdroidfilter/seforimlibrary/dao/repository/AndroidDbReadBenchmark.kt new file mode 100644 index 000000000..5535ebf49 --- /dev/null +++ b/dao/src/androidDeviceTest/kotlin/io/github/kdroidfilter/seforimlibrary/dao/repository/AndroidDbReadBenchmark.kt @@ -0,0 +1,48 @@ +package io.github.kdroidfilter.seforimlibrary.dao.repository + +import android.util.Log +import androidx.test.ext.junit.runners.AndroidJUnit4 +import androidx.test.platform.app.InstrumentationRegistry +import app.cash.sqldelight.driver.android.AndroidSqliteDriver +import io.github.kdroidfilter.seforimlibrary.db.SeforimDb +import kotlinx.coroutines.runBlocking +import org.junit.Test +import org.junit.runner.RunWith +import java.io.File + +/** + * [DbReadWorkload] on Android, through SQLDelight's Android driver, on a database pushed to the app's external files + * directory. Runs only with the instrumentation argument benchDb (the file's name there); `phase` runs one phase, the + * host dropping the page cache before (an app can't: posix_fadvise isn't public on Android): + * + * adb push seforim.db /sdcard/Android/data/io.github.kdroidfilter.seforimlibrary.dao.test/files/ + * adb root && adb shell 'echo 3 > /proc/sys/vm/drop_caches' + * adb shell am instrument -w -e benchDb seforim.db -e phase 0 \ + * io.github.kdroidfilter.seforimlibrary.dao.test/androidx.test.runner.AndroidJUnitRunner + */ +@RunWith(AndroidJUnit4::class) +class AndroidDbReadBenchmark { + @Test + fun benchmark() { + val name = InstrumentationRegistry.getArguments().getString("benchDb") ?: return + val context = InstrumentationRegistry.getInstrumentation().targetContext + val file = File(context.getExternalFilesDir(null), name) + check(file.exists()) { "No database at $file" } + val driver = AndroidSqliteDriver(SeforimDb.Schema, context, file.absolutePath) + val repository = SeforimRepository(file.absolutePath, driver) + report("BENCH ${file.name} ${file.length() / 1_048_576} MB on Android ${android.os.Build.VERSION.RELEASE}") + val phases = InstrumentationRegistry.getArguments().getString("phase")?.let { setOf(it.toInt()) } + runBlocking { DbReadWorkload(driver, repository, {}, ::readBytes).run(phases, ::report) } + driver.close() + } + + private fun report(line: String) { + Log.i("DbReadBenchmark", line) + println(line) + } + + private fun readBytes(): Long = + runCatching { + File("/proc/self/io").readLines().first { it.startsWith("read_bytes:") }.substringAfter(':').trim().toLong() + }.getOrDefault(-1) +} diff --git a/dao/src/androidMain/kotlin/io/github/kdroidfilter/seforimlibrary/dao/repository/SqliteTuning.android.kt b/dao/src/androidMain/kotlin/io/github/kdroidfilter/seforimlibrary/dao/repository/SqliteTuning.android.kt new file mode 100644 index 000000000..c92b3ef3e --- /dev/null +++ b/dao/src/androidMain/kotlin/io/github/kdroidfilter/seforimlibrary/dao/repository/SqliteTuning.android.kt @@ -0,0 +1,5 @@ +package io.github.kdroidfilter.seforimlibrary.dao.repository + +// Android counts an app's mapped pages in the memory it kills apps by (small devices first): a small cache, no map +internal actual const val SQLITE_CACHE_KIB: Long = 16000 +internal actual const val SQLITE_MMAP_BYTES: Long = 0 diff --git a/dao/src/commonMain/kotlin/io/github/kdroidfilter/seforimlibrary/dao/repository/SeforimRepository.kt b/dao/src/commonMain/kotlin/io/github/kdroidfilter/seforimlibrary/dao/repository/SeforimRepository.kt index d8cc04779..37edf2c8d 100644 --- a/dao/src/commonMain/kotlin/io/github/kdroidfilter/seforimlibrary/dao/repository/SeforimRepository.kt +++ b/dao/src/commonMain/kotlin/io/github/kdroidfilter/seforimlibrary/dao/repository/SeforimRepository.kt @@ -24,6 +24,8 @@ import io.github.kdroidfilter.seforimlibrary.core.models.Source import io.github.kdroidfilter.seforimlibrary.core.models.TocEntry import io.github.kdroidfilter.seforimlibrary.core.models.Topic import io.github.kdroidfilter.seforimlibrary.dao.extensions.toModel +import io.github.kdroidfilter.seforimlibrary.dao.text.LineTextCodec +import io.github.kdroidfilter.seforimlibrary.db.Line as LineRow import io.github.kdroidfilter.seforimlibrary.db.SeforimDb import io.github.kdroidfilter.seforimlibrary.env.getEnvironmentVariable import kotlinx.coroutines.Dispatchers @@ -39,7 +41,16 @@ import kotlinx.serialization.json.Json * @constructor Creates a repository with the specified database path and driver */ class SeforimRepository(databasePath: String, private val driver: SqlDriver) : LineSelectionRepository { - private val database = SeforimDb(driver) + // Its dictionaries load in init, once the schema exists + private val lineTextCodec: LineTextCodec = + LineTextCodec { + database.lineQueriesQueries.selectCodecDictionaries().executeAsList().associate { it.id.toInt() to it.data_ } + } + private val database: SeforimDb = + SeforimDb( + driver, + lineAdapter = LineRow.Adapter(contentAdapter = lineTextCodec.columnAdapter), + ) private val json = Json { ignoreUnknownKeys = true } private val logger = Logger.withTag("SeforimRepository") @@ -69,11 +80,13 @@ class SeforimRepository(databasePath: String, private val driver: SqlDriver) : L logger.d{"Initializing SeforimRepository"} // Create the database schema (fresh builds only; no runtime migrations needed) SeforimDb.Schema.create(driver) - // SQLite optimizations (balanced mode for desktop: 256MB cache + 512MB mmap) + lineTextCodec.loadDictionaries() + // SQLite's memory sized to the platform: the desktop's 256 MB cache and 512 MB map would get a small phone's + // app killed (mapped pages count in its memory) pragma("journal_mode=WAL") pragma("synchronous=NORMAL") - pragma("cache_size=-256000") // 256MB cache (negative = KiB) - pragma("mmap_size=536870912") // 512MB memory-mapped I/O + pragma("cache_size=-$SQLITE_CACHE_KIB") // negative = KiB + pragma("mmap_size=$SQLITE_MMAP_BYTES") pragma("temp_store=MEMORY") // Check if the database is empty diff --git a/dao/src/commonMain/kotlin/io/github/kdroidfilter/seforimlibrary/dao/repository/SqliteTuning.kt b/dao/src/commonMain/kotlin/io/github/kdroidfilter/seforimlibrary/dao/repository/SqliteTuning.kt new file mode 100644 index 000000000..fa24f891f --- /dev/null +++ b/dao/src/commonMain/kotlin/io/github/kdroidfilter/seforimlibrary/dao/repository/SqliteTuning.kt @@ -0,0 +1,7 @@ +package io.github.kdroidfilter.seforimlibrary.dao.repository + +/** SQLite's page cache, in KiB. */ +internal expect val SQLITE_CACHE_KIB: Long + +/** How much of the database SQLite maps into memory, in bytes (0: none). */ +internal expect val SQLITE_MMAP_BYTES: Long diff --git a/dao/src/commonMain/kotlin/io/github/kdroidfilter/seforimlibrary/dao/text/HebrewBytes.kt b/dao/src/commonMain/kotlin/io/github/kdroidfilter/seforimlibrary/dao/text/HebrewBytes.kt new file mode 100644 index 000000000..0325bada0 --- /dev/null +++ b/dao/src/commonMain/kotlin/io/github/kdroidfilter/seforimlibrary/dao/text/HebrewBytes.kt @@ -0,0 +1,66 @@ +package io.github.kdroidfilter.seforimlibrary.dao.text + +// One byte per character of the corpus' alphabet, where UTF-8 takes two for each Hebrew letter, nikud and taam: +// 0x00-0x7F ASCII, 0x80-0xEF U+0590-U+05FF, 0xF0-0xFD the commonest other characters, 0xFE then a UTF-16 unit +private const val HEBREW_FIRST = 0x0590 +private const val HEBREW_LAST = 0x05FF +private const val HEBREW_BYTE = 0x80 +private const val COMMON_BYTE = 0xF0 +private const val ESCAPE = 0xFE + +// Dashes, quotes, the bidi marks, no-break space +private val COMMON_CHARS = + charArrayOf( + '\u2013', '\u2014', '\u201D', '\u201C', '\u2019', '\u2018', '\u200E', + '\u00A0', '\u202C', '\u202B', '\u200F', '\u202A', '\u2026', '\u00B7', + ) + +private val BYTE_CHARS = + CharArray(ESCAPE) { b -> + when { + b < HEBREW_BYTE -> b.toChar() + b < COMMON_BYTE -> (HEBREW_FIRST + b - HEBREW_BYTE).toChar() + else -> COMMON_CHARS[b - COMMON_BYTE] + } + } + +/** [text] in Hebrew bytes. */ +internal fun encodeHebrewBytes(text: String): ByteArray { + val out = ByteArray(text.length * 3) + var n = 0 + for (c in text) { + val code = c.code + when { + code < HEBREW_BYTE -> out[n++] = code.toByte() + code in HEBREW_FIRST..HEBREW_LAST -> out[n++] = (HEBREW_BYTE + code - HEBREW_FIRST).toByte() + else -> { + val common = COMMON_CHARS.indexOf(c) + if (common >= 0) { + out[n++] = (COMMON_BYTE + common).toByte() + } else { + out[n++] = ESCAPE.toByte() + out[n++] = (code ushr 8).toByte() + out[n++] = code.toByte() + } + } + } + } + return out.copyOf(n) +} + +/** The text of [length] Hebrew bytes of [bytes]. */ +internal fun decodeHebrewBytes(bytes: ByteArray, length: Int): String { + val chars = CharArray(length) + var n = 0 + var i = 0 + while (i < length) { + val b = bytes[i++].toInt() and 0xFF + if (b == ESCAPE) { + chars[n++] = (((bytes[i].toInt() and 0xFF) shl 8) or (bytes[i + 1].toInt() and 0xFF)).toChar() + i += 2 + } else { + chars[n++] = BYTE_CHARS[b] + } + } + return chars.concatToString(0, n) +} diff --git a/dao/src/commonMain/kotlin/io/github/kdroidfilter/seforimlibrary/dao/text/LineTextCodec.kt b/dao/src/commonMain/kotlin/io/github/kdroidfilter/seforimlibrary/dao/text/LineTextCodec.kt new file mode 100644 index 000000000..85c879b0e --- /dev/null +++ b/dao/src/commonMain/kotlin/io/github/kdroidfilter/seforimlibrary/dao/text/LineTextCodec.kt @@ -0,0 +1,110 @@ +package io.github.kdroidfilter.seforimlibrary.dao.text + +import app.cash.sqldelight.ColumnAdapter + +// First byte of a compressed value: 0xFF never starts (or appears in) UTF-8 text +private const val COMPRESSED_MARKER: Byte = 0xFF.toByte() + +/** The dictionaries of the line texts: a value's header names the one it was compressed with. */ +object LineTextDictionaries { + const val CONTENT: Int = 1 +} + +/** + * The line texts as the database stores them: plain UTF-8, or compressed against a dictionary of the database's + * `line_codec_dict` table: 0xFF, the dictionary's id, the text's length in Hebrew bytes (a varint), then [Lz]'s + * sequences over the text in [Hebrew bytes][encodeHebrewBytes]. + * + * Lines are short (750 bytes of UTF-8 on average, many of 200). One byte per Hebrew letter, nikud or taam halves them; + * LZ against 60 KiB of the corpus' own text brings them to 3.1x in all, about as much as deflate with a dictionary, while + * decoding is copies only: no entropy decoding, no state to set up, no native call (the same code on every platform). + * The generator writes plain text; the shipped database is compressed by the packaging (`:packaging:compactDb`), and + * both read the same way. + * + * @param dictionaries loads the dictionaries (in Hebrew bytes) by id, on [loadDictionaries] or the first value read + */ +class LineTextCodec(dictionaries: () -> Map) { + private val dictionaries by lazy(dictionaries) + private val compressionDictionaries by lazy { this.dictionaries.mapValues { Lz.Dictionary(it.value) } } + + /** + * Loads the dictionaries now: a loader that queries the database must not run inside another query's cursor + * (SQLDelight's JDBC driver closes the thread's connection under it). + */ + fun loadDictionaries() { + dictionaries.size + } + + /** Plain UTF-8: what the generator writes. */ + fun encode(text: String): ByteArray = text.encodeToByteArray() + + /** [text] compressed against the dictionary [dictionaryId]. */ + fun compress(text: String, dictionaryId: Int): ByteArray { + val dictionary = compressionDictionaries[dictionaryId] ?: missing(dictionaryId) + val hebrew = encodeHebrewBytes(text) + val sequences = Lz.compress(hebrew, dictionary) + val out = ByteArray(2 + VARINT_MAX + sequences.size) + out[0] = COMPRESSED_MARKER + out[1] = dictionaryId.toByte() + val n = writeVarint(out, 2, hebrew.size) + sequences.copyInto(out, n) + return out.copyOf(n + sequences.size) + } + + fun decode(bytes: ByteArray): String { + if (bytes.isEmpty()) return "" + if (bytes[0] == COMPRESSED_MARKER) { + val dictionaryId = bytes[1].toInt() and 0xFF + val dictionary = dictionaries[dictionaryId] ?: missing(dictionaryId) + var at = 2 + var length = 0 + var shift = 0 + while (true) { + val b = bytes[at++].toInt() and 0xFF + length = length or ((b and 0x7F) shl shift) + if (b < 0x80) break + shift += 7 + } + val hebrew = ByteArray(length) + Lz.decompress(bytes, at, hebrew, dictionary) + return decodeHebrewBytes(hebrew, length) + } + // Android's cursors read a TEXT value (an older database's) as a blob with its terminating NUL + val end = if (bytes.last() == 0.toByte()) bytes.size - 1 else bytes.size + return bytes.decodeToString(0, end) + } + + private fun missing(id: Int): Nothing = error("Line text dictionary $id is missing from line_codec_dict") + + /** SQLDelight's adapter of the line's text. */ + val columnAdapter: ColumnAdapter = + object : ColumnAdapter { + override fun decode(databaseValue: ByteArray): String = this@LineTextCodec.decode(databaseValue) + + override fun encode(value: String): ByteArray = this@LineTextCodec.encode(value) + } + + companion object { + // Below LZ's reach (65,535 bytes back) by a line's length, so that most lines still see all of it + const val DICTIONARY_SIZE: Int = 60 * 1024 + + private const val VARINT_MAX = 5 + + /** A dictionary for [compress]: the tail of [sample] (texts of the corpus, end to end) in Hebrew bytes. */ + fun buildDictionary(sample: List, size: Int = DICTIONARY_SIZE): ByteArray { + val bytes = encodeHebrewBytes(sample.joinToString("")) + return bytes.copyOfRange((bytes.size - size).coerceAtLeast(0), bytes.size) + } + + private fun writeVarint(out: ByteArray, offset: Int, value: Int): Int { + var at = offset + var rest = value + while (rest >= 0x80) { + out[at++] = ((rest and 0x7F) or 0x80).toByte() + rest = rest ushr 7 + } + out[at++] = rest.toByte() + return at + } + } +} diff --git a/dao/src/commonMain/kotlin/io/github/kdroidfilter/seforimlibrary/dao/text/Lz.kt b/dao/src/commonMain/kotlin/io/github/kdroidfilter/seforimlibrary/dao/text/Lz.kt new file mode 100644 index 000000000..0ec808eb9 --- /dev/null +++ b/dao/src/commonMain/kotlin/io/github/kdroidfilter/seforimlibrary/dao/text/Lz.kt @@ -0,0 +1,181 @@ +package io.github.kdroidfilter.seforimlibrary.dao.text + +/** + * LZ77 without entropy coding, LZ4's block format, behind a dictionary: a match may reach back into the dictionary + * as if it preceded the data. Decoding is copies only, with nothing to set up per value: the dictionary is read where + * it lies. + * + * A sequence is a token (literal count in the high nibble, match length - 4 in the low one, 15 extended by bytes + * adding up to 255 each), the literals, then the match's offset on 2 bytes (little endian) and the length's + * extension; the last sequence has literals only. + */ +internal object Lz { + const val MIN_MATCH = 4 + const val MAX_OFFSET = 65_535 + + private const val HASH_BITS = 15 + private const val CHAIN_DEPTH = 64 + + /** Decodes [src] from [offset] into [out], exactly filled. */ + fun decompress(src: ByteArray, offset: Int, out: ByteArray, dictionary: ByteArray) { + val end = src.size + val dictSize = dictionary.size + var ip = offset + var op = 0 + while (ip < end) { + val token = src[ip++].toInt() and 0xFF + var literals = token ushr 4 + if (literals == 15) { + var b: Int + do { + b = src[ip++].toInt() and 0xFF + literals += b + } while (b == 255) + } + src.copyInto(out, op, ip, ip + literals) + ip += literals + op += literals + if (ip >= end) break + + val distance = (src[ip].toInt() and 0xFF) or ((src[ip + 1].toInt() and 0xFF) shl 8) + ip += 2 + var length = (token and 15) + MIN_MATCH + if (token and 15 == 15) { + var b: Int + do { + b = src[ip++].toInt() and 0xFF + length += b + } while (b == 255) + } + var from = op - distance + if (from < 0) { + // The match starts in the dictionary, and may run on into the data + val n = minOf(-from, length) + dictionary.copyInto(out, op, dictSize + from, dictSize + from + n) + op += n + length -= n + from = 0 + } + if (length > 0) { + if (op - from >= length) { + out.copyInto(out, op, from, from + length) + } else { + for (k in 0 until length) out[op + k] = out[from + k] + } + op += length + } + } + } + + /** The dictionary's hash chains, built once and shared by every [compress]. */ + class Dictionary(val bytes: ByteArray) { + internal val head = IntArray(1 shl HASH_BITS) { -1 } + internal val prev = IntArray(bytes.size) + + init { + for (i in 0..bytes.size - MIN_MATCH) { + val h = hash(bytes, i) + prev[i] = head[h] + head[h] = i + } + } + } + + /** [data] compressed against [dictionary]: greedy matching, with one step of lazy evaluation. */ + fun compress(data: ByteArray, dictionary: Dictionary): ByteArray { + val dict = dictionary.bytes + val dictSize = dict.size + val n = data.size + // Positions are virtual: the dictionary's first, then the data's from dictSize + val head = dictionary.head.copyOf() + val prev = IntArray(n) + val out = ByteArray(n + n / 255 + 16) + var op = 0 + var anchor = 0 + var i = 0 + + fun byteAt(p: Int): Byte = if (p < dictSize) dict[p] else data[p - dictSize] + + fun insert(at: Int) { + if (at + MIN_MATCH <= n) { + val h = hash(data, at) + prev[at] = head[h] + head[h] = dictSize + at + } + } + + // The longest match at data position [at]: (length shl 16) or distance, 0 if none + fun find(at: Int): Long { + if (at + MIN_MATCH > n) return 0 + val v = dictSize + at + var candidate = head[hash(data, at)] + var best = 0 + var bestDistance = 0 + var steps = 0 + while (candidate >= 0 && steps++ < CHAIN_DEPTH && v - candidate <= MAX_OFFSET) { + var length = 0 + while (at + length < n && byteAt(candidate + length) == data[at + length]) length++ + if (length > best) { + best = length + bestDistance = v - candidate + if (at + length == n) break + } + candidate = if (candidate < dictSize) dictionary.prev[candidate] else prev[candidate - dictSize] + } + return if (best >= MIN_MATCH) (best.toLong() shl 16) or bestDistance.toLong() else 0 + } + + fun writeLength(value: Int) { + var rest = value + while (rest >= 255) { + out[op++] = 255.toByte() + rest -= 255 + } + out[op++] = rest.toByte() + } + + fun emit(literalEnd: Int, length: Int, distance: Int) { + val literals = literalEnd - anchor + val matchCode = if (length == 0) 0 else minOf(length - MIN_MATCH, 15) + out[op++] = ((minOf(literals, 15) shl 4) or matchCode).toByte() + if (literals >= 15) writeLength(literals - 15) + data.copyInto(out, op, anchor, literalEnd) + op += literals + if (length == 0) return + out[op++] = distance.toByte() + out[op++] = (distance ushr 8).toByte() + if (length - MIN_MATCH >= 15) writeLength(length - MIN_MATCH - 15) + } + + while (i < n) { + var match = find(i) + if (match == 0L) { + insert(i) + i++ + continue + } + // A longer match one byte on wins over this one + insert(i) + val next = find(i + 1) + if (next ushr 16 > match ushr 16) { + i++ + match = next + insert(i) + } + val length = (match ushr 16).toInt() + emit(i, length, (match and 0xFFFF).toInt()) + for (p in i + 1 until i + length) insert(p) + i += length + anchor = i + } + if (anchor < n || op == 0) emit(n, 0, 0) + return out.copyOf(op) + } + + private fun hash(bytes: ByteArray, at: Int): Int { + val v = + (bytes[at].toInt() and 0xFF) or ((bytes[at + 1].toInt() and 0xFF) shl 8) or + ((bytes[at + 2].toInt() and 0xFF) shl 16) or ((bytes[at + 3].toInt() and 0xFF) shl 24) + return (v * -1640531535) ushr (32 - HASH_BITS) + } +} diff --git a/dao/src/commonMain/sqldelight/io/github/kdroidfilter/seforimlibrary/db/Database.sq b/dao/src/commonMain/sqldelight/io/github/kdroidfilter/seforimlibrary/db/Database.sq index 750fb6acc..6cf8b59f2 100644 --- a/dao/src/commonMain/sqldelight/io/github/kdroidfilter/seforimlibrary/db/Database.sq +++ b/dao/src/commonMain/sqldelight/io/github/kdroidfilter/seforimlibrary/db/Database.sq @@ -303,7 +303,9 @@ CREATE TABLE IF NOT EXISTS line ( id INTEGER PRIMARY KEY NOT NULL, bookId INTEGER NOT NULL, lineIndex INTEGER NOT NULL, - content TEXT NOT NULL, + -- Plain UTF-8, or deflated with a line_codec_dict dictionary (LineTextCodec): the shipped database compresses it + content BLOB AS kotlin.String NOT NULL, + -- Plain: short (36 bytes on average), it would save 180 MB but cost a second inflate per line read heRef TEXT, tocEntryId INTEGER, -- Visible character count of this line (HTML stripped). Used to compute scrollbar @@ -313,9 +315,16 @@ CREATE TABLE IF NOT EXISTS line ( FOREIGN KEY (tocEntryId) REFERENCES tocEntry(id) ON DELETE SET NULL ); -CREATE INDEX IF NOT EXISTS idx_line_book_index ON line(bookId, lineIndex); -CREATE INDEX IF NOT EXISTS idx_line_toc ON line(tocEntryId); -CREATE INDEX IF NOT EXISTS idx_line_heref ON line(heRef); +-- Covers charCount: a book's scrollbar reads its line sizes without reading its texts +CREATE INDEX IF NOT EXISTS idx_line_book_index ON line(bookId, lineIndex, charCount); +-- Only a tenth of the lines name their TOC entry (line_toc maps them all): the others stay out of the index +CREATE INDEX IF NOT EXISTS idx_line_toc ON line(tocEntryId) WHERE tocEntryId IS NOT NULL; + +-- The dictionaries the compressed line texts were deflated with, by the id their header names +CREATE TABLE IF NOT EXISTS line_codec_dict ( + id INTEGER PRIMARY KEY NOT NULL, + data BLOB NOT NULL +); -- TOC texts table CREATE TABLE IF NOT EXISTS tocText ( @@ -323,7 +332,6 @@ CREATE TABLE IF NOT EXISTS tocText ( text TEXT NOT NULL UNIQUE ); -CREATE INDEX IF NOT EXISTS idx_toc_text ON tocText(text); CREATE INDEX IF NOT EXISTS idx_toctext_text_length ON tocText(text, length(text)); -- TOC entries table @@ -385,10 +393,8 @@ CREATE TABLE IF NOT EXISTS link ( ); CREATE INDEX IF NOT EXISTS idx_link_source_book ON link(sourceBookId); -CREATE INDEX IF NOT EXISTS idx_link_source_line ON link(sourceLineId); CREATE INDEX IF NOT EXISTS idx_link_target_book ON link(targetBookId); CREATE INDEX IF NOT EXISTS idx_link_target_line ON link(targetLineId); -CREATE INDEX IF NOT EXISTS idx_link_type ON link(connectionTypeId); CREATE INDEX IF NOT EXISTS idx_link_type_source_line ON link(connectionTypeId, sourceLineId); -- Covering index for the forward commentaries path: filter by sourceLineId, then return rows -- already ordered by (targetBookOrderIndex, targetLineIndex) so the paged queries' ORDER BY + diff --git a/dao/src/commonMain/sqldelight/io/github/kdroidfilter/seforimlibrary/db/LineQueries.sq b/dao/src/commonMain/sqldelight/io/github/kdroidfilter/seforimlibrary/db/LineQueries.sq index b26139f31..e1c94b5ce 100644 --- a/dao/src/commonMain/sqldelight/io/github/kdroidfilter/seforimlibrary/db/LineQueries.sq +++ b/dao/src/commonMain/sqldelight/io/github/kdroidfilter/seforimlibrary/db/LineQueries.sq @@ -47,3 +47,6 @@ SELECT COUNT(*) FROM line WHERE bookId = ?; lastInsertRowId: SELECT last_insert_rowid(); + +selectCodecDictionaries: +SELECT id, data FROM line_codec_dict; diff --git a/dao/src/commonTest/kotlin/io/github/kdroidfilter/seforimlibrary/dao/repository/DbReadWorkload.kt b/dao/src/commonTest/kotlin/io/github/kdroidfilter/seforimlibrary/dao/repository/DbReadWorkload.kt new file mode 100644 index 000000000..5e61de172 --- /dev/null +++ b/dao/src/commonTest/kotlin/io/github/kdroidfilter/seforimlibrary/dao/repository/DbReadWorkload.kt @@ -0,0 +1,80 @@ +package io.github.kdroidfilter.seforimlibrary.dao.repository + +import app.cash.sqldelight.db.QueryResult +import app.cash.sqldelight.db.SqlDriver +import kotlin.random.Random +import kotlin.time.TimeSource + +/** + * The app's reads on a real database (opening books, jumping, scrolling, lines by id, commentaries), each phase timed cold + * then warm with the bytes it read from the disk: the benchmarks of the JVM (DbReadBenchmark) and of Android + * (AndroidDbReadBenchmark) run it. + * + * @param dropFromPageCache drops the database file from the OS page cache + * @param readBytes the bytes this process made the disk read so far, or -1 + */ +class DbReadWorkload( + private val driver: SqlDriver, + private val repository: SeforimRepository, + private val dropFromPageCache: () -> Unit, + private val readBytes: () -> Long, +) { + /** Runs the [phases] given by index (all by default). */ + suspend fun run(phases: Set? = null, report: (String) -> Unit) { + val maxLineId = driver.longs("SELECT MAX(id) FROM line").single() + val books = driver.longs("SELECT id FROM book WHERE totalLines > 100 ORDER BY id") + val random = Random(42) + val openBooks = List(150) { books[random.nextInt(books.size)] } + val pages = List(300) { books[random.nextInt(books.size)] to random.nextInt(0, 100) } + val longBooks = driver.longs("SELECT id FROM book WHERE totalLines > 1500 ORDER BY id") + val readBooks = List(20) { longBooks[random.nextInt(longBooks.size)] } + val lineIds = List(3000) { random.nextLong(1, maxLineId + 1) } + val commentaryLines = List(300) { random.nextLong(1, maxLineId + 1) } + + val all: List Unit>> = + listOf( + "open book (char counts + first 50 lines)" to { + for (b in openBooks) { + repository.getBookCharCounts(b) + repository.getLines(b, 0, 49) + } + }, + "jump (300 pages of 50 lines, random books)" to { + for ((b, start) in pages) repository.getLines(b, start, start + 49) + }, + "scroll (20 books, 30 pages of 50 lines each)" to { + for (b in readBooks) for (page in 0 until 30) repository.getLines(b, page * 50, page * 50 + 49) + }, + "random lines by id (3000)" to { + for (id in lineIds) repository.getLine(id) + }, + "commentaries with texts (300 lines)" to { + for (id in commentaryLines) repository.getCommentariesForLines(listOf(id)) + }, + ) + for ((index, entry) in all.withIndex()) { + if (phases != null && index !in phases) continue + val (name, phase) = entry + dropFromPageCache() + val (coldMs, coldBytes) = measure(phase) + val (warmMs, _) = measure(phase) + report( + "BENCH ${name.padEnd(42)} cold ${coldMs.toString().padStart(6)} ms " + + "${(coldBytes / 1_048_576.0).format1().padStart(7)} MB read | warm ${warmMs.toString().padStart(5)} ms", + ) + } + } + + private suspend fun measure(block: suspend () -> Unit): Pair { + val before = readBytes() + val mark = TimeSource.Monotonic.markNow() + block() + val ms = mark.elapsedNow().inWholeMilliseconds + return ms to if (before < 0) -1 else readBytes() - before + } + + private fun Double.format1(): String = if (this < 0) "?" else ((this * 10).toLong() / 10.0).toString() + + private fun SqlDriver.longs(sql: String): List = + executeQuery(null, sql, { c -> QueryResult.Value(buildList { while (c.next().value) add(c.getLong(0)!!) }) }, 0).value +} diff --git a/dao/src/iosMain/kotlin/io/github/kdroidfilter/seforimlibrary/dao/repository/SqliteTuning.ios.kt b/dao/src/iosMain/kotlin/io/github/kdroidfilter/seforimlibrary/dao/repository/SqliteTuning.ios.kt new file mode 100644 index 000000000..e3eb4e304 --- /dev/null +++ b/dao/src/iosMain/kotlin/io/github/kdroidfilter/seforimlibrary/dao/repository/SqliteTuning.ios.kt @@ -0,0 +1,5 @@ +package io.github.kdroidfilter.seforimlibrary.dao.repository + +// iOS: a moderate cache, mapped pages are clean memory there +internal actual const val SQLITE_CACHE_KIB: Long = 32000 +internal actual const val SQLITE_MMAP_BYTES: Long = 268435456 diff --git a/dao/src/jvmMain/kotlin/io/github/kdroidfilter/seforimlibrary/dao/repository/SqliteTuning.jvm.kt b/dao/src/jvmMain/kotlin/io/github/kdroidfilter/seforimlibrary/dao/repository/SqliteTuning.jvm.kt new file mode 100644 index 000000000..8e672258c --- /dev/null +++ b/dao/src/jvmMain/kotlin/io/github/kdroidfilter/seforimlibrary/dao/repository/SqliteTuning.jvm.kt @@ -0,0 +1,5 @@ +package io.github.kdroidfilter.seforimlibrary.dao.repository + +// The desktop: a large cache and map +internal actual const val SQLITE_CACHE_KIB: Long = 256000 +internal actual const val SQLITE_MMAP_BYTES: Long = 536870912 diff --git a/dao/src/jvmTest/kotlin/io/github/kdroidfilter/seforimlibrary/dao/repository/BenchPersistentSqliteDriver.kt b/dao/src/jvmTest/kotlin/io/github/kdroidfilter/seforimlibrary/dao/repository/BenchPersistentSqliteDriver.kt new file mode 100644 index 000000000..26eb2f99b --- /dev/null +++ b/dao/src/jvmTest/kotlin/io/github/kdroidfilter/seforimlibrary/dao/repository/BenchPersistentSqliteDriver.kt @@ -0,0 +1,167 @@ +package io.github.kdroidfilter.seforimlibrary.dao.repository + +// Copied from SeforimApp (framework/database), for DbReadBenchmark to read as the app does + +import app.cash.sqldelight.Query +import app.cash.sqldelight.db.QueryResult +import app.cash.sqldelight.db.SqlCursor +import app.cash.sqldelight.db.SqlPreparedStatement +import app.cash.sqldelight.driver.jdbc.JdbcCursor +import app.cash.sqldelight.driver.jdbc.JdbcDriver +import app.cash.sqldelight.driver.jdbc.JdbcPreparedStatement +import java.sql.Connection +import java.sql.DriverManager +import java.sql.PreparedStatement +import java.util.Properties + +/** + * Opt-in per-query timing (`-Dseforim.sqlTrace=true`, or set [listener] from a bench): reports the time spent + * waiting for the single connection and the time spent executing, to find slow queries and contention. + */ +object SqlTrace { + @Volatile + var listener: ((sql: String, waitNanos: Long, execNanos: Long) -> Unit)? = + if (System.getProperty("seforim.sqlTrace") != null) { + { sql, wait, exec -> + System.err.println( + "[sql] wait=${wait / 1_000_000}ms exec=${exec / 1_000_000}ms ${sql.replace(Regex("\\s+"), " ").take(160)}", + ) + } + } else { + null + } +} + +/** + * SQLite JDBC driver backed by a single persistent connection with a per-identifier + * [PreparedStatement] cache. + * + * Profiling (JFR 2026-04-23) showed the stock [app.cash.sqldelight.driver.jdbc.sqlite.JdbcSqliteDriver] + * routing every non-transactional query through `ThreadedConnectionManager` — which + * closes and re-opens the SQLite connection after each call, paying `sqlite3_open` + * + `sqlite3_prepare` + `sqlite3_close` per query. On a read-only reader workload + * that is pure waste: the reader corpus is immutable, so one connection suffices + * and every repeatedly-issued query benefits from a cached prepared statement. + * + * Design: + * - A single [Connection] opened at construction time, kept alive until [close]. + * - `getConnection()` returns that connection; `closeConnection()` is a no-op. + * - Read-tuning PRAGMAs applied once at init (WAL / NORMAL sync / page+mmap caches). + * - Prepared-statement cache keyed by SqlDelight's `identifier: Int` — the same + * integer it passes on every generated query call. Statements are synchronized + * on the single connection because SQLite's JDBC connection is not thread-safe. + * + * Transactions are handled by [JdbcDriver]'s base `autoCommit` machinery; we just + * ensure our cached prepared statements aren't handed out while another thread holds + * the connection by synchronizing the execute methods on `connection`. + */ + +class PersistentSqliteDriver( + url: String, + properties: Properties = Properties(), +) : JdbcDriver() { + private val connection: Connection = DriverManager.getConnection(url, properties) + + // Statement cache keyed by SQL text — SqlDelight sometimes reuses the same + // `identifier` for queries whose SQL varies (e.g. `IN (?,?,?)` with variable + // arity), so we avoid crashes by keying on the actual SQL string. Bounded in + // practice: a few hundred distinct queries across the whole app. Never evicted. + private val statementCache = HashMap() + + init { + connection.autoCommit = true + // Don't apply PRAGMAs here: `SeforimRepository.init` already issues its own + // tuned set (256 MB cache / 512 MB mmap). Running them twice while the repo + // still holds open cursors from its schema-create pass triggers SQLITE_BUSY. + } + + override fun getConnection(): Connection = connection + + override fun closeConnection(connection: Connection) = Unit + + override fun close() { + synchronized(connection) { + statementCache.values.forEach { runCatching { it.close() } } + statementCache.clear() + connection.close() + } + } + + override fun addListener( + vararg queryKeys: String, + listener: Query.Listener, + ) = Unit + + override fun removeListener( + vararg queryKeys: String, + listener: Query.Listener, + ) = Unit + + override fun notifyListeners(vararg queryKeys: String) = Unit + + override fun execute( + identifier: Int?, + sql: String, + parameters: Int, + binders: (SqlPreparedStatement.() -> Unit)?, + ): QueryResult { + synchronized(connection) { + val stmt = prepare(sql) + stmt.clearParameters() + if (binders != null) JdbcPreparedStatement(stmt).binders() + val hasResultSet = stmt.execute() + val rows = + if (hasResultSet) { + // Drain any result set to release the statement's cursor so the next + // call (e.g. a subsequent PRAGMA) doesn't hit SQLITE_BUSY. + stmt.resultSet?.close() + 0L + } else { + stmt.updateCount.toLong() + } + return QueryResult.Value(rows) + } + } + + override fun executeQuery( + identifier: Int?, + sql: String, + mapper: (SqlCursor) -> QueryResult, + parameters: Int, + binders: (SqlPreparedStatement.() -> Unit)?, + ): QueryResult { + val trace = SqlTrace.listener + val requested = if (trace != null) System.nanoTime() else 0L + synchronized(connection) { + val acquired = if (trace != null) System.nanoTime() else 0L + val stmt = prepare(sql) + stmt.clearParameters() + if (binders != null) JdbcPreparedStatement(stmt).binders() + // Inlined from `JdbcPreparedStatement.executeQuery`, minus the `preparedStatement.close()` + // in its `finally` — closing would defeat the whole point of caching. We close the + // ResultSet via `.use { }` instead so SQLite frees the cursor for the next call. + stmt.executeQuery().use { rs -> + val result = mapper(JdbcCursor(rs)) + if (trace != null) { + val done = System.nanoTime() + trace(sql, acquired - requested, done - acquired) + } + return result + } + } + } + + /** + * Returns a cached [PreparedStatement] for [sql], preparing it lazily on first + * use. Caller must hold the connection's monitor. + */ + private fun prepare(sql: String): PreparedStatement { + statementCache[sql]?.let { cached -> + if (!cached.isClosed) return cached + statementCache.remove(sql) + } + val fresh = connection.prepareStatement(sql) + statementCache[sql] = fresh + return fresh + } +} diff --git a/dao/src/jvmTest/kotlin/io/github/kdroidfilter/seforimlibrary/dao/repository/DbReadBenchmark.kt b/dao/src/jvmTest/kotlin/io/github/kdroidfilter/seforimlibrary/dao/repository/DbReadBenchmark.kt new file mode 100644 index 000000000..c908cf01e --- /dev/null +++ b/dao/src/jvmTest/kotlin/io/github/kdroidfilter/seforimlibrary/dao/repository/DbReadBenchmark.kt @@ -0,0 +1,44 @@ +package io.github.kdroidfilter.seforimlibrary.dao.repository + +import app.cash.sqldelight.db.QueryResult +import kotlinx.coroutines.runBlocking +import java.io.File +import kotlin.test.Test + +/** + * [DbReadWorkload] on the desktop, through the app's driver. Runs only with BENCH_DB set (a database the test may open + * read-write); BENCH_PROFILE=android applies Android's SQLite memory (16 MB cache, no map). + * + * BENCH_DB=/path/seforim.db ./gradlew :dao:jvmTest --tests '*DbReadBenchmark*' --rerun -i + */ +class DbReadBenchmark { + @Test + fun benchmark() { + val path = System.getenv("BENCH_DB") ?: return + val android = System.getenv("BENCH_PROFILE") == "android" + // The app's driver: one persistent connection, prepared statements cached + val driver = PersistentSqliteDriver("jdbc:sqlite:$path") + val repository = SeforimRepository(path, driver) + if (android) { + driver.execute(null, "PRAGMA cache_size=-16000", 0) + driver.executeQuery(null, "PRAGMA mmap_size=0", { QueryResult.Value(it.next().value) }, 0) + } + println("BENCH ${File(path).name} ${File(path).length() / 1_048_576} MB profile=${if (android) "android" else "desktop"}") + runBlocking { + DbReadWorkload(driver, repository, { dropFromPageCache(path) }, ::readBytes).run(report = ::println) + } + driver.close() + } + + // Bytes this process made the disk read (page cache misses) + private fun readBytes(): Long = + File("/proc/self/io").readLines().first { it.startsWith("read_bytes:") }.substringAfter(':').trim().toLong() + + // Also clears the simulated cache of a slow storage (SLOWIO_DROP, see COMPACT_DB.md) + private fun dropFromPageCache(path: String) { + val script = + "import os,sys\nfd=os.open(sys.argv[1],os.O_RDONLY)\nos.fdatasync(fd)\nos.posix_fadvise(fd,0,0,os.POSIX_FADV_DONTNEED)\n" + + "d=os.environ.get('SLOWIO_DROP')\nif d: open(d,'w').write('x')" + ProcessBuilder("python3", "-c", script, path).inheritIO().start().waitFor() + } +} diff --git a/dao/src/jvmTest/kotlin/io/github/kdroidfilter/seforimlibrary/dao/text/LineTextCodecTest.kt b/dao/src/jvmTest/kotlin/io/github/kdroidfilter/seforimlibrary/dao/text/LineTextCodecTest.kt new file mode 100644 index 000000000..004e1edd5 --- /dev/null +++ b/dao/src/jvmTest/kotlin/io/github/kdroidfilter/seforimlibrary/dao/text/LineTextCodecTest.kt @@ -0,0 +1,83 @@ +package io.github.kdroidfilter.seforimlibrary.dao.text + +import app.cash.sqldelight.db.QueryResult +import app.cash.sqldelight.driver.jdbc.sqlite.JdbcSqliteDriver +import io.github.kdroidfilter.seforimlibrary.dao.repository.SeforimRepository +import kotlinx.coroutines.runBlocking +import kotlin.random.Random +import kotlin.test.Test +import kotlin.test.assertContentEquals +import kotlin.test.assertEquals +import kotlin.test.assertTrue + +class LineTextCodecTest { + private val sample = List(200) { "בְּרֵ×�שִ×�ית בָּרָ×� ×�ֱלֹהִי×� ×�מר רבי יוחנן – “משו×�â€� רבי שמעון $it " } + private val dictionary = LineTextCodec.buildDictionary(sample) + private val codec = LineTextCodec { mapOf(LineTextDictionaries.CONTENT to dictionary) } + + private fun roundTrip(text: String) = assertEquals(text, codec.decode(codec.compress(text, LineTextDictionaries.CONTENT))) + + @Test + fun `compressed texts read back, long ones too`() { + listOf("", "×�", "a", "×�מר רבי יוחנן משו×� רבי שמעון בן יוחי", "וַיֹּ×�מֶר ".repeat(50_000)).forEach(::roundTrip) + } + + @Test + fun `any character reads back, escaped, surrogate or among the commonest others`() { + roundTrip("😀 中文 – — “ â€� ‘ ’ ‎â€�‪‫‬  … · \u0000 ï¿¿  ff ש×�") + val random = Random(7) + val alphabet = (0x20..0x7E) + (0x0590..0x05FF) + listOf(0x2013, 0x00A0, 0x4E2D, 0xD83D, 0xDE00, 0xFFFD) + repeat(2_000) { + roundTrip(String(CharArray(random.nextInt(0, 400)) { alphabet[random.nextInt(alphabet.size)].toChar() })) + } + } + + @Test + fun `matches reach into the dictionary and run on into the text`() { + // The text repeats the dictionary's tail, then itself: matches start in the dictionary and overlap + val tail = sample.takeLast(3).joinToString("") + listOf(tail, tail + tail, tail + "ab".repeat(300), "x" + tail.take(10) + "y".repeat(1000)).forEach(::roundTrip) + } + + @Test + fun `the corpus' own text compresses well`() { + val line = "בְּרֵ×�שִ×�ית בָּרָ×� ×�ֱלֹהִי×� ×�מר רבי יוחנן – “משו×�â€� רבי שמעון 77" + assertTrue(codec.compress(line, LineTextDictionaries.CONTENT).size * 4 < line.encodeToByteArray().size) + } + + @Test + fun `plain texts read as they are, with an Android cursor's terminating NUL`() { + val text = "ו×�ת ×”×�רץ" + assertEquals(text, codec.decode(codec.encode(text))) + assertEquals(text, codec.decode(text.encodeToByteArray() + 0)) + assertContentEquals(text.encodeToByteArray(), codec.encode(text)) + } + + @Test + fun `the repository reads compressed, plain and TEXT lines alike`() = + runBlocking { + val driver = JdbcSqliteDriver(JdbcSqliteDriver.IN_MEMORY) + // Creates the schema; the repository that reads opens the filled database, as the app does + SeforimRepository(":memory:", driver) + driver.execute(null, "INSERT INTO line_codec_dict(id, data) VALUES (1, ?)", 1) { bindBytes(0, dictionary) } + driver.execute(null, "INSERT INTO category(id, title, level) VALUES (1, 'c', 0)", 0) + driver.execute(null, "INSERT INTO source(id, name) VALUES (1, 's')", 0) + driver.execute(null, "INSERT INTO book(id, categoryId, sourceId, title) VALUES (1, 1, 1, 'b')", 0) + val texts = listOf("×�מר רבי יוחנן", "בר×�שית בר×�", "ו×�ת ×”×�רץ") + val stored = listOf(codec.compress(texts[0], LineTextDictionaries.CONTENT), codec.encode(texts[1])) + stored.forEachIndexed { i, bytes -> + driver.execute(null, "INSERT INTO line(id, bookId, lineIndex, content) VALUES (?, 1, ?, ?)", 3) { + bindLong(0, i + 1L) + bindLong(1, i.toLong()) + bindBytes(2, bytes) + } + } + driver.execute(null, "INSERT INTO line(id, bookId, lineIndex, content) VALUES (3, 1, 2, '${texts[2]}')", 0) + assertEquals(texts, SeforimRepository(":memory:", driver).getLines(1, 0, 2).map { it.content }) + val stored0 = driver.executeQuery(null, "SELECT typeof(content) FROM line WHERE id = 1", { c -> + QueryResult.Value(if (c.next().value) c.getString(0) else null) + }, 0).value + assertEquals("blob", stored0) + driver.close() + } +} diff --git a/delta-updater/src/jvmMain/kotlin/io/github/kdroidfilter/seforimlibrary/deltaupdater/LuceneUpdater.kt b/delta-updater/src/jvmMain/kotlin/io/github/kdroidfilter/seforimlibrary/deltaupdater/LuceneUpdater.kt index 5c750cb6e..34ee04b6b 100644 --- a/delta-updater/src/jvmMain/kotlin/io/github/kdroidfilter/seforimlibrary/deltaupdater/LuceneUpdater.kt +++ b/delta-updater/src/jvmMain/kotlin/io/github/kdroidfilter/seforimlibrary/deltaupdater/LuceneUpdater.kt @@ -1,6 +1,7 @@ package io.github.kdroidfilter.seforimlibrary.deltaupdater import co.touchlab.kermit.Logger +import io.github.kdroidfilter.seforimlibrary.dao.text.LineTextCodec import java.nio.file.Path import java.sql.Connection import java.sql.DriverManager @@ -63,8 +64,10 @@ class LuceneUpdater( liveDbPath: Path? = null, ): Stats { DriverManager.getConnection("jdbc:sqlite:${patchDb.toAbsolutePath()}").use { conn -> + // The texts are compressed with the live database's dictionaries (a patch never changes them) + val codec = LineTextCodec { (liveDbPath?.let(::readDictionaries) ?: emptyMap()) + readDictionaries(conn) } val deleted = forEachDelete(conn, deletes) - val upserted = forEachUpsert(conn, upserts) + val upserted = forEachUpsert(conn, upserts, codec) // Some patches change book-level metadata (title, categoryId, // orderIndex, isBaseBook, …) WITHOUT touching any of the book's // lines. The line-level loop above wouldn't see those, so the @@ -72,7 +75,7 @@ class LuceneUpdater( // would stay at the pre-patch values. Re-index every line of // those books so the search-side metadata stays in sync. val metaReindexed = if (liveDbPath != null) { - reindexBooksWithMetadataOnlyChange(conn, liveDbPath, upserts) + reindexBooksWithMetadataOnlyChange(conn, liveDbPath, upserts, codec) } else 0 logger.i { "Lucene delta — deletes=$deleted, upserts=$upserted, meta-reindexed lines=$metaReindexed" } return Stats(deleted, upserted + metaReindexed) @@ -83,6 +86,7 @@ class LuceneUpdater( patchConn: Connection, liveDbPath: Path, sink: UpsertSink, + codec: LineTextCodec, ): Int { if (!hasTable(patchConn, "upsert_book")) return 0 // Collect book ids touched at metadata level but not via line ops. @@ -112,7 +116,7 @@ class LuceneUpdater( id = rs.getLong(1), bookId = rs.getLong(2), lineIndex = rs.getInt(3), - content = rs.getString(4), + content = codec.decode(rs.getBytes(4) ?: ByteArray(0)), heRef = rs.getString(5), ), ) @@ -141,7 +145,7 @@ class LuceneUpdater( return n } - private fun forEachUpsert(conn: Connection, sink: UpsertSink): Int { + private fun forEachUpsert(conn: Connection, sink: UpsertSink, codec: LineTextCodec): Int { if (!hasTable(conn, "upsert_line")) return 0 var n = 0 conn.createStatement().use { st -> @@ -154,7 +158,7 @@ class LuceneUpdater( id = rs.getLong(1), bookId = rs.getLong(2), lineIndex = rs.getInt(3), - content = rs.getString(4), + content = codec.decode(rs.getBytes(4) ?: ByteArray(0)), heRef = rs.getString(5), ), ) @@ -171,4 +175,16 @@ class LuceneUpdater( ps.executeQuery().use { rs -> return rs.next() } } } + + private fun readDictionaries(db: Path): Map = + DriverManager.getConnection("jdbc:sqlite:${db.toAbsolutePath()}").use(::readDictionaries) + + private fun readDictionaries(conn: Connection): Map { + if (!hasTable(conn, "line_codec_dict")) return emptyMap() + return conn.createStatement().use { st -> + st.executeQuery("SELECT id, data FROM line_codec_dict").use { rs -> + buildMap { while (rs.next()) put(rs.getInt(1), rs.getBytes(2)) } + } + } + } } diff --git a/generator/common/src/jvmMain/kotlin/io/github/kdroidfilter/seforimlibrary/common/patch/LogicalContentHasher.kt b/generator/common/src/jvmMain/kotlin/io/github/kdroidfilter/seforimlibrary/common/patch/LogicalContentHasher.kt index fa6af8596..b17984f2e 100644 --- a/generator/common/src/jvmMain/kotlin/io/github/kdroidfilter/seforimlibrary/common/patch/LogicalContentHasher.kt +++ b/generator/common/src/jvmMain/kotlin/io/github/kdroidfilter/seforimlibrary/common/patch/LogicalContentHasher.kt @@ -93,6 +93,9 @@ class LogicalContentHasher( "book_pub_date", "book_edition", "tocEntry", + // Hashed, never patched: a release whose dictionaries differ from the previous one's can't be reached by a + // delta (its texts wouldn't read with the client's dictionaries), and the strict invariant says so + "line_codec_dict", "line", "line_toc", "link", diff --git a/generator/common/src/jvmMain/kotlin/io/github/kdroidfilter/seforimlibrary/common/patch/PatchDbSchema.kt b/generator/common/src/jvmMain/kotlin/io/github/kdroidfilter/seforimlibrary/common/patch/PatchDbSchema.kt index ec8157555..554eed979 100644 --- a/generator/common/src/jvmMain/kotlin/io/github/kdroidfilter/seforimlibrary/common/patch/PatchDbSchema.kt +++ b/generator/common/src/jvmMain/kotlin/io/github/kdroidfilter/seforimlibrary/common/patch/PatchDbSchema.kt @@ -19,7 +19,9 @@ import java.sql.Connection */ internal object PatchDbSchema { - const val CURRENT_VERSION: Int = 1 + // 2: the line texts are LineTextCodec values (compressed in the shipped database): a database of version 1 can + // only reach it by the full bundle, and an applier of version 1 refuses its patches + const val CURRENT_VERSION: Int = 2 /** Fixed-shape tables (metadata + auxiliaries). */ val baseStatements: List = listOf( diff --git a/generator/packaging/build.gradle.kts b/generator/packaging/build.gradle.kts index 698c0fe87..ff2edec7c 100644 --- a/generator/packaging/build.gradle.kts +++ b/generator/packaging/build.gradle.kts @@ -16,8 +16,15 @@ kotlin { implementation(kotlin("test")) } + jvmTest.dependencies { + implementation(libs.kotlinx.coroutines.core) + } + jvmMain.dependencies { implementation(project(":generator-common")) + implementation(project(":dao")) + implementation(libs.sqlite.jdbc) + implementation(libs.sqlDelight.driver.sqlite) implementation(libs.zstd) implementation(libs.commons.compress) } @@ -120,3 +127,25 @@ tasks.register("packageArtifacts") { jvmArgs = listOf("-Xmx512m") } + +// Write the shipped database from the generator's: line texts compressed, dev-only indexes dropped, pages full +// Usage: +// ./gradlew :packaging:compactDb +// ./gradlew :packaging:compactDb -PseforimDb=/path/to/seforim.db -PcompactDb=/path/to/seforim.compact.db +// ./gradlew :packaging:compactDb -PtrainDictionaries=src/jvmMain/resources/line_codec_dict (new dictionaries) +tasks.register("compactDb") { + group = "application" + description = "Write the compact seforim.db that ships (compressed line texts, no dev-only indexes)." + + dependsOn("jvmJar") + mainClass.set("io.github.kdroidfilter.seforimlibrary.packaging.CompactDbKt") + classpath = files(tasks.named("jvmJar")) + configurations.getByName("jvmRuntimeClasspath") + + val defaultDbPath = rootProject.layout.buildDirectory.file("seforim.db").get().asFile.absolutePath + systemProperty("seforimDb", (project.findProperty("seforimDb") as String?) ?: System.getenv("SEFORIM_DB") ?: defaultDbPath) + listOf("compactDb", "trainDictionaries", "pageSize").forEach { name -> + project.findProperty(name)?.let { systemProperty(name, it as String) } + } + + jvmArgs = listOf("-Xmx2g") +} diff --git a/generator/packaging/src/jvmMain/kotlin/io/github/kdroidfilter/seforimlibrary/packaging/CompactDb.kt b/generator/packaging/src/jvmMain/kotlin/io/github/kdroidfilter/seforimlibrary/packaging/CompactDb.kt new file mode 100644 index 000000000..7a92bd04f --- /dev/null +++ b/generator/packaging/src/jvmMain/kotlin/io/github/kdroidfilter/seforimlibrary/packaging/CompactDb.kt @@ -0,0 +1,258 @@ +package io.github.kdroidfilter.seforimlibrary.packaging + +import app.cash.sqldelight.driver.jdbc.sqlite.JdbcSqliteDriver +import co.touchlab.kermit.Logger +import io.github.kdroidfilter.seforimlibrary.dao.text.LineTextCodec +import io.github.kdroidfilter.seforimlibrary.dao.text.LineTextDictionaries +import io.github.kdroidfilter.seforimlibrary.db.SeforimDb +import java.nio.file.Files +import java.nio.file.Path +import java.nio.file.Paths +import java.sql.Connection +import java.sql.DriverManager +import java.util.concurrent.ExecutorService +import java.util.concurrent.Executors +import java.util.concurrent.Future +import kotlin.io.path.deleteIfExists +import kotlin.io.path.fileSize +import kotlin.random.Random + +private val logger = Logger.withTag("CompactDb") + +private const val DICTIONARY_SAMPLES = 30_000 +private const val DICTIONARY_SEED = 20_261_103L + +// On flash a 16 KiB read costs about the latency of a 4 KiB one, and holds 50 compressed lines: a page of the reader +// in one read (4 KiB pages read 3x more often on a small phone's storage, see COMPACT_DB.md) +private const val DEFAULT_PAGE_SIZE = 16384 +private const val CHUNK_LINES = 20_000 + +/** + * Writes the shipped database from the generator's: the line texts compressed against a dictionary of the corpus' own text + * ([LineTextCodec]), the tables and indexes of the current schema only (the generator's dev-only indexes go), every + * page written once and full. + * + * Usage: ./gradlew :packaging:compactDb [-PseforimDb=…] [-PcompactDb=…] [-PtrainDictionaries=] + * + * The dictionaries are the packaging's resources (`line_codec_dict/.bin`), the same for every release: a delta + * between two releases carries texts compressed alike. `trainDictionaries` builds new ones from the corpus and writes + * them to ; a release with new dictionaries can't be reached by a delta. + */ +fun main() { + val source = Paths.get(requireNotNull(System.getProperty("seforimDb")) { "seforimDb is required" }) + val target = System.getProperty("compactDb")?.let(Paths::get) ?: source.resolveSibling("seforim.compact.db") + val pageSize = System.getProperty("pageSize")?.toInt() ?: DEFAULT_PAGE_SIZE + val trainTo = System.getProperty("trainDictionaries")?.takeIf { it.isNotBlank() }?.let(Paths::get) + require(source != target) { "The compact database must be another file" } + compactDb(source, target, pageSize, trainTo) +} + +fun compactDb(source: Path, target: Path, pageSize: Int = DEFAULT_PAGE_SIZE, trainDictionariesTo: Path? = null) { + val started = System.nanoTime() + listOf("", "-wal", "-shm", "-journal").forEach { Paths.get("$target$it").deleteIfExists() } + + // The current schema, its indexes put aside until the rows are in + createSchema(target, pageSize) + DriverManager.getConnection("jdbc:sqlite:$target").use { conn -> + conn.exec("PRAGMA journal_mode=OFF") + conn.exec("PRAGMA synchronous=OFF") + conn.exec("PRAGMA cache_size=-262144") + conn.exec("PRAGMA foreign_keys=OFF") + val indexes = conn.strings("SELECT sql FROM sqlite_master WHERE type = 'index' AND sql IS NOT NULL") + conn.strings("SELECT name FROM sqlite_master WHERE type = 'index' AND sql IS NOT NULL") + .forEach { conn.exec("DROP INDEX \"$it\"") } + conn.exec("ATTACH DATABASE 'file:$source?mode=ro' AS src") + + val dictionaries = + if (trainDictionariesTo == null) { + shippedDictionaries() + } else { + buildDictionaries(conn).onEach { (id, data) -> + Files.createDirectories(trainDictionariesTo) + Files.write(trainDictionariesTo.resolve("$id.bin"), data) + } + } + conn.prepareStatement("INSERT INTO line_codec_dict(id, data) VALUES (?, ?)").use { ps -> + dictionaries.forEach { (id, data) -> + ps.setInt(1, id) + ps.setBytes(2, data) + ps.executeUpdate() + } + } + + conn.autoCommit = false + copyTables(conn) + copyLines(conn, LineTextCodec { dictionaries }) + conn.commit() + conn.autoCommit = true + + logger.i { "Creating ${indexes.size} indexes" } + indexes.forEach(conn::exec) + // No ANALYZE: the queries are tuned on plans without statistics, and loading sqlite_stat4 on each connection + // costs (SQLDelight's JDBC driver opens one per query) + conn.exec("DETACH DATABASE src") + conn.exec("PRAGMA journal_mode=DELETE") + } + val seconds = (System.nanoTime() - started) / 1e9 + logger.i { "Compact database: ${source.fileSize() / 1_048_576} MB → ${target.fileSize() / 1_048_576} MB in ${"%.0f".format(seconds)} s" } +} + +private fun createSchema(target: Path, pageSize: Int) { + // The page size holds once the file is written: VACUUM writes the empty database with it + DriverManager.getConnection("jdbc:sqlite:$target").use { + it.exec("PRAGMA page_size=$pageSize") + it.exec("VACUUM") + } + JdbcSqliteDriver("jdbc:sqlite:$target").use { SeforimDb.Schema.create(it) } +} + +/** Every table but the lines (and the dictionaries), copied row for row in rowid order, by their common columns. */ +private fun copyTables(conn: Connection) { + val tables = conn.strings("SELECT name FROM main.sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%'") + val sourceTables = conn.strings("SELECT name FROM src.sqlite_master WHERE type = 'table'").toSet() + for (table in tables) { + if (table == "line" || table == "line_codec_dict" || table !in sourceTables) continue + val sourceColumns = conn.strings("SELECT name FROM pragma_table_info('$table', 'src')").toSet() + val columns = conn.strings("SELECT name FROM pragma_table_info('$table', 'main')").filter { it in sourceColumns } + val withoutRowid = conn.strings("SELECT sql FROM src.sqlite_master WHERE name = '$table'") + .single().contains("WITHOUT ROWID", ignoreCase = true) + val list = columns.joinToString(",") { "\"$it\"" } + conn.exec( + "INSERT INTO main.\"$table\"($list) SELECT $list FROM src.\"$table\"" + + if (withoutRowid) "" else " ORDER BY rowid", + ) + } +} + +/** The lines in id order, their texts compressed in parallel by chunks and written in order. */ +private fun copyLines(conn: Connection, codec: LineTextCodec) { + val total = conn.strings("SELECT COUNT(*) FROM src.line").single().toLong() + val pool = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors().coerceAtMost(8)) + var written = 0L + var plainBytes = 0L + var storedBytes = 0L + try { + conn.prepareStatement( + "INSERT INTO main.line(id, bookId, lineIndex, content, heRef, tocEntryId, charCount) VALUES (?, ?, ?, ?, ?, ?, ?)", + ).use { insert -> + conn.createStatement().use { st -> + st.executeQuery("SELECT id, bookId, lineIndex, content, heRef, tocEntryId, charCount FROM src.line ORDER BY id").use { rs -> + // One chunk compressing while the previous one is written + var pending: List>>? = null + while (true) { + val chunk = ArrayList(CHUNK_LINES) + while (chunk.size < CHUNK_LINES && rs.next()) { + chunk += + SourceLine( + id = rs.getLong(1), + bookId = rs.getLong(2), + lineIndex = rs.getLong(3), + content = codec.decode(rs.getBytes(4) ?: ByteArray(0)), + heRef = rs.getString(5), + tocEntryId = rs.getLong(6).takeUnless { rs.wasNull() }, + charCount = rs.getLong(7), + ) + } + val next = if (chunk.isEmpty()) null else compressChunk(pool, codec, chunk) + pending?.flatMap { it.get() }?.forEach { line -> + insert.setLong(1, line.id) + insert.setLong(2, line.bookId) + insert.setLong(3, line.lineIndex) + insert.setBytes(4, line.content) + insert.setString(5, line.heRef) + if (line.tocEntryId == null) insert.setNull(6, java.sql.Types.INTEGER) else insert.setLong(6, line.tocEntryId) + insert.setLong(7, line.charCount) + insert.addBatch() + plainBytes += line.plainBytes + storedBytes += line.content.size + written++ + } + insert.executeBatch() + if (written > 0 && written % 500_000 < CHUNK_LINES) { + logger.i { "Lines: $written / $total, texts ${plainBytes / 1_048_576} MB → ${storedBytes / 1_048_576} MB" } + } + pending = next ?: break + } + } + } + } + } finally { + pool.shutdown() + } + logger.i { "Lines: $written, texts ${plainBytes / 1_048_576} MB → ${storedBytes / 1_048_576} MB" } +} + +private class SourceLine( + val id: Long, + val bookId: Long, + val lineIndex: Long, + val content: String, + val heRef: String?, + val tocEntryId: Long?, + val charCount: Long, +) + +private class CompactLine( + val id: Long, + val bookId: Long, + val lineIndex: Long, + val content: ByteArray, + val heRef: String?, + val tocEntryId: Long?, + val charCount: Long, + val plainBytes: Int, +) + +private fun compressChunk( + pool: ExecutorService, + codec: LineTextCodec, + chunk: List, +): List>> = + chunk.chunked(1_000).map { part -> pool.submit> { part.map { it.compact(codec) } } } + +private fun SourceLine.compact(codec: LineTextCodec): CompactLine { + val plainContent = codec.encode(content) + return CompactLine( + id = id, + bookId = bookId, + lineIndex = lineIndex, + content = smaller(plainContent, codec.compress(content, LineTextDictionaries.CONTENT)), + heRef = heRef, + tocEntryId = tocEntryId, + charCount = charCount, + plainBytes = plainContent.size, + ) +} + +// A text too short to gain from compression stays plain +private fun smaller(plain: ByteArray, compressed: ByteArray): ByteArray = if (compressed.size < plain.size) compressed else plain + +/** Random lines of the corpus, end to end, the last [LineTextCodec.DICTIONARY_SIZE] bytes kept. */ +private fun buildDictionaries(conn: Connection): Map { + val maxId = conn.strings("SELECT MAX(id) FROM src.line").single().toLong() + val random = Random(DICTIONARY_SEED) + val decoder = LineTextCodec { emptyMap() } + val sample = ArrayList(DICTIONARY_SAMPLES) + conn.prepareStatement("SELECT content FROM src.line WHERE id >= ? ORDER BY id LIMIT 1").use { ps -> + repeat(DICTIONARY_SAMPLES) { + ps.setLong(1, random.nextLong(1, maxId + 1)) + ps.executeQuery().use { rs -> if (rs.next()) rs.getBytes(1)?.let { sample += decoder.decode(it) } } + } + } + return mapOf(LineTextDictionaries.CONTENT to LineTextCodec.buildDictionary(sample)) +} + +private fun shippedDictionaries(): Map = + listOf(LineTextDictionaries.CONTENT).associateWith { id -> + val resource = "/line_codec_dict/$id.bin" + requireNotNull(object {}.javaClass.getResourceAsStream(resource)) { "Missing dictionary $resource" }.use { it.readBytes() } + } + +private fun Connection.exec(sql: String) { + createStatement().use { it.execute(sql) } +} + +private fun Connection.strings(sql: String): List = + createStatement().use { st -> + st.executeQuery(sql).use { rs -> buildList { while (rs.next()) add(rs.getString(1)) } } + } diff --git a/generator/packaging/src/jvmMain/resources/line_codec_dict/1.bin b/generator/packaging/src/jvmMain/resources/line_codec_dict/1.bin new file mode 100644 index 000000000..7600d22fe --- /dev/null +++ b/generator/packaging/src/jvmMain/resources/line_codec_dict/1.bin @@ -0,0 +1 @@ +Ì ÆÄ ÅÎË"Ù ÃÌ"Ù ÙÉÚ×Ï ÎÂ"Ú ÁÙÁÉÌ ÆÄ ÅÁÔØÈ ÃÂÅÓ ÄÎÂ"Ú ÙÐÚ×Ï ÁÒÚ ÄÆÀÚ ÄÉÄ ÁÙÁÉÌ ÄÖÃÅ×ÉÍ ÙÀÎØÅ ÃÒÖØÚ ÀÇØ ÄÙÁÚ ÅÒ"Ë ÃÄÀ ÃÀÑÅØ ÁÉÅÍ ÙÌÀÇØÉÅ ÄÅÀ ÁÇÌ ÁÇÅÌ ÅÙÅÁ ÄÃØÀ ×ÅÙÉÀ ÌÃÅËÚÀ ÃÄÉÀÊ ÀÑØÅ ÁÄÑÔà ÅÚÉÔÅ× ÌÉÄ ÃÀÑÅØ ÎÙÅÍ À"Ç ÀÎÐÍ ÁÂÅÓ Ä×ÅÙÉÀ ÐØÀÄ ÌÔÒÐ"à ÃÙÍ Î×ÙÄ ÎÄÑÔà ÃÌÉÎÀ Òà ÄÎÅÒà ÅÎÅÒà ÂÅÔÀ ÉÅ"È ÄÉÀ ÅÒ"Æ ÎÙÐÉ ÌÒÐÉÏ ÉÅÍ ÙÌÀÇØÉÅ ÅÄÉÉÐÅ ÁÄÑÔà ÅÎÒÚÄ ÐÉÄÅ ÃÀ"Ç ÀÑÅØ ÁÚÒÐÉÚ ÀÁÌ ÁÄÑÔà ÄÅÄ ÎÅÚØ ÃÄØÉ ÄÑÔà ÒÃÉÓ ÎÚÒÐÉÚ ÅÎ×ÖÚÄÅÏ ÃÌÀ ÌÎÑÔà ÅËÎ"Ù ØÙ"É ÙÍ ÃËÌÏ ÀÑÅØ ÁÚÒÐÉÅÚ ÅÎ×ÖÚÄÅÏ ÁÄÑÔà ÀÅÚÏ ÄÇÎÅØÉÍ ÅÎÒÚÄ ÎÙÅÍ À"Ú ÀÉÐÅ ÀÑÅØ Ø× ÁÚÒÐÉÅÚ ÁÌÁà ÅÁÔØÈ ÌÈÒÍ ÙÌ ØÙ"É ÁÑÅËÄ ÃÓ Î"Ä ÃÄÉÉÐÅ ÃÄÅÀ ÀÅÑØ ÌÇ ÅÙÍ ÌÀ ÀÎØÅ Ø× ÌÒÐÉÏ ÀËÉÌÄ ÅÙÚÉÉÄ ÅÂÍ ÌÈÒÍ ÙÌ ÄÉØÅÙÌÎÉ ÃÄÅÀ ÁØÄ ÃÎÅÒÃÀ Â"Ë ÌÀ ÀÑÅØ Ø× ÁÚÒÐÉÅÚ ÅÌËÊ ÀÑØÅ ÁÎÂ"Ú ÀÓ ÁÄÑÔÃ ÅÆ"Á ÌÔÒÐ"à ÅÁÌÀ"Ä ÉÙ ÌÅÎØ ÃÄÙ"Ñ ÃÉÌÏ ÇÅÌ× ÅÑÅÁØ ÃÀ"Ç ÎÅÚØ ÁÚÒÐÉÚ ÅËÎÅ ÃÇÅÌ× ÌÒÐÉÏ Ò"Ô ÃÎÁÅÀØ ÁÎ"Ñ ÃÀÑÅØ ÌÄÚÒÐÅÚ ÅËÎ"Ù ÁÎÌÎ"Ì ÙÍ:

ÃÓ ÎÂ.

ÑØÚÍ. ÎÌã ÄÑØÄ:ÅËÎÄ ËÃÐÉÉÃÉ ÐËÚÎÀ ÀÔÅÎÀ ÃÇÖÁÀ. ÔÉ' Ø' ÉÖÇ× ÆÖ"Ì ËÉÅÏ ÙÉÐÅà ËÅÚÌ ÄÀÔÃÐÀ ÎÙÄÅ, ËÀÙØ ÉÐÅà ÄËÑÅÉ ÒÌ ÔÉ ÄËà ËÙÄÀÙÄ ÐÅÙÀÚÅ ÅÄÅÌËÚ.

ÑÒÉÓ Ì

ËÌ Ä×ÅÃÍ ÁÄÏ ÆËÄ:

ÑÒÉÓ ×ÈÏ ËÃ

ÅËÃÁØÉ ÚÅÑ' ÃÄËÀ Ð×ÈÅ ÂÍ ÚÅÑ' Ì×ÎÏ ÌÆ: ÙÖÉÉÏ ÂÌÉÅÏ ÄÙ"Ñ. ÅØÀÄ ÒÅà ËÒÉÏ ÑÁØÀ ÆÅ ÁÚÅÑ' ÁÉÖÄ Ã: Ã"Ä ÅÚÐÏ. ÅØÀÄ ÒÅà ÎÙ"Ë ÌÉÙÁ ÄÙÔÚ ÀÎÚ ËÀÏ, ÅÒÎÅÃÉ ÀÅØ (ÑÉ' ÉÃ. È.), ÅÒ"Ò ÁÙÅ"Ú ÇÚÍ ÑÅÔØ (Ç"Æ ÑÉ' Â').ÁÔ' ØÀ"À ÀÍ ÌÀ ÄÁÉÀ ËÌÉ (ÙÁÚ ×Ì"Ä Ò"À) ÐÅÌà ÎÄÅÌ ÀÉÏ ÖØÉÊ ÌÄÈÉÓ ÃÍ ÁØÉÚ. ÅÀÉÏ ÎÇÌÌÉÏ ÒÌÉÅ ÄÙÁÚ ÉØÅÙÌ' ÙÇÉÈÄ ÚÅÌÃÚ ÇÁÅØÄ ÄÉÀ.(4) ÀÁÌ Ì×ÃÙÄ ËÙÄÉÀ ×ÈÐÄ - ÌÀ, Òà ÙÚÂÃÌ ÅÚÀÎØ: ÁÔÌÅÐÉ ÀÐÉ ØÅÖÄ, ØÙ"É. ÅÁØÙ"É [ÁØÀÙÉÚ ËÃ ÐÆ] ÒÌ ÎÄ ÙÀÎØÅ ÌÁÏ ÅÁÚÅÀÌ ÌÀÌÉÒÆØ "ÐרÀ ÌÐÒØÄ ÅÐÙÀÌÄ ÀÚ ÔÉÄ" ËÚÁ: ÎËÀÏ ÙÀÉÏ ÎÙÉÀÉÏ ÀÚ ÄÀÙÄ ÀÌÀ ÎÃÒÚÄ, ÅËÚÁ ÁÎÄØ"Í ÙÉÓ, ÃÆÄ ÄÅÀ Ä×ÙØ ÁÉÏ ÄÎÉÎØÅÚ ÁÒÐÉÏ Ä×ÈÐÄ ÙÀÉÏ ÎÙÉÀÉÏ ÀÅÚÄ Òà ÙÚÂÃÌ, ÌÎÄ ÙÀÎØÄ ÄÂÎØÀ ÌÒÉÌ ÙÎØÁ×Ä ÀÐÅ ÌÅÎÃÉÍ ÙÐÅÚÐÉÏ ÌÁÚÅÌÄ ÙÐÉÍ ÒÙØ ÇÅÃÙ.(É) Î¥À¥ÉÎ¨Ú§É À¥ÉÏ ×ũ֤֠ÉÏ À¦Ú ĨÀ¤ÉÌ¨Ï Á¬§Ù¬± Á¤ÉÒ¤ÉÚ. Á¬¥ÉÚ Ù±§Î¬§ÀÉ ÀũΠؤÉÍ, ˬ¨Ì ĨÀ¤ÉÌ¨Ï Î¤Ù¬±¦É¬Å©Ö¤ÉÀ. ŬÁ¥ÉÚ Ä¤Ì¬¥Ì ÀũΠؤÉÍ, ĦǨØÅ¬Á¤ÉÏ Î¤Ù¬±¦É¬ Ù±§Ì Ù±¥ÌŬ, Šħ¬ Ô¨Ð¤ÉÍ Î¤Ù¬±¦É¬ Â¨Ø ÒŬ, ŠħƬ¥ÉÚ¤ÉÍ Î¤Ù¬±¦É¬¨Ð¥ÖŬ, Ŭٱ À¨Ø ˬ¨Ì À¤ÉÌ¨Ï Î¤Ù¬±¦É¬Å©Ö¤ÉÀ. Å Ë¨Ì Ä¨À¤Ę́Ï, ˬ¥ÉÅ¨Ï Ù±¦Á¬¨À Ì ÒÅ©Ð§Ú Ä§Î¬§Ò§Ù² ØÅ©Ú, Ϋڬ¨Ø ̠ר֠ÖÅ©. ˬ§Î¬¨Ä ɠĥÀ Á§Æ¬§É¤Ú Å Ì©À ɠ׫֬¦Ð¬Å¬, Ø©Á§Ò. اÁ¬¨Ï Ù±¤Î ÒÅ©Ï Á¬¦Ï ¬§Î Ì¤ÉÀ¥Ì ÀũΥØ, ħˬ©Ì Ì Ô¤É Ä§Æ¬§É¤Ú: ÅÄÁÏ ËÉ ÉÑÅÃ ÄØÅÇ ÄÅÀ ÄÀÅÇÆ ÁÙÐÉ ÄÒÁØÉÍ ÁÉÏ ÄÎÉÍ ÅÁÉÏ ÄÀÙ ÅÀÅÇÆ ÁÙÐÉÄÍ ÅÎËØÉÒ ÁÉÐÉÄÍ, ÅÀÎÐÍ ËÉ ÑÅà ÄÒÐÉÏ ÄÆÄ ÁÄÉÅÚ ÁÎÒÙÄ ÁØÀÙÉÚ ÒÐÉÏ ÄÎÇÌÅ×Ú ÁÉÏ ÙÐÉ ÄÖÃÃÉÏ ËÉ ÄÎÇÌÅ×Ú ÄÅÀ ÚÎÉà ÁÉÏ ÄÀÙ ÅÁÉÏ ÄÎÉÍ ÀÁÌ ÄØÅÇ ÄÅÀ ÎËØÉÒ ÁÉÐÉÄÍ ÅÒÅÙÄ ÙÌÅÍ ÁÉÐÉÄÍ, ÅÒÌ ËÏ ÉÎÉ ÁØÀÙÉÚ ÀÎØÅ Æ"Ì ÌÎÄ ÌÀ ÐÀÎØ ËÉ ÈÅÁ ÁÙÐÉ ÎÔÐÉ ÙÁÅ ÐÁØÀ ÄÎÇÌÅ×Ú ËÉ ÄÎÇÌÅ×Ú ÄÉÚÄ ÁÉÏ ÄÉÅÍ ÄØÀÙÅÏ ÙÄÅÀ ÑÅà ÄÎÉÍ ÅÁÉÏ ÄÉÅÍ ÄÙÐÉ ÙÄÅÀ ÑÅà ÄÀÙ, ÅÒÌ ËÏ ÌÀ ÐÀÎØ ÁÉÅÍ ÄÙÐÉ ËÉ ÈÅÁ ËÉ ÄÅÀ ÙÎÀÌ ÅÁÅ ÄÚÒÅØØÅÚ ÄÎÇÌÅ×ÅÚ ÅÀÒ"Ô ÙÄÎÇÌÅ×Ú ÄÆÄ ÄÅÀ Ú×ÅÏ ÄÒÅÌÍ ÅÉÙÅÁÅ, ÀÁÌ ÀÒ"Ô ÙÄÅÀ ÙÎÀÌ ÎÔÐÉ ÙÁÅ ÐÁØÀ ÂÉÄÐÍ ÅÎÚÅÊ ÑÁÚ ÄÙÐÉ ÐÁØÀ ÂÉÄÐÍ, ËÉ ËÎÅ ÑÉÂ ÄÆÄÁ ÉÖÀ ÁÀÅÚÅ ÄÉÅÍ ÄÆÅÄÎÀ ÀÙØ ÁÅ ÅÄÁÏ, ÅÎÔÐÉ ËÏ ÌÀ ÐÀÎØ ÁÅ ËÉ ÈÅÁ, ÅÁÉÅÍ ÄÙÌÉÙÉ ÄÅÖÉÀ ÌÔÅÒÌ ÚÅËÏ ÙÐÉ ÄÉÎÉÍ ÅÐÑÚËÎÅ ÁÉÇà ÅÀÆÉ ÐÚÉÙÁ ÄÒÅÌÍ ÒÌ Ú×ÅÏ ÎÌÀËÚ ÄÎÇÙÁÄ ÄÒÌÉÅÐÄ, ÅÀÎÐÍ ËÉ ÌÔÉ ÆÄ ÄÑÅà ÐÀÎØ ÁÉÅÍ ÄÙÌÉÙÉ ËÉ ÈÅÁ ËÉ ÈÅÁ ÙÐÉ ÔÒÎÉÍ, ÅÎÄ ÐÇÎà ÄÒÐÉÏ ÁÄÉÅÚ ÄÎÃØÂÄ ÄÀÎÉÚÉ ÄÆÀÚ ÉÑÅà ÄÐרÀ ØÅÇ ÄÀÅÇÆ ÁÙÐÉ ÄÒÁØÉÍ ÅÎÑËÉÍ ÁÉÐÉÄÍ, ÅÒÌ ËÏ ÄÅÀ ÑÁÚ ËÅÌÍ ÅÄÅÀ ÙÌÅÍ:ÅÆÄ ÂÁ ÄÎÆÁÇ - ËÌÅÎØ ÁÀÎÄ ×ÈÐÄ ÆÅ ÐÎÃà ÄÀÎÄ ÙÌ ÎÆÁÇ ÄÆÄÁ ÃËÚÉÁ ÁÉÄ ÀÎÄ ÀØËÅ ÅÀÎÄ ØÇÁÅ (ÙÎÅÚ Ì) ÅÁÎÑËÚ ÎÐÇÅÚ ÁÔØ× ÙÚÉ ÄÌÇÍ (ÎÐÇÅÚ Ã' ÖÆ:) ÎÔØÙ ÌÉÄ ÌÄÀÉ ×ØÀ ÃÀÎÄ ÉÑÅà Ã×ÀÎØÉ Á×ÈÐÄ ÌÀÅ ÁØÅÇÁ ËÐÉÑÚ ÄÉÑÅà ÀÌÀ ÁÂÅÁÄ ÒÌÉÉÚÅ ÃÀÎØ ÎØ ÒÌÄ ÀÎÄ ÅËÐÑ ÀÎÄ ÆÄÅ ÉÑÅà ÀÁÌ ØÅÇÁ ÄËÐÉÑÄ ÁÀÎÚ ÁÚ ÙÙÄ ÅÀÎÄ ÑÅÁÁ ËÐÉÑÄ ÃÉÌÄ ÁÀÎÄ ×ÈÐÄ ÅÌÀ ÇÎÙ ÀÎÅÚ ÙÌ ÒÌÉÉÚ ÂÅÁÄÄ ÁÀÎÄ ×ÈÐÄ ËÃÚÐÏ ÒÌÄ ÇÎÙ ÅËÐÑ ÀÎÄ ÆÄ ÄÑÅÁÁ ÅרÐÅÚ ÌÀ ÙÐÀ ÂÅÁÄÏ ÅÌÀ ÙÐÀ ØÅÇÁÏ ÁÀÎÄ ×ÈÐÄ: ÄÂ"Ä - ËÀÙØ ÎÔÅØÙ Á×ÅÐÈØÑ ÙÎÒ ØÁÉÐÅ ÎØ' ÉÒ×Á ÁØ Éר ÅÒÚÄ ÇÆØ ÁÅ Ã×ÙÉÀ ÌÉÄ ÎÄ ÙÚØÂÍ ÉÅÐÚÏ ÀÎÄ ÀÎÄ ÅÈÔÇ ÀÎÚÀ ÃÄÉÀ ÀÎÚÀ ÅÔÙÊ ÅÐÎÖÀ ÃÁÀÎÄ ÂÃÅÌÄ ÎÉÉØÉ ÅÒÅà ÀÍ ËÃÁØÉ ÄÆ×Ï ÌÀ ÄÉ ÌÅ ÌËÚÅÁ ÅÇÉ× ËÉ ÀÍ ÇÉ× ÄÀÎÄ ÅÔÉØÙ ÌÐÅ ØÁÉÐÅ ÄËÉ ÌÎÒÌÄ ÄÆËÉØ ÎÃÅÚ ÄÎÆÁÇ ÅÄÀØÉÀÌ ÙÚÉÍ ÒÙØÄ ÀÎÄ ÅÙÀØ ÎÃÅÚÉÅ ÅÒÚÄ ËÊ ÀÎØ ÄËÚÅÁ ÀÌÀ ÎÃÅÚ ÄÎÆÁÇ ÙÀÎØÚÉ ÌÊ ÄËÌ ÐÎÃÃÅ ÁÀÎÄ ÙÄÉÀ ÀÎÄ ÅÈÔÇ ÅÇÉ× ÙÄÉÀ ÉÑÅà ÀÉÐÅ ÐÎÃà ÀÌÀ ÁÀÎÄ ÙÄÉÀ ÀÎÄ ×ÈÐÄ ÅÌÀ ÁÀÎÄ ÙÄÉÀ ÀÎÄ ÅÈÔÇ ÅÒÚÄ ÃÁØÉ ÉÅÐÚÏ ÁÏ ÒÅÆÉÀÌ ×ÉÉÎÉÏ ËÊ ÙÎÒÚÉ ÅÒÉר. Ò"Ë ÄÂ"Ä:ÚØÐ"ÆÔÅÐÃÉÅÏ ÒÉÉÏ: ÃÉÐØ ÙÙÅÄ. ËÑÓ ÑÚÍ. ÑÌÒ ÒÙØÉÍ ÅÀØÁÒÄ. ÔÃÉÅÏ ÁËÅØ.(ÉÃ) ÀÁÌ ÑÊ ÅËÅ' - ËÉÅÏ ÃÁÒÚ ÄÑÉËÄ ÌÀ ÐÂÒ ÄÙÎÏ ÁÄÒÅØ:ÀÎÅÐÚ ÄÇÃÅÙ ÉÙ ÎÀÉÏ ÀÓ ÀÍ ÄÉÀ ÀÎÅÐÄ ÖØÉÊ ÌËÌ ÁÒÌ ÃÚ ÀÌÄÉÚ ÌÄÀÎÉÐÄ, ËÎÅ ÙÉÇÅÉÉÁ ÄÎÀÎÉÏ ÁÚÅØÚ ÎÙÄ ÌÄÀÎÉÏ ÙÔÖÚÄ ÄÀØÕ ÀÚ ÔÉÄ ÅÚÁÌÒ ÀÚ ×ØÇ ÅÒÃÚÅ ÌÔÉ ÙÐÇÌ×Å ÒÌ ÎÙÄ, ÀÁÌ ÀÉÐÐÄ Òר ÎÒ×ØÉ ÄÚÅØÄ ÄÀÌÄÉÚ ÙÌÀ ÉÖÅÉÉØ ÎÖÉÀÅÚ ÚÅØÄ ÀÌÄÉÚ ÆÅÌÚÄ. ÅÌÀ ÄÚÇÉÌÄ ÄÚÅØÄ ÁÔØÙÚ ÁØÀÙÉÚ ÌÄÅØÅÚ ÒÌ ÇÃÅÙ ÉÙ ÎÀÉÏ ÅÌÙÅÎÅ Òר ÌÚÅØÄ ËÎÅ ÙÇÙÁÅ ÄØÁÄ ÎÏ ÄÇËÎÉÍ, ÌÔÉ ÙÀÓ ÀÍ ÄÎÀÎÉÏ Á×ÃÎÅÚ ÒÌ ÄÃØÊ ÙÉÀÎÉÐÄÅ ÀØÉÑÈÅ ÌÀ ÉÚÅÀØ ÄÙÍ ÁÙÉÙ ÌÅ ÉËÅÌÚ ÌÄÀØÉÊ ËÐÓ ÄÆÁÅÁ ÅÌÀ ÌÁØÅÀ ÐÎÌÄ ÁÒÌÚ ÀØÁÒ ØÂÌÉÍ ÁÌÁÃ, ËÌ ÙËÏ ÙÄÎÀÎÉÏ ÆÄ ÉËÇÉÙ ËÌ ÐÑÉ ÄÚÅØÄ, ËÉ ÌÀ ÉÀÎÉÏ ÙÉÙ ÌÅ ÉÚÁØÊ ÉËÅÌÚ ÌÄÔÅÊ ÄÎÈÄ ÐÇÙ ËÄØÓ ÒÉÏ ÅÄÎÉÍ ÃÍ ÅÄÒÔØ ËÐÉÍ, ÅÌÀ ÆÅ ÁÌÁà ÀÌÀ ÀÓ ÎÖÉÀÅÚ ÎÙÄ ÅÄÎÙÉÇ ÉÇÅÉÉÁ ÌÅ ÌÄËÇÉÙ, ÌÔÉ ÙÄÀÉÙ ÙÌÀ ÉÎÖÀ ÀÌÀ ÁÄÎÖÀ ×ÅÃÍ ÌÅ ÀÉÙÉÍ ÁÌÚÉ ÁÒÌÉ ÚËÌÉÚ ÀÉ ÀÔÙØ ÙÉÎÖÀ ÌÒÅÌÍ, ÌÔÉ ÙÄÁÌÚÉ ÁÒÌ ÚËÌÉÚ ÌÀ ÉËÌÄ ÌÒÅÌÍ, ÅÁÆÄ ÚÔÅÌ ÄÚÅØÄ ÁËÌÌÄ ÁÌÉ ÑÔ×, ÎËÌ Î×ÅÍ ÎÉ ÙÉÀÎÉÏ ÙÉÙ ÇÅÎØ ØÀÙÅÏ ×ÃÅÍ ÎÎÐÅ ÐÁØÀ ÅÐÚÇÃÙ ÄÒÅÌÍ ÁÒÚ ÙØÖÄ ÄÙÍ ÅËÎÅ ÙØÖÄ, ÌÀ ÉËÇÉÙ ÆÄ ÄÃÒÚ ÐÑÉ ÄÚÅØÄ ÅÎÅÔÚÉÄ, ËÉ ËÌ ÄÐÑÉÍ ÅÄÐÔÌÀÅÚ ÙÁÀÅ ÁÚÅØÄ ÁÙÉÐÅÉ ÈÁÒÅ ÅÎÐÄÂÅ ÙÌ ÒÅÌÍ ÌÀ ÄÉÅ ÉÖÉØÄ ÉÙ ÎÀÉÏ ÀÌÀ ÉÙ ÎÉÙ, ËÄÚÄÔÊ ÄÎÈÄ ÐÇÙ, ÅÙ×ÐÅ ÄÎÉÍ ÁÁÌÚÉ ÆÎÏ ÒÍ ÄÉÅÚÍ ÔÙÅÈÉÍ ÖÅØÚ ÃÍ, ÀÓ ÒÌ ÔÉ ÙÄÔÙÅÈ ÀÉ ÀÔÙØ ÙÉÚÄÔÊ ÃÍ, ËÉ ÌÆÄ ÌÀ ÉÆÅÐÅ ÄÎÉÍ ÀÚ ÄÁÒÌ ÇÉ, ÅÒÍ ËÌ ÆÄ Ä×ÐÄ ÄÙÍ ÉÚÁØÊ ÒÌ Éà ÎÙÄ ÐÁÉÀÅ ÌÇÌ× ÎÏ ÄÎÉÍ ÖÅØÚ ÀÙ ÅÌÇÌ× ÀÇØ ÖÅØÚ ÀÅÉØ ÅÌÇÌ× ÀÇØ ÖÅØÚ ÒÔØ ÅÈØÔÍ ÉÇÃ, ÅÐÚÎÆÂÅ ÅÐÄÔËÅ ÌÃÍ ÄÔÅÊ ÒÖÎÉ ÁÁÌÚÉ ÆÎÏ, ÅÌÀ ÌÎØÀÄ ÒÉÐÉÍ ÌÁÃ, ÙÀÍ ÄÉÄ ÌÎØÀÄ ÒÉÐÉÍ ÅÌÀ ÁÒÖÍ ÌÀ ÎÚÄ ÄÃÂÄ ÅÌÀ ÁÀÙ ÄÉÀÅØ. ÅËÏ ËÌ ÐÑÉ ÄÚÅØÄ ÅÄÐÁÉÀÉÍ ÙÄÉÅ ÁÒÖÎÉÍ ÌÀ ÄÉÚÄ ÁÄÍ ÉÖÉØÄ ÉÙ ÎÀÉÏ ÀÌÀ ÉÙ ÎÉÙ, ÅËÌ ÙËÏ ÎÄ ÙÄÉÅ ÎÄÍ ÁÎרÉÍ, ËÄÚÄÔÊ Éà ÎÙÄ ÎÖÅØÒÚ ËÙÌÂ.

ÑÒÉÓ ×ÈÏ Ç

ÔÑÅ× À

[*ÅÎÏ ÄÈÎÀ ÔÈÅØ. Î"Ù ÄØ"Á ÅÄÀÃÍ ÄÐÅÈÌÏ ÈÎÀ. ÄËÉ ÀÉÚÀ ÙÍ ÁÑÅÂÉ'. ÀÁÌ Ð"Ì ÃÌÀÅ ÃÅ×À. Ø× ËÃÉ ÙÉÄÀ ØÉÙÀ ÅÑÉÔÀ ÁÇà ÂÅÅÐÀ ÃÁÚØÅÅÉÉÄÅ ÄÀÃÍ ÈÎÀ. ×ÀÎØ [ÁÂÎ' ÎÒÈÏ ÈÎÀ] ÅÂÁØÀ ÈÎÀ ÅËÏ Ð"Ì ÎÚÅÊ ÔÉØÙ"É ÃÄÚÍ]: (É) ØÉÀÄ ÈØÔÄ ÙÐÎÖÀÚ ÁÉÏ ØÉÀÅÚ ËÙØÅÚ ÅÀÎØ ÄÁÅÃ× ÙÄÉ' ÉÅÃÒ ÁÀÅÚ' ÑÉØËÀ ÅÁÙÂÂÄ ÐÚÒØÁÅ ÀÅÚÄ ØÉÀÄ ÈØÔÄ ÁÉÏ ÄËÙØÅÚ ÅÌÀ ÄÉÚÄ ÁËÁÙÉÍ ÒØÁÅÁÉÀ ÄËÁÙÉÍ ÎÅÚØÉÍ:ÀÎÐÍ ÀÙÀ ÎÙÌÉ ÅÀÅÎØ ÎÙÌ ÌÐËÄ ØÂÌÉÍ ÀÉÐÅ ÉËÅÌ ÌÌËÚ ËÌ ÎÀÅÎÄ ÅÉÄÉ ÁÇÖÉ ÄÌÉÌÄ ÐÚÒÅØØ ÎÙÐÚÅ ÅØÀÄ ÃØÊ ÇÌÅÏ ÄÁÉÚ ÀÅØ ÌÄÁÚ ÀÙ ÂÃÅÌÄ ÎÀÉØÄ ÅËÁØ ËÎÄ ÁÚÉÍ ÃÅÌ×ÉÍ ÅÁÐÉ ÄÁÉÚ ËÌÍ ÉÙÐÉÍ, Ä×ÉÕ ÀÅÚÍ Á×ÅÌ ÖÒ×ÚÅ ÅÀÎØ ÎÄØÅ ×ÅÎÅ ÒÎÃÅ ÒÎÅÃÅ ÄÖÉÌÅ ÐÔÙÅÚÉËÍ ÅÂÍ ÀÚ ÐÔÙÉ ÄÖÉÌÅ ÒÎËÍ, ËÏ ÀÐËÉ ÒÎÃÉ ÉÃÒÚÉ ÂÍ ÉÃÒÚÉ ÎÊ ÒØËÉ ËÉ ÀÉÏ ÁÉ ËÇ ÌÄÖÉÌ ÀÚ ÒÖÎÉ ÎÀÙ ÎÉÃÚ ÄÃÉÏ ËÉ ÄÉÅÍ ÁÀ ÁÅÒØ ËÚÐÅØ ÀÎØÚÉ ÌÐÔÙÉ ÀÅÌÉ ÀÄÉÄ ÎÏ ÄÎÆËÄ ÀÚ ÄØÁÉÍ ÅÚÎÌÈÅ ÂÍ ÀÚ ÐÔÙÉ ÒÎËÍ ÅרÀÚÉ ÒÌÉ ÎרÀ ÆÄ רÀ ÁÂØÅÏ ÀÌ ÚÇÙÅÊ ËÙÅÔØ ÄØÍ ×ÅÌÊ (ÉÙÒÉÄ Ð"Ç, À') ÉØÖÄ ÙÌÀ ÉÃÀÅ ÄÎÅËÉÇ ÌÀÎØ ÎÉ ÀÐËÉ ÌÔÐÉ ÂÃÅÌÉÍ ÅÈÅÁÉÍ ÎÎÐÉ ËÉ ÀÁÅÀ ÌÄÒÉØ ÅÌÒÅØØ ÀÐÙÉÍ ÇÙÅÁÉÍ, ÌÀ ËÏ ÄÃÁØÉÍ É×Ç ×"Å ÎÏ ÄÙÅÔØ ÙÄÅÀ ÁÒÖÎÅÚÅ ÔÇÅÚ ÎÀà ËÉ ÀÉÐÅ Ø× ×ØÏ ÅÒÖÍ ÎÒÖÎÅÚ ÄÁÒ"Ç ÅÄÅÀ ×ÅØÀ ÅÎÅËÉÇ ÀÌ ÀÖÉÌÉ ÁÐÉ ÉÙØÀÌ, ÅÆÄŠרÀ ÁÂØÅÏ ÀÌ ÚÇÙÅÊ ÌÅÎØ ÎÉ ÀÚÄ ÌÄÅËÉÇ ÄÎÅÏ ÀÐÙÉÍ ØÁÉÍ Ò"Æ ÀÎØ ËÙÅÔØ ÄØÍ ×ÅÌÊ ÄÌÀ ÌÀ ÐÅÔÌ ÀÚÄ ÎÏ ÄÙÅÔØ Ä×ÅØÀ Á×ÅÌ ÅÎ×ÉÕ ÄÁØÉÅÚ:[Æ.] ÆÁÇÉÍ ÃÓ Ð"È ÀÎØ ØÁ ÎÆÁÇ ÙÐÔÂÍ ËÌ Ä×ÃÙÉÍ ÙÐÙÇÈÅ ÙÍ ÔÑÅÌÉÏ ÎרÀ ÄÅÀ ÁÉÃÉÐÅ ÅÙËÇÐÅÄÅ. ËÉ ÑÌÉ× ØÁ ËÄÐÀ ÀÙËÇÉ' ÌØ"Ù ÁØÉÁÉ ÃÀÎØ ÎÙÅÍ Ø' ÉÙÎÒÀÌ ÁØ' ÉÅÑÉ ÎÐÉÏ ÌÎÆÁÇ ÙÐÔÂÍ ÙËÌ Ä×ÃÙÉÍ ÙÐÙÇÈÅ ÙÍ ÔÑÅÌÉÏ ÙÐÀ' ÅÆÁÇÚ ÒÌÉÅ ÒÅÌÚÉÊ ÅËÉ ÒÌÉÅ ÄÅÀ ÆÅÁÇ ÀÌÀ ËÙÄÅÀ ÙÌÍ ÅÌÀ ËÙÄÅÀ ÇÑØ ÅËÅ' ÅØ' ÉÅÇÐÏ ÀÎØ ÀÇà ÆÄ ÅÀÇà ÆÄ ÔÑÅÌÉÏ (ÁÉÏ ÙÐÙÇÈÅ ÁÙÒÚ ÔÂÉÎÚÏ ÁÉÏ ÙÐÙÇÈÅ ÀÇØ Ú×ÅÐÅ ÔÑÅÌÉÏ ËÌ Ä×ÃÙÉÍ ÙÄÉÅ ×ÃÅÙÉÍ ÁÀÅÚÅ ÙÒÄ ÌÔÉ ÙÐØÀÅ ÅÐÃÇÅ) ÁÎÀÉ ÔÌÉÂÉ ØÁ ÑÁØ Á"Ç ÀÉÐÏ ÐÃÇÉÏ ÅØ"É ÑÁØ ÐÃÇÉÏ. ÎÉÚÁÉ ËÌ Ä×ÃÙÉÍ ÙÄÉÅ Òà ÙÌÀ ÐÁÐÄ ÎÆÁÇ ÅÀÇ"Ë ÐÁÐÄ ÄÎÆÁÇ ÔÑÅÌÉÏ. ÌÁÐÄ ÃÇÅÉÏ ÎÒÉרÀ ÐÉÐÄÅ ÀÌÀ Òà ÙÌÀ ÐÄØÑ ÄÎÆÁÇ. ÐÄØÑ ÄÀ ÀÉÆ×Ï ÌÄÅ ÀÌÀ Òà ÙÌÀ ÐÔÂÍ ÄÎÆÁÇ ÅÀÇ"Ë ÐÔÂÍ ÔÑÅÌ'. ÅÌÀ ÚØÅÖÉ ÎÚØÖÚ ÀÉÎÀ ÙÐÙÇÈÅ ÅËÅ'. ËÚÁÅ ÚÅÑ' ÚÉÎÀ ÃÀ"Ë ÎÙÎÒ ÃÔÉØËÀ ×ÎÉÉÚÀ ÃÔØÉÊ ÃÇÅÉÏ ÎÒÉרÀ ÄÅÉ ÅÀÔÉ' ÌØ' ÉÅÇÐÏ ÅÀÎÀÉ ÄÀ Ø"É ÑÁØ ÃÇÅÉ ÎÒÉרÀ ÄÅÉ ÃÇÅÉ. ÅÉ"Ì ÃÄÚÍ ÀÉÏ ÁÉÃÅ ÌÚ×Ï Î×ØÉ ÃÇÅÉ ÀÁÌ ÄËÀ ÁÉÃÅ ÌÚ×Ï ÄÎÆÁÇ ÅÌËÊ ÎÙÎÒ ÌÉ' ÄËÀ ÃÌË"Ò ÌÀ ÄÅÉ ÃÇÅÉ ÎÉÃÉ ÃÄÅÉ ÀÎÇÅÑØ ÆÎÏ ÁÂÅÔÏ ÅÁÁÒÌÉÍ ËÂÅÏ ÉÅÌÃÅÚ ÆÁ ÅÎÖÅØÒ ÙÄÔØÉÙŠרÁÐÅÚ ×ÅÃÍ ÆÎÐÏ Ä"Ð ÎÔØÉÙ ×ØÁÐÅ ÌÄרÉÁ ÌËÙÉÁÐÄ Á"Ä ÅÄÅÉ ËÎÇÅÑØ ÆÎÏ ÅÌÀ ÇÙÉÁ ÐÃÇÄ ÅËÅ' (ÎËÀÏ ÐØÀ' ÃÀÒ" ÃÎÆÁÇ ÙÐÔÂÍ Î×ØÉ ÁÉÃÅ Î"Î ËÉÅÏ ÃÐØÀ' ÅÐÃÇÄ ÌÀ ÎÄÐÉ ÁÉÃÅ ËÊ ÎÙÎÒ ÎÚÅÑ' ÄËÀ. ÅÖØÉÊ ÌÇÌ× ÁÉÏ ÄËÀ ÌÄÄÉÀ ÃÆÁÇÉÍ). ÅÁÎÐÇÅÚ ÃÓ Ð"È Ò"Á ÂØÑÉ' Ú"Ø ÌÀ ÉÙÉÍ ÒÌÉÄ ÙÎÏ (ÂÁÉ ÎÐÇÚ ÇÅÈÀ) ÅÀÍ ÙÍ ÔÑÅÌ ÉËÅÌ ÌÀ ÉÚÏ ÒÌÉÄ ÌÁÅÐÄ ÅÀÍ ÙÍ ÔÑÌ Ú"Ì ËÉ ÇÈÀÚ ÄÉÀ ÉËÅÌ ÀÓ ÁÙÎÏ Ú"Ì ÄÉÀ. ÅÎÄ ØÀÉÚ ÌÔÑÅÌ ÁÙÎÏ ÅÌÄËÙÉØ ÁÌÁÅÐ' ÙÎÏ À"À ÌÌÅ×ÈÅ ÌÁÅÐÄ ÀÔÙØ ÌÌÅ×ÈÅ. ÚÐÉÀ ÎÐÇÚ ÇÅÈÀ ÅÎÐÇÚ ×ÐÀÅÚ ÙÐÚÏ ÒÌÉÄ ÌÁÅÐÄ ÎÌ×È ÀÚ ÄÌÁÅÐ' ÅËÙØ' ÇÉÙÁ ÒÌÉÄ ÁÉÏ ÇÅÕ ÌÆÎÐÅ ÁÉÏ ÇÅÕ ÌÎ×ÅÎÅ ÀÍ Òà ÙÌÀ ÌÉ×È ÔÑÅÌ ÅÀÉÏ ÁÅ ËØÚ ÅËÅ' ÃÇÅÉ ÄÅÀ ØÁÀ ÀÎØ ÄÀ ÎÐÉ ÇÐÏ ÄÎÖØÉ ÃÌ"Ì ÃÇÅÉÏ ØÁ ÀÙÉ ÀÎØ ËÌ ÙÁÉÃÅ ÌÀ ÄÅÉ ÃÇÅÉ. ËÚÁÅ ÚÅÑ' ÖØÉÊ ÌÇÌ× ÁÉÏ ÆÄ ÌÄÄÉÀ ÃÆÁÇÉÍ ÃÓ Ð"È ÃËÌ Ä×ÃÙÉÍ ÙÄÉÅ Òà ÙÌÀ ÐÔÂÍ ÄÎÆÁÇ ÅËÅ' ÔÑÅÌÉÏ ÀÎÀÉ ÔÑÅÌÉÏ ÄÀ ÌÀ ÄÅÉ ÃÇÅÉ ËÉÅÏ ÃÁÉÃÅ ÌÚ×Ï ÄÎÆÁÇ ÒË"Ì:Î¥Ú Â¬Å©É Á¬ Ù±§Á¬¨Ú ΧÄŬ?

ÑÒÉÓ ÉÆ

ÌÒÎÌ ÚÅØÄ. ÀÒ" ÃÁËÌ ÒÐÉÉ ÃÒÌÎÀ ÀÉËÀ ÙËØ ÁÒÅÄ"Æ ÅÁÒÅÄ"Á Ð×È ÒÎÌÉ ÚÅØÄ ÃÒÃÉÓ ÆËÅÚÉÉÄÅ ÃÒÕ ÇÉÉÍ ÄÉÀ ÌÎÇÆÉ×ÉÍ ÁÄ. ÅÒÅà ÙÁÈÅÇ ÎÄËÙÌ ÁÀÐÙÉÍ ÙÀÉÐÍ ÎÄÅÂÐÉÍ:(ÎÆ) ÃÂÍ ÁÒÅÓ ÙÉÉÊ ÃÉÐÀ ÃÄÂ"Ä, ËÎÅ ÙËÚÁ ÄÙ"Ê ÙÍ ÁÉÅØÄ ÃÒÄ ÑÉÎÏ Ð"Ç ÑÒÉÓ ×ÈÏ ÃÀÉÏ ÇÅÔØÉÏ ËÅËÉÏ Å×ÁØÅÚ ÁÎÅÒà ñ ÂÎØ' ÎÀÉ ËÅËÉÏ ÀÎØ ØÁ ÉÄÅÃÄ ËÅËÉÏ ñ ÁÇÔÉØÄ, Å×ÁØÅÚ ñ ÁÁÐÉÏ ñ "ÚÁÅÀ ÁËÌÇ ÀÌÉ ×ÁØ" (ÀÉÅÁ Ä', Ë"Å) ÚØÂ' [ÚÒÅÌ] ÁÙÌÉÎÅÚ ÙÐÉÉÊ ÁËÅËÀ ÌÁÉÚ ×ÁÅØÚÀ.ÄØÁ ÉÒ×Á ÙÅÌÁÉÕ ÙÌÉÈ"ÀÐÒÅØ ÀÉÐÅ ÂÈ ÃÄÅÉÀ ÌÄ ÇÖØ ÄÎÙÚÎØÚ ÙÌÀ ÌÃÒÚÄ. ËÌÅÎØ ÌÔÉ ÙÄÒÁà ÎÙÎØ ÀÚ ÒÖÎÅ ÅÀÚ ÎÄ ÙÁÉÃÅ ÅÔØËÉÐÏ ÉÙÏ ÅÎÙÎØÚÅ ÄØÉ ÆÄ ÂÈ ÀÎÀÉ ÇÖØ ÎÄÌËÚ ÄÉÀ ÅÇÖØ ÎÄÌËÚ ÌÀ ×ÐÄ. ËÌÅÎØ ÃËÉ ÀÎÅØ ØÁÐÏ ÇÖØÅ ÙÌ ÀÃÍ ×ÅÐÄ ÌÅ ÌÀÅ ÁÎÄÌËÚ ÀÎÅØ ÃÙÐÉ ×Ø×ÒÉ ÃÐÉÉÃÉ ÎÎר×ÒÉ ÃÌÀ ÐÉÉÃÉ. ÅË"Ú ÉÙÏ ÙÀÐÉ ÅÄÀ ÀÎØ ØÁÀ ËÌ ÙÀÉÌÅ ÎÄÌÊ ÌÀ ×ÐÄ ÒÅÎà ÅÉÅÙÁ ÌÀ ×ÐÄ ÅÄÌËÚÀ ÁËÔÅÚ. ËÌÅÎØ ËÉ ×ÀÎØ ØÁÀ ÉÙÏ ÅÎÙÎØÚÅ Ä"Æ ÂÈ ÁËÔÅÚ ×ÀÎØ ÄÌËÊ ËÔÅÚ ÅÉÙÏ ÁÒÉÐÏ ËÔÅÚ ËÃÉ ÙÌÀ ÉÄÀ ÇÖØ ÎÄÌËÚ ÅÉÙÏ ËÃÉ ÙÉÄÀ ÎÙÚÎØ ÌÃÒÚÄ ÅÌÔÉ ÆÄ ÄÀ ÃÀÎØÉÐÏ ÁÄÎÁÉÀ ÚÐÉÉÏ (ÃÓ ËÀ.) ËÚÁ ÌÄ ÂÈ ÅÐÚÐÅ ÁÉà ÒÁÃÅ ÅËÚÁ ÌÄ ÙÈØ ÎÚÐÄ ÒÌÉÅ ×ÐÀÚÅ ÅÎÚÂØÙÚ ÁÅ ÅÀÅ×ÉÎÐÀ ÁËÔÅÚ ÅÌÀ ÎÃËØÉÐÀ ÉÙÏ ËÌÌ ÄÉÉÐÅ ÈÒÎÀ ÎÙÅÍ ÃÌÀ À×ÙÉÐÏ ÄÚÍ ÀÌÀ ÇÖØ ÎÄÌËÚ ÄÉÀ ÅÄËÉ ÔØËÉÐÏ ÌÄ ÅÎÙ"Ä ÀÅ×ÉÎÐÀ ÌÄ ÁËÔÅÚ ÅÎÉÄÅ Ä"Ä ÃÁÒÉÐÏ ÉÙÏ ÃÙÎÒÚÀ ÃØÁÀ ÄÉÀ ÁÄÃÉÀ ÅÀÇØÉÍ ÔÉØÙÅ ÃÄ"× ÅÄÌËÚÀ ÃÉÙÏ ÌÀ ×ÐÄ ÀÌÀ ÁËÔÅÚ ÅÀÉÎÀ ÄËÉ ËÔÅÚ ÅÎÙÎØÚÅ ÄØÉ ÆÄ ÂÈ ÀÉÐÅ ËÔÅÚ ÀÉÐÅ ÂÈ ÄÉÌËÊ ËÔÅÚ ÁÉÏ ÐÒÅØ ÁÉÏ ÉÙÏ ÄÅÉ ÂÈ ÅËÏ ÃÒÚ ÄØÎÁ"Í Æ"Ì ÁÔ"Ä ÎÄÌËÅÚ ÂÉØÅÙÉÏ ÅÀÉÐÅ ÎÇÅÅØ ÅÒÅà ÃÁØÉÅ ÎÚÎÉÄÉÏ ÙËÚÁ ÐÚÐÅ ÁÉà ÄÒÁà ÅÄÅÀ ÉÙÏ ÅÄÉÀ ÎÙÎØÚÅ Ä"Æ [ÂÈ] ÔÑÅÌ ÅÉÃÅÒ ÌÔÉ ÄËÌÌ ÙÌÅ ÙËÌ Î×ÅÍ ÙÄÅÀ ÎÆËÉØ ÔÑÅÌ ÀÉÐÅ ÀÌÀ ÎÃÁØÉ ÑÅÔØÉÍ ÅÀÍ ÐÙÀÚ ÌÀ ÚÖÀ ÅÆÅ ÎÐÉÏ ÌÅ. ÅËÚÁ ÒÅà ÙÍ ÙÀÍ ÀÉÐÅ ËÔÅÚ ÅÐÉÒÅØ [×ÐÚÄ] ÄÒÁà ÅÀÉÐÄ ÎÂÅØÙÚ Òà ÙÉÂÉÒ ÄÂÈ ÌÉÃÄ ÎÙÎÒ ÃÑ"Ì ÙÀÍ ÐÈÌÚÅ ÎÏ ÄÒÁà ÎÂÅØÙÚ ÅÄØÙÁ"À Æ"Ì ÎÑÚÔ× ÀÍ ÖØÉÊ ÙÉÈÌÐÅ ÄÁÒÌ ÅÉÇÆÅØ ÅÉÚÐÐÅ ÌÄ ÃËÙÐÈÌÚÅ ÄÉÀ ÃÉÌÎÀ ÄÅÄ ÌÉÄ ËÈÌÉ ÂÉÈÉÊ ÎÒÌ ÂÁÉ ×Ø×Ò:ÅÁÆÄ ÐÁÅÀ ÌÁÀØ ÌÙÅÏ ÄÂÎØÀ ÇÉÉÁ ÀÃÍ ÌÁÑÅÎÉ ÁÔÅØÉÀ Òà ÃÌÀ ÉÃÒ ÁÉÏ ÀØÅØ ÄÎÏ ÌÁØÅÊ ÎØÃËÉ, ÅÐ×ÃÉÍ ÎÄ ÙËÚÁÅ ÄÎÔØÙÉÍ (ÌÁÅÙ ÀÅ"Ç ÑÉÎÏ ÚØ"Ò ÑÒÉÓ Á') ÌÁÀØ ÌÎÄ ×ÁÒÅ ÉÎÉ ÄÇÐÅËÄ Ø× ÌÄÌÌ ÅÌÄÅÃÅÚ ÅÌÀ ×ÁÒÅ ÌÙÎÇÄ ËÎÅ ÁÔÅØÉÍ, ÃÁÔÅØÉÍ ÄÉÄ ÄÐÑ ÎÔÅØÑÍ ÌÄÖÌÚ ÐÔÙÅÚ ÉÙØÀÌ ÎÎÉÚÄ Ì"Ò ËÉ ÄÎÏ ØÖÄ ÌÄÙÎÉà ÌÄØÅ ÅÌÀÁà ÁÔÅÒÌ Ä' ÉÙÎØÐÅ, ÅÒÌ ÆÄ ÉÙ ÙÎÇÄ ÁÒÅÌÍ ÄÆÄ, ÀÁÌ ÁÇÐÅËÄ ÙÄÉÚÄ ÒÉר ËÅÅÐÚ ÄÉÅÅÐÉÍ ÌÒ×ÅØ ÃÚ ÉÙØÀÌ ÅÂÆØÅ ÂÆÉØÅÚ ÒÌ ÙÁÚ ÇÅÃÙ ÅÎÉÌÄ, ÌËÏ ×ÁÒÅ ÌÄÅÃÅÚ ÅÌÄÌÌ ÅÌÀ ÁÎÙÚÄ ÅÙÎÇÄ ÅÑÒÅÃÄ.ÉÙÉØ ÎÙÄ ÙÉØ ÄÙÉØÉÍ

ÑÉÎÏ ×ÉÈ

ÅÀÅÌÍ. ÄÅÀ"Å ÁÂÒÉÀ:(ÑÅ) ÅÇÆØÅ. ÒÁÀÄ"È ÙÌ ÎÄØÉ"È ÅÔÚ"Ù Î"Ù ÀÍ ÎÅÚØ ÌÒÙÅÚ ÉÉ"Ù Î×ÎÇ ÙÄÚÌÉÒ ÅÒÉ' ÁÙÌÇÏ ÂÁÅÄ Ñ"× É"Ç ÎÇÅÃÙ Â' ÙË' ÃÀÔÉ' ÌÄÈ"Æ ÃÀÑØ Á×ÎÇ ÉÅÃÄ ÃÁÇØÖÐÉÍ ÙÄÚÌÉÒÅ ÃÎÅÚØ ÌÒÙÅÚ ÎÎÐÅ ÉÉ"Ù ÃÌÉËÀ ÌÎÉÇÅÙ ÙÉÀËÌÅ ËÙÄÅÀ ÁÒÉÏ ÒÉÉ"Ù ÅËÄ ØÀÉÚÉ ÃÀÚÀ ÌÉÃÉ Ñ' ÆØ ÆÄÁ ÒÌ ÄÉÅ"à ËÚ"É ÎÄÂÀÅÏ ÁÒÌ ÀÅØÇ ÎÉÙÅØ Æ"Ì ÙÄÁÉÀ ÃÁØÉ ÄÖ"Ö ÄÐÆËØ ÅÎÚÎÄ ÒÌÉÅ ÒÌ ÙÌÀ ÄÁÉÀ ÃÁØÉ ÄÒ"Æ ÁÆÄ ÅÑÉÉÍ ÅÆ"Ì ÀÎÐÍ Ð"Ì ÔÙÅÈ ÃÂÁÉ ÔÌÅÉÎÉ"Ï ÂÍ ÄÈ"Æ ÎÅÃÄ ÃÎÅÚØ ÃÌÀ ÇÉÉÙÉÐÏ ÙÎÀ ÉÁÀ ÌÀËÌÅ ÁÒÉÏ ÃÄËÌ ÉÅÃÒÉÏ ÁÔÉØÅÚ ÙÉÙ ÁÅ ÚÅÌÒÉÍ ÙÀÑÅØ ÌÀËÌÅ ÃÐÚÌÙÅ ÁÎÇÅÁØ ÅÂÍ ØÅÁ ÄÒÅÌÍ ÐÆÄØÉÍ ÙÌÀ ÌÀËÅÌ ÔÌÅÉÎÒ"Ï ÀÅ ÃØÅË"Ï ÁÌÉ ÁÃÉ×Ä ÙÉÔÚÇÅ ÀÅÚÍ ÚÇÌÄ ÌØÀÅÚ ÀÍ ÉÙ ÁÅ ÚÅÌÒ ÅÄÅÉ ÄÀÉÑÅØ ÐÉËØ ÃÎÅÚØ ÌÎËÅØ Â"Ë ÅËÅ' ÒË"Ì ÅËÏ ÐÅÄÂÉÏ ÁÎ×ÅÎÉÐÅ ÙÒÅÙÉÏ ÉÉ"Ù ÎÙÆÅÔÉÍ ÙÄÍ ÎÌÀÉÍ ÚÅÌÒÉÍ ÅÑÃØ ÎÌÀËÚÏ ÙÐÅÚÐÉÏ ÄØÁÄ ÙÆÅÔÉÍ ÁÂÉÂÉÚ ÂÃÅÌÄ ÅÒÅÎà ÙÍ ËÎÄ ÉÎÉÍ Òà ÙÄÖÉØ ÆÁ ÎÄÙÆÅÔÉÍ ÌÄÂÉÂÉÚ ÅÐÒÙÄ ËÎÅ ÇÅÎÕ ÅÄÅÀ ÎÌÀ ÚÅÌÒÉÍ ÅØÅÇÙÉÏ ÁÚÅÊ ÄÂÉÂÉÚ ÄÐÄ ÅÄÐÄ ÒÅÙÉÏ ÎÎÐÄ ÉÉ"Ù ÅÀÉÏ ÙÅÍ ÀÃÍ ÎÔ×Ô× ÁÆÄ ÎÒÅÌÍ ÅÒÉ' ÁÙÅ"Ú Ç×ØÉ ÌÁ ÇÌ× À' ÎÉÅ"à ÑÉ' Ð" ÅÐ"à ÁÀØÉËÅÚ ÎÆÄ ÅÒÉ' ÁÑ' ÁÉÚ ÃÅà ÄÑÔØÃÉ ÇÉÅ"à ÑÉ' Ë"Æ ÅÁÑ' ÁÉÚ ÄØÅÀÄ ÃÓ Ì"È Ò"Á ÅÁÎÇÆÉ× ÁØËÄ ÀÅÚ È"Æ (ÅÒÉ' ÁÃÁØÉÐÅ ÌÄÌÏ Ñ"× ×"Î):ÑÔØÀ ÃÖÐÉÒÅÚÀ ÒÍ ÁÉÀÅØ ØÁÐÅ ÄÂØ"À ÆÌÌÄ"ÄÅÄËÉ ×ÀÎØ ËÌ ÐÃØÉÍ ÅÀÑØÉÍ ÅÙÁÅÒÅÚ Å×ÉÅÎÉÍ ÅËÅ' ÙÐÃØÐÅ ÅÙÀÑØÐÅ ÎÉÅÍ ÖÅÍ ÄËÉÔÅØÉÍ ÄÆÄ ÄÁÀ ÒÌÉÐÅ ÁËÅÌÍ ÇÆØÐÅ ÁÄÏ ËÌÅÎØ ÅÎÚÇØÈÉÍ ÀÐÅ ÁÄÏ ÒÌ ÙÒÙÉÐÅ ÀÅÚÍ ÅÀÅÎØ ÁÈÌ ÄÐÃØ ÎÒÉרŠÙÎÁÈÌÉÏ ÀÅÚÏ ÎÒÉ×ØÏ ËÃÉÏ ÄÚØÚ ÐÃØÉÍ ÅÀÓ ÒÌ ÂÁ ÃÄËÉ ÄÌËÚÀ ÃÖØÉÊ ÌÔØÅÈ ÀÚ ÄÐÃØ ÌÔÐÉ ÇËÍ ÅÄÐÉ ÌÀ ÔØÈÉ ÄÐÉ ÎÉÌÉ ÁÉÇÉà ÃÖØÉÊ ÌÔØÅÈ ÐÃØÅ ÙÎÀ ÐÃØ ÌÒÙÅÚ÷ÃÁØ ÈÅÁ ÅØÅÖÄ ÌÇÆÅØ ÁÅ ÅÀÍ ÉÔØÅÈ ÌÅ ÌÔÐÉ ÄÇËÍ ÌÀ ÉÚÉØ ÌÅ ÀÌÀ ÉÀÎØ ÌÅ ×ÉÉÍ ÀÚ ÐÃØÊ ÌËÊ ÄÌËÚÀ ÌÔØÅÈ.ÀÁÌ ÎÀÅØ ÒÉÐÉÐÅ ØÙ"É Æ"Ì ÃÒÚ ÀÇØÚ ÄÉÚÄ ÒÎÅ ÁÆÄ. ÃÌÀ ÐÉÇÀ ÌÉ' ÌÅÎØ ÃÀÉÏ ÎÃÌÉ×ÉÏ ÁÒÈØÏ ÀÔÉ' ÁÉÅ"È. ÎÙÅÍ ÃÀÍ ÐÉÎÀ ËÏ ÌÀ ÎÖÉÐÅ ÉÃÉÐÅ ÅØÂÌÉÐÅ ÁÁÉÄÎ"Ã. ÅÉÅ×ÙÄ ÌÐÅ ÚÅÑÔÚÀ ÒØÅËÄ ÁÔ"Á ÃÙÁÚ, ÄÎÅÁÀÚ ÂÍ ÁÙ"Ñ ÙÁÚ Ë"à ØÒ"À, ÃÚÐÉÀ ËÌ ÀÌÅ ÙÀÎØÅ ÀÉÏ ÎÃÌÉ×ÉÏ ÁÄÏ ÁÙÁÚ, ÎÃÌÉ×ÉÏ ÁÄÏ ÁÉÅ"È, ÇÅÕ ÎÙÎÏ ÙØÉÔÄ ÅËÅ'. ÅÀ"Ë ÎÄÀÉ ËÌÌÀ ÃÀÉÚÎØ ÁÔÉØÅÙ ÁÚÅÑÔÚÀ ÃÁËÌ ÀÌÅ ÙÀÉÏ ÎÃÌÉ×ÉÏ ÁÙÁÚ ÎÃÌÉ×ÉÏ ÁÉÅ"È. ÎÅËÇ ÌÄÃÉÀ ÃÂÍ ÁÒÈØÏ, ÀÒ" ÙÀÉÏ ÎÃÌÉ×ÉÏ ÁÅ ÁÙÁÚ, ÎÃÌÉ×ÉÏ ÁÅ ÁÉÅ"È. Á). ÅÎÆÄ ÄÅËÉÇ ØÙ"É Æ"Ì ÌÅÎØ ÃÂÍ ÈÒÎÀ ÃØ' ÉÙÎÒÀÌ ÃÀÉÏ ÎÃÌÉ×ÉÏ ÁÒÈØÏ ÎÔÐÉ ËÁÅà ÙÁÚ, ÃÄÉÉÐÅ ÎÚÅÊ ÙØÉÇÅ ØÒ ÂÆØÉÐÏ ÙÎÀ ÉÐÉÇÐÅ ÅÉÖÀ, ËÙÁÚ Ë"Ä Ò"À ÄÐ"Ì. ÌÀ ÙÉÉÊ ÐÎÉ Ø× ÂÁÉ ÙÁÚ. ÎÙÀ"Ë ÁÉÅ"È ÙÔÉØ ÎÃÌÉ×ÉÏ ÁÒÈØÏ. ÎÙÅÍ ÃÔÙÉÈÀ ÌÄÅ ÌË"Ò ÃÁÉÅ"È ÌÉËÀ ÌÎÉÂÆØ ÙÎÀ ÉÐÉÇÐÅ ÅÉÖÀ. ÙÄØÉ ÁÉÅ"È ÀÔÙØ ÌÄÃÌÉ× ÐØ ÀÇØ ÁÎ×ÅÎÅ ÙÌ ÄÐØ ÎÄÒÈØÏ, ÅÌÄÅÖÉÀ ÀÚ ÄÐØ ÙÌ ÄÒÈØÏ ÎÏ ÄÁÉÚ. ÅÒÔÉ"Æ ÙÔÉØ Ã×Ã× ØÙ"É Æ"Ì ÁÌÙÅÐÅ ÄÆÄÁ ÅËÚÁ:ÅÐØÀÄ ÌÁÀØ ÄÒÐÉÏ ÒÔ"É ÃØËÅ ÙÌ ÄÉÔ"Ú Æ"Ì ÀÊ ÁÀÅÔÏ ÀÇØ, ÃÄÐÄ Î"Ù ÄÉÔ"Ú ÃÀÉÏ ËÅÅÐÚ ÄÎÃØÙ ËÔÙÅÈÅ ÒÌ ÁÐÉ ÀÃÍ ÙÀÉÏ ÁÄÍ ÎÖÅÚ ÅÎÒÙÉÍ ÈÅÁÉÍ ËÐÌ, ÅÃÀÉ ÙÔÚÅ ÁØÅØ ÎÌÌÅ, ÙÄØÉ ÁÐÉ ÀÃÍ ËÀÌÅ ÀÉÏ ÙÉÉÊ ÌÄÚ×ÙØ ÒÎÄÍ ËÌÌ ÀÔÉÌÅ ÁØÎÆ, ÅÄÀÎÚ ÉÅØÄ ÃØËÅ ÃÎÉÉØÉ ÁÁÐ"À ÙÅÎØÉ ÚÅØÄ ÅÎÖÅÚ ÀÌÀ ÙÀÉÐÍ Ò"Ö ÄÙÌÉÎÅÚ ÅËÐ"Ì, ÀÎÐÍ ÀËÚÉ ÄÒÐÉÏ ÖØÉÊ ÁÉÀÅØ ×ÖÚ ÌÄÁÉÏ ÎÄÅ ÄÂÃØ ÁÆÄ, ÅÎÉ ËÄÇËÍ ÉÅÃÒ ÔÙØ ÃÁØ ÌÄÁÇÉÏ ÎÉ ÄÅÀ ÆÄ ÄÐÇÙÁ ÌÁÒÌ ÚÅØÄ ÅÎÒÙÉÍ ÈÅÁÉÍ ÅÀÉÆÄ ÄÅÀ ÄÐÇÙÁ ÌÀÉÏ ÁÅ ÚÅØÄ ÅÎÒÙÉÍ ÈÅÁÉÍ.Ä) ÌÅÇ ÄÎÅ×ÖÄ (ÒØÊ Î×ÌÓ ÉØ×ÅÚ) ð "ÎÌÀËÚÅ ÌÀÉÑÅØ".ÙÅÔØÅÚרÁÏ ÎÐÇÄ ÎÌÎà ÙÄÉÇÉà ÎÚÐÃÁ ÌÁÅÐÄ ÔÉ' ÌÁÅÐÄ ÁÔÐÉ ÒÖÎÄ ÁÌÀ ÎÐÇÄ. ÅרÁÏ ×ØÀ ×À ÃØÉÙ ÉÚÉØÀ:

ÙÉÒÅØÍ ÅÖÅØÚÍ

ÅÎÉ ÙØÉ ÌÎÑÐÉ. ÅÄ×ÙÄ ÁÇ×ØÉ ÌÁ ÃÓ ×Ì"à ÃÉÌÎÀ ÎÉÉØÉ ÃÒÁØ ÅÙÐÀ ÃÀÉ ÌÀÉÑÅØÀ ËÚÁ רÀ ÅÐØÀÄ ÃÌÀ ×ÙÉÀ ÃÃÅ×À ÁÀÉÑÅØ ÄÚÌÅÉ ÁÎÒÙÄ ËÚÉÁ רÀ ÌÀÉÑÅØ ÃÀÉ ÒÁØ ÅÒÙÄ ÀÁÌ ÃÁØ ÄÚÌÅÉ ÁÌÁ ÄÀÃÍ ÌÀ ÙÉÉÊ ÌÅÎØ ÃÀÉ ÒÁØ ÃÄØÉ ËÙÉØÀÄ ÇÎÅØ ÙÅÐÀÅ ÀÉÐÅ ØÙÀÉ ÌÄÐÉÇ ÅÌÔØÅ× ÁÙÁÉÌ ÙÐÀÚÅ ÙÄØÉ ÄÅÀ ÒÅÁØ ÒÌ ÌÀ ÚÙÐÀ ÀÇÉÊ ÁÌÁÁÊ ÀÌÀ ÅÅÃÀÉ ÌÄËÉ ËÚÁÄ ÚÅØÄ ÇÎÅØ ÙÅÐÀÊ ÁÒÐÉÏ ÃÎÅÚØ ÌÙÐÀÚÅ:

ÔÑÅ× À

Ñ×"Æ ÅÌÔÉ Î"Ù ÌÒÉÌ. Ø"Ì ÄÎÇÁØ ÁÑ"Ã:×ÐÂ. ÅÌÒÐÉÏ ÑÒÅÃÄ ÙÌÉÙÉÚ ÌÀ ÐÄÂÅ ÌÀ ÁÉÅÍ ÆÄ ÅÌÀ ÁÙÅÍ ÉÅÍ ÈÅÁ ËÉ ÀÉÏ ÑÒÅÃÄ ÙÌÉÙÉÚ Ø× ÁÙÁÚ ÁÌÁà ËÎÁÅÀØ ÑÅÃÏ ÁÑÔØ ÄÆÅÄØ ÙÄÍ ËÐÂà ÄÁÇÉÐÅÚ ÄÐÒÙÅÚ ÁÙÁÚ ÎÄ ÙÌÀ ÐÒÙÄ ËÏ ÁÙÅÍ Ç ÅÉÅÍ ÈÅÁ, ÅÌÔÉËÊ ÀÍ ÇÌ ÌÄÉÅÚ ØÀÙ ÄÙÐÄ ÁÙÁÚ ÌÀ ÉÁÈÌÐÄ ÅÉÒÙÐÄ ÁÃÁØ ÎÅÒÈ ËÃÉ ÙÉÒÅØ ÙÉÚÇÉÉÁ ÒÌÉÅ ÁØËÚ ÄÎÆÅÏ ÎÔÐÉ ËÁÅà ÉÅÍ ÈÅÁ ÙÐÉ ÅÒÌÉÅ ÚÁÀ ÁØËÚ ÈÅÁ.ÅÀÍ ÐÚÐÄ Ô×ÃÅÏ ÌÀÇØ ÒÉÉÏ ÁÈÅØ À"Ò ÅÙ"Ò ÑÉ' Ô"Å ÅÀÍ ÐÚÐÄ ÌÀÇà Ô×ÃÅÏ ÁÑÚ' ÅÌÀ ÔÉØÙÄ ÀÍ ÄÅÀ ÙÌÄ ÀÅ ÙÌ ÁÒÌÄ ÀÊ ÄÅÀ ØÂÌÉÍ ÌÃÁØ ÙÄÅÀ ÎÙÌ ÁÒÌ ÖØÉÊ ÌÄÇÆÉØ ÌÉÅØÙÉ ÄÁÒÌ ÎÄØ"Î ÎÉÐÕ ÑÉ' Ë" ÅÒÉÉÏ ÒÅà ÙÍ ÁÑÉÎÏ Ð"Ä:Ñ×È"Å ÂØÒ ÈÔÉ ÅËÅ'. ÃÄÀ ÁÎ×ÅÍ ÀÇà ÁØÅÁÅ ÅÁÁ' ÅÂ' Î×ÅÎÅÚ ÉÙ ÙÔÅÑÌÉÏ ÀÔÉ' ÁÎÉÒÅÈÅ ÅÎËÇ ×ÅÙÉÀ ÆÅ ÄÅËÉÇ ÄÎ"À ËÎÅ ÙÔÉØÙ ÁÑ"× É" ÃÎ"Ù ÙÍ ÎÖà ÀÇà ÀÉÏ ÔÉØÅÙÅ ÙÚÅÔÑ ÄÐÉÎÅØ ËÌ ÄÖà ÀÌÀ Ø"Ì ÙÀÉÐÅ ÚÅÔÑ Ø× ÚÉ×Ó ÎÖà ÀÇÃ:4. ÀÅÌÉ ÁÎ×ÅÍ ÎÖÅÄ [ÀÑÅØ ÎÖà ÙÌÉÇÅÚ].ÐÁ] ËÌÉ ÙÌÉÙÉ

×ÅÃÍ ÄÅÅÉÃÅÉ

ÉÙÁÒ ÖÃÉ× ÇËÎÄ ÎÅÑØ ÈÅÁ ÎÌÇÍ ÈÅÁ ÎÁÙØ ÑÔ×Å ÉÚÏ ÀÌ ÇÉ ÐÅÚÏ ÎØÅÍ ÌÇÍ ÀÌ ËÌ ÁÙØ ØÇÎÉ ÖÅØÅ ÄÍ ÙÁØÅ ËÉ Ùר ÁÈÇÅÏ ÐÃÉÁ ÅÙØ ÀÅËÌ ÖÃÉ× ÙÅÁÒ ÐÔÙÅ ËÉ ÙËÌÅ ÒÌ ÉÖØÅ ÄÅÙØ ÌÀ ÉØÒÉÁ ÀÌ ÐÔÙ ÖÃÉ× ÂÍ ÁÈÏ ØÙÒ ËÌ ÚÇÑØ.ÃØÙÄ ÁÇ ÄÙÁÅÒÅÚ ÚØÈ"Æ ÌÔ"× ÎÀÎ"Å ÄÂÀÅÏ ÔÀØ ÄÃÅØ Ë×Ù"Ú ÎÄÅ' ÉÅÃÀ ÀÑÀà Ð"É ÀÁ"à ÃÔÄ Ñ"Ä ÉÒ"À:

ÂÐÚ ÁÉÚÏ

ÚÌÎÅà ÌÅÎØ (ÅÉרÀ Æ,ÉÂ) ÒÌ ÇÌÚ ÌÇÍ ÇÎÕ [ÉרÉÁ רÁÐÅ ÒÌ ÆÁÇ ÚÅÃÚ ÙÌÎÉÅ]:' ÐÂà ÇÎÕ ÄÁÀ ÎÖÄ [ÑÔØÀ ÖÅ ÔØÙÄ Æ ÎÙÐÄ Æ] (ÎÐÄ ÄËÚÅÁ ÎÉÐÉÏ ÙÁÎÖÄ, ÅËÚÁ ÀÇØÉÄÏ ÒÌ ÇÌÚ ÌÇÍ ÇÎÕ - ÄØÉ ÄÉ×Ù; ÀÌÎÀ ÇÎÕ ÙÌÎÃÐÅ ÁÅ ÒÙØÄ ÒÙØÅÐÅÚ ð Á'ÄÉÎÐÅ ÅÃÁØ ÀÇØ' ÇÅÆØ ÅÎÌÎà ÒÌ ÄÎÖÄ ÁÄÉ×Ù ÒÙØÄ ÒÙØÅÐÅÚ); ÀÌÀ ÌÎÀÏ ÃÀÎØ ÄÅÉ ÄÉ×Ù - ÎÀÉ ÀÉËÀ ÌÎÉÎØ?ÀÌÅ ÉÎÉ ÄØÒÄ. ËÎ"Ù Ì×ÎÏ ÔÑÅ× Òà ÀÙØ ÌÀ ÉÁÅÀÅ ÉÎÉ ÄØÒÄ: È ØÁÉÐÅ ÄÂÃÅÌ ØÎ"À ÁÀ"ÄÒÆ ÁÑÉÎÏ Å' Ñ"Ç ÌÀÇØ ÙË' ÁÙ"Ò ÙÀ"Ð ÄÀÁ ÌÅÎØ ÙÐÙÁÉÚ ÁÚÅ ËÚÁ ÅÄ"Ä ÀÍ ÀÅÎØ ÙÐÁÒÌÄ ÁÒÉÌÚ ÀÉÑÅØ ÅÐØÙÍ Î×ÅØÅ ÎÎ"Î ÁÙÍ ØÙÁ"À ÅËÏ ÎÁÅÀØ ÁØ"Ï ÙË' ÅÀ"Ú ÌÄÉÎÐÄ ËÉ ÀÎØÄ ÐÙÁÚÄ ÁÎÂÅ ÙÄÉ' ÀÅÎØ ×ÃÙÚÉ ÁÁÉÀÄ ÌÔÅÑÌÄ ËÅ' ÌÀÅ ×Å' ÄÅÀ Ã×ÃÅÙÉ ÁÉÀÚ ÀÉÑÅØ ÌÀ ÀÙËÇÏ ÃÄÉÎÐÄ ÅÄËÉ ÎÅËÇ ÁÉØÅÙÌÎÉ ×ÃÙÚÉÄ ÌÀÇà ÎÏ ÄÔÑÅÌÉÏ ÌÄ ÐÀÎÏ ÄÁÒÌÚÉÄ ÌÀÇà ÎÏ ÄÔÑÅÌÉÏ ÌÄ À"Ð ÉÒ"Ù, ÅÀÅÌÍ ØÀÉÚÉ ÁØÉÈÁ"À ÙËÚÁ ÅÆ"Ì ÅËÉ ÚÉÎÀ ÌÉÄÎÏ ÌÔÑÌÄ ÌËÄÅÐÄ ÎÂÅ ÃÀÉ ÁÒÉ ÀÎØ Ù×ÃÙÄ ÅÄÙÉÀÄ ÁÁÉÀÄ ÌÎÎÆØ ÅÔÑÅÌÉ ËÄÅÐÄ ÉÒ"Ù ÙÎÅËØÇ ÙÑÅÁØ ÙÐÀÎÏ ÌÅÎØ Ù×ÃÙÄ ÅÄÙÉÀÄ ÁÁÉÀ' ÌÔÑÅÌÉÍ ÅÇÅÌ× ÒÌÉÄÍ ÅÁÒ"Ë ÎÔØÙ ÌÙÅÏ ÉØÅÙÌÎÉ ËÎ"Ù ÁÑ' ÄÔÌÀÄ ÄÁÒÌÚÉÄ ÁÆÐÅÚ ÃÄÅÉ ÃÅÎÉ' ÃÙÁÅÉ' ÀÁÌ ÐÀÎÏ ÌÅÎØ Ù×ÃÙÄ ÁÁÉÀÄ ÀÅ ÄÙÉÀÄ ÁÁÉÀÄ ÌÔÑÅÌ ÌÄ, ÄÂÍ ËÔÉ ÙÎÒÚÉ× ÄÔÐÉ ÉÄÅÙÒ ÃÁØÉ ØÉÈÁ"À ÌÀ ÎÅËÇ, ÀÁÌ ÁÌÙÅÏ ØÉÈÁ"À ÙÌÔÐÉÐÅ ÄÅÀ ËÎ"Ù, ÅËÏ ÁÌÙÅÏ ØÎÁ"Í ÁÔØ× É"Ç ÎÀ"Á ÄË"à ÙË' ÅÆ"Ì ÐÙÁÉÚ ÅÔÃÉÚÄ ËÅ' À"Ð ÙÌÀ ÄÀÎÉÐÄ ÚÅØÄ ÀÌÀ ÌÀÅÑØÄ ÎÙÅÍ ÀÉÙÅÚ ËÅ' ÀÁÌ ÌÀ ÌÔÅÑÌÄ ÎÙÅÍ ÆÐÅÚ ÉÒ"Ù ÎÙÎÒ ÃÅ×À ÆÐÅÚ ÀÁÌ ÀÍ ÀÎØ ÙÄÙÉÀÄ ÌÔÑÅÌ ÌÄ ËÉÅÏ ÙÄÅÀ ÃØÊ ÐÙÅÀÉÏ ÃËÌ ÐÚÉÐÅÚ ÁÎÙÎÒ ÎÌÙÅÏ ÀÚ ÁÚÉ ÐÚÚÉ ÅËÏ ÎÙÎÒ ÎÃÄÙÎÉÈ ÃÁØÉ ÉØÅÙÌÎÉ ÄÐ"Ì ÙÃØËÅ ÁËÌ Î×ÅÍ ÌÄÁÉÀ ÃÉÏ ÎÇÅÃÙ ÄÐÆËØ ÙÍ ÀÒ"Ë ÙÔÉ' ËÏ ÁËÅÅÐÚÅ ÌËÏ ËÌÌ ËÏ ÁÎÚ× ÌÙÅÐÅ Ä×ÃÅÙ ÅÀ"Ë ÉÙ ÌÚÎÅÄ ÒÌ ØÎ"À ÙÄÙÎÉÈ ÃÒÚÍ, ÅÀÅÌÉ Î"Ù ØÎ"À ËÐ"Ì ËÅÅÐÚÅ ÙÐÁÒÌÄ ÁÆÐÅÚ ÌÔÑÅÌ ÌÄ ÃË"Ò ÎÅÃÅ, ÀÁÌ ÀÍ ÀÅÎØ ÙÄÙÉÀÄ ÌÔÑÅÌ ÌÄ ÐÀÎÏ ÎÉÄÅ ÌÙÅÐÅ ÑÚÅÍ ÅÂÍ ÎÄ ÙÐØÙÍ Î×ÅØÅ ÎÄ"ÄÎ ÌÉÚÀ ÅÚÅ ÃÒË"Ô ÄÅ"Ì ÎÇÌÅ×Ú ÄÔÅÑ×ÉÍ ÄÐ"Ì ÅÖ"Ò, ÅÁÁÉÀÅØ ÃÁØÉ ÄØ"Ï ÎÁÅÀØ ÄÉÈÁ ÁÇÉÃÅÙÉ ÎÅÄØ"É ÈØÀÐÉ Æ"Ì ÙÍ ÉÒ"Ù ÅÄÂÀÅÏ ÁÒÌ ÔÐÉ ÉÄÅÙÒ Æ"Ì ÌÀ ØÀÄ ÃÁØÉ ÎÅÄØÉ"È ÅÄ×ÙÄ Â"Ë ×Å' ÎÀÉ Î×ÙÄ ÄÙ"Ñ ÅÄØÉ ÁÉÃÅ ÌÄÙÉÀÄ ÌÎÎÆØ ÃÌÎÀ ÌÀ ÆËÉ' ÌÉ' ØÇÎÐÀ Á×ÃÅÙÉ ÄÉÚØ ÅÚÉØÅÖÅ ÚÎÅÄ ËÎ"Ù ÁÑ' ÄÔÌÀÄ, ÅÄÐÄ ÎÅÄØÉ"È Æ"Ì ÚÉ' ÒÌ ×Å' ÄØ"Ï ÙÌÉËÀ ÎÂÅ ÙÀÉÏ ÀÅÎØÉÏ ÎÂÅ ÀÌÀ ËÙÈÒÐÅÚ ÙÅÅÉ' ÃÌÀ ÁÒÉ ÌÀØÅÒÉ ÐÔÙÉ' ÙÒÙÄ ÀÉÑÅØ ÁÉÃÉÍ ÀÁÌ ÁÒÉ ÌÀØÅÒÉ ÁÚÅ ÌÅÎØ ÙÄÉÀ ÔÂÅÎÄ ÙÐÙÁÉÚ, ÅÌËÀÅØÄ ×ÙÄ ÃÀ"Ë ÎÀÉ Î×ÙÄ ÄÙ"Ñ ÅÄØÉ ÁÉÃÅ ÌÄÙÉÀÄ ÌÎÎÆØ ÄÀ ÌÀ ÄÅÉ ÎÂÅ Ã×À ÎØÒÉ ÐÔÙÉ' ÙÒÅÙÄ ÒÖÎÅ ØÙÒ ÅÎÖÀÚÉ ÁÑ' ÙÒØÉ ÄÎÌÊ ÁÔÉ"Ç ÎÀ"Á ÄË"à ÙÄØÂÉÙ ÁÆÄ ÅÚÉØÕ ÅÙÎÀ ÎÂÅ ÃÁÉÃÅ ÀÌÉÍ ÈÔÉ ÅÎÄÐÉ ÀÔÉ' ÁÎ×ÅÍ ÙÎÙÉÍ ÒÖÎÅ ØÙÒ ÃÅÎÄ ÌÎ"Ù ÄØ"Ï Æ"Ì ÁÎÂÅ ÃÁÉÃÅ ÀÌÉÍ ÈÔÉ ÅÀÔÉ' ÁÎ×ÅÍ ÇÆ×Ä ÅË"Ë ÁÔË"Á ÎÎËÉØÄ ÁÑÅÔÅ, ÅÌÒÐ"à ÉÙ ÌÄÁÉÀ ×ÖÚ ÑÎÊ ÌÇÉÌÅ× ÄÌÆ ÎÄÀ ÃÀÉ' ÁËÚÅÁÚ ÀÎØ Ø' ÉÄÅÃÀ ÀÎØ ØÁ ÄÀÅÎØ ÙÈØ ÀÎÐÄ ÄÅÀ ÆÄ À"Ð ÅÎÅ×É ÄÙ"Ñ ËÂÅÏ ÃÀÎØ ÎÌÅÄ ÅËÂÅÏ ÙÇÁ ÌÀÇØÉÍ, ÅÄ×ÙÄ ÁÚÅÑ' ÌÄÉÎÏ ÁÎÂÅ ÃÎÇÉÌ ÅÐÀÎØÅ ÙÍ ÄØÁÄ ÚÉØÅÖÉÍ ÅÚÎÄ ÔÐÉ ÉÄÅÙÒ ÎÄ ÁËÊ ÃÀÉÚ ÌÉ' ÎÂÅ Î"Î À"Ð ÌÅÎØ ÙÈØ ÀÎÐÄ ËÉÅÏ ÙÎÙÉÍ ÒÖÎÅ ØÙÒ ÌÒÁÅØ ÒÌ ÌÀÅ ÃÀÌ ÚÙËÅÏ ÁÀÄÌÊ ÒÅÌÄ ÒÉÉÏ ÁËÐ"Ä ÑÉ' Ô" ÅÌÀ ÄÒÌÄ ÀØÅËÄ ÅÌÑÁØÚ ÄØ"Ï ÙÎÇÌ× ÃÎÂÅ ÃÀÉ ÁÒÉ ÒÁÉà ÒÃÉÓ Ì×"Î ÃÉ"Ì ÃÑ"Ì ÌÚÅÑ' ËÉÅÏ ÃÀÉ ÁÒÉ ÒÁÉà ÎÄÐÉ ÀÔÉ' ÁÎ×ÅÍ ÙÎÙÉÍ ÒÖÎÅ ØÙÒ ÀÓ ÃÌÀ ÀÎØÉÐÏ ÎÂÅ ÃÀÉ ÁÒÉ ÈÒÉÏ ÄÂÍ ÙÀÉÏ ÌÅ ÃÎÉÅÏ ËÌ ËÊ ÌÐÉÃÅÏ ÃÄËÀ ÃÄÚÍ ÄÅÀ ÄÈÒÐÄ ÙÈÅÒÏ ÒËÙÉÅ ÎÙÅÅÉ ÒÖÎÅ ØÙÒ ÅÄËÀ ÀÍ ÉÒÙÄ ÁÎÂÅ ÉÄÉ' ØÙÒ, Î"Î ÉÙ ÌÄÁÉÀ ÑÎÅËÉÏ ÌÑÁØÀ ÄÐ"Ì ÙÎÅËÇ ÙÒË"Ô ÎÂÅ ÃÀÉ ÁÒÉ ÒÁÉà ÒÃÉÓ, ÎÎÂÅ ÃÀÉ ÁÒÉ ÈÒÉÏ ËÒÉÏ ÙÎÁÉÀ ÄÙÒØÉ ÄÎÌÊ ØÀÉ' ÎØ"Ï ÙËÚÁ ÙÄÉËÉ ÙÈÒÐÄ ÙÈÅÒÏ ÒËÙÉÅ ÄÅÀ ÐÂÃ ÇÆ×Ä ÐÀÎÏ ÁÎÂÅ ÃÁÉÃÅ ÌÒÙÅÚ Ò"Æ ÎÁÉÀ ÑÎÊ ËÉÅÏ ÃÎÂÅ ÃÁÉÃÅ ÒÃÉÓ É"Ì ÙÎÄÐÉ ÎÂÅ ËÆÅ ÀÓ ÁÒÐÉÏ ÄÉËÉ ÙÀÍ ÉÒÙÄ ËÎÂÅ ÉÄÉ' ØÙÒ ÅÀ"Ë ÙÔÉØ ÉÙ ÌÄÁÉÀ ÑÎÅËÉÏ ÎÚÅÑ' ÄÐ"Ì, ÅÆÄÅ ÔÙÅÈ ÅÌÃÉÐÀ Ö"Ò:ÀÍ ÄÉÀ ÃÁÅ×Ä ÁÒÅÓ. ÎÌ' ÆÄ ÅÂÍ ÎÃÐ×È ÄØ"Á ÒÅÓ ÎÙÎÒ ÃÀÚÀ ÌÀÙÎÅÒÉÐÏ ÃÁÁÄÎÄ ÙÀÉÏ ÃØÊ ÌÄÉÅÚ ÄËÁà ÃÁÅ×Ä ÁÄ ÁÙÒÚ ÎÌÉÇÄ ÔÙÉÈÀ ÃÌÉËÀ Î"à ÃÁÒÉ ×ÌÉÔÄ ÀÁÌ ÐÎÖÀ ÁÚÅËÄ ËÙÀÉÐÄ ÃÁÅ×Ä ÌÀ ÅË"Ë ÁÀÅ"Ä ÙÍ ÁÄÃÉÀ ÅÔÑ×Å ÁÚ"Ç ÙÍ ÑÅÓ ÃÉÏ É' ÃÌÀ ËÃÎÙÎÒ ÁÒÈ"Æ ÃÀÔÉ' ÀÉÐÄ ÃÁÅ×Ä ÁÅ ÁÒÉ ×ÌÉÔÄ ÅÒÉÉÏ ÁÑ"× É"È:

ÑÒÉÓ Â

ÈÒÍ ÙÉÙ ÌÄÚÔÌÌ ÁÒÃ ÒÉÌÅÉ ÄÐÙÎÅÚ ÁÉÎÉ ÐÉÑÏ

(4) ÅÉÒÅÉÉÏ ÁØÙÁ''À [ÌÒÉÌ Á Á], ÙÒÎà ÒÌ ÎÄ ÙÀÉÏ ÄËÐÑÄ ÐÎÐÉÚ ÁËÌÌ ÄÀÁÅÚ, ÀÓ ÙÄÉÚÄ ÁÎÙËÏ.ÅÎÏ ÄÀÎÅØ ÐØÀÄ ÌÉ ÌÔØÙ ÁÄÔÈØÄ (ÉÙÒÉÄ ÐÃ, Ç-É) ÅÁÇÑà ÒÅÌÍ ØÇÎÚÉÊ ÅÂÅ' ËÉ ÎÉ ÐÇ ÆÀÚ ÌÉ ÅÂÅ' ËÉ ÄÄØÉÍ ÉÎÅÙÅ ÅÂÅ', ÌÎÀÉ ÎÃÎÄ ÆÄ ÌÎÉ ÐÇ. ÅÌÃÁØÉÐÅ ÉÚÁÀØ ÅÄËÉ ×ÀÎØ, ÅÁÇÑà ÒÅÌÍ ÃÉÉ×À ØÇÎÚÉÊ, ËÌÅÎØ ÁÎÃÚ ÄÇÑà ÄÁÀ ÎËÇ ÄÒÚÉà ÄÐÖÇÉ, ËÉ ÎÉ ÐÇ ÆÀÚ ÌÉ ÀÙØ ÐÙÁÒÚÉ ÎÒÁØ ÎÉ ÐÇ ÒÅà ÅÂÅ', ÁÙÁÉÌ ÄרÁÐÅÚ ÙÄרÉÁ ÐÇ, ÙÄÅÀ ÒÖÎÅ ÎÄ ÙÐÉÖÅÌ ÄÉÄ ÁÆËÅÚ ÁÐÉÅ, ËÀÎÅØ ÌÒÉÌ, ËÏ ÐÙÁÒÚÉ Î×ÖÅÓ ÒÌÉÊ ÅÂÅ', ÁÙÁÉÌ ÄÒÚÉà ÙÒÚÉÃÉÏ ÉÙØÀÌ ÄÍ ÀÅ ÒÌ ËÌ ÔÐÉÍ ÁÐÉÄÍ ÌÄÈÉÁ ÎÒÙÉÄÍ ÒÚ ËÉ ÚÂÌÄ ÅÚØÀÄ ÎÌËÅÚÅ ÒÌÉÐÅ. ÅÒÌ ÆÄ ÀÎØ, ÀÔÉÌÅ ËÉ ÄÄØÉÍ (ÆËÅÚ ÀÁÅÚ) ÉÎÅÙÅ, ÅÄÂÁÒÅÚ (ÆËÅÚ ÄÀÎÄÅÚ) ÚÎÅÈÉÐÄ, ÅÇÑÃÉ ÎÀÚÊ ÃÉÉ×À, ÄÉÉÐÅ ÄÇÑà ÙÀÐÉ ÎÖØÓ ÆËÅÚ ÄÒÚÉà ÌÁÀ ÎÎÊ ÅÎÁÐÉÊ, ÅÌÀ ÇÅÁ ÄÒÚÉÃ, ÌÀ ÉÎÅÙ (ËÎÁÅÀØ ÁÔØÙÚ ÃØËÉÍ ÙÍ ÙÆÄ ÎÇÑÃÅ ÉÚÁØÊ ÌÔÐÉÍ ÎÙÅØÚ ÄÃÉÏ ÌÄÑÚËÌ ÁÈÅÁ ÌÖØÔÅ ÅÌÀ ÁØÒ, ÒÉ"Ù). ÅÁØÉÚ ÙÌÅÎÉ ÌÀ ÚÎÅÈ, ËÉ ÙÌÅÍ ÁÉÏ ÀÉÙ ÌØÒÄÅ ÁÀ Ø× ÒÌ ÙÍ ÄÒÚÉÃ, ÙÒÚÉÃÉÏ ÌÀÄÅÁ ÆÄ ÀÚ ÆÄ ÅÌÄÈÉÁ ÆÄ ÒÍ ÆÄ, ËÎÅ ÙÔÉØÙÚÉ (ÔØ' ÅÀØÀ ÑÅÓ ÃÁÅØ ØÀÙÅÏ) ÄÀ ÃËÚÉÁ (ÙÍ ÑÅ, ÉÁ) ÄÐÐÉ ÐÅÈÄ ÀÌÉÄ ËÐÄØ ÙÌÅÍ, ÅÄÅÀ ÒÌ ÔÉ ÄÂÎØÀ ÔØ× ×ÎÀ ÃËÚÅÁÅÚ (É Ò"Á) ÀÌÎÐÄ ÃËÚÉÁÀ ÁÀÅØÉÉÚÀ ÒÌ ÙÍ ÃÒÚÉÃÉÏ ØÁÐÏ ÃÎÚ×ÐÉ ÌÄ ÎÐÄ, ÅÎÉ ËÚÁ רÀ ÌÒÚÉÃ, ÀÉÏ, ÃËÚÉÁ (ÁØÀÙÉÚ Á, ÉÃ) ÅÙÍ ÄÐÄØ ÄÙÌÉÙÉ ÇÃ×Ì ÄÅÀ ÄÄÅÌÊ ×ÃÎÚ ÀÙÅØ, ÅÎÉ ÄÅÄ, ÀÌÀ ÃÒÚÉà ËÅ'. ÅÆÄÅ ÙÀÎØ ÄÐÐÉ ÐÅÈÄ ÀÌÉÄ ËÐÄØ, ÙÐËÚÁ Î×ÅÎÅ ÒÌ ÙÍ ÄÒÚÉÃ, ËÎÅ ËÏ ÙÌÅÍ, ÒÌ ÙÍ ÄÒÚÉà ÙÚÈÉÁ ÎÒÙÉÊ. ÒÌ ËÏ ÀÎØ ÎØÇÎÊ (ÃÉÉ×À) Ä', ÁÆËÅÚÊ ÅÆËÅÚ ÖÀÖÀÉ ÎÒÉÊ:ÀÚ ÄËÚÐÅÚ. ÁÌÙÅÏ ØÁÉÍ ÄÉÉÐÅ ÌÀÄØÏ ÅÌÁÐÉÅ. ÅÀÒä ÙÌÀ ÐÚÔØÙ ÁËÚÐÅÚ ÄÁÐÉÍ ÎÎÄ ÉÄÉÅ ÎäÎ ËÊ ÐÖÈÅÄ ÒäÔ Äã. ÅËÏ ÎÒÙÄ ÀÅØÂ:Â) ÒÉ' ÒÅÌÚ ÙÁÚ (Ñ"× À') ð "ÅËÚÁ ÄÁ"Ç ÐÄÂÅ ÌÄ×Ì ÀÍ ØÅËÁ ÒÌ ÑÅÑ ÀÅ ÄÅÌÊ ÁÒÂÌÄ ÅÄÐÇ ÌÉÙØÀÌ ÎÅÈÁ ÅËÅ'".

ØÉÁÁ"Ï ñ ÁØËÅÚ

ÃÓ ÖÄ:

ÑÔØÀ ÃÖÐÉÒÅÚÀ ÒÍ ÁÉÀÅØ ØÁÐÅ ÄÂØ"À ÆÌÌÄ"Ä

ÑÎ" ÒÙÉÏ ÑÉÎÏ ×Ì"Ã

6. ÃØËÉ ÈÄØÄ (ÒÎ' Ø"À) ð "ÎÉ Ù×ÙÄ ÌÀÙÚÅ ÌÄÎÚÉÏ ÒÃ ÀÇØÉ ÇÖÅÚ ÌÉÌÄ, ÅËÙÎÒÉØÄ ÀÉÏ ÄÉÀ ÎÚØÖÉÚ Ë"Ë ÁÂÌÌ ÒÉÉÔÅÚ ÅËÃ', ÀÉÏ ÌÅ ÌÄÚÒËÁ ÒÃ ÀÇØÉ ÇÖÅÚ ÀÅ ÌÁÈÌ ÎÖÅÚ ÒÅÐÄ ÎÙÅÍ ËÊ, ÀÌÀ ÉÁÅÀ ÒÌÉÄ ÌÔÐÉ ÇÖÅÚ, ÅÌÀ ÉÚÇÑÃ ÅÉÒÉØÐÄ ÅÉÂØÅÍ ÖÒØ ÅÒÂÎÚ ÐÔÙ ÌÀÙÚÅ".

×ÄÌÚ ÉÒ×Á - Á

ÅÔØÉÊ: ÅÄÀ ÇÐÅËÄ ÃÌÀÅ ÄËÉ ÄÅÀ, ÙÀÉÐÅ ÇÌÅ× ÁרÁÐÅÚÉÅ, ÅÌÀÅ ÄËÉ ÄÅÀ, ÙÀÉÐÅ Î×ÅÃÙ ÁÒÙÉÉÚ ÎÌÀËÄ, Å×ÀÎØÉÐÏ ÁÅ ÄÌÌ.(Â) ÀÌÉÄ ØÁÄ ÅÚÅÑÔÅÚ ÙÁÚ ÃÌÀ ËÎÂÏ ÀÁØÄÍËÌ ÀÙØ ÌÁÏ ÁÅ. ÙÀÓ ÒÌ ÂÁ ÙÌÀ ÄÉÄ ÉÒ×Á ÐÅÈÌÍ ÁÌäÆ. ÎäÎ ÇÙÙ ÌÁÏ ÙÌÀ ÉÂØÅÍ ÎÒÈ ÄÌÁÐÅÐÉÚ ÙÉÅÌÉÃÅ ÒÉäÆ Ð×ÅÃÉÍ ÅÈÌÅÀÉÍ ÒäË ÄÑÉØ ÂÍ ÀÚ ÀÌÄ: Š˨ÚŬÁ ˬ§Ã ħ׬¦Î§Ç Ì©À Ë¨Ì¨Ú¨Ä Å Ö§Ô¬§Ç§Ú ħ٬±¦Î¦Ï Ì©À Ç¨Ñ¥Ø Ë¬¤Ã Á§Ø Ä' À¢Ù±¦Ø ì¤Á¬¦Ø Á¬ É§Ã À¥Ì¤É¬¨ÄŬ. Å Ë¤É À¤Í ÀÅ©ÚÅ© ×¦Î§Ç Ù±¦ÒũΥà Á¬ Î¤Ã¬¨Ä, Ù±¦Ä¨É¨Ä Π̩À Ë§Ó ×¦Î§Ç, Ì©À ԨѠ×Ŭ Τά¦Ð¬Å¬ Á¬ Ø¨ËÅ©Ú Î¤Ù¬±Å¬Í ì Á§Ø À¥Ì¤É¬¨ÄŬ, Ù±¦Ë¬¨ÚŬÁ ˬ§Ã ħ׬¦Î§Ç Ì©À ڤˠ̨Ä, Š˨ÚŬÁ ˬ§Ã ħ׬¦Î§Ç Ì©À Ë¨Ì¨Ú¨Ä - Τٱ Ë¬§Ï ĨҥÃŬÚ, À§Ó Ò§Ì Â¬§Á Ù±¦ÒũΥà Á¬ Ç¦Ù± Á¬Å©Ï, ÄÅ©À¤ÉÌ Å Ð¤Ô ×§Ã Ò§Ì É Ã¥É Î©Ù±¦Ä, ˬ¨Ì Ù±¦Ë¬¥Ï Å Ë¨Ì Ù±¦Ë¬¥Ï Ù±¦Ù¬±Å©Ø¤ÉÍ Á¬Å© Á¬ Ø¨ËÅ©Ú. Å Ò§Ì Æ¦Ä Ë¬¨ÚŬÁ, À¥Ì¬¦Ä Ô ×Å¬Ã¥É Ä§Î¬¤Ù± Ë¬¨Ï Τٱ Ë¬§Ï Ä¨Ò¥Ã«Ú À¢Ù±¦Ø Ô¬«×¬§Ã Ò§Ì Ô¬¤É Ωٱ¦Ä. À¥Ì¬¦Ä Ô ×Å¬Ã¥É Ä§Î¬¤Ù± Ë¬¨Ï. اÁ¬¤É ǤƠפɬ¨Ä Ô¬¨Ú§Ç Å À¨Î§Ø, (ÙÎÅÚ Â) À§Ì Ú¬¤× Ø§Á Ä¢Ì©Í Ù±§Ì РҨ̦ÉÊ  Î¥Ò§Ì Ø§Â Ì¦ÉÊ  Å ÂÅ©'. Ô¬¨ÑÅ¬× Æ¦Ä Ô¬¥Ø Ù±Å¬ÄŬ, Ù±¦Ä¤Ô Ø¤ÉÃÅ© ħ׬¨Ãũٱ Á¬¨ØÅ¬Ê  ÄŬÀ Î¥À¤Ù± Ú¬Å© ˬ Ã¥É ̠Ĥì¨Á¥× Á¬§Ù¬± Ë¤ÉШÄ, Ù±¦Ë¬¨ÚŬÁ ˬ¤É ħά¨×Å©Í À¢Ù±¦Ø À§Ú¬¨Ä ÒũΥà Ҩ̨ÉÅ À§Ã Î§Ú שæٱ ÄŬÀ. À§Ã Î§Ú שæٱ - ÆÅ© Ù± Ë¤ÉШÄ. Ĥì¨Á ×Å¬Ú × Ãũٱ¨Ä ФàÁ¬§× Ωٱ¦Ä Á¬ ÀũڨĬ Ù±¨Ò¨Ä ̠ΧҠ̨Ä.öËÙÌ

ÃÓ ÑÄ/Á

ÀÁÌ ÀÍ ÀÎØ ÄÁÒÌ ÀÉÐÉ ÆÐÊ Òà ÎÚÐÀÉ ÄËÚÅÁÄ. ÔØ× ÄÎÃÉØ (ÃÓ Ò') ÅÔØ× ÎÖÉÀÚ ÄÀÙÄ ÅÔ"× ÃÂÉÈÉÏ (ÃÓ É"Á) :

ÎÙÐÄ Å

ÀÎØÅ ÌÅ ÎÚ ÀÁÉÅ Å×ØÒ ÎÚ ÁÐÅ ÅÄÅÑÉÓ ÚÇÚÅÏ ÎÚÀÇÄ ÒÌÉÅÏ ÀÉÐÅ ÎÚÀÇÄ. ÅÄ×ÅØÒ ÎÚÅÊ ÄÙÌÌ ÎÚÅÊ ÄÎÌÌ ÎÚÅÊ ÄÌ×È ÎÚÅÊ ÄÑÅÌÎÅÚ ÌÀ ÉÖÀ ÎÚÅÊ ÄÀÉÇÅÉ ÉÖÀ, ÅÁÀÉÇÅÉ ÀÌËÑÐÃØÉ. ÎÚ ÀÁÉÅ ÎÚ ÀÎÅ ÎÚ ÀÇÉÅ ÎÚ ÀÇÅÚÅ ×ÅØÒ ×ØÒ ÀÇà ÌËÅÌÏ ØÁÉ ÉÄÅÃÄ ÁÏ ÁÚÉØÄ ÀÅÎØ ÒÌ ËÅÌÏ ×ØÒ ÀÇà ÅÒÌ ÀÁÉÅ ÅÀÎÅ ×ØÒ ÀÇÃ, ÀÎØ ÙÎÅÀÌ ÄÌËÄ [ËØÁÉ ÉÄÅÃÄ ÁÏ ÁÚÉØÄ ÅÎÉ ÀÎØ ÙÎÅÀÌ ÄËÉ ÅÄÀÎØ ÙÎÅÀÌ ÄÌËÄ] ËÃÁØÉ ÄÎ×ÉÌ ÁÀÁÌ ÀÁÉÌÅÚ ÌÇÅà ÅרÉÒÄ ÌÇÅÃ. ÅÀÍ ÐÚÎÌÀ רÉÒÄ ÁÎ×ÅÍ ÀÇÃ ÎØÇÉ× ÙÌÙ ÀÖÁÒÅÚ Å×ÅØÒ. ÅÄ×ÅØÒ ÎÌÎÈÄ [Å]ÎÏ ÄÖÃÃÉÏ ÌÀ ÉÖÀ. ÄÀÅÎØ ÌÇÁÉØÅ ÄÙÀÉÌÐÉ ÇÌÅ×Ê ÅÀÉÌÊ ÅÀÁר ÁÅ ÀÚ ÀÁÀ ÙÄÅÀ ÇÅÌÄ ÅÄÌÊ ÅÎÖÀÅ ÙÎÚ ×ÅØÒÅ ÅÎÀÇÅ ÅÎÇÆÉØ ÌÅ ÇÌÅ×Å ÅÐÅÚÏ ÌÅ ÃÎÉ Ä×ØÒ ÅÀÍ ÌÀ ÄÅÃÉÒÅ ÄØÉ ÆÄ ÌÀ ÉÂÒ ÁÅ. ÅÄÉÅÖÀ ÁÁÂÃ ×ØÅÒ ÌÔÐÉ ÄÎÚ ÄØÉ ÆÄ ÂÅÆÌ ÀÚ ÄÇÉÉÍ ÅÀÚ ÄÎÚÉÍ. ÀÎØÅ ÌÅ ÎÚ ÀÁÉÅ Å×ØÒ ÅÐÎÖÀ ÙÄÅÀ ÁÐÅ ÀÅ ÀÉÔËÀ ÀÍ ÁÚÅÊ ËÃÉ ÃÉÁÅØ ÐÎÖÀ ÉÖÀ ÉÃÉ ×ØÉÒÄ ÅÀÍ ÌÀÅ ÌÀ ÉÖÀ ÅËÏ ÀÍ ÐÚÒÌÓ Å×ØÒ ÅÎÚ ÁÚÅÊ ËÃÉ ÃÉÁÅØ ÉÖÀ. ÚÐÅ ØÁÐÏ ÇÅÌÄ ÙÎÚ ÌÅ ÎÚ ÀÉÏ ÎÅÃÉÒÉÏ ÀÅÚÅ ÙÎÀ ÚÈØÅÓ ÃÒÚÅ ÒÌÉÅ ÅÀÉÏ ÎרÒÉÏ ÅÎÙÚÉ×ÉÏ ÀÚ ÄÐÙÉÍ Î(Ì)ÔÐÉÅ. ÅÀÉÏ ÌÁØØ ÎÉËÏ ÙÀÍ ÄÅÀ ÁØÉÀ ÙÚÄÀ ÎÖÅÄ ÌÄÅÃÉÒÅ ÃÃÉÌÎÀ ØÙÅÚ ÁÉÃÅ ÌÄÅÃÉÒÅ. ÅÎרÒÉÏ Ì×ÈÏ ÎÔÐÉ ÒÂÎÚ ÐÔÙ. Å×ÅØÒ ÒÌ ÇÎÉÅ ÅÒÌ ÇÎÅÚÅ ÎÔÐÉ ËÁÅà ÀÙÚÅ. ÅÐØÀÄ ÌÉ ÃÄÐÉ ÎÉÌÉ ÁÔÐÉÄ ËÃÀÎØÉÐÏ ÌÒÉÌ [Ë' Ò"Á] ÁÀÔÄ ÐÄÅ ÀÁÉÌÅÚ. ÚÐÀ ÁÀÁÌ ØÁÚÉ [ÀÁÌ] ÌÀ ÉÐÉÇ ÚÉÐÅ× ÁÇÉ×Å ÙÎÁÉÀÅ ÌÉÃÉ ÙÇÅ× ÅÐÎÖÀ ÎÚÂÐÄ ÒÌ ÄÁØÉÅÚ.ÁÀ"à ÅÉ"Ì ÅËÅ' À"Ë ÁÎÀÉ ÀÚÀ ÌÀÔÌÅÂÉ ÀØÁ ÑÔØÀ ÅËÅ'. ÌÅÌÉ ÃÁØÉ ÚÅÑ' ÄÉÄ ÀÔ"Ì ÃÌØÁ ÑÔØÀ ÄÁÐÉÍ ÄÍ ÒÖÎÏ ÑÉÎÐÉÍ [ÅËÎ"Ù ÄÂØ"Ç], ÅÀÉÌÅ ÌØÁ ÆÁÉà ÄÅÄ Ø× ÑÉÎÏ ÃÉÙ ÙÒØÅÚ, ÅÌÒÅÌÍ ÄÄÉÌËÚÀ ÄÅÄ Ø× ÙÒØÅÚ [ÅËÑÁØÚ ÄÎÄØÉ"È]. ÅÎÁÅÀØ ÃÚÅÑ' ÌÀ ÇÌ×Å ÁÆÄ.ÒÁØÄ ÅÈÁÌÄ ÁÉÅÍ - ÙÌÀ ÎÇÎÚ ÀÅÐÑ - ÉÙ ÑÅÁØÉÍ ÙÁÉÅÍ ÄÙÁÉÒÉ ÌÑÔÉØÚÄ ÌÀ ÒÌÚÄ ÌÄ ÈÁÉÌÄ (ÙÀÉÌÚÅÚ ÃØÁ ÀÇÀÉ ÖÅ; ÚÅØÚ ÄÁÉÚ Ä×ÖØ Æ Æ ÙÍ, ÁÙÍ ÉÙ ÎÂÃÅÌÉ ÄÎÅØÉÍ, ÅÄÅÁÀ ÁÈÅØ ÉÅ"à ×ÖÆ; ÎÄØÉ"Ì ÄÌËÅÚ ÈÁÉÌÄ, ÄÅÁÀ ÁÁ"Ç ÙÍ, ÅÄÑËÉÍ ËÏ9733), ÙÀÍ ÐËÙÉØ ÀÚ ÄÈÁÉÌÄ, ÉÙ ÌÇÙÅÙ ÙÚÙÎÙ ÁÅ ÁÉÅÍ, ÅÌËÏ ÄÖØÉËÅÄ ÌÇÆÅØ ÅÌÈÁÅÌ ÁÌÉÌÄ (ÇÉÃÅÙÉ ÄØ"Ï ÐÃÄ ÑÆ Á, ÁÙÍ ÄØÀÁ"Ã), ÀÁÌ ÁÙÎÉÐÉ ÙÀÉÏ ÄÀÉÑÅØ ÌÈÁÅÌ ÀÌÀ ÎÔÐÉ "ÑØÊ ÁÚÄ" (ØÀÄ ÌÒÉÌ), ÒÌÚÄ ÌÄ ÄÈÁÉÌÄ ÁÃÉÒÁà (ÚÅØÚ ÄÁÉÚ ÄÀØÅÊ ÙÍ, ÀÓ ÌÙÀÉÌÚÅÚ; ÇÉÃÅÙÉ ÄØ"Ï ÙÍ ÁÙÍ ÄØÀÁ"Ã; ÈÅÙ"Ò ÙÍ ×ÖÆ Ä), ÙÄØÉ ÁÎ×ÅÍ ÀÅÐÑ ÖÉÐÄ ÅËÉÅÖÀ ÄÚÉØÅ ÌËÚÇÉÌÄ (ØÀÄ ÌÒÉÌ), ÅÄÅÀ ÄÃÉÏ - ÙÌÀ ÁÎ×ÅÍ ÀÅÐÑ - ÁÃÉÒÁà (ÚÅØÚ ÄÁÉÚ ÄÀØÅÊ ÙÍ). ÅÉÙ ÑÅÁØÉÍ ÙÀÓ ÀÍ ÒÁØÄ ÅÈÁÌÄ ÁÙÁÉÒÉ, ÒÌÚÄ ÌÄ ÈÁÉÌÄ (ÄÀÙËÅÌ ÎÄ; ØÎÁ"Í ÀÉÑÅØÉ ÁÉÀÄ ÉÀ ÉÆ; ÚÅØÚ ÄÁÉÚ ÄÀØÅÊ ÅÄ×ÖØ ÙÍ, ÅÄÅÁÀ ÁÈÅØ ÙÍ; ÙÅ"Ò ÙÍ), ÙÒÉר ÂÆÉØÄ ÆÅ ÃÁØ ØÇÅ× ÄÅÀ, ÅÌËÏ ÀÉÏ ÌÄÇÎÉØ ÁÃÉÒÁà (ÚÅØÚ ÄÁÉÚ ÄÀØÅÊ ÙÍ).(Å) ÀÁÌ ÒÉØÅÁÉ ÚÇÅÎÉÏ ÀÉÏ ÎÐÉÇÉÏ ÅËÅ' - Ã×ÐÉÏ ÙÁÉÚÄ ÄÅÀ Ë×ÐÉÏ ÁÉÚ ÅÁÉÚ ÌÀ ×ÐÉÐÏ ÁÉÅÍ ÈÅÁ ÀÔÉÌÅ ÁÚÐÀÉ ÅËÚÁ ÁÀ"Ø ÃÄÉÉÐÅ ÃÅ×À ÌËÚÇÌÄ ÀÁÌ ÁÃÉÒÁà ËÙËÁØ ÒÉØÁ ÎÄÐÉ ÁÙÐÉ ÉÅ"È ÙÌ ÂÌÉÅÚ ÅÄÁÉÀÅ ÄÔÎ" ÂÍ ËÏ ÌÒÉÌ ÁÑÉÎÏ ÚÈ"Æ ÅÒ"Ù ÁÁÄ"Ì Ã"Ä ÎÔÐÉ:ÁÒ"Ä

[×ÖÃ] ÔÈÅØ ÁÀÉÐÅ ÉÙÏ ÁÌÉÌÄ

ÔÑ×É ÚÅÑÔÅÚ ÒÌ ÎÙÐÄ ÎÃÅÚ

ÅÁÆÄ ÐØÀÄ ÌÉÉÙÁ ÎÄ ÙÚÎÄ ÄØÙÁ"À ÅÄÐ"É ÒÌ ÄØÉ"Ó ÙÔÑ× ÁÀÁÒÉ' ÃÒà ÀÇà ÁÎÌÇÎÄ ÐÀÎÏ ÅÁÀÁÒÉ' Òà ÀÇà ÁÎ×ÅÍ ×ÈÈÀ ËÚÁ ÄØÉ"Ó ÃÄÅÉ ÀÁÒÉ' ÃÌÀ ÀÔÙÉÈÀ. ÃÀÆÌÉÐÏ ÌÇÅÎØÀ ÅÌÀ ÎÄÉÎÏ. ÅÚÎÄÅ ÒÌÉÅ ÃÄÀ ÄÅÉ ËÅÌÄÅ ÇÃÀ ÈÒÎÀ ÃÀÁÒÉ' ÌÄÅ ÎÙÅÍ ÀÉÄÉ ÌÀ ÃÉÉ×À ÅÀ"Ë ÌÀ ÎÄÉÎÏ ÅÀÉ ÎÙÅÍ ÃÒÁÉÃÉ ÌÂÌÅÉÉ ÎÄÉÎÏ. ÅËÉÅÏ ÃËÚÁ ÄØÉ"Ó ÃÀÉÁÒÉ' ÃÒà ÀÇà ÁÎÌÇÎÄ ÀÔÙÈÀ ÃÎÄÉÎÏ ÎÄÄÅÀ ÂÁØÀ ÃÈÁÒ ÁÃÉÂÌÅÚ, ÅÀ"Ë ËÉÅÏ ÃÒà ÀÇà ÐÀÎÏ ÁÎÌÇÎÄ ÅÒ"Ë ÎÙÅÍ ÃÄÅÉ ÎÌÚÀ ÃÒÁÉÃÉ ÌÂÌÅÉÉ ÃÌÀ ÎÙרÀ À"Ë Ä"Ä Òà ÀÇà Á×ÈÈÄ ÎÄÉÎÏ ÒÉ"Ù. ÅÌÔÎ"Ù ÀÔÙØ ÌÅÎØ ÃÄØÉ"Ó ÂØÑ ÁÀÁÒÉ' ÃÒà ÀÇà ÁÎÌÇÎÄ ÀÅ ÃÌÎÀ ÈÒÎÀ ÃÒà ÀÇà ÃÎÄÉÎÏ ÎÙÅÍ ÃÀÉÄÉ ÃÉÉ×À ÅÎÐÑÁÀ. ÅÄÉÀ ÆÉÎÐÉÏ ÃÑÐÉÀ ÌÉ' ÌÀ ÃÉÉ×À ÅÎÐÑÁÀ. ÅËÏ ÄÅÀ ÄÂØÑÀ ÁØÉ"Ó ÂÍ ÄØÙÁ"À ÁÇÉÃÅÙÉÅ ËÚÁ ÃËÊ ÄÅÀ ÂØÑÚ ËÌ ÄÑÔØÉÍ. ÅÄÅÀ ÚÉÎÀ ÃÀÉ ÇÉÉÙ ÌÙÐÀÄ À"Ë ËÎÅ ÃÀÎØÉÐÏ ÄÀÙÄ ÙÀÎØÄ ÎÚ ÉÁÎÉ ÙÀÐÙÀ ÀÉÐÄ ÐÀÎÐÚ ÎÙÅÍ ÆÉÎÐÉÏ ÃÑÐÉ' ÅÌÀ ÚÉÃÅ× À"Ë ÂÍ ÁÀÅÎØÚ ÎÚ ÁÒÌÉ ÀÎÀÉ ÐÀÎÐÚ ÌÉÎÀ ÃÌÀ ÚÐÙÀ ÎÄÀÉ ÈÒÎÀ ÎÙÅÍ ÆÉÎÐÉÏ ÃÑÐÉÀ ÌÉ' ÅÌÀ ÚÉÃÅ×. ÅÒÅà Òà ÀÇà ÁÒÌÎÀ ÃÎÄÉÎÏ ÎÙÅÍ ÃÀÉÄÉ ÃÉÉ×À ÅÎÐÑÁÀ. ÐÉÇÅÙ ÃÌÎÀ ÑÐÉÀ ÌÉ' ÅÌÀ ÚÉÃÅ×. ÅÒ"Ë ÌÂØÑÚ ÄÑÔØÉÍ ÄÅÀ ËÎ"Ù ÄØÙÁ"À ÙÍ ÃÙÀÐÉ ÄËÀ ÃÄËÉ ×ÀÎØ ÃÌÎÀ ÑÐÉÀ ÌÉ' ×ÖÚ ÅÑÎËÄ ÄËÀ ÁÎÌÇÎÄ ÁÃÃÎÉ. ÀÁÌ ÁÒÌÎÀ ÃÌÉËÀ ÌÎÑÎÊ ËÌÌ ÌÅÎØ ÁÃÃÎÉ ÌÀ ÇÉÉÙÉÐÏ ÁÁÒÌ ÃÌÎÀ ÑÐÉ' ÌÉ' ËÅÌÉ ÄÀÉ ÅÌÀ ÚÉÃÅ× ÒÉ"Ù:

ØÙ"É

ÅË' ÄÀÁÅÃØÄÍ (Ô"É, ËÈ) 'ËÉ ÀÚÄ ÙÅÎÒ ÚÔÉÌÚ ËÌ ÔÄ', ÒÌ ÙÍ 'ÙÅÎÒ ÚÔÉÌÄ ÒÃÉÊ ËÌ ÁÙØ ÉÁÅÀÅ'. ÅÉÙ ÀÅÎØÉÍ ËÉ ÔÄ ÁÂÉÎÈØÉÀ ÎÉÌÄ, ËÌÅÎØ ÉÙØÀÌ ÙÄÍ ÎÄÅÌÉÍ, ÅÇÅÚÍ ÁÀ"É ÙÅÎÒ ÚÔÉÌÄ. ÅÆÄ ÙËÚÅÁ ÎËÅÚ (Ë" À') ÁÀ ÇÁ×Å× ËÅ'. ËÎÅ ÙËÚÅÁ ÌÄÂÉà ÅÂÅ' ÅÀÎÅÐÚÊ ÁÌÉÌÅÚ ËÉ ÁÁÅר ËÙÉÖÀ ÀÃÍ ÌÔÒÌÅ ÄÒÉר ÄÍ ÄÎÃÅÚ ÀÄÁÄ ÅÉØÀÄ ËÎÅ ÙËÚÅÁ ÁÚÉ×ÅÐÉÍ (ÚÉ' É') Ô×ÅÃÀ ÃÌÀ ÀÉÄÅ ÁÃÇÉÌÅ ÅØÇÉÎÅ ÅËÅ'. ÅÆÄÅ ÒÌ ÉÃÉ ÆËÉØÚ ÇÑÃÊ ËÎÅ ÙËÚÁ ÄØÎÁ"Í ØÔ"Á ÎÉÑÅÃÉ ÄÚÅØÄ ËÉÖà ÄÃØÊ ÌÀÄÁÄ ÅÉØÀÄ ËÅ' Ò"Ù. ÅÀÄÁÄ ÅÉØÀÄ ÄÍ ÄÎÒÅØØÉÍ ÄÔÒÅÌÅÚ ÀÁÌ ÁÒÚ ÄÙËÉÁÄ ÅÂØÅÉ ÄÙÉÐÄ ÙÖØÉÊ ÂÍ ËÏ ÌÉÃÒ ÌÔÐÉ ÎÉ ÄÅÀ ÙÅËÁ ÄÒÉר ÄÀÎÅÐÄ. ÙËÌ ÎÄ ÙØÅÀÄ ÙÎÉÍ ÅÀØÕ ÅËÌ ÀÙØ ÁÍ ÄËÌ ÌÄÙÍ ÉÚÁØÊ ÅÄÅÀ ÄÎÐÄÉ ÅÄÎÙÂÉÇ ÅÁÁÈÅÌ ËÌ ÃÁØ ÌÎ×ÅØÏ ÙÄÅÀ ÒÌ ÉÃÉ ÀÎÅÐÄ ÅÄ×ÉÅÅÉ ÌÉÙÅÒÄ ÙÒÌ ÉÃÉ ÆÄ ÄÉÀ ÙÁÉÚÚ ÄÔÒÅÌÅÚ ËÅÌÏ. ÅÆÄÅ ÁÌÉÌÅÚ ÁÒÅÌÍ ÄÆÄ ÁÂÌÅÚ ÅÌËÊ ÇÁ×Å× ÙÄÉÄ ØÅÀÄ ÅÎÚÀÅÐÏ ÒÌ ÀØÉËÚ ÅÚÅ×Ó ÄÂÌÅÚ ÄÅÀ ÙÄÒÎÉÃÏ ÒÌ ÀÇÚ ÅÄÅÀ ÀÎÅÐÄ. ÅÀÎØÅ ÀÖÌ ÄÇÑà ÁÁÅר ÅÌÀ ÁÉÅÍ ÃÅÂÎÚ ÁÌÉÌÅÚ. ÌÎÒÙÄ ÃÉ ÀÚÒØÅÚÀ ÃÌÚÚÀ ÁÀÄÁÄ ÅÉØÀÄ Ø× ÁÚÇÌÚ ÄÎÒÙÄ ÅÀÇØ ËÊ ÄÎÒÙÄ ËÅÌÄ ÎÎÙËÚ Ä×ÃÅÙÄ ÒÌÉÅ ËÎÅ ÙËÚÅÁ ÁÉÅÎÀ (Ì"È Á') ÃÎ×ÃÙÉÏ ÀÅÚÅ ÎÌÎÒÌÄ. ÅÄÉÉÐÅ ÒÌ ÉÃÉ ÎÒÙÄ ÄÎÖÅÄ ËÎÅ ÙÀÅÎØÉÍ ÀÙØ ×ÃÙÐÅ ÁÎÖÅÚÉÅ [ÅËÏ ÄÃÉÏ ÌÒÐÉÏ ÌÙÎÄ ÃÂÉÈÉÏ ÅÑÔØ ÚÅØÄ ÅÎÆÅÆÄ ÃÃÉ ÁÚÇÌÚ ÄËÚÉÁÄ ÅÀÇØ ËÊ ÑÚÎÉÄ ÌÙÎÄ ×ÀÉ ËÎÅ ÙËÚÅÁ ÁÚÙÅÁÄ ÁÑ"Ã] ÎÄ ÙÀÉÏ ËÏ ÁÄÒÃØ ×ÃÅÙÚ ÄÎÒÙÄ ËÅÌÄ ÌÉÌÄ ÆÎÏ ÌÄÎÙËÚ ÀÎÅÐÚ ÄÌÁ. [ÅÁÆÄ ÎÚÉÉÙÁ ÈÒÍ ×ØÉÀÚ ÙÎÒ ÙÌ ÙÇØÉÚ ÃØÙÉÐÏ Á×ÅÎÊ ÚÇÌÚ ×ÉÎÄ ÅÙÌ ÒØÁÉÚ ÆÎÐÄ ËÌ ÄÌÉÌÄ ÃÃØÙÉÐÏ ÁÙËÁÊ ËÌ ÆÎÏ ÙÙÅËÁÉÍ ÅÌÀ ÁÚÇÌÚ ÄÌÉÌÄ ÅÃÅ"×]:ì Ú§Ð¬¨À קά¨À ѨÁ§Ø ̧Ĭ ˬ Ø§Á¬¨Ð§Ï, ì À¨Î Ø¤É: À¥ÉÏ À¨Ã¨Í Î§× Ð¦Ä Ã¬¨Á¨Ø Ù±¦Ì¬©À Á¬¨À ̨Òų̃Í; ŠاÁ¬¤É À¦Ì Ò¨Æ¨Ø Á¬ Ø§Á¬¤É Ù±¤Î ÒÅ©Ï Ñ¨Á§Ø ˬ Ø§Á¬¤É Î¥À¤ÉØ, ì À¨Î§Ø: À¨Ã¨Í Î§× Ð¦Ä Ã¬¨Á¨Ø Ù±¦Ì¬©À Á¬¨À ̨Òų̃Í.ÀÚÀÏ ÌÐ"à ÃÁÙÈØ ËÚÅÁ ÎÒËÙÉÅ ÅÙÀ×"Î ÅÀÉËÀ ×ÐÉÏ ËÔÉ"à ÄÀÇ' Æ"Ì ÃÁÚØÉÄ ÃÎØÏ ÂØÉØÏ ÂÍ ÁÚÙÅ' À"Ë ÎÙÒÚ Ä×ÐÉÏ ÅËÚÉÁÚ ÄÙÈØ ×ÐÄ ÄÂÅÓ ×"Â. ÅÀÔÉ' ÄØÎ"Ñ Æ"Ì ÃÔ×Ô× ÌÃÒÚ ÄÑÅÁØÉÍ ÁÌ' ÄØÎÁ"Í ÃÁÎÚÐÚ ÁØÉÀ Ä"Ä ËÎÙ"Î ÃÌ"× ÂÅÔÀ ÎÄÉÅÍ Ë"À ÌÀÇ"Î ÅËÅ' Ä"à ÁÎÚÐÄ ÌÀÇØ ÅËÏ ÄÅÀ ÁÎÒËÙÉÅ ÅÙÀ×"Î ÄÅÉ ÄËÉ. ÁØÍ ÁËÅÚÁ ÌÁÐÅ ÅÃÀÉ ×ÐÉ ÄÂÅÓ ÎÄÉÅÍ ÅÔÉØÉ ÌÀÇ"Î ÅËÏ ÄÅÀ ÁÎÒËÙÉÅ ÅÙÀ×"Î ÅËÎÅ ÙËÏ ÎÁÅÀØ ÙÍ ÁÃÁØÉÅ ÅÄÈ' ÃÃÒÚÅ Ù"À רÅÁÄ ÀÖÌ ÁÐÅ ËÎÅ ÙË"Ë ÎÅÄØÉÈ"Õ ÅÄÎ"Î Æ"Ì ÁÔÉ' ÉÒÅ"Ò. ÅÀ"Ë ÁÐ"à ÃËÚÁ ÌÁÚÅ ÄÅÉ ËÎÅ ÙËÅÚÁ ÌÁÐÅ Ã×ÐÉ ÄÂÅÓ ×" ÎÒËÙÉÅ ÅÔÉØÉ ÙÀ×"Î ÃËÎÅ ÙÃÒÚÅ Ù"À רÅÁÄ ÀÖÌ ÁÐÅ ËÏ Ä"Ä ×ØÅÁÄ ÀÖÌ ÁÚÅ ËÎ"Ù ÄÎÁÉ"È Æ"Ì Ç"À ÑÉ×Ñ"Á ÎËÇ ÑÅÂÉÉÚ ÄÂÎ' ÀÍ ÚÌà ÀÙÚÉ ÆËØ ÅËÅ' Ò"Ù. ÅÁÑ' Ô"Î Ç"À ÉÙ ØÁÅÚÀ ÉÅÚØ ÃÙÍ ÁÑÉ"Ö ÁÚÙÅ' ÄØÉÄ"× Æ"Ì ÄÁÉÀ ÁÙÍ ÄÎÁÉ"È Æ"Ì Ç"À ÑÉÙÌ"È ÃÃÅ×À ÁÀÁ ÀÎØÅ ÙÃÒÚŠרÅÁÄ ÅËÅ' ÀÁÌ ÁÀÍ ÌÀ ÀÎØÉ' ËÏ ÅÙÂÍ ÎÅÄØÙ"Ê Ç" ÑÉÖ"à ÉÙ ÌÑÔ× ÁÃÁØÉÅ ÅÄÔ"Î ÁÑÉÖ"À ËÚÁ ÃÑ' ÄÎÁÉ"È ÄÉÀ ÃÇÅÉÄ ÎËÌ ÄÔÅÑ' ÅÂÍ ÎÅÄØÙ"Ê ÎÅØÄ ÃÔÌÉ ÄÅÀ ÒÌÉÅ Â"Ë. ÅÐÃÅÐÍ ÙÍ ÄÅÀ ÁÀÍ ÄÎÆËÄ ÌÒÅÁØ ÙÌÄ ÅÑ"Ì ÃÃÒÚÄ ×ØÅÁ ÌÁÚÄ ÙÉÌÃÄ ÀÇ"Ë ÅÀÔÉ' ÌÁÚ ÁÉÏ ÄÁÐÉÍ ËÉÒÅ"Ù. ÅÒÉÉÏ ÁËÐÄ" Ç"Î ÑÉØ"É ÁÄÂÄ"È ÀÅÈ"Å ÃÄÁÉÀ ÁÙÍ ÄÎÁÉ"È ÃÎÆËÄ ÌÁÚÅ ÀÔÉ' ÁÎ×ÅÍ ÁÏ ÀÎØÉ' ÃÒÚŠרÅÁÄ ÅËÅ' Ò"Ù. ÁØÍ ÇÆÅÚ ×"Ì ÃÐØ' ÃÁØÉ ÄÎÁÉ"È Æ"Ì ÑÅÚØÉÏ ÆÌ"Æ ÃÁÑÉÙÌ"È ËÚÁ ÃÃÅ×À ÀÁ ÌÁÏ ÃÒÚŠרÅÁÄ ÀÁÌ ÌÀ ÀÍ ÌÁÏ. ÅÀÉÌÅ ÁÇ"Á ÑÉ×Ì"Æ ÐØ' ÃÑ"Ì ÃÙÅÉÏ ÄÍ ÀÁ ÅÀÍ ÃÙÍ ÐÃÅÐÅ ÄÅÀ ÁÀÍ ÙÐÚÐÄ ÔÉ' ÄÇÚÅÌ ÌÁÚÄ ÅÄÇÚÅÌ ÌÁÐÄ Å×ÀÎØ ÃÆËÚÄ ÄÁÚ ÄÂÍ ÙÄÅÀ ÃÙÌÁ"Ì ÎÙÅÍ ÃÃÒÚÅ Ù"À ÅËÅ' ÅÀÒ" ÃÌÀ ÎÙÉÉØÀ ÌÀÇØ ÁÒÉ"Ô ÎÙÉÉØÀ ÌÁÚÄ ÃרÅÁ ÀÃÍ ÀÖÌ ÁÐÅ ÅÄÁÉÀ ÃÁØÉ ÄÙ"Ñ Ò"Æ ÉÒÅ"Ù. ÅÎÄÚÉÎÄ ÎÄËÐÄ" ÃÁÀÅÈ"Å ÙÍ ÄÁÉ"à ÄÎÁÉ"È ÙÁÇ"Á ÑÉ×Ì"Æ ÌÒÐÉÏ ÃÀÔÉ' ÁÚ ÁÎ×ÅÍ ÁÏ ÅÁÀÅÉ"Å ÄÁÉ"à ÙÁÇ"À ÑÉÙÌ"È ÃÃÅ×À ÀÁ ÌÁÏ ÀÁÌ ÌÀ ÀÍ ÌÁÏ ÅÀÉÄÅ Æ"Ì ÔÌÉ ÒÌÉÅ ÅËÚÁ ÃËÉÅÏ ÃÄÈÒÍ ÄÅÀ ÎÙÅÍ ÃÃÒÚÅ Ù"À רÅÁÄ ÀÖÌ ÁÐÅ Ä"Ä ÀÍ ÄÀÍ ÆËÚÄ ÌÒÅÁØ ÙÌÄ ×ÐÄ Ò"Ù. ÅÌÀ ÄÒÉØ ÒÌÉÅ ÃÃÁØÉÅ ÐØ' ÃÑÅÚØÉÏ ÆÀ"Æ. ÂÍ ÄÔ"Î Æ"Ì ÁÑÉÖ"À ËÙÃÇÄ ÃÁØÉÅ ÃÑÉÙÌ"È ÌÀ Ä×' ÒÌÉÅ ÃÁÇ"Á ÑÉ×Ì"Æ ÃÁØÉÅ ÐØ' ÃÑÅÚØÉÏ ÆÀ"Æ ÅÌÀ ÉÃÒÚÉ ÌÎÄ:(24) ØÀÄ ÎÄ ÙËÚÁ ØÙ"É ÁÎÙÐÄ ÙÃÉÏ ÆÄ ÀÎÅØ ËÙËÌ ÀÇà ÎÇÌ×É ÄËÌÉ ØÀÅÉ ÌÚÙÎÉÙ, ÅØÀÄ ÎÄ ÙËÚÁ ÙÍ ÄØÙ"Ù ÁÁÉÀÅØ ÄÃÁØ, ÅÄÁÉÀ ÂÍ ÃÁØÉ ØÙ"É ËÀÏ ÂÁÉ ÀÅÂÐÅ.ÀÁØÄÍ ÀÃÄÀÏ ÑÌÈ"ÀÉÙ ÄÁÃÌ ÁÉÏ 'ÄÉ×Ó' ÅÁÉÏ 'ÑÁÉÁ'. ÙÔÒÌ 'ÄÉ×Ó' ÄÅÐÇ ÁÉÇÅà ÒÌ ÄÑÁÅÁ ÄÙÌÍ ÀÁÌ ÔÒÌ 'ÑÁÅÁ' ÉÁÅÀ ÂÍ ÒÌ ÄÑÁÅÁ ÄÁÌÚÉ ÙÌÍ. Òà ÙÀÍ ØÅÖÄ ÌÖÉÉÏ ÙÉÄÉÄ ÄÄÉ×Ó ÙÌÍ ÉËÔÅÌ ÄÎÌÄ ð "ÑÁÉÁ ÑÁÉÁ", ÀÅ ÉÙÎÙ ÁÐÉ ÄÔÒÌÉÍ ËÎÅ "ÅÑÁÅÚÍ ÀÚ ÄÒÉØ Ä×Ó".

ÃÓ ÑÁ.

Á

ÌÉ×ÅÈÉ ÈÅØ ÀÄ"Ò:ÅÒÚÄ ÐÁÅÀ ÀÌ ÄÇ×ÉØÄ ÄÙÐÉÄ, ÎÄ ÙÉÙ ÌÒÅØØ ÁÆÄ, ÎÙÅÍ ÃÄÅÉ ÃÁØ ÎÀÅÑ ÅÎÂÅÐÄ ÌÄÙÚÎÙ ÎÄÐÑØÉÍ ÄÀÌÄ ÁÁÉÚ ÄËÐÑÚ ÅÌÚ×Ï ÒÌ ÉÃÍ Î×ÅÍ ÌÚÔÌÄ. ÀÉÁØÀ ÃËÏ ÎÖÉÐÅ ÁÙ"Ò ÑÉÎÏ ×Ð"à ÑÒÉÓ É"À, ÃÐØÅÚ ÙÐÚÐÍ ÒËÅ"Í ÌÒÁÅÃÚ ÀÌÉÌÉÍ ÅËÁÏ ÙÎÙÏ [ÃÀÓ ÃÒ"É ÁÉÈÅÌ ÆÄ ÎÅÚØÉÍ ÌÄÃÉÅÈ] ÃÀÑÅØ ÌÉÙØÀÌ ÄÌÅ×ÇÍ ÌÄÃÌÉ×Í ÁÁÉÚ ÄËÐÑÚ, ÎÙÅÍ ÃÎÀÉÑ ÌÂÁÅÄ, ÅËÏ ËÚÁÅ ÄÀÇØÅÐÉÍ ÙÍ, ÌÒÐÉÏ ÎÐÅØÅÚ ÙÄÉÅ ÁÁÉÚ ÀÌÉÌÉÍ ÙÌ×ÇÏ ÉÙØÀÌ ÀÇØ ÄÁÉÈÅÌ, ÀÔ"Ä ÌÁÉÚ ÄËÐÑÚ ÀÑÅØ, ÎÙÅÍ ÃÎÀÉÑ, ÅËÏ ÄÅÀ ÁÑÒÉÓ É"Á ÒËÁØ ÙÐÎÖÀ ÁÙÎÏ ÙÌ ÁÉÚ ÄËÐÑÚ ÀÍ ÄÅÀ ÎÀÅÑ ÀÑÅØ ÌÄÃÌÉ×Å ÁÁÉÚ ÄËÐÑÚ, ÅÒÉÉ"Ù ÁÀÇØÅÐÉÍ ÃÉÙ ÙÑÅÁØÉÍ ÃÀÔÉÌÅ ÉÙ ÙÙÉÍ ÃÎÅÚØ ÁÀËÉÌÄ, Î"Î ÀÑÅØ ÎÙÅÍ ÄרÉÁÄÅ ÐÀ ÌÔÚÇÊ ÒÉÉ"Ù, ÅÒÉÉÏ ÑÉÎÏ ×Ð" ÑÒÉÓ Ë"À ÁØÎ"À ÃÀÑÅØ ÌÒÙÅÚ ÎÀÚÐÏ ÆÅÐÄ ÅÎÇÉØ ËÌÁ ÃÁØ ÙÌ ÎÖÅÄ, ËÂÅÏ ÁÉÚ ÄËÐÑÄ ÀÅ ÑÔØ ÚÅØÄ, ÅÒÉÉÏ ÎÂ"À ÅÙÀØÉ ÀÇØÅÐÉÍ ÃÄÅÀ ÎÃØÁÐÏ ÎÙÅÍ ÎÉÀÅÑ ÅÁÆÉÅÏ ÌÁÉÄË"Ð ÅÑ"Ú.ÐÂÉÒÄ ÙÂÁÉ ÈÅÎÀÄ ÉÚÔÅÑ ÚÎÉà ÙÐÂÒ ÄÈÄÅØ ÁÈÎÀ, ËÉ ÒÌ ÄÈÄÅØ ÎÅÈÌ ÄÇÉÅÁ ÌÄÚØÇ× ÎÏ ÄÈÎÀ, ÌÀ ÁÄÔÊ.ÀÌÓ ÙÌÅÎÉ' ÌËÁÅà Ù"Á ÄØÁ ÄÎÀÄ" ÄÇØÉÓ ÅÁ×É ÄÎÔÅØÑÍ ÎÅ"Ä ÎØÃËÉ ÆÉÑ×ÅÐà Ð"É:ÅÎÒÚÄ ÐÁÅÀ ÌÑÔ× ÄÙÐÉ ÙÐÑÚÔ× ÄÇ' ÄÙ' ÅÀÚ"Ì ÙÄÃÉÏ ÒÍ ÉÙÙËØ ÅÇÉÉÁ ÆÁÅÌÅÏ ÌÉÚÏ ÌÅ ÇÖÉ ÀÅÚÅ ÄØÉÁÉÚ ÙÄÅÖÉÀ ÁÃÉÉÐÉ' ÄÙÚÀ ÎÁÒÉÀ ÌÏ ÀÍ ÁÎ×ÅÍ ØÉÅÇ ÄÉÄ ÙÍ ÄÔÑà ÁÀÅÚÅ ÄÙÅÚÔÅÚ ÅÐÅÃÒ ÄÃÁØ ÌÉÙÙËØ ÙÇÁÉØÅ ÆÁÅÌÅÏ ÌÅÄ ÎÒÅÚ ÁØÉÁÉÚ ÅÈÅÒÏ ÙÉÙÌÍ ÒÎÅ ÇÖÉ ËÌ ÄÄÔÑà ÅËÅ' ÅÉÙÙËØ ÈÅÒÏ ÙÀÍ ÌÀ ÄÉÄ ÌÅÄ ÀÅÚÏ ÄÎÒÅÚ ÌÀ ÄÉÄ ÄÄÔÑà Ë"Ë ÂÃÅÌ ÅÙÀÅÚÏ ÄÎÒÅÚ Ì×Ç ÁÌÉ ÉÃÉÒÚÅ ÅÌËÏ ÀÉÐÅ ØÅÖÄ ÌÙÌÍ ÁÀÅÚÅ ÄÄÔÑà ËÌÅÍ Ë"À ÁÀÅÚÅ ÄÑÊ ÄÎÂÉÒ ÌÅ ÁÎÎÅÏ ÙÄËÐÉÑÅ ÁÉÐÉÄÍ ÁÑÇÅØ' ÁÆÎÏ ÄÙÅÚÔÅÚ ÒÌ ÄËÌ ÉÁÀ ÅËÅ' ÙÑÔ× ÆÄ ÐÎÉ ÄÅÚØ ÎÎÉÌÀ ÎÎÄ ÙËÚÁ Â"Ë ÄØÎÁ"Í ÁÔ' Ä' ÎÄ' ÙÌÅÇÉÏ ÅÙÅÚÔÉÏ Ù×ÃÍ ÁÅ ÌÐÅ ÆËØÅ ÙËÚÁ ÅÉØÀÄ ÌÉ ÙÀÍ ÐÚÒÑ× ÁÃÁØ ÀÉÑÅØ ÙÌÀ ÎÃÒÚ ÇÁÉØÅ ÙÀÍ ÄÉÄ ÙÍ ÄÔÑà ÉÔÑÉà ÄÅÀ ÌÁÃÅ ËÉÅÏ ÙÌÀ ÎÃÒ' ÇÁÉØÅ ÒÙÄ ÅËÅ' ÉÒ"Ù:ÄÂØ"À Æ"Ì ÀÅÎØ, ÙÉÙÐÅ ÉÖØ ÄØÒ ÎÁÔÐÉÍ ÅÉÖØ ÄØÒ ÎÁÇÅÕ. ÄÎÚÁÅÐÏ ØÅÀÄ ÁÚÅØÄ Ä×ÃÅÙÄ ËÉ ËÌ ÄÔÇà ÀÉÐÅ ËÌ ËÊ ÎÔÐÉ ÄÉÖØ ÄØÒ ÎÁÔÐÉÍ, ËÎÅ ÎÄÉÖØ ÄØÒ ÎÁÇÅÕ, ÖØÉËÉÍ ÌÃÒÚ, ËÉ ÁÀÎÚ ÄÉÖØ ÄØÒ ÎÁÔÐÉÍ ÄÅÀ ÀÔÑ ÌÒÅÎÚ ÄÉÖØ ÄØÒ ÙÎÁÇÅÕ... ÅÌÎÄ ÁÀÎÚ ÄÅÀ ËÌ ËÊ ÇÆ×, ÄÅÀ ÙÀÐÅ ÀÅÎØÉÍ ÚÎÉà ËÌ ÄÒÅÌÎÅÚ ÙÌ ÇËÎÄ ÄÍ ÖÌ ÎÎÙ ÌÒÅÎÚ ÒÅÌÍ ÄÎÒÙÄ, ÄÂÁÅØÄ ÄÀÎÉÚÉÚ ÅÄÇÅÆ× ÄÅÀ Ø× ÒÅÌÍ ÄÎÒÙÄ. ÆÄÅ ÑÅÃÅ ÅËÇÅ ÙÌ ÉÖØ ÄØÒ ÎÁÇÅÕ, ÄÌÀ ÄÅÀ ÁÒÅÌÍ ÄÎÒÙÄ, ÅÌËÏ ÄÅÀ ÇÆ× ËÁØÆÌ. ÀÚ ÄÉÖØ ÄØÒ ÎÁÔÐÉÍ, ÅÉÄÉÄ ÀÔÉÌÅ ÇÆ× ÎÀÃ, ËÉÅÏ ÙÄÅÀ ÒÃÉÉÏ ÁÔÐÉÍ, ÁÄØÄÅØ ÅÎÇÙÁÄ, ÅÌÀ ÉÖÀ ÌÒÅÌÍ ÄÎÒÙÄ, ÑÅÓ ÑÅÓ ÉÅËÌÅ ÌÁÈÌÅ, ÀÊ ËÙÐÔÂÙÉÍ ÒÍ ÄÉÖØ ÄØÒ ÎÁÇÅÕ, ÀÔÉÌÅ ÎÁÈ ÁÒÌÎÀ ÎÑÅËÏ, ÅËÁØ ÌÀ ÉÒÁØÅ ÎÎÐÅ. ÒÌ "ÅÚØÀÅ ÀÚ Ù×ÅÖÉÄÍ" ÄÅÖØÊ ÌËØÅÚ ÁØÉÚ ÒÍ ÀÌÅÚ ÅÙÁÅÒÅÚ, ËÉ ÄÎÁÈ ÁÅÃÀÉ ÒÅÙÄ ØÅÙÍ. ÅÁÃØÊ ÆÅ ÉÙ ÌÄÁÉÏ ÀÚ ÑÅà ÄËÁÅÃ. ËÌ ÄÉÖØ ÄØÒ ÎÁÇÅÕ ÉÅÅÖØ ÎËÇ ÆÄ. ÒÐÉÏ ÄËÁÅà ÄÅÀ ÌÇ×ÅÚ ÀÇØÉÍ ÅÌÎÖÀ ÇÏ ÀÖÌÍ, ÅËÇ ÆÄ Î×ÉÓ ÀÚ ÄËÌ, ÀÉÏ ÀÓ ÖÒÃ, ÀÉÏ ÀÃÍ ÔÅÑÒ ÁÌÉ ËÅÅÐÄ ÌÎÖÀ ÇÏ... ÅÄÑÅÃ ÄÆÄ ËÌ ËÊ ÐÅØÀ, ÒÃ ÙØÅÖÉÍ ÌÎÖÀ ÇÏ ÀÓ ÁÒÉÐÉ ÄÙÔÌ ÙÁÙÔÌÉÍ ÎÎÙ, ÎÈÅØÓ ÀÍ ÐÎÖÀÉÍ ÀÚÅ ÁÁÉÚ ËÁØ ÉÚÐÄÂÅ ÁÀÅÔÏ ÀÇØ ÎËÔÉ ÙÄÉÅ ÎÚÐÄÂÉÍ ÀÍ ÄÉÅ ÁÁÉÚ ÌÁÃ... ÅÁÉÃÒÅ ÆÀÚ, ÒÌ ÄÀÃÍ ÌÄÚÔÇÃ ÄØÁÄ ÁÔÐÉ ÄØÇÅÁ, ÙÍ ØÅÀÉÍ ÄØÁÄ ÃÁØÉÍ... (ÙÍ ÒÎÅà ÙÌÄ ÉÖØ, ÄØÒ ÎÁÇÅÕ)ÀÎØ ÒÅà ÅÁÃÉÒÁà ËÌ ÄÙÅÔØÅÚ ËÙØÉÍ ÁÉÏ ÔÙÅÈÉÍ ÁÉÏ ËÔÅÔÉÍ ÅÎÖÅÄ ÁËÔÅÔÉÍ ÉÅÚØ ÅËÅ' ÙÍ ØÎÆ ÁÄ×' ÒÅà Î"Ù ÁÎÃ' ÅÆ"Ì ÔÐÄ ÀÌ ÚÔÌÚ ÄÒØÒØ ÅËÅ' ØÁÉ ÔÚØ רÀ ÁÃÅØÅÚ ÄÌÌÅ ÙÀÉÏ ÌÄÍ ÌÀ ÎÌÊ ÅÌÀ ÐÁÉÀ ÅÌÀ ÀÅ"Ú ÅÌÀ ËÄÏ ÅÎ×ÃÙ ÅËÅ' ÀÌÀ ÚÔÌÄ ÀÎØ ÃÅà ÌÔÐÉÅ ÉÚ' ØÁÙ"Ò ÀÌ ÚÁÆÄ ÚÔÌÚÍ ÚËÚÁ ÆÀÚ ÌÃÅØ ÀÇØÅÏ ÅÒÍ ÐÁØÀ ÉÄÌÌ ÉÄ ÒË"Ì ÄØÉ ÙÄÚÔÌÌ ÃÄÒ"Ä Ò"Ë ÉÙØÀÌ ÙÉ×ÁÌ ÚÔÌÚÍ ÀÔÉ' ÁÆÄ"Æ ÙÀÉÏ Î×ÃÙ ÅÌÀ רÁÐÅÚ ÅÌÀ ÀÅ"Ú ÅÒË"Æ ÙÉÄÉÅ ÌÔÐÉÅ ËÁØÉÄ ÇÃÙÄ ËÃÎÑÉÉÍ ÅÒÍ ÐÁØÀ ÉÄÌÌ ÉÄ ËÎ"Ù ÙÍ ÅÌÆÄ ØÎÆ ÄËÀ. ÅÁÃÉÒÁà Ø"Ì ÙÇØÁ Î×ÃÙ ÅÄÉÄ ÌÀÉÏ ÎÇÎà ËÌ ÒÉÏ ÅÌÀ ÐÙÀØ ÌÐÅ ËÉ ÀÍ ÙÉÇ ÙÔÚÅÚÐÅ ÁÚÔÉÌÚÐÅ ÅÀÔÉ' ÌÃÅØ ÀÇØÅÏ ËÃÅØ ÄÉÚÅÍ ÄÆÄ ÙÌÀ ÐÙÀØ ÌÐÅ ËÉ ÀÍ ÚÔÌÄ ÔÙÅÈÄ ÌÔÐÉÄ ÅÌÀÇØÉÄ ËÒÍ ËËÄÏ Ë×ÈÅÏ ËÂÃÅÌ ÐÅÑÇ ÚÔÌÄ ÀÇÚ ÌËÌ ÉÙØÀÌ ÀÙØ ÑÉÃØÅ ÌÐÅ ÀÐÙÉ ËÐÄ" ÅÀÉÏ ÀÉÚÐÅ ÉÅÃÒ Òà ÎÄ ÌËÅÉÏ ËÅÐÚ ËÌ ÚÔÌÄ ËÌÌ ÅÄÎËÅÉÏ ÁÚÔÌÚÅ ÀÔÉ' ÔÉ' ÄÎÌÅÚ ÀÙØ ÎÅÖÉÀ ÎÔÉÅ ÔÙÈÏ ÙÌ ÃÁØÉÍ ÇËÍ Éר ÅÎÉ ËÎÅÄÅ ÎÅØÄ ÒË"Æ ËÁØ ÄÚÔÌÌ ÃÄÒ"Ä ÂÍ ÌÃÅØ ÀÇØÅÏ ÙÚ×ÅÁÌ ÖÒ×ÚÐÅ ÌÔÐÉÅ ÉÚ"Ù ËÀÉÌÅ ÄרÁÐÅ ÚÎÉÃÉÏ ÅÎÅÑÔÉÏ ÅÎÅÑÔÉ Ø"Ä ËÄÌ' ÅÀÌ×'ÉÐÅ ÎØÇÍ É×ÉÉÍ ÃÁØÅ ÄÈÅÁ ÅÉÒÌÄ ÒÌÉÐÅ ÚÔÌÚÐÅ ËרÁÐÅÚÉÐÅ ÅÉÒÙÄ ÀÅÚÐÅ ËÁØÉÄ ÇÃÙÄ ÄÀ ÎÉÄÀ Â' ÎÃØÂÅÚ ÉÙ ÁÉÏ Î×ÃÙ À' ÃÄÅÀ ÃÅÎÄ ÌÎÖÅÄ ÎÏ ÄÎÅÁÇØ ÅÁÆÎÏ ÁÉÚ Á' ÒÃÉÓ ÎÉÐÏ ÔÅØÈÀ ÅÂØÒ ÎÆÎÏ ÁÉÚ À' ÙÄÉÄ ÎÌÊ ÅÖÉÁÅØ ÅÀÅ"Ú ÅËÅ' ÀÁÌ Î"Î ÒÃÉÔÉ ÎÉÐÏ ÙÄÉÄ ËÄ" ÅÁÂÃÉ ËÄÅÐÄ ÅÒÁÅÃÚ ÄרÁÐÅÚ ÅÒËÙÉÅ ÁÒÅÄ"Ø ÇÑØÉÍ ÎËÌ ÈÅÁ ÅÁÃÉÒÁà ÑÅ"Ñ ÉÅÖÀÉÍ ÉÃ"Ç ÅËÌ Ä×ÅÌÅÚ ËÙØÉÍ ÁÙÅÔØ ÄØÉ Â' ÇÌÅ×ÅÚ ÄÐÀÎØÉÍ ÁÀÎÚ ÅËÎ"Ù ÄØÈ"Æ Æ"Ì:(ËÈ) ÃÀÓ ÌÎÀÏ ÃÀÎØ ÎÖÅÚ ÀÉÏ ÖØÉËÅÚ ËÅÅÐÄ, ÎËÌ Î×ÅÍ ÀÍ ËÅÅÏ ÙÌÀ ÌÖÀÚ ÀÉÐÅ ÉÅÖÀ [ÄÂØ"À ÅÙÀØ ÀÇØÅÐÉÍ] ËÌ ÎÉ ÙÃØËÅ ÌÐÑÊ ËÚÁ ÄØÙÁ"À ÀÔÉ' ÐËØÉÍ ÙÁÇ"Ì (ÀÒ"Ô ÙÀÉÏ ÒÅÁÃÉÍ Ò"À ÒË"Ä). ÅÁÒÉÅÐÉ ØÀÉÚÉ ÁÔØÎ" ÙÄÒÌÄ ÙÄÃÉÏ ÄÆÄ ÐÇÌ× ÌÄ' ÇÌ×ÉÍ À') ÒÉÐÉÅ ØÅÀÉÍ ÒØÅÚÅ ÄÅÀ ÃÀÅØÉÉÚÀ ÅÄÉÉÐÅ ÁÒØÅÍ ÌÀ ÎÄÐÉ ÀÔÉ' ÇÆØÚ ÔÐÉÍ ÀÅ ÒÅÖÍ ÒÉÐÉÅ ÅÄÀ ÃËÚÉÁ ÌÀ ÉØÀÄ ÁÊ ÒØÅÚ ÃÁØ ×ÀÉ ÀÙËÉÐÄ [ÃÀÌ"Ë ×ÙÉ' ÎÃÅÒ ÒØÅÍ ÌÀ ÉÚØÅÍ ÉÒÖÉÍ ÒÉÐÉÅ] ÅÁÆÄ ÂÅÔÉ' ÐÇÌ×Å ÄÈÅ"Æ ÒÍ ÄÃØÉÙÄ, ÄÃØÉÙÄ Ñ"Ì ÁÂÅÅÐÀ ÙÀÉÏ ÀÇØ ÙÍ ÅÄÅÀ ÀÉÐÅ ØÅÀÄ À"Ë ÌÀ ÄÅ' ÁËÌÌ ÌÀ ÉØÀÄ ÅÄÅÀ ÃØÁÐÏ ÎÙÀ"Ë ÄÈÅ"Æ Ñ"Ì ÙÌÀ ÉØÀÄ ×ÀÉ ÀÙËÉÐÄ ÅÒÉÉÏ ÁÙÅ"Ò Ñ" ÅÁÔØÎ" ÄÅËÉÇ ÁÎ×ÖÚ ËÃØÉÙÄ ÒÉÉ"Ù Á') ÅÌÁÅ ØÅÀÄ ÒØÅÄ ÃØÁÐÏ ÅÆ"Ì ÙÍ ÅÄÔØÙ ÉÙ ÁÉÏ ÒÉÐÉÅ ØÅÀÅÚ ÌÀ ÎÄÐÉ ËÉÑÅÉ ÄÎÉÍ ËÎÅ ÒØÅÄ ÁÒÙÙÉÚ ÅÀÉÌÅ ÌÂÉÌÅÉ ÒØÅÄ ÎÄÐÉ ËÉÑÅÉ ËÎÅ ÙÉØÀÄ ÄØÅÀÄ ÁÃÁØÉÄÍ ÁÑÉ' ØÉ"Ù ÅËÀÏ ÅÁÀÎÚ ÈÒÎÉ' ÌÀ ÉÃÒÐÅ ÌÎÄ ÎÀÇØ ÃÌÀ ÉØÀÄ ×ÀÉ ÀÒÉÐÉÅ ÅÂÉÌÅÉ ÒØÅÄ Î"Ù ÆÄ ÎÆÄ ÅÄÔØ"Ç ÄØÂÉÙ ÁÆÄ ÅÄÙ"Ê ÁÉÅ"à ÄÒÉØ ÁÆÄ ÅÌÀ ÚÉ' ËÌÅÍ ÅÄÐÌÔÒÐ"à ÅËÎÅ ÙËÁØ ËÚÁÚÉ ÎÆÄ ÌÒÉÌ ÃÄÐÄ ÎÉÍ ÄÅ' ËÉÑÅÉ ÅÁË"Æ ÁØÅÀÄ ÌÀ ÎÄÐÉ ÅÁÙÌÅÎÀ ÁÂÌÅÉ ÒØÅÄ ×ÀÉ ÌÀ ÉØÀÄ ÀÙËÉÐÄ ÀÁÌ ÁËÉÑÅÉ ÅÀÉÐÅ ËÒÙÙÉÚ ÙÐØÀ' ÁÅ ÎÎÙ ÎÄÐÉ ÁÆÄ Â') ÁÂÌÅÉ ÒØÅÄ ÀÒ"Ô ÙÀÉÏ ÌÁÅ ÅÒÉÐÉÅ ØÅÀÅÚ ÅÄÅÀ ÃÀÅØÉÉÚÀ Ã') ÒÉÐÉÅ ØÅÀÅÚ ÒØÅÚ ÇÁÉØÅ ÄÅÀ ÃÀÅØÉÉÚÀ ÁË"Æ ÇÆØÚ ÔÐÉÍ ÀÅ ÒÖÉÎÚ ÒÉÐÉÅ ÌÉÙ ÙÉÈÅÚ ÎÄÐÉ ÅÒÉÉÏ ÁÑÉ' Ò"Ä ÁÎÂ"À ÀÅÚ È' ÅÈÅ"Æ ÀÅÚ Á' ÅËÎÅ ÙËÚÁÐÅ ÌÒÉÌ ÌÁÅ ØÅÀÄ ÒØÅÚ ÇÁÉØÅ ÄÅÀ ÎÁÅÀØ ÁÑÉ' Ò"à ÑÒÉÓ À' ÅÀÍ ÄËÚÅÐÚ Ã× ÎÀÅà ÃÉÐÅ ËÃÉÏ ÄÎÉÍ ÒÉÉ"Ù ÄÉÅÖÀ ÌÐÅ ÎÆÄ ÙÉÈÚ ÄÈÅ"Æ ÁÄÉÀ ÁÚÅÊ ÄÎÉÍ ÙÄÉÀ ÒÉ"Æ ËËÚÅÐÚ Ã× ÅËÏ ÀÉÐÅ ÎÑÚËÌÚ ÁÒØÅÚ' ÅÒ"Ë ÎÅÚØ Å×"Ì, ÅÄÐÄ ÁÙÅ"Ò ÀÉÚÀ ÁËÀÏ ÀÍ ÄÍ ÖÌÅÌÉÍ ÒÅËØÚÏ ÁØÂÌÉÅ ÅÄ×Ù' ÄÈÅ"Æ ÄÌÀ ÄÎÉÍ ÄÅ' ËÌÁÉÙÚ ÄÇÌÅ× ÅÎÃÅÒ ÖØÉÊ ÒÅËØÚÏ ÒÉÉ"Ù ÅÄÙ"Ê ËÚÁ ÙÄØÀÁ"à ÄÐ"Ì ÙËÚÁ ÒÅËØÚÏ ÁØÂÌÉ' ÌÀ Ñ"Ì ËÀÅ"Ç ÙÂÍ ÁÐÙÉÍ ÉÙ ÃÉÏ ÌÁÄ ØÅÀÄ ÀÚ ÄÒØÅ' ÄÐÄ ÆÄ Ö"Ò ÙÉÄÉ' ËÎÅ ÑÚÉØÄ ËÉ ÁÑÉ' Ò"à Ñ"Á ÄÒÚÉ× ÃÁØÉ ÄÀÅ"Ç ÅÄÐÌÔÒÐ"à ÌÚØÕ ÁËÅÅÐÚ ÎØÏ ÄÁ"É ÃÄÐÄ ÐÙÉ ÌÀÅ ÃÉÐÉ ÂÎÉØÄ ÅÄÐÄ ÁÇÌÅ× Ã× ÎÀÅà ÄÅ' ËÎÅ ÂÉÌÅÉ ÒØÅÄ ËÎÅ ÙËÚÁ ÄÔØÎ" ÄÐ"Ì Ò"Ë ÌÖÀÚ ÉÃÉ ËÌ ÄÃÉÒÅÚ ÄÅ' ÉÅÚØ ÈÅÁ ÙÚÒËØ ÁØÂÌÉ' ÙÀÆ ÌÀ ÙÉÉÊ ÙÅÍ ÄÑÚËÌÅÚ ÅÃÅ"× ÅÒÔ"É ÎÄ ÙËÚÁ ÄÔØÎ" ÄÐ"Ì ÙÎÉÍ ÖÌÅÌÉÍ ÌÀ ÄÅ' ÎÎÙ ËÌÁÉÙÚ ÄÇÌÅ× ÐËÅÏ Â"Ë ÙÉÅÚØ ÈÅÁ ÙÚÌÁÅÙ ÄÇÌÅ× ÆÄ ÎÄ ÙÒËÚ' ÁÉÃÉÐÅ ÁÄÌËÄ ÆÅ ÁÑ"Ã. ÅÄÐÄ ØÀÉÚÉ ÙÐÚ×ÙÅ ÁÎ"Ù ÄÈÅØ ÅË"Ë ÄØÀ"Ù ËÙÔÅÙÈÚ ÎÌÁÅÙÉ' ËÙÒÅÎÃÚ ÁÇÌÅ×Ä ÚÁØÊ ÎÃÅÒ ÌÀ ËÚÁ ÙËÏ ÔÑ× ÅÐ"Ì ÃÄÐÄ ÁÆÄ ÄÒÚÉ× ÄÈÅØ ÃÁØÉ ÀÁÉÅ ÁÎ"Ù Á×ÉÖÅØ ÁÑÅÓ Ä' ÐÃÄ ÅÁÔØ× ÙÌÙÄ ÙÀËÌÅ ÑÉ' Ì"à ÙÐÄÂÅ ÌÁØÊ ÁËÌ ÄÈÁÉÌÅÚ ÀÇØ ÄÈÁÉÌ' ÅËÏ ËÚÁ ÁÔØ× ×ÎÀ ÃÔÑÇÉÍ ÁÑÉ' É' ÁÙÍ ÄØ"É ÅÒ"Ë ÃÁØÉ ÄØÀ"Ù ÄÍ ÙÍ Á×ÉÖÅØ ÌÄÅØÅÚ ÎÄ ÃÐÄÂÅ ÀÁÌ ÌÄÌË' ÄÅÀ ÙÚÁØÊ ÀÇ"Ë ËÎÅ ÁËÌ ÄÈÁÉÌÅÚ ÅÃÅ"×. ÅÒÔ"É ÎÄ ÙËÚÁÚÉ ÁÀÅÚ À' ÌÁÀØ ÃÁØÉ ÄÀÙØ"É ÙÄÈÒÍ ÙÎÖÅÚÅ ÁËÊ ÎÅÒÉÌ Ø× ÌÑÐÉÓ ÅÌÀ ÌÑÁØ' ÇÆ×Ä ÅÎÄÉÉ"È ÑÎÊ ÄÀÙØ"É Ø× Ò"Æ ÁÎÉÌÚ ×ÈÏ ÅÌÀ ÁÎÉÌÚ ÂÃÅÌ ÒÉÉ"Ù Ð"Ì ÌÁÀØ ÃÁØÉ ÄÈÅ"Æ ÀÅ"Ç ÑÉ' Ô"à Ñ"× Á' ÙÄ×Ù' ÙÍ ÒÌ ÃÁØÉ ÄØ"Ø ÎÐÅÇ ÁÎ×ÅÀÅÚ ÙÌÐÅ ÙÎ"Ù ÁÁØËÚ ÄÈÁÉÌ' ÁÉÅ"à ÑÉ' ØÉ"Ù ÙËÚÁ ÄØÀ"Ù ËÙÔÅÙÈÚ ÌÁÅÙÉ' ËÙÒÅÎÃÚ ÁÇÌÅ×Ä ÚÁØÊ ÅÚÔÙÅÈ ÇÌÅ×Ä ÅÚÈÁÅÌ ÅËÅ' ÎÙÎÒ ÃÙÉÉÊ ÌÁØÊ ÁÁÉÚ ÄÈÁÉÌ' ÅÚÉ' ÃÄÊ ÁÉÚ ÄÈÁÉÌ' ÉÙ ÌÅ ÃÉÏ ÁÉÚ ÀÎÖÒÉ ÅËÉÅÏ ÙÄÅÀ ÄËØÇ ÎÅÚØ ÁÁÉÚ ÀÎÖÒÉ ÅÌËÀÅ' Ö"Ò ÅÒ"Ë ËÅÅÐÚ ÄÈÅ"Æ ÆÉ"Ò ÁÎ"Ù ÙÄÅÀ ÄËØÇ ÙÄÉÉÐÅ ÑÁØÚ ÄÀÙØ"É ÅÀ"Ë ÎÃÅÒ ÄÅÖØÊ ÌÅÎØ ÙÎ×ÅÀÅÚ ÙÌÐÅ ÄÅ' ËÁÉÚ ÄÀÎÖÒÉ ËÉÅÏ ÙÄÅÀ ÄËØÇ ÉÄÉ' ÎÅÚØ ÀÔÉ' ÁÁÉÚ ÄÔÐÉÎÉ ÀÌÀ Ò"Ë ÖØÉÊ ÌÅÎØ ÙÄÀÙØ"É ÆÉ"Ò ÑÎÊ ËÁÅ ÒÌ ÑÁØ' ÄÐ"Ì Ø× ÁÎ×ÅÍ ÑÐÉÓ ÁÒÌÎÀ ÅÃÅ"×. ÄÁÒÄ"Ç ÔÄ ÐÉÉÈØÀ ÙÒÚ ÇÉØÅÍ ÉÅÍ Ã' Ë"À ËÑÌÉÅ ÚØÒ"Ä ÅÐÆËÄ ÁÎÄØÄ ÌÙÎÅÒ ×ÅÌ ÎÁÙØ ÁØÀÙ ÄØÉÍ ÀËÉ"Ø:

ÔØ× ÙÐÉ

ÅÁÎÑËÚ ÔÑÇÉÍ ÁÔØ× ÄÀÙÄ (ÔÆ.) ÀÎØ Ä×Á"Ä ÌÄÅÙÒ, ÇÈÀÅ ÉÙØÀÌ. ÄÉÄ ÌÅ ÌÅÎØ, ÁÐÉÊ ÁÐÉ ÁÇÅÐÉÊ, ÁÐÉ ÀÁØÄÍ ÉÖÇ× ÅÉÒ×Á, ÂÌÂÌ ÒÌÉÄÍ ØÇÎÉÍ. ÌÀ ÃÉ ÙÌÀ ÀÎØ ËÊ, ÀÌÀ ÀÎØ, ØÁÅÐÅ ÙÌ ÒÅÌÍ, ËÌ ÄÒÅÌÍ ÙÌÊ, ÄÒÁÉØÍ ÁÀÅÎÄ ÀÇØÚ ËÅ'. Òà "ÅÉÀÎØ Ä' ÀÌ ÄÅÙÒ ×Ç ÌÊ ÀÙÚ ÆÐÅÐÉÍ ÅÉÌÃÉ ÆÐÅÐÉÍ ÅËÅ'" (ÄÅÙÒ À, Á), Òà ÀÇà ÎÃ' ×ÐÉÐÉÍ Ù×ÐÉÚÉ ÁÒÅÌÎÉ; ÚÅØÄ ×ÐÉÏ ÀÇÃ, ÃËÚÉÁ (ÎÙÌÉ Ç, ËÁ) "Ä' ×ÐÐÉ ØÀÙÉÚ ÃØËÅ". ÙÎÉÍ ÅÀØÕ ×ÐÉÏ ÀÇÃ, ÃËÚÉÁ (ÁØÀÙÉÚ ÉÃ, ÉÈ) "×ÅÐÄ ÙÎÉÍ ÅÀØÕ". ÉÙØÀÌ ×ÐÉÏ ÀÇÃ, ÃËÚÉÁ (ÙÎÅÚ ÈÅ, ÈÆ) "ÒÍ ÆÅ ×ÐÉÚ ÅËÅ'". ÁÉÚ ÄÎ×ÃÙ ×ÐÉÏ ÀÇÃ, ÃËÚÉÁ (Ø' ÚÄÌÉÍ ÒÇ, ÐÃ) "ÄØ ÆÄ ×ÐÚÄ ÉÎÉÐÊ", Òà ËÀÏ:Å À¤É Ú¬¥ÉΨÀ, ĨÀ ˬ Ú¤ÉÁ Á¬ Ë¨Ì רؠÁ¬ Ð¤ÉÏ Ì§É ÃÅ©¨"Ã, Å À¥ÉÊ  À¨Î§Ø Ð¨À ì À¤ÉÚ Ô¬¤ØÅ¬Ã¨À Á¬ À§Ú Å¨ÅÏ. À¦Ì¬¨À ħÀÉ À¤Ú¬ Î§Ø, Á¬ Ã§Ø Â¬¤ÉÏ Ã¬ À¤Ú Á¬ Ø¤ÉÀŬ Å À¤Ú × Ø¤ÉÀŬ Á¬¤Ù± Î¥ÉĬ. Š̨À ì À¤ÉÐ¬Å¬Ï À¤ÉÄŬ Χά¨Ù±. ĢèÀ ÄŬÀ äˠڤÉÁ, (ÉÙÒÉÄ ÎÂ) ˬ©Ì ħФנبÀ Á¤Ù± Î¤É Š̤ˠÁÅ©Ã¤É Á¬ Ø¨ÀÚ¤ÉÅ É Ö¬§Ø Ú¬¤ÉÅ À§Ó Ò¢Ù²¤ÉÚ¤ÉÅ. ì À¤ÉÚ À§Ú Å¨ÅÏ Ã¬§É ÃÅ©¨"à Á¬§À¢Ö¬¤ÉÌŬÚ, ì Ì¥ÉÚ Á¬ ÄÅ©Ï Ô¬¤ØÅ¬Ã¨À ŠħԠѨרÄ, ì À¤ÉÐ¬Å¬Ï Ë¬ Î§Á¬Å¬Ò¤ÉÏ Ì Â§Á¬§É ÉÄŬ, ì À§Ù± × É¬¨ÉÏ Ì À¤Ę́ФÉÏ. ŬÁ Â¤ÉÏ À¤Ì¬¥ÉÏ Ã¬ À¤Ú Á¬ Ø¤ÉÀŬ, À¤Ã¨Î É¨ÉÏ É' ̠إÉÙ±¨À, Å' Ì ÂŬԨÀ, Ä' Ä' Ì Ò¦Ù²¦Ø À¦Ö¬ Á¬ Ò¨Ï.ÙÍ ÅØÁ ÄÅÐÀ ÎÙÅÍ ÃÀÉÏ ÑÃØ ÌÎÙÐÄ ËÅ', ÅÄÐÄ ÎÙÎÒ ÎÄËÀ ÃÁÇÃÀ ÎÑËÚÀ ÃÉÙ ÑÃØ ÌÎÙÐÄ Ñ"Ì ÌØÁ ÄÅÐÀ ÃÎÇÌÅ×Ú ÅÀÇ"Ë ÑÚÍ ÄÌËÄ ËÑÚÍ, ÅÀÉÌÅ ÁÐÃØÉÍ Ø"Ô ÄÙÅÚÔÉÏ ÁÙÅÚÔÉÏ ÙÐÃØÅ ÄÐÀÄ ÆÎ"Æ ÔÌÉÂÉ ØÀÁ"É ÅØÁÐÏ. ÅÙÍ Î"Å Ò"Á ÔÑ× Ø"Ä ËØÀÁ"É, ÀÒ" ÃÚÉËÓ ÁÚØ ÄËÉ Î"Ç Ò"À ÐÙÐÉÚ ÑÚÍ ÎÙÐÄ ÃÌÀ ËØÀÁ"É, ÅÒ"Ù ÁØ"Ï Ã"Ä ÅÌÀ ÃÁØÅ, ÄØÉ ÃÌÀ ÔÑ× ËÑÚÍ ÀÇØÉ ÄÎÇÌÅ×Ú, ÅÀÅÌÉ ÌÂÁÉ ØÀÁ"É ÌÉÚÀ ÌÄÀÉ ËÌÌÀ, ÎÙÉÍ Ã×ÉÉ"Ì ÎÙÐÚÅ ×Á ÅÐ×É ËÃÀÎØÉÐÏ ÁÒÉØÅÁÉÏ Ñ"Á Ò"Á, ÅÒÎÙ"Ë ÁÇÉÃÅÙÉ ÌÁËÅØÅÚ Ë" Ò"Á.

ÇÃÅÙÉ ÄØÀ"Ä ñ ÁØËÅÚ

ÔÑÅ× ÉÈ

(Æ) ÌÙÅÏ ÔÌÉÌÄ ÙÄÅÀ ÀÅÚ ÅÄÅËÇÄ ËÅ'. ËÎÅ ÅÉÔÌÌ ÙÒÙÄ ÔÌÉÌÅÚ ÒÍ ×ÅÐÅ. ÚÅÑ': ØÙ"É ÀÌÅÏ ÎÅØÄ ÄÅÀ ÙËÍ ËÅ ÔÉ' ÎÃÌÀ ÀÎØ Òà ÙËÍ ÅÒà ÀÌÅÏ ÎÅØÄ ÁÅÉ"Å ÀÌÀ ÎÙÎÒ ÃÒà ÀÌÅÏ ÎÅØÄ ÄÅÀ ÔÉØÅÙ ÌÒà Î×ÅÍ ÙËÍ ËÀÌÅ ÀÎØ ÌÀÉÆÄ ÙËÍ ÌÀÉÌÅÏ ÎÅØÄ ÅÀÅÌÉ ÙÐÉ ÙËÍ ÉÙÐÏ:(Å) ̠Χ“Ò§Ï É¥Ã Ò‡Å¬ Τά¤Æ Ø§Ç®Ù±¦‰Î¦Ù±‰ ŬΤά§“ҢبÁ¨„į ˬ¤É®À¦†Ô¦Ñ Á¬¤Ì Ò¨Ã¨�É À¢Ð¤•É É Ä©Å¨†Ä Å À¥•ÉÏ Ò­Å©Ã³ÌÇÉ ÄÒÅÎà ÎÀÉÌÉÅ ÄÅÉ ÌÇÉ. ÅÄÅÀ ÃÑÎÉËÉ ÒÌÉÄ ÎÀÚÎÅÌ. ÅÀÉ ÌÀ ÑÎÉËÉ ÒÌÉÄ ÎÀÚÎÅÌ ÌÀ ÄÅÉ ÌÇÉ. ÎÇÉÖÄ ÄÒÅÎÃÚ ÎÀÌÉÄ ÄÅÉÀ ÎÇÉÖÄ. ÀÁÐÉ ÂÃØ ÄÉÅÖÀÅÚ ÎÏ ÄÂÃØ ÅÎÅÁÃÌÅÚ ÆÅ ÎÆÅ, ÔÇÅÚ ÎÙÌÙÄ ÀÉÏ ÖØÉÊ ÌÇÉ ÀÇØ. ÙÁÚ ÁÚÌ ÙÄÅÀ ÂÁÅÄ ÒÙØÄ ÅÄÅÀ ÎÀØÁÒ ÀÎÅÚ Òà ÁÉÚ ÑÀÚÉÍ. ÅËÏ ÁÐ×Ò ÒÎÅ× ÒÙØÄ ÅÄÅÀ ÎÀØÁÒ ÀÎÅÚ Òà ÁÉÚ ÑÀÚÉÍ, ÀÅ ×ÎÄ ×ÖÅØÄ ÅÙÉÁÅÌÅÚ Î×ÉÔÅÚ ÀÅÚÄ, ÎÄÌÊ ÀÚ ËÅÌÄ ÅÇÅÖÄ ÌÄ ÀÌÔÉÍ ÀÎÄ.ÄØÉ ÄÖÂÚÉ ÌÔÐÉÊ Ë"Å ÑÉÉÂÉÍ. ÙÄÐÆÄØ ÁÄÍ ÉÈÄØ ÎËÌ ÑÉÉÂÉÍ ÅÄÍ ÁÎÑÔØ ÙÍ ÄÅÉÄ ËÉ ÌÀ ÉÇÔÅÕ ÁÎÅÚ ÄÎÚ ËÉ ÀÍ ÁÙÅÁÅ ÎÃØËÉÅ ÅÇÉÄ:Ù"Î ÎÖÅÚ ÄÙÁÚ ×Ø×Ò ÌÁÒÌÉÄ ÁÉÅÁÌ. 2. ÎÉ×Ì.

ÃÓ ÔÂ.

ÅÌÎÄ ÙÒÉØÄ. ÌÔÉ Î"Ù ËÀÏ Ö"Ò ÙÄØÉ ÄÉÄ ÃØ ÁÙÒÉØ ÅÁÀ ÎÙÒÉØ ÅÇÆØ ÌÙÒÉØ ÀÊ ÁÁ"Ø Ô' Ô"Á ÑÉ' É"Â ÃØÙÅ ÒÌ ÔÑÅ× ÅÉÌÊ ÀÌ ÀØÕ ÎÔÐÉ ÉÒ×Á ÀÇÉÅ ÙÀÆ ÄÉÄ ÃØ ÒÍ ÉÒ×Á ÀÖÌ ÀÁÉÅ ÁÇÁØÅÏ ÅÉÖÀ ÌÙÒÉØ: ÔÙÉÈÀ!Ã"Ä ÎÅÃÄ ÃÇÉÉÙ Ø' ÉÄÅÙÒ Ì×ÎÏ ËÅ' ÚÔÅÌ ÄÚØÅÎÄ ËÅ' ËÖ"Ì:ÅËÚÁÅ ÁÙÍ ØÁÉÐÅ ÉÅÐÄ Æ"Ì ÙÄÉÄ ÀÅÎØ, ÎÚÅÊ ÃÁØÉ ØÁÉÐÅ ÎÙÄ Æ"Ì ÎÖÀÚÉ ÌÌÎÅÃ, ÃÄÉÑÇ ÄÃÒÚ ÌÀ ÄÅÉ ÀÌÀ ËÙÒÅÎà Á×ÌÅÚ ØÀÙ ÅÁÙÇÅ×, ÀÁÌ ËÙÒÅÎà ÁÉØÀÄ ÅÒÅÑ× ÁÖØËÉÅ, ÀÒ"Ô ÙÒÅÑ× ÁÀÅÎÐÅÚÅ ÅÀÉÏ ÃÒÚÅ ÒÌÉÄÍ ÎÎÙ ÀÉÏ ÆÄ ÐרÀ ÄÑÇ ÄÃÒÚ, ÅËÏ ËÚÁ ÄØÁ ÎÂ"À Æ"Ì ÁÑÉ' Î"à Ñ×"Á ÀÄÀ ÃÉÙÏ ÁÚÔÌÉÏ ÙÁØÀÙÅ ÙÉÐÚ ÒØÀÉ ÃÌÀ ÇÙÉÁ ÄÉÑÇ ÄÃÒÚ, ÀÌÀ ÙÇÅ× Å×ÌÅÚ ØÀÙ, ÅËÎ"Ù ÄÈÅØ ÁÙÍ ÀÁÉÅ ÄØÀ"Ù Æ"Ì. ÅÄÂÀÅÏ ÎÌÁÉòÍ Æ"Ì ÁÑÉ' Ë"Ç Ñ×"Á ËÚÁ ÅÆ"Ì, ÄØÀ"Ù ÁÔØ× ÎÉ ÙÎÚÅ, ÔÉØÙ ÙÄÑÇ ÄÃÒÚ ÀÉÐÅ ÀÌÀ ÙÇÅ× Å×ÌÅÚ ØÀÙ, ÅÌÃÒÚÅ ËÙÄÅÀ ÉÙÏ ÌÀ ÙÉÉÊ ÄÉÑÇ ÄÃÒÚ ÃÙÅËÇ ÄÁÌÉ ÄÒÅÌÍ, ÅËÃÁØÉÅ ËÚÁÅ ÚÌÎÉÃÉ ØÁÉÐÅ ÉÅÐÄ ÅØÁÉÐÅ ÉØÅÇÍ ÅÁÚÅÑÔÅÚ ÉÙÐÉÍ ÁÙÍ ØÁÉÐÅ ÇÐÐÀÌ, ÅË"Ë ÄØÙÁ"À ÁÇÃÅÙÉÅ ÌÑÅËÄ, ÅÁÀØÕ ÉÄÅÃÄ ÄÅËÇÚÉ ÙËÏ ÃÒÚ ØÙ"É ÅÚÅÑÔÅÚ ÁÑÅËÄ ÙÍ, ÙËÚÁÅ ÎÙÅÍ ÙÎÀ ÉÔÉÇ ÅÌÀ ÎÙÅÍ ÄÑÇ ÄÃÒÚ ÅËÅ' Ò"Ë Ò"Ù. ÅÐ"Ì ÀÍ ÎÇÙÁ ÁÒÐÉÐÉÍ ÇÉÖÅÐÉÍ ËÙÄÅÀ ÀÅÎØ ÉÅÖØ ÀÅØ ÁÄÉÅÚÅ ÌÅÁÙ ÚÔÉÌÉÏ ÄØÉ ÆÄ ÁËÌÌ ×ÌÅÚ ØÀÙ ÄÐÆ"Ì, ÅÀÑÅØ ÌË"Ò ÎÙÅÍ ÄÉÑÇ ÄÃÒÚ ÃÚÔÌÉÏ, ÅÉÙ ÌÃÁØ ÒÅà ÁÒÆÄ"É:(ÐÃ) ÀÌÀ À"Ë. ÒÁÀÄ"È Î"Ù ÎÄÙ"Ê ÃÀÔÉ' ÁÃÉÒÁà ÀÑÅØ ÅØ"Ì ÃÀÓ ÌÖÌÅÚÅ ÀÇ"Ë ÀÑÅØ. ÙÔ"à Ñ"× Ë" ÒÉÉ"Ù:ÚØÉ ÎØÈÅÈÄ. ÙÅØÄ ÑÎØÈÅÈ ÀÇà ÎÒØÁ ÉÅÄ"Ë ÅÉÄÁ ÌÉÄ ÚÇÅÚ ËÃÄ ÚÇÚ Ëà ÙÚÚÐÂÁ ÁÎ×ÖÚ ÅÌÎÇØ ÎÒÁÉØÄ ÒÌ ÔÐÉÅ:[102] ÅÁÇ"À ÌÁ"Á ÙÍ [Â, ÖÈ.] ÄÅÑÉÓ ËÀÏ ÁÆÄ"Ì: "ÅÎÆÄ ÚÁÉÏ ÒÐÉÏ ÄÔØÚ ÄÐÃØ, ÙËÀÙØ ÐÙÁÒ ÀÅ ÐÅÃØ ÄÅÀ ÉÅÖÀ ÎÏ ÙÀØ ÄËÌÌ ÁÃÁØ ÙÄÅÀ ÐÅÃØ, ÅÄÅÀ ÉÇÉà ÁÐÃØ ÄÆÄ, ÙÒÅÙÄ ÌÅ ÃÁØ ÎÉÅÇÃ. ÅÄÅÀ ÀÎØÍ Æ"Ì [ÐÃØÉÍ ËÁ.] ÄÐÅÃØ ËÀÉÌÅ ÁÅÐÄ ÁÎÄ. ÅÆÄ ËÉ ÄÁÅÐÄ ÁÎÄ ÌÒÖÎÅ ÎÅÖÉÀ ÒÖÎÅ ÎÏ ÄËÌÌ ÁÁÐÉÏ ÙÄÅÀ ÁÅÐÄ ÌÒÖÎÅ. ÅËÏ ÄÐÅÃØ ÎÅÖÉÀ ÒÖÎÅ ÎÏ ÄËÌÌ... ËÉ ËÌ ÒÐÉÏ ÄÐÃØ ÙÄÅÀ ÔØÈÉ, ÐÁÃÌ ÎÏ ÄËÌÌ. ÅËÀÙØ ÐÆ×× ÄÇËÍ ÀÅ ÙÌÙÄ ÄÃÉÅÈÅÚ ÀÌÉÅ, ÎÔÐÉ ÙËÌ ÒÐÉÏ ÄÇËÍ ÙÄÅÀ ËÌÌÉ ÉÅÚØ, ÅÌÔÉËÊ ËÀÙØ ÎÆ××ÉÍ ÌÄÚÉØ ÌÅ ÀÚ ÄÐÃØ ÀÙØ ÐÃØ Ò"Ò, ÀÆ ÄÂÆÉØÄ ÁÈÉÌÄ. ÅÃÁØ ÆÄ ÁØÅØ ËÉ ÄÅÀ ÑÅà ÄÐÃØ ÅÄÚØÚÅ. ÅÂÍ ÎÆÄ ÚÁÉÏ ËÉ ÐÃØ ÙÄÅÃØ ÒÌ ÃÒÚ ØÁÉÍ, ÙÀÉÏ ÌÅ ÄÚØÄ [ÂÉÈÉÏ ÌÅ.], ËÉ ÀÉÏ ÆÄ ÐÇÙÁ ÃÁØ ÔØÈÉ, ÙÀÉÏ ÄÚØÄ Ø× ÌÂÆÉØÄ ÔØÈÉÚ. ÅÌÔÉËÊ ÀÎØ 'ÎÉ ÎÔØ ÌÉ ÄÐÃØ' ÒÌ ÄØ ÑÉÐÉ, ÙÄÅÀ ÎÉÅÇà ÙÎÖÈØÔÉÍ ÒÌÉÅÐÉÍ ÅÚÇÚÅÐÉÍ ÁÉÇÃ". ÅØÀÄ ÌÒÉÌ ÄÒØÄ 69. ÅËÏ ÄÅÀ ÁÐÚÉÁ ÄÙÌÅÍ Ô"Á [À, ØË.], Ç"À ÌÉÁÎÅÚ ×È. [À. ×ÎÅ:], ÅÇ"À ÌÐÃØÉÍ ËÁ. [Á, Ã.].ÌÀ ÎÑØÄ ÌÄ ÀÌÀ ÙÎÉØÚ ÎÔÚÇ - ÅÌÀ ÑÎËÀ ÀÃÒÚÀ ÌÉËÐÑ ÃÐÚÔÑÚ ËÂÐÁ ÎËÀÏ ÙÀÍ ÚÔÑ ÄÎÅÙÌ ÀÚ ÄÉÄÅÃÉ ÅÄÐÉÇ ÙÎÉØÚ ÒÅÁÃÉ ËÅËÁÉÍ ÁÁÉÚÅ ÅÐÎÑØ ÌÄÍ ËÌ ÄÎÔÚÇÅÚ ÀÓ ÙÌ ÉÉÏ ÀÍ ÀÉÏ ÀÅËÌÉÍ ÅÙÅÚÉÍ ÎÎÄ ÙÁÁÉÚ ÄÉÙØÀÌ ÄÉÉÏ ÎÅÚØ ÅÀÍ ÀÅËÌÉÍ ÁÁÉÚ ÀÑÅØ ÅÀÎÐÍ ÀÍ ÎÖÀÏ ÄÉÙØÀÌ ËÎÅ ÙÄÐÉÇÍ ÎÌÀÉÍ ËÙØÉÍ ÃËÅÅÚÉÄ ÀÙËÇÏ ÂÁÉ ÁÂÃÉÅ ÌÒÐÉÏ ÈÅÎÀÄ ÙÀÍ ÎÖÀÏ ËÎÅ ÙÄÐÉÇÍ ÈÄÅØÉÍ ÅÀÎØÉÐÏ ÒÌÄ ÅËÏ ÁÉÉÏ ÐÑÊ ÅÀÅÌÉ ËÙÎÇÔÙÉÏ ÀÅÚÅ ÁËÌ Î×ÅÍ ÅÁר×Ò ÅÁËÚÌÉÍ ÀÚ ÎÈÎÅÐÉ ÉÙØÀÌ ÂÍ ÄÉÉÏ ÀÑÅØ ÌÔÉ ÙÂÍ ÌÚÅÊ ÇÁÉÅÚ ÄËÐÉÑÅ ×ÐÄ ÀØÅÊ ÌÇÔÙ ÁÅ ÀËÏ ÀÍ ÄÉÄ ÌÉÙØÀÌ ÑÉÎÏ ÅÇÁÅØ ÁÎÂÅÔÄ ÎÅÚØ ÃÀÍ ÄÑÉØÅÄ ÌÇÔÙ ÁÄ ÌÀ ÄÉÅ ÎÇÆÉØÉÏ ÀÅÚÄ ÃÄÀ ÌÀ ÎÉØÚÚÉ ÎÉÙØÀÌ ËÌÌ:ÔÑ'. ÅÀÚ ÙÚÉ ÄËÌÉÅÚ. ÌÀ ÁÒÌ ËÅÌÉÀ ÀÇÚ ÅÌÀ ÁÒÌ ÙÌÙ. ÅÀÚ ÄÇÌÁ ÀÙØ ÒÌÉÄÏ. ÅÌÀ ÄÁÙØ ÙÒÌÉÄÏ. ÀÙØ ÒÌ ÄËÑÌÉÍ. ÆÅ ÇÌÁ ÙÁÉÏ ÄÔ×Å×ÌÅÚ. ÃÁØÉ ØÁÉ Ò×ÉÁÀ. ØÁÉ ÉÅÑÉ ÄÂÌÉÌÉ ÀÅÎØ ÌÄÁÉÀ ÇÌÁ ÙÒÌ ÄÒÅ×Õ. Ø' ÉÙÎÒÀÌ ÀÅÎØ (ÎÄÇÌÁ) [ÎÄ ÇÌÁ] ÄÎËÑÄ ÀÚ ÄרÁ ÚÅÚÁ רÅÍ ÅÐ×ÌÓ ÀÓ ËÌ ÚÅÚÁ רÅÍ ÅÐ×ÌÓ. ÅÀÚ ÄÉÅÚØÚ ÒÌ ÄËÁÃ. ÆÄ ÇÖØ ÄËÁà ÙÉÈÅÌ ÎÏ ÄËÁà ÄÉÅÚØÚ. ÒÌ ÄËÌÉÅÚ ÉÑÉØÐÄ. ÀÔÉÌÅ ËÅÌÉÀ ÀÇÚ:ÙÍ ÅÀÉÎÀ ËÌ Çà ÅÇà ËÉ ÙÇÉÈ ÆÎÏ ÙÇÉÈÄ ÀÎØ ØÇÎÐÀ, Ð"Á ÃÎÑÚÁØÀ Ã×ÁÒ ÄËÚÅÁ ÆÎÏ ÀÇà ÌËÌ ÉÙØÀÌ ÅÌÀ ÙÉÒÙÅ ÀÂÅÃÅÚ ÀÂÅÃÅÚ, Ë"Ð ÎÃÁØÉ ÄÔÐ"É ÁØËÅÚ Á' À' Ã"Ä ÚÐÀ ÄÉËÉ ×ÀÉ ËÅ':ÅÌÔÉ"Æ ÉÅÁÏ ÎÃÅÒ ÌÀ ÄÆËÉØ ËÀÏ ÁØËÚ ÀÁØÄÍ, ÙÎÀÇØ ÙÇÙÁ ÙÀÉÏ ÙÅÍ ÀÇà ÐÚØÇ× ÅÙÐÉÄÍ ËÀÇà ËÌ ÁÉÚ ÉÙØÀÌ ÄÎÄ, ÅÆØÒ ÀÇØ ÀÉÏ ÌÅ, ÎÎÉÌÀ ÁØËÚ ÀÁØÄÍ ÒÌÉÄÍ ÚÁÅÀ ÁÄËØÇ, ÅÀÉÏ ÎÄÖÅØÊ ÌÁØÊ ÁÁØËÚ ÀÁØÄÍ ËÌÌ, Ø× ÀÇ"Ë ËÙØÀÄ ÙÒÙÅ ÐÃÇÄ ÙÄÅÀ Â"Ë ÎÆØÒÅ, ÄÅÖØÊ ÌÁØÊ ÀÚ ÉÒ×Á ÙÄÅÀ ÌÁÃÅ ÚÄÉ' ÌÅ ÁØËÚ ÀÁØÄÍ:

Á

ÅÙÍ ÁÑ' ÐÅÖØ ÇÑà Ô"Å Ã"Ä ÀÇÃÅÚ Ò"É ËÅ' ÑÉÉÍ ÁÄ ÅÆ"Ì, Òà ÙÄÎÌÊ ÐÈÌ ÀÚ ÒÉÐÉÅ ÇÉÆÅ ÃÄÀÉ ÒÌÎÀ, ÅÀÆ ËÌ ØÂÒ ÇÃÙ ÀÖÌÅ ÁÑÅà ÄÚËÌÌÅÚ ËÀÉÏ ÒÌÉÅÏ, ÉÅ"à ÆÒÉÃÀ, ÙÇÅÃÄ, ÃÌÉÚ ÌÄ ÒÉÉÐÉÏ, ÁÁÉÈÅÌ ÄÎÖÉÀÅÚ ÅËÅ', ÒË"Ì. ÅÐØÀÄ ÃÄÉØÅÙÌÎÉ ÅÄØÎÁ"Í Ñ"Ì ÙØ× ÆÉ×Ä ÙÌÁÑÅÓ ÐÂÎØÚ Á×ÉÅÍ ÎÖÅÄ ÄÅÉÀ ÆÉ×Ä ÄÀÅÑØÚ ÀÚ ÄÉÁÍ ÁרÅÁÅÚ ÄÆ×Å×Ä ÎÃÀÅØÉÉÚÀ, ÎÙÀ"Ë ÆÉ×Ä ÙÌÀ ÁÀÄ Ì×ÉÅÍ ÎÖÅÄ ÌÁÑÅÓ Ô×ÒÄ ÌÎÔØÒ ÅרÅÁÅÚ ÄÉÁÎÄ ÎÅÚØÅÚ. ÅÌÔÉËÊ ÀÍ ÄÉÁÎÄ ÎÚÄ ÙÌÀ ÐÂÎØÄ ÄÆÉ×Ä ÁÎÖÅÚ ÇÌÉÖÄ ÀÅ ÉÁÅÍ ÄÆÉ×Ä Ô×ÒÄ ÌÎÔØÒ. ÅÁËÏ ÀÉÑÅØÉ ×ØÅÁÅÚ Æ×Å×ÚÅ ÐÔ×ÒÉÍ ÌÎÔØÒ ÎÏ ÄÚÅØÄ, ÁÉÏ ÀÌÉÁÀ ÃÄÉØÅÙÌÎÉ ÅÁÉÏ ÀÌÉÁÀ ÃÄØÎÁ"Í, ÀÌÀ ÃÀÌÉÁÀ ÃÄØÎÁ"Í ÀÉÑÅØ רÅÁÅÚ Æ×Å×ÚÅ ÇÌ ÎÃØÁÐÏ ÅÀÉÌÅ ÌÉØÅÙÌÎÉ ÄרÅÁÅÚ ÄÅÚØÅ ÌÂÎØÉ.ÌËÊ ÑÉÔØ* ÚÅÌÃÅÚ ÄÙÁÈÉÍ ÆÄ ÀÇØ ÆÄ Òà ÌÅÉ, ËÌÅÎØ ËÙÐÅÌà ÄÙÌÉÙÉ ÀÆ ØÀÅÉ ÌÄÅÖÉÀ ÄÂÅÀÌÉÍ, ÅÑÉÔØ ÄÙÚÌÙÌÅÚ ÄÂÅÀÌÉÍ, ÙÄËÌ ÁÑÃØ ØÀÅÉ ÅÎËÅÅÏ* ÎÀÅÃ. ÅÀÉÏ ÃÁØ ÁÎרÄ, ËÎÅ ÙÀÎØÐÅ ÁËÎÄ Î×ÅÎÅÚ ÙÀÉÏ ÌÅÎØ ËÉ ÄÉÄ ÃÁØ ÀÇà ÁÎ×ØÄ ÎÏ ÄÂÀÅÌÄ, ËÌ ÙËÏ ÑÃØ ÄÙÚÌÙÌÅÚ, Ø× ÄËÌ ÒÌ ÔÉ Ä'. ÀÎÐÍ ÉÙ ÒÅà ÁÆÄ ÃÁØÉÍ ÒÎÅ×ÉÍ ÎÀÅà ÎÀÅà ÁÒÐÉÏ ÄÙÚÌÙÌÅÚ ÎÙÄ ÅÀÄØÏ, ÅÀÉÏ ÌÄÀØÉÊ ÉÅÚØ. Á"Ä:

ÉÃ ØÎÄ

ÅÉÙ ÁÇÉÐÚ ÄÃÁÅØ ÄÔÂÅÍ ËÐÂà ÄÒÙÉÄ ÙÙÍ Ä×ÌÉÔÅÚ, ËÂÅÏ ÌÙÅÏ ÄØÒ ÅØËÉÌÅÚ ÅÃÁØÉÍ ÁÈÌÉÍ ÅËÉÅÖÀ, ÅÌËÊ ÐÀÎØ (×ÄÌÚ É, Ç) ÔÅØÕ ÂÃØ ÉÙËÐÅ ÐÇÙ, ÙÄÅÀ ÔØÕ ÂÃØÉ ÇÅÎÅÚ ÄÌÙÅÏ, ËÎÅ ÙÄÐÇÙ ÒÅÎà ÌÒÅÌÍ ÁÉÏ ÄÂÃØÉÍ ÅÔØÕ ÂÃØÅ ÙÌ ÒÅÌÍ, ËÃÔÉ' Æ"Ì (ÁÎ"Ø ÉÈ, Á) ÀÎØ Ø"Ù ÁØ ÐÇÎÐÉ ÙÀÌÅ ÌÐÇÙ ÅÀÎØÅ ÌÅ ÌÎÄ ÀÚÄ ÎÖÅÉ ÁÉÏ ÄÂÃØÅÚ, ÀÎØ ÌÄÍ ÌÔÉ ÙÔØÖÚÉ ÂÃØÅ ÙÌ ÒÅÌÍ, ÀÎØÅ ÌÅ ÌÎÄ ÌÙÅÐÊ ÒÌ ÄÀØÕ, ÀÎØ ÌÄÍ ÄÅÀ ÂØÍ ÌÉ ÙÀÎØÚÉ ÌÙÅÏ ÄØÒ ÒÌ ÁÅØÀÉ, ÅÎÄ ÄÉÄ ÌÙÅÏ ÄØÒ ÙÀÎØ, ÀÎØ Ø"É ÃÑËÐÉÏ ÁÙÍ Ø"Ì ÄÐÇÙ ÄØÀÙÅÏ ÄÉÄ ÎÑÉÇ ËÁÐÉ ÀÃÍ, ËÉÅÏ ÙÌÀ ÄÉÅ ÀÃÍ ÅÇÅÄ ÎÁ×ÙÉÏ ÌÀËÅÌ ÎÀÅÚÅ ÀÉÌÏ ÄÚÇÉÌ ÌÅÎØ ÌÙÅÏ ÄØÒ ÒÌ ÁÅØÀÅ, ÀÎØ ÌÄÍ ÎÄÀÉÌÏ ÄÆÄ ÀËÌ ÄÁÅØÀ ÅÁØÀ ÀÚ ÒÅÌÎÅ ÅÖÅÄ ÀÚËÍ ÙÌÀ ÚÀËÌÅ ÎÎÐÅ ËÃÉ ÙÌÀ ÚÁØÀÅ ÒÅÌÎÅÚ ËÎÅÚÅ. ÎÄ ÒÙÄ Ä×ÃÅÙ ÁØÅÊ ÄÅÀ ×ÖÕ ØÂÌÉÅ, ÅËØÚ ÌÙÅÐÅ ÙÌÀ ÉÄÀ ÎÑÉÇ. ÙÀÌÅ ÌÐÇÙ ÎÄ ÀÚÄ ÐÄÐÄ ËÙÀÚÄ ÐÅÙÊ, ÀÎØ ÌÄÍ Òà ÙÀÚÍ ÙÅÀÌÉÏ ÌÉ ÙÀÌÅ ÌÁÒÌ ÌÙÅÏ ÄØÒ, ÃËÚÉÁ (×ÄÌÚ É, ÉÀ) ÀÍ ÉÙÅÊ ÄÐÇÙ ÁÌÀ ÌÇÙ ÅÀÉÏ ÉÚØÅÏ ÌÁÒÌ ÄÌÙÅÏ, ÎÄ ÄÅÀ ÐÄÐÄ ËÙÉÀÎØ ÌÙÅÏ ÄØÒ. ÀÎØÅ ÌÅ ÌÐÇÙ ÎÔÐÉ ÎÄ ÀÚÄ ÐÅÙÊ ÁÀÁØ ÀÇà ÅÀØÑ ÙÌÊ ÎÄÌÊ ÁËÌ ÄÀÁØÉÍ, ÀÎØ ÌÄÍ ÅÌÉ ÀÚÍ ÙÅÀÌÉÏ ÙÀÌÅ ÌÁÒÌ ÌÙÅÏ ÄØÒ ÙÄÅÀ ÀÅÎØ ÌÙÅÏ ÄØÒ ÁØÅÎÉ ÅÄÅØÂ ÁÑÅØÉÀ, Òà ËÀÏ ÌÙÅÐÍ. ÐÎÖÀ ÁÒÌ ÄÌÙÅÏ ÐÎÙÌ ÌÐÇÙ ÁËÌ ÖÃÃÉÅ, ÐÎÖÀ ÙÄÅÀ ÉÅØÃ ÀÌ Î×ÅÍ Ä×ÌÉÔÅÚ ÅÔÅØÕ ÂÃØÉ Ä×ÃÅÙÄ ÅÐÅÚÏ ÌÇÖÅÐÉ ÌÉËÐÑ, ÅËÎÅ ÙÉÚÁÀØ ÒÅà ÁÇÈÀ ÌÙÅÏ ÄØÒ.ÅËÉ ÎÈÉ ÌÄËÀ ÀÙËÇÉÄ ÃÒÑÉ× ÁÄÚÇÉÌ ÁÅ ÃÎÙÎÒ ÎÐÉÄ ÐÎÉ ÃÁÙÀØ ÀÉÌÏ ÀÉÐÅ ÎÖÉÌ ÙÉÒÅØ ÑÀÚÉÍ ÁÄÚÇÉÌ ËÐÆ'. ÅÁÄÀ ÀÉÚ ÌÉÄ ÌÄØ"Î ×ÖÚ ÑÁØÀ ÅÌÀ ÆØÄ ÅØÇÅ×Ä ÄÉÀ ËÌ ËÊ ËÄØÀÙÅÐÄ. ÎÙÅÍ ÃÀÉËÀ ÌÎÉÎØ ËÉÅÏ ÃÄÚÇÉÌ ÎÄÐÉ ÌÐÈÅÔÄ. ÌÉÄÐÉ ÐÎÉ ÌÙÀÉÐÅ ÐÈÅÔÄ. ÃÀÒ" ÃÑÀÚÉÍ ÌÀ ÄÅÅ ÁÉÄ ÙËÇÄ. ÌÄËÉ ÀÄÐÉ ÌÉÄ ÄÚÇÉÌ ÃÀÔ"Ä ÌÉÄÅÉ ÙËÇÄ. ÃÀÉ ÁÀÉÏ ÁÅ ÑÀÚÉÍ. ÌÀ ÎÄÐÉ ÁÉÄ ÅÌÀ ÎÉÃÉ. ÃÁÌÀ"Ä ÄÅÉ ÙËÇÄ. ÅÄÉÉÐÅ ÈÒÎÉÄ ÃÎÀÏ ÃÑ"Ì ÄËÉ ËÃÑÁØ ÁÒÚÉ"È ÁÃÒÚ ÄØ"Ù. ÅÒÌ ËÏ ÁÄÀ ÌÀ ×ÀÎØ ÁÌÉÙÐÀ ÃÌÒÉÌ ÙÀÉÐÅ ÎÇÅÅØ ËÌÌ. Ø× ÙÎÏ ÄÎÙÐÄ ÀÉÐÅ ÐØÀÄ ÃØ"Ì ÎÃÑÚÉÍ ÌÏ ÚÐÀ. ÅÌÀ ÐÇÉÚ ÌÔÌÅÂÉ ÁÄÐÉ ÇÉÌÅ×ÉÏ ËÃÌÒÉÌ: ÌÀ ÚÃÒ ÌÙÅÐÅ ÅÌÀ ÚÙÎÒ ÎÄ ÉÃÁØ. ËÎÅ ÁÌÒÂÉ ÙÔÄ ÅÁÌÙÅÏ ÀÇØÚ ÉÃÁØ ÀÌ ÄÒÍ ÄÆÄ (ÉÙÒÉÄÅ ËäÇ:ÉäÀ), ÌÀ ÚÃÒ ÌÙÅÐÅ ÄÅÀ ÌÙÅÏ ÀÇØÚ, ÅÌÀ ÚÙÎÒ ÎÄ ÉÃÁØ, ÄÅÀ ÌÒÂÉ ÙÔÄ, ÙÄÎÁÈÀ ÙÌÅ ÎÙÅÐÄ Òà ÙÂÍ ÄÉÅÃÒ ÄÌÙÅÏ ÌÀ ÉÁÉÏ ÃÁØÉÅ :ÀÉ ÀÔÙØ ÌÅÎØ ËÏ.ÀÌÀ ÃÉÙ ÌÄ×ÙÅÚ ÌËÀÅØÄ ÎÀÉ Î×ÙÄ ÄÙ"Ñ ÀÉÎØ ÃÙÎÒÉÚ ÌÉÄ ÌØÁÉ ÉÙ ÙÁÇ ÒÖÉÍ ÁÔÚ ÆÅÆ" ÎÉ ÙÎÒÉÚ ÌÉÄ ÅÎÐ"Ì ÅÎÐ"Ì ÌÀÅ×ÎÉ ÄÀ ÃÉÅÚÕ ËØÁÉ ÅÄÀ ÃÉÅÖÏ ËØÁÐÏ ÃÄÀ É"Ì ÃÁÌÀ"Ä ËÁØ ÄÒÉØ ÁÚÅÑ' ÌÎÄ ÇÃÙ ÉÅÖÏ ÅÐÃÇ×Å ÃÄÅÉ ËÃÉÒÁà ÅÌÅÌÉ ÙÚÐÉ ÁÁØÉÚÀ ÃÇÃÙ ÉÅÖÏ ÁÅÃÀÅ ÄÉ' ÀÐÅ ÀÅÎØÉÍ ÃÇÃÙ ÉÅÚÕ ÃÆÄ ÌÀ Î×ØÉ ÃÉÒÁà ÌÌÊ ÌÀÔÅÚ ÁÅ ÌËÚÇÉÌÄ ÅÀ"Ë É"Ì ÃÌÎÀ ÃÅ×À ÌØÁÐÏ ÃÑÁØÅ ÀÉÏ ÙÁÚ ÒÖÉÍ ÁÔÚ ËÌÌ ÅÂÍ ÁÚÐÅØ ÇÃÙ ÄÅÉ ÆÅÆ" ÃÄÅÉ ÚØÚÉ ÎÙÅ"Ä ÌÀ ÎÇÎÉØÉÏ ÌÅÎØ ÁÇÃÙ ÙÉÅÇÕ ÎÙÀ"Ë ÌØÁÉ ÃÑÁØ ÙÁÇ ÒÖÉÍ ÁÔÚ ÅÂÍ ÁÚÐÅØ ÅÌÀ ÐÙÀØ Ø× ÄÉÚØ ÃÆÅÆ" ÎÙÅ"Ä ÂÍ ÇÃÙ ÉÅÚÕ ÀÌÀ ÀÉ ÀÎØÉÐÏ ÃÁÌÅÇÙÅÚ ÔÌÉÂÅ À"Ù ÃÄÀ ÂÍ ÌØÁÐÏ ÁÚÐÅØ ÇÃÙ ÄÅÉ ÙÁÇ ÀÁÅ×Ä ÁÅ ÅÌÉËÀ ËÉ ÀÍ ÆÅÆ" ÌÇÅà ÅÙÔÉØ Î×ÙÄ ËÎÅ ÌØÁÐÏ ÁÁØÉÉÚÀ ÇÃÙ ÉÅÖÏ ÂÍ ÌØÁÉ ËÏ ÄÅÀ ÎÙÀ"Ë ÀÉ ÀÎØÉÐÏ ÁÀÁÅ×Ä ÔÌÉÂÅ ÁÅÃÀÉ ÉÙ ÌÀÅ×ÎÉ ÁØÉÉÚÀ ÃÉÅÚÕ ËØÁÉ ÅÁØÉÉÚÀ ÃÉÅÖÏ ËØÁÐÏ ÅÎÆÄ ØÀÉ' ÌËÀÅØÄ ÌÄØÀ"Ù ÅÁÒÄ"Î ÃÁÌÅÇÙÅÚ ÔÌÉÂÅ ÅÁÀÁÅ×Ä ÌË"Ò ÀÑÅØ, ÅÁÆÄ À"Ù ÄÀ ÃÀÎØ ÙÎÅÀÌ ÉÅÚÕ ÅËÁØ ÒÎà ÁÔÐ"É ÅÖÌ"Ç ÃÄÀ ÙÎÅÀÌ ÑÁØ ÆÅÆ" ÎÅÚØ ÅËÉÅÏ ÃÐ×È ÄÁØÉÉÚÀ ÌÄÌËÚÀ ÃÎÙÅ"Ä ÀÔÉ× ÄÁØÉÉÚÀ ÀÎÀÉ ÀÎØ ÉÅÚÕ ÅËÚÁ ÁÔÐ"É ÃÙÎÅÀÌ ÑÁØ ÃÆÄ ÄÅÉ ÌËÚÇÉÌÄ ÀÌÀ ÃÎÇÅÑØ ÄÁÐÄ ÌËÀÅØÄ ÃÄÀ ÚÐÉ ÁÁØÉÉÚÀ ÇÃÀ ÃÇÃÙ ÉÅÖÏ ÅÃÅÇ× ÌÅÎØ ÃÔÌÉ ÁÑÁØÀ ÒÌ ÄÁØÉÉÚÀ ÅÌÔÎ"Ù É"Ì ÃÙÎÅÀÌ ÑÁØ ÁÀÁÅ×Ä ÔÌÉÂÅ ÅØÁÐÏ ÌÉÚ ÌÄÅ ÙÁÇ ÒÖÉÍ ÅËÉÅÏ ÃÚØÅÅÉÉÄÅ Ì×ÅÌÀ ÀÉÏ ÙÁÇ ÒÖÉÍ ÅÂÍ ÆÅÆ" ÌÀ ÎÇÎÉØÉÏ ÌÅÎØ ÉÅÚÕ ÎÙÀ"Ë ÁØÉÉÚÀ ÃÉÅÚÕ ËØÁÉ ÃÌÉËÀ Ø× ÇÃÀ ÌÄÉÚØÀ ÅÄÙ"Ñ Î×ÙÄ ÅÀÆÉÌ ÌÎ"à ÁÂÇÌÉÍ ÌÅÇÙÚ ÔÌÉÂÅ ÀÁÌ ÙÎÅÀÌ ÑÁØ ÁÀÁÅ×Ä ÔÌÉÂÅ ÅËÉÅÏ ÃÑÁØ ËØÁÉ ÃÙÁÇ ÒÖÉÍ ÎÄ"È ÑÁØ ÐÎÉ ÉÅÚÕ ÅÀ"Ù.À) ÄÂØÙÆ"À ÆÖ"Ì (ÙÅÌÇÏ ÙÌÎÄ Ñ"× Ä') ð "Ö"Ò ÀÍ ÎÅÚØ ÌÄÀËÉÌ ÁÄÎÄ ÙÌ ÂÅÉ, ÃÀÓ ÙÄÅÀ ÙËÉØÅ Î"Î ÁÙÁÚ ÀÑÅØ ÅØ× [ÁËÌÁ ÄÚØÐÅ] ÎÔÐÉ ÙÎÅÈÌ ÒÌÉÅ [ÎÆÅÐÅÚÉÅ ËÎ"Ù ÁÙÅ"Ò.] ÅÒË"Ô ÌÒÙÅÚ ÌÅ ÈÅÁÄ ÀÅ ÌÄÀËÉÌ ÁÄÎÚ ÄÔר ÀÑÅØ".ÎØÇÉ×ÉÏ ÀÚ ÄÑÅÌÍ ÎÏ ÄÙÅÁÊ ÀØÁÒ ÀÎÅÚ ËÃÉ ÙÌÀ Ú×ÔÅÕ ÄÐÎÉÉÄ ÅÀ×ÙÉÐÏ ÒÌÄ ÌÉÎÀ ÎÚÐÉÚÉÏ ÃÌÀ ËØÁÉ ÉÅÑÉ ÅËÅ' ÅËÚÁ ØÁÉÐÅ ÙØÉØÀ ÄËÀ ÀÉÚ ×ÃÎÐÀ ÁÒÉÀ ÁÎÚÉÁÚÀ ÃËÌÄ ÁÀÃØ ÙÐÚ ØÔ"à ËÃÚÐÉÐÏ ÌÄÃÉÏ ÔØ×À ÎËÃÉ ÎØÉÙ ÔØ×À ÅÒà ÄËÀ ÁÀØÇÅ×É ÄÆÉ×À ÒÑÉ×ÉÐÏ ÎÀÉ ÙÐÀ ÃÙÁ×ÉÄ Òà ÄËÀ. ÅÔÉØÙ Òà ÄËÀ ÁÂÔÚ ÅÆÁÌ ÅÎÌÇ ÅÑÉà ÅÑÌÒÉÍ ÅÆØÒÉÍ ÅÎÇØÉÙÄ ÅÎÉ ØÂÌÉÍ ÅØÉÇÉÍ ÅÚÐÅØ ÅÇÐÅÚ ÅØÔÚ Áר Å×ÅÌ ÄÐËÐÑÉÏ ÅÄÉÅÖÀÉÏ ÅÑÎÉËÚ ËÅÚÌ ÎÙÅÍ ÃÅÙÀ ÅÇÌÅÐÅÚ ÎÙÅÍ ÄÉÆ× ØÀÉÄ ËÅÌÄÅÏ ÂÉØÉ ÃÙËÉÇ ÄÆÉ×À ÀÉÐÅÏ ÅËÉÅÏ ÃÀÚÀ ÌÑÅÌÍ ÃÌÉËÀ ÄÉÆ× ÁÑÅÌÍ ÀÖÈØÉÊ ÌÎÉÎØ ÌÉÎÀ ÎÚÐÉÚÉÏ ÃÌÀ ËØÁÉ ÉÅÑÉ ÅÎÚØÕ ÌÄ ÎÙÅÍ ÂÉØÉ. ÅØÁÉÐÅ ÇÐÐÀÌ ÅØÁÉÐÅ ÀÌÔÑ ÁÚØ ÄÀÉ ÈÒÎÀ ÀÆÌÉ ÃËÅÌÄ ÎÚÐÉÚÉÏ ÎÙÅÍ ÂÉØÉ ÅÌÀ ÃÎÉ ÌÀÉÌÏ ÃÁÒÉÃÐÀ Ã×À ÐÈÒ ÌÉÚÐÄÅ ÌÙØÙÉÍ. Å×ÙÉÀ ÌÏ ÁÄ ÈÅÁÀ ÃÀÎÚ ÄÎÉÍ ÅÐÁØËÚ ÄËÅÁÑÉÏ ÎÉÚÍ ÚÉÉÎÉ ÎÉÀ ËÉ ÄÉËÉ ÃÀÎØ ØÁÉÐÅ ÁÎÙØÄ ÅÉØ× ÅÆØÒÉÍ ÙÎÇÌÉÃÉÏ ÀÚ Äר×Ò ÅÂÔÚ ÅÆÁÌ ÃÎÙÅÍ ÄÁÌÀ ÐÉÐÄÅ ÁÚØ ÙÒÚÀ ÄÅÀ Ã×À ÎÑ×É ÌÄ ÅÇÐÅÚ ÅÚÐÅØ ÐÎÉ ËÄÐÊ. ÅÎÑÚÁØÀ ÃËÌÄÅ ÄÐÊ ÃÚÐÉÐÏ ÁËÅÌÉÄ ÔØ×ÉÏ ÎÙÅÍ ÎÎÅÐÅ ÄÅÀ ÙÎÆÉ× ÎÎÅÏ ÇÁÉØÅ ÅÌÀ ÃÎÅ ÌÀÉÌÏ ÅÁÅØ ÃÙØÙÉÍ ÔÐÉÍ ÇÃÙÅÚ ÁÀÅ ÌËÀÏ ÅËÑÅÌÍ ÄÅÀ ÃÃÎÅ ÙÄÙØÙÉÍ ËÐÎÉÄ ÅÀÅ×ÉÎÐÀ ËØÁÉ ÉÅÑÉ ÅÎÙÅÍ ÂÉØÉ. ÅÎØÇÉ×ÉÏ ÀÚ ÄÙÅÁÊ ÎÏ ÄÒÉØ ÅÀÚ ÄÀÉÌÏ ÎÏ ÄÒÉØ ÅÀÚ ÄÎÙØÄ ÎÏ ÄÉØ× ËÅÌÏ ÎØÇÉ×ÉÏ ÎÙÅÍ ÎÎÅÐÅ. ÅØÁÉÐÅ ÙÌÎÄ ÔÉØÙ ÃÈÅÁÀ ÀÉËÀ ÁÎÚÐÉÚÉÏ ÃÌÀ ËØÁÉ ÉÅÑÉ Å×ÀÎØ ÌÉÎÀ ÀÓ ÆÅ ÃÌÀ ËØÁÉ ÉÅÑÉ ÅÎÚØÖÉÐÏ ÌÄ ËØÁÉ ÉÅÑÉ ÅÎÙÅÍ ÂÉØÉ ÄÌËÊ ÌÔÉØÅÙÀ ÃÉÌÉÄ ÀÉËÀ ÌÔØÅÙÉ ÄÉ ÐÉÐÄÅ ÂÉØÉ ÅÌÀÅ ÂÉØÉ ÅÌÀÑÅ×ÉÐÄÅ ÀÌÉÁÀ ÃÄÌËÚÀ. ÅÁÐÅÑÇÀ ÒÚÉ×À ÃÉÌÏ ÌÀ ÂØÑÉÐÏ ÌÉÎÀ ÎÚÐÉÚÉÏ ÃÌÀ ËØÁÉ ÉÅÑÉ ÅÄËÉ ÀÉÚÄ ÀÓ ÒÌ ÂÁ ÃÀÎØ ØÁ ÉÄÅÃÄ ÀÎØ ÙÎÅÀÌ ÄÌËÄ ËØÁÉ ÉÅÑÉ ÀÎØ ØÁ ÀÙÉ ËÉ ÄÅÉÐÏ ÁÉ ØÁ ËÄÐÀ ÀÎØ ÌÏ ÎÅÃÄ ØÁÉ ÉÅÑÉ ÁÂÉØÉÄ ÅÆÎÐÉÏ ÃÁÄÃÉ ÃÎÅÚÉÁ ÌÉÄ ÅËÅ'. ÅËÚÁ ØÁÉÐÅ ÙØÉØÀ ÂØÎÀ ÃÂÉØÉ ÉÙ ÁÄ ×ÅÙÉÀ ÃÀÎØÉÐÏ ÎÅÃÄ ØÁÉ ÉÅÑÉ ÁËÅÌÉÄ ÔØ×ÉÏ ÅÎÅÃÄ ÁÎÙØÄ ÅËØÉÙÉÏ ÅÀÎØÉÐÏ ÁØÉÙ ÔØ×ÉÏ ØÁÉ ÉÅÑÉ ÌÃÁØÉÄÏ ÃØÁÐÏ ×ÀÎØ ÌÄÅ ÌÃÉÃÉ ÀÔÉÌÅ ÎÙØÄ ÅÉØ× ÌÀ ÁÒÉ ØÇÅ×É ÅÎÂÅ ÃÔÌÉ ÁÄÐÉ ÔÌÉ ÁËÅÌÉ ÔØ×À ÅÎÔØÙ ÁÈÒÎÀ ÃÎÉÌÚÀ ÔÌÉ ÅÌÀ ÁÒÉר ÃÉÐÀ. Å×ÙÉÀ ÌÉÄ ÌØÁÉÐÅ ÀÌÔÑ ÄÀÉ ÔÉØÅÙÀ Å×ÀÎØ ÎÙØÄ ÅÉØ× ÌØÁÉ ÉÅÑÉ ÃÌÀ ÁÒÉ ØÇÅ×É ÎÙÅÍ ÃÌÉËÀ ÂÉØÉ ÃÎÉÀ ÎÉÚÍ ÚÉÉÎÉ ÅÄÃØ ÀÆÌÉ ÅËØÙÉÏ ÄÆÉ×À ÃÌÀÇØ ÆÎÏ ÄÅÀ ËÙØÙÉ ÀÉÌÏ. ÅËÉ ×ÀÉ ÁÔÑ×À ÃÇØÃÌ ÀÎØ ÎÉÄÅ ÖØÉÊ ÌÀØÇÅ×É ÎÙØÄ ÅÉØ× ËÉ ÄÉËÉ ÃÌÀ ÌÉÄÅÉ ÂÉØÉ ËÉ ÄÉËÉ ÃÎØÇÉ×ÉÏ ÙÉÇ ÅÎÒØÄ. ÅÄÀÉ ÔÉØÅÙÀ ÌÀ ÀÉÚÁØØ ÂÁÏ ÄËÀ ÀÎØ ÎÉÚÍ ÚÉÉÎÉ ÎÉÀ ÅÄËÀ ÀÎØ ÃÁÒÉ ØÇÅ×É ËÉ ÄÉËÉ ÃÌÀ ÌÉÄÅÉ ÂÉØÉÄ ËÙÉÇ ÅÎÒØÄ. ÄÀ ÌÀ ÃÎÉ ÌÙÉÇ ÅÎÒØÄ ÃÄÚÍ ÀÉËÀ ËÅÚÌ Ã×ÙÉ ÌÉÄ ÎÚÅÐÀ ÄËÀ ÌÉËÀ ËÅÚÌ. ÅÚÅ ÀÎÚ ÄÎÉÍ ÐÎÉ ÄÀ ÎÉÚÍ ÚÉÉÎÉ ÎÉÀ ÐÉÎÀ ÃÌÀ ËØÁÉ ÉÅÑÉ. ÅÚÅ ÀÉ ÁÎÙØÄ ÅÉØ× ÌÉËÀ ÂÉØÉ ÀÁÉÉ ÄÉËÉ ÎÚØÕ ÌÎÚÐÉÚÉÏ ÀÌÉÁÀ ÃØÁÉ ÉÅÑÉ ÃÔÌÉ ÁÇØÃÌ ÅÎÅÃÄ ÁÎÙØÄ ÅÉØ× ÄÀ ÌÀÅ ÂÉØÉ ÐÉÐÄÅ. ÅÎÑÚÁØÀ ÃÄÀ ÃÀÎØÉÐÏ ÌÃÉÃÉ ÀÔÉÌÅ ÎÙØÄ ÅÉØ× ÌÀ ÁÒÉ ØÇÅ×É ÎÙÅÍ ÃÌÀ ÎÚÅ×ÎÀ ÎÚÐÉÚÉÏ ÀÌÀ ÁÌÅ×Ç ÅØÁÉÐÀ ÀÙÉÐÅÉÀ ÃØÁ ÔÔÀ ÑÎÊ ÅÁËÌÄÅ ÐÅÑÇÀÉ ÌÀ ÂØÑÉÐÏ ÀÌÀ ÅÄËÉ ÂØÑÉÐÏ ÀÎØ ØÁÉÐÀ ËÌ ÄÎÆÉ× ÒÌÉÅ ÌÄØÇÉ× ÀÚ ÒÖÎÅ ÅÀÔÉÌÅ ÌÅ×Ç. ÅØÁÉÐÅ ÙÌÎÄ ÄËÉ ÎÔØÙ ÌÄ ËÌ ÄÎÆÉ× ÒÌÉÅ ÌÄØÇÉ× ÀÚ ÒÖÎÅ ÀÓ ÒÌ ÔÉ ÙÚÇÉÌÚÅ ÁØÙÅÚ ÅØÁÉ ÉÅÑÉ ÑÁØ ËÌ ÄÐÉÆ× ÀÔÉÌÅ ÀÉÐÅ ÌÅ×Ç. ÅÄÌËÊ ÁÌÅ×Ç ÎÙØÄ ÅÉØ× ÁÒÉ ØÇÅ×É ÄÀ ÌÀÅ ÌÅ×Ç ÎØÇÉ× ÎÙØÄ ÅÉØ× ÅÃÉÐÉÉÄÅ ËËÅÌÄÅ ÄØÇ×ÅÚ ÃÎÚÐÉÚÉÏ. Å×ÉÉÎÀ ÌÏ ËØÁÉ ÉÅÑÉ ÃÄÀ ×ÉÎÀ ÌÏ ÃÈÅÒÐÉÏ ÌÌÅ×Ç ËÃÚÐÏ (Ë"Â.) ÀÍ Ì×ÇÅ ÀÔÉÌÅ ÁÉÚ ØÅÁÒ ÄØÉ ÄÅÀ ÁÇÆ×ÚÅ ÅØÁÉÐÅ ÀÌÔÑÉ ÁÌÅ×Ç ÎÅ×ÉÍ ÌÄ. ÅØÁÉÐÅ ÀÃÅÐÉÐÅ ÀÁÉÐÅ ÄËÉ ÎÔØÙ ÌÄ ÅÒÌ ËØÇÉÏ ÎÃ×ÀÎØÉÐÏ ËÃÀÎØ ØÁ ÔÔÀ ÁÌÅ×Ç ÙÎÒ ÎÉÐÄ ÄËÉ ÎÉÚØÖÀ. ÅËÌÄÅ ÔØÅ×É ÃÔØÉ× ØÁÀ ÌÒÉÌ ×ÉÉÎÉ ÅÄÌËÚÀ ËÅÚÉÄ ÅÄÁÀ ÌÑÎÅÊ ÀÉÐÅ ÑÅÎÊ ÌÀ ÙÐÀ ÀÉÚÉÄ ÌÐÉÆ× ÅÌÀ ÙÐÀ ÌÉÚÉÄ ÌÁØ ÎØÔÚ ÃÀÎØÉÐÏ ÄÚÍ ÃÉØÄ ÙÀÐÉ ÅÌÁØ ÎÀÉÌÏ ÅÇØÃÌ ÌØÁÉ ÉÅÑÉ ÀÉÌÏ ÎÙÅÍ ÃÁÒÉÃÐÀ Ã×À ÐÈÒ ÌÉÚÐÄÅ ÌÙØÙÉÍ ÅÇØÃÌ ÎÙÅÍ ÃÚØÅÅÉÉÄÅ ÎÆ×É ÀÄÃÃÉ ÅËÏ ÄÌËÚÀ. ñ ÅÎÑÔ×À ÌÉ ÙÉÒÅØÀ ÃÄØÇ×Ú ÎÙØÄ ÅÉØ× ÃÌÀ ÚÐÏ ÁÎÚÐÉÚÉÏ ÅÎÀÉ ÙÐÀ ÃÙÁ×ÉÄ ÌÙÉÒÅØÀ ñ ÅØÁÉÐÅ ÙØÉØÀ Ã×ÀÎØ Ã×ÅÙÉÀ ÁÚØÀ ÃØÁÀ ÌÀ ÐÎÖÀ ÌÔØÅ×Ä ÅÙÁÒÄ ×ÅÙÉÉÏ ÃØÁÀ ÒÎÃÅ ÇÎÙÄ ÎÄÏ ÅÁÈÌÅ ÄÔÉØÅ×ÉÏ ÙÔØ×Å ÅËÅÌÄÅ ÀÔÉÌÅ ÌØÁÐÏ ÈÒÎÀ ÃÀÉËÀ ËÅÌÄÅ ÄÀ ÌÉËÀ ÑÎÉÊ ÅÄÙÐÉÍ ÌÀ ÁÈÌÅ Å×ÀÎØ ÎÙÎÉÄ ÃÂÀÅÏ ÀÁÉ ÀÁÉÅ ÃÄÀ ÃÀÁÉÉ ÅØÁÀ ÌÀ ÀÔÙÉÈ ÅÌÀ ÙÎÒÉÐÏ ÎÙÎÉÄ ÃÂÀÅÏ ËÎÀÏ ÒÁÃÉÐÏ. ÅÀÉÚ ÎØÁÐÏ Ã×À ÑÌ×É ÃÒÚÄÅÏ ÃÄÌËÄ ËÀÁÉÉ ÃÄÀ ÀÚ×ÙÅ ÌØÁÀ ÅÁÈÉÌÅ ÔØÅ×É ÎÉÄÅ ÒÁÃÉÐÏ ËØÁÀ. ÅÚÎÉÄÀ ÌÏ ÁÔÉØÅÙÀ ÃÉÌÉÄ ÅÁÔÉØÅÙ ØÁÉÐÅ ÇÐÐÀÌ ÃÐÈÉÀ ÌÑÁØÀ ÃÉÌÉÄ ÃÀÎØ ÀÓ ÒÌ ÂÁ ÃÄÐÉ ÙÉÐÅÉÉ ÃÙÐÉÐÄÅ ØÁÀ ÌÉÚÐÄÅ ÅÃÇÉÉÚÀ ÐÉÐÄÅ ÎÉÄÅ ÁÁÅØ ×ÉÉÎÀ ÌÏ ËØÁÀ. ÅÀÐÏ ËÚÁÉÐÏ ÎÀÉ ÃÑÁÉØÀ ÌÏ. ÅÔÑ×À ÃËÚÁ ØÁÉÐÅ ÀÌÔÑ ÁÇØÃÌ ÄËÉ ÀÉÚÀ ÅÁÄËÉ ÎÚØÖÀ ËÅÌÄ ÅÀÔÙØ ÃÄÄÅÀ ÑÉÅÎÀ ÁÚØÀ ÒÉר ÅÄÉÀ ÎÏ ÄÄÂÄÅÚ ÙÄÂÉÄ.ÙÉËÅÌ ÌÅÎØ. ÀÔ"Ä ÎÉÂÅ ÀÉËÀ ÃÎÀÉ ÌÀ ÁÒÌÚÉ Ã×ÀÎØ ÄÉÒØÚÉ ÀÁÌ ÌÀ ÂÎØÚÉ ÄÁÉÀÄ ÅÁÙÔÇÄ ÇØÅÔÄ ÀÉÐÅ ÇÉÉÁ ÀÌÀ ÒÌ ÄÂÎØ ÁÉÀÄ ÃÙËÁÚ ÆØÒ ËÚÉÁ:ÑÌÉ×À ÇÉ' Ô' ÄÀÅÎØ ÁÒÆÄ"É, ÁØÉÊ ØÇÎÐÀ ÃÑÉÉÒÏ Òà ËÀÏ. ÄÅÀ ÉÒÆØÐÉ ÁÔØ×É' ÄÁÀÉ' ÌÃØÅÙ ËÎÉÏ ÇÅÎØ' ÉÅÍ ÌÉÅÍ ÌÄÁÉÒ ÀÅÎØ:ÄÐÅÃØ ÎÏ ÄÎÆÅÏ ÅËÅ'. ÅÁÉØÅÙÌÎÉ ÅÎÐÉÏ ÙËÌ ÄÃÁØÉÍ ×ØÅÉÉÏ ÎÆÅÏ ØÁ ÀÇÀ ÁØ ÒÅÌÀ ÀÎØ ÅÒÙØ ÀÚÅÐÅÚ ÐÅÙÀÅÚ ÁØ ÅÌÇÍ ÅÎÆÅÏ ÎÄ Ú"Ì ÎÆÅÏ ÀÌÀ ÎËÀÏ ÙËÌ ÄÃÁØÉÍ ×ØÅÉÏ ÎÆÅÏ Ò"Ë. ÅÀÉÚÀ ÐÎÉ ÙÍ Ø"Ô ÄÐÅÃØ ÎÏ ÄÎÁÅÙÌ ÅÁÔ" ÎÉÐÉÏ: ÌÀ) ÌËÀÅØÄ ÐÅËÌ ÌÄ×ÙÅÚ ÒÌ ÚÉØÅÖÉ ÃÄÐÄ ÁÔ"À ÃËÌÀÉÍ ÁÉØÅÙÌÎÉ (ÄÌËÄ À') ËÚÁ ÅÆ"Ì ËÚÉÁ ÙÃÊ ÌÀ ÚÆØÒ ËÌÀÉÍ ÄÉÉÚÉ ÀÅÎØ ÀÔÉÌÅ ÙÐÉ ÎÉÐÉ ÇÈÉÍ ÅÀÔÉÌÅ ÙÐÉ ÎÉÐÉ ÙÒÅØÉÍ ÁÄÎÚÊ ÌÀ ÚØÁÉÒ ËÌÀÉÍ ÄÉÉÚÉ ÀÅÎØ ÀÔÉÌÅ ÙÅØ ÙÇÅØ ÒÌ ÂÁÉ ÙÅØ ÌÁÏ. ÀÅ ÙÅØ ÌÁÏ Ò" ÙÅØ ÙÇÅØ ÅÁÂà ËÌÀÉÍ ÌÀ ÉÒÌÄ ÒÌÉÊ ÄÉÉÚÉ ÀÅÎØ ÙÐÉ ÎÉÐÉ ÖÎØ ÅÀÔÉÌÅ ÙÐÉ ÎÉÐÉ ÔÙÚÏ. ÔÉØÅÙ ÁÁÂÃÉÍ ÌÀ ÚÌÁÙ ÙÒÈÐÆ ÖÎØ ÅÔÙÚÉÍ ÉÇÃÉÅ ÎÄ ËÌÀÉ ÁÂÃÉÍ ÙÀÑØÚÉ ÌÊ ÙÐÉ ÎÉÐÉÏ ÌÀ ÆÄ ÎÎÉÏ ÆÄ ÅÌÀ ÆÄ ÎÎÉÏ ÆÄ ÀÓ ËÌÀÉÍ ÙÀÑØÚÉ ÌÊ ÁË"Î ÌÀ ÆÄ ÎÎÉÏ ÆÄ ÅÌÀ ÆÄ ÎÎÉÏ ÆÄ ÒË"Ì. ÅÉÒ"Ù ÁÉØÅÙÌÎÉ ËÌÀÉÍ (Ô"À Ä"Æ) ÙÌÎà ËÏ ÂÍ ÌËÌÀÉ ÀÉÌÏ ÉÒ"Ù. À"Ë ÐØÀÄ ÃÐÌÎà ËÌÀÉ ÀÉÌÏ ÎËÌÀÉ ÁÂÃÉÍ À"Ë ÐÌÎà Â"Ë ÆÄ ÎÆÄ Î×"Å Ë×ÙÉÚ ÄÁÉÚ ÀÔØÉÍ. ÀÅÌÍ ÁÀÎÚ ÀÉÐÅ ÄÙÂÄ. ÃÃÅ×À ×ÅÌÀ ÐÅËÌ ÌÌÎÅà ÙÍ ËÉÅÏ ÃÇÆÉÐÏ ÁËÌÀÉ ÁÂÃÉÍ ÃÄÀÉÑÅØ ØÁÉÒ ÒÌÉÄ ÌÒÅÌÍ ËÌ ÆÎÏ ÙÎÒÅØÁÉÍ ÅÀÔ"Ä ÃÅ×À ÖÎØ ÅÔÙÚÉÍ ÀÁÌ ÖÎØ ÀÓ ÙÄÍ ÙÐÉ ÎÉÐÉÍ ÌÀ ÀÑØÄ ÄÚÅØÄ. À"Ë Ë"Ù ÁËÌÀÉ ÀÉÌÏ Ã×ÉÌ ÃÇÆÉÐÏ ÃÄÚÅØÄ ÌÀ ×ÔÃÄ Ø× ÒÌ ÙÒÚ ÄÒÉØÅÁ ËÐ"Ì ÅÌÀ ÀÇ"Ë Ë"Ù ÃÎ×ÉÌÉÏ ÁÉÄ ËÙÀÉÐÍ ÙÐÉ ÎÉÐÉÍ. ÀÁÌ ÌÌÎÅà ÎÄ×"Å ÇÅÎØÀ ÌÀ ÐÅËÌ ÃÉÙ ÌÃÇÅÚ ÃÌÀ ÃÎÉ ÀÄÃÃÉ ËÐ"Ì:À¡Ì©Ä¥ÉÐŬ Ù±¦Á¬§Ù¬±¨Î§É¤Í ¬§Ì¬¥Ä ˬ Áũà Χ̠ËŬڠʨ Ҩ̥ÉÐŬ ΠĥبÄ:ÄÂÎØÀ ÃÅÇÄ ÄÅËÇÄ ÆÅ ÄÀÇØÅÐÄ: ÌÀ! ÀÉÏ ÎËÀÏ ØÀÉÄ, ËÉ ÌÒÅÌÍ (462) ÎÃÁØÚ ÄÁØÉÉÚÀ ÌÒÐÉÏ ËÔØÄ, ÅÌÀ ÌÒÐÉÏ ÚÎÅØÄ. ÅÃ×À ×ÙÉÀ ÌÊ, ÅÒÌ ÎÄ ÙÄ×ÙÉÚ, ÙÌÒÐÉÏ ËÔØÄ ÀÉÏ ÁËÊ ÙÅÍ ÇÉÃÅÙ, ËÉ ÎÚÐÄ Ã×À ÉÄÁÉÏ ÌÉÄ, ÅÒÚÄ ÄÅÀ ÙÌÅ -

ÉÂ

ÅÁÐÚÏ ÄÅÀ ÅÀÎØÄ ÄÉÀ, ÌÄØÎÁ"Í ÌÀ ÎÄÐÉ ÁÎÃÁØ ÒÎÄ ÚÇÌÄ ÁÒÑ× ×ÃÅÙÉ', ÎÃÌÀ ÎÇÌ× ËÀÏ, ÅÌÀ ÀÎØÉÐÏ ÃÑÎÉÊ ÒÌ Î"Ù Ì×ÎÏ, ÎÀÇØ ÃÄÃÉÏ ÐÅÚÏ ÌÇÌ× ÁÉÏ ÄËÀ ÅÁÉÏ ÄÄÉÀ ÃÌ×ÎÏ ÅËÐ"Ì. ÎÙÀ"Ë ÌÄØÉ"Ó É"Ì ÃÑÁÉØÀ ÌÉ' ËÄØÀ"Ù ÁÆÄ, ÎÃÄÁÉÀ ËÀÏ ÎÉÎØÀ ÃÎÒÙØ ÙÐÉ ÃÎÃÁØ ÒÎÄ ÒÌ ÒÑ× ×ÃÅÙÉ' ÎÄÐÉ, ÅÄ"Ä ÁÙÚÉ×Ä, ÙÎÒ ÎÉÐÄ ÃÑÁÉØÀ ÌÉ' ÃËÀÏ ÌÀ ÂØÒ ÀÎÉØÚÄ ÎÙÚÉ×Ä ÅËÄØÀ"Ù ÄÐ"Ì.ÄØÁ ÉÒ×Á ÙÅÌÁÉÕ ÙÌÉÈ"ÀÎÎÀÉ ÃÂÁØÀ ÌÀÅÑÅÔÉ ×ÎÉËÅÉÏ. ÀÔÉÌÅ ÌÎÀÏ ÃÀÎØ ÁÔ' ÁÚØÀ ÃÒÉØÅÁÉÏ (ÃÓ ×.) ÃÌÒÁÅØ ÎÙÅÍ ÁÌ ÚÅÑÉÓ ÌÀ ÁÒÉ ËÅÅÐÄ ÅÎÙÎÒ ÐÎÉ ÁÄÄÅÀ ÔÉØ×À ÃÌØÁÉ ÉÄÅÙÒ ÌÀ ÁÒÉ ËÅÅÐÄ Î"Î ÄËÀ ÎÅÃÄ ÃÌÉËÀ ÁÌ ÚÅÑÉÓ ËÉÅÏ ÃÌÁÈÅÌÉ ×ÎÉËÅÉÏ:ÅÌÒÐ"à ÉÅÚØ ÐËÅÏ ÌÔØÙ ËÔÉ ÙÉÈÚ ÄÙ"Ê ÄÐ"Ì Ù×ÀÉ ÀÁÉÖÉÍ, ÀÊ ÐÔØÙ ËÎÅ ÙÔÉØÙ"É ÁÌÙÅÏ ÄÙÐÉ, ÙËÏ ËÅÅÐÚÅ ÙÌ Ø" Á"Ø, ÀÁÀ ÌÀ. ÙÉÒØ ÁÎ"Æ ÙÌÀ ÑÎÊ ÌÄÚÉØ ÒÌ ÙÉÒÅØ Î"Æ ËÉ ÀÉÐÅ ÒÅÌÄ ×ÌÉÔÅÚ ÙÌ Î"Æ Òà ÙÉÄÉÅ ËÑ"À ÁÌÀ ×ÌÉÔÅÚ, ÅÀÐÉ ÀÙÒØ ÁÎ"Ä ÁÚÎÉÄ, ÀÉÊ À×Ì ËÌ ËÊ, ÅËÏ ÉÚÔØÙ ÎÄ ÙÀÎØ Ø' ÙÎÒÅÏ Á"Ø, ÀÁÀ ÌÀ ÙÉÒØ ÁÎ"Ä ÅÀÐÀ ÀÙÒØ ÁÎ" Â"Ë ËÀÅÔÏ ÆÄ, ÙÄØÉ ÙÀÁÀ ÌÀ ÑÎÊ ÒÌ Î"Ä ÙÉÒÌÄ ÌÑ"À ÅÀÐÀ ÀÙÒØ ÁÎ"Â. ÅÄÐÐÉ ÌÁÀØ ÎÄ ÙÐØÀÄ ÌÒÐ"à ÌÅÎØ ÁÎÀÉ ÔÌÉÂÉ Ø' ÂÎÌÉÀÌ ÅØ' ÙÎÒÅÏ ÆÄ ÀÎØ ÀÁÀ ÌÀ ÙÉÒØ ÁÎ"Æ, ÅÆÄ ÀÎØ ÀÁÀ ÌÀ ÙÉÒØ ÁÎ"Ä, ÅØÀÙÉÚ ÀÅÎØ ÙÎÃÀÎØ ÀÁÀ ÌÀ ÙÉÒØ ÁÎ"Æ ÎÙÅÍ ÙÎ"Æ ÀÉÏ ÒÅÌÄ ÌÑ"À ÁÌÀ ×ÌÉÔÅÚ ÎËÌÌÀ ÎÅËÇ ÙÁÎ"Ç ÎÙÒØÉÐÏ ÙÆÄ ÒÅÌÄ ÙÉÄÉÄ ËÇÙÁÅÏ Ñ"À ÁÌÀ ×ÌÉÔÅÚ, ÅËÏ ÌØ' ÙÎÒÅÏ Á"Ø ÃÀÎØ ÀÁÀ ÌÀ ÙÉÒØ ÁÎ"Ä, ÎÅËÇ ÎÆÄ ÃÑÁØ ÙÁÎ"Å ÄÉÄ ÎÙÒØ, ÅÐÎÖÀ ÌÔÉ ÇÙÁÅÏ ÆÄ ÀÌÉÁÀ ÃØ' ÂÎÌÉÀÌ Á"Ø ÃÀÎØ ÀÁÀ ÌÀ ÙÉÒØ ÁÎ"Æ ÀÁÌ ÁÎ"Ç ÙÔÉØ ÎÙÒØÉÐÏ, ÐÎÖÀ ÙÁÎ"Ç ×ÌÉÔÅÚ ÉÒÌÄ ÌÑËÅÍ É" ÁÉÖÉÍ ÁÌÀ ×ÌÉÔÅÚ, ÅÉÄÉÄ ÁÑ"Ä Ñ"À ÁÉÖÉÍ, ÐÎÖÀ ÌÔ"Æ ÁËÌ ÁÉÖÄ Î"Ç ÇÌ×ÉÍ ÎÎÐÄ ÄÅÀ ÄÁÉÖÄ ÁÌÀ Ä×ÌÉÔÄ ÅÙÌÅÙÄ ÒÙØ ÇÌ×É Ñ"À ÄÅÀ Ä×ÌÉÔÄ:ÒÙØ ÎÐÅØÅÚ ÒÙÄ ÙÌÎÄ, ÅÌÀ ÄÉÅ ÎÃÌÉ×ÉÏ ÀÌÀ ÁÙÌ ÎÙÄ, ÙÐÀÎØ: (ÃÁØÉ ÄÉÎÉÍ Á ÉÂ,ÉÀ) [ÅÎ×ÈØÉÍ ÌÄ' ÒÌÅÚ ÁÁר ÁÁר ÅÁÒØÁ ÁÒØÁ Å×ÈØÚ ÑÎÉÍ ÅÎÒØËÚ ÌÇÍ ÒÌ ÄÙÌÇÏ ÄÈÄÅØ Å]ÎÐÅØÚ ÄÆÄÁ ÅÐØÅÚÉÄ ÌÁÒØ ÁÒØÁ [ÁÒØÁ ËÉ ÙÎØÉÍ ÀÐÇÐÅ ÀÚ ÎÙÎØÚ Ä' ÀÌ×ÉÐÅ ÅÀÚÍ ÒÆÁÚÍ ÀÚÅ] ['ÎÐÅØÚ' ÌÙÅÏ ÉÇÉÃ];ÐÙÀÌÚÉ ÀÍ ÄÚÔÌÌ ÁÚÔÌÚ ÙÁÚ ÅÄÚÔÌÌ ÄÁØËÄ ÄÀÎÖÒÉÚ ËÐÅÑÇ ÄØÀÅÉ ÀÊ ÁÄÇÚÉÎÄ ÑÉÉÍ ÅÀÎØ Î×ÃÙ ÉÙØÀÌ ÅÄÆÎÐÉÍ ÀÍ ÉËÅÌ ÌÇÆÅØ ÁÅ ÚÅÊ Ë"à ÅÌÅÎØ Î×ÃÙ ÄÙÁÚ. ÀÅ ÃÖØÉÊ ÌÇÆÅØ ÌØÀÙ. ÅÀÎØÚÉ ÄÐÄ ÁÙÅ"Ò ÅÄÀÇØÅÐÉÍ ÌÀ ÐÎÖÀ ÄÃÉÏ ÄÆÄ ËÄ" ÎÎÙ. ÀÊ ÌÄÉÔÅÊ ÐÎÖÀ ÁÚÅÑ' (ÁØËÅÚ ÃÓ É"Á Ò"À) ÁÙÍ Ø"Ç ÃÀÍ ÄÉÄ ÉÅ"È ÅÑÉÉÍ Î×ÃÙ ÄÙÁÚ ÎÄÐÉ ÚÅÊ Ë"à ÌÑÉÉÍ Î×ÃÙ ÉÙØÀÌ ÅÄÆÎÐÉÍ. ÅÎÅÁÀ (ÁÙÅ"Ò ÀÅ"Ç ÑÉÎÏ ÚÔ"Æ) ÅÔÑ×Å ÙÍ ÃÄÉÉÐÅ ÙÄÉÄ ÉÅÃÒ ÙÄÅÀ ÉÅ"È. Ø× ÙÈÒÄ ÁÌÙÅÐÅ ÎÅÒÉÌ ÚÅÊ Ë"à ÌÇÆÅØ ÅÄÅÀ ÌÙÅÏ ÄÚÅÑ' ÀÇØÉ ÙÄÅÀ ÉÅÃÒ ÙÄÉÅÍ ÉÅ"È ÅÌÔ"Æ É"Ì ÃÄÉËÀ ÙÄÀÃÍ ÁÒÖÎÅ ÄÅÀ ÎÑÅÔ×. ÀÉÊ ÄÉÚÄ ÉÃÉÒÚÅ ÁÙÒÄ ÙÑÉÉÍ ÄÁØËÄ ÉÅËÌ ÌÑÎÅÊ ÃÁÅÃÀÉ ÄÉÚÄ ÉÃÉÒÚÅ ÙÄÅÀ ÉÅ"È. ÀÊ ÎÖà ÃÙÁÚ ÚÃÉØ ÅÙÂÅØ ÁÌÉÙÐÉÄ ÌÅÎØ Î×ÃÙ ÄÙÁÚ ÎÆÄ ÐÎÙÊ ÈÒÅÚÅ. ÅÎÙ"Ä ÄÅÉ ÙÅÁ ËÎÅ ÁÉÅÃÒ ÁÁÉØÅØ ÙÄÅÀ ÄÉÄ ÉÅÃÒ ÙÄÉÅÍ ÉÅ"È ÙÎÅÒÉÌ ÚÅÊ Ë"à ÅÃ"Ì. ÅÄÙÚÀ ÌÔ"Æ ÀÍ ÐØÖÄ ÌÔÙÅÈ ÁÒÉÉÏ ÁÙÁÚ ÄØÉ ÌËÀÅØÄ ÃÎÉ ÌÉÅ"È. ÀÁÌ ÌÔÉ ÃÒÚÉ É"Ì ÃÒ"Ë ÌÀ ÎÃÎÉÐÏ ÀÌÀ ÄÉËÀ ÙÄÉÄ ÉÅÃÒ ÙÄÅÀ ÙÁÚ. Ø× ÈÒÄ ÁÃÁÅØÅ. ÀÆ ÄÅÉ ÄÃÉÏ ËÎÅ ÁÉÅ"È ÃÎÅÒÉÌ ÚÅÊ Ë"Ã. ÀÁÌ ÄÉËÀ ÙÄÀÃÍ ÁÒÖÎÅ ÎÑÅÔ× ÀÍ ÄÉÄ ÉÅÃÒ ÁÑÉÅÍ ÄÁØËÄ ÙÄÉÅÍ ÄÅÀ ÙÁÚ. ÌÀ ÃÎÉ ÆÄ ÌÉÅ"È ÃÁÙÌÎÀ ÁÉÅ"È É"Ì ËÐ"Ì ÃÅÃÀÉ ÉÃÒ ÙÄÉÅÍ ÄÅÀ ÉÅ"È ÀÊ ÙÉÂØÀ ÃÌÉÙÐÀ ÃÙÁÚ ÃÚÃÉØ Ð×ÈÉÄ. ÀÁÌ ÁÙÁÚ ÀÃØÁÄ ÉÙ ØÀÉÄ ÃÄÉÄ ÑÁÅØ ÙÄÅÀ ÉÅ"È. ÃÀÌ"Ë ÎÐÀ ÌÉÄ ÌÈÒÅÚ ÅÌÅÎØ Î×ÃÙ ÉÙØÀÌ ÅÄÆÎÐÉÍ. ÃØ× ÙÌÙ ÔÒÎÉÍ ÁÙÐÄ ÀÅÎØÉÍ ËÏ. ÅÃ"Ì. ÅÄÐÄ ËÌ ÆÄ ÌÔÉ ÄÐØÀÄ ÎÃÁØÉ ÄÚÅÑ' ÅÄÙÅ"Ò ÃÁÒÉÐÏ ÙÉÃÒ ÙÄÅÀ ÉÅ"È. ÀÁÌ ÄÎÂ"À (ÙÍ ÁÑÉÎÏ ÚÔ"Æ Ñ"× Á') ÎÑÉ× ÃÄÌËÄ ËØÅÁ ÄÔÅÑ×ÉÍ ÃÀÔÉÌÅ ÁÑÁÅØ ÙÄÅÀ ÙÁÚ ÐÎÉ ÎÅÒÉÌ ÚÅÊ Ë"Ã. ÅÀ"Ë ÔÙÅÈ ÃÂÍ ËÀÏ ÐÄÉ ÃÉ"Ì ÃÄÉÄ ÑÁÅØ ÁÃÒÚÅ ÙÄÅÀ ÉÅ"È ÀÔ"Ä ÎÅÒÉÌ ÚÅÊ Ë"Ã. ÀÁÌ ÒÃÉÉÏ ÀÉÏ ÙÅÍ ØÀÉÄ. ÃÉ"Ì ÙÀÐÉ ÄËÀ Ã×ÉÉ"Ì ÃÉÅ"È ÀÉ×ØÉ ÐÎÉ ÙÁÚ ÀÁÌ ÙÁÚ ÌÀ ÀÉ×ØÉ ÉÅ"È ÁÙÅÍ Î×ÅÍ. ÀÊ ÌËÀÅØÄ É"Ì ÎÀÉ ÑÔÉ×À ÀÉËÀ. ÄËÉ ÂØÒ ÎÄÀÌ Ä×ÃÅÙ ÅÄÎÌÊ Ä×ÃÅÙ ÁÒÙÉ"Ú ÃÎÅÒÉÌ ÐÎÉ ÚÅÊ Ë"Ã. ËÎ"Ù ÁÀ"Ç ÑÉ' Ú×Ô"Á ÀÁÌ ÁÀÎÚ Ð"Ì ÌÇÃÙ ÁÆÄ ×ÖÚ ÃÒ"Ë ÌÀ ÎÅÒÉÌ ÀÌÀ ÁÙÐÅËÌ ÌÅÎØ ÄÚÉ×ÅÏ ÀÇØ ÄÀÎÉØÄ ËÎÅ ÄÀÌ Ä×ÃÅÙ ÅÌÀ ÖØÉÊ ÌÁÈÌ ÃÁØÉÅ ÄØÀÙÅÐÉÍ. ÅÎÙ"Ä ÀÍ ÀÎØ ÁÉÅ"È Î×ÃÙ ÄÙÁÚ ÉÅËÌ ÌÑÉÉÍ ÒÅà ÅÉÙØÀÌ ÅÄÆÎÐÉÍ ÃÄÀ ÉÅ"È ÀÉ×ØÉ ÙÁÚ. ÀÁÌ ÄËÀ ÁÐ"à ÃÙÁÚ ÌÀ ÀÉ×ØÉ ÆÎÏ ËÌÌ ÖØÉÊ ÌÁÈÌ ÃÁØÉÅ ÄØÀÙÅÐÉÍ ÎÙ"Ä Ð"Ì ÌÄÌËÄ ÃÖØÉÊ ÌÇÆÅØ ÌØÀÙ ÁÚÅØÚ ÐÃÁÄ. ÅÌÀ ÎÅÒÉÌ ÚÅÊ Ë"Ã. ÅÌÀ ÃÎÉ ÌÀÅÎØÚ À"À ÀÐÉ ÅÇÆØÄ ÅÀÎØÄ ÔÐÅÉÄ ÀÐÉ. ÃÄÚÍ ÒÌ ÄÂÉÌÅÉ ÎÄÃÁÅØ ÄÉÉÐÅ ÄÉÀÊ ÄÉÚÄ ÄÎÒÙÄ ÅÄËÀ ÄÃÁÅØ ÖØÉÊ ÁÒÖÍ ÅÃÅ"×:ÉÄÉ ÎÄ ÎËÌ ÎÄ ÙÐÆËØ Òà ËÀÏ ÉÄÉÄ ÀÉÊ ÙÉÄÉÄ, ÒÌ ËÌ ÔÐÉÍ ÐÅÃÒ ÁÀÎÚ ËÉ ÄÀÃÍ ÁÁÇÉØÚ ÎÒÙÉÅ ÐÅÂÒ ÌÎÒÌÄ ÌÎÒÌÄ ÁÂÁÄÉ ÎØÅÎÉÍ, ÅÉÙ ÁÒÁÅÃÄ ÖÅØÊ ÂÁÅÄ, ÅÙÆÄÅ ÚËÌÉÚ ÄÒÅÁà ÌÒÙÅÚ ÄËÌ ÌÙÎÅ ÉÚÁØÊ ÐÇÚ ØÅÇ ÌÉÅÖØÅ, ÌÀ ÌÖÅØÊ ÒÖÎÅ Ì×ÁÌ ÙËØ, ÀÌÀ ÌÎÒÏ ÙÎÅ ÁÀÄÁÄ ÅÑÅÓ ÄËÁÅà ÌÁÅÀ, ËÉ ÁÄÚØÁÅÚ ÄÙÔÒ ÌÎÒÌÄ ÎËÇ ÄÚÒÅØØÅÚ ÄÒÅÁÃ, ÀÆ ÉÅØÃ ÌÎÈÄ ÅÙÌÅÍ ÁËÌ:

ÔØ× Ã

\ No newline at end of file diff --git a/generator/packaging/src/jvmTest/kotlin/io/github/kdroidfilter/seforimlibrary/packaging/CompactDbTest.kt b/generator/packaging/src/jvmTest/kotlin/io/github/kdroidfilter/seforimlibrary/packaging/CompactDbTest.kt new file mode 100644 index 000000000..4d1630901 --- /dev/null +++ b/generator/packaging/src/jvmTest/kotlin/io/github/kdroidfilter/seforimlibrary/packaging/CompactDbTest.kt @@ -0,0 +1,77 @@ +package io.github.kdroidfilter.seforimlibrary.packaging + +import app.cash.sqldelight.driver.jdbc.sqlite.JdbcSqliteDriver +import io.github.kdroidfilter.seforimlibrary.dao.repository.SeforimRepository +import kotlinx.coroutines.runBlocking +import java.nio.file.Files +import java.sql.DriverManager +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertTrue + +class CompactDbTest { + private val texts = + List(300) { i -> + when (i % 3) { + 0 -> "�מר רבי יוחנן משו� רבי שמעון בן יוחי, שורה $i: " + "ו�מר רב� ".repeat(i % 20) + 1 -> "�" + else -> "בר�שית בר� �להי� �ת השמי� ו�ת ה�רץ $i" + } + } + + @Test + fun `the compact database reads as the generator's, its texts compressed`() { + val dir = Files.createTempDirectory("compactdb") + val source = dir.resolve("seforim.db") + val target = dir.resolve("seforim.compact.db") + // The generator's database: the schema, plain TEXT lines (as the databases built so far store them) + JdbcSqliteDriver("jdbc:sqlite:$source").use { SeforimRepository(source.toString(), it) } + DriverManager.getConnection("jdbc:sqlite:$source").use { conn -> + conn.createStatement().use { st -> + st.execute("INSERT INTO category(id, title, level) VALUES (1, 'תנ\"ך', 0)") + st.execute("INSERT INTO source(id, name) VALUES (1, 'otzaria')") + st.execute("INSERT INTO book(id, categoryId, sourceId, title, totalLines) VALUES (1, 1, 1, 'בר�שית', ${texts.size})") + st.execute("INSERT INTO connection_type(id, name) VALUES (1, 'COMMENTARY')") + } + conn.prepareStatement("INSERT INTO line(id, bookId, lineIndex, content, heRef, charCount) VALUES (?, 1, ?, ?, ?, ?)").use { ps -> + texts.forEachIndexed { i, text -> + ps.setLong(1, i + 1L) + ps.setInt(2, i) + ps.setString(3, text) + ps.setString(4, "בר�שית �, ${i + 1}") + ps.setInt(5, text.length) + ps.executeUpdate() + } + } + conn.createStatement().use { st -> + st.execute( + "INSERT INTO link(id, sourceBookId, targetBookId, sourceLineId, targetLineId, targetLineIndex, " + + "targetBookOrderIndex, connectionTypeId) VALUES (1, 1, 1, 1, 4, 3, 999, 1)", + ) + } + } + + compactDb(source, target, pageSize = 8192) + + DriverManager.getConnection("jdbc:sqlite:$target").use { conn -> + fun strings(sql: String) = conn.createStatement().use { st -> st.executeQuery(sql).use { rs -> buildList { while (rs.next()) add(rs.getString(1)) } } } + assertEquals(listOf("8192"), strings("PRAGMA page_size")) + assertTrue("idx_line_heref" !in strings("SELECT name FROM sqlite_master WHERE type = 'index'")) + assertTrue(strings("SELECT name FROM sqlite_master WHERE name LIKE 'sqlite_stat%'").isEmpty()) + assertEquals(listOf("blob"), strings("SELECT typeof(content) FROM line WHERE id = 1")) + assertEquals(listOf("1"), strings("SELECT COUNT(*) FROM link")) + } + JdbcSqliteDriver("jdbc:sqlite:$target").use { driver -> + val repository = SeforimRepository(target.toString(), driver) + runBlocking { + val lines = repository.getLines(1, 0, texts.size - 1) + assertEquals(texts, lines.map { it.content }) + assertEquals("בר�שית �, 1", lines.first().heRef) + assertEquals(texts[3], repository.getCommentariesForLines(listOf(1)).single().targetText) + assertEquals(texts.map { it.length }, repository.getBookCharCounts(1).toList()) + } + } + assertTrue(Files.size(target) > 0) + dir.toFile().deleteRecursively() + } +} diff --git a/generator/packaging/src/jvmTest/kotlin/io/github/kdroidfilter/seforimlibrary/packaging/CompactDbVerification.kt b/generator/packaging/src/jvmTest/kotlin/io/github/kdroidfilter/seforimlibrary/packaging/CompactDbVerification.kt new file mode 100644 index 000000000..56f9012f2 --- /dev/null +++ b/generator/packaging/src/jvmTest/kotlin/io/github/kdroidfilter/seforimlibrary/packaging/CompactDbVerification.kt @@ -0,0 +1,53 @@ +package io.github.kdroidfilter.seforimlibrary.packaging + +import io.github.kdroidfilter.seforimlibrary.dao.text.LineTextCodec +import java.sql.DriverManager +import kotlin.test.Test +import kotlin.test.assertEquals + +/** + * Every line of a compact database against the generator's, byte for byte. Runs only with SOURCE_DB and COMPACT_DB: + * + * SOURCE_DB=build/seforim.db COMPACT_DB=build/seforim.compact.db ./gradlew :packaging:jvmTest --tests '*CompactDbVerification*' --rerun + */ +class CompactDbVerification { + @Test + fun linesReadBack() { + val source = System.getenv("SOURCE_DB") ?: return + val compact = System.getenv("COMPACT_DB") ?: return + val sql = "SELECT id, bookId, lineIndex, content, heRef, tocEntryId, charCount FROM line ORDER BY id" + DriverManager.getConnection("jdbc:sqlite:file:$source?mode=ro").use { src -> + DriverManager.getConnection("jdbc:sqlite:file:$compact?mode=ro").use { dst -> + val codec = + LineTextCodec { + dst.createStatement().use { st -> + st.executeQuery("SELECT id, data FROM line_codec_dict").use { rs -> + buildMap { while (rs.next()) put(rs.getInt(1), rs.getBytes(2)) } + } + } + } + codec.loadDictionaries() + var lines = 0L + var mismatches = 0L + src.createStatement().use { a -> + dst.createStatement().use { b -> + val ra = a.executeQuery(sql) + val rb = b.executeQuery(sql) + while (ra.next()) { + check(rb.next()) { "The compact database has fewer lines" } + val same = + ra.getLong(1) == rb.getLong(1) && ra.getLong(2) == rb.getLong(2) && ra.getLong(3) == rb.getLong(3) && + ra.getString(4) == codec.decode(rb.getBytes(4)) && ra.getString(5) == rb.getString(5) && + ra.getObject(6) == rb.getObject(6) && ra.getLong(7) == rb.getLong(7) + if (!same) mismatches++ + lines++ + } + check(!rb.next()) { "The compact database has more lines" } + } + } + println("VERIFY lines $lines, mismatches $mismatches") + assertEquals(0, mismatches) + } + } + } +} diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml index 15dbada8c..a57b118e7 100644 --- a/gradle/libs.versions.toml +++ b/gradle/libs.versions.toml @@ -1,4 +1,6 @@ [versions] +androidx-test-runner = "1.7.0" +androidx-test-junit = "1.3.0" filekitCore = "0.13.0" kotlin = "2.4.20" @@ -28,6 +30,8 @@ slf4j = "2.0.17" sqlite-jdbc = "3.50.3.0" [libraries] +androidx-test-runner = { module = "androidx.test:runner", version.ref = "androidx-test-runner" } +androidx-test-junit = { module = "androidx.test.ext:junit", version.ref = "androidx-test-junit" } filekit-core = { module = "io.github.vinceglb:filekit-core", version.ref = "filekitCore" } kotlinx-coroutines-core = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-core", version.ref = "kotlinx-coroutines" }